wsdl-reader 0.0.1

data/lib/wsdl-reader/request.rb

@@ -0,0 +1,213 @@
+require 'wsdl-reader/core_ext'
+
+require 'wsdl-reader/xsd'
+require 'wsdl-reader/response'
+
+module SOAP
+  class Request
+    def initialize(wsdl, binding = nil) #:nodoc:
+      @wsdl = wsdl
+      @binding = binding
+      @request = nil
+    end
+
+    # Call a method for the current Request and get a SOAP::Response
+    #
+    # Example:
+    #   wsdl = SOAP::LC.new.wsdl("http://...")
+    #   request = wsdl.request
+    #   response = request.myMethod(:param1 => "hello")
+    #     # => #<SOAP::Response:0xNNNNNN>
+    def method_missing(id, *args)
+      call(id.id2name, args[0])
+    end
+
+    # Create a new SOAP::Request with the given envelope, uri and headers
+    #
+    # Example:
+    #   e = '<SOAP-ENV:Envelope 
+    #                    xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"
+    #                    xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/"
+    #                    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+    #                    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+    #                    SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
+    #          <SOAP-ENV:Header/>
+    #            <SOAP-ENV:Body>
+    #              <HelloWorld xmlns="urn:MyWebService">
+    #                <from>Greg</from>
+    #              </HelloWorld>
+    #            </SOAP-ENV:Body>
+    #          </SOAP-ENV:Envelope>'
+    #   r = SOAP::Request.request(e, "http://localhost:3000/hello/wsdl", "SOAPAction" => "my.soap.action")
+    def self.request(envelope, uri, headers = {})
+      req = new(nil, nil)
+      req.r(envelope, uri, headers)
+      return req
+    end
+    def r(envelope, uri, headers) #:nodoc:
+      @request = {
+        :headers  => make_header(envelope, headers),
+        :envelope => envelope,
+        :uri      => uri,
+        :wsdl     => nil,
+        :response => nil,
+        :binding  => @binding,
+        :method   => nil
+      }
+    end
+
+    # Return available SOAP actions
+    def operations
+      @wsdl.bindings.get_operations(@binding)
+    end
+    
+    # Call a method for the current Request
+    #
+    # Example:
+    #   wsdl = SOAP::LC.new.wsdl("http://...")
+    #   request = wsdl.request
+    #   response = request.call("myMethod", :param1 => "hello")
+    #     # => #<SOAP::Response:0xNNNNNN>
+    def call(method_name, args)
+      args = (args || {}).keys_to_sym!
+
+      # Get Binding
+      binding = @wsdl.bindings.get_binding_for_operation_name(@binding, method_name)
+      if binding.size == 0
+        raise SOAP::LCNoMethodError, "Undefined method `#{method_name}'"
+      elsif binding.size > 1
+        raise SOAP::LCError, "Ambigous method name `#{method_name}', please, specify a binding name"
+      else
+        binding = binding[0]
+        @binding = binding.name
+      end
+
+      # Get Binding Operation
+      binding_operation = binding.operations[method_name]
+
+      # Get PortType
+      port_type = @wsdl.port_types[binding.type.nns]
+      port_type_operation = port_type.operations[method_name]
+
+      # Get message for input operation
+      input_message = @wsdl.messages[port_type_operation[:input][:message].nns]
+
+      # Create method
+      soap_method = "<#{method_name} xmlns=\"#{@wsdl.target_namespace}\">\n"
+      input_message.parts.each do |_, attrs|
+        case attrs[:mode]
+          when :type
+            if SOAP::XSD::ANY_SIMPLE_TYPE.include?(attrs[attrs[:mode]].nns)
+              # Part refer to a builtin SimpleType
+              soap_method << SOAP::XSD.displayBuiltinType(attrs[:name], args, 1, 1)
+            else
+              # Part refer to an XSD simpleType or complexType defined in types
+              element = @wsdl.types[attrs[attrs[:mode]].nns][:value]
+              case element[:type]
+                when :simpleType
+                  soap_method << "<#{attrs[:name]}>\n#{element.display(@wsdl.types, args)}\n</#{attrs[:name]}>\n" # MAYBE ##########
+                when :complexType
+                  soap_method << "<#{attrs[:name]}>\n#{element.display(@wsdl.types, args)}\n</#{attrs[:name]}>\n" # MAYBE ##########
+                else
+                  raise SOAP::LCWSDLError, "Malformated part #{attrs[:name]}"
+              end
+            end
+          when :element
+            # Part refer to an XSD element
+            element = @wsdl.types[attrs[attrs[:mode]].nns][:value]
+            case @wsdl.types[attrs[attrs[:mode]].nns][:type]
+              when :simpleType
+                soap_method << element[element[:type]].display(@wsdl.types, args)
+              when :complexType
+                soap_method << element[element[:type]].display(@wsdl.types, args)
+              else
+                raise SOAP::LCWSDLError, "Malformed element `#{attrs[attrs[:mode]]}'"
+            end
+        
+            ## TODO ---------- USE element[:key]
+          else 
+            raise SOAP::LCWSDLError, "Malformed part #{attrs[:name]}"
+        end
+      end
+      soap_method += "</#{method_name}>\n"
+
+      # Create SOAP Envelope
+      envelope = soap_envelop { soap_header + soap_body(soap_method) }
+
+      # Create headers
+      headers = Hash.new
+
+      # Add SOAPAction to headers (if exist)
+      action = binding_operation[:soapAction] rescue nil
+
+      headers['SOAPAction'] = action unless action.nil? || action.length == 0
+
+      # Search URI
+      service_port = @wsdl.services.getServicePortForBindingName(binding.name)
+      address = service_port[:address]
+
+      # Complete request
+      @request = {
+        :headers  => make_header(envelope, headers),
+        :envelope => envelope,
+        :uri      => address,
+        :wsdl     => @wsdl,
+        :response => @wsdl.messages[port_type_operation[:output][:message].nns].name,
+        :binding  => @binding,
+        :method   => method_name
+      }
+      
+      self
+    end
+
+    # Get the SOAP Body for the request
+    def soap_body(soap_method)
+      "<SOAP-ENV:Body>\n" + soap_method + "</SOAP-ENV:Body>\n"
+    end
+
+    # Send request to the server and get a response (SOAP::Response)
+    def response
+      SOAP::Response.new(@request)
+    end
+    alias_method :result, :response
+
+    # Get the SOAP Envelope for the request
+    def envelope
+      @request[:envelope] || nil
+    end
+
+    # Get request headers
+    def headers
+      @request[:headers] || nil
+    end
+    
+    # Get request URI
+    def uri
+      @request[:uri] || nil
+    end
+
+    private
+    def make_header(e, h = {}) #:nodoc:
+      {
+        'User-Agent' => "SOAP::LC (#{SOAP::LC::VERSION}); Ruby (#{VERSION})",
+        'Content-Type' => 'text/xml', #'application/soap+xml; charset=utf-8',
+        'Content-Length' => "#{e.length}"
+      }.merge(h)
+    end
+
+    def soap_envelop(&b) #:nodoc:
+      "<SOAP-ENV:Envelope 
+          xmlns:SOAP-ENV=\"http://schemas.xmlsoap.org/soap/envelope/\"
+          xmlns:SOAP-ENC=\"http://schemas.xmlsoap.org/soap/encoding/\"
+          xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" 
+          xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\"
+          SOAP-ENV:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">\n" +
+        yield +
+      '</SOAP-ENV:Envelope>'
+    end
+
+    def soap_header
+      "<SOAP-ENV:Header/>\n"
+    end    
+  end
+end

data/lib/wsdl-reader/response.rb

@@ -0,0 +1,72 @@
+require 'rexml/document'
+
+module SOAP
+  class Response
+    # XML response
+    attr_reader :to_xml
+    # Hash response
+    attr_reader :to_h
+    
+    def initialize(request) #:nodoc:
+      @request = request
+      url = URI.parse(request[:uri])
+      @soap_response = Net::HTTP.new(url.host, url.port).start { |http|
+        http.post(url.request_uri, @request[:envelope], @request[:headers])
+      }
+      
+      @to_xml = @soap_response.body
+      @to_h = {}
+      
+      if @request[:wsdl].nil? or @request[:response].nil?
+        require 'rubygems'
+        require 'active_support'
+        
+        @to_h = Hash.from_xml(@soap_response.body)
+      else
+        processResponse() 
+      end
+    end
+    
+    def method_missing(id, *args)
+      get(id.id2name)
+    end
+    
+    def [](name)
+      @to_h[name]
+    end
+    def get(name)
+      @to_h[name]
+    end
+    
+    # Return SOAP error
+    def error
+      @soap_response.error!
+    end
+    
+    private
+    def processResponse
+      xml_result = REXML::Document.new(@to_xml)
+      # raise SOAP::LCElementError, "Invalide SOAP response!" if xml_result.root.children[0].children[0].name != "#{@request[:method]}Response"
+            
+      xml_response = xml_result.root.children[0].children[0].children
+      @request[:wsdl].messages[@request[:response]].parts.each do |node, attrs|
+        case attrs[:mode]
+          when :element
+            @to_h = @request[:wsdl].types[attrs[:element].nns][:value].responseToHash(xml_response, @request[:wsdl].types)
+          when :type
+            if SOAP::XSD::ANY_SIMPLE_TYPE.include?(attrs[:type].nns)
+              # **************************** NEED TO BE VERIFIED ************************************
+              @to_h = { node.to_sym => SOAP::XSD::Convert.to_ruby(attrs[:type].to_s, xml_response[0].children[0].to_s) }
+              # **************************** TODO ************************************
+            else
+              # **************************** TODO ************************************
+              warn("Complex type #{attrs[:type]} not yet supported! for #{xml_response}")
+              # **************************** TODO ************************************
+            end
+          else
+        end
+      end      
+    end
+    
+  end
+end

data/lib/wsdl-reader/service.rb

@@ -0,0 +1,56 @@
+module SOAP
+  class WSDL
+    class Services < Hash
+      def getServicePortForBindingName( name )
+        self.each do |binding_name, binding|
+          binding.ports.each do |port_name, port|
+            return port if port[:binding].nns == name
+          end
+        end
+        return nil
+      end
+    end
+    
+    class Service
+      attr_reader :ports
+      attr_reader :name
+      
+      def initialize( element )
+        @ports = Hash.new
+        @name = element.attributes['name']
+        
+        # Process all ports
+        element.find_all {|e| e.class == REXML::Element }.each { |port|
+          case port.name
+            when "port"
+              @ports[port.attributes['name']] = Hash.new
+              
+              # Store port attributs             
+              port.attributes.each { |name, value|
+                case name
+                  when 'name'
+                    @ports[port.attributes['name']][:name] = value
+                  when 'binding'
+                    @ports[port.attributes['name']][:binding] = value
+                  else
+                    warn "Ignoring attribut `#{name}' in port `#{port.attributes['name']}' for service `#{element.attributes['name']}'"
+                end
+              }
+              
+              # Store port soap:address
+              port.find_all {|e| e.class == REXML::Element }.each { |address|
+                case address.name
+                  when "address"
+                    @ports[port.attributes['name']][:address] = address.attributes['location']
+                  else
+                    warn "Ignoring element `#{address.name}' in port `#{port.attributes['name']}' for service `#{element.attributes['name']}'"
+                end
+              }
+            else
+              warn "Ignoring element `#{port.name}' in service `#{element.attributes['name']}'"
+          end
+        }
+      end
+    end
+  end
+end

data/lib/wsdl-reader/version.rb

@@ -0,0 +1,5 @@
+module Wsdl
+  module Reader
+    VERSION = "0.0.1"
+  end
+end

data/lib/wsdl-reader/wsdl.rb

@@ -0,0 +1,48 @@
+require 'soap/lc/wsdl/parser'
+require 'soap/lc/request'
+
+module SOAP 
+  class WSDL
+    attr_reader :parse
+    
+    def initialize(uri, binding) #:nodoc:
+      @parse = SOAP::WSDL::Parser.new(uri)
+      @binding = binding
+    end
+    
+    # Call a method for the current WSDL and get the corresponding SOAP::Request
+    #
+    # Example:
+    #   wsdl = SOAP::LC.new.wsdl("http://...")
+    #   request = wsdl.myMethod(:param1 => "hello")
+    #     # => #<SOAP::Request:0xNNNNNN>
+    def method_missing(id, *args) 
+      request(@binding).call(id.id2name, args[0])
+    end
+    
+    # Return available SOAP operations
+    def operations
+      request(@binding).operations
+    end
+    
+    # Call a method for the current WSDL and get the corresponding SOAP::Request
+    #
+    # Example:
+    #   wsdl = SOAP::LC.new.wsdl("http://...")
+    #   request = wsdl.call("myMethod", { :param1 => "hello" })
+    #     # => #<SOAP::Request:0xNNNNNN>
+    def call(name, args = {})
+      request(@binding).call(name, args)
+    end
+    
+    # Get a SOAP::Request object for the current WSDL
+    #
+    # Example:
+    #   wsdl = SOAP::LC.new.wsdl("http://...")
+    #   request = wsdl.request
+    #     # => #<SOAP::Request:0xNNNNNN>
+    def request(binding = nil)
+      SOAP::Request.new(@parse, binding)
+    end
+  end
+end

data/lib/wsdl-reader/xsd.rb

@@ -0,0 +1,98 @@
+require 'wsdl-reader/error'
+require 'wsdl-reader/core_ext'
+
+require 'wsdl-reader/xsd/complextype'
+require 'wsdl-reader/xsd/convert'
+require 'wsdl-reader/xsd/element'
+require 'wsdl-reader/xsd/enumeration'
+require 'wsdl-reader/xsd/restriction'
+require 'wsdl-reader/xsd/sequence'
+require 'wsdl-reader/xsd/simpletype'
+
+module SOAP
+  class XSD
+    include Comparable
+    attr_reader :elements
+    attr_reader :simpleTypes
+    attr_reader :complexType
+
+    ANY_SIMPLE_TYPE = %w(duration dateTime time date gYearMonth gYear gMonthDay gDay gMonth 
+      boolean base64Binary hexBinary float double anyURI QName NOTATION string normalizedString 
+      token language Name NMTOKEN NCName NMTOKENS ID IDREF ENTITY IDREFS ENTITIES
+      decimal integer nonPositiveInteger long nonNegativeInteger negativeInteger int unsignedLong positiveInteger
+      short unsignedInt byte unsignedShort unsignedByte)
+
+    def initialize()
+      @elements = Hash.new
+      @simpleTypes = Hash.new
+      @complexTypes = Hash.new
+      @types = Hash.new
+    end
+
+    def <=>(other)
+      @types <=> other.instance_variable_get(:@types)
+    end
+
+    def add_schema(types)
+      # Process all schema
+      types.children.find_all { |e| e.class == REXML::Element }.each { |schema|
+        schema.find_all { |e| e.class == REXML::Element }.each { |type|
+          processType type
+        }
+      }
+    end
+
+    def any_defined_type
+      @types.keys
+    end
+
+    def [](name)
+      @types[name]
+    end
+
+    def self.displayBuiltinType(name, args, min = 1, max = 1)
+      r = ""
+
+      if args.keys.include?(name.to_sym)
+        args[name.to_sym] = [args[name.to_sym]] unless args[name.to_sym].class == Array
+        if args[name.to_sym].size < min or args[name.to_sym].size > max
+          raise SOAP::LCArgumentError, "Wrong number or values for parameter `#{name}'"
+        end
+        args[name.to_sym].each { |v|
+          r << "<#{name}>#{v}</#{name}>\n"
+        }
+      elsif min > 0
+        raise SOAP::LCArgumentError, "Missing parameter `#{name}'" if min > 0
+      end
+
+      return r
+    end
+
+    private
+
+    def processType(type)
+      case type.name
+        when "element"
+          @elements[type.attributes['name']] = SOAP::XSD::Element.new(type)
+          @types[type.attributes['name']] = {
+              :type => :element,
+              :value => @elements[type.attributes['name']]
+          }
+        when "complexType"
+          @complexTypes[type.attributes['name']] = SOAP::XSD::ComplexType.new(type)
+          @types[type.attributes['name']] = {
+              :type => :complexType,
+              :value => @complexTypes[type.attributes['name']]
+          }
+        when "simpleType"
+          @simpleTypes[type.attributes['name']] = SOAP::XSD::SimpleType.new(type)
+          @types[type.attributes['name']] = {
+              :type => :simpleType,
+              :value => @simpleTypes[type.attributes['name']]
+          }
+        else
+          warn "Ignoring type '#{type.name}' in #{__FILE__}:#{__LINE__}" if ::WSDL::Reader.debugging?
+      end
+    end
+  end
+end