jets 1.9.32 → 2.0.0

data/lib/jets/router/error.rb

@@ -0,0 +1,4 @@
+class Jets::Router
+  class Error < RuntimeError
+  end
+end

data/lib/jets/router/helpers.rb

@@ -0,0 +1,4 @@
+module Jets::Router::Helpers
+  include CoreHelper
+  include NamedRoutesHelper
+end

data/lib/jets/router/helpers/core_helper.rb

@@ -0,0 +1,17 @@
+module Jets::Router::Helpers
+  module CoreHelper
+    # Used for form_for helper
+    def polymorphic_path(record, _)
+      url_for(record)
+    end
+
+    # override helper delegates to point to jets controller
+    # TODO: params is weird
+    CONTROLLER_DELEGATES = %w[session response headers]
+    CONTROLLER_DELEGATES.each do |meth|
+      define_method meth do
+        @_jets[:controller].send(meth)
+      end
+    end
+  end
+end

data/lib/jets/router/helpers/named_routes_helper.rb

@@ -0,0 +1,8 @@
+module Jets::Router::Helpers
+  module NamedRoutesHelper
+    def self.clear!
+      meths = public_instance_methods(false)
+      meths.each { |m| remove_method(m) }
+    end
+  end
+end

data/lib/jets/router/method_creator.rb

@@ -0,0 +1,54 @@
+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)
+
+      # puts "define_#{action}_methods:".color(:yellow) if code.path_method
+      # puts code.path_method.color(:blue) if code.path_method
+      # puts code.url_method.color(:blue) if code.url_method
+
+      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/method_creator/code.rb

@@ -0,0 +1,98 @@
+class Jets::Router::MethodCreator
+  class Code
+    include Jets::Router::Util
+
+    def initialize(options, scope, controller, action=nil)
+      @options, @scope, @controller, @action = options, scope, controller, action
+      @path, @as = options[:path], options[:as]
+    end
+
+    def meth_args
+      params = full_path.split('/').select { |x| x.include?(':') }
+      items = params.map { |x| x.sub(':','') }
+
+      items.empty? ? nil : "("+items.join(', ')+")"
+    end
+
+    def meth_result
+      results = full_path.split('/').map do |x|
+        if x.include?(':')
+          variable = x.sub(':','')
+          "\#{#{variable}.to_param}"
+        else
+          x
+        end
+      end
+
+      '/' + results.join('/') unless results.empty?
+    end
+
+    def full_path
+      route = Jets::Router::Route.new(@options, @scope)
+      route.compute_path
+    end
+
+    def action
+      @action || self.class.name.split('::').last.downcase
+    end
+
+    def full_as
+      @scope&.full_as
+    end
+
+    # The method_name_leaf is used to generate method names.
+    # Can be nil because sometimes the name is fully acquired from the scope.
+    def method_name_leaf
+      unless %w[resource resources].include?(@scope.from.to_s) && @options[:from_scope]
+        @controller
+      end
+    end
+
+    def full_meth_name(suffix=nil)
+      as =  @as || meth_name
+      name = [as, suffix].compact.join('_')
+      underscore(name)
+    end
+
+    def path_method
+      <<~EOL
+        def #{full_meth_name(:path)}#{meth_args}
+          "#{meth_result}"
+        end
+      EOL
+    end
+
+    def url_method
+      path_method_call = "#{full_meth_name(:path)}#{meth_args}"
+      # Note: It is important lazily get the value of ENV['JETS_HOST'] within the method.
+      # Since it is not set until the requrest goes through the main middleware.
+      <<~EOL
+        def #{full_meth_name(:url)}#{meth_args}
+          "\#{ENV['JETS_HOST']}\#{#{path_method_call}}"
+        end
+      EOL
+    end
+
+    def param_name(name)
+      # split('/').last for case:
+      #
+      #   resources :posts, prefix: "articles", only: :index do
+      #     resources :comments, only: :new
+      #   end
+      #
+      # Since the prefix at the scope level is added to the posts item, which results in:
+      #
+      #   param_name("articles/posts")
+      #
+      # We drop the articles prefix portion. The resources items can only be words with no /.
+      #
+      name.to_s.split('/').last.singularize + "_id"
+    end
+
+  private
+    def singularize(s)
+      return unless s # nil
+      s.singularize
+    end
+  end
+end

data/lib/jets/router/method_creator/edit.rb

@@ -0,0 +1,7 @@
+class Jets::Router::MethodCreator
+  class Edit < Code
+    def meth_name
+      join(action, singularize(full_as), singularize(method_name_leaf))
+    end
+  end
+end

data/lib/jets/router/method_creator/generic.rb

@@ -0,0 +1,11 @@
+class Jets::Router::MethodCreator
+  class Generic < Code
+    def meth_name
+      @options[:as]
+    end
+
+    def path_method
+      super if @options[:as]
+    end
+  end
+end

data/lib/jets/router/method_creator/index.rb

@@ -0,0 +1,42 @@
+class Jets::Router::MethodCreator
+  class Index < Code
+    def meth_name
+      # Well this is pretty confusing and tough to follow. TODO: figure out how to improve this.
+      #
+      # Example 1:
+      #
+      #     resources :users, only: [] do
+      #       resources :posts, only: :index
+      #     end
+      #
+      # Results in:
+      #
+      #     full_as: user_posts
+      #     method_name_leaf: nil
+      #
+      # Example 2:
+      #
+      #     resources :users, only: [] do
+      #       get "posts", to: "posts#index"
+      #     end
+      #
+      # Results in:
+      #
+      #     full_as: users
+      #     method_name_leaf: posts
+      #
+      # This is because using resources contains all the info we need in parent scopes.
+      # The scope.full_as already has the desired meth_name.
+      #
+      # However, when using the simple create_route methods like get, the parent scope does not contain
+      # all the info we need. In this tricky case, the method_name_leaf is set.
+      # We then have to reconstruct the meth_name.
+      #
+      if method_name_leaf
+        join(singularize(full_as), method_name_leaf) # reconstruct
+      else
+        join(full_as) # construct entirely from scope info
+      end
+    end
+  end
+end

data/lib/jets/router/method_creator/new.rb

@@ -0,0 +1,7 @@
+class Jets::Router::MethodCreator
+  class New < Code
+    def meth_name
+      join(action, singularize(full_as), singularize(method_name_leaf))
+    end
+  end
+end

data/lib/jets/router/method_creator/root.rb

@@ -0,0 +1,15 @@
+class Jets::Router::MethodCreator
+  class Root < Code
+    def meth_name
+      "root"
+    end
+
+    def meth_args
+      nil
+    end
+
+    def meth_result
+      nil
+    end
+  end
+end

data/lib/jets/router/method_creator/show.rb

@@ -0,0 +1,7 @@
+class Jets::Router::MethodCreator
+  class Show < Code
+    def meth_name
+      join(singularize(full_as), singularize(method_name_leaf))
+    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.rb

@@ -0,0 +1,226 @@
+# route = Jets::Router::Route.new(
+#   path: "posts",
+#   method: :get,
+#   to: "posts#index",
+# )
+class Jets::Router
+  class Route
+    include Util
+
+    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)
+
+      [prefix, @options[:path]].compact.join('/')
+    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 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 authorization_type
+      @options[:authorization_type]
+    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