soap-lc 0.0.1

data/lib/soap/lc/request.rb

@@ -0,0 +1,155 @@
+require 'soap/lc/response'
+
+module SOAP
+  class Request
+    def initialize( wsdl ) #:nodoc:
+      @wsdl = wsdl
+      @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
+    
+    # Call a method for the current Request and get a SOAP::Response
+    #
+    # Example:
+    #   wsdl = SOAP::LC.new( ).wsdl( "http://..." )
+    #   request = wsdl.request( )
+    #   response = request.call( "myMethod", :param1 => "hello" )
+    #     # => #<SOAP::Response:0xNNNNNN>
+    def call( methodName, args )
+      args = (args || {}).keys_to_sym!
+      
+      # Get Binding
+      binding = @wsdl.bindings.getBindingForOperationName( methodName )
+      raise SOAP::LCNoMethodError, "Undefined method `#{methodName}'" if binding.nil?
+
+      # Get Binding Operation
+      binding_operation = binding.operations[methodName]
+
+      # Get PortType
+      portType = @wsdl.portTypes[binding.type.nns]
+      portType_operation = portType.operations[methodName]
+
+      # Get message for input operation
+      input_message = @wsdl.messages[portType_operation[:input][:message].nns]
+      
+      # Create method
+      soap_method = "<#{methodName} xmlns=\"#{@wsdl.targetNamespace}\">\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 element[: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 SOAL::LCWSDLError, "Malformated element `#{attrs[attrs[:mode]]}'"
+            end
+            
+            ## TODO ---------- USE element[:key]
+          else 
+            raise SOAP::LCWSDLError, "Malformated part #{attrs[:name]}"
+          end
+      end
+      soap_method += "</#{methodName}>\n"
+
+      # Create SOAP Envelope
+      envelope = soap_envelop do 
+        soap_header + soap_body( soap_method )
+      end
+
+      # Create headers
+      headers = {
+        'Content-Type' => 'application/soap+xml; charset=utf-8',
+        'Content-Length' => "#{envelope.length}"
+      }
+      # Add SOAPAction to headers (if exist)
+      action = begin
+        binding_operation[:soapAction]
+      rescue
+        nil
+      end
+      headers['SOAPAction'] = action unless action.nil? or action.length == 0
+      
+      # Search URI
+      service_port = @wsdl.services.getServicePortForBindingName( binding.name )
+      address = service_port[:address]
+      
+      # Complete request
+      @request = {
+        :headers  => headers,
+        :envelope => envelope,
+        :uri      => address,
+        :response => @wsdl.messages[portType_operation[:output][:message].nns].name
+      }
+      
+      return 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( )
+      return( 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
+    
+    private
+    def soap_envelop( &b )
+      "<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/soap/lc/response.rb

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'active_support'
+
+module SOAP
+  class Response
+    # XML response
+    attr_reader :to_xml
+    # Hash response
+    attr_reader :to_h
+    
+    def initialize( request ) #:nodoc:
+      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 = Hash.from_xml( @soap_response.body )["Envelope"]["Body"][request[:response]]
+    end
+    
+    # Return SOAP error
+    def error
+      @soap_response.error!
+    end
+    
+    def method_missing( id, *args ) #:nodoc:
+      puts id.id2name
+    end
+    
+  end
+end

data/lib/soap/lc/wsdl.rb

@@ -0,0 +1,42 @@
+require 'soap/lc/wsdl/parser'
+require 'soap/lc/request'
+
+module SOAP 
+  class WSDL
+    attr_reader :parse
+    
+    def initialize( uri ) #:nodoc:
+      @parse = SOAP::WSDL::Parser.new( uri )
+    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 ) 
+      return request.call( id.id2name, args[0] )
+    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 )
+      return request.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( )
+      return SOAP::Request.new( @parse )
+    end
+  end      
+end

data/lib/soap/lc/wsdl/binding.rb

@@ -0,0 +1,160 @@
+module SOAP
+  class WSDL
+    class Bindings < Hash
+      def getBindingForOperationName( name )
+        self.each do |binding_name, binding|
+          return binding if binding.operations.keys.include?(name)
+        end
+        return nil
+      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"
+              # Get binding attributs
+              operation.attributes.each { |name, value|
+                case name
+                  when 'style'
+                    @style = value
+                  when 'transport'
+                    @transport = value
+                  else
+                    warn "Ignoring attribut `#{name}' for wsdlsoap:binding in binding `#{element.attributes['name']}'"
+                end
+              }
+            when "operation"
+              # Store operations
+              @operations[operation.attributes['name']] = Hash.new()
+              
+              # Get operation attributs
+              operation.attributes.each { |name, value|
+                case name
+                  when 'name'
+                    @operations[operation.attributes['name']][:name] = value
+                  else
+                    warn "Ignoring attribut `#{name}' for operation `#{operation.attributes['name']}' in binding `#{element.attributes['name']}'"
+                end
+              }
+              
+              # Store operation input, output, fault and operation
+              operation.find_all {|e| e.class == REXML::Element }.each { |action|
+                case action.name
+                  when "operation"
+                    # Get operation attributs
+                    action.attributes.each { |name, value|
+                      case name
+                        when 'soapAction'
+                          @operations[operation.attributes['name']][:soapAction] = value
+                        else
+                          warn "Ignoring attribut `#{name}' for wsdlsoap:operation in operation `#{operation.attributes['name']}' in binding `#{element.attributes['name']}'"
+                      end
+                    }
+                  when "input"
+                    @operations[operation.attributes['name']][:input] = Hash.new
+                    
+                    # Store input attributs
+                    action.attributes.each { |name, value|
+                      case name
+                        when 'name'
+                          @operations[operation.attributes['name']][:input][:name] = value
+                        else
+                          warn "Ignoring attribut `#{name}' in #{action.name} `#{action.attributes['name']}' in operation `#{operation.attributes['name']}' for binding `#{element.attributes['name']}'"
+                      end
+                    }
+                    
+                    # Store body 
+                    action.find_all {|e| e.class == REXML::Element }.each { |body|
+                      case body.name
+                        when "body"
+                          @operations[operation.attributes['name']][:input][:body] = Hash.new
+                          
+                          # Store body attributes
+                          body.attributes.each { |name, value|
+                            @operations[operation.attributes['name']][:input][: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
+                    }
+                  when "output"
+                    @operations[operation.attributes['name']][:output] = Hash.new
+                    
+                    # Store input attributs
+                    action.attributes.each { |name, value|
+                      case name
+                        when 'name'
+                          @operations[operation.attributes['name']][:output][:name] = value
+                        else
+                          warn "Ignoring attribut `#{name}' in #{action.name} `#{action.attributes['name']}' in operation `#{operation.attributes['name']}' for binding `#{element.attributes['name']}'"
+                      end
+                    }
+                    
+                    # Store body 
+                    action.find_all {|e| e.class == REXML::Element }.each { |body|
+                      case body.name
+                        when "body"
+                          @operations[operation.attributes['name']][:output][:body] = Hash.new
+                          
+                          # Store body attributes
+                          body.attributes.each { |name, value|
+                            @operations[operation.attributes['name']][:output][: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
+                    }
+                  when "fault"
+                    @operations[operation.attributes['name']][:fault] = Hash.new
+                    
+                    # Store input attributs
+                    action.attributes.each { |name, value|
+                      case name
+                        when 'name'
+                          @operations[operation.attributes['name']][:fault][:name] = value
+                        else
+                          warn "Ignoring attribut `#{name}' in #{action.name} `#{action.attributes['name']}' in operation `#{operation.attributes['name']}' for binding `#{element.attributes['name']}'"
+                      end
+                    }
+                    
+                    # Store body 
+                    action.find_all {|e| e.class == REXML::Element }.each { |body|
+                      case body.name
+                        when "body"
+                          @operations[operation.attributes['name']][:fault][:body] = Hash.new
+                          
+                          # Store body attributes
+                          body.attributes.each { |name, value|
+                            @operations[operation.attributes['name']][:fault][: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
+                    }                    
+                  else
+                    warn "Ignoring element `#{action.name}' in operation `#{operation.attributes['name']}' for binding `#{element.attributes['name']}'"
+                end
+              }
+            else
+              warn "Ignoring element `#{operation.name}' in binding `#{element.attributes['name']}'"
+          end
+        }
+      end
+    end
+  end
+end

data/lib/soap/lc/wsdl/message.rb

@@ -0,0 +1,44 @@
+require 'soap/lc/error'
+
+module SOAP
+  class WSDL
+    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.find_all {|e| e.class == REXML::Element }.each { |part| 
+          case part.name
+            when "part"
+              @parts[part.attributes['name']] = Hash.new
+              
+              # Store part attributs
+              part.attributes.each { |name, value|
+                case name
+                  when 'name'
+                    @parts[part.attributes['name']][:name] = value
+                  when 'element'
+                    @parts[part.attributes['name']][:element] = value
+                    @parts[part.attributes['name']][:mode] = :element
+                  when 'type'
+                    @parts[part.attributes['name']][:type] = value
+                    @parts[part.attributes['name']][:mode] = :type
+                  else
+                    warn "Ignoring attribut `#{name}' in part `#{part.attributes['name']}' for message `#{element.attributes['name']}'"
+                end
+              }
+            else
+              warn "Ignoring element `#{part.name}' in message `#{element.attributes['name']}'"
+          end
+        }
+      end
+    end
+  end
+end

data/lib/soap/lc/wsdl/parser.rb

@@ -0,0 +1,109 @@
+require 'open-uri'
+require 'rexml/document'
+
+require 'soap/lc/error'
+require 'soap/lc/wsdl/message'
+require 'soap/lc/wsdl/portType'
+require 'soap/lc/wsdl/binding'
+require 'soap/lc/wsdl/service'
+require 'soap/lc/xsd'
+
+module SOAP
+  class WSDL
+    class Parser
+      attr_reader :types
+      attr_reader :messages
+      attr_reader :portTypes
+      attr_reader :bindings
+      attr_reader :services
+      
+      attr_reader :prefixes
+      attr_reader :targetNamespace
+      
+      attr_reader :document
+      
+      def initialize( uri )
+        @types = SOAP::XSD.new()
+        @messages = SOAP::WSDL::Messages.new
+        @portTypes = SOAP::WSDL::PortTypes.new
+        @bindings = SOAP::WSDL::Bindings.new
+        @services = SOAP::WSDL::Services.new
+        
+        @prefixes = Hash.new
+        @targetNamespace = ""
+
+        # Get WSDL 
+        source = nil
+        begin
+          open( uri ) do |f|
+            source = f.read
+          end
+        rescue Errno::ECONNREFUSED, Errno::ENOENT, OpenURI::HTTPError => e
+          raise SOAP::LCError, "Can't open '#{uri}' : #{e.message}"
+        end
+
+        # Parse WSDL content
+        @document = REXML::Document.new( source )
+        
+        processAttributes @document.root.attributes
+        processContent @document.root.children
+      end
+      
+      private
+      def processAttributes( attributes )
+        @targetNamespace = attributes["targetNamespace"]
+        attributes.values.each{ |attribute|
+          if attribute.prefix == "xmlns" then
+            @prefixes[attribute.name] = attribute.value
+          end
+        }
+        if(default_namespace = attributes["xmlns"]) then
+          @prefixes["__default__"] = default_namespace
+        end
+      end
+      
+      def processContent( elements )
+        elements.find_all {|e| e.class == REXML::Element }.each { |element| 
+          case element.name
+            when "types"
+              processTypes( element )
+            when "message"
+              processMessage( element )
+            when "portType" 
+              processPortType( element )
+            when "binding"
+              processBinding( element )
+            when "service"
+              processService( element )
+            else
+              warn "Ignoring #{element}"
+          end
+        }
+      end
+      
+      def processTypes( element )
+        @types.add_schema( element )
+      end
+      
+      def processMessage( element )
+        name = element.attributes['name']
+        @messages[name] = SOAP::WSDL::Message.new( element )
+      end
+      
+      def processPortType( element )
+        name = element.attributes['name']
+        @portTypes[name] = SOAP::WSDL::PortType.new( element )
+      end
+      
+      def processBinding( element )
+        name = element.attributes['name']
+        @bindings[name] = SOAP::WSDL::Binding.new( element )
+      end
+      
+      def processService( element )
+        name = element.attributes['name']
+        @services[name] = SOAP::WSDL::Service.new( element )
+      end
+    end
+  end
+end