jets 3.1.0 → 5.0.10

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

@@ -0,0 +1,177 @@
+require "action_dispatch"
+require "action_dispatch/routing/route_set"
+
+module Jets::Router::Compat
+  # Related:
+  #
+  #   Jets::Controller::Compat::ActionDispatch::Routing::UrlFor
+  #   Jets::Controller::Request::Compat::RouteSet
+  #   Jets::Router::Compat::RouteSet
+  #
+  # Compat::RouteSet makes the Jets::Router::RouteSet "compatible" with the Rails RouteSet.
+  # Importantly, it provides a custom url_for method that mimics the Rails url_for method.
+  #
+  module RouteSet
+    # Original:
+    # RESERVED_OPTIONS = [:host, :protocol, :port, :subdomain, :domain, :tld_length,
+    #   :trailing_slash, :anchor, :params, :only_path, :script_name,
+    #   :original_script_name, :relative_url_root]
+    # UNKNOWN = ->(options) { ActionDispatch::Http::URL.url_for(options) }
+    RESERVED_OPTIONS = ActionDispatch::Routing::RouteSet::RESERVED_OPTIONS
+    UNKNOWN = ActionDispatch::Routing::RouteSet::UNKNOWN
+
+    # This method is a version of the Rails RouteSet#url_for method.
+    # It only resolves simple routes for simple cases:
+    #
+    #   when nil
+    #   when Hash, ActionController::Parameters
+    #
+    # This is because ActionDispatch::Routing::UrlFor#url_for gets called before
+    # and then calls out to this method. Only have to account for 2 cases to
+    # mimic Jets behavior.
+    #
+    # Based on Jets ActionDispatch::Routing::RouteSet#url_for
+    def url_for(options, route_name = nil, url_strategy = UNKNOWN, method_name = nil, reserved = RESERVED_OPTIONS)
+      user = password = nil
+
+      if options[:user] && options[:password]
+        user     = options.delete :user
+        password = options.delete :password
+      end
+
+      # save recall_controller for url_options when controller not specified by user
+      # IE: redirect_to action: :routes
+      recall_controller = options[:_recall][:controller]
+      recall = options.delete(:_recall) { {} }
+
+      original_script_name = options.delete(:original_script_name)
+      # script_name = find_script_name options (original)
+      script_name = options.delete(:script_name)
+
+      if original_script_name
+        script_name = original_script_name + script_name
+      end
+
+      path_options = options.dup
+      reserved.each { |ro| path_options.delete ro }
+      path_options[:controller] ||= recall_controller
+
+      route_with_params = generate(route_name, path_options, recall)
+      path = route_with_params.path(method_name)
+
+      if options[:trailing_slash] && !options[:format] && !path.end_with?("/")
+        path += "/"
+      end
+
+      params = route_with_params.params
+
+      if options.key? :params
+        if options[:params]&.respond_to?(:to_hash)
+          params.merge! options[:params]
+        else
+          params[:params] = options[:params]
+        end
+      end
+
+      options[:path]        = path
+      options[:script_name] = script_name
+      options[:params]      = params
+      options[:user]        = user
+      options[:password]    = password
+
+      url_strategy.call options
+    end
+
+    def generate(route_name, options, recall = {}, method_name = nil)
+      Generator.new(route_name, options, recall, self).generate
+    end
+    private :generate
+
+    # This is only used for Custom resolve polymporphic path support
+    # Stub out. Jets does not currently support this.
+    # interface method
+    def polymorphic_mappings
+      {}
+    end
+
+    # ActionView::Rendering ClassMethods build_view_context_class includes these modues. Something like this:
+    #
+    #   def build_view_context_class(klass, supports_path, routes, helpers)
+    #     ...
+    #     if routes
+    #       include routes.url_helpers(supports_path)
+    #       include routes.mounted_helpers
+    #     end
+    #
+    # interface method
+    # def url_helpers(supports_path=true)
+    #   ActionDispatch::Routing::UrlFor
+    # end
+
+    # interface method
+    def mounted_helpers
+      Module.new
+    end
+
+    # Based on Rails ActionDispatch::Routing::RouteSet::Generator
+    class Generator
+      attr_reader :options, :recall, :set, :named_route
+
+      def initialize(named_route, options, recall, set)
+        @named_route = named_route
+        @options     = options.dup
+        # Fix kaminari pagination links. Looks like Rails can handle nil params
+        @options.delete_if { |_, v| v.to_param.nil? }
+        @recall      = recall
+        @set         = set
+      end
+
+      # Generates a path from routes, returns a RouteWithParams or MissingRoute.
+      # MissingRoute will raise ActionController::UrlGenerationError.
+      def generate
+        RouteWithParams.new(named_route, recall, options)
+      end
+    end
+
+    class RouteWithParams
+      def initialize(route, parameterized_parts, params)
+        @route = route
+        @parameterized_parts = parameterized_parts
+        @params = params
+      end
+
+      def params
+        params = @params.dup
+        # So controller and action do not show up in the query string
+        params.delete(:controller)
+        params.delete(:action)
+        params
+      end
+
+      def path(_)
+        # Match with Jets router instead of Rails router
+        matcher = Jets::Router::Matcher.new
+        route = matcher.find_by_controller_action(@parameterized_parts[:controller], @parameterized_parts[:action])
+        if route
+          path = replace_placeholders(route.path, @parameterized_parts)
+          path.starts_with?('/') ? path : "/#{path}"
+        else
+          # Mimic Rails MissingRoute error
+          constraints = @params
+          missing_keys = []
+          unmatched_keys = []
+          routes = Jets.application.routes
+          name = nil
+          ActionDispatch::Journey::Formatter::MissingRoute.new(constraints, missing_keys, unmatched_keys, routes, name).path(name)
+        end
+      end
+
+      def replace_placeholders(path, params)
+        params.each do |key, value|
+          path = path.gsub(":#{key}", value.to_param)
+        end
+        path
+      end
+    end
+  end
+end

data/lib/jets/router/dsl/mount.rb

@@ -1,13 +1,47 @@
 module Jets::Router::Dsl
   module Mount
+    # support these notations:
+    #   mount Blorgh::Engine, at: "/blog"
+    #   mount sprockets_env => "/assets"
+    #   mount sprockets_env => "/assets", internal: true
+    def mount(*args)
+      options = args.extract_options!
+
+      if args.empty?
+        mount_option = options.find { |k,v| !k.is_a?(String) && !v.is_a?(Symbol) }
+        mount_class, at = mount_option[0], mount_option[1]
+      else
+        mount_class = args.first
+        at = options[:at]
+      end
+
+      at = "/#{at}" unless at.starts_with?("/")
+      mount_class_at(mount_class, options.merge(at: at))
+    end
+
     # The mounted class must be a Rack compatiable class
-    def mount(klass, at:)
-      options = {to: "jets/mount#call", mount_class: klass}
-      at = at[1..-1] if at.starts_with?('/') # be more forgiving if / accidentally included
-      at_wildcard = at.blank? ? "*path" : "#{at}/*path"
+    def mount_class_at(klass, options={})
+      if klass.is_a?(Class) && klass < Jets::Engine
+        mount_engine(klass, options)
+      else
+        # Handles mount like Sprockets::Environment.new
+        at = options.delete(:at)
+        at = at[1..-1] if at.starts_with?('/') # be more forgiving if / accidentally included
+        at_wildcard = at.blank? ? "*path" : "#{at}/*path"
+        options.merge!(to: "jets/mount#call", mount_class: klass)
+
+        any at, options
+        any at_wildcard, options
+      end
+    end
 
-      any at, options
-      any at_wildcard, options
+    mattr_accessor :mounted_engines
+    self.mounted_engines = {}
+    def mount_engine(klass, options={})
+      at = options.delete(:at)
+      options.merge!(engine: klass, path: at)
+      create_route(options)
+      @@mounted_engines[at] = klass
     end
   end
 end

data/lib/jets/router/dsl.rb

@@ -1,35 +1,88 @@
-class Jets::Router
+module Jets::Router
   module Dsl
     include Mount
 
     # Methods supported by API Gateway
     %w[any delete get head options patch post put].each do |method_name|
-      define_method method_name do |path, options={}|
-        create_route(options.merge(path: escape_path(path), method: __method__))
+      define_method method_name do |*args|
+        options = args.extract_options!
+        normalize_path_to_controller_map_option!(args, options)
+        options = options.clone
+        path_arg = args.first
+        if path_arg.is_a?(Symbol)
+          options[:action] = path_arg # Info#action uses
+        end
+        options[:path] ||= path_arg
+        options[:http_method] = __method__
+        create_route(options)
+      end
+    end
+
+    # Normally first args is a String that is the path
+    #     get "/posts", to: "posts#index"
+    # But it can also be a Hash that maps the path to the controller/action
+    #     get "/jets/info" => "jets/info#index"
+    # This logic normalize options to support both cases.
+    def normalize_path_to_controller_map_option!(args, options)
+      if !options[:to] && !args.first.is_a?(String) && !args.first.is_a?(Symbol)
+        map = options.find { |k,v| k.is_a?(String) }
+        path, to = map[0], map[1]
+        options[:to] = to
+        options[:path] = path
+        options.delete(path)
+      end
+    end
+
+    def match(path, options={})
+      via = options.delete(:via) || :any
+      Array(via).each do |http_method|
+        http_method = :any if via == :all
+        send http_method, path, options
       end
     end
 
+    def create_route(options)
+      one_apigw_method_for_all_routes_warning(options)
+      route = Route.new(options, @scope)
+      @routes << route
+    end
+
+    def constraints(constraints, &block)
+      scope(from: :constraints, constraints: constraints, &block)
+    end
+
+    def member(&block)
+      scope(from: :member, &block)
+    end
+
+    def collection(&block)
+      scope(from: :collection, &block)
+    end
+
+    def defaults(data={}, &block)
+      scope(from: :defaults, defaults: data, &block)
+    end
+
+    def path(path, &block)
+      scope(from: :path, path: path, &block)
+    end
+
     def namespace(ns, &block)
-      scope(module: ns, prefix: ns, as: ns, from: :namespace, &block)
+      scope(from: :namespace, path: ns, module: ns, as: ns, &block)
     end
 
-    def prefix(prefix, &block)
-      scope(prefix: prefix, &block)
+    def shallow(&block)
+      scope(from: :shallow, &block)
     end
 
-    # scope supports three options: module, prefix and as.
-    # Jets vs Rails:
-    #   module - module
-    #   prefix - path
-    #   as - as
-    def scope(args)
-      # normalizes `scope(:admin)` as `scope(prefix: :admin)`
-      options = case args
-      when Hash
-        args
-      when String, Symbol
-        { prefix: args }
-      end
+    # Examples
+    #   scope :admin
+    #   scope path: :admin
+    #   scope 'admin', as: 'admin'
+    def scope(*args)
+      options = args.extract_options!
+      path = args.first
+      options[:path] = path.to_s if path
 
       root_level = @scope.nil?
       @scope = root_level ? Scope.new(options) : @scope.new(options)
@@ -39,106 +92,73 @@ class Jets::Router
     end
 
     # resources macro expands to all the routes
-    def resources(*items, **options)
-      items.each do |item|
-        scope_options = scope_options!(item, options)
-        scope_options[:from] = :resources # flag for MethodCreator logic: to handle method_name_leaf and more
-        scope(scope_options) do
-          each_resources(item, options, block_given?)
+    def resources(*args)
+      options = args.extract_options!
+      resource_names = args
+      resource_names.each do |resource_name|
+        scope(options.merge(from: :resources, resource_name: resource_name)) do
+          each_resource(resource_name, options)
           yield if block_given?
         end
       end
     end
 
-    def scope_options!(item, options)
-      prefix = if options[:prefix]
-        # prefix given from the resources macro get automatically prepended to the item name
-        p = options.delete(:prefix)
-        "#{p}/#{item}"
-      else
-        item
-      end
-
-      {
-        as: options.delete(:as) || item, # delete as or it messes with create_route
-        prefix: prefix,
-        param: options[:param],
-        # module: options.delete(:module) || item, # NOTE: resources does not automatically set module, but namespace does
-      }
-    end
-
-    def each_resources(name, options={}, has_block=nil)
-      o = Resources::Options.new(name, options)
-      f = Resources::Filter.new(name, options)
-      param = default_param(has_block, name, options)
-
-      get name, o.build(:index) if f.yes?(:index)
-      get "#{name}/new", o.build(:new) if f.yes?(:new) && !api_mode?
-      get "#{name}/:#{param}", o.build(:show) if f.yes?(:show)
-      post name, o.build(:create) if f.yes?(:create)
-      get "#{name}/:#{param}/edit", o.build(:edit) if f.yes?(:edit) && !api_mode?
-      put "#{name}/:#{param}", o.build(:update) if f.yes?(:update)
-      post "#{name}/:#{param}", o.build(:update) if f.yes?(:update) # for binary uploads
-      patch "#{name}/:#{param}", o.build(:update) if f.yes?(:update)
-      delete "#{name}/:#{param}", o.build(:delete) if f.yes?(:delete)
-    end
-
-    def resource(*items, **options)
-      items.each do |item|
-        scope_options = scope_options!(item, options)
-        scope_options[:from] = :resource # flag for MethodCreator logic: to handle method_name_leaf and more
-        scope(scope_options) do
-          each_resource(item, options, block_given?)
+    def resource(*args)
+      options = args.extract_options!
+      resource_names = args
+      resource_names.each do |resource_name|
+        scope(options.merge(from: :resource, resource_name: resource_name)) do
+          each_resource(resource_name, options.merge(singular_resource: true))
           yield if block_given?
         end
       end
     end
 
-    def each_resource(name, options={}, has_block=nil)
-      o = Resources::Options.new(name, options.merge(singular_resource: true))
-      f = Resources::Filter.new(name, options)
-
-      get "#{name}/new", o.build(:new) if f.yes?(:new) && !api_mode?
-      get name, o.build(:show) if f.yes?(:show)
-      post name, o.build(:create) if f.yes?(:create)
-      get "#{name}/edit", o.build(:edit) if f.yes?(:edit) && !api_mode?
-      put name, o.build(:update) if f.yes?(:update)
-      post name, o.build(:update) if f.yes?(:update) # for binary uploads
-      patch name, o.build(:update) if f.yes?(:update)
-      delete name, o.build(:delete) if f.yes?(:delete)
-    end
-
-    def member
-      @on_option = :member
-      yield
-      @on_option = nil
-    end
-
-    def collection
-      @on_option = :collection
-      yield
-      @on_option = nil
-    end
-
-    # If a block has pass then we assume the resources will be nested and then prefix
-    # the param name with the resource. IE: post_id instead of id
-    # This avoids an API Gateway parent sibling variable collision.
-    def default_param(has_block, name, options)
-      default_param = has_block ? "#{name.to_s.singularize}_id".to_sym : :id
-      options[:param] || default_param
+    # Important: Options as, module, etc are handled by scope and should not be passed to the route
+    HANDLED_BY_SCOPE = [:as, :module, :path, :shallow].freeze
+    def each_resource(resource_name, options={})
+      HANDLED_BY_SCOPE.each do |opt|
+        options.delete(opt)
+      end
+      o = Resources::Options.new(resource_name, options)
+      f = Resources::Filter.new(resource_name, options)
+
+      # Looks a little weird with '' but the path is handled by the scope
+      get '', o.build(:index) if f.yes?(:index) && !options[:singular_resource]
+      post '', o.build(:create) if f.yes?(:create)
+      get 'new', o.build(:new) if f.yes?(:new) && !api_mode?
+      get 'edit', o.build(:edit) if f.yes?(:edit) && !api_mode?
+      get '', o.build(:show) if f.yes?(:show)
+      put '', o.build(:update) if f.yes?(:update)
+      # post to update wont work with singular_resource because it's a route collision
+      # Also makes it so that route.to is always changed
+      # Leaving in case need it for some reason. Will remove later.
+      # post '', o.build(:update) if f.yes?(:update) # for binary uploads
+      patch '', o.build(:update) if f.yes?(:update)
+      delete '', o.build(:destroy) if f.yes?(:destroy)
     end
 
     # root "posts#index"
-    def root(to, options={})
-      default = {path: '', to: to, method: :get, root: true}
-      options = default.merge(options)
-      MethodCreator.new(options, @scope).create_root_helper
-      @routes << Route.new(options, @scope)
-    end
-    private
+    # root to: "posts#index"
+    def root(*args)
+      if args.size == 1
+        options = args.first
+        if options.is_a?(String) # root "posts#index"
+          to = options
+          options = {}
+        elsif options.is_a?(Hash) # root to: "posts#index"
+          to = options.delete(:to)
+        end
+      else
+        to = args[0]
+        options = args[1] || {}
+      end
 
-    def escape_path(path)
-      path.to_s.split('/').map { |s| s =~ /\A[:\*]/ ? s : CGI.escape(s) }.join('/')
+      http_method = options.delete(:via)
+      http_method ||= Jets.config.api.cors ? :any : :get
+      default = {path: '/', to: to, http_method: http_method, root: true}
+      options = default.merge(options)
+      create_route(options)
     end
   end
 end

data/lib/jets/router/engine_mount.rb

@@ -0,0 +1,36 @@
+module Jets::Router
+  class EngineMount
+    def self.find_by(request_path: nil, engine: nil)
+      new.find_by(request_path: request_path, engine: engine)
+    end
+
+    def find_by(request_path: nil, engine: nil)
+      mount = if request_path
+                find_by_request_path(request_path)
+              elsif engine
+                find_by_engine(engine)
+              end
+
+      return unless mount
+
+      OpenStruct.new(at: mount[0], engine: mount[1])
+    end
+
+    def find_by_request_path(request_path)
+      mounted_engines.find do |at, engine|
+        request_path.starts_with?(at)
+      end
+    end
+
+    def find_by_engine(engine)
+      mounted = mounted_engines.find do |at, mounted_engine|
+        mounted_engine == engine
+      end
+    end
+
+    # Example mounted_engines: {"/blog"=>Blorgh::Engine}
+    def mounted_engines
+      Jets::Router::Dsl::Mount.mounted_engines
+    end
+  end
+end

data/lib/jets/router/help.rb

@@ -0,0 +1,130 @@
+require 'cli-format'
+
+module Jets::Router
+  class Help
+    extend Memoist
+
+    def initialize(options={})
+      @options = options
+      @engines = {}
+    end
+
+    def all_routes
+      Jets::Router.routes
+    end
+
+    def routes
+      routes = filter(all_routes)
+      collect_engine_routes(routes)
+      if ENV['JETS_ROUTES_INTERNAL']
+        routes = routes.select { |route| route.internal }
+      else
+        routes = routes.reject { |route| route.internal }
+      end
+      routes
+    end
+
+    def collect_engine_routes(routes)
+      routes.each do |route|
+        collect_engine_routes_per(route) if route.engine?
+      end
+    end
+
+    def collect_engine_routes_per(route)
+      name = route.endpoint
+      return unless route.engine?
+      return if @engines[name]
+
+      route_set = route.rack_app.route_set
+      if route_set.is_a?(Jets::Router::RouteSet)
+        @engines[name] = route_set.routes
+      end
+    end
+
+    def filter(routes)
+      if @options[:controller]
+        routes.select do |route|
+          route.controller.include?(@options[:controller])
+        end
+      elsif @options[:grep]
+        grep_pattern = Regexp.new(@options[:grep], 'i')
+        proc = filter_proc(grep_pattern)
+        routes.select(&proc)
+      elsif @options[:reject]
+        reject_pattern = Regexp.new(@options[:reject], 'i')
+        proc = filter_proc(reject_pattern)
+        routes.reject(&proc)
+      else
+        routes
+      end
+    end
+
+    def filter_proc(pattern)
+      Proc.new do |route|
+        route.as =~ pattern ||
+        route.http_method =~ pattern ||
+        route.path =~ pattern ||
+        route.controller =~ pattern ||
+        route.mount_class_name =~ pattern
+      end
+    end
+
+    def header
+      header = ["As (Prefix)", "Verb", "Path (URI Pattern)", "Controller#action"]
+      # any_mount = routes.any?(&:mount_class_name)
+      # header << "Mount" if any_mount
+      header
+    end
+
+    def any_mount?
+      routes.any?(&:mount_class_name)
+    end
+
+    def print
+      puts text
+    end
+
+    def text
+      text = presenter_text("Routes for app:", routes)
+      @engines.each do |name, routes|
+        text += presenter_text("Routes for #{name}:", routes)
+      end
+      text
+    end
+
+    def presenter_text(summary_line, routes)
+      text = format_with_newlines(summary_line)
+      if routes.empty?
+        text += "The routes table is empty.\n"
+        return text
+      end
+
+      presenter = CliFormat::Presenter.new(@options)
+      presenter.header = header unless @options[:header] == false
+      routes.each do |route|
+        row = [route.as, route.http_method, route.path, route.to]
+        # row << route.mount_class_name if any_mount?
+        presenter.rows << row
+      end
+      text += presenter.text.to_s # <Text::Table> => String
+      text += "\n" unless text.ends_with?("\n")
+      text += "\n" if @options[:format] == "space" # add another newline for space format
+      text
+    end
+
+    def format_with_newlines(line)
+      return '' if @options[:header] == false
+
+      case @options[:format]
+      when "markdown"
+        # need leading newline for routes_table jets prints when route not found
+        # Unsure why it needs to be here and not at the routes_table method.
+        "\n#{line}\n\n"
+      when "space"
+        "#{line}\n\n"
+      else
+        "#{line}\n"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Jets::Router::Helpers::NamedRoutes
+  module AddFullUrl
+    # Named add_full_url to avoid mental conflicts with Jets full_url_for
+    # Leverage Rails URL.url_for to avoid duplicating the logic
+    # Rails sets url_strategy to:
+    #     => ActionDispatch::Routing::RouteSet::UNKNOWN
+    #     => ActionDispatch::Http::URL.url_for(options)
+    def add_full_url(options)
+      options = url_options.merge(options)
+      ActionDispatch::Http::URL.url_for(options)
+    end
+  end
+end