thegarage-gitx 1.5.5.pre1 → 2.0.0.pre1

data/lib/thegarage/gitx/github.rb

@@ -1,185 +0,0 @@
-require 'rest_client'
-require 'json'
-require 'tempfile'
-
-module Thegarage
-  module Gitx
-    class Github
-      CLIENT_NAME = 'The Garage Git eXtensions'
-      CLIENT_URL = 'https://github.com/thegarage/thegarage-gitx'
-      PULL_REQUEST_FOOTER = <<-EOS.dedent
-        # Pull Request Protips(tm):
-        # * Include description of how this change accomplishes the task at hand.
-        # * Use GitHub flavored Markdown http://github.github.com/github-flavored-markdown/
-        # * Review CONTRIBUTING.md for recommendations of artifacts, links, images, screencasts, etc.
-        #
-        # This footer will automatically be stripped from the pull request description
-      EOS
-
-      attr_reader :repo, :shell
-
-      def initialize(repo, shell)
-        @repo = repo
-        @shell = shell
-      end
-
-      # returns [Hash] data structure of created pull request
-      # request github authorization token
-      # User-Agent is required
-      # store the token in local git config
-      # @returns [String] auth token stored in git (current repo, user config or installed global settings)
-      # @see http://developer.github.com/v3/oauth/#scopes
-      # @see http://developer.github.com/v3/#user-agent-required
-      def authorization_token
-        auth_token = repo.config['thegarage.gitx.githubauthtoken']
-        return auth_token unless auth_token.to_s.blank?
-
-        fail "Github user not configured.  Run: `git config --global github.user 'me@email.com'`" unless username
-        password = shell.ask("Github password for #{username}: ", :echo => false)
-
-        payload = {
-          :scopes => ['repo'],
-          :note => CLIENT_NAME,
-          :note_url => CLIENT_URL
-        }.to_json
-        response = RestClient::Request.new({
-          :url => "https://api.github.com/authorizations",
-          :method => "POST",
-          :user => username,
-          :password => password,
-          :payload => payload,
-          :headers => {
-            :accept => :json,
-            :content_type => :json,
-            :user_agent => 'thegarage/gitx'
-          }
-        }).execute
-        data = JSON.parse response.body
-        token = data['token']
-        repo.config['thegarage.gitx.githubauthtoken'] = token
-        token
-      rescue RestClient::Exception => e
-        process_error e
-      end
-
-      # @see http://developer.github.com/v3/pulls/
-      def create_pull_request(branch, changelog, options = {})
-        body = pull_request_body(changelog, options[:description])
-
-        shell.say "Creating pull request for "
-        shell.say "#{branch} ", :green
-        shell.say "against "
-        shell.say "#{Thegarage::Gitx::BASE_BRANCH} ", :green
-        shell.say "in "
-        shell.say remote_origin_name, :green
-
-        payload = {
-          :title => branch,
-          :base => Thegarage::Gitx::BASE_BRANCH,
-          :head => branch,
-          :body => body
-        }.to_json
-        response = RestClient::Request.new(:url => pull_request_url, :method => "POST", :payload => payload, :headers => request_headers).execute
-        pull_request = JSON.parse response.body
-
-        pull_request
-      rescue RestClient::Exception => e
-        process_error e
-      end
-
-      def assign_pull_request(pull_request, assignee)
-        shell.say "Assigning pull request to "
-        shell.say assignee, :green
-
-        branch = pull_request['head']['ref']
-        payload = {
-          :title => branch,
-          :assignee => assignee
-        }.to_json
-        RestClient::Request.new(:url => pull_request['issue_url'], :method => "PATCH", :payload => payload, :headers => request_headers).execute
-      rescue RestClient::Exception => e
-        process_error e
-      end
-
-      # @returns [Hash] data structure of pull request info if found
-      # @returns nil if no pull request found
-      def find_pull_request(branch)
-        head_reference = [remote_origin_name.split('/').first, branch].join(':')
-        params = {
-          head: head_reference,
-          state: 'open'
-        }
-        response = RestClient::Request.new(:url => pull_request_url, :method => "GET", :headers => request_headers.merge(params: params)).execute
-        data = JSON.parse(response.body)
-        data.first
-      rescue RestClient::Exception => e
-        process_error e
-      end
-
-      private
-
-      def process_error(e)
-        data = JSON.parse e.http_body
-        shell.say "Github request failed: #{data['message']}", :red
-        throw e
-      end
-
-      def pull_request_url
-        "https://api.github.com/repos/#{remote_origin_name}/pulls"
-      end
-
-      def request_headers
-        {
-          :accept => :json,
-          :content_type => :json,
-          'Authorization' => "token #{authorization_token}"
-        }
-      end
-
-      # @returns [String] github username (ex: 'wireframe') of the current github.user
-      # @returns empty [String] when no github.user is set on the system
-      def username
-        repo.config['github.user']
-      end
-
-      # lookup the current repository of the PWD
-      # ex: git@github.com:socialcast/thegarage/gitx.git OR https://github.com/socialcast/thegarage/gitx.git
-      def remote_origin_name
-        remote = repo.config['remote.origin.url']
-        remote.to_s.gsub(/\.git$/,'').split(/[:\/]/).last(2).join('/')
-      end
-
-      def pull_request_body(changelog, description = nil)
-        description_template = []
-        description_template << "#{description}\n" if description
-        description_template << '### Changelog'
-        description_template << changelog
-        description_template << PULL_REQUEST_FOOTER
-
-        body = input_from_editor(description_template.join("\n"))
-        body.gsub(PULL_REQUEST_FOOTER, '').chomp.strip
-      end
-
-      # launch configured editor to retreive message/string
-      def input_from_editor(initial_text = '')
-        Tempfile.open('reviewrequest.md') do |f|
-          f << initial_text
-          f.flush
-
-          editor = repo.config['core.editor'] || ENV['EDITOR'] || 'vi'
-          flags = case editor
-          when 'mate', 'emacs', 'subl'
-            '-w'
-          when 'mvim'
-            '-f'
-          else
-            ''
-          end
-          pid = fork { exec([editor, flags, f.path].join(' ')) }
-          Process.waitpid(pid)
-          File.read(f.path)
-        end
-      end
-    end
-  end
-end

data/spec/thegarage/gitx/cli_spec.rb

@@ -1,257 +0,0 @@
-require 'spec_helper'
-require 'timecop'
-
-describe Thegarage::Gitx::CLI do
-  let(:args) { [] }
-  let(:options) { {} }
-  let(:config) do
-    {
-      pretend: true
-    }
-  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
-    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(git).to receive(:update)
-
-      cli.update
-    end
-    it 'runs expected commands' do
-      should meet_expectations
-    end
-  end
-
-  describe '#integrate' do
-    context 'when target branch is ommitted' do
-      before do
-        expect(git).to receive(:integrate).with('staging')
-
-        cli.integrate
-      end
-      it 'defaults to staging branch' do
-        should meet_expectations
-      end
-    end
-    context 'when target branch == prototype' do
-      before do
-        expect(git).to receive(:integrate).with('prototype')
-
-        cli.integrate 'prototype'
-      end
-      it 'runs expected commands' do
-        should meet_expectations
-      end
-    end
-  end
-
-  describe '#release' do
-    context 'when user rejects release' do
-      before do
-        expect(cli).to receive(:yes?).and_return(false)
-
-        expect(git).to_not receive(:release)
-
-        cli.release
-      end
-      it 'only runs update commands' do
-        should meet_expectations
-      end
-    end
-    context 'when user confirms release' do
-      before do
-        expect(cli).to receive(:yes?).and_return(true)
-        expect(git).to receive(:release)
-        cli.release
-      end
-      it 'runs expected commands' do
-        should meet_expectations
-      end
-    end
-  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(git).to receive(:current_build_tag).with(good_branch).and_return(buildtag)
-        expect(git).to receive(:nuke).with(bad_branch, buildtag)
-
-        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(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
-      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(git).to receive(:current_build_tag).with('master').and_return(buildtag)
-        expect(git).to_not receive(:nuke)
-
-        cli.nuke 'prototype'
-      end
-      it 'runs expected commands' do
-        should meet_expectations
-      end
-    end
-  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(github).to receive(:authorization_token).and_return(authorization_token)
-        expect(github).to receive(:find_pull_request).and_return(nil)
-        expect(github).to receive(:create_pull_request).and_return(pull_request)
-
-        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
-        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(github).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(github).to receive(:authorization_token).and_return(authorization_token)
-        expect(github).to receive(:find_pull_request).and_return(pull_request)
-        expect(github).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(github).to receive(:authorization_token).and_return(authorization_token)
-        expect(github).to receive(:find_pull_request).and_return(pull_request)
-        expect(github).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(github).to receive(:authorization_token).and_return(authorization_token)
-        expect(github).to receive(:find_pull_request).and_return(pull_request)
-
-        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
-        should meet_expectations
-      end
-    end
-  end
-
-  describe '#track' do
-    it 'calls git.track' do
-      expect(git).to receive(:track)
-      cli.track
-    end
-  end
-
-  describe '#share' do
-    it 'calls git.share' do
-      expect(git).to receive(:share)
-      cli.share
-    end
-  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
-  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

@@ -1,231 +0,0 @@
-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