rails-rfc6570 2.2.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d60f820a63bedd023739098fd6635365024e50d57f1d8084ee63bb48e863b7d9
-  data.tar.gz: a674819b673438036ceeee890b5ac490533182e6c0715290c32109dde1e7077a
+  metadata.gz: cb6f9305fdd5bf479a341347ca33add86759ac067ec0ad2bff4e7953d8dcbb4f
+  data.tar.gz: fba3bdf42cd2a5d8d3cfd61030341d1733e9b3806d534fa08bdfee4b33fe61a3
 SHA512:
-  metadata.gz: a761b8f59debaa2abc77ed7d5bb359f41b186839f871c29bfa26077eccf55759b13b19a5f528e2a4921736095b6f0071b554a41e52eb341639a9eb8363efb3ba
-  data.tar.gz: 1e4ae6fa1638a8858130de15d33dcd1be337a72c92f9bbb60a728d2f98e27ff3a5e2ee5c83919fb38b5ea1df74d4cdfe9da7f2114f1f9f7058b0cc17478b5cb4
+  metadata.gz: 0d4a88801f28b407ca01c1258d477cf596944c155a2094b67118e970f8ef8430300f6979967855b97c4ebe7786a909567314f5f8eb34360dbd09ac347ba39cef
+  data.tar.gz: c68fa573cfd3ca16c2f8fcdb46550e0137be207e44c611f24ebcbac14169e4affa2bf680a31ca779577abad0531cccc240a548ca6d7b533ef6a8655b09186ca6

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 2.3.0
+
+* Newly written visitor and formatter to improve performance (#3)
+* Nested groups are expanded into a list of groups
+
 ## 2.2.0
 
 * Add support to Rails 5.2 to gemspec

data/README.md

@@ -93,7 +93,7 @@ class UserDecorator < Draper::Decorator
 end
 ```
 
-This gem does not support every construct possible with route matchers especially nested groups cannot be expressed in URI templates. It also makes some assumptions when converting splat matchers like swallowing a multiple slashes.
+This gem does not support every construct possible with route matchers especially nested groups cannot be expressed in URI templates. They are expanded into separate groups. It also makes some assumptions when converting splat matchers like swallowing a multiple slashes. An error is raised when routes with OR-clauses are tried to be converted.
 
 You can also combine **Rails::RFC6570** with [rack-link_headers](https://github.com/jgraichen/rack-link_headers) and provide hypermedia linking everywhere!
 

data/lib/rails/rfc6570.rb

@@ -1,168 +1,10 @@
 # frozen_string_literal: true
 
-require 'rails/rfc6570/version'
-
-module ActionDispatch
-  module Journey
-    module Visitors
-      class RFC6570 < Visitor # rubocop:disable ClassLength
-        DISPATCH_CACHE = {} # rubocop:disable MutableConstant
-
-        def initialize(opts = {})
-          super()
-
-          @opts        = opts
-          @stack       = []
-          @group_depth = 0
-        end
-
-        def ignore
-          @opts.fetch(:ignore) { %w[format] }
-        end
-
-        def route
-          @route ||= @opts[:route]
-        end
-
-        # rubocop:disable AbcSize
-        def accept(node)
-          str = visit(node)
-
-          if @opts.fetch(:params, true) && route
-            controller = route.defaults[:controller].to_s
-            action     = route.defaults[:action].to_s
-
-            if controller.present? && action.present?
-              params = Rails::RFC6570.params_for(controller, action)
-              str += '{?' + params.join(',') + '}' if params&.any?
-            end
-          end
-
-          str
-        end
-        # rubocop:enable all
-
-        def visit(node)
-          @stack.unshift node.type
-          send DISPATCH_CACHE.fetch(node.type), node
-        ensure
-          @stack.shift
-        end
-
-        def symbol_name(node)
-          name = node.to_s.tr '*:', ''
-
-          if ignore.include?(name)
-            nil
-          else
-            name
-          end
-        end
-
-        def placeholder(node, prefix = nil, suffix = nil, pretext = nil)
-          name = symbol_name node
-          if name
-            "#{pretext}{#{prefix}#{name}#{suffix}}"
-          else
-            ''
-          end
-        end
-
-        # rubocop:disable AbcSize
-        # rubocop:disable CyclomaticComplexity
-        # rubocop:disable MethodLength
-        # rubocop:disable PerceivedComplexity
-        def binary(node)
-          case [node.left.type, node.right.type]
-            when %i[DOT SYMBOL]
-              if @stack[0..1] == %i[CAT GROUP]
-                placeholder node.right, '.'
-              else
-                placeholder(node.right, nil, nil, '.')
-              end
-            when %i[SLASH SYMBOL]
-              if @stack[0..1] == %i[CAT GROUP]
-                placeholder(node.right, '/')
-              else
-                placeholder(node.right, nil, nil, '/')
-              end
-            when %i[SLASH STAR]
-              placeholder node.right, '/', '*'
-            when %i[SLASH CAT]
-              if node.right.left.type == :STAR
-                placeholder(node.right.left, '/', '*') +
-                  visit(node.right.right)
-              else
-                [visit(node.left), visit(node.right)].join
-              end
-            when %i[CAT STAR]
-              visit(node.left).to_s.gsub(%r{/+$}, '') +
-                placeholder(node.right, '/', '*')
-            else
-              [visit(node.left), visit(node.right)].join
-          end
-        end
-        # rubocop:enable all
-
-        def terminal(node)
-          node.left
-        end
-
-        def nary(node)
-          node.children.each {|c| visit(c) }
-        end
-
-        def unary(node)
-          visit(node.left)
-        end
-
-        # rubocop:disable MethodName
-        def visit_CAT(node)
-          binary(node)
-        end
-
-        def visit_LITERAL(node)
-          terminal(node)
-        end
-
-        def visit_SLASH(node)
-          terminal(node)
-        end
+require 'action_dispatch/journey'
 
-        def visit_DOT(node)
-          terminal(node)
-        end
-
-        def visit_SYMBOL(node)
-          placeholder(node)
-        end
-
-        def visit_OR(node)
-          nary(node)
-        end
-
-        def visit_STAR(node)
-          unary(node)
-        end
-
-        def visit_GROUP(node)
-          raise 'Cannot transform nested groups.' if @group_depth >= 1
-
-          @group_depth += 1
-          visit node.left
-        ensure
-          @group_depth -= 1
-        end
-        # rubocop:enable MethodName
-
-        instance_methods(true).each do |meth|
-          next unless meth =~ /^visit_(.*)$/
-          DISPATCH_CACHE[Regexp.last_match(1).to_sym] = meth
-        end
-      end
-    end
-  end
-end
+require 'rails/rfc6570/formatter'
+require 'rails/rfc6570/version'
+require 'rails/rfc6570/visitor'
 
 module Rails
   module RFC6570
@@ -170,7 +12,6 @@ module Rails
       class Railtie < ::Rails::Railtie # :nodoc:
         initializer 'rails-rfc6570', group: :all do |_app|
           require 'rails/rfc6570/patches'
-          require 'action_dispatch/journey'
 
           MAJOR = Rails::VERSION::MAJOR
           MINOR = Rails::VERSION::MINOR
@@ -184,9 +25,6 @@ module Rails
           ::ActionDispatch::Journey::Route.send :include,
             Rails::RFC6570::Extensions::JourneyRoute
 
-          ::ActionDispatch::Journey::Nodes::Node.send :include,
-            Rails::RFC6570::Extensions::JourneyNode
-
           ::ActiveSupport.on_load(:action_controller) do
             include Rails::RFC6570::Helper
             extend Rails::RFC6570::ControllerExtension
@@ -207,7 +45,6 @@ module Rails
           Hash[routes.map {|n, r| [n, r.to_rfc6570(opts)] }]
         end
 
-        # rubocop:disable AbcSize
         # rubocop:disable MethodLength
         def define_rfc6570_helpers(name, route, mod, set)
           rfc6570_name      = :"#{name}_rfc6570"
@@ -224,11 +61,13 @@ module Rails
             end
 
             define_method(rfc6570_url_name) do |opts = {}|
-              send rfc6570_name, opts.merge(path_only: false)
+              ::Rails::RFC6570.build_url_template(self, route,
+                opts.merge(path_only: false))
             end
 
             define_method(rfc6570_path_name) do |opts = {}|
-              send rfc6570_name, opts.merge(path_only: true)
+              ::Rails::RFC6570.build_url_template(self, route,
+                opts.merge(path_only: true))
             end
           end
 
@@ -248,14 +87,8 @@ module Rails
 
       module JourneyRoute
         def to_rfc6570(opts = {})
-          path.spec.to_rfc6570 opts.merge(route: self)
-        end
-      end
-
-      module JourneyNode
-        def to_rfc6570(opts = {})
-          ::Addressable::Template.new \
-            ::ActionDispatch::Journey::Visitors::RFC6570.new(opts).accept(self)
+          @rfc6570_formatter ||= RFC6570::Formatter.new(self)
+          @rfc6570_formatter.evaluate(opts)
         end
       end
     end
@@ -274,7 +107,7 @@ module Rails
         route = Rails.application.routes.named_routes[name]
         raise KeyError.new "No named routed for `#{name}'." unless route
 
-        ::Rails::RFC6570.build_url_template(self, route, opts)
+        route.to_rfc6570(**opts, ctx: self)
       end
     end
 
@@ -292,29 +125,6 @@ module Rails
       end
     end
 
-    # rubocop:disable MethodLength
-    def build_url_template(t, route, options)
-      template = route.to_rfc6570(options)
-
-      if options.fetch(:path_only, false)
-        template
-      else
-        options = t.url_options.merge(options)
-        options[:path] = template.pattern
-
-        original_script_name = options.delete(:original_script_name)
-
-        if original_script_name
-          options[:script_name] = original_script_name + options[:script_name]
-        end
-
-        url = ActionDispatch::Http::URL.url_for(options)
-
-        ::Addressable::Template.new(url)
-      end
-    end
-    # rubocop:enable all
-
     def params_for(controller, action)
       ctr = "#{controller.camelize}Controller".constantize
       ctr.rfc6570_defs[action.to_sym] if ctr.respond_to?(:rfc6570_defs)
@@ -322,6 +132,10 @@ module Rails
       nil
     end
 
+    def build_url_template(ctx, route, **kwargs)
+      route.to_rfc6570(ctx: ctx, **kwargs)
+    end
+
     extend self # rubocop:disable ModuleFunction
   end
 end

data/lib/rails/rfc6570/formatter.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Rails
+  module RFC6570
+    class Formatter
+      attr_reader :route
+
+      def initialize(route)
+        @route = route
+        @parts = Visitor.new(factory: method(:symbol)).accept(route.path.spec)
+      end
+
+      def evaluate(ignore: %w[format], ctx:, **kwargs)
+        parts = @parts.reject do |part|
+          part.is_a?(Subst) && ignore.include?(part.name)
+        end
+
+        if kwargs.fetch(:params, true) && route
+          controller = route.defaults[:controller].to_s
+          action     = route.defaults[:action].to_s
+
+          if controller.present? && action.present?
+            params = ::Rails::RFC6570.params_for(controller, action)
+            parts << '{?' + params.join(',') + '}' if params&.any?
+          end
+        end
+
+        if kwargs.fetch(:path_only, false)
+          ::Addressable::Template.new parts.join
+        else
+          options = ctx.url_options.merge(kwargs)
+          options[:path] = parts.join
+
+          if (osn = options.delete(:original_script_name))
+            options[:script_name] = osn + options[:script_name]
+          end
+
+          ::Addressable::Template.new \
+            ActionDispatch::Http::URL.url_for(options)
+        end
+      end
+
+      def symbol(node, prefix: nil, suffix: nil)
+        Subst.new(node.name, "{#{prefix}#{node.name}#{suffix}}")
+      end
+
+      Subst = Struct.new(:name, :to_s)
+    end
+  end
+end

data/lib/rails/rfc6570/version.rb

@@ -4,7 +4,7 @@ module Rails
   module RFC6570
     module VERSION
       MAJOR = 2
-      MINOR = 2
+      MINOR = 3
       PATCH = 0
       STAGE = nil
 

data/lib/rails/rfc6570/visitor.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Rails
+  module RFC6570
+    class Visitor < ::ActionDispatch::Journey::Visitors::Visitor
+      DISPATCH_CACHE = {} # rubocop:disable MutableConstant
+
+      def initialize(factory: nil)
+        super()
+
+        @stack   = []
+        @factory = factory || method(:symbolize)
+      end
+
+      def accept(node)
+        Array(visit(node)).flatten
+      end
+
+      def visit(node)
+        @stack.unshift node.type
+        send DISPATCH_CACHE.fetch(node.type), node
+      ensure
+        @stack.shift
+      end
+
+      def terminal(node)
+        node.left
+      end
+
+      # rubocop:disable MethodName
+      def visit_CAT(node)
+        if (mth = DISPATCH_CACHE[:"#{node.left.type}_#{node.right.type}"])
+          send mth, node.left, node.right
+        else
+          [visit(node.left), visit(node.right)]
+        end
+      end
+
+      def visit_LITERAL(node)
+        terminal(node)
+      end
+
+      def visit_SLASH(node)
+        terminal(node)
+      end
+
+      def visit_DOT(node)
+        terminal(node)
+      end
+
+      def visit_SYMBOL(node)
+        symbol(node)
+      end
+
+      def visit_OR(_node)
+        raise 'OR nodes cannot be serialized to URI templates'
+      end
+
+      def visit_GROUP(node)
+        # if @stack.include?(:GROUP) && @stack[1..-1].include?(:GROUP)
+        #   raise 'Cannot transform nested groups.'
+        # end
+
+        visit node.left
+      end
+
+      def visit_DOT_SYMBOL(dot, node)
+        if @stack[0..1] == %i[CAT GROUP]
+          symbol(node, prefix: '.')
+        else
+          [visit(dot), visit(node)]
+        end
+      end
+
+      def visit_SLASH_SYMBOL(slash, node)
+        if @stack[0..1] == %i[CAT GROUP]
+          symbol(node, prefix: '/')
+        else
+          [visit(slash), visit(node)]
+        end
+      end
+
+      # rubocop:disable AbcSize
+      def visit_SLASH_CAT(slash, cat)
+        if cat.left.type == :STAR
+          [symbol(cat.left.left, prefix: '/', suffix: '*'), visit(cat.right)]
+        elsif cat.left.type == :SYMBOL && @stack[0..1] == %i[CAT GROUP]
+          [symbol(cat.left, prefix: '/'), visit(cat.right)]
+        else
+          [visit(slash), visit(cat)]
+        end
+      end
+      # rubocop:enable AbcSize
+
+      def visit_SLASH_STAR(_slash, star)
+        symbol(star.left, prefix: '/', suffix: '*')
+      end
+
+      def visit_STAR_CAT(star, cat)
+        [symbol(star.left, prefix: '/', suffix: '*'), visit(cat)]
+      end
+      # rubocop:enable MethodName
+
+      instance_methods(true).each do |meth|
+        next unless meth =~ /^visit_(.*)$/
+        DISPATCH_CACHE[Regexp.last_match(1).to_sym] = meth
+      end
+
+      private
+
+      def symbol(node, **kwargs)
+        @factory.call(node, **kwargs)
+      end
+
+      def symbolize(node, prefix: nil, suffix: nil)
+        "{#{prefix}#{node.name}#{suffix}}"
+      end
+    end
+  end
+end