eventify 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1794610fc1c068a4f1d74d56f75bfab3ace97d6c
+  data.tar.gz: bbec3e34aeb04c91cc38316ef61abe58013af376
+SHA512:
+  metadata.gz: 2ad9d63a20ebdca21135cafa59fc54facab5a2b0c365aac974a10b65a9051136d5f4aa32b40152a29bc1cbd363dcaa144a4f3084234f6fa7a052656bb0b88c3f
+  data.tar.gz: c44b7b19adc7f91199b5cd9051dc0502c8883b2eb164428ec6bc935a6d853026d6c619e118ce2c1864b11df0ecd6fd70aa04b2f7d7995bce83f837cb7ce789d2

data/.gitignore

@@ -0,0 +1,4 @@
+*.log
+/coverage/*
+/pkg/*
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,11 @@
+rvm:
+ - 2.0.0
+ - 2.1.0
+ - ruby-head
+notifications:
+  recipients:
+    - jarmo.p@gmail.com
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+

data/Gemfile

@@ -0,0 +1,16 @@
+source "https://rubygems.org"
+
+gem "rufus-scheduler"
+
+group :development do
+  gem "guard"
+  gem "guard-rspec"
+  gem "guard-bundler"
+  gem "wdm", platform: :mingw
+  gem "win32console", platform: :mingw
+  gem "ruby_gntp"
+end
+
+gemspec
+
+gem "coveralls", :require => false

data/Guardfile

@@ -0,0 +1,12 @@
+notification :ruby_gntp
+#interactor :off
+
+guard 'rspec', version: 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+
+guard 'bundler' do
+  watch('Gemfile')
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Jarmo Pertman
+
+MIT License
+
+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/README.md

@@ -0,0 +1,67 @@
+# Eventify
+[![Gem Version](https://badge.fury.io/rb/eventify.png)](http://badge.fury.io/rb/eventify)
+[![Build Status](https://api.travis-ci.org/jarmo/eventify.png)](http://travis-ci.org/jarmo/eventify)
+[![Coverage](https://coveralls.io/repos/jarmo/eventify/badge.png?branch=master)](https://coveralls.io/r/jarmo/eventify)
+[![Dependency Status](https://gemnasium.com/jarmo/eventify.png)](https://gemnasium.com/jarmo/eventify)
+[![Code Climate](https://codeclimate.com/github/jarmo/eventify.png)](https://codeclimate.com/github/jarmo/eventify)
+
+Are you tired of missing some cool events because you just didn't know them
+happening? Are you tired of not getting good sitting places because you heard
+of some event too late?
+
+If the answer was yes to either of these questions then Eventify can help you!
+
+Eventify will notify you about upcoming events from different
+providers/organizers.
+
+## Installation
+
+    $ gem install eventify
+
+## Usage
+
+Create configuration file:
+
+    $ ruby -reventify -e "Eventify::Configuration.new.save"
+
+Edit configuration settings by adding your e-mail into `subscribers` list:
+    
+    $ vi ~/.eventify/config.yaml
+
+Run it from command line and add it into `cron`:
+
+    $ ruby -reventify -e "Eventify.new.process_new_events"
+
+## Supported Providers
+
+The following providers are currently supported:
+
+* [FBI](http://fbi.ee)
+* [Piletilevi](http://www.piletilevi.ee/)
+* [Ticketpro](http://www.ticketpro.ee/)
+
+## Adding New Providers
+
+Adding new providers is easy. You just need to create a class with one method
+satisfying the contract:
+
+```ruby
+require "eventify"
+
+class MyCustomProvider < Eventify::Provider::Base
+  def self.fetch
+    # fetch some atom feed
+    rss = SimpleRSS.parse open("http://example.org/rss.xml")
+    rss.entries.map { |entry| new id: entry.guid, title: entry.title, link: entry.link, date: entry.pubDate }
+  end
+end
+
+# use that provider with Eventify
+eventify = Eventify.new
+eventify.providers = [MyCustomProvider]
+eventify.process_new_events
+```
+
+## License
+
+See [LICENSE](https://github.com/jarmo/eventify/blob/master/LICENSE).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+task :release => :spec
+
+require "yard"
+YARD::Rake::YardocTask.new

data/eventify.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'eventify/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "eventify"
+  spec.version       = Eventify::VERSION
+  spec.authors       = ["Jarmo Pertman"]
+  spec.email         = ["jarmo.p@gmail.com"]
+  spec.description   = %q{Get notifications about upcoming events from different providers/organizers.}
+  spec.summary       = %q{Get notifications about upcoming events from different providers/organizers.}
+  spec.homepage      = "https://github.com/jarmo/eventify"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "simple-rss"
+  spec.add_dependency "nokogiri"
+  spec.add_dependency "sqlite3"
+  spec.add_dependency "mail"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "webmock"
+  spec.add_development_dependency "yard"
+end

data/lib/eventify.rb

@@ -0,0 +1,38 @@
+require File.expand_path("eventify/version", __dir__)
+require File.expand_path("eventify/configuration", __dir__)
+require File.expand_path("eventify/provider/base", __dir__)
+require File.expand_path("eventify/provider/fbi", __dir__)
+require File.expand_path("eventify/provider/piletilevi", __dir__)
+require File.expand_path("eventify/provider/ticketpro", __dir__)
+require File.expand_path("eventify/database", __dir__)
+require File.expand_path("eventify/mail", __dir__)
+
+class Eventify
+  attr_reader :configuration
+
+  def initialize(configuration=Eventify::Configuration.new)
+    @configuration = configuration
+  end
+
+  def all_events
+    @all_events ||= providers.flat_map(&:fetch).uniq
+  end
+
+  def new_events
+    @new_events ||= all_events.reject(&:exists?)
+  end
+
+  def process_new_events
+    all_new_events = new_events
+    return if all_new_events.empty?
+
+    Eventify::Mail.deliver all_new_events, @configuration
+    all_new_events.each(&:save)
+  end
+
+  attr_writer :providers
+
+  def providers
+    @providers ||= [Eventify::Provider::Piletilevi, Eventify::Provider::Ticketpro, Eventify::Provider::FBI]
+  end
+end

data/lib/eventify/configuration.rb

@@ -0,0 +1,31 @@
+require "yaml"
+
+class Eventify::Configuration
+  PATH = File.expand_path("~/.eventify/config.yaml")
+
+  def initialize(configuration = {})
+    @configuration = default_configuration.merge(load).merge(configuration)
+  end
+
+  def save
+    File.open(PATH, "w") { |f| f.write YAML.dump(@configuration) }
+  end
+
+  def [](key)
+    @configuration[key]
+  end
+
+  private
+
+  def default_configuration
+    {
+      subscribers: ["user@example.org"],
+      mail: Mail.delivery_method.settings
+    }
+  end
+
+  def load
+    YAML.load(File.read(PATH)) rescue {}
+  end
+
+end

data/lib/eventify/database.rb

@@ -0,0 +1,56 @@
+require "sqlite3"
+
+class Eventify::Database
+  PATH = File.expand_path("~/.eventify/events.sqlite3", __dir__)
+
+  class << self
+    def exists?(event)
+      results = sqlite.execute "select 1 from event where id=? and provider=? and link=?", event.id, event.provider, event.link
+      !results.empty?
+    end
+
+    def save(event)
+      sqlite.execute "insert into event values(?, ?, ?, ?, ?)", 
+        event.id,
+        event.provider,
+        event.title,
+        event.link,
+        event.date.to_s
+    end
+
+    def events
+      translated_events = []
+      sqlite.execute("select * from event") do |event|
+        translated_events << const_get(event["provider"]).new(
+          id: event["id"],
+          title: event["title"],
+          link: event["link"],
+          date: Time.parse(event["date"])
+        )
+      end
+
+      translated_events
+    end
+
+    private
+
+    def sqlite
+      @sqlite ||= begin
+                    FileUtils.mkdir_p File.dirname(PATH)
+                    database = SQLite3::Database.new PATH
+                    database.results_as_hash = true
+
+                    database.execute "create table if not exists event(
+                      id text,
+                      provider text,
+                      title text,
+                      link text,
+                      date text,
+                      primary key (id, provider, link)
+                    )"
+
+                    database
+                  end
+    end
+  end
+end

data/lib/eventify/mail.rb

@@ -0,0 +1,37 @@
+require "mail"
+
+class Eventify::Mail
+  class << self
+    def deliver(new_events, configuration)
+      formatted_events = format(new_events)
+
+      configuration[:subscribers].each do |subscriber|
+        ::Mail.deliver do
+          delivery_method :smtp, configuration[:mail]
+
+          content_type "text/plain; charset=utf-8"
+
+          to subscriber
+          from "no-reply@eventify.io"
+          subject "Event Rumours"
+          body formatted_events
+        end
+      end
+    end
+
+    def format(events)
+      header = "There are some rumours going on about #{events.size} possible awesome events:"
+
+      formatted_events = events.sort.reduce([header, ""]) do |memo, event|
+        memo << "* #{event.title}".force_encoding("UTF-8")
+        memo << "    #{event.link}"
+        memo << ""
+      end
+
+      footer = "Your Humble Servant,\nEventify"
+
+      formatted_events << footer
+      formatted_events.join("\n")
+    end
+  end
+end

data/lib/eventify/provider/base.rb

@@ -0,0 +1,51 @@
+class Eventify
+  module Provider
+    class Base
+      include Comparable
+
+      class << self
+        def fetch
+          raise NotImplementedError
+        end
+      end
+
+      attr_reader :id, :title, :link, :date
+
+      def initialize(event)
+        @id = event[:id] or raise MissingAttributeError.new("id is missing")
+        @title = event[:title] or raise MissingAttributeError.new("title is missing")
+        @link = event[:link] or raise MissingAttributeError.new("link is missing")
+        @date = event[:date]
+      end
+
+      def provider
+        @provider ||= self.class.name
+      end
+
+      def save
+        Database.save self 
+        self
+      end
+
+      def exists?
+        Database.exists? self
+      end
+
+      def ==(other)
+        id == other.id && provider == other.provider
+      end
+
+      alias_method :eql?, :==
+
+      def hash
+        "#{id}-#{provider}-#{link}".hash
+      end
+
+      def <=>(other)
+        title <=> other.title
+      end
+
+      MissingAttributeError = Class.new(RuntimeError)
+    end
+  end
+end

data/lib/eventify/provider/fbi.rb

@@ -0,0 +1,17 @@
+require "open-uri"
+require "nokogiri"
+
+module Eventify::Provider
+  class FBI < Base
+    URL = "http://www.fbi.ee/" 
+
+    class << self
+      def fetch
+        doc = Nokogiri::HTML(open(URL))
+        doc.search(".article-list li h2 a").map do |a|
+          new id: a["href"], title: a.content, link: a["href"], date: Time.now
+        end
+      end
+    end
+  end
+end

data/lib/eventify/provider/piletilevi.rb

@@ -0,0 +1,31 @@
+require "simple-rss"
+require "open-uri"
+
+module Eventify::Provider
+  class Piletilevi < Base
+    # http://www.piletilevi.ee/est/uldinfo/rss
+    URLS = [
+      "http://www.piletilevi.ee/news.rss.php?path=est/uudised",
+      "http://www.piletilevi.ee/news.rss.php?path=est/teatriuudised",
+      "http://www.piletilevi.ee/news.rss.php?path=est/muudatused",
+      "http://www.piletilevi.ee/category.rss.php?path=est/piletid/muusika",
+      # 404?
+      #"http://www.piletilevi.ee/category.rss.php?path=est/piletid/teater_-_kunst",
+      "http://www.piletilevi.ee/category.rss.php?path=est/piletid/kogupere",
+      "http://www.piletilevi.ee/category.rss.php?path=est/piletid/sport",
+      "http://www.piletilevi.ee/category.rss.php?path=est/piletid/festival",
+      "http://www.piletilevi.ee/category.rss.php?path=est/piletid/film",
+      "http://www.piletilevi.ee/category.rss.php?path=est/piletid/kinkekaardid",
+      "http://www.piletilevi.ee/category.rss.php?path=est/piletid/varia"
+    ]
+
+    class << self
+      def fetch
+        URLS.each.reduce([]) do |memo, url|
+          rss = SimpleRSS.parse open(url)
+          memo + rss.entries.map { |entry| new id: entry.guid, title: entry.title, link: entry.link, date: entry.pubDate }
+        end
+      end
+    end
+  end
+end