jets 4.0.17 → 5.0.0.beta1

data/lib/jets/commands/generate/generate_command.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Jets::Command
+  class GenerateCommand < Base # :nodoc:
+    no_commands do
+      # jets generate -h
+      # Note: Other help flags like jets generate scaffold -h will be handled by
+      # invoking the generator and letting it handle the help flag.
+      def help
+        require_application_and_environment!
+        load_generators
+        all_commands_help self.class.command_name
+      end
+    end
+
+    desc "Generate", "Generate code"
+    long_desc Help.text(:generate)
+    def perform(*)
+      # require lazily so that Rails constant is only defined within generators
+      require "jets/generators"
+
+      generator = args.shift
+      return help unless generator
+
+      require_application_and_environment!
+      load_generators # engine.rb load_generators => Jets.application.load_generators
+
+      ARGV.replace(args) # set up ARGV for third-party libraries
+
+      Jets::Generators.invoke generator, args, behavior: behavior, destination_root: Jets::Command.root
+    end
+
+  private
+    def behavior
+      :invoke
+    end
+
+    def all_commands_help(command = "generate")
+      puts "Usage: jets #{command} GENERATOR [args] [options]"
+      puts
+      puts "General options:"
+      puts "  -h, [--help]     # Print generator's options and usage"
+      puts "  -p, [--pretend]  # Run but do not make any changes"
+      puts "  -f, [--force]    # Overwrite files that already exist"
+      puts "  -s, [--skip]     # Skip files that already exist"
+      puts "  -q, [--quiet]    # Suppress status output"
+      puts
+      puts "Please choose a generator below."
+      puts
+
+      Rails::Generators.print_generators
+    end
+  end
+end
+
+# Decorate the Group#help method to replace rails with jets.
+#
+# Note: Initially tried only decorating when a help flag like `-h` is detected
+# but some commands will trigger help output without the flag.  For example:
+#   jets generate job
+# The command requires a name
+#   jets generate job NAME
+#
+# The underlying Rails::Generators.invoke does this
+#   if klass = find_by_namespace(names.pop, names.any? && names.join(":"))
+#     args << "--help" if args.empty? && klass.arguments.any?(&:required?)
+# and is able to detect that the name is missing and triggers the help output.
+#
+# Jets does not have this logic yet.  So we'll decorate the help method to
+# at the Thor::Group#help level.
+require "thor"
+class Thor::Group
+  module ReplaceHelpOutputWithJets
+    def help(shell)
+      out = capture_stdout_for_help do
+        super # invoke to get the help output
+      end
+      puts out.gsub('rails','jets').gsub('Rails','Jets')
+    end
+
+    def capture_stdout_for_help
+      stdout_old = $stdout
+      io = StringIO.new
+      $stdout = io
+      yield
+      $stdout = stdout_old
+      io.string
+    end
+  end
+
+  class << self
+    # The help method is defined in the Thor::Group class.  We are decorating it
+    prepend ReplaceHelpOutputWithJets
+  end
+end

data/lib/jets/commands/help/USAGE

@@ -0,0 +1,20 @@
+Common Jets commands:
+  generate     Generate new code (short-cut alias: "g")
+  console      Start the Jets console (short-cut alias: "c")
+  server       Start the Jets server (short-cut alias: "s")
+  deploy       Deploy application to Lambda
+  logs         View Lambda function logs
+<% unless engine? -%>
+  new          Create a new Jets application. "jets new demo" creates a
+               new application called Demo in "./demo"
+<% end -%>
+
+Jets Pro commands:
+  projects     List projects
+  stacks       List stacks
+  releases     List releases
+  rollback     Rollback to a previous release
+
+All commands can be run with -h (or --help) for more information.
+In addition to those commands, there are:
+

data/lib/jets/commands/help/help_command.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Jets
+  module Command
+    class HelpCommand < Base # :nodoc:
+      hide_command!
+
+      def help(*)
+        say self.class.desc
+
+        Jets::Command.print_commands
+      end
+    end
+  end
+end

data/lib/jets/commands/initializers/initializers_command.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Jets
+  module Command
+    class InitializersCommand < Base # :nodoc:
+      include EnvironmentArgument
+
+      desc "initializers", "Print out all defined initializers in the order they are invoked by Jets."
+      def perform
+        extract_environment_option_from_argument
+        require_application_and_environment!
+
+        Jets.application.initializers.tsort_each do |initializer|
+          say "#{initializer.context_class}.#{initializer.name}"
+        end
+      end
+    end
+  end
+end

data/lib/jets/commands/logs/logs_command.rb

@@ -0,0 +1,45 @@
+require "aws-logs"
+
+module Jets::Command
+  class LogsCommand < Base # :nodoc:
+    include Jets::AwsServices
+
+    option :since, desc: "From what time to begin displaying logs.  By default, logs will be displayed starting from 10m in the past. The value provided can be an ISO 8601 timestamp or a relative time. Examples: 10m 2d 2w"
+    option :follow, aliases: :f, default: false, type: :boolean, desc: " Whether to continuously poll for new logs. To exit from this mode, use Control-C."
+    option :format, default: "simple", desc: "The format to display the logs. IE: detailed or short.  With detailed, the log stream name is also shown."
+    option :filter_pattern, desc: "The filter pattern to use. If not provided, all the events are matched"
+    option :log_group_name, aliases: :n, desc: "The log group name.  By default, it is /aws/lambda/#{Jets.project_namespace}-controller"
+    option :refresh_rate, default: 1, type: :numeric, desc: "How often to refresh the logs in seconds."
+    option :wait_exists, default: true, type: :boolean, desc: "Whether to wait until the log group exists.  By default, it will wait."
+    long_desc Help.text(:logs)
+    def perform
+      show_logs
+    end
+
+  private
+    def show_logs
+      options = @options.dup # so it can be modified
+      options[:log_group_name] = log_group_name
+      options[:since] ||= "10m" # by default, start search 10m in the past
+      options[:wait_exists_retries] = 12 # 12 * 5 = 60 seconds
+
+      verb = options[:follow] ? "Tailing" : "Showing"
+      $stderr.puts "#{verb} logs for #{options[:log_group_name]}"
+
+      tail = AwsLogs::Tail.new(options)
+      tail.run
+    end
+
+    def log_group_name
+      default = "/aws/lambda/#{Jets.project_namespace}-controller"
+      return default unless @options[:log_group_name]
+
+      if @options[:log_group_name].include?("aws/lambda") || @options[:log_group_name].include?(Jets.project_namespace)
+        @options[:log_group_name]
+      else
+        # IE: hard_job-dig => /aws/lambda/demo-dev-hard_job-dig
+        "/aws/lambda/#{Jets.project_namespace}-#{@options[:log_group_name]}"
+      end
+    end
+  end
+end

data/lib/jets/commands/new/new_command.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Jets
+  module Command
+    class NewCommand < Base # :nodoc:
+      no_commands do
+        def help
+          Jets::Command.invoke :application, [ "--help" ]
+        end
+      end
+
+      def perform(*)
+        say "Can't initialize a new Jets application within the directory of another, please change to a non-Jets directory first.\n"
+        say "Type 'jets' for help."
+        exit 1
+      end
+    end
+  end
+end

data/lib/jets/commands/notes/notes_command.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Jets
+  module Command
+    class NotesCommand < Base # :nodoc:
+      class_option :annotations, aliases: "-a", desc: "Filter by specific annotations, e.g. Foobar TODO", type: :array
+
+      def perform(*)
+        require_application_and_environment!
+
+        # lazy require so Rails const is only defined when using notes
+        require "rails/source_annotation_extractor"
+
+        display_annotations
+      end
+
+      private
+        def display_annotations
+          annotations = options[:annotations] || Rails::SourceAnnotationExtractor::Annotation.tags
+          tag = (annotations.length > 1)
+
+          Rails::SourceAnnotationExtractor.enumerate annotations.join("|"), tag: tag, dirs: directories
+        end
+
+        def directories
+          Rails::SourceAnnotationExtractor::Annotation.directories
+        end
+    end
+  end
+end

data/lib/jets/commands/plugin/plugin_command.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Jets
+  module Command
+    class PluginCommand < Base # :nodoc:
+      hide_command!
+
+      def help
+        run_plugin_generator %w( --help )
+      end
+
+      def self.banner(*) # :nodoc:
+        "#{executable} new [options]"
+      end
+
+      class_option :rc, type: :string, default: File.join("~", ".jetsrc"),
+        desc: "Initialize the plugin command with previous defaults. Uses .jetsrc in your home directory by default."
+
+      class_option :no_rc, desc: "Skip evaluating .jetsrc."
+
+      def perform(type = nil, *plugin_args)
+        plugin_args << "--help" unless type == "new"
+
+        unless options.key?("no_rc") # Thor's not so indifferent access hash.
+          jetsrc = File.expand_path(options[:rc])
+
+          if File.exist?(jetsrc)
+            extra_args = File.read(jetsrc).split(/\n+/).flat_map(&:split)
+            say "Using #{extra_args.join(" ")} from #{jetsrc}"
+            plugin_args.insert(1, *extra_args)
+          end
+        end
+
+        run_plugin_generator plugin_args
+      end
+
+      private
+        def run_plugin_generator(plugin_args)
+          require "jets/generators"
+          require "jets/generators/jets/plugin/plugin_generator"
+          Jets::Generators::PluginGenerator.start plugin_args
+        end
+    end
+  end
+end

data/lib/jets/commands/projects/projects_command.rb

@@ -0,0 +1,30 @@
+module Jets::Command
+  class ProjectsCommand < Base # :nodoc:
+    desc "projects", "List deployed projects"
+    long_desc Help.text(:projects)
+    paging_options.call
+    def perform
+      no_token_exit!
+      resp = Jets::Api::Project.list(paging_params)
+      check_for_error_message!(resp)
+
+      data = resp["data"]
+      if data.empty?
+        $stderr.puts "No projects deployed yet."
+      else
+        show_items(data)
+      end
+    rescue Jets::Api::RequestError => e
+      puts "WARNING: Unable to list projects. #{e.class}: #{e.message}"
+    end
+
+  private
+    def show_items(items)
+      presenter = CliFormat::Presenter.new
+      presenter.header = ["Name"]
+      items.each do |item|
+        puts item["name"]
+      end
+    end
+  end
+end

data/lib/jets/commands/rake/rake_command.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Jets
+  module Command
+    class RakeCommand < Base # :nodoc:
+      extend Jets::Command::Actions
+
+      namespace "rake"
+
+      class << self
+        def printing_commands
+          formatted_rake_tasks.map(&:first)
+        end
+
+        def perform(task, args, config)
+          Jets.boot
+          require_rake
+          # Wonder if there's a better way to do this.
+          # We do not use the rask_task block to require dummy/rails
+          # because don't want Rails const to be defined for other rake tasks
+          # like jets:assets:precompile. We want the Rails const to be defined
+          # lazily at runtime only for db rake tasks.
+          require "jets/overrides/dummy/rails" if task.include?("db:")
+
+          Rake.with_application do |rake|
+            rake.init("jets", [task, *args])
+            rake.load_rakefile
+            if Jets.respond_to?(:root)
+              rake.options.suppress_backtrace_pattern = /\A(?!#{Regexp.quote(Jets.root.to_s)})/
+            end
+            rake.standard_exception_handling { rake.top_level }
+          end
+        end
+
+        private
+          def rake_tasks
+            require_rake
+
+            return @rake_tasks if defined?(@rake_tasks)
+
+            require_application!
+
+            Rake::TaskManager.record_task_metadata = true
+            Rake.application.instance_variable_set(:@name, "jets")
+            load_tasks
+            @rake_tasks = Rake.application.tasks.select(&:comment)
+          end
+
+          def formatted_rake_tasks
+            rake_tasks.map { |t| [ t.name_with_args, t.comment ] }
+          end
+
+          def require_rake
+            require "rake" # Defer booting Rake until we know it's needed.
+          end
+      end
+    end
+  end
+end

data/lib/jets/commands/releases/releases_command.rb

@@ -0,0 +1,72 @@
+module Jets::Command
+  class ReleasesCommand < Base # :nodoc:
+    desc "history", "List deploy history"
+    long_desc Help.text(:history)
+    paging_options(order: 'desc').call
+    def perform
+      Release.new(options.merge(paging_params)).list
+    end
+  end
+
+  class Release
+    include Jets::Command::ApiHelpers
+    def initialize(options={})
+      @options = options
+    end
+
+    def list
+      no_token_exit!
+      resp = Jets::Api::Stack.retrieve(:current)
+      if resp["error"] == "not_found"
+        puts "No release history. Stack not found: #{Jets.project_namespace}"
+        # Return early and avoid calling Jets::Api::Release.list if stack not found
+        # Note: Jets::Api::Release.list also checks for no stack found
+        return
+      end
+
+      name = "#{resp['name']} #{resp['location']}"
+      resp = Jets::Api::Release.list(@options)
+      check_for_error_message!(resp) # can also return "Stack not found #{name}" message
+      data = resp["data"]
+      if data.empty?
+        $stderr.puts "No releases found for stack: #{name}"
+      else
+        $stderr.puts "Releases for stack: #{name}"
+        show_items(data)
+      end
+    rescue Jets::Api::RequestError => e
+      puts "ERROR: Unable to list history. #{e.class}: #{e.message}"
+    end
+
+    def show_items(items)
+      presenter = CliFormat::Presenter.new
+      presenter.header = ["Version", "Status", "Released At", "Message"]
+      items.each do |item|
+        version = item["version"]
+        status = item["stack_status"]
+        released_at = item["pretty_created_at"] || item["created_at"]
+        message = item["message"] || "Deployed"
+
+        row = [version, status, format_time(released_at), message]
+        presenter.rows << row
+      end
+      presenter.show
+    end
+
+    def format_time(string)
+      if string.include?("ago") # IE: 5 minutes ago
+        string
+      else
+        time = Time.parse(string)
+        time.in_time_zone(Time.zone)
+      end
+    end
+
+    def get(version)
+      resp = Jets::Api::Release.retrieve(version)
+      check_for_error_message!(resp)
+    rescue Jets::Api::RequestError => e
+      puts "ERROR: Unable to get history. #{e.class}: #{e.message}"
+    end
+  end
+end

data/lib/jets/commands/rollback/rollback_command.rb

@@ -0,0 +1,41 @@
+require "jets/commands/releases/releases_command"
+
+module Jets::Command
+  class RollbackCommand < Base # :nodoc:
+    desc "rollback", "Rollback to a previous release"
+    long_desc Help.text(:rollback)
+    def perform(version=nil)
+      Rollback.new(options.merge(version: version)).run
+    end
+  end
+
+  class Rollback
+    include Jets::Command::ApiHelpers
+    attr_reader :version
+    def initialize(options={})
+      @options = options
+      @version = options[:version]
+      # Handle more gracefully than the way Jets does it currently
+      if @version.nil?
+        puts <<~EOL
+          ERROR: version required
+          Usage: jets rollback VERSION
+        EOL
+        exit 1
+      end
+    end
+
+    def run
+      no_token_exit!
+      Jets.boot
+      payload = Release.new(@options).get(version)
+      check_for_error_message!(payload)
+
+      puts "Rolling back to version #{version}"
+      # Download previous cfn templates
+      Jets::Cfn::Download.new.download_templates(version)
+      # Run cloudformation update
+      Jets::Cfn::Ship.new(@options.merge(rollback_version: version)).run # also creates the Jets Api deployment record
+    end
+  end
+end

data/lib/jets/commands/routes/routes_command.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "cli-format"
+
+module Jets::Command
+  class RoutesCommand < Base # :nodoc:
+    option :controller, aliases: :c, desc: "Filter by a specific controller, e.g. PostsController or Admin::PostsController"
+    option :format, default: "table", desc: "Output formats: #{CliFormat.formats.join(', ')}" # csv, equal, json, space, table, tab
+    option :grep, aliases: :g, desc: "Grep routes by a specific pattern"
+    option :reject, aliases: :r, desc: "Reject filter routes by a specific pattern"
+
+    desc "routes", "Print out your application routes"
+    long_desc Help.text(:routes)
+    def perform(*)
+      require_application_and_environment!
+      Jets::Router::Help.new(options).print
+    end
+  end
+end

data/lib/jets/commands/runner/runner_command.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Jets
+  module Command
+    class RunnerCommand < Base # :nodoc:
+      include EnvironmentArgument
+
+      self.environment_desc = "The environment for the runner to operate under (test/development/production)"
+
+      no_commands do
+        def help
+          super
+          say self.class.desc
+        end
+      end
+
+      def self.banner(*)
+        "#{super} [<'Some.ruby(code)'> | <filename.rb> | -]"
+      end
+
+      desc "runner", "Run Ruby code in the context of Jets app non-interactively"
+      long_desc Help.text(:runner)
+      def perform(code_or_file = nil, *command_argv)
+        extract_environment_option_from_argument
+
+        unless code_or_file
+          help
+          exit 1
+        end
+
+        require_application_and_environment!
+        Jets.application.load_runner
+
+        args = command_argv
+
+        ARGV.replace(command_argv)
+
+        if code_or_file == "-"
+          eval($stdin.read, TOPLEVEL_BINDING, "stdin")
+        elsif File.exist?(code_or_file)
+          expanded_file_path = File.expand_path code_or_file
+          $0 = expanded_file_path
+          Kernel.load expanded_file_path
+        else
+          begin
+            # Jets changed TOPLEVEL_BINDING to binding to have access to args
+            # To keep args working https://github.com/boltops-tools/jets/pull/669
+            eval(code_or_file, binding, __FILE__, __LINE__)
+          rescue SyntaxError, NameError => e
+            error "Please specify a valid ruby command or the path of a script to run."
+            error "Run '#{self.class.executable} -h' for help."
+            error ""
+            error e
+            exit 1
+          end
+        end
+      end
+    end
+  end
+end