wasabi 5.1.0 → 5.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af912c6da83bd8794f7929d89c792716f295b9949c6f6acf30211cdf7a608d9f
-  data.tar.gz: 7c4826039acd022be1150ddde566e3217653b594199a42b55de82a36c2225109
+  metadata.gz: fafbc0e7f78682f50c3f1466447f9d724e9cc00fc1dd6b8d7751c6f473c1f297
+  data.tar.gz: 193032ab7fcc93c7cd4f71bd69ca09e545ce5ede2167efa975fde11ce9c7ceaf
 SHA512:
-  metadata.gz: 7ba504cc015d6b070728279f8a50bc0b4e46c5a375fca2b2a4912c20f3d731c2a37dea913380397e7d2bdc8317c3f38cbb27f4c204ca2b5954087bbb464de1cb
-  data.tar.gz: 207e7d588b64eab57a496b4de40fa5da60b75d140f3452714415d4400155b6d8fc4633907c402726d6c3ae0bc87e88942873f18d4b5cea4960afbb1b8b4f36eb
+  metadata.gz: 992ad19eb27a2e31594698517147b412dc05f9aab8825009325835276fbb97a1cffac5abc10d2fea3f103a9a4cfe8ed86e56df6806e3a45b8499a0ec581414e2
+  data.tar.gz: bd5a22e85ebbcc5273c276dd887268edf6c6a94387663f6f12d48c00e72646e2ea680f7a3a80a363635c7f5d70f2b4a033d8939c2474d8d2b67dc8bef209adee

data/CHANGELOG.md

@@ -1,8 +1,9 @@
 # CHANGELOG for Wasabi
 
-## Unreleased
+## 5.2.0 (2026-09-18)
 
-- _Your new line here. Mind the style of prefix used in the rest of the document._
+- Resolve each operation to its WSDL port's SOAP endpoint via `Wasabi::ServicePorts` and `Document#endpoint_for_operation` ([#138](https://github.com/savonrb/wasabi/pull/138)). `Document#endpoint` keeps its legacy first-port behavior. Known limitation: the lookup walks operation -> portType -> binding -> port and takes the first matching portType, while Savon's operation map is built from bindings (last binding wins). If the same operation name appears in two portTypes, the SOAP action may come from a different binding than the endpoint's port; a future pass could walk operation -> binding -> port for consistency.
+- Parse operation faults and expose the raw operation name in the operation hash ([#121](https://github.com/savonrb/wasabi/pull/121)) by @ekzobrain.
 
 ## 5.1.0 (2024-10-27)
 

data/README.md

@@ -2,10 +2,8 @@
 
 A simple WSDL parser.
 
-[![Test](https://github.com/savonrb/wasabi/actions/workflows/test.yml/badge.svg)](https://github.com/savonrb/wasabi/actions/workflows/test.yml)
+[![CI](https://github.com/savonrb/wasabi/actions/workflows/ci.yml/badge.svg)](https://github.com/savonrb/wasabi/actions/workflows/ci.yml)
 [![Gem Version](https://badge.fury.io/rb/wasabi.svg)](http://badge.fury.io/rb/wasabi)
-[![Code Climate](https://codeclimate.com/github/savonrb/wasabi.svg)](https://codeclimate.com/github/savonrb/wasabi)
-[![Coverage Status](https://coveralls.io/repos/savonrb/wasabi/badge.svg?branch=master)](https://coveralls.io/r/savonrb/wasabi)
 
 ## Installation
 

data/lib/wasabi/core_ext/string.rb

@@ -3,10 +3,9 @@
 module Wasabi
   module CoreExt
     module String
-
       def self.snakecase(str)
         str = str.dup
-        str.gsub!(/::/, '/')
+        str.gsub!("::", "/")
         str.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
         str.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
         str.tr!(".", "_")
@@ -14,7 +13,6 @@ module Wasabi
         str.downcase!
         str
       end
-
     end
   end
 end

data/lib/wasabi/document.rb

@@ -5,12 +5,10 @@ require "wasabi/resolver"
 require "wasabi/parser"
 
 module Wasabi
-
   # = Wasabi::Document
   #
   # Represents a WSDL document.
   class Document
-
     ELEMENT_FORM_DEFAULTS = [:unqualified, :qualified]
 
     # Validates if a given +value+ is a valid elementFormDefault value.
@@ -18,14 +16,14 @@ module Wasabi
     def self.validate_element_form_default!(value)
       return if ELEMENT_FORM_DEFAULTS.include?(value)
 
-      raise ArgumentError, "Invalid value for elementFormDefault: #{value}\n" +
-                           "Must be one of: #{ELEMENT_FORM_DEFAULTS.inspect}"
+      raise ArgumentError, "Invalid value for elementFormDefault: #{value}\n" \
+        "Must be one of: #{ELEMENT_FORM_DEFAULTS.inspect}"
     end
 
     # Accepts a WSDL +document+ to parse.
     def initialize(document = nil, adapter = nil)
       self.document = document
-      self.adapter  = adapter
+      self.adapter = adapter
     end
 
     attr_accessor :document, :request, :adapter
@@ -42,6 +40,19 @@ module Wasabi
     # Sets the SOAP endpoint.
     attr_writer :endpoint
 
+    # Returns the SOAP endpoint of the port serving the given SOAP operation.
+    #
+    # Walks operation -> portType -> binding -> port, so WSDLs exposing
+    # several ports resolve to the address of the port that actually serves
+    # the operation instead of the first port's address. When +soap_version+
+    # is given, a port for that SOAP version is preferred; otherwise the
+    # first SOAP port for the operation is returned. Non-SOAP ports are
+    # never returned. Returns +nil+ when the operation has no SOAP ports,
+    # so callers can fall back to #endpoint.
+    def endpoint_for_operation(operation_name, soap_version: nil)
+      service_ports.endpoint_for_operation(operation_name, soap_version: soap_version)
+    end
+
     # Returns the target namespace.
     def namespace
       @namespace ||= parser.namespace
@@ -91,7 +102,7 @@ module Wasabi
     # Returns a list of parameter names for a given +key+
     def soap_action_parameters(key)
       params = operation_input_parameters(key)
-      params.keys if params
+      params&.keys
     end
 
     # Returns a list of input parameters for a given +key+.
@@ -103,15 +114,17 @@ module Wasabi
       @type_namespaces ||= begin
         namespaces = []
 
-        parser.types.each do |ns, types|
-          types.each do |type, info|
-            namespaces << [[type], info[:namespace]]
+        if document
+          parser.types.each do |ns, types|
+            types.each do |type, info|
+              namespaces << [[type], info[:namespace]]
 
-            element_keys(info).each do |field|
-              namespaces << [[type, field], info[:namespace]]
+              element_keys(info).each do |field|
+                namespaces << [[type, field], info[:namespace]]
+              end
             end
           end
-        end if document
+        end
 
         namespaces
       end
@@ -121,16 +134,18 @@ module Wasabi
       @type_definitions ||= begin
         result = []
 
-        parser.types.each do |ns, types|
-          types.each do |type, info|
-            element_keys(info).each do |field|
-              field_type = info[field][:type]
-              tag, namespace = field_type.split(":").reverse
+        if document
+          parser.types.each do |ns, types|
+            types.each do |type, info|
+              element_keys(info).each do |field|
+                field_type = info[field][:type]
+                tag, namespace = field_type.split(":").reverse
 
-              result << [[type, field], tag] if user_defined(namespace)
+                result << [[type, field], tag] if user_defined(namespace)
+              end
             end
           end
-        end if document
+        end
 
         result
       end
@@ -153,7 +168,12 @@ module Wasabi
       @parser ||= guard_parse && parse
     end
 
-  private
+    private
+
+    # Returns the service ports of the WSDL document.
+    def service_ports
+      @service_ports ||= ServicePorts.new(parser.document)
+    end
 
     # Raises an error if the WSDL document is missing.
     def guard_parse

data/lib/wasabi/parser.rb

@@ -1,26 +1,28 @@
 # frozen_string_literal: true
 
-require 'uri'
-require 'addressable/uri'
-require 'wasabi/core_ext/string'
+require "uri"
+require "addressable/uri"
+require "wasabi/core_ext/string"
 
 module Wasabi
-
   # = Wasabi::Parser
   #
   # Parses WSDL documents and remembers their important parts.
   class Parser
+    XSD = "http://www.w3.org/2001/XMLSchema"
+    WSDL = "http://schemas.xmlsoap.org/wsdl/"
+    SOAP_1_1 = "http://schemas.xmlsoap.org/wsdl/soap/"
+    SOAP_1_2 = "http://schemas.xmlsoap.org/wsdl/soap12/"
 
-    XSD      = 'http://www.w3.org/2001/XMLSchema'
-    WSDL     = 'http://schemas.xmlsoap.org/wsdl/'
-    SOAP_1_1 = 'http://schemas.xmlsoap.org/wsdl/soap/'
-    SOAP_1_2 = 'http://schemas.xmlsoap.org/wsdl/soap12/'
+    # A wsdl message an operation input, output, or fault resolves to.
+    # Contains the message type name and its namespace identifier.
+    MessageRef = Struct.new(:namespace_id, :type)
 
     def initialize(document)
       self.document = document
       self.operations = {}
       self.namespaces = {}
-      self.service_name = ''
+      self.service_name = ""
       self.types = {}
       self.deferred_types = []
       self.element_form_default = :unqualified
@@ -67,22 +69,21 @@ module Wasabi
     end
 
     def parse_namespaces
-      element_form_default = schemas.first && schemas.first['elementFormDefault']
+      element_form_default = schemas.first && schemas.first["elementFormDefault"]
       @element_form_default = element_form_default.to_s.to_sym if element_form_default
 
-      namespace = document.root['targetNamespace']
+      namespace = document.root["targetNamespace"]
       @namespace = namespace.to_s if namespace
 
-      @namespaces = @document.namespaces.inject({}) do |memo, (key, value)|
-        memo[key.sub('xmlns:', '')] = value
-        memo
+      @namespaces = @document.namespaces.each_with_object({}) do |(key, value), memo|
+        memo[key.sub("xmlns:", "")] = value
       end
     end
 
     def parse_endpoint
-      if service_node = service
-        endpoint = service_node.at_xpath('.//soap11:address/@location', 'soap11' => SOAP_1_1)
-        endpoint ||= service_node.at_xpath(service_node, './/soap12:address/@location', 'soap12' => SOAP_1_2)
+      if (service_node = service)
+        endpoint = service_node.at_xpath(".//soap11:address/@location", "soap11" => SOAP_1_1)
+        endpoint ||= service_node.at_xpath(service_node, ".//soap12:address/@location", "soap12" => SOAP_1_2)
       end
 
       @endpoint = parse_url(endpoint) if endpoint
@@ -96,85 +97,94 @@ module Wasabi
     end
 
     def parse_service_name
-      service_name = document.root['name']
+      service_name = document.root["name"]
       @service_name = service_name.to_s if service_name
     end
 
     def parse_messages
-      messages = document.root.element_children.select { |node| node.name == 'message' }
-      @messages = Hash[messages.map { |node| [node['name'], node] }]
+      messages = document.root.element_children.select { |node| node.name == "message" }
+      @messages = messages.map { |node| [node["name"], node] }.to_h
     end
 
     def parse_port_types
-      port_types = document.root.element_children.select { |node| node.name == 'portType' }
-      @port_types = Hash[port_types.map { |node| [node['name'], node] }]
+      port_types = document.root.element_children.select { |node| node.name == "portType" }
+      @port_types = port_types.map { |node| [node["name"], node] }.to_h
     end
 
     def parse_port_type_operations
       @port_type_operations = {}
 
       @port_types.each do |port_type_name, port_type|
-        operations = port_type.element_children.select { |node| node.name == 'operation' }
-        @port_type_operations[port_type_name] = Hash[operations.map { |node| [node['name'], node] }]
+        operations = port_type.element_children.select { |node| node.name == "operation" }
+        @port_type_operations[port_type_name] = operations.map { |node| [node["name"], node] }.to_h
       end
     end
 
     def parse_operations_parameters
-       document.xpath("wsdl:definitions/wsdl:types/*[local-name()='schema']/*[local-name()='element']", 'wsdl' => WSDL).each do |element|
-        name = Wasabi::CoreExt::String.snakecase(element.attribute('name').to_s).to_sym
+      document.xpath("wsdl:definitions/wsdl:types/*[local-name()='schema']/*[local-name()='element']", "wsdl" => WSDL).each do |element|
+        name = Wasabi::CoreExt::String.snakecase(element.attribute("name").to_s).to_sym
 
-        if operation = @operations[name]
+        if (operation = @operations[name])
           element.xpath("*[local-name() ='complexType']/*[local-name() ='sequence']/*[local-name() ='element']").each do |child_element|
-            attr_name = child_element.attribute('name').to_s
-            attr_type = (attr_type = child_element.attribute('type').to_s.split(':')).size > 1 ? attr_type[1] : attr_type[0]
+            attr_name = child_element.attribute("name").to_s
+            attr_type = ((attr_type = child_element.attribute("type").to_s.split(":")).size > 1) ? attr_type[1] : attr_type[0]
 
             operation[:parameters] ||= {}
-            operation[:parameters][attr_name.to_sym] = { :name => attr_name, :type => attr_type }
+            operation[:parameters][attr_name.to_sym] = {name: attr_name, type: attr_type}
           end
         end
       end
     end
 
     def parse_operations
-      operations = document.xpath('wsdl:definitions/wsdl:binding/wsdl:operation', 'wsdl' => WSDL)
+      operations = document.xpath("wsdl:definitions/wsdl:binding/wsdl:operation", "wsdl" => WSDL)
       operations.each do |operation|
-        name = operation.attribute('name').to_s
+        name = operation.attribute("name").to_s
         snakecase_name = Wasabi::CoreExt::String.snakecase(name).to_sym
 
         # TODO: check for soap namespace?
-        soap_operation = operation.element_children.find { |node| node.name == 'operation' }
-        soap_action = soap_operation['soapAction'] if soap_operation
-        soap_document = soap_operation['style'] == 'document'  if soap_operation
+        soap_operation = operation.element_children.find { |node| node.name == "operation" }
+        soap_action = soap_operation["soapAction"] if soap_operation
+        soap_document = soap_operation["style"] == "document" if soap_operation
 
         if soap_action || soap_document
           soap_action = soap_action.to_s
-          action = soap_action && !soap_action.empty? ? soap_action : name
+          action = (soap_action && !soap_action.empty?) ? soap_action : name
 
           # There should be a matching portType for each binding, so we will lookup the input from there.
-          namespace_id, output = output_for(operation)
-          namespace_id, input = input_for(operation)
+          input = input_for(operation)
+          output = output_for(operation)
+          faults = faults_for(operation)
 
           # Store namespace identifier so this operation can be mapped to the proper namespace.
-          @operations[snakecase_name] = { :action => action, :input => input, :output => output, :namespace_identifier => namespace_id}
+          operation_entry = {
+            name: name,
+            action: action,
+            input: input.type,
+            output: output.type,
+            namespace_identifier: input.namespace_id
+          }
+          operation_entry[:fault] = faults.map(&:type) if faults.any?
+          @operations[snakecase_name] = operation_entry
         elsif !@operations[snakecase_name]
-          @operations[snakecase_name] = { :action => name, :input => name }
+          @operations[snakecase_name] = {action: name, input: name}
         end
       end
     end
 
     def parse_types
       schemas.each do |schema|
-        schema_namespace = schema['targetNamespace']
+        schema_namespace = schema["targetNamespace"]
 
         schema.element_children.each do |node|
           namespace = schema_namespace || @namespace
 
           case node.name
-          when 'element'
-            complex_type = node.at_xpath('./xs:complexType', 'xs' => XSD)
-            process_type namespace, complex_type, node['name'].to_s if complex_type
-          when 'complexType'
-            process_type namespace, node, node['name'].to_s
+          when "element"
+            complex_type = node.at_xpath("./xs:complexType", "xs" => XSD)
+            process_type namespace, complex_type, node["name"].to_s if complex_type
+          when "complexType"
+            process_type namespace, node, node["name"].to_s
           end
         end
       end
@@ -182,15 +192,15 @@ module Wasabi
 
     def process_type(namespace, type, name)
       @types[namespace] ||= {}
-      @types[namespace][name] ||= { :namespace => namespace }
+      @types[namespace][name] ||= {namespace: namespace}
       @types[namespace][name][:order!] = []
 
-      type.xpath('./xs:sequence/xs:element', 'xs' => XSD).each do |inner|
-        element_name = inner.attribute('name').to_s
-        @types[namespace][name][element_name] = { :type => inner.attribute('type').to_s }
+      type.xpath("./xs:sequence/xs:element", "xs" => XSD).each do |inner|
+        element_name = inner.attribute("name").to_s
+        @types[namespace][name][element_name] = {type: inner.attribute("type").to_s}
 
-        [ :nillable, :minOccurs, :maxOccurs ].each do |attr|
-          if v = inner.attribute(attr.to_s)
+        [:nillable, :minOccurs, :maxOccurs].each do |attr|
+          if (v = inner.attribute(attr.to_s))
             @types[namespace][name][element_name][attr] = v.to_s
           end
         end
@@ -198,15 +208,15 @@ module Wasabi
         @types[namespace][name][:order!] << element_name
       end
 
-      type.xpath('./xs:complexContent/xs:extension/xs:sequence/xs:element', 'xs' => XSD).each do |inner_element|
-        element_name = inner_element.attribute('name').to_s
-        @types[namespace][name][element_name] = { :type => inner_element.attribute('type').to_s }
+      type.xpath("./xs:complexContent/xs:extension/xs:sequence/xs:element", "xs" => XSD).each do |inner_element|
+        element_name = inner_element.attribute("name").to_s
+        @types[namespace][name][element_name] = {type: inner_element.attribute("type").to_s}
 
         @types[namespace][name][:order!] << element_name
       end
 
-      type.xpath('./xs:complexContent/xs:extension[@base]', 'xs' => XSD).each do |inherits|
-        base = inherits.attribute('base').value.match(/\w+$/).to_s
+      type.xpath("./xs:complexContent/xs:extension[@base]", "xs" => XSD).each do |inherits|
+        base = inherits.attribute("base").value.match(/\w+$/).to_s
 
         if @types[namespace][base]
           # Reverse merge because we don't want subclass attributes to be overriden by base class
@@ -214,7 +224,7 @@ module Wasabi
           @types[namespace][name][:order!] = @types[namespace][base][:order!] | @types[namespace][name][:order!]
           @types[namespace][name][:base_type] = base
         else
-          p = Proc.new do
+          p = proc do
             if @types[namespace][base]
               # Reverse merge because we don't want subclass attributes to be overriden by base class
               @types[namespace][name] = @types[namespace][base].merge(@types[namespace][name])
@@ -231,100 +241,112 @@ module Wasabi
       deferred_types.each(&:call)
     end
 
+    # wasabi reports a single input and a single output per operation.
+    # When the portType or its message cannot be resolved or doesn't exist
+    # like with a one-way operation, it falls back to the operation name.
     def input_for(operation)
-      input_output_for(operation, 'input')
+      resolve_messages(operation, "input").first || MessageRef.new(nil, operation["name"])
     end
 
     def output_for(operation)
-      input_output_for(operation, 'output')
+      resolve_messages(operation, "output").first || MessageRef.new(nil, operation["name"])
     end
 
-    # @return [namespace_id, message_type]
-    def input_output_for(operation, input_output)
-      operation_name = operation['name']
-
-      # Look up the input by walking up to portType, then up to the message.
-
-      binding_type = operation.parent['type'].to_s.split(':').last
-      if @port_type_operations[binding_type]
-        port_type_operation = @port_type_operations[binding_type][operation_name]
-      end
+    # An operation may declare any number of faults, or none at all.
+    def faults_for(operation)
+      resolve_messages(operation, "fault")
+    end
 
-      port_type_input_output = port_type_operation&.element_children&.find { |node| node.name == input_output }
+    # Resolves the wsdl messages an operation's input, output, or fault elements
+    # point at, by walking up to the portType and down into the messages. Returns
+    # one MessageRef per matching element, so none when there are no matches.
+    #
+    # @return [Array<MessageRef>]
+    def resolve_messages(operation, element_name)
+      port_type_operation = port_type_operation_for(operation)
 
-      # find the message for the portType operation
-      # if there is no message, we will use the operation name as the message name
+      # Sometimes portTypes are actually included in a separate WSDL,
+      # so the portType operation cannot be resolved here.
+      port_type_elements = port_type_operation&.element_children&.select { |node| node.name == element_name } || []
 
-      # TODO: Stupid fix for missing support for imports.
-      # Sometimes portTypes are actually included in a separate WSDL.
-      if port_type_input_output
-        # If the message attribute contains a colon, it means the message is namespaced.
-        if port_type_input_output.attribute('message').to_s.include? ':'
-          port_message_ns_id, port_message_type = port_type_input_output.attribute('message').to_s.split(':')
-        else
-          port_message_type = port_type_input_output.attribute('message').to_s
-        end
+      port_type_elements.each_with_index.map do |port_type_element, index|
+        message_ref_for(operation, port_type_element, element_name, index)
+      end
+    end
 
-        message_ns_id, message_type = nil
+    # Looks up the portType operation matching a binding operation,
+    # walking up to the portType via the binding's type attribute.
+    def port_type_operation_for(operation)
+      binding_type = operation.parent["type"].to_s.split(":").last
+      @port_type_operations.dig(binding_type, operation["name"])
+    end
 
-        # When there is a parts attribute in soap:body element, we should use that value
-        # to look up the message part from messages array.
-        input_output_element = operation.element_children.find { |node| node.name == input_output }
-        if input_output_element
-          soap_body_element = input_output_element.element_children.find { |node| node.name == 'body' }
-          soap_body_parts = soap_body_element['parts'] if soap_body_element
-        end
+    # Resolves a single portType input/output/fault element to the message it
+    # points at, walking portType -> message -> part -> element. Falls back to
+    # the operation name when the message cannot be resolved.
+    #
+    # @return [MessageRef]
+    def message_ref_for(operation, port_type_element, element_name, index)
+      operation_name = operation["name"]
+
+      # If the message attribute contains a colon, the message is namespaced.
+      parts = port_type_element.attribute("message").to_s.split(":", 2)
+      port_message_ns_id, port_message_type = (parts.size == 2) ? parts : [nil, *parts]
+
+      message_ns_id = nil
+      message_type = nil
+
+      # When there is a parts attribute in the soap:body element, use that value
+      # to look up the message part from the messages array.
+      input_output_element = operation.element_children.select { |node| node.name == element_name }.at(index)
+      if input_output_element
+        soap_body_element = input_output_element.element_children.find { |node| node.name == "body" }
+        soap_body_parts = soap_body_element["parts"] if soap_body_element
+      end
 
-        # look for any message part that matches the soap body parts
-        message = @messages[port_message_type]
-        port_message_part = message&.element_children&.find do |node|
-          soap_body_parts.nil? ? (node.name == "part") : (node.name == "part" && node["name"] == soap_body_parts)
-        end
+      # look for any message part that matches the soap body parts
+      message = @messages[port_message_type]
+      port_message_part = message&.element_children&.find do |node|
+        soap_body_parts.nil? ? (node.name == "part") : (node.name == "part" && node["name"] == soap_body_parts)
+      end
 
-        if port_message_part && port_element = port_message_part.attribute('element')
-          port_message_part = port_element.to_s
-          if port_message_part.include?(':')
-            message_ns_id, message_type = port_message_part.split(':')
-          else
-            message_type = port_message_part
-          end
+      if port_message_part && (port_element = port_message_part.attribute("element"))
+        port_message_part = port_element.to_s
+        if port_message_part.include?(":")
+          message_ns_id, message_type = port_message_part.split(":")
+        else
+          message_type = port_message_part
         end
+      end
 
-        # If the message is not found, we should use the operation name as the message name for document style operations
-        # applies only to output
-        if input_output == 'output'
-          # if the operation is document style and theres no port_message_part, we should use the operation_name
-          soap_operation = operation.element_children.find { |node| node.name == 'operation' }
-          if message_type.nil? && (soap_operation.nil? || soap_operation['style'] != 'rpc')
-            if port_message_part.nil?
-              message_ns_id = port_message_ns_id
-              message_type = operation_name
-            else
-              message_ns_id = port_message_ns_id
-              message_type = port_message_type
-            end
-          end
+      # If the message is not found, we should use the operation name as the message name
+      # for document style operations applies only to output
+      if element_name == "output"
+        # if the operation is document style and theres no port_message_part, we should
+        # use the operation_name
+        soap_operation = operation.element_children.find { |node| node.name == "operation" }
+        if message_type.nil? && (soap_operation.nil? || soap_operation["style"] != "rpc")
+          message_ns_id = port_message_ns_id
+          message_type = port_message_part.nil? ? operation_name : port_message_type
         end
+      end
 
-        # Fall back to the name of the binding operation
-        if message_type
-          [message_ns_id, message_type]
-        else
-          [port_message_ns_id, operation_name]
-        end
+      # Fall back to the name of the binding operation
+      if message_type
+        MessageRef.new(message_ns_id, message_type)
       else
-        [nil, operation_name]
+        MessageRef.new(port_message_ns_id, operation_name)
       end
     end
 
     def schemas
-      types = section('types').first
+      types = section("types").first
       types ? types.element_children : []
     end
 
     def service
-      services = section('service')
-      services.first if services  # service nodes could be imported?
+      services = section("service")
+      services&.first  # service nodes could be imported?
     end
 
     def section(section_name)

data/lib/wasabi/resolver.rb

@@ -3,27 +3,25 @@
 require "faraday"
 
 module Wasabi
-
   # = Wasabi::Resolver
   #
   # Resolves local and remote WSDL documents.
   class Resolver
-
     class HTTPError < StandardError
-      def initialize(message, response=nil)
+      def initialize(message, response = nil)
         super(message)
         @response = response
       end
       attr_reader :response
     end
 
-    URL = /^http[s]?:/
+    URL = /^https?:/
     XML = /^</
 
     def initialize(document, request = nil, adapter = nil)
       @document = document
-      @request  = request || Faraday.new
-      @adapter  = adapter
+      @request = request || Faraday.new
+      @adapter = adapter
     end
 
     attr_reader :document, :request, :adapter
@@ -32,9 +30,9 @@ module Wasabi
       raise ArgumentError, "Unable to resolve: #{document.inspect}" unless document
 
       case document
-        when URL then load_from_remote
-        when XML then document
-        else          load_from_disc
+      when URL then load_from_remote
+      when XML then document
+      else load_from_disc
       end
     end
 
@@ -50,7 +48,7 @@ module Wasabi
 
         raise HTTPError.new("Error: #{response.code} for url #{request.url}", response) if response.error?
       else
-        request.adapter *adapter if adapter
+        request.adapter(*adapter) if adapter
         response = request.get(document)
 
         raise HTTPError.new("Error: #{response.status} for url #{document}", response) unless response.success?
@@ -62,6 +60,5 @@ module Wasabi
     def load_from_disc
       File.read(document)
     end
-
   end
 end

data/lib/wasabi/service_ports.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require "uri"
+require "addressable/uri"
+require "wasabi/core_ext/string"
+
+module Wasabi
+  # = Wasabi::ServicePorts
+  #
+  # Parses the +wsdl:service+ ports and +wsdl:binding+ elements of a WSDL
+  # document, so callers can resolve the SOAP endpoint of the port that
+  # serves a given operation instead of always using the first port's
+  # address.
+  class ServicePorts
+    SOAP_1_1 = "http://schemas.xmlsoap.org/wsdl/soap/"
+    SOAP_1_2 = "http://schemas.xmlsoap.org/wsdl/soap12/"
+
+    def initialize(document)
+      @document = document
+    end
+
+    # Returns the parsed service ports as an Array of Hashes with +:name+,
+    # +:binding+ (local binding name), +:address+ (URI) and +:soap_version+
+    # (1, 2 or nil when the address is not a SOAP address) keys, in
+    # document order.
+    def ports
+      @ports ||= parse_ports
+    end
+
+    # Returns the SOAP endpoint (address) of the port serving the given
+    # SOAP operation.
+    #
+    # Walks operation -> portType -> binding -> port, so WSDLs exposing
+    # several ports resolve to the address of the port that actually serves
+    # the operation instead of the first port's address. When +soap_version+
+    # is given, a port for that SOAP version is preferred, but the first
+    # SOAP port for the operation is returned when no port matches the
+    # requested version — routing degrades to the operation's best
+    # available SOAP port instead of silently falling back to the WSDL's
+    # first port. Non-SOAP ports (e.g. +http:address+) are never returned.
+    # Returns +nil+ when the operation has no SOAP ports at all, so
+    # callers can fall back to the default endpoint.
+    def endpoint_for_operation(operation_name, soap_version: nil)
+      port = preferred_port(operation_name, soap_version)
+      port && port[:address]
+    end
+
+    private
+
+    # Returns the preferred SOAP port serving the given SOAP operation.
+    # Ports for the requested SOAP version win; otherwise the first SOAP
+    # port in document order. Returns nil when the operation has no SOAP
+    # ports at all.
+    def preferred_port(operation_name, soap_version)
+      candidates = soap_ports_for_operation(operation_name)
+
+      candidates.find { |port| port[:soap_version] == soap_version } || candidates.first
+    end
+
+    # Returns the SOAP ports serving the given SOAP operation, in document
+    # order. Non-SOAP ports (e.g. +http:address+) and ports with
+    # unparsable addresses never qualify as routing candidates.
+    def soap_ports_for_operation(operation_name)
+      port_type = port_type_for_operation(operation_name)
+      return [] unless port_type
+
+      bindings = parse_bindings
+
+      ports.select { |port|
+        !port[:soap_version].nil? && !port[:address].nil? &&
+          bindings[port[:binding]] == port_type
+      }
+    end
+
+    # Returns the name of the portType defining the given operation.
+    # Operation names are compared snake-cased, like the keys of
+    # Wasabi::Parser#operations.
+    def port_type_for_operation(operation_name)
+      target = operation_name.to_sym
+
+      port_type_operations.each do |port_type_name, operations|
+        match = operations.any? { |name| Wasabi::CoreExt::String.snakecase(name.to_s).to_sym == target }
+        return port_type_name if match
+      end
+
+      nil
+    end
+
+    # Returns a map from portType name to its operation names.
+    def port_type_operations
+      @port_type_operations ||= @document.root.element_children.each_with_object({}) do |node, memo|
+        next unless node.name == "portType"
+
+        operations = node.element_children.select { |child| child.name == "operation" }
+        memo[node["name"]] = operations.map { |operation| operation["name"] }
+      end
+    end
+
+    # Parses every +wsdl:port+ of the service in document order. Address
+    # elements are matched by local name so any namespace prefix works, and
+    # the SOAP version is derived from the address element's namespace.
+    def parse_ports
+      service_node = @document.root.element_children.find { |node| node.name == "service" }
+      return [] unless service_node
+
+      service_node.element_children.each_with_object([]) do |port, memo|
+        next unless port.name == "port"
+
+        address = port.element_children.find { |node| node.name == "address" }
+        next unless address && address["location"]
+
+        memo << {
+          name: port["name"].to_s,
+          binding: local_name(port["binding"]),
+          address: parse_url(address["location"]),
+          soap_version: soap_version_of(address)
+        }
+      end
+    end
+
+    # Parses every +wsdl:binding+ into a map from the local binding name
+    # to the local portType name.
+    def parse_bindings
+      @document.root.element_children.each_with_object({}) do |node, memo|
+        next unless node.name == "binding"
+
+        memo[node["name"].to_s] = local_name(node["type"])
+      end
+    end
+
+    # Returns the local part of a QName ("tns:Foo" -> "Foo").
+    def local_name(qname)
+      qname.to_s.split(":").last.to_s
+    end
+
+    # Returns 1 for SOAP 1.1 addresses, 2 for SOAP 1.2 addresses and nil
+    # for anything else (e.g. http:address ports).
+    def soap_version_of(address)
+      href = address.namespace&.href
+
+      if href == SOAP_1_2
+        2
+      elsif href == SOAP_1_1
+        1
+      end
+    end
+
+    def parse_url(url)
+      unescaped_url = Addressable::URI.unescape(url.to_s)
+      escaped_url = Addressable::URI.escape(unescaped_url)
+      URI(escaped_url)
+    rescue URI::InvalidURIError, Addressable::URI::InvalidURIError
+      nil
+    end
+  end
+end

data/lib/wasabi/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Wasabi
-  VERSION = '5.1.0'
+  VERSION = "5.2.0"
 end

data/lib/wasabi.rb

@@ -3,12 +3,11 @@
 require "wasabi/version"
 require "wasabi/document"
 require "wasabi/resolver"
+require "wasabi/service_ports"
 
 module Wasabi
-
   # Expects a WSDL document and returns a <tt>Wasabi::Document</tt>.
   def self.document(document)
     Document.new(document)
   end
-
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: wasabi
 version: !ruby/object:Gem::Version
-  version: 5.1.0
+  version: 5.2.0
 platform: ruby
 authors:
 - Daniel Harrington
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-10-27 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -73,17 +72,17 @@ files:
 - lib/wasabi/document.rb
 - lib/wasabi/parser.rb
 - lib/wasabi/resolver.rb
+- lib/wasabi/service_ports.rb
 - lib/wasabi/version.rb
 homepage: https://github.com/savonrb/wasabi
 licenses:
 - MIT
 metadata:
-  changelog_uri: https://github.com/savonrb/wasabi/blob/master/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/wasabi/5.1.0
+  changelog_uri: https://github.com/savonrb/wasabi/blob/main/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/wasabi/5.2.0
   source_code_uri: https://github.com/savonrb/wasabi
   bug_tracker_uri: https://github.com/savonrb/wasabi/issues
   rubygems_mfa_required: 'true'
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -98,8 +97,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A simple WSDL parser
 test_files: []