feedbook 0.9.0

data/lib/feedbook/errors/notifier_configuration_error.rb

@@ -0,0 +1,12 @@
+module Feedbook
+  module Errors
+    class NotifierConfigurationError < StandardError
+      attr_reader :notifier
+
+      def initialize(notifier, message = {})
+        @notifier = notifier
+        super(message)
+      end
+    end
+  end
+end

data/lib/feedbook/errors/notifier_notify_error.rb

@@ -0,0 +1,12 @@
+module Feedbook
+  module Errors
+    class NotifierNotifyError < StandardError
+      attr_reader :notifier
+
+      def initialize(notifier, message = {})
+        @notifier = notifier
+        super(message)
+      end
+    end
+  end
+end

data/lib/feedbook/errors/parse_feed_error.rb

@@ -0,0 +1,11 @@
+module Feedbook
+  module Errors
+    class ParseFeedError < StandardError
+      attr_reader :url
+      def initialize(url, message)
+        @url = url
+        super(message)
+      end
+    end
+  end
+end

data/lib/feedbook/errors/template_syntax_error.rb

@@ -0,0 +1,6 @@
+module Feedbook
+  module Errors
+    class TemplateSyntaxError < StandardError
+    end
+  end
+end

data/lib/feedbook/errors/unsupported_notifier_error.rb

@@ -0,0 +1,12 @@
+module Feedbook
+  module Errors
+    class UnsupportedNotifierError < StandardError
+      attr_reader :notifier
+
+      def initialize(notifier, message)
+        @notifier = notifier
+        super(message)
+      end
+    end
+  end
+end

data/lib/feedbook/factories/notifiers_factory.rb

@@ -0,0 +1,28 @@
+require 'feedbook/notifiers'
+require 'feedbook/errors/unsupported_notifier_error'
+
+module Feedbook
+  module Factories
+    class NotifiersFactory
+
+      # Returns instance of Notifier for given type.
+      # @param type [Symbol/String] name of requested notifier
+      # 
+      # @return [Notifier] Notifier instance
+      def self.create(type)
+        case type
+        when :null, 'null'
+          Notifiers::NullNotifier.instance
+        when :twitter, 'twitter'
+          Notifiers::TwitterNotifier.instance
+        when :facebook, 'facebook'
+          Notifiers::FacebookNotifier.instance
+        when :irc, 'irc'
+          Notifiers::IRCNotifier.instance
+        else
+          raise Errors::UnsupportedNotifierError.new(type)
+        end
+      end
+    end
+  end
+end

data/lib/feedbook/feed.rb

@@ -0,0 +1,85 @@
+require 'uri'
+require 'feedjira'
+require 'feedbook/post'
+require 'feedbook/notification'
+require 'feedbook/errors/parse_feed_error'
+require 'feedbook/errors/invalid_feed_url_error'
+require 'feedbook/errors/invalid_variables_format_error'
+
+module Feedbook
+  class Feed
+
+    attr_reader :urls, :notifications, :variables 
+
+    # Initializes new Feed instance for given configuration
+    # @param opts = {} [Hash] Hash with configuration options for feed
+    # 
+    # @return [NilClass] nil
+    def initialize(opts = {})
+      @urls          = opts.fetch(:urls, '').split
+      @variables     = opts.fetch(:variables, {})
+      @notifications = opts.fetch(:notifications, []).map do |notification|
+        Notification.new(
+          type:      notification['type'],
+          template:  notification['template'],
+          variables: variables
+        )
+      end
+    end
+
+    # Fetches and parses all feed and merges into single array.
+    # 
+    # @return [Array] array of Posts
+    def fetch
+      urls
+      .map do |url|
+        parse_feed(Feedjira::Feed.fetch_and_parse(url))
+      end
+      .inject :+
+    end
+
+    # Validates if given parameters are valid
+    # 
+    # @return [NilClass] nil
+    # @raise [Feedbook::Errors::InvalidVariablesFormatError] if variables parameter is not a Hash
+    # @raise [Feedbook::Errors::InvalidFeedUrlError] if url collection is not a empty and contains valid urls 
+    def valid?
+      if urls.empty? || urls.any? { |url| url !~ /\A#{URI::regexp}\z/ }
+        raise Errors::InvalidFeedUrlError.new
+      end
+
+      unless variables.is_a? Hash
+        raise Errors::InvalidVariablesFormatError.new
+      end
+
+      notifications.each { |notification| notification.valid? }
+    end
+
+    private
+
+    # Parses feetched feed into Feedbook::Post 
+    # @param feed [Feedjira::Parser::Atom] Atom/RSS feed 
+    # 
+    # @return [Array] array of Posts created from feed entries
+    def parse_feed(feed)
+      feed.entries.map do |entry|
+        Post.new(
+           author:     entry.author,
+           published:  entry.published,
+           url:        entry.url,
+           title:      entry.title,
+           feed_title: feed.title
+        )
+      end
+    end
+
+    # Determines behavior of failure in fetching feeds
+    # @param url [String] requested url
+    # 
+    # @raise [Feedbook::Error::ParseFeedError] if fetching and parsing feed was unsuccessful
+    def on_failure(url)
+      raise Error::ParseFeedError.new(url)
+    end
+
+  end
+end

data/lib/feedbook/helpers/time_interval_parser.rb

@@ -0,0 +1,38 @@
+require 'timeloop'
+require 'feedbook/errors/invalid_interval_format_error'
+
+module Feedbook
+  module Helpers
+    class TimeIntervalParser
+
+      INTERVAL_FORMAT = /\A(\d+)(s|m|h|d)\z/
+
+      # Parses given string with interval and converts into a amount of seconds.
+      # @param value [String] String with interval (e.g. '10m', '100s', '20h', '10d')
+      # 
+      # @return [Integer] amount of seconds that equals given interval value 
+      # @raise [Feedbook::Errors::InvalidIntervalFormatError] if given string is not a valid format
+      def self.parse(value)
+        if value.strip =~ INTERVAL_FORMAT
+          number, type = INTERVAL_FORMAT.match(value).captures
+          case type
+          when 's'
+            Integer(number).seconds
+          when 'm'
+            Integer(number).minutes
+          when 'h'
+            Integer(number).hours
+          when 'd'
+            Integer(number).days
+          end
+        else
+          raise ArgmumentError.new
+        end
+
+      rescue
+        raise Errors::InvalidIntervalFormatError.new
+      end
+
+    end
+  end
+end

data/lib/feedbook/listener.rb

@@ -0,0 +1,122 @@
+require 'yaml'
+require 'timeloop'
+require 'feedbook/feed'
+require 'feedbook/errors'
+require 'feedbook/configuration'
+require 'feedbook/comparers/posts_comparer'
+
+module Feedbook
+  class Listener
+
+    # Starts listening on feeds and notifies if there is new post.
+    # @param path [String] configuration file path
+    def self.start(path)
+      handle_exceptions do
+        print "Loading configuration from file #{path}... "
+        feeds, configuration = load_configuration(path)
+        feeds.each { |feed| feed.valid? }
+        puts 'completed.'
+
+        puts 'Loading notifiers... '
+        configuration.load_notifiers
+        puts 'completed.'
+
+        print 'Fetching feeds for the first use... '
+        observed_feeds = feeds.map do |feed|
+          {
+            feed: feed,
+            old_posts: feed.fetch,
+            new_posts: [] 
+          }
+        end
+        puts 'completed.'
+
+        puts 'Listener started...'
+        every configuration.interval do
+          
+          puts 'Fetching feeds...'
+          observed_feeds.each do |feed|
+            new_posts = feed[:feed].fetch
+
+            difference = Comparers::PostsComparer.get_new_posts(feed[:old_posts], new_posts)
+            
+            if difference.empty?
+              puts 'No new posts found.'
+            else
+              puts "#{difference.size} new posts found."
+              print 'Started sending notifications... '
+            end
+
+            difference.each do |post|
+              feed[:feed].notifications.each do |notification|
+                notification.notify(post)
+              end
+            end
+
+            unless difference.empty?
+              puts 'completed.'
+            end
+
+            feed[:old_posts] = new_posts
+            feed[:new_posts] = []
+          end
+        end
+      end
+    end
+
+    private
+
+    # Handle exceptions rescued from given block 
+    def self.handle_exceptions
+      yield if block_given?
+    rescue Errors::InvalidFeedUrlError
+      abort 'feed url collection is not valid (contains empty or invalid urls)'
+    rescue Errors::InvalidIntervalFormatError
+      abort 'interval value in configuration is not valud (should be in format: "(Number)(TimeType)" where TimeType is s, m, h or d)'
+    rescue Errors::InvalidVariablesFormatError
+      abort 'invalid variables format in configuration (should be a key-value pairs)'
+    rescue Errors::NoConfigurationFileError => e
+      abort "configuration file could not be loaded: #{e.message}"
+    rescue Errors::NotifierConfigurationError => e
+      abort "notifier #{e.notifier} has invalid configuration (#{e.message})."
+    rescue Errors::NotifierNotifyError => e
+      p     "notifier #{e.notifier} did not notify because of client error (#{e.message})."
+    rescue Errors::ParseFeedError => e
+      p     "feed on #{e.url} could not be parsed because of fetching/parsing error."
+    rescue Errors::UnsupportedNotifierError => e
+      abort "notifier #{e.notifier} is not supported by Feedbook."
+    rescue Errors::TemplateSyntaxError
+      abort "one of your templates in configuration file is not valid."
+    end
+
+    # Load configuration from given path
+    # @param path [String] configuration file path
+    # 
+    # @return [[Array, Feedbook::Configuration]] feeds and Configuration instance 
+    # @raise [Feedbook::Errors::NoConfigurationFileError] if path to config file is invalid of configuration file is missing
+    def self.load_configuration(path)
+      config = YAML.load_file(path)
+
+      feeds = config.fetch('feeds', []).map do |feed|
+        Feed.new(
+          urls:          feed['url'],
+          variables:     feed['variables'],
+          notifications: feed['notifications']
+        )
+      end
+      
+      configuration_hash = config.fetch('configuration', {})
+
+      configuration = Configuration.new(
+        twitter:     configuration_hash['twitter'],
+        facebook:    configuration_hash['facebook'],
+        interval:    configuration_hash['interval'],
+      )
+
+      [feeds, configuration]
+    rescue Errno::ENOENT => e
+      raise Errors::NoConfigurationFileError.new(e)
+    end
+
+  end
+end

data/lib/feedbook/notification.rb

@@ -0,0 +1,62 @@
+require 'liquid'
+require 'feedbook/factories/notifiers_factory'
+require 'feedbook/errors/template_syntax_error'
+require 'feedbook/errors/invalid_variables_format_error'
+
+module Feedbook
+  class Notification
+    
+    attr_reader :type, :template, :variables
+
+    # Initializes Notification instance
+    # @param opts = {} [Hash] Hash with 
+    # 
+    # @return [type] [description]
+    def initialize(opts = {})
+      @type      = opts.fetch(:type, '')
+      @variables = opts.fetch(:variables, {})
+      @template  = parse_template(opts.fetch(:template, ''))
+    end
+
+    # Notifies selected gateway about new post
+    # @param object [Object] objct that respond to :to_hash method
+    # 
+    # @return [NilClass] nil
+    def notify(object)
+      message = template.render(object.to_hash.merge(variables))
+      
+      notifier.notify(message)
+    end
+
+    # Validates if given parameters are valid
+    # 
+    # @return [NilClass] nil
+    # @raise [Feedbook::Errors::InvalidVariablesFormatError] if variables parameter is not a Hash
+    def valid?
+      unless variables.is_a? Hash
+        raise Errors::InvalidVariablesFormatError.new
+      end
+    end
+
+    private
+
+    # Parses template from string into a valid Liquid::Template
+    # @param template [String] String with valid Liquid template
+    # 
+    # @return [Liquid::Template] compiled Liquid template
+    # @raise [Feedbook::Errors::TemplateSyntaxError] if there is a SyntaxError inside template
+    def parse_template(template)
+      Liquid::Template.parse(template)
+    rescue SyntaxError => e
+      raise Errors::TemplateSyntaxError.new(e.message)
+    end
+
+    # Returms Notifier instance
+    # 
+    # @return [Notifier] Notifier instance for given type
+    def notifier
+      @notifier ||= Factories::NotifiersFactory.create(type)
+    end
+
+  end
+end

data/lib/feedbook/notifiers.rb

@@ -0,0 +1,5 @@
+require 'feedbook/notifiers/facebook_notifier'
+require 'feedbook/notifiers/irc_notifier'
+require 'feedbook/notifiers/mail_notifier'
+require 'feedbook/notifiers/null_notifier'
+require 'feedbook/notifiers/twitter_notifier'

data/lib/feedbook/notifiers/facebook_notifier.rb

@@ -0,0 +1,44 @@
+require 'singleton'
+require 'koala'
+require 'feedbook/errors/notifier_configuration_error'
+require 'feedbook/errors/notifier_notify_error'
+
+module Feedbook
+  module Notifiers
+    class FacebookNotifier
+      include Singleton
+
+      # Sends notification to Facebook wall
+      # @param message [String] message to be send to Facebook wall
+      # 
+      # @return [NilClass] nil
+      # @raise [Feedbook::Errors::NotifierNotifyError] if notify method fails 
+      def notify(message)
+        if client.nil?
+          puts "Message has not been notified on Facebook: #{message} because of invalid client configuration"
+        else
+          client.put_wall_post(message)
+          puts "New message has been notified on Facebook: #{message}"
+        end
+      rescue Koala::KoalaError => e
+        raise Errors::NotifierNotifyError.new(:facebook, e.message)
+      end
+
+      # Load configuration for FacebookNotifier
+      # @param configuration = {} [Hash] Configuration hash (required: token)
+      # 
+      # @return [NilClass] nil
+      # @raise [Feedbook::Errors::NotifierConfigurationError] if notifier configuration fails 
+      def load_configuration(configuration = {})
+        @client = Koala::Facebook::API.new(configuration.fetch('token'))
+        
+        puts 'Configuration loaded for FacebookNotifier'
+      rescue Koala::KoalaError => e
+        raise Errors::NotifierConfigurationError.new(:facebook, e.message)
+      end
+
+      private
+      attr_reader :client
+    end
+  end
+end