Deserilzation with flatten=true and namespace does not work

[irvingoujAtDevolution]

use yaserde::{YaDeserialize, YaSerialize};
use yaserde::de::from_str;
use yaserde::ser::to_string;

// Test: Flatten with different namespaces (this should reproduce the bug)
#[derive(Debug, PartialEq, YaDeserialize, YaSerialize)]
#[yaserde(
    rename = "Inner",
    prefix = "ns1",
    namespaces = {
        "ns1" = "http://example.com/ns1"
    }
)]
pub struct Inner {
    #[yaserde(prefix = "ns1", rename = "field1")]
    pub field1: String,
    #[yaserde(prefix = "ns1", rename = "field2")]
    pub field2: String,
}

#[derive(Debug, PartialEq, YaDeserialize, YaSerialize)]
#[yaserde(
    rename = "Outer",
    prefix = "ns2",
    namespaces = {
        "ns2" = "http://example.com/ns2"
    }
)]
pub struct Outer {
    #[yaserde(flatten = true)]
    pub inner: Inner,
}

fn main() {
    println!("=== yaserde flatten + namespace bug reproduction ===\n");
    
    // Create test data
    let test_data = Outer {
        inner: Inner {
            field1: "value1".to_string(),
            field2: "value2".to_string(),
        }
    };
    
    // Test serialization
    println!("1. Serialization test:");
    match to_string(&test_data) {
        Ok(xml) => {
            println!("✅ Serialization SUCCESS:");
            println!("{}", xml);
            
            // Test deserialization with the serialized XML
            println!("\n2. Deserialization test (using serialized XML):");
            match from_str::<Outer>(&xml) {
                Ok(parsed) => {
                    println!("✅ Deserialization SUCCESS:");
                    println!("   field1: {}", parsed.inner.field1);
                    println!("   field2: {}", parsed.inner.field2);
                }
                Err(e) => {
                    println!("❌ Deserialization FAILED: {}", e);
                    println!("   This shows the namespace + flatten bug!");
                }
            }
        }
        Err(e) => {
            println!("❌ Serialization FAILED: {}", e);
        }
    }
    
    // Test with manually crafted XML that should work with flatten
    println!("\n3. Manual XML test (what flatten should parse):");
    let manual_xml = r#"<ns2:Outer xmlns:ns1="http://example.com/ns1" xmlns:ns2="http://example.com/ns2">
<ns1:field1>value1</ns1:field1>
<ns1:field2>value2</ns1:field2>
</ns2:Outer>"#;
    
    match from_str::<Outer>(manual_xml) {
        Ok(parsed) => {
            println!("✅ Manual XML SUCCESS:");
            println!("   field1: {}", parsed.inner.field1);
            println!("   field2: {}", parsed.inner.field2);
        }
        Err(e) => {
            println!("❌ Manual XML FAILED: {}", e);
            println!("   This confirms the namespace + flatten bug");
        }
    }
}

output :

=== yaserde flatten + namespace bug reproduction ===

1. Serialization test:
✅ Serialization SUCCESS:
<?xml version="1.0" encoding="UTF-8"?><ns2:Outer xmlns:ns1="http://example.com/ns1" xmlns:ns2="http://example.com/ns2"><ns1:field1>value1</ns1:field1><ns1:field2>value2</ns1:field2></ns2:Outer>

2. Deserialization test (using serialized XML):
❌ Deserialization FAILED: bad namespace for Outer, found http://example.com/ns2
   This shows the namespace + flatten bug!

3. Manual XML test (what flatten should parse):
❌ Manual XML FAILED: bad namespace for Outer, found http://example.com/ns2
   This confirms the namespace + flatten bug