jets 4.0.17 → 5.0.0.beta1

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,101 @@
-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 = @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 = 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 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 method != route.method && route.method != "ANY"
+      return false if request_method != route.http_method && route.http_method != "ANY"
 
       route_path = route.path
+      route_path = "#{mount.at}#{route_path}" if mount
 
-      if path == route_path
+      if request_path == route_path
         # regular string match detection
         return true # exact route matches are highest precedence
       end
@@ -21,18 +103,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
 
-    attr_reader :path, :method
+    # 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
+
+  private
 
     # catchall/globbing/wildcard/proxy routes. Examples:
     #
@@ -40,7 +158,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 +179,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 +194,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

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

@@ -0,0 +1,45 @@
+class Jets::Router::Route
+  # Work in progress. Considering making Jets Route more compatiable with Rails Route.
+  # Then will be able to leverage Rails RouteWrapper for presenting the routes for /jets/info/routes.
+  # Ran into Route#path method that is a bit of work to make compatiable.
+  # Leaving this here for the future.
+  module Compat
+    extend Memoist
+
+    # Interface based on Rails ActionDispatch::Routing::Endpoint
+    class App # :nodoc:
+      def initialize(route)
+        @route = route
+      end
+
+      def dispatcher?;   false; end
+      def redirect?;     false; end
+      def matches?(req);  true; end
+      def app;            self; end
+      def rack_app;        app; end
+
+      def engine?
+        @route.engine?
+      end
+    end
+
+    def app
+      App.new(self)
+    end
+    memoize :app
+
+    # Rails interface method for ActionDispatch::Routing::RouteWrapper
+    def name
+      as || ''
+    end
+
+    # Rails interface method for ActionDispatch::Routing::RouteWrapper
+    def verb
+      http_method
+    end
+
+    def internal
+      !!@options[:internal]
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+class Jets::Router::Route
+  # Organize to.controller and to.action into a class
+  # so don't have to keep repeating the logic.
+  class Info
+    def initialize(options, scope)
+      @options, @scope = options, scope
+    end
+
+    # IE: posts
+    def controller
+      return if @options[:engine] # IE: { engine: Blorgh::Engine, path: "/blog" }
+
+      controller = if @options[:controller]
+          @options[:controller]
+        elsif @options[:to]
+          @options[:to].split('#').first # IE: posts#index => posts
+        elsif @scope.virtual_controller
+          @scope.virtual_controller
+        else # {"/jets/info/properties"=>"jets/info#properties"}
+          map = @options.find { |k,v| k.is_a?(String) }
+          path, to = map[0], map[1]
+          to.split('#').first
+        end
+
+      if controller.starts_with?('/')
+        # absolute controller path specified. use without scope adjustments
+        return controller.delete_prefix('/') # remove leading slash
+      end
+
+      # no controller found yet, imply from the scope
+      segments = scoped_module_segments
+      segments << controller if controller
+      segments.compact.join('/') # add module
+    end
+
+    # IE: index
+    def action
+      if @options.key?(:action)
+        @options[:action].to_s
+      elsif is_collection?(@scope) || is_member?(@scope)
+        @options[:path].to_s.delete_prefix('/') # action
+      elsif @options[:on] && @options[:on] != :member && @options[:on] != :collection
+        @options[:on].to_s
+      elsif @options[:to]
+        @options[:to].split('#').last
+      else # {"/"=>"jets/welcome#index", :internal=>true}
+        map = @options.find { |k,v| k.is_a?(String) }
+        path, to = map[0], map[1]
+        to.split('#').last
+      end
+    end
+
+    def scoped_module_segments
+      segments = []
+      @scope.from_top.each do |scope|
+        segments << scope.module if scope.module
+        if @scope == scope # last scope node
+          last_segment = @options[:module]
+          segments << last_segment if last_segment
+        end
+      end
+      segments
+    end
+
+    def is_collection?(scope)
+      scope.from == :collection || @options[:on] == :collection
+    end
+
+    def is_member?(scope)
+      scope.from == :member || @options[:on] == :member
+    end
+  end
+end
+