schlick-pickler 0.0.6.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Tim Pope
+
+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/README.rdoc

@@ -0,0 +1,62 @@
+= Pickler
+
+Synchronize user stories in Pivotal Tracker with Cucumber features.
+
+If you aren't using Cucumber, you can still use pickler as a Pivotal Tracker
+command line client, provided you humor it with a features/ directory
+containing a tracker.yml file.
+
+== Getting started
+
+  gem install tpope-pickler --source=http://gems.github.com
+  echo "api_token: ..."  > ~/.tracker.yml
+  echo "project_id: ..." > ~/my/app/features/tracker.yml
+  echo "ssl: [true|false]" >> ~/my/app/features/tracker.yml
+  pickler --help
+
+"ssl" defaults to false if not configured in the yml file.
+
+For details about the Pivotal Tracker API, including where to find your API
+token and project id, see http://www.pivotaltracker.com/help/api .
+
+The pull and push commands map the story's name into the "Feature: ..." line
+and the story's description with an additional two space indent into the
+feature's body.  Keep this in mind when entering stories into Pivotal Tracker.
+
+== Usage
+
+  pickler pull
+
+Download all well formed stories to the features/ directory.
+
+  pickler push
+
+Upload all features with a tracker url in a comment on the first line.
+
+  pickler search <query>
+
+List all stories matching the given query.
+
+  pickler start <story>
+
+Pull a given feature and change its state to started.
+
+  pickler finish <story>
+
+Push a given feature and change its state to finished.
+
+  pickler --help
+
+Full list of commands.
+
+  pickler <command> --help
+
+Further help for a given command.
+
+== Disclaimer
+
+No warranties, expressed or implied.
+
+Notably, the push and pull commands are quite happy to blindly clobber
+features if so instructed.  Pivotal Tracker has a history to recover things
+server side.

data/bin/pickler

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.join(File.dirname(File.dirname(__FILE__)),'lib'))
+begin; require 'rubygems'; rescue LoadError; end
+require 'pickler'
+
+Pickler.run(ARGV)

data/lib/pickler.rb

@@ -0,0 +1,136 @@
+require 'yaml'
+
+class Pickler
+
+  class Error < RuntimeError
+  end
+
+  autoload :Runner,  'pickler/runner'
+  autoload :Feature, 'pickler/feature'
+  autoload :Tracker, 'pickler/tracker'
+
+  def self.config
+    @config ||= {'api_token' => ENV["TRACKER_API_TOKEN"]}.merge(
+      if File.exist?(path = File.expand_path('~/.tracker.yml'))
+        YAML.load_file(path)
+      end || {}
+    )
+  end
+
+  def self.run(argv)
+    Runner.new(argv).run
+  end
+
+  attr_reader :directory
+
+  def initialize(path = '.')
+    @lang = 'en'
+    @directory = File.expand_path(path)
+    until File.directory?(File.join(@directory,'features'))
+      if @directory == File.dirname(@directory)
+        raise Error, 'Project not found.  Make sure you have a features/ directory.', caller
+      end
+      @directory = File.dirname(@directory)
+    end
+  end
+
+  def features_path(*subdirs)
+    File.join(@directory,'features',*subdirs)
+  end
+
+  def config_file
+    features_path('tracker.yml')
+  end
+
+  def config
+    @config ||= File.exist?(config_file) && YAML.load_file(config_file) || {}
+    self.class.config.merge(@config)
+  end
+
+  def real_name
+    config["real_name"] || (require 'etc'; Etc.getpwuid.gecos.split(',').first)
+  end
+
+  def new_story(attributes = {}, &block)
+    attributes = attributes.inject('requested_by' => real_name) do |h,(k,v)|
+      h.update(k.to_s => v)
+    end
+    project.new_story(attributes, &block)
+  end
+
+  def stories(*args)
+    project.stories(*args)
+  end
+
+  def name
+    project.name
+  end
+
+  def iteration_length
+    project.iteration_length
+  end
+
+  def point_scale
+    project.point_scale
+  end
+
+  def week_start_day
+    project.week_start_day
+  end
+
+  def deliver_all_finished_stories
+    project.deliver_all_finished_stories
+  end
+
+  def parser
+    require 'cucumber'
+    require "cucumber/treetop_parser/feature_#@lang"
+    Cucumber.load_language(@lang)
+    @parser ||= Cucumber::TreetopParser::FeatureParser.new
+  end
+
+  def project_id
+    config["project_id"] || (self.class.config["projects"]||{})[File.basename(@directory)]
+  end
+
+  def project
+    @project ||= Dir.chdir(@directory) do
+      unless token = config['api_token']
+        raise Error, 'echo api_token: ... > ~/.tracker.yml'
+      end
+      unless id = project_id
+        raise Error, 'echo project_id: ... > features/tracker.yml'
+      end
+      ssl = config['ssl']
+      Tracker.new(token, ssl).project(id)
+    end
+  end
+
+  def scenario_word
+    parser
+    Cucumber.language['scenario']
+  end
+
+  def local_features
+    Dir[features_path('**','*.feature')].map {|f|feature(f)}.select {|f|f.id}
+  end
+
+  def scenario_features
+    project.stories(scenario_word, :includedone => true).reject do |s|
+      %(unscheduled unstarted).include?(s.current_state)
+    end.select do |s|
+      s.to_s =~ /^\s*#{Regexp.escape(scenario_word)}:/ && parser.parse(s.to_s)
+    end
+  end
+
+  def feature(string)
+    string.kind_of?(Feature) ? string : Feature.new(self,string)
+  end
+
+  def story(string)
+    feature(string).story
+  end
+
+  protected
+
+end

data/lib/pickler/feature.rb

@@ -0,0 +1,95 @@
+class Pickler
+  class Feature
+    URL_REGEX = %r{\bhttp://www\.pivotaltracker\.com/\S*/(\d+)\b}
+    attr_reader :pickler
+
+    def initialize(pickler, identifier)
+      @pickler = pickler
+      case identifier
+      when nil, /^\s+$/
+        raise Error, "No feature given"
+
+      when Pickler::Tracker::Story
+        @story = identifier
+        @id = @story.id
+
+      when Integer
+        @id = identifier
+
+      when /^#{URL_REGEX}$/, /^(\d+)$/
+        @id = $1.to_i
+
+      when /\.feature$/
+        if File.exist?(identifier)
+          @filename = identifier
+        end
+
+      else
+        if File.exist?(path = pickler.features_path("#{identifier}.feature"))
+          @filename = path
+        end
+
+      end or raise Error, "Unrecogizable feature #{identifier}"
+    end
+
+    def local_body
+      File.read(filename) if filename
+    end
+
+    def filename
+      unless defined?(@filename)
+        @filename = Dir[pickler.features_path("**","*.feature")].detect do |f|
+          File.read(f)[/#\s*#{URL_REGEX}/,1].to_i == @id
+        end
+      end
+      @filename
+    end
+
+    def to_s
+      local_body || story.to_s
+    end
+
+    def pull(default = nil)
+      filename = filename() || pickler.features_path("#{default||id}.feature")
+      File.open(filename,'w') {|f| f.puts story}
+      @filename = filename
+    end
+
+    def start(default = nil)
+      story.transition!("started") if story.startable?
+      if filename || default
+        pull(default)
+      end
+    end
+
+    def push
+      return if story.to_s == local_body.to_s
+      story.to_s = local_body
+      story.save
+    end
+
+    def finish
+      if filename
+        story.finish
+        story.to_s = local_body
+        story.save
+      else
+        story.finish!
+      end
+    end
+
+    def id
+      unless defined?(@id)
+        @id = if id = local_body.to_s[/#\s*#{URL_REGEX}/,1]
+                id.to_i
+              end
+      end
+      @id
+    end
+
+    def story
+      @story ||= @pickler.project.story(id) if id
+    end
+
+  end
+end

data/lib/pickler/runner.rb

@@ -0,0 +1,502 @@
+require 'optparse'
+
+class Pickler
+  class Runner
+
+    class Base
+      attr_reader :argv
+
+      def initialize(argv)
+        @argv = argv
+        @tty = $stdout.tty?
+        @opts = OptionParser.new
+        @opts.version = "0.0"
+        @opts.banner = "Usage: pickler #{self.class.command_name} #{self.class.banner_arguments}"
+        @opts.base.long["help"] = OptionParser::Switch::NoArgument.new do
+          help = @opts.help.chomp.chomp + "\n"
+          help += "\n#{self.class.description}" if self.class.description
+          puts help
+          @exit = 0
+        end
+        @opts.separator("")
+      end
+
+      def self.options
+        @options ||= []
+      end
+
+      def self.on(*args, &block)
+        options << args
+        define_method("option_#{args.object_id}", &block)
+      end
+
+      def self.banner_arguments(value = nil)
+        if value
+          @banner_arguments = value
+        else
+          @banner_arguments || (arity.zero? ? "" : "...")
+        end
+      end
+
+      def self.summary(value = nil)
+        if value
+          @summary = value
+        else
+          @summary
+        end
+      end
+
+      def self.description(value = nil)
+        if value
+          @description = value
+        else
+          @description || "#@summary."
+        end
+      end
+
+      def self.command_name
+        name.split('::').last.gsub(/(.)([A-Z])/) {"#$1-#$2"}.downcase
+      end
+
+      def self.method_name
+        command_name.gsub('-','_')
+      end
+
+      def self.process(&block)
+        define_method(:process, &block)
+      end
+
+      def self.arity
+        instance_method(:process).arity
+      end
+
+      def arity
+        self.class.arity
+      end
+
+      def pickler
+        @pickler ||= Pickler.new(Dir.getwd)
+      end
+
+      def abort(message)
+        raise Error, message
+      end
+
+      def too_many
+        abort "too many arguments"
+      end
+
+      def run
+        self.class.options.each do |arguments|
+          @opts.on(*arguments, &method("option_#{arguments.object_id}"))
+        end
+        begin
+          @opts.parse!(@argv)
+        rescue OptionParser::InvalidOption
+          abort $!.message
+        end
+        return @exit if @exit
+        minimum = arity < 0 ? -1 - arity : arity
+        if arity >= 0 && arity < @argv.size
+          too_many
+        elsif minimum > @argv.size
+          abort "not enough arguments"
+        end
+        process(*@argv)
+      end
+
+      def process(*argv)
+        pickler.send(self.class.method_name,*argv)
+      end
+
+      def color?
+        case pickler.config["color"]
+        when "always" then true
+        when "never"  then false
+        else
+          @tty && RUBY_PLATFORM !~ /mswin|mingw/
+        end
+      end
+
+      def colorize(code, string)
+        if color?
+          "\e[#{code}m#{string}\e[00m"
+        else
+          string.to_s
+        end
+      end
+
+      def puts_summary(story)
+        summary = "%6d " % story.id
+        type  = story.estimate || TYPE_SYMBOLS[story.story_type]
+        state = STATE_SYMBOLS[story.current_state]
+        summary << colorize("3#{STATE_COLORS[story.current_state]}", state) << ' '
+        summary << colorize("01;3#{TYPE_COLORS[story.story_type]}", type) << ' '
+        summary << story.name
+        puts summary
+      end
+
+      def puts_full(story)
+        puts colorize("01;3#{TYPE_COLORS[story.story_type]}", story.name)
+        puts "Type:      #{story.story_type}".rstrip
+        if story.story_type == "release"
+          puts "Deadline:  #{story.deadline}".rstrip
+        else
+          puts "Estimate:  #{story.estimate}".rstrip
+        end
+        puts "State:     #{story.current_state}".rstrip
+        puts "Labels:    #{story.labels.join(', ')}".rstrip
+        puts "Requester: #{story.requested_by}".rstrip
+        puts "Owner:     #{story.owned_by}".rstrip
+        puts "URL:       #{story.url}".rstrip
+        puts unless story.description.blank?
+        story.description_lines.each do |line|
+          puts "  #{line}".rstrip
+        end
+        story.notes.each do |note|
+          puts
+          puts "  #{colorize('01', note.author)} (#{note.date})"
+          puts *note.lines(72).map {|l| "    #{l}".rstrip}
+        end
+      end
+
+      def paginated_output
+        stdout = $stdout
+        if @tty && pager = pickler.config["pager"]
+          # Modeled after git
+          ENV["LESS"] ||= "FRSX"
+          IO.popen(pager,"w") do |io|
+            $stdout = io
+            yield
+          end
+        else
+          yield
+        end
+      rescue Errno::EPIPE
+      ensure
+        $stdout = stdout
+      end
+
+    end
+
+    def self.[](command)
+      klass_name = command.to_s.capitalize.gsub(/[-_](.)/) { $1.upcase }
+      if klass_name =~ /^[A-Z]\w*$/ && const_defined?(klass_name)
+        klass = const_get(klass_name)
+        if Class === klass && klass < Base
+          return klass
+        end
+      end
+    end
+
+    def self.commands
+      constants.map {|c| Runner.const_get(c)}.select {|c| Class === c && c < Runner::Base}.sort_by {|r| r.command_name}.uniq
+    end
+
+    def self.command(name, &block)
+      const_set(name.to_s.capitalize.gsub(/[-_](.)/) { $1.upcase },Class.new(Base,&block))
+    end
+
+    command :show do
+      banner_arguments "<story>"
+      summary "Show details for a story"
+
+      process do |*args|
+        case args.size
+        when 0
+          puts "#{pickler.project_id} #{pickler.project.name}"
+        when 1
+          story = pickler.story(args.first)
+          paginated_output do
+            puts_full story
+          end
+        else
+          too_many
+        end
+      end
+    end
+
+    command :search do
+      banner_arguments "[query]"
+      summary "List all stories matching a query"
+
+      def modifications
+        @modifications ||= {}
+      end
+      [:label, :type, :state].each do |o|
+        on "--#{o} #{o.to_s.upcase}" do |value|
+          modifications[o] = value
+        end
+      end
+      [:requester, :owner, :mywork].each do |o|
+        on "--#{o}[=USERNAME]" do |value|
+          modifications[o] = value || pickler.real_name
+        end
+      end
+      on "--[no-]includedone", "include accepted stories" do |value|
+        modifications[:includedone] = value
+        @iterations ||= []
+        @iterations << :done?
+      end
+
+      on "-b", "--backlog", "filter results to future iterations" do |c|
+        @iterations ||= []
+        @iterations << :backlog?
+      end
+
+      on "-c", "--current", "filter results to current iteration" do |b|
+        @iterations ||= []
+        @iterations << :current?
+      end
+
+      on "--[no-]full", "show full story, not a summary line" do |b|
+        @full = b
+      end
+
+      process do |*argv|
+        argv << modifications unless modifications.empty?
+        if argv == [{:includedone => true}]
+          # Bypass the 200 search results limitation
+          stories = pickler.project.stories
+        else
+          stories = pickler.project.stories(*argv)
+        end
+        if @iterations && @iterations != [:done?]
+          stories.reject! {|s| !@iterations.any? {|i| s.send(i)}}
+        end
+        paginated_output do
+          first = true
+          stories.each do |story|
+            if @full
+              puts unless first
+              puts_full story
+            else
+              puts_summary story
+            end
+            first = false
+          end
+        end
+      end
+    end
+
+    command :push do
+      banner_arguments "[story] ..."
+      summary "Upload stories"
+      description <<-EOF
+Upload the given story or all features with a tracker url in a comment on the
+first line.
+      EOF
+
+      process do |*args|
+        args.replace(pickler.local_features) if args.empty?
+        args.each do |arg|
+          pickler.feature(arg).push
+        end
+      end
+    end
+
+    command :pull do
+      banner_arguments "[story] ..."
+      summary "Download stories"
+      description <<-EOF
+Download the given story or all well formed stories to the features/ directory.
+Previously unseen stories will be given a numeric filename that you are
+encouraged to change.
+      EOF
+
+      process do |*args|
+        args.replace(pickler.scenario_features) if args.empty?
+        args.each do |arg|
+          pickler.feature(arg).pull
+        end
+      end
+    end
+
+    command :start do
+      banner_arguments "<story> [basename]"
+      summary "Pull a story and mark it started"
+      description <<-EOF
+Pull a given story and change its state to started.  If basename is given
+and no local file exists, features/basename.feature will be created.
+      EOF
+
+      process do |story, *args|
+        pickler.feature(story).start(args.first)
+      end
+    end
+
+    command :finish do
+      banner_arguments "<story>"
+      summary "Push a story and mark it finished"
+
+      process do |story|
+        pickler.feature(story).finish
+      end
+    end
+
+    command :deliver do
+      banner_arguments "[story] ..."
+      summary "Mark stories delivered"
+      on "--all-finished", "deliver all finished stories" do
+        @all = true
+      end
+      process do |*args|
+        if @all
+          pickler.deliver_all_finished_stories
+        end
+        args.each do |arg|
+          pickler.story(arg).transition!('delivered')
+        end
+      end
+    end
+
+    command :unstart do
+      banner_arguments "[story] ..."
+      summary "Mark stories unstarted"
+      on "--all-started", "unstart all started stories" do
+        @all = true
+      end
+      process do |*args|
+        if @all
+          pickler.project.stories(:state => "started").each do |story|
+            story.transition!('unstarted')
+          end
+        end
+        args.each do |arg|
+          pickler.story(arg).transition!('unstarted')
+        end
+      end
+    end
+
+    command :unschedule do
+      banner_arguments "[story] ..."
+      summary "Move stories to icebox"
+      process do |*args|
+        args.each do |arg|
+          pickler.story(arg).transition!('unscheduled')
+        end
+      end
+    end
+
+    command :browse do
+      banner_arguments "[story]"
+      summary "Open a story in the web browser"
+      description <<-EOF
+Open project or a story in the web browser.
+
+Requires launchy (gem install launchy).
+      EOF
+
+      on "--dashboard" do
+        @special = "dashboard"
+      end
+      on "--faq" do
+        @special = "help"
+      end
+      on "--profile", "get your API Token here" do
+        @special = "profile"
+      end
+      on "--time", "not publicly available" do
+        @special = "time_shifts?project=#{pickler.project_id}"
+      end
+
+      process do |*args|
+        too_many if args.size > 1 || @special && args.first
+        if args.first
+          url = pickler.story(args.first).url
+        elsif @special
+          url = "http://www.pivotaltracker.com/#@special"
+        else
+          url = "http://www.pivotaltracker.com/projects/#{pickler.project_id}/stories"
+        end
+        require 'launchy'
+        Launchy.open(url)
+      end
+    end
+
+    command :comment do
+      banner_arguments "<story> <paragraph> ..."
+      summary "Post a comment to a story"
+
+      process do |story, *paragraphs|
+        pickler.story(story).comment!(paragraphs.join("\n\n"))
+      end
+    end
+
+    def initialize(argv)
+      @argv = argv
+    end
+
+    COLORS = {
+      :black   => 0,
+      :red     => 1,
+      :green   => 2,
+      :yellow  => 3,
+      :blue    => 4,
+      :magenta => 5,
+      :cyan    => 6,
+      :white   => 7
+    }
+
+    STATE_COLORS = {
+      nil           => COLORS[:black],
+      "rejected"    => COLORS[:red],
+      "accepted"    => COLORS[:green],
+      "delivered"   => COLORS[:yellow],
+      "unscheduled" => COLORS[:white],
+      "started"     => COLORS[:magenta],
+      "finished"    => COLORS[:cyan],
+      "unstarted"   => COLORS[:blue]
+    }
+
+    STATE_SYMBOLS = {
+      "unscheduled" => "  ",
+      "unstarted"   => ":|",
+      "started"     => ":/",
+      "finished"    => ":)",
+      "delivered"   => ";)",
+      "rejected"    => ":(",
+      "accepted"    => ":D"
+    }
+
+    TYPE_COLORS = {
+      'chore'   => COLORS[:blue],
+      'feature' => COLORS[:magenta],
+      'bug'     => COLORS[:red],
+      'release' => COLORS[:cyan]
+    }
+
+    TYPE_SYMBOLS = {
+      "feature" => "*",
+      "chore"   => "%",
+      "release" => "!",
+      "bug"     => "/"
+    }
+
+    def run
+      command = @argv.shift
+      if klass = self.class[command]
+        result = klass.new(@argv).run
+        exit result.respond_to?(:to_int) ? result.to_int : 0
+      elsif ['help', '--help', '-h', '', nil].include?(command)
+        puts "usage: pickler <command> [options] [arguments]"
+        puts
+        puts "Commands:"
+        self.class.commands.each do |command|
+          puts "    %-19s %s" % [command.command_name, command.summary]
+        end
+        puts
+        puts "Run pickler <command> --help for help with a given command"
+      else
+        raise Error, "Unknown pickler command #{command}"
+      end
+    rescue Pickler::Error
+      $stderr.puts "#$!"
+      exit 1
+    rescue Interrupt
+      $stderr.puts "Interrupted!"
+      exit 130
+    end
+
+  end
+end

data/lib/pickler/tracker.rb

@@ -0,0 +1,113 @@
+require 'date'
+
+class Pickler
+  class Tracker
+
+    ADDRESS = 'www.pivotaltracker.com'
+    BASE_PATH = '/services/v1'
+    SEARCH_KEYS = %w(label type state requester owner mywork id includedone)
+
+    class Error < Pickler::Error; end
+
+    attr_reader :token
+
+    def initialize(token, ssl = false)
+      require 'active_support/core_ext/blank'
+      require 'active_support/core_ext/hash'
+      @token = token
+      @ssl = ssl
+    end
+
+    def ssl?
+      @ssl
+    end
+
+    def http
+      unless @http
+        if ssl?
+          require 'net/https'
+          @http = Net::HTTP.new(ADDRESS, Net::HTTP.https_default_port)
+          @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          @http.use_ssl = true
+        else
+          require 'net/http'
+          @http = Net::HTTP.new(ADDRESS)
+        end
+      end
+      @http
+    end
+
+    def request(method, path, *args)
+      headers = {
+        "X-TrackerToken" => @token,
+        "Accept"         => "application/xml",
+        "Content-type"   => "application/xml"
+      }
+      klass = Net::HTTP.const_get(method.to_s.capitalize)
+      http.request(klass.new("#{BASE_PATH}#{path}", headers), *args)
+    end
+
+    def request_xml(method, path, *args)
+      response = request(method,path,*args)
+      raise response.inspect if response["Content-type"].split(/; */).first != "application/xml"
+      Hash.from_xml(response.body)["response"]
+    end
+
+    def get_xml(path)
+      response = request_xml(:get, path)
+      unless response["success"] == "true"
+        if response["message"]
+          raise Error, response["message"], caller
+        else
+          raise "#{path}: #{response.inspect}"
+        end
+      end
+      response
+    end
+
+    def project(id)
+      Project.new(self,get_xml("/projects/#{id}")["project"].merge("id" => id.to_i))
+    end
+
+    class Abstract
+      def initialize(attributes = {})
+        @attributes = {}
+        (attributes || {}).each do |k,v|
+          @attributes[k.to_s] = v
+        end
+        yield self if block_given?
+      end
+
+      def self.reader(*methods)
+        methods.each do |method|
+          define_method(method) { @attributes[method.to_s] }
+        end
+      end
+
+      def self.date_reader(*methods)
+        methods.each do |method|
+          define_method(method) { value = @attributes[method.to_s] and Date.parse(value) }
+        end
+      end
+
+      def self.accessor(*methods)
+        reader(*methods)
+        methods.each do |method|
+          define_method("#{method}=") { |v| @attributes[method.to_s] = v }
+        end
+      end
+      reader :id
+
+      def to_xml(options = nil)
+        @attributes.to_xml({:dasherize => false, :root => self.class.name.split('::').last.downcase}.merge(options||{}))
+      end
+
+    end
+
+  end
+end
+
+require 'pickler/tracker/project'
+require 'pickler/tracker/story'
+require 'pickler/tracker/iteration'
+require 'pickler/tracker/note'

data/lib/pickler/tracker/iteration.rb

@@ -0,0 +1,38 @@
+class Pickler
+  class Tracker
+    class Iteration < Abstract
+      attr_reader :project
+      date_reader :start, :finish
+
+      def initialize(project, attributes = {})
+        @project = project
+        super(attributes)
+      end
+
+      def number
+        @attributes['number'].to_i
+      end
+      alias to_i number
+
+      def range
+        start...finish
+      end
+
+      def include?(date)
+        range.include?(date)
+      end
+
+      def succ
+        self.class.new(project, 'number' => number.succ.to_s, 'start' => @attributes['finish'], 'finish' => (finish + (finish - start)).strftime("%b %d, %Y"))
+      end
+
+      def inspect
+        "#<#{self.class.inspect}:#{number.inspect} (#{range.inspect})>"
+      end
+
+      def to_s
+        "#{number} (#{start}...#{finish})"
+      end
+    end
+  end
+end

data/lib/pickler/tracker/note.rb

@@ -0,0 +1,27 @@
+class Pickler
+  class Tracker
+    class Note < Abstract
+      attr_reader :story
+      reader :text, :author
+      date_reader :date
+
+      def initialize(story, attributes = {})
+        @story = story
+        super(attributes)
+      end
+
+      def to_xml
+        @attributes.to_xml(:dasherize => false, :root => 'note')
+      end
+
+      def inspect
+        "#<#{self.class.inspect}:#{id.inspect}, story_id: #{story.id.inspect}, date: #{date.inspect}, author: #{author.inspect}, text: #{text.inspect}>"
+      end
+
+      def lines(width = 79)
+        text.scan(/(?:.{0,#{width}}|\S+?)(?:\s|$)/).map! {|line| line.strip}[0..-2]
+      end
+
+    end
+  end
+end

data/lib/pickler/tracker/project.rb

@@ -0,0 +1,47 @@
+class Pickler
+  class Tracker
+    class Project < Abstract
+
+      attr_reader :tracker
+      reader :point_scale, :week_start_day, :name, :iteration_length
+
+      def initialize(tracker, attributes = {})
+        @tracker = tracker
+        super(attributes)
+      end
+
+      def story(story_id)
+        raise Error, "No story id given" if story_id.to_s.empty?
+        Story.new(self,tracker.get_xml("/projects/#{id}/stories/#{story_id}")["story"])
+      end
+
+      def stories(*args)
+        filter = encode_term(args) if args.any?
+        path = "/projects/#{id}/stories"
+        path << "?filter=#{CGI.escape(filter)}" if filter
+        response = tracker.get_xml(path)
+        [response["stories"]["story"]].flatten.compact.map {|s| Story.new(self,s)}
+      end
+
+      def new_story(attributes = {}, &block)
+        Story.new(self, attributes, &block)
+      end
+
+      def deliver_all_finished_stories
+        request_xml(:put,"/projects/#{id}/stories_deliver_all_finished")
+      end
+
+      private
+      def encode_term(term)
+        case term
+        when Array   then term.map {|v| encode_term(v)}.join(" ")
+        when Hash    then term.map {|k,v| encode_term("#{k}:#{v}")}.join(" ")
+        when /^\S+$/, Symbol then term
+        when /^(\S+?):(.*)$/ then %{#$1:"#$2"}
+        else %{"#{term}"}
+        end
+      end
+
+    end
+  end
+end

data/lib/pickler/tracker/story.rb

@@ -0,0 +1,166 @@
+class Pickler
+  class Tracker
+    class Story < Abstract
+
+      TYPES = %w(bug feature chore release)
+      STATES = %w(unscheduled unstarted started finished delivered rejected accepted)
+
+      attr_reader :project, :iteration, :labels
+      reader :url
+      date_reader :created_at, :accepted_at, :deadline
+      accessor :current_state, :name, :description, :owned_by, :requested_by, :story_type
+
+      def initialize(project, attributes = {})
+        @project = project
+        super(attributes)
+        @iteration = Iteration.new(project, @attributes["iteration"]) if @attributes["iteration"]
+        @labels = normalize_labels(@attributes["labels"])
+      end
+
+      def labels=(value)
+        @labels = normalize_labels(value)
+      end
+
+      def transition!(state)
+        raise Pickler::Tracker::Error, "Invalid state #{state}", caller unless STATES.include?(state)
+        self.current_state = state
+        if id
+          xml = "<story><current_state>#{state}</current_state></story>"
+          error = tracker.request_xml(:put, resource_url, xml).fetch("errors",{})["error"] || true
+        else
+          error = save
+        end
+        raise Pickler::Tracker::Error, Array(error).join("\n"), caller unless error == true
+      end
+
+      def finish
+        case story_type
+        when "bug", "feature"
+          self.current_state = "finished" unless complete?
+        when "chore", "release"
+          self.current_state = "accepted"
+        end
+        current_state
+      end
+
+      def finish!
+        transition!(finish)
+      end
+
+      def backlog?(as_of = Date.today)
+        iteration && iteration.start >= as_of
+      end
+
+      def current?(as_of = Date.today)
+        iteration && iteration.include?(as_of)
+      end
+
+      # In a previous iteration
+      def done?(as_of = Date.today)
+        iteration && iteration.finish <= as_of
+      end
+
+      def complete?
+        %w(finished delivered accepted).include?(current_state)
+      end
+
+      def startable?
+        %w(unscheduled unstarted rejected).include?(current_state)
+      end
+
+      def tracker
+        project.tracker
+      end
+
+      def to_s
+        to_s = "# #{url}\n#{story_type.capitalize}: #{name}\n"
+        description_lines.each do |line|
+          to_s << "  #{line}".rstrip << "\n"
+        end
+        to_s
+      end
+
+      def to_s=(body)
+        body = body.sub(/\A# .*\n/,'')
+        if body =~ /\A(\w+): (.*)/
+          self.story_type = $1.downcase
+          self.name = $2
+          description = $'
+        else
+          self.story_type = "feature"
+          self.name = body[/.*/]
+          description = $'
+        end
+        self.description = description.gsub(/\A\n+|\n+\Z/,'') + "\n"
+        if description_lines.all? {|l| l.empty? || l =~ /^  /}
+          self.description.gsub!(/^  /,'')
+        end
+        self
+      end
+
+      def description_lines
+        array = []
+        description.to_s.each_line do |line|
+          array << line.chomp
+        end
+        array
+      end
+
+      def notes
+        [@attributes["notes"]].flatten.compact.map {|n| Note.new(self,n)}
+      end
+
+      def estimate
+        @attributes["estimate"].to_i < 0 ? nil : @attributes["estimate"]
+      end
+
+      def comment!(body)
+        response = tracker.request_xml(:post, "#{resource_url}/notes",{:text => body}.to_xml(:dasherize => false, :root => 'note'))
+        if response["note"]
+          Note.new(self, response["note"])
+        else
+          raise Pickler::Tracker::Error, Array(response["errors"]["error"]).join("\n"), caller
+        end
+      end
+
+      def to_xml(force_labels = true)
+        hash = @attributes.reject do |k,v|
+          !%w(current_state deadline description estimate name owned_by requested_by story_type).include?(k)
+        end
+        if force_labels || !id || normalize_labels(@attributes["labels"]) != labels
+          hash["labels"] = labels.join(", ")
+        end
+        hash.to_xml(:dasherize => false, :root => "story")
+      end
+
+      def destroy
+        if id
+          response = tracker.request_xml(:delete, "/projects/#{project.id}/stories/#{id}", "")
+          raise Error, response["message"], caller if response["success"] != "true"
+          @attributes["id"] = nil
+          self
+        end
+      end
+
+      def resource_url
+        ["/projects/#{project.id}/stories",id].compact.join("/")
+      end
+
+      def save
+        response = tracker.request_xml(id ? :put : :post,  resource_url, to_xml(false))
+        if response["success"] == "true"
+          initialize(project, response["story"])
+          true
+        else
+          Array(response["errors"]["error"])
+        end
+      end
+
+      private
+      def normalize_labels(value)
+        Array(value).join(", ").strip.split(/\s*,\s*/)
+      end
+
+    end
+  end
+end

data/pickler.gemspec

@@ -0,0 +1,30 @@
+Gem::Specification.new do |s|
+  s.name                = "pickler"
+  s.version             = "0.0.6.1"
+
+  s.summary             = "PIvotal traCKer Liaison to cucumbER"
+  s.description         = "Synchronize between Cucumber and Pivotal Tracker"
+  s.authors             = ["Tim Pope"]
+  s.email               = "ruby@tpope.i"+'nfo'
+  s.homepage            = "http://github.com/tpope/pickler"
+  s.default_executable  = "pickler"
+  s.executables         = ["pickler"]
+  s.files               = [
+    "README.rdoc",
+    "MIT-LICENSE",
+    "pickler.gemspec",
+    "bin/pickler",
+    "lib/pickler.rb",
+    "lib/pickler/feature.rb",
+    "lib/pickler/runner.rb",
+    "lib/pickler/tracker.rb",
+    "lib/pickler/tracker/project.rb",
+    "lib/pickler/tracker/story.rb",
+    "lib/pickler/tracker/iteration.rb",
+    "lib/pickler/tracker/note.rb"
+  ]
+  s.add_dependency("activesupport", [">= 2.0.0"])
+  s.add_dependency("cucumber", [">= 0.1.9"])
+  s.add_dependency("builder")
+  s.add_dependency("xml-simple")
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification 
+name: schlick-pickler
+version: !ruby/object:Gem::Version 
+  version: 0.0.6.1
+platform: ruby
+authors: 
+- Tim Pope
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-11 00:00:00 -08:00
+default_executable: pickler
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.9
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: builder
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: xml-simple
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Synchronize between Cucumber and Pivotal Tracker
+email: ruby@tpope.info
+executables: 
+- pickler
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.rdoc
+- MIT-LICENSE
+- pickler.gemspec
+- bin/pickler
+- lib/pickler.rb
+- lib/pickler/feature.rb
+- lib/pickler/runner.rb
+- lib/pickler/tracker.rb
+- lib/pickler/tracker/project.rb
+- lib/pickler/tracker/story.rb
+- lib/pickler/tracker/iteration.rb
+- lib/pickler/tracker/note.rb
+has_rdoc: false
+homepage: http://github.com/tpope/pickler
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: PIvotal traCKer Liaison to cucumbER
+test_files: []
+