whistle 0.1

data/History.txt

@@ -0,0 +1,3 @@
+=== 0.1 / 2008-03-05
+
+* Initial release!

data/README.txt

@@ -0,0 +1,38 @@
+= whistle
+
+* http://whistle.rubyforge.org/
+
+== DESCRIPTION:
+
+Whistle is a jabber bot that will follow SVN repositories and RSS/Atom feeds and notify you about the new changes
+
+== INSTALL:
+
+sudo gem install whistle
+
+Follow directions from http://whistle.rubyforge.org/
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Esad Hajdarevic <esad@esse.at>
+
+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/bin/whistle

@@ -0,0 +1,90 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__),'..','lib')
+Dir[File.join(File.dirname(__FILE__),'..','vendor','**','lib')].each { |p| $LOAD_PATH << p }
+
+begin
+  if ARGV.empty?
+    puts "Hey there! You'll need to specify at least a config file"
+    exit
+  end
+  require 'config'
+  path = ARGV.shift
+  path += '.yml' unless path[/\.yml$/]
+  $config = Whistle::Config.new(path)
+rescue Errno::ENOENT
+  puts "Config file #{path} not found, push enter to create sample or CTRL-C"
+  gets
+  require 'fileutils'
+  FileUtils.copy(Whistle::Config::SAMPLE,path)
+  puts "Ok, edit the #{path} and try again."
+  exit
+end
+
+puts "Starting..."
+
+# Ugly global logger to STDOUT only ;-)
+def log(msg)
+  puts msg
+  STDOUT.flush
+end
+
+# Initialize some utilities and stuff we need
+require 'rubygems'
+gem 'activesupport'
+require 'activesupport'
+
+# Other extensions and patches
+require 'time_ext'
+require 'ssl_patch'
+
+# Initialize store
+require 'phash'
+$store = PHash.new($config.name + '.data') # Global store
+
+# Initialize switchbox
+require 'switchbox'
+$switchbox = Whistle::Switchbox.new($config.jabber.user,$config.jabber.password,$config.jabber.subscribers)
+puts "Logged into jabber as #{$config.jabber.user}, notifying:"
+$config.jabber.subscribers.each {|s| puts "- #{s}" }
+#at_exit { $switchbox.deliver("Bye!") }
+
+# Initialize relay
+if $config.relay
+  require 'relay'
+  Whistle::Relay.activate 
+end
+
+require 'resource'
+
+$switchbox.inform("Hello! I just started.")
+
+begin
+  while true do
+    log "Check started"
+    start = Time.now
+    $config.check.map {|url| Whistle::Resource.new(url) }.each do |r|
+      log "  Checking #{r.url}"
+      begin
+        message = r.tail
+        if message.blank?
+          log "    - nothing new"
+        else
+          log "    - new stuff, sending notification"
+          $switchbox.deliver(message)
+        end
+      rescue => e
+        log "    - error (#{e.message})"
+        $switchbox.inform("Error while processing #{r.url}: #{e.message}")
+      end
+      $store.flush
+    end
+    left = (5.minutes - (Time.now - start)).to_i
+    if left > 0
+      log "Finished! Now sleeping a bit."
+      sleep left 
+    end
+  end
+rescue => e
+ensure 
+  $switchbox.inform("Hey! Something funny (#{(e && e.message)}) happened. I have to shutdown now.")
+  raise e
+end

data/lib/config.rb

@@ -0,0 +1,19 @@
+require 'yaml'
+require 'ostruct'
+
+module Whistle
+  class Config
+    SAMPLE = File.join(File.dirname(__FILE__),'..','sample','config.yml')
+    attr_reader :check, :jabber, :name, :relay
+    def initialize(path)
+      @name = File.basename(path,'.yml')
+      @config = YAML.load_file(path)
+      @check = @config['check']
+      @jabber = OpenStruct.new(@config['jabber'])
+      if @config['relay']
+        host, port = @config['relay'].split(/\:/)
+        @relay = OpenStruct.new :host => host, :port => port
+      end
+    end
+  end
+end

data/lib/phash.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'activesupport' #to_yaml
+
+class PHash < Hash
+  def initialize(path)
+    @path = path
+    if File.exist?(@path)
+      data = YAML.load(File.read(@path)) rescue nil
+      self.replace(data) if data
+    end
+  end
+  
+  def flush
+    File.open(@path,'w') { |f| f.write(self.to_yaml)}
+  end
+end

data/lib/relay.rb

@@ -0,0 +1,24 @@
+require 'socket'
+
+module Whistle
+  class Relay
+    def self.activate
+      Thread.new do
+        server = TCPServer.new($config.relay.host, $config.relay.port)
+        puts "Started relay on port #{$config.relay.port}"
+        while s = server.accept
+          begin
+            msg = s.gets
+            puts "Received #{msg}, relaying"
+            msg.chomp!.strip! unless msg.blank?
+            $switchbox.deliver(msg) unless msg.blank?
+          rescue => e
+            puts "ERROR: #{e.message}"
+          ensure
+            s.close
+          end
+        end
+      end #.abort_on_exception = true
+    end
+  end
+end

data/lib/resource.rb

@@ -0,0 +1,113 @@
+require 'uri'
+
+# Patch it so that we can remove userinfo
+module URI
+  class Generic
+    def remove_userinfo!
+      @user, @password = nil, nil
+    end
+  end
+end
+
+require 'cgi'
+
+require 'open-uri'
+require 'feedparser'
+require 'activesupport'
+
+require 'rscm'
+
+require 'htmlentities/string'
+
+module Whistle
+  class Resource
+    attr_reader :url
+    
+    def initialize(url)
+      @uri = returning URI.parse(url) do |u|
+        @username, @password = u.user, u.password
+        @username = CGI.unescape(@username) unless @username.blank? # Convert %40 in username to @ (gmail) 
+        u.remove_userinfo!
+      end
+      @url = @uri.to_s
+      @store = ($store[@url] ||= {})
+      @type = (@store[:type] ||= guess_type) 
+    end
+    
+    def tail
+      case @type
+        when :svn
+          revisions = []
+          silence_stream(STDOUT) do # RSCM outputs everything to stdout?
+            scm = returning RSCM::Subversion.new(@url) do |svn|
+              svn.username, svn.password = @username, @password
+            end
+            since = @store[:last] || begin
+              rs = scm.revisions(7.days.ago)
+              diff_from = rs[rs.length-2]
+              return if diff_from.nil? # There's no revision in last days to show updates since
+              diff_from.identifier # Grab max last two
+            end
+            revisions = scm.revisions(since)
+          end
+          last_revision = revisions[revisions.length-1]
+          @store[:last] = last_revision.identifier.to_i if last_revision
+          revisions.map do |r| 
+            message = "Revision #{r.identifier} commited by #{r.developer} #{Time.now.distance_in_words_since(r.time)} ago: "
+            message << "\n"
+            message << r.message.chomp.strip
+            message << "\n"
+            message << r.map {|f| " #{f.status[0,1]} #{f.path}" }.join("\n")
+            message << "\n"
+            message
+          end
+        when :feed
+          f = FeedParser::Feed.new(open(@url,:http_basic_authentication => [@username,@password]).read)
+          
+          @store[:seen] ||= {}
+          @store[:seen].delete_if {|link,date| date && (date < 1.month.ago) } # Purge seen hash remove items older than one month
+          
+          old, new = f.items.partition {|i| @store[:seen].has_key?(i.link) }
+          new = new.first(5) if @store[:seen].empty? # Limit first tail to 5 entries
+          
+          # Mark all items as seen
+          f.items.each { |i| @store[:seen][i.link] = i.date }
+          
+          return new.reverse.map do |i|
+            safe_title = i.title.encode_entities(:basic)
+            title = ''
+            if @uri.host == 'mail.google.com'
+              #title = "<span style=\"background:#ccccff; color: #000000;\">#{@username}</span>"
+              title << "#{@username}: #{safe_title}"
+            else
+              title = safe_title
+              title << " (#{i.creator})" if i.creator
+            end  
+            link = i.link.encode_entities(:basic) # xmpp4r had problems with unencoded &
+            pre,post = title.split(/\:/,2)
+            if post.nil?
+              body = "#{title} <a href=\"#{link}\">#</a>"
+            else
+              body = "#{pre}: <a href=\"#{link}\">#{post.strip}</a>"
+            end
+            "<html><body>#{body}</body></html>"
+          end
+      end
+    end
+  private
+    def guess_type
+      log "Guessing type for #{@url}"
+      type = case @uri.scheme
+        when 'svn'
+          return :svn
+        when 'http'
+          is_svn = RSCM::Subversion.new(@url).central_exists? rescue false
+          return is_svn ? :svn : :feed
+        else
+          return :feed
+      end 
+      log "Guessed #{type}"
+      return type
+    end
+  end
+end

data/lib/ssl_patch.rb

@@ -0,0 +1,15 @@
+require 'net/https'
+
+module Net
+  class HTTP
+    alias :orig_use_ssl= :use_ssl= 
+    def use_ssl=(flag)
+      self.orig_use_ssl=(flag)
+      @ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    end
+    
+    def verify_mode=(m)
+      # Ignore, don't let open-uri reconfigure verify mode
+    end
+  end
+end

data/lib/switchbox.rb

@@ -0,0 +1,54 @@
+require 'xmpp4r-simple'
+require 'htmlentities/string'
+
+module Whistle
+  class Switchbox
+    attr_reader :user
+    
+    def initialize(user,password,subscribers)
+      @user, @password, @subscribers = user, password, subscribers
+      @jabber = Jabber::Simple.new(@user, @password)
+    end
+    
+    def deliver(messages)
+      @subscribers.each do |to| 
+        Array(messages).each do |body| 
+          format_and_send :to => to, :body => body  
+        end
+      end
+    end
+    
+    # Sends message to primary (first) subscriber only
+    def inform(message)
+      if (primary = @subscribers.first)
+        format_and_send :to => @subscribers.first, :body => message
+      end
+    end
+private    
+    # Processes html in the messages and sends it to a recipient
+    def format_and_send(options)
+      m = Jabber::Message::new(options[:to],options[:body]).set_type(:normal)
+      r = REXML::Document.new(options[:body]) rescue nil
+      if r && r.root && r.root.name == 'html'
+        # We have a html message here, prepare for sending via jabber
+        m.body = strip_tags(options[:body]) # Make a plaintext version
+        r.root.add_namespace('http://jabber.org/protocol/xhtml-im')
+        r.root.elements['body'].add_namespace('http://www.w3.org/1999/xhtml')
+        m.add_element(r)
+      end
+      # Use deliver from xmpp4r-simple so it will try adding contact first and queue the delivery
+      @jabber.deliver(options[:to],m) 
+    end
+    
+    def strip_tags(html)
+      html.gsub(/<.+?>/,'').
+      gsub(/&amp;/,'&').
+      gsub(/&quot;/,'"').
+      gsub(/&lt;/,'<').
+      gsub(/&gt;/,'>').
+      gsub(/&ellip;/,'...').
+      gsub(/&apos;/, "'").
+      gsub("\n",'')
+    end
+  end
+end

data/lib/time_ext.rb

@@ -0,0 +1,30 @@
+class Time
+  # Taken from ruby on rails
+  def distance_in_words_since(from_time, include_seconds = true)
+      distance_in_minutes = (((self - from_time).abs)/60).round
+      distance_in_seconds = ((self - from_time).abs).round
+
+      case distance_in_minutes
+        when 0..1
+          return (distance_in_minutes == 0) ? 'less than a minute' : '1 minute' unless include_seconds
+          case distance_in_seconds
+            when 0..4   then 'less than 5 seconds'
+            when 5..9   then 'less than 10 seconds'
+            when 10..19 then 'less than 20 seconds'
+            when 20..39 then 'half a minute'
+            when 40..59 then 'less than a minute'
+            else             '1 minute'
+          end
+
+        when 2..44           then "#{distance_in_minutes} minutes"
+        when 45..89          then 'about 1 hour'
+        when 90..1439        then "about #{(distance_in_minutes.to_f / 60.0).round} hours"
+        when 1440..2879      then '1 day'
+        when 2880..43199     then "#{(distance_in_minutes / 1440).round} days"
+        when 43200..86399    then 'about 1 month'
+        when 86400..525959   then "#{(distance_in_minutes / 43200).round} months"
+        when 525960..1051919 then 'about 1 year'
+        else                      "over #{(distance_in_minutes / 525960).round} years"
+      end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Whistle
+  VERSION = '0.1'
+end

data/sample/config.yml

@@ -0,0 +1,12 @@
+check:
+  - svn://user:password@svn.example.org/repos/trunk
+  - http://user:password@example.org/rss
+jabber:
+  user: user@jabber.example.com 
+  password: mypassword
+  subscribers:
+  - django@example.org
+  - tina@somewhere.org
+  #- disabled@user.org
+# Uncomment this to enable relaying - everything sent to this port will get relayed over jabber
+#relay: localhost:2000 

data/vendor/rscm-0.5.1-patched-stripped/README

@@ -0,0 +1,218 @@
+= RSCM - Ruby Source Control Management (0.5.1)
+
+RSCM is to SCM what DBI/JDBC/ODBC are to databases - an SCM-independent API for accessing different SCMs. The high level features are roughly:
+
+* Check out a working copy (with possibility to specify branch/date/label)
+* Get revisions (changesets) (Emulated for non-transactional SCMs like CVS, ClearCase and StarTeam)
+* Get diffs
+* Add and commit files
+* Manipluate triggers
+
+Although RSCM's main focus is operations on a working copy of an SCM repository, 
+the API also allows some level of interaction with the SCM repository itself, 
+like creating new repositories.
+
+== Download
+
+RSCM is available as a RubyGem, and can be installed like this:
+
+  gem install rscm
+
+(You may need administrator access to do this on a POSIX system). You can also download prebuilt gems from
+http://rubyforge.org/frs/?group_id=490
+
+If you want the latest and greatest, you can get the sources from subversion:
+
+  svn co svn://buildpatterns.com/svn/repos/rscm/trunk
+
+== Contributors
+
+* Aslak Hellesoy - All
+* Steven Baker - Monotone
+* Jon Tirsen - CVS, Subversion
+* Yogi Kulkarni - Perforce
+
+== Supported SCMs
+
+* CVS - http://www.nongnu.org/cvs (stable)
+* Subversion - http://subversion.tigris.org (stable)
+
+In progress:
+
+* ClearCase - http://www-306.ibm.com/software/awdtools/clearcase (not thoroughly tested)
+* Darcs - http://www.abridgegame.org/darcs (very incomplete)
+* Monotone - http://www.venge.net/monotone (half complete)
+* Perforce - http://www.perforce.com (nearly complete - a little out of date with recent API)
+* StarTeam - http://www.borland.com/starteam (nearly complete - a little out of date with recent API)
+
+Planned:
+
+Loads! All of them! How to add support for a new one is described further down in this file.
+
+== Related projects
+
+* DamageControl - http://dev.buildpatterns.com/trac/wiki/DamageControl (Continuous Integration system
+built on top of RSCM and Ruby on Rails).
+
+== Sample usage
+
+Here is an example of how to use RSCM to get a list of revisions (aka changesets) from a subversion repository:
+
+  require 'rscm'
+  
+  scm = RSCM::Subversion.new("svn://some.server/some/path/trunk")
+  # What follows would look the same for any supported SCM
+  revisions = scm.revisions(Time.utc(2004, 11, 10, 12, 34, 22)) # For Subversion, you can also pass a revision number (int)
+  revisions.each do |revision|
+    puts revision # or do something more funky with it
+  end
+
+== Future plans
+
+=== Cross-SCM synchronisation
+RSCM could be used as a tool to migrate files from one SCM to another (of a different type)
+while keeping the history. -Similar to cvs2svn or http://nautilus.homeip.net/~lele/projects/tailor/
+
+RSCM could also be used as a continuous synchronisation service between SCMs. This can be very useful
+when you have to work with an SCM and you'd rather use a different one. RSCM could synchronise between
+the central SCM and one that you set up on your local machine.
+
+=== SCM browser
+A rails webapp that allows browsing of a repository, using RSCM to access it. -Perhaps even with a simple
+editor allowing people to modify files and commit them via the browser.
+
+= Implementing a new RSCM adapter
+
+If you want RSCM to support a new SCM, you must implement a subclass of RSCM::Base.
+You should focus on implementing only the features that you need. For example, if
+you plan to use your new RSCM adapter with DamageControl, you only need to implement
+the parts of the API that are used by DamageControl.
+
+We'll see what steps are needed to make an adapter that passes the DamageControl compatibility suite
+(which is part of RSCM). Let's imagine we want DamageControl to be able to work with the imaginary SCM 
+called Mooky. The rest of this section explains how to get started. You're going to need a preexisting
+repository with some existing contents, basic knowledge of the SCM's command line tools and some Ruby
+programming skills.
+
+== Create the test class and the implementation class
+
+Start by writing a test that includes the compatibility test suite you're interested in:
+
+  test/rscm/scm/mooky_test.rb
+
+With the following content:
+
+  require 'rscm/test_helper'
+
+  module RSCM
+    class MookyTest < Test::Unit::TestCase
+      include Compatibility::DamageControlMinimal
+    end
+  end
+
+Now create the implementation class:
+
+  lib/rscm/scm/mooky.rb
+
+With the following content:
+
+  require 'rscm/base'
+
+  module RSCM
+    class Cvs < Base
+    end
+  end
+
+Now that we have set up the basics, we can run the tests:
+
+  rake test TEST=test/rscm/scm/mooky_test.rb
+
+It will fail - there is still some setup to do:
+
+== Create testdata directory
+You must create a new directory under test/rscm/compatibility to contain testdata. Give it a name representative 
+of the scm type and the contents of the scm. For example, if the existing mooky repository we're going to test 
+against contains source code for a chess engine, we could call the directory test/rscm/compatibility/mooky_chess.
+
+Also add an entry in test/rscm/compatibility/config.yml mapping your test class to the testdata directory.
+
+The DamageControl compatibility suite expects to find three YAML files in this directory, scm.yml, revisions.yml
+and files_0.yml.
+
+=== Create scm.yml 
+This file should contain a YAML representation of the SCM instance used for testing. The test suite will load it to create an instance of your class. You're free to use whatever properties you want in your SCM implementation, and the YAML file should
+contain the necessary values to connect to the preexisting repository.
+
+=== Create revisions.yml
+This file should contain a RSCM::Revisions object with two RSCM::Revision objects. You can start off by making a copy of one of the
+existing revisions.yml files, but you should hand-edit this file to represent two revisions in the existing repository.
+
+You cannot choose any revision though. There are some constraints that need to be followed:
+* There must be exactly two RSCM::Revision objects
+* The two RSCM::Revision objects must represent to adjacent revisions from the repository
+* Each of the RSCM::Revision objects must contain at least two RSCM::RevisionFile objects
+* The second RSCM::Revision object must contain at least one RSCM::RevisionFile with "ADDED" state
+
+Given these constraints you should spend some time locating two revisions that follow these constraints.
+This would be a good time to familiarize yourself with the SCM's command line tool (or whatever kind of tool
+the SCM provides to access it).
+
+==== Special note for non-transactional SCMs
+
+Non-transactional SCMs usually use dates (and not revision identifiers) to report changes. Most SCMs report changes to files
+(which will become RSCM::RevisionFile instances) in some sort of log. These changes will typically not be logically 
+grouped. RSCM::Revisions.add will group revision files that have:
+* similar modification time (max 1 minute apart)
+* the same commit message
+* the same developer
+
+So when mining for revisions that follow the constraints for revisions.yml, you should also be looking for groupings
+in modification time, commit message and developer.
+
+=== Create files_0.yml
+This file should contain the files that will be in the working copy after a checkout of the 1st revision in revisions.yml,
+sorted by their path.
+
+=== Create old.yml
+This file should contain a start time and all the revision identifiers before that time. 
+The start time should be a carefully selected timestamp close to the start of the scm.
+"identifiers" should be a list of all identifiers from the beginning of time up until 
+the start identifier.
+
+=== Create diff.txt
+This file should contain a diff. It should be the diff of the first revision file in revisions.yml - 
+between its native_revision_identifier and the previous_revision_identifier.
+
+=== Create file.txt
+This file should contain the contents of the first revision file in revisions.yml (at the revision
+specified by native_revision_identifier).
+
+== Implement the methods
+Now that we have set up everything needed for the tests, we can run the tests again:
+
+  rake test TEST=test/rscm/scm/mooky_test.rb
+
+Now you should get errors about methods not being implemented. At this point you should start implementing the methods.
+
+== Implementation tips
+* Run the tests often. Let the error messages guide you in what you do next.
+* Use the execute method to invoke command line tools.
+* Split the implementation into two classes. One class for parsing logs and one for translating API calls to command line executions. This will allow you to test the log parsing against hard coded logs in your tests.
+
+= Building RSCM
+This section is for developers who are new to ruby development and do not already know how to build and install Ruby gems.
+
+You need to install rubygems from http://rubyforge.org/projects/rubygems
+Afterwards you need to install rake and rails
+
+  gem install rake
+
+Now change to the RSCM root directory and type
+
+  rake gem
+
+This will create a gem for RSCM. To install this gem, you have to change to the pkg directory and type
+
+  sudo gem install pkg/rscm-0.4.X.gem
+  
+Now you can use RSCM in other Ruby apps with a simple require 'rscm'.