jiragit 0.5.0

data/lib/jiragit.rb

@@ -0,0 +1,10 @@
+require 'jiragit/version'
+require 'jiragit/logger'
+require 'jiragit/configuration'
+require 'jiragit/cli'
+require 'jiragit/git/repository'
+require 'jiragit/git/commit_response'
+require 'jiragit/git/branch'
+require 'jiragit/tag'
+require 'jiragit/vault'
+require 'jiragit/jira_store'

data/lib/jiragit/cli.rb

@@ -0,0 +1,249 @@
+module Jiragit
+
+  class Cli
+
+    COMMANDS = [
+      :install,
+      :uninstall,
+      :jira,
+      :branch,
+      :jira_branch,
+      :browse,
+      :remote,
+      :local,
+      :configure,
+      :configuration
+    ]
+
+    FLAGS = [
+      :silent
+    ]
+
+    def initialize(args)
+      exit_with_help and return if args.empty?
+      @args = args
+      command = args[0].to_sym
+      @params = args[1..-1]
+      exit_with_help and return unless COMMANDS.include?(command)
+
+      @config = Jiragit::Configuration.new("#{`echo ~`.chomp}/.jiragit")
+
+      begin
+        self.send(command)
+      rescue => error
+        $stderr.puts error.message
+      end
+    end
+
+    def exit_with_help
+      puts "jira {command}"
+      puts
+      puts "Commands"
+      puts "--------"
+      COMMANDS.each do |command|
+        puts command
+      end
+    end
+
+    def install
+      puts "Installing into #{Jiragit::Git.repository_root}" unless silent?
+      gem_hook_paths.each do |hook|
+        `cp #{hook} #{Jiragit::Git.repository_root}/.git/hooks/`
+      end
+      gem_hook_files.each do |hook|
+        `chmod a+x #{Jiragit::Git.repository_root}/.git/hooks/#{hook}`
+      end
+    end
+
+    def uninstall
+      puts "Uninstalling from #{Jiragit::Git.repository_root}"
+      gem_hook_files.each do |hook|
+        `rm #{Jiragit::Git.repository_root}/.git/hooks/#{hook}`
+      end
+    end
+
+    def jira
+      if @params.empty? || @params[0].empty?
+        warn "Please provide a jira"
+        return
+      end
+      puts "Listing all relations for jira #{@params[0]}"
+      js = JiraStore.new("#{Jiragit::Git.repository_root}/.git/jiragit/jira_store")
+      puts js.relations(jira: @params[0]).to_a
+    end
+
+    def branch
+      branch = @params[0] || Jiragit::Git.current_branch
+      puts "Listing all relations for branch #{branch}"
+      js = JiraStore.new("#{Jiragit::Git.repository_root}/.git/jiragit/jira_store")
+      puts js.relations(branch: branch).to_a
+    end
+
+    def jira_branch
+      puts "Relating jira #{@params[0]} and branch #{@params[1]}"
+      js = JiraStore.new("#{Jiragit::Git.repository_root}/.git/jiragit/jira_store")
+      js.relate(jira: @params[0], branch: @params[1])
+    end
+
+    def browse
+      type = :branch
+      type, object = classify(*@params) unless @params.empty?
+      unless object
+        object = case type
+        when :jira
+          related(:jira, {branch: Jiragit::Git.current_branch}).first
+        when :branch
+          Jiragit::Git.current_branch
+        when :commit
+          related(:commit, {branch: Jiragit::Git.current_branch}).first
+        end
+      end
+      self.send("browse_#{type}", object)
+    end
+
+    def remote
+      # remote branches
+      type = (@params[0] || 'branches').to_sym
+      case type
+      when :branches
+        list_remote_branches
+      end
+    end
+
+    def local
+      # local branches
+      type = (@params[0] || 'branches').to_sym
+      case type
+      when :branches
+        list_local_branches
+      end
+    end
+
+    def configure
+      if @params.size!=2 || @params.first.empty? || @params.last.empty?
+        warn "Please provide parameter and value"
+        return
+      end
+      @config[@params.first.to_sym] = @params.last
+      puts "Setting #{@params.first.to_sym} to #{@params.last}"
+    end
+
+    def configuration
+      puts "Configuration settings"
+      @config.each do |key,value|
+        puts "#{key} = #{value}"
+      end
+    end
+
+    private
+
+      def run(command)
+        `#{command}`
+      end
+
+      def silent?
+        !!@args.detect { |a| a == :silent }
+      end
+
+      def gem_hook_paths
+        spec = Gem::Specification.find_by_name('jiragit')
+        Dir.glob("#{spec.gem_dir}/hooks/*")
+      end
+
+      def gem_hook_files
+        gem_hook_paths.map { |hook| File.basename(hook) }
+      end
+
+      IS_JIRA = /\b([A-Z]{1,4}-[1-9][0-9]{0,6})\b/
+      IS_COMMIT = /\b([0-9a-f]{6,40})\b/
+      IS_BRANCH = /\b(?!\/)(?!.*\/\.)(?!.*\.\.)(?!.*\/\/)(?!.*\@\{)(?!.*\\)[^\040\177\s\~\^\:\?\*\[]+(?<!\.lock)(?<!\/)(?<!\.)\b/
+
+      def classify(*params)
+        case params.first
+        when /jira/
+          [ :jira, params.size>1 ? params.last[IS_JIRA] : nil ]
+        when /commit/
+          [ :commit, params.size>1 ? params.last[IS_COMMIT] : nil ]
+        when /branch/
+          [ :branch, params.size>1 ? params.last[IS_BRANCH] : nil ]
+        when IS_JIRA
+          [ :jira, params.first[IS_JIRA] ]
+        when IS_COMMIT
+          [ :commit, params.first[IS_COMMIT] ]
+        when IS_BRANCH
+          [ :branch, params.first[IS_BRANCH] ]
+        else
+          [ nil, nil ]
+        end
+      end
+
+      def browse_jira(jira)
+        if !jira || jira.empty?
+          warn "No jira available"
+          return
+        end
+        if !@config[:jira_url]
+          warn "No jira_url configured"
+          return
+        end
+        puts "Browsing jira #{jira}"
+        puts "Visiting #{@config[:jira_url]}/browse/#{jira}"
+        run "open #{@config[:jira_url]}/browse/#{jira}"
+      end
+
+      def related(type, relation)
+        js = JiraStore.new("#{Jiragit::Git.repository_root}/.git/jiragit/jira_store")
+        jiras = js
+          .relations(relation)
+          .to_a
+          .select { |r| r.type == type }
+          .map(&:label)
+      end
+
+      def browse_branch(branch)
+        if !branch || branch.empty?
+          warn "No branch available"
+          return
+        end
+        puts "Browsing branch #{branch}"
+        url = Jiragit::Git.github_branch_url(branch)
+        unless url
+          puts "No remote repository found on Github"
+          return
+        end
+        puts "Visiting #{url}"
+        run "open #{url}"
+      end
+
+      def browse_commit(commit)
+        if !commit || commit.empty?
+          warn "No commit available"
+          return
+        end
+        puts "Browsing commit #{commit}"
+        url = Jiragit::Git.github_commit_url(commit)
+        unless url
+          puts "No remote repository found on Github"
+          return
+        end
+        puts "Visiting #{url}"
+        run "open #{url}"
+      end
+
+      def list_remote_branches
+        puts "Fetching remote branch information"
+        Jiragit::Git.remote_branches.each do |branch|
+          puts "#{'%-10.10s'%branch.date}\s\s#{branch.short_commit}\s\s#{'%-10.10s'%branch.committer}\s\s#{branch.short_name}"
+        end
+      end
+
+      def list_local_branches
+        puts "Fetching local branch information"
+        Jiragit::Git.local_branches.each do |branch|
+          puts "#{'%-10.10s'%branch.date}\s\s#{branch.short_commit}\s\s#{'%-10.10s'%branch.committer}\s\s#{branch.short_name}"
+        end
+      end
+
+  end
+
+end

data/lib/jiragit/configuration.rb

@@ -0,0 +1,51 @@
+require 'yaml'
+
+module Jiragit
+
+  class Configuration
+
+    def initialize(location)
+      self.location = location
+      load_or_create
+    end
+
+    def load_or_create
+      self.config = load || create
+    end
+
+    def load
+      return false unless File.exists?(location)
+      self.config = YAML.load(File.read(location))
+    end
+
+    def create
+      self.config = {}
+      save
+      config
+    end
+
+    def save
+      File.open(location, 'w+') { |file| file.write YAML.dump(config) }
+    end
+
+    def [](key)
+      config[key]
+    end
+
+    def []=(key, value)
+      config[key] = value
+      save
+    end
+
+    def include?(key)
+      config.include?(key)
+    end
+
+    private
+
+      attr_accessor :config
+      attr_accessor :location
+
+  end
+
+end

data/lib/jiragit/git/branch.rb

@@ -0,0 +1,29 @@
+module Jiragit
+
+  module Git
+
+    class Branch
+
+      attr_accessor :name, :commit
+
+      def short_name
+        @name.gsub(/refs\/heads\//,'')
+      end
+
+      def date
+        @date ||= Jiragit::Git.timestamp(commit)
+      end
+
+      def committer
+        @committer ||= Jiragit::Git.committer(commit)
+      end
+
+      def short_commit
+        commit[0,6]
+      end
+
+    end
+
+  end
+
+end

data/lib/jiragit/git/commit_response.rb

@@ -0,0 +1,23 @@
+class CommitResponse
+
+  def initialize(string)
+    @response = string
+  end
+
+  def commit_string
+    @response[/(?<=\[)(.*?)(?=\])/] || ""
+  end
+
+  def branch
+    commit_string.split(/ /).first
+  end
+
+  def sha
+    commit_string.split(/ /).last
+  end
+
+  def message
+    @response[/.*?(?=\n)/]
+  end
+
+end

data/lib/jiragit/git/repository.rb

@@ -0,0 +1,222 @@
+require 'pty'
+
+module Jiragit
+
+  module Git
+
+    class NoRepositoryError < StandardError;
+      def initialize(msg = "No valid Git repository was found in current directory.")
+        super
+      end
+    end
+
+    def self.repository_root
+      value = `git rev-parse --show-toplevel 2>&1`.chomp
+      raise NoRepositoryError if value=~/Not a git repository/
+      value
+    end
+
+    def self.current_branch
+      value = `git symbolic-ref -q HEAD --short 2>&1`.chomp
+      raise NoRepositoryError if value=~/Not a git repository/
+      value
+    end
+
+    def self.current_commit
+      value = `git log -1 --format=%H 2>&1`.chomp
+      raise NoRepositoryError if value=~/Not a git repository/
+      value
+    end
+
+    def self.previous_branch
+      value = `git rev-parse --symbolic-full-name --abbrev-ref @{-1} 2>&1`.chomp
+      raise NoRepositoryError if value=~/Not a git repository/
+      value
+    end
+
+    def self.remote
+      value = `git config --get remote.origin.url 2>&1`.chomp
+      raise NoRepositoryError if value=~/Not a git repository/
+      value
+    end
+
+    def self.github_branch_url(branch = current_branch)
+      return unless remote =~ /github.com/
+      remote
+        .gsub(/git\@github.com\:/,'https://github.com/')
+        .gsub(/.git$/,"/tree/#{branch}")
+    end
+
+    def self.github_commit_url(commit)
+      return unless remote =~ /github.com/
+      remote
+        .gsub(/git\@github.com\:/,'https://github.com/')
+        .gsub(/.git$/,"/commit/#{commit}")
+    end
+
+    def self.remote_branches
+      value = `git fetch 2>&1`
+      raise NoRepositoryError if value=~/Not a git repository/
+
+      `git ls-remote --heads origin 2>&1`
+        .split(/\n/)
+        .map(&:chomp)
+        .map{ |line| line.split(/\t/) }
+        .map{ |entries|
+          Branch.new.tap do |branch|
+            branch.commit = entries.first
+            branch.name = entries.last
+          end
+        }
+        .sort_by{ |branch| branch.date }
+        .reverse
+    end
+
+    def self.local_branches
+      value = `git for-each-ref --sort=-committerdate refs/heads --format="%(objectname) %(refname)" 2>&1`
+        .split(/\n/)
+        .map(&:chomp)
+        .map{ |line| line.split(/ /) }
+        .map{ |entries|
+          Branch.new.tap do |branch|
+            branch.commit = entries.first
+            branch.name = entries.last
+          end
+        }
+        .sort_by{ |branch| branch.date }
+        .reverse
+      raise NoRepositoryError if value=~/Not a git repository/
+      value
+    end
+
+    def self.timestamp(reference)
+      value = `git log -1 --format=%ci #{reference} 2>&1`.chomp
+      raise NoRepositoryError if value=~/Not a git repository/
+      value
+    end
+
+    def self.committer(reference)
+      value = `git log -1 --format=%cN #{reference} 2>&1`.chomp
+      raise NoRepositoryError if value=~/Not a git repository/
+      value
+    end
+
+    class Repository
+
+      def self.create(path)
+        Dir.mkdir(path) unless Dir.exists?(path)
+        `cd #{path}; git init .` unless File.exists?("#{path}/.git")
+        repo = self.new(path)
+      end
+
+      def initialize(path)
+        self.path = path
+      end
+
+      def remove
+        `rm -rf #{path}` if Dir.exists?(path)
+      end
+
+      def checkout_new_branch(branch, &block)
+        run_command("git checkout -b #{branch}", &block)
+      end
+
+      def checkout_branch(branch, &block)
+        run_command("git checkout #{branch}", &block)
+      end
+
+      def create(filename, message)
+        run_command("echo '#{message}' > #{filename}")
+      end
+
+      def add(filename)
+        run_command("git add #{filename}")
+      end
+
+      def merge(branch, message="", &block)
+        number = rand(100)
+        run_command("echo '#{message}' > .git_commit_body")
+        output = run_command({env: "export GIT_EDITOR=$PWD/spec/git_editor.rb", command:"git merge #{branch}"}, &block)
+        run_command("rm .git_commit_body")
+        CommitResponse.new(output)
+      end
+
+      def commit(message, &block)
+        number = rand(100)
+        run_command("echo '#{message}' > .git_commit_body")
+        output = run_command({env: "export GIT_EDITOR=$PWD/spec/git_editor.rb", command:"git commit"}, &block)
+        run_command("rm .git_commit_body")
+        CommitResponse.new(output)
+      end
+
+      def make_a_commit(&block)
+        number = rand(100)
+        output = run_command({env: "export GIT_EDITOR=$PWD/spec/git_editor.rb", command:"echo \"#{number}\" > README.md; git add README.md; git commit"}, &block)
+        CommitResponse.new(output)
+      end
+
+      def make_a_command_line_commit(&block)
+        number = rand(100)
+        output = run_command("echo \"#{number}\" > README.md; git add README.md; git commit -m 'command line specified commit message #{number}'", &block)
+        CommitResponse.new(output)
+      end
+
+      def log(&block)
+        run_command("git log", &block)
+      end
+
+      def log_for_one_commit(sha, &block)
+        run_command("git log -n 1 #{sha}", &block)
+      end
+
+      def one_line_log(&block)
+        run_command("git log --format=oneline", &block)
+      end
+
+      def oneline_log_for_one_commit(sha, &block)
+        run_command("git log --format=oneline -n 1 #{sha}", &block)
+      end
+
+      def current_commit(&block)
+        run_command("git log -1 --format=%H", &block)
+      end
+
+      def root
+        @path
+      end
+
+      def origin
+        run_command("git remote -v")
+      end
+
+      def origin=(path)
+        run_command("git remote add origin #{path}")
+      end
+
+      private
+
+        attr_accessor :path
+
+        def run_command(command, &block)
+          if command.is_a? Hash
+            env = command[:env]
+            command = command[:command]
+            full_command = "#{env}; cd #{path}; #{command} 2>&1"
+          else
+            full_command = "cd #{path}; #{command} 2>&1"
+          end
+          if block_given?
+            PTY.spawn(full_command) do |output, input|
+              sleep(1) #avoid race conditions
+              yield output, input
+            end
+          else
+            `#{full_command}`.chomp
+          end
+        end
+
+    end
+
+  end
+
+end