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

Changeset 1522

Show
Ignore:
Timestamp:
04/29/05 17:10:31 (4 years ago)
Author:
nahi
Message:

let xmlele and xmlattr of SOAP::Mapping::Object keep each value with QName
as a key (not a String).

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

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

    r1520 r1522  
    280280        else 
    281281          obj.instance_variable_set('@' + name, value) 
    282         end 
    283       end 
    284     end 
     282          begin 
     283            define_attr_accessor(obj, name, 
     284              proc { instance_variable_get('@' + name) }, 
     285              proc { |value| instance_variable_set('@' + name, value) }) 
     286          rescue TypeError 
     287            # singleton class may not exist (e.g. Float) 
     288          end 
     289        end 
     290      end 
     291    end 
     292  end 
     293 
     294  def self.define_attr_accessor(obj, name, getterproc, setterproc = nil) 
     295    sclass = class << obj; self; end 
     296    sclass.__send__(:define_method, name, getterproc) 
     297    sclass.__send__(:define_method, name + '=', setterproc) if setterproc 
    285298  end 
    286299 

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

    r1520 r1522  
    8383  end 
    8484 
    85   def [](name) 
    86     @__xmlele[name] 
    87   end 
    88  
    89   def []=(name, value) 
    90     @__xmlele[name] = value 
    91   end 
    92  
    93   def __set_xmlele(name, value) 
    94     unless @__xmlele.key?(name) 
    95       __define_attr_accessor(name) 
    96     end 
    97     __set_xmlele_value(name, value) 
     85  def [](qname) 
     86    unless qname.is_a?(XSD::QName) 
     87      qname = XSD::QName.new(nil, qname) 
     88    end 
     89    @__xmlele[qname] 
     90  end 
     91 
     92  def []=(qname, value) 
     93    unless qname.is_a?(XSD::QName) 
     94      qname = XSD::QName.new(nil, qname) 
     95    end 
     96    @__xmlele[qname] = value 
     97  end 
     98 
     99  def __set_xmlele(qname, value) 
     100    unless @__xmlele.key?(qname) 
     101      __define_attr_accessor(qname) 
     102    end 
     103    __set_xmlele_value(qname, value) 
    98104  end 
    99105 
    100106private 
    101107 
    102   def __set_xmlele_value(name, value) 
    103     org = self[name] 
    104     case @__xmlele_type[name] 
     108  def __set_xmlele_value(qname, value) 
     109    org = self[qname] 
     110    case @__xmlele_type[qname] 
    105111    when :single 
    106       self[name] = [org, value] 
    107       @__xmlele_type[name] = :multi 
     112      self[qname] = [org, value] 
     113      @__xmlele_type[qname] = :multi 
    108114    when :multi 
    109115      org << value 
    110116    else 
    111       self[name] = value 
    112       @__xmlele_type[name] = :single 
     117      self[qname] = value 
     118      @__xmlele_type[qname] = :single 
    113119    end 
    114120    value 
    115121  end 
    116122 
    117   def __define_attr_accessor(name) 
    118     sclass = class << self; self; end 
    119     sclass.__send__(:define_method, name, proc { 
    120       self[name] 
    121     }) 
    122     sclass.__send__(:define_method, name + '=', proc { |value| 
    123       self[name] = value 
    124     }) 
     123  def __define_attr_accessor(qname) 
     124    Mapping.define_attr_accessor(self, qname.name, 
     125      proc { self[qname] }, 
     126      proc { |value| self[qname] = value }) 
    125127  end 
    126128end 

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

    r1520 r1522  
    224224      mark_marshalled_obj(obj, param) 
    225225      obj.__xmlele.each do |key, value| 
    226         param.add(key, Mapping._obj2soap(value, map)) 
     226        param.add(key.name, Mapping._obj2soap(value, map)) 
    227227      end 
    228228      obj.__xmlattr.each do |key, value| 
    …… 
    384384      mark_unmarshalled_obj(node, obj) 
    385385      node.each do |name, value| 
    386         obj.__set_xmlele(name, Mapping._soap2obj(value, map)) 
     386        obj.__set_xmlele(XSD::QName.new(nil, name), 
     387          Mapping._soap2obj(value, map)) 
    387388      end 
    388389      unless node.extraattr.empty? 

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

    r1520 r1522  
    139139      obj 
    140140    elsif obj.class.class_variables.include?('@@schema_element') 
    141       ele = SOAPElement.new(name) 
    142       add_elements2soap(obj, ele) 
    143       add_attributes2soap(obj, ele) 
    144       ele 
     141      unknownobj2definedsoap(obj, name) 
     142    elsif obj.is_a?(SOAP::Mapping::Object) 
     143      mappingobj2soap(obj, name) 
    145144    elsif obj.is_a?(Hash) 
    146145      ele = SOAPElement.from_obj(obj) 
    …… 
    150149      # expected to be a basetype or an anyType. 
    151150      # SOAPStruct, etc. is used instead of SOAPElement. 
    152       o = Mapping.obj2soap(obj) 
    153       o.elename = name 
    154       o 
    155     end 
     151      begin 
     152        ele = Mapping.obj2soap(obj) 
     153        ele.elename = name 
     154        ele 
     155      rescue MappingError 
     156        ele = SOAPElement.new(name, obj.to_s) 
     157      end 
     158      if obj.respond_to?(:__xmlattr) 
     159        obj.__xmlattr.each do |key, value| 
     160          ele.extraattr[key] = value 
     161        end 
     162      end 
     163      ele 
     164    end 
     165  end 
     166 
     167  def unknownobj2definedsoap(obj, name) 
     168    ele = SOAPElement.new(name) 
     169    add_elements2soap(obj, ele) 
     170    add_attributes2soap(obj, ele) 
     171    ele 
     172  end 
     173 
     174  def mappingobj2soap(obj, name) 
     175    ele = SOAPElement.new(name) 
     176    obj.__xmlele.each do |key, value| 
     177      if value.is_a?(::Array) 
     178        value.each do |item| 
     179          ele.add(obj2soap(item, key)) 
     180        end 
     181      else 
     182        ele.add(obj2soap(value, key)) 
     183      end 
     184    end 
     185    obj.__xmlattr.each do |key, value| 
     186      ele.extraattr[key] = value 
     187    end 
     188    ele 
    156189  end 
    157190 
    …… 
    176209    attributes = schema_attribute_definition(obj.class) 
    177210    if attributes 
    178       attributes.each do |attrname, param| 
     211      attributes.each do |qname, param| 
    179212        attr = obj.__send__('xmlattr_' + 
    180           XSD::CodeGen::GenSupport.safevarname(attrname)) 
    181         ele.extraattr[attrname] = attr 
     213          XSD::CodeGen::GenSupport.safevarname(qname.name)) 
     214        ele.extraattr[qname] = attr 
    182215      end 
    183216    end 
    …… 
    270303  def add_attributes2obj(node, obj) 
    271304    if attributes = schema_attribute_definition(obj.class) 
    272       vars = {} 
    273       obj.instance_variable_set('@__xmlattr', {}) 
    274       attributes.each do |attrname, class_name| 
    275         attr = node.extraattr[XSD::QName.new(nil, attrname)] 
     305      define_xmlattr(obj) 
     306      attributes.each do |qname, class_name| 
     307        attr = node.extraattr[qname] 
    276308        next if attr.nil? or attr.empty? 
    277309        klass = Mapping.class_from_name(class_name) 
    …… 
    281313          child = attr 
    282314        end 
    283         vars['xmlattr_' + attrname] = child 
    284       end 
    285       Mapping.set_attributes(obj, vars) 
     315        obj.__xmlattr[qname] = child 
     316        Mapping.define_attr_accessor(obj, 'xmlattr_' + qname.name, 
     317          proc { @__xmlattr[qname] }, 
     318          proc { |value| @__xmlattr[qname] = value }) 
     319      end 
    286320    end 
    287321  end 
    …… 
    289323  def add_elements2undefinedobj(node, obj) 
    290324    node.each do |name, value| 
    291       obj.__set_xmlele(name, soapele2obj(value)) 
     325      obj.__set_xmlele(XSD::QName.new(nil, name), soapele2obj(value)) 
    292326    end 
    293327  end 
    …… 
    295329  def add_attributes2undefinedobj(node, obj) 
    296330    return if node.extraattr.empty? 
    297     obj.instance_variable_set('@__xmlattr', node.extraattr) 
     331    define_xmlattr(obj) 
     332    node.extraattr.each do |qname, value| 
     333      attrname = qname.name 
     334      obj.__xmlattr[qname] = value 
     335      Mapping.define_attr_accessor(obj, 'xmlattr_' + attrname, 
     336        proc { @__xmlattr[qname] }, 
     337        proc { |value| @__xmlattr[qname] = value }) 
     338    end 
     339  end 
     340 
     341  def define_xmlattr(obj) 
     342    obj.instance_variable_set('@__xmlattr', {}) 
    298343    unless obj.respond_to?(:__xmlattr) 
    299       class << obj 
    300         define_method(:__xmlattr, proc { @__xmlattr }) 
    301       end 
     344      Mapping.define_attr_accessor(obj, :__xmlattr, proc { @__xmlattr }) 
    302345    end 
    303346  end 

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

    r1520 r1522  
    132132    params = [] 
    133133    typedef.each_element do |element| 
    134       name = name_element(element) 
    135134      if element.type == XSD::AnyTypeName 
    136135        type = nil 
    …… 
    149148        # </element> 
    150149      end 
     150      name = name_element(element).name 
    151151      attrname = safemethodname?(name) ? name : safemethodname(name) 
    152152      varname = safevarname(name) 
    …… 
    225225        type = nil 
    226226      end 
    227       varname = safevarname('xmlattr_' + name) 
    228       c.def_method(varname) do <<-__EOD__ 
    229           (@__xmlattr ||= {})[#{name.dump}] 
     227      methodname = safemethodname('xmlattr_' + name.name) 
     228      c.def_method(methodname) do <<-__EOD__ 
     229          (@__xmlattr ||= {})[#{dqname(name)}] 
    230230        __EOD__ 
    231231      end 
    232       c.def_method(varname + '=', 'value') do <<-__EOD__ 
    233           (@__xmlattr ||= {})[#{name.dump}] = value 
     232      c.def_method(methodname + '=', 'value') do <<-__EOD__ 
     233          (@__xmlattr ||= {})[#{dqname(name)}] = value 
    234234        __EOD__ 
    235235      end 
    …… 
    239239      '{' + 
    240240        schema_attribute.collect { |name, type| 
    241           name.dump + ' => ' + ndq(type) 
     241          dqname(name) + ' => ' + ndq(type) 
    242242        }.join(', ') + 
    243243      '}' 
    …… 
    246246 
    247247  def name_element(element) 
    248     return element.name.name if element.name  
    249     return element.ref.name if element.ref 
     248    return element.name if element.name  
     249    return element.ref if element.ref 
    250250    raise RuntimeError.new("cannot define name of #{element}") 
    251251  end 
    252252 
    253253  def name_attribute(attribute) 
    254     return attribute.name.name if attribute.name  
    255     return attribute.ref.name if attribute.ref 
     254    return attribute.name if attribute.name  
     255    return attribute.ref if attribute.ref 
    256256    raise RuntimeError.new("cannot define name of #{attribute}") 
    257257  end 

  • trunk/test/wsdl/document/echo.rb

    r1519 r1522  
    55  @@schema_type = "echoele" 
    66  @@schema_ns = "urn:docrpc" 
    7   @@schema_attribute = {"attr_string" => "SOAP::SOAPString", "attr-int" => "SOAP::SOAPInt"} 
     7  @@schema_attribute = {XSD::QName.new(nil, "attr_string") => "SOAP::SOAPString", XSD::QName.new(nil, "attr-int") => "SOAP::SOAPInt"} 
    88  @@schema_element = [["struct1", "Echo_struct"], ["struct_2", ["Echo_struct", XSD::QName.new(nil, "struct-2")]]] 
    99 
    …… 
    1212 
    1313  def xmlattr_attr_string 
    14     (@__xmlattr ||= {})["attr_string"] 
     14    (@__xmlattr ||= {})[XSD::QName.new(nil, "attr_string")] 
    1515  end 
    1616 
    1717  def xmlattr_attr_string=(value) 
    18     (@__xmlattr ||= {})["attr_string"] = value 
     18    (@__xmlattr ||= {})[XSD::QName.new(nil, "attr_string")] = value 
    1919  end 
    2020 
    2121  def xmlattr_attr_int 
    22     (@__xmlattr ||= {})["attr-int"] 
     22    (@__xmlattr ||= {})[XSD::QName.new(nil, "attr-int")] 
    2323  end 
    2424 
    2525  def xmlattr_attr_int=(value) 
    26     (@__xmlattr ||= {})["attr-int"] = value 
     26    (@__xmlattr ||= {})[XSD::QName.new(nil, "attr-int")] = value 
    2727  end 
    2828 
    …… 
    3838  @@schema_type = "echo_response" 
    3939  @@schema_ns = "urn:docrpc" 
    40   @@schema_attribute = {"attr_string" => "SOAP::SOAPString", "attr-int" => "SOAP::SOAPInt"} 
     40  @@schema_attribute = {XSD::QName.new(nil, "attr_string") => "SOAP::SOAPString", XSD::QName.new(nil, "attr-int") => "SOAP::SOAPInt"} 
    4141  @@schema_element = [["struct1", "Echo_struct"], ["struct_2", ["Echo_struct", XSD::QName.new(nil, "struct-2")]]] 
    4242 
    …… 
    4545 
    4646  def xmlattr_attr_string 
    47     (@__xmlattr ||= {})["attr_string"] 
     47    (@__xmlattr ||= {})[XSD::QName.new(nil, "attr_string")] 
    4848  end 
    4949 
    5050  def xmlattr_attr_string=(value) 
    51     (@__xmlattr ||= {})["attr_string"] = value 
     51    (@__xmlattr ||= {})[XSD::QName.new(nil, "attr_string")] = value 
    5252  end 
    5353 
    5454  def xmlattr_attr_int 
    55     (@__xmlattr ||= {})["attr-int"] 
     55    (@__xmlattr ||= {})[XSD::QName.new(nil, "attr-int")] 
    5656  end 
    5757 
    5858  def xmlattr_attr_int=(value) 
    59     (@__xmlattr ||= {})["attr-int"] = value 
     59    (@__xmlattr ||= {})[XSD::QName.new(nil, "attr-int")] = value 
    6060  end 
    6161 
    …… 
    7171  @@schema_type = "echo_struct" 
    7272  @@schema_ns = "urn:docrpc" 
    73   @@schema_attribute = {"m_attr" => "SOAP::SOAPString"} 
     73  @@schema_attribute = {XSD::QName.new("urn:docrpc", "m_attr") => "SOAP::SOAPString"} 
    7474  @@schema_element = [["m_string", "SOAP::SOAPString"], ["m_datetime", "SOAP::SOAPDateTime"]] 
    7575 
    …… 
    7878 
    7979  def xmlattr_m_attr 
    80     (@__xmlattr ||= {})["m_attr"] 
     80    (@__xmlattr ||= {})[XSD::QName.new("urn:docrpc", "m_attr")] 
    8181  end 
    8282 
    8383  def xmlattr_m_attr=(value) 
    84     (@__xmlattr ||= {})["m_attr"] = value 
     84    (@__xmlattr ||= {})[XSD::QName.new("urn:docrpc", "m_attr")] = value 
    8585  end 
    8686 

  • trunk/test/wsdl/ref/expectedProduct.rb

    r1519 r1522  
    1212  @@schema_type = "Product-Bag" 
    1313  @@schema_ns = "urn:product" 
    14   @@schema_attribute = {"version" => "SOAP::SOAPString", "yesno" => "SOAP::SOAPString"} 
     14  @@schema_attribute = {XSD::QName.new("urn:product", "version") => "SOAP::SOAPString", XSD::QName.new("urn:product", "yesno") => "SOAP::SOAPString"} 
    1515  @@schema_element = [["bag", "Product[]"], ["rating", ["SOAP::SOAPString[]", XSD::QName.new("urn:product", "Rating")]], ["product_Bag", [nil, XSD::QName.new("urn:product", "Product-Bag")]], ["comment_1", nil], ["comment_2", ["Comment[]", XSD::QName.new(nil, "comment-2")]]] 
    1616 
    …… 
    2929 
    3030  def xmlattr_version 
    31     (@__xmlattr ||= {})["version"] 
     31    (@__xmlattr ||= {})[XSD::QName.new("urn:product", "version")] 
    3232  end 
    3333 
    3434  def xmlattr_version=(value) 
    35     (@__xmlattr ||= {})["version"] = value 
     35    (@__xmlattr ||= {})[XSD::QName.new("urn:product", "version")] = value 
    3636  end 
    3737 
    3838  def xmlattr_yesno 
    39     (@__xmlattr ||= {})["yesno"] 
     39    (@__xmlattr ||= {})[XSD::QName.new("urn:product", "yesno")] 
    4040  end 
    4141 
    4242  def xmlattr_yesno=(value) 
    43     (@__xmlattr ||= {})["yesno"] = value 
     43    (@__xmlattr ||= {})[XSD::QName.new("urn:product", "yesno")] = value 
    4444  end 
    4545