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

data/lib/jets/resource/standardizer.rb

@@ -0,0 +1,42 @@
+class Jets::Resource
+  class Standardizer
+    attr_reader :definition
+    def initialize(*definition)
+      @definition = definition.flatten
+    end
+
+    def template
+      camelize(standarize(@definition))
+    end
+
+    def camelize(attributes)
+      Jets::Camelizer.transform(attributes)
+    end
+
+    def standarize(definition)
+      first, second, third, _ = definition
+      if definition.size == 1 && first.is_a?(Hash) # long form
+        first # pass through
+      elsif definition.size == 2 && second.is_a?(Hash) # medium form
+        logical_id, attributes = first, second
+        attributes.delete(:properties) if attributes[:properties].nil? || attributes[:properties].empty?
+        { logical_id => attributes }
+      elsif definition.size == 2 && second.is_a?(String) # short form
+        logical_id, type = first, second
+        { logical_id => {
+            type: type
+        }}
+      elsif definition.size == 3 && (second.is_a?(String) || second.is_a?(NilClass))# short form
+        logical_id, type, properties = first, second, third
+        template = { logical_id => {
+                       type: type
+                    }}
+        attributes = template.values.first
+        attributes[:properties] = properties unless properties.empty?
+        template
+      else # Dont understand this form
+        raise "Invalid form provided. definition #{definition.inspect}"
+      end
+    end
+  end
+end

data/lib/jets/resource.rb

@@ -0,0 +1,71 @@
+class Jets::Resource
+  extend Memoist
+
+  attr_reader :definition, :replacements
+  def initialize(definition, replacements={})
+    @definition = definition
+    @replacements = replacements
+  end
+
+  def template
+    standarize(definition)
+  end
+  memoize :template
+
+  # CloudFormation Resources reference: https://amzn.to/2NKg6ip
+  def standarize(*definition)
+    Standardizer.new(definition).template
+  end
+
+  def logical_id
+    id = template.keys.first
+    # replace possible {namespace} in the logical id
+    id = replacer.replace_value(id)
+    id = Jets::Camelizer.camelize(id)
+
+    Jets::Resource.truncate_id(id)
+  end
+
+  def self.truncate_id(id, postfix = '')
+    # Api Gateway resource name has a limit of 64 characters.
+    # Yet it throws not found when ID is longer than 62 characters and I don't know why.
+    # To keep it safe, let's stick to the 62 characters limit.
+    if id.size + postfix.size > 62
+      "#{id[0..(55 - postfix.size)]}#{Digest::MD5.hexdigest(id)[0..5]}#{postfix}"
+    else
+      "#{id}#{postfix}"
+    end
+  end
+
+  def type
+    attributes['Type']
+  end
+
+  def properties
+    attributes['Properties']
+  end
+
+  def attributes
+    attributes = template.values.first
+    attributes = replacer.replace_placeholders(attributes)
+    Jets::Camelizer.transform(attributes)
+  end
+
+  def parameters
+    {}
+  end
+
+  def outputs
+    {}
+  end
+
+  def replacer
+    Replacer.new(replacements)
+  end
+  memoize :replacer
+
+  def permission
+    Permission.new(replacements, self)
+  end
+  memoize :permission
+end

data/lib/jets/router/dsl/mount.rb

@@ -0,0 +1,13 @@
+module Jets::Router::Dsl
+  module Mount
+    # The mounted class must be a Rack compatiable class
+    def mount(klass, at:)
+      options = {to: "jets/mount#call", mount_class: klass}
+      at = at[1..-1] if at.starts_with?('/') # be more forgiving if / accidentally included
+      at_wildcard = at.blank? ? "*path" : "#{at}/*path"
+
+      any at, options
+      any at_wildcard, options
+    end
+  end
+end

data/lib/jets/router/dsl.rb

@@ -0,0 +1,144 @@
+class 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 |path, options={}|
+        create_route(options.merge(path: escape_path(path), method: __method__))
+      end
+    end
+
+    def namespace(ns, &block)
+      scope(module: ns, prefix: ns, as: ns, from: :namespace, &block)
+    end
+
+    def prefix(prefix, &block)
+      scope(prefix: prefix, &block)
+    end
+
+    # scope supports three options: module, prefix and as.
+    # Jets vs Rails:
+    #   module - module
+    #   prefix - path
+    #   as - as
+    def scope(args)
+      # normalizes `scope(:admin)` as `scope(prefix: :admin)`
+      options = case args
+      when Hash
+        args
+      when String, Symbol
+        { prefix: args }
+      end
+
+      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(*items, **options)
+      items.each do |item|
+        scope_options = scope_options!(item, options)
+        scope_options[:from] = :resources # flag for MethodCreator logic: to handle method_name_leaf and more
+        scope(scope_options) do
+          each_resources(item, options, block_given?)
+          yield if block_given?
+        end
+      end
+    end
+
+    def scope_options!(item, options)
+      prefix = if options[:prefix]
+        # prefix given from the resources macro get automatically prepended to the item name
+        p = options.delete(:prefix)
+        "#{p}/#{item}"
+      else
+        item
+      end
+
+      {
+        as: options.delete(:as) || item, # delete as or it messes with create_route
+        prefix: prefix,
+        param: options[:param],
+        # module: options.delete(:module) || item, # NOTE: resources does not automatically set module, but namespace does
+      }
+    end
+
+    def each_resources(name, options={}, has_block=nil)
+      o = Resources::Options.new(name, options)
+      f = Resources::Filter.new(name, options)
+      param = default_param(has_block, name, options)
+
+      get name, o.build(:index) if f.yes?(:index)
+      get "#{name}/new", o.build(:new) if f.yes?(:new) && !api_mode?
+      get "#{name}/:#{param}", o.build(:show) if f.yes?(:show)
+      post name, o.build(:create) if f.yes?(:create)
+      get "#{name}/:#{param}/edit", o.build(:edit) if f.yes?(:edit) && !api_mode?
+      put "#{name}/:#{param}", o.build(:update) if f.yes?(:update)
+      post "#{name}/:#{param}", o.build(:update) if f.yes?(:update) # for binary uploads
+      patch "#{name}/:#{param}", o.build(:update) if f.yes?(:update)
+      delete "#{name}/:#{param}", o.build(:delete) if f.yes?(:delete)
+    end
+
+    def resource(*items, **options)
+      items.each do |item|
+        scope_options = scope_options!(item, options)
+        scope_options[:from] = :resource # flag for MethodCreator logic: to handle method_name_leaf and more
+        scope(scope_options) do
+          each_resource(item, options, block_given?)
+          yield if block_given?
+        end
+      end
+    end
+
+    def each_resource(name, options={}, has_block=nil)
+      o = Resources::Options.new(name, options.merge(singular_resource: true))
+      f = Resources::Filter.new(name, options)
+
+      get "#{name}/new", o.build(:new) if f.yes?(:new) && !api_mode?
+      get name, o.build(:show) if f.yes?(:show)
+      post name, o.build(:create) if f.yes?(:create)
+      get "#{name}/edit", o.build(:edit) if f.yes?(:edit) && !api_mode?
+      put name, o.build(:update) if f.yes?(:update)
+      post name, o.build(:update) if f.yes?(:update) # for binary uploads
+      patch name, o.build(:update) if f.yes?(:update)
+      delete name, o.build(:delete) if f.yes?(:delete)
+    end
+
+    def member
+      @on_option = :member
+      yield
+      @on_option = nil
+    end
+
+    def collection
+      @on_option = :collection
+      yield
+      @on_option = nil
+    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 default_param(has_block, name, options)
+      default_param = has_block ? "#{name.to_s.singularize}_id".to_sym : :id
+      options[:param] || default_param
+    end
+
+    # root "posts#index"
+    def root(to, options={})
+      default = {path: '', to: to, method: :get, root: true}
+      options = default.merge(options)
+      MethodCreator.new(options, @scope).create_root_helper
+      @routes << Route.new(options, @scope)
+    end
+    private
+
+    def escape_path(path)
+      path.to_s.split('/').map { |s| s =~ /\A[:\*]/ ? s : CGI.escape(s) }.join('/')
+    end
+  end
+end

data/lib/jets/router/error.rb

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

data/lib/jets/router/finder.rb

@@ -0,0 +1,47 @@
+class Jets::Router
+  class Finder
+    extend Memoist
+
+    def initialize(path, method)
+      @path = path
+      @method = method.to_s.upcase
+    end
+
+    def run
+      reset_routes!
+      # Precedence:
+      # 1. Routes with no captures get highest precedence: posts/new
+      # 2. Then we consider the routes with captures: post/:id
+      #
+      # Within these 2 groups we consider the routes with the longest path first
+      # since posts/:id and posts/:id/edit can both match.
+      routes = router.ordered_routes
+      route = routes.find do |r|
+        matcher.match?(r)
+      end
+      route
+    end
+
+  private
+
+    attr_reader :path, :method
+
+    # "hot reload" for development
+    def reset_routes!
+      return unless Jets.env.development?
+
+      Jets::Router.clear!
+      Jets.application.load_routes(refresh: true)
+    end
+
+    def matcher
+      Jets::Router::Matcher.new(path, method)
+    end
+    memoize :matcher
+
+    def router
+      Jets.application.routes
+    end
+    memoize :router
+  end
+end

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

@@ -0,0 +1,27 @@
+module Jets::Router::Helpers
+  module CoreHelper
+    extend ActiveSupport::Concern
+
+    # 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
+
+    class_methods do
+      def define_helper_method(name)
+        define_method(name) do
+          @_jets[:controller].send(name)
+        end
+      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/helpers.rb

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

data/lib/jets/router/matcher.rb

@@ -0,0 +1,81 @@
+class Jets::Router
+  class Matcher
+    def initialize(path, method)
+      @path = path.sub(/^\//,'')
+      @method = method.to_s.upcase
+    end
+
+    def match?(route)
+      # Immediately stop checking when the request method: GET, POST, ANY, etc
+      # doesnt match.
+
+      return false if method != route.method && route.method != "ANY"
+
+      route_path = route.path
+
+      if path == route_path
+        # regular string match detection
+        return true # exact route matches are highest precedence
+      end
+
+      # Check path for route capture and wildcard matches:
+      # A colon (:) means the variable has a variable
+      if route_path.include?(':') # 2nd highest precedence
+        capture_detection(route_path, path) # early return true or false
+      # A star (*) means the variable has a glob
+      elsif route_path.include?('*') # lowest precedence
+        proxy_detection(route_path, path) # early return true or false
+      else
+        false # reach here, means no route matched
+      end
+    end
+
+  private
+
+    attr_reader :path, :method
+
+    # catchall/globbing/wildcard/proxy routes. Examples:
+    #
+    #    get "files/*path", to: "files#show"
+    #    get "others/*rest", to: "others#show"
+    #    get "*catchall", to: "public_files#show" # last catchall route for Jets
+    #
+    def proxy_detection(route_path, actual_path)
+      # drop the proxy_segment
+      leading_path = route_path.split('/')[0..-2].join('/')
+
+      # get "*catchall", to: "public_files#show"
+      if leading_path.empty? # This is the last catchall route "*catchall"
+        return true # always return true here because the entire path
+        # will always match
+      end
+
+      # Other types of wildcard route:
+      #
+      #    get "files/*path", to: "files#show"
+      #    get "others/*rest", to: "others#show"
+      unless leading_path.ends_with?('/')
+        # Ensure trailing slash to make pattern matching stricter
+        leading_path = "#{leading_path}/"
+      end
+
+      pattern = "^#{leading_path}"
+      regexp = Regexp.new(pattern)
+      !!regexp.match(actual_path) # could be true or false
+    end
+
+    def capture_detection(route_path, actual_path)
+      # changes path to a string used for a regexp
+      # posts/:id/edit => posts\/(.*)\/edit
+      regexp_string = route_path.split('/').map do |s|
+                        s.include?(':') ? Jets::Router::Route::CAPTURE_REGEX : s
+                      end.join('\/')
+      # make sure beginning and end of the string matches
+      regexp_string = "^#{regexp_string}$"
+
+      regexp = Regexp.new(regexp_string)
+
+      !!regexp.match(actual_path) # could be true or false
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+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 # MethodCreator::Edit, MethodCreator::New, etc
+    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
+      return if @as == :disabled
+      <<~EOL
+        def #{full_meth_name(:path)}#{meth_args}
+          "#{meth_result}"
+        end
+      EOL
+    end
+
+    def url_method
+      return if @as == :disabled
+      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 request 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)
+      s&.singularize
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+class Jets::Router::MethodCreator
+  class Edit < Code
+    def meth_name
+      path_items = @path.to_s.split('/')
+      if method_name_leaf && path_items.size != 3
+        nil # fallback: do not define url method
+      else  # comes from resources
+        join(action, singularize(full_as), singularize(method_name_leaf))
+      end
+    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,48 @@
+class Jets::Router::MethodCreator
+  class Index < Code
+    def meth_name
+      # TODO: figure out how to improve this and make easier to follow.
+      #
+      # 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
+        path_items = @path.to_s.split('/')
+        if path_items.size == 1
+          join(singularize(full_as), method_name_leaf) # reconstruct
+        else
+          nil # fallback: do not define url method
+        end
+      else  # comes from resources
+        join(full_as) # construct entirely from scope info
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+class Jets::Router::MethodCreator
+  class New < Code
+    def meth_name
+      path_items = @path.to_s.split('/')
+      if method_name_leaf && path_items.size != 2
+        nil # fallback: do not define url method
+      else  # comes from resources
+        join(action, singularize(full_as), singularize(method_name_leaf))
+      end
+    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,12 @@
+class Jets::Router::MethodCreator
+  class Show < Code
+    def meth_name
+      path_items = @path.to_s.split('/')
+      if method_name_leaf && path_items.size != 2
+        nil # fallback: do not define url method
+      else  # comes from resources
+        join(singularize(full_as), singularize(method_name_leaf))
+      end
+    end
+  end
+end