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

Changeset 1975

Show
Ignore:
Timestamp:
09/19/07 11:29:44 (10 months ago)
Author:
nahi
Message:
  • XML attribute must not be affected by default namespace. closes #430.
Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/lib/soap/encodingstyle/handler.rb

    r1936 r1975  
    9595  end 
    9696 
     97  def encode_attr_key(attrs, ns, qname) 
     98    if qname.namespace.nil? 
     99      qname.name 
     100    else 
     101      unless ns.assigned_as_tagged?(qname.namespace) 
     102        Generator.assign_ns!(attrs, ns, qname.namespace) 
     103      end 
     104      ns.name_attr(qname) 
     105    end 
     106  end 
     107 
    97108  def encode_qname(attrs, ns, qname) 
    98     unless qname.namespace.nil? 
     109    if qname.namespace.nil? 
     110      qname.name 
     111    else 
    99112      Generator.assign_ns(attrs, ns, qname.namespace) 
    100113      ns.name(qname) 
    101     else 
    102       qname.name 
    103114    end 
    104115  end 
  • trunk/lib/soap/encodingstyle/literalHandler.rb

    r1974 r1975  
    3232    data.extraattr.each do |key, value| 
    3333      next if !@generate_explicit_type and key == XSD::AttrTypeName 
    34       # ToDo: check generator.attributeformdefault here 
    3534      keytag = key 
    3635      if key.is_a?(XSD::QName) 
    37         keytag = encode_qname(attrs, ns, key) 
     36        keytag = encode_attr_key(attrs, ns, key) 
    3837      end 
    3938      if value.is_a?(XSD::QName) 
  • trunk/lib/soap/encodingstyle/soapHandler.rb

    r1970 r1975  
    302302      keytag = key 
    303303      if key.is_a?(XSD::QName) 
    304         keytag = encode_qname(attrs, ns, key) 
     304        keytag = encode_attr_key(attrs, ns, key) 
    305305      end 
    306306      if value.is_a?(XSD::QName) 
  • trunk/lib/soap/generator.rb

    r1974 r1975  
    4141    @generate_explicit_type = 
    4242      opt.key?(:generate_explicit_type) ? opt[:generate_explicit_type] : true 
    43     # ':elementformdefault' is for backward compatibility 
    4443    @use_default_namespace = opt[:use_default_namespace] 
    4544    @attributeformdefault = opt[:attributeformdefault] 
     
    5453    @buf = io || '' 
    5554    @indent = '' 
    56     @encode_char_regexp = 
    57       ENCODE_CHAR_REGEXP[XSD::Charset.encoding] ||= 
    58         Regexp.new("[#{EncodeMap.keys.join}]", nil, XSD::Charset.encoding) 
     55    @encode_char_regexp = get_encode_char_regexp() 
    5956 
    6057    prologue 
     
    213210  end 
    214211 
     212  def encode_string(str) 
     213    @buf << get_encoded(str) 
     214  end 
     215 
     216  def element_local?(element) 
     217    element.elename.namespace.nil? 
     218  end 
     219 
     220  def self.assign_ns(attrs, ns, namespace, tag = nil) 
     221    if namespace.nil? 
     222      raise FormatEncodeError.new("empty namespace") 
     223    end 
     224    override_default_ns = (tag == '' and namespace != ns.default_namespace) 
     225    if override_default_ns or !ns.assigned?(namespace) 
     226      assign_ns!(attrs, ns, namespace, tag) 
     227    end 
     228  end 
     229 
     230  def self.assign_ns!(attrs, ns, namespace, tag = nil) 
     231    tag = ns.assign(namespace, tag) 
     232    if tag == '' 
     233      attr = 'xmlns' 
     234    else 
     235      attr = "xmlns:#{tag}" 
     236    end 
     237    attrs[attr] = namespace 
     238  end 
     239 
     240private 
     241 
     242  def prologue 
     243  end 
     244 
     245  def epilogue 
     246  end 
     247 
    215248  ENCODE_CHAR_REGEXP = {} 
    216249 
     
    223256    "\r" => '&#xd;' 
    224257  } 
    225  
    226   def encode_string(str) 
    227     @buf << get_encoded(str) 
    228   end 
    229258 
    230259  def get_encoded(str) 
     
    243272  end 
    244273 
    245   def element_local?(element) 
    246     element.elename.namespace.nil? 
    247   end 
    248  
    249   def self.assign_ns(attrs, ns, namespace, tag = nil) 
    250     if namespace.nil? 
    251       raise FormatEncodeError.new("empty namespace") 
    252     end 
    253     override_default_ns = (tag == '' and namespace != ns.default_namespace) 
    254     if override_default_ns or !ns.assigned?(namespace) 
    255       tag = ns.assign(namespace, tag) 
    256       if tag == '' 
    257         attr = 'xmlns' 
    258       else 
    259         attr = "xmlns:#{tag}" 
    260       end 
    261       attrs[attr] = namespace 
    262     end 
    263   end 
    264  
    265 private 
    266  
    267   def prologue 
    268   end 
    269  
    270   def epilogue 
     274  def get_encode_char_regexp 
     275    ENCODE_CHAR_REGEXP[XSD::Charset.encoding] ||= 
     276      Regexp.new("[#{EncodeMap.keys.join}]", nil, XSD::Charset.encoding) 
    271277  end 
    272278 
  • trunk/lib/soap/rpc/proxy.rb

    r1974 r1975  
    132132      :default_encodingstyle => 
    133133        @default_encodingstyle || op_info.request_default_encodingstyle, 
    134       :use_default_namespace => @use_default_namespace, 
    135       :elementformdefault => op_info.elementformdefault, 
    136       :attributeformdefault => op_info.attributeformdefault 
     134      :use_default_namespace => 
     135        op_info.use_default_namespace || @use_default_namespace 
    137136    ) 
    138137    resopt = create_encoding_opt( 
    139138      :envelopenamespace => @options["soap.envelope.responsenamespace"], 
    140139      :default_encodingstyle => 
    141         @default_encodingstyle || op_info.response_default_encodingstyle, 
    142       :use_default_namespace => @use_default_namespace, 
    143       :elementformdefault => op_info.elementformdefault, 
    144       :attributeformdefault => op_info.attributeformdefault 
     140        @default_encodingstyle || op_info.response_default_encodingstyle 
    145141    ) 
    146142    env = route(req_header, req_body, reqopt, resopt) 
     
    355351    attr_reader :request_use 
    356352    attr_reader :response_use 
    357     attr_reader :elementformdefault 
    358     attr_reader :attributeformdefault 
     353    attr_reader :use_default_namespace 
    359354 
    360355    def initialize(soapaction, param_def, opt) 
     
    364359      @request_use = opt[:request_use] 
    365360      @response_use = opt[:response_use] 
    366       # set nil(unqualified) by default 
    367       @elementformdefault = opt[:elementformdefault] 
    368       @attributeformdefault = opt[:attributeformdefault] 
     361      @use_default_namespace = 
     362        opt[:use_default_namespace] || opt[:elementformdefault] 
     363      if opt.key?(:elementformdefault) 
     364        warn("option :elementformdefault is deprecated.  use :use_default_namespace instead") 
     365      end 
    369366      check_style(@request_style) 
    370367      check_style(@response_style) 
  • trunk/lib/soap/wsdlDriver.rb

    r1953 r1975  
    128128        :response_style => op_bind.soapoperation_style, 
    129129        :request_use => op_bind.soapbody_use_input, 
    130         :response_use => op_bind.soapbody_use_output, 
    131         :elementformdefault => false, 
    132         :attributeformdefault => false 
     130        :response_use => op_bind.soapbody_use_output 
    133131      } 
    134132      if op_bind.soapoperation_style == :rpc 
  • trunk/lib/xsd/ns.rb

    r1956 r1975  
    2525 
    2626    def initialize(known_tag) 
    27       @known_tag = known_tag 
     27      @known_tag = known_tag.dup 
    2828      @count = 0 
    2929    end 
     
    7777  end 
    7878 
     79  def assigned_as_tagged?(ns) 
     80    @ns2tag.key?(ns) 
     81  end 
     82 
    7983  def assigned_tag?(tag) 
    8084    @tag2ns.key?(tag) 
     
    8892  end 
    8993 
    90   def name(name) 
    91     if (name.namespace == @default_namespace) 
    92       name.name 
    93     elsif tag = @ns2tag[name.namespace] 
    94       "#{tag}:#{name.name}" 
     94  def name(qname) 
     95    if qname.namespace == @default_namespace 
     96      qname.name 
     97    elsif tag = @ns2tag[qname.namespace] 
     98      "#{tag}:#{qname.name}" 
    9599    else 
    96       raise FormatError.new("namespace: #{name.namespace} not defined yet") 
     100      raise FormatError.new("namespace: #{qname.namespace} not defined yet") 
     101    end 
     102  end 
     103 
     104  # no default namespace 
     105  def name_attr(qname) 
     106    if tag = @ns2tag[qname.namespace] 
     107      "#{tag}:#{qname.name}" 
     108    else 
     109      raise FormatError.new("namespace: #{qname.namespace} not defined yet") 
    97110    end 
    98111  end 
  • trunk/test/soap/test_custom_ns.rb

    r1973 r1975  
    3939__XML__ 
    4040 
     41  XML_WITH_DEFAULT_NS = <<__XML__.chomp 
     42<?xml version="1.0" encoding="utf-8" ?> 
     43<env:Envelope xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
     44    xmlns:env="http://schemas.xmlsoap.org/soap/envelope/" 
     45    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
     46  <env:Header> 
     47      <headeritem xmlns="my:foo">hi</headeritem> 
     48  </env:Header> 
     49  <env:Body> 
     50    <test xmlns:n1="my:bar" 
     51        xmlns:n2="my:foo" 
     52        n1:baz="qux" 
     53        n2:quxx="quxxx" 
     54        xmlns="my:foo">bi</test> 
     55  </env:Body> 
     56</env:Envelope> 
     57__XML__ 
     58 
    4159  def test_custom_ns 
    4260    # create test env 
     
    6583    assert_equal(CUSTOM_NS_XML, result) 
    6684  end 
     85 
     86  def test_default_namespace 
     87    # create test env 
     88    header = SOAP::SOAPHeader.new() 
     89    hi = SOAP::SOAPElement.new(XSD::QName.new("my:foo", "headeritem"), 'hi') 
     90    header.add("test", hi) 
     91    body = SOAP::SOAPBody.new() 
     92    bi = SOAP::SOAPElement.new(XSD::QName.new("my:foo", "bodyitem"), 'bi') 
     93    bi.extraattr[XSD::QName.new('my:bar', 'baz')] = 'qux' 
     94    bi.extraattr[XSD::QName.new('my:foo', 'quxx')] = 'quxxx' 
     95    body.add("test", bi) 
     96    env = SOAP::SOAPEnvelope.new(header, body) 
     97    # normal 
     98    opt = {:use_default_namespace => true} 
     99    result = SOAP::Processor.marshal(env, opt) 
     100    assert_equal(XML_WITH_DEFAULT_NS, result) 
     101  end 
    67102end 
    68103