git_toolbox 0.7.2 → 0.9.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,12 +22,16 @@ 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
 
   INITIAL_LEVEL = 1
+  NOT_NEGABLE_OPTIONS = [
+    'help',
+    'version',
+  ].freeze
 
   HEADER = <<~HEADER
     #!/usr/bin/env bash
@@ -37,7 +41,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 +79,19 @@ 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}")
+      long_options.push("--no-#{option.long}") if option.flag? && !NOT_NEGABLE_OPTIONS.include?(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,66 +17,77 @@
 
 # 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
-
-  @@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)
-  end
-  # rubocop:enable Metrics/BlockLength
-
   def initialize
-    super(@@usage, @@description) do
-      @options = Common.with_subcommand_exception_handling @@option_parser do
-        @@option_parser.parse
-      end
-
+    super() do
+      @usage = 'complete -h|(<subcommand> [<subcommand-options])'
+      @description = 'Print the shell completion script. ' \
+                     'Run \'get complete --info\' to learn how to install the completion.'
+      @subcommands = {}
       @completions = {
-        bash: proc { bash_completion(Get, 'get') }
+        bash: {
+          generator: proc { bash_completion(Get, 'get') },
+          info: <<~INFO
+            Add the following line to your .bashrc (or a sourced script):
+            eval "$(get complete)" && complete -F _get_completion get
+          INFO
+        }
       }
+    end
+  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 :shell,
+          'Select the type of shell of which the completion will be generated.',
+          { type: :string, default: 'bash' }
+      opt :info,
+          'Print the instructions to install the completion for the selected shell.',
+          { short: :none }
+      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
 
       selected_shell = @options[:shell].to_sym
 
+      print_info_and_exit(selected_shell) if @options[:info]
+
       Common.error "Completion for shell '#{selected_shell}' not available." unless @completions.key?(selected_shell)
 
-      puts @completions[selected_shell].call
+      puts @completions[selected_shell][:generator].call
     end
   end
+
+  def print_info_and_exit(selected_shell)
+    puts @completions[selected_shell][:info]
+    exit 0
+  end
 end
 # rubocop:enable Metrics/ClassLength

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

@@ -22,50 +22,67 @@ 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 updated_stable_version(stable_version)
+    return Git::DEFAULT_RELEASE_VERSION if stable_version.nil?
+
+    greatest_change_from_stable_version = Git.with_commit_list_from(stable_version) do |commits_from_version|
+      greatest_change_in(commits_from_version)
+    end
+    split_version = stable_version.split('.')
+    case greatest_change_from_stable_version
+    when :MAJOR
+      "#{split_version[0].to_i + 1}.0.0"
+    when :MINOR
+      "#{split_version[0].to_i}.#{split_version[1].to_i + 1}.0"
+    when :PATCH
+      "#{split_version[0].to_i}.#{split_version[1].to_i}.#{split_version[2].to_i + 1}"
+    else
+      "#{split_version[0].to_i}.#{split_version[1].to_i}.#{split_version[2].to_i}"
+    end
+  end
+
+  private
+
+  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
 
   # 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])
-
-      :NONE
-    end
-  end
-
-  public
+  # 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[3])
+    return :PATCH if triggers_patch?(groups[1], groups[3])
 
-  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