jets 5.0.14 → 6.0.0.beta1

data/lib/jets/command/help/upgrade.md

@@ -1,7 +0,0 @@
-Upgrades the Jets project structure to the latest version. This command is designed to be idempotent, so it should be safe to run this command multiple times.
-
-## Example
-
-    $ jets upgrade
-
-Refer to https://rubyonjets.com/docs/extras/upgrading/

data/lib/jets/command/help.rb

@@ -1,17 +0,0 @@
-module Jets::Command
-  class Help
-    class << self
-      def text(namespaced_command)
-        file = namespaced_command.to_s.gsub(':','/')
-        path = File.expand_path("../help/#{file}.md", __FILE__)
-        return IO.read(path) if File.exist?(path)
-
-        # Also look up for a help folder within the current command folder
-        called_from = caller.first.split(':').first
-        unnamespaced_command = namespaced_command.to_s.split(':').last
-        path = File.expand_path("../help/#{unnamespaced_command}.md", called_from)
-        return IO.read(path) if File.exist?(path)
-      end
-    end
-  end
-end

data/lib/jets/command/helpers/editor.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/encrypted_file"
-
-module Jets
-  module Command
-    module Helpers
-      module Editor
-        private
-          def ensure_editor_available(command:)
-            if ENV["EDITOR"].to_s.empty?
-              say "No $EDITOR to open file in. Assign one like this:"
-              say ""
-              say %(EDITOR="mate --wait" #{command})
-              say ""
-              say "For editors that fork and exit immediately, it's important to pass a wait flag,"
-              say "otherwise the credentials will be saved immediately with no chance to edit."
-
-              false
-            else
-              true
-            end
-          end
-
-          def catch_editing_exceptions
-            yield
-          rescue Interrupt
-            say "Aborted changing file: nothing saved."
-          rescue ActiveSupport::EncryptedFile::MissingKeyError => error
-            say error.message
-          end
-      end
-    end
-  end
-end

data/lib/jets/command/rake_decorate.rb

@@ -1,38 +0,0 @@
-module Jets::Command
-  module RakeDecorate
-    # Decorate this method because this does not get called until runtime.
-    # It's "lazy loaded" so we can avoid the Rails const being defined in general.
-    def [](task_name, scopes=nil)
-      super # => Rake::TaskManager#[]
-    rescue RuntimeError => e
-      # We require dummy/rails since this time because all the rake tasks have been loaded
-      # and we need to load dummy/rails to get the database configurations. Normally,
-      # we do not want to require dummy/rails because it defines the Rails.
-      # However, a "command not found" error, more accurately,
-      # a "rake task not found" error, has already been encountered.
-      # Also:
-      # require "dummy/rails" to prevent another error.
-      #   from lib/active_record/railties/databases.rake
-      #
-      #   NoMethodError: undefined method `env' for Rails:Module (NoMethodError)
-      #     database_configs = ActiveRecord::DatabaseConfigurations.new(databases).configs_for(env_name: Rails.env)
-      #
-      require "jets/overrides/dummy/rails"
-
-      # Original error message from rake is something like this
-      #
-      #   Don't know how to build task 'foo:bar' (See the list of available tasks with `jets --tasks`)
-      #
-      # With an ugly backtrace.
-      # We override the error message to be more user friendly.
-      #
-      # All of that in order for
-      #   jets foo:bar
-      # to show a pretty error message.
-      $stderr.puts "ERROR: Could not find command: #{task_name.inspect}".color(:red)
-      require "jets/commands/help/help_command"
-      Jets::Command::HelpCommand.new.help
-      exit 1
-    end
-  end
-end

data/lib/jets/command.rb

@@ -1,142 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support"
-require "active_support/core_ext/enumerable"
-require "active_support/core_ext/object/blank"
-
-require "thor"
-
-module Jets
-  module Command
-    extend ActiveSupport::Autoload
-
-    autoload :Behavior
-    autoload :Base
-
-    include Behavior
-
-    HELP_MAPPINGS = %w(-h -? --help)
-
-    cattr_accessor :original_cli_command
-
-    class << self
-      def hidden_commands # :nodoc:
-        @hidden_commands ||= []
-      end
-
-      def environment # :nodoc:
-        ENV["JETS_ENV"].presence || ENV["RACK_ENV"].presence || "development"
-      end
-
-      # Receives a namespace, arguments, and the behavior to invoke the command.
-      def invoke(full_namespace, args = [], **config)
-        namespace = full_namespace = full_namespace.to_s
-        Jets::Command.original_cli_command = full_namespace
-
-        if char = namespace =~ /:(\w+)$/
-          command_name, namespace = $1, namespace.slice(0, char)
-        else
-          command_name = namespace
-        end
-
-        command_name, namespace = "help", "help" if command_name.blank? || HELP_MAPPINGS.include?(command_name)
-        command_name, namespace, args = "application", "application", ["--help"] if jets_new_with_no_path?(args)
-        command_name, namespace = "version", "version" if %w( -v --version ).include?(command_name)
-
-        original_argv = ARGV.dup
-        ARGV.replace(args)
-
-        command = find_by_namespace(namespace, command_name)
-        if command && command.all_commands[command_name]
-          command.perform(full_namespace, command_name, args, config)
-        else
-          # Decorate the rake [] method in order to rescue the error and print out
-          # a user friendly message. This works to catch rake errors but
-          # unsure why cannot just rescue RuntimeError here.
-          # More details in the RakeDecorate module.
-          require "rake/application"
-          Rake::Application.send(:include, RakeDecorate)
-          args = ["--describe", full_namespace] if HELP_MAPPINGS.include?(args[0])
-          find_by_namespace("rake").perform(full_namespace, args, config)
-        end
-      ensure
-        ARGV.replace(original_argv)
-      end
-
-      # Jets finds namespaces similar to Thor, it only adds one rule:
-      #
-      # Command names must end with "_command.rb". This is required because Jets
-      # looks in load paths and loads the command just before it's going to be used.
-      #
-      #   find_by_namespace :webrat, :integration
-      #
-      # Will search for the following commands:
-      #
-      #   "webrat", "webrat:integration", "jets:webrat", "jets:webrat:integration"
-      #
-      def find_by_namespace(namespace, command_name = nil) # :nodoc:
-        lookups = [ namespace ]
-        lookups << "#{namespace}:#{command_name}" if command_name
-        lookups.concat lookups.map { |lookup| "jets:#{lookup}" }
-
-        lookup(lookups)
-
-        namespaces = subclasses.index_by(&:namespace)
-        namespaces[(lookups & namespaces.keys).first]
-      end
-
-      # Returns the root of the Jets engine or app running the command.
-      def root
-        if defined?(ENGINE_ROOT)
-          Pathname.new(ENGINE_ROOT)
-        elsif defined?(APP_PATH)
-          Pathname.new(File.expand_path("../..", APP_PATH))
-        end
-      end
-
-      def print_commands # :nodoc:
-        commands.each { |command| puts("  #{command}") }
-      end
-
-        COMMANDS_IN_USAGE = %w(
-          generate
-          console
-          server
-          deploy
-          logs
-          new
-        )
-        private_constant :COMMANDS_IN_USAGE
-
-        PRO_COMMANDS = %w(
-          projects
-          stacks
-          releases
-          rollback
-        )
-
-        def jets_new_with_no_path?(args)
-          args == ["new"]
-        end
-
-        def commands
-          lookup!
-          visible_commands = (subclasses - hidden_commands).flat_map(&:printing_commands)
-          (visible_commands - COMMANDS_IN_USAGE - PRO_COMMANDS).sort
-        end
-
-      private
-        def command_type # :doc:
-          @command_type ||= "command"
-        end
-
-        def lookup_paths # :doc:
-          @lookup_paths ||= %w( jets/commands commands )
-        end
-
-        def file_lookup_paths # :doc:
-          @file_lookup_paths ||= [ "{#{lookup_paths.join(',')}}", "**", "*_command.rb" ]
-        end
-    end
-  end
-end

data/lib/jets/commands/application/application_command.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module Jets
-  module Command
-    class ApplicationCommand < Base # :nodoc:
-      hide_command!
-
-      self.bin = "jets" if respond_to?(:bin=) # Rails 7.1
-
-      def help
-        perform # Punt help output to the generator.
-      end
-
-      # This is:
-      #
-      #   bundle exec jets application:help => jets new --help
-      #   bundle exec jets application      => jets new --help
-      #
-      def perform(*args)
-        version_flags = %w[-v --version] & args
-        unless version_flags.empty?
-          puts "Jets #{Jets::VERSION}"
-          return
-        end
-
-        # require lazily so that Rails constant is only defined within generators
-        require "jets/generators/overrides/app/app_generator"
-        override_exit_on_failure?
-        argv = Rails::Generators::ARGVScrubber.new(args).prepare!
-        Jets::Generators::AppGenerator.start argv
-      end
-
-    private
-      # We override this way because Jets require generators lazily
-      def override_exit_on_failure?
-        Jets::Generators::AppGenerator.class_eval do
-          # We want to exit on failure to be kind to other libraries
-          # This is only when accessing via CLI
-          def self.exit_on_failure?
-            true
-          end
-        end
-      end
-    end
-  end
-end

data/lib/jets/commands/build/build_command.rb

@@ -1,33 +0,0 @@
-module Jets::Command
-  class BuildCommand < Base # :nodoc:
-    include EnvironmentArgument
-
-    option :templates, type: :boolean, desc: "Build CloudFormation templates only"
-
-    desc "build", "Builds and packages project for AWS Lambda"
-    long_desc Help.text(:build)
-    def perform
-      ENV['JETS_TEMPLATES'] = '1' if options[:templates]
-
-      extract_environment_option_from_argument
-      require_application_and_environment!
-
-      puts "Building project for Lambda..."
-      # run gets called from the CLI and does not have all the stack_options yet.
-      # We compute it and change the options early here.
-      @options.merge!(stack_type: stack_type, s3_bucket: Jets.s3_bucket)
-      do_build
-    end
-
-  private
-    # Note: build is picked up as a command so naming it do_build
-    def do_build
-      Jets::Builders::CodeBuilder.new.build unless ENV['JETS_TEMPLATES']
-      Jets::Cfn::Builder.new(@options).build
-    end
-
-    def stack_type
-      first_run? ? :minimal : :full
-    end
-  end
-end

data/lib/jets/commands/call/anonymous_guesser.rb

@@ -1,96 +0,0 @@
-module Jets::Commands::Call
-  class AnonymousGuesser < BaseGuesser
-    def detect_class_name
-      found_path = function_paths.find do |path|
-        File.exist?("#{Jets.root}/#{path}")
-      end
-
-      klass = Jets::Klass.from_path(found_path) if found_path
-      klass.to_s
-    end
-
-    def method_name
-      return @method_name if defined?(@method_name)
-
-      full_function_name = @provided_function_name.underscore
-      underscored_class_name = class_name.underscore
-      meth = full_function_name.sub("#{underscored_class_name}_","")
-
-      if meth == class_name.constantize.handler.to_s
-        @method_name = meth
-      else
-        @method_name_error = "#{class_name} class found but #{meth} method not found"
-        @method_name = nil
-      end
-    end
-
-    # Useful to printing out what was attempted to look up
-    def error_message
-      guess_paths = function_paths
-      puts "Unable to find the function to call."
-      if class_name and !method_name
-        puts @method_name_error
-      else
-        puts "Tried: #{guess_paths.join(', ')}"
-      end
-    end
-
-    def function_filenames(meth=nil, primary_namespace=nil)
-      guesses = []
-      parts = meth.split('_')
-
-      if primary_namespace.nil?
-        guesses << meth
-
-        if parts.size == 1 # already on final_primary_namespace
-          return guesses # end of recursion
-        else
-          next_primary_namespace =  parts.first
-          guesses += function_filenames(meth, next_primary_namespace) # start of recursion
-          return guesses # return early
-        end
-      end
-
-      next_meth = meth.sub("#{primary_namespace}_", '')
-      next_parts = next_meth.split('_')
-
-      # Takes the next_parts and creates guesses with the parts joined by '/'
-      # with the primary_namespace prepended.  So if next_parts is
-      # ["long", "name", "function"] and primary_namespace is "complex"
-      #
-      # guesses that get added:
-      #
-      #   [
-      #     "complex/long_name_function",
-      #     "complex/long/name_function",
-      #     "complex/long/name/function",
-      #   ]
-      n = next_parts.size + 1
-      next_parts.size.times do |i|
-        namespace = i == 0 ? nil : next_parts[0..i-1].join('/')
-        class_path = next_parts[i..-1].join('_')
-        guesses << [primary_namespace, namespace, class_path].compact.join('/')
-      end
-
-      final_primary_namespace = parts[0..-2].join('_')
-      if primary_namespace == final_primary_namespace
-        return guesses # end of recursion
-      else
-        namespace_size = parts.size - next_parts.size
-        next_primary_namespace = parts[0..namespace_size].join('_')
-        guesses += function_filenames(meth, next_primary_namespace)
-        return guesses
-      end
-    end
-
-    def function_paths
-      # drop the last word for starting filename
-      starting_filename = @provided_function_name.underscore.split('_')[0..-2].join('_')
-      filenames = function_filenames(starting_filename)
-      filenames.map do |name|
-        "app/functions/#{name}.rb"
-      end
-    end
-
-  end
-end

data/lib/jets/commands/call/autoload_guesser.rb

@@ -1,136 +0,0 @@
-module Jets::Commands::Call
-  class AutoloadGuesser < BaseGuesser
-    def detect_class_name
-      # First guess the class name assuming simple
-      class_name = simple_detect_class_name
-      return class_name if class_name
-
-      guess_classes.each do |class_name_guess|
-        begin
-          class_name_guess.constantize
-          return class_name_guess # if there's no error then the class is found
-        rescue NameError
-          if out_of_guesses(class_name_guess)
-            # puts "Unable to find the class to call. Tried guessing: #{guess_classes[0..-2].join(', ')}."
-            # raise # re-raise NameError for now but maybe better to provide
-              # a custom error class, so we can rescue it and provide a
-              # friendly message to the user
-          else
-            next
-          end
-        end
-      end
-
-      nil
-    end
-
-    # Can guess name by looking at underscore and dashes.
-    #
-    # Example:
-    #
-    #   @provided_function_name: first_module-lost_controller-index
-    #   return: FirstModule::LostController
-    #
-    def simple_detect_class_name
-      parts = @provided_function_name.split('-')
-      namespace = parts[0..-3].join('/')
-      controller = parts[-2..-2] # dont include the action
-      class_name = [namespace, controller].reject {|s| s.empty?}.compact.join('/').camelize
-      begin
-        class_name.constantize
-        return class_name
-      rescue NameError
-        nil
-      end
-    end
-
-    def method_name
-      return @method_name if defined?(@method_name)
-      return nil unless class_name
-
-      underscored_class_name = class_name.underscore.gsub('/','_')
-      underscored_function_name = @provided_function_name.underscore.gsub('/','_')
-      meth = underscored_function_name.sub(underscored_class_name, '')
-      meth = meth.sub(/^[-_]/,'') # remove leading _ or -
-
-      if class_name.constantize.definitions.map(&:meth).include?(meth.to_sym)
-        @method_name = meth
-      else
-        @method_name_error ="#{class_name} class found but #{meth} method not found"
-        @method_name = nil
-      end
-    end
-
-    # Useful to printing out what was attempted to look up
-    def error_message
-      guesses = guess_classes
-      puts "Unable to find the function to call."
-      if class_name and !method_name
-        puts @method_name_error
-      else
-        puts "Tried: #{guesses.join(', ')}"
-      end
-    end
-
-    def process_type
-      if @provided_function_name =~ /[-_]controller/
-        "controller"
-      elsif @provided_function_name =~ /[-_]job/
-        "job"
-      elsif @provided_function_name =~ /[-_]rule/
-        "rule"
-      else
-        "function"
-      end
-    end
-
-    def process_type_pattern
-      Regexp.new("[-_]#{process_type}[-_](.*)")
-    end
-
-    # Strips the action because we dont want it to guess the class name
-    # So:
-    #   admin-related-pages => admin_related_pages_controller
-    def underscored_name
-      # strip action and concidentally the _controller_ string
-      name = @provided_function_name.sub(process_type_pattern,'')
-      # Ensure _controller or _job at the end except for simple functions
-      unless process_type == "function"
-        name = name.gsub('-','_') + "_#{process_type}"
-      end
-      name
-    end
-
-    # Guesses autoload paths.
-    #
-    # underscored_name: admin_related_pages_controller
-    # Returns:
-    #   [
-    #     "admin_related_pages_controller",
-    #     "admin/related_pages_controller",
-    #     "admin_related/pages_controller",
-    #     "admin_related_pages/controller",
-    #   ]
-    def autoload_paths
-      guesses = []
-
-      parts = underscored_name.split('_')
-      parts.size.times do |i|
-        namespace = i == 0 ? nil : parts[0..i-1].join('/')
-        class_path = parts[i..-1].join('_')
-        guesses << [namespace, class_path].compact.join('/')
-      end
-
-      guesses
-    end
-
-    def guess_classes
-      autoload_paths.map(&:classify)
-    end
-
-    def out_of_guesses(guess)
-      guess.include?("::Controller")
-    end
-
-  end
-end

data/lib/jets/commands/call/base_guesser.rb

@@ -1,62 +0,0 @@
-# Subclasses of BaseGuessor must implement interface:
-#   detect_class_name
-#   method_name
-#   error_message
-#
-module Jets::Commands::Call
-  class BaseGuesser
-    include Jets::AwsServices
-
-    # provided_function_name:
-    #   admin/related_pages_controller-list_all
-    #   admin-related-pages-controller-list-all
-    def initialize(provided_function_name)
-      @provided_function_name = provided_function_name
-    end
-
-    def class_name
-      return @class_name if @detection_ran
-
-      @class_name = detect_class_name
-      @detection_ran = true
-      @class_name
-    end
-
-    def function_name
-      # Strip the project namespace if the user has accidentally added it
-      # Since we're going to automatically add it no matter what at the end
-      # and dont want the namespace to be included twice
-      @provided_function_name = @provided_function_name.sub("#{Jets.project_namespace}-", "")
-
-      code_path = class_name.underscore.gsub('/','-')
-      function_name = [Jets.project_namespace, code_path, method_name].join('-')
-      generated_function_name(function_name)
-    end
-
-    def generated_function_name(function_name)
-      if function_name.size > Jets::Cfn::Resource::Lambda::Function::MAX_FUNCTION_NAME_SIZE # name generated by CloudFormation
-        logical_id = @class_name.gsub('::','')
-
-        parent_resources = stack_resources(parent_stack.stack_id)
-        app_stack = parent_resources.find { |s| s.logical_resource_id == logical_id }
-
-        resources = stack_resources(app_stack.physical_resource_id)
-        resource = resources.find { |r| r.logical_resource_id == method_name.camelize + "LambdaFunction" } # method_name only contains the method
-        resource.physical_resource_id # actual function name
-      else
-        function_name
-      end
-    end
-
-    # Class variable caches
-    @@stack_resources = {}
-    def stack_resources(stack_name)
-      @@stack_resources[stack_name] ||= cfn.describe_stack_resources(stack_name: stack_name).stack_resources
-    end
-
-    @@parent_stack = nil
-    def parent_stack
-      @@parent_stack ||= cfn.describe_stacks(stack_name: Jets::Names.parent_stack_name).stacks.first
-    end
-  end
-end

data/lib/jets/commands/call/call_command.rb

@@ -1,27 +0,0 @@
-require "base64"
-require "json"
-
-module Jets::Command
-  class CallCommand < Base # :nodoc:
-    include Jets::AwsServices
-
-    desc "call [function] [event]", "Call a lambda function on AWS or locally"
-    long_desc Help.text(:call)
-    option :invocation_type, default: "RequestResponse", desc: "RequestResponse, Event, or DryRun"
-    option :log_type, default: "Tail", desc: "Works if invocation_type set to RequestResponse"
-    option :qualifier, desc: "Lambda function version or alias name"
-    option :show_log, type: :boolean, desc: "Shows last 4KB of log in the x-amz-log-result header"
-    option :show_logs, type: :boolean, desc: "Shows last 4KB of log in the x-amz-log-result header"
-    option :lambda_proxy, type: :boolean, default: true, desc: "Enables automatic Lambda proxy transformation of the event payload"
-    option :guess, type: :boolean, default: true, desc: "Enables guess mode. Uses inference to allows use of all dashes to specify functions. Guess mode verifies that the function exists in the code base."
-    option :local, type: :boolean, desc: "Enables local mode. Instead of invoke the AWS Lambda function, the method gets called locally with current app code. With local mode guess mode is always used."
-    option :retry_limit, type: :numeric, default: nil, desc: "Retry count of invoking function. It work with remote call"
-    option :read_timeout, type: :numeric, default: nil, desc: " The number of seconds to wait for response data. It work with remote call"
-    def perform(function_name, payload='')
-      $stdout.sync = true
-      $stderr.sync = true
-      $stdout = $stderr # jets call operation
-      Jets::Commands::Call::Caller.new(function_name, payload, options).run
-    end
-  end
-end