jets 0.8.18 → 0.9.0

data/lib/jets/klass.rb

@@ -15,6 +15,7 @@
 #   Jets::Klass.from_path("app/jobs/hard_job.rb")
 #   Jets::Klass.from_path("app/functions/hello.rb")
 #   Jets::Klass.from_path("app/functions/hello_function.rb")
+#   Jets::Klass.from_path("app/shared/functions/whatever.rb")
 #
 #   Jets::Klass.from_task(task)
 #
@@ -37,7 +38,11 @@ class Jets::Klass
 
     # app/controllers/posts_controller.rb => PostsController
     def class_name(path)
-      path.sub(%r{.*app\/(.*?)/},'').sub(/\.rb$/,'').classify
+      if path.include?("/shared/")
+        path.sub(%r{.*app/shared/(.*?)/},'').sub(/\.rb$/,'').classify
+      else
+        path.sub(%r{.*app/(.*?)/},'').sub(/\.rb$/,'').classify
+      end
     end
 
     def from_task(task)

data/lib/jets/lambda/dsl.rb

@@ -1,5 +1,9 @@
+require 'active_support/concern'
+
 # Other dsl that rely on this must implement
-#   default_associated_resource: must return @resources
+#
+#   default_associated_resource_definition
+#
 module Jets::Lambda::Dsl
   extend ActiveSupport::Concern
 
@@ -130,41 +134,67 @@ module Jets::Lambda::Dsl
       end
 
       #############################
-      # Main methood that registers resources associated with the Lambda function.
+      # Main method that registers resources associated with the Lambda function.
       # All resources methods lead here.
-      def resources(*definitions)
-        if definitions == [nil] # when resources called with no arguments
-          @resources || []
+      def associated_resources(*definitions)
+        if definitions == [nil] # when associated_resources called with no arguments
+          @associated_resources || []
         else
-          @resources ||= []
-          @resources += definitions
-          @resources.flatten!
+          @associated_resources ||= []
+          @associated_resources << Jets::Resource::Associated.new(definitions)
+          @associated_resources.flatten!
         end
       end
-      alias_method :resource, :resources
+      # User-friendly short resource method. Users will use this.
+      alias_method :resource, :associated_resources
 
-      # Main method that the convenience methods call for to create resources associated
-      # with the Lambda function. References the first resource and updates it inplace.
-      # Useful for associated resources that are meant to be declare and associated
-      # with only one Lambda function. Example:
-      #
-      #   Config Rule <=> Lambda function is 1-to-1
-      #
-      # Note: This methods calls default_associated_resource. The inheriting DSL class
-      # must implement default_associated_resource. The default_associated_resource should
-      # wrap another method that is nicely name so that the nicely name method is
-      # available in the DSL. Example:
-      #
-      #   def default_associated_resource
-      #     config_rule
-      #   end
-      #
-      def update_properties(values={})
-        @resources ||= default_associated_resource
-        definition = @resources.first # singleton
-        attributes = definition.values.first
-        attributes[:properties].merge!(values)
-        @resources
+      # Properties belonging to the associated resource
+      def associated_properties(options={})
+        @associated_properties ||= {}
+        @associated_properties.deep_merge!(options)
+      end
+      alias_method :associated_props, :associated_properties
+
+      # meta definition
+      def self.define_associated_properties(associated_properties)
+        associated_properties.each do |property|
+          # Example:
+          #   def config_rule_name(value)
+          #     associated_properties(config_rule_name: value)
+          #   end
+          class_eval <<~CODE
+            def #{property}(value)
+              associated_properties(#{property}: value)
+            end
+          CODE
+        end
+      end
+
+      # Loop back through the resources and add a counter to the end of the id
+      # to handle multiple events.
+      # Then replace @associated_resources entirely
+      def add_logical_id_counter
+        numbered_resources = []
+        n = 1
+        @associated_resources.map do |associated|
+          logical_id = associated.logical_id
+          attributes = associated.attributes
+
+          logical_id = logical_id.sub(/\d+$/,'')
+          new_definition = { "#{logical_id}#{n}" => attributes }
+          numbered_resources << Jets::Resource::Associated.new(new_definition)
+          n += 1
+        end
+        @associated_resources = numbered_resources
+      end
+
+      def depends_on(*stacks)
+        if stacks == []
+          @depends_on
+        else
+          @depends_on ||= []
+          @depends_on += stacks
+        end
       end
 
       # meth is a Symbol
@@ -179,12 +209,26 @@ module Jets::Lambda::Dsl
         # 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.
+
+        # At this point we can use the current associated_properties and defined the
+        # associated resource with the Lambda function.
+        unless associated_properties.empty?
+          associated_resources(default_associated_resource_definition(meth))
+        end
+
+        # Unsure why but we have to use @associated_resources vs associated_resources
+        # associated_resources is always nil
+        if @associated_resources && @associated_resources.size > 1
+          add_logical_id_counter
+        end
+
         all_tasks[meth] = Jets::Lambda::Task.new(self.name, meth,
-          resources: @resources, # associated resources
           properties: @properties, # lambda function properties
           iam_policy: @iam_policy,
           managed_iam_policy: @managed_iam_policy,
-          lang: lang)
+          associated_resources: @associated_resources,
+          lang: lang,
+          replacements: replacements(meth))
 
         # Done storing options, clear out for the next added method.
         clear_properties
@@ -199,11 +243,16 @@ module Jets::Lambda::Dsl
         true
       end
 
+      # Meant to be overridden to add more custom replacements based on the app class type
+      def replacements(meth)
+        {}
+      end
+
       def clear_properties
-        @resources = nil
         @properties = nil
         @iam_policy = nil
         @managed_iam_policy = nil
+        @associated_resources = nil
       end
 
       # Returns the all tasks for this class with their method names as keys.
@@ -252,6 +301,25 @@ module Jets::Lambda::Dsl
       def node(meth)
         defpoly(:node, meth)
       end
+    end # end of class << self
+  end # end of included
+
+  def self.add_custom_resource_extensions(base)
+    base_path = "#{Jets.root}/app/extensions"
+    unless ActiveSupport::Dependencies.autoload_paths.include?(base_path)
+      ActiveSupport::Dependencies.autoload_paths += [base_path]
     end
+
+    Dir.glob("#{base_path}/**/*.rb").each do |path|
+      next unless File.file?(path)
+
+      class_name = path.sub("#{base_path}/", '').sub(/\.rb/,'').classify
+      klass = class_name.constantize # autoload
+      base.extend(klass)
+    end
+  end
+
+  def self.included(base)
+    add_custom_resource_extensions(base)
   end
 end

data/lib/jets/lambda/function_constructor.rb

@@ -45,10 +45,10 @@ module Jets::Lambda
       function_klass # assign this to a Constant for a pretty class name
     end
 
-    # For anonymous classes method_added during task registeration contains ""
+    # For anonymous classes method_added during task registration contains ""
     # for the class name.  We adjust it here.
     def adjust_tasks(klass)
-      class_name = @code_path.sub(/.*app\/functions\//,'').sub(/\.rb$/, '')
+      class_name = @code_path.sub(/.*\/functions\//,'').sub(/\.rb$/, '')
       class_name = class_name.classify
       klass.tasks.each do |task|
         task.class_name = class_name

data/lib/jets/lambda/task.rb

@@ -1,16 +1,17 @@
 class Jets::Lambda::Task
   attr_accessor :class_name, :type
-  attr_reader :meth, :resources, :properties, :iam_policy, :managed_iam_policy, :lang
+  attr_reader :meth, :properties, :iam_policy, :managed_iam_policy, :lang, :associated_resources
   def initialize(class_name, meth, options={})
     @class_name = class_name.to_s
     @meth = meth
     @options = options
     @type = options[:type] || get_type  # controller, job, or function
-    @resources = options[:resources] || {}
     @properties = options[:properties] || {}
     @iam_policy = options[:iam_policy]
     @managed_iam_policy = options[:managed_iam_policy]
     @lang = options[:lang] || :ruby
+    @associated_resources = options[:associated_resources] || {}
+    @replacements = options[:replacements] || {} # added to baseline replacements
   end
 
   def build_function_iam?
@@ -82,11 +83,15 @@ class Jets::Lambda::Task
     handler_path.sub("handlers/", "app/")
   end
 
-  ###
-  # Useful for Jets::Resource late building.
   def replacements
+    # Merge in the custom replacements specific to each app class: ConfigRule, Job, etc.
+    baseline_replacements.merge(@replacements)
+  end
+
+  def baseline_replacements
     {
-      namespace: "#{@class_name.gsub('::','')}#{@meth.to_s.camelize}", # camelized because used in not just keys but also values
+      # camelized because used in not just keys but common used in values
+      namespace: @meth.to_s.camelize,
     }
   end
 end

data/lib/jets/naming.rb

@@ -4,9 +4,16 @@
 class Jets::Naming
   # Mainly used by build.rb
   class << self
-    def template_path(app_class)
+    extend Memoist
+
+    def app_template_path(app_class)
       underscored = app_class.to_s.underscore.gsub('/','-')
-      "#{template_path_prefix}-#{underscored}.yml"
+      "#{template_path_prefix}-app-#{underscored}.yml"
+    end
+
+    def shared_template_path(shared_class)
+      underscored = shared_class.to_s.underscore.gsub('/','-')
+      "#{template_path_prefix}-shared-#{underscored}.yml"
     end
 
     def template_path_prefix
@@ -27,6 +34,10 @@ class Jets::Naming
       "#{template_path_prefix}-api-deployment.yml"
     end
 
+    def shared_resources_template_path
+      "#{template_path_prefix}-shared-resources.yml"
+    end
+
     def parent_stack_name
       File.basename(parent_template_path, ".yml")
     end

data/lib/jets/processors/deducer.rb

@@ -27,14 +27,25 @@ class Jets::Processors::Deducer
   # process_type is key. It can be either "controller" or "job". It is used to
   # deduce the rest of the methods: code, path.
   def process_type
-    @handler.split('/')[1].singularize # controller or job
+    if shared?
+      "function" # all app/shared/functions are always function process_type
+    else
+      @handler.split('/')[1].singularize # controller, job, rule, etc
+    end
+  end
+
+  def shared?
+    @handler.include?("/shared/functions")
   end
 
   # Example underscored_class_name:
   #   class_name = underscored_class_name
   #   class_name = class_name # PostsController
   def class_name
-    regexp = Regexp.new(".*handlers/#{process_type.pluralize}/")
+    regexp = shared? ?
+      Regexp.new(".*handlers/shared/functions/") :
+      Regexp.new(".*handlers/#{process_type.pluralize}/")
+
     # Example regexp:
     #   /.*handlers\/controllers\//
     #   /.*handlers\/jobs\//

data/lib/jets/processors/main_processor.rb

@@ -44,7 +44,7 @@ class Jets::Processors::MainProcessor
       #
       # JSON.dump is pretty robust.  If it cannot dump the structure into a
       # json string, it just dumps it to a plain text string.
-      resp = Jets::Util.normalize_result(result) # String
+      Jets::Util.normalize_result(result) # resp is a String
     rescue Exception => e
       # Customize error message slightly so nodejs shim can process the
       # returned error message.

data/lib/jets/rails_overrides.rb

@@ -1,4 +1,4 @@
 require "jets/rails_overrides/common_methods"
 require "jets/rails_overrides/url_helper"
 require "jets/rails_overrides/rendering_helper"
-require "jets/rails_overrides/asset_tag_helper"
+require "jets/rails_overrides/asset_tag_helper"

data/lib/jets/resource.rb

@@ -1,14 +1,19 @@
 class Jets::Resource
   extend Memoist
 
-  autoload :Base, 'jets/resource/base'
-  autoload :Replacer, 'jets/resource/replacer'
-  autoload :Permission, 'jets/resource/permission'
   autoload :ApiGateway, 'jets/resource/api_gateway'
+  autoload :Associated, 'jets/resource/associated'
+  autoload :Base, 'jets/resource/base'
   autoload :ChildStack, 'jets/resource/child_stack'
+  autoload :Config, 'jets/resource/config'
+  autoload :Events, 'jets/resource/events'
   autoload :Function, 'jets/resource/function'
   autoload :Iam, 'jets/resource/iam'
+  autoload :Permission, 'jets/resource/permission'
+  autoload :Replacer, 'jets/resource/replacer'
   autoload :S3, 'jets/resource/s3'
+  autoload :Sns, 'jets/resource/sns'
+  autoload :Standardizer, 'jets/resource/standardizer'
 
   attr_reader :definition, :replacements
   def initialize(definition, replacements={})
@@ -16,8 +21,18 @@ class Jets::Resource
     @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 = definition.keys.first
+    id = template.keys.first
     # replace possible {namespace} in the logical id
     id = replacer.replace_value(id)
     Jets::Camelizer.camelize(id)
@@ -32,7 +47,7 @@ class Jets::Resource
   end
 
   def attributes
-    attributes = definition.values.first
+    attributes = template.values.first
     attributes = replacer.replace_placeholders(attributes)
     Jets::Camelizer.transform(attributes)
   end

data/lib/jets/resource/api_gateway/deployment.rb

@@ -20,7 +20,6 @@ module Jets::Resource::ApiGateway
       }
     end
 
-    # value is Value
     def outputs
       {
         "RestApiUrl" => "!Sub 'https://${RestApi}.execute-api.${AWS::Region}.amazonaws.com/#{stage_name}/'",

data/lib/jets/resource/associated.rb

@@ -0,0 +1,26 @@
+# Does not do full expansion, mainly a container that holds the definition and
+# standardizes it without camelizing it.
+class Jets::Resource
+  class Associated
+    extend Memoist
+
+    attr_reader :definition
+    def initialize(*definition)
+      @definition = definition.flatten
+    end
+
+    def logical_id
+      standardized.keys.first
+    end
+
+    def attributes
+      standardized.values.first
+    end
+
+    def standardized
+      standardizer = Standardizer.new(definition)
+      standardizer.standarize(definition) # doesnt camelize keys yet
+    end
+    memoize :standardized
+  end
+end

data/lib/jets/resource/base.rb

@@ -1,3 +1,15 @@
+# Classes that inherit from this method should NOT define and override:
+#
+#   logical_id
+#   type
+#   properties
+#   attributes
+#
+# These are computed methods that derive their values from the resource definition itself.
+# Overriding these methods will remove the computed logical which handles things
+# like camelizing and replacements.
+#
+# The implementation of these methods are in `Jets::Resource`.
 class Jets::Resource
   class Base
     extend Memoist

data/lib/jets/resource/child_stack.rb

@@ -2,4 +2,6 @@ module Jets::Resource::ChildStack
   autoload :AppClass, 'jets/resource/child_stack/app_class'
   autoload :ApiGateway, 'jets/resource/child_stack/api_gateway'
   autoload :ApiDeployment, 'jets/resource/child_stack/api_deployment'
+  autoload :Base, 'jets/resource/child_stack/base'
+  autoload :Shared, 'jets/resource/child_stack/shared'
 end

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

@@ -1,9 +1,10 @@
+# Implements:
+#
+#   definition
+#   template_filename
+#
 module Jets::Resource::ChildStack
-  class ApiDeployment < Jets::Resource::Base
-    def initialize(s3_bucket)
-      @s3_bucket = s3_bucket
-    end
-
+  class ApiDeployment < Base
     def definition
       {
         deployment_id => {
@@ -32,7 +33,7 @@ module Jets::Resource::ChildStack
         # map the path to a camelized logical_id. Example:
         #   /tmp/jets/demo/templates/demo-dev-2-posts_controller.yml to
         #   PostsController
-        regexp = Regexp.new(".*#{Jets.config.project_namespace}-")
+        regexp = Regexp.new(".*#{Jets.config.project_namespace}-app-")
         controller_name = path.sub(regexp, '').sub('.yml', '')
         controller_logical_id = controller_name.underscore.camelize
         controller_logical_ids << controller_logical_id
@@ -40,19 +41,12 @@ module Jets::Resource::ChildStack
       controller_logical_ids
     end
 
-    def outputs
-      {
-        logical_id => "!Ref #{logical_id}",
-      }
-    end
-
     def deployment_id
       Jets::Resource::ApiGateway::Deployment.logical_id
     end
 
-    def template_url
-      path = File.basename("#{Jets.config.project_namespace}-api-deployment.yml")
-      "https://s3.amazonaws.com/#{@s3_bucket}/jets/cfn-templates/#{path}"
+    def template_filename
+      "#{Jets.config.project_namespace}-api-deployment.yml"
     end
   end
 end