thegarage-gitx 1.5.4 → 1.5.5.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 12ad97ed250ce473831e0bec8c9bdd39ded30b53
-  data.tar.gz: f2ec63227dd93e13a4f8d42a6b948141600ae281
+  metadata.gz: 1b5057c596d4343322b8f10cb5cc5ffa5d88cc5d
+  data.tar.gz: 0a0d051f8550bf0e3570e900bfffa4c11bf17e29
 SHA512:
-  metadata.gz: dd9dda74370073881e10818c206e89a8c95ee8cf913d722f5998f381658d737586054615cb0998ea9d2d284ab2dd826cd0c34a548732affa5ca1205e2763f646
-  data.tar.gz: fa758c96f712fcff8753c712071e64a0e32a62277a0763cfc774200645caa2e7baba43a681db0e6dae11c5512bdb4df1619de15c726ce5a6e256552f056c867f
+  metadata.gz: 363c8537bd5f8a1332a523532d4554f5b7ae72a7cab3c5e943eaf7dbd9239ab1bbe7baac6bc7a97aa8f8f8d86d1992c6c1c19e5bee3c9ed007ac0ce1ab6c28fb
+  data.tar.gz: a6263f625f0c130626419a035d90e8f64c6e7066ff738a1be3dfd3af4c6df791972aff7e81f96ad01859a1195977467d7c8d90827c11cfda5d08c045778d8f9a

data/lib/thegarage/gitx.rb

@@ -2,8 +2,6 @@ require 'thegarage/gitx/version'
 require 'thegarage/gitx/string_extensions'
 require 'thegarage/gitx/git'
 require 'thegarage/gitx/github'
-require 'English'
-
 
 module Thegarage
   module Gitx

data/lib/thegarage/gitx/cli.rb

@@ -1,7 +1,10 @@
+require 'English'
 require "thor"
 require 'rest_client'
 require 'thegarage/gitx'
+require 'thegarage/gitx/git'
 require 'thegarage/gitx/github'
+require 'thegarage/gitx/runner'
 
 module Thegarage
   module Gitx
@@ -9,10 +12,6 @@ module Thegarage
       include Thor::Actions
       add_runtime_options!
 
-      include Thegarage::Gitx::Git
-
-      TAGGABLE_BRANCHES = %w(master staging)
-
       method_option :trace, :type => :boolean, :aliases => '-v'
       def initialize(*args)
         super(*args)
@@ -28,87 +27,53 @@ module Thegarage
       def reviewrequest
         fail 'Github authorization token not found' unless github.authorization_token
 
-        pull_request = github.find_pull_request(current_branch)
+        branch = git.current_branch.name
+        pull_request = github.find_pull_request(branch)
         if pull_request.nil?
-          update
-          changelog = run_cmd "git log #{Thegarage::Gitx::BASE_BRANCH}...#{current_branch} --no-merges --pretty=format:'* %s%n%b'"
-          pull_request = github.create_pull_request(current_branch, changelog, options)
+          git.update
+          changelog = runner.run_cmd "git log #{Thegarage::Gitx::BASE_BRANCH}...#{branch} --no-merges --pretty=format:'* %s%n%b'"
+          pull_request = github.create_pull_request(branch, changelog, options)
           say 'Pull request created: '
           say pull_request['html_url'], :green
         end
         github.assign_pull_request(pull_request, options[:assignee]) if options[:assignee]
 
-        run_cmd "open #{pull_request['html_url']}" if options[:open]
+        runner.run_cmd "open #{pull_request['html_url']}" if options[:open]
       end
 
-      # TODO: use --no-edit to skip merge messages
-      # TODO: use pull --rebase to skip merge commit
       desc 'update', 'Update the current branch with latest changes from the remote feature branch and master'
       def update
-        branch = current_branch
-
-        say 'updating '
-        say "#{branch} ", :green
-        say "to have most recent changes from "
-        say Thegarage::Gitx::BASE_BRANCH, :green
-
-        run_cmd "git pull origin #{branch}", :allow_failure => true
-        run_cmd "git pull origin #{Thegarage::Gitx::BASE_BRANCH}"
-        run_cmd 'git push origin HEAD'
+        git.update
       end
 
       desc 'cleanup', 'Cleanup branches that have been merged into master from the repo'
       def cleanup
-        run_cmd "git checkout #{Thegarage::Gitx::BASE_BRANCH}"
-        run_cmd "git pull"
-        run_cmd 'git remote prune origin'
-
-        say "Deleting branches that have been merged into "
-        say Thegarage::Gitx::BASE_BRANCH, :green
-        branches(:merged => true, :remote => true).each do |branch|
-          run_cmd "git push origin --delete #{branch}" unless aggregate_branch?(branch)
-        end
-        branches(:merged => true).each do |branch|
-          run_cmd "git branch -d #{branch}" unless aggregate_branch?(branch)
-        end
+        git.cleanup
       end
 
       desc 'track', 'set the current branch to track the remote branch with the same name'
       def track
-        track_branch current_branch
+        git.track
       end
 
       desc 'start', 'start a new git branch with latest changes from master'
       def start(branch_name = nil)
-        unless branch_name
-          example_branch = %w{ api-fix-invalid-auth desktop-cleanup-avatar-markup share-form-add-edit-link }.shuffle.first
-          repo = Grit::Repo.new(Dir.pwd)
-          remote_branches = repo.remotes.collect {|b| b.name.split('/').last }
-          until branch_name = ask("What would you like to name your branch? (ex: #{example_branch})") {|q|
-              q.validate = Proc.new { |branch|
-                branch =~ /^[A-Za-z0-9\-_]+$/ && !remote_branches.include?(branch)
-              }
-            }
-          end
+        until git.valid_new_branch_name?(branch_name)
+          example_branch = %w{ api-fix-invalid-auth desktop-cleanup-avatar-markup share-form-add-edit-link }.sample
+          branch_name = ask("What would you like to name your branch? (ex: #{example_branch})")
         end
 
-        run_cmd "git checkout #{Thegarage::Gitx::BASE_BRANCH}"
-        run_cmd 'git pull'
-        run_cmd "git checkout -b #{branch_name}"
+        git.start branch_name
       end
 
       desc 'share', 'Share the current branch in the remote repository'
       def share
-        share_branch current_branch
+        git.share
       end
 
       desc 'integrate', 'integrate the current branch into one of the aggregate development branches'
       def integrate(target_branch = 'staging')
-        branch = current_branch
-
-        update
-        integrate_branch(branch, target_branch)
-        run_cmd "git checkout #{branch}"
+        git.integrate target_branch
       end
 
       desc 'nuke', 'nuke the specified aggregate branch and reset it to a known good state'
@@ -117,63 +82,35 @@ module Thegarage
         good_branch = options[:destination] || ask("What branch do you want to reset #{bad_branch} to? (default: #{bad_branch})")
         good_branch = bad_branch if good_branch.length == 0
 
-        last_known_good_tag = build_tags_for_branch(good_branch).last
-        raise "No known good tag found for branch: #{good_branch}.  Verify tag exists via `git tag -l 'build-#{good_branch}-*'`" unless last_known_good_tag
+        last_known_good_tag = git.current_build_tag(good_branch)
         return unless yes?("Reset #{bad_branch} to #{last_known_good_tag}? (y/n)", :green)
 
-        nuke_branch(bad_branch, last_known_good_tag)
+        git.nuke bad_branch, last_known_good_tag
       end
 
       desc 'release', 'release the current branch to production'
       def release
-        branch = current_branch
-        assert_not_protected_branch!(branch, 'release')
-        update
-
-        return unless yes?("Release #{branch} to production? (y/n)", :green)
-        run_cmd "git checkout #{Thegarage::Gitx::BASE_BRANCH}"
-        run_cmd "git pull origin #{Thegarage::Gitx::BASE_BRANCH}"
-        run_cmd "git pull . #{branch}"
-        run_cmd "git push origin HEAD"
-        integrate_branch('master', 'staging')
-        cleanup
+        return unless yes?("Release #{git.current_branch.name} to production? (y/n)", :green)
+        git.release
       end
 
       desc 'buildtag', 'create a tag for the current Travis-CI build and push it back to origin'
       def buildtag
-        branch = ENV['TRAVIS_BRANCH']
-        pull_request = ENV['TRAVIS_PULL_REQUEST']
-
-        raise "Unknown branch. ENV['TRAVIS_BRANCH'] is required." unless branch
-
-        if pull_request != 'false'
-          say "Skipping creation of tag for pull request: #{pull_request}"
-        elsif !TAGGABLE_BRANCHES.include?(branch)
-          say "Cannot create build tag for branch: #{branch}. Only #{TAGGABLE_BRANCHES} are supported."
-        else
-          label = "Generated tag from TravisCI build #{ENV['TRAVIS_BUILD_NUMBER']}"
-          create_build_tag(branch, label)
-        end
+        git.buildtag
       end
 
       private
 
-      # execute a shell command and raise an error if non-zero exit code is returned
-      # return the string output from the command
-      def run_cmd(cmd, options = {})
-        output = run(cmd, capture: true)
-        success = $CHILD_STATUS.to_i == 0
-        fail "#{cmd} failed" unless success || options[:allow_failure]
-        output
+      def github
+        @github ||= Thegarage::Gitx::Github.new(git.repo, shell)
       end
 
-      # check if --pretend or -p flag passed to CLI
-      def pretend?
-        options[:pretend]
+      def git
+        @git ||= Thegarage::Gitx::Git.new(shell, runner)
       end
 
-      def github
-        @github ||= Thegarage::Gitx::Github.new(current_repo, self)
+      def runner
+        @runner ||= Thegarage::Gitx::Runner.new(shell, options)
       end
     end
   end

data/lib/thegarage/gitx/git.rb

@@ -1,24 +1,140 @@
-require 'grit'
 require 'pathname'
+require 'rugged'
 
 module Thegarage
   module Gitx
-    module Git
-      AGGREGATE_BRANCHES = %w{ staging prototype }
-      RESERVED_BRANCHES = %w{ HEAD master next_release } + AGGREGATE_BRANCHES
+    class Git
+      AGGREGATE_BRANCHES = %w( staging prototype )
+      RESERVED_BRANCHES = %w( HEAD master next_release ) + AGGREGATE_BRANCHES
+      TAGGABLE_BRANCHES = %w( master staging )
+
+      attr_accessor :shell, :runner, :repo
+
+      def initialize(shell, runner, path = Dir.pwd)
+        @shell = shell
+        @runner = runner
+        root_path = Rugged::Repository.discover(path)
+        @repo = Rugged::Repository.new(root_path)
+      end
 
-      private
-      def assert_not_protected_branch!(branch, action)
-        raise "Cannot #{action} reserved branch" if RESERVED_BRANCHES.include?(branch) || aggregate_branch?(branch)
+      def update
+        shell.say 'Updating '
+        shell.say "#{current_branch.name} ", :green
+        shell.say "with latest changes from "
+        shell.say Thegarage::Gitx::BASE_BRANCH, :green
+
+        runner.run_cmd "git pull origin #{current_branch.name}", :allow_failure => true
+        runner.run_cmd "git pull origin #{Thegarage::Gitx::BASE_BRANCH}"
+        runner.run_cmd 'git push origin HEAD'
+      end
+
+      def track
+        runner.run_cmd "git branch --set-upstream-to origin/#{current_branch.name}"
+      end
+
+      def share
+        runner.run_cmd "git push origin #{current_branch.name}"
+        track
+      end
+
+      def valid_new_branch_name?(branch)
+        remote_branches = Rugged::Branch.each_name(repo, :remote).to_a.map { |branch| branch.split('/').last }
+        branch =~ /^[A-Za-z0-9\-_]+$/ && !remote_branches.include?(branch)
+      end
+
+      def start(branch_name)
+        runner.run_cmd "git checkout #{Thegarage::Gitx::BASE_BRANCH}"
+        runner.run_cmd 'git pull'
+        runner.run_cmd "git checkout -b #{branch_name}"
       end
 
-      # lookup the current branch of the PWD
+      def cleanup
+        runner.run_cmd "git checkout #{Thegarage::Gitx::BASE_BRANCH}"
+        runner.run_cmd "git pull"
+        runner.run_cmd 'git remote prune origin'
+
+        shell.say "Deleting branches that have been merged into "
+        shell.say Thegarage::Gitx::BASE_BRANCH, :green
+        branches(:merged => true, :remote => true).each do |branch|
+          runner.run_cmd "git push origin --delete #{branch}" unless aggregate_branch?(branch)
+        end
+        branches(:merged => true).each do |branch|
+          runner.run_cmd "git branch -d #{branch}" unless aggregate_branch?(branch)
+        end
+      end
+
+      def integrate(target_branch = 'staging')
+        update
+
+        branch = current_branch.name
+        integrate_branch(branch, target_branch)
+        runner.run_cmd "git checkout #{branch}"
+      end
+
+      def current_build_tag(branch)
+        last_build_tag = build_tags_for_branch(branch).last
+        raise "No known good tag found for branch: #{branch}.  Verify tag exists via `git tag -l 'build-#{branch}-*'`" unless last_build_tag
+        last_build_tag
+      end
+
+      # reset the specified aggregate branch to the same set of commits as the destination branch
+      def nuke(outdated_branch, target_reference)
+        return if outdated_branch == target_reference
+        fail "Only aggregate branches are allowed to be reset: #{AGGREGATE_BRANCHES}" unless aggregate_branch?(outdated_branch)
+        return if migrations_need_to_be_reverted?
+
+        shell.say "Resetting "
+        shell.say "#{outdated_branch} ", :green
+        shell.say "branch to "
+        shell.say target_reference, :green
+
+        runner.run_cmd "git checkout #{Thegarage::Gitx::BASE_BRANCH}"
+        runner.run_cmd "git branch -D #{outdated_branch}", :allow_failure => true
+        runner.run_cmd "git push origin --delete #{outdated_branch}", :allow_failure => true
+        runner.run_cmd "git checkout -b #{outdated_branch} #{target_reference}"
+        runner.run_cmd "git push origin #{outdated_branch}"
+        runner.run_cmd "git branch --set-upstream-to origin/#{outdated_branch}"
+        runner.run_cmd "git checkout #{Thegarage::Gitx::BASE_BRANCH}"
+      end
+
+      # lookup the current branch of the repo
       def current_branch
-        Grit::Head.current(current_repo).name
+        repo.branches.find(&:head?)
       end
 
-      def current_repo
-        @repo ||= Grit::Repo.new(Dir.pwd)
+      def release
+        branch = current_branch.name
+        assert_not_protected_branch!(branch, 'release')
+        update
+
+        runner.run_cmd "git checkout #{Thegarage::Gitx::BASE_BRANCH}"
+        runner.run_cmd "git pull origin #{Thegarage::Gitx::BASE_BRANCH}"
+        runner.run_cmd "git pull . #{branch}"
+        runner.run_cmd "git push origin HEAD"
+        integrate('staging')
+        cleanup
+      end
+
+      def buildtag
+        branch = ENV['TRAVIS_BRANCH']
+        pull_request = ENV['TRAVIS_PULL_REQUEST']
+
+        raise "Unknown branch. ENV['TRAVIS_BRANCH'] is required." unless branch
+
+        if pull_request != 'false'
+          shell.say "Skipping creation of tag for pull request: #{pull_request}"
+        elsif !TAGGABLE_BRANCHES.include?(branch)
+          shell.say "Cannot create build tag for branch: #{branch}. Only #{TAGGABLE_BRANCHES} are supported."
+        else
+          label = "Generated tag from TravisCI build #{ENV['TRAVIS_BUILD_NUMBER']}"
+          create_build_tag(branch, label)
+        end
+      end
+
+      private
+
+      def assert_not_protected_branch!(branch, action)
+        raise "Cannot #{action} reserved branch" if RESERVED_BRANCHES.include?(branch) || aggregate_branch?(branch)
       end
 
       # retrieve a list of branches
@@ -36,56 +152,27 @@ module Thegarage
         branches.uniq
       end
 
-      # reset the specified aggregate branch to the same set of commits as the destination branch
-      def nuke_branch(outdated_branch, head_branch)
-        return if outdated_branch == head_branch
-        fail "Only aggregate branches are allowed to be reset: #{AGGREGATE_BRANCHES}" unless aggregate_branch?(outdated_branch)
-        return if migrations_need_to_be_reverted?
-
-        say "Resetting "
-        say "#{outdated_branch} ", :green
-        say "branch to "
-        say head_branch, :green
-
-        run_cmd "git checkout #{Thegarage::Gitx::BASE_BRANCH}"
-        run_cmd "git branch -D #{outdated_branch}", :allow_failure => true
-        run_cmd "git push origin --delete #{outdated_branch}", :allow_failure => true
-        run_cmd "git checkout -b #{outdated_branch} #{head_branch}"
-        share_branch outdated_branch
-        run_cmd "git checkout #{Thegarage::Gitx::BASE_BRANCH}"
-      end
-
-      # share the local branch in the remote repo
-      def share_branch(branch)
-        run_cmd "git push origin #{branch}"
-        track_branch branch
-      end
-
-      def track_branch(branch)
-        run_cmd "git branch --set-upstream-to origin/#{branch}"
-      end
-
       # integrate a branch into a destination aggregate branch
       # blow away the local aggregate branch to ensure pulling into most recent "clean" branch
       def integrate_branch(branch, destination_branch)
         assert_not_protected_branch!(branch, 'integrate') unless aggregate_branch?(destination_branch)
         raise "Only aggregate branches are allowed for integration: #{AGGREGATE_BRANCHES}" unless aggregate_branch?(destination_branch) || destination_branch == Thegarage::Gitx::BASE_BRANCH
-        say "Integrating "
-        say "#{branch} ", :green
-        say "into "
-        say destination_branch, :green
+        shell.say "Integrating "
+        shell.say "#{branch} ", :green
+        shell.say "into "
+        shell.say destination_branch, :green
 
         refresh_branch_from_remote destination_branch
-        run_cmd "git pull . #{branch}"
-        run_cmd "git push origin HEAD"
-        run_cmd "git checkout #{branch}"
+        runner.run_cmd "git pull . #{branch}"
+        runner.run_cmd "git push origin HEAD"
+        runner.run_cmd "git checkout #{branch}"
       end
 
       # nuke local branch and pull fresh version from remote repo
       def refresh_branch_from_remote(destination_branch)
-        run_cmd "git branch -D #{destination_branch}", :allow_failure => true
-        run_cmd "git fetch origin"
-        run_cmd "git checkout #{destination_branch}"
+        runner.run_cmd "git branch -D #{destination_branch}", :allow_failure => true
+        runner.run_cmd "git fetch origin"
+        runner.run_cmd "git checkout #{destination_branch}"
       end
 
       def aggregate_branch?(branch)
@@ -95,26 +182,26 @@ module Thegarage
       def create_build_tag(branch, label)
         timestamp = Time.now.utc.strftime '%Y-%m-%d-%H-%M-%S'
         git_tag = "build-#{branch}-#{timestamp}"
-        run_cmd "git tag #{git_tag} -a -m '#{label}'"
-        run_cmd "git push origin #{git_tag}"
+        runner.run_cmd "git tag #{git_tag} -a -m '#{label}'"
+        runner.run_cmd "git push origin #{git_tag}"
       end
 
       def build_tags_for_branch(branch)
-        run_cmd "git fetch --tags"
-        build_tags = run_cmd("git tag -l 'build-#{branch}-*'").split
+        runner.run_cmd "git fetch --tags"
+        build_tags = runner.run_cmd("git tag -l 'build-#{branch}-*'").split
         build_tags.sort
       end
 
       def migrations_need_to_be_reverted?
         return false unless File.exists?('db/migrate')
-        outdated_migrations = run_cmd("git diff #{head_branch}...#{outdated_branch} --name-only db/migrate").split
+        outdated_migrations = runner.run_cmd("git diff #{head_branch}...#{outdated_branch} --name-only db/migrate").split
         return false if outdated_migrations.empty?
 
-        say "#{outdated_branch} contains migrations that may need to be reverted.  Ensure any reversable migrations are reverted on affected databases before nuking.", :red
-        say 'Example commands to revert outdated migrations:'
+        shell.say "#{outdated_branch} contains migrations that may need to be reverted.  Ensure any reversable migrations are reverted on affected databases before nuking.", :red
+        shell.say 'Example commands to revert outdated migrations:'
         outdated_migrations.reverse.each do |migration|
           version = File.basename(migration).split('_').first
-          say "rake db:migrate:down VERSION=#{version}"
+          shell.say "rake db:migrate:down VERSION=#{version}"
         end
         !yes?("Are you sure you want to nuke #{outdated_branch}? (y/n) ", :green)
       end

data/lib/thegarage/gitx/runner.rb

@@ -0,0 +1,24 @@
+require 'English'
+
+module Thegarage
+  module Gitx
+    class Runner
+      attr_accessor :shell, :options
+
+      def initialize(shell, options = {})
+        @shell = shell
+        @options = options
+      end
+
+      # execute a shell command and raise an error if non-zero exit code is returned
+      # return the string output from the command
+      def run_cmd(cmd, options = {})
+        shell.say "$ #{cmd}"
+        output = `#{cmd}`
+        success = $CHILD_STATUS.to_i == 0
+        fail "#{cmd} failed" unless success || options[:allow_failure]
+        output
+      end
+    end
+  end
+end

data/lib/thegarage/gitx/version.rb

@@ -1,5 +1,5 @@
 module Thegarage
   module Gitx
-    VERSION = '1.5.4'
+    VERSION = '1.5.5.pre1'
   end
 end

data/spec/thegarage/gitx/cli_spec.rb

@@ -10,17 +10,21 @@ describe Thegarage::Gitx::CLI do
     }
   end
   let(:cli) { Thegarage::Gitx::CLI.new(args, options, config) }
+  let(:git) { double('fake git') }
+  let(:github) { double('fake github') }
+  let(:runner) { double('fake runner') }
+  let(:branch) { double('fake branch', name: 'feature-branch') }
 
   before do
-    # default current branch to: feature-branch
-    allow(cli).to receive(:current_branch).and_return('feature-branch')
+    allow(cli).to receive(:git).and_return(git)
+    allow(cli).to receive(:runner).and_return(runner)
+    allow(cli).to receive(:github).and_return(github)
+    allow(git).to receive(:current_branch).and_return(branch)
   end
 
   describe '#update' do
     before do
-      expect(cli).to receive(:run).with('git pull origin feature-branch', capture: true).ordered
-      expect(cli).to receive(:run).with('git pull origin master', capture: true).ordered
-      expect(cli).to receive(:run).with('git push origin HEAD', capture: true).ordered
+      expect(git).to receive(:update)
 
       cli.update
     end
@@ -32,16 +36,7 @@ describe Thegarage::Gitx::CLI do
   describe '#integrate' do
     context 'when target branch is ommitted' do
       before do
-        expect(cli).to receive(:run).with("git pull origin feature-branch", capture: true).ordered
-        expect(cli).to receive(:run).with("git pull origin master", capture: true).ordered
-        expect(cli).to receive(:run).with("git push origin HEAD", capture: true).ordered
-        expect(cli).to receive(:run).with("git branch -D staging", capture: true).ordered
-        expect(cli).to receive(:run).with("git fetch origin", capture: true).ordered
-        expect(cli).to receive(:run).with("git checkout staging", capture: true).ordered
-        expect(cli).to receive(:run).with("git pull . feature-branch", capture: true).ordered
-        expect(cli).to receive(:run).with("git push origin HEAD", capture: true).ordered
-        expect(cli).to receive(:run).with("git checkout feature-branch", capture: true).ordered
-        expect(cli).to receive(:run).with("git checkout feature-branch", capture: true).ordered
+        expect(git).to receive(:integrate).with('staging')
 
         cli.integrate
       end
@@ -51,16 +46,7 @@ describe Thegarage::Gitx::CLI do
     end
     context 'when target branch == prototype' do
       before do
-        expect(cli).to receive(:run).with("git pull origin feature-branch", capture: true).ordered
-        expect(cli).to receive(:run).with("git pull origin master", capture: true).ordered
-        expect(cli).to receive(:run).with("git push origin HEAD", capture: true).ordered
-        expect(cli).to receive(:run).with("git branch -D prototype", capture: true).ordered
-        expect(cli).to receive(:run).with("git fetch origin", capture: true).ordered
-        expect(cli).to receive(:run).with("git checkout prototype", capture: true).ordered
-        expect(cli).to receive(:run).with("git pull . feature-branch", capture: true).ordered
-        expect(cli).to receive(:run).with("git push origin HEAD", capture: true).ordered
-        expect(cli).to receive(:run).with("git checkout feature-branch", capture: true).ordered
-        expect(cli).to receive(:run).with("git checkout feature-branch", capture: true).ordered
+        expect(git).to receive(:integrate).with('prototype')
 
         cli.integrate 'prototype'
       end
@@ -68,17 +54,6 @@ describe Thegarage::Gitx::CLI do
         should meet_expectations
       end
     end
-    context 'when target branch != staging || prototype' do
-      it 'raises an error' do
-        expect(cli).to receive(:run).with("git pull origin feature-branch", capture: true).ordered
-        expect(cli).to receive(:run).with("git pull origin master", capture: true).ordered
-        expect(cli).to receive(:run).with("git push origin HEAD", capture: true).ordered
-
-        lambda {
-          cli.integrate 'some-other-branch'
-        }.should raise_error(/Only aggregate branches are allowed for integration/)
-      end
-    end
   end
 
   describe '#release' do
@@ -86,9 +61,7 @@ describe Thegarage::Gitx::CLI do
       before do
         expect(cli).to receive(:yes?).and_return(false)
 
-        expect(cli).to receive(:run).with("git pull origin feature-branch", capture: true).ordered
-        expect(cli).to receive(:run).with("git pull origin master", capture: true).ordered
-        expect(cli).to receive(:run).with("git push origin HEAD", capture: true).ordered
+        expect(git).to_not receive(:release)
 
         cli.release
       end
@@ -99,27 +72,7 @@ describe Thegarage::Gitx::CLI do
     context 'when user confirms release' do
       before do
         expect(cli).to receive(:yes?).and_return(true)
-        expect(cli).to receive(:branches).and_return(%w( old-merged-feature )).twice
-
-        expect(cli).to receive(:run).with("git pull origin feature-branch", capture: true).ordered
-        expect(cli).to receive(:run).with("git pull origin master", capture: true).ordered
-        expect(cli).to receive(:run).with("git push origin HEAD", capture: true).ordered
-        expect(cli).to receive(:run).with("git checkout master", capture: true).ordered
-        expect(cli).to receive(:run).with("git pull origin master", capture: true).ordered
-        expect(cli).to receive(:run).with("git pull . feature-branch", capture: true).ordered
-        expect(cli).to receive(:run).with("git push origin HEAD", capture: true).ordered
-        expect(cli).to receive(:run).with("git branch -D staging", capture: true).ordered
-        expect(cli).to receive(:run).with("git fetch origin", capture: true).ordered
-        expect(cli).to receive(:run).with("git checkout staging", capture: true).ordered
-        expect(cli).to receive(:run).with("git pull . master", capture: true).ordered
-        expect(cli).to receive(:run).with("git push origin HEAD", capture: true).ordered
-        expect(cli).to receive(:run).with("git checkout master", capture: true).ordered
-        expect(cli).to receive(:run).with("git checkout master", capture: true).ordered
-        expect(cli).to receive(:run).with("git pull", capture: true).ordered
-        expect(cli).to receive(:run).with("git remote prune origin", capture: true).ordered
-        expect(cli).to receive(:run).with("git push origin --delete old-merged-feature", capture: true).ordered
-        expect(cli).to receive(:run).with("git branch -d old-merged-feature", capture: true).ordered
-
+        expect(git).to receive(:release)
         cli.release
       end
       it 'runs expected commands' do
@@ -132,76 +85,34 @@ describe Thegarage::Gitx::CLI do
     context 'when target branch == prototype and --destination == master' do
       let(:options) do
         {
-          destination: 'master'
-        }
-      end
-      let(:buildtags) do
-        %w( build-master-2013-10-01-01 ).join("\n")
-      end
-      before do
-        expect(cli).to receive(:yes?).and_return(true)
-
-        expect(cli).to receive(:run).with("git fetch --tags", capture: true).ordered
-        expect(cli).to receive(:run).with("git tag -l 'build-master-*'", capture: true).and_return(buildtags).ordered
-        expect(cli).to receive(:run).with("git checkout master", capture: true).ordered
-        expect(cli).to receive(:run).with("git branch -D prototype", capture: true).ordered
-        expect(cli).to receive(:run).with("git push origin --delete prototype", capture: true).ordered
-        expect(cli).to receive(:run).with("git checkout -b prototype build-master-2013-10-01-01", capture: true).ordered
-        expect(cli).to receive(:run).with("git push origin prototype", capture: true).ordered
-        expect(cli).to receive(:run).with("git branch --set-upstream-to origin/prototype", capture: true).ordered
-        expect(cli).to receive(:run).with("git checkout master", capture: true).ordered
-
-        cli.nuke 'prototype'
-      end
-      it 'runs expected commands' do
-        should meet_expectations
-      end
-    end
-    context 'when target branch == staging and --destination == staging' do
-      let(:options) do
-        {
-          destination: 'staging'
+          destination: good_branch
         }
       end
-      let(:buildtags) do
-        %w( build-staging-2013-10-02-02 ).join("\n")
-      end
+      let(:good_branch) { 'master' }
+      let(:bad_branch) { 'prototype' }
+      let(:buildtag) { 'build-master-2013-10-01-01' }
       before do
         expect(cli).to receive(:yes?).and_return(true)
 
-        expect(cli).to receive(:run).with("git fetch --tags", capture: true).ordered
-        expect(cli).to receive(:run).with("git tag -l 'build-staging-*'", capture: true).and_return(buildtags).ordered
-        expect(cli).to receive(:run).with("git checkout master", capture: true).ordered
-        expect(cli).to receive(:run).with("git branch -D staging", capture: true).ordered
-        expect(cli).to receive(:run).with("git push origin --delete staging", capture: true).ordered
-        expect(cli).to receive(:run).with("git checkout -b staging build-staging-2013-10-02-02", capture: true).ordered
-        expect(cli).to receive(:run).with("git push origin staging", capture: true).ordered
-        expect(cli).to receive(:run).with("git branch --set-upstream-to origin/staging", capture: true).ordered
-        expect(cli).to receive(:run).with("git checkout master", capture: true).ordered
+        expect(git).to receive(:current_build_tag).with(good_branch).and_return(buildtag)
+        expect(git).to receive(:nuke).with(bad_branch, buildtag)
 
-        cli.nuke 'staging'
+        cli.nuke bad_branch
       end
       it 'runs expected commands' do
         should meet_expectations
       end
     end
     context 'when target branch == prototype and destination prompt == nil' do
-      let(:buildtags) do
-        %w( build-prototype-2013-10-03-03 ).join("\n")
-      end
+      let(:good_branch) { 'master' }
+      let(:bad_branch) { 'prototype' }
+      let(:buildtag) { 'build-master-2013-10-01-01' }
       before do
-        expect(cli).to receive(:ask).and_return('')
+        expect(cli).to receive(:ask).and_return(good_branch)
         expect(cli).to receive(:yes?).and_return(true)
 
-        expect(cli).to receive(:run).with("git fetch --tags", capture: true).ordered
-        expect(cli).to receive(:run).with("git tag -l 'build-prototype-*'", capture: true).and_return(buildtags).ordered
-        expect(cli).to receive(:run).with("git checkout master", capture: true).ordered
-        expect(cli).to receive(:run).with("git branch -D prototype", capture: true).ordered
-        expect(cli).to receive(:run).with("git push origin --delete prototype", capture: true).ordered
-        expect(cli).to receive(:run).with("git checkout -b prototype build-prototype-2013-10-03-03", capture: true).ordered
-        expect(cli).to receive(:run).with("git push origin prototype", capture: true).ordered
-        expect(cli).to receive(:run).with("git branch --set-upstream-to origin/prototype", capture: true).ordered
-        expect(cli).to receive(:run).with("git checkout master", capture: true).ordered
+        expect(git).to receive(:current_build_tag).with(good_branch).and_return(buildtag)
+        expect(git).to receive(:nuke).with(bad_branch, buildtag)
 
         cli.nuke 'prototype'
       end
@@ -209,49 +120,14 @@ describe Thegarage::Gitx::CLI do
         should meet_expectations
       end
     end
-    context 'when target branch == prototype and destination prompt = master' do
-      let(:buildtags) do
-        %w( build-master-2013-10-01-01 ).join("\n")
-      end
-      before do
-        expect(cli).to receive(:ask).and_return('master')
-        expect(cli).to receive(:yes?).and_return(true)
-
-        expect(cli).to receive(:run).with("git fetch --tags", capture: true).ordered
-        expect(cli).to receive(:run).with("git tag -l 'build-master-*'", capture: true).and_return(buildtags).ordered
-        expect(cli).to receive(:run).with("git checkout master", capture: true).ordered
-        expect(cli).to receive(:run).with("git branch -D prototype", capture: true).ordered
-        expect(cli).to receive(:run).with("git push origin --delete prototype", capture: true).ordered
-        expect(cli).to receive(:run).with("git checkout -b prototype build-master-2013-10-01-01", capture: true).ordered
-        expect(cli).to receive(:run).with("git push origin prototype", capture: true).ordered
-        expect(cli).to receive(:run).with("git branch --set-upstream-to origin/prototype", capture: true).ordered
-        expect(cli).to receive(:run).with("git checkout master", capture: true).ordered
-
-        cli.nuke 'prototype'
-      end
-      it 'runs expected commands' do
-        should meet_expectations
-      end
-    end
-    context 'when target branch != staging || prototype' do
-      it 'raises error' do
-        lambda {
-          expect(cli).to receive(:ask).and_return('master')
-          expect(cli).to receive(:yes?).and_return(true)
-          cli.nuke 'not-an-integration-branch'
-        }.should raise_error(/Only aggregate branches are allowed to be reset/)
-      end
-    end
     context 'when user does not confirm nuking the target branch' do
-      let(:buildtags) do
-        %w( build-master-2013-10-01-01 ).join("\n")
-      end
+      let(:buildtag) { 'build-master-2013-10-01-01' }
       before do
         expect(cli).to receive(:ask).and_return('master')
         expect(cli).to receive(:yes?).and_return(false)
 
-        expect(cli).to receive(:run).with("git fetch --tags", capture: true).ordered
-        expect(cli).to receive(:run).with("git tag -l 'build-master-*'", capture: true).and_return(buildtags).ordered
+        expect(git).to receive(:current_build_tag).with('master').and_return(buildtag)
+        expect(git).to_not receive(:nuke)
 
         cli.nuke 'prototype'
       end
@@ -259,23 +135,9 @@ describe Thegarage::Gitx::CLI do
         should meet_expectations
       end
     end
-    context 'when no known good build tag found' do
-      let(:buildtags) do
-        ''
-      end
-      it 'raises error' do
-        expect(cli).to receive(:ask).and_return('master')
-
-        expect(cli).to receive(:run).with("git fetch --tags", capture: true).ordered
-        expect(cli).to receive(:run).with("git tag -l 'build-master-*'", capture: true).and_return(buildtags).ordered
-
-        expect { cli.nuke('prototype') }.to raise_error(/No known good tag found for branch/)
-      end
-    end
   end
 
   describe '#reviewrequest' do
-    let(:github) { double('fake github') }
     let(:pull_request) do
       {
         'html_url' => 'https://path/to/new/pull/request',
@@ -284,9 +146,6 @@ describe Thegarage::Gitx::CLI do
         }
       }
     end
-    before do
-      allow(cli).to receive(:github).and_return(github)
-    end
     context 'when pull request does not exist' do
       let(:authorization_token) { '123123' }
       let(:changelog) { '* made some fixes' }
@@ -295,10 +154,8 @@ describe Thegarage::Gitx::CLI do
         expect(github).to receive(:find_pull_request).and_return(nil)
         expect(github).to receive(:create_pull_request).and_return(pull_request)
 
-        expect(cli).to receive(:run).with("git pull origin feature-branch", capture: true).ordered
-        expect(cli).to receive(:run).with("git pull origin master", capture: true).ordered
-        expect(cli).to receive(:run).with("git push origin HEAD", capture: true).ordered
-        expect(cli).to receive(:run).with("git log master...feature-branch --no-merges --pretty=format:'* %s%n%b'", capture: true).and_return("2013-01-01 did some stuff").ordered
+        expect(git).to receive(:update)
+        expect(runner).to receive(:run_cmd).with("git log master...feature-branch --no-merges --pretty=format:'* %s%n%b'").and_return("2013-01-01 did some stuff").ordered
         cli.reviewrequest
       end
       it 'creates github pull request' do
@@ -357,7 +214,7 @@ describe Thegarage::Gitx::CLI do
         expect(github).to receive(:authorization_token).and_return(authorization_token)
         expect(github).to receive(:find_pull_request).and_return(pull_request)
 
-        expect(cli).to receive(:run).with("open #{pull_request['html_url']}", capture: true).ordered
+        expect(runner).to receive(:run_cmd).with("open #{pull_request['html_url']}").ordered
         cli.reviewrequest
       end
       it 'runs open command with pull request url' do
@@ -366,56 +223,35 @@ describe Thegarage::Gitx::CLI do
     end
   end
 
-  describe '#buildtag' do
-    let(:env_travis_branch) { nil }
-    let(:env_travis_pull_request) { nil }
-    let(:env_travis_build_number) { nil }
-    before do
-      ENV['TRAVIS_BRANCH'] = env_travis_branch
-      ENV['TRAVIS_PULL_REQUEST'] = env_travis_pull_request
-      ENV['TRAVIS_BUILD_NUMBER'] = env_travis_build_number
+  describe '#track' do
+    it 'calls git.track' do
+      expect(git).to receive(:track)
+      cli.track
     end
-    context 'when ENV[\'TRAVIS_BRANCH\'] is nil' do
-      it 'raises Unknown Branch error' do
-        expect { cli.buildtag }.to raise_error "Unknown branch. ENV['TRAVIS_BRANCH'] is required."
-      end
-    end
-    context 'when the travis branch is master and the travis pull request is not false' do
-      let(:env_travis_branch) { 'master' }
-      let(:env_travis_pull_request) { '45' }
-      before do
-        expect(cli).to receive(:say).with("Skipping creation of tag for pull request: #{ENV['TRAVIS_PULL_REQUEST']}")
-        cli.buildtag
-      end
-      it 'tells us that it is skipping the creation of the tag' do
-        should meet_expectations
-      end
+  end
+
+  describe '#share' do
+    it 'calls git.share' do
+      expect(git).to receive(:share)
+      cli.share
     end
-    context 'when the travis branch is NOT master and is not a pull request' do
-      let(:env_travis_branch) { 'random-branch' }
-      let(:env_travis_pull_request) { 'false' }
-      before do
-        expect(cli).to receive(:say).with(/Cannot create build tag for branch: #{ENV['TRAVIS_BRANCH']}/)
-        cli.buildtag
-      end
-      it 'tells us that the branch is not supported' do
-        should meet_expectations
+  end
+
+  describe '#start' do
+    context 'when user inputs branch that is valid' do
+      it 'calls git.start' do
+        expect(git).to receive(:valid_new_branch_name?).with('new-branch').and_return(true)
+        expect(git).to receive(:start).with('new-branch')
+
+        cli.start 'new-branch'
       end
     end
-    context 'when the travis branch is master and not a pull request' do
-      let(:env_travis_branch) { 'master' }
-      let(:env_travis_pull_request) { 'false' }
-      let(:env_travis_build_number) { '24' }
-      before do
-        Timecop.freeze(Time.utc(2013, 10, 30, 10, 21, 28)) do
-          expect(cli).to receive(:run).with("git tag build-master-2013-10-30-10-21-28 -a -m 'Generated tag from TravisCI build 24'", capture: true).ordered
-          expect(cli).to receive(:run).with("git push origin build-master-2013-10-30-10-21-28", capture: true).ordered
-          cli.buildtag
-        end
-      end
-      it 'creates a tag for the branch and push it to github' do
-        should meet_expectations
-      end
+  end
+
+  describe '#buildtag' do
+    it 'calls git.buildtag' do
+      expect(git).to receive(:buildtag)
+      cli.buildtag
     end
   end
 end

data/spec/thegarage/gitx/git_spec.rb

@@ -0,0 +1,231 @@
+require 'spec_helper'
+require 'timecop'
+
+describe Thegarage::Gitx::Git do
+  let(:runner) { double('fake runner') }
+  let(:shell) { double('fake shell', say: nil) }
+  let(:branch) { double('fake git branch', name: 'feature-branch') }
+  subject { Thegarage::Gitx::Git.new(shell, runner) }
+
+  # default current branch to: feature-branch
+  before do
+    allow(subject).to receive(:current_branch).and_return(branch)
+  end
+
+  describe '#update' do
+    before do
+      allow(shell).to receive(:say)
+
+      expect(runner).to receive(:run_cmd).with('git pull origin feature-branch', allow_failure: true).ordered
+      expect(runner).to receive(:run_cmd).with('git pull origin master').ordered
+      expect(runner).to receive(:run_cmd).with('git push origin HEAD').ordered
+
+      subject.update
+    end
+    it 'runs expected commands' do
+      should meet_expectations
+    end
+  end
+
+  describe '#track' do
+    before do
+      expect(runner).to receive(:run_cmd).with('git branch --set-upstream-to origin/feature-branch').ordered
+
+      subject.track
+    end
+    it 'runs expected commands' do
+      should meet_expectations
+    end
+  end
+
+  describe '#share' do
+    before do
+      expect(runner).to receive(:run_cmd).with('git push origin feature-branch').ordered
+      expect(runner).to receive(:run_cmd).with('git branch --set-upstream-to origin/feature-branch').ordered
+
+      subject.share
+    end
+    it 'runs expected commands' do
+      should meet_expectations
+    end
+  end
+
+  describe '#integrate' do
+    context 'when target branch is ommitted' do
+      before do
+        expect(subject).to receive(:update)
+
+        expect(runner).to receive(:run_cmd).with("git branch -D staging", allow_failure: true).ordered
+        expect(runner).to receive(:run_cmd).with("git fetch origin").ordered
+        expect(runner).to receive(:run_cmd).with("git checkout staging").ordered
+        expect(runner).to receive(:run_cmd).with("git pull . feature-branch").ordered
+        expect(runner).to receive(:run_cmd).with("git push origin HEAD").ordered
+        expect(runner).to receive(:run_cmd).with("git checkout feature-branch").ordered
+        expect(runner).to receive(:run_cmd).with("git checkout feature-branch").ordered
+
+        subject.integrate
+      end
+      it 'defaults to staging branch' do
+        should meet_expectations
+      end
+    end
+    context 'when target branch == prototype' do
+      before do
+        expect(subject).to receive(:update)
+
+        expect(runner).to receive(:run_cmd).with("git branch -D prototype", allow_failure: true).ordered
+        expect(runner).to receive(:run_cmd).with("git fetch origin").ordered
+        expect(runner).to receive(:run_cmd).with("git checkout prototype").ordered
+        expect(runner).to receive(:run_cmd).with("git pull . feature-branch").ordered
+        expect(runner).to receive(:run_cmd).with("git push origin HEAD").ordered
+        expect(runner).to receive(:run_cmd).with("git checkout feature-branch").ordered
+        expect(runner).to receive(:run_cmd).with("git checkout feature-branch").ordered
+
+        subject.integrate 'prototype'
+      end
+      it 'runs expected commands' do
+        should meet_expectations
+      end
+    end
+    context 'when target branch != staging || prototype' do
+      it 'raises an error' do
+        expect(subject).to receive(:update)
+
+        expect { subject.integrate('some-other-branch') }.to raise_error(/Only aggregate branches are allowed for integration/)
+      end
+    end
+  end
+
+  describe '#release' do
+    it 'merges feature branch into master' do
+      expect(subject).to receive(:update)
+
+      expect(runner).to receive(:run_cmd).with("git checkout master").ordered
+      expect(runner).to receive(:run_cmd).with("git pull origin master").ordered
+      expect(runner).to receive(:run_cmd).with("git pull . feature-branch").ordered
+      expect(runner).to receive(:run_cmd).with("git push origin HEAD").ordered
+
+      expect(subject).to receive(:integrate).with('staging')
+      expect(subject).to receive(:cleanup)
+
+      subject.release
+    end
+  end
+
+  describe '#nuke' do
+    context 'when target branch == prototype and head is a valid buildtag' do
+      let(:buildtag) { 'build-master-2013-10-01-01' }
+      before do
+        expect(runner).to receive(:run_cmd).with("git checkout master").ordered
+        expect(runner).to receive(:run_cmd).with("git branch -D prototype", allow_failure: true).ordered
+        expect(runner).to receive(:run_cmd).with("git push origin --delete prototype", allow_failure: true).ordered
+        expect(runner).to receive(:run_cmd).with("git checkout -b prototype build-master-2013-10-01-01").ordered
+        expect(runner).to receive(:run_cmd).with("git push origin prototype").ordered
+        expect(runner).to receive(:run_cmd).with("git branch --set-upstream-to origin/prototype").ordered
+        expect(runner).to receive(:run_cmd).with("git checkout master").ordered
+
+        subject.nuke 'prototype', buildtag
+      end
+      it 'runs expected commands' do
+        should meet_expectations
+      end
+    end
+    context 'when target branch == staging and head is a valid buildtag' do
+      let(:buildtag) { 'build-master-2013-10-02-02' }
+      before do
+        expect(runner).to receive(:run_cmd).with("git checkout master").ordered
+        expect(runner).to receive(:run_cmd).with("git branch -D staging", allow_failure: true).ordered
+        expect(runner).to receive(:run_cmd).with("git push origin --delete staging", allow_failure: true).ordered
+        expect(runner).to receive(:run_cmd).with("git checkout -b staging build-master-2013-10-02-02").ordered
+        expect(runner).to receive(:run_cmd).with("git push origin staging").ordered
+        expect(runner).to receive(:run_cmd).with("git branch --set-upstream-to origin/staging").ordered
+        expect(runner).to receive(:run_cmd).with("git checkout master").ordered
+
+        subject.nuke 'staging', buildtag
+      end
+      it 'runs expected commands' do
+        should meet_expectations
+      end
+    end
+    context 'when target branch != staging || prototype' do
+      it 'raises error' do
+        expect { subject.nuke('not-an-integration-branch', 'master') }.to raise_error(/Only aggregate branches are allowed to be reset/)
+      end
+    end
+  end
+
+  describe '#current_build_tag' do
+    context 'when multiple build tags returned' do
+      let(:buildtags) { %w( build-master-2013-01-01-01 build-master-2013-01-01-02 ).join("\n") }
+      it 'returns the last one' do
+        expect(runner).to receive(:run_cmd).with("git fetch --tags").ordered
+        expect(runner).to receive(:run_cmd).with("git tag -l 'build-master-*'").and_return(buildtags).ordered
+
+        result = subject.current_build_tag 'master'
+        expect(result).to eq 'build-master-2013-01-01-02'
+      end
+    end
+    context 'when no known good build tag found' do
+      let(:buildtags) { '' }
+      it 'raises error' do
+        expect(runner).to receive(:run_cmd).with("git fetch --tags").ordered
+        expect(runner).to receive(:run_cmd).with("git tag -l 'build-master-*'").and_return(buildtags).ordered
+
+        expect { subject.current_build_tag('master') }.to raise_error(/No known good tag found for branch/)
+      end
+    end
+  end
+
+  describe '#buildtag' do
+    let(:env_travis_branch) { nil }
+    let(:env_travis_pull_request) { nil }
+    let(:env_travis_build_number) { nil }
+    before do
+      ENV['TRAVIS_BRANCH'] = env_travis_branch
+      ENV['TRAVIS_PULL_REQUEST'] = env_travis_pull_request
+      ENV['TRAVIS_BUILD_NUMBER'] = env_travis_build_number
+    end
+    context 'when ENV[\'TRAVIS_BRANCH\'] is nil' do
+      it 'raises Unknown Branch error' do
+        expect { subject.buildtag }.to raise_error "Unknown branch. ENV['TRAVIS_BRANCH'] is required."
+      end
+    end
+    context 'when the travis branch is master and the travis pull request is not false' do
+      let(:env_travis_branch) { 'master' }
+      let(:env_travis_pull_request) { '45' }
+      before do
+        expect(shell).to receive(:say).with("Skipping creation of tag for pull request: #{ENV['TRAVIS_PULL_REQUEST']}")
+        subject.buildtag
+      end
+      it 'tells us that it is skipping the creation of the tag' do
+        should meet_expectations
+      end
+    end
+    context 'when the travis branch is NOT master and is not a pull request' do
+      let(:env_travis_branch) { 'random-branch' }
+      let(:env_travis_pull_request) { 'false' }
+      before do
+        expect(shell).to receive(:say).with(/Cannot create build tag for branch: #{ENV['TRAVIS_BRANCH']}/)
+        subject.buildtag
+      end
+      it 'tells us that the branch is not supported' do
+        should meet_expectations
+      end
+    end
+    context 'when the travis branch is master and not a pull request' do
+      let(:env_travis_branch) { 'master' }
+      let(:env_travis_pull_request) { 'false' }
+      let(:env_travis_build_number) { '24' }
+      before do
+        Timecop.freeze(Time.utc(2013, 10, 30, 10, 21, 28)) do
+          expect(runner).to receive(:run_cmd).with("git tag build-master-2013-10-30-10-21-28 -a -m 'Generated tag from TravisCI build 24'").ordered
+          expect(runner).to receive(:run_cmd).with("git push origin build-master-2013-10-30-10-21-28").ordered
+          subject.buildtag
+        end
+      end
+      it 'creates a tag for the branch and push it to github' do
+        should meet_expectations
+      end
+    end
+  end
+end

data/thegarage-gitx.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "grit"
+  spec.add_runtime_dependency "rugged"
   spec.add_runtime_dependency "rest-client", ">= 1.4.0"
   spec.add_runtime_dependency "thor"
 

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: thegarage-gitx
 version: !ruby/object:Gem::Version
-  version: 1.5.4
+  version: 1.5.5.pre1
 platform: ruby
 authors:
 - Ryan Sonnek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-27 00:00:00.000000000 Z
+date: 2014-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: grit
+  name: rugged
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -178,11 +178,13 @@ files:
 - lib/thegarage/gitx/cli.rb
 - lib/thegarage/gitx/git.rb
 - lib/thegarage/gitx/github.rb
+- lib/thegarage/gitx/runner.rb
 - lib/thegarage/gitx/string_extensions.rb
 - lib/thegarage/gitx/version.rb
 - spec/spec_helper.rb
 - spec/support/meet_expectations_matcher.rb
 - spec/thegarage/gitx/cli_spec.rb
+- spec/thegarage/gitx/git_spec.rb
 - spec/thegarage/gitx/github_spec.rb
 - thegarage-gitx.gemspec
 homepage: ''
@@ -200,9 +202,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.0.3
@@ -213,4 +215,5 @@ test_files:
 - spec/spec_helper.rb
 - spec/support/meet_expectations_matcher.rb
 - spec/thegarage/gitx/cli_spec.rb
+- spec/thegarage/gitx/git_spec.rb
 - spec/thegarage/gitx/github_spec.rb