flux 0.0.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.flux

@@ -0,0 +1,9 @@
+# -*- mode: yaml -*-
+
+trackers:
+  adapter: pivotal_tracker
+  project_id: 128808
+rcs:
+  adapter: git
+workflows:
+  adapter: mojotech

data/.flux.local.sample

@@ -0,0 +1,3 @@
+trackers:
+  token: abcdef1234567890
+  email: david@mojotech.com

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,17 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+gem "thor", "~> 0.14.0"
+gem "pivotal-tracker", "~> 0.4.0"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "grit", "~> 2.4.0"
+  gem "rspec", "~> 2.0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.2"
+  gem "rcov", ">= 0"
+  gem "rr", "~> 1.0.0"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 MojoTech
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "flux"
+  gem.homepage = "http://github.com/mojotech/flux"
+  gem.license = "MIT"
+  gem.summary = %Q{Command line workflow manager.}
+  gem.email = "david@mojotech.com"
+  gem.authors = ["David Leal"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "flux #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/bin/flux

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+require 'thor/runner'
+
+require 'flux'
+
+class Flux::Runner < Thor::Runner
+  alias_method :help, :list
+
+  private
+
+  def initialize_thorfiles(whocares = nil, nevermind = nil)
+    # birds chirping
+  end
+end
+
+begin
+  $thor_runner = true
+  Flux::Runner.start(ARGV, {'environment' => Flux.setup})
+rescue Flux::FluxError => e
+  $stderr.puts e.message
+  exit 1
+end

data/lib/flux.rb

@@ -0,0 +1,65 @@
+require 'ostruct'
+require 'pathname'
+require 'thor'
+require 'yaml'
+
+require 'flux/util'
+
+module Flux
+  RC       = '.flux'
+  RC_LOCAL = RC + '.local'
+
+  class FluxError < StandardError; end
+  class TrackerError < FluxError; end
+
+  class << self
+    attr_accessor :environment
+
+    def setup
+      self.environment = load_environment
+
+      environment.each { |k, v|
+        load_adapter k, v['adapter'] if v.is_a?(Hash) && v['adapter']
+      }
+    end
+
+    def find_upwards(object, start_dir)
+      p  = Pathname(start_dir)
+      f  = (p + object).expand_path.to_s
+
+      if File.exist?(f)
+        f
+      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}'."
+      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) : {}
+
+      env_l.each { |k, v| env[k].merge!(v) if env[k].respond_to?(:merge) }
+
+      env
+    end
+  end
+end

data/lib/flux/ext/pivotal-tracker.rb

@@ -0,0 +1,13 @@
+module Flux
+  module PivotalTracker
+    module IterationExt
+      def current_backlog(project, options = {})
+        params = ::PivotalTracker.encode_options(options)
+        path   = "/projects/#{project.id}/iterations/current_backlog#{params}"
+        parse(::PivotalTracker::Client.connection[path].get)
+      end
+
+      ::PivotalTracker::Iteration.send(:extend, self)
+    end
+  end
+end

data/lib/flux/rcs/git.rb

@@ -0,0 +1,26 @@
+require 'grit'
+
+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
+
+      private
+
+      def repo
+        @repo ||=
+          begin
+            repo = Flux.find_upwards('.git', Dir.pwd) or
+              raise RCSError, "Couldn't find git repo starting at #{Dir.pwd}."
+
+            Grit::Repo.new(repo)
+          end
+      end
+    end
+  end
+end

data/lib/flux/trackers/pivotal_tracker.rb

@@ -0,0 +1,129 @@
+require 'pivotal-tracker'
+require 'flux/ext/pivotal-tracker'
+
+module Flux
+  module Trackers
+    class PivotalTracker < Thor
+      include Flux::Util
+
+      namespace :stories
+
+      default_task :list
+
+      desc "list", "list stories, excluding icebox by default"
+      def list
+        list_stories pt::Iteration.
+          current_backlog(fake_project).map { |i| i.stories }.flatten
+      end
+
+      desc "finish STORY_ID", "finish the given story"
+      method_option :estimate, :type => :numeric, :aliases => '-e'
+      def finish(story_id)
+        update_state story_id, 'finished'
+      end
+
+      desc "grab STORY_ID", "assign yourself the given story"
+      def grab(story_id)
+        invoke :update, [story_id], :attributes => {:owner => me.name}
+      end
+
+      desc "start STORY_ID", "start the given story"
+      method_option :estimate, :type => :numeric, :aliases => '-e'
+      def start(story_id)
+        update_state story_id, 'started'
+      end
+
+      STATES_W_ESTIMATE = %w(started finished delivered accepted rejected)
+      STATES            = %w(unscheduled unstarted) + STATES_W_ESTIMATE
+
+      MAPPINGS = Hash.new { |h, k| h[k] = k }
+      MAPPINGS['owner'] = 'owned_by'
+      MAPPINGS['state'] = 'current_state'
+
+      desc "update STORY_ID", "update a story's attributes"
+      method_option :attributes, :type => :hash, :required => true
+      def update(story_id)
+        story          = story!(story_id)
+        native, custom =
+          options[:attributes].
+            map { |k, v| [MAPPINGS[k.to_s], v] }.
+            partition { |(k, v)| story.respond_to?("#{k}=") }
+
+        native_h = Hash[*native.flatten]
+
+        if native_h['current_state']
+          unless STATES.include?(native_h['current_state'])
+            raise TrackerError, "Invalid state: #{native_h['current_state']}"
+          end
+
+          if STATES_W_ESTIMATE.include?(native_h['current_state']) &&
+             ! story.estimate &&
+             ! native_h['estimate']
+            raise TrackerError,
+                  "Need an estimate for state `#{native_h['current_state']}'."
+          end
+        end
+
+        story.update(native_h) unless native.empty?
+
+        unless custom.empty?
+          str = YAML.dump(Hash[*custom.flatten])
+
+          pt::Note.new(:owner => story, :text => str).create
+        end
+      end
+
+      private
+
+      def config
+        Flux.environment['trackers']
+      end
+
+      def fake_project
+        @fp ||= OpenStruct.new(:id => config['project_id'])
+      end
+
+      def fake_story(id)
+        pt::Story.new(:id         => id,
+                      :project_id => config['project_id'])
+      end
+
+      STORY_LIST_HEADERS = %w(ID STATE ASSIGNEE STORY)
+
+      def list_stories(stories)
+        puts_table [STORY_LIST_HEADERS] + stories.map { |s|
+          [s.id, s.current_state, s.owned_by, s.name]
+        }
+      end
+
+      def login
+        ::PivotalTracker::Client.token = config['token']
+      end
+
+      def me
+        ms = pt::Membership.all(fake_project)
+
+        ms.find { |m| m.email == config['email'] }
+      end
+
+      def pt
+        login and return ::PivotalTracker
+      end
+
+      def story(id)
+        pt::Story.find(id, config['project_id'])
+      end
+
+      def story!(id)
+        story(id) or raise TrackerError, "Couldn't find story #{id}."
+      end
+
+      def update_state(story_id, state)
+        attrs            = {:state => state}
+        attrs[:estimate] = options[:estimate] if options[:estimate]
+
+        invoke :update, [story_id], :attributes => attrs
+      end
+    end
+  end
+end

data/lib/flux/util.rb

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

data/lib/flux/util/table.rb

@@ -0,0 +1,99 @@
+module Flux
+  module Util
+    # Initialize a new Table.
+    #
+    # @param [Array<Array>] raw_data the table's annotated data
+    # @param field_sep the string used to separate columns
+    # @param [Integer] max_width the maximum width for this table.
+    #   Lines exceeding this width will be truncated.
+    # @param shell the shell object used by the current task
+    def puts_table(raw_data, field_sep = '  ', max_width = nil)
+      $stdout.puts Table.new(shell, raw_data, field_sep, max_width)
+    end
+
+    # A table pretty printer that allows us to take a peek at the data after
+    # it's been stripped of formatting information. It exists to make testing
+    # easier.
+    #
+    # If any cell in the first row is prefixed with '>', then that column's
+    # contents will be right-aligned. This is useful when showing numbers.
+    class Table
+      ALIGN_RIGHT = '>'
+
+      attr_reader :field_sep, :raw_data, :shell, :max_width
+
+      # @see Flux::Util#puts_table
+      def initialize(shell, raw_data, field_sep, max_width)
+        @shell     = shell
+        @raw_data  = raw_data
+        @field_sep = field_sep
+        @max_width = max_width || terminal_width
+      end
+
+      # @return whether a given column's contents will be aligned to the right
+      def align_right?(index)
+        meta[index].include?(ALIGN_RIGHT)
+      end
+
+      # @return all rows but the first
+      def body
+        @body ||= raw_data[1..-1]
+      end
+
+      # @return the table data, stripped of format information
+      def data
+        @data ||= body.unshift(headers)
+      end
+
+      # @return the table's first row
+      def headers
+        @headers = raw_data.first.each_with_index.map { |e, i|
+          align_right?(i) ? e[1..-1] : e
+        }
+      end
+
+      # @return the table's format information
+      def meta
+        @meta ||= @raw_data.first.inject([]) { |a, e|
+          a << (e =~ /^>/ ? ALIGN_RIGHT : '')
+        }
+      end
+
+      def to_s
+        @s ||=
+          begin
+            widths  = data.transpose.inject([]) { |a, col|
+              a << col.max { |a, b| a.to_s.size <=> b.to_s.size }.to_s.size
+            }
+
+            # we don't need the last column's width if it is to be left-aligned
+            widths[-1] = nil unless align_right?(-1)
+
+            format  = meta.each_with_index.inject('') { |a, (e, i)|
+              w     = widths[i] ? widths[i].to_s : ''
+              align = align_right?(i) ? '' : '-'
+
+              a << "#{field_sep}%" << align << w << 's'
+            }.strip
+
+            max_width
+
+            data.inject('') { |a, r|
+              l =
+              a << truncate(format % r, max_width) << "\n"
+            }
+          end
+      end
+
+      private
+
+      def truncate(string, width)
+        shell.send(:truncate, string, width)
+      end
+
+      def terminal_width
+        shell.send(:terminal_width)
+      end
+    end
+  end
+end

data/lib/flux/workflows/mojotech.rb

@@ -0,0 +1,31 @@
+module Flux
+  module Workflows
+    module MojoTech
+      class Developer < Thor
+        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
+
+        private
+
+        def current_branch_id
+          silence { @current_branch_id ||= invoke('branches:current', []) }
+        end
+
+        def silence
+          old_stdout = $stdout
+          $stdout    = StringIO.new
+
+          yield
+        ensure
+          $stdout = old_stdout
+        end
+      end
+    end
+  end
+end

data/spec/flux/trackers/pivotal_tracker_spec.rb

@@ -0,0 +1,155 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+require 'flux/trackers/pivotal_tracker'
+
+describe Flux::Trackers::PivotalTracker do
+  let(:environment) {
+    {'trackers' => {'project_id' => PROJECT.id,
+                    'token'      => PROJECT.token,
+                    'email'      => 'david@mojotech.com'}}
+  }
+
+  before { Flux.environment = environment }
+
+  it "lists stories by iteration" do
+    mock(PivotalTracker::Iteration).current_backlog(fake_project) {
+      [OpenStruct.new(:stories => [
+                        OpenStruct.new(:id            => 1,
+                                       :current_state => 'unstarted',
+                                       :owned_by      => '',
+                                       :name          => 'first story')]),
+       OpenStruct.new(:stories => [
+                        OpenStruct.new(:id            => 2,
+                                       :current_state => 'started',
+                                       :owned_by      => 'David Leal',
+                                       :name          => 'second story')])]
+    }
+
+    t = [['ID', 'STATE', 'ASSIGNEE', 'STORY'],
+         [1, 'unstarted', '', 'first story'],
+         [2, 'started', 'David Leal', 'second story']]
+
+    lambda { subject.invoke :list }.should print_table(t)
+  end
+
+  it "grabs a story" do
+    prepare_myself
+
+    mock_update(123, 'owned_by' => 'David Leal')
+
+    subject.invoke :grab, [123]
+  end
+
+  [%w(starts started start),
+   %w(finishes finished finish)].each do |(action, state, task)|
+    it "#{action} a story that was already estimated" do
+      s = mock_update(123, 'current_state' => state)
+      s.estimate = 2
+
+      subject.invoke task, [123]
+    end
+
+    it "#{action} a story that needs to be estimated" do
+      mock_update(123, 'current_state' => state, 'estimate' => 2)
+
+      subject.invoke task, [123], :estimate => 2
+    end
+  end
+
+  describe "attributes" do
+    it "updates custom attributes" do
+      attrs = {'branch' => 'blah', 'other' => 'yay'}
+
+      mock_find(123)
+      mock(PivotalTracker::Note).new(observe { |h|
+                                       h[:owner].id == 123 &&
+                                       h[:text] == YAML.dump(attrs)
+                                     }).mock!.create
+
+      subject.invoke :update, [123], :attributes => attrs
+    end
+
+    it "updates native attributes" do
+      attrs = {'owner'    => 'David Leal',
+               'state'    => 'started',
+               'estimate' => 2,
+               'name'     => 'My story'}
+
+      mock_update(123,
+                  'owned_by'      => 'David Leal',
+                  'current_state' => 'started',
+                  'estimate'      => 2,
+                  'name'          => 'My story')
+
+      subject.invoke :update, [123], :attributes => attrs
+    end
+
+    it "updates valid states only" do
+      attrs = {'state' => 'sitting'}
+
+      s = mock_find(123)
+
+      lambda { subject.invoke :update, [123], :attributes => attrs }.
+        should raise_error(Flux::TrackerError, /Invalid state/)
+    end
+
+    it "updates state when story has estimate" do
+      attrs = {'state' => 'started'}
+
+      s          = mock_update(123, 'current_state' => 'started')
+      s.estimate = 2
+
+      subject.invoke :update, [123], :attributes => attrs
+    end
+
+    it "updates state when story estimate is given" do
+      attrs = {'state' => 'started', 'estimate' => 2}
+
+      s = mock_update(123, 'current_state' => 'started',
+                           'estimate'      => 2)
+
+      subject.invoke :update, [123], :attributes => attrs
+    end
+
+    Flux::Trackers::PivotalTracker::STATES_W_ESTIMATE.each do |state|
+      it "fails to update state `#{state}' if no estimate given" do
+        attrs = {'state' => state}
+
+        s = mock_find(123)
+
+        lambda { subject.invoke :update, [123], :attributes => attrs }.
+          should raise_error(Flux::TrackerError, /Need an estimate/)
+      end
+    end
+  end
+
+  def iteration(which, data)
+    mock(PivotalTracker::Iteration).__send__(which, fake_project) {
+      OpenStruct.new(:stories => data.map { |d| OpenStruct.new(d) })
+    }
+  end
+
+  def fake_project
+    OpenStruct.new(:id => PROJECT.id)
+  end
+
+  def fake_story(id)
+    PivotalTracker::Story.new(:id => id, :project_id => PROJECT.id)
+  end
+
+  def mock_find(story_id)
+    fake_story(story_id).tap { |s|
+      mock(PivotalTracker::Story).find(story_id, PROJECT.id) { s }
+    }
+  end
+
+  def mock_update(story_id, attrs)
+    mock_find(story_id).tap { |s| mock(s).update(attrs) }
+  end
+
+  def prepare_myself
+    mock(PivotalTracker::Membership).all(fake_project) {
+      [OpenStruct.new(:name => 'David Leal', :email => 'david@mojotech.com')]
+    }
+  end
+end

data/spec/flux/util/table_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Flux::Util::Table do
+  let(:body) {
+    [[123, 'unstarted', 'David Leal', 'First story'],
+     [456, 'unscheduled', '', 'Second story']]
+  }
+
+  it "is converted to a string" do
+    t = Flux::Util::Table.new(Thor::Shell::Basic.new,
+                              [%w(ID STATE ASSIGNEE STORY)] + body,
+                              '  ',
+                              nil)
+
+    t.to_s.should == <<EOT
+ID   STATE        ASSIGNEE    STORY
+123  unstarted    David Leal  First story
+456  unscheduled              Second story
+EOT
+  end
+
+  it "aligns its columns to the right" do
+    t = Flux::Util::Table.new(Thor::Shell::Basic.new,
+                              [%w(>ID >STATE >ASSIGNEE >STORY)] + body,
+                              '  ',
+                              nil)
+
+    t.to_s.should == <<EOT
+ ID        STATE    ASSIGNEE         STORY
+123    unstarted  David Leal   First story
+456  unscheduled              Second story
+EOT
+  end
+
+  it "truncates lines to a given width" do
+    t = Flux::Util::Table.new(Thor::Shell::Basic.new,
+                              [%w(ID STATE ASSIGNEE STORY)] + body,
+                              '  ',
+                              7)
+
+    t.to_s.should == <<EOT
+ID  ...
+123 ...
+456 ...
+EOT
+  end
+end

data/spec/flux_spec.rb

@@ -0,0 +1,43 @@
+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) }
+
+    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'}}
+      }
+
+      Flux.setup.should ==
+        {'trackers'   => {'project_id' => 123, 'token' => 'mytoken'},
+         'workflow'  => 'mojotech'}
+    end
+
+    it "instantiates an adapter" do
+      mock(YAML).load_file(flux_env) {
+        {'trackers' => {'adapter' => 'pivotal_tracker'}}
+      }
+
+      Flux.setup
+
+      defined?(Flux::Trackers::PivotalTracker).should be_true
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'flux'
+
+PROJECT = OpenStruct.new(:id => 1, :token => 'tok')
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.mock_with :rr
+end

data/spec/support/matchers/print_table.rb

@@ -0,0 +1,46 @@
+RSpec::Matchers.define :print_table do |data|
+  class FakeStdout
+    attr_reader :table
+
+    def initialize(stdout)
+      @stdout = stdout
+    end
+
+    def puts(*args)
+      case args.first
+      when Flux::Util::Table
+        @table = args.first
+      else
+        @stdout.puts *args
+      end
+    end
+
+    def write(data)
+      @stdout.write data
+    end
+  end
+
+
+  match do |block|
+    stdout  = $stdout
+    $stdout = @stdout = FakeStdout.new(stdout)
+
+    begin
+      block.call
+
+      @stdout.table.should_not be_nil
+      @stdout.table.data.should == data
+    ensure
+      $stdout = stdout
+    end
+  end
+
+  failure_message_for_should do |block|
+    "Expected table:\n\n#{Flux::Util::Table.new(data, '  ', nil)}\n" <<
+      "but got:\n\n#{@stdout.table ? @stdout.table : 'nil'}"
+  end
+
+  failure_message_for_should_not do |block|
+    raise NotImplementedError
+  end
+end

data/spec/support/rr.rb

@@ -0,0 +1,8 @@
+require 'rr'
+
+module RR::Adapters::RRMethods
+  def observe(&block)
+    RR::WildcardMatchers::Satisfy.new(block)
+  end
+end
+

metadata

@@ -0,0 +1,167 @@
+--- !ruby/object:Gem::Specification 
+name: flux
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- David Leal
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-05 00:00:00 +01:00
+default_executable: flux
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thor
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.14.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: pivotal-tracker
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: grit
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.4.0
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.0"
+  type: :development
+  prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.6.2
+  type: :development
+  prerelease: false
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: rr
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *id008
+description: 
+email: david@mojotech.com
+executables: 
+- flux
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+files: 
+- .document
+- .flux
+- .flux.local.sample
+- .rspec
+- Gemfile
+- LICENSE.txt
+- Rakefile
+- VERSION
+- bin/flux
+- lib/flux.rb
+- lib/flux/ext/pivotal-tracker.rb
+- lib/flux/rcs/git.rb
+- lib/flux/trackers/pivotal_tracker.rb
+- lib/flux/util.rb
+- lib/flux/util/table.rb
+- lib/flux/workflows/mojotech.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
+has_rdoc: true
+homepage: http://github.com/mojotech/flux
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 692717009
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Command line workflow manager.
+test_files: []
+