tomo 0.1.0

data/lib/tomo/cli/rules/argument.rb

@@ -0,0 +1,42 @@
+class Tomo::CLI::Rules
+  class Argument
+    def initialize(label, multiple: false, required: false, values_proc:)
+      @label = label
+      @multiple = multiple
+      @required = required
+      @values_proc = values_proc
+    end
+
+    def match(arg, literal: false)
+      1 if literal || !arg.start_with?("-")
+    end
+
+    def process(arg, state:)
+      state.parsed_arg(arg)
+    end
+
+    def candidates(literal: false, state:)
+      values(state).reject { |val| literal && val.start_with?("-") }
+    end
+
+    def required?
+      @required
+    end
+
+    def multiple?
+      @multiple
+    end
+
+    def to_s
+      @label
+    end
+
+    private
+
+    attr_reader :values_proc
+
+    def values(state)
+      values_proc.call(*state.args, state.options)
+    end
+  end
+end

data/lib/tomo/cli/rules/switch.rb

@@ -0,0 +1,43 @@
+class Tomo::CLI::Rules
+  class Switch
+    def initialize(key,
+                   *switches,
+                   required: false,
+                   callback_proc:,
+                   &convert_proc)
+      @key = key
+      @switches = switches
+      @callback_proc = callback_proc
+      @convert_proc = convert_proc || proc { true }
+      @required = required
+    end
+
+    def match(arg, literal: false)
+      return nil if literal
+
+      1 if switches.include?(arg)
+    end
+
+    def process(arg, state:)
+      value = convert_proc.call(arg)
+      callback_proc&.call(value)
+      state.parsed_option(key, value)
+    end
+
+    def candidates(literal: false, **_kwargs)
+      literal ? [] : switches
+    end
+
+    def required?
+      @required
+    end
+
+    def multiple?
+      true
+    end
+
+    private
+
+    attr_reader :key, :switches, :convert_proc, :callback_proc
+  end
+end

data/lib/tomo/cli/rules/value_switch.rb

@@ -0,0 +1,58 @@
+class Tomo::CLI::Rules
+  class ValueSwitch < Switch
+    include Tomo::Colors
+
+    def initialize(key, *switches, values_proc:, callback_proc:)
+      super(key, *switches, callback_proc: callback_proc)
+
+      @values_proc = values_proc
+    end
+
+    def match(arg, literal: false)
+      return nil if literal
+      return 2 if switches.include?(arg)
+
+      1 if arg.start_with?("--") && switches.include?(arg.split("=").first)
+    end
+
+    def process(switch, arg=nil, state:)
+      value = if switch.include?("=")
+                switch.split("=", 2).last
+              elsif !arg.to_s.start_with?("-")
+                arg
+              end
+
+      raise_missing_value(switch) if value.nil?
+
+      callback_proc&.call(value)
+      state.parsed_option(key, value)
+    end
+
+    def candidates(switch=nil, literal: false, state:)
+      return [] if literal
+
+      vals = values(state)
+      return vals.reject { |val| val.start_with?("-") } if switch
+
+      switches.each_with_object([]) do |each_switch, result|
+        result << each_switch
+        vals.each do |value|
+          result << "#{each_switch}=#{value}" if each_switch.start_with?("--")
+        end
+      end
+    end
+
+    private
+
+    attr_reader :values_proc
+
+    def values(state)
+      values_proc.call(*state.args, state.options)
+    end
+
+    def raise_missing_value(switch)
+      raise Tomo::CLI::Error,
+            "Please specify a value for the #{yellow(switch)} option."
+    end
+  end
+end

data/lib/tomo/cli/rules.rb

@@ -0,0 +1,98 @@
+module Tomo
+  class CLI
+    class Rules
+      autoload :Argument, "tomo/cli/rules/argument"
+      autoload :Switch, "tomo/cli/rules/switch"
+      autoload :ValueSwitch, "tomo/cli/rules/value_switch"
+
+      ARG_PATTERNS = {
+        /\A\[[A-Z_]+\]\z/       => :optional_arg_rule,
+        /\A[A-Z_]+\z/           => :required_arg_rule,
+        /\A\[[A-Z_]+\.\.\.\]\z/ => :mutiple_optional_args_rule
+      }.freeze
+
+      OPTION_PATTERNS = {
+        /\A--\[no-\]([\-a-z]+)\z/               => :on_off_switch_rule,
+        /\A(-[a-z]), (--[\-a-z]+)\z/            => :basic_switch_rule,
+        /\A(-[a-z]), (--[\-a-z]+) [A-Z=_\-]+\z/ => :value_switch_rule
+      }.freeze
+
+      private_constant :ARG_PATTERNS, :OPTION_PATTERNS
+
+      def initialize
+        @rules = []
+      end
+
+      def add_arg(spec, values_proc)
+        rule = ARG_PATTERNS.find do |regexp, method|
+          break send(method, spec, values_proc) if regexp.match?(spec)
+        end
+        raise ArgumentError, "Unrecognized arg style: #{spec}" if rule.nil?
+
+        rules << rule
+      end
+
+      def add_option(key, spec, values_proc, &block)
+        rule = OPTION_PATTERNS.find do |regexp, method|
+          match = regexp.match(spec)
+          break send(method, key, *match.captures, values_proc, block) if match
+        end
+        raise ArgumentError, "Unrecognized option style: #{spec}" if rule.nil?
+
+        rules << rule
+      end
+
+      def to_a
+        rules
+      end
+
+      private
+
+      attr_reader :rules
+
+      def optional_arg_rule(spec, values_proc)
+        Rules::Argument.new(
+          spec,
+          values_proc: values_proc,
+          required: false,
+          multiple: false
+        )
+      end
+
+      def required_arg_rule(spec, values_proc)
+        Rules::Argument.new(
+          spec,
+          values_proc: values_proc,
+          required: true,
+          multiple: false
+        )
+      end
+
+      def mutiple_optional_args_rule(spec, values_proc)
+        Rules::Argument.new(spec, multiple: true, values_proc: values_proc)
+      end
+
+      def on_off_switch_rule(key, name, _values_proc, callback_proc)
+        Rules::Switch.new(key,
+                          "--#{name}",
+                          "--no-#{name}",
+                          callback_proc: callback_proc) do |arg|
+          arg == "--#{name}"
+        end
+      end
+
+      def basic_switch_rule(key, *switches, _values_proc, callback_proc)
+        Rules::Switch.new(key, *switches, callback_proc: callback_proc)
+      end
+
+      def value_switch_rule(key, *switches, values_proc, callback_proc)
+        Rules::ValueSwitch.new(
+          key,
+          *switches,
+          values_proc: values_proc,
+          callback_proc: callback_proc
+        )
+      end
+    end
+  end
+end

data/lib/tomo/cli/rules_evaluator.rb

@@ -0,0 +1,71 @@
+module Tomo
+  class CLI
+    class RulesEvaluator
+      def self.evaluate(**kwargs)
+        new(**kwargs).call
+      end
+
+      def initialize(rules:, argv:, state:, literal:, completions: nil)
+        @rules = rules
+        @argv = argv.dup
+        @state = state
+        @literal = literal
+        @completions = completions || Completions.new(literal: literal)
+      end
+
+      def call
+        until argv.empty?
+          complete_if_needed(remaining_rules, *argv) if argv.length == 1
+          rule, matched_args = match_next_rule
+          complete_if_needed([rule], *matched_args) if argv.empty?
+          rule.process(*matched_args, state: state)
+          state.processed_rule(rule)
+        end
+      end
+
+      private
+
+      attr_reader :rules, :argv, :state, :literal, :completions
+
+      def match_next_rule
+        matched_rule, length = remaining_rules.find do |rule|
+          matching_length = rule.match(argv.first, literal: literal)
+          break [rule, matching_length] if matching_length
+        end
+        raise_unrecognized_args if matched_rule.nil?
+
+        matched_args = argv.shift(length)
+        [matched_rule, matched_args]
+      end
+
+      def complete_if_needed(matched_rules, *matched_args)
+        return unless Completions.active?
+
+        completions.print_completions_and_exit(
+          matched_rules,
+          *matched_args,
+          state: state
+        )
+      end
+
+      def remaining_rules
+        rules.reject do |rule|
+          state.processed?(rule) && !rule.multiple?
+        end
+      end
+
+      def raise_unrecognized_args
+        problem_arg = argv.first
+        type = if literal || !problem_arg.start_with?("-")
+                 "arg"
+               else
+                 "option"
+               end
+
+        raise CLI::Error,
+              "#{Colors.yellow(problem_arg)} is not a recognized #{type} "\
+              "for this tomo command."
+      end
+    end
+  end
+end

data/lib/tomo/cli/state.rb

@@ -0,0 +1,29 @@
+module Tomo
+  class CLI
+    class State
+      attr_reader :args, :options, :processed_rules
+
+      def initialize
+        @args = []
+        @options = Options.new
+        @processed_rules = []
+      end
+
+      def parsed_arg(arg)
+        args << arg
+      end
+
+      def parsed_option(key, value)
+        options.all(key) << value
+      end
+
+      def processed_rule(rule)
+        @processed_rules |= [rule]
+      end
+
+      def processed?(rule)
+        @processed_rules.include?(rule)
+      end
+    end
+  end
+end

data/lib/tomo/cli/usage.rb

@@ -0,0 +1,42 @@
+module Tomo
+  class CLI
+    class Usage
+      def initialize
+        @options = []
+        @banner_proc = proc { "" }
+      end
+
+      def add_option(spec, desc)
+        options << [
+          spec.start_with?("--") ? "    #{spec}" : spec,
+          desc
+        ]
+      end
+
+      def banner=(banner)
+        @banner_proc = banner.respond_to?(:call) ? banner : proc { banner }
+      end
+
+      def to_s
+        indent([
+          "", banner_proc.call, "Options:", "", indent(options_help), "\n"
+        ].join("\n"))
+      end
+
+      private
+
+      attr_reader :banner_proc, :options
+
+      def options_help
+        width = options.map(&:first).map(&:length).max
+        options.each_with_object([]) do |(spec, desc), help|
+          help << "#{Colors.yellow(spec.ljust(width))}    #{desc}"
+        end.join("\n")
+      end
+
+      def indent(str)
+        str.gsub(/^/, "  ")
+      end
+    end
+  end
+end

data/lib/tomo/cli.rb

@@ -0,0 +1,75 @@
+require "abbrev"
+
+module Tomo
+  class CLI
+    autoload :Command, "tomo/cli/command"
+    autoload :CommonOptions, "tomo/cli/common_options"
+    autoload :Completions, "tomo/cli/completions"
+    autoload :DeployOptions, "tomo/cli/deploy_options"
+    autoload :Error, "tomo/cli/error"
+    autoload :InterruptedError, "tomo/cli/interrupted_error"
+    autoload :Options, "tomo/cli/options"
+    autoload :Parser, "tomo/cli/parser"
+    autoload :ProjectOptions, "tomo/cli/project_options"
+    autoload :Rules, "tomo/cli/rules"
+    autoload :RulesEvaluator, "tomo/cli/rules_evaluator"
+    autoload :State, "tomo/cli/state"
+    autoload :UnknownOptionError, "tomo/cli/unknown_option_error"
+    autoload :Usage, "tomo/cli/usage"
+
+    class << self
+      attr_accessor :show_backtrace
+    end
+
+    COMMANDS = {
+      "deploy" => Tomo::Commands::Deploy,
+      "help" => Tomo::Commands::Help,
+      "init" => Tomo::Commands::Init,
+      "run" => Tomo::Commands::Run,
+      "setup" => Tomo::Commands::Setup,
+      "tasks" => Tomo::Commands::Tasks,
+      "version" => Tomo::Commands::Version,
+      "completion-script" => Tomo::Commands::CompletionScript
+    }.freeze
+
+    def call(argv)
+      prepare_completions(argv)
+      command, command_name = lookup_command(argv)
+      command.parse(argv)
+    rescue Interrupt
+      handle_error(InterruptedError.new, command_name)
+    rescue StandardError => e
+      handle_error(e, command_name)
+    end
+
+    private
+
+    def prepare_completions(argv)
+      return unless %w[--complete --complete-word].include?(argv[0])
+
+      Completions.activate
+      argv << "" if argv.shift == "--complete"
+    end
+
+    def lookup_command(argv)
+      command_name = argv.first unless Completions.active? && argv.length == 1
+      command_name = Abbrev.abbrev(COMMANDS.keys)[command_name]
+      argv.shift if command_name
+
+      command = COMMANDS[command_name] || Tomo::Commands::Default
+      [command, command_name]
+    end
+
+    def handle_error(error, command_name)
+      return if Completions.active?
+      raise error unless error.respond_to?(:to_console)
+
+      error.command_name = command_name if error.respond_to?(:command_name=)
+      Tomo.logger.error(error.to_console)
+      status = error.respond_to?(:exit_status) ? error.exit_status : 1
+      exit(status) unless Tomo::CLI.show_backtrace
+
+      raise error
+    end
+  end
+end

data/lib/tomo/colors.rb

@@ -0,0 +1,46 @@
+module Tomo
+  module Colors
+    ANSI_CODES = {
+      red: 31,
+      green: 32,
+      yellow: 33,
+      blue: 34,
+      gray: 90
+    }.freeze
+    private_constant :ANSI_CODES
+
+    class << self
+      attr_writer :enabled
+
+      def enabled?
+        return @enabled if defined?(@enabled)
+
+        @enabled = determine_color_support
+      end
+
+      private
+
+      def determine_color_support
+        if ENV["CLICOLOR_FORCE"] == "1"
+          true
+        elsif ENV["TERM"] == "dumb"
+          false
+        else
+          tty?($stdout) && tty?($stderr)
+        end
+      end
+
+      def tty?(io)
+        io.respond_to?(:tty?) && io.tty?
+      end
+    end
+
+    module_function
+
+    ANSI_CODES.each do |name, code|
+      define_method(name) do |str|
+        ::Tomo::Colors.enabled? ? "\e[0;#{code};49m#{str}\e[0m" : str
+      end
+    end
+  end
+end

data/lib/tomo/commands/completion_script.rb

@@ -0,0 +1,46 @@
+module Tomo
+  module Commands
+    class CompletionScript
+      def self.parse(_argv)
+        puts <<~'SCRIPT'
+          # TOMO COMPLETIONS FOR BASH
+          #
+          # Assuming tomo is in your PATH, you can install tomo bash completions by
+          # adding this line to your .bashrc:
+          #
+          #   eval "$(tomo completion-script)"
+          #
+          # The eval technique is a bit slow but ensures bash is always using the
+          # latest version of the tomo completion script.
+          #
+          # Alternatively, you can copy and paste the current version of the script
+          # into your .bashrc. The full script is listed below.
+
+          _tomo_complete() {
+            local cur="${COMP_WORDS[COMP_CWORD]}"
+            local prev="${COMP_WORDS[COMP_CWORD-1]}"
+
+            if [[ $prev == "-c" || $prev == "--config" ]]; then
+              COMPREPLY=($(compgen -f -- ${cur}))
+              return 0
+            fi
+
+            if [[ "${COMP_LINE: -1}" == " " ]]; then
+              command=${COMP_LINE/tomo/tomo --complete}
+            else
+              command=${COMP_LINE/tomo/tomo --complete-word}
+            fi
+
+            suggestions=$($command)
+            local IFS=$'\n'
+            COMPREPLY=($suggestions)
+            return 0
+          }
+
+          complete -o nospace -F _tomo_complete tomo
+
+        SCRIPT
+      end
+    end
+  end
+end

data/lib/tomo/commands/default.rb

@@ -0,0 +1,72 @@
+module Tomo
+  module Commands
+    class Default < CLI::Command
+      arg "COMMAND", values: CLI::COMMANDS.keys
+
+      option :version, "-v, --version", "Display tomo’s version and exit" do
+        Version.parse([])
+        exit
+      end
+
+      include CLI::CommonOptions
+
+      def banner
+        <<~BANNER
+          Usage: #{green('tomo')} #{yellow('COMMAND [options]')}
+
+          Tomo is an extensible tool for deploying projects to remote hosts via SSH.
+          Please specify a #{yellow('COMMAND')}, which can be:
+
+          #{commands.map { |name, help| "  #{yellow(name.ljust(10))} #{help}" }.join("\n")}
+
+          Tomo accepts abbreviations for its commands. For example, #{blue('tomo deploy')}
+          can be shortened to #{blue('tomo d')}. You can use bash completions as well!
+          Run #{blue('tomo completion-script')} for installation instructions.
+
+          For help with any command, add #{blue('-h')} to the command, like this:
+
+            #{blue('tomo run -h')}
+
+          Or read the full documentation for all commands at:
+
+            #{blue('https://tomo-deploy.com/')}
+        BANNER
+      end
+
+      def call(*args, options)
+        # The bare `tomo` command (i.e. without `--help` or `--version`) doesn't
+        # do anything, so if we got this far, something has gone wrong.
+
+        if options.any?
+          raise CLI::Error,
+                "Options must be specified after the command: " +
+                yellow("tomo #{args.first} [options]")
+        end
+
+        raise_unrecognized_command(args.first)
+      end
+
+      private
+
+      def raise_unrecognized_command(command)
+        error = "#{yellow(command)} is not a recognized tomo command."
+        if command.match?(/\A\S+:\S+\z/)
+          suggestion = "tomo run #{command}"
+          error << "\nMaybe you meant #{blue(suggestion)}?"
+        end
+
+        raise CLI::Error, error
+      end
+
+      def commands
+        CLI::COMMANDS.each_with_object({}) do |(name, klass), result|
+          command = klass.new
+          help = command.summary if command.respond_to?(:summary)
+          next if help.nil?
+
+          result[name] = help
+        end
+      end
+    end
+  end
+end

data/lib/tomo/commands/deploy.rb

@@ -0,0 +1,67 @@
+module Tomo
+  module Commands
+    class Deploy < CLI::Command
+      include CLI::DeployOptions
+      include CLI::ProjectOptions
+      include CLI::CommonOptions
+
+      def summary
+        "Deploy the current project to remote host(s)"
+      end
+
+      def banner
+        <<~BANNER
+          Usage: #{green('tomo deploy')} #{yellow('[--dry-run] [options]')}
+
+          Sequentially run the "deploy" list of tasks specified in #{DEFAULT_CONFIG_PATH} to
+          deploy the project to a remote host. Use the #{blue('--dry-run')} option to quickly
+          simulate the entire deploy without actually connecting to the host.
+
+          For a #{DEFAULT_CONFIG_PATH} that specifies distinct environments (e.g. staging,
+          production), you must specify the target environment using the #{blue('-e')} option. If
+          you omit this option, tomo will automatically prompt for it.
+
+          Tomo will use the settings specified in #{DEFAULT_CONFIG_PATH} to configure the
+          deploy. You may override these on the command line using #{blue('-s')}. E.g.:
+
+            #{blue('tomo deploy -e staging -s git_branch=develop')}
+
+          Or use environment variables with the special #{blue('TOMO_')} prefix:
+
+            #{blue('TOMO_GIT_BRANCH=develop tomo deploy -e staging')}
+
+          Bash completions are provided for tomo’s options. For example, you could type
+          #{blue('tomo deploy -s <TAB>')} to see a list of all settings, or #{blue('tomo deploy -e pr<TAB>')}
+          to expand #{blue('pr')} to #{blue('production')}. For bash completion installation instructions,
+          run #{blue('tomo completion-script')}.
+
+          More documentation and examples can be found here:
+
+            #{blue('https://tomo-deploy.com/commands/deploy')}
+        BANNER
+      end
+
+      def call(options)
+        logger.info "tomo deploy v#{Tomo::VERSION}"
+
+        runtime = configure_runtime(options)
+        plan = runtime.deploy!
+
+        log_completion(plan)
+      end
+
+      private
+
+      def log_completion(plan)
+        app = plan.settings[:application]
+        target = "#{app} to #{plan.applicable_hosts_sentence}"
+
+        if dry_run?
+          logger.info(green("* Simulated deploy of #{target} (dry run)"))
+        else
+          logger.info(green("✔ Deployed #{target}"))
+        end
+      end
+    end
+  end
+end