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

Changeset 2000

Show
Ignore:
Timestamp:
10/09/07 23:16:36 (1 year ago)
Author:
nahi
Message:
  • removed backward compatibility definitions for soap4r-1.4.X. closes #445.
    • removed SOAPlet#{app_scope_router,add_servant} -> use methods in HTTPServer instead.
    • removed SOAP::WSDLDriver#generateEncodeType -> use SOAP::WSDLDriver#generate_explicit_type
    • removed SOAP::SOAPGenerator -> use SOAP::Generator instead.
    • removed compatibility method definitions for ruby-1.6.X.
  • rpc/encoded service + detail element without xsi:type attribute caused NameError? since 1.5.6. (#435)
  • extract attr_proxy definition. added soap/attrproxy.rb and wsdl/xmlSchema/ref.rb.
Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/lib/soap/generator.rb

    r1975 r2000  
    299299end 
    300300 
    301 SOAPGenerator = Generator       # for backward compatibility 
    302  
    303301 
    304302end 

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

    r1998 r2000  
    403403  end 
    404404 
    405   if RUBY_VERSION >= '1.8.0' 
    406     def addextend2obj(obj, attr) 
    407       return unless attr 
    408       attr.split(/ /).reverse_each do |mstr| 
    409         obj.extend(Mapping.module_from_name(mstr)) 
    410       end 
    411     end 
    412   else 
    413     # (class < false; self; end).ancestors includes "TrueClass" under 1.6... 
    414     def addextend2obj(obj, attr) 
    415       return unless attr 
    416       attr.split(/ /).reverse_each do |mstr| 
    417         m = Mapping.module_from_name(mstr) 
    418         obj.extend(m) 
    419       end 
     405  def addextend2obj(obj, attr) 
     406    return unless attr 
     407    attr.split(/ /).reverse_each do |mstr| 
     408      obj.extend(Mapping.module_from_name(mstr)) 
    420409    end 
    421410  end 

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

    r1982 r2000  
    9292  def self.fault2exception(fault, registry = nil) 
    9393    registry ||= Mapping::DefaultRegistry 
    94     detail = if fault.detail 
    95         soap2obj(fault.detail, registry) || "" 
    96       else 
    97         "" 
    98       end 
     94    detail = "" 
     95    if fault.detail 
     96      begin 
     97        fault.detail.type ||= XSD::QName::EMPTY 
     98        detail = soap2obj(fault.detail, registry) || "" 
     99      rescue MappingError 
     100        detail = fault.detail 
     101      end 
     102    end 
    99103    if detail.is_a?(Mapping::SOAPException) 
    100104      begin 
    …… 
    151155  end 
    152156 
    153   if Object.respond_to?(:allocate) 
    154     # ruby/1.7 or later. 
    155     def self.create_empty_object(klass) 
    156       klass.allocate 
    157     end 
    158   else 
    159     MARSHAL_TAG = { 
    160       String => ['"', 1], 
    161       Regexp => ['/', 2], 
    162       Array => ['[', 1], 
    163       Hash => ['{', 1] 
    164     } 
    165     def self.create_empty_object(klass) 
    166       if klass <= Struct 
    167         name = klass.name 
    168         return ::Marshal.load(sprintf("\004\006S:%c%s\000", name.length + 5, name)) 
    169       end 
    170       if MARSHAL_TAG.has_key?(klass) 
    171         tag, terminate = MARSHAL_TAG[klass] 
    172         return ::Marshal.load(sprintf("\004\006%s%s", tag, "\000" * terminate)) 
    173       end 
    174       MARSHAL_TAG.each do |k, v| 
    175         if klass < k 
    176           name = klass.name 
    177           tag, terminate = v 
    178           return ::Marshal.load(sprintf("\004\006C:%c%s%s%s", name.length + 5, name, tag, "\000" * terminate)) 
    179         end 
    180       end 
    181       name = klass.name 
    182       ::Marshal.load(sprintf("\004\006o:%c%s\000", name.length + 5, name)) 
    183     end 
     157  def self.create_empty_object(klass) 
     158    klass.allocate 
    184159  end 
    185160 
    …… 
    470445    is_anonymous = definition[:is_anonymous] 
    471446    schema_basetype = definition[:schema_basetype] 
    472     # wrap if needed for backward compatibility 
    473     if schema_ns 
    474       schema_name = Mapping.to_qname(schema_name, schema_ns) if schema_name 
    475       schema_type = Mapping.to_qname(schema_type, schema_ns) if schema_type 
    476       # no need for schema_basetype bacause it's introduced later 
    477     end 
    478447    schema_qualified = definition[:schema_qualified] 
    479448    schema_element = definition[:schema_element] 
    …… 
    498467  end 
    499468 
    500   # for backward compatibility 
    501469  # returns SchemaComplexTypeDefinition 
    502470  def self.parse_schema_definition(schema_element, default_ns) 
    …… 
    527495        minoccurs, maxoccurs = occurrence 
    528496      else 
    529         # for backward compatibility 
    530497        minoccurs, maxoccurs = 1, 1 
    531498      end 

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

    r1873 r2000  
    125125      end 
    126126      param.add('source', SOAPBase64.new(obj.source)) 
    127       if obj.respond_to?('options') 
    128         # Regexp#options is from Ruby/1.7 
    129         options = obj.options 
    130       else 
    131         options = 0 
    132         obj.inspect.sub(/^.*\//, '').each_byte do |c| 
    133           options += case c 
    134             when ?i 
    135               1 
    136             when ?x 
    137               2 
    138             when ?m 
    139               4 
    140             when ?n 
    141               16 
    142             when ?e 
    143               32 
    144             when ?s 
    145               48 
    146             when ?u 
    147               64 
    148             end 
    149         end 
    150       end 
     127      options = obj.options 
    151128      param.add('options', SOAPInt.new(options)) 
    152129      addiv2soapattr(param, obj, map) 
    …… 
    217194      end 
    218195    when ::IO, ::Binding, ::Continuation, ::Data, ::Dir, ::File::Stat, 
    219         ::MatchData, Method, ::Proc, ::Thread, ::ThreadGroup 
    220         # from 1.8: Process::Status, UnboundMethod 
     196        ::MatchData, Method, ::Proc, ::Process::Status, ::Thread, 
     197        ::ThreadGroup, ::UnboundMethod 
    221198      return nil 
    222199    when ::SOAP::Mapping::Object 
    …… 
    267244    end 
    268245    singleton_class = class << obj; self; end 
    269     if !singleton_methods_true(obj).empty? or 
     246    if !obj.singleton_methods(true).empty? or 
    270247        !singleton_class.instance_variables.empty? 
    271248      raise TypeError.new("singleton can't be dumped #{obj}") 
    …… 
    281258    setiv2soap(param, obj, map) 
    282259    param 
    283   end 
    284  
    285   if RUBY_VERSION >= '1.8.0' 
    286     def singleton_methods_true(obj) 
    287       obj.singleton_methods(true) 
    288     end 
    289   else 
    290     def singleton_methods_true(obj) 
    291       obj.singleton_methods 
    292     end 
    293260  end 
    294261 

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

    r1974 r2000  
    88 
    99require 'soap/soap' 
     10require 'soap/attrproxy' 
    1011require 'soap/mapping' 
    1112require 'soap/rpc/rpc' 
    …… 
    2223 
    2324class Driver 
    24   class << self 
    25     if RUBY_VERSION >= "1.7.0" 
    26       def __attr_proxy(symbol, assignable = false) 
    27         name = symbol.to_s 
    28         define_method(name) { 
    29           @proxy.__send__(name) 
    30         } 
    31         if assignable 
    32           aname = name + '=' 
    33           define_method(aname) { |rhs| 
    34             @proxy.__send__(aname, rhs) 
    35           } 
    36         end 
    37       end 
    38     else 
    39       def __attr_proxy(symbol, assignable = false) 
    40         name = symbol.to_s 
    41         module_eval <<-EOS 
    42           def #{name} 
    43             @proxy.#{name} 
    44           end 
    45         EOS 
    46         if assignable 
    47           module_eval <<-EOS 
    48             def #{name}=(value) 
    49               @proxy.#{name} = value 
    50             end 
    51           EOS 
    52         end 
    53       end 
    54     end 
    55   end 
    56  
    57   __attr_proxy :endpoint_url, true 
    58   __attr_proxy :mapping_registry, true 
    59   __attr_proxy :literal_mapping_registry, true 
    60   __attr_proxy :allow_unqualified_element, true 
    61   __attr_proxy :default_encodingstyle, true 
    62   __attr_proxy :generate_explicit_type, true 
    63   __attr_proxy :use_default_namespace, true 
    64   __attr_proxy :return_response_as_xml, true 
    65   __attr_proxy :headerhandler 
    66   __attr_proxy :filterchain 
    67   __attr_proxy :streamhandler 
    68   __attr_proxy :test_loopback_response 
    69   __attr_proxy :reset_stream 
     25  include AttrProxy 
     26 
     27  attr_proxy :endpoint_url, true 
     28  attr_proxy :mapping_registry, true 
     29  attr_proxy :literal_mapping_registry, true 
     30  attr_proxy :allow_unqualified_element, true 
     31  attr_proxy :default_encodingstyle, true 
     32  attr_proxy :generate_explicit_type, true 
     33  attr_proxy :use_default_namespace, true 
     34  attr_proxy :return_response_as_xml, true 
     35  attr_proxy :headerhandler 
     36  attr_proxy :filterchain 
     37  attr_proxy :streamhandler 
     38  attr_proxy :test_loopback_response 
     39  attr_proxy :reset_stream 
    7040 
    7141  attr_reader :proxy 
    …… 
    183153 
    184154private 
     155 
     156  def attrproxy 
     157    @proxy 
     158  end 
    185159 
    186160  def set_wiredump_file_base(name) 

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

    r1974 r2000  
    88 
    99require 'logger' 
     10require 'soap/attrproxy' 
    1011require 'soap/rpc/soaplet' 
    1112require 'soap/streamHandler' 
    …… 
    1819 
    1920class HTTPServer < Logger::Application 
     21  include AttrProxy 
     22 
    2023  attr_reader :server 
    2124  attr_accessor :default_namespace 
    2225 
    23   class << self 
    24     if RUBY_VERSION >= "1.7.0" 
    25       def __attr_proxy(symbol, assignable = false) 
    26         name = symbol.to_s 
    27         define_method(name) { 
    28           @router.__send__(name) 
    29         } 
    30         if assignable 
    31           aname = name + '=' 
    32           define_method(aname) { |rhs| 
    33             @router.__send__(aname, rhs) 
    34           } 
    35         end 
    36       end 
    37     else 
    38       def __attr_proxy(symbol, assignable = false) 
    39         name = symbol.to_s 
    40         module_eval <<-EOS 
    41           def #{name} 
    42             @router.#{name} 
    43           end 
    44         EOS 
    45         if assignable 
    46           module_eval <<-EOS 
    47             def #{name}=(value) 
    48               @router.#{name} = value 
    49             end 
    50           EOS 
    51         end 
    52       end 
    53     end 
    54   end 
    55  
    56   __attr_proxy :mapping_registry, true 
    57   __attr_proxy :literal_mapping_registry, true 
    58   __attr_proxy :generate_explicit_type, true 
    59   __attr_proxy :use_default_namespace, true 
     26  attr_proxy :mapping_registry, true 
     27  attr_proxy :literal_mapping_registry, true 
     28  attr_proxy :generate_explicit_type, true 
     29  attr_proxy :use_default_namespace, true 
    6030 
    6131  def initialize(config) 
    …… 
    7545      @server.mount('/wsdl', WEBrick::HTTPServlet::FileHandler, wsdldir) 
    7646    end 
    77     # for backward compatibility 
    7847    @server.mount('/', @soaplet) 
    7948  end 
    …… 
    160129private 
    161130 
     131  def attrproxy 
     132    @router 
     133  end 
     134 
    162135  def run 
    163136    @server.start 

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

    r1983 r2000  
    177177      conn_data.send_contenttype = mime.headers['content-type'].str 
    178178    end 
    179     conn_data = @streamhandler.send(@endpoint_url, conn_data, 
    180       reqopt[:soapaction]) 
     179    conn_data.soapaction = reqopt[:soapaction] 
     180    conn_data = @streamhandler.send(@endpoint_url, conn_data) 
    181181    if conn_data.receive_string.empty? 
    182182      return nil 

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

    r1829 r2000  
    4949    @authenticator = nil 
    5050    @config = {} 
    51   end 
    52  
    53   # for backward compatibility 
    54   def app_scope_router 
    55     @router 
    56   end 
    57  
    58   # for backward compatibility 
    59   def add_servant(obj, namespace) 
    60     @router.add_rpc_servant(obj, namespace) 
    6151  end 
    6252 

  • trunk/lib/soap/streamHandler.rb

    r1885 r2000  
    168168  end 
    169169 
    170   def send(url, conn_data, soapaction = nil, charset = @charset) 
    171     conn_data.soapaction ||= soapaction # for backward conpatibility 
     170  def send(url, conn_data, charset = @charset) 
    172171    conn_data = send_post(url, conn_data, charset) 
    173172    @client.save_cookie_store if @cookie_store 

  • trunk/lib/soap/wsdlDriver.rb

    r1975 r2000  
    1111require 'xsd/qname' 
    1212require 'xsd/codegen/gensupport' 
     13require 'soap/attrproxy' 
    1314require 'soap/mapping/wsdlencodedregistry' 
    1415require 'soap/mapping/wsdlliteralregistry' 
    …… 
    5556    WSDLDriver.new(@wsdl, port, nil) 
    5657  end 
    57  
    58   # Backward compatibility. 
    59   alias createDriver create_driver 
    6058 
    6159  def dump_method_signatures(servicename = nil, portname = nil) 
    …… 
    181179 
    182180class WSDLDriver 
    183   class << self 
    184     if RUBY_VERSION >= "1.7.0" 
    185       def __attr_proxy(symbol, assignable = false) 
    186         name = symbol.to_s 
    187         define_method(name) { 
    188           @servant.__send__(name) 
    189         } 
    190         if assignable 
    191           aname = name + '=' 
    192           define_method(aname) { |rhs| 
    193             @servant.__send__(aname, rhs) 
    194           } 
    195         end 
    196       end 
    197     else 
    198       def __attr_proxy(symbol, assignable = false) 
    199         name = symbol.to_s 
    200         module_eval <<-EOS 
    201           def #{name} 
    202             @servant.#{name} 
    203           end 
    204         EOS 
    205         if assignable 
    206           module_eval <<-EOS 
    207             def #{name}=(value) 
    208               @servant.#{name} = value 
    209             end 
    210           EOS 
    211         end 
    212       end 
    213     end 
    214   end 
    215  
    216   __attr_proxy :options 
    217   __attr_proxy :headerhandler 
    218   __attr_proxy :streamhandler 
    219   __attr_proxy :test_loopback_response 
    220   __attr_proxy :endpoint_url, true 
    221   __attr_proxy :mapping_registry, true          # for RPC unmarshal 
    222   __attr_proxy :wsdl_mapping_registry, true     # for RPC marshal 
    223   __attr_proxy :default_encodingstyle, true 
    224   __attr_proxy :generate_explicit_type, true 
    225   __attr_proxy :allow_unqualified_element, true 
     181  include AttrProxy 
     182 
     183  attr_proxy :options 
     184  attr_proxy :headerhandler 
     185  attr_proxy :streamhandler 
     186  attr_proxy :test_loopback_response 
     187  attr_proxy :endpoint_url, true 
     188  attr_proxy :mapping_registry, true            # for RPC unmarshal 
     189  attr_proxy :wsdl_mapping_registry, true       # for RPC marshal 
     190  attr_proxy :default_encodingstyle, true 
     191  attr_proxy :generate_explicit_type, true 
     192  attr_proxy :allow_unqualified_element, true 
    226193 
    227194  def httpproxy 
    …… 
    269236  end 
    270237 
    271   # Backward compatibility. 
    272   alias generateEncodeType= generate_explicit_type= 
     238private 
     239 
     240  def attrproxy 
     241    @servant 
     242  end 
    273243 
    274244  class Servant__ 

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

    r1824 r2000  
    88 
    99require 'wsdl/info' 
     10require 'wsdl/xmlSchema/ref' 
    1011 
    1112 
    …… 
    1516 
    1617class Attribute < Info 
    17   class << self 
    18     if RUBY_VERSION > "1.7.0" 
    19       def attr_reader_ref(symbol) 
    20         name = symbol.to_s 
    21         define_method(name) { 
    22           instance_variable_get("@#{name}") || 
    23             (refelement ? refelement.__send__(name) : nil) 
    24         } 
    25       end 
    26     else 
    27       def attr_reader_ref(symbol) 
    28         name = symbol.to_s 
    29         module_eval <<-EOS 
    30           def #{name} 
    31             @#{name} || (refelement ? refelement.#{name} : nil) 
    32           end 
    33         EOS 
    34       end 
    35     end 
    36   end 
     18  include Ref 
    3719 
    3820  attr_writer :use 
    …… 
    5234  attr_reader_ref :fixed 
    5335 
    54   attr_accessor :ref 
    5536  attr_accessor :arytype 
    5637 
    …… 
    6748    @refelement = nil 
    6849    @arytype = nil 
    69   end 
    70  
    71   def refelement 
    72     @refelement ||= root.collect_attributes[@ref] 
    7350  end 
    7451 
    …… 
    11794    parent.is_a?(Schema) 
    11895  end 
     96 
     97  def refelement 
     98    @refelement ||= root.collect_attributes[@ref] 
     99  end 
    119100end 
    120101 

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

    r1917 r2000  
    88 
    99require 'wsdl/info' 
     10require 'wsdl/xmlSchema/ref' 
    1011 
    1112 
    …… 
    1516 
    1617class AttributeGroup < Info 
    17   class << self 
    18     if RUBY_VERSION > "1.7.0" 
    19       def attr_reader_ref(symbol) 
    20         name = symbol.to_s 
    21         define_method(name) { 
    22           instance_variable_get("@#{name}") || 
    23             (refelement ? refelement.__send__(name) : nil) 
    24         } 
    25       end 
    26     else 
    27       def attr_reader_ref(symbol) 
    28         name = symbol.to_s 
    29         module_eval <<-EOS 
    30           def #{name} 
    31             @#{name} || (refelement ? refelement.#{name} : nil) 
    32           end 
    33         EOS 
    34       end 
    35     end 
    36   end 
     18  include Ref 
    3719 
    3820  attr_writer :name     # required 
    …… 
    4224  attr_reader_ref :attributes 
    4325 
    44   attr_accessor :ref 
    45  
    4626  def initialize 
    4727    super 
    …… 
    5030    @ref = nil 
    5131    @refelement = nil 
    52   end 
    53  
    54   def refelement 
    55     @refelement ||= root.collect_attributegroups[@ref] 
    5632  end 
    5733 
    …… 
    8056    end 
    8157  end 
     58 
     59private 
     60 
     61  def refelement 
     62    @refelement ||= root.collect_attributegroups[@ref] 
     63  end 
    8264end 
    8365 

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

    r1906 r2000  
    88 
    99require 'wsdl/info' 
     10require 'wsdl/xmlSchema/ref' 
    1011 
    1112 
    …… 
    1516 
    1617class Element < Info 
    17   class << self 
    18     if RUBY_VERSION > "1.7.0" 
    19       def attr_reader_ref(symbol) 
    20         name = symbol.to_s 
    21         define_method(name) { 
    22           instance_variable_get("@#{name}") || 
    23             (refelement ? refelement.__send__(name) : nil) 
    24         } 
    25       end 
    26     else 
    27       def attr_reader_ref(symbol) 
    28         name = symbol.to_s 
    29         module_eval <<-EOS 
    30           def #{name} 
    31             @#{name} || (refelement ? refelement.#{name} : nil) 
    32           end 
    33         EOS 
    34       end 
    35     end 
    36   end 
     18  include Ref 
    3719 
    3820  attr_writer :name     # required 
    …… 
    5638  attr_reader_ref :abstract 
    5739 
    58   attr_accessor :ref 
    59  
    6040  def initialize(name = nil, type = nil) 
    6141    super() 
    …… 
    7656  def empty? 
    7757    !(local_simpletype || local_complextype || constraint || type) 
    78   end 
    79  
    80   def refelement 
    81     @refelement ||= (@ref ? root.collect_elements[@ref] : nil) 
    8258  end 
    8359 
    …… 
    167143    parent.is_a?(Schema) 
    168144  end 
     145 
     146  def refelement 
     147    @refelement ||= (@ref ? root.collect_elements[@ref] : nil) 
     148  end 
    169149end 
    170150 

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

    r1917 r2000  
    88 
    99require 'wsdl/info' 
     10require 'wsdl/xmlSchema/ref' 
    1011 
    1112 
    …… 
    1516 
    1617class Group < Info 
    17   class << self 
    18     if RUBY_VERSION > "1.7.0" 
    19       def attr_reader_ref(symbol) 
    20         name = symbol.to_s 
    21         define_method(name) { 
    22           instance_variable_get("@#{name}") || 
    23             (refelement ? refelement.__send__(name) : nil) 
    24         } 
    25       end 
    26     else 
    27       def attr_reader_ref(symbol) 
    28         name = symbol.to_s 
    29         module_eval <<-EOS 
    30           def #{name} 
    31             @#{name} || (refelement ? refelement.#{name} : nil) 
    32           end 
    33         EOS 
    34       end 
    35     end 
    36   end 
     18  include Ref 
    3719 
    3820  attr_writer :name     # required 
    …… 
    4426  attr_reader_ref :content 
    4527 
    46   attr_accessor :ref 
    47  
    4828  def initialize(name = nil) 
    4929    super() 
    …… 
    5434    @ref = nil 
    5535    @refelement = nil 
    56   end 
    57  
    58   def refelement 
    59     @refelement ||= (@ref ? root.collect_modelgroups[@ref] : nil) 
    6036  end 
    6137 
    …… 
    11288    end 
    11389  end 
     90 
     91private 
     92 
     93  def refelement 
     94    @refelement ||= (@ref ? root.collect_modelgroups[@ref] : nil) 
     95  end 
    11496end 
    11597