Extract build_single_operation and OperationInfo delegators

Refactors the large build_operations loop into two focused methods
(build_single_operation, populate_operation_metadata) and adds
input?, rpc_input_namespace, rpc_output_namespace delegators to
OperationInfo so the builder goes through the facade instead of
reaching into binding internals.

* Add builder edge-case tests: missing portType op, missing input
  element, overloaded operations, unresolved binding reference
* Add OperationInfo spec covering the new delegator methods

Author: rubiii

lib/wsdl/definition/builder.rb

@@ -88,72 +88,100 @@ def build_services
 
       # Builds operations for a given port.
       #
-      # Resolves binding and port_type once, then iterates all operations
-      # directly.
+      # Resolves binding and port_type once, then delegates each operation
+      # to {#build_single_operation}.
       #
       # @param port [Parser::Port] the port
       # @return [Hash{String => Hash, Array<Hash>}] operation data keyed by name
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/BlockLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       def build_operations(port)
         binding = port.fetch_binding(@documents)
         port_type = binding.fetch_port_type(@documents)
         operations = {}
         element_builder = XML::ElementBuilder.new(@schemas, limits: @limits, issues: @build_issues)
 
         binding.operations.to_a.each do |op_entry|
-          op_name = op_entry[:name]
-          input_name = op_entry[:input_name]
-          metadata = default_operation(op_name, input_name:)
-
-          binding_op = binding.operations.fetch(op_name, input_name:)
-          port_type_op = port_type.operations.fetch(op_name, input_name:) { nil }
-
-          unless port_type_op
-            record_build_issue(op_name,
-              "Binding operation #{op_name.inspect} not found in portType #{port_type.name.inspect}")
-            store_operation(operations, op_name, metadata.freeze)
-            next
-          end
-
-          op_info = Parser::OperationInfo.new(
-            op_name, binding_op, port_type_op,
-            documents: @documents, schemas: @schemas,
-            limits: @limits, issues: @build_issues,
-            element_builder:
-          )
-
-          metadata[:soap_action] = op_info.soap_action
-          metadata[:soap_version] = op_info.soap_version
-
-          if binding_op.input?
-            metadata[:input_style] = op_info.input_style
-            metadata[:output_style] = op_info.output_style
-            metadata[:rpc_input_namespace] = binding_op.input_body[:namespace]
-            metadata[:rpc_output_namespace] = binding_op.output_body&.dig(:namespace)
-          else
-            record_build_issue(op_name,
-              "Binding operation #{op_name.inspect} is missing a required <input> element")
-          end
-
-          metadata[:schema_complete] = schema_complete_for_operation?(op_info)
-          metadata[:input] = build_message(op_info.input)
-          metadata[:output] = op_info.output ? build_message(op_info.output) : nil
-          store_operation(operations, op_name, metadata.freeze)
+          metadata = build_single_operation(op_entry, binding, port_type, element_builder)
+          store_operation(operations, op_entry[:name], metadata.freeze)
         end
 
         operations
       rescue UnresolvedReferenceError => e
         record_build_issue(nil, e.message)
         {}
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/BlockLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      # Builds a single operation's metadata hash.
+      #
+      # Resolves binding and port type operations, validates the port type
+      # match, and populates the metadata from the resolved operation info.
+      # Returns a default metadata hash when the port type operation is missing.
+      #
+      # @param op_entry [Hash] operation entry from {Parser::OperationMap#to_a}
+      # @param binding [Parser::Binding] the resolved binding
+      # @param port_type [Parser::PortType] the resolved port type
+      # @param element_builder [XML::ElementBuilder] shared element builder
+      # @return [Hash] operation metadata
+      def build_single_operation(op_entry, binding, port_type, element_builder)
+        op_name = op_entry[:name]
+        metadata = default_operation(op_name, input_name: op_entry[:input_name])
+
+        binding_op = binding.operations.fetch(op_name, input_name: op_entry[:input_name])
+        port_type_op = port_type.operations.fetch(op_name, input_name: op_entry[:input_name]) { nil }
+
+        unless port_type_op
+          record_build_issue(op_name,
+            "Binding operation #{op_name.inspect} not found in portType #{port_type.name.inspect}")
+          return metadata
+        end
+
+        op_info = Parser::OperationInfo.new(
+          op_name, binding_op, port_type_op,
+          documents: @documents, schemas: @schemas,
+          limits: @limits, issues: @build_issues,
+          element_builder:
+        )
+
+        populate_operation_metadata(metadata, op_name, op_info)
+        metadata
+      end
+
+      # Populates an operation metadata hash from resolved operation info.
+      #
+      # Sets SOAP protocol fields, binding styles, schema completeness,
+      # and resolved input/output messages. All data is accessed through the
+      # {Parser::OperationInfo} facade rather than reaching into lower-level
+      # binding or port type objects directly.
+      #
+      # @param metadata [Hash] the operation metadata hash to populate
+      # @param op_name [String] the operation name (for error reporting)
+      # @param op_info [Parser::OperationInfo] the resolved operation info
+      # @return [void]
+      # rubocop:disable Metrics/AbcSize -- data-mapping method; high ABC from 9 hash assignments, not complexity
+      def populate_operation_metadata(metadata, op_name, op_info)
+        metadata[:soap_action] = op_info.soap_action
+        metadata[:soap_version] = op_info.soap_version
+
+        if op_info.input?
+          metadata[:input_style] = op_info.input_style
+          metadata[:output_style] = op_info.output_style
+          metadata[:rpc_input_namespace] = op_info.rpc_input_namespace
+          metadata[:rpc_output_namespace] = op_info.rpc_output_namespace
+        else
+          record_build_issue(op_name,
+            "Binding operation #{op_name.inspect} is missing a required <input> element")
+        end
+
+        metadata[:schema_complete] = schema_complete_for_operation?(op_info)
+        metadata[:input] = build_message(op_info.input)
+        metadata[:output] = op_info.output ? build_message(op_info.output) : nil
+      end
+      # rubocop:enable Metrics/AbcSize
 
       # Returns an operation hash with safe defaults.
       #
-      # Each field starts as nil/empty. The loop in {#build_operations}
-      # progressively enhances the hash with binding-level metadata and
-      # resolved message data. If any step fails, the rescue stores
-      # whatever was captured up to that point.
+      # Each field starts as nil/empty. {#build_single_operation} and
+      # {#populate_operation_metadata} progressively enhance the hash
+      # with binding-level metadata and resolved message data.
       #
       # @param name [String] the operation name
       # @param input_name [String, nil] disambiguator for overloaded operations

lib/wsdl/parser/operation_info.rb

@@ -38,12 +38,6 @@ def initialize(name, binding_operation, port_type_operation,
       # @return [String] the name of this operation
       attr_reader :name
 
-      # @return [BindingOperation] the binding operation with protocol details
-      attr_reader :binding_operation
-
-      # @return [PortTypeOperation] the port type operation with interface details
-      attr_reader :port_type_operation
-
       # Returns the SOAP action for this operation.
       #
       # The SOAP action is typically used as an HTTP header value to indicate
@@ -99,6 +93,27 @@ def output
         )
       end
 
+      # Returns whether the binding operation defines an input element.
+      #
+      # @return [Boolean] true if the binding has an +<input>+ element
+      def input?
+        @binding_operation.input?
+      end
+
+      # Returns the RPC input namespace from the binding's input body.
+      #
+      # @return [String, nil] the namespace URI, or nil if not specified
+      def rpc_input_namespace
+        @binding_operation.input_body[:namespace]
+      end
+
+      # Returns the RPC output namespace from the binding's output body.
+      #
+      # @return [String, nil] the namespace URI, or nil if not specified
+      def rpc_output_namespace
+        @binding_operation.output_body[:namespace]
+      end
+
       # Returns the input style for this operation.
       #
       # The style is a combination of the binding style and use attribute,

spec/wsdl/definition/builder_spec.rb

@@ -208,6 +208,146 @@
     end
   end
 
+  describe 'build_operations edge cases' do
+    let(:tempfiles) { [] }
+
+    after do
+      tempfiles.each(&:close!)
+    end
+
+    def write_wsdl_file(wsdl_xml)
+      file = Tempfile.new(['builder-spec', '.wsdl'])
+      file.write(wsdl_xml)
+      file.flush
+      tempfiles << file
+      file.path
+    end
+
+    def parse_definition(wsdl_xml)
+      WSDL::Parser.parse(write_wsdl_file(wsdl_xml), http_mock)
+    end
+
+    describe 'binding operation not in portType' do
+      subject(:definition) do
+        parse_definition(<<~XML)
+          <definitions xmlns="http://schemas.xmlsoap.org/wsdl/"
+                       xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
+                       xmlns:tns="http://t.com" targetNamespace="http://t.com">
+            <portType name="PT"/>
+            <binding name="B" type="tns:PT">
+              <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
+              <operation name="GhostOp">
+                <soap:operation soapAction="ghost"/>
+                <input><soap:body use="literal"/></input>
+                <output><soap:body use="literal"/></output>
+              </operation>
+            </binding>
+            <service name="S">
+              <port name="P" binding="tns:B"><soap:address location="http://x.com"/></port>
+            </service>
+          </definitions>
+        XML
+      end
+
+      it 'records a build issue referencing the portType' do
+        expect(definition.build_issues).to contain_exactly(
+          a_hash_including(type: :build_error, operation: 'GhostOp')
+        )
+        expect(definition.build_issues.first[:error]).to include('portType')
+      end
+
+      it 'stores the operation with default metadata' do
+        op = definition.operation_data('S', 'P', 'GhostOp')
+
+        expect(op[:name]).to eq('GhostOp')
+        expect(op[:soap_action]).to be_nil
+        expect(op[:input_style]).to be_nil
+        expect(op[:input]).to eq(header: [], body: [])
+        expect(op[:output]).to be_nil
+      end
+    end
+
+    describe 'binding operation missing input element' do
+      subject(:definition) do
+        parse_definition(<<~XML)
+          <definitions xmlns="http://schemas.xmlsoap.org/wsdl/"
+                       xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
+                       xmlns:tns="http://t.com" targetNamespace="http://t.com">
+            <portType name="PT"><operation name="Op"/></portType>
+            <binding name="B" type="tns:PT">
+              <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
+              <operation name="Op"><soap:operation soapAction="DoStuff"/></operation>
+            </binding>
+            <service name="S">
+              <port name="P" binding="tns:B"><soap:address location="http://x.com"/></port>
+            </service>
+          </definitions>
+        XML
+      end
+
+      it 'records a build issue about missing input' do
+        expect(definition.build_issues).to include(
+          a_hash_including(
+            type: :build_error,
+            operation: 'Op',
+            error: a_string_matching(/missing a required.*input/i)
+          )
+        )
+      end
+
+      it 'populates soap_action and soap_version but not styles' do
+        op = definition.operation_data('S', 'P', 'Op')
+
+        expect(op[:soap_action]).to eq('DoStuff')
+        expect(op[:soap_version]).to eq('1.1')
+        expect(op[:input_style]).to be_nil
+        expect(op[:output_style]).to be_nil
+      end
+    end
+
+    describe 'overloaded operations' do
+      subject(:definition) do
+        WSDL::Parser.parse(fixture('parser/operation_overloading'), http_mock)
+      end
+
+      it 'stores overloaded operations as an array' do
+        ops = definition.to_h.dig('services', 'LookupService', 'ports', 'LookupPort', 'operations')
+        lookup = ops['Lookup']
+
+        expect(lookup).to be_an(Array)
+        expect(lookup.size).to eq(2)
+        expect(lookup.map { |o| o['input_name'] }).to contain_exactly('LookupById', 'LookupByName')
+      end
+
+      it 'assigns distinct metadata to each overload' do
+        by_id = definition.operation_data('LookupService', 'LookupPort', 'Lookup', input_name: 'LookupById')
+        by_name = definition.operation_data('LookupService', 'LookupPort', 'Lookup', input_name: 'LookupByName')
+
+        expect(by_id[:soap_action]).to eq('LookupById')
+        expect(by_name[:soap_action]).to eq('LookupByName')
+        expect(by_id[:input][:body]).not_to eq(by_name[:input][:body])
+      end
+    end
+
+    describe 'unresolved binding reference' do
+      subject(:definition) do
+        WSDL::Parser.parse(fixture('parser/unresolved_references/binding'), http_mock)
+      end
+
+      it 'records a build issue with nil operation' do
+        expect(definition.build_issues).to include(
+          a_hash_including(type: :build_error, operation: nil)
+        )
+      end
+
+      it 'returns empty operations for the affected port' do
+        port = definition.to_h.dig('services', 'BadService', 'ports', 'BadPort')
+
+        expect(port['operations']).to be_empty
+      end
+    end
+  end
+
   private
 
   def collect_types(elements)