Welcome to the "trac"-ing site of soap4r!
[soap4r] [httpclient] [openpgp4u] [pkcs1] [logger] [csv] [vtr]

Changeset 1739

Show
Ignore:
Timestamp:
10/21/06 00:51:38 (2 years ago)
Author:
nahi
Message:
Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/lib/soap/encodingstyle/aspDotNetHandler.rb

    r1735 r1739  
    3434    # should be qualified.  propagate parent's namespace to children. 
    3535    if data.elename.namespace.nil? 
    36       data.elename.namespace = parent.elename.namespace 
     36      data.elename = 
     37        XSD::QName.new(parent.elename.namespace, data.elename.name) 
    3738    end 
    3839    name = generator.encode_name(ns, data, attrs) 

  • trunk/lib/soap/mapping/encodedregistry.rb

    r1731 r1739  
    363363      end 
    364364    end 
    365     if definition 
    366       conv, obj = soap2stubobj(node, klass, definition) 
    367     end 
    368     return obj if conv 
     365    if definition and node.is_a?(::SOAP::SOAPStruct) 
     366      return elesoap2stubobj(node, klass, definition) 
     367    end 
    369368    if node.extraattr.key?(RubyTypeName) 
    370369      conv, obj = @rubytype_factory.soap2obj(nil, node, nil, self) 
    …… 
    450449    return SOAPNil.new if obj.nil? 
    451450    if definition.elements.size == 0 
    452       qname = XSD::QName.new(definition.ns, definition.name) 
    453451      ele = Mapping.obj2soap(obj) 
    454       ele.elename = qname 
     452      ele.elename = definition.elename if definition.elename 
    455453      return ele 
    456454    else 
    457       typename = XSD::QName.new(definition.ns, definition.type) 
    458       ele = SOAPStruct.new(typename) 
     455      ele = SOAPStruct.new(definition.type) 
    459456      mark_marshalled_obj(obj, ele) 
    460457    end 
    …… 
    478475  end 
    479476 
    480   def soap2stubobj(node, obj_class, definition) 
    481     return false unless node.is_a?(::SOAP::SOAPStruct) 
     477  def elesoap2stubobj(node, obj_class, definition) 
    482478    obj = Mapping.create_empty_object(obj_class) 
     479    add_elesoap2stubobj(node, obj, definition) 
     480    obj 
     481  end 
     482 
     483  # XXX consider to merge with the method in LiteralRegistry 
     484  def add_elesoap2stubobj(node, obj, definition) 
    483485    vars = {} 
    484486    node.each do |name, value| 
    485       item = definition.elements.find { |k, v| k.elename.name == name } 
     487      item = definition.elements.find { |k, v| 
     488        k.elename == value.elename 
     489      } 
    486490      if item 
    487         child = soap2typedobj(value, item.type) 
     491        child = soap2typedobj(value, item.mapped_class) 
    488492      else 
     493        # unknown element is treated as anyType. 
    489494        child = Mapping._soap2obj(value, self) 
    490495      end 
    491496      if item and item.as_array? 
    492497        (vars[name] ||= []) << child 
     498      elsif vars.key?(name) 
     499        vars[name] = [vars[name], child].flatten 
    493500      else 
    494501        vars[name] = child 
    495502      end 
    496503    end 
    497     if obj.is_a?(::Array) 
    498       obj.replace(vars.values.flatten) 
     504    if obj.is_a?(::Array) and vars.keys.size == 1 
     505      obj.replace(vars.values[0]) 
    499506    else 
    500507      Mapping.set_attributes(obj, vars) 
    501508    end 
    502     return true, obj 
    503   end 
    504  
    505   def soap2typedobj(value, typename) 
    506     if klass = Mapping.class_from_name(typename) 
    507       if klass.ancestors.include?(::SOAP::SOAPBasetype) 
    508         if value.respond_to?(:data) 
    509           obj = klass.new(value.data).data 
    510         else 
    511           obj = klass.new(nil).data 
    512         end 
    513       else 
    514         obj = Mapping._soap2obj(value, self, klass) 
    515       end 
    516     elsif klass = Mapping.module_from_name(eledef.type) 
    517       # simpletype 
    518       if value.respond_to?(:data) 
    519         obj = value.data 
    520       else 
    521         raise MappingError.new("cannot map to a module value: #{eledef.type}") 
    522       end 
     509  end 
     510 
     511  def soap2typedobj(value, klass) 
     512    unless klass 
     513      raise MappingError.new("unknown class: #{klass}") 
     514    end 
     515    if klass.ancestors.include?(::SOAP::SOAPBasetype) 
     516      obj = base2obj(value, klass) 
    523517    else 
    524       raise MappingError.new("unknown class/module: #{eledef.type}") 
     518      obj = Mapping._soap2obj(value, self, klass) 
    525519    end 
    526520    obj 

  • trunk/lib/soap/mapping/literalregistry.rb

    r1735 r1739  
    106106    ele.qualified = definition.qualified 
    107107    if definition.type 
    108       ele.extraattr[XSD::AttrTypeName] = 
    109         XSD::QName.new(definition.ns, definition.type) 
     108      ele.extraattr[XSD::AttrTypeName] = definition.type 
    110109    end 
    111110    any = nil 
    …… 
    167166      end 
    168167    end 
    169     if node.is_a?(SOAPElement) or node.is_a?(SOAPStruct) 
     168    if node.is_a?(::SOAP::SOAPElement) or node.is_a?(::SOAP::SOAPStruct) 
    170169      if definition 
    171170        return elesoap2stubobj(node, obj_class, definition) 
    …… 
    206205    vars = {} 
    207206    node.each do |name, value| 
    208       item = definition.elements.find { |k, v| k.elename.name == name } 
     207      item = definition.elements.find { |k, v| 
     208        k.elename == value.elename 
     209      } 
    209210      if item 
    210         child = elesoapchild2obj(value, definition.ns, item) 
     211        child = elesoapchild2obj(value, item) 
    211212      else 
    212213        # unknown element is treated as anyType. 
    …… 
    215216      if item and item.as_array? 
    216217        (vars[name] ||= []) << child 
     218      elsif vars.key?(name) 
     219        vars[name] = [vars[name], child].flatten 
    217220      else 
    218221        vars[name] = child 
    219222      end 
    220223    end 
    221     if obj.is_a?(::Array) 
    222       obj.replace(vars.values.flatten) 
     224    if obj.is_a?(::Array) and vars.keys.size == 1 
     225      obj.replace(vars.values[0]) 
    223226    else 
    224227      Mapping.set_attributes(obj, vars) 
    …… 
    226229  end 
    227230 
    228   def elesoapchild2obj(value, ns, eledef) 
     231  def elesoapchild2obj(value, eledef) 
    229232    child_definition = schema_definition_from_elename(eledef.elename) 
    230233    if child_definition 
    231234      any2obj(value, child_definition.class_for) 
    232     elsif eledef.type 
    233       child_definition = 
    234         schema_definition_from_type(XSD::QName.new(ns, eledef.type)) 
     235    elsif eledef.mapped_class 
     236      child_definition = schema_definition_from_class(eledef.mapped_class) 
    235237      if child_definition 
    236238        any2obj(value, child_definition.class_for) 
    237       elsif klass = Mapping.class_from_name(eledef.type) 
    238         # klass must be a SOAPBasetype or a class 
    239         if klass.ancestors.include?(::SOAP::SOAPBasetype) 
    240           if value.respond_to?(:data) 
    241             klass.new(value.data).data 
    242           else 
    243             klass.new(nil).data 
    244           end 
     239      else 
     240        if eledef.mapped_class.ancestors.include?(::SOAP::SOAPBasetype) 
     241          base2obj(value, eledef.mapped_class) 
    245242        else 
    246           any2obj(value, klass) 
    247         end 
    248       elsif klass = Mapping.module_from_name(eledef.type) 
    249         # simpletype 
    250         if value.respond_to?(:data) 
    251           value.data 
    252         else 
    253           raise MappingError.new("cannot map to a module value: #{eledef.type}") 
    254         end 
    255       else 
    256         raise MappingError.new("unknown class/module: #{eledef.type}") 
     243          any2obj(value, eledef.mapped_class) 
     244        end 
    257245      end 
    258246    else 
    …… 
    269257        attr = node.extraattr[qname] 
    270258        next if attr.nil? or attr.empty? 
    271         klass = Mapping.class_from_name(class_name) 
    272         if klass.ancestors.include?(::SOAP::SOAPBasetype) 
    273           child = klass.new(attr).data 
    274         else 
    275           child = attr 
     259        child = attr 
     260        if class_name 
     261          klass = Mapping.class_from_name(class_name) 
     262          if klass.ancestors.include?(::SOAP::SOAPBasetype) 
     263            child = klass.new(attr).data 
     264          end 
    276265        end 
    277266        obj.__xmlattr[qname] = child 

  • trunk/lib/soap/mapping/mapping.rb

    r1724 r1739  
    229229 
    230230  def self.class2element(klass) 
    231     type = Mapping.class2qname(klass) 
    232     type.name ||= Mapping.name2elename(klass.name) 
    233     type.namespace ||= RubyCustomTypeNamespace 
    234     type 
     231    name = schema_type_definition(klass) || 
     232    Mapping.name2elename(klass.name) 
     233    namespace = schema_ns_definition(klass) || RubyCustomTypeNamespace 
     234    XSD::QName.new(namespace, name) 
    235235  end 
    236236 
    …… 
    404404    schema_element = definition[:schema_element] 
    405405    schema_attributes = definition[:schema_attribute] 
    406     definition = SchemaDefinition.new(klass, schema_ns, schema_name, 
    407       schema_type, schema_qualified) 
     406    elename = schema_name ? XSD::QName.new(schema_ns, schema_name) : nil 
     407    type = schema_type ? XSD::QName.new(schema_ns, schema_type) : nil 
     408    definition = SchemaDefinition.new(klass, elename, type, schema_qualified) 
    408409    definition.attributes = schema_attributes 
    409410    if schema_element 
    410       if schema_element[0] == :choice 
    411         schema_element.shift 
    412         definition.set_choice 
    413       end 
    414       schema_element.each do |element| 
    415         varname, info = element 
    416         class_name, name = info 
    417         as_array = klass.ancestors.include?(::Array) 
    418         if /\[\]$/ =~ class_name 
    419           class_name = class_name.sub(/\[\]$/, '') 
    420           if class_name.empty? 
    421             class_name = nil 
    422           end 
    423           as_array = true 
    424         end 
    425         if name == XSD::AnyTypeName 
    426           definition.set_any 
    427         end 
    428         definition.elements << 
    429           SchemaElementDefinition.new( 
    430             varname, 
    431             name || XSD::QName.new(schema_ns, varname), 
    432             class_name, 
    433             as_array 
    434           ) 
     411      if schema_element.respond_to?(:is_concrete_definition) and 
     412          schema_element.is_concrete_definition 
     413        definition.elements.replace(schema_element) 
     414      else 
     415        parse_schema_element_definition(klass, definition, schema_element) 
    435416      end 
    436417    end 
    …… 
    438419  end 
    439420 
     421  # for backward compatibility 
     422  def self.parse_schema_element_definition(klass, definition, schema_element) 
     423    if schema_element[0] == :choice 
     424      schema_element.shift 
     425      definition.set_choice 
     426    end 
     427    schema_element.each do |element| 
     428      varname, info = element 
     429      mapped_class, elename = info 
     430      as_array = klass.ancestors.include?(::Array) 
     431      if /\[\]$/ =~ mapped_class 
     432        mapped_class = mapped_class.sub(/\[\]$/, '') 
     433        if mapped_class.empty? 
     434          mapped_class = nil 
     435        end 
     436        as_array = true 
     437      end 
     438      if mapped_class 
     439        mapped_class = Mapping.class_from_name(mapped_class) 
     440      end 
     441      if elename == XSD::AnyTypeName 
     442        definition.set_any 
     443      elsif elename.nil? 
     444        ns ||= definition.elename.namespace if definition.elename 
     445        ns ||= definition.type.namespace if definition.type 
     446        elename = XSD::QName.new(ns, varname) 
     447      end 
     448      definition.elements << 
     449        SchemaElementDefinition.new(varname, mapped_class, elename, as_array) 
     450    end 
     451  end 
     452 
    440453  class SchemaElementDefinition 
    441     attr_reader :varname, :elename, :type 
    442  
    443     def initialize(varname, elename, type, as_array) 
     454    attr_reader :varname, :mapped_class, :elename 
     455 
     456    def initialize(varname, mapped_class, elename, as_array) 
    444457      @varname = varname 
     458      @mapped_class = mapped_class 
    445459      @elename = elename 
    446       @type = type 
    447460      @as_array = as_array 
    448461    end 
    …… 
    451464      @as_array 
    452465    end 
     466 
     467    def is_concrete_definition 
     468      true 
     469    end 
     470  end 
     471 
     472  class SchemaElementChoiceDefinition < ::Array 
     473    def is_concrete_definition 
     474      true 
     475    end 
    453476  end 
    454477 
    455478  class SchemaDefinition 
    456     attr_reader :class_for, :ns, :name, :type, :qualified, :elements 
     479    attr_reader :class_for 
     480    attr_reader :elename, :type 
     481    attr_reader :qualified, :elements 
    457482    attr_accessor :attributes 
    458483 
    459     def initialize(class_for, ns, name, type, qualified) 
     484    def initialize(class_for, elename, type, qualified) 
    460485      @class_for = class_for 
    461       @ns = ns 
    462       @name = name 
     486      @elename = elename 
    463487      @type = type 
    464488      @qualified = qualified 

  • trunk/lib/soap/mapping/registry.rb

    r1731 r1739  
    187187    definition = Mapping.create_schema_definition(obj_class, definition) 
    188188    @class_schema_definition[obj_class] = definition 
    189     if definition.name 
    190       qname = XSD::QName.new(definition.ns, definition.name) 
    191       @elename_schema_definition[qname] = definition 
     189    if definition.elename 
     190      @elename_schema_definition[definition.elename] = definition 
    192191    end 
    193192    if definition.type 
    194       qname = XSD::QName.new(definition.ns, definition.type) 
    195       @type_schema_definition[qname] = definition 
     193      @type_schema_definition[definition.type] = definition 
    196194    end 
    197195  end 
    …… 
    237235    if type <= XSD::XSDString 
    238236      str = XSD::Charset.encoding_conv(obj.to_s, 
    239         Thread.current[:SOAPMapping][:ExternalCES], XSD::Charset.encoding) 
     237        Thread.current[:SOAPMapping][:ExternalCES], 
     238        XSD::Charset.encoding) 
    240239      soap_obj = type.new(str) 
    241240    else 
    …… 
    245244    soap_obj 
    246245  end 
    247 end 
    248  
    249  
    250 end 
    251 end 
     246 
     247  def base2obj(value, klass) 
     248    if value.respond_to?(:data) 
     249      klass.new(value.data).data 
     250    else 
     251      klass.new(nil).data 
     252    end 
     253  end 
     254end 
     255 
     256 
     257end 
     258end 

  • trunk/lib/soap/mapping/wsdlencodedregistry.rb

    r1731 r1739  
    224224    vars = {} 
    225225    node.each do |name, value| 
    226       item = definition.elements.find { |k, v| k.elename.name == name } 
    227       if item and item.type 
    228         if klass = Mapping.class_from_name(item.type) 
    229           # klass must be a SOAPBasetype or a class 
    230           if klass.ancestors.include?(::SOAP::SOAPBasetype) 
    231             if value.respond_to?(:data) 
    232               child = klass.new(value.data).data 
    233             else 
    234               child = klass.new(nil).data 
    235             end 
     226      item = definition.elements.find { |k, v| k.elename == value.elename } 
     227      if item and item.mapped_class 
     228        # klass must be a SOAPBasetype or a class 
     229        if item.mapped_class.ancestors.include?(::SOAP::SOAPBasetype) 
     230          if value.respond_to?(:data) 
     231            child = item.mapped_class.new(value.data).data 
    236232          else 
    237             child = Mapping._soap2obj(value, self, klass) 
    238           end 
    239         elsif klass = Mapping.module_from_name(item.type) 
    240           # simpletype 
    241           if value.respond_to?(:data) 
    242             child = value.data 
    243           else 
    244             raise MappingError.new("cannot map to a module value: #{item.type}") 
     233            child = item.mapped_class.new(nil).data 
    245234          end 
    246235        else 
    247           raise MappingError.new("unknown class: #{item.type}") 
     236          child = Mapping._soap2obj(value, self, item.mapped_class) 
    248237        end 
    249238      else      # untyped element is treated as anyType. 

  • trunk/lib/soap/rpc/element.rb

    r1731 r1739  
    116116    params.each do |param, data| 
    117117      @inparam[param] = data 
    118       data.elename.name = param 
     118      data.elename = XSD::QName.new(data.elename.namespace, param) 
    119119      data.parent = self 
    120120    end 
    …… 
    124124    params.each do |param, data| 
    125125      @outparam[param] = data 
    126       data.elename.name = param 
     126      data.elename = XSD::QName.new(data.elename.namespace, param) 
    127127    end 
    128128  end 

  • trunk/lib/wsdl/soap/definitions.rb

    r1643 r1739  
    3131    attr = XMLSchema::Attribute.new 
    3232    attr.ref = ::SOAP::AttrArrayTypeName 
    33     anytype = XSD::AnyTypeName.dup 
    34     anytype.name += '[]' 
    35     attr.arytype = anytype 
     33    anyarray = XSD::QName.new( 
     34      XSD::AnyTypeName.namespace, 
     35      XSD::AnyTypeName.name + '[]') 
     36    attr.arytype = anyarray 
    3637    type.complexcontent.restriction.attributes << attr 
    3738    type 

  • trunk/lib/xsd/qname.rb

    r1604 r1739  
    1111 
    1212class QName 
    13   attr_accessor :namespace 
    14   attr_accessor :name 
     13  attr_reader :namespace 
     14  attr_reader :name 
    1515  attr_accessor :source 
    1616 

  • trunk/test/wsdl/document/array/test_array.rb

    r1731 r1739  
    104104    @client.literal_mapping_registry = DoubleMappingRegistry::LiteralRegistry 
    105105    @client.wiredump_dev = STDOUT if $DEBUG 
    106     arg = {:ary => {:double => [0.1, 0.2, 0.3]}} 
    107     assert_equal(arg[:ary][:double], @client.echo(arg).ary) 
     106    double = [0.1, 0.2, 0.3] 
     107    arg = { 
     108      :ary => { 
     109        XSD::QName.new("http://tempuri.org/", "double") => double 
     110      } 
     111    } 
     112    assert_equal(double, @client.echo(arg).ary) 
    108113  end 
    109114end