lolsoap 0.8.3 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a60c39b2f4f03c4308d6f8c9dbcfa2b33c67eba3
-  data.tar.gz: e46ab60e8fcd3048c379c08544329bffe051f58d
+SHA256:
+  metadata.gz: 7adc22f6b91f820d8f182293ede6bbfbde631dacd43e2cc3a0519f20d446ddc2
+  data.tar.gz: 2af9641360a9091eff4224690aa48fdef48c3b0a5a36da43e8bc5e18e91615f2
 SHA512:
-  metadata.gz: 099b596571f4f0d34bf41768e2819bcea1f5411457c6deb28d28090c6b480b571515bb87e8333cb411e47041fd2eaa7feacf73c12ba6ab43f446feda05b77965
-  data.tar.gz: 4ecf0b3962d57e6bf8e768e706414716df634633fc7f3ebbc3da1c0ea6df96eb86764ac1dba16c7acd891b2fac71e50d2a001b64d4920732c1882feac75d0b9e
+  metadata.gz: 66f69ccca6a132a97d91d2402ec25f57e47d93963fe13dfb9c82a7b5423b0add88d914a6ef1849bc5186b75358e79d5f407514485cc7adf62c8f3ca0f9812abc
+  data.tar.gz: 1b181fb487fab405e6fe29c9cedc2a3d39be008963531689a99dee50648efeebd1c1958bd7d80af4cd09326a72363e2bb0c3cfb1c459c63c338d7e9daa8826dc

data/.gitignore

@@ -19,6 +19,8 @@ pkg
 
 Gemfile.lock
 
+Dockerfile
+
 # Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore: 
 #
 # * Create a file at ~/.gitignore

data/README.md

@@ -120,6 +120,18 @@ Development sponsored by [Loco2](http://loco2.com/).
 
 ## Changelog ##
 
+### 0.11 ###
+
+* Use `frozen_string_literal` to improve speed/memory usage
+
+### 0.10 ###
+
+* Added support for using WSDL with abstract types in operation definitions
+
+### 0.9 ###
+
+* Support unqualified form for elements in a schema
+
 ### 0.8 ###
 
 * Use namespaces when looking up definitions

data/lib/lolsoap/builder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'lolsoap/wsdl'
 
 module LolSoap
@@ -68,7 +70,21 @@ module LolSoap
       sub_node = @node.document.create_element(name.to_s, *args)
       sub_node.namespace = @node.namespace_scopes.find { |n| n.prefix == prefix }
 
-      @node << sub_node
+      # Nokogiri doesn't currently allow to add a child element without a
+      # namespace to a parent with a namespace: the child inherits the parent's
+      # namespace.  It's a known issue:
+      # https://github.com/sparklemotion/nokogiri/issues/1469 Until it's fixed,
+      # we'll use this workaround: store the parent's namespace, set it to nil
+      # temporarily, add the child and re-add the original namespace to the
+      # parent.
+      if sub_node.namespace.nil?
+        parent_namespace = @node.namespace
+        @node.namespace = nil
+        @node << sub_node
+        @node.namespace = parent_namespace
+      else
+        @node << sub_node
+      end
 
       builder = __class__.new(sub_node, sub_type)
       yield builder if block_given?

data/lib/lolsoap/version.rb

@@ -1,3 +1,3 @@
 module LolSoap
-  VERSION = "0.8.3"
+  VERSION = "0.11.0"
 end

data/lib/lolsoap/wsdl.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'lolsoap/wsdl_parser'
 
 module LolSoap
@@ -13,8 +15,8 @@ module LolSoap
     require 'lolsoap/wsdl/operation_io_part'
 
     # Create a new instance by parsing a raw string of XML
-    def self.parse(raw)
-      new(WSDLParser.parse(raw))
+    def self.parse(raw, options={})
+      new(WSDLParser.parse(raw), options)
     end
 
     # The SOAP endpoint URL
@@ -29,13 +31,15 @@ module LolSoap
     # The version of SOAP detected.
     attr_reader :soap_version
 
-    def initialize(parser)
-      @prefixes     = generate_prefixes(parser)
-      @namespaces   = prefixes.invert
-      @types        = load_types(parser)
-      @operations   = load_operations(parser)
-      @endpoint     = parser.endpoint
+    def initialize(parser, options={})
+      @prefixes = generate_prefixes(parser)
+      @namespaces = prefixes.invert
+      @abstract_types = load_types(parser.abstract_types)
+      @types = load_types(parser.types)
+      @operations = load_operations(parser)
+      @endpoint = parser.endpoint
       @soap_version = parser.soap_version
+      @allow_abstract_types = options[:allow_abstract_types]
     end
 
     # Hash of types declared by the service
@@ -43,9 +47,23 @@ module LolSoap
       Hash[@types.values.map { |t| [t.name, t] }]
     end
 
+    # Hash of abstract types declared by the service
+    def abstract_types
+      Hash[@abstract_types.values.map { |t| [t.name, t] }]
+    end
+
     # Get a single type, or a NullType if the type doesn't exist
     def type(namespace, name)
-      @types.fetch([namespace, name]) { NullType.new }
+      if @allow_abstract_types
+        @types.fetch([namespace, name]) { abstract_type(namespace, name) }
+      else
+        @types.fetch([namespace, name]) { NullType.new }
+      end
+    end
+
+    # Get a single abstract type, or a NullType if the type doesn't exist
+    def abstract_type(namespace, name)
+      @abstract_types.fetch([namespace, name]) { NullType.new }
     end
 
     # Hash of operations that are supported by the SOAP service
@@ -73,9 +91,9 @@ module LolSoap
     private
 
     # @private
-    def load_types(parser)
+    def load_types(types)
       Hash[
-        parser.types.map do |id, type|
+        types.map do |id, type|
           [id, build_type(type)]
         end
       ]
@@ -135,7 +153,7 @@ module LolSoap
       Element.new(
         self,
         params[:name],
-        prefix(params[:namespace]),
+        params[:namespace] && prefix(params[:namespace]),
         type_reference(params[:type]),
         params[:singular]
       )

data/lib/lolsoap/wsdl_parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'nokogiri'
 require 'cgi'
 
@@ -6,25 +8,55 @@ module LolSoap
   class WSDLParser
     class ParseError < StandardError; end
 
+    class Schema < Struct.new(:target_namespace, :element_form_default)
+      UNQUALIFIED = 'unqualified'
+
+      def self.from_node(node)
+        new(
+          node.attr('targetNamespace').to_s,
+          node.attr('elementFormDefault')
+        )
+      end
+
+      def default_form
+        element_form_default || UNQUALIFIED
+      end
+    end
+
     class Node
-      attr_reader :parser, :node, :target_namespace, :name, :namespace
+      attr_reader :parser, :node, :schema, :name, :namespace
 
-      def initialize(parser, node, target_namespace)
-        @parser           = parser
-        @node             = node
-        @target_namespace = target_namespace
-        @namespace, @name = parser.namespace_and_name(node, node.attr('name').to_s, target_namespace)
+      def initialize(parser, schema, node)
+        @parser = parser
+        @node   = node
+        @schema = schema
       end
 
       def id
         [namespace, name]
       end
+
+      def target_namespace
+        schema.target_namespace
+      end
     end
 
     class Element < Node
+      QUALIFIED = 'qualified'
+
+      attr_reader :form
+
+      def initialize(*params)
+        super(*params)
+
+        @form = node.attr('form') || schema.default_form
+
+        @namespace, @name = parser.namespace_and_name(node, node.attr('name').to_s, default_namespace)
+      end
+
       def type
         if complex_type = node.at_xpath('xs:complexType', parser.ns)
-          type = Type.new(parser, complex_type, target_namespace)
+          type = Type.new(parser, schema, complex_type)
           {
             :elements   => type.elements,
             :namespace  => type.namespace,
@@ -39,6 +71,14 @@ module LolSoap
         max_occurs.empty? || max_occurs == '1'
       end
 
+      def qualified?
+        form == QUALIFIED
+      end
+
+      def default_namespace
+        target_namespace
+      end
+
       private
 
       def max_occurs
@@ -72,6 +112,12 @@ module LolSoap
     end
 
     class Type < Node
+      def initialize(*params)
+        super(*params)
+
+        @namespace, @name = parser.namespace_and_name(node, node.attr('name').to_s, target_namespace)
+      end
+
       def elements
         parent_elements.merge(own_elements)
       end
@@ -108,7 +154,8 @@ module LolSoap
 
       def element_nodes
         node.xpath('*/xs:element | */*/xs:element | xs:complexContent/xs:extension/*/xs:element | xs:complexContent/xs:extension/*/*/xs:element', parser.ns).map { |el|
-          element = Element.new(parser, el, target_namespace)
+          element = TypeElement.new(parser, schema, el)
+
           if reference = el.attribute('ref')
             ReferencedElement.new(element, parser.element(*parser.namespace_and_name(el, reference.to_s)))
           else
@@ -140,6 +187,12 @@ module LolSoap
       end
     end
 
+    class TypeElement < Element
+      def default_namespace
+        target_namespace if qualified?
+      end
+    end
+
     class AttributeGroup < Node
       def attributes
         own_attributes + referenced_attributes
@@ -254,14 +307,20 @@ module LolSoap
     def types
       @types ||= begin
         types = {}
-        each_node('xs:complexType[not(@abstract="true")]') do |node, target_ns|
-          type = Type.new(self, node, target_ns)
-          types[type.id] = {
-            :name       => type.name,
-            :namespace  => type.namespace,
-            :elements   => type.elements,
-            :attributes => type.attributes
-          }
+        each_node('xs:complexType[not(@abstract="true")]') do |node, schema|
+          type = Type.new(self, schema, node)
+          types[type.id] = type_record(type)
+        end
+        types
+      end
+    end
+
+    def abstract_types
+      @abstract_types ||= begin
+        types = {}
+        each_node('xs:complexType[@abstract="true"]') do |node, schema|
+          type = Type.new(self, schema, node)
+          types[type.id] = type_record(type)
         end
         types
       end
@@ -274,8 +333,8 @@ module LolSoap
     def elements
       @elements ||= begin
         elements = {}
-        each_node('xs:element') do |node, target_ns|
-          element = Element.new(self, node, target_ns)
+        each_node('xs:element') do |node, schema|
+          element = Element.new(self, schema, node)
           elements[element.id] = {
             :name      => element.name,
             :namespace => element.namespace,
@@ -378,11 +437,10 @@ module LolSoap
     end
 
     def each_node(xpath)
-      schemas.each do |schema|
-        target_namespace = schema.attr('targetNamespace').to_s
-
-        schema.xpath(xpath, ns).each do |node|
-          yield node, target_namespace
+      schemas.each do |schema_node|
+        schema = Schema.from_node(schema_node)
+        schema_node.xpath(xpath, ns).each do |node|
+          yield node, schema
         end
       end
     end
@@ -392,9 +450,19 @@ module LolSoap
       target = schemas if target.size == 0
 
       if node = target.at_xpath("xs:#{selector}[@name='#{name.split(':').last}']", ns)
-        target_namespace = node.at_xpath('parent::xs:schema/@targetNamespace', ns).to_s
-        node_class.new(self, node, target_namespace)
+        schema = Schema.from_node(node.at_xpath('parent::xs:schema', ns))
+        node_class.new(self, schema, node)
       end
     end
+
+    private
+    def type_record(type)
+      {
+        :name       => type.name,
+        :namespace  => type.namespace,
+        :elements   => type.elements,
+        :attributes => type.attributes
+      }
+    end
   end
 end

data/lolsoap.gemspec

@@ -19,8 +19,8 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'nokogiri', '~> 1.5'
 
-  spec.add_development_dependency "bundler", "~> 1.7"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 12.3"
   spec.add_development_dependency "minitest", "~> 2.10.0"
   spec.add_development_dependency "yard"
 end

data/test/fixtures/stock_quote.wsdl

@@ -12,7 +12,8 @@
   <types>
     <schema targetNamespace="http://example.com/stockquote.xsd"
             xmlns:xsd3="http://example.com/stockquote.xsd"
-            xmlns="http://www.w3.org/2001/XMLSchema">
+            xmlns="http://www.w3.org/2001/XMLSchema"
+            elementFormDefault="qualified">
       <attributeGroup name="BaseRequestAttributes">
         <attribute name="signature" type="xs:string"/>
       </attributeGroup>

data/test/integration/test_envelope.rb

@@ -28,7 +28,7 @@ module LolSoap
       el.wont_equal nil
       el.text.to_s.must_equal 'LOCO2'
 
-      el = doc.at_xpath('//ns0:tradePriceRequest/ns0:specialTickerSymbol/ns1:name', doc.namespaces)
+      el = doc.at_xpath('//ns0:tradePriceRequest/ns0:specialTickerSymbol/name', doc.namespaces)
       el.wont_equal nil
       el.text.to_s.must_equal 'LOCOLOCOLOCO'
 

data/test/integration/test_wsdl.rb

@@ -28,6 +28,11 @@ module LolSoap
         o.input.body.content.name.must_equal 'historicalPriceRequest'
       end
 
+      subject.abstract_types.length.must_equal 1
+      subject.abstract_types.fetch('BaseRequest').tap do |t|
+        t.prefix.must_equal 'ns0'
+      end
+
       subject.types.length.must_equal 4
       subject.types.fetch('TradePriceRequest').tap do |t|
         t.prefix.must_equal 'ns0'

data/test/unit/test_builder.rb

@@ -35,6 +35,7 @@ module LolSoap
 
       doc.expect(:create_element, sub_node, args)
       sub_node.expect(:namespace=, nil, [namespace])
+      sub_node.expect(:namespace, namespace)
       node.children.expect(:<<, nil, [sub_node])
 
       yield sub_node

data/test/unit/test_wsdl.rb

@@ -59,8 +59,16 @@ module LolSoap
               :attributes => ['id'],
               :namespace  => namespace
             }
-         },
-         :elements => {
+          },
+          :abstract_types => {
+            [namespace, 'BaseBrush'] => {
+              :name => 'BaseBrush',
+              :elements => {},
+              :attributes => ['id'],
+              :namespace  => namespace
+            },
+          },
+          :elements => {
             [namespace, 'brush'] => {
               :name      => 'brush',
               :namespace => namespace,
@@ -172,6 +180,16 @@ module LolSoap
         end
       end
 
+      describe '#abstract_types' do
+        it 'returns a hash of abstract types' do
+          subject.abstract_types.length.must_equal 1
+
+          subject.abstract_types['BaseBrush'].tap do |t|
+            t.attributes.must_equal ['id']
+          end
+        end
+      end
+
       describe '#type' do
         it 'returns a single type' do
           subject.type(namespace, 'Brush').must_equal subject.types.fetch('Brush')
@@ -180,6 +198,28 @@ module LolSoap
         it 'returns a null object if a type is missing' do
           subject.type(namespace, 'FooBar').must_equal WSDL::NullType.new
         end
+
+        it 'returns a null object for abstract types' do
+          subject.type(namespace, 'BaseBrush').must_equal WSDL::NullType.new
+        end
+
+        describe 'when abstract types are allowed' do
+          subject { WSDL.new(parser, :allow_abstract_types => true) }
+
+          it 'returns an abstract type' do
+            subject.type(namespace, 'BaseBrush').must_equal subject.abstract_types.fetch('BaseBrush')
+          end
+        end
+      end
+
+      describe '#abstract_type' do
+        it 'returns a single type' do
+          subject.abstract_type(namespace, 'BaseBrush').must_equal subject.abstract_types.fetch('BaseBrush')
+        end
+
+        it 'returns a null object if a type is missing' do
+          subject.abstract_type(namespace, 'FooBar').must_equal WSDL::NullType.new
+        end
       end
     end
   end

data/test/unit/test_wsdl_parser.rb

@@ -96,7 +96,7 @@ module LolSoap
             :elements  => {
               'name' => {
                 :name      => 'name',
-                :namespace => namespace2,
+                :namespace => nil,
                 :type      => [xs, "string"],
                 :singular  => true
               }
@@ -107,6 +107,26 @@ module LolSoap
       end
     end
 
+    describe "#abstract_types" do
+      it 'returns the abstract types, with attributes and namespace' do
+        subject.abstract_types.must_equal({
+          [namespace, "BaseRequest"] => {
+            :name => "BaseRequest",
+            :namespace => "http://example.com/stockquote.xsd",
+            :elements => {
+              "accountId" => {
+                :name => "accountId",
+                :namespace => "http://example.com/stockquote.xsd",
+                :type => [xs, "string"],
+                :singular=>true
+              }
+            },
+            :attributes=>["signature"]
+          },
+        })
+      end
+    end
+
     describe '#elements' do
       it 'returns the elements with inline types' do
         subject.elements.must_equal({

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lolsoap
 version: !ruby/object:Gem::Version
-  version: 0.8.3
+  version: 0.11.0
 platform: ruby
 authors:
 - Jon Leighton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-13 00:00:00.000000000 Z
+date: 2022-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -30,28 +30,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.3'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -156,8 +156,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: A library for dealing with SOAP requests and responses.
@@ -183,4 +182,3 @@ test_files:
 - test/unit/test_wsdl_parser.rb
 - test/unit/wsdl/test_element.rb
 - test/unit/wsdl/test_type.rb
-has_rdoc: