jets.benforeva 3.0.17.pre.mount.pre.fix

data/lib/jets/router/method_creator.rb

@@ -0,0 +1,50 @@
+class Jets::Router
+  class MethodCreator
+    include Util
+
+    def initialize(options, scope)
+      @options, @scope = options, scope
+      @controller, @action = get_controller_action(@options)
+    end
+
+    def define_url_helper!
+      return unless @options[:method] == :get
+
+      if %w[index new show edit].include?(@action)
+        create_method(@action)
+      else
+        create_method("generic")
+      end
+    end
+
+    # Examples:
+    #
+    #   posts_path: path: 'posts'
+    #   admin_posts_path: prefix: 'admin', path: 'posts'
+    #   new_post_path
+    #
+    def create_method(action)
+      # Code eventually does this:
+      #
+      #     code = Jets::Router::MethodCreator::Edit.new
+      #     def_meth code.path_method
+      #
+      class_name = "Jets::Router::MethodCreator::#{action.camelize}"
+      klass = class_name.constantize # Index, Show, Edit, New
+      code = klass.new(@options, @scope, @controller)
+
+      def_meth(code.path_method) if code.path_method
+      def_meth(code.url_method) if code.url_method
+    end
+
+    def create_root_helper
+      code = Jets::Router::MethodCreator::Root.new(@options, @scope, @controller)
+      def_meth(code.path_method)
+      def_meth(code.url_method)
+    end
+
+    def def_meth(str)
+      Jets::Router::Helpers::NamedRoutesHelper.class_eval(str)
+    end
+  end
+end

data/lib/jets/router/resources/base.rb

@@ -0,0 +1,7 @@
+module Jets::Router::Resources
+  class Base
+    def initialize(name, options)
+      @name, @options = name, options
+    end
+  end
+end

data/lib/jets/router/resources/filter.rb

@@ -0,0 +1,15 @@
+module Jets::Router::Resources
+  class Filter < Base
+    def yes?(action)
+      return true unless @options[:only] || @options[:except]
+
+      if @options[:only]
+        only = [@options[:only]].flatten.map(&:to_s)
+        only.include?(action.to_s)
+      else # except
+        except = [@options[:except]].flatten.map(&:to_s)
+        !except.include?(action.to_s)
+      end
+    end
+  end
+end

data/lib/jets/router/resources/options.rb

@@ -0,0 +1,13 @@
+module Jets::Router::Resources
+  class Options < Base
+    def build(action)
+      controller = @options[:singular_resource] ? @name.to_s.pluralize : @name
+      options = @options.merge(to: "#{controller}##{action}") # important to create a copy of the options
+      # remove special options from getting to create_route. For some reason .slice! doesnt work
+      options.delete(:only)
+      options.delete(:except)
+      options[:from_scope] = true # flag to drop the prefix later in Route#compute_path
+      options
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+class Jets::Router::Route
+  module Authorizer
+    # IE: main#protect => MainProtectAuthorizer
+    def authorizer_id(prefix_class: true)
+      return unless authorizer
+      logical_id(authorizer, prefix_class: prefix_class)
+    end
+
+    # Metadata about the authorizer class that can be used later. Stored in the Authorizer template parameters.
+    # In app_class.rb `def controller_params` it is used to build the input parameters for controller templates.
+    def authorizer_metadata
+      metadata(authorizer)
+    end
+
+    def authorizer
+      @options[:authorizer]
+    end
+
+    def authorization_scopes
+      @options[:authorization_scopes]
+    end
+
+    def authorization_type
+      @options[:authorization_type] || inferred_authorization_type
+    end
+
+    def api_key_required
+      @options[:api_key_required]
+    end
+
+    module ModuleMethods
+      def logical_id(authorizer, prefix_class: true)
+        klass, meth = authorizer.split("#")
+        words = [meth, "authorizer"]
+        words.unshift(klass) if prefix_class
+        words.join('_').camelize # logical_id
+      end
+
+      def metadata(authorizer)
+        klass = authorizer.split("#").first
+        authorizer_class = "#{klass}_authorizer".camelize
+        logical_id = logical_id(authorizer, prefix_class: false)
+        # IE: MainAuthorizer.ProtectAuthorizer
+        "#{authorizer_class}.#{logical_id}"
+      end
+    end
+    include ModuleMethods # so available as instance methods
+    extend ModuleMethods # so also available as module method. IE: Jets::Router::Route::Authorizer.metadata(auth_to)
+
+  private
+    def inferred_authorization_type
+      return unless authorizer
+      Jets::Authorizer::Base.authorization_type(authorizer)
+    end
+
+  end
+end

data/lib/jets/router/route.rb

@@ -0,0 +1,230 @@
+# route = Jets::Router::Route.new(
+#   path: "posts",
+#   method: :get,
+#   to: "posts#index",
+# )
+class Jets::Router
+  class Route
+    include Util
+    include Authorizer
+
+    CAPTURE_REGEX = "([^/]*)" # as string
+
+    attr_reader :to, :as
+    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
+    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
+    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}"
+    end
+
+    def compute_as
+      return nil if @options[:as] == :disabled
+      return unless @options[:method] == :get || @options[:root]
+
+      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
+
+      klass.new(@options, @scope, controller).full_meth_name(nil)
+    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
+    end
+
+    def method
+      @options[:method].to_s.upcase
+    end
+
+    def internal?
+      !!@options[:internal]
+    end
+
+    def homepage?
+      path == ''
+    end
+
+    # IE: PostsController
+    def controller_name
+      to.sub(/#.*/,'').camelize + "Controller"
+    end
+
+    # IE: index
+    def action_name
+      to.sub(/.*#/,'')
+    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
+        return false
+      end
+      controller_class.lambda_functions.include?(action_name.to_sym)
+    end
+
+    # Extracts the path parameters from the actual path
+    # Only supports extracting 1 parameter. So:
+    #
+    #   actual_path: posts/tung/edit
+    #   route.path: posts/:id/edit
+    #
+    # Returns:
+    #    { id: "tung" }
+    def extract_parameters(actual_path)
+      if path.include?(':')
+        extract_parameters_capture(actual_path)
+      elsif path.include?('*')
+        extract_parameters_proxy(actual_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)
+      # 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 = actual_path.match(regexp)[1]
+      else
+        value = actual_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(actual_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(actual_path).captures
+      labels.map do |next_label|
+        [next_label, values.delete_at(0)]
+      end.to_h
+    end
+
+    def mount_class
+      @options[:mount_class]
+    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/scope.rb

@@ -0,0 +1,95 @@
+module Jets
+  class Router
+    class Scope
+      include Util
+
+      attr_reader :options, :parent, :level
+      def initialize(options = {}, parent = nil, level = 1)
+        @options = options
+        @parent = parent
+        @level = level
+      end
+
+      def root?
+        @parent.nil?
+      end
+
+      def new(options={})
+        self.class.new(options, self, level + 1)
+      end
+
+      def full_module
+        items = walk_parents do |current, i, result|
+          mod = current.options[:module]
+          next unless mod
+          result.unshift(mod)
+        end
+
+        items.empty? ? nil : items.join('/')
+      end
+
+      def full_prefix
+        items = walk_parents do |current, i, result|
+          prefix = current.options[:prefix]
+          next unless prefix
+
+          case current.from
+          when :resources
+            path_param = if current.options[:param]
+              ":#{current.options[:param]}"
+            else
+              resource_name = prefix.to_s.split('/').last
+              resource_name = ":#{resource_name.singularize}_id"
+            end
+            result.unshift(path_param)
+            result.unshift(prefix)
+          else # resource, namespace or general scope
+            result.unshift(prefix)
+          end
+        end
+
+        items.empty? ? nil : items.join('/')
+      end
+
+      def full_as
+        items = []
+        current = self
+        while current
+          items.unshift(current.options[:as]) # <= option_name
+          current = current.parent
+        end
+
+        items.compact!
+        return if items.empty?
+
+        items = singularize_leading(items)
+        items.join('_')
+      end
+
+      def walk_parents
+        current, i, result = self, 0, []
+        while current
+          yield(current, i, result)
+          current = current.parent
+          i += 1
+        end
+        result
+      end
+
+      # singularize all except last item
+      def singularize_leading(items)
+        result = []
+        items.each_with_index do |item, index|
+          item = item.to_s
+          r = index == items.size - 1 ? item : item.singularize
+          result << r
+        end
+        result
+      end
+
+      def from
+        @options[:from]
+      end
+    end
+  end
+end

data/lib/jets/router/util.rb

@@ -0,0 +1,38 @@
+class Jets::Router
+  module Util
+    # used in MethodCreator logic
+    def join(*items)
+      list = items.compact.join('_')
+      underscore(list)
+    end
+
+    def underscore(str)
+      return unless str
+      str.to_s.gsub(/[^a-zA-Z0-9]/,'_')
+    end
+
+    def get_controller_action(options)
+      if options.key?(:controller) && options.key?(:action)
+        [options[:controller], options[:action]]
+      elsif options.key?(:controller) && options.key?(:to)
+        action = options[:to].split('#').last
+        [options[:controller], action]
+      elsif options.key?(:on)
+        handle_on!(options)
+      else
+        options[:to].split('#') # controller, action
+      end
+    end
+
+    def handle_on!(options)
+      controller = @scope.options[:prefix].to_s
+      to = "#{controller}##{options[:path]}"
+      options[:to] = to
+
+      as = @options[:on] == :member ? controller.singularize : controller
+      as = "#{@options[:path]}_#{as}"
+      options[:as] = as
+      to.split('#')
+    end
+  end
+end

data/lib/jets/router.rb

@@ -0,0 +1,180 @@
+require 'text-table'
+
+module Jets
+  class Router
+    include Dsl
+
+    attr_reader :routes
+    def initialize
+      @routes = []
+      @scope = Scope.new
+    end
+
+    def draw(&block)
+      instance_eval(&block)
+      check_collision!
+    end
+
+    # Validate routes that deployable
+    def check_collision!
+      paths = self.routes.map(&:path)
+      collision = Jets::Resource::ApiGateway::RestApi::Routes::Collision.new
+      collide = collision.collision?(paths)
+      raise collision.exception if collide
+    end
+
+    def create_route(options)
+      # TODO: Can use it to add additional things like authorization_type
+      # Would be good to add authorization_type at the controller level also
+      infer_to_option!(options)
+      handle_on!(options)
+      MethodCreator.new(options, @scope).define_url_helper!
+      @routes << Route.new(options, @scope)
+    end
+
+    # Can possibly infer to option from the path. Example:
+    #
+    #     get 'posts/index'
+    #     get 'posts', to: 'posts#index'
+    #
+    #     get 'posts/show'
+    #     get 'posts', to: 'posts#show'
+    #
+    def infer_to_option!(options)
+      return if options[:to]
+
+      path = options[:path].to_s
+      return unless path.include?('/')
+
+      items = path.split('/')
+      if items.size == 2
+        options[:to] = items.join('#')
+      end
+    end
+
+    def handle_on!(options)
+      if options[:on] && !%w[resources resource].include?(@scope.from.to_s)
+        raise Error.new("ERROR: The `on:` option can only be used within a resource or resources block")
+      end
+      options[:on] ||= @on_option if @on_option
+    end
+
+    def api_mode?
+      if Jets.config.key?(:api_mode) || Jets.config.key?(:api_generator)
+        puts <<~EOL.color(:yellow)
+          DEPRECATED: Jets.config.api_generator
+          Instead, please update your config/application.rb to use:
+            Jets.config.mode = 'api'
+          You can also run:
+            jets upgrade
+        EOL
+      end
+      api_mode = Jets.config.mode == 'api' || Jets.config.api_mode || Jets.config.api_generator
+      api_mode
+    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
+
+    class << self
+      def has_controller?(name)
+        routes.detect { |r| r.controller_name == name }
+      end
+
+      # Class methods
+      def draw
+        drawn_router
+      end
+
+      @@drawn_router = nil
+      def drawn_router
+        return @@drawn_router if @@drawn_router
+
+        router = Jets.application.routes
+        @@drawn_router = router
+      end
+
+      def clear!
+        @@drawn_router = nil
+        Jets::Router::Helpers::NamedRoutesHelper.clear!
+      end
+
+      def routes
+        drawn_router.routes
+      end
+
+      # Returns all paths including subpaths.
+      # Example:
+      # Input: ["posts/:id/edit"]
+      # Output: ["posts", "posts/:id", "posts/:id/edit"]
+      def all_paths
+        drawn_router.all_paths
+      end
+
+      def help(routes)
+        return "Your routes table is empty." if routes.empty?
+
+        table = Text::Table.new
+        table.head = %w[As Verb Path Controller#action]
+        routes.each do |route|
+          table.rows << [route.as, route.method, route.path, route.to]
+        end
+        table
+      end
+
+      def all_routes_valid?
+        invalid_routes.empty?
+      end
+
+      def invalid_routes
+        routes.select { |r| !r.valid? }
+      end
+
+      def validate_routes!
+        check_route_connected_functions
+      end
+
+      # Checks that all routes are validate and have corresponding lambda functions
+      def check_route_connected_functions
+        return true if all_routes_valid?
+
+        puts "Please double check the routes below map to valid controllers:".color(:red)
+        invalid_routes.each do |route|
+          puts "  /#{route.path} => #{route.controller_name}##{route.action_name}"
+        end
+        false
+      end
+    end
+  end
+end