feedbook 0.9.0

data/lib/feedbook/notifiers/irc_notifier.rb

@@ -0,0 +1,42 @@
+require 'singleton'
+require 'irc-notify'
+
+module Feedbook
+  module Notifiers
+    class IRCNotifier
+      include Singleton
+
+      # Sends notification to IRC
+      # @param message [String] message to be send to IRC
+      # 
+      # @return [NilClass] nil
+      def notify(message)
+        client.register(nick)
+        client.notify(message)
+        client.quit
+        
+        puts "New message has been notified on IRC: #{message}"
+      end
+
+      # Load configuration for IRCNotifier
+      # @param configuration = {} [Hash] Configuration hash (required: address, domain, username, password, to, from, subject)
+      # 
+      # @return [NilClass] nil
+      def load_configuration(configuration = {})
+        irc_url     = configuration.fetch('url')
+        irc_port    = configuration.fetch('port')
+        ssl_enabled = configuration.fetch('ssl_enabled')
+
+        @channel = configuration.fetch('channel')
+        @nick    = configuration.fetch('nick')
+        
+        @client = IrcNotify::Client.build(irc_url, irc_port, ssl: ssl_enabled)
+
+        puts 'Configuration loaded for IRCNotifier'
+      end
+
+      private
+      attr_reader :client, :nick, :channel
+    end
+  end
+end

data/lib/feedbook/notifiers/mail_notifier.rb

@@ -0,0 +1,52 @@
+require 'singleton'
+require 'mail'
+
+module Feedbook
+  module Notifiers
+    class MailNotifier
+      include Singleton
+
+      # Sends notification to Mail
+      # @param message [String] message to be send via email
+      # 
+      # @return [NilClass] nil
+      def notify(message)
+        Mail.deliver do
+          to      to
+          from    from
+          subject subject
+          body    message
+        end
+
+        puts "New message has been notified on Mail: #{message}"
+      end
+
+      # Load configuration for MailNotifier
+      # @param configuration = {} [Hash] Configuration hash (required: address, domain, username, password, to, from, subject)
+      # 
+      # @return [NilClass] nil
+      def load_configuration(configuration = {})
+        options = { address:              configuration.fetch('address'),
+                    port:                 configuration.fetch('port', 5870),
+                    domain:               configuration.fetch('domain'),
+                    user_name:            configuration.fetch('username'),
+                    password:             configuration.fetch('password'),
+                    authentication:       configuration.fetch('authentication', 'plain'),
+                    enable_starttls_auto: configuration.fetch('enable_starttls_auto', true)  }
+
+        @to      = configuration.fetch('to')
+        @from    = configuration.fetch('from')
+        @subject = configuration.fetch('subject')
+
+        Mail.defaults do
+          delivery_method :smtp, options
+        end
+
+        puts 'Configuration loaded for MailNotifier'
+      end
+
+      private
+      attr_reader :to, :from, :subject
+    end
+  end
+end

data/lib/feedbook/notifiers/null_notifier.rb

@@ -0,0 +1,25 @@
+require 'singleton'
+
+module Feedbook
+  module Notifiers
+    class NullNotifier
+      include Singleton
+
+      # Sends notification to Nil
+      # @param message [String] message to be displayed in console
+      # 
+      # @return [NilClass] nil
+      def notify(message)
+        puts "New message has been notified: #{message}"
+      end
+      
+      # Load configuration for NullNotifier
+      # @param configuration = {} [Hash] Configuration hash
+      # 
+      # @return [NilClass] nil
+      def load_configuration(configuration = {})
+        puts 'Configuration loaded for NullNotifier'
+      end
+    end
+  end
+end

data/lib/feedbook/notifiers/twitter_notifier.rb

@@ -0,0 +1,49 @@
+require 'singleton'
+require 'twitter'
+require 'feedbook/errors/notifier_configuration_error'
+require 'feedbook/errors/notifier_notify_error'
+
+module Feedbook
+  module Notifiers
+    class TwitterNotifier
+      include Singleton
+
+      # Sends notification to Twitter
+      # @param message [String] message to be send to Twitter
+      # 
+      # @return [NilClass] nil
+      # @raise [Feedbook::Errors::NotifierNotifyError] if notify method fails 
+      def notify(message)
+        if client.nil?
+          puts "Message has not been notified on Twitter: #{message} because of invalid client configuration"
+        else
+          client.update(message)
+          puts "New message has been notified on Twitter: #{message}"
+        end
+      rescue Twitter::Error => e
+        raise Errors::NotifierNotifyError.new(:twitter, e.message)
+      end
+
+      # Load configuration for TwitterNotifier
+      # @param configuration = {} [Hash] Configuration hash (required: consumer_key, consumer_secret, access_token, access_token_secret)
+      # 
+      # @return [NilClass] nil
+      # @raise [Feedbook::Errors::NotifierConfigurationError] if notifier configuration fails 
+      def load_configuration(configuration = {})
+        @client = Twitter::REST::Client.new do |config|
+          config.consumer_key        = configuration.fetch('consumer_key')
+          config.consumer_secret     = configuration.fetch('consumer_secret')
+          config.access_token        = configuration.fetch('access_token')
+          config.access_token_secret = configuration.fetch('access_token_secret')
+        end
+
+        puts 'Configuration loaded for TwitterNotifier'
+      rescue Twitter::Error => e
+        raise Errors::NotifierConfigurationError.new(:twitter, e.message)
+      end
+
+      private
+      attr_reader :client
+    end
+  end
+end

data/lib/feedbook/post.rb

@@ -0,0 +1,33 @@
+module Feedbook
+  class Post
+
+    attr_reader :author, :published, :url, :title, :feed_title 
+
+    # Initializes new Post from opts Hash
+    # @param opts = {} [Hash] Hash with params required for Post creation
+    # 
+    # @return [NilClass] nil
+    def initialize(opts = {})
+      @author     = opts.fetch(:author)
+      @published  = opts.fetch(:published)
+      @url        = opts.fetch(:url)
+      @title      = opts.fetch(:title)
+      @feed_title = opts.fetch(:feed_title)
+    end
+
+    # Returns hash with values from posts.
+    # 
+    # @return [Hash] Hash with post variables
+    def to_hash
+      {
+        'author'     => author,
+        'published'  => published,
+        'url'        => url,
+        'title'      => title,
+        'feed_title' => feed_title
+      }
+    end
+    alias :to_h :to_hash
+
+  end
+end

data/lib/feedbook/version.rb

@@ -0,0 +1,3 @@
+module Feedbook
+  VERSION = '0.9.0'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'coveralls'
+Coveralls.wear!
+
+require 'feedbook'
+
+RSpec.configure do |config|
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  if config.files_to_run.one?
+    config.default_formatter = 'doc'
+  end
+
+  config.profile_examples = 10
+  config.order = :random
+
+  Kernel.srand config.seed
+
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = :expect
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.syntax = :expect
+    mocks.verify_partial_doubles = true
+  end
+end

data/spec/unit/lib/comparers/posts_comparer_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Feedbook::Comparers::PostsComparer do
+
+  describe '#get_new_posts' do
+    let(:old_posts) { [OpenStruct.new(name: 'test1', url: 'test1.blog.lo'), OpenStruct.new(name: 'test1', url: 'test1.blog.lo'), OpenStruct.new(name: 'test3', url: 'test3.blog.lo'), OpenStruct.new(name: 'test1', url: 'test2.blog.lo')] }
+    let(:new_posts) { old_posts + [OpenStruct.new(name: 'test1', url: 'test4.blog.lo'), OpenStruct.new(name: 'test1', url: 'test7.blog.lo'), OpenStruct.new(name: 'test6', url: 'test5.blog.lo'), OpenStruct.new(name: 'test7', url: 'test2.blog.lo')] }
+
+    it 'should return only posts with urls that did not exists in old posts' do
+      expect(Feedbook::Comparers::PostsComparer.get_new_posts(old_posts, new_posts)).to eq([OpenStruct.new(name: 'test1', url: 'test4.blog.lo'), OpenStruct.new(name: 'test1', url: 'test7.blog.lo'), OpenStruct.new(name: 'test6', url: 'test5.blog.lo')])
+    end
+  end
+end

data/spec/unit/lib/configuration_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Feedbook::Configuration do
+  
+  let(:hash) do
+    {
+      twitter:  {},
+      facebook: {},
+      irc:      {},
+      interval: '5m'
+    }
+  end
+
+  before :each do
+    allow(Feedbook::Helpers::TimeIntervalParser).to receive(:parse).with('5m').and_return(300)
+    allow(Feedbook::Helpers::TimeIntervalParser).to receive(:parse).with('').and_raise(Feedbook::Errors::InvalidIntervalFormatError.new)
+  end
+
+  subject { Feedbook::Configuration.new(hash) } 
+  
+  describe '#initialize' do
+
+    it 'parses hash and creates Configuration instance' do
+      expect(subject.interval).to eq(300)
+    end
+  
+    it 'should raise Errors::InvalidIntervalFormatError if interval parameter is missing' do
+      expect { Feedbook::Configuration.new({}) }.to raise_error(Feedbook::Errors::InvalidIntervalFormatError)
+    end
+  end
+
+  describe '#load_notifiers' do
+
+    it 'should return hash with Post parameters' do
+      expect(Feedbook::Notifiers::TwitterNotifier).to  receive_message_chain(:instance, load_configuration: {}) { true }
+      expect(Feedbook::Notifiers::FacebookNotifier).to receive_message_chain(:instance, load_configuration: {}) { true }
+      expect(Feedbook::Notifiers::IRCNotifier).to      receive_message_chain(:instance, load_configuration: {}) { true }
+
+      subject.load_notifiers
+    end
+  end
+
+end

data/spec/unit/lib/factories/notifiers_factory_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Feedbook::Factories::NotifiersFactory do
+
+  describe '#create' do
+
+    context 'FacebookNotifier' do
+      it { expect(Feedbook::Factories::NotifiersFactory.create('facebook')).to  be(Feedbook::Notifiers::FacebookNotifier.instance) }
+      it { expect(Feedbook::Factories::NotifiersFactory.create(:facebook)).to  be(Feedbook::Notifiers::FacebookNotifier.instance) }
+    end
+
+    context 'IRCNotifier' do
+      it { expect(Feedbook::Factories::NotifiersFactory.create('irc')).to  be(Feedbook::Notifiers::IRCNotifier.instance) }
+      it { expect(Feedbook::Factories::NotifiersFactory.create(:irc)).to  be(Feedbook::Notifiers::IRCNotifier.instance) }
+    end
+
+    context 'NullNotifier' do
+      it { expect(Feedbook::Factories::NotifiersFactory.create('null')).to  be(Feedbook::Notifiers::NullNotifier.instance) }
+      it { expect(Feedbook::Factories::NotifiersFactory.create(:null)).to  be(Feedbook::Notifiers::NullNotifier.instance) }
+    end
+
+    context 'TwitterNotifier' do
+      it { expect(Feedbook::Factories::NotifiersFactory.create('twitter')).to  be(Feedbook::Notifiers::TwitterNotifier.instance) }
+      it { expect(Feedbook::Factories::NotifiersFactory.create(:twitter)).to  be(Feedbook::Notifiers::TwitterNotifier.instance) }
+    end
+
+  end
+end

data/spec/unit/lib/feed_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Feedbook::Feed do
+  
+  let(:hash) do
+    {
+      urls:           'http://blog.test.lo/blog http://blog.test.lo/blog2',
+      notifications:  [
+        { 'type' => 'twitter',  'template' => '{{ test_variable }} POST'   }, 
+        { 'type' => 'facebook', 'template' => '{{ test_variable }} POST 2' }
+      ],
+      variables:      { 'test_variable' => 'test_value' }
+    }
+  end
+
+  subject { Feedbook::Feed.new(hash) } 
+  
+  describe '#initialize' do
+
+    it 'parses hash and creates Feed instance' do
+      expect(subject.urls).to      eq(['http://blog.test.lo/blog', 'http://blog.test.lo/blog2'])
+      expect(subject.variables).to eq({ 'test_variable' => 'test_value' })
+    end
+  
+    it 'should raise Errors::InvalidIntervalFormatError if interval parameter is missing' do
+      expect(Feedbook::Feed.new({}).urls).to          eq([])
+      expect(Feedbook::Feed.new({}).notifications).to eq([])
+      expect(Feedbook::Feed.new({}).variables).to     eq({})
+    end
+  end
+
+  describe '#fetch' do
+
+    it 'should send fetch_and_parse to Feedjira::Feed' do
+      allow(Feedjira::Feed).to  receive(:fetch_and_parse).with('http://blog.test.lo/blog').and_return([])
+      allow(Feedjira::Feed).to  receive(:fetch_and_parse).with('http://blog.test.lo/blog2').and_return([])
+
+      expect(subject.fetch).to eq([])
+    end
+  end
+
+end

data/spec/unit/lib/helpers/time_interval_parser_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Feedbook::Helpers::TimeIntervalParser do
+
+  describe '#parse' do
+
+    context 'with proper input parameter' do
+      it { expect(Feedbook::Helpers::TimeIntervalParser.parse('1s')).to  eq(1) }
+      it { expect(Feedbook::Helpers::TimeIntervalParser.parse('40s')).to eq(40) }
+      it { expect(Feedbook::Helpers::TimeIntervalParser.parse('1m')).to  eq(60) }
+      it { expect(Feedbook::Helpers::TimeIntervalParser.parse('30m')).to eq(1800) }
+      it { expect(Feedbook::Helpers::TimeIntervalParser.parse('1h')).to  eq(3600) }
+      it { expect(Feedbook::Helpers::TimeIntervalParser.parse('24h')).to eq(86400) }
+      it { expect(Feedbook::Helpers::TimeIntervalParser.parse('1d')).to  eq(86400) }
+      it { expect(Feedbook::Helpers::TimeIntervalParser.parse('10d')).to eq(864000) }
+    end
+
+    context 'with invalid input parameter' do
+      it { expect { Feedbook::Helpers::TimeIntervalParser.parse(nil)  }.to  raise_error(Feedbook::Errors::InvalidIntervalFormatError) }
+      it { expect { Feedbook::Helpers::TimeIntervalParser.parse('')   }.to   raise_error(Feedbook::Errors::InvalidIntervalFormatError) }
+      it { expect { Feedbook::Helpers::TimeIntervalParser.parse('xx') }.to raise_error(Feedbook::Errors::InvalidIntervalFormatError) }
+    end
+
+  end
+
+end

data/spec/unit/lib/listener_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Feedbook::Listener do
+  
+  subject { Feedbook::Listener } 
+  
+  describe '#start' do
+
+    let(:configuration) { double }
+    let(:feeds) { [double, double, double] }
+
+    before :each do
+      allow(configuration).to receive(:interval).and_return(300)
+      allow(subject).to receive(:load_configuration).with('feedbook.yml').and_return([feeds, configuration])
+    end
+
+    it 'parses hash and creates Feed instance' do
+      allow(configuration).to receive(:load_notifiers)
+      feeds.each do |feed|
+        expect(feed).to receive(:fetch)
+        expect(feed).to receive(:valid?)
+      end
+
+      expect(Object).to receive(:every).with(300).and_return(300)
+
+      subject.start('feedbook.yml')
+    end
+  end
+end

data/spec/unit/lib/notification_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Feedbook::Notification do
+  
+  let(:hash) do
+    {
+      type:      'twitter',
+      template:  'Post {{ test_variable }} on {{ url }}',
+      variables: { 'test_variable' => 'test_value' }
+    }
+  end
+
+  subject { Feedbook::Notification.new(hash) }
+  
+  describe '#initialize' do
+
+    it 'parses hash and creates Notification instance' do
+      expect(subject.type).to      eq('twitter')
+      expect(subject.variables).to eq({ 'test_variable' => 'test_value' })
+    end
+  
+    it 'should set default values' do
+      expect(Feedbook::Notification.new({}).type).to      eq('')
+      expect(Feedbook::Notification.new({}).variables).to eq({})
+    end
+  end
+
+  describe '#notify' do
+
+    it 'create and send notification message to notifier' do
+      expect(Liquid::Template).to receive_message_chain(parse: 'Post {{ test_variable }} on {{ url }}', render: { 'test_variable' => 'test_value', 'url' => 'test_url' })
+      expect(subject).to          receive_message_chain(:notifier, notify: OpenStruct.new(to_hash: { 'url' => 'test_url' }))
+      
+      subject.notify(OpenStruct.new(to_hash: { 'url' => 'test_url' }))
+    end
+
+    it 'raises TemplateSyntaxError if template was not correct' do
+      allow(Liquid::Template).to receive(:parse).with('Post {{ test_variable }} on {{ url }}').and_raise(SyntaxError)
+      
+      expect { subject.notify(OpenStruct.new(to_hash: { 'url' => 'test_url' })) }.to raise_error(Feedbook::Errors::TemplateSyntaxError)
+    end
+  end
+
+end