tomo 0.1.0

data/lib/tomo/configuration/plugins_registry/gem_resolver.rb

@@ -0,0 +1,63 @@
+module Tomo
+  class Configuration
+    class PluginsRegistry::GemResolver
+      PLUGIN_PREFIX = "tomo/plugin".freeze
+      private_constant :PLUGIN_PREFIX
+
+      def self.resolve(name)
+        new(name).plugin_module
+      end
+
+      def initialize(name)
+        @name = name
+      end
+
+      def plugin_module
+        plugin_path = [PLUGIN_PREFIX, name.tr("-", "/")].join("/")
+        require plugin_path
+
+        plugin = constantize(plugin_path)
+        assert_compatible_api(plugin)
+
+        plugin
+      rescue LoadError => e
+        raise unless e.message.match?(/\s#{Regexp.quote(plugin_path)}$/)
+
+        raise_unknown_plugin_error(e)
+      end
+
+      private
+
+      attr_reader :name
+
+      def assert_compatible_api(plugin)
+        return if plugin.is_a?(::Tomo::PluginDSL)
+
+        raise "#{plugin} does not extend Tomo::PluginDSL"
+      end
+
+      def constantize(path)
+        parts = path.split("/")
+        parts.reduce(Object) do |parent, part|
+          child = part.gsub(/^[a-z]|_[a-z]/) { |str| str.chars.last.upcase }
+          parent.const_get(child, false)
+        end
+      end
+
+      def raise_unknown_plugin_error(error)
+        UnknownPluginError.raise_with(
+          error.message,
+          name: name,
+          gem_name: "#{PLUGIN_PREFIX}/#{name}".tr("/", "-"),
+          known_plugins: scan_for_plugins
+        )
+      end
+
+      def scan_for_plugins
+        Gem.find_latest_files("#{PLUGIN_PREFIX}/*.rb").map do |file|
+          file[%r{#{PLUGIN_PREFIX}/(.+).rb$}, 1].tr("/", "-")
+        end.uniq.sort
+      end
+    end
+  end
+end

data/lib/tomo/configuration/plugins_registry.rb

@@ -0,0 +1,67 @@
+module Tomo
+  class Configuration
+    class PluginsRegistry
+      autoload :FileResolver,
+               "tomo/configuration/plugins_registry/file_resolver"
+      autoload :GemResolver, "tomo/configuration/plugins_registry/gem_resolver"
+
+      attr_reader :helper_modules, :settings
+
+      def initialize
+        @settings = {}
+        @helper_modules = []
+        @namespaced_classes = []
+      end
+
+      def task_names
+        bind_tasks(nil).keys
+      end
+
+      def bind_tasks(context)
+        namespaced_classes.each_with_object({}) do |(namespace, klass), result|
+          library = klass.new(context)
+
+          klass.public_instance_methods(false).each do |name|
+            qualified = [namespace, name].compact.join(":")
+            result[qualified] = library.public_method(name)
+          end
+        end
+      end
+
+      def load_plugin_by_name(name)
+        plugin = GemResolver.resolve(name)
+        load_plugin(name, plugin)
+      end
+
+      def load_plugin_from_path(path)
+        name = File.basename(path).sub(/\.rb$/i, "")
+        plugin = FileResolver.resolve(path)
+        load_plugin(name, plugin)
+      end
+
+      def load_plugin(namespace, plugin_class)
+        Tomo.logger.debug("Loading plugin #{plugin_class}")
+
+        helper_modules.push(*plugin_class.helper_modules)
+        settings.merge!(plugin_class.default_settings) { |_, exist, _| exist }
+        register_task_libraries(namespace, *plugin_class.tasks_classes)
+      end
+
+      private
+
+      attr_reader :namespaced_classes
+
+      def register_task_libraries(namespace, *library_classes)
+        library_classes.each { |cls| register_task_library(namespace, cls) }
+      end
+
+      def register_task_library(namespace, library_class)
+        Tomo.logger.debug(
+          "Registering task library #{library_class}"\
+          " (#{namespace.inspect} namespace)"
+        )
+        namespaced_classes << [namespace, library_class]
+      end
+    end
+  end
+end

data/lib/tomo/configuration/project_not_found_error.rb

@@ -0,0 +1,28 @@
+module Tomo
+  class Configuration
+    class ProjectNotFoundError < Tomo::Error
+      attr_accessor :path
+
+      def to_console
+        path == DEFAULT_CONFIG_PATH ? default_message : custom_message
+      end
+
+      private
+
+      def default_message
+        <<~ERROR
+          A #{yellow(path)} configuration file is required to run this command.
+          Are you in the right directory?
+
+          To create a new #{yellow(path)} file, run #{blue('tomo init')}.
+        ERROR
+      end
+
+      def custom_message
+        <<~ERROR
+          #{yellow(path)} does not exist.
+        ERROR
+      end
+    end
+  end
+end

data/lib/tomo/configuration/role_based_task_filter.rb

@@ -0,0 +1,42 @@
+module Tomo
+  class Configuration
+    class RoleBasedTaskFilter
+      def initialize
+        @globs = {}
+      end
+
+      def freeze
+        globs.freeze
+        super
+      end
+
+      def add_role(name, task_specs)
+        name = name.to_s
+        task_globs = Array(task_specs).flatten.map { |spec| Glob.new(spec) }
+        task_globs.each do |task_glob|
+          (globs[task_glob] ||= []) << name
+        end
+      end
+
+      def filter(tasks, host:)
+        roles = host.roles
+        roles = roles.empty? ? [""] : roles
+        tasks.select do |task|
+          roles.any? { |role| match?(task, role) }
+        end
+      end
+
+      private
+
+      attr_reader :globs
+
+      def match?(task, role)
+        task_globs = globs.keys.select { |glob| glob.match?(task) }
+        return true if task_globs.empty?
+
+        roles = globs.values_at(*task_globs).flatten
+        roles.include?(role)
+      end
+    end
+  end
+end

data/lib/tomo/configuration/unknown_environment_error.rb

@@ -0,0 +1,46 @@
+module Tomo
+  class Configuration
+    class UnknownEnvironmentError < Tomo::Error
+      attr_accessor :name, :known_environments
+
+      def to_console
+        known_environments.empty? ? no_envs : wrong_envs
+      end
+
+      private
+
+      def no_envs
+        <<~ERROR
+          This project does not have distinct environments.
+
+          Run tomo again without the #{yellow("-e #{name}")} option.
+        ERROR
+      end
+
+      def wrong_envs
+        error = <<~ERROR
+          #{yellow(name)} is not a recognized environment for this project.
+        ERROR
+
+        if suggestions.any?
+          error << suggestions.to_console
+        else
+          envs = known_environments.map { |env| blue("  #{env}") }
+          error << <<~ENVS
+
+            The following environments are available:
+
+            #{envs.join("\n")}
+          ENVS
+        end
+      end
+
+      def suggestions
+        @_suggestions ||= Error::Suggestions.new(
+          dictionary: known_environments,
+          word: name
+        )
+      end
+    end
+  end
+end

data/lib/tomo/configuration/unknown_plugin_error.rb

@@ -0,0 +1,28 @@
+module Tomo
+  class Configuration
+    class UnknownPluginError < Tomo::Error
+      attr_accessor :name, :known_plugins, :gem_name
+
+      def to_console
+        error = <<~ERROR
+          #{yellow(name)} is not a recognized plugin.
+        ERROR
+
+        sugg = Error::Suggestions.new(dictionary: known_plugins, word: name)
+        error << sugg.to_console if sugg.any?
+
+        error << gem_suggestion
+      end
+
+      private
+
+      def gem_suggestion
+        if Tomo.bundled?
+          "\nYou may need to add #{yellow(gem_name)} to your Gemfile."
+        else
+          "\nYou may need to install the #{yellow(gem_name)} gem."
+        end
+      end
+    end
+  end
+end

data/lib/tomo/configuration/unspecified_environment_error.rb

@@ -0,0 +1,28 @@
+module Tomo
+  class Configuration
+    class UnspecifiedEnvironmentError < Tomo::Error
+      attr_accessor :environments
+
+      def to_console
+        <<~ERROR
+          No environment specified.
+
+          This is a multi-environment project. To run a remote task you must specify
+          which environment to use by including the #{blue('-e')} option.
+
+          Run tomo again with one of these options to specify the environment:
+
+          #{env_options}
+        ERROR
+      end
+
+      private
+
+      def env_options
+        environments.each_with_object([]) do |env, options|
+          options << blue("  -e #{env}")
+        end.join("\n")
+      end
+    end
+  end
+end

data/lib/tomo/configuration.rb

@@ -0,0 +1,124 @@
+module Tomo
+  class Configuration
+    autoload :DSL, "tomo/configuration/dsl"
+    autoload :Environment, "tomo/configuration/environment"
+    autoload :Glob, "tomo/configuration/glob"
+    autoload :PluginFileNotFoundError,
+             "tomo/configuration/plugin_file_not_found_error"
+    autoload :PluginsRegistry, "tomo/configuration/plugins_registry"
+    autoload :ProjectNotFoundError, "tomo/configuration/project_not_found_error"
+    autoload :RoleBasedTaskFilter, "tomo/configuration/role_based_task_filter"
+    autoload :UnknownEnvironmentError,
+             "tomo/configuration/unknown_environment_error"
+    autoload :UnknownPluginError, "tomo/configuration/unknown_plugin_error"
+    autoload :UnspecifiedEnvironmentError,
+             "tomo/configuration/unspecified_environment_error"
+
+    def self.from_config_rb(path=DEFAULT_CONFIG_PATH)
+      ProjectNotFoundError.raise_with(path: path) unless File.file?(path)
+      Tomo.logger.debug("Loading configuration from #{path.inspect}")
+      config_rb = IO.read(path)
+
+      new.tap do |config|
+        config.working_dir = File.dirname(path)
+        DSL::ConfigFile.new(config).instance_eval(config_rb, path.to_s, 1)
+      end
+    rescue StandardError => e
+      raise DSL::ErrorFormatter.decorate(e, path, config_rb&.lines)
+    end
+
+    attr_accessor :environments, :deploy_tasks, :setup_tasks, :hosts, :plugins,
+                  :settings, :task_filter, :working_dir
+
+    def initialize
+      @environments = {}
+      @hosts = []
+      @plugins = []
+      @settings = {}
+      @deploy_tasks = []
+      @setup_tasks = []
+      @task_filter = RoleBasedTaskFilter.new
+    end
+
+    def for_environment(environment)
+      validate_environment!(environment)
+
+      dup.tap do |copy|
+        copy.environments = {}
+        copy.hosts = hosts_for(environment)
+        copy.settings = settings_with_env_overrides(environment)
+      end
+    end
+
+    def build_runtime
+      validate_environment!(nil)
+      plugins_registry = register_plugins
+
+      Runtime.new(
+        deploy_tasks: deploy_tasks,
+        setup_tasks: setup_tasks,
+        plugins_registry: plugins_registry,
+        hosts: add_log_prefixes(hosts),
+        settings: settings,
+        task_filter: task_filter
+      )
+    end
+
+    private
+
+    def validate_environment!(name)
+      if name.nil?
+        raise_no_environment_specified unless environments.empty?
+      else
+        raise_unknown_environment(name) unless environments.key?(name)
+      end
+    end
+
+    def hosts_for(environ)
+      return hosts.dup unless environments.key?(environ)
+
+      environments[environ].hosts
+    end
+
+    def add_log_prefixes(host_arr)
+      return host_arr if host_arr.length == 1
+      return host_arr unless host_arr.all? { |h| h.log_prefix.nil? }
+
+      width = host_arr.length.to_s.length
+      host_arr.map.with_index do |host, i|
+        host.with_log_prefix((i + 1).to_s.rjust(width, "0"))
+      end
+    end
+
+    def register_plugins
+      plugins_registry = PluginsRegistry.new
+
+      (["core"] + plugins.uniq).each do |plug|
+        if %w[. /].include?(plug[0])
+          plug = File.expand_path(plug, working_dir) unless working_dir.nil?
+          plugins_registry.load_plugin_from_path(plug)
+        else
+          plugins_registry.load_plugin_by_name(plug)
+        end
+      end
+
+      plugins_registry
+    end
+
+    def settings_with_env_overrides(environ)
+      return settings.dup unless environments.key?(environ)
+
+      settings.merge(environments[environ].settings)
+    end
+
+    def raise_no_environment_specified
+      UnspecifiedEnvironmentError.raise_with(environments: environments.keys)
+    end
+
+    def raise_unknown_environment(environ)
+      UnknownEnvironmentError.raise_with(
+        name: environ, known_environments: environments.keys
+      )
+    end
+  end
+end

data/lib/tomo/console/key_reader.rb

@@ -0,0 +1,51 @@
+require "forwardable"
+require "io/console"
+require "time"
+
+module Tomo
+  module Console
+    class KeyReader
+      extend Forwardable
+
+      def initialize(input=$stdin)
+        @buffer = ""
+        @input = input
+      end
+
+      def next
+        pressed = raw { getc }
+        pressed << read_chars_nonblock if pressed == "\e"
+        raise Interrupt if pressed == ?\C-c
+
+        clear if !pressed.match?(/\A\w+\z/) || seconds_since_last_press > 0.75
+        buffer << pressed
+      end
+
+      private
+
+      def_delegators :@input, :getc, :raw, :read_nonblock
+      def_delegators :buffer, :clear
+
+      attr_reader :buffer
+
+      def seconds_since_last_press
+        start = @last_press_at || 0
+        @last_press_at = Time.now.to_f
+        @last_press_at - start
+      end
+
+      def read_chars_nonblock
+        chars = ""
+        loop do
+          next_char = raw { read_nonblock(1) }
+          break if next_char.nil?
+
+          chars << next_char
+        end
+        chars
+      rescue IO::WaitReadable
+        chars
+      end
+    end
+  end
+end

data/lib/tomo/console/menu.rb

@@ -0,0 +1,109 @@
+require "forwardable"
+require "io/console"
+
+module Tomo
+  module Console
+    class Menu
+      ARROW_UP = "\e[A".freeze
+      ARROW_DOWN = "\e[B".freeze
+      RETURN = "\r".freeze
+      ENTER = "\n".freeze
+
+      extend Forwardable
+      include Colors
+
+      def initialize(question, options, key_reader: KeyReader.new,
+                     output: $stdout)
+        @question = question
+        @options = options
+        @position = 0
+        @key_reader = key_reader
+        @output = output
+      end
+
+      def selected_option
+        options[position]
+      end
+
+      def prompt_for_selection
+        render_loop do |key|
+          case key
+          when RETURN, ENTER then break
+          when ARROW_UP then move(-1)
+          when ARROW_DOWN then move(1)
+          else self.position = find_match_index(key)
+          end
+        end
+        print "#{yellow(question)} #{blue(selected_option)}\n"
+        selected_option
+      end
+
+      private
+
+      def_delegators :@output, :flush, :print
+
+      attr_reader :key_reader, :question, :options
+      attr_accessor :position
+
+      def render_loop
+        loop do
+          render
+          key = key_reader.next
+          clear
+          yield key
+        end
+      end
+
+      def move(amount)
+        new_position = position + amount
+        return if new_position.negative? || new_position >= options.length
+
+        self.position = new_position
+      end
+
+      def find_match_index(string)
+        exact = options.find_index do |opt|
+          opt.match?(/^#{Regexp.quote(string)}/i)
+        end
+        substring = options.find_index do |opt|
+          opt.match?(/#{Regexp.quote(string)}/i)
+        end
+
+        exact || substring || position
+      end
+
+      def render
+        print "#{yellow(question)} #{gray(hint)}\n"
+        visible_options.each do |option, selected|
+          print selected ? blue("❯ #{option}\n") : "  #{option}\n"
+        end
+        flush
+      end
+
+      def hint
+        return unless options.length > visible_options.length
+
+        "(press up/down to reveal more options)"
+      end
+
+      def clear
+        height = 2 + visible_options.length
+        esc_codes = Array.new(height) { "\e[2K\e[1G" }.join("\e[1A")
+        print esc_codes
+      end
+
+      def visible_options
+        options.map.with_index { |opt, i| [opt, i == position] }[visible_range]
+      end
+
+      def visible_range
+        max_visible = [8, options.length].min
+
+        offset = [0, position - max_visible / 2].max
+        adjusted_offset = [offset, options.length - max_visible].min
+
+        adjusted_offset...(adjusted_offset + max_visible)
+      end
+    end
+  end
+end

data/lib/tomo/console.rb

@@ -0,0 +1,33 @@
+require "io/console"
+
+module Tomo
+  module Console
+    autoload :KeyReader, "tomo/console/key_reader"
+    autoload :Menu, "tomo/console/menu"
+
+    class << self
+      def interactive?(input=$stdin)
+        input.respond_to?(:raw) && input.respond_to?(:tty?) && input.tty?
+      end
+
+      def prompt(question)
+        assert_interactive
+
+        print question
+        $stdin.gets.chomp
+      end
+
+      def menu(question, choices:)
+        assert_interactive
+
+        Menu.new(question, choices).prompt_for_selection
+      end
+
+      private
+
+      def assert_interactive
+        raise "An interactive console is required" unless interactive?
+      end
+    end
+  end
+end

data/lib/tomo/error/suggestions.rb

@@ -0,0 +1,44 @@
+module Tomo
+  class Error
+    class Suggestions
+      def initialize(dictionary:, word:)
+        @dictionary = dictionary
+        @word = word
+      end
+
+      def any?
+        to_a.any?
+      end
+
+      def to_a
+        @_suggestions ||= begin
+          if defined?(DidYouMean::SpellChecker)
+            checker = DidYouMean::SpellChecker.new(dictionary: dictionary)
+            suggestions = checker.correct(word)
+            suggestions || []
+          else
+            []
+          end
+        end
+      end
+
+      def to_console
+        return unless any?
+
+        sentence = to_sentence(to_a.map { |word| Colors.blue(word) })
+        "\nDid you mean #{sentence}?\n"
+      end
+
+      private
+
+      attr_reader :dictionary, :word
+
+      def to_sentence(words)
+        return words.first if words.length == 1
+        return words.join(" or ") if words.length == 2
+
+        words[0...-1].join(", ") + ", or " + words.last
+      end
+    end
+  end
+end

data/lib/tomo/error.rb

@@ -0,0 +1,22 @@
+module Tomo
+  class Error < StandardError
+    autoload :Suggestions, "tomo/error/suggestions"
+
+    include Colors
+
+    def self.raise_with(message=nil, attributes)
+      err = new(message)
+      attributes.each { |attr, value| err.public_send("#{attr}=", value) }
+      raise err
+    end
+
+    private
+
+    def debug_suggestion
+      return if Tomo.debug?
+
+      "For more troubleshooting info, run tomo again using the "\
+      "#{blue('--debug')} option."
+    end
+  end
+end