git_toolbox 0.7.1 → 0.8.0

data/lib/get/subcommand/commit/prompt.rb

@@ -18,15 +18,14 @@
 # frozen_string_literal: true
 
 require 'highline'
-require 'get/commons/git'
+require_relative '../../commons/git'
 
-# Module for asking to the user informations about a commit message.
+# Module for asking to the user information about a commit message.
 module PromptHandler
-  @@cli = HighLine.new
-
-  @@custom_values_initialized = nil
-  @@custom_types = []
-  @@custom_scopes = []
+  Common.module_instance_value(self, 'cli', 'HighLine.new')
+  Common.module_instance_attr(self, 'custom_values_initialized', false)
+  Common.module_instance_value(self, 'custom_types', [])
+  Common.module_instance_value(self, 'custom_scopes', [])
 
   STRING_VALUE_VALIDATOR = /\s*\S+\s*/
   BODY_END_DELIMITER = "\n\n\n"
@@ -46,14 +45,15 @@ module PromptHandler
 
   def ask_for_type
     extract_types_and_scopes
-    @@cli.choose do |menu|
+
+    MOD_REF.cli.choose do |menu|
       menu.flow = :columns_down
       menu.prompt = 'Choose the type of your commit: '
-      DEFAULT_TYPES.union(@@custom_types).each do |type|
+      DEFAULT_TYPES.union(MOD_REF.custom_types).each do |type|
         menu.choice(type.to_sym)
       end
       menu.choice('Create a new type (rarely needed)') do |_|
-        @@cli.ask('Write the new type to use', String) do |question|
+        MOD_REF.cli.ask('Write the new type to use', String) do |question|
           question.verify_match = true
           question.validate = STRING_VALUE_VALIDATOR
         end
@@ -63,14 +63,14 @@ module PromptHandler
 
   def ask_for_scope
     extract_types_and_scopes
-    @@cli.choose do |menu|
+    MOD_REF.cli.choose do |menu|
       menu.flow = :columns_down
       menu.prompt = 'Choose the scope of your commit: '
-      @@custom_scopes.each do |scope|
+      MOD_REF.custom_scopes.each do |scope|
         menu.choice(scope.to_sym)
       end
       menu.choice('Create a new scope') do |_|
-        @@cli.ask('Write the new scope to use', String) do |question|
+        MOD_REF.cli.ask('Write the new scope to use', String) do |question|
           question.verify_match = true
           question.validate = STRING_VALUE_VALIDATOR
         end
@@ -80,13 +80,13 @@ module PromptHandler
   end
 
   def ask_for_breaking
-    @@cli.agree('Does the commit contain a breaking change? (yes/no) ') do |question|
+    MOD_REF.cli.agree('Does the commit contain a breaking change? (yes/no) ') do |question|
       question.default = false
     end
   end
 
   def ask_for_summary
-    @@cli.ask('The summary of the commit:') do |question|
+    MOD_REF.cli.ask('The summary of the commit:') do |question|
       question.verify_match = true
       question.validate = STRING_VALUE_VALIDATOR
     end
@@ -94,31 +94,33 @@ module PromptHandler
 
   def ask_for_message
     # This method needs a special implementation as the body message can span multiple lines.
-    @@cli.puts('The body of the commit (ends after 3 new lines):')
-    @@cli.input.gets(BODY_END_DELIMITER)
+    MOD_REF.cli.puts('The body of the commit (ends after 3 new lines):')
+    MOD_REF.cli.input.gets(BODY_END_DELIMITER)
   end
 
   private
 
   FIRST_COMMIT = nil
 
+  Common.add_module_self_reference(self)
+
   # This method tries to optimize input parsing by performing multiple operations in one go.
   # So its complexity is a bit higher as it needs to make multiple checks.
   # rubocop:disable Metrics/CyclomaticComplexity
   def extract_types_and_scopes
-    return unless @@custom_values_initialized.nil?
+    return if MOD_REF.custom_values_initialized
 
     Git.with_commit_list_from(FIRST_COMMIT) do |commit_list|
-      commit_list.map do |element|
+      commit_list.reverse.map do |element|
         match = Git::CONVENTIONAL_COMMIT_REGEX.match(element)
         next if match.nil?
 
-        type_already_added = DEFAULT_TYPES.include?(match[1].to_sym) || @@custom_types.include?(match[1])
-        @@custom_types.append(match[1]) unless type_already_added
-        @@custom_scopes.append(match[3]) unless match[3].nil? || @@custom_scopes.include?(match[3])
+        type_already_added = DEFAULT_TYPES.include?(match[1].to_sym) || MOD_REF.custom_types.include?(match[1])
+        MOD_REF.custom_types.append(match[1]) unless type_already_added
+        MOD_REF.custom_scopes.append(match[3]) unless match[3].nil? || MOD_REF.custom_scopes.include?(match[3])
       end
     end
-    @@custom_values_initialized = true
+    MOD_REF.custom_values_initialized = true
   end
   # rubocop:enable Metrics/CyclomaticComplexity
 end

data/lib/get/subcommand/complete/bash_completion.rb

@@ -22,7 +22,7 @@ module BashCompletion
   def bash_completion(main_module, command_name)
     generate_functions(main_module, command_name, INITIAL_LEVEL)
 
-    "#{HEADER}\n#{@@function_stack.reverse.join("\n")}"
+    "#{HEADER}\n#{MOD_REF.function_stack.reverse.join("\n")}"
   end
 
   private
@@ -37,7 +37,8 @@ module BashCompletion
     #
   HEADER
 
-  @@function_stack = []
+  Common.add_module_self_reference(self)
+  Common.module_instance_value(self, 'function_stack', [])
 
   def full_subcommand_name(base, name)
     "#{base}_#{name}"
@@ -74,18 +75,18 @@ module BashCompletion
     short_options = []
     subcommands = []
 
-    command_class.class_variable_get(:@@option_parser).specs.each_value do |option|
+    command_class.instance.option_parser.specs.each_value do |option|
       long_options.push("--#{option.long}")
       short_options.push("-#{option.short.nil? ? option.long[0] : option.short}") if option.short != :none
     end
 
-    command_class.class_variable_get(:@@subcommands).each_key do |subcommand|
+    command_class.instance.subcommands.each_key do |subcommand|
       subcommands.push(subcommand.to_s)
     end
 
-    @@function_stack.push(completion_function_definition(name, level, long_options, short_options, subcommands))
+    MOD_REF.function_stack.push(completion_function_definition(name, level, long_options, short_options, subcommands))
 
-    command_class.class_variable_get(:@@subcommands).each do |element|
+    command_class.instance.subcommands.each do |element|
       generate_functions(element[1].class, full_subcommand_name(name, element[0].to_s), level + 1)
     end
   end

data/lib/get/subcommand/complete/complete.rb

@@ -17,54 +17,49 @@
 
 # frozen_string_literal: true
 
-require 'English'
-require 'get/commons/common'
-require 'get/subcommand/command'
-require 'get/subcommand/complete/bash_completion'
-require 'get'
+require_relative '../../commons/common'
+require_relative '../command'
+require_relative './bash_completion'
+require_relative '../../../get'
 
 # Class length is disabled as most of its length is given by formatting.
 # rubocop:disable Metrics/ClassLength
 # Subcommand, prints the bash completion script.
 class Complete < Command
-  def self.command
-    @@command ||= new
-    @@command
-  end
-
-  private_class_method :new
-
   private
 
   include BashCompletion
 
-  @@command = nil
+  def initialize
+    super() do
+      @usage = 'complete -h|(<subcommand> [<subcommand-options])'
+      @description = 'Print the shell completion script.'
+      @subcommands = {}
+    end
+  end
 
-  @@usage = 'complete -h|(<subcommand> [<subcommand-options])'
-  @@description = 'Print the shell completion script.'
-  @@subcommands = {}
-  # This block is Optimist configuration. It is as long as the number of options of the command.
-  # rubocop:disable Metrics/BlockLength
-  @@option_parser = Optimist::Parser.new do
-    subcommand_max_length = @@subcommands.keys.map { |k| k.to_s.length }.max
-    subcommand_section = <<~SUBCOMMANDS unless @@subcommands.empty?
-      Subcommands:
-      #{@@subcommands.keys.map { |k| "  #{k.to_s.ljust(subcommand_max_length)} => #{@@subcommands[k].description}" }.join("\n")}
-    SUBCOMMANDS
-    usage @@usage
-    synopsis @@description + (subcommand_section.nil? ? '' : "\n") + subcommand_section.to_s
-    opt :shell,
-        'Select the type of shell of which the completion will be generated.',
-        { type: :string, default: 'bash' }
-    educate_on_error
-    stop_on @@subcommands.keys.map(&:to_s)
+  protected
+
+  def setup_option_parser
+    @option_parser = Optimist::Parser.new(
+      @usage,
+      full_description,
+      stop_condition
+    ) do |usage_header, description, stop_condition|
+      usage usage_header
+      synopsis description
+      opt :shell,
+          'Select the type of shell of which the completion will be generated.',
+          { type: :string, default: 'bash' }
+      educate_on_error
+      stop_on stop_condition
+    end
   end
-  # rubocop:enable Metrics/BlockLength
 
-  def initialize
-    super(@@usage, @@description) do
-      @options = Common.with_subcommand_exception_handling @@option_parser do
-        @@option_parser.parse
+  def setup_action
+    @action = lambda do
+      @options = Common.with_subcommand_exception_handling @option_parser do
+        @option_parser.parse
       end
 
       @completions = {

data/lib/get/subcommand/describe/change.rb

@@ -22,50 +22,48 @@ module ChangeHandler
   # Array with change types in ascending order of importance.
   CHANGE_TYPE = %i[NONE PATCH MINOR MAJOR].freeze
 
-  @@major_trigger = 'is_breaking'
-  @@minor_trigger = "type == 'feat'"
-  @@patch_trigger = "type == 'fix'"
+  DEFAULT_MAJOR_TRIGGER = 'is_breaking'
+  DEFAULT_MINOR_TRIGGER = "type == 'feat'"
+  DEFAULT_PATCH_TRIGGER = "type == 'fix'"
 
-  module_function
+  Common.module_instance_attr(self, 'major_trigger', :DEFAULT_MAJOR_TRIGGER)
+  Common.module_instance_attr(self, 'minor_trigger', :DEFAULT_MINOR_TRIGGER)
+  Common.module_instance_attr(self, 'patch_trigger', :DEFAULT_PATCH_TRIGGER)
+
+  def greatest_change_in(commit_list)
+    commit_list
+      .grep(Git::CONVENTIONAL_COMMIT_REGEX)
+      .map { |commit| to_change(commit) }
+      .max { |a, b| CHANGE_TYPE.index(a) <=> CHANGE_TYPE.index(b) }
+  end
+
+  private
 
   # In this block method arguments can be used by user.
   # Also `eval` is needed to allow users to define their custom triggers.
   # rubocop:disable Lint/UnusedMethodArgument
   # rubocop:disable Security/Eval
   def triggers_major?(type, scope, is_breaking)
-    eval(@@major_trigger)
+    eval(ChangeHandler.major_trigger)
   end
 
   def triggers_minor?(type, scope)
-    eval(@@minor_trigger)
+    eval(ChangeHandler.minor_trigger)
   end
 
   def triggers_patch?(type, scope)
-    eval(@@patch_trigger)
+    eval(ChangeHandler.patch_trigger)
   end
   # rubocop:enable Lint/UnusedMethodArgument
   # rubocop:enable Security/Eval
 
-  # Open String class to inject method to convert a (commit) string into
-  # a change.
-  class ::String
-    # Convert the string (as a conventional commit string) into a change type.
-    def to_change
-      groups = Git::CONVENTIONAL_COMMIT_REGEX.match(self)
-      return :MAJOR if ChangeHandler.triggers_major?(groups[1], groups[3], !groups[4].nil?)
-      return :MINOR if ChangeHandler.triggers_minor?(groups[1], groups[2])
-      return :PATCH if ChangeHandler.triggers_patch?(groups[1], groups[2])
+  # Convert the string (as a conventional commit string) into a change type.
+  def to_change(commit_message)
+    groups = Git::CONVENTIONAL_COMMIT_REGEX.match(commit_message)
+    return :MAJOR if triggers_major?(groups[1], groups[3], !groups[4].nil?)
+    return :MINOR if triggers_minor?(groups[1], groups[2])
+    return :PATCH if triggers_patch?(groups[1], groups[2])
 
-      :NONE
-    end
-  end
-
-  public
-
-  def greatest_change_in(commit_list)
-    commit_list
-      .grep(Git::CONVENTIONAL_COMMIT_REGEX)
-      .map(&:to_change)
-      .max { |a, b| CHANGE_TYPE.index(a) <=> CHANGE_TYPE.index(b) }
+    :NONE
   end
 end

data/lib/get/subcommand/describe/describe.rb

@@ -17,24 +17,20 @@
 
 # frozen_string_literal: true
 
-require 'get/commons/common'
-require 'get/commons/git'
-require 'get/subcommand/command'
-require 'get/subcommand/describe/change'
-require 'get/subcommand/describe/prerelease'
-require 'get/subcommand/describe/metadata'
-require 'get/subcommand/describe/docker/docker'
+require_relative '../../commons/common'
+require_relative '../../commons/git'
+require_relative '../command'
+require_relative './change'
+require_relative './prerelease'
+require_relative './metadata'
+require_relative './docker/docker'
 
 # Class length is disabled as most of its length is given by formatting.
 # rubocop:disable Metrics/ClassLength
 # Subcommand, it manages the description of the current git repository using semantic version.
+# All its subcommands should have a method named "describe_current_commit" as it will be called.
 class Describe < Command
-  def self.command
-    @@command ||= new
-    @@command
-  end
-
-  private_class_method :new
+  include Singleton
 
   private
 
@@ -42,8 +38,6 @@ class Describe < Command
   include PrereleaseHandler
   include MetadataHandler
 
-  @@command = nil
-
   DEFAULT_RELEASE_VERSION = '0.1.0'
   FULL_SEMANTIC_VERSION_REGEX = /
       ^((0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)) # Stable version, major, minor, patch
@@ -51,107 +45,41 @@ class Describe < Command
       (?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$ # metadata
     /x
 
-  @@usage = 'describe -h|(<subcommand> [<subcommand-options])'
-  @@description = 'Describe the current git repository with semantic version.'
-  @@subcommands = {
-    docker: DescribeDocker.command,
-  }
-  # This block is Optimist configuration. It is as long as the number of options of the command.
-  # rubocop:disable Metrics/BlockLength
-  @@option_parser = Optimist::Parser.new do
-    subcommand_max_length = @@subcommands.keys.map { |k| k.to_s.length }.max
-    subcommand_section = <<~SUBCOMMANDS unless @@subcommands.empty?
-      Subcommands:
-      #{@@subcommands.keys.map { |k| "  #{k.to_s.ljust(subcommand_max_length)} => #{@@subcommands[k].description}" }.join("\n")}
-    SUBCOMMANDS
-    usage @@usage
-    synopsis @@description + (subcommand_section.nil? ? '' : "\n") + subcommand_section.to_s
-    opt :prerelease,
-        'Describe a prerelease rather than a release',
-        short: :none
-    opt :exclude_metadata,
-        'Do not include metadata in version.'
-    opt :metadata,
-        'Set which metadata to include in the string. ' \
-        'Multiple value can be specified by separating the with a comma \',\'.',
-        { type: :string, default: 'sha' }
-    opt :major_trigger,
-        'Set the trigger for a major release. ' \
-        'This must be a valid Ruby expression. ' \
-        'In this expression the string values "type" and "scope" ' \
-        'and the boolean value "is_breaking" can be used.',
-        { short: :none, type: :string, default: 'is_breaking' }
-    opt :minor_trigger,
-        'Set the trigger for a minor release. ' \
-        'This must be a valid Ruby expression. ' \
-        'In this expression the string values "type" and "scope" can be used.',
-        { short: :none, type: :string, default: "type == 'feat'" }
-    opt :patch_trigger,
-        'Set the trigger for a patch release. ' \
-        'This must be a valid Ruby expression. ' \
-        'In this expression the string values "type" and "scope" can be used.',
-        { short: :none, type: :string, default: "type == 'fix'" }
-    opt :prerelease_pattern,
-        'Set the pattern of the prerelease. This must contain the placeholder "(p)".',
-        { short: :none, type: :string, default: 'dev(p)' }
-    opt :old_prerelease_pattern,
-        'Set the pattern of the old prerelease. It is useful for changing prerelease pattern.',
-        { short: :none, type: :string, default: 'prerelease-pattern value' }
-    opt :diff,
-        'Print also the last version.'
-    opt :create_tag,
-        'Create a signed tag with the computed version.',
-        { short: :none }
-    opt :tag_message,
-        'Add the given message to the tag. Requires "--create-tag".',
-        { short: :none, type: :string }
-    educate_on_error
-    stop_on @@subcommands.keys.map(&:to_s)
-  end
-  # rubocop:enable Metrics/BlockLength
-
   def initialize
-    super(@@usage, @@description) do
-      @options = Common.with_subcommand_exception_handling @@option_parser do
-        @@option_parser.parse
-      end
-      Common.error 'describe need to be run inside a git repository' unless Git.in_repo?
-      set_options
-
-      if ARGV.length.positive?
-        subcommand = ARGV.shift.to_sym
-        if @@subcommands.include?(subcommand)
-          @@subcommands[subcommand].action.call(describe_current_commit)
-        else
-          # This error should not be disabled by -W0
-          # rubocop:disable Style/StderrPuts
-          $stderr.puts "Error: subcommand '#{subcommand}' unknown."
-          # rubocop:enable Style/StderrPuts
-          exit 1
-        end
-      else
-        puts describe_current_commit
-      end
+    super() do
+      @usage = 'describe -h|(<subcommand> [<subcommand-options])'
+      @description = 'Describe the current git repository with semantic version.'
+      @subcommands = {
+        docker: DescribeDocker.instance,
+      }
     end
   end
 
   def set_options
-    @@major_trigger = @options[:major_trigger] if @options[:major_trigger_given]
-    @@minor_trigger = @options[:minor_trigger] if @options[:minor_trigger_given]
-    @@patch_trigger = @options[:patch_trigger] if @options[:patch_trigger_given]
-    @@old_prerelease_pattern = @options[:old_prerelease_pattern] if @options[:old_prerelease_pattern_given]
-    @@prerelease_pattern = @options[:prerelease_pattern] if @options[:prerelease_pattern_given]
+    ChangeHandler.major_trigger = @options[:major_trigger] if @options[:major_trigger_given]
+    ChangeHandler.minor_trigger = @options[:minor_trigger] if @options[:minor_trigger_given]
+    ChangeHandler.patch_trigger = @options[:patch_trigger] if @options[:patch_trigger_given]
+    if @options[:old_prerelease_pattern_given]
+      PrereleaseHandler.old_prerelease_pattern = @options[:old_prerelease_pattern]
+    end
+    PrereleaseHandler.prerelease_pattern = @options[:prerelease_pattern] if @options[:prerelease_pattern_given]
   end
 
   def describe_current_commit
-    return Git.last_version if Git.with_commit_list_from(Git.last_version, &:empty?)
-
-    puts "Last version: #{Git.last_version}" if @options[:diff]
+    if Git.with_commit_list_from(Git.last_version, &:empty?)
+      if Git.last_version.nil?
+        Common.error('Cannot describe an empty repository.')
+      else
+        Git.last_version
+      end
+    else
+      puts "Last version: #{Git.last_version}" if @options[:diff]
 
-    current_commit_version = next_release
-    create_signed_tag(current_commit_version) if @options[:create_tag]
+      current_commit_version = next_release
+      create_signed_tag(current_commit_version) if @options[:create_tag]
 
-    current_commit_version
+      current_commit_version
+    end
   end
 
   def next_release
@@ -207,17 +135,87 @@ class Describe < Command
   end
 
   def create_signed_tag(computed_version)
-    system(
-      'git tag -s ' \
-      "#{
-        if @options[:tag_message_given]
-          "-m #{@options[:tag_message]}"
+    tag_message_cli = if @options[:tag_message_given]
+                        "\"#{@options[:tag_message].gsub('"', '\"')}\""
+                      else
+                        '""'
+                      end
+    CommandIssuer.run('git', 'tag', '-s', '-m', tag_message_cli, "'#{computed_version}'")
+  end
+
+  protected
+
+  def setup_option_parser
+    @option_parser = Optimist::Parser.new(
+      @usage,
+      full_description,
+      stop_condition
+    ) do |usage_header, description, stop_condition|
+      usage usage_header
+      synopsis description
+      opt :prerelease,
+          'Describe a prerelease rather than a release',
+          short: :none
+      opt :exclude_metadata,
+          'Do not include metadata in version.'
+      opt :metadata,
+          'Set which metadata to include in the string. ' \
+          'Multiple value can be specified by separating the with a comma \',\'.',
+          { type: :string, default: 'sha' }
+      opt :major_trigger,
+          'Set the trigger for a major release. ' \
+          'This must be a valid Ruby expression. ' \
+          'In this expression the string values "type" and "scope" ' \
+          'and the boolean value "is_breaking" can be used.',
+          { short: :none, type: :string, default: 'is_breaking' }
+      opt :minor_trigger,
+          'Set the trigger for a minor release. ' \
+          'This must be a valid Ruby expression. ' \
+          'In this expression the string values "type" and "scope" can be used.',
+          { short: :none, type: :string, default: "type == 'feat'" }
+      opt :patch_trigger,
+          'Set the trigger for a patch release. ' \
+          'This must be a valid Ruby expression. ' \
+          'In this expression the string values "type" and "scope" can be used.',
+          { short: :none, type: :string, default: "type == 'fix'" }
+      opt :prerelease_pattern,
+          'Set the pattern of the prerelease. This must contain the placeholder "(p)".',
+          { short: :none, type: :string, default: 'dev(p)' }
+      opt :old_prerelease_pattern,
+          'Set the pattern of the old prerelease. It is useful for changing prerelease pattern.',
+          { short: :none, type: :string, default: 'prerelease-pattern value' }
+      opt :diff,
+          'Print also the last version.'
+      opt :create_tag,
+          'Create a signed tag with the computed version.',
+          { short: :none }
+      opt :tag_message,
+          'Add the given message to the tag. Requires "--create-tag".',
+          { short: :none, type: :string }
+      educate_on_error
+      stop_on stop_condition
+    end
+  end
+
+  def setup_action
+    @action = lambda do
+      @options = Common.with_subcommand_exception_handling @option_parser do
+        @option_parser.parse
+      end
+      Common.error 'describe need to be run inside a git repository' unless Git.in_repo?
+      set_options
+
+      if ARGV.length.positive?
+        subcommand = ARGV.shift.to_sym
+        if @subcommands.include?(subcommand)
+          @subcommands[subcommand].action.call(describe_current_commit)
         else
-          ''
+          Common.error "subcommand '#{subcommand}' unknown."
         end
-      } " \
-      "'#{computed_version}'"
-    )
+      else
+        puts describe_current_commit
+      end
+    end
   end
 end
 # rubocop:enable Metrics/ClassLength