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

Changeset 1556

Show
Ignore:
Timestamp:
05/21/05 01:42:13 (4 years ago)
Author:
nahi
Message:

Hash decoding(soap2obj) failed with WSDLEncodedRegistry. fixed. closes #112.
changed some method name for clear intention.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

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

    r1538 r1556  
    3939  end 
    4040 
    41   def obj2soap(obj, type_qname = nil) 
     41  def obj2soap(obj, qname = nil) 
    4242    soap_obj = nil 
    43     if type = @definedtypes[type_qname] 
    44       soap_obj = obj2type(obj, type) 
    45     elsif obj.nil? 
    46       soap_obj = SOAPNil.new 
    47     elsif type_qname.nil? or type_qname == XSD::AnyTypeName 
    48       soap_obj = @rubytype_factory.obj2soap(nil, obj, nil, self) 
    49     elsif obj.is_a?(XSD::NSDBase) 
    50       soap_obj = soap2soap(obj, type_qname) 
    51     elsif (type = TypeMap[type_qname]) 
    52       soap_obj = base2soap(obj, type) 
     43    if type = @definedtypes[qname] 
     44      soap_obj = obj2typesoap(obj, type) 
     45    else 
     46      soap_obj = any2soap(obj, qname) 
    5347    end 
    5448    return soap_obj if soap_obj 
    …… 
    5953      return soap_obj if soap_obj 
    6054    end 
    61     if type_qname 
    62       raise MappingError.new("cannot map #{obj.class.name} as #{type_qname}") 
     55    if qname 
     56      raise MappingError.new("cannot map #{obj.class.name} as #{qname}") 
    6357    else 
    6458      raise MappingError.new("cannot map #{obj.class.name} to SOAP/OM") 
    …… 
    6963  def soap2obj(node, obj_class = nil) 
    7064    begin 
    71       return _soap2obj(node, obj_class) 
     65      return any2obj(node, obj_class) 
    7266    rescue MappingError 
    7367    end 
    …… 
    8579private 
    8680 
     81  def any2soap(obj, qname) 
     82    if obj.nil? 
     83      SOAPNil.new 
     84    elsif qname.nil? or qname == XSD::AnyTypeName 
     85      @rubytype_factory.obj2soap(nil, obj, nil, self) 
     86    elsif obj.is_a?(XSD::NSDBase) 
     87      soap2soap(obj, qname) 
     88    elsif (type = TypeMap[qname]) 
     89      base2soap(obj, type) 
     90    else 
     91      nil 
     92    end 
     93  end 
     94 
    8795  def soap2soap(obj, type_qname) 
    8896    if obj.is_a?(SOAPBasetype) 
    …… 
    106114  end 
    107115 
    108   def obj2type(obj, type) 
     116  def obj2typesoap(obj, type) 
    109117    if type.is_a?(::WSDL::XMLSchema::SimpleType) 
    110       simple2soap(obj, type) 
    111     else 
    112       complex2soap(obj, type) 
    113     end 
    114   end 
    115  
    116   def simple2soap(obj, type) 
     118      simpleobj2soap(obj, type) 
     119    else 
     120      complexobj2soap(obj, type) 
     121    end 
     122  end 
     123 
     124  def simpleobj2soap(obj, type) 
    117125    type.check_lexical_format(obj) 
    118126    return SOAPNil.new if obj.nil?      # ToDo: check nillable. 
    …… 
    121129  end 
    122130 
    123   def complex2soap(obj, type) 
     131  def complexobj2soap(obj, type) 
    124132    case type.compoundtype 
    125133    when :TYPE_STRUCT 
    …… 
    130138      map2soap(obj, type.name, type) 
    131139    when :TYPE_SIMPLE 
    132       simple2soap(obj, type.simplecontent) 
     140      simpleobj2soap(obj, type.simplecontent) 
    133141    when :TYPE_EMPTY 
    134142      raise MappingError.new("should be empty") unless obj.nil? 
    …… 
    203211  end 
    204212 
    205   def _soap2obj(node, obj_class) 
     213  def any2obj(node, obj_class) 
    206214    unless obj_class 
    207215      typestr = XSD::CodeGen::GenSupport.safeconstname(node.elename.name) 
    …… 
    209217    end 
    210218    if obj_class and obj_class.class_variables.include?('@@schema_element') 
    211       soap2definedobj(node, obj_class) 
    212     else 
    213       Mapping.soap2obj(node, nil, obj_class) 
    214     end 
    215   end 
    216  
    217   def soap2definedobj(node, obj_class) 
     219      soap2stubobj(node, obj_class) 
     220    else 
     221      Mapping._soap2obj(node, Mapping::DefaultRegistry, obj_class) 
     222    end 
     223  end 
     224 
     225  def soap2stubobj(node, obj_class) 
    218226    obj = Mapping.create_empty_object(obj_class) 
    219227    unless node.is_a?(SOAPNil) 
    220       add_elements2obj(node, obj) 
     228      add_elements2stubobj(node, obj) 
    221229    end 
    222230    obj 
    223231  end 
    224232 
    225   def add_elements2obj(node, obj) 
     233  def add_elements2stubobj(node, obj) 
    226234    elements, as_array = schema_element_definition(obj.class) 
    227235    vars = {} 

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

    r1553 r1556  
    3030    @excn_handler_obj2soap = nil 
    3131    @excn_handler_soap2obj = nil 
    32     @rubytype_factory = RubytypeFactory.new(:allow_original_mapping => false) 
    3332    @schema_element_cache = {} 
    3433    @schema_attribute_cache = {} 
    …… 
    3635 
    3736  def obj2soap(obj, qname) 
    38     ret = nil 
     37    soap_obj = nil 
    3938    if ele = @definedelements[qname] 
    40       ret = _obj2soap(obj, ele) 
     39      soap_obj = obj2elesoap(obj, ele) 
    4140    elsif type = @definedtypes[qname] 
    42       ret = obj2type(obj, type) 
    43     else 
    44       ret = unknownobj2soap(obj, qname) 
    45     end 
    46     return ret if ret 
     41      soap_obj = obj2typesoap(obj, type) 
     42    else 
     43      soap_obj = any2soap(obj, qname) 
     44    end 
     45    return soap_obj if soap_obj 
    4746    if @excn_handler_obj2soap 
    48       ret = @excn_handler_obj2soap.call(obj) { |yield_obj| 
     47      soap_obj = @excn_handler_obj2soap.call(obj) { |yield_obj| 
    4948        Mapping._obj2soap(yield_obj, self) 
    5049      } 
    51       return ret if ret 
    52     end 
    53     raise MappingError.new("cannot map #{obj.class.name} to SOAP/OM") 
     50      return soap_obj if soap_obj 
     51    end 
     52    raise MappingError.new("cannot map #{obj.class.name} as #{qname}") 
    5453  end 
    5554 
    …… 
    6059    end 
    6160    begin 
    62       return soapele2obj(node) 
     61      return any2obj(node) 
    6362    rescue MappingError 
    6463    end 
    …… 
    7675private 
    7776 
    78   def _obj2soap(obj, ele) 
     77  def obj2elesoap(obj, ele) 
    7978    o = nil 
    8079    if ele.type 
    8180      if type = @definedtypes[ele.type] 
    82         o = obj2type(obj, type) 
     81        o = obj2typesoap(obj, type) 
    8382      elsif type = TypeMap[ele.type] 
    8483        o = base2soap(obj, type) 
    …… 
    8887      o.elename = ele.name 
    8988    elsif ele.local_complextype 
    90       o = obj2type(obj, ele.local_complextype) 
     89      o = obj2typesoap(obj, ele.local_complextype) 
    9190      o.elename = ele.name 
    9291      add_attributes2soap(obj, o) 
    9392    elsif ele.local_simpletype 
    94       o = obj2type(obj, ele.local_simpletype) 
     93      o = obj2typesoap(obj, ele.local_simpletype) 
    9594      o.elename = ele.name 
    9695    else 
    …… 
    10099  end 
    101100 
    102   def obj2type(obj, type) 
     101  def obj2typesoap(obj, type) 
    103102    if type.is_a?(::WSDL::XMLSchema::SimpleType) 
    104       simple2soap(obj, type) 
    105     else 
    106       complex2soap(obj, type) 
    107     end 
    108   end 
    109  
    110   def simple2soap(obj, type) 
     103      simpleobj2soap(obj, type) 
     104    else 
     105      complexobj2soap(obj, type) 
     106    end 
     107  end 
     108 
     109  def simpleobj2soap(obj, type) 
     110    type.check_lexical_format(obj) 
     111    return SOAPNil.new if obj.nil?      # ToDo: check nillable. 
    111112    o = base2soap(obj, TypeMap[type.base]) 
    112     type.check_lexical_format(obj) 
    113113    o 
    114114  end 
    115115 
    116   def complex2soap(obj, type) 
     116  def complexobj2soap(obj, type) 
    117117    o = SOAPElement.new(type.name) 
    118118    type.each_element do |child_ele| 
    …… 
    122122          # ToDo: test 
    123123          # add empty element 
    124           o.add(_obj2soap(nil)) 
     124          o.add(obj2elesoap(nil)) 
    125125        elsif Integer(child_ele.minoccurs) == 0 
    126126          # nothing to do 
    …… 
    130130      elsif child_ele.map_as_array? 
    131131        child.each do |item| 
    132           o.add(_obj2soap(item, child_ele)) 
     132          o.add(obj2elesoap(item, child_ele)) 
    133133        end 
    134134      else 
    135         o.add(_obj2soap(child, child_ele)) 
     135        o.add(obj2elesoap(child, child_ele)) 
    136136      end 
    137137    end 
    …… 
    139139  end 
    140140 
    141   def unknownobj2soap(obj, name) 
     141  def any2soap(obj, qname) 
    142142    if obj.is_a?(SOAPElement) 
    143143      obj 
    144144    elsif obj.class.class_variables.include?('@@schema_element') 
    145       unknownobj2definedsoap(obj, name) 
     145      stubobj2soap(obj, qname) 
    146146    elsif obj.is_a?(SOAP::Mapping::Object) 
    147       mappingobj2soap(obj, name) 
     147      mappingobj2soap(obj, qname) 
    148148    elsif obj.is_a?(Hash) 
    149149      ele = SOAPElement.from_obj(obj) 
    150       ele.elename = name 
     150      ele.elename = qname 
    151151      ele 
    152152    else 
    …… 
    155155      begin 
    156156        ele = Mapping.obj2soap(obj) 
    157         ele.elename = name 
     157        ele.elename = qname 
    158158        ele 
    159159      rescue MappingError 
    160         ele = SOAPElement.new(name, obj.to_s) 
     160        ele = SOAPElement.new(qname, obj.to_s) 
    161161      end 
    162162      if obj.respond_to?(:__xmlattr) 
    …… 
    169169  end 
    170170 
    171   def unknownobj2definedsoap(obj, name) 
    172     ele = SOAPElement.new(name) 
     171  def stubobj2soap(obj, qname) 
     172    ele = SOAPElement.new(qname) 
    173173    add_elements2soap(obj, ele) 
    174174    add_attributes2soap(obj, ele) 
    …… 
    176176  end 
    177177 
    178   def mappingobj2soap(obj, name) 
    179     ele = SOAPElement.new(name) 
     178  def mappingobj2soap(obj, qname) 
     179    ele = SOAPElement.new(qname) 
    180180    obj.__xmlele.each do |key, value| 
    181181      if value.is_a?(::Array) 
    …… 
    227227    if type <= XSD::XSDString 
    228228      soap_obj = type.new(XSD::Charset.is_ces(obj, $KCODE) ? 
    229         XSD::Charset.encoding_conv(obj, $KCODE, XSD::Charset.encoding) : 
    230         obj) 
     229        XSD::Charset.encoding_conv(obj, $KCODE, XSD::Charset.encoding) : obj) 
    231230    else 
    232231      soap_obj = type.new(obj) 
    …… 
    244243  end 
    245244 
    246   def soapele2obj(node, obj_class = nil) 
     245  def any2obj(node, obj_class = nil) 
    247246    unless obj_class 
    248247      typestr = XSD::CodeGen::GenSupport.safeconstname(node.elename.name) 
    …… 
    250249    end 
    251250    if obj_class and obj_class.class_variables.include?('@@schema_element') 
    252       soapele2definedobj(node, obj_class) 
     251      soapele2stubobj(node, obj_class) 
    253252    elsif node.is_a?(SOAPElement) or node.is_a?(SOAPStruct) 
    254253        # SOAPArray for literal? 
    255       soapele2undefinedobj(node) 
    256     else 
    257       result, obj = @rubytype_factory.soap2obj(nil, node, nil, self) 
    258       if result 
    259         add_attributes2undefinedobj(node, obj) 
    260       end 
     254      soapele2plainobj(node) 
     255    else 
     256      obj = Mapping._soap2obj(node, Mapping::DefaultRegistry, obj_class) 
     257      add_attributes2plainobj(node, obj) 
    261258      obj 
    262259    end 
    263260  end 
    264261 
    265   def soapele2definedobj(node, obj_class) 
     262  def soapele2stubobj(node, obj_class) 
    266263    obj = Mapping.create_empty_object(obj_class) 
    267     add_elements2obj(node, obj) 
    268     add_attributes2obj(node, obj) 
     264    add_elements2stubobj(node, obj) 
     265    add_attributes2stubobj(node, obj) 
    269266    obj 
    270267  end 
    271268 
    272   def soapele2undefinedobj(node) 
     269  def soapele2plainobj(node) 
    273270    obj = anytype2obj(node) 
    274     add_elements2undefinedobj(node, obj) 
    275     add_attributes2undefinedobj(node, obj) 
     271    add_elements2plainobj(node, obj) 
     272    add_attributes2plainobj(node, obj) 
    276273    obj 
    277274  end 
    278275 
    279   def add_elements2obj(node, obj) 
     276  def add_elements2stubobj(node, obj) 
    280277    elements, as_array = schema_element_definition(obj.class) 
    281278    vars = {} 
    …… 
    290287            end 
    291288          else 
    292             child = soapele2obj(value, klass) 
     289            child = any2obj(value, klass) 
    293290          end 
    294291        else 
    …… 
    296293        end 
    297294      else      # untyped element is treated as anyType. 
    298         child = soapele2obj(value) 
     295        child = any2obj(value) 
    299296      end 
    300297      if as_array.include?(class_name) 
    …… 
    307304  end 
    308305 
    309   def add_attributes2obj(node, obj) 
     306  def add_attributes2stubobj(node, obj) 
    310307    if attributes = schema_attribute_definition(obj.class) 
    311308      define_xmlattr(obj) 
    …… 
    325322  end 
    326323 
    327   def add_elements2undefinedobj(node, obj) 
     324  def add_elements2plainobj(node, obj) 
    328325    node.each do |name, value| 
    329       obj.__add_xmlele_value(XSD::QName.new(nil, name), soapele2obj(value)) 
    330     end 
    331   end 
    332  
    333   def add_attributes2undefinedobj(node, obj) 
     326      obj.__add_xmlele_value(XSD::QName.new(nil, name), any2obj(value)) 
     327    end 
     328  end 
     329 
     330  def add_attributes2plainobj(node, obj) 
    334331    return if node.extraattr.empty? 
    335332    define_xmlattr(obj)