herald 0.1 → 0.2

data/lib/herald/notifiers/ping.rb

@@ -4,42 +4,23 @@ class Herald
 
       module Ping
 
-        attr_reader :uri
-
-        # lazy-load net/http when this Module is used
+        # Ping and Post share a lot of code, so
+        # when Ping is extended, extend the calling class
+        # with the Post module
         def self.extended(base)
-          Herald.lazy_load('net/http')
-        end
-
-        # note: dupe between ping and post
-        def parse_options(options)
-          begin
-            @uri = URI.parse(options.delete(:uri) || options.delete(:url))
-            # if URI lib can't resolve a protocol (because it was missing from string)
-            if @uri.class == URI::Generic
-              @uri = URI.parse("http://#{@uri.path}")
+          Herald::lazy_load_module("notifiers/post")
+          base.send(:extend, Post)
+          # and redefine notify() to ping instead of post data
+          class << base
+            def notify(item)
+              @uris.each do |uri| 
+                Net::HTTP.new(uri.host).head('/')
+              end
             end
-          rescue URI::InvalidURIError
-            raise ArgumentError, ":uri for :ping action not specified or invalid"
-          end
-        end
-        
-        def test
-          response = Net::HTTP.new(@uri.host).head('/')
-          return if response.kind_of?(Net::HTTPOK)
-          # TODO raise custom error types
-          if response.kind_of?(Net::HTTPFound)
-            raise "URI #{@uri} is being redirected to #{response.header['location']}"
-          else
-            raise "URI #{@uri} cannot be reached. Ping returned status code: #{response.code}"
-          end
-        end
-
-        def notify(item)
-          Net::HTTP.new(@uri.host).head('/')
-        end
+          end # end
+        end # end method
 
-      end
+      end # end module
 
     end
   end  

data/lib/herald/notifiers/post.rb

@@ -5,39 +5,51 @@ class Herald
       # note most of this code is duplicated between ping and post
       module Post
 
-        attr_reader :uri
-
         # lazy-load net/http when this Module is used
         def self.extended(base)
           Herald.lazy_load('net/http')
+          class << base
+            attr_accessor :uri
+          end
         end
 
         def parse_options(options)
-          begin
-            @uri = URI.parse(options.delete(:uri) || options.delete(:url))
-            # if URI lib can't resolve a protocol (because it was missing from string)
-            if @uri.class == URI::Generic
-              @uri = URI.parse("http://#{@uri.path}")
+          @uris = []
+          uris = Array(options.delete(:uri) || options.delete(:url) || options.delete(:uris) || options.delete(:urls))
+          if uris.empty?
+            raise ArgumentError, ":uri for :ping action not specified"
+          end
+          uris.each do |uri|
+            begin
+              uri = URI.parse(uri)
+              # if URI lib can't resolve a protocol (because it was missing from string)
+              if uri.class == URI::Generic
+                uri = URI.parse("http://#{uri.path}")
+              end
+              # add trailing slash if nil path. path() will return nil
+              # if uri passed was a domain missing a trailing slash. net/http's post
+              # methods require the trailing slash to be present otherwise they fail
+              uri.path = "/" if uri.path.empty?
+              @uris << uri
+            rescue URI::InvalidURIError
+              raise ArgumentError, ":uri for :ping action invalid"
             end
-          rescue URI::InvalidURIError
-            raise ArgumentError, ":uri for :ping action not specified or invalid"
           end
         end
-
-        # test by pinging to URI throw exception if fail
+        
         def test
-          response = Net::HTTP.new(@uri.host).head('/')
-          return if response.kind_of?(Net::HTTPOK)
-          # TODO raise custom error types
-          if response.kind_of?(Net::HTTPFound)
-            raise "URI #{@uri} is being redirected to #{response.header['location']}"
-          else
-            raise "URI #{@uri} cannot be reached. Ping returned status code: #{response.code}"
+          @uris.each do |uri|
+            response = Net::HTTP.new(uri.host).head('/')
+            return if response.kind_of?(Net::HTTPOK)
+            # TODO raise custom error types
+            raise "#{response.code} status code returned for URI #{uri}. 200 code expected"
           end
         end
 
         def notify(item)
-          Net::HTTP.post_form(@uri.to_s, { "title" => item.title, "message" => item.message })
+          @uris.each do |uri|
+            Net::HTTP.post_form(uri, { "title" => item.title, "message" => item.message }.merge(item.data))
+          end
         end
 
       end

data/lib/herald/untitled.txt

@@ -0,0 +1,5 @@
+require 'herald'
+herald = Herald.watch do
+  check :website, :from => "http://www.google.co.nz", :within_tags => ["#some_id", #another_id]
+  _for "search"
+end

data/lib/herald/version.rb

@@ -1,3 +1,3 @@
 class Herald
-  VERSION = "0.1"
+  VERSION = "0.2"
 end

data/lib/herald/watcher.rb

@@ -2,33 +2,29 @@ class Herald
   
   class Watcher
     
-    @@watcher_types = [:rss, :twitter] # :imap
+    @@watcher_types = [:rss, :twitter, :website]
     DEFAULT_TIMER = 60
 
-    attr_reader :type, :keep_alive, :thread, :items
-    attr_accessor :notifiers, :keywords, :timer
-    
-    def initialize(type, keep_alive, options, &block)
+    attr_reader :type, :keep_alive, :thread
+    attr_accessor :notifiers, :keywords, :timer, :items
+
+    def initialize(type, options, &block)
       @type = type.to_sym
-      # TODO this is prepared to handle other protocols, but might not be necessary
-#      if @type == :inbox
-#        if options.key?(:imap)
-#          @type = :imap
-#          options[:host] = options[:imap]
-#        end
-#      end
       # check watcher type
       unless @@watcher_types.include?(@type)
         raise ArgumentError, "#{@type} is not a valid Watcher type"
       end
-      @keep_alive = keep_alive
       @keywords = []
       @notifiers = []
       @items = []
+      @keep_alive = options.delete(:keep_alive)
       @timer = Watcher::DEFAULT_TIMER
       Herald.lazy_load_module("watchers/#{@type}")
-      # extend class with module
-      send(:extend, eval(@type.to_s.capitalize))
+      # include module
+      @@type = @type
+      class << self
+        send(:include, eval(@@type.to_s.capitalize))
+      end
       # each individual Watcher will handle their options
       parse_options(options)
       # eval the block, if given
@@ -40,11 +36,13 @@ class Herald
     
     def _for(*keywords)
       @keywords += keywords.flatten
+      self
     end
     
     # assign the Notifier
     def action(type = :callback, options = {}, &block)
       @notifiers << Herald::Watcher::Notifier.new(type, options, &block)
+      self
     end
     
     # parse a hash like { 120 => "seconds" }
@@ -63,6 +61,7 @@ class Herald
         raise ArgumentError, "Invalid time unit for every. (Use seconds, minutes, hours or days)"
       end
       @timer = quantity * unit
+      self
     end
     
     # call the Notifier and pass it a message
@@ -70,6 +69,7 @@ class Herald
       @notifiers.each do |notifier|
         notifier.notify(item)
       end
+      self
     end
     
     def start
@@ -85,6 +85,7 @@ class Herald
           sleep @timer if @keep_alive
         end while @keep_alive
       }
+      self
     end
         
     def stop
@@ -92,6 +93,7 @@ class Herald
       @keep_alive = false
       # cleanup() is defined in the individual Watcher modules
       cleanup()
+      self
     end
     
   end

data/lib/herald/watchers/rss.rb

@@ -4,10 +4,11 @@ class Herald
     module Rss
 
       attr_accessor :uris
-      
+    
       # lazy-load open-uri when this Module is used
-      def self.extended(base)
+      def self.included(base)
         Herald.lazy_load('open-uri')
+        Herald.lazy_load('crack')
       end
       
       def parse_options(options)
@@ -15,20 +16,21 @@ class Herald
         if @uris.empty?
           raise ArgumentError, "RSS source not specified in :from Hash"
         end
+        @uris.map!{ |uri| URI.escape(uri) }
       end
 
       def prepare; end
       def cleanup; end
       
       def to_s
-        "Herald RSS Watcher, URL: #{@uris}, Keywords: '#{@keywords}', Timer: #{@timer}, State: #{@keep_alive ? 'Watching' : 'Stopped'}"
+        "Herald RSS Watcher, URIs: #{@uris}, Keywords: '#{@keywords}', Timer: #{@timer}, State: #{@keep_alive ? 'Watching' : 'Stopped'}"
       end
             
     private
     
       def activities
         @uris.each do |uri|
-          # return response as string and parse to RSS
+          # return response as a Hash
           begin
             rss = Crack::XML.parse(open(uri).read)
           rescue
@@ -37,10 +39,15 @@ class Herald
           # skip if rss variable is nil, or is missing
           # rss elements in the expected nested format
           next unless defined?(rss["rss"]["channel"]["item"])
+          rss = rss["rss"]["channel"]["item"]
+          # if there is only 1 <item> in the rss document, 
+          # rss variable at the moment will be a Hash, so
+          # convert to a single element array
+          rss = [rss] if rss.is_a?(Hash) 
           # ignore items that have been part of a notification round
           # or that don't contain the keywords being looked for
           items = []
-          rss["rss"]["channel"]["item"].each do |item|
+          rss.each do |item|
             # if we've already seen this item, skip to next item
             if @items.include?(item)
               next

data/lib/herald/watchers/twitter.rb

@@ -4,12 +4,13 @@ class Herald
     # TODO, ignore retweets, if option passed
     module Twitter
 
-      attr_accessor :uri, :last_tweet_id
       TWITTER_API = "http://search.twitter.com/search.json"
-      
+      attr_accessor :uri, :last_tweet_id
+
       # lazy-load open-uri when this Module is used
-      def self.extended(base)
+      def self.included(base)
         Herald.lazy_load('open-uri')
+        Herald.lazy_load('crack')
       end
 
       def parse_options(options); end
@@ -37,13 +38,13 @@ class Herald
 
       def activities
         # return response as string from Twitter and parse it to JSON
-        json = Crack::JSON.parse(open(@uri.join("&")).read)
+        json = Crack::JSON.parse(open(URI.escape(@uri.join("&"))).read)
         # will be nil if there are no results
         return if json["results"].nil?
         @last_tweet_id = json["max_id"]
         json["results"].each do |tweet|
           @items << tweet
-          notify(Item.new("@#{tweet['from_user']}", tweet['text'], json['results']))
+          notify(Item.new("@#{tweet['from_user']}", tweet['text'], tweet))
         end
         @uri = [@uri.first, "since_id=#{@last_tweet_id}"]
       end

data/lib/herald/watchers/website.rb

@@ -0,0 +1,95 @@
+class Herald
+  class Watcher
+
+    module Website
+
+      attr_accessor :uris, :selectors, :traverse
+
+      # lazy-load open-uri when this Module is used
+      def self.included(base)
+        %w(open-uri hpricot crack).each do |lib|
+          Herald.lazy_load(lib)
+        end
+      end
+
+      def parse_options(options)
+        # assign an array of selectors
+        # user can pass in either :only_in_tag[s], or :within_tag[s].
+        # :only_in_tag will limit hpricot to search for text
+        # in that particular tag only, whereas :within_tag will
+        # include all children of the tag in the search
+        # find the option param that matches "tag"
+        options.find do |k, v|
+          if k.to_s.match(/tag/)
+            @selectors = Array(v) # coerce to Array
+            # if the key is :only_tag[s]
+            @traverse = false if k.to_s.match(/only/)
+          end
+        end
+        # default selector if no relevant option passed
+        @selectors ||= ["body"]
+        # if we should traverse, append a * (css for "every child") to all selectors
+        if @traverse
+          @selectors.map!{|s|"#{s} *"}
+        end
+        # parse uri Strings to URI objects
+        @uris = Array(options.delete(:from))
+        if @uris.empty?
+          raise ArgumentError, "Website source not specified in :from Hash"
+        end
+        @uris.map!{ |uri| URI.escape(uri) }
+      end
+
+      def prepare; end
+      def cleanup; end
+      
+      def to_s
+        "Herald Website Watcher, URIs: #{@uris}, Elements #{@selectors}, Keywords: '#{@keywords}', Timer: #{@timer}, State: #{@keep_alive ? 'Watching' : 'Stopped'}"
+      end
+            
+    private
+
+      def activities
+        @uris.each do |uri|
+#          hpricot = Hpricot(open(uri).read, :fixup_tags => true)
+          hpricot = Hpricot(open(uri).read, :xhtml_strict => true)
+          hpricot.search("script").remove
+          if title = hpricot.search("title").inner_html
+            title.strip!
+          end
+          title ||= "Website"
+          # for every selector given
+          @selectors.each do |selector|
+            # and for every keyword given
+            @keywords.each do |keyword|
+              # return response as string and parse to RSS
+              begin
+                # search for elements in the page that match the
+                # selector, and contain the keyword as text
+                # TODO - keywords should be parsed and validated
+                # TODO - keywords at the moment are case-sensitive
+                # get the second to last element
+                elements = hpricot.search("#{selector} [text()*=#{keyword}]")
+                element = elements[elements.size - 2]
+                if text = element.inner_html
+                  text.strip!
+                end
+                html = element.to_html
+                tag = element.name
+                data = {:title => title, :text => text, :tag => tag, :html => html}
+                # ignore items that have been part of a notification round
+                next if @items.include?(data)
+                # notify!
+                notify(Item.new(title, text, data))
+                @items << data
+              rescue
+                # TODO handle errors
+              end # end begin
+            end # end each keyword
+          end # end each selector
+        end # end each uri
+      end # end method
+
+    end
+  end
+end

data/test/herald_test.rb

@@ -2,7 +2,7 @@
 
 describe Herald do
   before do
-    @herald = Herald.watch { check :twitter; _for "test" }
+    @herald = Herald.watch_twitter { _for "test" }
   end
   
   after do
@@ -25,12 +25,6 @@ describe Herald do
   end
 
   describe "initialisation of twitter watcher" do
-    it "must throw an error if no keywords are given" do
-      skip("Test not working")
-      assert_raises(ArgumentError) do
-        Herald.watch { check :twitter }
-      end
-    end
     it "must assign a twitter watcher" do
       @herald.watchers.first.type.must_equal(:twitter)
     end
@@ -52,7 +46,7 @@ describe Herald do
     it "must assign keyword when passed as a string" do
       @herald.watchers.first.keywords.must_be_kind_of(Array)
       @herald.watchers.first.keywords.size.must_equal(1)
-      @herald.watchers.first.keywords.to_s.must_equal("test")
+      @herald.watchers.first.keywords.join.must_equal("test")
     end
     it "must slurp keywords when passed as a multiargument strings" do
       keywords = ["test1", "test2"]
@@ -70,7 +64,7 @@ describe Herald do
 
   describe "initialisation with actions" do
     it "should assign stdout as the default Notifier" do
-      skip("@notifiers appears as empty, possible due to threading?")
+      skip("@notifiers appears as empty because anything assigned in the process fork can't be accessed outside it")
       @herald.watchers.first.notifiers.size.must_equal(1)
     end
   end