jets 5.0.14 → 6.0.0.beta1

data/lib/jets/router/matcher.rb

@@ -1,204 +0,0 @@
-module Jets::Router
-  class Matcher
-    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 http_method: GET, POST, ANY, etc
-      # doesnt match.
-      return false if request_method != route.http_method && route.http_method != "ANY"
-
-      route_path = strip_format(route.path)
-      route_path = "#{mount.at}#{route_path}" if mount
-
-      if request_path == route_path
-        # regular string match detection
-        return true # exact route matches are highest precedence
-      end
-
-      # 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, 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, request_path) # early return true or false
-      else
-        false # reach here, means no route matched
-      end
-    end
-
-    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
-
-  private
-
-    # catchall/globbing/wildcard/proxy routes. Examples:
-    #
-    #    get "files/*path", to: "files#show"
-    #    get "others/*rest", to: "others#show"
-    #    get "*catchall", to: "public_files#show" # last catchall route for Jets
-    #
-    def proxy_detection(route_path, request_path)
-      # drop the proxy_segment
-      leading_path = route_path.split('/')[0..-2].join('/')
-
-      # get "*catchall", to: "public_files#show"
-      if leading_path.empty? # This is the last catchall route "*catchall"
-        return true # always return true here because the entire path
-        # will always match
-      end
-
-      # Other types of wildcard route:
-      #
-      #    get "files/*path", to: "files#show"
-      #    get "others/*rest", to: "others#show"
-      unless leading_path.ends_with?('/')
-        # Ensure trailing slash to make pattern matching stricter
-        leading_path = "#{leading_path}/"
-      end
-
-      pattern = "^#{leading_path}"
-      regexp = Regexp.new(pattern)
-
-      !!regexp.match(request_path) # could be true or false
-    end
-
-    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|
-                        s.include?(':') ? Jets::Router::Route::CAPTURE_REGEX : s
-                      end.join('\/')
-      # make sure beginning and end of the string matches
-      regexp_string = "^#{regexp_string}$"
-
-      regexp = Regexp.new(regexp_string)
-
-      !!regexp.match(request_path) # could be true or false
-    end
-  end
-end

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

@@ -1,7 +0,0 @@
-module Jets::Router::Resources
-  class Base
-    def initialize(name, options)
-      @name, @options = name, options
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-module Jets::Router::Resources
-  class Filter < Base
-    def yes?(action)
-      return true unless @options[:only] || @options[:except]
-
-      if @options[:only]
-        only = [@options[:only]].flatten.map(&:to_s)
-        only.include?(action.to_s)
-      else # except
-        except = [@options[:except]].flatten.map(&:to_s)
-        !except.include?(action.to_s)
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-module Jets::Router::Resources
-  class Options < Base
-    def build(action)
-      # 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)
-      controller = options[:singular_resource] ? @name.to_s.pluralize : @name
-      options[:to] = "#{controller}##{action}"
-      options
-    end
-  end
-end

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

@@ -1,64 +0,0 @@
-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

@@ -1,93 +0,0 @@
-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

@@ -1,58 +0,0 @@
-class Jets::Router::Route
-  module Authorizer
-    # IE: main#protect => MainProtectAuthorizer
-    def authorizer_id(prefix_class: true)
-      return unless authorizer
-      logical_id(authorizer, prefix_class: prefix_class)
-    end
-
-    # Metadata about the authorizer class that can be used later. Stored in the Authorizer template parameters.
-    # In app_class.rb `def controller_params` it is used to build the input parameters for controller templates.
-    def authorizer_metadata
-      metadata(authorizer)
-    end
-
-    def authorizer
-      @options[:authorizer]
-    end
-
-    def authorization_scopes
-      @options[:authorization_scopes]
-    end
-
-    def authorization_type
-      @options[:authorization_type] || inferred_authorization_type
-    end
-
-    def api_key_required
-      @options[:api_key_required]
-    end
-
-    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
-      end
-
-      def metadata(authorizer)
-        klass = authorizer.split("#").first
-        authorizer_class = "#{klass}_authorizer".camelize
-        logical_id = logical_id(authorizer, prefix_class: false)
-        # IE: MainAuthorizer.ProtectAuthorizer
-        "#{authorizer_class}.#{logical_id}"
-      end
-    end
-    include ModuleMethods # so available as instance methods
-    extend ModuleMethods # so also available as module method. IE: Jets::Router::Route::Authorizer.metadata(auth_to)
-
-  private
-    def inferred_authorization_type
-      return unless authorizer
-      Jets::Authorizer::Base.authorization_type(authorizer)
-    end
-
-  end
-end

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

@@ -1,45 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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
-