ssp-pickler 0.1.4

data/lib/pickler/tracker.rb

@@ -0,0 +1,120 @@
+require 'date'
+require 'cgi'
+
+class Pickler
+  class Tracker
+
+    ADDRESS = 'www.pivotaltracker.com'
+    BASE_PATH = '/services/v3'
+    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'
+      @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"
+      }
+      http # trigger require of 'net/http'
+      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 = Hash.from_xml(response.body)
+      if hash["message"] && (response.code.to_i >= 400 || hash["success"] == "false")
+        raise Error, hash["message"], caller
+      end
+      hash
+    end
+
+    def get_xml(path)
+      request_xml(:get, path)
+    end
+
+    def project(id)
+      Project.new(self,get_xml("/projects/#{id}")["project"])
+    end
+
+    class Abstract
+      def initialize(attributes = {})
+        @attributes = {}
+        (attributes || {}).each do |k,v|
+          if respond_to?("#{k}=")
+            send("#{k}=", v)
+          else
+            @attributes[k.to_s] = v
+          end
+        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) do
+            value = @attributes[method.to_s]
+            value.kind_of?(String) ? Date.parse(value) : value
+          end
+        end
+      end
+
+      def self.accessor(*methods)
+        reader(*methods)
+        methods.each do |method|
+          define_method("#{method}=") { |v| @attributes[method.to_s] = v }
+        end
+      end
+
+      def id
+        id = @attributes['id'] and Integer(id)
+      end
+
+      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,45 @@
+class Pickler
+  class Tracker
+    class Iteration < Abstract
+      attr_reader :project
+
+      def initialize(project, attributes = {})
+        @project = project
+        super(attributes)
+      end
+
+      def start
+        Date.parse(@attributes['start'].to_s)
+      end
+
+      def finish
+        Date.parse(@attributes['finish'].to_s)
+      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)))
+      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,31 @@
+class Pickler
+  class Tracker
+    class Note < Abstract
+      attr_reader :story
+      reader :text, :author
+      date_reader :noted_at
+
+      def date
+        noted_at && Date.new(noted_at.year, noted_at.mon, noted_at.day)
+      end
+
+      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,51 @@
+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 use_https?
+        @attributes['use_https'].to_s == 'true'
+      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"]].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,208 @@
+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, :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
+        @labels = []
+        super(attributes)
+        @iteration = Iteration.new(project, @attributes["iteration"]) if @attributes["iteration"]
+      end
+
+      def iteration
+        unless current_state == 'unscheduled' || defined?(@iteration)
+          @iteration = project.stories(:id => id, :includedone => true).first.iteration
+        end
+        @iteration
+      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(format = :tag)
+        to_s = "#{header(format)}\n#{story_type.capitalize}: #{name}\n"
+        description_lines.each do |line|
+          to_s << "  #{line}".rstrip << "\n"
+        end
+        if to_s !~ /\A[\0-\177]*\z/
+          to_s = "# -*- coding: utf-8 -*-\n#{to_s}"
+        end
+        to_s
+      end
+
+      def header(format = :tag)
+        case format
+        when :tag
+          "@#{url || "#{project.use_https? ? 'https' : 'http'}://www.pivotaltracker.com/story/new"}#{labels.map {|l| " @#{l.tr(' _','_,')}"}.join}"
+        else
+          "# #{url}"
+        end
+      end
+
+      def to_s=(body)
+        if body =~ /\A@https?\b\S*(\s+@\S+)*\s*$/
+          self.labels = body[/\A@.*/].split(/\s+/)[1..-1].map {|l| l[1..-1].tr('_,',' _')}
+        end
+        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 estimate=(value)
+        @attributes["estimate"] = value.nil? ? -1 : value
+      end
+
+      def suggested_basename(user_override = nil)
+        if user_override.to_s !~ /\A-?\z/
+          user_override
+        else
+          name.to_s.empty? ? id.to_s : name.gsub(/[^\w-]+/,'_').downcase
+        end
+      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["message"]
+          @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["story"]
+          initialize(project, response["story"])
+          true
+        else
+          Array(response["errors"]["error"])
+        end
+      end
+
+      def save!
+        errors = save
+        if errors != true
+          raise Pickler::Tracker::Error, Array(errors).join("\n"), caller
+        end
+        self
+      end
+
+      private
+      def normalize_labels(value)
+        Array(value).join(", ").strip.split(/\s*,\s*/)
+      end
+
+    end
+  end
+end