github-pivotal-flow 0.0.1

data/lib/github_pivotal_flow/finish.rb

@@ -0,0 +1,33 @@
+# The class that encapsulates finishing a Pivotal Tracker Story
+module GithubPivotalFlow
+  class Finish < Command
+
+    # Finishes a Pivotal Tracker story
+    def run!
+      story = @configuration.story(@project)
+      story.can_merge?
+      commit_message = options[:commit_message]
+      if story.release?
+        story.merge_release!(commit_message, @options)
+      else
+        story.merge_to_root!(commit_message, @options)
+      end
+      return 0
+    end
+
+    private
+
+    def parse_argv(*args)
+      OptionParser.new do |opts|
+        opts.banner = "Usage: git finish [options]"
+        opts.on("-t", "--api-token=", "Pivotal Tracker API key") { |k| options[:api_token] = k }
+        opts.on("-p", "--project-id=", "Pivotal Tracker project id") { |p| options[:project_id] = p }
+        opts.on("-n", "--full-name=", "Your Pivotal Tracker full name") { |n| options[:full_name] = n }
+        opts.on("-m", "--message=", "Specify a commit message") { |m| options[:commit_message] = m }
+
+        opts.on("--no-complete", "Do not mark the story completed on Pivotal Tracker") { options[:no_complete] = true }
+        opts.on_tail("-h", "--help", "This usage guide") { put opts.to_s; exit 0 }
+      end.parse!(args)
+    end
+  end
+end

data/lib/github_pivotal_flow/git.rb

@@ -0,0 +1,150 @@
+module GithubPivotalFlow
+  class Git
+    def self.current_branch
+      exec('git branch').scan(/\* (.*)/)[0][0]
+    end
+
+    def self.checkout(branch_name)
+      exec "git checkout --quiet #{branch_name}" unless branch_name == self.current_branch
+    end
+
+    def self.pull(ref, origin)
+      exec "git pull --quiet #{[origin, ref].compact.join(' ')}"
+    end
+
+    def self.get_remote
+      remote = get_config('remote', :branch).strip
+      return exec('git remote').strip if remote.blank?
+      remote
+    end
+
+    def self.pull_remote(branch_name = nil)
+      prev_branch = self.current_branch
+      branch_name ||= self.current_branch
+      self.checkout(branch_name)
+      remote = self.get_remote
+      self.pull(branch_name, remote) unless remote.blank?
+      self.checkout(prev_branch)
+    end
+
+    def self.create_branch(branch_name, start_point = nil, options = {})
+      return if branch_exists?(branch_name)
+      exec "git branch --quiet #{[branch_name, start_point].compact.join(' ')}"
+      puts 'OK'
+    end
+
+    def self.branch_exists?(name)
+      system "git show-ref --quiet --verify refs/heads/#{name}"
+    end
+
+    def self.ensure_branch_exists(branch_name)
+      return if branch_name == current_branch || self.branch_exists?(branch_name)
+      exec "git branch --quiet #{branch_name}", false
+    end
+
+    def self.merge(branch_name, options = {})
+      command = "git merge --quiet"
+      command << " --no-ff" if options[:no_ff]
+      command << " -m \"#{options[:commit_message]}\"" unless options[:commit_message].blank?
+      exec "#{command} #{branch_name}"
+      puts 'OK'
+    end
+
+    def self.publish(branch_name)
+      branch_name ||= self.current_branch
+      exec "git checkout --quiet #{branch_name}" unless branch_name == self.current_branch
+      exec "git push #{self.get_remote} #{branch_name}"
+    end
+
+    def self.commit(options = {})
+      command = "git commit --quiet"
+      command << " --allow-empty" if options[:allow_empty]
+      command << " -m \"#{options[:commit_message]}\"" unless options[:commit_message].blank?
+      exec command
+    end
+
+    def self.tag(tag_name)
+      exec "git tag #{tag_name}"
+    end
+
+    def self.delete_branch(branch_name, options = {})
+      command = "git branch"
+      command << (options[:force] ? " -D" : " -d")
+      exec "#{command} #{branch_name}"
+      puts 'OK'
+    end
+
+    def self.delete_remote_branch(branch_name)
+      exec "git push #{Git.get_remote} --delete #{branch_name}"
+    end
+
+    def self.push(*refs)
+      remote = self.get_remote
+
+      print "Pushing to #{remote}... "
+      exec "git push --quiet #{remote} " + refs.join(' ')
+      puts 'OK'
+    end
+
+    def self.push_tags
+      exec "git push --tags #{self.get_remote}"
+    end
+
+    def self.get_config(key, scope = :inherited)
+      if :branch == scope
+        exec("git config branch.#{self.current_branch}.#{key}", false).strip
+      elsif :inherited == scope
+        exec("git config #{key}", false).strip
+      else
+        raise "Unable to get Git configuration for scope '#{scope}'"
+      end
+    end
+
+    def self.set_config(key, value, scope = :local)
+      if :branch == scope
+        exec "git config --local branch.#{self.current_branch}.#{key} #{value}"
+      elsif :global == scope
+        exec "git config --global #{key} #{value}"
+      elsif :local == scope
+        exec "git config --local #{key} #{value}"
+      else
+        raise "Unable to set Git configuration for scope '#{scope}'"
+      end
+    end
+
+    def self.repository_root
+      repository_root = Dir.pwd
+
+      until Dir.entries(repository_root).any? { |child| File.directory?(child) && (child =~ /^.git$/) }
+        next_repository_root = File.expand_path('..', repository_root)
+        abort('Current working directory is not in a Git repository') unless repository_root != next_repository_root
+        repository_root =  next_repository_root
+      end
+      repository_root
+    end
+
+    def self.add_hook(name, source, overwrite = false)
+      hooks_directory =  File.join repository_root, '.git', 'hooks'
+      hook = File.join hooks_directory, name
+
+      if overwrite || !File.exist?(hook)
+        print "Creating Git hook #{name}...  "
+
+        FileUtils.mkdir_p hooks_directory
+        File.open(source, 'r') do |input|
+          File.open(hook, 'w') do |output|
+            output.write(input.read)
+            output.chmod(0755)
+          end
+        end
+
+        puts 'OK'
+      end
+    end
+
+    private
+    def self.exec(command, abort_on_failure = true)
+      return Shell.exec(command, abort_on_failure)
+    end
+  end
+end

data/lib/github_pivotal_flow/github_api.rb

@@ -0,0 +1,241 @@
+module GithubPivotalFlow
+  # Client for the GitHub v3 API.
+  class GitHubAPI
+    attr_reader :config, :oauth_app_url
+
+    def initialize config, options
+      @config = config
+      @oauth_app_url = options.fetch(:app_url)
+    end
+
+    # Fake exception type for net/http exception handling.
+    # Necessary because net/http may or may not be loaded at the time.
+    module Exceptions
+      def self.===(exception)
+        exception.class.ancestors.map {|a| a.to_s }.include? 'Net::HTTPExceptions'
+      end
+    end
+
+    def api_host host
+      host = host.downcase
+      'github.com' == host ? 'api.github.com' : host
+    end
+
+    def username_via_auth_dance host
+      host = api_host(host)
+      config.github_username(host) do
+        if block_given?
+          yield
+        else
+          res = get("https://%s/user" % host)
+          res.error! unless res.success?
+          config.github_username = res.data['login']
+        end
+      end
+    end
+
+    # Returns parsed data from the new pull request.
+    def create_pullrequest options
+      project = options.fetch(:project)
+      params = {
+          :base => options.fetch(:base),
+          :head => options.fetch(:head)
+      }
+
+      if options[:issue]
+        params[:issue] = options[:issue]
+      else
+        params[:title] = options[:title] if options[:title]
+        params[:body]  = options[:body]  if options[:body]
+      end
+
+      res = post "https://%s/repos/%s/%s/pulls" %
+                     [api_host(project.host), project.owner, project.name], params
+
+      res.error! unless res.success?
+      res.data
+    end
+
+    def statuses project, sha
+      res = get "https://%s/repos/%s/%s/statuses/%s" %
+                    [api_host(project.host), project.owner, project.name, sha]
+
+      res.error! unless res.success?
+      res.data
+    end
+
+    module HttpMethods
+      # Decorator for Net::HTTPResponse
+      module ResponseMethods
+        def status() code.to_i end
+        def data?() content_type =~ /\bjson\b/ end
+        def data() @data ||= JSON.parse(body) end
+        def error_message?() data? and data['errors'] || data['message'] end
+        def error_message() error_sentences || data['message'] end
+        def success?() Net::HTTPSuccess === self end
+        def error_sentences
+          data['errors'].map do |err|
+            case err['code']
+            when 'custom'        then err['message']
+            when 'missing_field'
+              %(Missing field: "%s") % err['field']
+            when 'invalid'
+              %(Invalid value for "%s": "%s") % [ err['field'], err['value'] ]
+            when 'unauthorized'
+              %(Not allowed to change field "%s") % err['field']
+            end
+          end.compact if data['errors']
+        end
+      end
+
+      def get url, &block
+        perform_request url, :Get, &block
+      end
+
+      def post url, params = nil
+        perform_request url, :Post do |req|
+          if params
+            req.body = JSON.dump params
+            req['Content-Type'] = 'application/json;charset=utf-8'
+          end
+          yield req if block_given?
+          req['Content-Length'] = byte_size req.body
+        end
+      end
+
+      def byte_size str
+        if    str.respond_to? :bytesize then str.bytesize
+        elsif str.respond_to? :length   then str.length
+        else  0
+        end
+      end
+
+      def post_form url, params
+        post(url) {|req| req.set_form_data params }
+      end
+
+      def perform_request url, type
+        url = URI.parse url unless url.respond_to? :host
+
+        require 'net/https'
+        req = Net::HTTP.const_get(type).new request_uri(url)
+        # TODO: better naming?
+        http = configure_connection(req, url) do |host_url|
+          create_connection host_url
+        end
+
+        req['User-Agent'] = "Hub 1.11.1"
+        apply_authentication(req, url)
+        yield req if block_given?
+        finalize_request(req, url)
+
+        begin
+          res = http.start { http.request(req) }
+          res.extend ResponseMethods
+          return res
+        rescue SocketError => err
+          raise Context::FatalError, "error with #{type.to_s.upcase} #{url} (#{err.message})"
+        end
+      end
+
+      def request_uri url
+        str = url.request_uri
+        str = '/api/v3' << str if url.host != 'api.github.com' && url.host != 'gist.github.com'
+        str
+      end
+
+      def configure_connection req, url
+        if ENV['HUB_TEST_HOST']
+          req['Host'] = url.host
+          url = url.dup
+          url.scheme = 'http'
+          url.host, test_port = ENV['HUB_TEST_HOST'].split(':')
+          url.port = test_port.to_i if test_port
+        end
+        yield url
+      end
+
+      def apply_authentication req, url
+        user = url.user ? CGI.unescape(url.user) : config.github_username(url.host)
+        pass = config.github_password(url.host, user)
+        req.basic_auth user, pass
+      end
+
+      def finalize_request(req, url)
+        if !req['Accept'] || req['Accept'] == '*/*'
+          req['Accept'] = 'application/vnd.github.v3+json'
+        end
+      end
+
+      def create_connection url
+        use_ssl = 'https' == url.scheme
+
+        proxy_args = []
+        if proxy = config.proxy_uri(use_ssl)
+          proxy_args << proxy.host << proxy.port
+          if proxy.userinfo
+            # proxy user + password
+            proxy_args.concat proxy.userinfo.split(':', 2).map {|a| CGI.unescape a }
+          end
+        end
+
+        http = Net::HTTP.new(url.host, url.port, *proxy_args)
+
+        if http.use_ssl = use_ssl
+          # FIXME: enable SSL peer verification!
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+        return http
+      end
+    end
+
+    module OAuth
+      def apply_authentication req, url
+        if req.path =~ %r{^(/api/v3)?/authorizations$}
+          super
+        else
+          user = url.user ? CGI.unescape(url.user) : config.github_username(url.host)
+          token = config.github_api_token(url.host, user) {
+            obtain_oauth_token url.host, user
+          }
+          req['Authorization'] = "token #{token}"
+        end
+      end
+
+      def obtain_oauth_token host, user, two_factor_code = nil
+        auth_url = URI.parse("https://%s@%s/authorizations" % [CGI.escape(user), host])
+
+        # dummy request to trigger a 2FA SMS since a HTTP GET won't do it
+        post(auth_url) if !two_factor_code
+
+        # first try to fetch existing authorization
+        res = get(auth_url) do |req|
+          req['X-GitHub-OTP'] = two_factor_code if two_factor_code
+        end
+        unless res.success?
+          if !two_factor_code && res['X-GitHub-OTP'].to_s.include?('required')
+            two_factor_code = config.ask_auth_code
+            return obtain_oauth_token(host, user, two_factor_code)
+          else
+            res.error!
+          end
+        end
+
+        if found = res.data.find {|auth| auth['app']['url'] == oauth_app_url }
+          found['token']
+        else
+          # create a new authorization
+          res = post auth_url,
+                     :scopes => %w[repo], :note => 'github-pivotal-flow', :note_url => oauth_app_url do |req|
+            req['X-GitHub-OTP'] = two_factor_code if two_factor_code
+          end
+          res.error! unless res.success?
+          res.data['token']
+        end
+      end
+    end
+
+    include HttpMethods
+    include OAuth
+  end
+end

data/lib/github_pivotal_flow/prepare-commit-msg.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+CURRENT_BRANCH=$(git branch | grep "*" | sed "s/* //")
+STORY_ID=$(git config branch.$CURRENT_BRANCH.pivotal-story-id)
+
+if [[ $2 != "commit" && -n $STORY_ID ]]; then
+	ORIG_MSG_FILE="$1"
+	TEMP=$(mktemp /tmp/git-XXXXX)
+
+	(printf "\n\n[#$STORY_ID]" ; cat "$1") > "$TEMP"
+	cat "$TEMP" > "$ORIG_MSG_FILE"
+fi

data/lib/github_pivotal_flow/project.rb

@@ -0,0 +1,23 @@
+module GithubPivotalFlow
+  class Project < Struct.new(:owner, :name, :host)
+    def self.from_url(url)
+      _, owner, name = url.path.split('/', 4)
+      self.new(owner, name.sub(/\.git$/, ''), url.host)
+    end
+
+    def initialize(*args)
+      super
+      self.name = self.name.tr(' ', '-')
+      self.host ||= 'github.com'
+      self.host = host.sub(/^ssh\./i, '') if 'ssh.github.com' == host.downcase
+    end
+
+    def name_with_owner
+      "#{owner}/#{name}"
+    end
+
+    def ==(other)
+      name_with_owner == other.name_with_owner
+    end
+  end
+end