zomgit 0.0.1

data/lib/zomgit/concerns/findable.rb

@@ -0,0 +1,135 @@
+module Zomgit
+  module Concerns
+    module Findable
+      class Finder
+        # IMPROVE: Permit the query to be more complex (e.g.: a regex)
+        def self.fuzzy_find(files, query, options = {})
+          return Array.new if query.empty?
+
+          eager_pattern = "\\b#{Regexp.escape(query)}"
+
+          if query.include?("/")
+            greedy_pattern = query.split("/").map { |p| p.split("").map { |c| Regexp.escape(c) }.join(")[^\/]*?(").prepend("[^\/]*?(") + ")[^\/]*?" }.join("\/")
+            greedy_pattern << "\/" if query[-1] == "/"
+          else
+            greedy_pattern = query.split("").map { |c| Regexp.escape(c) }.join(").*?(").prepend(".*?(") + ").*?"
+          end
+
+          eager_results = []
+          greedy_results = []
+          exact_match_found = false
+
+          files.each do |f|
+            if f =~ /#{eager_pattern}/
+              eager_results << f
+              exact_match_found = true
+              next
+            end
+
+            if exact_match_found
+              next unless !!options[:greedy]
+            end
+
+            greedy_results << f if f =~ /#{greedy_pattern}/
+          end
+
+          if eager_results.empty? || !!options[:greedy]
+            eager_results + greedy_results
+          else
+            eager_results
+          end
+        end
+      end
+
+      def search(arguments, options = [])
+        greedy = !!options[:greedy] && !!!options[:G]
+        clean = !!options[:refine]
+        files = Array.new
+
+        case options[:filter].to_s.to_sym
+        when :all
+          cmds = ["ls-files --others --cached --exclude-standard"]
+        when :untracked
+          cmds = ["ls-files --others --exclude-standard"]
+        when :tracked
+          cmds = ["ls-files"]
+        when :unstaged
+          cmds = ["ls-files --others --exclude-standard", "diff --name-only"]
+        when :staged
+          cmds = ["diff --name-only --cached"]
+        when :modified
+          cmds = ["diff --name-only"]
+        else
+          cmds = ["ls-files --others --cached --exclude-standard"]
+        end
+
+        cmds.each { |c| files << `command git #{c}`.split("\n") }
+        files.flatten!
+
+        if files.count == 0
+          raise Zomgit::Exceptions::NoChangesError.new("No changes matching this filter")
+        end
+
+        if arguments.count == 1 && arguments.first == "."
+          found = files
+        else
+          indices = arguments.map { |a| a if a =~ /\A[1-9]+(?:\.{2}[0-9]+)?\Z/ }.compact
+
+          unless indices.empty?
+            index = Zomgit::Persistor.instance.index
+
+            if index.empty?
+              raise Zomgit::Exceptions::NoIndexError.new("No index found")
+            end
+
+            arguments -= indices
+
+            indices.map! do |i|
+              if i.include?("..")
+                head, tail = i.split("..").map(&:to_i)
+
+                if head > tail || head > files.count || tail > index.count
+                  raise Zomgit::Exceptions::InvalidIndexRangeError.new("Invalid index range: #{[head, tail].join("..")}")
+                end
+
+                index[Range.new(head - 1, tail - 1)]
+              else
+                ii = i.to_i
+
+                unless ii > 0 && ii <= index.count
+                  raise Zomgit::Exceptions::InvalidIndexError.new("Invalid index: #{i}")
+                end
+
+                index[ii - 1]
+              end
+            end
+
+            indices.flatten!
+          end
+
+          if clean
+            found = files
+
+            arguments.each do |arg|
+              found = Finder.fuzzy_find(found, arg, greedy: greedy)
+            end
+          else
+            found = Array.new
+
+            arguments.each do |arg|
+              found << Finder.fuzzy_find(files, arg, greedy: greedy)
+            end
+
+            found = found.flatten.uniq
+          end
+
+          unless indices.empty?
+            found = (found + indices).uniq
+          end
+        end
+
+        found
+      end
+    end
+  end
+end

data/lib/zomgit/exceptions.rb

@@ -0,0 +1,37 @@
+module Zomgit
+  module Exceptions
+    #
+    # Base exception
+    #
+    class BaseError < ArgumentError; end
+
+    #
+    # Global exceptions
+    #
+    class NoGitRepoFoundError < BaseError; end
+    class InvalidOptionError < BaseError; end
+    class NoChangesError < BaseError; end
+
+    #
+    # Indices exceptions
+    #
+    class NoIndexError < BaseError; end
+    class InvalidIndexError < BaseError; end
+    class InvalidIndexRangeError < BaseError; end
+
+    #
+    # Status command exceptions
+    #
+    class TooManyChangesError < BaseError; end
+
+    #
+    # Find command exceptions
+    #
+    class MissingQueryError < BaseError; end
+
+    #
+    # Add command exceptions
+    #
+    class FileOrDirectoryNotFoundError < BaseError; end
+  end
+end

data/lib/zomgit/helpers/file_helper.rb

@@ -0,0 +1,17 @@
+module Zomgit
+  module Helpers
+    module FileHelper
+      def relative_path(base, target)
+        back = ""
+
+        while target.sub(base, "") == target
+          base = base.sub(/\/[^\/]*$/, "")
+          back = "../#{back}"
+        end
+
+        "#{back}#{target.sub("#{base}/","")}"
+      end
+    end
+  end
+end
+

data/lib/zomgit/helpers/rainbow_helper.rb

@@ -0,0 +1,46 @@
+module Zomgit
+  module Helpers
+    module RainbowHelper
+      # Black       0;30     Dark Gray     1;30
+      # Blue        0;34     Light Blue    1;34
+      # Green       0;32     Light Green   1;32
+      # Cyan        0;36     Light Cyan    1;36
+      # Red         0;31     Light Red     1;31
+      # Purple      0;35     Light Purple  1;35
+      # Brown       0;33     Yellow        1;33
+      # Light Gray  0;37     White         1;37
+
+      COLOR_CODES = {
+        white:         "0",
+        black:         "30",
+        red:           "31",
+        green:         "32",
+        yellow:        "33",
+        blue:          "34",
+        purple:        "35",
+        cyan:          "36",
+        gray:          "37"
+      }
+
+      COLOR_CODE_PREFIX = "\033["
+      COLOR_CODE_SUFFIX = "m"
+
+      def paint(message, color = "white", options = {})
+        options[:bold] ||= false
+
+        raise ArgumentError, "Invalid color (#{color})" unless COLOR_CODES.has_key?(color.to_sym)
+        raise ArgumentError, "Invalid color (white, bold)" if color == "white" && options[:bold]
+
+        modifier = options[:bold] ? "1;" : "0;"
+
+        "#{COLOR_CODE_PREFIX}#{modifier}#{COLOR_CODES[color.to_sym]}#{COLOR_CODE_SUFFIX}#{message}#{COLOR_CODE_PREFIX}#{COLOR_CODES[:white]}#{COLOR_CODE_SUFFIX}"
+      end
+
+      COLOR_CODES.keys.each do |color|
+        define_method color do |message, options = {}|
+          paint message, color, options
+        end
+      end
+    end
+  end
+end

data/lib/zomgit/persistor.rb

@@ -0,0 +1,51 @@
+require "singleton"
+require "fileutils"
+
+module Zomgit
+  class Persistor
+    attr_reader :index, :indexed, :index_file
+    alias_method :indexed?, :indexed
+
+    RUNTIME_DIR = File.expand_path(File.join(ENV["HOME"], ".zomgit"))
+    INDEXES_DIR = File.join(RUNTIME_DIR, "indexes")
+
+    include Singleton
+
+    def initialize
+      unless File.directory?(RUNTIME_DIR)
+        FileUtils.mkdir_p([RUNTIME_DIR, INDEXES_DIR])
+      end
+
+      if File.file?(self.index_file)
+        @index = File.read(self.index_file).split("\n")
+        @indexed = true
+      else
+        @index = []
+        @indexed = false
+      end
+    end
+
+    def cache_index(files)
+      @index = files
+
+      File.open(self.index_file, "wb") { |f| f.puts files.join("\n") }
+
+      @indexed = true
+    end
+
+    def clean_index_cache!
+      if self.indexed?
+        File.unlink(self.index_file)
+        @indexed = false
+      end
+    end
+
+    def index_file
+      unless @index_file
+        @index_file = File.join(INDEXES_DIR, Zomgit::project_root.gsub(/#{Regexp.escape(File::SEPARATOR)}/, "~~"))
+      end
+
+      @index_file
+    end
+  end
+end

data/lib/zomgit/version.rb

@@ -0,0 +1,3 @@
+module Zomgit
+  VERSION = "0.0.1"
+end

data/share/commands/add.zsh

@@ -0,0 +1,92 @@
+ga() {
+  local gitopts
+  local fileopts
+  local options
+  local files
+
+  gitopts=()
+  options=()
+
+  if (( $# == 0 )); then
+    fileopts="."
+    options=( --filter unstaged )
+  else
+    local opts
+
+    gitopts=( $(echo "${@}" | command grep -o -E "(--( (.*)))$" | command sed -E "s/^-- ?//") )
+    opts=( $(echo "$@" | sed -E "s/(.*)(--( .*))$/\1/g") )
+
+    # Remove the git options from the regular options array
+    set -- "${opts[@]}"
+
+    #
+    # Parse ZOMGit options
+    #
+    local opt_filter
+    local opt_greedy
+    local opt_refine
+
+    opt_filter=( unstaged )
+    opt_greedy=()
+    opt_refine=()
+
+    zparseopts -K -D f:=opt_filter -filter:=opt_filter g=opt_greedy G=opt_greedy -greedy=opt_greedy -no-greedy=opt_greedy r=opt_refine -refine=opt_refine
+
+    local filter=${opt_filter[${#opt_filter}]}
+    local greedy=${opt_greedy[${#opt_greedy}]}
+    local refine=${#opt_refine}
+
+    if [[ "${filter}" != "" ]]; then
+      options=( $options --filter $filter )
+    fi
+
+    if [[ "${greedy}" != "" && "${greedy}" =~ "G|no" ]]; then
+      options=( $options $greedy )
+    fi
+
+    if (( $refine > 0 )); then
+      options=( $options --refine )
+    fi
+
+    if (( $# == 0 )); then
+      fileopts="."
+    else
+      fileopts="$@"
+    fi
+  fi
+
+  if (( ${#gitopts} == 0 )); then
+    gitopts=( -A )
+  else
+    typeset -U gitopts
+  fi
+
+  files="$(zomgit find ${options[@]} ${fileopts} 2>&1)"
+  local exitcode=$?
+
+  if (( ${exitcode} > 0 )); then
+    echo "${fg[red]}${files}${reset_color}"
+    return ${exitcode}
+  fi
+
+  local params
+  params=( add ${gitopts[@]} $(echo ${files} | command tr '\n' ' ') )
+
+  if type hub > /dev/null; then
+    command hub ${params[@]}
+  elif type gh > /dev/null; then
+    command gh ${params[@]}
+  else
+    command git ${params[@]}
+  fi
+
+  zomgit status
+}
+
+gau() {
+  ga --filter untracked ${@}
+}
+
+gap() {
+  ga ${@} -- -p
+}

data/share/commands/branch.zsh

@@ -0,0 +1,11 @@
+gb() {
+  command git branch ${@}
+}
+
+gba() {
+  gb -a ${@}
+}
+
+gbd() {
+  gb -D ${@}
+}

data/share/commands/checkout.zsh

@@ -0,0 +1,18 @@
+gco() {
+  local output
+  output="$(command git checkout ${@} 2>&1)"
+  local exitcode=$?
+
+  if (( $exitcode > 0 )); then
+    echo "${fg[red]}Error running git checkout!${reset_color}"
+    return $exitcode
+  fi
+
+  echo "${fg[green]}$(echo -n $output | command head -1)${reset_color}"
+
+  zomgit status
+}
+
+gcob() {
+  gco -b ${@}
+}

data/share/commands/clone.zsh

@@ -0,0 +1,18 @@
+gcl() {
+  local params
+  params=( clone --recursive )
+
+  if (( $# == 0 )); then
+    params=( $params $(pbpaste) )
+  else
+    params=( $params ${@} )
+  fi
+
+  if type hub > /dev/null; then
+    command hub ${params[@]}
+  elif type gh > /dev/null; then
+    command gh ${params[@]}
+  else
+    command git ${params[@]}
+  fi
+}

data/share/commands/commit.zsh

@@ -0,0 +1,7 @@
+gc() {
+  command git commit ${@}
+}
+
+gcv() {
+  gc --verbose ${@}
+}