flux 0.0.3 → 0.0.5

data/lib/flux/git.rb

@@ -0,0 +1,81 @@
+require 'forwardable'
+
+module Flux
+  module Git
+    def self.git(path = repo_path)
+      Grit::Git.new(path)
+    end
+
+    def self.repo(path = repo_path)
+      Grit::Repo.new(path)
+    end
+
+    def self.repo_path(start_dir = Dir.pwd)
+      Flux.find_upwards('.git', start_dir) or
+        raise RCSError, "Couldn't find git repo starting at #{start_dir}."
+    end
+
+    class Branch
+      extend Forwardable
+
+      def self.current(repo_path = Git.repo_path)
+        Branch.local(Git.repo(repo_path).head.name, repo_path)
+      end
+
+      def self.remote(remote, name, repo_path = Git.repo_path)
+        new(repo_path, remote, name)
+      end
+
+      def self.local(name, repo_path = Git.repo_path)
+        new(repo_path, nil, name)
+      end
+
+      def_delegator :head, :commit
+
+      attr_reader :name, :remote
+
+      def initialize(repo_path, remote, name)
+        @git    = Git.git(repo_path)
+        @remote = remote
+        @name   = name
+        @repo   = Git.repo(repo_path)
+      end
+
+      def config(var, value = nil)
+        gitvar = "branch.#{name}.#{var.gsub('_', '')}"
+
+        if value
+          @git.config({:add => true}, gitvar, value)
+        else
+          @git.config({}, gitvar).chomp
+        end
+      end
+
+      def create(parent)
+        tap { @git.branch({}, @name, parent.name) }
+      end
+
+      def checkout
+        tap { @git.checkout({}, @name) }
+      end
+
+      def fqdn
+        "#{remote}/#{name}"
+      end
+
+      def publish(upstream)
+        tap {
+          @git.push({}, upstream.remote, "+#{@name}:#{upstream.name}")
+        }
+      end
+
+      def track(upstream)
+        tap { @git.branch({:set_upstream => true}, @name, upstream.fqdn) }
+      end
+
+      private
+
+      def_delegator :@repo, :head
+    end
+  end
+end

data/lib/flux/pivotal_tracker.rb

@@ -0,0 +1,81 @@
+module Flux
+  module PT
+    class Project
+      attr_reader :id
+
+      def initialize(id)
+        @id = id
+      end
+
+      def members
+        ::PivotalTracker::Membership.all(self)
+      end
+
+      def stories
+        Story::Finders.new(self)
+      end
+    end
+
+    class Story
+      STATES_W_ESTIMATE = %w(started finished delivered accepted rejected)
+      STATES            = %w(unscheduled unstarted) + STATES_W_ESTIMATE
+
+      extend Forwardable
+
+      class Finders
+        def initialize(project)
+          @project = project
+        end
+
+        def find(id)
+          story = ::PivotalTracker::Story.find(id, @project.id) or
+            raise TrackerError, "Couldn't find story #{id}."
+
+          Story.new(story)
+        end
+
+        def scheduled
+          ::PivotalTracker::Iteration.
+            current_backlog(@project).
+            map(&:stories).
+            flatten.map { |s| Story.new(s) }
+        end
+      end
+
+      def_delegators :@story, :id, :name, :owned_by, :current_state, :url
+
+      alias_method :state, :current_state
+
+      def self.id_from_url(url)
+        URI.parse(url).path.split('/').last
+      end
+
+      def initialize(story)
+        @story = story
+      end
+
+      def estimate
+        (@story.estimate && @story.estimate < 0) ? nil : @story.estimate
+      end
+
+      alias_method :est, :estimate
+
+      def update(attrs)
+        if attrs[:current_state]
+          unless STATES.include?(attrs[:current_state])
+            raise TrackerError, "Invalid state: #{attrs[:current_state]}"
+          end
+
+          if STATES_W_ESTIMATE.include?(attrs[:current_state]) &&
+             ! estimate &&
+             ! attrs[:estimate]
+            raise TrackerError,
+                  "Need an estimate for state `#{attrs[:current_state]}'."
+          end
+        end
+
+        @story.update attrs
+      end
+    end
+  end
+end

data/lib/flux/rcs.rb

@@ -0,0 +1 @@
+require 'flux/rcs/git'

data/lib/flux/rcs/git.rb

@@ -1,33 +1,150 @@
 require 'grit'
+require 'json'
 
 module Flux
   module RCS
     class Branches < Thor
       namespace :branches
 
-      desc "current", "show the current branch"
-      def current
-        repo.head.name.tap { |h| $stdout.puts h }
-      end
+      desc "review BRANCH_NAME", "review a branch"
+      method_option :parent, :type => :string, :default => "master", :desc => "upstream"
+      method_option :close, :type => :boolean, :default => false, :desc => "whether or not to close previous review requests for this branch", :aliases => '-c'
+      def review(branch_name=nil)
+        # note: we ignore any closed review requests for this branch
+        # so, if there are no open review requests, this one will start out at version 1.
+        related = open_reviews_for(branch_name)
 
-      desc "checkout BRANCH_ID", "checkout a branch"
-      def checkout(branch_id)
-        git.checkout({}, branch_id)
-      end
+        if branch_name
+          # we use the sha instead of the branch name in order to prevent GH from
+          # updating the pull-request when someone pushed to the branch again.
+          head = repo.get_head(branch_name).commit.sha
+        else
+          head = repo.head.commit.sha
+        end
+
+        if related.last
+          previous_title = related.last["title"]
+          previous_version = previous_title.match(/Please review .+ \(v(\d+)\)/)[1].to_i
+          new_version = previous_version + 1
+        else
+          new_version = 1
+        end
+        history = related.map {|pr| pr["title"] }.join("\n")
+        history = "PRIOR VERSIONS: \n" + history unless history.empty?
+        data = {
+          :title => "Please review #{branch_name} (v#{new_version}) (#{head[0..8]})",
+          :head => head,
+          :base => options[:parent],
+          :body => history
+        }.to_json
+        cmd = "curl -s #{auth_string} #{pulls_url} -d '#{data}'"
 
-      desc "create BRANCH_ID", "create a branch"
-      method_option :public, :type => :boolean, :aliases => '-p'
-      def create(branch_id)
-        git.branch({}, branch_id)
+        puts cmd if @debug
+        new_pr = JSON.parse(`#{cmd}`)
+        if new_pr["number"].to_i > 0
+          puts "Created a new review request: #{new_pr["html_url"]}"
+        else
+          puts "Error: "
+          puts new_pr
+          return
+        end
 
-        if options[:public]
-          git.push({}, 'origin', "+#{branch_id}:#{branch_id}")
-          git.branch({:set_upstream => true}, branch_id, "origin/#{branch_id}")
+        if options.close?
+          # close previous pull requests
+          related.each {|pr| close_pull_request(pr) }
         end
+        new_pr
+      end
+
+      desc "all_reviews", "list all pending reviews"
+      def all_reviews
+        reviews("open").group_by {|pr|
+          pr["title"].match(/Please review (.+) \(v.+\)/)[1]
+        }.each_pair {|branch_name, prs|
+          puts "\nReviews for #{branch_name}:"
+          prior_head = nil
+          pr = nil
+          our_reviews = reviews_for(branch_name)
+          our_reviews.each {|pr|
+            head = pr["title"].match(/Please review .+ \(v.+\) \((.+)\)/)[1]
+            title = pr["title"].sub("Please review #{branch_name}", "")
+            line = "  #{title} : #{pulls_url}/#{pr["number"]}"
+            if prior_head
+              line << " : #{compare_cmd(prior_head, head)}"
+            end
+            puts line
+            prior_head = head
+          }
+          puts "  Latest review request: #{our_reviews.last["html_url"]}"
+        }
       end
 
       private
 
+      def compare_cmd(prior_head, head)
+        "git diff #{prior_head}..#{head}"
+      end
+
+      def reviews(state = "open")
+        @cached ||= {}
+        return @cached[state] if @cached[state]
+        cmd = "curl -s #{auth_string} #{pulls_url}?state=#{state}"
+        puts cmd if @debug
+        pull_requests = JSON.parse(`#{cmd}`)
+        @cached[state] = pull_requests.select {|pr|
+          pr["title"] =~ /Please review .+ \(v.+\)/
+        }
+      end
+
+      def filter_for_branch(pull_requests, branch_name)
+        pull_requests.select {|pr|
+          pr["title"] =~ /Please review #{branch_name} \(v.+\)/
+        }.sort_by {|pr| pr["title"] }
+      end
+
+      def open_reviews_for(branch_name)
+        filter_for_branch(reviews("open"), branch_name)
+      end
+
+      def closed_reviews_for(branch_name)
+        filter_for_branch(reviews("closed"), branch_name)
+      end
+
+      def reviews_for(branch_name)
+        filter_for_branch(reviews("closed"), branch_name) + filter_for_branch(reviews("open"), branch_name)
+      end
+
+      def close_pull_request(pr)
+        puts "closing review request: #{pr["title"]}"
+        data = {
+          "state" => "closed",
+          "body" => "This review request has been replaced by: \n" + pr["body"]
+        }.to_json
+        cmd = "curl -s -X PATCH #{auth_string} #{pulls_url}/#{pr["number"]} -d '#{data}'"
+        puts cmd if @debug
+        `#{cmd}`
+      end
+
+      def api_host
+        "https://api.github.com"
+      end
+
+      def pulls_url
+        repo_user = config['repo_user']
+        repo_name = config['repo_name']
+        "#{api_host}/repos/#{repo_user}/#{repo_name}/pulls"
+      end
+
+      def auth_string
+        username = config['username']
+        password = config['password']
+        "-u \"#{username}:#{password}\""
+      end
+
+      def config
+        Flux.environment['github']
+      end
+
       def git
         @git ||= Grit::Git.new(repo_path)
       end

data/lib/flux/util.rb

@@ -1,3 +1,2 @@
-require 'flux/util/table'
 require 'flux/util/output'
 

data/lib/flux/workflows/mojotech.rb

@@ -1,32 +1,38 @@
+require 'flux/git'
+
 module Flux
   module Workflows
     module MojoTech
-      class Developer < Thor
-        include Util::Output
-
-        namespace :dev
-
-        desc "link STORY_ID", "link a story to a branch"
-        def link(story_id)
-          invoke 'stories:update',
-                 [story_id],
-                 :attributes => {'branch' => current_branch_id}
-        end
+      class Feature < Thor
+        namespace :feature
 
         desc "start STORY_ID BRANCH_ID", "start working on a story"
-        method_option :estimate, :type => :numeric
+        method_option :estimate,      :type    => :numeric
+        method_option :parent_branch, :type    => :string,
+                                      :default => 'master',
+                                      :aliases => '-b'
         def start(story_id, branch_id)
           invoke 'stories:grab', [story_id], :estimate => options[:estimate]
           invoke 'stories:start', [story_id]
-          invoke 'branches:create', [branch_id]
-          invoke 'branches:checkout', [branch_id]
-          invoke :link, [story_id]
+
+          create_branch branch_id, options
         end
 
         private
 
-        def current_branch_id
-          silence { @current_branch_id ||= invoke('branches:current', []) }
+        def create_branch(branch_id, options = {})
+          up     = Branch.remote(repo_path, 'origin', branch_id)
+          parent = Branch.local(repo_path, options[:parent_branch])
+          branch = Branch.local(repo_path, branch_id).
+            create(parent).
+            publish(up).
+            track(up).
+            checkout
+        end
+
+        def repo_path
+          Flux.find_upwards('.git', Dir.pwd) or
+            raise RCSError, "Couldn't find git repo starting at #{Dir.pwd}."
         end
       end
     end

data/spec/flux_spec.rb

@@ -3,41 +3,30 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 require 'flux'
 
 describe Flux do
-  context "with environment files" do
-    let(:root)       { File.expand_path(File.dirname(__FILE__ + '/../../..')) }
-    let(:flux_env)   { File.join(root, Flux::RC) }
-    let(:flux_env_l) { File.join(root, Flux::RC_LOCAL) }
+  describe "project files" do
+    let(:current_dir) { File.expand_path(File.dirname(__FILE__)) }
+    let(:project_dir) { File.expand_path(File.join(current_dir, '..')) }
 
-    before {
-      mock(File).exist?(is_a(String)).any_times { false }
-
-      mock(File).exist?(flux_env) { true }
-    }
-
-    it "merges the environment" do
-      mock(File).exist?(flux_env_l) { true }
-
-      mock(YAML).load_file(flux_env) {
-        {'trackers'   => {'project_id' => 123},
-          'workflow' => 'mojotech'}
-      }
-      mock(YAML).load_file(flux_env_l) {
-        {'trackers' => {'token' => 'mytoken'}}
+    it "uses an rc file called #{Flux::RC}" do
+      Dir.chdir(current_dir) {
+        Flux.rc.should == File.join(project_dir, Flux::RC)
       }
+    end
 
-      Flux.setup.should ==
-        {'trackers'   => {'project_id' => 123, 'token' => 'mytoken'},
-         'workflow'  => 'mojotech'}
+    it "requires #{Flux::RC} to exist" do
+      lambda {
+        Dir.chdir('/') { Flux.rc }
+      }.should raise_error(Flux::FluxError)
     end
 
-    it "instantiates an adapter" do
-      mock(YAML).load_file(flux_env) {
-        {'trackers' => {'adapter' => 'pivotal_tracker'}}
+    it "allows the user to keep a local rc file called #{Flux::RC_LOCAL}" do
+      Dir.chdir(current_dir) {
+        Flux.rc_local.should == File.join(project_dir, Flux::RC_LOCAL)
       }
+    end
 
-      Flux.setup
-
-      defined?(Flux::Trackers::PivotalTracker).should be_true
+    it "does not require #{Flux::RC_LOCAL} to exist" do
+      lambda { Dir.chdir('/') { Flux.rc_local } }.should_not raise_error
     end
   end
 end