jets_bb_fork 0.0.4

data/lib/jets/builders/shim_vars/app.rb

@@ -0,0 +1,78 @@
+# Jets::Builders::ShimVars::Shared.new(path)
+#
+#   @vars.functions.each do |function_name|
+#     @vars.handler_for(function_name)
+#   end
+#
+# Implements:
+#
+#   functions: IE [:index, :show]
+#   handler_for(function_name): IE handlers/controllers/posts_controller.index
+#   dest_path: IE: handlers/controllers/posts_controller.js
+#
+module Jets::Builders::ShimVars
+  class App < Base
+    # Allow user to specify relative or full path. The right path gets used
+    # internally. Example paths:
+    #   app/controllers/posts_controller.rb
+    #   app/jobs/hard_job.rb
+    #   /tmp/jets/build/app_root/app/jobs/hard_job.rb
+    #   /tmp/jets/build/app_root/app/functions/hello.rb
+    def initialize(path)
+      @full_path = full(path)
+      @relative_path = relative(path)
+    end
+
+    def full(path)
+      path = "#{Jets.root}/#{path}" unless path.starts_with?("/")
+      path
+    end
+
+    def relative(path)
+      full_path = full(path)
+      full_path.sub("#{Jets.root}/", "")
+               .sub(/.*internal\/app/, "app")
+
+    end
+
+    # process_type is key, it will either "controller" or "job".
+    # It is used to deduce klass, etc.
+    # We get the process_type from the path.
+    # Example paths:
+    #   app/controllers/posts_controller.rb
+    #   app/jobs/hard_job.rb
+    def process_type
+      @relative_path.split('/')[1].singularize # controller or job
+    end
+
+    # Returns the public methods of the child_class.
+    # Example: [:create, :update]
+    def functions
+      klass.lambda_functions
+    end
+
+    # Examples: PostsController, HardJob, Hello, HelloFunction
+    def klass
+      @klass ||= Jets::Klass.from_path(@relative_path)
+    end
+
+    def lang(meth)
+      klass.tasks.find
+    end
+
+    # This gets called in the node shim js template
+    # IE handlers/controllers/posts_controller.index
+    def handler_for(meth)
+      # possibly not include _function
+      underscored_name = @relative_path.sub(%r{app/(\w+)/},'').sub('.rb','')
+      "handlers/#{process_type.pluralize}/#{underscored_name}.#{meth}"
+    end
+
+    # Example return: "handlers/controllers/posts.js"
+    # TODO: rename this to dest_path or something better now since using native ruby
+    def dest_path
+      @relative_path
+        .sub("app", "handlers")
+    end
+  end
+end

data/lib/jets/builders/shim_vars/base.rb

@@ -0,0 +1,25 @@
+module Jets::Builders::ShimVars
+  class Base
+    include Jets::AwsServices
+    extend Memoist
+
+    def s3_bucket
+      Jets.aws.s3_bucket
+    end
+
+    def rack_zip
+      checksum_zip(:rack)
+    end
+
+    def bundled_zip
+      checksum_zip(:bundled)
+    end
+
+  private
+    def checksum_zip(name)
+      checksum = Jets::Builders::Md5.checksums["stage/#{name}"]
+      return unless checksum
+      "#{name}-#{checksum}.zip"
+    end
+  end
+end

data/lib/jets/builders/shim_vars/shared.rb

@@ -0,0 +1,37 @@
+# Jets::Builders::ShimVars::Shared.new(fun)
+#
+#   @deducer.functions.each do |function_name|
+#     @deducer.handler_for(function_name)
+#   end
+#
+# Implements:
+#
+#   functions: IE [:index, :show]
+#   handler_for(function_name): IE handlers/controllers/posts_controller.index
+#   dest_path: IE: handlers/controllers/posts_controller.js
+#
+module Jets::Builders::ShimVars
+  class Shared < Base
+    # fun is a Jets::Stack::Function
+    def initialize(fun)
+      @fun = fun
+    end
+
+    # Always only one element for shared functions
+    # functions: IE [:handle]
+    def functions
+      [@fun.meth] # function_names
+    end
+
+    # Dont need function_name arg but keeping the same interface as parent class
+    # IE handlers/shared/functions/bob.handle
+    def handler_for(function_name)
+      @fun.handler_dest
+    end
+
+    # IE handlers/shared/functions/bob.js
+    def dest_path
+      @fun.handler_dest
+    end
+  end
+end

data/lib/jets/builders/templates/handler.rb

@@ -0,0 +1,12 @@
+require "bundler/setup"
+require "jets"
+Jets.once  # runs once in lambda execution context
+
+<% @vars.functions.each do |function_name|
+  handler = @vars.handler_for(function_name)
+  meth = handler.split('.').last
+-%>
+def <%= meth -%>(event:, context:)
+  Jets.process(event, context, "<%= handler -%>")
+end
+<% end %>

data/lib/jets/builders/tidy.rb

@@ -0,0 +1,107 @@
+module Jets::Builders
+  class Tidy
+    include Util
+
+    def initialize(project_root, noop: false)
+      @project_root = project_root
+      @noop = noop
+    end
+
+    def cleanup!
+      removals.each do |removal|
+        removal = removal.sub(%r{^/},'') # remove leading slash
+        path = "#{@project_root}/#{removal}"
+        rm_rf(path)
+      end
+
+      clean_vendor_gems
+      clean_webpack_assets
+    end
+
+    # Clean out unnecessary src and compiled packs because Jets serves them out of s3.
+    # This keeps the code size down to help keep it in size limit so we can use the
+    # live Lambda console editor.
+    def clean_webpack_assets
+      FileUtils.rm_rf("#{@project_root}/app/javascript/src")
+
+      return unless File.exist?("#{@project_root}/public/packs") # this class works for rack subfolder too
+      FileUtils.mv("#{@project_root}/public/packs/manifest.json", "#{stage_area}/manifest.json")
+      FileUtils.rm_rf("#{@project_root}/public/packs")
+      FileUtils.mkdir_p("#{@project_root}/public/packs")
+      FileUtils.mv("#{stage_area}/manifest.json", "#{@project_root}/public/packs/manifest.json")
+    end
+
+    def removals
+      removals = always_removals
+      removals += get_removals("#{@project_root}/.gitignore")
+      removals += get_removals("#{@project_root}/.dockerignore")
+      removals = removals.reject do |p|
+        jetskeep.find do |keep|
+          p.include?(keep)
+        end
+      end
+      removals.uniq
+    end
+
+    def get_removals(file)
+      path = file
+      return [] unless File.exist?(path)
+
+      removal = File.read(path).split("\n")
+      removal.map {|i| i.strip}.reject {|i| i =~ /^#/ || i.empty?}
+      # IE: ["/handlers", "/bundled*", "/vendor/jets]
+    end
+
+    # We clean out ignored files pretty aggressively. So provide
+    # a way for users to keep files from being cleaned out.
+    def jetskeep
+      always = %w[.bundle packs]
+      path = "#{@project_root}/.jetskeep"
+      return always unless File.exist?(path)
+
+      keep = IO.readlines(path)
+      keep = keep.map {|i| i.strip}.reject { |i| i =~ /^#/ || i.empty? }
+      (always + keep).uniq
+    end
+
+    # folders to remove in the vendor/gems folder regardless of the level of the folder
+    def clean_vendor_gems
+      # Thanks: https://stackoverflow.com/questions/11385795/ruby-list-directory-with-dir-including-dotfiles-but-not-and
+      Dir.glob("#{@project_root}/vendor/gems/**/*", File::FNM_DOTMATCH).each do |path|
+        next unless File.directory?(path)
+        dir = File.basename(path)
+        next unless always_removals.include?(dir)
+
+        rm_rf(path)
+      end
+
+      remove_gem_cache
+    end
+
+    # Reason do not remove the cache folder generally is because some gems have
+    # actual cache folders that they used.
+    def remove_gem_cache
+      ruby_minor_version = Jets::RUBY_VERSION.split('.')[0..1].join('.') + '.0'
+      cache_path = "#{@project_root}/vendor/gems/ruby/#{ruby_minor_version}/cache"
+      FileUtils.rm_rf(cache_path)
+    end
+
+    def rm_rf(path)
+      exists = File.exist?("#{path}/.gitkeep") || File.exist?("#{path}/.keep")
+      return if exists
+
+      # say "  rm -rf #{path}".color(:yellow) # uncomment to debug
+      system("rm -rf #{path}") unless @noop
+    end
+
+    # These directories will be removed regardless of dir level
+    def always_removals
+      %w[.git spec tmp]
+    end
+
+    def say(message)
+      message = "NOOP #{message}" if @noop
+      puts message
+    end
+  end
+end

data/lib/jets/builders/util.rb

@@ -0,0 +1,31 @@
+module Jets::Builders
+  module Util
+  private
+    def sh(command)
+      puts "=> #{command}".color(:green)
+      success = system(command)
+      unless success
+        puts "#{command} failed to run.".color(:red)
+        puts caller[0]
+        exit 1
+      end
+      success
+    end
+
+    def headline(message)
+      puts "=> #{message}".color(:cyan)
+    end
+
+    def build_area
+      Jets.build_root
+    end
+
+    def stage_area
+      "#{build_area}/stage"
+    end
+
+    def cache_area
+      "#{build_area}/cache" # cleaner to use full path for this setting
+    end
+  end
+end

data/lib/jets/bundle.rb

@@ -0,0 +1,82 @@
+require "jets/turbo"
+
+module Jets
+  # Named Bundle vs Bundler to avoid having to fully qualify ::Bundler
+  module Bundle
+    # Looks like for zeitwerk module autovivification to work `bundle exec` must be called.
+    # This allows zeitwork module autovivification to work even if the user has not called jets with `bundle exec jets`.
+    # Bundler.setup is essentially the same as `bundle exec`
+    # Reference: https://www.justinweiss.com/articles/what-are-the-differences-between-irb/
+    #
+    # The Bundler.setup is only necessary because we use Bundler.require after require "zeitwerk" is called.
+    #
+    # Note, this is called super early right before require "zeitwerk"
+    # The initially Bundler.setup does not include the Jets.env group.
+    # Later in Jets::Booter, Bundle.require is called and includes the Jets.env group.
+    #
+    def setup
+      return unless bundler_enabled?
+      Kernel.require "bundler/setup"
+      Bundler.setup # Same as Bundler.setup(:default)
+    rescue LoadError => e
+      handle_error(e)
+    end
+
+    # Bundler.require called when environment boots up via Jets.boot.  This will eagerly require all gems in the
+    # Gemfile. This means the user will not have to explictly require dependencies.
+    #
+    # It also useful for when to loading Rake tasks in Jets::Commands::RakeTasks.load! For example, some gems like
+    # webpacker that load rake tasks are specified with a git based source:
+    #
+    #   gem "webpacker", git: "https://github.com/tongueroo/webpacker.git"
+    #
+    # This results in the user having to specific bundle exec in front of jets for those rake tasks to show up in
+    # jets help. Instead, when the user is within the project folder, jets automatically requires bundler for the
+    # user. So the rake tasks show up when calling jets help.
+    #
+    # When the user calls jets help from outside the project folder, bundler is not used and the load errors get
+    # rescued gracefully.  This is done in Jets::Commands::RakeTasks.load!  In the case when user is in another
+    # project with another Gemfile, the load errors will also be rescued.
+    def require
+      return unless bundler_enabled?
+      Kernel.require "bundler/setup"
+      Bundler.require(*bundler_groups)
+    rescue LoadError => e
+      handle_error(e)
+    end
+
+    def handle_error(e)
+      puts e.message
+      puts <<~EOL.color(:yellow)
+        WARNING: Unable to require "bundler/setup"
+        There may be something funny with your ruby and bundler setup.
+        You can try upgrading bundler and rubygems:
+
+            gem update --system
+            gem install bundler
+
+        Here are some links that may be helpful:
+
+        * https://bundler.io/blog/2019/01/03/announcing-bundler-2.html
+        * https://community.rubyonjets.com/t/jets-1-9-8-install-issue-bundler-setup-missing/185/2
+
+        Also, running bundle exec in front of your command may remove this message.
+      EOL
+    end
+
+    # Also check for Afterburner mode since in that mode jets is a standalone tool.
+    def bundler_enabled?
+      !Jets::Turbo.afterburner? && gemfile?
+    end
+
+    def gemfile?
+      ENV['BUNDLE_GEMFILE'] || File.exist?("Gemfile")
+    end
+
+    def bundler_groups
+      [:default, Jets.env.to_sym]
+    end
+
+    extend self
+  end
+end

data/lib/jets/camelizer.rb

@@ -0,0 +1,71 @@
+# Custom Camelizer with CloudFormation specific handling.
+# Based on: https://stackoverflow.com/questions/8706930/converting-nested-hash-keys-from-camelcase-to-snake-case-in-ruby
+module Jets
+  class Camelizer
+    class << self
+      def transform(value, parent_keys=[])
+        case value
+        when Array
+          value.map { |v| transform(v, parent_keys) }
+        when Hash
+          initializer = value.map do |k, v|
+            new_key = camelize_key(k, parent_keys)
+            [new_key, transform(v, parent_keys+[new_key])]
+          end
+          Hash[initializer]
+        else
+          value # do not transform values
+        end
+      end
+
+      def camelize_key(k, parent_keys=[])
+        k = k.to_s
+
+        if passthrough?(k, parent_keys)
+          k # pass through untouch
+        elsif parent_keys.last == "EventPattern" # top-level
+          k.dasherize
+        elsif parent_keys.include?("EventPattern")
+          # Any keys at 2nd level under EventPattern will be pascalized
+          pascalize(k)
+        else
+          camelize(k)
+        end
+      end
+
+      def passthrough?(k, parent_keys)
+        # do not transform keys anything under these special keys
+        parent_keys.include?("Variables") ||
+        parent_keys.include?("ResponseParameters") ||
+        parent_keys.include?("Fn::Sub") ||
+        k.include?('-') || k.include?('/')
+      end
+
+      def camelize(value)
+        return value if value.is_a?(Integer)
+
+        value = value.to_s.camelize
+        special_map[value] || value
+      end
+
+      def pascalize(value)
+        new_value = value.camelize
+        first_char = new_value[0..0].downcase
+        new_value[0] = first_char
+        new_value
+      end
+
+      # Some keys have special mappings
+      def special_map
+        {
+          "TemplateUrl" => "TemplateURL",
+          "Ttl" => "TTL",
+          "MaxReceiveCount" => "maxReceiveCount",
+          "DeadLetterTargetArn" => "deadLetterTargetArn",
+          "DbSubnetGroupDescription" => "DBSubnetGroupDescription",
+          "DbSubnetGroupName" => "DBSubnetGroupName",
+        }
+      end
+    end
+  end
+end