wsdl 1.0.0 → 1.1.0

data/lib/wsdl/parser/binding_operation.rb

@@ -11,22 +11,28 @@ module WSDL
     # @api private
     #
     class BindingOperation
+      # Shared empty frozen array used as default for header node lists.
+      # @return [Array] empty frozen array
+      # @api private
+      EMPTY_NODES = [].freeze
+
       # Creates a new BindingOperation from a WSDL operation XML node.
       #
+      # Categorizes all child elements in a single pass to avoid repeated
+      # Nokogiri element_children traversals and node_name allocations.
+      #
       # @param operation_node [Nokogiri::XML::Node] the wsdl:operation element within a binding
       # @param defaults [Hash] default values inherited from the parent binding
       # @option defaults [String] :style the default operation style ('document' or 'rpc')
       def initialize(operation_node, defaults = {})
         @operation_node = operation_node
+        @has_input = false
+        @input_body_node = nil
+        @input_header_nodes = EMPTY_NODES
+        @output_body_node = nil
+        @output_header_nodes = EMPTY_NODES
 
-        if (soap_operation_node = find_soap_operation_node)
-          namespace = soap_operation_node.first
-          node = soap_operation_node.last
-
-          @soap_namespace = namespace
-          @soap_action = node['soapAction']
-          @style = node['style'] || defaults[:style]
-        end
+        categorize_children!(defaults)
       end
 
       # @return [String, nil] the SOAPAction HTTP header value
@@ -38,6 +44,12 @@ module WSDL
       # @return [String] the SOAP namespace URI (1.1 or 1.2)
       attr_reader :soap_namespace
 
+      # @return [String, nil] the name attribute of the input wrapper element
+      attr_reader :input_name
+
+      # @return [String, nil] the name attribute of the output wrapper element
+      attr_reader :output_name
+
       # Returns the name of this operation.
       #
       # @return [String] the operation name
@@ -45,6 +57,13 @@ module WSDL
         @operation_node['name']
       end
 
+      # Returns whether this binding operation has an input element.
+      #
+      # @return [Boolean] true if the binding operation defines an input
+      def input?
+        @has_input
+      end
+
       # Returns the input header definitions for this operation.
       #
       # Each header is represented as a Hash with keys:
@@ -56,10 +75,7 @@ module WSDL
       #
       # @return [Array<HeaderReference>] the input header references
       def input_headers
-        return @input_headers if @input_headers
-
-        header_nodes = find_input_child_nodes('header') || []
-        @input_headers = build_headers(header_nodes)
+        @input_headers ||= @input_header_nodes.map { |node| HeaderReference.from_node(node) }
       end
 
       # Returns the input body definition for this operation.
@@ -71,19 +87,7 @@ module WSDL
       #
       # @return [Hash] the input body definition
       def input_body
-        return @input_body if @input_body
-
-        input_body = {}
-
-        if (body_node = find_input_child_nodes('body').first)
-          input_body = {
-            encoding_style: body_node['encodingStyle'],
-            namespace: body_node['namespace'],
-            use: body_node['use']
-          }
-        end
-
-        @input_body = input_body
+        @input_body ||= build_body(@input_body_node)
       end
 
       # Returns the output header definitions for this operation.
@@ -97,10 +101,7 @@ module WSDL
       #
       # @return [Array<HeaderReference>] the output header references
       def output_headers
-        return @output_headers if @output_headers
-
-        header_nodes = find_output_child_nodes('header') || []
-        @output_headers = build_headers(header_nodes)
+        @output_headers ||= @output_header_nodes.map { |node| HeaderReference.from_node(node) }
       end
 
       # Returns the output body definition for this operation.
@@ -112,68 +113,98 @@ module WSDL
       #
       # @return [Hash] the output body definition
       def output_body
-        return @output_body if @output_body
-
-        output_body = {}
-
-        if (body_node = find_output_child_nodes('body').first)
-          output_body = {
-            encoding_style: body_node['encodingStyle'],
-            namespace: body_node['namespace'],
-            use: body_node['use']
-          }
-        end
-
-        @output_body = output_body
+        @output_body ||= build_body(@output_body_node)
       end
 
       private
 
-      # Finds child nodes of a specific type within the input element.
+      # Single-pass categorization of all operation children.
       #
-      # @param child_name [String] the name of the child element to find
-      # @return [Array<Nokogiri::XML::Node>, nil] the matching child nodes
-      def find_input_child_nodes(child_name)
-        input_node = @operation_node.element_children.find { |node| node.name == 'input' }
-        return unless input_node
-
-        input_node.element_children.select { |node| node.name == child_name }
+      # Traverses element_children once to find the SOAP operation, input, and
+      # output nodes. Also pre-categorizes each wrapper's children (body/header
+      # nodes) to avoid repeated element_children calls when accessors are invoked.
+      #
+      # @param defaults [Hash] default values inherited from the parent binding
+      # @return [void]
+      def categorize_children!(defaults)
+        @operation_node.element_children.each do |child|
+          case child.name
+          when 'operation'
+            extract_soap_operation!(child, defaults)
+          when 'input'
+            @has_input = true
+            @input_name = child['name']
+            categorize_input_children!(child)
+          when 'output'
+            @output_name = child['name']
+            categorize_output_children!(child)
+          end
+        end
       end
 
-      # Finds child nodes of a specific type within the output element.
+      # Extracts SOAP operation metadata from a soap:operation or soap12:operation node.
       #
-      # @param child_name [String] the name of the child element to find
-      # @return [Array<Nokogiri::XML::Node>, nil] the matching child nodes
-      def find_output_child_nodes(child_name)
-        output_node = @operation_node.element_children.find { |node| node.name == 'output' }
-        return unless output_node
+      # @param node [Nokogiri::XML::Node] a child element of the binding operation
+      # @param defaults [Hash] default values inherited from the parent binding
+      # @return [void]
+      def extract_soap_operation!(node, defaults)
+        namespace = node.namespace&.href
 
-        output_node.element_children.select { |node| node.name == child_name }
-      end
+        soap11 = namespace == NS::WSDL_SOAP_1_1
+        soap12 = namespace == NS::WSDL_SOAP_1_2
+        return unless soap11 || soap12
 
-      # Builds normalized header metadata from SOAP header nodes.
-      #
-      # @param header_nodes [Array<Nokogiri::XML::Node>] SOAP header nodes
-      # @return [Array<HeaderReference>] normalized header metadata
-      def build_headers(header_nodes)
-        header_nodes.map { |header_node| HeaderReference.from_node(header_node) }
+        @soap_namespace = namespace
+        @soap_action = node['soapAction']
+        @style = node['style'] || defaults[:style]
       end
 
-      # Finds the SOAP operation element within this binding operation.
+      # Pre-categorizes the input wrapper's children into body and header nodes.
       #
-      # @return [Array<String, Nokogiri::XML::Node>, nil] a tuple of [namespace, node], or nil if not found
-      def find_soap_operation_node
-        @operation_node.element_children.each do |node|
-          namespace = node.namespace.href
+      # @param wrapper [Nokogiri::XML::Node] the input wrapper node
+      # @return [void]
+      def categorize_input_children!(wrapper)
+        headers = nil
+
+        wrapper.element_children.each do |child|
+          case child.name
+          when 'body'   then @input_body_node = child
+          when 'header' then (headers ||= []) << child
+          end
+        end
 
-          soap11    = namespace == NS::WSDL_SOAP_1_1
-          soap12    = namespace == NS::WSDL_SOAP_1_2
-          operation = node.name == 'operation'
+        @input_header_nodes = headers if headers
+      end
 
-          return [namespace, node] if (soap11 || soap12) && operation
+      # Pre-categorizes the output wrapper's children into body and header nodes.
+      #
+      # @param wrapper [Nokogiri::XML::Node] the output wrapper node
+      # @return [void]
+      def categorize_output_children!(wrapper)
+        headers = nil
+
+        wrapper.element_children.each do |child|
+          case child.name
+          when 'body'   then @output_body_node = child
+          when 'header' then (headers ||= []) << child
+          end
         end
 
-        nil
+        @output_header_nodes = headers if headers
+      end
+
+      # Builds a body definition hash from a SOAP body node.
+      #
+      # @param body_node [Nokogiri::XML::Node, nil] the soap:body node
+      # @return [Hash] the body definition
+      def build_body(body_node)
+        return {} unless body_node
+
+        {
+          encoding_style: body_node['encodingStyle'],
+          namespace: body_node['namespace'],
+          use: body_node['use']
+        }
       end
     end
   end

data/lib/wsdl/parser/document.rb

@@ -19,6 +19,7 @@ module WSDL
         @document = document
         @schemas = schemas
 
+        reject_empty_document!
         reject_unsupported_version!
 
         @messages = {}
@@ -92,10 +93,17 @@ module WSDL
       # @raise [WSDL::UnsupportedWSDLVersionError] if the document uses WSDL 2.0
       # @return [void]
       def reject_unsupported_version!
-        return unless @document.root&.namespace&.href == NS::WSDL_2_0
+        return unless @document.root.namespace&.href == NS::WSDL_2_0
 
         raise UnsupportedWSDLVersionError,
-              'WSDL 2.0 is not supported. This library only supports WSDL 1.1 documents.'
+          'WSDL 2.0 is not supported. This library only supports WSDL 1.1 documents.'
+      end
+
+      def reject_empty_document!
+        return if @document.root
+
+        raise Error, 'The document could not be parsed as WSDL. ' \
+                     'Expected an XML document with a root element.'
       end
 
       # Collects sections from the WSDL document and stores them in their respective collections.

data/lib/wsdl/parser/document_collection.rb

@@ -27,7 +27,7 @@ module WSDL
       def <<(document)
         if sealed?
           raise SealedCollectionError,
-                'Cannot add documents after import has completed and the collection is sealed.'
+            'Cannot add documents after import has completed and the collection is sealed.'
         end
 
         @documents << document

data/lib/wsdl/parser/import_result.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module WSDL
+  module Parser
+    # Result of resolving and importing a WSDL document.
+    #
+    # Returned by {Parser.import} and consumed by {Definition::Builder}
+    # or directly by callers that need the intermediate parse structures
+    # without building a full {Definition}.
+    #
+    # @example Accessing parsed structures
+    #   result = WSDL::Parser.import('service.wsdl', http)
+    #   result.documents  # => Parser::DocumentCollection
+    #   result.schemas    # => Schema::Collection
+    #
+    # @api private
+    ImportResult = Data.define(:documents, :schemas, :provenance, :schema_import_errors)
+  end
+end

data/lib/wsdl/parser/input_output.rb

@@ -13,14 +13,25 @@ module WSDL
       #
       # @param binding_operation [BindingOperation] the binding operation with protocol details
       # @param port_type_operation [PortTypeOperation] the port type operation with interface details
-      # @param parser_result [Result] the parser result for resolving references
-      def initialize(binding_operation, port_type_operation, parser_result)
+      # @param documents [DocumentCollection] for resolving message references
+      # @param schemas [Schema::Collection] for building element trees
+      # @param limits [Limits] resource limits for element building
+      # @param issues [Array, nil] optional issues collector for recording build problems
+      # rubocop:disable Metrics/ParameterLists -- per-operation + build context
+      # @param [Object, nil] element_builder
+      def initialize(binding_operation, port_type_operation,
+                     documents:, schemas:, limits:, issues: nil, element_builder: nil)
         @binding_operation = binding_operation
         @port_type_operation = port_type_operation
-        @parser_result = parser_result
+        @documents = documents
+        @schemas = schemas
+        @limits = limits
+        @issues = issues
+        @element_builder = element_builder
 
         build_parts
       end
+      # rubocop:enable Metrics/ParameterLists
 
       # The header part elements for this message.
       #
@@ -40,105 +51,101 @@ module WSDL
 
       # Builds the header and body parts from the operation definitions.
       #
-      # Resolves message references from the port type operation and
-      # builds XML element definitions. Header parts that are explicitly
-      # defined in the binding are removed from the body parts.
+      # Bails out early when the message reference is missing — records
+      # one issue and sets empty parts without doing any further work.
       #
       # @return [void]
       def build_parts
-        body_parts = collect_body_parts
+        reference = message_reference
+        unless reference
+          record_issue("Operation #{@port_type_operation.name.inspect} is missing a required message reference")
+          @header_parts = []
+          @body_parts = []
+          return
+        end
+
+        body_parts = collect_body_parts(reference)
         header_parts = collect_header_parts
 
         # remove explicit header parts from the body parts
         header_part_names = header_parts.map { |part| part[:name] }
         body_parts.reject! do |part|
-          header_part_names.include? part[:name]
+          header_part_names.include?(part[:name])
         end
 
-        builder = XML::ElementBuilder.new(@parser_result.schemas, limits: @parser_result.limits)
+        builder = @element_builder || XML::ElementBuilder.new(@schemas, limits: @limits, issues: @issues)
         @header_parts = builder.build(header_parts)
         @body_parts = builder.build(body_parts)
       end
 
       # Collects the body parts from the referenced message.
       #
+      # @param reference [MessageReference] the message reference
       # @return [Array<Hash>] the body part definitions
-      def collect_body_parts
-        reference = message_reference
-        find_message(reference).parts
+      def collect_body_parts(reference)
+        message = find_message(reference)
+        return [] unless message
+
+        message.parts
       end
 
       # Returns the message reference for this direction.
       # Subclasses must override to return the input or output reference.
       #
-      # @return [MessageReference] parsed message reference
+      # @return [MessageReference, nil] parsed message reference
       def message_reference
         raise NotImplementedError
       end
 
       # Collects the header parts from explicitly defined header references.
       #
-      # Each header in the binding may reference a different message
-      # and part, allowing headers to be defined separately from
-      # the main message.
+      # Skips headers with missing or invalid references, recording
+      # issues instead of raising.
       #
       # @return [Array<Hash>] the header part definitions
       def collect_header_parts
         headers.each_with_object([]) do |header, parts|
-          validate_header_reference!(header)
+          next unless valid_header_reference?(header)
 
           message = find_message(header)
-          parts << find_header_part(message, header)
+          next unless message
+
+          part = find_header_part(message, header)
+          parts << part if part
         end
       end
 
       # Validates required soap:header reference attributes.
       #
-      # The WSDL SOAP binding requires header references to identify both
-      # a message and a part. Missing either makes the contract ambiguous
-      # and must fail closed.
-      #
       # @param header [HeaderReference] header metadata from the binding
-      # @return [void]
-      # @raise [UnresolvedReferenceError] when required attributes are missing
-      def validate_header_reference!(header)
+      # @return [Boolean] true if the header reference is valid
+      def valid_header_reference?(header)
         if header.message.nil?
-          raise UnresolvedReferenceError.new(
-            'Unable to resolve soap:header because @message is missing',
-            reference_type: :message,
-            reference_name: nil,
-            context: "soap:header for operation #{@port_type_operation.name.inspect}"
-          )
+          record_issue('Unable to resolve soap:header for operation ' \
+                       "#{@port_type_operation.name.inspect} because @message is missing")
+          return false
         end
 
-        return if header.part
+        unless header.part
+          record_issue('Unable to resolve soap:header part for message ' \
+                       "#{header.message.inspect} because @part is missing")
+          return false
+        end
 
-        raise UnresolvedReferenceError.new(
-          "Unable to resolve soap:header part for message #{header.message.inspect} because @part is missing",
-          reference_type: :message_part,
-          reference_name: nil,
-          namespace: header.message_name&.namespace,
-          context: "soap:header for operation #{@port_type_operation.name.inspect}"
-        )
+        true
       end
 
       # Finds a SOAP header part in a message definition.
       #
       # @param message [MessageInfo] the message that should contain the part
       # @param header [HeaderReference] header metadata from the binding
-      # @return [Hash] the resolved message part
-      # @raise [UnresolvedReferenceError] if the referenced part does not exist
+      # @return [Hash, nil] the resolved message part, or nil if not found
       def find_header_part(message, header)
         message_part = message.parts.find { |part| part[:name] == header.part }
         return message_part if message_part
 
-        raise UnresolvedReferenceError.new(
-          "Unable to find part #{header.part.inspect} in message #{header.message.inspect}",
-          reference_type: :message_part,
-          reference_name: header.part.to_s,
-          namespace: header.message_name&.namespace,
-          context: "soap:header for operation #{@port_type_operation.name.inspect}"
-        )
+        record_issue("Unable to find part #{header.part.inspect} in message #{header.message.inspect}")
+        nil
       end
 
       # Returns the header definitions from the binding operation.
@@ -152,19 +159,24 @@ module WSDL
       # Finds a message by reference metadata.
       #
       # @param reference [MessageReference, HeaderReference] message reference
-      # @return [MessageInfo] the message object
-      # @raise [UnresolvedReferenceError] if the message cannot be found
+      # @return [MessageInfo, nil] the message object, or nil if not found
       def find_message(reference)
         message_name = reference.message_name
-        message = @parser_result.documents.messages[message_name]
+        message = @documents.messages[message_name]
         return message if message
 
-        raise UnresolvedReferenceError.new(
-          "Unable to find message #{reference.message.inspect}",
-          reference_type: :message,
-          reference_name: reference.message.to_s,
-          context: "operation #{@port_type_operation.name.inspect}"
-        )
+        record_issue("Unable to find message #{reference.message.inspect} " \
+                     "for operation #{@port_type_operation.name.inspect}")
+        nil
+      end
+
+      # Records a build issue if an issues collector is available.
+      #
+      # @param error [String] description of the problem
+      # @return [void]
+      def record_issue(error)
+        operation = @port_type_operation.name
+        @issues&.push(type: :build_error, operation:, error:)
       end
     end
 

data/lib/wsdl/parser/message_info.rb

@@ -42,8 +42,13 @@ module WSDL
 
       # Parses and returns all parts from the message node.
       #
+      # All wsdl:part children inherit the same namespace scope from
+      # the parent wsdl:message element, so we resolve it once and
+      # share the frozen hash across every part.
+      #
       # @return [Array<Hash>] the parsed parts
       def parts!
+        namespaces = @message_node.namespaces.freeze
         parts = []
 
         @message_node.element_children.each do |part|
@@ -53,7 +58,7 @@ module WSDL
             name: part['name'],
             type: part['type'],
             element: part['element'],
-            namespaces: part.namespaces
+            namespaces:
           }
         end
 

data/lib/wsdl/parser/message_reference.rb

@@ -10,11 +10,14 @@ module WSDL
         # Builds a message reference from an input/output node.
         #
         # @param node [Nokogiri::XML::Node] wsdl:input or wsdl:output node
+        # @param namespaces [Hash{String => String}, nil] pre-resolved namespace
+        #   declarations to avoid repeated Nokogiri namespace lookups on sibling nodes
         # @return [MessageReference] parsed reference
-        def from_node(node)
+        def from_node(node, namespaces: nil)
+          namespaces ||= node.namespaces
           message = node['message']
           default_namespace = QName.document_namespace(node.document.root)
-          message_name = message ? QName.parse(message, namespaces: node.namespaces, default_namespace:) : nil
+          message_name = message ? QName.parse(message, namespaces:, default_namespace:) : nil
 
           new(name: node['name'], message:, message_name:)
         end