jets 4.0.9 → 5.0.0.beta1

data/lib/jets/resource/child_stack/api_resource.rb

@@ -1,54 +0,0 @@
-# Implements:
-#
-#   definition
-#   template_filename
-#
-module Jets::Resource::ChildStack
-  class ApiResource < Base
-    def initialize(*)
-      super
-      @page = @options[:page]
-    end
-
-    def definition
-      {
-        "api_resources_#{@page}" =>  {
-          type: "AWS::CloudFormation::Stack",
-          # depends_on: "ApiGateway", # CloudFormation seems to be smart enough
-          properties: {
-            template_url: template_url,
-            parameters: parameters,
-          }
-        }
-      }
-    end
-
-    def parameters
-      params = {}
-      # Since dont have all the info required.
-      # Read the template back to find the parameters required.
-      # Actually might be easier to rationalize this approach.
-      template_path = Jets::Names.api_resources_template_path(@page)
-      template = Jets::Cfn::BuiltTemplate.get(template_path)
-      template['Parameters'].keys.each do |p|
-        case p
-        when "RestApi"
-          params[p] = "!GetAtt ApiGateway.Outputs.RestApi"
-        when "RootResourceId"
-          params[p] = "!GetAtt ApiGateway.Outputs.RootResourceId"
-        else
-          params[p] = "!GetAtt #{api_resource_page(p)}.Outputs.#{p}"
-        end
-      end
-      params
-    end
-
-    def api_resource_page(parameter)
-      Page.logical_id(parameter)
-    end
-
-    def template_filename
-      "#{Jets.config.project_namespace}-api-resources-#{@page}.yml"
-    end
-  end
-end

data/lib/jets/resource/child_stack/base.rb

@@ -1,24 +0,0 @@
-# Inheriting classes should implement:
-#
-#   definition
-#   template_filename
-#
-module Jets::Resource::ChildStack
-  class Base < Jets::Resource::Base
-    def initialize(s3_bucket, options={})
-      @s3_bucket = s3_bucket
-      @options = options
-    end
-
-    def outputs
-      {
-        logical_id => "!Ref #{logical_id}",
-      }
-    end
-
-    def template_url
-      basename = File.basename(template_filename)
-      "https://s3.amazonaws.com/#{@s3_bucket}/jets/cfn-templates/#{basename}"
-    end
-  end
-end

data/lib/jets/resource/lambda/function.rb

@@ -1,221 +0,0 @@
-module Jets::Resource::Lambda
-  class Function < Jets::Resource::Base
-    include Environment
-
-    def initialize(task)
-      @task = task
-      @app_class = task.class_name.to_s
-    end
-
-    def definition
-      {
-        function_logical_id => {
-          type: "AWS::Lambda::Function",
-          properties: combined_properties
-        }
-      }
-    end
-
-    def function_logical_id
-      "{namespace}_lambda_function".underscore
-    end
-
-    def replacements
-      @task.replacements # has namespace replacement
-    end
-
-    def combined_properties
-      props = env_properties
-        .deep_merge(global_properties)
-        .deep_merge(class_properties)
-        .deep_merge(function_properties)
-      finalize_properties!(props)
-    end
-
-    # Global properties example:
-    # jets defaults are in jets/default/application.rb.
-    # Your application's default config/application.rb then get used. Example:
-    #
-    #   Jets.application.configure do
-    #     config.function = ActiveSupport::OrderedOptions.new
-    #     config.function.timeout = 30
-    #     config.function.runtime = "nodejs8.10"
-    #     config.function.memory_size = 1536
-    #   end
-    def global_properties
-      baseline = {
-        code: {
-          s3_bucket: "!Ref S3Bucket",
-          s3_key: code_s3_key
-        },
-        role: "!Ref IamRole",
-        environment: { variables: environment },
-      }
-
-      application_config = Jets.application.config.function.to_h
-      baseline.merge(application_config)
-    end
-
-    # Class properties example:
-    #
-    #   class PostsController < ApplicationController
-    #     class_timeout 22
-    #     ...
-    #   end
-    #
-    # Also handles iam policy override at the class level. Example:
-    #
-    #   class_iam_policy("logs:*")
-    #
-    def class_properties
-      # klass is PostsController, HardJob, GameRule, Hello or HelloFunction
-      klass = Jets::Klass.from_task(@task)
-
-      class_properties = lookup_class_properties(klass)
-      if klass.build_class_iam?
-        iam_policy = Jets::Resource::Iam::ClassRole.new(klass)
-        class_properties[:role] = "!GetAtt #{iam_policy.logical_id}.Arn"
-      end
-
-      class_properties
-    end
-
-    # Accounts for inherited class_properties
-    def lookup_class_properties(klass)
-      all_classes = []
-      while klass != Object
-        all_classes << klass
-        klass = klass.superclass
-      end
-      class_properties = {}
-      # Go back down class heirachry top to down
-      all_classes.reverse.each do |k|
-        class_properties.merge!(k.class_properties)
-      end
-      class_properties
-    end
-
-    # Function properties example:
-    #
-    # class PostsController < ApplicationController
-    #   timeout 18
-    #   def index
-    #     ...
-    #   end
-    #
-    # Also handles iam policy override at the function level. Example:
-    #
-    #   iam_policy("ec2:*")
-    #   def new
-    #     render json: params.merge(action: "new")
-    #   end
-    #
-    def function_properties
-      properties = @task.properties
-      if @task.build_function_iam?
-        iam_policy = Jets::Resource::Iam::FunctionRole.new(@task)
-        properties[:role] = "!GetAtt #{iam_policy.logical_id}.Arn"
-      end
-      properties
-    end
-
-    # Properties managed by Jets with merged with finality.
-    def finalize_properties!(props)
-      handler = full_handler(props)
-      runtime = get_runtime(props)
-      description = get_descripton(props)
-      managed = {
-        handler: handler,
-        runtime: runtime,
-        description: description,
-      }
-      managed[:function_name] = function_name if function_name
-      layers = get_layers(runtime)
-      managed[:layers] = layers if layers
-      props.merge!(managed)
-    end
-
-    def get_layers(runtime)
-      return nil unless runtime =~ /^ruby/ || runtime =~ /^provided/
-      return Jets.config.lambda.layers if Jets.config.gems.disable
-
-      ["!Ref GemLayer"] + Jets.config.lambda.layers
-    end
-
-    def get_runtime(props)
-      props[:runtime] || default_runtime
-    end
-
-    def default_runtime
-      map = {
-        node: "nodejs8.10",
-        python: "python3.6",
-        ruby: Jets.ruby_runtime,
-      }
-      map[@task.lang]
-    end
-
-    def default_handler
-      map = {
-        node: @task.full_handler(:handler), # IE: handlers/controllers/posts/show.handler
-        python: @task.full_handler(:lambda_handler), # IE: handlers/controllers/posts/show.lambda_handler
-        ruby: handler, # IE: handlers/controllers/posts_controllers.index
-      }
-      map[@task.lang]
-    end
-
-    def handler
-      handler_value(@task.meth)  # IE: handlers/controllers/posts_controllers.index
-    end
-
-    # Used for node-shim also
-    def handler_value(meth)
-      "handlers/#{@task.type.pluralize}/#{@app_class.underscore}.#{meth}"
-    end
-
-    # Ensure that the handler path is normalized.
-    def full_handler(props)
-      if props[:handler]
-        handler_value(props[:handler])
-      else
-        default_handler
-      end
-    end
-
-    def code_s3_key
-      checksum = Jets::Builders::Md5.checksums["stage/code"]
-      "jets/code/code-#{checksum}.zip" # s3_key
-    end
-
-    # Examples:
-    #   "#{Jets.config.project_namespace}-sleep_job-perform"
-    #   "demo-dev-sleep_job-perform"
-    def function_name
-      # Example values:
-      #   @app_class: admin/pages_controller
-      #   @task.meth: index
-      #   method: admin/pages_controller
-      #   method: admin-pages_controller-index
-      method = @app_class.underscore
-      method = method.gsub('/','-').gsub(/[^0-9a-z\-_]/i, '') + "-#{@task.meth}"
-      function_name = "#{Jets.config.project_namespace}-#{method}"
-      # Returns nil if function name is too long.
-      # CloudFormation will managed the the function name in this case.
-      # A pretty function name won't be generated but the deploy will be successful.
-      function_name.size > Jets::MAX_FUNCTION_NAME_SIZE ? nil : function_name
-    end
-
-    def get_descripton(props)
-      props[:description] || default_description
-    end
-
-    def default_description
-      # Example values:
-      #   @app_class: Admin/PagesController
-      #   @task.meth: index
-      # Returns:
-      #   Admin/PagesController#index
-      "#{@app_class}##{@task.meth}"
-    end
-  end
-end

data/lib/jets/resource/logs/subscription_filter.rb

@@ -1,31 +0,0 @@
-# CloudFormation Log Subscription docs: https://amzn.to/2SNiSpr
-module Jets::Resource::Logs
-  class SubscriptionFilter < Jets::Resource::Base
-    def initialize(props={})
-      @props = props # associated_properties from dsl.rb
-    end
-
-    def definition
-      {
-        log_logical_id => {
-          type: "AWS::Logs::SubscriptionFilter",
-          properties: merged_properties,
-        }
-      }
-    end
-
-    # Do not name this method properties, that is a computed method of `Jets::Resource::Base`
-    def merged_properties
-      {
-        destination_arn: "!GetAtt {namespace}LambdaFunction.Arn",
-        filter_pattern: "", # matches everything https://amzn.to/2N3b39I
-        # log_group_name: string # will be set by log_event
-        # role_arn: string # only required for kinensis, we dont use this for Lambda
-      }.deep_merge(@props)
-    end
-
-    def log_logical_id
-      "{namespace}_subscription_filter"
-    end
-  end
-end

data/lib/jets/resource/permission.rb

@@ -1,45 +0,0 @@
-class Jets::Resource
-  class Permission < Jets::Resource::Base
-    def initialize(replacements, associated_resource)
-      @replacements = replacements
-      @associated_resource = associated_resource
-    end
-
-    def definition
-      logical_id = permission_logical_id
-
-      definition = {
-        logical_id => {
-          type: "AWS::Lambda::Permission",
-          properties: {
-            function_name: "!GetAtt {namespace}LambdaFunction.Arn",
-            action: "lambda:InvokeFunction",
-            principal: principal
-          }
-        }
-      }
-
-      # From AWS docs: https://amzn.to/2N0QXQL
-      # source_arn is "not supported by all event sources"
-      definition[logical_id][:properties][:source_arn] = source_arn if source_arn
-
-      definition
-    end
-
-    def permission_logical_id
-      logical_id = "{namespace}_permission"
-      md = @associated_resource.logical_id.match(/(\d+)$/)
-      counter = md[1] if md
-      [logical_id, counter].compact.join('').underscore
-    end
-
-    # Auto-detect principal from the associated resources.
-    def principal
-      Replacer.principal_map(@associated_resource.type)
-    end
-
-    def source_arn
-      Replacer.source_arn_map(@associated_resource.type)
-    end
-  end
-end

data/lib/jets/resource.rb

@@ -1,71 +0,0 @@
-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/error.rb

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

data/lib/jets/router/finder.rb

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

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

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

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

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

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

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

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