jets 3.1.0 → 5.0.0

data/lib/jets/router/helpers/named_routes/generated.rb

@@ -0,0 +1,197 @@
+require 'active_support/core_ext/module/remove_method'
+
+module Jets::Router::Helpers::NamedRoutes
+  module Generated
+    def create_helper_module(route_set)
+      module_name = helper_module_name(route_set)
+      module_name.constantize rescue create_helper_module!(module_name, route_set)
+    end
+
+    def helper_module_name(route_set)
+      engine_class = route_set.engine.class
+      name = engine_class == Jets.app_class ? "main_app" : engine_class.engine_name
+      name = name.gsub('::','')
+      name = "#{name.camelize}Helpers" # MainAppHelpers or BlorghHelpers
+      "Jets::Router::Helpers::NamedRoutes::Generated::#{name}"
+    end
+
+    def create_helper_module!(module_name, route_set)
+      mod = Module.new do
+        extend ActiveSupport::Concern # Needed for _url_for_modules to work since or UrlHelper ClassMethods not included
+        mattr_accessor :path_helpers, default: Set.new
+        mattr_accessor :url_helpers, default: Set.new
+
+        include AddFullUrl
+
+        # For compatibility with Rails url_helpers
+        include ActionDispatch::Routing::UrlFor
+        define_singleton_method(:_routes) { route_set } # needed for controller class context
+        define_method(:_routes) { route_set } # needed for view context
+        # Jets convenience method
+        define_singleton_method(:route_set) { route_set }
+
+        define_singleton_method(:_url_for_modules) { ActionView::RoutingUrlFor }
+        define_method(:_url_for_modules) { ActionView::RoutingUrlFor }
+
+        # Mimic Rails behavior
+        # Precdence:
+        #   1. config.action_mailer.default_url_options
+        #   2. Jets.application.default_url_options
+        def default_url_options
+          self.class.default_url_options.empty? ? Jets.application.default_url_options : self.class.default_url_options
+        end
+
+        def add_methods!
+          route_set.routes.each do |route|
+            next unless route.as
+            next if route.engine?
+
+            name = route.as
+            path_name = "#{name}_path"
+            url_name  = "#{name}_url"
+            engine_class = route_set.engine.class
+
+            # Normally, self is <PostsController> or View context instance
+            define_method(path_name) do |*args|
+              NamedRouteMethod.new(route, args, self, engine_class).path
+            end
+            self.path_helpers.add(path_name)
+
+            define_method(url_name) do |*args|
+              path = send(path_name, *args)
+              options = args.extract_options!
+              add_full_url(options.merge(path: path))
+            end
+            self.url_helpers.add(url_name)
+          end
+        end
+
+        def remove_methods!
+          remove = Proc.new { |method| remove_method(method) }
+          path_helpers.each(&:remove)
+          url_helpers.each(&:remove)
+          self.path_helpers.clear
+          self.url_helpers.clear
+        end
+
+        # Wonder if extend self is may idea since it can allow context to be module itself
+        # instead of the controller or view instance. However, it allows
+        # Jets.application.routes.url_helpers.posts_path style calls in jets console
+        extend self
+
+        add_methods!
+      end
+
+      # Name it instead of using anonymous module to help debugging
+      # IE: Jets::Router::Helpers::NamedRoutes::Generated::MainAppHelpers
+      basename = module_name.split('::').last.to_sym
+      Jets::Router::Helpers::NamedRoutes::Generated.const_set(basename, mod)
+
+      define_mounted_helper(mod, route_set)
+
+      mod
+    end
+
+    def define_mounted_helper(mod, route_set)
+      name = mod.name.split('::').last.sub('Helpers','').underscore.to_sym
+      return if MountedHelpers.method_defined?(name)
+
+      helpers_module = route_set.url_helpers
+
+      MountedHelpers.class_eval do
+        define_method "_#{name}" do
+          Jets::Router::Helpers::NamedRoutes::Proxy.new(self, helpers_module)
+        end
+      end
+
+      MountedHelpers.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        def #{name}
+          @_#{name} ||= _#{name}
+        end
+      RUBY
+    end
+
+    module MountedHelpers
+      extend ActiveSupport::Concern
+    end
+
+    # Contains all the mounted helpers across different
+    # engines and the `main_app` helper for the application.
+    # You can include this in your classes if you want to
+    # access routes for other engines.
+    def mounted_helpers
+      MountedHelpers
+    end
+
+    extend self
+  end
+
+  class NamedRouteMethod
+    include Jets::Controller::Decorate::ApigwStage
+
+    attr_reader :options
+    def initialize(route, args, context, engine_class)
+      @route, @args, @context, @engine_class = route, args, context, engine_class
+      @path = route.path # With placeholders still IE: /posts/:id
+      @options = normalize_options(@path, args)
+    end
+
+    # Normalized with format in options
+    # Helps to mimic Rails behavior.
+    # Processes extra arguments to support format and query string.
+    #
+    #    post_path(post, "json", {foo: 'bar'}) => "/posts/1.json?foo=bar"
+    #    post_path(post, {foo: 'bar'})         => "/posts/1?foo=bar"
+    #
+    def normalize_options(path, args)
+      args = args.dup
+      options = args.extract_options!
+      # If there is still an argument in rest, it's the format. Rails behavior.
+      rest = args[placeholders.size..-1]
+      format = rest.last
+      options[:format] = format if format
+      options
+    end
+
+    def path
+      query_string = @options.dup # make copy to modify
+      format = query_string.delete(:format)
+      query_string.delete(:action)
+      query_string.delete(:controller)
+      query_string.delete(:only_path)
+
+      path = path_with_replaced_placeholders
+      path = prepend_engine_mounted_at(path)
+      path = "#{path}.#{format}" if format
+      path = "#{path}?#{query_string.to_query}" unless query_string.empty?
+      path = add_apigw_stage(path)
+      path
+    end
+
+    # Needed for add_apigw_stage
+    delegate :event, :request, to: :@context
+
+    # IE: /posts/1
+    def path_with_replaced_placeholders
+      path = @path
+      placeholders.each_with_index do |placeholder, index|
+        path = path.gsub(placeholder, @args[index].to_param)
+      end
+      path
+    end
+
+    def placeholders
+      @path.scan(/:\w+/)
+    end
+
+    def prepend_engine_mounted_at(path)
+      mount = Jets::Router::EngineMount.find_by(engine: @engine_class)
+      if mount
+        path = path.delete_prefix('/')
+        [mount.at, path].compact.join('/')
+      else
+        path
+      end
+    end
+  end
+end

data/lib/jets/router/helpers/named_routes/proxy.rb

@@ -0,0 +1,66 @@
+module Jets::Router::Helpers::NamedRoutes
+  class Proxy
+    include AddFullUrl
+
+    def initialize(view_context, helpers_module)
+      @helpers = helpers_class(helpers_module).new(view_context)
+    end
+
+    # * The helpers_module is passed as a argument to give the anonymous class
+    #   access via closure at include time.
+    # * view_context is passed at initialize to provide access at instantiation time.
+    def helpers_class(helpers_module)
+      Class.new do
+        include helpers_module # IE: Generated::MainAppHelpers
+        def initialize(view_context)
+          @view_context = view_context
+        end
+
+        # Important:
+        #
+        # * The add_full_url method needs url_options.
+        #   Without url_options the proxy methods are unavailable and creates
+        #   an infinite loop with method_missing.
+        # * request is needed for add_apigw_stage? to check request correctly
+        #   Otherwise, gems like kingsman, that use the named routes proxy methods,
+        #   won't get able to get the correct url with the stage name prepended.
+        #
+        # The request is the main reason an anonymous class is used since the
+        # view_context has included modules like ApigwStage that assume a
+        # request method is available.
+        delegate :url_options, :request, :event, to: :@view_context
+      end
+    end
+
+    # No need to check respond_to? and call raise NoMethodError again because anonymous
+    # class will already return a undefined method error.
+    #
+    # It's annoying that we need to add_full_url here because
+    # the proxy calls the url methods with a module view_context instead
+    # of the controller or view_context instance. So we don't have access to
+    # the request and url_options.  The url_options are only available in the controller
+    # or view_context instance.
+    #
+    # So we call the path method instead and then add_full_url here.
+    # Not calling the url method directly because could add the full url twice,
+    # when the user is setting the default_url_options.
+    # Also calling the url method would cause an error because request and url_options
+    # is not available.
+    #
+    # The logic is a bit convoluted but it works. Rails does something similar
+    # with their RoutesProxy class and view_context.url_options.
+    def method_missing(method_name, *args)
+      path_name = method_name.to_s.sub(/_url$/, '_path').to_sym
+      path = @helpers.send(path_name, *args)
+      if method_name.to_s.end_with?('_url')
+        options = args.extract_options!
+        options.merge!(path: path)
+        options = url_options.merge(options)
+        add_full_url(options)
+      else
+        path
+      end
+    end
+  end
+end
+

data/lib/jets/router/matcher.rb

@@ -1,19 +1,105 @@
-class Jets::Router
+module Jets::Router
   class Matcher
-    def initialize(path, method)
-      @path = path.sub(/^\//,'')
-      @method = method.to_s.upcase
+    extend Memoist
+
+    attr_reader :routes
+    def initialize(route_set=Jets.application.routes)
+      @route_set = route_set
+      @routes = route_set.ordered_routes
+    end
+
+    def request_path
+      # Ensure leading slash
+      # Be more forgiving and allow the request_path to be passed in without a leading slash.
+      # Note: request PATH_INFO will always have a leading slash, but just in case.
+      # This is also covered in specs.
+      return unless @request_path
+      @request_path.starts_with?('/') ? @request_path : "/#{@request_path}"
+    end
+
+    def request_method
+      @request_method.to_s.upcase if @request_method
+    end
+
+    # Precedence:
+    # 1. Routes with no captures get highest precedence: posts/new
+    # 2. Then we consider the routes with captures: post/:id
+    #
+    # Within these 2 groups we consider the routes with the longest path first
+    # since posts/:id and posts/:id/edit can both match.
+    def find_by_request(request, request_method=nil)
+      @request = request # @request is used to check constraints
+      # Checking the request_method_from_hidden_method_field so that handler can find the right route
+      # super early in the process. Otherwise lambda routes to the wrong controller action.
+      @request_method = request_method || @request.request_method_from_hidden_method_field || @request.request_method.to_s.upcase
+      @request_path = strip_format(@request.path)
+      route = find_route
+      match_constraints(route) if route
+    end
+
+    # Simpler version of find_by_request that does not check constraints.
+    # Used by Jets::Controller::Middleware::Mimic and called super-early on.
+    # Does not have access to @request object and path_params
+    def find_by_env(env)
+      @env = env
+      @request_method = env["REQUEST_METHOD"] || "GET"
+      @request_path = strip_format(env["PATH_INFO"])
+      find_route
+    end
+
+    def find_by_controller_action(controller, action)
+      controller = "#{controller.camelize}Controller"
+      routes.find do |r|
+        r.controller_name == controller.to_s &&
+        r.action_name == action.to_s
+      end
+    end
+
+    def find_route
+      routes.each do |r|
+        if r.engine
+          route = find_engine_route(r)
+          return route if route
+        else
+          found = match?(r)
+          return r if found
+        end
+      end
+      nil
+    end
+
+    def find_engine_route(route)
+      return unless mount
+
+      engine_matcher = self.class.new(route.engine.route_set)
+      engine_route = if @request
+                       engine_matcher.find_by_request(@request, @request_method)
+                     else
+                       engine_matcher.find_by_env(@env)
+                     end
+      # save original engine for route.extract_parameters later
+      engine_route.original_engine = route.engine if engine_route
+      engine_route
+    end
+
+    def mount
+      EngineMount.find_by(request_path: request_path)
+    end
+    memoize :mount
+
+    def strip_format(path)
+      path.sub(/\..+$/, '') # Remove format from the end of the path
     end
 
     def match?(route)
-      # Immediately stop checking when the request method: GET, POST, ANY, etc
+      # Immediately stop checking when the request http_method: GET, POST, ANY, etc
       # doesnt match.
+      return false if request_method != route.http_method && route.http_method != "ANY"
 
-      return false if method != route.method && route.method != "ANY"
+      route_path = strip_format(route.path)
+      route_path = "#{mount.at}#{route_path}" if mount
 
-      route_path = route.path
-
-      if path == route_path
+      if request_path == route_path
         # regular string match detection
         return true # exact route matches are highest precedence
       end
@@ -21,18 +107,54 @@ class Jets::Router
       # Check path for route capture and wildcard matches:
       # A colon (:) means the variable has a variable
       if route_path.include?(':') # 2nd highest precedence
-        capture_detection(route_path, path) # early return true or false
+        capture_detection(route_path, request_path) # early return true or false
       # A star (*) means the variable has a glob
       elsif route_path.include?('*') # lowest precedence
-        proxy_detection(route_path, path) # early return true or false
+        proxy_detection(route_path, request_path) # early return true or false
       else
         false # reach here, means no route matched
       end
     end
 
-  private
+    def match_constraints(route)
+      return unless route
+      constraints_matches?(route) ? route : nil
+    end
+
+    # Matcher called in mimic.rb before mimic event is available
+    # We need to extract the parameters from the possible matching route directly
+    # since event is unavailable.
+    def constraints_matches?(route)
+      # Matcher is used super-early when request not yet available.
+      # Cannot check constraints because we dont have the request object.
+      # To build a request object, would need to build a mimic event and it's not yet available.
+      return true if @request.nil?
+
+      constraints = route.constraints
+      return true if constraints.blank?
+
+      if constraints.is_a?(Hash)
+        parameters = route.extract_parameters(request_path) # extract directly
+        constraints.any? do |key, value|
+          key = key.to_s
+          if value.is_a?(Regexp)
+            value.match(parameters[key])
+          else # String
+            if parameters[key]
+              value == parameters[key]
+            elsif @request.respond_to?(key)
+              value == @request.send(key)
+            end
+          end
+        end
+      elsif constraints.respond_to?(:call)
+        constraints.call(@request)
+      elsif constraints.respond_to?(:matches?)
+        constraints.matches?(@request)
+      end
+    end
 
-    attr_reader :path, :method
+  private
 
     # catchall/globbing/wildcard/proxy routes. Examples:
     #
@@ -40,7 +162,7 @@ class Jets::Router
     #    get "others/*rest", to: "others#show"
     #    get "*catchall", to: "public_files#show" # last catchall route for Jets
     #
-    def proxy_detection(route_path, actual_path)
+    def proxy_detection(route_path, request_path)
       # drop the proxy_segment
       leading_path = route_path.split('/')[0..-2].join('/')
 
@@ -61,10 +183,11 @@ class Jets::Router
 
       pattern = "^#{leading_path}"
       regexp = Regexp.new(pattern)
-      !!regexp.match(actual_path) # could be true or false
+
+      !!regexp.match(request_path) # could be true or false
     end
 
-    def capture_detection(route_path, actual_path)
+    def capture_detection(route_path, request_path)
       # changes path to a string used for a regexp
       # posts/:id/edit => posts\/(.*)\/edit
       regexp_string = route_path.split('/').map do |s|
@@ -75,7 +198,7 @@ class Jets::Router
 
       regexp = Regexp.new(regexp_string)
 
-      !!regexp.match(actual_path) # could be true or false
+      !!regexp.match(request_path) # could be true or false
     end
   end
 end

data/lib/jets/router/resources/options.rb

@@ -1,12 +1,14 @@
 module Jets::Router::Resources
   class Options < Base
     def build(action)
-      controller = @options[:singular_resource] ? @name.to_s.pluralize : @name
-      options = @options.merge(to: "#{controller}##{action}") # important to create a copy of the options
-      # remove special options from getting to create_route. For some reason .slice! doesnt work
+      # Important to create a copy of the options since we are mutating it
+      # The original options are used for resources and resource scope
+      options = @options.dup
+      # Remove special options from getting to create_route. For some reason .slice! doesnt work
       options.delete(:only)
       options.delete(:except)
-      options[:from_scope] = true # flag to drop the prefix later in Route#compute_path
+      controller = options[:singular_resource] ? @name.to_s.pluralize : @name
+      options[:to] = "#{controller}##{action}"
       options
     end
   end

data/lib/jets/router/route/after_initialize.rb

@@ -0,0 +1,64 @@
+class Jets::Router::Route
+  module AfterInitialize
+    def after_initialize
+      normalize_to_option!
+      normalize_path_option!
+      normalize_id_constraint!
+      check_on_option!
+    end
+
+    # Possibly infer to option from the path. Example:
+    #
+    #     get 'posts/index'
+    #     get 'posts', to: 'posts#index'
+    #
+    #     get 'posts/show'
+    #     get 'posts', to: 'posts#show'
+    #
+    def normalize_to_option!
+      return if @options[:to]
+
+      path = @options[:path].to_s
+      return unless path.include?('/')
+
+      path = path.delete_prefix('/') # remove leading slash
+      items = path.split('/')
+      if items.size == 2
+        @options[:to] = items.join('#')
+      end
+    end
+
+    def normalize_path_option!
+      path = @options[:path]
+      resource_name = @scope.resource_name
+      if path.is_a?(Symbol) and resource_name # Treat as controller action
+        # Only supported with used within scope, resource, resources block
+        action = path # IE: get :list => action = :list
+        controller = @scope.virtual_controller
+        # infer and set to option if not set
+        @options[:to] ||= "#{controller}##{action}"
+      end
+
+      # override
+      @options.merge!(path: escape_path(path)) if path
+    end
+
+    def normalize_id_constraint!
+      if @options[:id] && !@options[:constraints]
+        @options[:constraints] = { id: @options[:id] }
+      end
+    end
+
+    def check_on_option!
+      if @options[:on] && !%w[resources resource].include?(@scope.from.to_s)
+        raise Jets::Router::Error.new("ERROR: The `on:` option can only be used within a resource or resources block")
+      end
+    end
+
+    def escape_path(path)
+      path.to_s.split('/').map { |s| s =~ /\A[:\*]/ ? s : CGI.escape(s) }.join('/')
+      path = "/#{path}" unless path.starts_with?('/')
+      path
+    end
+  end
+end

data/lib/jets/router/route/as.rb

@@ -0,0 +1,93 @@
+class Jets::Router::Route
+  module As
+    def as
+      return nil if @options[:as] == :disabled
+      return @options[:engine].engine_name if @options[:engine]
+      return unless @options[:root] || [:get, :post, :patch, :put, :delete].include?(@options[:http_method])
+
+      as = scoped_as
+      as = add_underscore_path(as)
+      as = add_action(as)
+      as = add_root(as)
+      as
+    end
+
+    def scoped_as
+      list = []
+      @scope.from_top.each do |scope|
+        node = Node.new(self, scope)
+
+        as = node.resolved_as
+        as = as.to_s.singularize if node.has_param?
+        list << as if as && node.append_as?
+      end
+      list.reject!(&:blank?) # IE: list [:posts, :comments]
+      list.unshift(@options[:as]) if @options[:as]
+      list.join('_').gsub('/','_') unless list.empty?
+    end
+
+    # IE: posts/:id/edit => posts
+    # Using this convention so that regular routes under namespace and path
+    # can be reassemble as if they were under resources
+    def add_underscore_path(as)
+      if as.nil? && @scope.needs_controller_path? # only consider leaf scope
+        @options[:as] || underscore_path_before_param
+      else
+        as
+      end
+    end
+
+    # IE: posts/:id/edit => posts
+    # Using this convention so that regular routes under namespace and path
+    # can be reassemble as if they were under resources
+    def underscore_path_before_param
+      action_suffixes = %w[new edit] # edit in case of singular resource
+      parts = []
+      path = @options[:path].to_s
+      return nil if path.include?('*') || !path.ascii_only? # IE: get '*catchall', to: 'public_files#show'
+
+      path = path.delete_prefix('/')
+      path.split('/').each do |part|
+        if part.starts_with?(':') || part.starts_with?('*') || action_suffixes.include?(part)
+          break
+        end
+        parts << part
+      end
+      parts.map! { |p| p.gsub(/[^a-zA-Z0-9]/,'_') }
+      path = parts.join('_').squeeze('_')
+      if action_suffixes.include?(@info.action)
+        path.singularize
+      else
+        path
+      end
+    end
+
+    def add_action(resource)
+      resource = resource.to_s
+      return resource if resource.blank?
+
+      as_name = @options[:as] || @info.action
+      as_name = as_name.to_s.delete_prefix('/') if as_name
+
+      if %w[new edit].include?(@info.action) && @options[:as].nil?
+        "#{as_name}_#{resource.singularize}"  # IE: new_post
+      elsif %[index create].include?(@info.action)
+        resource                              # IE: posts
+      elsif %w[show edit update destroy].include?(as_name)
+        "#{resource.singularize}"             # IE: post
+      elsif is_collection?(@scope) && @options[:as].nil?
+        "#{as_name}_#{resource}"              # IE: list_post
+      elsif (is_member?(@scope) || @scope.from == :resource) && @options[:as].nil?
+        "#{as_name}_#{resource.singularize}"  # IE: rate_post
+      elsif @scope.resource_name && @options[:as].nil?
+        "#{resource.singularize}_#{as_name}"  # IE: post_list
+      else
+        resource                              # IE: post
+      end
+    end
+
+    def add_root(as)
+      @options[:root] ? 'root' : as
+    end
+  end
+end

data/lib/jets/router/route/authorizer.rb

@@ -31,6 +31,7 @@ class Jets::Router::Route
     module ModuleMethods
       def logical_id(authorizer, prefix_class: true)
         klass, meth = authorizer.split("#")
+        klass += "_authorizer"
         words = [meth, "authorizer"]
         words.unshift(klass) if prefix_class
         words.join('_').camelize # logical_id