jets 5.0.14 → 6.0.0.beta1

data/lib/jets/router/dsl.rb

@@ -1,164 +0,0 @@
-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 |*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(from: :namespace, path: ns, module: ns, as: ns, &block)
-    end
-
-    def shallow(&block)
-      scope(from: :shallow, &block)
-    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)
-      yield
-    ensure
-      @scope = @scope.parent if @scope
-    end
-
-    # resources macro expands to all the routes
-    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 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
-
-    # 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"
-    # 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
-
-      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

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

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

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

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

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