openapi_first 4.2.0 → 4.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 70cf5324252fd4c36421cb732127b220e45c3eefbafba7ed63ee513aea2d5b84
-  data.tar.gz: 43358cb067c765b59920160f589eb929216a9721b806a4a37b24ab039f536599
+  metadata.gz: db682408d3927edb6c83c2778f16edecfa428c3e85bdc33ec96664259ddd3f0b
+  data.tar.gz: 4519ccef3e6c27da6372f52fea09a1e36aa09b5648534edce6caf4d7bdbca8b3
 SHA512:
-  metadata.gz: d1b97b74dcdf98616c0f51c3e6a2c53cedb3685518f9697491eadca4110d39f12f68c54769535e6d171bf401d8d47085279124d70534fb5959c47cdf3b4d4eda
-  data.tar.gz: a27158cbd2760fa99de1f26193ce5450f5d2ef409c4a780da94ab102c24439dd1d149d6824a99cc8287617cd999cccc9de4989a33edaaaad2debfd7045a3892e
+  metadata.gz: d37cc2c5d0d99331907a5d565eba3a404e492c7cef71c154e5badd52fe05fb2c7761d17cbe2f94dfec14cda1df59e354f5848bcdc44b515069d325a1316d14aa
+  data.tar.gz: 20d09dc7debef84d08504202bd6b2acabc33d172486d79d82685bce22362dbf15f920bda84287619bc7517f42da5701c454bf1e23c74a7eeb0c870ab8ae7025c

data/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## Unreleased
 
+## 4.3.0
+
+- Fix: Passing a block to `config.register` not works when called inside `OpenapiFirst.configure` block. Before the block was ignored.
+- Faster routing for OADs with many dynamic paths. The router now looks up path templates in a prefix tree of path segments instead of trying each template one by one.
+- Changed: If more than one path template matches a request path, the router now compares the templates segment by segment from left to right. For example `/users/{id}/{action}` wins over `/{tenant}/settings/profile` for `/users/settings/profile`. Before, the template with more literal characters overall won.
+
+## 4.2.1
+
+- Fix deprecation warnings when using multi_json >= 1.21. openapi_first now uses `MultiJSON.parse`/`MultiJSON.generate` if available ([#508](https://github.com/ahx/openapi_first/issues/508)).
+
 ## 4.2.0
 
 - Added `config.regexp_resolver` configuration option, `'ruby'` (default) or `'ecma'` (also as Symbol). The value is passed to json_schemer's `regexp_resolver` configuration. In OpenAPI, the pattern keyword specifies a regular expression that must conform to the ECMA-262 standard. So using `'ecma'` is recommended.

data/lib/openapi_first/configuration.rb

@@ -19,8 +19,8 @@ module OpenapiFirst
       @regexp_resolver = nil
     end
 
-    def register(path_or_definition, as: :default)
-      OpenapiFirst.register(path_or_definition, as:)
+    def register(path_or_definition, as: :default, &)
+      OpenapiFirst.register(path_or_definition, as:, &)
     end
 
     attr_reader :hooks, :request_validation_error_response, :regexp_resolver

data/lib/openapi_first/definition.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative 'path_template'
 require_relative 'builder'
 require 'forwardable'
 
@@ -80,8 +81,7 @@ module OpenapiFirst
       request_def = routes.lazy.flat_map(&:requests).find { |r| r.operation_id == operation_id.to_s }
       raise ArgumentError, "Operation #{operation_id.inspect} is not defined in #{key}." unless request_def
 
-      request_def.path.gsub(/\{([^}]+)\}/) do
-        name = Regexp.last_match(1)
+      PathTemplate.expand(request_def.path) do |name|
         params.fetch(name.to_sym) do
           params.fetch(name) do
             raise ArgumentError, "Missing path parameter #{name.inspect} for operation #{operation_id.inspect}."

data/lib/openapi_first/json.rb

@@ -1,22 +1,25 @@
 # frozen_string_literal: true
 
 # This tries to load MultiJson if available to keep compatibility
-# with MultiJson until next major version
+# with MultiJson
 
 begin
   require 'multi_json'
+
   module OpenapiFirst
     # Compatibility with MultiJson
     # @visibility private
     module JSON
-      ParserError = MultiJson::ParseError
-
-      def self.parse(string)
-        MultiJson.load(string)
-      end
-
-      def self.generate(object)
-        MultiJson.dump(object)
+      if defined?(::MultiJSON)
+        # multi_json >= 1.21.0
+        ParserError = MultiJSON::ParseError
+        def self.parse(string) = MultiJSON.parse(string)
+        def self.generate(object) = MultiJSON.generate(object)
+      else
+        # multi_json < 1.21.0
+        ParserError = MultiJson::ParseError
+        def self.parse(string) = MultiJson.load(string)
+        def self.generate(object) = MultiJson.dump(object)
       end
     end
   end

data/lib/openapi_first/path_template.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module OpenapiFirst
+  # Path templating as described in https://spec.openapis.org/oas/v3.1.0#path-templating
+  # @visibility private
+  module PathTemplate
+    VARIABLE = /\{(?<name>[^{}]+)\}/
+    SEGMENT_VARIABLE = /\A#{VARIABLE}\z/
+
+    # @return [Boolean] whether the path contains at least one variable
+    def self.template?(path)
+      path.match?(VARIABLE)
+    end
+
+    # @return [Boolean] whether the path segment consists of exactly one variable
+    def self.variable?(segment)
+      segment.match?(SEGMENT_VARIABLE)
+    end
+
+    # @return [Array<String>] the variable names in order of appearance
+    def self.variable_names(template)
+      template.scan(VARIABLE).flatten
+    end
+
+    # Replaces each variable with the value the block returns for its name
+    def self.expand(template)
+      template.gsub(VARIABLE) { yield Regexp.last_match(:name) }
+    end
+  end
+end

data/lib/openapi_first/registry.rb

@@ -23,7 +23,6 @@ module OpenapiFirst
           "#{name}.register(#{path_or_definition.inspect}, as: :my_other_api)"
         )
       end
-
       definition = OpenapiFirst.load(path_or_definition, &)
       definitions[as] = definition
       definition

data/lib/openapi_first/router/path_trie.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative '../path_template'
+require_relative 'segment_pattern'
+
+module OpenapiFirst
+  class Router
+    # @visibility private
+    class PathTrie
+      def initialize
+        @static = {}
+        @partial = {}
+        @variable = nil
+        @leaf = nil
+      end
+
+      def add(template, value)
+        names = PathTemplate.variable_names(template)
+        node = template.split('/', -1).reduce(self) { |parent, segment| parent.child(segment) }
+        node.leaf ||= [value, names]
+      end
+
+      def match(path)
+        values = []
+        value, names = find(path.split('/', -1), 0, values)
+        [value, names.zip(values).to_h] if value
+      end
+
+      def find(segments, index, values)
+        return @leaf if index == segments.size
+
+        @static[segments[index]]&.find(segments, index + 1, values) ||
+          find_partial(segments, index, values) ||
+          find_variable(segments, index, values)
+      end
+
+      protected
+
+      attr_accessor :leaf
+
+      def child(segment)
+        return @variable ||= PathTrie.new if PathTemplate.variable?(segment)
+        return partial_child(segment) if PathTemplate.template?(segment)
+
+        @static[segment] ||= PathTrie.new
+      end
+
+      private
+
+      def find_partial(segments, index, values)
+        @partial.each_value do |pattern, node|
+          captures = pattern.match(segments[index])
+          next unless captures
+
+          values.concat(captures)
+          found = node.find(segments, index + 1, values)
+          return found if found
+
+          values.pop(captures.size)
+        end
+        nil
+      end
+
+      def find_variable(segments, index, values)
+        segment = segments[index]
+        return if @variable.nil? || segment.empty?
+
+        values << segment
+        found = @variable.find(segments, index + 1, values)
+        values.pop unless found
+        found
+      end
+
+      def partial_child(segment)
+        @partial[segment] ||= [SegmentPattern.new(segment), PathTrie.new]
+        @partial = @partial.sort_by.with_index { |(key, _), i| [-literal_length(key), i] }.to_h
+        @partial[segment].last
+      end
+
+      def literal_length(segment)
+        segment.gsub(PathTemplate::VARIABLE, '').length
+      end
+    end
+  end
+end

data/lib/openapi_first/router/segment_pattern.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative '../path_template'
+
+module OpenapiFirst
+  class Router
+    # Matches one path segment against a segment of a path template that mixes literals and variables
+    # @visibility private
+    class SegmentPattern
+      def initialize(segment)
+        @pattern = build_pattern(segment)
+      end
+
+      # @return [Array<String>, nil] the variable values in order of appearance, or nil
+      def match(segment)
+        @pattern.match(segment)&.captures
+      end
+
+      private
+
+      def build_pattern(segment)
+        parts = segment.split(PathTemplate::VARIABLE).each_slice(2).map do |literal, name|
+          "#{Regexp.escape(literal)}#{'([^/?#]+)' if name}"
+        end
+        /\A#{parts.join}\z/
+      end
+    end
+  end
+end

data/lib/openapi_first/router.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'router/path_template'
+require_relative 'path_template'
+require_relative 'router/path_trie'
 require_relative 'router/find_content'
 require_relative 'router/find_response'
 
@@ -27,15 +28,14 @@ module OpenapiFirst
 
     def initialize
       @static = {}
-      @dynamic = {} # TODO: use a trie or similar
+      @dynamic = {}
+      @trie = PathTrie.new
     end
 
     # Returns an enumerator of all routes
     def routes
       @static.chain(@dynamic).lazy.flat_map do |path, request_methods|
-        request_methods.filter_map do |request_method, content|
-          next if request_method == :template
-
+        request_methods.map do |request_method, content|
           Route.new(path:, request_method:, requests: content.requests.each_value.lazy.uniq,
                     responses: content.responses.each_value.lazy.flat_map(&:values))
         end
@@ -95,7 +95,7 @@ module OpenapiFirst
     def route_at(path, request_method)
       request_method = request_method.upcase
       path_item = if PathTemplate.template?(path)
-                    @dynamic[path] ||= { template: PathTemplate.new(path) }
+                    @dynamic[path] ||= {}.tap { @trie.add(path, _1) }
                   else
                     @static[path] ||= {}
                   end
@@ -112,15 +112,7 @@ module OpenapiFirst
       found = @static[request_path]
       return [found, {}] if found
 
-      @dynamic.each_value.reduce(nil) do |best, path_item|
-        params = path_item[:template].match(request_path)
-        next best unless params
-
-        candidate = [path_item, params]
-        next candidate unless best
-
-        params.values.sum(&:length) < best[1].values.sum(&:length) ? candidate : best
-      end
+      @trie.match(request_path)
     end
   end
 end

data/lib/openapi_first/sinatra.rb

@@ -62,9 +62,6 @@ module OpenapiFirst
   # encoded characters, ...) - a request Sinatra matches is not re-checked against openapi_first's own
   # path matching. Avoid path shapes where the two routers disagree.
   module Sinatra
-    PATH_PARAMETER = /\{[^}]+\}/
-    private_constant :PATH_PARAMETER
-
     # The configuration lives in Sinatra settings (rather than plain instance variables) so a
     # subclass of a configured app inherits the loaded description and its operation index.
     def self.registered(app)
@@ -133,7 +130,7 @@ module OpenapiFirst
     end
 
     def operation_handler(path_template, block)
-      param_names = path_template.scan(PATH_PARAMETER).map! { |placeholder| placeholder[1..-2] }
+      param_names = PathTemplate.variable_names(path_template)
       proc do |*captures|
         path_params = param_names.zip(captures).to_h
         validated = settings.openapi_definition.validate_request(request, path_template:, path_params:)
@@ -147,7 +144,7 @@ module OpenapiFirst
     end
 
     def sinatra_pattern(path)
-      path.gsub(PATH_PARAMETER) { |placeholder| ":#{placeholder[1..-2].gsub(/[^A-Za-z0-9_]/, '_')}" }
+      PathTemplate.expand(path) { |name| ":#{name.gsub(/[^A-Za-z0-9_]/, '_')}" }
     end
 
     def build_operation_index(definition)

data/lib/openapi_first/test/configuration.rb

@@ -25,8 +25,8 @@ module OpenapiFirst
       # Register OADs, but don't load them just yet
       # @param [OpenapiFirst::OAD] oad The OAD to register
       # @param [Symbol] as The name to register the OAD under
-      def register(oad, as: :default)
-        Test.register(oad, as:)
+      def register(oad, as: :default, &)
+        Test.register(oad, as:, &)
       end
 
       # Observe a rack app

data/lib/openapi_first/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OpenapiFirst
-  VERSION = '4.2.0'
+  VERSION = '4.3.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openapi_first
 version: !ruby/object:Gem::Version
-  version: 4.2.0
+  version: 4.3.0
 platform: ruby
 authors:
 - Andreas Haller
@@ -108,6 +108,7 @@ files:
 - lib/openapi_first/parameter_content_parsers.rb
 - lib/openapi_first/parameters_parser.rb
 - lib/openapi_first/parsed_request.rb
+- lib/openapi_first/path_template.rb
 - lib/openapi_first/plugins.rb
 - lib/openapi_first/plugins/x_public.rb
 - lib/openapi_first/query_string_parser.rb
@@ -125,7 +126,8 @@ files:
 - lib/openapi_first/router.rb
 - lib/openapi_first/router/find_content.rb
 - lib/openapi_first/router/find_response.rb
-- lib/openapi_first/router/path_template.rb
+- lib/openapi_first/router/path_trie.rb
+- lib/openapi_first/router/segment_pattern.rb
 - lib/openapi_first/schema/hash.rb
 - lib/openapi_first/schema/validation_error.rb
 - lib/openapi_first/schema/validation_result.rb

data/lib/openapi_first/router/path_template.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module OpenapiFirst
-  class Router
-    # @visibility private
-    class PathTemplate
-      # See also https://spec.openapis.org/oas/v3.1.0#path-templating
-      TEMPLATE_EXPRESSION = /(\{[^{}]+\})/
-
-      def self.template?(string)
-        string.include?('{')
-      end
-
-      def initialize(template)
-        @template = template
-        @pattern = build_pattern(template)
-      end
-
-      def to_s
-        @template
-      end
-
-      def match(path)
-        return {} if path == @template
-
-        matches = path.match(@pattern)
-        return unless matches
-
-        matches.named_captures
-      end
-
-      private
-
-      def build_pattern(template)
-        parts = template.split(TEMPLATE_EXPRESSION).map! do |part|
-          if part.start_with?('{')
-            "(?<#{part[1..-2]}>[^/?#]+)"
-          else
-            Regexp.escape(part)
-          end
-        end
-
-        /^#{parts.join}$/
-      end
-    end
-  end
-end