jets 5.0.14 → 6.0.0.beta1

data/lib/jets/spec_helpers/controllers/request.rb

@@ -1,107 +0,0 @@
-module Jets::SpecHelpers::Controllers
-  class Request
-    extend Memoist
-
-    attr_accessor :method, :path, :headers, :params
-    def initialize(method, path, headers={}, params={})
-      @method, @path, @headers, @params = method, path, headers, params
-    end
-
-    def event
-      json = {}
-      id_params = route.path.scan(%r{:([^/]+)}).flatten
-      expanded_path = route.escape_path(path)
-      path_parameters = {}
-
-      id_params.each do |id_param|
-        raise "missing param: :#{id_param}" unless path_params.include? id_param.to_sym
-
-        path_param_value = path_params[id_param.to_sym]
-        raise "Path param :#{id_param} value cannot be blank" if path_param_value.blank?
-
-        escaped_path_param_value = CGI.escape(path_param_value.to_s)
-        expanded_path = expanded_path.gsub(":#{id_param}", escaped_path_param_value)
-        path_parameters.deep_merge!(id_param => escaped_path_param_value)
-      end
-
-      json['resource'] = strip_query_string(route.path.gsub(/:(\w+)/, '{\1}'))
-      json['path'] = strip_query_string(expanded_path)
-      json['httpMethod'] = method.to_s.upcase
-      json['pathParameters'] = path_parameters
-      json['headers'] = (headers || {}).stringify_keys
-
-      if method != :get
-        json['headers']['Content-Type'] ||= 'application/x-www-form-urlencoded'
-
-        if params.body_params.is_a? String
-          body = params.body_params
-          json['headers']['Content-Length'] ||= body.length.to_s
-        else
-          body = Rack::Multipart.build_multipart(params.body_params)
-
-          if body
-            json['headers']['Content-Length'] ||= body.length.to_s
-            json['headers']['Content-Type'] = "multipart/form-data; boundary=#{Rack::Multipart::MULTIPART_BOUNDARY}"
-          else
-            body = Rack::Utils.build_nested_query(params.body_params)
-          end
-        end
-
-        json['body'] = Base64.encode64(body)
-        json['isBase64Encoded'] = true
-      end
-
-      json['queryStringParameters'] = params.query_params if params.query_params.present?
-
-      json
-    end
-
-    def path_params
-      params.path_params.reverse_merge(extract_parameters)
-    end
-    memoize :path_params
-
-    def extract_parameters
-      route.extract_parameters(normalized_path).symbolize_keys
-    end
-
-    def normalized_path
-      path = self.path
-      path = path[0..-2] if path.end_with? '/'
-      path = path[1..-1] if path.start_with? '/'
-      path = strip_query_string(path)
-      path
-    end
-
-    def strip_query_string(path)
-      path.sub(/\?.*/, '')
-    end
-
-    def route
-      Jets::Router::Matcher.new(Jets.application.routes).find_by_env(
-        "REQUEST_METHOD" => method.to_s.upcase,
-        "PATH_INFO" => path,
-      )
-    end
-    memoize :route
-
-    def request
-      Jets::Controller::Request.new(event: event)
-    end
-    memoize :request
-
-    def dispatch!
-      klass = Object.const_get(route.controller_name)
-      context = Jets::Controller::Middleware::Mimic::LambdaContext.new
-      rack_env = Jets::Controller::RackAdapter::Env.new(event, context).convert
-      controller = klass.new(event, context, route.action_name, rack_env)
-      response = controller.process! # response is API Gateway Hash
-
-      unless response['statusCode'] && response['body']
-        raise "Expected response to an API Gateway Hash Structure. Are you rendering correctly?"
-      end
-
-      Response.new(response) # converts APIGW hash to prettier object
-    end
-  end
-end

data/lib/jets/spec_helpers/controllers/response.rb

@@ -1,10 +0,0 @@
-module Jets::SpecHelpers::Controllers
-  class Response
-    attr_reader :status, :headers, :body
-    def initialize(response)
-      @status = response['statusCode'].to_i
-      @headers = response['headers']
-      @body = response['body']
-    end
-  end
-end

data/lib/jets/spec_helpers/controllers.rb

@@ -1,54 +0,0 @@
-module Jets::SpecHelpers
-  module Controllers
-    include Jets::Router::Helpers # must be at the top because response is overridden later
-
-    rest_methods = %w[get post put patch delete]
-    rest_methods.each do |meth|
-      define_method(meth) do |path, **params|
-        http_call(method: meth, path: path, **params)
-      end
-      # Example:
-      # def get(path, **params)
-      #   http_call(method: :get, path: path, **params)
-      # end
-    end
-
-    attr_reader :request, :response
-    def http_call(method:, path:, **options)
-      headers = options.delete(:headers) || {}
-      params_hash = options.delete(:params) || options
-      md = path.match(/\?(.*)/)
-      path = path.gsub("?#{md[1]}", '') if md
-      query = md ? Rack::Utils.parse_nested_query(md[1]).merge(params_hash) : params_hash
-
-      params = Params.new
-      if method.to_sym == :get
-        params.body_params = {}
-        params.query_params = query || {}
-      else
-        params.body_params = options.delete(:body) || query
-      end
-
-      # Note: Do not cache the request object.  Otherwise, it cannot be reused between specs.
-      # See: https://community.rubyonjets.com/t/is-jets-spechelpers-controllers-request-being-cached/244/2
-      @request = Request.new(method, path, headers, params)
-
-      @request.method = method.to_sym
-      @request.path = path
-      @request.headers.deep_merge!(headers)
-
-      suppress_logging do
-        @response = @request.dispatch!
-      end
-    end
-
-    def suppress_logging
-      old_logger = Jets.logger
-      unless ENV['JETS_TEST_LOGGING']
-        Jets.logger = ActionView::Base.logger = Logger.new("/dev/null")
-      end
-      yield
-      Jets.logger = old_logger
-    end
-  end
-end

data/lib/jets/spec_helpers/fixtures.rb

@@ -1,11 +0,0 @@
-module Jets::SpecHelpers
-  module Fixtures
-    def fixture_path(filename)
-      "#{Jets.root}/spec/fixtures/#{filename}"
-    end
-
-    def fixture_file(filename)
-      File.new(fixture_path(filename))
-    end
-  end
-end

data/lib/jets/spec_helpers.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require 'base64'
-
-module Jets
-  module SpecHelpers
-    include Fixtures
-    include Controllers
-  end
-end
-
-require "rspec"
-RSpec.configure do |c|
-  c.include Jets::SpecHelpers
-end

data/lib/jets/stack/builder.rb

@@ -1,44 +0,0 @@
-class Jets::Stack
-  class Builder
-    extend Memoist
-    include Jets::Util::Camelize
-
-    def initialize(stack)
-      @stack = stack
-      @template = {} # will build this structure up
-    end
-
-    def template
-      build_section(:parameters)
-      build_section(:resources)
-      build_section(:outputs)
-      camelize(@template).deep_stringify_keys
-    end
-    memoize :template
-
-    def build_section(section)
-      elements = build_elements(section)
-      return unless elements
-
-      if section == :parameters
-        elements[:GemLayer] = {Type: "String"} if Jets.gem_layer?
-      end
-      @template[section] = elements
-    end
-
-    def build_elements(section)
-      # s is a "section element".  Examples:
-      #
-      #   Jets::Stack::Parameter
-      #   Jets::Stack::Resource
-      #   Jets::Stack::Output
-      #
-      section_elements = @stack.send(section)
-      return unless section_elements
-
-      section_elements.inject({}) do |template_section, s|
-        template_section.merge(s.template)
-      end
-    end
-  end
-end

data/lib/jets/stack/definition.rb

@@ -1,47 +0,0 @@
-# Class that include Definition should implement:
-#
-#   template - method should use @definition to build a CloudFormation template section
-#
-class Jets::Stack
-  module Definition
-    extend ActiveSupport::Concern
-    include Jets::Util::Camelize
-
-    # Example of usage that leads here:
-    #
-    #   Parameter.new(self, *definition).register
-    #
-    # Which  is defined in parameter/dsl.rb
-    #
-    # Example subclass: ExampleStack < Jets::Stack
-    def initialize(subclass, *definition)
-      @subclass = subclass.to_s # important to use to_s, dont want the object as keys in @definitions
-      @definition = definition.flatten
-    end
-
-    def register
-      self.class.register(@subclass, *@definition)
-    end
-
-    class_methods do
-      def register(subclass, *definition)
-        @definitions ||= {}
-        @definitions[subclass.to_s] ||= []
-        # Create instance of the CloudFormation section class and register it.  Examples:
-        #   Stack::Parameter.new(definition)
-        #   Stack::Resource.new(definition)
-        #   Stack::Output.new(definition)
-        @definitions[subclass.to_s] << new(subclass, definition)
-      end
-
-      def definitions(subclass)
-        @definitions ||= {}
-        @definitions[subclass.to_s]
-      end
-
-      def all_definitions
-        @definitions
-      end
-    end
-  end
-end

data/lib/jets/stack/depends/item.rb

@@ -1,26 +0,0 @@
-# Usage examples:
-#
-#   Jets::Stack::Depends::Item.new(:custom)
-#   Jets::Stack::Depends::Item.new(:custom, :alert)
-#   Jets::Stack::Depends::Item.new(:custom, class_prefix: true)
-#   Jets::Stack::Depends::Item.new(:custom, :alert, class_prefix: true)
-#
-# The Jets::Stack::Depends#params uses the options to determine if the class prefix should be added.
-#
-class Jets::Stack::Depends
-  class Item
-    attr_reader :stack, :options
-    def initialize(stack, options={})
-      @stack = stack # should be underscore format. IE: admin/posts_controller
-      @options = options
-    end
-
-    def logical_id
-      @stack.to_s.gsub('::','').gsub('/','_').camelize
-    end
-
-    def class_name
-      @stack.to_s.camelize
-    end
-  end
-end

data/lib/jets/stack/depends.rb

@@ -1,34 +0,0 @@
-class Jets::Stack
-  class Depends
-    def initialize(items)
-      @items = items # Jets::Stack::Depends::Item - has stack and options properties
-    end
-
-    def params
-      result = {}
-      @items.each do |item|
-        class_name = item.class_name
-        dependency_outputs(class_name).each do |output|
-          dependency_class = class_name.to_s.camelize
-          output_key = item.options[:class_prefix] ?
-            "#{dependency_class}#{output}" : # already camelized
-            output
-
-          output_value = "!GetAtt #{dependency_class}.Outputs.#{output}"
-          result[output_key] = output_value
-        end
-      end
-      result
-    end
-
-    # Returns CloudFormation template logical ids
-    def stack_list
-      @items.map(&:logical_id)
-    end
-
-  private
-    def dependency_outputs(class_name)
-      class_name.to_s.camelize.constantize.output_keys
-    end
-  end
-end

data/lib/jets/stack/function.rb

@@ -1,71 +0,0 @@
-class Jets::Stack
-  class Function
-    extend Memoist
-
-    attr_reader :template
-    def initialize(template)
-      @template = template
-    end
-
-    def meth
-      attributes = @template.values.first
-      handler = attributes[:Properties][:Handler]
-      handler.split('.').last
-    end
-
-    def lang
-      return if internal?
-
-      if source_file
-        # Detect language from file extension
-        ext = File.extname(source_file).sub(/^\./,'').to_sym
-        lang_map[ext]
-      else
-        puts "WARN: Unable to find a source file for function. Looked at: #{search_expression}".color(:yellow)
-      end
-    end
-
-    def lang_map
-      {
-        rb: :ruby,
-        py: :python,
-        js: :node,
-      }
-    end
-
-    def source_file
-      Dir.glob(search_expression).first
-    end
-    memoize :source_file
-
-    def search_expression
-      base_search_expression.sub('handlers/shared/', "#{Jets.root}/app/shared/")
-    end
-
-    def internal_search_expression
-      internal = File.expand_path("../internal", File.dirname(__FILE__))
-      base_search_expression.sub('handlers/shared/', "#{internal}/app/shared/")
-    end
-
-    def base_search_expression
-      attributes = @template.values.first
-      handler = attributes[:Properties][:Handler]
-      handler.split('.')[0..-2].join('.') + '.*' # search_expression
-      # Example: handlers/shared/functions/jets/s3_bucket_config.*
-    end
-
-    # Internal flag is mainly used to disable WARN messages
-    def internal?
-      return true if internal_search_expression.include?("jets/base_path")
-      return true if internal_search_expression.include?("jets/s3_bucket_config")
-      !!Dir.glob(internal_search_expression).first
-    end
-
-    # Relative path
-    # app/shared/functions/kevin.py => handlers/shared/functions/kevin.py
-    def handler_dest
-      return unless source_file
-      source_file.sub(%r{.*/app/}, "handlers/")
-    end
-  end
-end

data/lib/jets/stack/main/dsl/cloudwatch.rb

@@ -1,19 +0,0 @@
-module Jets::Stack::Main::Dsl
-  module Cloudwatch
-    def cloudwatch_alarm(id, hash={})
-      if hash.key?(:DependsOn)
-        attributes = hash # leave structure alone and add type only
-        attributes[:Type] = "AWS::CloudWatch::Alarm"
-      else
-        # the attributes are properties
-        properties = hash
-        attributes = {
-          Type: "AWS::CloudWatch::Alarm",
-          Properties: properties,
-        }
-      end
-      resource(id, attributes)
-      output(id)
-    end
-  end
-end

data/lib/jets/stack/main/dsl/iam.rb

@@ -1,8 +0,0 @@
-module Jets::Stack::Main::Dsl
-  module Iam
-    def iam_role(id, props={})
-      resource(id, "AWS::IAM::Role", props)
-      output(id) # IAM Arn
-    end
-  end
-end

data/lib/jets/stack/main/dsl/kinesis.rb

@@ -1,15 +0,0 @@
-module Jets::Stack::Main::Dsl
-  module Kinesis
-    def kinesis_stream(id, props={})
-      defaults = {
-        Name: id,
-        ShardCount: 1
-      }
-
-      props = defaults.merge(props)
-
-      resource(id, "AWS::Kinesis::Stream", props)
-      output(id)
-    end
-  end
-end

data/lib/jets/stack/main/dsl/lambda.rb

@@ -1,90 +0,0 @@
-module Jets::Stack::Main::Dsl
-  module Lambda
-    include Jets::Util::Camelize
-
-    # Example:
-    #
-    #   function(:hello,
-    #     handler: handler("hello.lambda_hander"),
-    #     runtime: "python3.6"
-    #   )
-    #
-    # Defaults to ruby. So:
-    #
-    #   function(:hello)
-    #
-    # is the same as:
-    #
-    #   function(:hello,
-    #     handler: handler("hello.hande"),
-    #     runtime: :ruby
-    #   )
-    #
-    def function(id, props={})
-      # Required: code, handler, role, runtime Docs: https://amzn.to/2pdot7S
-      meth = sanitize_method_name(id)
-      class_namespace = self.to_s.underscore.gsub('/','-') # IE: Jets::Domain => jets-domain
-      description = "#{self.to_s} #{meth}" # not bother adding extension
-      defaults = {
-        Code: {
-          S3Bucket: "!Ref S3Bucket",
-          S3Key: code_s3_key
-        },
-        Role: "!Ref IamRole",
-        Handler: "#{id}.lambda_handler", # default ruby convention
-        Timeout: Jets.config.function.timeout,
-        MemorySize: Jets.config.function.memory_size,
-        EphemeralStorage: Jets.config.function.ephemeral_storage,
-        Description: description,
-      }
-
-      function_name = "#{Jets.project_namespace}-#{class_namespace}-#{meth}"
-      function_name = function_name.size > Jets::Cfn::Resource::Lambda::Function::MAX_FUNCTION_NAME_SIZE ? nil : function_name
-      defaults[:FunctionName] = function_name if function_name
-
-      props = defaults.merge(props)
-      # shared/functions do not include the GemLayer and no custom runtime support
-      props[:Runtime] ||= Jets.ruby_runtime
-      props[:Handler] = handler(props[:Handler])
-
-      logical_id = id.to_s.gsub('/','_')
-      resource(logical_id, "AWS::Lambda::Function", props)
-    end
-    alias_method :ruby_function, :function
-    alias_method :lambda_function, :function
-
-    def python_function(id, props={})
-      meth = sanitize_method_name(id)
-      props[:Handler] ||= "#{meth}.lambda_handler" # default python convention
-      props[:Runtime] ||= default_runtimes[:python]
-      function(id, props)
-    end
-
-    def default_runtimes
-      Jets::Cfn::Resource::Lambda::Function.default_runtimes
-    end
-
-    def node_function(id, props={})
-      meth = sanitize_method_name(id)
-      props[:Handler] ||= "#{meth}.handler" # default python convention
-      props[:Runtime] ||= default_runtimes[:node]
-      function(id, props)
-    end
-
-    # Usage:
-    #
-    #   permission(:my_permission, principal: "events.amazonaws.com")
-    #
-    def permission(id, props={})
-      defaults = { Action: "lambda:InvokeFunction" }
-      props = defaults.merge(props)
-      resource(id, "AWS::Lambda::Permission", props)
-    end
-
-  private
-    # demo-dev-hard_job-dig_me
-    def sanitize_method_name(id)
-      id.to_s.gsub('/','-')
-    end
-  end
-end

data/lib/jets/stack/main/dsl/s3.rb

@@ -1,12 +0,0 @@
-module Jets::Stack::Main::Dsl
-  module S3
-    def s3_bucket(id, props={})
-      resource(id, "AWS::S3::Bucket", props)
-      output(id) # Bucket name
-    end
-
-    def s3_bucket_configuration(id, props={})
-      resource(id, "Custom::S3BucketConfiguration", props)
-    end
-  end
-end

data/lib/jets/stack/main/dsl/sns.rb

@@ -1,16 +0,0 @@
-module Jets::Stack::Main::Dsl
-  module Sns
-    def sns_topic(id, props={})
-      resource(id, "AWS::SNS::Topic", props)
-      output(id) # Topic Arn
-    end
-
-    def sns_topic_policy(id, props={})
-      resource(id, "AWS::SNS::TopicPolicy", props)
-    end
-
-    def sns_subscription(id, props={})
-      resource(id, "AWS::SNS::Subscription", props)
-    end
-  end
-end

data/lib/jets/stack/main/dsl/sqs.rb

@@ -1,10 +0,0 @@
-module Jets::Stack::Main::Dsl
-  module Sqs
-    def sqs_queue(id, props={})
-      # props[:queue_name] ||= id.to_s # comment out to allow CloudFormation to generate name
-      resource(id, "AWS::SQS::Queue", props)
-      output(id, Value: get_att("#{id}.Arn")) # normal !Ref returns the sqs url the ARN is useful for nested stacks depends_on
-      output("#{id}_url", ref(id)) # useful for Stack.lookup method. IE: List.lookup(:waitlist_url)
-    end
-  end
-end

data/lib/jets/stack/main/dsl.rb

@@ -1,17 +0,0 @@
-class Jets::Stack
-  class Main
-    module Dsl
-      extend ActiveSupport::Concern
-
-      class_methods do
-        include Base
-        include Cloudwatch
-        include Iam
-        include Lambda
-        include S3
-        include Sns
-        include Sqs
-      end
-    end
-  end
-end

data/lib/jets/stack/main.rb

@@ -1,4 +0,0 @@
-class Jets::Stack
-  class Main
-  end
-end

data/lib/jets/stack/output/dsl.rb

@@ -1,19 +0,0 @@
-class Jets::Stack
-  class Output
-    module Dsl
-      extend ActiveSupport::Concern
-
-      def outputs
-        Output.definitions(self.class)
-      end
-
-      class_methods do
-        def output(*definition)
-          # self is subclass is the stack that inherits from Jets::Stack
-          # IE: ExampleStack < Jets::Stack
-          Output.new(self, *definition).register
-        end
-      end
-    end
-  end
-end

data/lib/jets/stack/output.rb

@@ -1,35 +0,0 @@
-# Implements:
-#
-#   template - uses @definition to build a CloudFormation template section
-#
-class Jets::Stack
-  class Output
-    include Definition
-
-    def template
-      camelize(standarize(@definition))
-    end
-
-    # Value is the only required property: https://amzn.to/2xbhmk3
-    def standarize(definition)
-      first, second, _ = 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, properties = first, second
-        { logical_id => properties }
-      elsif definition.size == 2 && second.is_a?(String) # short form
-        logical_id = first
-        properties = second.is_a?(String) ? { Value: second } : {}
-        { logical_id => properties }
-      elsif definition.size == 1
-        logical_id = first.to_s
-        properties = {Value: "!Ref #{logical_id.camelize}"}
-        { logical_id => properties }
-      else # I dont know what form
-        raise "Invalid form provided. definition #{definition.inspect}"
-      end
-    end
-  end
-end
-