git-commander 0.1.0

data/git-commander.gemspec

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "lib/git_commander/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "git-commander"
+  spec.version       = GitCommander::VERSION
+  spec.authors       = ["Valentino Stoll"]
+  spec.email         = ["v@codenamev.com"]
+
+  spec.summary       = "Make your own git commands"
+  spec.description   = "Build custom flexible git workflows with Ruby!"
+  spec.homepage      = "https://github.com/codenamev/git-commander"
+  spec.license       = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "byebug", "~> 11"
+  spec.add_development_dependency "rake", "~> 12.3"
+  spec.add_development_dependency "rdoc", "~> 6.2"
+  spec.add_development_dependency "rspec", "< 4.0"
+
+  spec.add_dependency "bundler", "~> 2.1", ">= 1.10.0"
+end

data/lib/git_commander.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "git_commander/command"
+require "git_commander/logger"
+require "git_commander/plugin"
+require "git_commander/registry"
+require "git_commander/system"
+require "git_commander/version"
+
+# GitCommander is the global module used to house the global logger
+module GitCommander
+  module_function
+
+  def logger(*args)
+    @logger ||= GitCommander::Logger.new(*args)
+  end
+end

data/lib/git_commander/cli.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require_relative "registry"
+require_relative "version"
+require "optparse"
+
+module GitCommander
+  # Manages mapping commands and their arguments that are run from the command-line (via `git-cmd`)
+  # to their corresponding git-commander registered commands.
+  #
+  # @example Run a registered "start" command with a single argument
+  #   GitCommander::CLI.new.run ["start", "new-feature""]
+  #
+  class CLI
+    attr_reader :output, :registry
+
+    # @param registry [GitCommander::Registry] (GitCommander::Registry.new) the
+    #   command registry to use for matching available commands
+    # @param output [IO] (STDOUT) the IO object you want to use to send output to when running commands
+    def initialize(registry: GitCommander::Registry.new, output: STDOUT)
+      @registry = registry
+      @output = output
+    end
+
+    # Runs a GitCommander command
+    #
+    # @param args [Array] (ARGV) a list of arguments to pass to the registered command
+    def run(args = ARGV)
+      arguments = Array(args)
+      command = registry.find arguments.shift
+      options = parse_command_options!(command, arguments)
+      command.run options
+    rescue Registry::CommandNotFound
+      log_command_not_found(command)
+
+      help
+    rescue StandardError => e
+      say e.message
+      say e.backtrace
+    end
+
+    def say(message)
+      output.puts message
+    end
+
+    # Parses an array of values (as ARGV would provide) for the provided git-cmd command name.
+    # The +arguments+ are run through Ruby's [OptionParser] for validation and
+    # then filtered through the +command+ to extract it's options with any
+    # default values.
+    #
+    # @param command [Command] the git-cmd command to parse the arguments for
+    # @param arguments [Array] the command line arguments
+    # @return [Array<GitCommander::Command::Option>] the available options with values
+    def parse_command_options!(command, arguments)
+      parser = configure_option_parser_for_command(command)
+      parser.parse!(arguments)
+
+      # Add arguments to options to pass to defined commands
+      command.arguments.each do |argument|
+        argument.value = arguments.shift
+      end
+
+      command.options
+    rescue OptionParser::InvalidOption, OptionParser::MissingArgument => e
+      command.help
+      GitCommander.logger.debug "[CLI] Failed to parse command line options – #{e.inspect}"
+      exit 1
+    end
+
+    private
+
+    def help
+      say "NAME"
+      say "    git-cmd – Git Commander allows running custom git commands from a centralized location."
+      say "VERSION"
+      say "    #{GitCommander::VERSION}"
+      say "USAGE"
+      say "    git-cmd command [command options] [arguments...]"
+      say "COMMANDS"
+      say registry.commands.keys.join(", ")
+    end
+
+    def log_command_not_found(command)
+      GitCommander.logger.error <<~ERROR_LOG
+        #{command} not found in registry.  Available commands: #{registry.commands.keys.inspect}
+      ERROR_LOG
+    end
+
+    def configure_option_parser_for_command(command)
+      valid_arguments_for_command = command.arguments.map { |arg| "[#{arg.name}]" }.join(" ")
+
+      OptionParser.new do |opts|
+        opts.banner = "USAGE:\n    git-cmd #{command.name} [command options] #{valid_arguments_for_command}"
+        opts.separator  ""
+        opts.separator  "COMMAND OPTIONS:" if command.flags.any? || command.switches.any?
+
+        configure_flags_for_option_parser_and_command(opts, command)
+        configure_switches_for_option_parser_and_command(opts, command)
+      end
+    end
+
+    def configure_flags_for_option_parser_and_command(option_parser, command)
+      command.flags.each do |flag|
+        option_parser.on("-#{flag.name[0]}", command_line_flag_formatted_name(flag), flag.description.to_s) do |f|
+          flag.value = f
+        end
+      end
+    end
+
+    def configure_switches_for_option_parser_and_command(option_parser, command)
+      command.switches.each do |switch|
+        option_parser.on("-#{switch.name[0]}", "--[no-]#{switch.name}", switch.description) do |s|
+          switch.value = s
+        end
+      end
+    end
+
+    def command_line_flag_formatted_name(flag)
+      "--#{underscore_to_kebab(flag.name)} #{flag.name.upcase}"
+    end
+
+    def underscore_to_kebab(sym_or_string)
+      sym_or_string.to_s.gsub("_", "-").to_sym
+    end
+  end
+end

data/lib/git_commander/command.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "set"
+require_relative "command/configurator"
+require_relative "command/option"
+require_relative "command/runner"
+require_relative "command_loader_options"
+
+module GitCommander
+  # Wraps domain logic for executing git-cmd Commands
+  class Command
+    include GitCommander::CommandLoaderOptions
+
+    attr_reader :arguments, :flags, :switches, :block, :name, :registry
+    attr_accessor :output
+
+    # @param name [String, Symbol] the name of the command
+    # @param registry [GitCommander::Registry] (GitCommander::Registry.new) the
+    #   command registry to use lookups
+    # @param options [Hash] the options to create the command with
+    #
+    # @option options [String] :description (nil) a short description to use in the
+    #   single line version of the command's help output
+    # @option options [String] :summary (nil) the long-form description of the command
+    #   to use in the command's help output
+    # @option options [IO] :output (STDOUT) the IO object you want to use to
+    #   send outut from the command to
+    # @option options [Array] :arguments an array of hashes describing the
+    #   argument names and default values that can be supplied to the command
+    # @option options [Array] :flags an array of hashes describing the
+    #   flags and default values that can be supplied to the command
+    # @option options [Array] :switches an array of hashes describing the
+    #   switches and default values that can be supplied to the command
+    #
+    # @yieldparam [Array<Option>] run_options an Array of
+    #   Option instances defined from the above +options+
+    #
+    def initialize(name, registry: nil, **options, &block)
+      @name = name
+      @description = options[:description]
+      @summary = options[:summary]
+      @block = block_given? ? block : proc {}
+      @registry = registry || GitCommander::Registry.new
+      @output = options[:output] || STDOUT
+
+      define_command_options(options)
+    end
+
+    # Executes the block for the command with the provided run_options.
+    #
+    # @param run_options [Array<Option>] an array of Option(s) to pass to the {#block} of this Command
+    #
+    def run(run_options = [])
+      assign_option_values(run_options)
+      Runner.new(self).run options.map(&:to_h).reduce(:merge)
+    end
+
+    # Appends the +message+ to the Command's {#output}
+    #
+    # @param message [String] the string to append to the {#output}
+    #
+    def say(message)
+      output.puts message
+    end
+
+    # Adds command-line help text to the {#output} of this Command
+    #
+    def help
+      say "NAME"
+      say "    git-cmd #{name} – #{summary}"
+      say "USAGE"
+      say "    git-cmd #{name} [command options] #{arguments.map { |arg| "[#{arg.name}]" }.join(" ")}"
+      description_help
+      argument_help
+      options_help
+    end
+
+    # Access to a unique Set of this Command's {#arguments}, {#flags}, and {#switches}
+    #
+    # @return [Set] a unique list of all options this command can accept
+    #
+    def options
+      Set.new(@arguments + @flags + @switches)
+    end
+
+    # Add to this Command's {#arguments}, {#flags}, or {#switches}
+    #
+    # @param option_type [String, Symbol] the type of option to add
+    # @param options [Hash] the options to create the [Option] with
+    #
+    # @option options [String, Symbol] :name the name of the option to add
+    # @option options [Object] :default (nil) the default value of the Option
+    # @option options [String] :description (nil) a description of the Option to use in
+    #   help text output
+    # @option options [Object] :value (nil) the value on of the Option
+    #
+    def add_option(option_type, options = {})
+      case option_type.to_sym
+      when :argument
+        @arguments << Option.new(**options)
+      when :flag
+        @flags << Option.new(**options)
+      when :switch
+        @switches << Option.new(**options)
+      end
+    end
+
+    private
+
+    def define_command_options(options)
+      @arguments = options_from_hash(options[:arguments])
+      @flags = options_from_hash(options[:flags])
+      @switches = options_from_hash(options[:switches])
+    end
+
+    def options_from_hash(hash)
+      Array(hash).map { |v| Option.new(**v) }
+    end
+
+    def assign_option_values(command_options)
+      options.each do |option|
+        command_option = command_options.find { |o| o.name == option.name }
+        next if command_option.nil?
+
+        option.value = command_option.value
+      end
+    end
+
+    def description_help
+      return if description.to_s.empty?
+
+      say "DESCRIPTION"
+      say "    #{description}"
+    end
+
+    def argument_help
+      return unless arguments.any?
+
+      say "ARGUMENTS"
+      arguments.each do |argument|
+        default_text = argument.default.nil? ? "" : "(default: #{argument.default.inspect}) "
+        say "    #{argument.name} – #{default_text}#{argument.description}"
+      end
+    end
+
+    def options_help
+      return unless flags.any? || switches.any?
+
+      say "COMMAND OPTIONS"
+      flag_help
+      switch_help
+    end
+
+    def flag_help
+      flags.each do |flag|
+        flag_names = ["-#{flag.name.to_s[0]}", "--#{flag.name}"]
+        say "    #{flag_names} – #{flag.default.nil? ? "" : "(default: #{flag.default})  "}#{flag.description}"
+      end
+    end
+
+    def switch_help
+      switches.each do |switch|
+        switch_names = [switch.name.to_s[0], "-#{switch.name}"].map { |s| "-#{s}" }.join(", ")
+        say "    #{switch_names} – #{switch.default.nil? ? "" : "(default: #{switch.default})  "}#{switch.description}"
+      end
+    end
+  end
+end

data/lib/git_commander/command/configurator.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module GitCommander
+  class Command
+    # Allows configuring a [GitCommander::Command] with a block
+    class Configurator
+      class ConfigurationError < StandardError; end
+
+      attr_reader :registry
+
+      def initialize(registry)
+        @registry = registry
+      end
+
+      def configure(name, &block)
+        new_command = GitCommander::Command.new(name, registry: registry)
+        new_command.instance_exec new_command, &block if block_given?
+        new_command
+      rescue StandardError => e
+        configuration_error = ConfigurationError.new(e.message)
+        configuration_error.set_backtrace e.backtrace
+        raise configuration_error
+      end
+    end
+  end
+end

data/lib/git_commander/command/loaders/file_loader.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../../loader"
+
+module GitCommander
+  class Command
+    module Loaders
+      # @abstract Handles loading commands from file
+      class FileLoader < ::GitCommander::Loader
+        class FileNotFoundError < StandardError; end
+        class FileLoadError < StandardError; end
+
+        attr_reader :filename
+
+        def load(filename)
+          raw_loader = Raw.new(registry)
+          @result = raw_loader.load(File.read(filename))
+        rescue Errno::ENOENT => e
+          handle_error FileNotFoundError, e
+        rescue StandardError => e
+          handle_error FileLoadError, e
+        end
+
+        private
+
+        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
+end

data/lib/git_commander/command/loaders/raw.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../configurator"
+require_relative "../../loader"
+require_relative "../../plugin/loader"
+
+module GitCommander
+  class Command
+    module Loaders
+      # @abstract Handles loading commands from raw strings
+      class Raw < ::GitCommander::Loader
+        class CommandParseError < StandardError; end
+
+        attr_reader :content
+
+        def load(content = "")
+          @content = content
+          instance_eval @content
+          result
+        # In this case, since we're evaluating raw IO in the context of this
+        # instance, we need to catch a wider range of exceptions.  Otherwise,
+        # syntax errors would blow this up.
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          parse_error = CommandParseError.new(e.message)
+          parse_error.set_backtrace e.backtrace
+          result.errors << parse_error
+          result
+        end
+
+        def command(name, &block)
+          result.commands << Configurator.new(registry).configure(name, &block)
+        rescue 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
+      end
+    end
+  end
+end