git_toolbox 0.7.2 → 0.9.0

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,105 +38,24 @@ 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
-      (?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))? # prerelease
-      (?:\+([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
@@ -162,68 +77,101 @@ class Describe < Command
 
   def next_release
     if @options[:prerelease]
-      prepare_prerelease_tag(Git.last_release, Git.last_version)
+      updated_stable_version(Git.last_release)
+        .then { |stable| "#{stable}-#{updated_prerelease(Git.last_version, stable)}" }
     else
-      prepare_release_tag(Git.last_release)
+      updated_stable_version(Git.last_release).to_s
     end + metadata
   end
 
-  def prepare_release_tag(last_release)
-    updated_stable_version(last_release).to_s
-  end
+  def metadata
+    return '' if @options[:exclude_metadata] || @options[:metadata].empty?
 
-  def prepare_prerelease_tag(last_release, last_version)
-    new_stable_version = updated_stable_version(last_release)
-    base_version_match_data = FULL_SEMANTIC_VERSION_REGEX.match(last_version)
-    no_changes_from_last_release = base_version_match_data[1] == new_stable_version && base_version_match_data[5].nil?
-    Common.error 'No changes from last release' if no_changes_from_last_release
-    new_stable_version +
-      "-#{updated_prerelease(base_version_match_data[5], need_reset: base_version_match_data[1] != new_stable_version)}"
+    "+#{compute_metadata(@options[:metadata])}"
   end
 
-  def updated_stable_version(stable_version)
-    return 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
+  def create_signed_tag(computed_version)
+    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
 
-  # Return the updated prerelease number
-  def updated_prerelease(prerelease = nil, need_reset: false)
-    compute_prerelease(prerelease, need_reset: prerelease.nil? || need_reset)
+  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
 
-  # Compute the metadata string
-  def metadata
-    return '' if @options[:exclude_metadata] || @options[:metadata].empty?
-
-    "+#{compute_metadata(@options[:metadata])}"
-  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
 
-  def create_signed_tag(computed_version)
-    system(
-      'git tag -s ' \
-      "#{
-        if @options[:tag_message_given]
-          "-m #{@options[:tag_message]}"
+      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

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

@@ -17,82 +17,43 @@
 
 # frozen_string_literal: true
 
-require 'get/commons/common'
-require 'get/commons/git'
-require 'get/subcommand/command'
+require_relative '../../../commons/common'
+require_relative '../../../commons/git'
+require_relative '../../command'
 
 # 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.
 class DescribeDocker < Command
-  def self.command
-    @@command ||= new
-    @@command
-  end
-
-  private_class_method :new
-
   private
 
   INCREMENTAL_VERSION_PATTERN = /(((\d+)\.\d+)\.\d+)/
 
-  @@command = nil
-
-  @@usage = 'describe docker -h|(<subcommand> [<subcommand-options])'
-  @@description = 'Describe the current git repository with a list of version for docker'
-  @@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
-    usage @@usage
-    synopsis <<~SUBCOMMANDS unless @@subcommands.empty?
-      Subcommands:
-      #{@@subcommands.keys.map { |k| "  #{k.to_s.ljust(subcommand_max_length)} => #{@@subcommands[k].description}" }.join("\n")}
-    SUBCOMMANDS
-    opt :separator,
-        'Use the given value as separator for versions',
-        { type: :string, default: '\n' }
-    opt :not_latest,
-        'Do not include "latest" in the version list.',
-        short: :none
-    opt :substitute_plus,
-        'Set which character will be used in place of "+".',
-        { type: :string, short: :none }
-    educate_on_error
-    stop_on @@subcommands.keys.map(&:to_s)
-  end
-  # rubocop:enable Metrics/BlockLength
-
   def initialize
-    super(@@usage, @@description) do |version|
-      Common.error 'describe need to be run inside a git repository' unless Git.in_repo?
-      @options = Common.with_subcommand_exception_handling @@option_parser do
-        @@option_parser.parse
-      end
-      set_options
-
-      puts version_list_from(version).join(@@separator)
+    super() do
+      @usage = 'describe docker -h|(<subcommand> [<subcommand-options])'
+      @description = 'Describe the current git repository with a list of version for docker'
+      @subcommands = {}
     end
   end
 
   def set_options
-    @@separator = if @options[:separator_given]
-                    @options[:separator]
-                  else
-                    "\n"
-                  end
-    @@not_latest = @options[:not_latest]
-    @@plus_substitution = if @options[:substitute_plus_given]
-                            @options[:substitute_plus]
-                          else
-                            '+'
-                          end
+    @separator = if @options[:separator_given]
+                   @options[:separator]
+                 else
+                   "\n"
+                 end
+    @not_latest = @options[:not_latest]
+    @plus_substitution = if @options[:substitute_plus_given]
+                           @options[:substitute_plus]
+                         else
+                           '+'
+                         end
   end
 
   def version_list_from(full_version)
     [
-      full_version.sub('+', @@plus_substitution),
+      full_version.sub('+', @plus_substitution),
       reduced_versions(full_version),
       latest
     ]
@@ -114,5 +75,41 @@ class DescribeDocker < Command
       ['latest']
     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 :separator,
+          'Use the given value as separator for versions',
+          { type: :string, default: '\n' }
+      opt :not_latest,
+          'Do not include "latest" in the version list.',
+          short: :none
+      opt :substitute_plus,
+          'Set which character will be used in place of "+".',
+          { type: :string, short: :none }
+      educate_on_error
+      stop_on stop_condition
+    end
+  end
+
+  def setup_action
+    @action = lambda do |version|
+      Common.error 'describe need to be run inside a git repository' unless Git.in_repo?
+      @options = Common.with_subcommand_exception_handling @option_parser do
+        @option_parser.parse
+      end
+      set_options
+
+      puts version_list_from(version).join(@separator)
+    end
+  end
 end
 # rubocop:enable Metrics/ClassLength

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

@@ -17,37 +17,34 @@
 
 # frozen_string_literal: true
 
+require_relative '../../commons/command_issuer'
+
 # Module with methods to handle tag metadata.
 #
 # To add a new metadata type, create a new method and link it to a symbol.
 module MetadataHandler
-  @@metadata_computers = {}
+  def compute_metadata(metadata_specs)
+    requested_metadata = metadata_specs.split(',')
+    unless requested_metadata.all? { |element| metadata_computers.include?(element.to_sym) }
+      Common.error('Some of the metadata requested are not supported')
+    end
+    requested_metadata.map { |element| metadata_computers[element.to_sym].call }.join('-')
+  end
 
-  module_function
+  private
 
   def last_commit_sha
-    `git --no-pager log -n 1 --pretty=%h`.strip
+    CommandIssuer.run('git', '--no-pager', 'log', '-n', '1', '--pretty=%h').output.strip
   end
 
   def current_date
     Time.now.strftime('%0Y%0m%0d')
   end
 
-  def init_computers
-    @@metadata_computers[:sha] = proc { last_commit_sha }
-    @@metadata_computers[:date] = proc { current_date }
-  end
-
-  public
-
-  def compute_metadata(metadata_specs)
-    metadata_specs
-      .split(',')
-      .map { |element| @@metadata_computers[element.to_sym].call }
-      .join('-')
-  end
-
-  def self.included(_mod)
-    init_computers
+  def metadata_computers
+    @metadata_computers ||= {
+      sha: proc { last_commit_sha },
+      date: proc { current_date },
+    }
   end
 end

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

@@ -22,19 +22,36 @@ module PrereleaseHandler
   FIRST_PRERELEASE = 1
   DEFAULT_PRERELEASE_STRING = 'dev'
   PRERELEASE_PLACEHOLDER = '(p)'
+  DEFAULT_PRERELEASE_PATTERN = "#{DEFAULT_PRERELEASE_STRING}#{PRERELEASE_PLACEHOLDER}".freeze
 
-  @@prerelease_pattern = "#{DEFAULT_PRERELEASE_STRING}#{PRERELEASE_PLACEHOLDER}"
-  @@old_prerelease_pattern = proc { @@prerelease_pattern }
+  Common.module_instance_attr(self, 'prerelease_pattern', :DEFAULT_PRERELEASE_PATTERN)
+  Common.module_instance_attr(self, 'old_prerelease_pattern', 'proc { prerelease_pattern }')
 
-  module_function
+  def updated_prerelease(last_version, new_stable_version)
+    if last_version.nil?
+      compute_prerelease(nil, need_reset: true)
+    else
+      base_version_match_data = Git::FULL_SEMANTIC_VERSION_REGEX.match(last_version)
+      no_changes_from_last_release = base_version_match_data[1] == new_stable_version &&
+                                     base_version_match_data[5].nil?
+      Common.error 'No changes from last release' if no_changes_from_last_release
+      compute_prerelease(base_version_match_data[5], need_reset: base_version_match_data[1] != new_stable_version)
+    end
+  end
+
+  private
+
+  def compute_prerelease(current_prerelease, need_reset: false)
+    pattern_changed = PrereleaseHandler.prerelease_pattern != actual_old_prerelease_pattern
+    new_prerelease = if need_reset || pattern_changed
+                       FIRST_PRERELEASE
+                     else
+                       extract_prerelease_number(current_prerelease) + 1
+                     end.to_s
+    PrereleaseHandler.prerelease_pattern.sub(PRERELEASE_PLACEHOLDER, new_prerelease)
+  end
 
   def extract_prerelease_number(current_prerelease)
-    actual_old_prerelease_pattern =
-      if @@old_prerelease_pattern.respond_to?('call')
-        @@old_prerelease_pattern.call
-      else
-        @@old_prerelease_pattern
-      end
     Common.error "The given old pattern does not contains the placeholder '(p)'" unless
       actual_old_prerelease_pattern.include?(PRERELEASE_PLACEHOLDER)
     old_prerelease_regex = actual_old_prerelease_pattern.sub(PRERELEASE_PLACEHOLDER, '(\\d+)')
@@ -46,10 +63,11 @@ module PrereleaseHandler
     end
   end
 
-  public
-
-  def compute_prerelease(current_prerelease, need_reset: false)
-    new_prerelease = (need_reset ? FIRST_PRERELEASE : (extract_prerelease_number(current_prerelease) + 1)).to_s
-    @@prerelease_pattern.sub(PRERELEASE_PLACEHOLDER, new_prerelease)
+  def actual_old_prerelease_pattern
+    if PrereleaseHandler.old_prerelease_pattern.respond_to?('call')
+      PrereleaseHandler.old_prerelease_pattern.call
+    else
+      PrereleaseHandler.old_prerelease_pattern
+    end
   end
 end

data/lib/get/subcommand/init/init.rb

@@ -17,60 +17,28 @@
 
 # frozen_string_literal: true
 
-require 'English'
-require 'get/commons/common'
-require 'get/commons/git'
-require 'get/subcommand/command'
+require_relative '../../commons/common'
+require_relative '../../commons/git'
+require_relative '../command'
 
 # Class length is disabled as most of its length is given by formatting.
 # rubocop:disable Metrics/ClassLength
 # Subcommand, it allow to create a new repository and add an initial, empty commit to it.
 class Init < Command
-  def self.command
-    @@command ||= new
-    @@command
-  end
-
-  private_class_method :new
-
   private
 
-  @@command = nil
-
-  @@usage = 'init -h|(<subcommand> [<subcommand-options])'
-  @@description = 'Initialize a new git repository with an initial empty commit.'
-  @@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 :empty,
-        'Do not create the first, empty commit.'
-    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 'The current directory is already a git repository' if Git.in_repo?
-
-      init_repository
+    super() do
+      @usage = 'init -h|(<subcommand> [<subcommand-options])'
+      @description = 'Initialize a new git repository with an initial empty commit.'
+      @subcommands = {}
     end
   end
 
   def init_repository
-    `git init`
-    Common.error 'Failed to init the repository' if $CHILD_STATUS.exitstatus.positive?
+    command_result = CommandIssuer.run('git', 'init')
+
+    Common.error 'Failed to init the repository' if command_result.exit_status.positive?
 
     create_first_commit unless @options[:empty]
 
@@ -78,8 +46,39 @@ class Init < Command
   end
 
   def create_first_commit
-    `git commit --allow-empty -m "chore: initialize repository"`
-    Common.error 'Failed to create first commit' if $CHILD_STATUS.exitstatus.positive?
+    command_result = CommandIssuer.run('git', 'commit', '--allow-empty', '-m', '"chore: initialize repository"')
+    Common.error "Failed to create first commit: #{command_result.error}" if command_result.exit_status.positive?
+  end
+
+  protected
+
+  def setup_option_parser
+    # 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(
+      @usage,
+      full_description,
+      stop_condition
+    ) do |usage_header, description, stop_condition|
+      usage usage_header
+      synopsis description
+      opt :empty,
+          'Do not create the first, empty commit.'
+      educate_on_error
+      stop_on stop_condition
+    end
+    # rubocop:enable Metrics/BlockLength
+  end
+
+  def setup_action
+    @action = lambda do
+      @options = Common.with_subcommand_exception_handling @option_parser do
+        @option_parser.parse
+      end
+      Common.error 'The current directory is already a git repository' if Git.in_repo?
+
+      init_repository
+    end
   end
 end
 # rubocop:enable Metrics/ClassLength