whistle 0.1

data/vendor/rscm-0.5.1-patched-stripped/lib/rscm/scm/subversion_log_parser.rb

@@ -0,0 +1,165 @@
+require 'rscm/parser'
+require 'rscm/revision'
+require 'rscm/revisions'
+require 'rscm/revision_file'
+require 'time'
+
+module RSCM
+
+  class SubversionLogParser
+    def initialize(io, url, exclude_below_and_including=nil, exclude_above_and_including=nil, path=nil)
+      @io = io
+      @revision_parser = SubversionLogEntryParser.new(url, path)
+      @exclude_below_and_including = exclude_below_and_including
+      @exclude_above_and_including = exclude_above_and_including
+    end
+    
+    def parse_revisions(&line_proc)
+      # skip over the first ------
+      @revision_parser.parse(@io, true, &line_proc)
+      revisions = Revisions.new
+      while(!@io.eof?)
+        revision = @revision_parser.parse(@io, &line_proc)
+        unless(revision.nil?)
+          # Filter out the lower bound to avoid inclusiveness of the lower bound (see contract)
+          # We're doing this instead of increasing the from_identifer with 1, since that causes an error.
+          too_low = false
+          too_high = false
+          next if revision.time.nil?
+          if(@exclude_below_and_including.is_a? Time)
+            too_low = revision.time <= @exclude_below_and_including
+          elsif(@exclude_below_and_including.is_a? Numeric)
+            too_low = revision.identifier <= @exclude_below_and_including
+          end
+
+          if(@exclude_above_and_including.is_a? Time)
+            too_high = revision.time >= @exclude_above_and_including
+          elsif(@exclude_above_and_including.is_a? Numeric)
+            too_high = revision.identifier >= @exclude_above_and_including
+          end
+          revisions.add(revision) unless too_low || too_high
+        end
+      end
+      revisions
+    end
+  end
+  
+  class SubversionLogEntryParser < Parser
+
+    def initialize(url, path=nil)
+      super(/^------------------------------------------------------------------------/)
+      @url = url
+      @path = path
+    end
+
+    def parse(io, skip_line_parsing=false, &line_proc)
+      # We have to trim off the last newline - it's not meant to be part of the message
+      revision = super
+      revision.message = revision.message[0..-2] if revision
+      revision
+    end
+
+    def relative_path(url, path_from_root)
+      path_from_root = path_from_root.chomp
+      url_tokens = url.split('/')
+      path_from_root_tokens = path_from_root.split('/')
+      
+      max_similar = path_from_root_tokens.length
+      while(max_similar > 0)
+        url = url_tokens[-max_similar..-1]
+        path = path_from_root_tokens[0..max_similar-1]
+        if(url == path)
+          break
+        end
+        max_similar -= 1
+      end
+
+      if(max_similar == 0) 
+        if(@path.nil? || @path == "")
+          path_from_root
+        else
+          nil
+        end
+      else
+        path_from_root_tokens[max_similar..-1].join("/")
+      end
+    end
+    
+  protected
+
+    def parse_line(line)
+      if(@revision.nil?)
+        parse_header(line)
+      elsif(line.strip == "")
+        @parse_state = :parse_message
+      elsif(line =~ /Changed paths/)
+        @parse_state = :parse_files
+      elsif(@parse_state == :parse_files)
+        file = parse_file(line)
+        if(file && file.path)
+          previously_added_file = @revision[-1]
+          if(previously_added_file)
+            # remove previous revision_file if it's a dir
+            previous_tokens = previously_added_file.path.split("/")
+            current_tokens = file.path.split("/")
+            current_tokens.pop
+            if(previous_tokens == current_tokens)
+              @revision.pop
+            end
+          end
+          @revision.add file
+        end
+      elsif(@parse_state == :parse_message)
+        @revision.message << line.chomp << "\n"
+      end
+    end
+
+    def next_result
+      result = @revision
+      @revision = nil
+      result
+    end
+
+  private
+  
+    STATES = {"M" => RevisionFile::MODIFIED, "A" => RevisionFile::ADDED, "D" => RevisionFile::DELETED} unless defined? STATES
+
+    def parse_header(line)
+      @revision = Revision.new
+      @revision.message = ""
+      revision, developer, time, the_rest = line.split("|")
+      @revision.identifier = revision.strip[1..-1].to_i unless revision.nil?
+      developer.strip!
+      @revision.developer = developer unless developer.nil? || developer == "(no author)"
+      time.strip!
+      @revision.time = Time.parse(time).utc unless time.nil? || time == "(no date)"
+    end
+    
+    def parse_file(line)
+      file = RevisionFile.new
+      path_from_root = nil
+      if(line =~ /^   [M|A|D|R] ([^\s]+) \(from (.*)\)/)
+        path_from_root = $1
+        file.status = RevisionFile::MOVED
+      elsif(line =~ /^   ([M|A|D|R]) (.+)$/)
+        status = $1
+        path_from_root = $2
+        file.status = STATES[status]
+      else
+        raise "could not parse file line: '#{line}'"
+      end
+
+      path_from_root.gsub!(/\\/, "/")
+      path_from_root = path_from_root[1..-1]
+      rp = relative_path(@url, path_from_root)
+      return if rp.nil?
+      
+      file.path = rp
+      file.native_revision_identifier =  @revision.identifier
+      # http://jira.codehaus.org/browse/DC-204
+      file.previous_native_revision_identifier = file.native_revision_identifier.to_i - 1;
+      file
+    end
+  end
+
+end

data/vendor/rscm-0.5.1-patched-stripped/lib/rscm/tempdir.rb

@@ -0,0 +1,17 @@
+require 'fileutils'
+
+module RSCM
+
+  def method_name
+    /\`([^\']+)\'/.match(caller.first)[1]
+  end
+
+  def new_temp_dir(suffix="", basedir=File.dirname(__FILE__) + "/../../target")
+    identifier = identifier.to_s
+    identifier.gsub!(/\(|:|\)/, '_')
+    dir = "#{basedir}/temp_#{identifier}_#{Time.new.to_i}#{suffix}"
+    FileUtils.mkdir_p(dir)
+    dir
+  end
+  module_function :new_temp_dir
+end

data/vendor/rscm-0.5.1-patched-stripped/lib/rscm/time_ext.rb

@@ -0,0 +1,11 @@
+class Time
+  class << self
+    def epoch
+      Time.utc(1972)
+    end
+
+    def infinity
+      Time.utc(2036)
+    end
+  end
+end

data/vendor/rscm-0.5.1-patched-stripped/lib/rscm/version.rb

@@ -0,0 +1,13 @@
+module RSCM
+  module VERSION
+    MAJOR = 0
+    MINOR = 5
+    TINY  = 1
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+
+    NAME = "RSCM"
+    FULLNAME = "Ruby Source Control Management"
+    URL = "http://rscm.rubyforge.org/"  
+  end
+end

data/vendor/ruby-feedparser-0.5-stripped/README

@@ -0,0 +1,14 @@
+ Ruby-Feedparser 
+-----------------
+by Lucas Nussbaum <lucas@lucas-nussbaum.net>
+
+Currently, all the information is provided on
+
+       http://home.gna.org/ruby-feedparser/
+
+If you need to ask questions, feel free to ask them on the
+ruby-feedparser-devel@gna.org mailing list.
+
+Ruby-Feedparser is released under the Ruby license (see the LICENSE file),
+which is compatible with the GNU GPL (see the COPYING file) via an explicit
+dual-licensing clause.

data/vendor/ruby-feedparser-0.5-stripped/lib/feedparser.rb

@@ -0,0 +1,28 @@
+# =Ruby-feedparser - ATOM/RSS feed parser for Ruby
+# License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
+# Website::http://home.gna.org/ruby-feedparser/
+#
+# ==Introduction
+#
+# Ruby-Feedparser is an RSS and Atom parser for Ruby.
+# Ruby-feedparser is :
+# * based on REXML
+# * built for robustness : most feeds are not valid, a parser can't ignore that
+# * fully unit-tested
+# * easy to use (it can output text or HTML easily)
+#
+# ==Example
+#  require 'net/http'
+#  require 'feedparser'
+#  require 'uri'
+#  s = Net::HTTP::get URI::parse('http://rss.slashdot.org/Slashdot/slashdot')
+#  f = FeedParser::Feed::new(s)
+#  f.title
+#  => "Slashdot"
+#  f.items.each { |i| puts i.title }
+#  [...]
+#  require 'feedparser/html-output'
+#  f.items.each { |i| puts i.to_html }
+#
+
+require 'feedparser/feedparser'

data/vendor/ruby-feedparser-0.5-stripped/lib/feedparser/feedparser.rb

@@ -0,0 +1,300 @@
+require 'rexml/document'
+require 'time'
+require 'feedparser/textconverters'
+require 'feedparser/rexml_patch'
+require 'feedparser/text-output'
+require 'base64'
+
+module FeedParser
+
+  VERSION = "0.5"
+
+  class UnknownFeedTypeException < RuntimeError
+  end
+
+  # an RSS/Atom feed
+  class Feed
+    attr_reader :type, :title, :link, :description, :creator, :encoding, :items
+
+    # REXML::Element for this feed.
+    attr_reader :xml
+
+    # parse str to build a Feed
+    def initialize(str = nil)
+      parse(str) if str
+    end
+
+    # Determines all the fields using a string containing an
+    # XML document
+    def parse(str)
+      # Dirty hack: some feeds contain the & char. It must be changed to &amp;
+      str.gsub!(/&(\s+)/, '&amp;\1')
+      doc = REXML::Document.new(str)
+      @xml = doc.root
+      # get feed info
+      @encoding = doc.encoding
+      @title,@link,@description,@creator = nil
+      @items = []
+      if doc.root.elements['channel'] || doc.root.elements['rss:channel']
+        @type = "rss"
+        # We have a RSS feed!
+        # Title
+        if (e = doc.root.elements['channel/title'] ||
+          doc.root.elements['rss:channel/rss:title']) && e.text
+          @title = e.text.unescape_html.toUTF8(@encoding).rmWhiteSpace!
+        end
+        # Link
+        if (e = doc.root.elements['channel/link'] ||
+            doc.root.elements['rss:channel/rss:link']) && e.text
+          @link = e.text.rmWhiteSpace!
+        end
+        # Description
+        if (e = doc.root.elements['channel/description'] || 
+            doc.root.elements['rss:channel/rss:description']) && e.text
+          @description = e.text.toUTF8(@encoding).rmWhiteSpace!
+        end
+        # Creator
+        if ((e = doc.root.elements['channel/dc:creator']) && e.text) ||
+            ((e = doc.root.elements['channel/author'] ||
+            doc.root.elements['rss:channel/rss:author']) && e.text)
+          @creator = e.text.unescape_html.toUTF8(@encoding).rmWhiteSpace!
+        end
+        # Items
+        if doc.root.elements['channel/item']
+          query = 'channel/item'
+        elsif doc.root.elements['item']
+          query = 'item'
+        elsif doc.root.elements['rss:channel/rss:item']
+          query = 'rss:channel/rss:item'
+        else
+          query = 'rss:item'
+        end
+        doc.root.each_element(query) { |e| @items << RSSItem::new(e, self) }
+
+      elsif doc.root.elements['/feed']
+        # We have an ATOM feed!
+        @type = "atom"
+        # Title
+        if (e = doc.root.elements['/feed/title']) && e.text
+          @title = e.text.unescape_html.toUTF8(@encoding).rmWhiteSpace!
+        end
+        # Link
+        doc.root.each_element('/feed/link') do |e|
+          if e.attribute('type') and (
+              e.attribute('type').value == 'text/html' or
+              e.attribute('type').value == 'application/xhtml' or
+              e.attribute('type').value == 'application/xhtml+xml')
+            if (h = e.attribute('href')) && h
+              @link = h.value.rmWhiteSpace!
+            end
+          end
+        end
+        # Description
+        if e = doc.root.elements['/feed/info']
+          e = e.elements['div'] || e
+          @description = e.to_s.toUTF8(@encoding).rmWhiteSpace!
+        end
+        # Items
+        doc.root.each_element('/feed/entry') do |e|
+           @items << AtomItem::new(e, self)
+        end
+      else
+        raise UnknownFeedTypeException::new
+      end
+    end
+
+    def to_s(localtime = true)
+      s  = ''
+      s += "Type: #{@type}\n"
+      s += "Encoding: #{@encoding}\n"
+      s += "Title: #{@title}\n"
+      s += "Link: #{@link}\n"
+      s += "Description: #{@description}\n"
+      s += "Creator: #{@creator}\n"
+      s += "\n"
+      @items.each { |i| s += i.to_s(localtime) }
+      s
+    end
+  end
+
+  # an Item from a feed
+  class FeedItem
+    attr_accessor :title, :link, :content, :date, :creator, :subject,
+                  :category, :cacheditem
+
+    # The item's enclosures childs. An array of (url, length, type) triplets.
+    attr_accessor :enclosures
+
+    attr_reader :feed
+
+    # REXML::Element for this item
+    attr_reader :xml
+
+    def initialize(item = nil, feed = nil)
+      @xml = item
+      @feed = feed
+      @title, @link, @content, @date, @creator, @subject, @category = nil
+      @enclosures = []
+      parse(item) if item
+    end
+
+    def parse(item)
+      raise "parse() should be implemented by subclasses!"
+    end
+
+    def to_s(localtime = true)
+      s = "--------------------------------\n" +
+        "Title: #{@title}\nLink: #{@link}\n"
+      if localtime or @date.nil?
+        s += "Date: #{@date.to_s}\n"
+      else
+        s += "Date: #{@date.getutc.to_s}\n"
+      end
+      s += "Creator: #{@creator}\n" +
+        "Subject: #{@subject}\nCategory: #{@category}\nContent:\n#{content}\n"
+      if defined?(@enclosures) and @enclosures.length > 0
+        s2 = "Enclosures:\n"
+        @enclosures.each do |e|
+          s2 += e.join(' ') + "\n"
+        end
+        s += s2
+      end
+      return s
+    end
+  end
+
+  class RSSItem < FeedItem
+
+
+    def parse(item)
+      # Title. If no title, use the pubDate as fallback.
+      if ((e = item.elements['title'] || item.elements['rss:title']) &&
+          e.text)  ||
+          ((e = item.elements['pubDate'] || item.elements['rss:pubDate']) &&
+           e.text)
+        @title = e.text.unescape_html.toUTF8(@feed.encoding).html2text.rmWhiteSpace!
+      end
+      # Link
+      if ((e = item.elements['link'] || item.elements['rss:link']) && e.text)||
+          (e = item.elements['guid'] || item.elements['rss:guid'] and
+          not (e.attribute('isPermaLink') and
+          e.attribute('isPermaLink').value == 'false'))
+        @link = e.text.rmWhiteSpace!
+      end
+      # Content
+      if (e = item.elements['content:encoded']) ||
+        (e = item.elements['description'] || item.elements['rss:description'])
+        @content = FeedParser::getcontent(e, @feed)
+      end
+      # Date
+      if e = item.elements['dc:date'] || item.elements['pubDate'] || 
+          item.elements['rss:pubDate']
+        begin
+          @date = Time::xmlschema(e.text)
+        rescue
+          begin
+            @date = Time::rfc2822(e.text)
+          rescue
+            begin
+              @date = Time::parse(e.text)
+            rescue
+              @date = nil
+            end
+          end
+        end
+      end
+      # Creator
+      @creator = @feed.creator
+      if (e = item.elements['dc:creator'] || item.elements['author'] ||
+          item.elements['rss:author']) && e.text
+        @creator = e.text.unescape_html.toUTF8(@feed.encoding).rmWhiteSpace!
+      end
+      # Subject
+      if (e = item.elements['dc:subject']) && e.text
+        @subject = e.text.unescape_html.toUTF8(@feed.encoding).rmWhiteSpace!
+      end
+      # Category
+      if (e = item.elements['dc:category'] || item.elements['category'] ||
+          item.elements['rss:category']) && e.text
+        @category = e.text.unescape_html.toUTF8(@feed.encoding).rmWhiteSpace!
+      end
+      # Enclosures
+      item.each_element('enclosure') do |e|
+        url = e.attribute('url').value if e.attribute('url')
+        length = e.attribute('length').value if e.attribute('length')
+        type = e.attribute('type').value if e.attribute('type')
+        @enclosures << [ url, length, type ] if url
+      end
+    end
+  end
+
+  class AtomItem < FeedItem
+    def parse(item)
+      # Title
+      if (e = item.elements['title']) && e.text
+        @title = e.text.unescape_html.toUTF8(@feed.encoding).html2text.rmWhiteSpace!
+      end
+      # Link
+      item.each_element('link') do |e|
+        if (h = e.attribute('href')) && h.value
+          @link = h.value
+        end
+      end
+      # Content
+      if e = item.elements['content'] || item.elements['summary']
+        if (e.attribute('mode') and e.attribute('mode').value == 'escaped') &&
+          e.text
+          @content = e.text.toUTF8(@feed.encoding).rmWhiteSpace!
+        else
+          @content = FeedParser::getcontent(e, @feed)
+        end
+      end
+      # Date
+      if (e = item.elements['issued'] || e = item.elements['created'] || e = item.elements['updated'] || e = item.elements['published']) && e.text
+        begin
+          @date = Time::xmlschema(e.text)
+        rescue
+          begin
+            @date = Time::rfc2822(e.text)
+          rescue
+            begin
+              @date = Time::parse(e.text)
+            rescue
+              @date = nil
+            end
+          end
+        end
+      end
+      # Creator
+      @creator = @feed.creator
+      if (e = item.elements['author/name']) && e.text
+        @creator = e.text.unescape_html.toUTF8(@feed.encoding).rmWhiteSpace!
+      end
+    end
+  end
+
+  def FeedParser::getcontent(e, feed = nil)
+    encoding = feed ? feed.encoding : 'utf-8'
+    children = e.children.reject do |i|
+      i.class == REXML::Text and i.to_s.chomp == ''
+    end
+    if children.length > 1
+      s = ''
+      children.each do |c|
+        s += c.to_s if c.class != REXML::Comment
+      end
+      return s.toUTF8(encoding).rmWhiteSpace!.text2html(feed)
+    elsif children.length == 1
+      c = children[0]
+      if c.class == REXML::Text
+        return e.text.toUTF8(encoding).rmWhiteSpace!.text2html(feed)
+      else
+        if c.class == REXML::CData
+          return c.to_s.toUTF8(encoding).rmWhiteSpace!.text2html(feed)
+        elsif c.text
+          return c.text.toUTF8(encoding).text2html(feed)
+        end
+      end
+    end
+  end
+end