jigit 1.0.0

data/lib/jigit/commands/runner.rb

@@ -0,0 +1,22 @@
+require "jigit/version"
+require "jigit/helpers/informator"
+require "claide"
+require "cork"
+
+module Jigit
+  class Runner < CLAide::Command
+    self.abstract_command = true
+    self.summary = "Jira + Git = onelove"
+    self.version = Jigit::VERSION
+    self.command = "jigit"
+
+    def initialize(argv)
+      super
+      @cork = Cork::Board.new(silent: argv.option("silent", false), verbose: argv.option("verbose", false))
+    end
+
+    def ui
+      @ui ||= Informator.new(@cork)
+    end
+  end
+end

data/lib/jigit/commands/start_issue.rb

@@ -0,0 +1,58 @@
+require "jigit/commands/issue"
+require "jigit/jira/jira_transition_finder"
+
+module Jigit
+  class StartIssueRunner < IssueRunner
+    self.abstract_command = false
+    self.summary = "Command to put the given JIRA issue to 'In Progress' state"
+    self.command = "start"
+
+    def run
+      self
+      begin
+        jira_issue = @jira_api_client.fetch_jira_issue(@issue_name)
+        return unless could_start_working_on_issue?(jira_issue, @issue_name)
+        return unless want_to_start_working_on_issue?(jira_issue)
+        put_issue_to_in_progress(jira_issue)
+      rescue Jigit::JiraInvalidIssueKeyError
+        ui.say "#{@issue_name} doesn't exist on JIRA, skipping..."
+      rescue Jigit::JiraAPIClientError => exception
+        ui.error "Error while executing issue start command: #{exception.message}"
+      rescue Jigit::NetworkError => exception
+        ui.error "Error while executing issue start command: #{exception.message}"
+      end
+    end
+
+    private
+
+    def put_issue_to_in_progress(jira_issue)
+      transition_finder = Jigit::JiraTransitionFinder.new(@jira_api_client.fetch_issue_transitions(jira_issue))
+      to_in_progress_transition = transition_finder.find_transition_to(@jigitfile.in_progress_status)
+      unless to_in_progress_transition
+        ui.error("#{issue.key} doesn't have transition to '#{@jigitfile.in_progress_status}' status...")
+        return
+      end
+
+      jira_issue.make_transition(to_in_progress_transition.id)
+      ui.inform("#{@issue_name} now is '#{@jigitfile.in_progress_status}' 💪")
+    end
+
+    def want_to_start_working_on_issue?(jira_issue)
+      proceed_option = ui.ask_with_answers("Are you going to work on #{jira_issue.key}?\n", ["yes", "no"])
+      proceed_option == "yes"
+    end
+
+    def could_start_working_on_issue?(jira_issue, issue_name)
+      unless jira_issue
+        ui.say("#{issue_name} doesn't exist on JIRA, skipping...")
+        return false
+      end
+
+      if jira_issue.status.name == @jigitfile.in_progress_status
+        ui.say("#{jira_issue.key} is already #{@jigitfile.in_progress_status}...")
+        return false
+      end
+      return true
+    end
+  end
+end

data/lib/jigit/commands/stop_issue.rb

@@ -0,0 +1,53 @@
+require "jigit/commands/issue"
+require "jigit/jira/jira_transition_finder"
+
+module Jigit
+  class StopIssueRunner < IssueRunner
+    self.abstract_command = false
+    self.summary = "Command to put the given JIRA issue to any state, but 'In Progress'"
+    self.command = "stop"
+
+    def run
+      self
+      begin
+        jira_issue = @jira_api_client.fetch_jira_issue(@issue_name)
+        return unless issue_exists?(jira_issue)
+        new_status = ask_for_new_status_for_issue
+        put_issue_to_status(jira_issue, new_status)
+      rescue Jigit::JiraInvalidIssueKeyError
+        ui.say "#{@issue_name} doesn't exist on JIRA, skipping..."
+      rescue Jigit::NetworkError => exception
+        ui.error "Error while executing issue stop command: #{exception.message}"
+      rescue Jigit::JiraAPIClientError => exception
+        ui.error "Error while executing issue stop command: #{exception.message}"
+      end
+    end
+
+    private
+
+    def put_issue_to_status(jira_issue, new_status)
+      transition_finder = Jigit::JiraTransitionFinder.new(@jira_api_client.fetch_issue_transitions(jira_issue))
+      to_new_status_transition = transition_finder.find_transition_to(new_status)
+      unless to_new_status_transition
+        ui.error("#{jira_issue.key} doesn't have transition to '#{new_status}' status...")
+        return
+      end
+      jira_issue.make_transition(to_new_status_transition.id)
+      ui.inform("#{jira_issue.key} now is '#{new_status}' 🎉")
+    end
+
+    def issue_exists?(jira_issue)
+      unless jira_issue
+        ui.say("#{@issue_name} doesn't exist on JIRA, skipping...")
+        return false
+      end
+      return true
+    end
+
+    def ask_for_new_status_for_issue
+      question = "You've stopped working on '#{@issue_name}', to which status do you want to put it\n"
+      new_status = ui.ask_with_answers(question, @jigitfile.other_statuses, true)
+      new_status
+    end
+  end
+end

data/lib/jigit/core/jigitfile.rb

@@ -0,0 +1,31 @@
+require "yaml"
+require "jigit/core/jigitfile_constants"
+
+module Jigit
+  class Jigitfile
+    # @return [String] The status which represens In Progress state
+    attr_accessor :in_progress_status
+    # @return [Array] The other possible statuses
+    attr_accessor :other_statuses
+    # @return [String] JIRA server host
+    attr_accessor :host
+
+    def initialize(path)
+      raise "Path is a required parameter" if path.nil?
+      raise "Couldn't find Jigitfile file at '#{path}'" unless File.exist?(path)
+      jigitfile = File.read(path)
+      yaml_hash = read_data_from_yaml_file(jigitfile, path)
+      self.in_progress_status = yaml_hash[JigitfileConstants.in_progress_status]
+      self.other_statuses = yaml_hash[JigitfileConstants.other_statuses]
+      self.host = yaml_hash[JigitfileConstants.host]
+    end
+
+    private
+
+    def read_data_from_yaml_file(yaml_file, path)
+      YAML.load(yaml_file)
+    rescue Psych::SyntaxError
+      raise "File at '#{path}' doesn't have a legit YAML syntax"
+    end
+  end
+end

data/lib/jigit/core/jigitfile_constants.rb

@@ -0,0 +1,15 @@
+module Jigit
+  class JigitfileConstants
+    def self.in_progress_status
+      "in_progress_status"
+    end
+
+    def self.other_statuses
+      "other_statuses"
+    end
+
+    def self.host
+      "host"
+    end
+  end
+end

data/lib/jigit/core/jigitfile_generator.rb

@@ -0,0 +1,34 @@
+require "jigit/core/jigitfile_constants"
+require "fileutils"
+require "yaml"
+
+module Jigit
+  class JigitfileGenerator
+    def initialize(path = nil)
+      @path = path ? path : ".jigit"
+      @jigitfile_hash = {}
+    end
+
+    def write_jira_host(host)
+      raise "Host can not be empty" if host.nil? || host.empty?
+      @jigitfile_hash[JigitfileConstants.host] = host
+    end
+
+    def write_in_progress_status_name(name)
+      raise "In progress status name can not be empty" if name.nil? || name.empty?
+      @jigitfile_hash[JigitfileConstants.in_progress_status] = name
+    end
+
+    def write_other_statuses(other_statuses)
+      raise "All statuses must be string" if other_statuses.select { |status| !status.kind_of?(String) }.count > 0
+      @jigitfile_hash[JigitfileConstants.other_statuses] = other_statuses
+    end
+
+    def save
+      FileUtils.mkdir_p(@path)
+      File.open("#{@path}/Jigitfile.yml", "w") do |file|
+        file.write(@jigitfile_hash.to_yaml)
+      end
+    end
+  end
+end

data/lib/jigit/git/git_hook.rb

@@ -0,0 +1,11 @@
+module Jigit
+  class GitHook
+    def self.hook_lines
+      raise "GitHook subclass must specify the actual hook lines"
+    end
+
+    def self.name
+      raise "GitHook subclass must specify the actual name"
+    end
+  end
+end

data/lib/jigit/git/git_hook_installer.rb

@@ -0,0 +1,60 @@
+require "fileutils"
+
+module Jigit
+  # Command to setup the git hook for jigit
+  class GitHookInstaller
+    def initialize(git_hooks_folder = nil, git_path = nil)
+      @git_hooks_folder = git_hooks_folder ? git_hooks_folder : default_git_hooks_folder
+      @git_path = git_path ? git_path : default_git_path
+      @is_git_hook_file_new = false
+    end
+
+    def install(hook)
+      @git_hook_name = hook.name
+      @git_hook_file_path = "#{@git_hooks_folder}/#{@git_hook_name}"
+
+      ensure_git_hook_file_exists
+      ensure_git_hook_file_is_executable
+      write_hook_lines(hook.hook_lines)
+    end
+
+    private
+
+    def ensure_git_hook_file_exists
+      @git_hook_file_path = File.realpath(@git_hook_file_path) if File.symlink?(@git_hook_file_path)
+      return if File.exist?(@git_hook_file_path)
+
+      raise "Git folder is not found at '#{@git_path}'" unless Dir.exist?(@git_path)
+
+      FileUtils.mkdir_p(@git_hooks_folder)
+      @git_hook_file_path = "#{@git_hooks_folder}/#{@git_hook_name}"
+      FileUtils.touch(@git_hook_file_path)
+      FileUtils.chmod("u=xwr", @git_hook_file_path)
+      @is_git_hook_file_new = true
+    end
+
+    def ensure_git_hook_file_is_executable
+      raise "git hook file at '#{@git_hook_file_path}' is not executable by the effective user id of this process" unless File.executable?(@git_hook_file_path)
+    end
+
+    def write_hook_lines(hook_lines)
+      File.open(@git_hook_file_path, @is_git_hook_file_new ? "r+" : "a") do |f|
+        hook_lines.each do |line|
+          f.puts(line)
+        end
+      end
+    end
+
+    def git_hook_file_path
+      "#{default_git_hooks_folder}/#{@git_hook_name}"
+    end
+
+    def default_git_path
+      ".git"
+    end
+
+    def default_git_hooks_folder
+      "#{default_git_path}/hooks"
+    end
+  end
+end

data/lib/jigit/git/git_ignore_updater.rb

@@ -0,0 +1,20 @@
+module Jigit
+  class GitIgnoreUpdater
+    def initialize(git_ignore_path = nil)
+      @gitignore_path = git_ignore_path ? git_ignore_path : default_gitignore_path
+      raise "Gitignore file at #{@gitignore_path} is not found" unless @gitignore_path
+    end
+
+    def ignore(line_to_ignore)
+      File.open(@gitignore_path, "a") do |f|
+        f.puts(line_to_ignore)
+      end
+    end
+
+    private
+
+    def default_gitignore_path
+      ".gitignore"
+    end
+  end
+end

data/lib/jigit/git/post_checkout_hook.rb

@@ -0,0 +1,23 @@
+require "jigit/git/git_hook"
+
+module Jigit
+  class PostCheckoutHook < GitHook
+    def self.hook_lines
+      ["#!/usr/bin/env bash",
+       "checkoutType=$3",
+       "[[ $checkoutType == 1 ]] && checkoutType='branch' || checkoutType='file'",
+       "if [ $checkoutType == 'branch' ]; then",
+       "  newBranchName=`git symbolic-ref --short HEAD`",
+       "  oldBranchName=`git rev-parse --abbrev-ref @{-1}`",
+       "  if [ $newBranchName != $oldBranchName ]; then",
+       "    jigit issue start --name=$newBranchName",
+       "    jigit issue stop --name=$oldBranchName",
+       "  fi",
+       "fi"]
+    end
+
+    def self.name
+      "post-checkout"
+    end
+  end
+end

data/lib/jigit/helpers/informator.rb

@@ -0,0 +1,131 @@
+require "cork"
+
+module Jigit
+  # This class is heavily based on the Interviewer class from the Danger gem
+  # The original link is https://github.com/danger/danger/blob/master/lib/danger/commands/init_helpers/interviewer.rb
+  class Informator
+    attr_accessor :no_waiting, :ui, :no_delay
+
+    def initialize(cork_board)
+      @ui = cork_board
+    end
+
+    def show_prompt
+      ui.print("> ".bold.green)
+    end
+
+    def say(message)
+      ui.puts(message)
+    end
+
+    def inform(message)
+      ui.puts(message.green)
+    end
+
+    def link(url)
+      say " -> " + url.underline + "\n"
+    end
+
+    def pause(time)
+      sleep(time) unless @no_waiting
+    end
+
+    def header(title)
+      say title.yellow
+      say ""
+      pause 0.6
+    end
+
+    def important(message)
+      i = message.length + 8
+      inform("-" * i)
+      inform("--- " + message + " ---")
+      inform("-" * i)
+    end
+
+    def warn(message)
+      ui.puts(message.yellow)
+    end
+
+    def error(message)
+      ui.puts(message.red)
+    end
+
+    def wait_for_return
+      STDOUT.flush
+      STDIN.gets unless @no_delay
+      ui.puts
+    end
+
+    def ask(question)
+      STDIN.reopen(File.open("/dev/tty", "r"))
+
+      answer = ""
+      loop do
+        ui.puts "\n#{question}?"
+
+        show_prompt
+        answer = STDIN.gets.chomp
+
+        break unless answer.empty?
+
+        ui.print "\nYou need to provide an answer."
+      end
+      answer
+    end
+
+    def ask_with_answers(question, possible_answers, is_numerated = false)
+      STDIN.reopen(File.open("/dev/tty", "r"))
+
+      ui.print("\n#{question}? [")
+      possible_answers_to_print = is_numerated ? possible_answers.map.with_index { |answer, index| "#{index}. #{answer}" } : possible_answers
+      print_possible_answers(possible_answers_to_print)
+      answer = ""
+      loop do
+        show_prompt
+        answer = read_answer(possible_answers)
+
+        if is_numerated
+          numerated_answer = begin
+                               Integer(answer)
+                             rescue
+                               break
+                             end
+          break if numerated_answer < 0 && possible_answers.count <= numerated_answer
+          answer = possible_answers[numerated_answer]
+        end
+
+        break if possible_answers.include? answer
+
+        ui.print "\nPossible answers are ["
+        print_possible_answers(possible_answers)
+      end
+      answer
+    end
+
+    private
+
+    def read_answer(possible_answers)
+      answer = @no_waiting ? possible_answers[0] : STDIN.gets
+      answer = answer.chomp unless answer.nil?
+      answer = "yes" if answer == "y"
+      answer = "no" if answer == "n"
+
+      # default to first answer
+      if answer == ""
+        answer = possible_answers[0]
+        ui.puts "Using: " + answer.yellow
+      end
+      answer
+    end
+
+    def print_possible_answers(possible_answers)
+      possible_answers.each_with_index do |answer, i|
+        the_answer = i.zero? ? answer.underline : answer
+        ui.print " " + the_answer
+        ui.print(" /") if i != possible_answers.length - 1
+      end
+      ui.print " ]\n"
+    end
+  end
+end