flux 0.0.3 → 0.0.5

data/.flux.local.rb.sample

@@ -0,0 +1,3 @@
+use :pivotal_tracker, token: 'abcdef1234567890',
+                      email: 'david@mojotech.com'
+use :github, username: 'david', password: 'password'

data/.flux.rb.sample

@@ -0,0 +1,4 @@
+use :pivotal_tracker, project_id: 128808
+use :git
+use :github, repo_user: 'mojotech', repo_name: 'flux'
+use :mojotech

data/Gemfile

@@ -5,6 +5,8 @@ source "http://rubygems.org"
 gem "thor", "~> 0.14.0"
 gem "pivotal-tracker", "~> 0.4.0"
 gem "grit", "~> 2.4.0"
+gem 'hirb'
+gem 'github_api'
 
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.

data/README.md

@@ -46,8 +46,8 @@ This project's `.flux` file is as follows:
 The `.flux` file should be used for project-wide configuration and kept under
 version control. Obviously you aren't going to store your account credentials
 there, so you need a different place where you can store them. That place is
-`.flux.local`. If you're using Git, this file should be added to the project's
-`.gitignore`.
+`.flux.local`. If you're using Git (and really, why wouldn't you?), this file
+ should be added to the project's `.gitignore`.
 
 Here's an example of a `.flux.local` file.
 
@@ -56,3 +56,53 @@ Here's an example of a `.flux.local` file.
       email: david@mojotech.com
 
 Note for Pivotal Tracker: Your API token is at https://www.pivotaltracker.com/profile
+
+
+Code Reviews Workflow
+---------------------
+
+# start your feature on a branch
+$ git checkout feature-branch
+
+# code your feature
+$ git commit # rinse, repeat
+
+# make sure your code to review is available
+$ git push
+
+# request a review
+$ flux branches:review feature-branch [ --parent master ]
+# Note: currently, you must explicitly list your feature branch name
+# This feature branch name will be used to keep track of multiple rounds
+# of the review.
+
+# flux will generate a pull request and print its URL
+
+# Github takes sends out notices.
+# other devs review and comment
+
+# You fix up your commits.
+$ git rebase -i origin/master
+# I'm in your branch... rewriting your history.
+
+# Time to resubmit for review
+$ git push
+$ flux request-review feature-branch [ --parent master ] [ --close ]
+
+# flux closes old review request for feature-branch (optionally)
+# flux opens a new review request for feature-branch
+# The process repeats.
+
+# Now the reviewers want to see if you addressed their concerns.
+# They run:
+$ flux branches:all_reviews
+# (TODO: should be able to limit this report to one feature branch)
+
+# They see: the most recent review request for each branch, but also links
+# to the diffs between each previous review request for that branch.
+
+# So, instead of repeating the entire review, they can look at just the "inter-diff"
+
+
+
+

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.0.5

data/flux.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "flux"
-  s.version = "0.0.3"
+  s.version = "0.0.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["David Leal"]
-  s.date = "2011-10-07"
+  s.date = "2012-02-17"
   s.email = "david@mojotech.com"
   s.executables = ["flux"]
   s.extra_rdoc_files = [
@@ -18,8 +18,8 @@ Gem::Specification.new do |s|
   ]
   s.files = [
     ".document",
-    ".flux",
-    ".flux.local.sample",
+    ".flux.local.rb.sample",
+    ".flux.rb.sample",
     ".rspec",
     "Gemfile",
     "LICENSE.txt",
@@ -29,25 +29,26 @@ Gem::Specification.new do |s|
     "bin/flux",
     "flux.gemspec",
     "lib/flux.rb",
+    "lib/flux/cli.rb",
+    "lib/flux/cli/feature.rb",
+    "lib/flux/cli/pivotal_tracker.rb",
+    "lib/flux/cli/review.rb",
     "lib/flux/ext/pivotal-tracker.rb",
+    "lib/flux/git.rb",
+    "lib/flux/pivotal_tracker.rb",
+    "lib/flux/rcs.rb",
     "lib/flux/rcs/git.rb",
-    "lib/flux/trackers/pivotal_tracker.rb",
     "lib/flux/util.rb",
     "lib/flux/util/output.rb",
-    "lib/flux/util/table.rb",
     "lib/flux/workflows/mojotech.rb",
-    "spec/flux/rcs/git_spec.rb",
-    "spec/flux/trackers/pivotal_tracker_spec.rb",
-    "spec/flux/util/table_spec.rb",
     "spec/flux_spec.rb",
     "spec/spec_helper.rb",
-    "spec/support/matchers/print_table.rb",
     "spec/support/rr.rb"
   ]
   s.homepage = "http://github.com/mojotech/flux"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.10"
+  s.rubygems_version = "1.8.11"
   s.summary = "Command line workflow manager."
 
   if s.respond_to? :specification_version then
@@ -57,6 +58,8 @@ Gem::Specification.new do |s|
       s.add_runtime_dependency(%q<thor>, ["~> 0.14.0"])
       s.add_runtime_dependency(%q<pivotal-tracker>, ["~> 0.4.0"])
       s.add_runtime_dependency(%q<grit>, ["~> 2.4.0"])
+      s.add_runtime_dependency(%q<hirb>, [">= 0"])
+      s.add_runtime_dependency(%q<github_api>, [">= 0"])
       s.add_development_dependency(%q<rspec>, ["~> 2.0"])
       s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
       s.add_development_dependency(%q<jeweler>, ["~> 1.6.2"])
@@ -66,6 +69,8 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<thor>, ["~> 0.14.0"])
       s.add_dependency(%q<pivotal-tracker>, ["~> 0.4.0"])
       s.add_dependency(%q<grit>, ["~> 2.4.0"])
+      s.add_dependency(%q<hirb>, [">= 0"])
+      s.add_dependency(%q<github_api>, [">= 0"])
       s.add_dependency(%q<rspec>, ["~> 2.0"])
       s.add_dependency(%q<bundler>, ["~> 1.0.0"])
       s.add_dependency(%q<jeweler>, ["~> 1.6.2"])
@@ -76,6 +81,8 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<thor>, ["~> 0.14.0"])
     s.add_dependency(%q<pivotal-tracker>, ["~> 0.4.0"])
     s.add_dependency(%q<grit>, ["~> 2.4.0"])
+    s.add_dependency(%q<hirb>, [">= 0"])
+    s.add_dependency(%q<github_api>, [">= 0"])
     s.add_dependency(%q<rspec>, ["~> 2.0"])
     s.add_dependency(%q<bundler>, ["~> 1.0.0"])
     s.add_dependency(%q<jeweler>, ["~> 1.6.2"])

data/lib/flux.rb

@@ -6,21 +6,34 @@ require 'yaml'
 require 'flux/util'
 
 module Flux
-  RC       = '.flux'
-  RC_LOCAL = RC + '.local'
+  NAME     = '.flux'
+  RC       = "#{NAME}.rb"
+  RC_LOCAL = "#{NAME}.local.rb"
 
   class FluxError < StandardError; end
   class TrackerError < FluxError; end
 
   class << self
-    attr_accessor :environment
+    def environment
+      @project ||= {}
+    end
 
     def setup
-      self.environment = load_environment
+      load rc
+      load rc_local if File.exist?(rc_local)
+
+      require 'flux/rcs'
+      require 'flux/cli'
+    end
+
+    def rc
+      find_upwards(RC, Dir.pwd) or
+        raise FluxError, "Could not find a '#{RC}' " <<
+                         "file in the current filesystem hierarchy."
+    end
 
-      environment.each { |k, v|
-        load_adapter k, v['adapter'] if v.is_a?(Hash) && v['adapter']
-      }
+    def rc_local
+      find_upwards(RC_LOCAL, Dir.pwd)
     end
 
     def find_upwards(object, start_dir)
@@ -32,34 +45,17 @@ module Flux
       elsif p == p.parent
         nil
       else
-        find_upwards(p.parent)
-      end
-    end
-
-    private
-
-    def load_adapter(kind, adapter)
-      adapter_path = "flux/#{kind}/#{adapter}"
-
-      begin
-        require adapter_path
-      rescue LoadError
-        raise FluxError, "Could not load `#{adapter_path}'."
+        find_upwards(object, p.parent)
       end
     end
+  end
+end
 
-    def load_environment
-      rc   = find_upwards(RC, Dir.pwd) or
-        raise FluxError, "Could not find a '#{RC}' " <<
-                           "file in the current filesystem hierarchy."
-      rc_l = File.join(File.dirname(rc), RC_LOCAL)
-
-      env   = YAML.load_file(rc)
-      env_l = File.exist?(rc_l) ? YAML.load_file(rc_l) : {}
+module Kernel
+  def use(mod, options = {})
+    (Flux.environment[mod.to_s] ||= {}).
+      merge! Hash[*options.map { |k, v| [k.to_s, v] }.flatten]
 
-      env_l.each { |k, v| env[k].merge!(v) if env[k].respond_to?(:merge) }
 
-      env
-    end
   end
 end

data/lib/flux/cli.rb

@@ -0,0 +1,3 @@
+require 'flux/cli/feature'
+require 'flux/cli/pivotal_tracker'
+require 'flux/cli/review'

data/lib/flux/cli/feature.rb

@@ -0,0 +1,39 @@
+require 'flux/git'
+
+module Flux
+  module CLI
+    class Feature < Thor
+      namespace :feature
+
+      desc "start STORY_ID BRANCH_ID", "start working on a story"
+      method_option :estimate,      :type    => :numeric
+      method_option :parent_branch, :type    => :string,
+                                    :default => 'master',
+                                    :aliases => '-b'
+      def start(story_id, branch_id)
+        invoke 'pt:grab', [story_id], :estimate => options[:estimate]
+        invoke 'pt:start', [story_id]
+
+        create_branch branch_id, story_id, options
+      end
+
+      private
+
+      def create_branch(branch_id, story_id, options = {})
+        up     = Git::Branch.remote('origin', branch_id)
+        parent = Git::Branch.local(options[:parent_branch])
+        branch = Git::Branch.local(branch_id).
+          create(parent).
+          publish(up).
+          track(up).
+          checkout
+
+        link_branch_to_story branch_id, story_id
+      end
+
+      def link_branch_to_story(branch_id, story_id)
+        Git::Branch.local(branch_id).config('story_id', story_id)
+      end
+    end
+  end
+end

data/lib/flux/cli/pivotal_tracker.rb

@@ -0,0 +1,72 @@
+require 'pivotal-tracker'
+require 'hirb'
+require 'flux/pivotal_tracker'
+require 'flux/ext/pivotal-tracker'
+require 'forwardable'
+
+module Flux
+  module CLI
+    class PT < Thor
+      extend  Forwardable
+      include Flux::Util
+
+      namespace :pt
+
+      default_task :list
+
+      class << self
+        def config
+          Flux.environment['pivotal_tracker']
+        end
+
+        def login
+          ::PivotalTracker::Client.token = config['token']
+        end
+
+        def story_update(name, attrs = nil, &get_attrs)
+          desc "#{name} STORY_ID", "#{name} a story"
+          method_option :estimate, :type => :numeric, :aliases => '-e'
+          define_method name do |story_id|
+            a = attrs || instance_eval(&get_attrs)
+
+            a[:estimate] = options[:estimate] if options[:estimate]
+
+            story(story_id).update a
+          end
+        end
+      end
+
+      no_tasks {
+        def_delegator self, :config
+      }
+
+      login if config
+
+      desc "list", "list stories, excluding icebox by default"
+      def list
+        puts Hirb::Helpers::ObjectTable.render(
+          current_project.stories.scheduled,
+          :fields => [:id, :state, :owned_by, :est, :name]
+        )
+      end
+
+      story_update :finish, :current_state => 'finished'
+      story_update(:grab)   {{:owned_by => me.name}}
+      story_update :start,  :current_state => 'started'
+
+      private
+
+      def current_project
+        Flux::PT::Project.new(config['project_id'])
+      end
+
+      def me
+        current_project.members.find { |m| m.email == config['email'] }
+      end
+
+      def story(id)
+        current_project.stories.find(id)
+      end
+    end
+  end
+end

data/lib/flux/cli/review.rb

@@ -0,0 +1,190 @@
+require 'open-uri'
+require 'flux/git'
+require 'github_api'
+
+module Flux
+  module CLI
+    class Review < Thor
+      namespace 'review'
+
+      desc "diff", "show interdiff between last 2 reviews"
+      method_option :from,  :type => :numeric, :aliases => '-f'
+      method_option :to,    :type => :numeric, :aliases => '-t'
+      method_option :color, :type => :boolean, :aliases => '-c'
+      def diff(branch_name = Git::Branch.current.name)
+        reqs = pull_requests(:state => 'all', :branch_name => branch_name)
+
+        if options[:from] && options[:to]
+          to   = reqs.find { |r| r[:number].to_i == options[:to].to_i }
+          from = reqs.find { |r| r[:number].to_i == options[:from].to_i }
+        else
+          to, from = reqs.first(2)
+        end
+
+        if from
+          auth = [gh_config['username'], gh_config['password']]
+
+          to_diff = Tempfile.new("to_diff")
+          to_diff.write(open(to[:diff_url],
+                               :http_basic_authentication => auth).read)
+
+          from_diff = Tempfile.new("from_diff")
+          from_diff.write(open(from[:diff_url],
+                               :http_basic_authentication => auth).read)
+
+          cmd =  "interdiff #{from_diff.path} #{to_diff.path}"
+          cmd << "| colordiff"
+
+          system cmd
+        end
+      end
+
+      desc "request", "request a review for the current feature"
+      def request
+        branch = Git::Branch.current
+        story  = current_project.stories.find(branch.config('story_id'))
+        body   = {:branch_name => branch.name,
+                  :story_url   => story.url,
+                  :iterations  => iterations(branch.name)}
+        data   = {:base  => 'master',
+                  :head  => branch.commit.sha,
+                  :title => story.name,
+                  :body  => PullRequestBody.to_markdown(body)}
+
+        gh.pull_requests.create_request gh_config['repo_user'],
+                                        gh_config['repo_name'],
+                                        data
+      end
+
+      desc "list", "list pull requests for the current project"
+      def list
+        list_pull_requests pull_requests
+      end
+
+      desc "history BRANCH_ID", "show review history for branch"
+      def history(branch_id = Git::Branch.current.name)
+        reqs = pull_requests(:branch_name => branch_id, :state => 'all')
+
+        list_pull_requests reqs
+      end
+
+      private
+
+      def config
+        Flux.environment
+      end
+
+      def current_project
+        Flux::PT::Project.new(pt_config['project_id'])
+      end
+
+      def gh
+        Github.new :login    => gh_config['username'],
+                   :password => gh_config['password']
+      end
+
+      def gh_config
+        config['github']
+      end
+
+      def pt_config
+        config['pivotal_tracker']
+      end
+
+      def iterations(branch_name)
+        last = pull_requests(:branch_name => branch_name).first
+
+        if last
+          [last[:url]].concat(last[:body][:iterations])
+        else
+          []
+        end
+      end
+
+      def pull_requests(opts = {})
+        if opts[:state] == 'all'
+          return pull_requests(opts.merge(:state => 'open')) +
+                 pull_requests(opts.merge(:state => 'closed'))
+        end
+
+        branch_name = opts.delete(:branch_name)
+
+        reqs = gh.pull_requests.pull_requests(gh_config['repo_user'],
+                                              gh_config['repo_name'],
+                                              opts).each { |r|
+          r[:author]   = r[:user][:login]
+          r[:body]     = PullRequestBody.from_markdown(r[:body])
+          r[:story_id] = Flux::PT::Story.id_from_url(r[:body][:story_url])
+        }
+
+        if branch_name
+          reqs.select { |r| r[:body][:branch_name] == branch_name }
+        else
+          reqs
+        end
+      end
+
+      def list_pull_requests(pull_requests)
+        puts Hirb::Helpers::Table.render(
+          pull_requests,
+          :fields => [:number, :title, :story_id, :author, :created_at]
+        )
+      end
+
+      module PullRequestBody
+        def self.from_markdown(md)
+          if (md || '').include?(signoff)
+            _, branch_name, story_url, iter = md.
+              gsub(signoff, '').
+              split(/### [^\n]+/).map(&:strip)
+
+            if iter
+              _, iterations = iter.split('*').map(&:strip)
+
+              iterations = Array(iterations)
+            else
+              iterations = []
+            end
+          else
+            branch_name = nil
+            story_url   = "http://mojotech.com"
+            iterations  = []
+          end
+
+          {:branch_name => branch_name,
+           :story_url   => story_url,
+           :iterations  => iterations}
+        end
+
+        def self.to_markdown(data)
+          tmpl = <<MARKDOWN
+### Branch
+
+#{data[:branch_name]}
+
+### Story
+
+#{data[:story_url]}
+
+MARKDOWN
+
+          if data[:iterations].empty?
+            tmpl << signoff << "\n"
+          else
+            tmpl << <<ITERATIONS
+### Prior Versions
+
+#{"* " + data[:iterations].join("\n* ") + "\n"}
+
+#{signoff}
+ITERATIONS
+          end
+        end
+
+        def self.signoff
+          "*Your friendly neighborhood Flux*"
+        end
+      end
+    end
+  end
+end