jets 4.0.8 → 5.0.0.beta1

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

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