soap-lc 0.0.1 → 0.0.2

data/lib/soap/lc/response.rb

@@ -1,5 +1,5 @@
-require 'rubygems'
-require 'active_support'
+require 'rexml/document'
+require 'soap/lc/error'
 
 module SOAP
   class Response
@@ -9,13 +9,34 @@ module SOAP
     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] ) 
+        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]]
+      @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
@@ -23,8 +44,25 @@ module SOAP
       @soap_response.error!
     end
     
-    def method_missing( id, *args ) #:nodoc:
-      puts id.id2name
+    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 |_, 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 )
+              # **************************** TODO ************************************
+            else
+              # **************************** TODO ************************************
+            end
+          else
+        end
+      end      
     end
     
   end

data/lib/soap/lc/version.rb

@@ -0,0 +1,5 @@
+module SOAP
+  class LC
+    SOAP::LC::VERSION = "0.0.2"
+  end
+end

data/lib/soap/lc/wsdl.rb

@@ -5,8 +5,9 @@ module SOAP
   class WSDL
     attr_reader :parse
     
-    def initialize( uri ) #:nodoc:
+    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
@@ -16,7 +17,7 @@ module SOAP
     #   request = wsdl.myMethod( :param1 => "hello" )
     #     # => #<SOAP::Request:0xNNNNNN>
     def method_missing( id, *args ) 
-      return request.call( id.id2name, args[0] )
+      return request( @binding ).call( id.id2name, args[0] )
     end
     
     # Call a method for the current WSDL and get the corresponding SOAP::Request
@@ -25,8 +26,8 @@ module SOAP
     #   wsdl = SOAP::LC.new( ).wsdl( "http://..." )
     #   request = wsdl.call( "myMethod", { :param1 => "hello" } )
     #     # => #<SOAP::Request:0xNNNNNN>
-    def call( name, args )
-      return request.call( name, args )
+    def call( name, args = {} )
+      return request( @binding ).call( name, args )
     end
     
     # Get a SOAP::Request object for the current WSDL
@@ -35,8 +36,8 @@ module SOAP
     #   wsdl = SOAP::LC.new( ).wsdl( "http://..." )
     #   request = wsdl.request( )
     #     # => #<SOAP::Request:0xNNNNNN>
-    def request( )
-      return SOAP::Request.new( @parse )
+    def request( binding = nil )
+      return SOAP::Request.new( @parse, binding )
     end
   end      
 end

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

@@ -1,11 +1,16 @@
 module SOAP
   class WSDL
     class Bindings < Hash
-      def getBindingForOperationName( name )
-        self.each do |binding_name, binding|
-          return binding if binding.operations.keys.include?(name)
+      def getBindingForOperationName( binding, name )
+        r = []
+        if binding.nil?        
+          self.each do |binding_name, binding|
+            r << binding if binding.operations.keys.include?(name)
+          end
+        else
+          r << self[binding] if self[binding].operations.keys.include?(name)
         end
-        return nil
+        return r
       end
     end
     
@@ -61,6 +66,8 @@ module SOAP
                       case name
                         when 'soapAction'
                           @operations[operation.attributes['name']][:soapAction] = value
+                        when 'style'
+                          @operations[operation.attributes['name']][:style] = value
                         else
                           warn "Ignoring attribut `#{name}' for wsdlsoap:operation in operation `#{operation.attributes['name']}' in binding `#{element.attributes['name']}'"
                       end

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

@@ -1,5 +1,3 @@
-require 'soap/lc/error'
-
 module SOAP
   class WSDL
     class Messages < Hash

data/lib/soap/lc/xsd.rb

@@ -1,3 +1,14 @@
+require 'soap/lc/error'
+require 'soap/lc/core_ext'
+
+require 'soap/lc/xsd/complextype'
+require 'soap/lc/xsd/convert'
+require 'soap/lc/xsd/element'
+require 'soap/lc/xsd/enumeration'
+require 'soap/lc/xsd/restriction'
+require 'soap/lc/xsd/sequence'
+require 'soap/lc/xsd/simpletype'
+
 module SOAP
   class XSD
     attr_reader :elements
@@ -77,442 +88,5 @@ module SOAP
           warn "Ignoring type `#{type.name}'"
       end
     end
-        
-    class Restriction < Hash
-      def initialize( content )
-        content.attributes.each { |name, value| 
-          self[name.to_sym] = value
-        }
-        content.find_all{ |e| e.class == REXML::Element }.each { |restrictions|
-          case restrictions.name
-            when "annotation"
-              ###############################################################################
-              warn "xsd:annotation in xsd:restriction is not yet supported!"
-              ###############################################################################
-            when "fractionDigits"
-              ###############################################################################
-              warn "xsd:fractionDigits in xsd:restriction is not yet supported!"
-              ###############################################################################
-            when "enumeration"
-              self[:enumeration] = SOAP::XSD::Enumeration.new unless self.has_key?( :enumeration )
-              self[:enumeration] << restrictions.attributes['value']
-            when "length"
-              ###############################################################################
-              warn "xsd:length in xsd:restriction is not yet supported!"
-              ###############################################################################
-            when "maxExclusive"
-              ###############################################################################
-              warn "xsd:maxExclusive in xsd:restriction is not yet supported!"
-              ###############################################################################
-            when "maxInclusive"
-              ###############################################################################
-              warn "xsd:maxInclusive in xsd:restriction is not yet supported!"
-              ###############################################################################
-            when "maxLength"
-              ###############################################################################
-              warn "xsd:maxLength in xsd:restriction is not yet supported!"
-              ###############################################################################
-            when "minExclusive"
-              ###############################################################################
-              warn "xsd:minExclusive in xsd:restriction is not yet supported!"
-              ###############################################################################
-            when "minInclusive"
-              ###############################################################################
-              warn "xsd:minInclusive in xsd:restriction is not yet supported!"
-              ###############################################################################
-            when "minLength"
-              ###############################################################################
-              warn "xsd:minLength in xsd:restriction is not yet supported!"
-              ###############################################################################
-            when "pattern"
-              ###############################################################################
-              warn "xsd:pattern in xsd:restriction is not yet supported!"
-              ###############################################################################
-            when "simpleType"
-              ###############################################################################
-              warn "xsd:simpleType in xsd:restriction is not yet supported!"
-              ###############################################################################
-            when "totalDigits"
-              ###############################################################################
-              warn "xsd:totalDigits in xsd:restriction is not yet supported!"
-              ###############################################################################
-            when "whiteSpace"
-              ###############################################################################
-              warn "xsd:whiteSpace in xsd:restriction is not yet supported!"
-              ###############################################################################
-            else
-              warn "Ignoring `#{restrictions.name}' in xsd:restriction for xsd:simpleType `#{type.attributes['name']}'"
-          end
-        }
-      end
-    end
-
-    class Enumeration < Array
-    end
-        
-    class Sequence < Hash
-      def initialize( type )
-        type.attributes.each { |name, value|
-          self[name.to_sym] = value
-        }
-        
-        type.find_all{ |e| e.class == REXML::Element }.each { |content|
-          case content.name
-            when "annotation"
-              ###############################################################################
-              warn "xsd:annotation in xsd:sequence is not yet supported!"
-              ###############################################################################
-            when "element"
-              raise SOAP::LCElementError, "Malformated sequence" unless self[:type].nil? or self[:type] = :element
-              if self[:type].nil?
-                self[:type] = :element
-                self[:element] = Array.new
-              end
-              self[:element] << SOAP::XSD::Element.new( content )
-            when "choice"
-              raise SOAP::LCElementError, "Malformated sequence" unless self[:type].nil? or self[:type] = :choice
-              self[:type] = :choice
-              ###############################################################################
-              warn "xsd:choice in xsd:sequence is not yet supported!"
-              ###############################################################################              
-            when "group"
-              raise SOAP::LCElementError, "Malformated sequence" unless self[:type].nil? or self[:type] = :group
-              self[:type] = :group
-              ###############################################################################
-              warn "xsd:group in xsd:sequence is not yet supported!"
-              ###############################################################################              
-            when "sequence"
-              raise SOAP::LCElementError, "Malformated sequence" unless self[:type].nil? or self[:type] = :sequence
-              self[:type] = :sequence
-              ###############################################################################
-              warn "xsd:sequence in xsd:sequence is not yet supported!"
-              ###############################################################################              
-            when "any"
-              raise SOAP::LCElementError, "Malformated sequence" unless self[:type].nil? or self[:type] = :any
-              self[:type] = :any
-              ###############################################################################
-              warn "xsd:any in xsd:sequence is not yet supported!"
-              ###############################################################################              
-            else
-              raise SOAP::LCElementError, "Invalid element `#{content.name}' in xsd:sequence"
-          end
-        }
-      end
-      
-      def display( types, args )
-        r = ""
-        
-        case self[:type]
-          when :element
-            self[:element].each { |element|
-              r << element.display( types, args )
-            }
-          when :choice
-            ###############################################################################
-            warn "xsd:choice in xsd:sequence is not yet supported!"
-            ###############################################################################              
-          when :group
-            ###############################################################################
-            warn "xsd:group in xsd:sequence is not yet supported!"
-            ###############################################################################              
-          when :sequence
-            ###############################################################################
-            warn "xsd:sequence in xsd:sequence is not yet supported!"
-            ###############################################################################              
-          when :any
-            ###############################################################################
-            warn "xsd:any in xsd:sequence is not yet supported!"
-            ###############################################################################              
-          else
-            raise SOAP::LCWSDLError, "Malformated sequence `#{self[:name]}'"
-        end
-      
-        return r
-      end
-    end
-    
-    class SimpleType < Hash
-      def initialize( type )
-        type.attributes.each { |name, value|
-          self[name.to_sym] = value
-        }
-        
-        type.find_all{ |e| e.class == REXML::Element }.each { |content|
-          case content.name
-            when "list"
-              raise SOAP::LCElementError, "Malformated simpleType `#{type.attributes['name']}'" unless self[:type].nil?
-              self[:type] = :list
-              self[:list] = nil
-              ###############################################################################
-              warn "xsd:list in xsd:simpleType is not yet supported!"
-              ###############################################################################
-            when "union"
-              raise SOAP::LCElementError, "Malformated simpleType `#{type.attributes['name']}'" unless self[:type].nil?
-              self[:type] = :union
-              self[:union] = nil
-              ###############################################################################
-              warn "xsd:union in xsd:simpleType is not yet supported!"
-              ###############################################################################
-            when "restriction"
-              raise SOAP::LCElementError, "Malformated simpleType `#{type.attributes['name']}'" unless self[:type].nil?
-              self[:type] = :restriction
-              self[:restriction] = SOAP::XSD::Restriction.new( content )
-            when "annotation"
-              ###############################################################################
-              warn "xsd:annotation in xsd:simpleType is not yet supported!"
-              ###############################################################################            
-            else
-              raise SOAP::LCElementError, "Invalid element `#{content.name}' in xsd:simpleType `#{type.attributes['name']}'"
-          end
-        }
-      end
-      
-      def display( types, args )
-        r = ""
-
-        case self[:type]
-          when :restriction
-            # TODO ########################################################################
-            # TODO ########################################################################
-            # TODO ########################################################################
-            # TODO ########################################################################              
-          when :list
-            ###############################################################################
-            warn "xsd:list in xsd:simpleType is not yet supported!"
-            ###############################################################################
-          when :union
-            ###############################################################################
-            warn "xsd:union in xsd:simpleType is not yet supported!"
-            ###############################################################################
-          else
-            raise SOAP::LCWSDLError, "Malformated simpleType `#{self[:name]}'"
-        end
-
-        return r
-      end
-      
-    end
-    
-    class ComplexType < Hash
-      def initialize( type )
-        type.attributes.each { |name, value|
-          self[name.to_sym] = value
-        }
-
-        type.find_all{ |e| e.class == REXML::Element }.each { |content|
-          case content.name
-            when "simpleContent"
-              raise SOAP::LCElementError, "Malformated complexType `#{type.attributes['name']}'" unless self[:type].nil?
-              self[:type] = :simpleContent
-              ###############################################################################
-              warn "xsd:simpleContent in xsd:complexType (global definition) is not yet supported!"
-              ###############################################################################
-            when "complexContent"
-              raise SOAP::LCElementError, "Malformated complexType `#{type.attributes['name']}'" unless self[:type].nil?
-              self[:type] = :complexContent
-              ###############################################################################
-              warn "xsd:complexContent in xsd:complexType (global definition) is not yet supported!"
-              ###############################################################################
-            when "group"
-              raise SOAP::LCElementError, "Malformated complexType `#{type.attributes['name']}'" unless self[:type].nil?
-              self[:type] = :group
-              ###############################################################################
-              warn "xsd:group in xsd:complexType (global definition) is not yet supported!"
-              ###############################################################################
-            when "all"
-              raise SOAP::LCElementError, "Malformated complexType `#{type.attributes['name']}'" unless self[:type].nil?
-              self[:type] = :all
-              ###############################################################################
-              warn "xsd:all in xsd:complexType (global definition) is not yet supported!"
-              ###############################################################################
-            when "choise"
-              raise SOAP::LCElementError, "Malformated complexType `#{type.attributes['name']}'" unless self[:type].nil?
-              self[:type] = :choise
-              ###############################################################################
-              warn "xsd:choise in xsd:complexType (global definition) is not yet supported!"
-              ###############################################################################
-            when "sequence"
-              raise SOAP::LCElementError, "Malformated complexType `#{type.attributes['name']}'" unless self[:type].nil?
-              self[:type] = :sequence
-              self[:sequence] = SOAP::XSD::Sequence.new( content )
-            when "attribute"
-              raise SOAP::LCElementError, "Malformated complexType `#{type.attributes['name']}'" if (not(self[:attributes_type].nil?) and self[:attributes_type] != :attribute) or [:simpleContent, :complexContent].include?(self[:type])
-              self[:attributes_type] = :attribute
-              ###############################################################################
-              warn "xsd:attribute in xsd:complexType (global definition) is not yet supported!"
-              ###############################################################################
-            when "attributeGroup"
-              raise SOAP::LCElementError, "Malformated complexType `#{type.attributes['name']}'" if (not(self[:attributes_type].nil?) and self[:attributes_type] != :attributeGroup) or [:simpleContent, :complexContent].include?(self[:type])
-              self[:attributes_type] = :attributeGroup
-              ###############################################################################
-              warn "xsd:attributeGroup in xsd:complexType (global definition) is not yet supported!"
-              ###############################################################################
-            when "anyAttribute"
-              raise SOAP::LCElementError, "Malformated complexType `#{type.attributes['name']}'" if not(self[:any_attributes].nil?) or [:simpleContent, :complexContent].include?(self[:type])
-              self[:any_attributes] = :anyAttribute
-              ###############################################################################
-              warn "xsd:anyAttribute in xsd:complexType (global definition) is not yet supported!"
-              ###############################################################################
-            when "annotation"
-              ###############################################################################
-              warn "xsd:annotation in xsd:complexType (global definition) (global definition) is not yet supported!"
-              ###############################################################################            
-            else
-              raise SOAP::LCElementError, "Invalid element `#{content.name}' in xsd:complexType `#{type.attributes['name']}'"
-          end
-        }
-      end
-      
-      def display( types, args )
-        r = ""
-        
-        case self[:type]
-          when :simpleContent
-            ###############################################################################
-            warn "xsd:simpleContent in xsd:complexType (global definition) is not yet supported!"
-            ###############################################################################
-          when :complexContent
-            ###############################################################################
-            warn "xsd:complexContent in xsd:complexType (global definition) is not yet supported!"
-            ###############################################################################
-          when :group
-            ###############################################################################
-            warn "xsd:group in xsd:complexType (global definition) is not yet supported!"
-            ###############################################################################
-          when :all
-            ###############################################################################
-            warn "xsd:all in xsd:complexType (global definition) is not yet supported!"
-            ###############################################################################
-          when :choise
-            ###############################################################################
-            warn "xsd:choise in xsd:complexType (global definition) is not yet supported!"
-            ###############################################################################
-          when :sequence
-            r << self[:sequence].display( types, args )
-          else
-            raise SOAP::LCWSDLError, "Malformated complexType `#{self[:name]}'"
-        end
-        
-        return r
-      end
-    end
-    
-    class Element < Hash
-      def initialize( type )
-        type.attributes.each { |name, value|
-          self[name.to_sym] = value
-        }
-        
-        type.find_all{ |e| e.class == REXML::Element }.each { |content|
-          case content.name
-            when "simpleType"
-              raise SOAP::LCElementError, "Malformated element `#{type.attributes['name']}'" unless self[:type].nil?
-              self[:type] = :simpleType
-              ###############################################################################
-              warn "xsd:simpleType in xsd:element is not yet supported!"
-              ###############################################################################
-            when "complexType"
-              raise SOAP::LCElementError, "Malformated element `#{type.attributes['name']}'" unless self[:type].nil?
-              self[:type] = :complexType
-              self[:complexType] = SOAP::XSD::ComplexType.new( content )
-            when "unique"
-              raise SOAP::LCElementError, "Malformated element `#{type.attributes['name']}'" unless self[:key].nil?
-              self[:key] = :unique
-              ###############################################################################
-              warn "xsd:unique in xsd:element is not yet supported!"
-              ###############################################################################
-            when "key"
-              raise SOAP::LCElementError, "Malformated element `#{type.attributes['name']}'" unless self[:key].nil?
-              self[:key] = :key
-              ###############################################################################
-              warn "xsd:unique in xsd:element is not yet supported!"
-              ###############################################################################
-            when "keyref"
-              raise SOAP::LCElementError, "Malformated element `#{type.attributes['name']}'" unless self[:key].nil?
-              self[:key] = :keyref
-              ###############################################################################
-              warn "xsd:unique in xsd:element is not yet supported!"
-              ###############################################################################
-            when "annotation"
-              ###############################################################################
-              warn "xsd:annotation in xsd:complexType (global definition) (global definition) is not yet supported!"
-              ###############################################################################            
-            else
-              raise SOAP::LCElementError, "Invalid element `#{content.name}' in xsd:element `#{type.attributes['name']}'"
-          end
-        }
-      end
-    
-      def display( types, args )
-        r = ""
-        
-        min, max = getOccures( args )
-        if SOAP::XSD::ANY_SIMPLE_TYPE.include?( self[:type].nns )
-          r << SOAP::XSD.displayBuiltinType( self[:name], args, min, max )
-        else
-          case types[self[:type].nns][:type]
-            when :simpleType
-              if args.keys.include?( self[:name].to_sym )
-                args[self[:name].to_sym] = [args[self[:name].to_sym]] unless args[self[:name].to_sym].class == Array
-                if args[self[:name].to_sym].size < min or args[self[:name].to_sym].size > max
-                  raise SOAP::LCArgumentError, "Wrong number or values for parameter `#{name}'"
-                end
-                args[self[:name].to_sym].each { |v|
-                  r << "<#{self[:name]}>"
-                  r << "#{v}" ############ CHECK !!!
-                  r << "</#{self[:name]}>\n"
-                }
-              elsif min > 0
-                raise SOAP::LCArgumentError, "Missing parameter `#{name}'" if min > 0
-              end
-            when :complexType
-              if args.keys.include?( self[:name].to_sym )
-                if args.keys.include?( self[:name].to_sym )
-                  args[self[:name].to_sym] = [args[self[:name].to_sym]] unless args[self[:name].to_sym].class == Array
-                  if args[self[:name].to_sym].size < min or args[self[:name].to_sym].size > max
-                    raise SOAP::LCArgumentError, "Wrong number or values for parameter `#{name}'"
-                  end
-                  args[self[:name].to_sym].each { |v|
-                    r << "<#{self[:name]}>"
-                    r << types[self[:type].nns][:value].display( types, v )
-                    r << "</#{self[:name]}>\n"
-                  }
-                elsif min > 0
-                  raise SOAP::LCArgumentError, "Missing parameter `#{name}'" if min > 0
-                end
-              else
-                r << "<#{self[:name]}>\n"
-                r << types[self[:type].nns][:value].display( types, args )
-                r << "</#{self[:name]}>\n"
-              end
-            else
-              raise SOAL::LCWSDLError, "Malformated element `#{self[:name]}'"
-          end          
-        end
-        
-        return r
-      end
-      
-      def getOccures( args )
-        element_min = self[:minOccurs].to_i || 1
-        element_max = self[:maxOccurs] || "1"
-        if element_max == "unbounded"
-          if args.keys.include?(self[:name].to_sym)
-            if args[self[:name].to_sym].class == Array
-              element_max = args[self[:name].to_sym].size
-            else
-              element_max = 1
-            end
-          else
-            element_max = 1
-          end
-        else
-          element_max = element_max.to_i
-        end
-
-        return( [element_min, element_max] )
-      end
-      
-    end
   end
 end