wasabi 3.1.0 → 3.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ad4024db6f2cc825dec1eb8223812bd8da45c884
+  data.tar.gz: af57d52095cb5daf9b530f9974b65b9d747cda11
+SHA512:
+  metadata.gz: b61533673c5f483625c6bd884236c7592a03cfa0c6c8f5a47b18600cbc2e903ff5f83864fd85d53a42c3430de7f5a53907222c2bf0b19fc53338eb47fe625be6
+  data.tar.gz: 59212805b9b770b20a37e175e950f9df1a4ff973ce52d0ca4b8b88f41b94678025684591480251900a930d4236ade904120a4eb14cbf5965e1d1cd9376f1db16

data/CHANGELOG.md

@@ -1,3 +1,20 @@
+## 3.2.0 (2013-07-26)
+
+* Feature: [#20](https://github.com/savonrb/wasabi/issues/20) Limited support for listing an
+  operation's parameters. Please note that if your WSDL defines imports, this method might
+  not return all types.
+
+* Improvement: [#7](https://github.com/savonrb/wasabi/issues/7) Major speed improvements.
+
+* Improvement: [#16](https://github.com/savonrb/wasabi/issues/16) Various improvements regarding
+  element order and type information.
+
+* Fix: [#25](https://github.com/savonrb/wasabi/issues/25) Fixes a problem where Wasabi escaped
+  an already escaped endpoint URL.
+
+* Fix: [#15](https://github.com/savonrb/wasabi/issues/15) Fixes a bug where the operation tag
+  name was not correctly extracted from the WSDL document.
+
 ## 3.1.0 (2013-04-21)
 
 * Feature: [#22](https://github.com/savonrb/wasabi/issues/22) added `Wasabi::Document#service_name`
@@ -15,22 +32,22 @@
 
 ## 2.5.1 (2012-08-22)
 
-* Fix: [#14](https://github.com/rubiii/wasabi/issues/14) fixes an issue where
+* Fix: [#14](https://github.com/savonrb/wasabi/issues/14) fixes an issue where
   finding the correct SOAP input tag and namespace identifier fails when portTypes
   are imported, since imports are currently not supported.
 
-  The bug was introduced in v2.2.0 by [583cf6](https://github.com/rubiii/wasabi/commit/583cf658f1953411a7a7a4c22923fa0a046c8d6d)
+  The bug was introduced in v2.2.0 by [583cf6](https://github.com/savonrb/wasabi/commit/583cf658f1953411a7a7a4c22923fa0a046c8d6d)
 
 * Refactoring: Removed `Object#blank?` core extension.
 
 ## 2.5.0 (2012-06-28)
 
-* Fix: [#10](https://github.com/rubiii/wasabi/issues/10) fixes an issue where
+* Fix: [#10](https://github.com/savonrb/wasabi/issues/10) fixes an issue where
   Wasabi used the wrong operation name.
 
 ## 2.4.1 (2012-06-18)
 
-* Fix: [rubiii/savon#296](https://github.com/rubiii/savon/issues/296) fixes an issue where
+* Fix: [savonrb/savon#296](https://github.com/savonrb/savon/issues/296) fixes an issue where
   the WSDL message element doesn't have part element.
 
 ## 2.4.0 (2012-06-08)
@@ -41,25 +58,25 @@
 
 ## 2.3.0 (2012-06-07)
 
-* Improvement: [#3](https://github.com/rubiii/wasabi/pull/3) adds object inheritance.
+* Improvement: [#3](https://github.com/savonrb/wasabi/pull/3) adds object inheritance.
 
 ## 2.2.0 (2012-06-06)
 
-* Improvement: [#5](https://github.com/rubiii/wasabi/pull/5) - Get input from message
-  element or portType input. See [rubiii/savon#277](https://github.com/rubiii/savon/pull/277)
+* Improvement: [#5](https://github.com/savonrb/wasabi/pull/5) - Get input from message
+  element or portType input. See [savonrb/savon#277](https://github.com/savonrb/savon/pull/277)
   to get the full picture on how this all works together, and enables you to pass a single
   symbol into the `Savon::Client#request` method and get automatic namespace mapping, as well
   as the proper operation name -> input message mapping.
 
 ## 2.1.1 (2012-05-18)
 
-* Fix: [issue 7](https://github.com/rubiii/wasabi/issues/7) - Performance regression.
+* Fix: [issue 7](https://github.com/savonrb/wasabi/issues/7) - Performance regression.
 
 ## 2.1.0 (2012-02-17)
 
 * Improvement: The value of elementFormDefault can now be manually specified/overwritten.
 
-* Improvement: [issue 2](https://github.com/rubiii/wasabi/issues/2) - Allow symbolic endpoints
+* Improvement: [issue 2](https://github.com/savonrb/wasabi/issues/2) - Allow symbolic endpoints
   like "http://server:port".
 
 ## 2.0.0 (2011-07-07)

data/Gemfile

@@ -1,2 +1,6 @@
-source "http://rubygems.org"
+source 'https://rubygems.org'
 gemspec
+
+gem 'simplecov',       :require => false
+gem 'method_profiler', :require => false
+gem 'coveralls',       :require => false

data/README.md

@@ -1,11 +1,14 @@
-Wasabi [![Build Status](https://secure.travis-ci.org/rubiii/wasabi.png)](http://travis-ci.org/rubiii/wasabi)
-=====
+# Wasabi
 
 A simple WSDL parser.
 
+[![Build Status](https://secure.travis-ci.org/savonrb/wasabi.png)](http://travis-ci.org/savonrb/wasabi)
+[![Gem Version](https://badge.fury.io/rb/wasabi.png)](http://badge.fury.io/rb/wasabi)
+[![Code Climate](https://codeclimate.com/github/savonrb/wasabi.png)](https://codeclimate.com/github/savonrb/wasabi)
+[![Coverage Status](https://coveralls.io/repos/savonrb/wasabi/badge.png?branch=master)](https://coveralls.io/r/savonrb/wasabi)
 
-Installation
-------------
+
+## Installation
 
 Wasabi is available through [Rubygems](http://rubygems.org/gems/wasabi) and can be installed via:
 
@@ -14,8 +17,7 @@ $ gem install wasabi
 ```
 
 
-Getting started
----------------
+## Getting started
 
 ``` ruby
 document = Wasabi.document File.read("some.wsdl")

data/Rakefile

@@ -3,7 +3,5 @@ require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new
 
-task :release
-
 task :default => :spec
 task :test => :spec

data/lib/wasabi/document.rb

@@ -83,13 +83,29 @@ module Wasabi
 
     attr_writer :service_name
 
+    # Returns a list of parameter names for a given +key+
+    def soap_action_parameters(key)
+      params = operation_input_parameters(key)
+      params.keys if params
+    end
+
+    # Returns a list of input parameters for a given +key+.
+    def operation_input_parameters(key)
+      parser.operations[key][:parameters] if operations[key]
+    end
+
     def type_namespaces
       @type_namespaces ||= begin
         namespaces = []
+
         parser.types.each do |type, info|
           namespaces << [[type], info[:namespace]]
-          (info.keys - [:namespace]).each { |field| namespaces << [[type, field], info[:namespace]] }
+
+          element_keys(info).each do |field|
+            namespaces << [[type, field], info[:namespace]]
+          end
         end if document
+
         namespaces
       end
     end
@@ -97,13 +113,16 @@ module Wasabi
     def type_definitions
       @type_definitions ||= begin
         result = []
+
         parser.types.each do |type, info|
-          (info.keys - [:namespace]).each do |field|
+          element_keys(info).each do |field|
             field_type = info[field][:type]
             tag, namespace = field_type.split(":").reverse
+
             result << [[type, field], tag] if user_defined(namespace)
           end
         end if document
+
         result
       end
     end
@@ -140,5 +159,8 @@ module Wasabi
       parser
     end
 
+    def element_keys(info)
+      info.keys - [:namespace, :order!, :base_type]
+    end
   end
 end

data/lib/wasabi/parser.rb

@@ -1,5 +1,4 @@
 require "uri"
-require "wasabi/xpath_helper"
 require "wasabi/core_ext/string"
 
 module Wasabi
@@ -8,7 +7,11 @@ module Wasabi
   #
   # Parses WSDL documents and remembers their important parts.
   class Parser
-    include XPathHelper
+
+    XSD      = "http://www.w3.org/2001/XMLSchema"
+    WSDL     = "http://schemas.xmlsoap.org/wsdl/"
+    SOAP_1_1 = "http://schemas.xmlsoap.org/wsdl/soap/"
+    SOAP_1_2 = "http://schemas.xmlsoap.org/wsdl/soap12/"
 
     def initialize(document)
       self.document = document
@@ -51,16 +54,20 @@ module Wasabi
       parse_namespaces
       parse_endpoint
       parse_service_name
+      parse_messages
+      parse_port_types
+      parse_port_type_operations
       parse_operations
+      parse_operations_parameters
       parse_types
       parse_deferred_types
     end
 
     def parse_namespaces
-      element_form_default = at_xpath("wsdl:definitions/wsdl:types/xs:schema/@elementFormDefault")
+      element_form_default = schemas.first && schemas.first['elementFormDefault']
       @element_form_default = element_form_default.to_s.to_sym if element_form_default
 
-      namespace = at_xpath("wsdl:definitions/@targetNamespace")
+      namespace = document.root['targetNamespace']
       @namespace = namespace.to_s if namespace
 
       @namespaces = @document.namespaces.inject({}) do |memo, (key, value)|
@@ -70,38 +77,80 @@ module Wasabi
     end
 
     def parse_endpoint
-      endpoint = at_xpath("wsdl:definitions/wsdl:service//soap11:address/@location")
-      endpoint ||= at_xpath("wsdl:definitions/wsdl:service//soap12:address/@location")
-
-      begin
-        @endpoint = URI(URI.escape(endpoint.to_s)) if endpoint
-      rescue URI::InvalidURIError
-        @endpoint = nil
+      if service_node = service
+        endpoint = service_node.at_xpath(".//soap11:address/@location", 'soap11' => SOAP_1_1)
+        endpoint ||= service_node.at_xpath(service_node, ".//soap12:address/@location", 'soap12' => SOAP_1_2)
       end
+
+      @endpoint = parse_url(endpoint) if endpoint
+    end
+
+    def parse_url(url)
+      unescaped_url = URI.unescape(url.to_s)
+      escaped_url   = URI.escape(unescaped_url)
+      URI.parse(escaped_url)
+    rescue URI::InvalidURIError
     end
 
     def parse_service_name
-      service_name = at_xpath("wsdl:definitions/@name")
+      service_name = document.root['name']
       @service_name = service_name.to_s if service_name
     end
 
+    def parse_messages
+      messages = document.root.element_children.select { |node| node.name == 'message' }
+      @messages = Hash[messages.map { |node| [node['name'], node] }]
+    end
+
+    def parse_port_types
+      port_types = document.root.element_children.select { |node| node.name == 'portType' }
+      @port_types = Hash[port_types.map { |node| [node['name'], node] }]
+    end
+
+    def parse_port_type_operations
+      @port_type_operations = {}
+
+      @port_types.each do |port_type_name, port_type|
+        operations = port_type.element_children.select { |node| node.name == 'operation' }
+        @port_type_operations[port_type_name] = Hash[operations.map { |node| [node['name'], node] }]
+      end
+    end
+
+    def parse_operations_parameters
+      root_elements = document.xpath("wsdl:definitions/wsdl:types/*[local-name()='schema']/*[local-name()='element']", 'wsdl' => WSDL).each do |element|
+        name = element.attribute("name").to_s.snakecase.to_sym
+
+        if operation = @operations[name]
+          element.xpath("*[local-name() ='complexType']/*[local-name() ='sequence']/*[local-name() ='element']").each do |child_element|
+            attr_name = child_element.attribute("name").to_s
+            attr_type = (attr_type = child_element.attribute("type").to_s.split(":")).size > 1 ? attr_type[1] : attr_type[0]
+
+            operation[:parameters] ||= {}
+            operation[:parameters][attr_name.to_sym] = { :name => attr_name, :type => attr_type }
+          end
+        end
+      end
+    end
+
     def parse_operations
-      operations = xpath("wsdl:definitions/wsdl:binding/wsdl:operation")
+      operations = document.xpath("wsdl:definitions/wsdl:binding/wsdl:operation", 'wsdl' => WSDL)
       operations.each do |operation|
         name = operation.attribute("name").to_s
 
-        soap_action = at_xpath(operation, ".//soap11:operation/@soapAction")
-        soap_action ||= at_xpath(operation, ".//soap12:operation/@soapAction")
+        # TODO: check for soap namespace?
+        soap_operation = operation.element_children.find { |node| node.name == 'operation' }
+        soap_action = soap_operation['soapAction'] if soap_operation
 
         if soap_action
           soap_action = soap_action.to_s
           action = soap_action && !soap_action.empty? ? soap_action : name
 
           # There should be a matching portType for each binding, so we will lookup the input from there.
+          namespace_id, output = output_for(operation)
           namespace_id, input = input_for(operation)
 
           # Store namespace identifier so this operation can be mapped to the proper namespace.
-          @operations[name.snakecase.to_sym] = { :action => action, :input => input, :namespace_identifier => namespace_id }
+          @operations[name.snakecase.to_sym] = { :action => action, :input => input, :output => output, :namespace_identifier => namespace_id}
         elsif !@operations[name.snakecase.to_sym]
           @operations[name.snakecase.to_sym] = { :action => name, :input => name }
         end
@@ -109,38 +158,65 @@ module Wasabi
     end
 
     def parse_types
-      xpath("wsdl:definitions/wsdl:types/xs:schema/xs:element[@name]").
-        each { |type| process_type(at_xpath(type, "./xs:complexType"), type.attribute("name").to_s) }
-
-      xpath("wsdl:definitions/wsdl:types/xs:schema/xs:complexType[@name]").
-        each { |type| process_type(type, type.attribute("name").to_s) }
+      schemas.each do |schema|
+        schema_namespace = schema['targetNamespace']
+
+        schema.element_children.each do |node|
+          namespace = schema_namespace || @namespace
+
+          case node.name
+          when 'element'
+            complex_type = node.at_xpath('./xs:complexType', 'xs' => XSD)
+            process_type namespace, complex_type, node['name'].to_s if complex_type
+          when 'complexType'
+            process_type namespace, node, node['name'].to_s
+          end
+        end
+      end
     end
 
-    def process_type(type, name)
-      return unless type
-      @types[name] ||= { :namespace => find_namespace(type) }
+    def process_type(namespace, type, name)
+      @types[name] ||= { :namespace => namespace }
+      @types[name][:order!] = []
 
-      xpath(type, "./xs:sequence/xs:element").
-        each { |inner| @types[name][inner.attribute("name").to_s] = { :type => inner.attribute("type").to_s } }
+      type.xpath("./xs:sequence/xs:element", 'xs' => XSD).each do |inner|
+        element_name = inner.attribute("name").to_s
+        @types[name][element_name] = { :type => inner.attribute("type").to_s }
 
-      type.xpath("./xs:complexContent/xs:extension/xs:sequence/xs:element",
-        "xs" => "http://www.w3.org/2001/XMLSchema"
-      ).each do |inner_element|
-        @types[name][inner_element.attribute('name').to_s] = {
-          :type => inner_element.attribute('type').to_s
-        }
+        [ :nillable, :minOccurs, :maxOccurs ].each do |attr|
+          if v = inner.attribute(attr.to_s)
+           @types[name][element_name][attr] = v.to_s
+          end
+        end
+
+        @types[name][:order!] << element_name
+      end
+
+      type.xpath("./xs:complexContent/xs:extension/xs:sequence/xs:element", 'xs' => XSD).each do |inner_element|
+        element_name = inner_element.attribute('name').to_s
+        @types[name][element_name] = { :type => inner_element.attribute('type').to_s }
+
+        @types[name][:order!] << element_name
       end
 
-      type.xpath('./xs:complexContent/xs:extension[@base]',
-        "xs" => "http://www.w3.org/2001/XMLSchema"
-      ).each do |inherits|
+      type.xpath('./xs:complexContent/xs:extension[@base]', 'xs' => XSD).each do |inherits|
         base = inherits.attribute('base').value.match(/\w+$/).to_s
+
         if @types[base]
-          @types[name].merge! @types[base]
+          # Reverse merge because we don't want subclass attributes to be overriden by base class
+          @types[name] = types[base].merge(types[name])
+          @types[name][:order!] = @types[base][:order!] | @types[name][:order!]
+          @types[name][:base_type] = base
         else
-          deferred_types << Proc.new {
-            @types[name].merge! @types[base] if @types[base]
-          }
+          p = Proc.new do
+            if @types[base]
+              # Reverse merge because we don't want subclass attributes to be overriden by base class
+              @types[name] = @types[base].merge(@types[name])
+              @types[name][:order!] = @types[base][:order!] | @types[name][:order!]
+              @types[name][:base_type] = base
+            end
+          end
+          deferred_types << p
         end
       end
     end
@@ -149,28 +225,39 @@ module Wasabi
       deferred_types.each(&:call)
     end
 
-    def find_namespace(type)
-      schema_namespace = at_xpath(type, "ancestor::xs:schema/@targetNamespace")
-      schema_namespace ? schema_namespace.to_s : @namespace
+    def input_for(operation)
+     input_output_for(operation, "input")
     end
 
-    def input_for(operation)
+    def output_for(operation)
+     input_output_for(operation, "output")
+    end
+
+    def input_output_for(operation, input_output)
       operation_name = operation["name"]
 
       # Look up the input by walking up to portType, then up to the message.
 
-      binding_type = at_xpath(operation, "../@type").to_s.split(':').last
-      port_type_input = at_xpath(operation, "../../wsdl:portType[@name='#{binding_type}']/wsdl:operation[@name='#{operation_name}']/wsdl:input")
+      binding_type = operation.parent['type'].to_s.split(':').last
+      if @port_type_operations[binding_type]
+        port_type_operation = @port_type_operations[binding_type][operation_name]
+      end
+
+      port_type_input_output = port_type_operation &&
+                               port_type_operation.element_children.find { |node| node.name == input_output }
 
       # TODO: Stupid fix for missing support for imports.
       # Sometimes portTypes are actually included in a separate WSDL.
-      if port_type_input
-        port_message_ns_id, port_message_type = port_type_input.attribute("message").to_s.split(':')
+      if port_type_input_output
+        port_message_ns_id, port_message_type = port_type_input_output.attribute("message").to_s.split(':')
 
         message_ns_id, message_type = nil
 
         # TODO: Support multiple 'part' elements in the message.
-        if (port_message_part = at_xpath(port_type_input, "../../../wsdl:message[@name='#{port_message_type}']/wsdl:part[1]"))
+        message = @messages[port_message_type]
+        port_message_part = message.element_children.find { |node| node.name == 'part' }
+
+        if port_message_part
           if (port_message_part_element = port_message_part.attribute("element"))
             message_ns_id, message_type = port_message_part_element.to_s.split(':')
           end
@@ -180,12 +267,38 @@ module Wasabi
         if message_type
           [message_ns_id, message_type]
         else
-          [port_message_ns_id, operation_name]
+          [port_message_ns_id, port_message_type]
         end
       else
         [nil, operation_name]
       end
     end
 
+    def schemas
+      types = section('types').first
+      types ? types.element_children : []
+    end
+
+    def service
+      services = section('service')
+      services.first if services  # service nodes could be imported?
+    end
+
+    def section(section_name)
+      sections[section_name] || []
+    end
+
+    def sections
+      return @sections if @sections
+
+      sections = {}
+      document.root.element_children.each do |node|
+        (sections[node.name] ||= []) << node
+      end
+
+      @sections = sections
+    end
+
   end
+
 end