wsdl-reader 0.0.2 → 0.0.3

data/lib/wsdl-reader.rb

@@ -1,5 +1,6 @@
 require "active_support/core_ext/hash/keys"
 require "active_support/core_ext/module/delegation"
+require "active_support/core_ext/string/inflections"
 require "wsdl-reader/version"
 require "wsdl-reader/error"
 require "wsdl-reader/parser"

data/lib/wsdl-reader/binding.rb

@@ -20,7 +20,14 @@ module WSDL
       end
 
       def all_operations
-        self.map { |_, binding| binding.operations.keys }.flatten
+        self.map { |_, binding| binding.operations.values }.flatten
+      end
+
+      def operations(binding=nil)
+        bindings = binding.nil? ? self : ({ a: self[binding] })
+        bindings.inject({ }) do |hash, (_, b)|
+          hash.merge b.operations
+        end
       end
 
       def operation?(operation_name)
@@ -32,53 +39,63 @@ module WSDL
       attr_reader :operations
       attr_reader :name
       attr_reader :type
+      attr_reader :type_nns
       attr_reader :style
       attr_reader :transport
 
       def initialize(element)
-        @operations = Hash.new
+        @operations = Operations.new
         @name       = element.attributes['name']
         @type       = element.attributes['type'] # because of Object#type
+        @type_nns   = @type.split(':').last rescue @type
         @style      = nil
         @transport  = nil
 
         # Process all binding and operation
-        element.find_all { |e| e.class == REXML::Element }.each { |operation|
-          case operation.name
+        element.find_all { |e| e.class == REXML::Element }.each do |operation_element|
+          case operation_element.name
             when "binding" # soap:binding
-              store_style_and_transport(element, operation)
+              store_style_and_transport(operation_element)
 
             when "operation"
-              store_operation_name(element, operation)
-
-              operation.find_all { |e| e.class == REXML::Element }.each { |action|
-                store_action(action, element, operation)
-              }
+              append_operation(operation_element)
             else
               warn "Ignoring element `#{operation.name}' in binding `#{element.attributes['name']}'"
           end
-        }
+        end
       end
 
       def operation?(name)
-        operations.include? name
+        operations.include? camelize_operation(name)
+      end
+
+      def lookup_port_type(port_types)
+        port_types[type.split(':').last]
       end
 
       protected
 
-      def store_style_and_transport(element, operation)
-        operation.attributes.each do |name, value|
+      def append_operation(operation_element)
+        @operations << Operation.new(operation_element, self)
+      end
+
+      def store_style_and_transport(operation_element)
+        operation_element.attributes.each do |name, value|
           case name
             when 'style'
               @style = value
             when 'transport'
               @transport = value
-            else
-              warn "Ignoring attribute `#{name}' for wsdlsoap:binding in binding `#{element.attributes['name']}'"
           end
         end
       end
 
+      def camelize_operation(name)
+        name.to_s.tap do |name_string|
+          return name_string.camelize :lower if name_string.underscore == name_string
+        end
+      end
+
       def store_operation_name(element, operation)
         operation.attributes.each do |name, value|
           case name
@@ -90,7 +107,7 @@ module WSDL
         end
       end
 
-      def fill_action(action, operation)
+      def fill_action(action, operation, element)
         filling_action = { }
 
         action.attributes.each do |name, value|
@@ -109,6 +126,12 @@ module WSDL
               filling_action[:body] = { }
 
               body.attributes.each { |name, value| filling_action[:body][name.to_sym] = value }
+
+            when "fault"
+              filling_action[:body] = { }
+
+              body.attributes.each { |name, value| filling_action[:body][name.to_sym] = value }
+
             else
               warn "Ignoring element `#{body.name}' in #{action.name} `#{action.attributes['name']}' in operation `#{operation.attributes['name']}' for binding `#{element.attributes['name']}'"
           end
@@ -130,13 +153,13 @@ module WSDL
               end
             end
           when "input"
-            current_operation(operation)[:input] = fill_action(action, operation)
+            current_operation(operation)[:input] = fill_action(action, operation, element)
 
           when "output"
-            current_operation(operation)[:output] = fill_action(action, operation)
+            current_operation(operation)[:output] = fill_action(action, operation, element)
 
           when "fault"
-            current_operation(operation)[:fault] = fill_action(action, operation)
+            current_operation(operation)[:fault] = fill_action(action, operation, element)
 
           else
             warn "Ignoring element `#{action.name}' in operation `#{operation.attributes['name']}' for binding `#{element.attributes['name']}'"
@@ -149,4 +172,4 @@ module WSDL
 
     end
   end
-end
+end

data/lib/wsdl-reader/error.rb

@@ -3,6 +3,30 @@ module WSDL
     class ParserError < StandardError
     end
 
+    class LookupError < StandardError
+    end
+
+    class ManyOperationsFoundError < LookupError
+      def initialize(type, element_name)
+        @type, @element_name = type, element_name
+      end
+
+
+      def message
+        "More than one operations found for element: [#@element_name]"
+      end
+    end
+
+    class OperationNotFoundError < LookupError
+      def initialize(type, element_name)
+        @type, @element_name = type, element_name
+      end
+
+      def message
+        "No operation matches for element: [#@element_name]"
+      end
+    end
+
     class FileOpenError < ParserError
     end
   end

data/lib/wsdl-reader/message.rb

@@ -1,6 +1,32 @@
 module WSDL
   module Reader
     class Messages < Hash
+
+      def lookup_operations_by_element(type, element_name, port_types)
+        messages = lookup_messages_by_element(element_name)
+        messages.map do |message|
+          port_types.lookup_operations_by_message(type, message)
+        end.flatten
+      end
+
+      def lookup_operation_by_element! (type, element_name, port_types)
+        messages = lookup_operations_by_element type, element_name, port_types
+        case messages.size
+          when 1
+            messages.first
+          when 0
+            raise OperationNotFoundError.new type, element_name
+          else
+            raise ManyOperationsFoundError.new type, element_name
+        end
+      end
+
+      def lookup_messages_by_element(element_name)
+        values.select do |message|
+          message.parts.values.find { |part| part[:element].split(':').last == element_name }
+        end
+      end
+
     end
 
     class Message
@@ -9,11 +35,15 @@ module WSDL
 
       def initialize(element)
         @parts = Hash.new
-        @name = element.attributes['name']
+        @name  = element.attributes['name']
 
         process_all_parts element
       end
 
+      def element
+        parts.map { |_, hash| hash[:element] }.first
+      end
+
       protected
 
       def process_all_parts(element)
@@ -36,7 +66,7 @@ module WSDL
               current_part[:name] = value
             when 'element'
               current_part[:element] = value
-              current_part[:mode] = :element
+              current_part[:mode]    = :element
             when 'type'
               current_part[:type] = value
               current_part[:mode] = :type
@@ -47,4 +77,4 @@ module WSDL
       end
     end
   end
-end
+end

data/lib/wsdl-reader/operation.rb

@@ -0,0 +1,85 @@
+module WSDL
+  module Reader
+
+    class Operations < Hash
+      def <<(operation)
+        self[operation.name] = operation
+      end
+    end
+
+    class Operation
+      attr_reader :soap_action, :style, :input, :output, :fault
+      attr_reader :name, :binding
+
+      def initialize(element, binding)
+        @name = element.attributes['name']
+        @binding = binding
+
+        parse! element
+      end
+
+      def method_name
+        @name.underscore
+      end
+
+      def message
+        @name
+      end
+
+      def lookup_element(port_types, messages)
+        message = port_types.lookup_operation_message :input, self, messages
+        message.element.split(':').last
+      end
+
+      private
+
+      def parse!(operation_element)
+        operation_element.find_all { |e| e.class == REXML::Element }.each do |action_element|
+          store_action(action_element)
+        end
+      end
+
+      def store_action(action_element)
+        case action_element.name
+          when "operation" # soap:operation
+            action_element.attributes.each do |name, value|
+              case name
+                when 'soapAction'
+                  @soap_action = value
+                when 'style'
+                  @style = value
+              end
+            end
+          when "input"
+            @input = fill_action(action_element)
+
+          when "output"
+            @output = fill_action(action_element)
+
+          when "fault"
+            @fault = fill_action(action_element)
+        end
+      end
+
+      def fill_action(action_element)
+        filling_action = { }
+
+        filling_action[:name] = action_element.attributes['name']
+
+        # Store body
+        action_element.find_all { |e| e.class == REXML::Element }.each do |body|
+          if body.name = "body"
+            filling_action[:body] = { }
+
+            body.attributes.each do |name, value|
+              filling_action[:body][name.to_sym] = value
+            end
+          end
+        end
+
+        filling_action
+      end
+
+    end
+  end
+end

data/lib/wsdl-reader/parser.rb

@@ -4,6 +4,7 @@ require 'rexml/document'
 require 'wsdl-reader/message'
 require 'wsdl-reader/port_type'
 require 'wsdl-reader/binding'
+require 'wsdl-reader/operation'
 require 'wsdl-reader/service'
 require 'wsdl-reader/xsd'
 
@@ -14,7 +15,8 @@ module WSDL
       attr_reader :prefixes, :target_namespace
       attr_reader :document, :uri
 
-      delegate :get_operations, to: :bindings
+      delegate :operations, :operation?, to: :bindings
+      delegate :lookup_operation_by_element!, to: :messages
 
       def initialize(uri)
         @uri = uri
@@ -104,4 +106,4 @@ module WSDL
       end
     end
   end
-end
+end

data/lib/wsdl-reader/port_type.rb

@@ -1,6 +1,18 @@
 module WSDL
   module Reader
     class PortTypes < Hash
+      def lookup_operation_message(type, operation, messages) # TODO: lookup_message_by_operation
+        each do |_, port_type|
+          message = port_type.lookup_operation_message type, operation, messages
+          return message if message
+        end
+      end
+
+      def lookup_operations_by_message(type, message)
+        inject([]) do |array, (_, port_type)|
+          array + port_type.lookup_operations_by_message(type, message)
+        end
+      end
     end
 
     class PortType
@@ -9,11 +21,31 @@ module WSDL
 
       def initialize(element)
         @operations = Hash.new
-        @name = element.attributes['name']
+        @name       = element.attributes['name']
 
         process_all_operations(element)
       end
 
+      def lookup_operation_message(type, operation, messages)
+        operation_name = operation.is_a?(Operation) ? operation.name : operation.to_s
+        messages[@operations[operation_name][type][:message].split(':').last]
+      end
+
+      def lookup_operations_by_message(type, message)
+        ops = @operations.values.select do |operation|
+          operation_message? type, operation, message
+        end
+        ops.map do |operation_hash|
+          operation_hash[:name]
+        end
+      end
+
+      def operation_message?(type, operation, message)
+        message_name = message.is_a?(Message) ? message.name : message.to_s
+        operation[type][:message] == message_name ||
+            operation[type][:message].split(':').last == message_name
+      end
+
       protected
 
       def store_attributes(element, operation)
@@ -79,17 +111,17 @@ module WSDL
 
               operation.find_all { |e| e.class == REXML::Element }.each do |action|
                 case action.name
-                when "input"
-                  store_input(action, element, operation)
+                  when "input"
+                    store_input(action, element, operation)
 
-                when "output"
-                  store_output(action, element, operation)
+                  when "output"
+                    store_output(action, element, operation)
 
-                when "fault"
-                  store_fault(action, element, operation)
+                  when "fault"
+                    store_fault(action, element, operation)
 
-                else
-                  warn "Ignoring element '#{action.name}' in operation '#{operation.attributes['name']}' for portType '#{element.attributes['name']}'"
+                  else
+                    warn "Ignoring element '#{action.name}' in operation '#{operation.attributes['name']}' for portType '#{element.attributes['name']}'"
                 end
               end
             else
@@ -103,4 +135,4 @@ module WSDL
       end
     end
   end
-end
+end

data/lib/wsdl-reader/version.rb

@@ -1,5 +1,5 @@
 module Wsdl
   module Reader
-    VERSION = "0.0.2"
+    VERSION = "0.0.3"
   end
 end

data/spec/binding_spec.rb

@@ -12,25 +12,25 @@ describe "WSDL Binding" do
     it "#get_operations with binding UserServicePortBinding" do
       operations = subject.get_operations "UserServicePortBinding"
       operations.should have(2).operation
-      operations.should eq %w{getFirstName getLastName}
+      operations.should eq %w{getFirstNameOperation getLastNameOperation}
     end
 
     it "#get_binding_for_operation_name with binding = UserServicePortBinding and operation = getFirstName" do
-      bindings_array = subject.get_binding_for_operation_name "UserServicePortBinding", "getFirstName"
+      bindings_array = subject.get_binding_for_operation_name "UserServicePortBinding", "getFirstNameOperation"
 
       bindings_array.should have(1).binding
       bindings_array.first.should be_a WSDL::Reader::Binding
       bindings_array.first.name.should eq "UserServicePortBinding"
-      bindings_array.first.operations.keys.should include "getFirstName"
+      bindings_array.first.operations.keys.should include "getFirstNameOperation"
     end
 
     it "#get_binding_for_operation_name operation = getFirstName but without binding" do
-      bindings_array = subject.get_binding_for_operation_name "getFirstName"
+      bindings_array = subject.get_binding_for_operation_name "getFirstNameOperation"
 
-      bindings_array.should have(1).binding
+      bindings_array.should have(2).binding
       bindings_array.first.should be_a WSDL::Reader::Binding
       bindings_array.first.name.should eq "UserServicePortBinding"
-      bindings_array.first.operations.keys.should include "getFirstName"
+      bindings_array.first.operations.keys.should include "getFirstNameOperation"
     end
 
     it "#all_operations should eql to #get_operations(nil)" do
@@ -38,7 +38,7 @@ describe "WSDL Binding" do
     end
 
     it "#operation? should return true if any binding include is operation_name" do
-      subject.operation?("getFirstName").should be_true
+      subject.operation?("getFirstNameOperation").should be_true
     end
 
     it "#operation? should return false if all bindings dont include is operation_name" do
@@ -49,27 +49,27 @@ describe "WSDL Binding" do
   context "WSDL::Reader::Binding" do
 
     def operations
-      { "getFirstName" => { :name       => "getFirstName",
-                            :soapAction => "",
-                            :input      => { :body => { :use => "literal" } },
-                            :output     => { :body => { :use => "literal" } } },
-
-        "getLastName"  => { :name       => "getLastName",
-                            :soapAction => "",
-                            :input      => { :body => { :use => "literal" } },
-                            :output     => { :body => { :use => "literal" } } }
-      }
+      %w{getFirstNameOperation getLastNameOperation}
     end
 
+    let(:parser) {  WSDL::Reader::Parser.new('spec/fixtures/UserService.wsdl') }
     subject do
-      WSDL::Reader::Parser.new('spec/fixtures/UserService.wsdl').bindings.values.first
+      parser.bindings.values.first
     end
 
-    its(:operations) { should eq operations }
+    its('operations.keys') { should eq operations }
     its(:name) { should eq "UserServicePortBinding" }
     its(:type) { should eq "tns:UserService" }
     its(:style) { should eq "document" }
     its(:transport) { should eq "http://schemas.xmlsoap.org/soap/http" }
+
+    it "#operation? should find for operation name" do
+      subject.operation?("getFirstNameOperation").should be_true
+    end
+
+    it "#lookup_port_type should lookup port_type from given port_types" do
+      subject.lookup_port_type(parser.port_types).name.should eq "UserService"
+    end
   end
 
-end
+end