sekken 0.1.0

data/lib/sekken/xs/schema.rb

@@ -0,0 +1,57 @@
+require 'sekken/xs/types'
+
+class Sekken
+  class XS
+    class Schema
+
+      def initialize(schema, schemas)
+        @schema = schema
+        @schemas = schemas
+
+        @target_namespace     = @schema['targetNamespace']
+        @element_form_default = @schema['elementFormDefault'] || 'unqualified'
+
+        @attributes       = {}
+        @attribute_groups = {}
+        @elements         = {}
+        @complex_types    = {}
+        @simple_types     = {}
+        @imports          = {}
+
+        parse
+      end
+
+      attr_accessor :target_namespace, :element_form_default, :imports,
+                    :attributes, :attribute_groups, :elements, :complex_types, :simple_types
+
+      private
+
+      def parse
+        schema = {
+          :target_namespace => @target_namespace,
+          :element_form_default => @element_form_default
+        }
+
+        @schema.element_children.each do |node|
+          case node.name
+          when 'attribute'      then store_element(@attributes, node, schema)
+          when 'attributeGroup' then store_element(@attribute_groups, node, schema)
+          when 'element'        then store_element(@elements, node, schema)
+          when 'complexType'    then store_element(@complex_types, node, schema)
+          when 'simpleType'     then store_element(@simple_types, node, schema)
+          when 'import'         then store_import(node)
+          end
+        end
+      end
+
+      def store_element(collection, node, schema)
+        collection[node['name']] = XS.build(node, @schemas, schema)
+      end
+
+      def store_import(node)
+        @imports[node['namespace']] = node['schemaLocation']
+      end
+
+    end
+  end
+end

data/lib/sekken/xs/schema_collection.rb

@@ -0,0 +1,49 @@
+class Sekken
+  class XS
+    class SchemaCollection
+      include Enumerable
+
+      def initialize
+        @schemas = []
+      end
+
+      def <<(schema)
+        @schemas << schema
+      end
+
+      def push(schemas)
+        @schemas += schemas
+      end
+
+      def each(&block)
+        @schemas.each(&block)
+      end
+
+      def attribute(namespace, name)
+        find_by_namespace(namespace).attributes[name]
+      end
+
+      def attribute_group(namespace, name)
+        find_by_namespace(namespace).attribute_groups[name]
+      end
+
+      def element(namespace, name)
+        find_by_namespace(namespace).elements[name]
+      end
+
+      def complex_type(namespace, name)
+        find_by_namespace(namespace).complex_types[name]
+      end
+
+      def simple_type(namespace, name)
+        find_by_namespace(namespace).simple_types[name]
+      end
+
+      # TODO: store by namespace instead?
+      def find_by_namespace(namespace)
+        find { |schema| schema.target_namespace == namespace }
+      end
+
+    end
+  end
+end

data/lib/sekken/xs/types.rb

@@ -0,0 +1,272 @@
+class Sekken
+  class XS
+
+    class BaseType
+
+      def initialize(node, schemas, schema = {})
+        @node = node
+        @schemas = schemas
+        @schema = schema
+      end
+
+      attr_reader :node
+
+      def [](key)
+        @node[key]
+      end
+
+      def empty?
+        children.empty? || children.first.empty?
+      end
+
+      def children
+        @children ||= @node.element_children.map { |child| XS.build(child, @schemas, @schema) }
+      end
+
+      def collect_child_elements(memo = [])
+        children.each do |child|
+          if child.kind_of? Element
+            memo << child
+          else
+            memo = child.collect_child_elements(memo)
+          end
+        end
+
+        memo
+      end
+
+      def collect_attributes(memo = [])
+        children.each do |child|
+          if child.kind_of? Attribute
+            memo << child
+          else
+            memo = child.collect_attributes(memo)
+          end
+        end
+
+        memo
+      end
+
+      def inspect
+        attributes = @node.attributes.
+          inject({}) { |memo, (k, attr)| memo[k.to_s] = attr.value; memo }.
+          map { |i| "%s=\"%s\"" % i }.
+          join(' ')
+        "<%s %s>" % [self.class, attributes]
+      end
+
+    end
+
+    class PrimaryType < BaseType
+
+      def initialize(node, schemas, schema = {})
+        super
+
+        @namespace = schema[:target_namespace]
+        @element_form_default = schema[:element_form_default]
+
+        @name = node['name']
+        # Because you've overriden the form method, you don't need to set
+        # unqualified as the default when no form is specified.
+        #@form = node['form'] || 'unqualified'
+        @form = node['form']
+
+        @namespaces = node.namespaces
+      end
+
+      attr_reader :name, :form, :namespace, :namespaces
+
+      def form
+        if @form
+            @form
+        elsif @element_form_default == 'qualified'
+          'qualified'
+        else
+          'unqualified'
+        end
+      end
+
+    end
+
+    class SimpleType < PrimaryType
+
+      def base
+        child = @node.element_children.first
+        local = child.name.split(':').last
+
+        child['base'] if local == 'restriction'
+      end
+
+    end
+
+    class Element < PrimaryType
+
+      def initialize(node, schemas, schema = {})
+        super
+
+        @type = node['type']
+        @ref  = node['ref']
+      end
+
+      attr_reader :type, :ref
+
+      def inline_type
+        children.first
+      end
+
+    end
+
+    class ComplexType < PrimaryType
+
+      alias_method :elements, :collect_child_elements
+      alias_method :attributes, :collect_attributes
+
+      def id
+        [namespace, name].join(':')
+      end
+
+    end
+
+    class Extension < BaseType
+
+      def collect_child_elements(memo = [])
+        if @node['base']
+          local, nsid = @node['base'].split(':').reverse
+          namespace = @node.namespaces["xmlns:#{nsid}"]
+
+          if complex_type = @schemas.complex_type(namespace, local)
+            memo += complex_type.elements
+
+          # TODO: can we find a testcase for this?
+          else #if simple_type = @schemas.simple_type(namespace, local)
+            raise 'simple type extension?!'
+            #memo << simple_type
+          end
+        end
+
+        super
+      end
+
+    end
+
+    class AnyType        < BaseType; end
+    class ComplexContent < BaseType; end
+    class Restriction    < BaseType; end
+    class All            < BaseType; end
+    class Sequence       < BaseType; end
+    class Choice         < BaseType; end
+    class Enumeration    < BaseType; end
+
+    class Attribute < BaseType
+
+      def initialize(node, schemas, schema = {})
+        super
+
+        @name = node['name']
+        @type = node['type']
+        @ref  = node['ref']
+
+        @use     = node['use'] || 'optional'
+        @default = node['default']
+        @fixed   = node['fixed']
+
+        @namespaces = node.namespaces
+      end
+
+      attr_reader :name, :type, :ref, :namespaces,
+                  :use, :default, :fixed
+
+      def inline_type
+        children.first
+      end
+
+      # stop searching for child elements
+      def collect_child_elements(memo = [])
+        memo
+      end
+
+    end
+
+    class AttributeGroup < BaseType
+
+      alias_method :attributes, :collect_attributes
+
+      def collect_attributes(memo = [])
+        if @node['ref']
+          local, nsid = @node['ref'].split(':').reverse
+          namespace = @node.namespaces["xmlns:#{nsid}"]
+
+          attribute_group = @schemas.attribute_group(namespace, local)
+          memo += attribute_group.attributes
+        else
+          super
+        end
+      end
+    end
+
+    class SimpleContent < BaseType
+
+      # stop searching for attributes
+      def collect_attributes(memo = [])
+        memo
+      end
+
+      # stop searching for child elements
+      def collect_child_elements(memo = [])
+        memo
+      end
+
+    end
+
+    class Annotation < BaseType
+
+      # stop searching for attributes
+      def collect_attributes(memo = [])
+        memo
+      end
+
+      # stop searching for child elements
+      def collect_child_elements(memo = [])
+        memo
+      end
+
+    end
+
+    TYPE_MAPPING = {
+      'attribute'      => Attribute,
+      'attributeGroup' => AttributeGroup,
+      'element'        => Element,
+      'complexType'    => ComplexType,
+      'simpleType'     => SimpleType,
+      'simpleContent'  => SimpleContent,
+      'complexContent' => ComplexContent,
+      'extension'      => Extension,
+      'restriction'    => Restriction,
+      'all'            => All,
+      'sequence'       => Sequence,
+      'choice'         => Choice,
+      'enumeration'    => Enumeration,
+      'annotation'     => Annotation
+    }
+
+    def self.build(node, schemas, schema = {})
+      type_class(node).new(node, schemas, schema)
+    end
+
+    def self.type_class(node)
+      type = node.name.split(':').last
+
+      if TYPE_MAPPING.include? type
+        TYPE_MAPPING[type]
+      else
+        logger.debug("No type mapping for #{type.inspect}. ")
+        AnyType
+      end
+    end
+
+    def self.logger
+      @logger ||= Logging.logger[self]
+    end
+
+  end
+end

data/sekken.gemspec

@@ -0,0 +1,42 @@
+# -*- encoding : utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$:.unshift lib unless $:.include? lib
+
+require 'sekken/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'sekken'
+  s.version     = Sekken::VERSION
+  s.authors     = ['Daniel Harrington', 'Tim Jarratt']
+  s.email       = 'tjarratt@gmail.com'
+  s.homepage    = 'http://savonrb.com'
+  s.summary     = 'Next-Gen SOAP client'
+  s.description = 'Sekken is an experimental SOAP client for the Ruby community.'
+
+  s.rubyforge_project = s.name
+  s.license = 'MIT'
+
+  # TODO: get rid of Nori.
+  s.add_dependency 'nori',     '~> 2.2.0'
+
+  s.add_dependency 'nokogiri',   '>= 1.4.0'
+  s.add_dependency 'builder',    '>= 3.0.0'
+  s.add_dependency 'httpclient', '~> 2.3'
+  s.add_dependency 'logging',    '~> 1.8'
+
+  s.add_development_dependency 'rake',  '~> 10.1'
+  s.add_development_dependency 'rspec', '~> 2.14'
+  s.add_development_dependency 'mocha', '~> 0.14'
+  s.add_development_dependency 'equivalent-xml', '~> 0.3'
+
+  ignores  = File.readlines('.gitignore').grep(/\S+/).map(&:chomp)
+  dotfiles = %w[.gitignore .travis.yml .yardopts]
+
+  all_files_without_ignores = Dir['**/*'].reject { |f|
+    File.directory?(f) || ignores.any? { |i| File.fnmatch(i, f) }
+  }
+
+  s.files = (all_files_without_ignores + dotfiles).sort
+
+  s.require_path = 'lib'
+end

data/spec/fixtures/response/another_soap_fault.xml

@@ -0,0 +1,14 @@
+<SOAP-ENV:Envelope SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
+  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:Body>
+    <SOAP-ENV:Fault>
+      <faultcode>ERR_NO_SESSION</faultcode>
+      <faultfactor>doGetItemsInfo - Wrong session</faultfactor>
+      <faultstring>Wrong session message</faultstring>
+      <detail><soapVal><ERRNO xsi:type="xsd:string">80:1289245853:55</ERRNO></soapVal></detail>
+    </SOAP-ENV:Fault>
+  </SOAP-ENV:Body>
+</SOAP-ENV:Envelope>

data/spec/fixtures/response/authentication.xml

@@ -0,0 +1,14 @@
+<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
+   <soap:Body>
+      <ns2:authenticateResponse xmlns:ns2="http://v1_0.ws.user.example.com">
+         <return>
+            <authenticationValue>
+              <token>a68d1d6379b62ff339a0e0c69ed4d9cf</token>
+              <tokenHash>AAAJxA;cIedoT;mY10ExZwG6JuKgp2OYKxow==</tokenHash>
+              <client>radclient</client>
+            </authenticationValue>
+            <success>true</success>
+         </return>
+      </ns2:authenticateResponse>
+   </soap:Body>
+</soap:Envelope>