jets 4.0.10 → 5.0.0

data/lib/jets/lambda/dsl.rb

@@ -2,6 +2,8 @@
 #
 #   default_associated_resource_definition
 #
+require "dsl_evaluator" # for DslEvaluator.print_code only
+
 module Jets::Lambda::Dsl
   extend ActiveSupport::Concern
 
@@ -12,6 +14,7 @@ module Jets::Lambda::Dsl
   included do
     class << self
       extend Memoist
+      include Warnings
 
       def class_properties(options=nil)
         if options
@@ -31,23 +34,23 @@ module Jets::Lambda::Dsl
 
       def class_environment(hash)
         environment = standardize_env(hash)
-        class_properties(environment: environment)
+        class_properties(Environment: environment)
       end
       alias_method :class_env, :class_environment
 
       def environment(hash)
         environment = standardize_env(hash)
-        properties(environment: environment)
+        properties(Environment: environment)
       end
       alias_method :env, :environment
 
       # Allows user to pass in hash with or without the :variables key.
       def standardize_env(hash)
-        return hash if hash.key?(:variables)
+        return hash if hash.key?(:Variables)
 
         environment = {}
-        environment[:variables] ||= {}
-        environment[:variables].merge!(hash)
+        environment[:Variables] ||= {}
+        environment[:Variables].merge!(hash)
         environment
       end
 
@@ -99,7 +102,9 @@ module Jets::Lambda::Dsl
         if definitions.empty?
           @iam_policy
         else
-          @iam_policy = definitions.flatten
+          iam_policy_unused_warning(managed=false)
+          @iam_policy ||= []
+          @iam_policy += definitions.flatten
         end
       end
 
@@ -108,7 +113,9 @@ module Jets::Lambda::Dsl
         if definitions.empty?
           @class_iam_policy
         else
-          @class_iam_policy = definitions.flatten
+          class_iam_policy_unused_warning(managed=false)
+          @class_iam_policy ||= []
+          @class_iam_policy += definitions.flatten
         end
       end
 
@@ -117,7 +124,9 @@ module Jets::Lambda::Dsl
         if definitions.empty?
           @managed_iam_policy
         else
-          @managed_iam_policy = definitions.flatten
+          iam_policy_unused_warning(managed=true)
+          @managed_iam_policy ||= []
+          @managed_iam_policy += definitions.flatten
         end
       end
 
@@ -126,7 +135,9 @@ module Jets::Lambda::Dsl
         if definitions.empty?
           @class_managed_iam_policy
         else
-          @class_managed_iam_policy = definitions.flatten
+          class_iam_policy_unused_warning(managed=true)
+          @class_managed_iam_policy ||= []
+          @class_managed_iam_policy += definitions.flatten
         end
       end
 
@@ -142,7 +153,7 @@ module Jets::Lambda::Dsl
           @associated_resources || []
         else
           @associated_resources ||= []
-          associated_resource = Jets::Resource::Associated.new(definitions)
+          associated_resource = Jets::Cfn::Resource::Associated.new(definitions)
           associated_resource.multiple_resources = @multiple_resources
           @associated_resources << associated_resource
           @associated_resources.flatten!
@@ -208,7 +219,7 @@ module Jets::Lambda::Dsl
 
           logical_id = logical_id.to_s.sub(/\d+$/,'')
           new_definition = { "#{logical_id}#{n}" => attributes }
-          numbered_resources << Jets::Resource::Associated.new(new_definition)
+          numbered_resources << Jets::Cfn::Resource::Associated.new(new_definition)
           n += 1
         end
         @associated_resources = numbered_resources
@@ -248,13 +259,13 @@ module Jets::Lambda::Dsl
         return if %w[initialize method_missing].include?(meth.to_s)
         return unless public_method_defined?(meth)
 
-        register_task(meth)
+        register_definition(meth)
       end
 
-      def register_task(meth, lang=:ruby)
+      def register_definition(meth, lang=:ruby)
         # Note: for anonymous classes like for app/functions self.name is ""
         # We adjust the class name when we build the functions later in
-        # FunctionContstructor#adjust_tasks.
+        # FunctionContstructor#adjust_definitions.
 
         # At this point we can use the current associated_properties and defined the
         # associated resource with the Lambda function.
@@ -268,7 +279,7 @@ module Jets::Lambda::Dsl
           add_logical_id_counter
         end
 
-        all_tasks[meth] = Jets::Lambda::Task.new(self.name, meth,
+        all_definitions[meth] = Jets::Lambda::Definition.new(self.name, meth,
           properties: @properties, # lambda function properties
           iam_policy: @iam_policy,
           managed_iam_policy: @managed_iam_policy,
@@ -279,7 +290,7 @@ module Jets::Lambda::Dsl
         # Done storing options, clear out for the next added method.
         clear_properties
         # Important to clear @properties at the end of registering outside of
-        # register_task because register_task is overridden in Jets::Job::Dsl
+        # register_definition because register_definition is overridden in Jets::Job::Dsl
         #
         #   Jets::Job::Base < Jets::Lambda::Functions
         #
@@ -302,28 +313,28 @@ module Jets::Lambda::Dsl
         @associated_properties = nil
       end
 
-      # Returns the all tasks for this class with their method names as keys.
+      # Returns the all definitions for this class with their method names as keys.
       #
       # ==== Returns
-      # OrderedHash:: An ordered hash with tasks names as keys and Task
+      # OrderedHash:: An ordered hash with definitions names as keys and definition
       #               objects as values.
       #
-      def all_tasks
-        @all_tasks ||= ActiveSupport::OrderedHash.new
+      def all_definitions
+        @all_definitions ||= ActiveSupport::OrderedHash.new
       end
-      # Do not call all tasks outside this class, instead use: tasks or lambda functions
-      private :all_tasks
+      # Do not call all definitions outside this class, instead use: definitions or lambda functions
+      private :all_definitions
 
-      # Goes up the class inheritance chain to build the tasks.
+      # Goes up the class inheritance chain to build the definitions.
       #
       # Example heirarchy:
       #
       #   Jets::Lambda::Functions > Jets::Controller::Base > ApplicationController ...
       #     > PostsController > ChildPostsController
       #
-      # Do not include tasks from the direct subclasses of Jets::Lambda::Functions
+      # Do not include definitions from the direct subclasses of Jets::Lambda::Functions
       # because those classes are abstract.  Dont want those methods to be included.
-      def find_all_tasks(options={})
+      def find_all_definitions(options={})
         public = options[:public].nil? ? true : options[:public]
         klass = self
         direct_subclasses = Jets::Lambda::Functions.subclasses
@@ -331,53 +342,53 @@ module Jets::Lambda::Dsl
 
         # Go up class inheritance and builds lookup structure in memory
         until direct_subclasses.include?(klass)
-          lookup << klass.send(:all_tasks) # one place we want to call private all_tasks method
+          lookup << klass.send(:all_definitions) # one place we want to call private all_definitions method
           klass = klass.superclass
         end
-        merged_tasks = ActiveSupport::OrderedHash.new
-        # Go back down the class inheritance chain in reverse order and merge the tasks
-        lookup.reverse.each do |tasks_hash|
-          # tasks_hash is a result of all_tasks. Example: PostsController.all_tasks
-          merged_tasks.merge!(tasks_hash)
+        merged_definitions = ActiveSupport::OrderedHash.new
+        # Go back down the class inheritance chain in reverse order and merge the definitions
+        lookup.reverse.each do |definitions_hash|
+          # definitions_hash is a result of all_definitions. Example: PostsController.all_definitions
+          merged_definitions.merge!(definitions_hash)
         end
 
         # The cfn builders required the right final child class to build the lambda functions correctly.
-        merged_tasks.each do |meth, task|
+        merged_definitions.each do |meth, definition|
           # Override the class name for the cfn builders
-          task = task.clone # do not stomp over current tasks since things are usually looked by reference
-          task.instance_variable_set(:@class_name, self.name)
-          merged_tasks[meth] = task
+          definition = definition.clone # do not stomp over current definitions since things are usually looked by reference
+          definition.instance_variable_set(:@class_name, self.name)
+          merged_definitions[meth] = definition
         end
 
         # Methods can be made private with the :private keyword after the method has been defined.
         # To account for this, loop back thorugh all the methods and check if the method is indeed public.
-        tasks = ActiveSupport::OrderedHash.new
-        merged_tasks.each do |meth, task|
+        definitions = ActiveSupport::OrderedHash.new
+        merged_definitions.each do |meth, definition|
           if public
-            tasks[meth] = task if task.public_meth?
+            definitions[meth] = definition if definition.public_meth?
           else
-            tasks[meth] = task unless task.public_meth?
+            definitions[meth] = definition unless definition.public_meth?
           end
         end
-        tasks
+        definitions
       end
-      memoize :find_all_tasks
+      memoize :find_all_definitions
 
-      def all_public_tasks
-        find_all_tasks(public: true)
+      def all_public_definitions
+        find_all_definitions(public: true)
       end
 
-      def all_private_tasks
-        find_all_tasks(public: false)
+      def all_private_definitions
+        find_all_definitions(public: false)
       end
 
-      # Returns the tasks for this class in Array form.
+      # Returns the definitions for this class in Array form.
       #
       # ==== Returns
-      # Array of task objects
+      # Array of definition objects
       #
-      def tasks
-        all_public_tasks.values
+      def definitions
+        all_public_definitions.values
       end
 
       # The public methods defined in the project app class ulimately become
@@ -386,18 +397,18 @@ module Jets::Lambda::Dsl
       # Example return value:
       #   [:index, :new, :create, :show]
       def lambda_functions
-        all_public_tasks.keys
+        all_public_definitions.keys
       end
 
-      # Used in Jets::Cfn::Builders::Interface#build
+      # Used in Jets::Cfn::Builder::Interface#build
       # Overridden in rule/dsl.rb
       def build?
-        !tasks.empty?
+        !definitions.empty?
       end
 
       # Polymorphic support
       def defpoly(lang, meth)
-        register_task(meth, lang)
+        register_definition(meth, lang)
       end
 
       def python(meth)

data/lib/jets/lambda/function.rb

@@ -13,11 +13,11 @@ module Jets::Lambda
     end
 
     def self.handler
-      handler_task.meth
+      handler_definition.meth
     end
 
-    def self.handler_task
-      tasks.first
+    def self.handler_definition
+      definitions.first
     end
 
     # Used by main_processor.rb.  Same interface as controllers and jobs.

data/lib/jets/lambda/function_constructor.rb

@@ -36,18 +36,18 @@ module Jets::Lambda
       code = IO.read(@code_path)
       function_klass = Class.new(Jets::Lambda::Function)
       function_klass.module_eval(code, @code_path)
-      adjust_tasks(function_klass)
+      adjust_definitions(function_klass)
       function_klass # assign this to a Constant for a pretty class name
     end
 
-    # For anonymous classes method_added during task registration contains ""
+    # For anonymous classes method_added during definition registration contains ""
     # for the class name.  We adjust it here.
-    def adjust_tasks(klass)
+    def adjust_definitions(klass)
       class_name = @code_path.to_s.sub(/.*\/functions\//,'').sub(/\.rb$/, '')
       class_name = class_name.camelize
-      klass.tasks.each do |task|
-        task.class_name = class_name
-        task.type = "function"
+      klass.definitions.each do |definition|
+        definition.class_name = class_name
+        definition.type = "function"
       end
     end
   end

data/lib/jets/lambda/functions.rb

@@ -7,6 +7,8 @@ require 'json'
 #   Jets::Job::Base
 module Jets::Lambda
   class Functions
+    include Jets::ExceptionReporting
+
     attr_reader :event, :context, :meth
     def initialize(event, context, meth)
       @event = HashWithIndifferentAccess.new(event) # Hash, JSON.parse(event) ran BaseProcessor
@@ -16,11 +18,44 @@ module Jets::Lambda
       # to use later.
     end
 
+    def logger
+      Jets.logger
+    end
+
     include Dsl # At the end so methods like event, context and method
       # do not trigger method_added
 
+    # Pretty hacky since action_view/rendering.rb _normalize_options calls super
+    def _normalize_options(options) # :doc:
+      options
+    end
+
     class << self
-      # Tracking subclasses because it helps with Lambda::Dsl#find_all_tasks
+      attr_reader :abstract
+      alias_method :abstract?, :abstract
+      @abstract = true
+
+      class << self
+        def inherited(klass) # :nodoc:
+          # Define the abstract ivar on subclasses so that we don't get
+          # uninitialized ivar warnings
+          unless klass.instance_variable_defined?(:@abstract)
+            klass.instance_variable_set(:@abstract, false)
+          end
+          super
+        end
+      end
+
+      # Define a controller as abstract. See internal_methods for more details.
+      def abstract!
+        @abstract = true
+      end
+
+      def _prefixes
+        []
+      end
+
+      # Tracking subclasses because it helps with Lambda::Dsl#find_all_definitions
       def subclasses
         @subclasses ||= []
       end

data/lib/jets/mega/request/source.rb

@@ -2,8 +2,7 @@ class Jets::Mega::Request
   class Source
     def initialize(event)
       @event = event
-      env = Jets::Controller::Rack::Env.new(@event, {}).convert # convert to Rack env
-      @source_request = Rack::Request.new(env)
+      @source_request = Rack::Request.new(event: event)
     end
 
     def body

data/lib/jets/mega/request.rb

@@ -14,14 +14,14 @@ module Jets::Mega
 
     def proxy
       http_method = @event['httpMethod'] # GET, POST, PUT, DELETE, etc
-      params = @controller.params(raw: true, path_parameters: false)
+      params = @controller.params(include_path_params: false)
 
       uri = get_uri
 
       http = Net::HTTP.new(uri.host, uri.port)
       http.open_timeout = http.read_timeout = 60
 
-      # Rails sets _method=patch or _method=put as workaround
+      # Jets sets _method=patch or _method=put as workaround
       # Falls back to GET when testing in lambda console
       http_class = params['_method'] || http_method || 'GET'
       http_class.capitalize!
@@ -115,7 +115,7 @@ module Jets::Mega
     end
     memoize :source
 
-    # Rails sets _method=patch or _method=put as workaround
+    # Jets sets _method=patch or _method=put as workaround
     # Falls back to GET when testing in lambda console
     # @event['httpMethod'] is GET, POST, PUT, DELETE, etc
     def http_class
@@ -125,7 +125,7 @@ module Jets::Mega
     end
 
     def params
-      @controller.params(raw: true, path_parameters: false, body_parameters: true)
+      @controller.params(include_path_params: false, include_body_params: true)
     end
     memoize :params
 

data/lib/jets/names.rb

@@ -6,54 +6,70 @@ class Jets::Names
   class << self
     extend Memoist
 
+    def templates_folder
+      "#{Jets.build_root}/templates"
+    end
+
+    def one_controller_template_path
+      "#{templates_folder}/jets-controller.yml"
+    end
+
     def app_template_path(app_class)
       underscored = underscore(app_class)
-      "#{template_path_prefix}-app-#{underscored}.yml"
+      "#{templates_folder}/app-#{underscored}.yml"
     end
 
     def shared_template_path(shared_class)
       underscored = underscore(shared_class)
-      "#{template_path_prefix}-shared-#{underscored}.yml"
-    end
-
-    def template_path_prefix
-      "#{Jets.build_root}/templates/#{Jets.config.project_namespace}"
+      "#{templates_folder}/shared-#{underscored}.yml"
     end
 
     # consider moving these methods into cfn/builder/helpers.rb or that area.
     def parent_template_path
-      "#{template_path_prefix}.yml"
+      "#{templates_folder}/parent.yml"
     end
 
     # consider moving these methods into cfn/builder/helpers.rb or that area.
     def api_gateway_template_path
-      "#{template_path_prefix}-api-gateway.yml"
+      "#{templates_folder}/api-gateway.yml"
     end
 
-    def api_resources_template_path(page)
-      "#{template_path_prefix}-api-resources-#{page}.yml"
+    def api_resources_template_path(page_number)
+      "#{templates_folder}/api-resources-#{page_number}.yml"
+    end
+
+    def api_cors_template_path(page_number)
+      "#{templates_folder}/api-cors-#{page_number}.yml"
+    end
+
+    def api_methods_template_path(page_number)
+      "#{templates_folder}/api-methods-#{page_number}.yml"
     end
 
     def api_deployment_template_path
-      "#{template_path_prefix}-api-deployment.yml"
+      "#{templates_folder}/api-deployment.yml"
+    end
+
+    def api_mapping_template_path
+      "#{templates_folder}/api-mapping.yml"
     end
 
     def shared_resources_template_path
-      "#{template_path_prefix}-shared-resources.yml"
+      "#{templates_folder}/shared-resources.yml"
     end
 
     def parent_stack_name
-      File.basename(parent_template_path, ".yml")
+      Jets.project_namespace
     end
 
     def gateway_api_name
-      "#{Jets.config.project_namespace}"
+      Jets.project_namespace
     end
 
     def authorizer_template_path(path)
       underscored = underscore(path)
       underscored.sub!(/^app-/, '')
-      "#{template_path_prefix}-#{underscored}.yml"
+      "#{templates_folder}/#{underscored}.yml"
     end
 
     def underscore(s)

data/lib/jets/overrides/dummy/rails.rb

@@ -0,0 +1,11 @@
+# This is a dummy Rails class that delegates to Jets.
+# It's only used for jets generate and jets db:migrate.
+# It's easier to mock out the Rails module then to get them working.
+
+module Rails
+  cattr_accessor :application
+  self.application = Jets.application
+  class << self
+    delegate :env, :root, to: Jets
+  end
+end

data/lib/jets/overrides/lambda/marshaller.rb

@@ -22,6 +22,16 @@ module AwsLambda
         else
           # Orignal method calls .to_json but this collides with ActiveSupport's to_json
           # method_response.to_json # application/json is assumed
+          # https://stackoverflow.com/questions/18067203/ruby-to-json-issue-with-error-illegal-malformed-utf-8
+          if method_response.is_a?(Hash)
+            method_response.deep_transform_values! do |v|
+              if v.respond_to?(:force_encoding) && !v.frozen?
+                v.force_encoding("ISO-8859-1").encode("UTF-8")
+              else
+                v # IE: Integer
+              end
+            end
+          end
           JSON.dump(method_response)
         end
       end

data/lib/jets/overrides/puma.rb

@@ -0,0 +1,10 @@
+require "puma/error_logger"
+class Puma::ErrorLogger
+  alias_method :original_title, :title
+  def title(options={})
+    string = original_title(options)
+    error = options[:error]
+    string << "\n#{error.backtrace.join("\n")}" if error
+    string
+  end
+end