thegarage-gitx 1.5.5.pre1 → 2.0.0.pre1

data/lib/thegarage/gitx/cli/start_command.rb

@@ -0,0 +1,31 @@
+require 'thor'
+require 'thegarage/gitx'
+require 'thegarage/gitx/cli/base_command'
+
+module Thegarage
+  module Gitx
+    module Cli
+      class StartCommand < BaseCommand
+        EXAMPLE_BRANCH_NAMES = %w( api-fix-invalid-auth desktop-cleanup-avatar-markup share-form-add-edit-link )
+
+        desc 'start', 'start a new git branch with latest changes from master'
+        def start(branch_name = nil)
+          until valid_new_branch_name?(branch_name)
+            branch_name = ask("What would you like to name your branch? (ex: #{EXAMPLE_BRANCH_NAMES.sample})")
+          end
+
+          run_cmd "git checkout #{Thegarage::Gitx::BASE_BRANCH}"
+          run_cmd 'git pull'
+          run_cmd "git checkout -b #{branch_name}"
+        end
+
+        private
+
+        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
+      end
+    end
+  end
+end

data/lib/thegarage/gitx/cli/track_command.rb

@@ -0,0 +1,16 @@
+require 'thor'
+require 'thegarage/gitx'
+require 'thegarage/gitx/cli/base_command'
+
+module Thegarage
+  module Gitx
+    module Cli
+      class TrackCommand < BaseCommand
+        desc 'track', 'set the current branch to track the remote branch with the same name'
+        def track
+          run_cmd "git branch --set-upstream-to origin/#{current_branch.name}"
+        end
+      end
+    end
+  end
+end

data/lib/thegarage/gitx/cli/update_command.rb

@@ -0,0 +1,23 @@
+require 'thor'
+require 'thegarage/gitx'
+require 'thegarage/gitx/cli/base_command'
+
+module Thegarage
+  module Gitx
+    module Cli
+      class UpdateCommand < BaseCommand
+        desc 'update', 'Update the current branch with latest changes from the remote feature branch and master'
+        def update
+          say 'Updating '
+          say "#{current_branch.name} ", :green
+          say "with latest changes from "
+          say Thegarage::Gitx::BASE_BRANCH, :green
+
+          run_cmd "git pull origin #{current_branch.name}", :allow_failure => true
+          run_cmd "git pull origin #{Thegarage::Gitx::BASE_BRANCH}"
+          run_cmd 'git push origin HEAD'
+        end
+      end
+    end
+  end
+end

data/lib/thegarage/gitx/version.rb

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

data/lib/thegarage/gitx.rb

@@ -1,7 +1,5 @@
 require 'thegarage/gitx/version'
 require 'thegarage/gitx/string_extensions'
-require 'thegarage/gitx/git'
-require 'thegarage/gitx/github'
 
 module Thegarage
   module Gitx

data/spec/spec_helper.rb

@@ -1,8 +1,10 @@
+require 'coveralls'
+Coveralls.wear!
 require 'rubygems'
 require 'bundler/setup'
 require 'pry'
 require 'webmock/rspec'
-require 'thegarage/gitx/cli'
+require 'timecop'
 
 # Requires supporting ruby files with custom matchers and macros, etc,
 # in spec/support/ and its subdirectories.

data/spec/thegarage/gitx/cli/buildtag_command_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'thegarage/gitx/cli/buildtag_command'
+
+describe Thegarage::Gitx::Cli::BuildtagCommand do
+  let(:args) { [] }
+  let(:options) { {} }
+  let(:config) do
+    {
+      pretend: true
+    }
+  end
+  let(:cli) { Thegarage::Gitx::Cli::BuildtagCommand.new(args, options, config) }
+  let(:branch) { double('fake branch', name: 'feature-branch') }
+
+  before do
+    allow(cli).to receive(:current_branch).and_return(branch)
+  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 { 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
+    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
+    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_cmd).with("git tag build-master-2013-10-30-10-21-28 -a -m 'Generated tag from TravisCI build 24'").ordered
+          expect(cli).to receive(:run_cmd).with("git push origin build-master-2013-10-30-10-21-28").ordered
+          cli.buildtag
+        end
+      end
+      it 'creates a tag for the branch and push it to github' do
+        should meet_expectations
+      end
+    end
+  end
+end

data/spec/thegarage/gitx/cli/cleanup_command_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'thegarage/gitx/cli/cleanup_command'
+
+describe Thegarage::Gitx::Cli::CleanupCommand do
+  let(:args) { [] }
+  let(:options) { {} }
+  let(:config) do
+    {
+      pretend: true
+    }
+  end
+  let(:cli) { Thegarage::Gitx::Cli::CleanupCommand.new(args, options, config) }
+  let(:branch) { double('fake branch', name: 'feature-branch') }
+
+  before do
+    allow(cli).to receive(:current_branch).and_return(branch)
+  end
+
+  describe '#cleanup' do
+    before do
+      allow(cli).to receive(:say)
+
+      expect(cli).to receive(:merged_remote_branches).and_return(%w( merged-remote-feature ))
+      expect(cli).to receive(:merged_local_branches).and_return(%w( merged-local-feature ))
+
+      expect(cli).to receive(:run_cmd).with('git checkout master').ordered
+      expect(cli).to receive(:run_cmd).with('git pull').ordered
+      expect(cli).to receive(:run_cmd).with('git remote prune origin').ordered
+      expect(cli).to receive(:run_cmd).with('git push origin --delete merged-remote-feature').ordered
+      expect(cli).to receive(:run_cmd).with('git branch -d merged-local-feature').ordered
+
+      cli.cleanup
+    end
+    it 'runs expected commands' do
+      should meet_expectations
+    end
+  end
+end

data/spec/thegarage/gitx/cli/integrate_command_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'thegarage/gitx/cli/integrate_command'
+
+describe Thegarage::Gitx::Cli::IntegrateCommand do
+  let(:args) { [] }
+  let(:options) { {} }
+  let(:config) do
+    {
+      pretend: true
+    }
+  end
+  let(:cli) { Thegarage::Gitx::Cli::IntegrateCommand.new(args, options, config) }
+  let(:branch) { double('fake branch', name: 'feature-branch') }
+
+  before do
+    allow(cli).to receive(:current_branch).and_return(branch)
+  end
+
+  describe '#integrate' do
+    let(:fake_update_command) { double('fake update command') }
+    before do
+      allow(Thegarage::Gitx::Cli::UpdateCommand).to receive(:new).and_return(fake_update_command)
+    end
+    context 'when target branch is ommitted' do
+      before do
+        expect(fake_update_command).to receive(:update)
+
+        expect(cli).to receive(:run_cmd).with("git branch -D staging", allow_failure: true).ordered
+        expect(cli).to receive(:run_cmd).with("git fetch origin").ordered
+        expect(cli).to receive(:run_cmd).with("git checkout staging").ordered
+        expect(cli).to receive(:run_cmd).with("git pull . feature-branch").ordered
+        expect(cli).to receive(:run_cmd).with("git push origin HEAD").ordered
+        expect(cli).to receive(:run_cmd).with("git checkout feature-branch").ordered
+
+        cli.integrate
+      end
+      it 'defaults to staging branch' do
+        should meet_expectations
+      end
+    end
+    context 'when target branch == prototype' do
+      before do
+        expect(fake_update_command).to receive(:update)
+
+        expect(cli).to receive(:run_cmd).with("git branch -D prototype", allow_failure: true).ordered
+        expect(cli).to receive(:run_cmd).with("git fetch origin").ordered
+        expect(cli).to receive(:run_cmd).with("git checkout prototype").ordered
+        expect(cli).to receive(:run_cmd).with("git pull . feature-branch").ordered
+        expect(cli).to receive(:run_cmd).with("git push origin HEAD").ordered
+        expect(cli).to receive(:run_cmd).with("git checkout feature-branch").ordered
+
+        cli.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 { cli.integrate('some-other-branch') }.to raise_error(/Only aggregate branches are allowed for integration/)
+      end
+    end
+  end
+end

data/spec/thegarage/gitx/cli/nuke_command_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+require 'thegarage/gitx/cli/nuke_command'
+
+describe Thegarage::Gitx::Cli::NukeCommand do
+  let(:args) { [] }
+  let(:options) { {} }
+  let(:config) do
+    {
+      pretend: true
+    }
+  end
+  let(:cli) { Thegarage::Gitx::Cli::NukeCommand.new(args, options, config) }
+  let(:branch) { double('fake branch', name: 'feature-branch') }
+
+  before do
+    allow(cli).to receive(:current_branch).and_return(branch)
+  end
+
+  describe '#nuke' do
+    context 'when target branch == prototype and --destination == master' do
+      let(:options) do
+        {
+          destination: good_branch
+        }
+      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(:current_build_tag).with(good_branch).and_return(buildtag)
+
+        expect(cli).to receive(:run_cmd).with("git checkout master").ordered
+        expect(cli).to receive(:run_cmd).with("git branch -D prototype", allow_failure: true).ordered
+        expect(cli).to receive(:run_cmd).with("git push origin --delete prototype", allow_failure: true).ordered
+        expect(cli).to receive(:run_cmd).with("git checkout -b prototype build-master-2013-10-01-01").ordered
+        expect(cli).to receive(:run_cmd).with("git push origin prototype").ordered
+        expect(cli).to receive(:run_cmd).with("git branch --set-upstream-to origin/prototype").ordered
+        expect(cli).to receive(:run_cmd).with("git checkout master").ordered
+
+        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(:good_branch) { 'master' }
+      let(:bad_branch) { 'prototype' }
+      let(:buildtag) { 'build-master-2013-10-01-01' }
+      before do
+        expect(cli).to receive(:ask).and_return(good_branch)
+        expect(cli).to receive(:yes?).and_return(true)
+
+        expect(cli).to receive(:current_build_tag).with(good_branch).and_return(buildtag)
+
+        expect(cli).to receive(:run_cmd).with("git checkout master").ordered
+        expect(cli).to receive(:run_cmd).with("git branch -D prototype", allow_failure: true).ordered
+        expect(cli).to receive(:run_cmd).with("git push origin --delete prototype", allow_failure: true).ordered
+        expect(cli).to receive(:run_cmd).with("git checkout -b prototype build-master-2013-10-01-01").ordered
+        expect(cli).to receive(:run_cmd).with("git push origin prototype").ordered
+        expect(cli).to receive(:run_cmd).with("git branch --set-upstream-to origin/prototype").ordered
+        expect(cli).to receive(:run_cmd).with("git checkout master").ordered
+
+        cli.nuke 'prototype'
+      end
+      it 'defaults to prototype and should run expected commands' do
+        should meet_expectations
+      end
+    end
+    context 'when user does not confirm nuking the target branch' do
+      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(:current_build_tag).with('master').and_return(buildtag)
+
+        expect(cli).to_not receive(:run_cmd)
+
+        cli.nuke 'prototype'
+      end
+      it 'runs expected commands' do
+        should meet_expectations
+      end
+    end
+    context 'when no valid buildtag is found' do
+      let(:options) do
+        {
+          destination: good_branch
+        }
+      end
+      let(:good_branch) { 'master' }
+      let(:bad_branch) { 'prototype' }
+      let(:buildtags) { '' }
+      it 'raises error' do
+        expect(cli).to receive(:run_cmd).with("git fetch --tags").ordered
+        expect(cli).to receive(:run_cmd).with("git tag -l 'build-master-*'").and_return(buildtags).ordered
+
+        expect { cli.nuke('prototype') }.to raise_error(/No known good tag found for branch/)
+      end
+    end
+  end
+end

data/spec/thegarage/gitx/cli/release_command_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+require 'thegarage/gitx/cli/release_command'
+
+describe Thegarage::Gitx::Cli::ReleaseCommand do
+  let(:args) { [] }
+  let(:options) { {} }
+  let(:config) do
+    {
+      pretend: true
+    }
+  end
+  let(:cli) { Thegarage::Gitx::Cli::ReleaseCommand.new(args, options, config) }
+  let(:branch) { double('fake branch', name: 'feature-branch') }
+
+  before do
+    allow(cli).to receive(:current_branch).and_return(branch)
+  end
+
+  describe '#release' do
+    context 'when user rejects release' do
+      before do
+        expect(cli).to receive(:yes?).and_return(false)
+        expect(cli).to_not receive(:run_cmd)
+
+        cli.release
+      end
+      it 'only runs update commands' do
+        should meet_expectations
+      end
+    end
+    context 'when user confirms release' do
+      let(:fake_update_command) { double('fake update command', update: nil) }
+      let(:fake_integrate_command) { double('fake integrate command') }
+      let(:fake_cleanup_command) { double('fake cleanup command', cleanup: nil) }
+      before do
+        expect(Thegarage::Gitx::Cli::UpdateCommand).to receive(:new).and_return(fake_update_command)
+        expect(Thegarage::Gitx::Cli::IntegrateCommand).to receive(:new).and_return(fake_integrate_command)
+        expect(Thegarage::Gitx::Cli::CleanupCommand).to receive(:new).and_return(fake_cleanup_command)
+
+        expect(fake_integrate_command).to receive(:integrate).with('staging')
+
+        expect(cli).to receive(:yes?).and_return(true)
+
+        expect(cli).to receive(:run_cmd).with("git checkout master").ordered
+        expect(cli).to receive(:run_cmd).with("git pull origin master").ordered
+        expect(cli).to receive(:run_cmd).with("git pull . feature-branch").ordered
+        expect(cli).to receive(:run_cmd).with("git push origin HEAD").ordered
+
+        cli.release
+      end
+      it 'runs expected commands' do
+        should meet_expectations
+      end
+    end
+  end
+end

data/spec/thegarage/gitx/cli/review_request_command_spec.rb

@@ -0,0 +1,188 @@
+require 'spec_helper'
+require 'thegarage/gitx/cli/review_request_command'
+
+describe Thegarage::Gitx::Cli::ReviewRequestCommand do
+  let(:args) { [] }
+  let(:options) { {} }
+  let(:config) do
+    {
+      pretend: true
+    }
+  end
+  let(:cli) { Thegarage::Gitx::Cli::ReviewRequestCommand.new(args, options, config) }
+  let(:repo) { double('fake repo', config: repo_config) }
+  let(:repo_config) do
+    {
+      'remote.origin.url' => 'https://github.com/thegarage/thegarage-gitx'
+    }
+  end
+  let(:branch) { double('fake branch', name: 'feature-branch') }
+
+  before do
+    allow(cli).to receive(:repo).and_return(repo)
+    allow(cli).to receive(:current_branch).and_return(branch)
+  end
+
+  describe '#reviewrequest' do
+    let(:pull_request) do
+      {
+        'html_url' => 'https://path/to/new/pull/request',
+        'head' => {
+          'ref' => 'branch_name'
+        }
+      }
+    end
+    context 'when pull request does not exist' do
+      let(:authorization_token) { '123123' }
+      let(:changelog) { '* made some fixes' }
+      before do
+        expect(cli).to receive(:authorization_token).and_return(authorization_token)
+        expect(cli).to receive(:find_pull_request).and_return(nil)
+        expect(cli).to receive(:create_pull_request).and_return(pull_request)
+        expect(cli).to receive(:update)
+        expect(cli).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
+        should meet_expectations
+      end
+      it 'runs expected commands' do
+        should meet_expectations
+      end
+    end
+    context 'when authorization_token is missing' do
+      let(:authorization_token) { nil }
+      it do
+        expect(cli).to receive(:authorization_token).and_return(authorization_token)
+        expect { cli.reviewrequest }.to raise_error(/token not found/)
+      end
+    end
+    context 'when pull request already exists' do
+      let(:authorization_token) { '123123' }
+      before do
+        expect(cli).to receive(:authorization_token).and_return(authorization_token)
+        expect(cli).to receive(:find_pull_request).and_return(pull_request)
+        expect(cli).to_not receive(:create_pull_request)
+
+        cli.reviewrequest
+      end
+      it 'does not create new pull request' do
+        should meet_expectations
+      end
+    end
+    context 'when --assignee option passed' do
+      let(:options) do
+        {
+          assignee: 'johndoe'
+        }
+      end
+      let(:authorization_token) { '123123' }
+      before do
+        expect(cli).to receive(:authorization_token).and_return(authorization_token)
+        expect(cli).to receive(:find_pull_request).and_return(pull_request)
+        expect(cli).to receive(:assign_pull_request)
+
+        cli.reviewrequest
+      end
+      it 'calls assign_pull_request method' do
+        should meet_expectations
+      end
+    end
+    context 'when --open flag passed' do
+      let(:options) do
+        {
+          open: true
+        }
+      end
+      let(:authorization_token) { '123123' }
+      before do
+        expect(cli).to receive(:authorization_token).and_return(authorization_token)
+        expect(cli).to receive(:find_pull_request).and_return(pull_request)
+        expect(cli).to receive(:run_cmd).with("open #{pull_request['html_url']}").ordered
+        cli.reviewrequest
+      end
+      it 'runs open command with pull request url' do
+        should meet_expectations
+      end
+    end
+  end
+
+  describe '#authorization_token' do
+    context 'when github.user is not configured' do
+      it 'raises error' do
+        expect do
+          cli.send(:authorization_token)
+        end.to raise_error(/Github user not configured/)
+      end
+    end
+    context 'when config.authorization_token is nil' do
+      let(:repo_config) do
+        {
+          'remote.origin.url' => 'https://github.com/thegarage/thegarage-gitx',
+          'github.user' => 'ryan@codecrate.com'
+        }
+      end
+      let(:github_password) { 'secretz' }
+      let(:authorization_token) { '123981239123' }
+      let(:expected_auth_body) do
+        JSON.dump({
+         scopes: ["repo"],
+         note: "The Garage Git eXtensions - thegarage/thegarage-gitx",
+         note_url: "https://github.com/thegarage/thegarage-gitx"
+        })
+      end
+      before do
+        stub_request(:post, "https://ryan@codecrate.com:secretz@api.github.com/authorizations").
+          with(:body => expected_auth_body).
+          to_return(:status => 200, :body => JSON.dump(token: authorization_token), :headers => {})
+
+        expect(cli).to receive(:ask).with('Github password for ryan@codecrate.com: ', {:echo => false}).and_return(github_password)
+
+        @auth_token = cli.send(:authorization_token)
+      end
+      it 'stores authorization_token in git config' do
+        expect(repo_config).to include('thegarage.gitx.githubauthtoken' => authorization_token)
+      end
+      it { expect(@auth_token).to eq authorization_token }
+    end
+    context 'when there is an existing authorization_token' do
+      let(:authorization_token) { '123981239123' }
+      let(:repo_config) do
+        {
+          'remote.origin.url' => 'https://github.com/thegarage/thegarage-gitx',
+          'github.user' => 'ryan@codecrate.com',
+          'thegarage.gitx.githubauthtoken' => authorization_token
+        }
+      end
+      before do
+        @auth_token = cli.send(:authorization_token)
+      end
+      it { expect(@auth_token).to eq authorization_token }
+    end
+  end
+  describe '#create_pull_request' do
+    context 'when there is an existing authorization_token' do
+      let(:authorization_token) { '123981239123' }
+      let(:repo_config) do
+        {
+          'remote.origin.url' => 'https://github.com/thegarage/thegarage-gitx',
+          'github.user' => 'ryan@codecrate.com',
+          'thegarage.gitx.githubauthtoken' => authorization_token
+        }
+      end
+      before do
+        stub_request(:post, "https://api.github.com/repos/thegarage/thegarage-gitx/pulls").
+          to_return(:status => 200, :body => %q({"html_url": "http://github.com/repo/project/pulls/1"}), :headers => {})
+
+        expect(cli).to receive(:input_from_editor).and_return('scrubbed text')
+        cli.send(:create_pull_request, 'example-branch', 'changelog')
+      end
+      it 'should create github pull request' do
+        should meet_expectations
+      end
+      it 'should run expected commands' do
+        should meet_expectations
+      end
+    end
+  end
+end

data/spec/thegarage/gitx/cli/share_command_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'thegarage/gitx/cli/share_command'
+
+describe Thegarage::Gitx::Cli::ShareCommand do
+  let(:args) { [] }
+  let(:options) { {} }
+  let(:config) do
+    {
+      pretend: true
+    }
+  end
+  let(:cli) { Thegarage::Gitx::Cli::ShareCommand.new(args, options, config) }
+  let(:branch) { double('fake branch', name: 'feature-branch') }
+
+  before do
+    allow(cli).to receive(:current_branch).and_return(branch)
+  end
+
+  describe '#share' do
+    before do
+      allow(cli).to receive(:say)
+
+      expect(cli).to receive(:run_cmd).with('git push origin feature-branch').ordered
+      expect(cli).to receive(:run_cmd).with('git branch --set-upstream-to origin/feature-branch').ordered
+
+      cli.share
+    end
+    it 'runs expected commands' do
+      should meet_expectations
+    end
+  end
+end