jets 4.0.9 → 5.0.0.beta1

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

data/lib/jets/paths.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Jets
+  module Paths
+    # This object is an extended hash that behaves as root of the <tt>Jets::Paths</tt> system.
+    # It allows you to collect information about how you want to structure your application
+    # paths through a Hash-like API. It requires you to give a physical path on initialization.
+    #
+    #   root = Root.new "/jets"
+    #   root.add "app/controllers", eager_load: true
+    #
+    # The above command creates a new root object and adds "app/controllers" as a path.
+    # This means we can get a Jets::Paths::Path object back like below:
+    #
+    #   path = root["app/controllers"]
+    #   path.eager_load?               # => true
+    #   path.is_a?(Jets::Paths::Path) # => true
+    #
+    # The +Path+ object is simply an enumerable and allows you to easily add extra paths:
+    #
+    #   path.is_a?(Enumerable) # => true
+    #   path.to_ary.inspect    # => ["app/controllers"]
+    #
+    #   path << "lib/controllers"
+    #   path.to_ary.inspect    # => ["app/controllers", "lib/controllers"]
+    #
+    # Notice that when you add a path using +add+, the path object created already
+    # contains the path with the same path value given to +add+. In some situations,
+    # you may not want this behavior, so you can give <tt>:with</tt> as option.
+    #
+    #   root.add "config/routes", with: "config/routes.rb"
+    #   root["config/routes"].inspect # => ["config/routes.rb"]
+    #
+    # The +add+ method accepts the following options as arguments:
+    # eager_load, autoload, autoload_once, and glob.
+    #
+    # Finally, the +Path+ object also provides a few helpers:
+    #
+    #   root = Root.new "/jets"
+    #   root.add "app/controllers"
+    #
+    #   root["app/controllers"].expanded # => ["/jets/app/controllers"]
+    #   root["app/controllers"].existent # => ["/jets/app/controllers"]
+    #
+    # Check the <tt>Jets::Paths::Path</tt> documentation for more information.
+    class Root
+      attr_accessor :path
+
+      def initialize(path)
+        @path = path
+        @root = {}
+      end
+
+      def []=(path, value)
+        glob = self[path] ? self[path].glob : nil
+        add(path, with: value, glob: glob)
+      end
+
+      def add(path, options = {})
+        with = Array(options.fetch(:with, path))
+        @root[path] = Path.new(self, path, with, options)
+      end
+
+      def [](path)
+        @root[path]
+      end
+
+      def values
+        @root.values
+      end
+
+      def keys
+        @root.keys
+      end
+
+      def values_at(*list)
+        @root.values_at(*list)
+      end
+
+      def all_paths
+        values.tap(&:uniq!)
+      end
+
+      def autoload_once
+        filter_by(&:autoload_once?)
+      end
+
+      def eager_load
+        filter_by(&:eager_load?)
+      end
+
+      def autoload_paths
+        filter_by(&:autoload?)
+      end
+
+      def load_paths
+        filter_by(&:load_path?)
+      end
+
+    private
+      def filter_by(&block)
+        all_paths.find_all(&block).flat_map { |path|
+          paths = path.existent
+          paths - path.children.flat_map { |p| yield(p) ? [] : p.existent }
+        }.uniq
+      end
+    end
+
+    class Path
+      include Enumerable
+
+      attr_accessor :glob
+
+      def initialize(root, current, paths, options = {})
+        @paths   = paths
+        @current = current
+        @root    = root
+        @glob    = options[:glob]
+        @exclude = options[:exclude]
+
+        options[:autoload_once] ? autoload_once! : skip_autoload_once!
+        options[:eager_load]    ? eager_load!    : skip_eager_load!
+        options[:autoload]      ? autoload!      : skip_autoload!
+        options[:load_path]     ? load_path!     : skip_load_path!
+      end
+
+      def absolute_current # :nodoc:
+        File.expand_path(@current, @root.path)
+      end
+
+      def children
+        keys = @root.keys.find_all { |k|
+          k.start_with?(@current) && k != @current
+        }
+        @root.values_at(*keys.sort)
+      end
+
+      def first
+        expanded.first
+      end
+
+      def last
+        expanded.last
+      end
+
+      %w(autoload_once eager_load autoload load_path).each do |m|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{m}!        # def eager_load!
+            @#{m} = true   #   @eager_load = true
+          end              # end
+                           #
+          def skip_#{m}!   # def skip_eager_load!
+            @#{m} = false  #   @eager_load = false
+          end              # end
+                           #
+          def #{m}?        # def eager_load?
+            @#{m}          #   @eager_load
+          end              # end
+        RUBY
+      end
+
+      def each(&block)
+        @paths.each(&block)
+      end
+
+      def <<(path)
+        @paths << path
+      end
+      alias :push :<<
+
+      def concat(paths)
+        @paths.concat paths
+      end
+
+      def unshift(*paths)
+        @paths.unshift(*paths)
+      end
+
+      def to_ary
+        @paths
+      end
+
+      def paths
+        raise "You need to set a path root" unless @root.path
+
+        map do |p|
+          Pathname.new(@root.path).join(p)
+        end
+      end
+
+      def extensions # :nodoc:
+        $1.split(",") if @glob =~ /\{([\S]+)\}/
+      end
+
+      # Expands all paths against the root and return all unique values.
+      def expanded
+        raise "You need to set a path root" unless @root.path
+        result = []
+
+        each do |path|
+          path = File.expand_path(path, @root.path)
+
+          if @glob && File.directory?(path)
+            result.concat files_in(path)
+          else
+            result << path
+          end
+        end
+
+        result.uniq!
+        result
+      end
+
+      # Returns all expanded paths but only if they exist in the filesystem.
+      def existent
+        expanded.select do |f|
+          does_exist = File.exist?(f)
+
+          if !does_exist && File.symlink?(f)
+            raise "File #{f.inspect} is a symlink that does not point to a valid file"
+          end
+          does_exist
+        end
+      end
+
+      def existent_directories
+        expanded.select { |d| File.directory?(d) }
+      end
+
+      alias to_a expanded
+
+      private
+        def files_in(path)
+          files = Dir.glob(@glob, base: path)
+          files -= @exclude if @exclude
+          files.map! { |file| File.join(path, file) }
+          files.sort
+        end
+    end
+  end
+end

data/lib/jets/{poly_fun → poly}/base_executor.rb

@@ -1,12 +1,12 @@
 require 'open3'
 require 'tmpdir'
 
-class Jets::PolyFun
+class Jets::Poly
   class BaseExecutor
     extend Memoist
 
-    def initialize(task)
-      @task = task
+    def initialize(definition)
+      @definition = definition
     end
 
     # Handler is in properties:
@@ -37,19 +37,19 @@ class Jets::PolyFun
     end
 
     def copy_src_to_temp
-      app_class = @task.class_name.constantize
+      app_class = @definition.class_name.constantize
       internal = app_class.respond_to?(:internal) && app_class.internal
       src = internal ?
-        "#{File.expand_path("../internal", File.dirname(__FILE__))}/#{@task.poly_src_path}" :
-        "#{Jets.root}/#{@task.poly_src_path}"
-      dest = "#{@temp_dir}/#{@task.poly_src_path}"
+        "#{File.expand_path("../internal", File.dirname(__FILE__))}/#{@definition.poly_src_path}" :
+        "#{Jets.root}/#{@definition.poly_src_path}"
+      dest = "#{@temp_dir}/#{@definition.poly_src_path}"
 
       FileUtils.mkdir_p(File.dirname(dest))
       FileUtils.cp(src, dest)
     end
 
     def lambda_executor_script
-      File.dirname("#{@temp_dir}/#{@task.poly_src_path}") + "/lambda_executor" + @task.lang_ext
+      File.dirname("#{@temp_dir}/#{@definition.poly_src_path}") + "/lambda_executor" + @definition.lang_ext
     end
 
     # When polymorphic method errors, this method reproduces an error in the lambda format
@@ -75,7 +75,7 @@ class Jets::PolyFun
     #     "errorType": "AttributeError",
     #     "stackTrace": [
     #       [
-    #         "/var/task/handlers/controllers/posts_controller/python/index.py",
+    #         "/var/definition/handlers/controllers/posts_controller/python/index.py",
     #         22,
     #         "handle",
     #         "return response({'message': e.message}, 400)"
@@ -84,7 +84,7 @@ class Jets::PolyFun
     #   }
     #
     def run_lambda_executor(event, context)
-      interpreter = @task.lang
+      interpreter = @definition.lang
       command = %Q|#{interpreter} #{lambda_executor_script} '#{JSON.dump(event)}' '#{JSON.dump(context)}'|
       stdout, stderr, status = Open3.capture3(command)
       # puts "=> #{command}".color(:green)
@@ -103,7 +103,7 @@ class Jets::PolyFun
         stack_trace = error_lines.reverse # python shows stack trace in opposite order from ruby
         JSON.dump(
           "errorMessage" => error_message,
-          "errorType" => error_type, # hardcode
+          "errorType" => error_type,
           "stackTrace" => stack_trace
         )
       end
@@ -116,8 +116,8 @@ class Jets::PolyFun
     def handler
       # Must use the generated CloudFormation template to get the handler because
       # the handler is derived from mutiple sources.
-      resource = Jets::Resource::Lambda::Function.new(@task)
-      full_handler = resource.properties["Handler"] # full handler here
+      resource = Jets::Cfn::Resource::Lambda::Function.new(@definition)
+      full_handler = resource.properties[:Handler] # full handler here
       File.extname(full_handler).sub(/^./,'') # the extension of the full handler is the handler
     end
     memoize :handler

data/lib/jets/{poly_fun → poly}/lambda_executor.rb

@@ -1,13 +1,13 @@
 require 'json'
 
-class Jets::PolyFun
+class Jets::Poly
   class LambdaExecutor
     def initialize(task)
       @task = task
     end
 
     def run(event, context)
-      executor_class = "Jets::PolyFun::#{@task.lang.capitalize}Executor".constantize
+      executor_class = "Jets::Poly::#{@task.lang.capitalize}Executor".constantize
       executor = executor_class.new(@task)
       text = executor.run(event, context)
       JSON.load(text)

data/lib/jets/{poly_fun → poly}/node_error.rb

@@ -1,4 +1,4 @@
-class Jets::PolyFun
+class Jets::Poly
   class NodeError < StandardError
     def initialize(message, backtrace)
       super(message)

data/lib/jets/{poly_fun → poly}/node_executor.rb

@@ -1,4 +1,4 @@
-class Jets::PolyFun
+class Jets::Poly
   class NodeExecutor < BaseExecutor
     # Code for wrapper script that mimics lambda execution. Wrapper script usage:
     #
@@ -18,7 +18,7 @@ class Jets::PolyFun
 
     # https://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-handler.html
     def async_syntax?
-      app_path = "#{Jets.root}/" + @task.handler_path.sub('handlers/', 'app/')
+      app_path = "#{Jets.root}/" + @definition.handler_path.sub('handlers/', 'app/')
       source_code = IO.read(app_path)
       source_code.match(/=\s*async.*\(/)
     end
@@ -29,7 +29,7 @@ var event = process.argv[2]
 event = JSON.parse(event)
 var context = {}
 
-var app = require("./#{@task.meth}.js")
+var app = require("./#{@definition.meth}.js")
 app.#{handler}(event, context).then(resp => console.log(JSON.stringify(resp)))
 EOL
     end
@@ -46,7 +46,7 @@ var event = process.argv[2]
 event = JSON.parse(event)
 var context = {}
 
-var app = require("./#{@task.meth}.js")
+var app = require("./#{@definition.meth}.js")
 var resp = app.#{handler}(event, context, callback)
 EOL
     end

data/lib/jets/{poly_fun → poly}/python_error.rb

@@ -1,4 +1,4 @@
-class Jets::PolyFun
+class Jets::Poly
   class PythonError < StandardError
     def initialize(message, backtrace)
       super(message)

data/lib/jets/{poly_fun → poly}/python_executor.rb

@@ -1,4 +1,4 @@
-class Jets::PolyFun
+class Jets::Poly
   class PythonExecutor < BaseExecutor
     # Code for wrapper script that mimics lambda execution. Wrapper script usage:
     #
@@ -11,7 +11,7 @@ class Jets::PolyFun
       <<-EOL
 import sys
 import json
-from #{@task.meth} import #{handler}
+from #{@definition.meth} import #{handler}
 event = json.loads(sys.argv[1])
 context = {}
 resp = #{handler}(event, context)