git_shizzle 0.2.6

data/lib/git_shizzle/index_specifications/combined.rb

@@ -0,0 +1,51 @@
+# -*- encoding: utf-8 -*-
+
+module GitShizzle::IndexSpecifications
+  class Combined
+    def initialize(specs)
+      @specs = specs
+    end
+
+    def include?(index)
+      index = humanize index
+
+      @specs.any? do |spec|
+        spec.include? index
+      end
+    end
+
+    def register_match(index)
+      index = humanize index
+
+      @specs.each do |spec|
+        spec.register_match index
+      end
+    end
+
+    def unmatched
+      []
+    end
+
+    def apply(files)
+      result = files.each_with_index.map do |element, index|
+        next unless include? index
+        register_match index
+
+        element
+      end.compact
+
+      unmatched_indexes = @specs.map do |spec|
+        spec.unmatched
+      end.flatten.compact.uniq.sort
+
+      raise IndexSpecificationError.new(unmatched_indexes) if unmatched_indexes.any?
+
+      result
+    end
+
+    private
+    def humanize(index)
+      index + 1
+    end
+  end
+end

data/lib/git_shizzle/index_specifications/errors.rb

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+module GitShizzle::IndexSpecifications
+  class IndexSpecificationError < GitShizzle::Error
+    def initialize(indexes)
+      super "Could not determine files for indexes: #{indexes.join(', ')}"
+    end
+  end
+
+  class IndexParserError < GitShizzle::Error
+    def initialize(index)
+      super "Could not parse index '#{index}'. Please use numeric indexes or Ruby-style ranges."
+    end
+  end
+
+  class NoFilesError < GitShizzle::Error
+    def initialize(identifier)
+      super "No files for command '#{identifier}'."
+    end
+  end
+end

data/lib/git_shizzle/index_specifications/everything.rb

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+
+module GitShizzle::IndexSpecifications
+  class Everything < Base
+    def include?(index)
+      true
+    end
+
+    def unmatched
+      []
+    end
+
+    def inspect
+      self.class
+    end
+  end
+end

data/lib/git_shizzle/index_specifications/exclusive_range.rb

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+
+module GitShizzle::IndexSpecifications
+  class ExclusiveRange < Base
+    def initialize(index)
+      spec = index.split('...')
+      assert_numeric index, *spec
+
+      @range = ::Range.new(*spec.map(&:to_i)).to_a[0..-2]
+    end
+
+    def include?(index)
+      @range.include? index
+    end
+
+    def unmatched
+      @range - matches
+    end
+
+    def inspect
+      "#{self.class}: #{@range.inspect}"
+    end
+  end
+end

data/lib/git_shizzle/index_specifications/file.rb

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+
+module GitShizzle::IndexSpecifications
+  class File < Base
+    def initialize(index)
+      assert_numeric index
+      @index = index.to_i
+    end
+
+    def include?(index)
+      @index == index
+    end
+
+    def unmatched
+      ([] << @index) - matches
+    end
+
+    def inspect
+      "#{self.class}: #{@index}"
+    end
+  end
+end

data/lib/git_shizzle/index_specifications/range.rb

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+
+module GitShizzle::IndexSpecifications
+  class Range < Base
+    def initialize(index)
+      spec = index.split('..')
+      assert_numeric index, *spec
+
+      @range = ::Range.new(*spec.map(&:to_i)).to_a
+    end
+
+    def include?(index)
+      @range.include? index
+    end
+
+    def unmatched
+      @range - matches
+    end
+
+    def inspect
+      "#{self.class}: #{@range.inspect}"
+    end
+  end
+end

data/lib/git_shizzle/index_specifications.rb

@@ -0,0 +1,10 @@
+# -*- encoding: utf-8 -*-
+
+require 'git_shizzle/index_specifications/base'
+
+Dir["#{File.dirname(__FILE__)}/index_specifications/*.rb"].each do |path|
+  require "git_shizzle/index_specifications/#{File.basename(path, '.rb')}"
+end
+
+module GitShizzle::IndexSpecifications
+end

data/lib/git_shizzle/version.rb

@@ -0,0 +1,5 @@
+# -*- encoding: utf-8 -*-
+
+module GitShizzle
+  VERSION = '0.2.6'
+end

data/lib/git_shizzle.rb

@@ -0,0 +1,53 @@
+# -*- encoding: utf-8 -*-
+
+require 'git_shizzle/error'
+require 'git_shizzle/dsl'
+require 'git_shizzle/git'
+require 'git_shizzle/index_specifications'
+
+module GitShizzle
+
+  class QuickGit
+    def initialize(git = Git::Git.new(Dir.pwd))
+      @git = git
+      @commands = GitShizzle::Dsl::CommandCollection.new
+      @commands.load
+    end
+
+    def run(command, *indexes)
+      cmd = @commands.find command
+      files = changes_for(indexes, cmd)
+
+      cmd.invoke @git, files
+    end
+
+    def method_missing(sym, *args)
+      run(sym, *args)
+    end
+
+    private
+    def create_index_specification(indexes)
+      specs = indexes.map { |index|
+        case index
+          when /\.\.\./
+            IndexSpecifications::ExclusiveRange.new(index)
+          when /\.\./
+            IndexSpecifications::Range.new(index)
+          when /\./
+            IndexSpecifications::Everything.new
+          else
+            IndexSpecifications::File.new(index)
+        end
+      }
+
+      IndexSpecifications::Combined.new specs
+    end
+
+    def changes_for(indexes, command)
+      files = command.applicable_files(@git.status)
+
+      spec = create_index_specification indexes
+      spec.apply files
+    end
+  end
+end

data/spec/git-shizzle/builtin_commands/checkout_spec.rb

@@ -0,0 +1,49 @@
+require File.join(File.dirname(__FILE__), '../../spec_helper')
+require 'git_shizzle'
+
+describe 'Checkout files by index' do
+
+  let(:git) { GitShizzle::Git::Git.new(repo) }
+  subject { GitShizzle::QuickGit.new(git) }
+
+  context 'repository with modified files' do
+    before (:each) do
+      %w{ deleted modified }.each { |f| create f; stage f }
+      `git commit --message Blah`
+
+      delete 'deleted'
+      modify 'modified'
+      
+      git.status[0].work_tree_status.should == :deleted
+      git.status[1].work_tree_status.should == :modified
+    end
+
+    context 'when a modified file is checked out' do
+      it 'should run git checkout' do
+        git.stub(:command).and_call_original
+        git.stub(:command).with(/checkout/, anything)
+
+        expect(git).to receive(:command).with('checkout --', ['modified'])
+
+        subject.checkout 2
+      end
+    end
+
+    context 'when a deleted file is checked out' do
+      it 'should run git checkout' do
+        git.stub(:command).and_call_original
+        git.stub(:command).with(/checkout/, anything)
+
+        expect(git).to receive(:command).with('checkout --', ['deleted'])
+
+        subject.checkout 1
+      end
+    end
+  end
+
+  context 'when the repository contains no modified files' do
+    it 'should fail' do
+      expect { subject.checkout 1 }.to raise_error
+    end
+  end
+end

data/spec/git-shizzle/builtin_commands/diff_cached_spec.rb

@@ -0,0 +1,53 @@
+require File.join(File.dirname(__FILE__), '../../spec_helper')
+require 'git_shizzle'
+
+describe 'Diff staged/cached files by index' do
+
+  let(:git) { GitShizzle::Git::Git.new(repo) }
+  subject { GitShizzle::QuickGit.new(git) }
+
+  context 'repository with modified files' do
+    before (:each) do
+      %w{ deleted modified }.each { |f| create f; stage f }
+      `git commit --message Blah`
+
+      delete 'deleted'
+      stage 'deleted'
+      modify 'modified'
+      stage 'modified'
+      
+      git.status[0].work_tree_status.should == nil
+      git.status[0].index_status.should == :deleted
+      git.status[1].work_tree_status.should == nil
+      git.status[1].index_status.should == :modified
+    end
+
+    context 'when a staged modified file is diffed' do
+      it 'should run git diff --cached' do
+        git.stub(:command).and_call_original
+        git.stub(:command).with(/diff/, anything)
+
+        expect(git).to receive(:command).with('diff --cached --', ['modified'])
+
+        subject.diff_cached 2
+      end
+    end
+
+    context 'when a staged deleted file is diffed' do
+      it 'should run git diff --cached' do
+        git.stub(:command).and_call_original
+        git.stub(:command).with(/diff/, anything)
+
+        expect(git).to receive(:command).with('diff --cached --', ['deleted'])
+
+        subject.diff_cached 1
+      end
+    end
+  end
+
+  context 'when the repository contains no staged files' do
+    it 'should fail' do
+      expect { subject.diff_cached 1 }.to raise_error
+    end
+  end
+end

data/spec/git-shizzle/builtin_commands/diff_spec.rb

@@ -0,0 +1,49 @@
+require File.join(File.dirname(__FILE__), '../../spec_helper')
+require 'git_shizzle'
+
+describe 'Diff files by index' do
+
+  let(:git) { GitShizzle::Git::Git.new(repo) }
+  subject { GitShizzle::QuickGit.new(git) }
+
+  context 'repository with modified files' do
+    before (:each) do
+      %w{ deleted modified }.each { |f| create f; stage f }
+      `git commit --message Blah`
+
+      delete 'deleted'
+      modify 'modified'
+
+      git.status[0].work_tree_status.should == :deleted
+      git.status[1].work_tree_status.should == :modified
+    end
+
+    context 'when a modified file is diffed' do
+      it 'should run git diff' do
+        git.stub(:command).and_call_original
+        git.stub(:command).with(/diff/, anything)
+
+        expect(git).to receive(:command).with('diff --', ['modified'])
+
+        subject.diff 2
+      end
+    end
+
+    context 'when a deleted file is diffed' do
+      it 'should run git diff' do
+        git.stub(:command).and_call_original
+        git.stub(:command).with(/diff/, anything)
+
+        expect(git).to receive(:command).with('diff --', ['deleted'])
+
+        subject.diff 1
+      end
+    end
+  end
+
+  context 'when the repository contains no modified files' do
+    it 'should fail' do
+      expect { subject.diff 1 }.to raise_error
+    end
+  end
+end

data/spec/git-shizzle/builtin_commands/stage_patch_spec.rb

@@ -0,0 +1,32 @@
+require File.join(File.dirname(__FILE__), '../../spec_helper')
+require 'git_shizzle'
+
+describe 'Stage patches by index', :draft => true do
+
+  let(:git) { GitShizzle::Git::Git.new(repo) }
+  subject { GitShizzle::QuickGit.new(git) }
+
+  context 'repository with modified files' do
+    before (:each) do
+      %w{ deleted modified }.each { |f| create f; stage f }
+      `git commit --message Blah`
+
+      delete 'deleted'
+      modify 'modified'
+
+      git.status[0].work_tree_status.should == :deleted
+      git.status[1].work_tree_status.should == :modified
+    end
+
+    context 'when a modified file is staged' do
+      it 'should run git add --patch' do
+        git.stub(:command).and_call_original
+        git.stub(:command).with(/add/, anything)
+
+        expect(git).to receive(:command).with('add --patch --', ['modified'])
+
+        subject.stage_with_patch 2
+      end
+    end
+  end
+end

data/spec/git-shizzle/builtin_commands/stage_spec.rb

@@ -0,0 +1,75 @@
+require File.join(File.dirname(__FILE__), '../../spec_helper')
+require 'git_shizzle'
+
+describe 'Stage files by index' do
+
+  let(:git) { GitShizzle::Git::Git.new(repo) }
+  subject { GitShizzle::QuickGit.new(git) }
+
+  context 'repository with modified files' do
+    before (:each) do
+      %w{ deleted modified }.each { |f| create f; stage f }
+      `git commit --message Blah`
+
+      delete 'deleted'
+      modify 'modified'
+
+      git.status[0].work_tree_status.should == :deleted
+      git.status[1].work_tree_status.should == :modified
+    end
+
+    context 'when a deleted file is staged' do
+      it 'should run git rm' do
+        subject.stage 1
+
+        git.status[0].index_status.should == :deleted
+        git.status[1].index_status.should be_nil
+      end
+    end
+
+    context 'when a modified file is staged' do
+      it 'should run git add' do
+        subject.stage 2
+
+        git.status[0].index_status.should be_nil
+        git.status[1].index_status.should == :modified
+      end
+    end
+
+    context 'when a modified and a deleted file is staged' do
+      it 'should run git add and git rm' do
+        subject.stage 1, 2
+
+        git.status[0].index_status.should == :deleted
+        git.status[1].index_status.should == :modified
+      end
+    end
+  end
+
+  context 'staged file has been modified' do
+    context 'when the file is staged' do
+      before do
+        %w{ modified }.each { |f| create f; stage f }
+        `git commit --message Blah`
+
+        %w{ modified }.each { |f| modify f; stage f; modify f }
+
+        git.status[0].index_status.should == :modified
+        git.status[0].work_tree_status.should == :modified
+      end
+
+      it 'should run git add' do
+        subject.stage 1
+
+        git.status[0].index_status.should == :modified
+        git.status[0].work_tree_status.should be_nil
+      end
+    end
+  end
+
+  context 'when the repository contains no modified files' do
+    it 'should fail' do
+      expect { subject.stage 1 }.to raise_error
+    end
+  end
+end

data/spec/git-shizzle/builtin_commands/track_spec.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(__FILE__), '../../spec_helper')
+require 'git_shizzle'
+
+describe 'Track files by index' do
+
+  let(:git) { GitShizzle::Git::Git.new(repo) }
+  subject { GitShizzle::QuickGit.new(git) }
+
+  context 'repository with untracked files' do
+    before (:each) do
+      create 'untracked-1'
+      create 'untracked-2'
+
+      git.status[0].work_tree_status.should == :untracked
+      git.status[1].work_tree_status.should == :untracked
+    end
+
+    context 'when a single file is tracked' do
+      it 'should run git add for the file' do
+        subject.track 1
+
+        git.status[0].index_status.should == :added
+        git.status[1].index_status.should == :untracked
+      end
+    end
+
+    context 'when multiple files are tracked' do
+      it 'should run git add for all specified files' do
+        subject.track 1, 2
+
+        git.status.each { |entry| entry.index_status.should == :added }
+      end
+    end
+  end
+
+  context 'when the repository contains no untracked files' do
+    it 'should fail' do
+      expect { subject.track 1 }.to raise_error
+    end
+  end
+end

data/spec/git-shizzle/builtin_commands/unstage_spec.rb

@@ -0,0 +1,68 @@
+require File.join(File.dirname(__FILE__), '../../spec_helper')
+require 'git_shizzle'
+
+describe 'Unstage staged/cached files by index' do
+
+  let(:git) { GitShizzle::Git::Git.new(repo) }
+  subject { GitShizzle::QuickGit.new(git) }
+
+  context 'repository with modified files' do
+    before (:each) do
+      %w{ deleted modified }.each { |f| create f; stage f }
+      `git commit --message Blah`
+
+      delete 'deleted'
+      stage 'deleted'
+      modify 'modified'
+      stage 'modified'
+      create 'untracked'
+      stage 'untracked'
+
+      git.status[0].work_tree_status.should == nil
+      git.status[0].index_status.should == :deleted
+      git.status[1].work_tree_status.should == nil
+      git.status[1].index_status.should == :modified
+      git.status[2].work_tree_status.should == nil
+      git.status[2].index_status.should == :added
+    end
+
+    context 'when a staged modified file is unstaged' do
+      it 'should run git reset HEAD' do
+        git.stub(:command).and_call_original
+        git.stub(:command).with(/reset/, anything)
+
+        expect(git).to receive(:command).with('reset HEAD --', ['modified'])
+
+        subject.unstage 2
+      end
+    end
+
+    context 'when a staged deleted file is unstaged' do
+      it 'should run git reset HEAD' do
+        git.stub(:command).and_call_original
+        git.stub(:command).with(/reset/, anything)
+
+        expect(git).to receive(:command).with('reset HEAD --', ['deleted'])
+
+        subject.unstage 1
+      end
+    end
+
+    context 'when a staged new file is unstaged' do
+      it 'should run git reset HEAD' do
+        git.stub(:command).and_call_original
+        git.stub(:command).with(/reset/, anything)
+
+        expect(git).to receive(:command).with('reset HEAD --', ['untracked'])
+
+        subject.unstage 3
+      end
+    end
+  end
+
+  context 'when the repository contains no staged files' do
+    it 'should fail' do
+      expect { subject.unstage 1 }.to raise_error
+    end
+  end
+end

data/spec/git-shizzle/command_spec.rb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__), '../spec_helper')
+require 'git_shizzle'
+
+describe 'Commands specified on the CLI' do
+
+  let(:git) { GitShizzle::Git::Git.new(repo) }
+  subject { GitShizzle::QuickGit.new(git) }
+
+  context 'when invoking a command that does not exist' do
+    it 'should fail' do
+      expect { subject.run(:blah) }.to raise_error(GitShizzle::Dsl::CommandNotFoundError, "Could not find 'blah' command.")
+    end
+  end
+end

data/spec/git-shizzle/dsl_spec.rb

@@ -0,0 +1,48 @@
+require File.join(File.dirname(__FILE__), '../spec_helper')
+require 'git_shizzle'
+
+describe 'Command DSL' do
+
+  context 'when reading commands' do
+    it 'should not accept commands without a definition' do
+      commands = GitShizzle::Dsl::CommandCollection.new
+      command_spec = <<-EOF
+command :foo
+      EOF
+
+      expect { commands.load command_spec }.to raise_error(GitShizzle::Dsl::CommandDefinitionError, "Command 'foo': #command requires a block.")
+    end
+  end
+
+  it 'should not accept duplicate identifiers' do
+    commands = GitShizzle::Dsl::CommandCollection.new
+    command_spec = <<-EOF
+command :foo do end
+command :foo do end
+    EOF
+
+    expect { commands.load command_spec }.to raise_error(GitShizzle::Dsl::DuplicateCommandDefinitionError, "The 'foo' command was specified twice.")
+  end
+
+  it 'should not accept empty filters' do
+    commands = GitShizzle::Dsl::CommandCollection.new
+    command_spec = <<-EOF
+command :foo do
+  applies_to
+end
+    EOF
+
+    expect { commands.load command_spec }.to raise_error(GitShizzle::Dsl::CommandDefinitionError, "Command 'foo': #applies_to requires a block.")
+  end
+
+  it 'should not accept empty actions' do
+    commands = GitShizzle::Dsl::CommandCollection.new
+    command_spec = <<-EOF
+command :foo do
+  action
+end
+    EOF
+
+    expect { commands.load command_spec }.to raise_error(GitShizzle::Dsl::CommandDefinitionError, "Command 'foo': #action requires a block.")
+  end
+end

data/spec/git-shizzle/git_spec.rb

@@ -0,0 +1,15 @@
+require File.join(File.dirname(__FILE__), '../spec_helper')
+require 'git_shizzle'
+
+describe 'Git Repository' do
+
+  let(:git) { GitShizzle::Git::Git.new(repo) }
+  subject { GitShizzle::QuickGit.new(git) }
+
+  context 'when invoking a command outside a Git repository' do
+    it 'should fail' do
+      FileUtils.rm_rf '.git'
+      expect { subject.run(:track) }.to raise_error(GitShizzle::Git::GitExecuteError, /Not a git repository/)
+    end
+  end
+end