git-commander 0.1.0

data/lib/git_commander/command/option.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module GitCommander
+  class Command
+    # @abstract Wraps [Command] arguments, flags, and switches in a generic
+    #           object to normalize their representation in the context of a
+    #           [Command].
+    class Option
+      attr_reader :default, :description, :name
+      attr_writer :value
+
+      # Creates a [Option] object.
+      #
+      # @param name [String, Symbol] the name of the option, these are unique per [Command]
+      # @param default [anything] the default value the option should have
+      # @param description [String] a description of the option for display in
+      #        the [Command]'s help text
+      # @param value [anything] a value for the option
+      def initialize(name:, default: nil, description: nil, value: nil)
+        @name = name.to_sym
+        @default = default
+        @description = description
+        @value = value
+      end
+
+      def value
+        @value || @default
+      end
+
+      def ==(other)
+        other.class == self.class &&
+          other.name == name &&
+          other.default == default &&
+          other.description == description
+      end
+      alias eql? ==
+
+      def to_h
+        { name => value }
+      end
+    end
+  end
+end

data/lib/git_commander/command/runner.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module GitCommander
+  class Command
+    # @abstract A container to execute blocks defined in command definitions
+    #
+    # Command @block will be executed in this class' context and methods will be
+    # delegated based on methods defined here, or in plugins.
+    class Runner
+      attr_reader :command
+
+      undef :system
+
+      def initialize(command)
+        @command = command
+      end
+
+      def run(options = {})
+        GitCommander.logger.info "Running '#{command.name}' with arguments: #{options.inspect}"
+        instance_exec(options, &command.block)
+      end
+
+      def say(message)
+        command.say message
+      end
+
+      def respond_to_missing?(method_sym, include_all = false)
+        plugin_executor(method_sym).respond_to?(method_sym, include_all) ||
+          super(method_sym, include_all)
+      end
+
+      def method_missing(method_sym, *arguments, &block)
+        return plugin_executor(method_sym) if plugin_executor(method_sym)
+
+        super
+      end
+
+      private
+
+      def plugin_executor(plugin_name)
+        @plugin_executor ||= command.registry.find_plugin(plugin_name)&.executor
+      end
+    end
+  end
+end

data/lib/git_commander/command_loader_options.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module GitCommander
+  # Establishes values to be set by loaders
+  module CommandLoaderOptions
+    def summary(value = nil)
+      return @summary = value if value
+
+      @summary
+    end
+
+    def description(value = nil)
+      return @description = value if value
+
+      @description
+    end
+
+    def argument(arg_name, options = {})
+      add_option :argument, options.merge(name: arg_name)
+    end
+
+    def flag(flag_name, options = {})
+      add_option :flag, options.merge(name: flag_name)
+    end
+
+    def switch(switch_name, options = {})
+      add_option :switch, options.merge(name: switch_name)
+    end
+
+    def on_run(&on_run)
+      @block = on_run
+    end
+  end
+end

data/lib/git_commander/loader.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "bundler/inline"
+require_relative "loader_result"
+
+module GitCommander
+  # @abstract The interface class outlining requirements for an operational Loader
+  class Loader
+    # Let the loaders proxy system calls in the git-commander context
+    undef :system
+
+    attr_reader :registry, :result
+
+    def initialize(registry)
+      @registry = registry
+      @result = LoaderResult.new
+    end
+
+    # Expected to return an instance of GitCommander::LoaderResult
+    def load(_options = {})
+      raise NotImplementedError
+    end
+
+    def system
+      GitCommander::System
+    end
+  end
+end

data/lib/git_commander/loader_result.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module GitCommander
+  # @abstract A simple object to wrap errors loading any given loader
+  class LoaderResult
+    attr_accessor :commands, :plugins, :errors
+
+    def initialize
+      @errors = []
+      @commands = []
+      @plugins = []
+    end
+
+    def success?
+      Array(errors).empty?
+    end
+  end
+end

data/lib/git_commander/logger.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module GitCommander
+  # Handles logging for GitCommander
+  class Logger < ::Logger
+    DEFAULT_LOG_FILE = "/tmp/git-commander.log"
+
+    def initialize(*args)
+      log_file = args.shift || log_file_path
+      args.unshift(log_file)
+      super(*args)
+      @formatter = SimpleFormatter.new
+    end
+
+    # Simple formatter which only displays the message.
+    class SimpleFormatter < ::Logger::Formatter
+      # This method is invoked when a log event occurs
+      def call(severity, _timestamp, _progname, msg)
+        "#{severity}: #{String === msg ? msg : msg.inspect}\n"
+      end
+    end
+
+    private
+
+    def log_file_path
+      return @log_file_path unless @log_file_path.to_s.empty?
+
+      # Here we have to run the command in isolation to avoid a recursive loop
+      # to log this command run to fetch the config setting.
+      configured_log_file_path = `git config --get commander.log-file-path`
+
+      return @log_file_path = DEFAULT_LOG_FILE if configured_log_file_path.empty?
+
+      @log_file_path = configured_log_file_path
+    end
+  end
+end

data/lib/git_commander/plugin.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "plugin/executor"
+
+module GitCommander
+  #
+  # @abstract Allows for proxying methods to a plugin from within the context of
+  # a Command's block.
+  #
+  # A Plugin provides additional external instances to a Command's @block
+  # context.  Plugins can define their own inline gems, and can define
+  # additional Commands.
+  #
+  # @example A simple `git` plugin
+  #   require "git"
+  #   git_instance = Git.open(Dir.pwd, log: GitCommander.logger)
+  #   GitCommander::Plugin.new(:git, source_instance: git_instance)
+  #
+  class Plugin
+    class CommandNotFound < StandardError; end
+
+    attr_accessor :commands, :executor, :name, :registry
+
+    # Creates a Plugin object. +name+ is the name of the plugin.
+    #
+    # Options include:
+    #
+    # +source_instance+ - an instance of an object to use in the Command's block context
+    # +registry+ - a Registry instance for where this Plugin will be stored for lookup
+    def initialize(name, source_instance: nil, registry: nil)
+      @name = name
+      @executor = Executor.new(source_instance) if source_instance
+      @registry = registry || GitCommander::Registry.new
+    end
+
+    def find_command(command_name)
+      GitCommander.logger.debug "[#{logger_tag}] looking up command: #{command_name.inspect}"
+      command = commands[command_name.to_s.to_sym]
+      raise CommandNotFound, "[#{logger_tag}] #{command_name} does not exist for this plugin" if command.nil?
+
+      command
+    end
+
+    private
+
+    def logger_tag
+      [name, "plugin"].compact.join(" ")
+    end
+  end
+end

data/lib/git_commander/plugin/executor.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module GitCommander
+  class Plugin
+    class Executor < SimpleDelegator
+    end
+  end
+end

data/lib/git_commander/plugin/loader.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative "../command/configurator"
+require_relative "../loader"
+
+module GitCommander
+  class Plugin
+    # @abstract Handles loading native plugins by name.
+    class Loader < ::GitCommander::Loader
+      class NotFoundError < StandardError; end
+      class LoadError < StandardError; end
+
+      NATIVE_PLUGIN_DIR = File.expand_path(File.join(__dir__, "..", "plugins"))
+
+      attr_reader :content, :commands, :name
+
+      def initialize(registry)
+        @commands = []
+        super
+      end
+
+      def load(name)
+        @plugin = GitCommander::Plugin.new(
+          resolve_plugin_name(name),
+          source_instance: instance_eval(resolve_content(name))
+        )
+        @plugin.commands = @commands
+        result.plugins << @plugin
+        result.commands |= @commands
+        result
+      rescue Errno::ENOENT, Errno::EACCES => e
+        handle_error LoadError, e
+      rescue StandardError => e
+        handle_error NotFoundError, e
+      end
+
+      def resolve_plugin_name(native_name_or_filename)
+        return @name = native_name_or_filename if native_name_or_filename.is_a? Symbol
+
+        @name = File.basename(native_name_or_filename).split(".").first.to_sym
+      end
+
+      def resolve_content(native_name_or_filename)
+        if native_name_or_filename.is_a? Symbol
+          return @content = File.read("#{NATIVE_PLUGIN_DIR}/#{native_name_or_filename}.rb")
+        end
+
+        @content = File.read(native_name_or_filename)
+      end
+
+      def command(name, &block)
+        GitCommander.logger.debug("Loading command :#{name} from plugin #{@name}")
+        @commands << Command::Configurator.new(registry).configure("#{plugin_name_formatted_for_cli}:#{name}".to_sym, &block)
+      rescue Command::Configurator::ConfigurationError => e
+        result.errors << e
+      end
+
+      def plugin(name, **options)
+        plugin_result = GitCommander::Plugin::Loader.new(registry).load(name, **options)
+        result.plugins |= plugin_result.plugins
+      end
+
+      private
+
+      def plugin_name_formatted_for_cli
+        @name.to_s.gsub("_", "-").to_sym
+      end
+
+      def handle_error(error_klass, original_error)
+        error = error_klass.new(original_error.message)
+        error.set_backtrace original_error.backtrace
+        @result.errors << error
+        @result
+      end
+    end
+  end
+end

data/lib/git_commander/plugins/git.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+gemfile do
+  source "https://rubygems.org"
+  gem "rugged"
+end
+
+CONFIG_FILE_PATH = "#{ENV["HOME"]}/.gitconfig.commander"
+
+# @private
+# Overrides Rugged::Repository#global_config so that we can use a custom config
+# file for all git-commander related configurations
+class RuggedRepositoryWithCustomConfig < SimpleDelegator
+  attr_reader :global_config
+
+  def initialize(repository)
+    @global_config = Rugged::Config.new(CONFIG_FILE_PATH)
+    super repository
+  end
+end
+
+unless File.exist?(CONFIG_FILE_PATH)
+  system.run "touch #{CONFIG_FILE_PATH}"
+  system.say "Created #{CONFIG_FILE_PATH} for git-commander specific configurations."
+  system.run "git config --global --add include.path \"#{CONFIG_FILE_PATH}\""
+  system.say "Added #{CONFIG_FILE_PATH} to include.path in $HOME/.gitconfig"
+end
+
+RuggedRepositoryWithCustomConfig.new(
+  Rugged::Repository.new(Dir.pwd)
+)

data/lib/git_commander/plugins/github.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+gemfile do
+  source "https://rubygems.org"
+  gem "octokit"
+end
+
+plugin :git
+plugin :prompt
+
+command :setup do |cmd|
+  cmd.summary "Connects to GitHub, creates an access token, and stores it in the git-cmd section of your git config"
+
+  cmd.on_run do
+    gh_user = prompt.ask("Please enter your GitHub username", required: true)
+    gh_password = promt.mask("Please enter your GitHub password (this is NOT stored): ", required: true)
+
+    github.login = gh_user
+    github.password = gh_password
+
+    # Check for 2-factor requirements
+    begin
+      github.user
+    rescue Octokit::Unauthorized
+      github.user(
+        gh_user,
+        headers: { "X-GitHub-OTP" => prompt.ask("Please enter your two-factor authentication code") }
+      )
+    end
+
+    say "GitHub account successfully setup!"
+  end
+end
+
+Octokit::Client.new

data/lib/git_commander/plugins/prompt.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+gemfile do
+  source "https://rubygems.org"
+  gem "tty-prompt"
+end
+
+TTY::Prompt.new

data/lib/git_commander/plugins/system.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+GitCommander::System

data/lib/git_commander/registry.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative "loader"
+require_relative "plugin/loader"
+require_relative "command/loaders/file_loader"
+require_relative "command/loaders/raw"
+
+module GitCommander
+  # @abstract Manages available GitCommander commands
+  class Registry
+    class CommandNotFound < StandardError; end
+    class LoadError < StandardError; end
+
+    attr_accessor :commands, :name, :plugins
+
+    def initialize
+      @commands = {}
+      @plugins = {}
+    end
+
+    # Adds a command to the registry
+    #
+    # @param [String, Symbol] command_name the name of the command to add to the
+    #   registry
+    def register(command_name, **options, &block)
+      command = GitCommander::Command.new(command_name.to_sym, registry: self, **options.merge(block: block))
+      register_command(command)
+    end
+
+    # Adds a pre-built command to the registry
+    # @param [Command] command the Command instance to add to the registry
+    def register_command(command)
+      GitCommander.logger.debug "[#{logger_tag}] Registering command `#{command.name}` with args: #{command.inspect}..."
+
+      commands[command.name] = command
+    end
+
+    # Adds a pre-built Plugin to the registry
+    # @param [Plugin] plugin the Plugin instance to add to the registry
+    def register_plugin(plugin)
+      GitCommander.logger.debug "[#{logger_tag}] Registering plugin `#{plugin.name}`..."
+
+      plugins[plugin.name] = plugin
+    end
+
+    # Adds command(s) to the registry using the given loader
+    #
+    # @param [CommandLoader] loader the class to use to load with
+    def load(loader, *args)
+      result = loader.new(self).load(*args)
+
+      if result.success?
+        result.plugins.each { |plugin| register_plugin(plugin) }
+        result.commands.each { |cmd| register_command(cmd) }
+      end
+
+      result
+    end
+
+    # Looks up a command in the registry
+    #
+    # @param [String, Symbol] command_name the name of the command to look up in the
+    #   registry
+    #
+    # @example Fetch a command from the registry
+    #   registry = GitCommander::Registry.new
+    #   registry.register :wtf
+    #   registry.find :wtf
+    #
+    # @raise [CommandNotFound] when no command is found in the registry
+    # @return [GitCommander::Command, #run] a command object that responds to #run
+    def find(command_name)
+      GitCommander.logger.debug "[#{logger_tag}] looking up command: #{command_name.inspect}"
+      command = commands[command_name.to_s.to_sym]
+      raise CommandNotFound, "[#{logger_tag}] #{command_name} does not exist in the registry" if command.nil?
+
+      command
+    end
+
+    def find_plugin(plugin_name)
+      GitCommander.logger.debug "[#{logger_tag}] looking up plugin: #{plugin_name.inspect}"
+      plugins[plugin_name.to_s.to_sym]
+    end
+
+    private
+
+    def logger_tag
+      [name, "registry"].compact.join(" ")
+    end
+  end
+end