thegarage-gitx 1.0.0.alpha

data/lib/thegarage/gitx/cli.rb

@@ -0,0 +1,139 @@
+require "thor"
+require 'rest_client'
+require 'thegarage/gitx'
+
+module Thegarage
+  module Gitx
+    class CLI < Thor
+      include Thegarage::Gitx
+      include Thegarage::Gitx::Git
+      include Thegarage::Gitx::Github
+
+      PULL_REQUEST_DESCRIPTION = "\n\n" + <<-EOS.dedent
+        # Use GitHub flavored Markdown http://github.github.com/github-flavored-markdown/
+        # Links to screencasts or screenshots with a desciption of what this is showcasing. For architectual changes please include diagrams that will make it easier for the reviewer to understand the change. Format is ![title](url).
+        # Link to ticket describing feature/bug (plantain, JIRA, bugzilla). Format is [title](url).
+        # Brief description of the change, and how it accomplishes the task they set out to do.
+      EOS
+
+      method_option :quiet, :type => :boolean, :aliases => '-q'
+      method_option :trace, :type => :boolean, :aliases => '-v'
+      def initialize(*args)
+        super(*args)
+        RestClient.proxy = ENV['HTTPS_PROXY'] if ENV.has_key?('HTTPS_PROXY')
+        RestClient.log = Logger.new(STDOUT) if options[:trace]
+      end
+
+      desc "reviewrequest", "Create a pull request on github"
+      method_option :description, :type => :string, :aliases => '-d', :desc => 'pull request description'
+      # @see http://developer.github.com/v3/pulls/
+      def reviewrequest
+        update
+
+        token = authorization_token
+        description = options[:description] || editor_input(PULL_REQUEST_DESCRIPTION)
+        branch = current_branch
+        repo = current_repo
+        url = create_pull_request token, branch, repo, description
+        say "Pull request created: #{url}"
+      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}" rescue nil
+        run_cmd "git pull origin #{Thegarage::Gitx::BASE_BRANCH}"
+        run_cmd 'git push origin HEAD'
+      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
+      end
+
+      desc 'track', 'set the current branch to track the remote branch with the same name'
+      def track
+        track_branch current_branch
+      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 }.sort_by { rand }.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
+        end
+
+        run_cmd "git checkout #{Thegarage::Gitx::BASE_BRANCH}"
+        run_cmd 'git pull'
+        run_cmd "git checkout -b #{branch_name}"
+      end
+
+      desc 'share', 'Share the current branch in the remote repository'
+      def share
+        share_branch current_branch
+      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}"
+      end
+
+      desc 'nuke', 'nuke the specified aggregate branch and reset it to a known good state'
+      method_option :destination, :type => :string, :aliases => '-d', :desc => 'destination branch to reset to'
+      def nuke(bad_branch)
+        default_good_branch = "last_known_good_#{bad_branch}"
+        good_branch = options[:destination] || ask("What branch do you want to reset #{bad_branch} to? (default: #{default_good_branch})")
+        good_branch = default_good_branch if good_branch.length == 0
+        good_branch = "last_known_good_#{good_branch}" unless good_branch.starts_with?('last_known_good_')
+
+        removed_branches = nuke_branch(bad_branch, good_branch)
+        nuke_branch("last_known_good_#{bad_branch}", good_branch)
+      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
+      end
+    end
+  end
+end

data/lib/thegarage/gitx/git.rb

@@ -0,0 +1,178 @@
+require 'grit'
+require 'pathname'
+
+module Thegarage
+  module Gitx
+    module Git
+      AGGREGATE_BRANCHES = %w{ staging prototype }
+      RESERVED_BRANCHES = %w{ HEAD master next_release } + AGGREGATE_BRANCHES
+
+      private
+      def assert_not_protected_branch!(branch, action)
+        raise "Cannot #{action} reserved branch" if RESERVED_BRANCHES.include?(branch) || aggregate_branch?(branch)
+      end
+
+      # lookup the current branch of the PWD
+      def current_branch
+        repo = Grit::Repo.new(Dir.pwd)
+        Grit::Head.current(repo).name
+      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 current_repo
+        repo = `git config -z --get remote.origin.url`.strip
+        repo.gsub(/\.git$/,'').split(/[:\/]/).last(2).join('/')
+      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 current_user
+        `git config -z --get github.user`.strip
+      end
+
+      # @returns [String] auth token stored in git (current repo, user config or installed global settings)
+      def github_auth_token
+        `git config -z --get thegarage.gitx.github_auth_token`.strip
+      end
+
+      # store new auth token in the local project git config
+      def github_auth_token=(new_token)
+        `git config thegarage.gitx.github_auth_token "#{new_token}"`
+      end
+
+      # retrieve a list of branches
+      def branches(options = {})
+        branches = []
+        args = []
+        args << '-r' if options[:remote]
+        args << "--merged #{options[:merged].is_a?(String) ? options[:merged] : ''}" if options[:merged]
+        output = `git branch #{args.join(' ')}`.split("\n")
+        output.each do |branch|
+          branch = branch.gsub(/\*/, '').strip.split(' ').first
+          branch = branch.split('/').last if options[:remote]
+          branches << branch unless RESERVED_BRANCHES.include?(branch)
+        end
+        branches.uniq
+      end
+
+      # reset the specified branch to the same set of commits as the destination branch
+      # reverts commits on aggregate branches back to a known good state
+      # returns list of branches that were removed
+      def nuke_branch(branch, head_branch)
+        return [] if branch == head_branch
+        raise "Only aggregate branches are allowed to be reset: #{AGGREGATE_BRANCHES}" unless aggregate_branch?(branch)
+        say "Resetting "
+        say "#{branch} ", :green
+        say "branch to "
+        say head_branch, :green
+
+        run_cmd "git checkout #{Thegarage::Gitx::BASE_BRANCH}"
+        refresh_branch_from_remote head_branch
+        removed_branches = branches(:remote => true, :merged => "origin/#{branch}") - branches(:remote => true, :merged => "origin/#{head_branch}")
+        run_cmd "git branch -D #{branch}" rescue nil
+        run_cmd "git push origin --delete #{branch}" rescue nil
+        run_cmd "git checkout -b #{branch}"
+        share_branch branch
+        run_cmd "git checkout #{Thegarage::Gitx::BASE_BRANCH}"
+
+        removed_branches
+      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 #{branch} 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
+
+        refresh_branch_from_remote destination_branch
+        run_cmd "git pull . #{branch}"
+        run_cmd "git push origin HEAD"
+        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}" rescue nil
+        run_cmd "git fetch origin"
+        run_cmd "git checkout #{destination_branch}"
+      end
+
+      def aggregate_branch?(branch)
+        AGGREGATE_BRANCHES.include?(branch) || branch.starts_with?('last_known_good')
+      end
+
+      # build a summary of changes
+      def changelog_summary(branch)
+        changes = `git diff --stat origin/#{Thegarage::Gitx::BASE_BRANCH}...#{branch}`.split("\n")
+        stats = changes.pop
+        if changes.length > 5
+          dirs = changes.map do |file_change|
+            filename = "#{file_change.split.first}"
+            dir = filename.gsub(/\/[^\/]+$/, '')
+            dir
+          end
+          dir_counts = Hash.new(0)
+          dirs.each {|dir| dir_counts[dir] += 1 }
+          changes = dir_counts.to_a.sort_by {|k,v| v}.reverse.first(5).map {|k,v| "#{k} (#{v} file#{'s' if v > 1})"}
+        end
+        (changes + [stats]).join("\n")
+      end
+
+      # launch configured editor to retreive message/string
+      def editor_input(initial_text = '')
+        require 'tempfile'
+        Tempfile.open('reviewrequest.md') do |f|
+          f << initial_text
+          f.flush
+
+          editor = ENV['EDITOR'] || 'vi'
+          flags = case editor
+          when 'mate', 'emacs'
+            '-w'
+          when 'mvim'
+            '-f'
+          else
+            ''
+          end
+          pid = fork { exec "#{editor} #{flags} #{f.path}" }
+          Process.waitpid(pid)
+          description = File.read(f.path)
+          description.gsub(/^\#.*/, '').chomp.strip
+        end
+      end
+
+      # load SC Git Extensions Config YAML
+      # @returns [Hash] of configuration options from YAML file (if it exists)
+      def config
+        @config ||= begin
+          if config_file.exist?
+            YAML.load_file(config_file)
+          else
+            {}
+          end
+        end
+      end
+
+      # @returns a [Pathname] for the scgitx.yml Config File
+      # from either ENV['SCGITX_CONFIG_PATH'] or default $PWD/config/scgitx.yml
+      def config_file
+        Pathname((ENV['SCGITX_CONFIG_PATH'] || ([Dir.pwd, '/config/scgitx.yml']).join))
+      end
+    end
+  end
+end

data/lib/thegarage/gitx/github.rb

@@ -0,0 +1,60 @@
+require 'thegarage/gitx/git'
+require 'rest_client'
+require 'json'
+
+module Thegarage
+  module Gitx
+    module Github
+      include Thegarage::Gitx::Git
+
+      private
+      # request github authorization token
+      # User-Agent is required
+      # store the token in ~/.socialcast/credentials.yml for future reuse
+      # @see http://developer.github.com/v3/oauth/#scopes
+      # @see http://developer.github.com/v3/#user-agent-required
+      def authorization_token
+        auth_token = github_auth_token
+        return auth_token if auth_token
+
+        username = current_user
+        raise "Github user not configured.  Run: `git config --global github.user 'me@email.com'`" if username.empty?
+        password = ask("Github password for #{username}: ") { |q| q.echo = false }
+
+        payload = {:scopes => ['repo'], :note => 'Socialcast Git eXtension', :note_url => 'https://github.com/socialcast/thegarage/gitx'}.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']
+        github_auth_token = token
+        token
+      rescue RestClient::Exception => e
+        process_error e
+        throw e
+      end
+
+      # returns the url of the created pull request
+      # @see http://developer.github.com/v3/pulls/
+      def create_pull_request(token, branch, repo, body)
+        payload = {:title => branch, :base => Thegarage::Gitx::BASE_BRANCH, :head => branch, :body => body}.to_json
+        say "Creating pull request for "
+        say "#{branch} ", :green
+        say "against "
+        say "#{Thegarage::Gitx::BASE_BRANCH} ", :green
+        say "in "
+        say repo, :green
+        response = RestClient::Request.new(:url => "https://api.github.com/repos/#{repo}/pulls", :method => "POST", :payload => payload, :headers => {:accept => :json, :content_type => :json, 'Authorization' => "token #{token}"}).execute
+        data = JSON.parse response.body
+        url = data['html_url']
+        url
+      rescue RestClient::Exception => e
+        process_error e
+        throw e
+      end
+
+      def process_error(e)
+        data = JSON.parse e.http_body
+        say "Failed to create pull request: #{data['message']}", :red
+      end
+    end
+  end
+end

data/lib/thegarage/gitx/string_extensions.rb

@@ -0,0 +1,11 @@
+class String
+  def undent
+    a = $1 if match(/\A(\s+)(.*\n)(?:\1.*\n)*\z/)
+    gsub(/^#{a}/,'')
+  end
+  alias :dedent :undent
+
+  def starts_with?(characters)
+    !!self.match(/^#{characters}/)
+  end
+end

data/lib/thegarage/gitx/version.rb

@@ -0,0 +1,5 @@
+module Thegarage
+  module Gitx
+    VERSION = '1.0.0.alpha'
+  end
+end

data/lib/thegarage/gitx.rb

@@ -0,0 +1,21 @@
+require "thegarage/gitx/version"
+require 'thegarage/gitx/version'
+require 'thegarage/gitx/string_extensions'
+require 'thegarage/gitx/git'
+require 'thegarage/gitx/github'
+
+
+module Thegarage
+  module Gitx
+    BASE_BRANCH = 'master'
+
+    private
+
+    # execute a shell command and raise an error if non-zero exit code is returned
+    def run_cmd(cmd)
+      say "\n$ "
+      say cmd.gsub("'", ''), :red
+      raise "#{cmd} failed" unless system cmd
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'rspec/mocks'
+require 'webmock/rspec'
+require 'pry'
+RSpec::Mocks::setup(Object.new)
+
+require 'thegarage/gitx/cli'
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+
+  def capture_with_status(stream)
+    exit_status = 0
+    begin
+      stream = stream.to_s
+      eval "$#{stream} = StringIO.new"
+      begin
+        yield
+      rescue SystemExit => system_exit # catch any exit calls
+        exit_status = system_exit.status
+      end
+      result = eval("$#{stream}").string
+    ensure
+      eval("$#{stream} = #{stream.upcase}")
+    end
+    return result, exit_status
+  end
+
+  def remove_directories(*names)
+    project_dir = Pathname.new(Dir.pwd)
+    names.each do |name|
+      FileUtils.rm_rf(project_dir.join(name)) if FileTest.exists?(project_dir.join(name))
+    end
+  end
+end