jets 5.0.14 → 6.0.0.beta1

data/lib/jets/commands/encrypted/USAGE

@@ -1,46 +0,0 @@
-## Storing Encrypted Files in Source Control
-
-The Jets `encrypted` commands provide access to encrypted files or configurations.
-See the `Jets.application.encrypted` documentation for using them in your app.
-
-This is a more generalized concept of `jets credentials`.
-
-## Encryption Keys
-
-By default, Jets looks for the encryption key in `config/master.key` or
-`ENV["JETS_MASTER_KEY"]`, but that lookup can be overridden with `--key`:
-
-    jets encrypted:edit config/encrypted_file.yml.enc --key config/encrypted_file.key
-
-Don't commit the key! Add it to your source control's ignore file. If you use
-Git, Jets handles this for you.
-
-## Editing Files
-
-To edit or create an encrypted file use:
-
-    jets encrypted:edit config/encrypted_file.yml.enc
-
-This opens a temporary file in `$EDITOR` with the decrypted contents for editing.
-
-## Viewing Files
-
-To print the decrypted contents of an encrypted file use:
-
-    jets encrypted:show config/encrypted_file.yml.enc
-
-## Access in App
-
-Let's say you have encrypted like so:
-
-    ❯ jets encrypted:show config/encrypted_file.yml.enc
-    cloud:
-      foo: bar
-
-You can access them in the app like so:
-
-    $ jets console
-    > file = ActiveSupport::EncryptedFile.new(content_path: "./config/encrypted_file.yml.enc", key_path: "./config/master.key", env_key: Jets.env, raise_if_missing_key: true)
-    > YAML.load(file.read)
-    => {"cloud"=>{"foo"=>"bar"}}
-    >

data/lib/jets/commands/encrypted/encrypted_command.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-require "pathname"
-require "active_support"
-require "jets/command/helpers/editor"
-
-module Jets
-  module Command
-    class EncryptedCommand < Jets::Command::Base # :nodoc:
-      include Helpers::Editor
-
-      class_option :key, aliases: "-k", type: :string,
-        default: "config/master.key", desc: "The Jets.root relative path to the encryption key"
-
-      no_commands do
-        def help
-          say "Usage:\n  #{self.class.banner}"
-          say ""
-          say self.class.desc
-        end
-      end
-
-      def edit(file_path)
-        require_application!
-        encrypted = Jets.application.encrypted(file_path, key_path: options[:key])
-
-        ensure_editor_available(command: "bin/jets encrypted:edit") || (return)
-        ensure_encryption_key_has_been_added(options[:key]) if encrypted.key.nil?
-        ensure_encrypted_file_has_been_added(file_path, options[:key])
-
-        catch_editing_exceptions do
-          change_encrypted_file_in_system_editor(file_path, options[:key])
-        end
-
-        say "File encrypted and saved."
-      rescue ActiveSupport::MessageEncryptor::InvalidMessage
-        say "Couldn't decrypt #{file_path}. Perhaps you passed the wrong key?"
-      end
-
-      def show(file_path)
-        require_application!
-        encrypted = Jets.application.encrypted(file_path, key_path: options[:key])
-
-        say encrypted.read.presence || missing_encrypted_message(key: encrypted.key, key_path: options[:key], file_path: file_path)
-      end
-
-      private
-        def ensure_encryption_key_has_been_added(key_path)
-          encryption_key_file_generator.add_key_file(key_path)
-          encryption_key_file_generator.ignore_key_file(key_path)
-        end
-
-        def ensure_encrypted_file_has_been_added(file_path, key_path)
-          encrypted_file_generator.add_encrypted_file_silently(file_path, key_path)
-        end
-
-        def change_encrypted_file_in_system_editor(file_path, key_path)
-          Jets.application.encrypted(file_path, key_path: key_path).change do |tmp_path|
-            system("#{ENV["EDITOR"]} #{tmp_path}")
-          end
-        end
-
-
-        def encryption_key_file_generator
-          require "rails/generators"
-          require "rails/generators/rails/encryption_key_file/encryption_key_file_generator"
-
-          Rails::Generators::EncryptionKeyFileGenerator.new
-        end
-
-        def encrypted_file_generator
-          require "rails/generators"
-          require "rails/generators/rails/encrypted_file/encrypted_file_generator"
-
-          Rails::Generators::EncryptedFileGenerator.new
-        end
-
-        def missing_encrypted_message(key:, key_path:, file_path:)
-          if key.nil?
-            "Missing '#{key_path}' to decrypt data. See `bin/jets encrypted:help`"
-          else
-            "File '#{file_path}' does not exist. Use `bin/jets encrypted:edit #{file_path}` to change that."
-          end
-        end
-    end
-  end
-end

data/lib/jets/commands/gems/gems_command.rb

@@ -1,14 +0,0 @@
-module Jets::Command
-  class GemsCommand < Base
-    desc "check", "Check if precompiled Lambda gems are available"
-    long_desc Help.text("gems:check")
-    option :verbose, type: :boolean, desc: "Verbose mode"
-    def check
-      Jets.boot
-      check = Jets::Api::Gems::Check.new(@options)
-      check.run! # exits early if missing gems found
-      # If reach here, means all gems are ok.
-      puts "Congrats! All gems are available in as precompiled Lambda gems 👍"
-    end
-  end
-end

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

@@ -1,95 +0,0 @@
-# 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

@@ -1,20 +0,0 @@
-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

@@ -1,15 +0,0 @@
-# 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

@@ -1,19 +0,0 @@
-# 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

@@ -1,45 +0,0 @@
-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

@@ -1,19 +0,0 @@
-# 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

@@ -1,30 +0,0 @@
-# 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

@@ -1,45 +0,0 @@
-# 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

@@ -1,30 +0,0 @@
-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

@@ -1,59 +0,0 @@
-# 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

@@ -1,124 +0,0 @@
-module Jets::Command
-  class ReleasesCommand < Base # :nodoc:
-    desc "releases", "List releases"
-    long_desc Help.text(:releases)
-    paging_options(order: 'desc').call
-    option :sha, desc: "Show release git sha"
-    def perform
-      Release.new(options.merge(paging_params)).list
-    end
-
-    desc "releases:info", "View detailed information for a release"
-    long_desc Help.text(:info)
-    def info(version=nil)
-      if version.nil?
-        puts "ERROR: Must provide a version".color(:red)
-        puts <<~EOL
-          Example:
-
-            jets releases:info 3
-        EOL
-        exit 1
-      end
-      Release.new(options.merge(version: version)).show
-    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 releases. #{e.class}: #{e.message}"
-    end
-
-    def show_items(items)
-      presenter = CliFormat::Presenter.new
-      header = ["Version", "Status", "Released At", "Message"]
-      header << "Git Sha" if @options[:sha]
-      presenter.header = header
-      items.each do |item|
-        version = item["version"]
-        status = item["stack_status"]
-        released_at = item["pretty_created_at"] || item["created_at"]
-        message = item["message"] || "Deployed"
-        message = message[0..50]
-
-        row = [version, status, format_time(released_at), message]
-        if @options[:sha]
-          sha = item["git_sha"].to_s[0..7] if item["git_sha"]
-          row << sha
-        end
-        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 release. #{e.class}: #{e.message}"
-    end
-
-    def show
-      release = get(@options[:version])
-      release_at = release['pretty_created_at'] || release['created_at']
-
-      data = [
-        ["Version", release['version']],
-        ["Status", release['stack_status']],
-        ["Released At", format_time(release_at)],
-        ["Message", release['message']],
-        ["User", release['deploy_user']],
-        ["Jets Env", release['jets_env']],
-        ["Jets Extra", release['jets_extra']],
-        ["Jets Version", release['jets_version']],
-        ["Ruby Version", release['ruby_version']],
-        ["Region", release['region']],
-        ["Git Branch", release['git_branch']],
-        ["Git Sha", release['git_sha']],
-        ["Git Url", release['git_url']],
-        ["Git Message", release['git_message']],
-      ]
-      column1_width = data.map { |row| row[1].nil? ? 0 : row[0].to_s.length }.max
-      column2_width = data.map { |row| row[1].nil? ? 0 : row[1].to_s.length }.max
-
-      puts Jets.project_namespace.color(:green)
-      data.each do |row|
-        puts "#{row[0].ljust(column1_width)}   #{row[1]}" unless row[1].nil?
-      end
-    end
-  end
-end