wsdl-reader 0.0.1

data/.idea/wsdl-reader.iml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="RUBY_MODULE" version="4">
+  <component name="DBNavigator.Module.ConnectionManager">
+    <connections />
+  </component>
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" scope="PROVIDED" name="diff-lcs (v1.1.3, RVM: ruby-1.9.3-p0 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rspec-mocks (v2.9.0, RVM: ruby-1.9.3-p0 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="multi_json (v1.2.0, RVM: ruby-1.9.3-p0 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="activesupport (v3.2.3, RVM: ruby-1.9.3-p0 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="thor (v0.14.6, RVM: ruby-1.9.3-p0 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="ffi (v1.0.11, RVM: ruby-1.9.3-p0 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="i18n (v0.6.0, RVM: ruby-1.9.3-p0 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rspec-expectations (v2.9.1, RVM: ruby-1.9.3-p0 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rspec-core (v2.9.0, RVM: ruby-1.9.3-p0 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="bundler (v1.0.21, RVM: ruby-1.9.3-p0 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rspec (v2.9.0, RVM: ruby-1.9.3-p0 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="guard (v1.0.1, RVM: ruby-1.9.3-p0 [global]) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="guard-rspec (v0.7.0, RVM: ruby-1.9.3-p0 [global]) [gem]" level="application" />
+  </component>
+</module>
+

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+gem 'activesupport'
+# Specify your gem's dependencies in wsdl-reader.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/wsdl-reader/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+  watch(%r{spec/fixtures/.+})  { "spec" }
+end

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/wsdl-reader.rb

@@ -0,0 +1,15 @@
+require "active_support/core_ext/hash/keys"
+require "wsdl-reader/version"
+require "wsdl-reader/error"
+require "wsdl-reader/parser"
+require "wsdl-reader/request"
+
+module WSDL
+  module Reader
+    def debugging?
+      false
+    end
+
+    module_function :debugging?
+  end
+end

data/lib/wsdl-reader/binding.rb

@@ -0,0 +1,148 @@
+module WSDL
+  module Reader
+    class Bindings < Hash
+      def get_binding_for_operation_name(binding_name = nil, operation_name)
+        if binding_name.nil?
+          self.map do |_, binding|
+            binding if binding.operation?(operation_name)
+          end.flatten
+        else
+          [self[binding_name]] if self[binding_name].operation?(operation_name)
+        end
+      end
+
+      def get_operations(binding_name = nil)
+        if binding_name.nil?
+          all_operations
+        else
+          self[binding_name].operations.keys
+        end
+      end
+
+      def all_operations
+        self.map { |_, binding| binding.operations.keys }.flatten
+      end
+    end
+
+    class Binding
+      attr_reader :operations
+      attr_reader :name
+      attr_reader :type
+      attr_reader :style
+      attr_reader :transport
+
+      def initialize(element)
+        @operations = Hash.new
+        @name       = element.attributes['name']
+        @type       = element.attributes['type'] # because of Object#type
+        @style      = nil
+        @transport  = nil
+
+        # Process all binding and operation
+        element.find_all { |e| e.class == REXML::Element }.each { |operation|
+          case operation.name
+            when "binding" # soap:binding
+              store_style_and_transport(element, operation)
+
+            when "operation"
+              store_operation_name(element, operation)
+
+              operation.find_all { |e| e.class == REXML::Element }.each { |action|
+                store_action(action, element, operation)
+              }
+            else
+              warn "Ignoring element `#{operation.name}' in binding `#{element.attributes['name']}'"
+          end
+        }
+      end
+
+      def operation?(name)
+        operations.include? name
+      end
+
+      protected
+
+      def store_style_and_transport(element, operation)
+        operation.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 store_operation_name(element, operation)
+        operation.attributes.each do |name, value|
+          case name
+            when 'name'
+              current_operation(operation)[:name] = value
+            else
+              warn "Ignoring attribute `#{name}' for operation `#{operation.attributes['name']}' in binding `#{element.attributes['name']}'"
+          end
+        end
+      end
+
+      def fill_action(action, operation)
+        filling_action = { }
+
+        action.attributes.each do |name, value|
+          case name
+            when 'name'
+              filling_action[:name] = value
+            else
+              warn "Ignoring attribute `#{name}' in #{action.name} `#{action.attributes['name']}' in operation `#{operation.attributes['name']}' for binding `#{element.attributes['name']}'"
+          end
+        end
+
+        # Store body
+        action.find_all { |e| e.class == REXML::Element }.each do |body|
+          case body.name
+            when "body"
+              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
+        end
+        filling_action
+      end
+
+      def store_action(action, element, operation)
+        case action.name
+          when "operation" # soap:operation
+            action.attributes.each do |name, value|
+              case name
+                when 'soapAction'
+                  current_operation(operation)[:soapAction] = value
+                when 'style'
+                  current_operation(operation)[:style] = value
+                else
+                  warn "Ignoring attribut `#{name}' for wsdlsoap:operation in operation `#{operation.attributes['name']}' in binding `#{element.attributes['name']}'"
+              end
+            end
+          when "input"
+            current_operation(operation)[:input] = fill_action(action, operation)
+
+          when "output"
+            current_operation(operation)[:output] = fill_action(action, operation)
+
+          when "fault"
+            current_operation(operation)[:fault] = fill_action(action, operation)
+
+          else
+            warn "Ignoring element `#{action.name}' in operation `#{operation.attributes['name']}' for binding `#{element.attributes['name']}'"
+        end
+      end
+
+      def current_operation(operation)
+        @operations[operation.attributes['name']] ||= { }
+      end
+
+    end
+  end
+end

data/lib/wsdl-reader/core_ext.rb

@@ -0,0 +1,28 @@
+class String #:nodoc:
+  def nns
+    self.gsub( /^[^:]*:/, "" )
+  end
+end
+
+class Hash #:nodoc:
+  def keys_to_sym!( )
+    self.each {|k, v| 
+      self.delete(k)
+      self[k.to_sym] = v
+    }
+  end
+
+  def kvTable( k, v )
+    self[k] = v
+#    if( self.keys.include?(k) )
+#      if self[k].class == Array
+#        self[k] << v
+#      else
+#        self[k] = [self[k], v]
+#      end
+#    else
+#      self[k] = v
+#    end
+  end  
+end
+

data/lib/wsdl-reader/error.rb

@@ -0,0 +1,29 @@
+module WSDL
+  module Reader
+    class ParserError < StandardError
+    end
+
+    class FileOpenError < ParserError
+    end
+  end
+end
+
+module SOAP
+  class LCError < RuntimeError
+  end
+
+  class LCWSDLError < NameError
+  end
+
+  class LCNoMethodError < NoMethodError
+  end
+
+  class LCArgumentError < ArgumentError
+  end
+
+  class LCElementError < NameError
+  end
+
+  class LCTypeError < NameError
+  end
+end

data/lib/wsdl-reader/message.rb

@@ -0,0 +1,50 @@
+module WSDL
+  module Reader
+    class Messages < Hash
+    end
+
+    class Message
+      attr_reader :parts
+      attr_reader :name
+
+      def initialize(element)
+        @parts = Hash.new
+        @name = element.attributes['name']
+
+        process_all_parts element
+      end
+
+      protected
+
+      def process_all_parts(element)
+        element.select { |e| e.class == REXML::Element }.each do |part|
+          case part.name
+            when "part"
+              @parts[part.attributes['name']] = Hash.new
+              store_part_attributes(part)
+            else
+              warn "Ignoring element `#{part.name}' in message `#{element.attributes['name']}'"
+          end
+        end
+      end
+
+      def store_part_attributes(part)
+        current_part = @parts[part.attributes['name']]
+        part.attributes.each do |name, value|
+          case name
+            when 'name'
+              current_part[:name] = value
+            when 'element'
+              current_part[:element] = value
+              current_part[:mode] = :element
+            when 'type'
+              current_part[:type] = value
+              current_part[:mode] = :type
+            else
+              warn "Ignoring attribute `#{name}' in part `#{part.attributes['name']}' for message `#{element.attributes['name']}'"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wsdl-reader/parser.rb

@@ -0,0 +1,105 @@
+require 'open-uri'
+require 'rexml/document'
+
+require 'wsdl-reader/message'
+require 'wsdl-reader/port_type'
+require 'wsdl-reader/binding'
+require 'wsdl-reader/service'
+require 'wsdl-reader/xsd'
+
+module WSDL
+  module Reader
+    class Parser
+      attr_reader :types, :messages, :port_types, :bindings, :services
+      attr_reader :prefixes, :target_namespace
+      attr_reader :document, :uri
+
+      def initialize(uri)
+        @uri = uri
+        @types = SOAP::XSD.new()
+        @messages = WSDL::Reader::Messages.new
+        @port_types = WSDL::Reader::PortTypes.new
+        @bindings = WSDL::Reader::Bindings.new
+        @services = SOAP::WSDL::Services.new
+
+        @prefixes = Hash.new
+        @target_namespace = ""
+
+        @document = REXML::Document.new(get_wsdl_source)
+
+        process_attributes @document.root.attributes
+        process_content @document.root.children
+      end
+
+      private
+
+      def get_wsdl_source
+        # Get WSDL
+        source = nil
+        begin
+          open(uri) { |f| source = f.read }
+        rescue Errno::ECONNREFUSED, Errno::ENOENT, OpenURI::HTTPError => e
+          raise WSDL::Reader::FileOpenError, "Can't open '#{uri}' : #{e.message}"
+        end
+        source
+      end
+
+      def process_attributes(attributes)
+        @target_namespace = attributes["targetNamespace"]
+
+        attributes.values.each do |attribute|
+          if attribute.prefix == "xmlns" then
+            @prefixes[attribute.name] = attribute.value
+          end
+        end
+
+        if (default_namespace = attributes["xmlns"]) then
+          @prefixes["__default__"] = default_namespace
+        end
+      end
+
+      def process_content(elements)
+        elements.find_all { |e| e.class == REXML::Element }.each do |element|
+          case element.name
+            when "types"
+              process_types(element)
+            when "message"
+              process_message(element)
+            when "portType"
+              process_port_type(element)
+            when "binding"
+              process_binding(element)
+            when "service"
+              process_service(element)
+            else
+              warn "Ignoring #{element} in #{__FILE__}:#{__LINE__}"
+          end
+        end
+      end
+
+      def process_types(element)
+        @types.add_schema(element)
+      end
+
+      def process_message(element)
+        name = element.attributes['name']
+        @messages[name] = WSDL::Reader::Message.new(element)
+      end
+
+      def process_port_type(element)
+        name = element.attributes['name']
+        @port_types[name] = WSDL::Reader::PortType.new(element)
+      end
+
+      def process_binding(element)
+        name = element.attributes['name']
+        @bindings[name] = WSDL::Reader::Binding.new(element)
+      end
+
+      def process_service(element)
+        name = element.attributes['name']
+        @services[name] = SOAP::WSDL::Service.new(element)
+      end
+    end
+  end
+end

data/lib/wsdl-reader/port_type.rb

@@ -0,0 +1,106 @@
+module WSDL
+  module Reader
+    class PortTypes < Hash
+    end
+
+    class PortType
+      attr_reader :operations
+      attr_reader :name
+
+      def initialize(element)
+        @operations = Hash.new
+        @name = element.attributes['name']
+
+        process_all_operations(element)
+      end
+
+      protected
+
+      def store_attributes(element, operation)
+        operation.attributes.each { |name, value|
+          case name
+            when 'name'
+              @operations[operation.attributes['name']][:name] = value
+            else
+              warn "Ignoring attribut '#{name}' in operation '#{operation.attributes['name']}' for portType '#{element.attributes['name']}'"
+          end
+        }
+      end
+
+      def store_input(action, element, operation)
+        @operations[operation.attributes['name']][:input] = Hash.new
+        action.attributes.each do |name, value|
+          case name
+            when 'name'
+              @operations[operation.attributes['name']][:input][:name] = value
+            when 'message'
+              @operations[operation.attributes['name']][:input][:message] = value
+            else
+              warn_ignoring(action, element, name, operation)
+          end
+        end
+      end
+
+      def store_output(action, element, operation)
+        @operations[operation.attributes['name']][:output] = Hash.new
+        action.attributes.each { |name, value|
+          case name
+            when 'name'
+              @operations[operation.attributes['name']][:output][:name] = value
+            when 'message'
+              @operations[operation.attributes['name']][:output][:message] = value
+            else
+              warn_ignoring(action, element, name, operation)
+          end
+        }
+      end
+
+      def store_fault(action, element, operation)
+        @operations[operation.attributes['name']][:fault] = Hash.new
+        action.attributes.each { |name, value|
+          case name
+            when 'name'
+              @operations[operation.attributes['name']][:fault][:name] = value
+            when 'message'
+              @operations[operation.attributes['name']][:fault][:message] = value
+            else
+              warn_ignoring(action, element, name, operation)
+          end
+        }
+      end
+
+      def process_all_operations(element)
+        element.find_all { |e| e.class == REXML::Element }.each do |operation|
+          case operation.name
+            when "operation"
+              @operations[operation.attributes['name']] = Hash.new
+
+              store_attributes(element, operation)
+
+              operation.find_all { |e| e.class == REXML::Element }.each do |action|
+                case action.name
+                when "input"
+                  store_input(action, element, operation)
+
+                when "output"
+                  store_output(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']}'"
+                end
+              end
+            else
+              warn "Ignoring element '#{operation.name}' in portType '#{element.attributes['name']}'"
+          end
+        end
+      end
+
+      def warn_ignoring(action, element, name, operation)
+        warn "Ignoring attribute '#{name}' in #{action.name} '#{action.attributes['name']}' in operation '#{operation.attributes['name']}' for portType '#{element.attributes['name']}'"
+      end
+    end
+  end
+end