zomgit 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 80f6335b31391049698c6dcacedaae4f23301607
+  data.tar.gz: 55cb63a2f815c6d983d52d08d400e11e135b9953
+SHA512:
+  metadata.gz: 502a4016e94784734b0321846739ec227d556bbacd302eac6cc224d179b4716d360cca67c4f1615a55b84eb0a2996c1581e170c554492efd79fff03f90166f06
+  data.tar.gz: 38725c3df10035e239802e5f89cd56002a8f66de45640f06b986936d1e3a49a14f2ecdbc7617f018979b4119787683b5e0d0085d10fe6146ab227447d8567cf3

data/.gitignore

@@ -0,0 +1,21 @@
+*.a
+*.bundle
+*.gem
+*.o
+*.rbc
+*.so
+.bundle
+.config
+/.bundle/
+/.config
+/InstalledFiles
+/lib/bundler/man/
+/pkg/
+/tmp/
+Gemfile.lock
+InstalledFiles
+lib/bundler/man
+mkmf.log
+pkg
+tmp
+

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Robert Audi
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,51 @@
+ZOMGit
+======
+
+ZOMGit is a git wrapper written in ruby. It was hugely inspired by [SCM Breeze](https://github.com/ndbroadbent/scm_breeze).
+
+Installation
+------------
+
+```sh
+> gem install zomgit
+```
+
+Usage
+-----
+
+TODO: Write usage instructions here
+
+Contributing
+------------
+
+1. Fork it ( https://github.com/RobertAudi/zomgit/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+License
+-------
+
+Copyright (c) 2014 Robert Audi
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,10 @@
+require "rake/clean"
+require "rubygems"
+require "rubygems/package_task"
+
+spec = eval(File.read("zomgit.gemspec"))
+
+Gem::PackageTask.new(spec) do |pkg|
+end
+
+task default: %i(clean clobber gem)

data/bin/zomgit

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require_relative File.join("..", "lib", "zomgit")
+
+Signal.trap("SIGINT") do
+  puts "\nTerminating"
+  exit 1
+end
+
+zomgit = Zomgit::CLI
+
+exit zomgit.run(ARGV)

data/lib/zomgit.rb

@@ -0,0 +1,81 @@
+# Dev shit
+if ENV["ZOMGIT_DEBUG_MODE"] == "enabled"
+  require "awesome_print" rescue nil
+end
+
+# Require gems shit
+require "gli"
+require "rainbow/ext/string"
+
+
+%w(helpers concerns).each { |f| Dir.glob(File.join(File.dirname(File.realpath(__FILE__)), "zomgit", f, "*.rb")).each { |ff| require ff } }
+
+require_relative File.join(".", "zomgit", "version")
+require_relative File.join(".", "zomgit", "persistor")
+require_relative File.join(".", "zomgit", "exceptions")
+require_relative File.join(".", "zomgit", "commands")
+
+module Zomgit
+  def project_root
+    @project_root
+  end
+  module_function :project_root
+
+  def project_root=(value)
+    if value.empty?
+      raise Zomgit::Exceptions::NoGitRepoFoundError.new("Directory is not a git repository (#{Dir.getwd})")
+    end
+
+    @project_root = value
+  end
+  module_function :project_root=
+
+  class CLI
+    extend GLI::App
+
+    program_desc  "git wrapper for the Z shell"
+    version       Zomgit::VERSION
+
+    pre do |global_options,command,options,args|
+      Zomgit::project_root = File.directory?(File.join(Dir.getwd, ".git")) ? Dir.getwd : `\git rev-parse --show-toplevel 2> /dev/null`.strip
+    end
+
+    command :config do |c|
+      desc "Show the location of the zomgit file to source"
+
+      c.action do |global_options, options, args|
+        puts File.expand_path(File.join("..", "share", "zomgit.zsh"))
+      end
+    end
+
+    Zomgit::Commands::LIST.each do |cname|
+      cmd = Zomgit::Commands.const_get("#{cname.capitalize}Command")
+
+      desc cmd::DESCRIPTION
+      command cname do |c|
+        if cmd.const_defined?("FLAGS")
+          cmd::FLAGS.each { |names, params| c.flag(*names, params) }
+        end
+
+        if cmd.const_defined?("SWITCHES")
+          cmd::SWITCHES.each { |names, params| c.switch(*names, params) }
+        end
+
+        c.action do |global_options, options, args|
+          the_command = cmd.new(args, options)
+          puts the_command.send(Zomgit::Commands::EXECUTION_METHOD)
+        end
+      end
+    end
+
+    on_error do |exception|
+      case exception
+      when Zomgit::Exceptions::BaseError
+        $stderr.puts exception.message.color(:red)
+        false
+      else
+        true
+      end
+    end
+  end
+end

data/lib/zomgit/commands.rb

@@ -0,0 +1,18 @@
+module Zomgit
+  module Commands
+    EXECUTION_METHOD = :execute!
+    FILES = Dir.glob(File.join(File.dirname(File.realpath(__FILE__)), "commands", "*.rb"))
+    LIST = FILES.map { |c| File.basename(c, ".rb") }
+
+    class BasicCommand
+      attr_reader :arguments, :options
+
+      def initialize(arguments = [], options = {})
+        @arguments = arguments
+        @options = options
+      end
+    end
+  end
+end
+
+Zomgit::Commands::FILES.each { |f| require f }

data/lib/zomgit/commands/find.rb

@@ -0,0 +1,49 @@
+module Zomgit
+  module Commands
+    class FindCommand < BasicCommand
+      include Zomgit::Concerns::Findable
+
+      DESCRIPTION = "Find files in the git repo"
+      SWITCHES = {
+        %i(greedy g) => {
+          default_value: true,
+          negatable: true,
+          desc: "Let the finder be greedy (less accurate, more results)"
+        },
+        %i(G) => {
+          default_value: false,
+          negatable: false,
+          desc: "Alias to --no-greedy",
+        },
+        %i(r refine) => {
+          default_value: false,
+          negatable: false,
+          desc: "Let the finder be selective (more accurate, less results)"
+        }
+      }
+
+      FLAGS = {
+        %i(filter f) => {
+          arg_name: "filter",
+          desc: "Limit the search to a specific state (tracked, untracked, etc)",
+          must_match: %w(all untracked tracked unstaged staged modified)
+        }
+      }
+
+      def find
+        if self.arguments.empty?
+          raise Zomgit::Exceptions::MissingQueryError.new("You need to supply a search query!")
+        end
+
+        files = self.search(self.arguments, self.options)
+
+        if files.empty?
+          raise Zomgit::Exceptions::FileOrDirectoryNotFoundError.new("Nothing found matching your query")
+        end
+
+        files.join("\n")
+      end
+      alias_method Zomgit::Commands::EXECUTION_METHOD, :find
+    end
+  end
+end

data/lib/zomgit/commands/status.rb

@@ -0,0 +1,248 @@
+module Zomgit
+  module Commands
+    class StatusCommand < BasicCommand
+      include Zomgit::Helpers::FileHelper
+      include Zomgit::Helpers::RainbowHelper
+
+      attr_reader :filter, :files
+
+      DESCRIPTION = "Show the status of the git repo"
+      FLAGS = {
+        %i(filter f) => {
+          arg_name: "filter",
+          desc: "Status filter",
+          must_match: %w(staged unmerged unstaged untracked)
+        }
+      }
+
+      MAX_CHANGES = 150
+
+      COLORS = {
+        reset:     [:white,  { bold: false }],
+        deleted:   [:red,    { bold: false }],
+        modified:  [:green,  { bold: false }],
+        added:     [:yellow, { bold: false }],
+        renamed:   [:blue,   { bold: false }],
+        copied:    [:yellow, { bold: false }],
+        retyped:   [:purple, { bold: false }],
+        untracked: [:cyan,   { bold: false }],
+        dark:      [:black,  { bold: true  }],
+        branch:    [:gray,   { bold: true  }],
+        header:    [:white,  { bold: false }]
+      }
+
+      GROUPS = {
+        staged:    { color: :yellow, message:       "Changes to be committed" },
+        unmerged:  { color: :red,    message:                "Unmerged paths" },
+        unstaged:  { color: :green,  message: "Changes not staged for commit" },
+        untracked: { color: :cyan,   message:               "Untracked files" }
+      }
+
+      def initialize(arguments = [], options = {})
+        super arguments, options
+
+        @filter = options[:filter].to_sym if options[:filter]
+        @index = 0
+      end
+
+      def show
+        status = `command git status --porcelain`.split("\n")
+
+        if status.count > self.max_changes
+          raise Zomgit::Exceptions::TooManyChangesError.new("Too many changes")
+        end
+
+        git_branch_output = `command git branch -v 2> /dev/null`
+        branch = git_branch_output[/^\* (\(no branch\)|[^ ]*)/, 1]
+        ahead  = git_branch_output[/^\* [^ ]* *[^ ]* *\[ahead ?(\d+).*\]/, 1]
+        behind = git_branch_output[/^\* [^ ]* *[^ ]* *\[.*behind ?(\d+)\]/, 1]
+
+        difference = ["-#{behind}", "+#{ahead}"].select{ |diff| diff.length > 1 }.join("/")
+        if difference.length > 0
+          diff = ""
+          diff << dark_color(" | ")
+          diff << added_color(difference)
+          difference = diff
+        else
+          difference = ""
+        end
+
+        output = ""
+        output << dark_color("#")
+        output << " On branch: "
+        output << branch_color(branch)
+        output << difference
+        output << dark_color(" | ")
+
+        if status.empty?
+          output << modified_color("No changes (working directory clean)")
+        else
+          output << self.stats_for(status).gsub(/(\d+)/, modified_color('\1'))
+          output << dark_color("\n#\n")
+
+          changes = self.changes_for status
+
+          if self.has_filter? && GROUPS.has_key?(self.filter)
+            if changes[self.filter].empty?
+              raise Zomgit::Exceptions::NoChangesError.new("No changes matching this filter")
+            else
+              self.index! changes[self.filter]
+              output << self.output_for(self.filter, changes[self.filter])
+            end
+          else
+            self.index! changes
+            GROUPS.keys.each { |g| output << self.output_for(g, changes[g]) unless changes[g].empty? }
+          end
+        end
+
+        output
+      end
+      alias_method Zomgit::Commands::EXECUTION_METHOD, :show
+
+      # Dynamically create color methods
+      # i.e.: `branch_color`
+      COLORS.each do |type, spec|
+        define_method "#{type}_color" do |message|
+          send(spec.first, message, spec.last)
+        end
+      end
+
+      # Same as above, but for groups
+      GROUPS.each do |group, spec|
+        define_method "#{group}_group_color" do |message, options = {}|
+          send(spec[:color], message, options)
+        end
+      end
+
+      def max_changes
+        unless @max_changes
+          max = ENV["ZOMGIT_STATUS_MAX_CHANGES"].to_i
+          @max_changes = max > 0 ? max : MAX_CHANGES
+        end
+
+        @max_changes
+      end
+
+      def has_modules?
+        @has_modules ||= File.exists?(File.join(Zomgit::project_root, ".gitmodules"))
+      end
+
+      def has_dirty_module?
+        !!@has_dirty_module
+      end
+
+      def has_dirty_module!
+        @has_dirty_module = true
+      end
+
+      def has_filter?
+        !self.filter.nil?
+      end
+
+      def long_status
+        @long_status ||= `command git status`
+      end
+
+      def stats_for(status)
+        stats = "#{status.count} changes ("
+        staged = status.grep(/\A[^ ?]/).count
+        unstaged = status.grep(/\A[ ?]/).count
+        stats << "#{staged} staged, #{unstaged} unstaged"
+        stats << ")"
+      end
+
+      def changes_for(status)
+        changes = {
+          staged:    [],
+          unmerged:  [],
+          unstaged:  [],
+          untracked: []
+        }
+
+        modules = self.has_modules? ? File.read(File.join(Zomgit::project_root, ".gitmodules")) : ""
+
+        status.each do |raw_change|
+          change = { left: raw_change[0], right: raw_change[1], file: raw_change[3..-1] }
+
+          if !self.has_dirty_module? && modules.include?(change[:file])
+            self.has_dirty_module!
+          end
+
+          case raw_change[0..1]
+          when "DD"; changes[:unmerged]  << { message: "   both deleted",  color: :deleted,   file: change[:file] }
+          when "AU"; changes[:unmerged]  << { message: "    added by us",  color: :added,     file: change[:file] }
+          when "UD"; changes[:unmerged]  << { message: "deleted by them",  color: :deleted,   file: change[:file] }
+          when "UA"; changes[:unmerged]  << { message: "  added by them",  color: :added,     file: change[:file] }
+          when "DU"; changes[:unmerged]  << { message: "  deleted by us",  color: :deleted,   file: change[:file] }
+          when "AA"; changes[:unmerged]  << { message: "     both added",  color: :added,     file: change[:file] }
+          when "UU"; changes[:unmerged]  << { message: "  both modified",  color: :modified,  file: change[:file] }
+          when /M./; changes[:staged]    << { message: "  modified",       color: :modified,  file: change[:file] }
+          when /A./; changes[:staged]    << { message: "  new file",       color: :added,     file: change[:file] }
+          when /D./; changes[:staged]    << { message: "   deleted",       color: :deleted,   file: change[:file] }
+          when /R./; changes[:staged]    << { message: "   renamed",       color: :renamed,   file: change[:file] }
+          when /C./; changes[:staged]    << { message: "    copied",       color: :copied,    file: change[:file] }
+          when /T./; changes[:staged]    << { message: "typechange",       color: :retyped,   file: change[:file] }
+          when "??"; changes[:untracked] << { message: " untracked",       color: :untracked, file: change[:file] }
+          end
+
+          if change[:right] == "M"
+            changes[:unstaged] << { message: "  modified", color: :modified, file: change[:file] }
+          elsif change[:right] == "D" && change[:left] != "D" && change[:left] != "U"
+            changes[:unstaged] << { message: "   deleted", color: :deleted, file: change[:file] }
+          elsif change[:right] == "T"
+            changes[:unstaged] << { message: "typechange", color: :retyped, file: change[:file] }
+          end
+        end
+
+        changes
+      end
+
+      def output_for(group, changes)
+        output = ""
+
+        output << send("#{group}_group_color", "\u27A4".encode("utf-8"), bold: true)
+        output << header_color("  #{GROUPS[group][:message]}\n")
+        output << send("#{group}_group_color", "#")
+        output << "\n"
+
+        changes.each do |change|
+          relative_file = relative_path(Dir.pwd, File.join(Zomgit::project_root, change[:file]))
+
+          submodule_change = nil
+          if self.has_dirty_module?
+            submodule_change = self.long_status[/#{change[:file]} \((.*)\)/, 1]
+
+            unless submodule_change.nil?
+              submodule_change = "(#{submodule_change})"
+            end
+          end
+
+          output << send("#{group}_group_color", "#     ")
+          output << send("#{change[:color]}_color", change[:message])
+          output << ": "
+
+          index = self.files.index(change[:file]) + 1
+
+          padding = ""
+          padding << " " if changes.count >= 10 && index < 10
+          padding << " " if changes.count >= 100 && index < 100
+
+          output << "[#{padding}#{index}] "
+
+          output << send("#{group}_group_color", relative_file)
+          output << " #{submodule_change}\n"
+        end
+
+        output << send("#{group}_group_color", "#")
+        output << "\n"
+        output
+      end
+
+      def index!(changes, persist: true)
+        @files = changes.values.flatten.map { |c| c[:file] }
+
+        Zomgit::Persistor.instance.cache_index(@files) if persist
+      end
+    end
+  end
+end