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

Changeset 1724

Show
Ignore:
Timestamp:
09/24/06 21:02:36 (2 years ago)
Author:
nahi
Message:

more aggressive xml 'qualified' control. closes #260.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/lib/soap/baseData.rb

    r1705 r1724  
    8282  include SOAP 
    8383 
     84  attr_accessor :qualified 
     85 
    8486  def initialize(*arg) 
    8587    super 
     88    @qualified = nil 
    8689  end 
    8790end 
    …… 
    9598  include SOAP 
    9699 
     100  attr_accessor :qualified 
     101 
    97102  def initialize(*arg) 
    98103    super 
     104    @qualified = nil 
    99105  end 
    100106end 

  • trunk/lib/soap/element.rb

    r1690 r1724  
    162162    @actor = actor 
    163163    element.parent = self if element 
     164    element.qualified = true 
    164165  end 
    165166 

  • trunk/lib/soap/generator.rb

    r1707 r1724  
    3838    @generate_explicit_type = 
    3939      opt.key?(:generate_explicit_type) ? opt[:generate_explicit_type] : true 
     40    # elementformdefault is for default namespace usage controll 
     41    # TODO: should be renamed 
    4042    @elementformdefault = opt[:elementformdefault] 
    4143    @attributeformdefault = opt[:attributeformdefault] 
    …… 
    139141      data.elename.name 
    140142    else 
    141       if element_qualified?(data) 
     143      if @elementformdefault 
    142144        SOAPGenerator.assign_ns(attrs, ns, data.elename.namespace, '') 
    143145      else 
    …… 
    217219  end 
    218220 
    219   def element_qualified?(element) 
    220     if element.respond_to?(:qualified) 
    221       if element.qualified.nil? 
    222         @elementformdefault 
    223       else 
    224         element.qualified 
    225       end 
    226     else 
    227       @elementformdefault 
    228     end 
    229   end 
    230  
    231221  def self.assign_ns(attrs, ns, namespace, tag = nil) 
    232222    if namespace.nil? 

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

    r1720 r1724  
    5454 
    5555  def setdefinediv2soap(ele, obj, map) 
    56     # cache needed? 
    5756    definition = Mapping.schema_definition_classdef(obj.class) 
    5857    definition.elements.each do |eledef| 

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

    r1721 r1724  
    2929    @excn_handler_soap2obj = nil 
    3030    @class_schema_definition = {} 
    31     @qname_schema_definition = {} 
     31    @elename_schema_definition = {} 
     32    @type_schema_definition = {} 
    3233  end 
    3334 
    …… 
    3738    if definition.name 
    3839      qname = XSD::QName.new(definition.ns, definition.name) 
    39       @qname_schema_definition[qname] = [obj_class, definition] 
     40      @elename_schema_definition[qname] = definition 
    4041    end 
    4142    if definition.type 
    4243      qname = XSD::QName.new(definition.ns, definition.type) 
    43       @qname_schema_definition[qname] = [obj_class, definition] 
     44      @type_schema_definition[qname] = definition 
    4445    end 
    4546  end 
    …… 
    124125    end 
    125126    ele.qualified = definition.qualified 
    126     ele.extraattr[XSD::AttrTypeName] = 
    127       XSD::QName.new(definition.ns, definition.type) 
     127    if definition.type 
     128      ele.extraattr[XSD::AttrTypeName] = 
     129        XSD::QName.new(definition.ns, definition.type) 
     130    end 
    128131    any = nil 
    129132    if definition.have_any? 
    …… 
    172175      definition = schema_definition_from_class(obj_class) 
    173176    else 
    174       obj_class, definition = schema_definition_from_qname(node.elename) 
    175       unless obj_class 
    176         typestr = XSD::CodeGen::GenSupport.safeconstname(node.elename.name) 
    177         obj_class = Mapping.class_from_name(typestr) 
    178         definition = schema_definition_from_class(obj_class) if obj_class 
     177      definition = schema_definition_from_elename(node.elename) 
     178      if definition 
     179        obj_class = definition.class_for 
    179180      end 
    180181    end 
    …… 
    239240 
    240241  def elesoapchild2obj(value, ns, eledef) 
    241     obj_class, child_definition = schema_definition_from_qname(eledef.elename) 
     242    child_definition = schema_definition_from_elename(eledef.elename) 
    242243    if child_definition 
    243       any2obj(value, obj_class) 
     244      any2obj(value, child_definition.class_for) 
    244245    elsif eledef.type 
    245       obj_class, child_definition = 
    246         schema_definition_from_qname(XSD::QName.new(ns, eledef.type)) 
     246      child_definition = 
     247        schema_definition_from_type(XSD::QName.new(ns, eledef.type)) 
    247248      if child_definition 
    248         any2obj(value, obj_class) 
     249        any2obj(value, child_definition.class_for) 
    249250      elsif klass = Mapping.class_from_name(eledef.type) 
    250251        # klass must be a SOAPBasetype or a class 
    …… 
    342343  end 
    343344 
    344   def class_from_schema_definition(definition) 
    345     @class_schema_definition.key(definition) 
    346   end 
    347  
    348   def schema_definition_from_qname(qname) 
    349     @qname_schema_definition[qname] 
     345  def schema_definition_from_elename(qname) 
     346    @elename_schema_definition[qname] || find_schema_definition(qname.name) 
     347  end 
     348 
     349  def schema_definition_from_type(type) 
     350    @type_schema_definition[type] || find_schema_definition(type.name) 
     351  end 
     352 
     353  def find_schema_definition(name) 
     354    typestr = XSD::CodeGen::GenSupport.safeconstname(name) 
     355    obj_class = Mapping.class_from_name(typestr) 
     356    if obj_class 
     357      schema_definition_from_class(obj_class) 
     358    end 
    350359  end 
    351360end 

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

    r1721 r1724  
    404404    schema_element = definition[:schema_element] 
    405405    schema_attributes = definition[:schema_attribute] 
    406     definition = SchemaDefinition.new(schema_ns, schema_name, schema_type, 
    407       schema_qualified) 
     406    definition = SchemaDefinition.new(klass, schema_ns, schema_name, 
     407      schema_type, schema_qualified) 
    408408    definition.attributes = schema_attributes 
    409409    if schema_element 
    …… 
    454454 
    455455  class SchemaDefinition 
    456     attr_reader :ns, :name, :type, :qualified, :elements 
     456    attr_reader :class_for, :ns, :name, :type, :qualified, :elements 
    457457    attr_accessor :attributes 
    458458 
    459     def initialize(ns, name, type, qualified) 
     459    def initialize(class_for, ns, name, type, qualified) 
     460      @class_for = class_for 
    460461      @ns = ns 
    461462      @name = name 

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

    r1720 r1724  
    151151   
    152152  def add_attributes2soap(obj, ele) 
    153     schema_definition = Mapping.schema_definition_classdef(obj.class) 
    154     if schema_definition && attributes = schema_definition.attributes 
     153    definition = Mapping.schema_definition_classdef(obj.class) 
     154    if definition && attributes = definition.attributes 
    155155      attributes.each do |qname, param| 
    156156        at = obj.__send__( 
    …… 
    165165  end 
    166166 
    167   def base2soap(obj, type) 
     167  def base2soap(obj, type, qualified = nil) 
    168168    soap_obj = nil 
    169169    if type <= XSD::XSDString 
    …… 
    174174      soap_obj = type.new(obj) 
    175175    end 
     176    soap_obj.qualified = qualified 
    176177    soap_obj 
    177178  end 

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

    r1720 r1724  
    8080    if eledef.type 
    8181      if type = @definedtypes[eledef.type] 
    82         ele = obj2typesoap(obj, type, qualified) 
     82        ele = obj2typesoap(obj, type) 
    8383      elsif type = TypeMap[eledef.type] 
    8484        ele = base2soap(obj, type) 
    …… 
    8787      end 
    8888    elsif eledef.local_complextype 
    89       ele = obj2typesoap(obj, eledef.local_complextype, qualified) 
     89      ele = obj2typesoap(obj, eledef.local_complextype) 
    9090    elsif eledef.local_simpletype 
    91       ele = obj2typesoap(obj, eledef.local_simpletype, qualified) 
     91      ele = obj2typesoap(obj, eledef.local_simpletype) 
    9292    else 
    9393      raise MappingError.new('illegal schema?') 
    9494    end 
    9595    ele.elename = eledef.name 
    96     ele 
    97   end 
    98  
    99   def obj2typesoap(obj, type, qualified) 
     96    ele.qualified = qualified 
     97    ele 
     98  end 
     99 
     100  def obj2typesoap(obj, type) 
    100101    ele = nil 
    101102    if type.is_a?(::WSDL::XMLSchema::SimpleType) 
    …… 
    104105      ele = simpleobj2soap(obj, type.simplecontent) 
    105106    else 
    106       ele = complexobj2soap(obj, type, qualified) 
     107      ele = complexobj2soap(obj, type) 
    107108    end 
    108109    add_attributes2soap(obj, ele) 
    …… 
    124125  end 
    125126 
    126   def complexobj2soap(obj, type, qualified) 
     127  def complexobj2soap(obj, type) 
    127128    ele = SOAPElement.new(type.name) 
    128     ele.qualified = qualified 
    129129    if type.choice? 
    130130      complexobj2choicesoap(obj, ele, type) 

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

    r1720 r1724  
    9999    opt[:request_use] ||= :literal 
    100100    opt[:response_use] ||= :literal 
    101     # default values of these values are unqualified in XML Schema. 
    102     # set true for backward compatibility. 
    103     unless opt.key?(:elementformdefault) 
    104       opt[:elementformdefault] = true 
    105     end 
    106     unless opt.key?(:attributeformdefault) 
    107       opt[:attributeformdefault] = true 
    108     end 
    109101    op = Operation.new(soapaction, param_def, opt) 
    110102    assign_operation(name, nil, soapaction, op) 
    …… 
    487479        ele = Mapping.obj2soap(values[idx], mapping_registry, nil, opt) 
    488480        ele.elename = @doc_request_qnames[idx] 
     481        ele.qualified = @doc_request_qualified[idx] 
    489482        ele 
    490483      } 
    …… 
    496489          @doc_request_qnames[idx], opt) 
    497490        ele.encodingstyle = LiteralNamespace 
    498         if ele.respond_to?(:qualified) 
    499           ele.qualified = @doc_request_qualified[idx] 
    500         end 
     491        ele.qualified = @doc_request_qualified[idx] 
    501492        ele 
    502493      } 

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

    r1720 r1724  
    538538        ele = Mapping.obj2soap(result[idx], mapping_registry, nil, opt) 
    539539        ele.elename = @doc_response_qnames[idx] 
     540        ele.qualified = @doc_response_qualified[idx] 
    540541        ele 
    541542      } 
    …… 
    547548          @doc_response_qnames[idx]) 
    548549        ele.encodingstyle = LiteralNamespace 
    549         if ele.respond_to?(:qualified) 
    550           ele.qualified = @doc_response_qualified[idx] 
    551         end 
     550        ele.qualified = @doc_response_qualified[idx] 
    552551        ele 
    553552      } 

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

    r1719 r1724  
    7272        dump_complextypedef(ele.name, ele.local_complextype, qualified) 
    7373      elsif ele.local_simpletype 
    74         dump_simpletypedef(ele.name, ele.local_simpletype) 
     74        qualified = (ele.elementform == 'qualified') 
     75        dump_simpletypedef(ele.name, ele.local_simpletype, qualified) 
    7576      else 
    7677        nil 
    …… 
    99100  end 
    100101 
    101   def dump_simpletypedef(qname, simpletype) 
     102  def dump_simpletypedef(qname, simpletype, qualified = false) 
    102103    if simpletype.restriction 
    103       dump_simpletypedef_restriction(qname, simpletype) 
     104      dump_simpletypedef_restriction(qname, simpletype, qualified) 
    104105    elsif simpletype.list 
    105       dump_simpletypedef_list(qname, simpletype) 
     106      dump_simpletypedef_list(qname, simpletype, qualified) 
    106107    else 
    107108      raise RuntimeError.new("unknown kind of simpletype: #{simpletype}") 
    …… 
    109110  end 
    110111 
    111   def dump_simpletypedef_restriction(qname, typedef) 
     112  def dump_simpletypedef_restriction(qname, typedef, qualified) 
    112113    restriction = typedef.restriction 
    113114    if restriction.enumeration.empty? 
    …… 
    126127    end 
    127128    c.def_classvar('schema_ns', ndq(qname.namespace)) 
     129    c.def_classvar('schema_qualified', dq('true')) if qualified 
    128130    define_classenum_restriction(c, classname, restriction.enumeration) 
    129131    c.dump 
    130132  end 
    131133 
    132   def dump_simpletypedef_list(qname, typedef) 
     134  def dump_simpletypedef_list(qname, typedef, qualified) 
    133135    list = typedef.list 
    134136    c = ClassDef.new(create_class_name(qname), '::Array') 

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

    r1720 r1724  
    99require 'wsdl/info' 
    1010require 'wsdl/soap/mappingRegistryCreator' 
     11require 'wsdl/soap/literalMappingRegistryCreator' 
    1112require 'wsdl/soap/methodDefCreator' 
    1213require 'wsdl/soap/classDefCreatorSupport' 
    …… 
    4445  def dump_porttype(porttype) 
    4546    class_name = create_class_name(porttype) 
    46     methoddef, types = MethodDefCreator.new(@definitions).dump(porttype) 
     47    methoddef, methodtypes = MethodDefCreator.new(@definitions).dump(porttype) 
    4748    mr_creator = MappingRegistryCreator.new(@definitions) 
     49    literal_mr_creator = LiteralMappingRegistryCreator.new(@definitions) 
    4850    binding = @definitions.bindings.find { |item| item.type == porttype } 
    4951    if binding.nil? or binding.soapbinding.nil? 
    …… 
    5557    c = XSD::CodeGen::ClassDef.new(class_name, "::SOAP::RPC::Driver") 
    5658    c.def_require("soap/rpc/driver") 
     59    #c.def_const("EncodedMappingRegistry", "::SOAP::Mapping::EncodedRegistry.new") 
    5760    c.def_const("MappingRegistry", "::SOAP::Mapping::EncodedRegistry.new") 
     61    #c.def_const("LiteralMappingRegistry", "::SOAP::Mapping::LiteralRegistry.new") 
    5862    c.def_const("DefaultEndpointUrl", ndq(address)) 
    59     c.def_code(mr_creator.dump(types)) 
     63    c.def_code(mr_creator.dump(methodtypes)) 
     64    #c.def_code(literal_mr_creator.dump) 
    6065    c.def_code <<-EOD 
    6166Methods = [ 
    …… 
    6368] 
    6469    EOD 
     70        #self.literal_mapping_registry = LiteralMappingRegistry 
    6571    c.def_method("initialize", "endpoint_url = nil") do 
    6672      <<-EOD 

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

    r1711 r1724  
    7070    operation.inputparts.each do |input| 
    7171      param << param_set(::SOAP::RPC::SOAPMethod::IN, input.name, 
    72         documentdefinedtype(input), elementqualified(input)) 
     72        documentdefinedtype(input)) 
    7373    end 
    7474    operation.outputparts.each do |output| 
    7575      param << param_set(::SOAP::RPC::SOAPMethod::OUT, output.name, 
    76         documentdefinedtype(output), elementqualified(output)) 
     76        documentdefinedtype(output)) 
    7777    end 
    7878    param 
    …… 
    170170  end 
    171171 
    172   def elementqualified(part) 
    173     if mapped = basetype_mapped_class(part.type) 
    174       false 
    175     elsif definedtype = @simpletypes[part.type] 
    176       false 
    177     elsif definedtype = @elements[part.element] 
    178       definedtype.elementform == 'qualified' 
    179     elsif definedtype = @complextypes[part.type] 
    180       false 
    181     else 
    182       raise RuntimeError.new("part: #{part.name} cannot be resolved") 
    183     end 
    184   end 
    185  
    186172  def param_set(io_type, name, type, ele = nil) 
    187173    [io_type, name, type, ele] 

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

    r1653 r1724  
    5050    when ElementName 
    5151      o = Element.new 
     52      o.form = elementformdefault 
    5253      @elements << o 
    5354      o 

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

    r1648 r1724  
    116116    when FormAttrName 
    117117      @form = value.source 
     118      if @form != 'qualified' and @name.namespace 
     119        @name = XSD::QName.new(nil, @name.name) 
     120      end 
     121      @form 
    118122    when TypeAttrName 
    119123      @type = value 

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

    r1580 r1724  
    7070    when ElementName 
    7171      o = Element.new 
     72      o.form = 'qualified'      # root element is qualified 
    7273      @elements << o 
    7374      o 

  • trunk/test/soap/asp.net/test_aspdotnet.rb

    r1624 r1724  
    9898      @client.default_encodingstyle = SOAP::EncodingStyle::ASPDotNetHandler::Namespace 
    9999      assert_equal("Hello Mike", @client.sayHello("Mike")) 
    100       assert_equal(REQUEST_ASPDOTNETHANDLER, parse_requestxml(str)) 
     100      assert_equal(REQUEST_ASPDOTNETHANDLER, parse_requestxml(str), 
     101        [REQUEST_ASPDOTNETHANDLER, parse_requestxml(str)].join("\n\n")) 
    101102    end 
    102103 

  • trunk/test/soap/helloworld/test_helloworld.rb

    r1520 r1724  
    2020    @endpoint = "http://localhost:#{Port}/" 
    2121    @client = SOAP::RPC::Driver.new(@endpoint, 'urn:hws') 
     22    @client.wiredump_dev = STDERR if $DEBUG 
    2223    @client.add_method("hello_world", "from") 
    2324  end 

  • trunk/test/wsdl/any/any.wsdl

    r1649 r1724  
    2121 
    2222  <message name="msg_echoitem"> 
    23     <part name="parameters" element="txd:foo.bar"/> 
     23    <part name="parameters" type="txd:foo.bar"/> 
    2424  </message> 
    2525 

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

    r1720 r1724  
    1010    [ "urn:example.com:echo", 
    1111      "echo", 
    12       [ ["in", "parameters", ["::SOAP::SOAPElement", "urn:example.com:echo-type", "foo.bar"], false], 
    13         ["out", "parameters", ["::SOAP::SOAPElement", "urn:example.com:echo-type", "foo.bar"], false] ], 
     12      [ ["in", "parameters", ["::SOAP::SOAPElement", "urn:example.com:echo-type", "foo.bar"]], 
     13        ["out", "parameters", ["::SOAP::SOAPElement", "urn:example.com:echo-type", "foo.bar"]] ], 
    1414      { :request_style =>  :document, :request_use =>  :literal, 
    1515        :response_style => :document, :response_use => :literal } 

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

    r1720 r1724  
    1111    [ "urn:example.com:echo", 
    1212      "echo", 
    13       [ ["in", "parameters", ["::SOAP::SOAPElement", "urn:example.com:echo-type", "foo.bar"], false], 
    14         ["out", "parameters", ["::SOAP::SOAPElement", "urn:example.com:echo-type", "foo.bar"], false] ], 
     13      [ ["in", "parameters", ["::SOAP::SOAPElement", "urn:example.com:echo-type", "foo.bar"]], 
     14        ["out", "parameters", ["::SOAP::SOAPElement", "urn:example.com:echo-type", "foo.bar"]] ], 
    1515      { :request_style =>  :document, :request_use =>  :literal, 
    1616        :response_style => :document, :response_use => :literal } 

  • trunk/test/wsdl/qualified/np.wsdl

    r1626 r1724  
    66        <s:complexType> 
    77          <s:sequence> 
     8            <s:element minOccurs="0" maxOccurs="1" form="unqualified" name="Min" type="s:string" /> 
    89            <s:element minOccurs="0" maxOccurs="1" name="Max" type="s:string" /> 
    910          </s:sequence> 

  • trunk/test/wsdl/qualified/test_qualified.rb

    r1621 r1724  
    8888  end 
    8989 
    90   LOGIN_REQUEST_QUALIFIED_NS = 
     90  LOGIN_REQUEST_QUALIFIED = 
    9191%q[<?xml version="1.0" encoding="utf-8" ?> 
    9292<env:Envelope xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
    …… 
    9595  <env:Body> 
    9696    <n1:GetPrimeNumbers xmlns:n1="http://www50.brinkster.com/vbfacileinpt/np"> 
     97      <Min>2</Min> 
    9798      <n1:Max>10</n1:Max> 
    9899    </n1:GetPrimeNumbers> 
    99   </env:Body> 
    100 </env:Envelope>] 
    101  
    102   LOGIN_REQUEST_QUALIFIED = 
    103 %q[<?xml version="1.0" encoding="utf-8" ?> 
    104 <env:Envelope xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
    105     xmlns:env="http://schemas.xmlsoap.org/soap/envelope/" 
    106     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
    107   <env:Body> 
    108     <GetPrimeNumbers xmlns="http://www50.brinkster.com/vbfacileinpt/np"> 
    109       <Max>10</Max> 
    110     </GetPrimeNumbers> 
    111100  </env:Body> 
    112101</env:Envelope>] 
    …… 
    124113    @client.endpoint_url = "http://localhost:#{Port}/" 
    125114    @client.wiredump_dev = str = '' 
    126     @client.GetPrimeNumbers(:Max => 10) 
    127     assert_equal(LOGIN_REQUEST_QUALIFIED_NS, parse_requestxml(str)) 
     115    @client.GetPrimeNumbers(:Min => 2, :Max => 10) 
     116    assert_equal(LOGIN_REQUEST_QUALIFIED, parse_requestxml(str), 
     117      [LOGIN_REQUEST_QUALIFIED, parse_requestxml(str)].join("\n\n")) 
    128118  end 
    129119 
    …… 
    140130 
    141131    @client.wiredump_dev = str = '' 
    142     @client.getPrimeNumbers(GetPrimeNumbers.new(10)) 
    143     assert_equal(LOGIN_REQUEST_QUALIFIED, parse_requestxml(str)) 
     132    @client.getPrimeNumbers(GetPrimeNumbers.new(2, 10)) 
     133    assert_equal(LOGIN_REQUEST_QUALIFIED, parse_requestxml(str), 
     134      [LOGIN_REQUEST_QUALIFIED, parse_requestxml(str)].join("\n\n")) 
    144135  end 
    145136 

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

    r1719 r1724  
    55  @@schema_type = nil 
    66  @@schema_ns = "urn:ref" 
     7  @@schema_qualified = "true" 
    78 
    89  C_0 = Rating.new("0") 
    …… 
    1516  @@schema_type = nil 
    1617  @@schema_ns = "urn:ref" 
     18  @@schema_qualified = "true" 
    1719  @@schema_attribute = { 
    1820    XSD::QName.new("urn:ref", "version") => "SOAP::SOAPString",