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

Changeset 1788

Show
Ignore:
Timestamp:
05/20/07 15:36:14 (2 years ago)
Author:
nahi
Message:
  • support combination of choice + sequence. closes #205.
Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

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

    r1776 r1788  
    503503    vars = {} 
    504504    node.each do |name, value| 
    505       item = definition.elements.find { |k, v| 
    506         k.elename == value.elename 
    507       } 
     505      item = definition.elements.find_element(value.elename) 
    508506      if item 
    509507        child = soap2typedobj(value, item.mapped_class) 
    …… 
    538536    obj 
    539537  end 
    540  
    541   def find_node_definition(node) 
    542     schema_definition_from_elename(node.elename) || schema_definition_from_type(node.type) 
    543   end 
    544538end 
    545539 

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

    r1771 r1788  
    108108      ele.extraattr[XSD::AttrTypeName] = definition.type 
    109109    end 
    110     any = nil 
    111     if definition.have_any? 
    112       any = Mapping.get_attributes_for_any(obj, definition.elements) 
    113     end 
    114     definition.elements.each do |eledef| 
    115       if eledef.elename == XSD::AnyTypeName 
    116         if any 
    117           SOAPElement.from_objs(any).each do |child| 
    118             ele.add(child) 
    119           end 
    120         end 
    121       elsif obj.respond_to?(:each) and eledef.as_array? 
    122         obj.each do |item| 
    123           ele.add(obj2soap(item, eledef.elename)) 
    124         end 
    125       else 
    126         child = Mapping.get_attribute(obj, eledef.varname) 
    127         if child.respond_to?(:each) and eledef.as_array? 
    128           child.each do |item| 
    129             ele.add(obj2soap(item, eledef.elename)) 
    130           end 
    131         else 
    132           ele.add(obj2soap(child, eledef.elename)) 
    133         end 
    134       end 
    135     end 
     110    stubobj2soap_elements(obj, ele, definition.elements) 
    136111    if definition.attributes 
    137112      definition.attributes.each do |qname, param| 
    …… 
    142117    end 
    143118    ele 
     119  end 
     120 
     121  def stubobj2soap_elements(obj, ele, definition, add_if_nil = true) 
     122    added = false 
     123    case definition 
     124    when SchemaSequenceDefinition, SchemaEmptyDefinition 
     125      definition.each do |eledef| 
     126        ele_added = stubobj2soap_elements(obj, ele, eledef, add_if_nil) 
     127        added = true if ele_added 
     128      end 
     129    when SchemaChoiceDefinition 
     130      definition.each do |eledef| 
     131        added = stubobj2soap_elements(obj, ele, eledef, false) 
     132        break if added 
     133      end 
     134    else 
     135      added = true 
     136      if definition.as_any? 
     137        any = Mapping.get_attributes_for_any(obj) 
     138        SOAPElement.from_objs(any).each do |child| 
     139          ele.add(child) 
     140        end 
     141      elsif obj.respond_to?(:each) and definition.as_array? 
     142        obj.each do |item| 
     143          ele.add(obj2soap(item, definition.elename)) 
     144        end 
     145      else 
     146        child = Mapping.get_attribute(obj, definition.varname) 
     147        if child.nil? and !add_if_nil 
     148          added = false 
     149        else 
     150          if child.respond_to?(:each) and definition.as_array? 
     151            child.each do |item| 
     152              ele.add(obj2soap(item, definition.elename)) 
     153            end 
     154          else 
     155            ele.add(obj2soap(child, definition.elename)) 
     156          end 
     157        end 
     158      end 
     159    end 
     160    added 
    144161  end 
    145162 
    …… 
    206223    vars = {} 
    207224    node.each do |name, value| 
    208       item = definition.elements.find { |k, v| 
    209         k.elename == value.elename 
    210       } 
     225      item = definition.elements.find_element(value.elename) 
    211226      if item 
    212227        child = elesoapchild2obj(value, item) 

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

    r1779 r1788  
    88 
    99require 'xsd/codegen/gensupport' 
     10require 'soap/mapping/schemadefinition' 
    1011 
    1112 
    …… 
    297298  end 
    298299 
    299   def self.get_attributes_for_any(obj, elements) 
     300  def self.get_attributes_for_any(obj) 
    300301    if obj.respond_to?(:__xmlele_any) 
    301302      obj.__xmlele_any 
    302303    else 
    303       any = get_attributes(obj) 
    304       if elements 
    305         elements.each do |child_ele| 
    306           child = get_attribute(obj, child_ele.name.name) 
    307           if k = any.key(child) 
    308             any.delete(k) 
    309           end 
    310         end 
    311       end 
    312       any 
     304      get_attributes(obj) 
    313305    end 
    314306  end 
    …… 
    438430      if schema_element.respond_to?(:is_concrete_definition) and 
    439431          schema_element.is_concrete_definition 
    440         definition.elements.replace(schema_element) 
     432        definition.elements = schema_element 
    441433      else 
    442         parse_schema_element_definition(klass, definition, schema_element) 
     434        default_ns = elename.namespace if elename 
     435        default_ns ||= type.namespace if type 
     436        definition.elements = parse_schema_definition(schema_element, default_ns) 
     437        # needed? 
     438        if klass.ancestors.include?(::Array) 
     439          definition.elements.set_array 
     440        end 
    443441      end 
    444442    end 
    …… 
    447445 
    448446  # for backward compatibility 
    449   def self.parse_schema_element_definition(klass, definition, schema_element) 
     447  # returns SchemaComplexTypeDefinition 
     448  def self.parse_schema_definition(schema_element, default_ns) 
     449    definition = nil 
    450450    if schema_element[0] == :choice 
    451451      schema_element.shift 
    452       definition.set_choice 
    453     end 
    454     schema_element.each do |element| 
    455       varname, info = element 
     452      definition = SchemaChoiceDefinition.new 
     453    else 
     454      definition = SchemaSequenceDefinition.new 
     455    end 
     456    schema_element.each do |ele| 
     457      element_definition = parse_schema_element_definition(ele, default_ns) 
     458      definition << element_definition 
     459      if element_definition.as_array? 
     460        definition.set_array 
     461      end 
     462    end 
     463    definition 
     464  end 
     465 
     466  # returns SchemaElementDefinition 
     467  def self.parse_schema_element_definition(schema_element, default_ns) 
     468    if schema_element[0] == :choice 
     469      parse_schema_definition(schema_element, default_ns) 
     470    elsif schema_element[0].is_a?(Array) 
     471      parse_schema_definition(schema_element, default_ns) 
     472    else 
     473      varname, info = schema_element 
    456474      mapped_class_str, elename = info 
    457       as_array = klass.ancestors.include?(::Array) 
     475      as_any = as_array = false 
    458476      if /\[\]$/ =~ mapped_class_str 
    459477        mapped_class_str = mapped_class_str.sub(/\[\]$/, '') 
    …… 
    470488      end 
    471489      if elename == XSD::AnyTypeName 
    472         definition.set_any 
     490        as_any = true 
    473491      elsif elename.nil? 
    474         ns ||= definition.elename.namespace if definition.elename 
    475         ns ||= definition.type.namespace if definition.type 
    476         elename = XSD::QName.new(ns, varname) 
    477       end 
    478       definition.elements << 
    479         SchemaElementDefinition.new(varname, mapped_class, elename, as_array) 
    480     end 
    481   end 
    482  
    483   class SchemaElementDefinition 
    484     attr_reader :varname, :mapped_class, :elename 
    485  
    486     def initialize(varname, mapped_class, elename, as_array) 
    487       @varname = varname 
    488       @mapped_class = mapped_class 
    489       @elename = elename 
    490       @as_array = as_array 
    491     end 
    492  
    493     def as_array? 
    494       @as_array 
    495     end 
    496  
    497     def is_concrete_definition 
    498       true 
    499     end 
    500   end 
    501  
    502   class SchemaElementChoiceDefinition < ::Array 
    503     def is_concrete_definition 
    504       true 
    505     end 
    506   end 
    507  
    508   class SchemaDefinition 
    509     attr_reader :class_for 
    510     attr_reader :elename, :type 
    511     attr_reader :qualified, :elements 
    512     attr_accessor :attributes 
    513  
    514     def initialize(class_for, elename, type, qualified) 
    515       @class_for = class_for 
    516       @elename = elename 
    517       @type = type 
    518       @qualified = qualified 
    519       @elements = [] 
    520       @attributes = nil 
    521       @choice = false 
    522       @any = false 
    523     end 
    524  
    525     def choice? 
    526       @choice 
    527     end 
    528  
    529     def have_any? 
    530       @any 
    531     end 
    532  
    533     def set_choice 
    534       @choice = true 
    535     end 
    536  
    537     def set_any 
    538       @any = true 
     492        elename = XSD::QName.new(default_ns, varname) 
     493      end 
     494      SchemaElementDefinition.new( 
     495        varname, mapped_class, elename, as_any, as_array) 
    539496    end 
    540497  end 

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

    r1771 r1788  
    207207  end 
    208208 
     209  def find_node_definition(node) 
     210    schema_definition_from_elename(node.elename) || 
     211      schema_definition_from_type(node.type) 
     212  end 
     213 
    209214  def find_schema_definition(name) 
    210215    return nil unless name 

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

    r1731 r1788  
    135135 
    136136  def complexobj2sequencesoap(obj, ele, type) 
    137     elements = type.elements 
    138     any = nil 
    139     if type.have_any? 
    140       any = Mapping.get_attributes_for_any(obj, elements) 
    141     end 
    142     elements.each do |child_ele| 
     137    type.elements.each do |child_ele| 
    143138      case child_ele 
    144139      when WSDL::XMLSchema::Any 
    145         if any 
    146           SOAPElement.from_objs(any).each do |child| 
    147             ele.add(child) 
    148           end 
     140        any = Mapping.get_attributes_for_any(obj) 
     141        SOAPElement.from_objs(any).each do |child| 
     142          ele.add(child) 
    149143        end 
    150144      when WSDL::XMLSchema::Element 
    …… 
    162156 
    163157  def complexobj2choicesoap(obj, ele, type) 
    164     elements = type.elements 
    165     any = nil 
    166     if type.have_any? 
    167       raise MappingError.new( 
    168         "<any/> in <choice/> is not supported: #{ele.name.name}") 
    169     end 
    170     elements.each do |child_ele| 
     158    type.elements.each do |child_ele| 
    171159      break if complexobj2soapchildren(obj, ele, child_ele, true) 
    172160    end 

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

    r1782 r1788  
    4747      result << dump_classdef(type.name, type) 
    4848    else 
     49      str = dump_complextype 
     50      unless str.empty? 
     51        result << "\n" unless result.empty? 
     52        result << str 
     53      end 
     54      str = dump_simpletype 
     55      unless str.empty? 
     56        result << "\n" unless result.empty? 
     57        result << str 
     58      end 
    4959      str = dump_element 
    5060      unless str.empty? 
    …… 
    5767        result << str 
    5868      end 
    59       str = dump_complextype 
    60       unless str.empty? 
    61         result << "\n" unless result.empty? 
    62         result << str 
    63       end 
    64       str = dump_simpletype 
    65       unless str.empty? 
    66         result << "\n" unless result.empty? 
    67         result << str 
    68       end 
    6969    end 
    7070    if @modulepath 
    …… 
    8080  def dump_element 
    8181    @elements.collect { |ele| 
     82      qualified = (ele.elementform == 'qualified') 
    8283      if ele.local_complextype 
    83         qualified = (ele.elementform == 'qualified') 
    8484        dump_complextypedef(ele.name, ele.local_complextype, qualified) 
    8585      elsif ele.local_simpletype 
    86         qualified = (ele.elementform == 'qualified') 
    8786        dump_simpletypedef(ele.name, ele.local_simpletype, qualified) 
     87      elsif ele.type 
     88        if @complextypes[ele.type] 
     89          dump_complextypedef(ele.name, @complextypes[ele.type], qualified) 
     90        elsif @simpletypes[ele.type] 
     91          dump_simpletypedef(ele.name, @simpletypes[ele.type], qualified) 
     92        else 
     93          nil 
     94        end 
    8895      else 
    8996        nil 

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

    r1759 r1788  
    3535    @varname = varname 
    3636    result = '' 
     37    str = dump_complextype 
     38    unless str.empty? 
     39      result << "\n" unless result.empty? 
     40      result << str 
     41    end 
     42    str = dump_simpletype 
     43    unless str.empty? 
     44      result << "\n" unless result.empty? 
     45      result << str 
     46    end 
    3747    str = dump_element 
    3848    unless str.empty? 
    …… 
    4151    end 
    4252    str = dump_attribute 
    43     unless str.empty? 
    44       result << "\n" unless result.empty? 
    45       result << str 
    46     end 
    47     str = dump_complextype 
    48     unless str.empty? 
    49       result << "\n" unless result.empty? 
    50       result << str 
    51     end 
    52     str = dump_simpletype 
    5353    unless str.empty? 
    5454      result << "\n" unless result.empty? 
    …… 
    6262  def dump_element 
    6363    @elements.collect { |ele| 
     64      qualified = (ele.elementform == 'qualified') 
    6465      if ele.local_complextype 
    65         qualified = (ele.elementform == 'qualified') 
    6666        dump_complextypedef(ele.name, ele.local_complextype, qualified) 
    6767      elsif ele.local_simpletype 
    68         dump_simpletypedef(ele.name, ele.local_simpletype) 
     68        dump_simpletypedef(ele.name, ele.local_simpletype, qualified) 
     69      elsif ele.type 
     70        if @complextypes[ele.type] 
     71          dump_complextypedef(ele.name, @complextypes[ele.type], qualified) 
     72        elsif @simpletypes[ele.type] 
     73          dump_simpletypedef(ele.name, @simpletypes[ele.type], qualified) 
     74        else 
     75          nil 
     76        end 
    6977      else 
    7078        nil 

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

    r1782 r1788  
    198198  end 
    199199 
    200   def dump_simpletypedef(qname, simpletype) 
     200  def dump_simpletypedef(qname, simpletype, qualified = false) 
    201201    if simpletype.restriction 
    202       dump_simpletypedef_restriction(qname, simpletype) 
     202      dump_simpletypedef_restriction(qname, simpletype, qualified) 
    203203    elsif simpletype.list 
    204       dump_simpletypedef_list(qname, simpletype) 
     204      dump_simpletypedef_list(qname, simpletype, qualified) 
    205205    elsif simpletype.union 
    206       dump_simpletypedef_union(qname, simpletype) 
     206      dump_simpletypedef_union(qname, simpletype, qualified) 
    207207    else 
    208208      raise RuntimeError.new("unknown kind of simpletype: #{simpletype}") 
    …… 
    210210  end 
    211211 
    212   def dump_simpletypedef_restriction(qname, typedef) 
     212  def dump_simpletypedef_restriction(qname, typedef, qualified) 
    213213    restriction = typedef.restriction 
    214214    if restriction.enumeration.empty? 
    …… 
    227227  end 
    228228 
    229   def dump_simpletypedef_list(qname, typedef) 
     229  def dump_simpletypedef_list(qname, typedef, qualified) 
    230230    nil 
    231231  end 
    232232 
    233   def dump_simpletypedef_union(qname, typedef) 
     233  def dump_simpletypedef_union(qname, typedef, qualified) 
    234234    nil 
    235235  end 

  • trunk/lib/wsdl/xmlSchema/complexContent.rb

    r1772 r1788  
    5656 
    5757  def attributes 
    58     content.attributes 
     58    content ? content.attributes : XSD::NamedElements::Empty 
    5959  end 
    6060 
    6161  def nested_elements 
    6262    # restrict and extension does not have particle. 
    63     elements 
     63    content ? content.nested_elements : XSD::NamedElements::Empty 
    6464  end 
    6565 

  • trunk/lib/wsdl/xmlSchema/complexExtension.rb

    r1727 r1788  
    4747    result.concat(basetype.elements) 
    4848    result.concat(content.elements) if content 
     49    result 
     50  end 
     51 
     52  def nested_elements 
     53    result = XSD::NamedElements.new 
     54    result.concat(basetype.nested_elements) 
     55    result.concat(content.nested_elements) if content 
    4956    result 
    5057  end 

  • trunk/lib/wsdl/xmlSchema/complexRestriction.rb

    r1772 r1788  
    4848  end 
    4949 
     50  def nested_elements 
     51    @content ? @content.nested_elements : XSD::NamedElements::Empty 
     52  end 
     53 
    5054  def check_type 
    5155    if @base == ::SOAP::ValueArrayName 

  • trunk/test/wsdl/any/expectedEcho.rb

    r1771 r1788  
    11require 'xsd/qname' 
    22 
    3 # {urn:example.com:echo-type}setOutputAndCompleteRequest 
    4 class SetOutputAndCompleteRequest 
    5   attr_accessor :taskId 
    6   attr_accessor :data 
    7   attr_accessor :participantToken 
     3# {urn:example.com:echo-type}foo.bar 
     4class FooBar 
     5  attr_accessor :before 
     6  attr_reader :__xmlele_any 
     7  attr_accessor :after 
    88 
    9   def initialize(taskId = nil, data = nil, participantToken = nil) 
    10     @taskId = taskId 
    11     @data = data 
    12     @participantToken = participantToken 
     9  def set_any(elements) 
     10    @__xmlele_any = elements 
     11  end 
     12 
     13  def initialize(before = nil, after = nil) 
     14    @before = before 
     15    @__xmlele_any = nil 
     16    @after = after 
    1317  end 
    1418end 
    …… 
    3034  end 
    3135end 
     36 
     37# {urn:example.com:echo-type}setOutputAndCompleteRequest 
     38class SetOutputAndCompleteRequest 
     39  attr_accessor :taskId 
     40  attr_accessor :data 
     41  attr_accessor :participantToken 
     42 
     43  def initialize(taskId = nil, data = nil, participantToken = nil) 
     44    @taskId = taskId 
     45    @data = data 
     46    @participantToken = participantToken 
     47  end 
     48end 

  • trunk/test/wsdl/choice/choice.wsdl

    r1657 r1788  
    5454        </xsd:complexType> 
    5555      </xsd:element> 
     56 
     57      <xsd:element name="echoele_complex" type="tns:andor" /> 
     58      <xsd:element name="echo_complex_response" type="tns:andor" /> 
    5659    </xsd:schema> 
    5760  </types> 
    …… 
    6366    <part name="parameters" element="tns:echo_response" /> 
    6467  </message> 
     68  <message name="echo_complex_in"> 
     69    <part name="parameters" element="tns:echoele_complex" /> 
     70  </message> 
     71  <message name="echo_complex_out"> 
     72    <part name="parameters" element="tns:echo_complex_response" /> 
     73  </message> 
    6574 
    6675  <portType name="choice_porttype"> 
    …… 
    6877      <input message="tns:echo_in" /> 
    6978      <output message="tns:echo_out" /> 
     79    </operation> 
     80 
     81    <operation name="echo_complex"> 
     82      <input message="tns:echo_complex_in" /> 
     83      <output message="tns:echo_complex_out" /> 
    7084    </operation> 
    7185  </portType> 
    …… 
    7589    <operation name="echo"> 
    7690      <soap:operation soapAction="urn:choice:echo" style="document" /> 
     91      <input> 
     92        <soap:body use="literal" /> 
     93      </input> 
     94      <output> 
     95        <soap:body use="literal" /> 
     96      </output> 
     97    </operation> 
     98 
     99    <operation name="echo_complex"> 
     100      <soap:operation soapAction="urn:choice:echo_complex" style="document" /> 
    77101      <input> 
    78102        <soap:body use="literal" /> 

  • trunk/test/wsdl/choice/test_choice.rb

    r1755 r1788  
    2121        XSD::QName.new(Namespace, 'echo_response') 
    2222      ) 
     23      add_document_method( 
     24        self, 
     25        Namespace + ':echo_complex', 
     26        'echo_complex', 
     27        XSD::QName.new(Namespace, 'echoele_complex'), 
     28        XSD::QName.new(Namespace, 'echo_complex_response') 
     29      ) 
    2330      @router.literal_mapping_registry = ChoiceMappingRegistry::LiteralRegistry 
    2431    end 
    2532   
    2633    def echo(arg) 
     34      arg 
     35    end 
     36 
     37    def echo_complex(arg) 
     38      p arg 
    2739      arg 
    2840    end 
    …… 
    132144    assert_nil(ret.terminalID.imei) 
    133145  end 
     146 
     147  def test_naive_complex 
     148    @client = ::SOAP::RPC::Driver.new("http://localhost:#{Port}/") 
     149    @client.add_document_method('echo_complex', 'urn:choice:echo_complex', 
     150      XSD::QName.new('urn:choice', 'echoele_complex'), 
     151      XSD::QName.new('urn:choice', 'echo_complex_response')) 
     152    @client.wiredump_dev = STDOUT if $DEBUG 
     153    @client.literal_mapping_registry = ChoiceMappingRegistry::LiteralRegistry 
     154    # 
     155    ret = @client.echo_complex(Andor.new("A", "B1", nil, nil, nil, nil, "C1", "C2")) 
     156    assert_equal("A", ret.a) 
     157    assert_equal("B1", ret.b1) 
     158    assert_equal(nil, ret.b2a) 
     159    assert_equal(nil, ret.b2b) 
     160    assert_equal(nil, ret.b3a) 
     161    assert_equal(nil, ret.b3b) 
     162    assert_equal("C1", ret.c1) 
     163    assert_equal("C2", ret.c2) 
     164    # 
     165    ret = @client.echo_complex(Andor.new("A", nil, "B2a", "B2b", nil, nil, "C1", "C2")) 
     166    assert_equal("A", ret.a) 
     167    assert_equal(nil, ret.b1) 
     168    assert_equal("B2a", ret.b2a) 
     169    assert_equal("B2b", ret.b2b) 
     170    assert_equal(nil, ret.b3a) 
     171    assert_equal(nil, ret.b3b) 
     172    assert_equal("C1", ret.c1) 
     173    assert_equal("C2", ret.c2) 
     174    # 
     175    ret = @client.echo_complex(Andor.new("A", nil, nil, nil, "B3a", nil, "C1", "C2")) 
     176    assert_equal("A", ret.a) 
     177    assert_equal(nil, ret.b1) 
     178    assert_equal(nil, ret.b2a) 
     179    assert_equal(nil, ret.b2b) 
     180    assert_equal("B3a", ret.b3a) 
     181    assert_equal(nil, ret.b3b) 
     182    assert_equal("C1", ret.c1) 
     183    assert_equal("C2", ret.c2) 
     184    # 
     185    ret = @client.echo_complex(Andor.new("A", nil, nil, nil, nil, "B3b", "C1", "C2")) 
     186    assert_equal("A", ret.a) 
     187    assert_equal(nil, ret.b1) 
     188    assert_equal(nil, ret.b2a) 
     189    assert_equal(nil, ret.b2b) 
     190    assert_equal(nil, ret.b3a) 
     191    assert_equal("B3b", ret.b3b) 
     192    assert_equal("C1", ret.c1) 
     193    assert_equal("C2", ret.c2) 
     194  end 
    134195end 
    135196 

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

    r1772 r1788  
    11require 'xsd/qname' 
    2  
    3 # {urn:ref}Rating 
    4 class Rating < ::String 
    5   C_0 = Rating.new("0") 
    6   C_1 = Rating.new("+1") 
    7   C_1_2 = Rating.new("-1") 
    8 end 
    9  
    10 # {urn:ref}Product-Bag 
    11 class ProductBag 
    12   attr_accessor :bag 
    13   attr_accessor :rating 
    14   attr_accessor :comment_1 
    15   attr_accessor :comment_2 
    16  
    17   def m___point 
    18     @v___point 
    19   end 
    20  
    21   def m___point=(value) 
    22     @v___point = value 
    23   end 
    24  
    25   def xmlattr_version 
    26     (@__xmlattr ||= {})[XSD::QName.new("urn:ref", "version")] 
    27   end 
    28  
    29   def xmlattr_version=(value) 
    30     (@__xmlattr ||= {})[XSD::QName.new("urn:ref", "version")] = value 
    31   end 
    32  
    33   def xmlattr_yesno 
    34     (@__xmlattr ||= {})[XSD::QName.new("urn:ref", "yesno")] 
    35   end 
    36  
    37   def xmlattr_yesno=(value) 
    38     (@__xmlattr ||= {})[XSD::QName.new("urn:ref", "yesno")] = value 
    39   end 
    40  
    41   def initialize(bag = [], rating = [], comment_1 = [], comment_2 = [], v___point = nil) 
    42     @bag = bag 
    43     @rating = rating 
    44     @comment_1 = comment_1 
    45     @comment_2 = comment_2 
    46     @v___point = v___point 
    47     @__xmlattr = {} 
    48   end 
    49 end 
    50  
    51 # {urn:ref}Creator 
    52 class Creator < ::String 
    53   def xmlattr_Role 
    54     (@__xmlattr ||= {})[XSD::QName.new(nil, "Role")] 
    55   end 
    56  
    57   def xmlattr_Role=(value) 
    58     (@__xmlattr ||= {})[XSD::QName.new(nil, "Role")] = value 
    59   end 
    60  
    61   def initialize(*arg) 
    62     super 
    63     @__xmlattr = {} 
    64   end 
    65 end 
    66  
    67 # {urn:ref}yesno 
    68 class Yesno < ::String 
    69   N = Yesno.new("N") 
    70   Y = Yesno.new("Y") 
    71 end 
    722 
    733# {urn:ref}Product 
    …… 
    15787  end 
    15888end 
     89 
     90# {urn:ref}Rating 
     91class Rating < ::String 
     92  C_0 = Rating.new("0") 
     93  C_1 = Rating.new("+1") 
     94  C_1_2 = Rating.new("-1") 
     95end 
     96 
     97# {urn:ref}Product-Bag 
     98class ProductBag 
     99  attr_accessor :bag 
     100  attr_accessor :rating 
     101  attr_accessor :comment_1 
     102  attr_accessor :comment_2 
     103 
     104  def m___point 
     105    @v___point 
     106  end 
     107 
     108  def m___point=(value) 
     109    @v___point = value 
     110  end 
     111 
     112  def xmlattr_version 
     113    (@__xmlattr ||= {})[XSD::QName.new("urn:ref", "version")] 
     114  end 
     115 
     116  def xmlattr_version=(value) 
     117    (@__xmlattr ||= {})[XSD::QName.new("urn:ref", "version")] = value 
     118  end 
     119 
     120  def xmlattr_yesno 
     121    (@__xmlattr ||= {})[XSD::QName.new("urn:ref", "yesno")] 
     122  end 
     123 
     124  def xmlattr_yesno=(value) 
     125    (@__xmlattr ||= {})[XSD::QName.new("urn:ref", "yesno")] = value 
     126  end 
     127 
     128  def initialize(bag = [], rating = [], comment_1 = [], comment_2 = [], v___point = nil) 
     129    @bag = bag 
     130    @rating = rating 
     131    @comment_1 = comment_1 
     132    @comment_2 = comment_2 
     133    @v___point = v___point 
     134    @__xmlattr = {} 
     135  end 
     136end 
     137 
     138# {urn:ref}Creator 
     139class Creator < ::String 
     140  def xmlattr_Role 
     141    (@__xmlattr ||= {})[XSD::QName.new(nil, "Role")] 
     142  end 
     143 
     144  def xmlattr_Role=(value) 
     145    (@__xmlattr ||= {})[XSD::QName.new(nil, "Role")] = value 
     146  end 
     147 
     148  def initialize(*arg) 
     149    super 
     150    @__xmlattr = {} 
     151  end 
     152end 
     153 
     154# {urn:ref}yesno 
     155class Yesno < ::String 
     156  N = Yesno.new("N") 
     157  Y = Yesno.new("Y") 
     158end 

  • trunk/test/wsdl/rpc/test_rpc_lit.rb

    r1755 r1788  
    322322    assert_equal('+1', result.varFloat) 
    323323    assert_equal('str', result.structItem.varString) 
    324     assert_equal('1', result.structItem.varInt) 
    325     assert_equal('+1', result.structItem.varFloat) 
     324    assert_equal(1, result.structItem.varInt) 
     325    assert_equal(1.0, result.structItem.varFloat) 
    326326    assert_equal(ECHO_NESTED_STRUCT_REQUEST, parse_requestxml(str)) 
    327327    assert_equal(ECHO_NESTED_STRUCT_RESPONSE, parse_responsexml(str))