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

Changeset 1923

Show
Ignore:
Timestamp:
08/26/07 17:45:43 (1 year ago)
Author:
nahi
Message:
  • removed :schema_ns definition from mappingRegistry stub file. this definition is only needed for constructing QName of :schema_name or :schema_type. just put QNames for :schema_name and :schema_type in generated stub file.
Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/lib/soap/baseData.rb

    r1910 r1923  
    643643    if elename.nil? 
    644644      elename = XSD::QName::EMPTY 
    645     elsif !elename.is_a?(XSD::QName) 
    646       elename = XSD::QName.new(nil, elename) 
     645    else 
     646      elename = Mapping.to_qname(elename) 
    647647    end 
    648648    @encodingstyle = LiteralNamespace 

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

    r1894 r1923  
    270270    else 
    271271      XSD::QName.new(namespace, name) 
     272    end 
     273  end 
     274 
     275  def self.to_qname(obj, ns = nil) 
     276    if obj.is_a?(XSD::QName) 
     277      obj 
     278    else 
     279      XSD::QName.new(ns, obj) 
    272280    end 
    273281  end 
    …… 
    391399      return Thread.current[:SOAPMapping][:SchemaDefinition][klass] 
    392400    end 
    393     ns = schema_ns_definition(klass) 
    394     name = schema_name_definition(klass) 
    395     type = schema_type_definition(klass) 
     401    schema_ns = schema_ns_definition(klass) 
     402    schema_name = schema_name_definition(klass) 
     403    schema_type = schema_type_definition(klass) 
    396404    qualified = schema_qualified_definition(klass) 
    397405    elements = schema_element_definition(klass) 
    398406    attributes = schema_attribute_definition(klass) 
    399     return nil if ns.nil? and name.nil? and type.nil? and elements.nil? and attributes.nil? 
     407    return nil if schema_name.nil? and schema_type.nil? 
     408    schema_name = Mapping.to_qname(schema_name, schema_ns) if schema_name 
     409    schema_type = Mapping.to_qname(schema_type, schema_ns) if schema_type 
    400410    definition = create_schema_definition(klass, 
    401       :schema_ns => ns, 
    402       :schema_name => name, 
    403       :schema_type => type, 
     411      :schema_name => schema_name, 
     412      :schema_type => schema_type, 
    404413      :schema_qualified => qualified, 
    405414      :schema_element => elements, 
    …… 
    414423    schema_name = definition[:schema_name] 
    415424    schema_type = definition[:schema_type] 
     425    # wrap if needed for backward compatibility 
     426    if schema_ns 
     427      schema_name = Mapping.to_qname(schema_name, schema_ns) if schema_name 
     428      schema_type = Mapping.to_qname(schema_type, schema_ns) if schema_type 
     429    end 
    416430    schema_qualified = definition[:schema_qualified] 
    417431    schema_element = definition[:schema_element] 
    418432    schema_attributes = definition[:schema_attribute] 
    419     elename = schema_name ? XSD::QName.new(schema_ns, schema_name) : nil 
    420     type = schema_type ? XSD::QName.new(schema_ns, schema_type) : nil 
    421     definition = SchemaDefinition.new(klass, elename, type, schema_qualified) 
     433    definition = SchemaDefinition.new(klass, schema_name, schema_type, schema_qualified) 
    422434    definition.attributes = schema_attributes 
    423435    if schema_element 
    …… 
    426438        definition.elements = schema_element 
    427439      else 
    428         default_ns = elename.namespace if elename 
    429         default_ns ||= type.namespace if type 
     440        default_ns = schema_name.namespace if schema_name 
     441        default_ns ||= schema_type.namespace if schema_type 
    430442        definition.elements = parse_schema_definition(schema_element, default_ns) 
    431443        if klass < ::Array 

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

    r1862 r1923  
    5252 
    5353  def [](qname) 
    54     unless qname.is_a?(XSD::QName) 
    55       qname = XSD::QName.new(nil, qname) 
    56     end 
     54    qname = Mapping.to_qname(qname) 
    5755    @__xmlele.each do |k, v| 
    5856      return v if k == qname 
    …… 
    6664 
    6765  def []=(qname, value) 
    68     unless qname.is_a?(XSD::QName) 
    69       qname = XSD::QName.new(nil, qname) 
    70     end 
     66    qname = Mapping.to_qname(qname) 
    7167    found = false 
    7268    @__xmlele.each do |pair| 

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

    r1915 r1923  
    124124    var = {} 
    125125    var[:class] = create_class_name(qname, @modulepath) 
    126     var[:schema_ns] = qname.namespace 
     126    schema_ns = qname.namespace 
    127127    if typedef.name.nil? 
    128128      # local complextype of a element 
    129       var[:schema_name] = qname.name 
     129      var[:schema_name] = qname 
    130130    else 
    131131      # named complextype 
    132       var[:schema_type] = qname.name 
     132      var[:schema_type] = qname 
    133133    end 
    134134    child_type = typedef.child_type 
    …… 
    161161    parsed_element << [child_element_name.name, child_element_name, type, occurrence] 
    162162    var[:schema_element] = dump_schema_element_definition(parsed_element, 2) 
    163     assign_const(var[:schema_ns], 'Ns') 
     163    assign_const(schema_ns, 'Ns') 
    164164    dump_entry(@varname, var) 
    165165  end 

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

    r1915 r1923  
    3030    var[:class] = create_class_name(qname, parentmodule) 
    3131    if as_element 
    32       var[:schema_name] = as_element.name 
    33       var[:schema_ns] = as_element.namespace 
     32      var[:schema_name] = as_element 
     33      chema_ns = as_element.namespace 
    3434    elsif typedef.name.nil? 
    35       var[:schema_name] = qname.name 
    36       var[:schema_ns] = qname.namespace 
    37     else 
    38       var[:schema_type] = qname.name 
    39       var[:schema_ns] = qname.namespace 
     35      var[:schema_name] = qname 
     36      schema_ns = qname.namespace 
     37    else 
     38      var[:schema_type] = qname 
     39      schema_ns = qname.namespace 
    4040    end 
    4141    # true, false, or nil 
    …… 
    5353      var[:schema_attribute] = define_attribute(typedef.attributes) 
    5454    end 
    55     assign_const(var[:schema_ns], 'Ns') 
     55    assign_const(schema_ns, 'Ns') 
    5656    dump_entry(@varname, var) 
    5757  end 
    …… 
    6161    var[:class] = create_class_name(qname, @modulepath) 
    6262    if as_element 
    63       var[:schema_name] = as_element.name 
    64       var[:schema_ns] = as_element.namespace 
     63      var[:schema_name] = as_element 
     64      schema_ns = as_element.namespace 
    6565    elsif typedef.name.nil? 
    66       var[:schema_name] = qname.name 
    67       var[:schema_ns] = qname.namespace 
    68     else 
    69       var[:schema_type] = qname.name 
    70       var[:schema_ns] = qname.namespace 
     66      var[:schema_name] = qname 
     67      schema_ns = qname.namespace 
     68    else 
     69      var[:schema_type] = qname 
     70      schema_ns = qname.namespace 
    7171    end 
    7272    unless typedef.attributes.empty? 
    7373      var[:schema_attribute] = define_attribute(typedef.attributes) 
    7474    end 
    75     assign_const(var[:schema_ns], 'Ns') 
     75    assign_const(schema_ns, 'Ns') 
    7676    dump_entry(@varname, var) 
    7777  end 
    …… 
    211211        dump_entry_item(var, :class), 
    212212        dump_entry_item(var, :soap_class), 
    213         dump_entry_item(var, :schema_ns, true), 
    214         dump_entry_item(var, :schema_name, true), 
    215         dump_entry_item(var, :schema_type, true), 
     213        dump_entry_item(var, :schema_name, :qname), 
     214        dump_entry_item(var, :schema_type, :qname), 
    216215        dump_entry_item(var, :schema_qualified), 
    217216        dump_entry_item(var, :schema_element), 
    …… 
    221220  end 
    222221 
    223   def dump_entry_item(var, key, as_string = false) 
     222  def dump_entry_item(var, key, dump_type = :none) 
    224223    if var.key?(key) 
    225       if as_string 
     224      case dump_type 
     225      when :none 
     226        ":#{key} => #{var[key]}" 
     227      when :string 
    226228        if @defined_const.key?(var[key]) 
    227229          ":#{key} => #{@defined_const[var[key]]}" 
    …… 
    229231          ":#{key} => #{ndq(var[key])}" 
    230232        end 
     233      when :qname 
     234        qname = var[key] 
     235        if @defined_const.key?(qname.namespace) 
     236          ns = @defined_const[qname.namespace] 
     237        else 
     238          ns = ndq(qname.namespace) 
     239        end 
     240        ":#{key} => XSD::QName.new(#{ns}, #{ndq(qname.name)})" 
    231241      else 
    232         ":#{key} => #{var[key]}" 
     242        raise "Unknown dump type: #{dump_type}" 
    233243      end 
    234     else 
    235       nil 
    236244    end 
    237245  end 
    …… 
    258266    var[:class] = create_class_name(qname, @modulepath) 
    259267    if as_element 
    260       var[:schema_type] = nil 
    261       var[:schema_ns] = as_element.namespace 
     268      var[:schema_name] = as_element 
     269      schema_ns = as_element.namespace 
    262270    elsif typedef.name.nil? 
    263       var[:schema_type] = nil 
    264       var[:schema_ns] = qname.namespace 
    265     else 
    266       var[:schema_type] = qname.name 
    267       var[:schema_ns] = qname.namespace 
    268     end 
    269     assign_const(var[:schema_ns], 'Ns') 
     271      var[:schema_name] = qname 
     272      schema_ns = qname.namespace 
     273    else 
     274      var[:schema_type] = qname 
     275      schema_ns = qname.namespace 
     276    end 
     277    assign_const(schema_ns, 'Ns') 
    270278    dump_entry(@varname, var) 
    271279  end 

  • trunk/test/wsdl/anonymous/expectedMappingRegistry.rb

    r1915 r1923  
    1111  EncodedRegistry.register( 
    1212    :class => WSDL::Anonymous::LoginResponse, 
    13     :schema_ns => NsLp, 
    14     :schema_type => "loginResponse", 
     13    :schema_type => XSD::QName.new(NsLp, "loginResponse"), 
    1514    :schema_element => [ 
    1615      ["loginResult", ["WSDL::Anonymous::LoginResponse::LoginResult", XSD::QName.new(nil, "loginResult")]] 
    …… 
    2019  EncodedRegistry.register( 
    2120    :class => WSDL::Anonymous::LoginResponse::LoginResult, 
    22     :schema_ns => nil, 
    23     :schema_name => "loginResult", 
     21    :schema_name => XSD::QName.new(nil, "loginResult"), 
    2422    :schema_element => [ 
    2523      ["sessionID", "SOAP::SOAPString"] 
    …… 
    2927  LiteralRegistry.register( 
    3028    :class => WSDL::Anonymous::LoginResponse, 
    31     :schema_ns => NsLp, 
    32     :schema_type => "loginResponse", 
     29    :schema_type => XSD::QName.new(NsLp, "loginResponse"), 
    3330    :schema_qualified => false, 
    3431    :schema_element => [ 
    …… 
    3936  LiteralRegistry.register( 
    4037    :class => WSDL::Anonymous::LoginResponse::LoginResult, 
    41     :schema_ns => nil, 
    42     :schema_name => "loginResult", 
     38    :schema_name => XSD::QName.new(nil, "loginResult"), 
    4339    :schema_qualified => false, 
    4440    :schema_element => [ 
    …… 
    4945  LiteralRegistry.register( 
    5046    :class => WSDL::Anonymous::Login, 
    51     :schema_ns => NsLp, 
    52     :schema_name => "login", 
     47    :schema_name => XSD::QName.new(NsLp, "login"), 
    5348    :schema_qualified => true, 
    5449    :schema_element => [ 
    …… 
    5954  LiteralRegistry.register( 
    6055    :class => WSDL::Anonymous::Login::LoginRequest, 
    61     :schema_ns => nil, 
    62     :schema_name => "loginRequest", 
     56    :schema_name => XSD::QName.new(nil, "loginRequest"), 
    6357    :schema_qualified => true, 
    6458    :schema_element => [ 
    …… 
    7165  LiteralRegistry.register( 
    7266    :class => WSDL::Anonymous::LoginResponse, 
    73     :schema_ns => NsLp, 
    74     :schema_name => "loginResponse", 
     67    :schema_name => XSD::QName.new(NsLp, "loginResponse"), 
    7568    :schema_qualified => true, 
    7669    :schema_element => [ 
    …… 
    8174  LiteralRegistry.register( 
    8275    :class => WSDL::Anonymous::LoginResponse::LoginResult, 
    83     :schema_ns => nil, 
    84     :schema_name => "loginResult", 
     76    :schema_name => XSD::QName.new(nil, "loginResult"), 
    8577    :schema_qualified => true, 
    8678    :schema_element => [ 

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

    r1915 r1923  
    1212  EncodedRegistry.register( 
    1313    :class => WSDL::Any::FooBar, 
    14     :schema_ns => NsEchoType, 
    15     :schema_type => "foo.bar", 
     14    :schema_type => XSD::QName.new(NsEchoType, "foo.bar"), 
    1615    :schema_element => [ 
    1716      ["before", ["SOAP::SOAPString", XSD::QName.new(nil, "before")]], 
    …… 
    2322  LiteralRegistry.register( 
    2423    :class => WSDL::Any::FooBar, 
    25     :schema_ns => NsEchoType, 
    26     :schema_type => "foo.bar", 
     24    :schema_type => XSD::QName.new(NsEchoType, "foo.bar"), 
    2725    :schema_qualified => false, 
    2826    :schema_element => [ 
    …… 
    3533  LiteralRegistry.register( 
    3634    :class => WSDL::Any::FooBar, 
    37     :schema_ns => NsEchoType, 
    38     :schema_name => "foo.bar", 
     35    :schema_name => XSD::QName.new(NsEchoType, "foo.bar"), 
    3936    :schema_qualified => true, 
    4037    :schema_element => [ 
    …… 
    4744  LiteralRegistry.register( 
    4845    :class => WSDL::Any::SetOutputAndCompleteRequest, 
    49     :schema_ns => NsEchoType, 
    50     :schema_name => "setOutputAndCompleteRequest", 
     46    :schema_name => XSD::QName.new(NsEchoType, "setOutputAndCompleteRequest"), 
    5147    :schema_qualified => true, 
    5248    :schema_element => [ 
    …… 
    5955  LiteralRegistry.register( 
    6056    :class => WSDL::Any::SetOutputAndCompleteRequest::C_Data, 
    61     :schema_ns => nil, 
    62     :schema_name => "data", 
     57    :schema_name => XSD::QName.new(nil, "data"), 
    6358    :schema_qualified => true, 
    6459    :schema_element => [ 

  • trunk/test/wsdl/group/expectedMappingRegistry.rb

    r1917 r1923  
    1212  EncodedRegistry.register( 
    1313    :class => WSDL::Group::Groupele_type, 
    14     :schema_ns => NsGrouptype, 
    15     :schema_type => "groupele_type", 
     14    :schema_type => XSD::QName.new(NsGrouptype, "groupele_type"), 
    1615    :schema_element => [ 
    1716      ["comment", "SOAP::SOAPString", [0, 1]], 
    …… 
    3130  LiteralRegistry.register( 
    3231    :class => WSDL::Group::Groupele_type, 
    33     :schema_ns => NsGrouptype, 
    34     :schema_type => "groupele_type", 
     32    :schema_type => XSD::QName.new(NsGrouptype, "groupele_type"), 
    3533    :schema_qualified => false, 
    3634    :schema_element => [ 
    …… 
    5149  LiteralRegistry.register( 
    5250    :class => WSDL::Group::Groupele_type, 
    53     :schema_ns => NsGrouptype, 
    54     :schema_name => "groupele", 
     51    :schema_name => XSD::QName.new(NsGrouptype, "groupele"), 
    5552    :schema_qualified => true, 
    5653    :schema_element => [ 

  • trunk/test/wsdl/simpletype/rpc/expectedMappingRegistry.rb

    r1896 r1923  
    99  EncodedRegistry.register( 
    1010    :class => Version_struct, 
    11     :schema_ns => NsSimpletypeRpcType, 
    12     :schema_type => "version_struct", 
     11    :schema_type => XSD::QName.new(NsSimpletypeRpcType, "version_struct"), 
    1312    :schema_element => [ 
    1413      ["version", ["Version", XSD::QName.new(nil, "version")]], 
    …… 
    1918  EncodedRegistry.register( 
    2019    :class => Version, 
    21     :schema_ns => NsSimpletypeRpcType, 
    22     :schema_type => "version" 
     20    :schema_type => XSD::QName.new(NsSimpletypeRpcType, "version") 
    2321  ) 
    2422 
    2523  EncodedRegistry.register( 
    2624    :class => StateType, 
    27     :schema_ns => NsSimpletypeRpcType, 
    28     :schema_type => "stateType" 
     25    :schema_type => XSD::QName.new(NsSimpletypeRpcType, "stateType") 
    2926  ) 
    3027 
    3128  EncodedRegistry.register( 
    3229    :class => ZipIntType, 
    33     :schema_ns => NsSimpletypeRpcType, 
    34     :schema_type => "zipIntType" 
     30    :schema_type => XSD::QName.new(NsSimpletypeRpcType, "zipIntType") 
    3531  ) 
    3632 
    3733  LiteralRegistry.register( 
    3834    :class => Version_struct, 
    39     :schema_ns => NsSimpletypeRpcType, 
    40     :schema_type => "version_struct", 
     35    :schema_type => XSD::QName.new(NsSimpletypeRpcType, "version_struct"), 
    4136    :schema_qualified => false, 
    4237    :schema_element => [ 
    …… 
    4843  LiteralRegistry.register( 
    4944    :class => Version, 
    50     :schema_ns => NsSimpletypeRpcType, 
    51     :schema_type => "version" 
     45    :schema_type => XSD::QName.new(NsSimpletypeRpcType, "version") 
    5246  ) 
    5347 
    5448  LiteralRegistry.register( 
    5549    :class => StateType, 
    56     :schema_ns => NsSimpletypeRpcType, 
    57     :schema_type => "stateType" 
     50    :schema_type => XSD::QName.new(NsSimpletypeRpcType, "stateType") 
    5851  ) 
    5952 
    6053  LiteralRegistry.register( 
    6154    :class => ZipIntType, 
    62     :schema_ns => NsSimpletypeRpcType, 
    63     :schema_type => "zipIntType" 
     55    :schema_type => XSD::QName.new(NsSimpletypeRpcType, "zipIntType") 
    6456  ) 
    6557end 

  • trunk/test/wsdl/soap/wsdl2ruby/expectedMappingRegistry.rb

    r1896 r1923  
    99  EncodedRegistry.register( 
    1010    :class => Version_struct, 
    11     :schema_ns => NsSimpletypeRpcType, 
    12     :schema_type => "version_struct", 
     11    :schema_type => XSD::QName.new(NsSimpletypeRpcType, "version_struct"), 
    1312    :schema_element => [ 
    1413      ["version", ["Version", XSD::QName.new(nil, "version")]], 
    …… 
    1918  EncodedRegistry.register( 
    2019    :class => Version, 
    21     :schema_ns => NsSimpletypeRpcType, 
    22     :schema_type => "version" 
     20    :schema_type => XSD::QName.new(NsSimpletypeRpcType, "version") 
    2321  ) 
    2422 
    2523  LiteralRegistry.register( 
    2624    :class => Version_struct, 
    27     :schema_ns => NsSimpletypeRpcType, 
    28     :schema_type => "version_struct", 
     25    :schema_type => XSD::QName.new(NsSimpletypeRpcType, "version_struct"), 
    2926    :schema_qualified => false, 
    3027    :schema_element => [ 
    …… 
    3633  LiteralRegistry.register( 
    3734    :class => Version, 
    38     :schema_ns => NsSimpletypeRpcType, 
    39     :schema_type => "version" 
     35    :schema_type => XSD::QName.new(NsSimpletypeRpcType, "version") 
    4036  ) 
    4137end 

  • trunk/test/xsd/xsd2ruby/expected_mysample_mapping_registry.rb

    r1896 r1923  
    1010  Registry.register( 
    1111    :class => XSD::XSD2Ruby::Question, 
    12     :schema_ns => NsMysample, 
    13     :schema_type => "question", 
     12    :schema_type => XSD::QName.new(NsMysample, "question"), 
    1413    :schema_qualified => false, 
    1514    :schema_element => [ 
    …… 
    2019  Registry.register( 
    2120    :class => XSD::XSD2Ruby::Section, 
    22     :schema_ns => NsMysample, 
    23     :schema_type => "section", 
     21    :schema_type => XSD::QName.new(NsMysample, "section"), 
    2422    :schema_qualified => false, 
    2523    :schema_element => [ 
    …… 
    3432  Registry.register( 
    3533    :class => XSD::XSD2Ruby::SectionArray, 
    36     :schema_ns => NsMysample, 
    37     :schema_type => "sectionArray", 
     34    :schema_type => XSD::QName.new(NsMysample, "sectionArray"), 
    3835    :schema_element => [ 
    3936      ["element", ["XSD::XSD2Ruby::Section[]", XSD::QName.new(nil, "element")], [1, nil]] 
    …… 
    4340  Registry.register( 
    4441    :class => XSD::XSD2Ruby::SectionElement, 
    45     :schema_ns => NsMysample, 
    46     :schema_name => "sectionElement", 
     42    :schema_name => XSD::QName.new(NsMysample, "sectionElement"), 
    4743    :schema_qualified => true, 
    4844    :schema_element => [