jets 3.1.0 → 5.0.0

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

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

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

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

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

@@ -0,0 +1,93 @@
+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,98 +1,58 @@
 # route = Jets::Router::Route.new(
 #   path: "posts",
-#   method: :get,
+#   http_method: :get,
 #   to: "posts#index",
 # )
-class Jets::Router
+module Jets::Router
   class Route
-    include Util
+    extend Memoist
+    include Compat
+    include AfterInitialize
+    include As
     include Authorizer
+    include Path
+    include Util
 
     CAPTURE_REGEX = "([^/]*)" # as string
 
-    attr_reader :to, :as
+    attr_reader :options, :scope, :info, :defaults
+    attr_accessor :original_engine
     def initialize(options, scope=Scope.new)
-      @options, @scope = options, scope
-      @path = compute_path
-      @to = compute_to
-      @as = compute_as
-    end
-
-    def compute_path
-      # Note: The @options[:prefix] 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 more simple.
-      #
-      prefix = @scope.full_prefix
-      prefix = account_scope(prefix)
-      prefix = account_on(prefix)
-
-      path = [prefix, @options[:path]].compact.join('/')
-      path = path[1..-1] if path.starts_with?('/') # be more forgiving if / accidentally included
-      path
-    end
-
-    def account_scope(prefix)
-      return unless prefix
-      return prefix unless @options[:from_scope]
-
-      if @options[:singular_resource]
-        prefix.split('/')[0..-2].join('/')
-      else
-        prefix.split('/')[0..-3].join('/')
-      end
+      @options = options
+      @scope = scope
+      @info = Info.new(@options, @scope) # @info.action and @info.controller
+      after_initialize
+      @path_names = {}
     end
 
-    def account_on(prefix)
-      # Tricky @scope.from == :resources since the account_scope already has accounted for it
-      if @options[:on] == :collection && @scope.from == :resources
-        prefix = prefix.split('/')[0..-2].join('/')
-      end
-      prefix == '' ? nil : prefix
+    def to
+      engine || "#{@info.controller}##{@info.action}" # IE: posts#index
     end
 
-    def compute_to
-      controller, action = get_controller_action(@options)
-      mod = @options[:module] || @scope.full_module
-      controller = [mod, controller].compact.join('/') # add module
-      "#{controller}##{action}"
+    def engine
+      @options[:engine]
     end
+    alias rack_app engine
 
-    def compute_as
-      return nil if @options[:as] == :disabled
-      return unless @options[:method] == :get || @options[:root]
+    def engine?
+      !!engine
+    end
 
-      controller, action = get_controller_action(@options)
-      klass = if @options[:root]
-        Jets::Router::MethodCreator::Root
-      elsif %w[index edit show new].include?(action.to_s)
-        class_name = "Jets::Router::MethodCreator::#{action.camelize}"
-        class_name.constantize # Index, Show, Edit, New
-      else
-        Jets::Router::MethodCreator::Generic
-      end
+    def endpoint
+      engine.to_s if engine
+    end
 
-      klass.new(@options, @scope, controller).full_meth_name(nil)
+    def resolved_defaults
+      defaults = @options[:defaults] || {}
+      @scope.resolved_defaults.merge(defaults)
     end
 
-    # IE: standard: posts/:id/edit
-    #     api_gateway: posts/{id}/edit
-    def path(format=:jets)
-      case format
-      when :api_gateway
-        api_gateway_format(@path)
-      when :raw
-        @path
-      else # jets format
-        ensure_jets_format(@path)
-      end
+    def http_method
+      @options[:http_method].to_s.upcase
     end
 
-    def method
-      @options[:method].to_s.upcase
+    def constraints
+      @options[:constraints] || @scope.resolved_constraints
     end
 
     def internal?
@@ -100,17 +60,18 @@ class Jets::Router
     end
 
     def homepage?
-      path == ''
+      path == '/'
     end
 
     # IE: PostsController
-    def controller_name
-      to.sub(/#.*/,'').camelize + "Controller"
-    end
-
     # IE: index
-    def action_name
-      to.sub(/.*#/,'')
+    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
@@ -118,32 +79,55 @@ class Jets::Router
     def valid?
       controller_class = begin
         controller_name.constantize
-      rescue NameError
+      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:
     #
-    #   actual_path: posts/tung/edit
+    #   request_path: posts/tung/edit
     #   route.path: posts/:id/edit
     #
     # Returns:
     #    { id: "tung" }
-    def extract_parameters(actual_path)
+    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(actual_path)
+        extract_parameters_capture(request_path)
       elsif path.include?('*')
-        extract_parameters_proxy(actual_path)
+        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 extract_parameters_proxy(actual_path)
+    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\/(.*)
@@ -152,9 +136,9 @@ class Jets::Router
         # leading_path: nested/others
         # capture everything after the leading_path as the value
         regexp = Regexp.new("#{leading_path}/(.*)")
-        value = actual_path.match(regexp)[1]
+        value = request_path.match(regexp)[1]
       else
-        value = actual_path
+        value = request_path
       end
 
       # the last segment without the '*' is the key
@@ -165,7 +149,7 @@ class Jets::Router
       { key => value }
     end
 
-    def extract_parameters_capture(actual_path)
+    def extract_parameters_capture(request_path)
       # changes path to a string used for a regexp
       # posts/:id/edit => posts\/(.*)\/edit
       labels = []
@@ -181,16 +165,51 @@ class Jets::Router
       regexp_string = "^#{regexp_string}$"
       regexp = Regexp.new(regexp_string)
 
-      values = regexp.match(actual_path).captures
+      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|