jets 3.1.0 → 5.0.10

data/lib/jets/cli.rb

@@ -1,208 +1,33 @@
-require "thor"
-
-class Jets::CLI
-  def self.start(given_args=ARGV)
-    new(given_args).start
-  end
-
-  def self.thor_tasks
-    Jets::Commands::Base.namespaced_commands
-  end
-
-  def initialize(given_args=ARGV, **config)
-    @given_args = given_args.dup
-    @config = config
-  end
-
-  def start
-    # Needs to be at the beginning to avoid boot_jets which causes some load errors
-    if version_requested?
-      puts Jets.version
-      return
-    end
-
-    # Need to boot jets at this point for commands like: jets routes, deploy, console, etc to work
-    boot_jets
-    command_class = lookup(full_command)
-    if command_class
-      command_class.perform(full_command, thor_args)
-    else
-      main_help
-    end
-  end
-
-  # The commands new and help do not call Jets.boot. Main reason is that Jets.boot should be run in a Jets project.
-  #
-  #   * jets new - need to generate a project outside a project folder.
-  #   * jets help - don't need to be in a project folder general help.
-  #
-  # When you are inside a project folder though, more help commands are available and displayed.
-  #
-  def boot_jets
-    set_jets_env_from_cli_arg!
-    command = thor_args.first
-    unless %w[new help].include?(command)
-      Jets::Turbo.new.charge # handles Afterburner mode
-      Jets.boot
-    end
-  end
-
-  def version_requested?
-    #   jets --version
-    #   jets -v
-    version_flags = ["--version", "-v"]
-    @given_args.length == 1 && !(@given_args & version_flags).empty?
-  end
-
-  # Adjust JETS_ENV before boot_jets is called for the `jets deploy` command.  Must do this early in the process
-  # before Jets.boot because because `bundler_require` is called as part of the bootup process. It sets the Jets.env
-  # to whatever the JETS_ENV is at the time to require the right bundler group.
-  #
-  # Defaults to development when not set.
-  def set_jets_env_from_cli_arg!
-    # Pretty tricky, we need to use the raw @given_args as thor_args eventually calls Commands::Base#eager_load!
-    # which uses Jets.env before we get a chance to override ENV['JETS_ENV']
-    command, env = @given_args[0..1]
-    return unless %w[deploy delete].include?(command)
-    env = nil if env&.starts_with?('-')
-    return unless env
-    ENV['JETS_ENV'] = env ? env : 'development'
-  end
-
-  # thor_args normalized the args Array to work with our Thor command
-  # subclasses.
-  # 1. The namespace is stripe
-  # 2. Help is shifted in front if a help flag is detected
-  def thor_args
-    args = @given_args.clone
-
-    # jets generate is a special command requires doesn't puts out the help menu automatically when
-    # `jets generate` is called without additional args.  We'll take it over early and fix it here.
-    generate = full_command == "generate"
-
-    if generate && ((args.size == 1 || help_flags.include?(args.last)) || args.size == 2)
-      puts Jets::Generator.help
-      exit
-    end
-
-    help_args = args & help_flags
-    unless help_args.empty?
-      # Allow using help flags at the end of the command to trigger help menu
-      args -= help_flags # remove "help" and help flags from args
-      args[0] = meth # first command will always be the meth now since
-        # we removed the help flags
-      args.unshift("help")
-      args.compact!
-      return args
-    end
-
-    # reassigns the command without the namespace if reached here
-    args[0] = meth
-    args.compact
-  end
-
-  def meth
-    return nil unless full_command
-
-    if full_command.include?(':')
-      full_command.split(':').pop
-    else
-      full_command
-    end
-  end
-
-  ALIASES = {
-    "g"  => "generate",
-    "c"  => "console",
-    "s"  => "server",
-    "db" => "dbconsole",
-  }
-  def full_command
-    # Removes any args that starts with -, those are option args.
-    # Also remove "help" flag.
-    args = @given_args.reject {|o| o =~ /^-/ } - help_flags
-    command = args[0] # first argument should always be the command
-    command = ALIASES[command] || command
-    Jets::Commands::Base.autocomplete(command)
-  end
-
-  # 1. look up Thor tasks
-  # 2. look up Rake tasks
-  # 3. help menu with all commands when both Thor and Rake tasks are not found
-  def lookup(full_command)
-    thor_task_found = Jets::Commands::Base.namespaced_commands.include?(full_command)
-    if thor_task_found
-      return Jets::Commands::Base.klass_from_namespace(namespace)
-    end
-
-    return unless jets_project?
-    rake_task_found = Jets::Commands::RakeCommand.namespaced_commands.include?(full_command)
-    if rake_task_found
-      return Jets::Commands::RakeCommand
-    end
-  end
-
-  def jets_project?
-    File.exist?("config/application.rb")
-  end
-
-  # ["-h", "-?", "--help", "-D", "help"]
-  def help_flags
-    Thor::HELP_MAPPINGS + ["help"]
-  end
-
-  def namespace
-    return nil unless full_command
-
-    if full_command.include?(':')
-      words = full_command.split(':')
-      words.pop
-      words.join(':')
-    end
-  end
-
-  def main_help
-    shell = Thor::Shell::Basic.new
-    shell.say "Commands:"
-    shell.print_table(thor_list, :indent => 2, :truncate => true)
-
-    if jets_project? && !rake_list.empty?
-      shell.say "\nCommands via rake:"
-      shell.print_table(rake_list, :indent => 2, :truncate => true)
-    end
-
-    shell.say "\n"
-    shell.say main_help_body
-  end
-
-  def thor_list
-    Jets::Commands::Base.help_list(show_all_tasks)
-  end
-
-  def rake_list
-    list = Jets::Commands::RakeCommand.formatted_rake_tasks(show_all_tasks)
-    list.map do |array|
-      array[0] = "jets #{array[0]}"
-      array
-    end
-  end
-
-  def show_all_tasks
-    @given_args.include?("--all") || @given_args.include?("-A")
-  end
+# frozen_string_literal: true
+
+require "jets/app_loader"
+
+# If we are inside a Jets application this method performs an exec and thus
+# the rest of this script is not run.
+# exec_app either runs bin/jets or an inline version of it.
+Jets::AppLoader.exec_app
+
+# Allow running jets with local source code when bin/jets does not exist
+# Useful for development: jets build
+# Also allows jets to work without a bin/jets file in the project.
+if File.exist?("config/application.rb")
+  APP_PATH = File.expand_path("config/application", Dir.pwd)
+  require "jets"
+  require "jets/commands"
+  return
+end
 
-  def main_help_body
-    <<-EOL
-Add -h to any of the commands for more help.  Examples:
+# The rest of the script runs if outside of Jets application. IE:
+# jets new demo
 
-  jets call -h
-  jets routes -h
-  jets deploy -h
-  jets status -h
-  jets dynamodb:create -h
-  jets db:create -h
+require "jets/ruby_version_check"
+Signal.trap("INT") { puts; exit(1) }
 
-EOL
-  end
+require "jets/command"
 
+if ARGV.first == "plugin"
+  ARGV.shift
+  Jets::Command.invoke :plugin, ARGV
+else
+  Jets::Command.invoke :application, ARGV
 end

data/lib/jets/command/actions.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Jets
+  module Command
+    module Actions
+      # Change to the application's path if there is no <tt>config.ru</tt> file in current directory.
+      # This allows us to run <tt>jets server</tt> from other directories, but still get
+      # the main <tt>config.ru</tt> and properly set the <tt>tmp</tt> directory.
+      def set_application_directory!
+        Dir.chdir(File.expand_path("../..", APP_PATH)) unless File.exist?(File.expand_path("config.ru"))
+      end
+
+      def require_application_and_environment!
+        Jets.boot
+      end
+
+      def require_application!
+        require ENGINE_PATH if defined?(ENGINE_PATH)
+
+        if defined?(APP_PATH)
+          require APP_PATH
+        end
+      end
+
+      if defined?(ENGINE_PATH)
+        def load_tasks
+          Rake.application.init("jets")
+          Rake.application.load_rakefile
+        end
+
+        def load_generators
+          engine = ::Jets::Engine.find(ENGINE_ROOT)
+          Jets::Generators.namespace = engine.railtie_namespace
+          engine.load_generators
+        end
+      else
+        def load_tasks
+          Jets.boot # hack
+          Jets.application.load_tasks
+        end
+
+        def load_generators
+          Jets.application.load_generators
+        end
+      end
+    end
+  end
+end
+

data/lib/jets/command/api_helpers.rb

@@ -0,0 +1,42 @@
+module Jets
+  module Command
+    module ApiHelpers # :nodoc:
+      extend ActiveSupport::Concern
+
+      include Jets::Api
+
+      def no_token_exit!
+        return if Jets::Api.token
+        puts "ERROR: This command requires Jets Api".color(:red)
+        puts "Please run `jets configure` first"
+        exit 1
+      end
+
+      def check_for_error_message!(resp)
+        # IE: {"error":"Invalid token. Please check your token in ~/.jets/config.yml"}
+        if resp && resp["error"]
+          $stderr.puts "ERROR: #{resp["error"]}"
+          exit 1
+        end
+        resp
+      end
+
+      def paging_params
+        Jets.boot
+        params = {}
+        params[:page] = @options[:page] if @options[:page]
+        params[:order] = @options[:order] if @options[:order]
+        params
+      end
+
+      module ClassMethods
+        def paging_options(defaults={})
+          Proc.new do
+            option :page, aliases: :p, type: :numeric, desc: "Page number"
+            option :order, default: defaults[:order] || 'asc', desc: "Order: asc or desc"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jets/command/aws_helpers.rb

@@ -0,0 +1,26 @@
+module Jets
+  module Command
+    module AwsHelpers # :nodoc:
+      extend ActiveSupport::Concern
+
+      include Jets::AwsServices
+
+      def first_run?
+        return false if ENV['JETS_TEMPLATES']
+        !stack_exists?(Jets::Names.parent_stack_name)
+      end
+
+      def find_stack(stack_name)
+        resp = cfn.describe_stacks(stack_name: stack_name)
+        resp.stacks.first
+      rescue Aws::CloudFormation::Errors::ValidationError => e
+        # example: Stack with id demo-dev does not exist
+        if e.message =~ /Stack with/ && e.message =~ /does not exist/
+          nil
+        else
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/jets/command/base.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+require "thor"
+require "erb"
+
+require "active_support/core_ext/string/filters"
+require "active_support/core_ext/string/inflections"
+
+require "jets/command/actions"
+
+module Jets
+  module Command
+    class Base < Thor
+      extend Memoist
+
+      class Error < Thor::Error # :nodoc:
+      end
+
+      class CorrectableError < Error # :nodoc:
+        attr_reader :key, :options
+
+        def initialize(message, key, options)
+          @key     = key
+          @options = options
+          super(message)
+        end
+
+        if defined?(DidYouMean::SpellChecker) && defined?(DidYouMean::Correctable)
+          include DidYouMean::Correctable
+
+          def corrections
+            @corrections ||= DidYouMean::SpellChecker.new(dictionary: options).correct(key)
+          end
+        end
+      end
+
+      include Actions
+      include AwsHelpers
+      include ApiHelpers
+
+      no_commands do
+        cattr_accessor :full_namespace
+      end
+
+      class << self
+        def long_desc(long_description, options = {})
+          options[:wrap] = false
+          super
+        end
+
+        def exit_on_failure? # :nodoc:
+          false
+        end
+
+        # Returns true when the app is a Jets engine.
+        def engine?
+          defined?(ENGINE_ROOT)
+        end
+
+        # Tries to get the description from a USAGE file one folder above the command
+        # root.
+        def desc(usage = nil, description = nil, options = {})
+          if usage
+            super
+          else
+            @desc ||= ERB.new(File.read(usage_path), trim_mode: "-").result(binding) if usage_path
+          end
+        end
+
+        # Convenience method to get the namespace from the class name. It's the
+        # same as Thor default except that the Command at the end of the class
+        # is removed.
+        def namespace(name = nil)
+          if name
+            super
+          else
+            @namespace ||= super.chomp("_command").sub(/:command:/, ":")
+          end
+        end
+
+        # Convenience method to hide this command from the available ones when
+        # running jets command.
+        def hide_command!
+          Jets::Command.hidden_commands << self
+        end
+
+        def inherited(base) # :nodoc:
+          super
+
+          if base.name && !base.name.end_with?("Base")
+            Jets::Command.subclasses << base
+          end
+        end
+
+        def perform(full_namespace, command, args, config) # :nodoc:
+          if Jets::Command::HELP_MAPPINGS.include?(args.first)
+            command, args = "help", []
+            self.full_namespace = full_namespace # store for help. clean:log => log
+          end
+
+          dispatch(command, args.dup, nil, config)
+        rescue Thor::InvocationError => e
+          puts e.message.color(:red) # message already has ERROR prefix
+          self.full_namespace = full_namespace # store for help. clean:log => log
+          dispatch("help", [], nil, config)
+          exit 1
+        end
+
+        def printing_commands
+          namespaced_commands
+        end
+
+        def executable
+          "jets #{full_namespace || command_name}"
+        end
+
+        # Use Jets' default banner.
+        def banner(*)
+          command_name = full_namespace ? full_namespace.split(':').last : command_name
+          command = commands[command_name]
+          options_arg = '[options]' unless command && command.options.empty?
+          output = "#{executable} #{arguments.map(&:usage).join(' ')} #{options_arg}".squish
+          "  #{output}" # add 2 more spaces in front
+        end
+
+        # Sets the base_name taking into account the current class namespace.
+        #
+        #   Jets::Command::TestCommand.base_name # => 'jets'
+        def base_name
+          @base_name ||= if base = name.to_s.split("::").first
+            base.underscore
+          end
+        end
+
+        # Return command name without namespaces.
+        #
+        #   Jets::Command::TestCommand.command_name # => 'test'
+        def command_name
+          @command_name ||= if command = name.to_s.split("::").last
+            command.chomp!("Command")
+            command.underscore
+          end
+        end
+
+        # Path to lookup a USAGE description in a file.
+        def usage_path
+          if default_command_root
+            path = File.join(default_command_root, "USAGE")
+            path if File.exist?(path)
+          end
+        end
+
+        # Default file root to place extra files a command might need, placed
+        # one folder above the command file.
+        #
+        # For a Jets::Command::TestCommand placed in <tt>jets/command/test_command.rb</tt>
+        # would return <tt>jets/test</tt>.
+        def default_command_root
+          path = File.expand_path(relative_command_path, __dir__)
+          path if File.exist?(path)
+        end
+
+        private
+          # Allow the command method to be called perform.
+          def create_command(meth)
+            if meth == "perform"
+              alias_method command_name, meth
+            else
+              # Prevent exception about command without usage.
+              # Some commands define their documentation differently.
+              @usage ||= ""
+              @desc  ||= ""
+
+              super
+            end
+          end
+
+          def command_root_namespace
+            (namespace.split(":") - %w(jets)).join(":")
+          end
+
+          def relative_command_path
+            File.join("../commands", *command_root_namespace.split(":"))
+          end
+
+          def namespaced_commands
+            commands.keys.map do |key|
+              if command_root_namespace.match?(/(\A|:)#{key}\z/)
+                command_root_namespace
+              else
+                "#{command_root_namespace}:#{key}"
+              end
+            end
+          end
+      end
+
+      def help
+        if full_namespace = self.class.full_namespace
+          command_name = full_namespace.split(':').last # clean:log => log
+          self.class.command_help(shell, command_name)
+        elsif command_name = self.class.command_name
+          self.class.command_help(shell, command_name)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/jets/command/behavior.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "active_support"
+
+module Jets
+  module Command
+    module Behavior # :nodoc:
+      extend ActiveSupport::Concern
+
+      class_methods do
+        # Remove the color from output.
+        def no_color!
+          Thor::Base.shell = Thor::Shell::Basic
+        end
+
+        # Track all command subclasses.
+        def subclasses
+          @subclasses ||= []
+        end
+
+        private
+          # Prints a list of generators.
+          def print_list(base, namespaces)
+            return if namespaces.empty?
+            puts "#{base.camelize}:"
+
+            namespaces.each do |namespace|
+              puts("  #{namespace}")
+            end
+
+            puts
+          end
+
+          # Receives namespaces in an array and tries to find matching generators
+          # in the load path.
+          def lookup(namespaces)
+            paths = namespaces_to_paths(namespaces)
+            paths.each do |raw_path|
+              lookup_paths.each do |base|
+                path = "#{base}/#{raw_path}_#{command_type}"
+
+                begin
+                  require path
+                  return
+                rescue LoadError => e
+                  raise unless /#{Regexp.escape(path)}$/.match?(e.message)
+                rescue Exception => e
+                  warn "[WARNING] Could not load #{command_type} #{path.inspect}. Error: #{e.message}.\n#{e.backtrace.join("\n")}"
+                end
+              end
+            end
+          end
+
+          # This will try to load any command in the load path to show in help.
+          def lookup!
+            $LOAD_PATH.each do |base|
+              Dir[File.join(base, *file_lookup_paths)].each do |path|
+                path = path.delete_prefix("#{base}/")
+                require path
+              rescue Exception
+                # No problem
+              end
+            end
+          end
+
+          # Convert namespaces to paths by replacing ":" for "/" and adding
+          # an extra lookup. For example, "jets:model" should be searched
+          # in both: "jets/model/model_generator" and "jets/model_generator".
+          def namespaces_to_paths(namespaces)
+            paths = []
+            namespaces.each do |namespace|
+              pieces = namespace.split(":")
+              path = pieces.join("/")
+              paths << "#{path}/#{pieces.last}"
+              paths << path
+            end
+            paths.uniq!
+            paths
+          end
+      end
+    end
+  end
+end

data/lib/jets/command/environment_argument.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/core_ext/class/attribute"
+
+module Jets
+  module Command
+    module EnvironmentArgument # :nodoc:
+      extend ActiveSupport::Concern
+
+      included do
+        no_commands do
+          class_attribute :environment_desc, default: "Specifies the environment to run this #{self.command_name} under (test/development/production)."
+        end
+        class_option :environment, aliases: "-e", type: :string, desc: environment_desc
+      end
+
+      private
+        def extract_environment_option_from_argument(default_environment: Jets::Command.environment)
+          if options[:environment]
+            self.options = options.merge(environment: acceptable_environment(options[:environment]))
+          else
+            self.options = options.merge(environment: default_environment)
+          end
+          # JETS_ENV needs to be set before config/application is required.
+          ENV["JETS_ENV"] = options[:environment]
+        end
+
+        def acceptable_environment(env = nil)
+          if available_environments.include? env
+            env
+          else
+            %w( production development test ).detect { |e| /^#{env}/.match?(e) } || env
+          end
+        end
+
+        def available_environments
+          Dir["config/environments/*.rb"].map { |fname| File.basename(fname, ".*") }
+        end
+    end
+  end
+end