soap-lc 0.0.1 → 0.0.2

data/lib/soap/lc/xsd/complextype.rb

@@ -0,0 +1,136 @@
+module SOAP
+  class XSD
+    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
+    
+      def responseToHash( xml, types )
+        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].responseToHash( xml, types )
+        end
+        return r
+      end
+    end
+  end
+end

data/lib/soap/lc/xsd/convert.rb

@@ -0,0 +1,107 @@
+module SOAP
+  class XSD
+    class Convert
+      
+      def self.to_ruby( t, v )
+        new().c( t.gsub( /.*:/, "xsd_" ), v )
+      end
+      
+      def c( t, v )
+        self.method( t ).call( v )
+      end
+      
+      def xsd_int( x )
+        x.to_i
+      end
+      alias_method :xsd_long, :xsd_int
+      alias_method :xsd_integer, :xsd_int
+      
+      def xsd_float( x )
+        x.to_f
+      end
+      alias_method :xsd_double, :xsd_float
+      alias_method :xsd_decimal, :xsd_float
+      
+      def xsd_string( x )
+        x
+      end
+      alias_method :xsd_normalizedString, :xsd_string
+      
+      def xsd_boolean( x )
+        (x == "true")
+      end
+      
+      def xsd_duration( x )
+      end 
+      def xsd_dateTime( x )
+      end
+      def xsd_time( x )
+      end 
+      def xsd_date( x )
+      end
+      def xsd_gYearMonth( x )
+      end
+      def xsd_gYear( x )
+      end
+      def xsd_gMonthDay( x )
+      end
+      def xsd_gDay( x )
+      end
+      def xsd_gMonth( x )
+      end
+      def xsd_base64Binary( x )
+      end
+      def xsd_hexBinary( x )
+      end
+      def xsd_anyURI( x )
+      end
+      def xsd_QName( x )
+      end
+      def xsd_NOTATION( x )
+      end
+      def xsd_token( x )
+      end
+      def xsd_language( x )
+      end
+      def xsd_Name( x )
+      end
+      def xsd_NMTOKEN( x )
+      end
+      def xsd_NCName( x )
+      end
+      def xsd_NMTOKENS( x )
+      end
+      def xsd_ID( x )
+      end
+      def xsd_IDREF( x )
+      end
+      def xsd_ENTITY( x )
+      end
+      def xsd_IDREFS( x )
+      end
+      def xsd_ENTITIES( x )
+      end
+      def xsd_nonPositiveInteger( x )
+      end
+      def xsd_nonNegativeInteger( x )
+      end
+      def xsd_negativeInteger( x )
+      end
+      def xsd_unsignedLong( x )
+      end
+      def xsd_positiveInteger( x )
+      end
+      def xsd_short( x )
+      end
+      def xsd_unsignedInt( x )
+      end
+      def xsd_byte( x )
+      end
+      def xsd_unsignedShort( x )
+      end
+      def xsd_unsignedByte( x )
+      end
+    end
+  end
+end
+    

data/lib/soap/lc/xsd/element.rb

@@ -0,0 +1,167 @@
+module SOAP
+  class XSD
+    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
+      
+      def responseToHash( xml, types )
+        r = {}
+
+        if SOAP::XSD::ANY_SIMPLE_TYPE.include?( self[:type].to_s.nns )
+          xml.each { |e| 
+            if e.name == self[:name]
+              r[self[:name]] = SOAP::XSD::Convert.to_ruby( self[:type].to_s, e.text )
+            end
+          }
+        else
+          case self[:type]
+            when :simpleType
+              # **************************** TODO ************************************
+            when :complexType
+              # **************************** TO VERIFY ************************************
+              r = self[:complexType].responseToHash( xml, types )
+            else
+              xml.each { |e| 
+                if e.name == self[:name]
+                  case types[self[:type].to_s.nns][:type]
+                    when :simpleType
+                      if r.keys.include?(self[:name])
+                        unless r[self[:name]].class == Array
+                          r[self[:name]] = [r[self[:name]]]
+                        end
+                        r[self[:name]] << types[self[:type].to_s.nns][:value].responseToHash( e.text, types )
+                      else
+                        r[self[:name]] = types[self[:type].to_s.nns][:value].responseToHash( e.text, types )
+                      end
+                    else
+                      if r.keys.include?(self[:name])
+                        unless r[self[:name]].class == Array
+                          r[self[:name]] = [r[self[:name]]]
+                        end
+                        r[self[:name]] << types[self[:type].to_s.nns][:value].responseToHash( e, types )
+                      else
+                        r[self[:name]] = types[self[:type].to_s.nns][:value].responseToHash( e, types )
+                      end
+                  end
+                end
+              }
+          end
+        end
+        
+        return r
+      end
+    end
+  end
+end

data/lib/soap/lc/xsd/enumeration.rb

@@ -0,0 +1,6 @@
+module SOAP
+  class XSD
+    class Enumeration < Array
+    end
+  end
+end

data/lib/soap/lc/xsd/restriction.rb

@@ -0,0 +1,76 @@
+module SOAP
+  class XSD
+    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
+    
+      def responseToHash( xml, types )
+        SOAP::XSD::Convert.to_ruby( self[:base].to_s, xml )
+      end
+    end
+  end
+end