rlt 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 8da7586a22e7a30c47783bdd63909e61e16e45be6f995c0443ba85fac3a3a054
-  data.tar.gz: 3af912d1b8183616a323220962098ed5ffb628f9f9d6ea096a3b3b60c6797058
+SHA1:
+  metadata.gz: e8103d3ed650fed8f99f8e0c57f5515c66849626
+  data.tar.gz: 65012e4e9b016e389e82b9db9206cd4b952f0766
 SHA512:
-  metadata.gz: 214bcde24666186a54441671bc0fedba0506d777a3bfd4aef18bff319368d50a36c10ff51b549e3acc4b3c63444409a5faa671bf44c1e990ae301ff5046bc66a
-  data.tar.gz: 45d85c1a76f73a3f375ba69a9f0f8d8f619e6e26c9172e3f070eddb9eb504e4abfc2bc615a19e0bad4fa1224fdda14919ba3e64b13c2f0406848d0d656aebc4e
+  metadata.gz: 88122ab1296aba40b00b3469883d1dbe8025db9031fd44cd43934d924e3da7951de0486e9b7030192a2214d3b24c70ea9984627f264d214a9039d7a27417832f
+  data.tar.gz: 98adfc71e188bf936dc9887ea61bf951fb0b6047a5447f20aaa1d7486d71b5f046a0a427bc166853940441d63f6bca492da75f8708175bdab8912c44a0309c31

data/exe/rlt

@@ -2,8 +2,18 @@
 
 # frozen_string_literal: true
 
-$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+$LOAD_PATH << File.expand_path('lib', __dir__)
 
 require 'rlt'
 
-Rlt.run(ARGV)
+begin
+  Rlt::CLI.start(ARGV)
+rescue TTY::Reader::InputInterrupt
+  puts ''
+  # ignore
+rescue TTY::Command::ExitError
+  puts ''
+  # ignore
+rescue Rlt::GitNativeCommandError
+  Rlt::Utils::GitUtil.execute_native_command(ARGV)
+end

data/lib/rlt/cli.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'rlt/commands/cmt'
+require 'rlt/commands/switch'
+require 'rlt/commands/close'
+
+module Rlt
+  class CLI < Thor
+    def self.handle_no_command_error(command)
+      raise GitNativeCommandError if Utils::GitUtil::NATIVE_COMMANDS.include? command
+      super
+    end
+
+    def self.command_name(klass)
+      Utils::StringUtil.underscore(klass.name.split('::').last)
+    end
+
+    def self.run(klass, *arguments)
+      config = Rlt.config('command', command_name(klass))
+      klass.send(:run, config, *arguments)
+    end
+
+    desc 'cmt', 'Commit with structured commit message'
+    method_option :add_all,
+                  aliases: '-a',
+                  desc: 'Add all before commit',
+                  type: :boolean, default: false
+    def cmt
+      CLI.run Rlt::Commands::Cmt, options.add_all?
+    end
+
+    desc 'switch <branch_name>', 'Switch branches with auto stash/unstash'
+    def switch(branch_name)
+      CLI.run Rlt::Commands::Switch, branch_name
+    end
+
+    desc 'close', 'Delete current branch and merge it to master'
+    def close
+      CLI.run Rlt::Commands::Close
+    end
+  end
+end

data/lib/rlt/commands/close.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Rlt
+  module Commands
+    class Close
+      def self.run(config)
+        master_branch = master_branch(config)
+        current_branch_name = Utils::GitUtil.current_branch_name
+        return if should_stop?(master_branch, config)
+        run_internal(current_branch_name, master_branch)
+        Utils::Logger.info "Done closing `#{current_branch_name}`."
+      end
+
+      def self.run_internal(current_branch_name, master_branch)
+        merge_back_and_forth(current_branch_name, master_branch)
+        delete_branch(current_branch_name)
+      end
+
+      def self.should_stop?(master_branch, config)
+        return true if uncommitted_changes?
+        return true if config_not_existing?(config)
+        return true if master_branch_now?(master_branch)
+      end
+
+      def self.uncommitted_changes?
+        result = Utils::GitUtil.uncommitted_change?
+        print_uncommitted_changes_error if result
+        result
+      end
+
+      def self.config_not_existing?(config)
+        result = config['master_branch'].nil?
+        print_explicit_config_error if result
+        result
+      end
+
+      def self.master_branch_now?(master_branch)
+        result = Utils::GitUtil.current_branch_name == master_branch
+        print_master_branch_now_error(master_branch) if result
+        result
+      end
+
+      def self.master_branch(config)
+        config['master_branch']
+      end
+
+      def self.merge_back_and_forth(current_branch_name, master_branch)
+        Utils::GitUtil.merge_from(master_branch, print_info: true)
+        return if any_conflict?
+        Utils::GitUtil.checkout(master_branch, print_info: true)
+        Utils::GitUtil.merge_from(current_branch_name, print_info: true)
+      end
+
+      def self.any_conflict?
+        result = Utils::GitUtil.any_conflict?
+        print_conflict_error if result
+        result
+      end
+
+      def self.print_uncommitted_changes_error
+        Utils::Logger.error 'There are uncommitted changes.'
+        Utils::Logger.error 'Commit them first!'
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def self.print_explicit_config_error
+        Utils::Logger.error 'You must explicitly configure name of master branch at `.rlt.yml`'
+        Utils::Logger.error 'For example,'
+        Utils::Logger.error ''
+        Utils::Logger.error '# .rlt.yml'
+        Utils::Logger.error 'command:'
+        Utils::Logger.error '  close:'
+        Utils::Logger.error '    master_branch: master'
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def self.print_master_branch_now_error(master_branch)
+        Utils::Logger.error "You cannot close `#{master_branch}`."
+      end
+
+      def self.print_conflict_error
+        Utils::Logger.error 'Aborting the process due to the conflict.'
+        Utils::Logger.error 'Resolve them first, and try it again.'
+      end
+
+      def self.delete_branch(current_branch_name)
+        Utils::GitUtil.delete_branch(current_branch_name, print_info: true)
+        Utils::GitUtil.remotes.each do |remote|
+          Utils::GitUtil.safely_delete_remote_branch(remote, current_branch_name, print_info: true)
+        end
+      end
+    end
+  end
+end

data/lib/rlt/commands/{cmt_command.rb → cmt.rb}

@@ -6,22 +6,18 @@ require 'tmpdir'
 
 module Rlt
   module Commands
-    class CmtCommand < BaseCommand
-      CONF_SUBJECT_TEMPLATE = 'subject_template'.freeze
-      CONF_BODY_TEMPLATE = 'body_template'.freeze
+    class Cmt
+      CONF_SUBJECT_TEMPLATE = 'subject_template'
+      CONF_BODY_TEMPLATE = 'body_template'
 
-      def self.run(config, *arguments)
-        branch_name = acquire_branch_name
-        puts "Commiting to '#{ColoredText.info(branch_name)}'\n\n"
+      def self.run(config, add_all)
+        branch_name = Utils::GitUtil.current_branch_name
+        Utils::Logger.info "Committing to '#{branch_name}'"
         (subject, body) = subject_and_body(config, branch_name)
-        add_all if arguments[0] == '-a'
+        Utils::GitUtil.add_all if add_all
         commit(subject, body)
       end
 
-      def self.add_all
-        Shell.new.run 'git', 'add', '.'
-      end
-
       def self.subject_and_body(config, branch_name)
         subject = adjust_subject_template(ask_subject, config, branch_name)
         body = adjust_body_template(ask_body, config, branch_name)
@@ -29,27 +25,20 @@ module Rlt
       end
 
       def self.commit(subject, body)
-        commit_msg_file_path = "#{Dir.tmpdir}/.rlt.commit.msg.#{short_random_string}"
-        File.write(commit_msg_file_path, "#{subject}\n\n#{body}".strip)
-        Shell.new.run 'git', 'commit', '-F', commit_msg_file_path
-        File.delete(commit_msg_file_path)
-      end
-
-      def self.short_random_string
-        (0...4).map { rand(65..90).chr }.join
+        Utils::GitUtil.commit_with_long_message("#{subject}\n\n#{body}".strip)
       end
 
       def self.ask_subject
         prompt = TTY::Prompt.new
-        prompt.ask('Subject:', active_color: :cyan) do |q|
+        prompt.ask('Subject:', active_color: :magenta) do |q|
           q.required true
           q.modify :capitalize
-        end
+        end.gsub(/\.$/, '')
       end
 
       def self.ask_body
-        puts 'Body: ' + ColoredText.desc('(Insert empty line to finish)')
-        lines = ask_multiline_until_done('>', :cyan)
+        puts 'Body: (Insert empty line to finish)'
+        lines = ask_multiline_until_done('>', :magenta)
         lines.join("\n")
       end
 
@@ -76,21 +65,6 @@ module Rlt
         return body if config.nil? || template.nil?
         ERB.new(template).result binding
       end
-
-      def self.acquire_branch_name
-        `git rev-parse --abbrev-ref HEAD`.strip
-      end
-
-      def self.print_help(*_arguments)
-        puts 'USAGE:'
-        puts '  1. rlt commit # Almost same as `git commit`. You do not need `-m` parameter here.'
-        puts ''
-        puts '  2. rlt commit -a # This performs `git add .` before committing.'
-      end
-
-      def self.valid_parameters?(*arguments)
-        arguments.empty? || (arguments.size == 1 && arguments[0] == '-a')
-      end
     end
   end
 end

data/lib/rlt/commands/switch.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'erb'
+
+module Rlt
+  module Commands
+    class Switch
+      CONF_BRANCH_NAME_TEMPLATE = 'branch_name_template'
+
+      def self.run(config, branch_name)
+        modified_branch_name = change_branch_name(config, branch_name)
+        save_stash_if_any
+        switch(modified_branch_name)
+        apply_stash_if_any(modified_branch_name)
+      end
+
+      def self.change_branch_name(config, branch_name)
+        return branch_name if dont_change_branch_name?(config, branch_name)
+        branch_name_template = config[CONF_BRANCH_NAME_TEMPLATE]
+        return branch_name if branch_name_template.nil?
+        ERB.new(branch_name_template).result binding
+      end
+
+      def self.save_stash_if_any
+        return if Utils::GitUtil.uncommitted_change?
+        Utils::GitUtil.save_stash('Auto stash', print_info: true)
+      end
+
+      def self.apply_stash_if_any(branch_name)
+        stash_name = Utils::GitUtil.latest_stash_name(branch_name)
+        return if stash_name.nil?
+        Utils::GitUtil.apply_stash(stash_name, print_info: true)
+        Utils::GitUtil.drop_stash(stash_name, print_info: true)
+      end
+
+      def self.dont_change_branch_name?(config, branch_name)
+        list = %w[master develop] + (config['exclude'] || [])
+        list.include? branch_name
+      end
+
+      def self.switch(branch_name)
+        create_and_checkout(branch_name) unless checkout(branch_name)
+      end
+
+      def self.checkout(branch_name)
+        result = Utils::GitUtil.silently_try_checkout(branch_name)
+        Utils::Logger.info "Switched to '#{branch_name}'." if result
+        result
+      end
+
+      def self.create_and_checkout(branch_name)
+        Utils::GitUtil.silently_create_and_checkout(branch_name)
+        Utils::Logger.info "Created & Switched to '#{branch_name}'."
+      end
+    end
+  end
+end

data/lib/rlt/config.rb

@@ -7,11 +7,11 @@ module Rlt
     def config(category, command)
       c = config_map.dig category, command
       return c unless c.nil?
-      return {} if command == original_name(command)
-      config_map.dig(category, original_name(command)) || {}
+      return {} if command == original_name_of_alias(command)
+      config_map.dig(category, original_name_of_alias(command)) || {}
     end
 
-    def original_name(command)
+    def original_name_of_alias(command)
       config_map.dig 'alias', command
     end
 
@@ -28,15 +28,15 @@ module Rlt
     end
 
     def file_path
-      if Rlt.debug
-        "#{Dir.pwd}/.rlt.sample.yml"
-      else
-        "#{Dir.pwd}/.rlt.yml"
-      end
+      sample_config_path = "#{Dir.pwd}/.rlt.sample.yml"
+      return sample_config_path if Rlt.debug && File.exist?(sample_config_path)
+      "#{Dir.pwd}/.rlt.yml"
     end
 
     def config_map
       (@config_map ||= load_config)
     end
   end
+
+  extend Config
 end

data/lib/rlt/debug.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rlt
+  def self.debug
+    ENV['RLT_DEBUG']
+  end
+end

data/lib/rlt/error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Rlt
+  class GitNativeCommandError < StandardError
+  end
+end

data/lib/rlt/utils/colored_text.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'pastel'
+
+module Rlt
+  module Utils
+    class ColoredText
+      def self.verbose(msg)
+        Pastel.new.white(msg)
+      end
+
+      def self.info(msg)
+        Pastel.new.magenta.bold(msg)
+      end
+
+      def self.desc(msg)
+        Pastel.new.green(msg)
+      end
+
+      def self.warn(msg)
+        Pastel.new.yellow(msg)
+      end
+
+      def self.error(msg)
+        Pastel.new.red(msg)
+      end
+    end
+  end
+end

data/lib/rlt/utils/git_util.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Rlt
+  module Utils
+    class GitUtil
+      # git help -a
+      NATIVE_COMMANDS =
+        %w[add add--interactive am annotate apply archimport archive bisectbisect--helper blame
+           branch bundle cat-file check-attr check-ignore check-mailmap check-ref-format checkout
+           checkout-index cherry cherry-pick citool clean clone column commit commit-tree config
+           count-objects credential credential-cache credential-cache--daemon credential-store
+           cvsexportcommit cvsimport cvsserver daemon describe diff diff-files diff-index diff-tree
+           difftool difftool--helper fast-export fast-import fetch fetch-pack filter-branch
+           fmt-merge-msg for-each-ref format-patch fsck fsck-objects gc get-tar-commit-id grep gui
+           gui--askpass hash-object help http-backend http-fetch http-push index-pack init init-db
+           instaweb interpret-trailers log ls-files ls-remote ls-tree mailinfo mailsplit merge
+           merge-base merge-file merge-index merge-octopus merge-one-file merge-ours merge-recursive
+           merge-resolve merge-subtree merge-tree mergetool mktag mktree mv name-rev notes p4
+           pack-objects pack-redundant pack-refs patch-id prune prune-packed pull push quiltimport
+           read-tree rebase receive-pack reflog relink remote remote-ext remote-fd remote-ftp
+           remote-ftps remote-http remote-https remote-testsvn repack replace request-pull rerere
+           reset rev-list rev-parse revert rm send-email send-pack sh-i18n--envsubst shell shortlog
+           show show-branch show-index show-ref stage stash status stripspace submodule
+           submodule--helper svn symbolic-ref tag unpack-file unpack-objects update-index update-ref
+           update-server-info upload-archive upload-pack var verify-commit verify-pack verify-tag
+           web--browse whatchanged worktree write-tree].freeze
+
+      def self.execute_native_command(args)
+        Shell.new.run 'git', *args
+      end
+
+      def self.current_branch_name
+        `git rev-parse --abbrev-ref HEAD`.strip
+      end
+
+      def self.add_all
+        Shell.new.run 'git', 'add', '-A'
+      end
+
+      def self.uncommitted_change?
+        !`git status -s`.strip.empty?
+      end
+
+      def self.latest_stash_name(branch_name)
+        line = `git stash list`.strip.split("\n").find do |l|
+          l.split(':')[1].strip == "On #{branch_name}"
+        end
+        return nil if line.nil?
+        line.split(':').first
+      end
+
+      def self.save_stash(message, opts = {})
+        Logger.info 'Saving stash' if opts[:print_info]
+        Shell.new.run 'git', 'stash', 'save', '--include-untracked', message
+      end
+
+      def self.apply_stash(name, opts = {})
+        Logger.info 'Applied stash' if opts[:print_info]
+        Shell.new.run 'git', 'stash', 'apply', name, '--index'
+      end
+
+      def self.drop_stash(name, opts = {})
+        Logger.info 'Dropped stash' if opts[:print_info]
+        Shell.new.run 'git', 'stash', 'drop', name
+      end
+
+      def self.checkout(branch_name, opts = {})
+        Logger.info "Switching to `#{branch_name}`" if opts[:print_info]
+        Shell.new.run 'git', 'checkout', branch_name
+      end
+
+      def self.silently_try_checkout(branch_name)
+        result = Shell.new(no_output: true).run_safely 'git', 'checkout', branch_name
+        result.success?
+      end
+
+      def self.silently_create_and_checkout(branch_name)
+        Shell.new(no_output: true).run 'git', 'checkout', '-b', branch_name
+      end
+
+      def self.commit_with_long_message(message)
+        Logger.verbose message if Rlt.debug
+        commit_msg_file_path = "#{Dir.tmpdir}/.rlt.commit.msg.#{StringUtil.short_random_string}"
+        File.write(commit_msg_file_path, message)
+        Shell.new.run 'git', 'commit', '-F', commit_msg_file_path
+        File.delete(commit_msg_file_path)
+      end
+
+      def self.merge_from(branch_name, opts = {})
+        Logger.info "Merging from `#{branch_name}`" if opts[:print_info]
+        Shell.new.run 'git', 'merge', branch_name
+      end
+
+      def self.any_conflict?
+        !`git diff --name-only --diff-filter=U`.strip.empty?
+      end
+
+      def self.delete_branch(branch_name, opts = {})
+        Logger.info "Deleting `#{branch_name}`" if opts[:print_info]
+        Shell.new.run 'git', 'branch', '-d', branch_name
+      end
+
+      def self.remotes
+        `git remote`.strip.split('\n')
+      end
+
+      def self.safely_delete_remote_branch(remote, branch_name, opts = {})
+        Logger.info "Try deleting remote branch: #{remote}/#{branch_name}" if opts[:print_info]
+        Shell.new.run_safely 'git', 'push', remote, ":#{branch_name}"
+      end
+    end
+  end
+end

data/lib/rlt/utils/logger.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'pastel'
+
+module Rlt
+  module Utils
+    class Logger
+      def self.verbose(msg)
+        puts ColoredText.verbose(msg)
+      end
+
+      def self.info(msg)
+        puts ColoredText.info(msg)
+      end
+
+      def self.desc(msg)
+        puts ColoredText.desc(msg)
+      end
+
+      def self.warn(msg)
+        puts ColoredText.warn(msg)
+      end
+
+      def self.error(msg)
+        puts ColoredText.error(msg)
+      end
+    end
+  end
+end

data/lib/rlt/utils/shell.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'tty-command'
+
+module Rlt
+  module Utils
+    class Shell
+      def initialize(opts = {})
+        @cmd = TTY::Command.new(printer: printer(opts), pty: true, dry_run: Rlt.debug)
+      end
+
+      def run(*args)
+        result = @cmd.run(*args, user: current_user)
+        puts '' if Rlt.debug
+        result
+      end
+
+      def run_safely(*args)
+        result = @cmd.run!(*args, user: current_user)
+        puts '' if Rlt.debug
+        result
+      end
+
+      def current_user
+        ENV['USER'] || ENV['USERNAME']
+      end
+
+      private
+
+      def printer(opts)
+        if Rlt.debug
+          :quiet
+        else
+          opts[:no_output] ? :null : :quiet
+        end
+      end
+    end
+  end
+end

data/lib/rlt/utils/string_util.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Rlt
+  module Utils
+    class StringUtil
+      def self.underscore(str)
+        str.gsub(/::/, '/')
+           .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+           .tr('-', '_')
+           .downcase
+      end
+
+      def self.short_random_string
+        (0...4).map { rand(65..90).chr }.join
+      end
+    end
+  end
+end

data/lib/rlt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rlt
-  VERSION = '0.1.5'
+  VERSION = '0.1.6'
 end

data/lib/rlt.rb

@@ -1,24 +1,12 @@
 # frozen_string_literal: true
 
 require 'rlt/version'
-require 'rlt/shell'
-require 'rlt/colored_text'
-require 'rlt/logger'
-require 'rlt/base_command'
-require 'rlt/git_native_command_builder'
-Dir["#{__dir__}/rlt/commands/**/*.rb"].each { |f| require f }
-require 'rlt/register_commands'
-require 'rlt/register_aliases'
-require 'rlt/command_runner'
 require 'rlt/config'
-
-module Rlt
-  def self.debug
-    ENV['RLT_DEBUG']
-  end
-  extend Config
-  extend CommandRunner
-
-  RegisterCommands.register
-  RegisterAliases.register
-end
+require 'rlt/utils/shell'
+require 'rlt/utils/colored_text'
+require 'rlt/utils/logger'
+require 'rlt/utils/string_util'
+require 'rlt/utils/git_util'
+require 'rlt/debug'
+require 'rlt/error'
+require 'rlt/cli'