jets 5.0.17 → 6.0.0.beta1

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

@@ -1,137 +0,0 @@
-class Jets::Router::Route
-  # The Node class groups logic that requires both of route and scope info.
-  # It does not really belong in either the Route or Scope class and
-  # requires both to do its job.  So it gets its own class.
-  # This seems to help keep the Route and Scope classes simpler.
-  #
-  # An instance of this class is made available with each
-  # iteration of loop that processes the DSL scopes.
-  class Node
-    attr_reader :route, :scope, :leaf_scope
-    def initialize(route, scope)
-      @route, @scope = route, scope # scope is current scope of iteration
-      @info = route.info
-      @options = route.options
-      @leaf_scope = @route.scope # the route scope is the leaf scope
-    end
-
-    def append_path?
-      has_path? && add_path_segment?
-    end
-
-    def append_param?
-      has_param? && add_path_segment?
-    end
-
-    def append_as?
-      has_path? && add_path_segment? ||
-      scope.from.nil? && scope.as
-    end
-
-    # Accounts for shallow scope. Example:
-    #
-    #   resources :posts, shallow: true do
-    #     resources :comments do
-    #       resources :likes
-    #     end
-    #   end
-    #
-    # add_path_segment? = add_path_segment_considering_shallow?
-    #
-    def add_path_segment?
-      if param_action? && shallow_param_action?
-        leaf? # only add path segments for leaf
-      elsif paramless_action? && shallow_paramless_action?
-        leaf? || leaf_scope.real_parent?(scope)
-      else
-        true # default is to always path preceding path segments
-      end
-    end
-
-    def shallow_param_action?
-      lookahead_shallow? || leaf_scope.any_parent_shallow?
-    end
-
-    def shallow_paramless_action?
-      lookahead_shallow?(parent: true) || scope.any_parent_shallow?
-    end
-
-    def lookahead_shallow?(parent: false)
-      next_scope = scope
-      while next_scope
-        check_scope = parent ? next_scope.parent : next_scope
-        # Important to check next_scope == leaf_scope
-        # Otherwise it'll collapse path segments for higher scopes also.
-        return true if check_scope.shallow? && next_scope == leaf_scope
-        next_scope = next_scope.next
-      end
-      false
-    end
-
-    def has_path?
-      scope.resolved_path && !scope.virtual?
-    end
-
-    def has_param?
-      return false if scope.root?
-
-      resolved_param && param_action? ||
-      scope.resource_descendent? && !leaf? ||
-      scope.resource_sibling? && !leaf?
-    end
-
-    def resolved_as
-      as = scope.as || scope.resource_name
-      # as = scope.as || scope.resource_name
-      if scope.resource_name
-        controller = nil # dont need controller. can infer from resources, namespace, etc
-      else # direct route method without scope or module only etc
-        controller = @info.controller.split('/').last if leaf? #&& as.nil?
-      end
-      [as, controller].compact.join('_')
-    end
-
-    def param_action?
-      @options[:on] == :member || scope.from == :member ||
-      %w[edit show update destroy].include?(@info.action)
-    end
-
-    def paramless_action?
-      @options[:on] == :collection || scope.from == :collection ||
-      %w[index new create].include?(@info.action)
-    end
-
-    def leaf?
-      scope == leaf_scope
-    end
-
-    def resolved_path
-      scope.resolved_path
-    end
-
-    def resolved_param
-      case scope.from
-      when :resources, :member
-        ":#{param}"
-      else # :resource, :namespace, :path, :collection
-        nil
-      end
-    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 param
-      return scope.options[:param] if scope.options[:param]
-
-      if leaf? && Jets.config.routes.allow_sibling_conflicts
-        "id"
-      elsif scope.resource_descendent? ||
-            scope.resource_sibling? && scope.colliding_resource_sibling?
-        "#{scope.resource_name.to_s.singularize}_id"
-      else
-        "id"
-      end
-    end
-  end
-end

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

@@ -1,93 +0,0 @@
-class Jets::Router::Route
-  module Path
-    # Note: The @options[:path] is missing prefix and is not support via direct create_route.
-    # This is because it can be added directly to the path. IE:
-    #
-    #     get "myprefix/posts", to: "posts#index"
-    #
-    # Also, this helps to keep the method creator logic simpler.
-    #
-    def path(format=:jets)
-      segments = path_prefixes + [path_option]
-      segments = add_path_suffix(segments)
-      path = segments.reject(&:blank?).join('/')
-      format_path(format, path)
-    end
-
-    # When scope used directly. IE: not coming from namespace or resources
-    # When coming from namespace or resources, the path is already accounted for.
-    def path_prefixes
-      list = []
-      @scope.from_top.each do |scope|
-        node = Node.new(self, scope)
-        # Update @path_names as we walk down
-        @path_names.merge!(scope.options[:path_names] || {})
-
-        list << scope.resolved_path if node.append_path?
-        list << node.resolved_param if node.append_param?
-      end
-      list.reject!(&:blank?) # allows for path: '' to remove resource name from path
-      list
-    end
-
-    def path_option
-      node = Node.new(self, @scope)
-      path = @options[:path].to_s.delete_prefix('/') # IE: new or edit
-      path.sub!(@scope.param_placeholder, ":#{node.resolved_param}")
-      path
-    end
-
-    # Accounts for path names options map. Example:
-    #
-    #   {path_names: {new: "sign_up", edit: "edit"}}
-    #
-    # new    posts/new      => posts/sign_up
-    # edit   posts/:id/edit => posts/:id/edit
-    #
-    def add_path_suffix(all_segments)
-      # rip apart last path as segments
-      # work with and modify segments to be returned
-      segments = all_segments.last.to_s.split('/')
-      current_suffix = segments.last
-
-      new_or_edit = %w[new edit].include?(current_suffix)
-      additional_action = @options[:on].is_a?(Symbol) && @options[:on] != :member && @options[:on] != :collection
-      will_replace = new_or_edit || additional_action
-
-      if will_replace
-        segments_without_last = all_segments[0..-2]
-        # reassemble path with additional on action
-        segments_without_last << @options[:on].to_s if additional_action
-        # reassemble with new suffix from path_names map
-        new_suffix = @path_names[current_suffix.to_sym] || current_suffix
-        segments_without_last << new_suffix
-        new_last = segments_without_last.join('/')
-        segments[-1] = new_last # replace
-        segments
-      else
-        all_segments # original
-      end
-    end
-
-    def path_suffixes
-      list = []
-      list << action_suffix if action_suffix
-      list
-    end
-
-    # IE: standard: posts/:id/edit
-    #     api_gateway: posts/{id}/edit
-    def format_path(format, path)
-      path = case format
-      when :api_gateway
-        api_gateway_format(path)
-      when :raw
-        path
-      else # jets format
-        ensure_jets_format(path)
-      end
-      path = "/#{path}" unless path.starts_with?('/') # ensure starts with / be forgiving if / accidentally not included
-      path
-    end
-  end
-end

data/lib/jets/router/route.rb

@@ -1,249 +0,0 @@
-# route = Jets::Router::Route.new(
-#   path: "posts",
-#   http_method: :get,
-#   to: "posts#index",
-# )
-module Jets::Router
-  class Route
-    extend Memoist
-    include Compat
-    include AfterInitialize
-    include As
-    include Authorizer
-    include Path
-    include Util
-
-    CAPTURE_REGEX = "([^/]*)" # as string
-
-    attr_reader :options, :scope, :info, :defaults
-    attr_accessor :original_engine
-    def initialize(options, scope=Scope.new)
-      @options = options
-      @scope = scope
-      @info = Info.new(@options, @scope) # @info.action and @info.controller
-      after_initialize
-      @path_names = {}
-    end
-
-    def to
-      engine || "#{@info.controller}##{@info.action}" # IE: posts#index
-    end
-
-    def engine
-      @options[:engine]
-    end
-    alias rack_app engine
-
-    def engine?
-      !!engine
-    end
-
-    def endpoint
-      engine.to_s if engine
-    end
-
-    def resolved_defaults
-      defaults = @options[:defaults] || {}
-      @scope.resolved_defaults.merge(defaults)
-    end
-
-    def http_method
-      @options[:http_method].to_s.upcase
-    end
-
-    def constraints
-      @options[:constraints] || @scope.resolved_constraints
-    end
-
-    def internal?
-      !!@options[:internal]
-    end
-
-    def homepage?
-      path == '/'
-    end
-
-    # IE: PostsController
-    # IE: index
-    delegate :action, :controller, :is_collection?, :is_member?, to: :@info
-    alias action_name action
-
-    # IE: PostsController
-    # Different from @info.action
-    def controller_name
-      "#{controller.camelize}Controller" if controller
-    end
-
-    # Checks to see if the corresponding controller exists. Useful to validate routes
-    # before deploying to CloudFormation and then rolling back.
-    def valid?
-      controller_class = begin
-        controller_name.constantize
-      rescue NameError => e
-        return false
-      end
-      controller_class.lambda_functions.include?(action_name.to_sym)
-    end
-
-    # For Jets.config.cfn.build.routes == "one_apigw_method_for_all_routes"
-    # Need to build the pathParameters for the API Gateway event.
-    def rebuild_path_parameters(event)
-      extracted = extract_parameters(event["path"])
-      if extracted
-        params = event["pathParameters"] || {}
-        params.merge(extracted)
-      else
-        event["pathParameters"] # pass through
-      end
-    end
-
-    # Extracts the path parameters from the actual path
-    # Only supports extracting 1 parameter. So:
-    #
-    #   request_path: posts/tung/edit
-    #   route.path: posts/:id/edit
-    #
-    # Returns:
-    #    { id: "tung" }
-    def extract_parameters(request_path)
-      request_path = "/#{request_path}" unless request_path.starts_with?('/') # be more forgiving if / accidentally not included
-      request_path = remove_engine_mount_at_path(request_path)
-      if path.include?(':')
-        extract_parameters_capture(request_path)
-      elsif path.include?('*')
-        extract_parameters_proxy(request_path)
-      else
-        # Lambda AWS_PROXY sets null to the input request when there are no path parmeters
-        nil
-      end
-    end
-
-    def remove_engine_mount_at_path(request_path)
-      return request_path unless original_engine
-
-      mount = Jets::Router::EngineMount.find_by(engine: original_engine)
-      return request_path unless mount
-
-      request_path.sub(mount.at, '')
-    end
-
-    def extract_parameters_proxy(request_path)
-      # changes path to a string used for a regexp
-      # others/*proxy => others\/(.*)
-      # nested/others/*proxy => nested/others\/(.*)
-      if path.include?('/')
-        leading_path = path.split('/')[0..-2].join('/') # drop last segment
-        # leading_path: nested/others
-        # capture everything after the leading_path as the value
-        regexp = Regexp.new("#{leading_path}/(.*)")
-        value = request_path.match(regexp)[1]
-      else
-        value = request_path
-      end
-
-      # the last segment without the '*' is the key
-      proxy_segment = path.split('/').last # last segment is the proxy segment
-      # proxy_segment: *proxy
-      key = proxy_segment.sub('*','')
-
-      { key => value }
-    end
-
-    def extract_parameters_capture(request_path)
-      # changes path to a string used for a regexp
-      # posts/:id/edit => posts\/(.*)\/edit
-      labels = []
-      regexp_string = path.split('/').map do |s|
-                        if s.start_with?(':')
-                          labels << s.delete_prefix(':')
-                          CAPTURE_REGEX
-                        else
-                          s
-                        end
-                      end.join('\/')
-      # make sure beginning and end of the string matches
-      regexp_string = "^#{regexp_string}$"
-      regexp = Regexp.new(regexp_string)
-
-      values = regexp.match(request_path).captures
-      labels.map do |next_label|
-        [next_label, values.delete_at(0)]
-      end.to_h
-    end
-
-    # Prevents infinite loop when calling route.to_json for state.save("routes", ...)
-    def as_json(options= nil)
-      data = {
-        path: path,
-        http_method: http_method,
-        to: to,
-      }
-      data[:engine] = engine if engine
-      data[:internal] = internal if internal
-      data
-    end
-
-    # To keep "self #{self}" more concise and helpful
-    # Use "self #{self.inspect}" more verbose info
-    def to_s
-      "#<Jets::Router::Route:#{object_id} @options=#{@options}>"
-    end
-
-    # Old notes:
-    # For Grape apps, calling ActiveSupport to_json on a Grape class used to cause an infinite loop.
-    # Believe Grape fixed this issue. A GrapeApp.to_json now produces a string.
-    # No longer need to coerce to a string and back to a class.
-    #
-    # This is important because Sprocket::Environment.new cannot be coerced into a string or mounting wont work.
-    # This is used in sprockets-jets/lib/sprockets/jets/engine.rb
-    #
-    # Related PR: smarter apigw routes paging calculation #635
-    # https://github.com/boltops-tools/jets/pull/635
-    # Debugging notes: https://gist.github.com/tongueroo/c9baa7e98d5ad68bbdd770fde4651963
-    def mount_class
-      @options[:mount_class]
-    end
-
-    # For jets routes help table of routes
-    def mount_class_name
-      return unless mount_class
-      mount_class.class == Class ? mount_class : "#{mount_class.class}.new"
-    end
-
-  private
-    def ensure_jets_format(path)
-      path.split('/').map do |s|
-        if s =~ /^\{/ and s =~ /\+\}$/
-          s.sub(/^\{/, '*').sub(/\+\}$/,'') # {proxy+} => *proxy
-        elsif s =~ /^\{/ and s =~ /\}$/
-          s.sub('{',':').sub(/\}$/,'') # {id} => :id
-        else
-          s
-        end
-      end.join('/')
-    end
-
-    def api_gateway_format(path)
-      path.split('/')
-        .map {|s| transform_capture(s) }
-        .map {|s| transform_proxy(s) }
-        .join('/')
-    end
-
-    def transform_capture(text)
-      if text.starts_with?(':')
-        text = text.sub(':','')
-        text = "{#{text}}"
-      end
-      text
-    end
-
-    def transform_proxy(text)
-      if text.starts_with?('*')
-        text = text.sub('*','')
-        text = "{#{text}+}"
-      end
-      text
-    end
-  end
-end

data/lib/jets/router/route_set.rb

@@ -1,214 +0,0 @@
-require 'dsl_evaluator'
-
-# The Jets::Router::RouteSet mimics the Rails interface.
-# Jets works in a similar way to Rails.
-# For example the url_helpers:
-#
-#   Jets.application.routes.url_helpers
-#     => Jets.application.routes.named_routes.path_helpers_module
-#       => Jets::Router::Helpers::NamedRoutes::Generated::MainAppHelpers
-#
-# Jets makes less use of anonymous modules. It uses generated named modules
-# to help debugging. Whereas Rails:
-#
-#   Rails.application.routes.url_helpers => <Module>
-#   Rails.application.routes.named_routes.path_helpers_module => <Module>
-#   Rails.application.routes.named_routes.url_helpers_module  => <Module>
-#
-# Rails generates an anonymous module for url_helpers that wraps
-# and includes the path_helpers_module and url_helpers_module.
-#
-# Jets tries to exhibit enough of the same as Rails interface to make it
-# compatible with with ActionController and ActionView components.
-#
-module Jets::Router
-  class RouteSet
-    extend Memoist
-    include Compat::RouteSet
-    include Dsl
-
-    # With Jets, this class is not a really a Collection. It's a wrapper
-    # around Helpers::NamedRoutes::Generated which does the real work.
-    # Naming it NamedRouteCollection to be consistent with Rails and possibly
-    # in the future to make them more similar.
-    class NamedRouteCollection
-      attr_reader :url_helpers_module
-      def initialize(route_set)
-        @url_helpers_module = Helpers::NamedRoutes::Generated.create_helper_module(route_set)
-      end
-
-      # interface method
-      # Rails AbstractController::UrlFor calls this method
-      # Reason why this wrapper is needed.
-      def helper_names
-        url_helpers_module.path_helpers.map(&:to_s) +
-        url_helpers_module.url_helpers.map(&:to_s)
-      end
-
-      delegate :remove_methods!, :add_methods!, to: :url_helpers_module
-    end
-
-    attr_reader :routes, :engine
-    attr_accessor :draw_paths, :default_scope, :default_url_options,
-      :disable_clear_and_finalize
-    def initialize(engine=Jets.application)
-      @engine = engine
-      @engine_class = engine.class
-      @default_url_options = {} # {host: "localhost"}
-      @routes = []
-      @draw_paths = [] # not part of clear! addtional paths: config/routes/admin.rb
-      @prepend = []    # not part of clear! Otherwise breaks engines like sprockets-jets
-      @append = []     # not part of clear!
-      @finalized = false
-      @disable_clear_and_finalize = false
-      @default_scope = {}
-    end
-
-    # draw is called from config/routes.rb
-    # load! is what we just internally to trigger it
-    def draw(&block)
-      clear! unless @disable_clear_and_finalize
-      scope(default_scope) do
-        instance_eval(&block)
-      end
-      finalize! unless @disable_clear_and_finalize
-      check_collision!
-    end
-
-    # Be selective about what to clear. Keep other initialized instance variables
-    # like @prepend, @append, @default_scope
-    # Otherwise can break engines like sprockets-jets that use prepend.
-    def clear!
-      @finalized = false
-      @routes = []
-      @scope = Scope.new
-      named_routes.remove_methods!
-      @prepend.each { |blk| instance_eval(&blk) }
-    end
-
-    # Interface method for plugins.
-    # Plugins like kingsman use to hook into Jets after routes are loaded.
-    def finalize!
-      return if @finalized
-      @append.each { |blk| instance_eval(&blk) }
-      load_external_paths
-      named_routes.add_methods!
-      @finalized = true
-    end
-
-    # additonal paths: config/routes/admin.rb
-    def load_external_paths
-      @draw_paths.each do |draw_path|
-        Dir.glob("#{draw_path}/*.rb").each do |route_path|
-          instance_eval(File.read(route_path), route_path.to_s)
-        end
-      end
-    end
-
-    def append(&block)
-      @append << block
-    end
-
-    def prepend(&block)
-      @prepend << block
-    end
-
-    # Rails interface method
-    def eager_load!
-      # noop for Jets
-    end
-
-    def url_helpers(supports_path = true)
-      @url_helpers ||= named_routes.url_helpers_module
-    end
-
-    def mounted_helpers
-      # Calling url_helpers to create the mounted_helpers proxy methods
-      # IE: main_app and blorgh
-      url_helpers
-      @mounted_helpers ||= Helpers::NamedRoutes::Generated::MountedHelpers
-    end
-
-    def define_mounted_helper(name)
-      Helpers::NamedRoutes::Generated.define_mounted_helper(name, self)
-    end
-
-    # Note: Jets assigns this to a instance varialbe in the initialize method
-    # But Jets cannot do this because we currently eager load internally and
-    # that routes draw would not be called in proper order.
-    def named_routes
-      NamedRouteCollection.new(self)
-    end
-    memoize :named_routes
-
-    # Validate routes that deployable
-    def check_collision!
-      return if Jets.config.cfn.build.routes == "one_apigw_method_for_all_routes"
-      paths = self.routes.map(&:path)
-      collision = Jets::Cfn::Resource::ApiGateway::RestApi::Routes::Collision.new
-      collide = collision.collision?(paths)
-      raise collision.exception if collide
-    end
-
-    def one_apigw_method_for_all_routes_warning(options)
-      return unless options[:authorizer]
-      return unless Jets.config.cfn.build.routes == "one_apigw_method_for_all_routes"
-      return if options[:path].starts_with?('*') # *catchall
-      return if options[:path] == '' # root
-
-      puts <<~EOL.color(:yellow)
-        WARNING: Authorizer should not be set at individual routes when using
-
-            config.cfn.build.routes == "one_apigw_method_for_all_routes"
-
-        You should only set authorizer for the root route and *catchall route.
-        The root route uses the root authorizer.
-        And all other routes uses the *catchall authorizer.
-        Docs: http://rubyonjets.com/docs/routing/authorizers/one-method/
-      EOL
-      DslEvaluator.print_code(routes_call_line) if routes_call_line
-    end
-
-    def routes_call_line
-      caller.find { |l| l.include?('config/routes.rb') }
-    end
-
-    def api_mode?
-      Jets.config.mode == 'api' || Jets.config.api_only
-    end
-
-    # Useful for creating API Gateway Resources
-    def all_paths
-      results = []
-      paths = routes.map(&:path)
-      paths.each do |p|
-        sub_paths = []
-        parts = p.split('/')
-        until parts.empty?
-          parts.pop
-          sub_path = parts.join('/')
-          sub_paths << sub_path unless sub_path == ''
-        end
-        results += sub_paths
-      end
-      @all_paths = (results + paths).sort.uniq
-    end
-
-    # Useful for RouterMatcher
-    #
-    # Precedence:
-    # Routes with wildcards are considered after routes without wildcards
-    #
-    # Routes with fewer captures are ordered first since both
-    # /posts/:post_id/comments/new and /posts/:post_id/comments/:id are equally
-    # long
-    #
-    # Routes with the same amount of captures and wildcards are orderd so that
-    # the longest path is considered first since posts/:id and posts/:id/edit
-    # can both match.
-    def ordered_routes
-      length = Proc.new { |r| [r.path.count("*"), r.path.count(":"), r.path.length * -1] }
-      routes.sort_by(&length)
-    end
-  end
-end