calagator 0.0.1.pre1

data/app/models/calagator/event/search_engine/sql.rb

@@ -0,0 +1,107 @@
+module Calagator
+
+class Event < ActiveRecord::Base
+  class SearchEngine
+    class Sql < Struct.new(:query, :opts)
+      # Return an Array of non-duplicate Event instances matching the search +query+..
+      #
+      # Options:
+      # * :order => How to order the entries? Defaults to :date. Permitted values:
+      #   * :date => Sort by date
+      #   * :name => Sort by event title
+      #   * :title => same as :name
+      #   * :venue => Sort by venue title
+      # * :limit => Maximum number of entries to return. Defaults to 50.
+      # * :skip_old => Return old entries? Defaults to false.
+      def self.search(*args)
+        new(*args).all
+      end
+
+      def self.score?
+        false
+      end
+
+      def all
+        current_events + past_events
+      end
+
+      private
+
+      def current_events
+        search.current.scope.to_a
+      end
+
+      def past_events
+        skip_old ? [] : search.past.scope.to_a
+      end
+
+      def search
+        base.keywords.order.limit
+      end
+
+      def skip_old
+        opts[:skip_old] == true
+      end
+
+      protected
+
+      attr_accessor :scope
+
+      def base
+        column_names = Event.column_names.map { |name| "events.#{name}"}
+        column_names << "venues.id"
+        @scope = Event.scoped
+          .group(column_names)
+          .joins("LEFT OUTER JOIN taggings on taggings.taggable_id = events.id AND taggings.taggable_type LIKE '%Event'")
+          .joins("LEFT OUTER JOIN tags ON tags.id = taggings.tag_id")
+          .includes(:venue)
+        self
+      end
+
+      def keywords
+        query_conditions = @scope.where('LOWER(events.title) LIKE ?', "%#{query.downcase}%")
+          .where('LOWER(events.description) LIKE ?', "%#{query.downcase}%")
+
+        query_conditions = query.split.inject(query_conditions) do |query_conditions, keyword|
+          like = "%#{keyword.downcase}%"
+          query_conditions
+            .where(['LOWER(events.url) LIKE ?', like])
+            .where(['LOWER(tags.name) = ?', keyword])
+        end
+        @scope = @scope.where(query_conditions.where_values.join(' OR '))
+        self
+      end
+
+      def order
+        order = case opts[:order].try(:to_sym)
+        when :name, :title
+          'LOWER(events.title) ASC'
+        when :location, :venue
+          'LOWER(venues.title) ASC'
+        else
+          'events.start_time DESC'
+        end
+        @scope = @scope.order(order)
+        self
+      end
+
+      def limit
+        limit = opts.fetch(:limit, 50)
+        @scope = @scope.limit(limit)
+        self
+      end
+
+      def current
+        @scope = @scope.where("events.start_time >= ?", Date.yesterday.to_time)
+        self
+      end
+
+      def past
+        @scope = @scope.where("events.start_time < ?", Date.yesterday.to_time)
+        self
+      end
+    end
+  end
+end
+
+end

data/app/models/calagator/source.rb

@@ -0,0 +1,115 @@
+# == Schema Information
+# Schema version: 20110604174521
+#
+# Table name: sources
+#
+#  id          :integer         not null, primary key
+#  title       :string(255)
+#  url         :string(255)
+#  imported_at :datetime
+#  created_at  :datetime
+#  updated_at  :datetime
+#  reimport    :boolean
+#
+
+# == Source
+#
+# A model that represents a source of events data, such as feeds for hCal, iCal, etc.
+require "calagator/decode_html_entities_hack"
+require "paper_trail"
+require "loofah-activerecord"
+require "loofah/activerecord/xss_foliate"
+
+module Calagator
+
+class Source < ActiveRecord::Base
+  self.table_name = "sources"
+
+  attr_protected
+
+  validate :assert_url
+
+  has_many :events,  :dependent => :destroy
+  has_many :venues,  :dependent => :destroy
+
+  scope :listing, -> { order('created_at DESC') }
+
+  has_paper_trail
+
+  xss_foliate
+  include DecodeHtmlEntitiesHack
+
+  # Return a newly-created or existing Source record matching the given
+  # attributes. The +attrs+ hash is the same format as used when calling
+  # Source::new.
+  #
+  # This method is intended to supplement the import process by providing a
+  # single Source record for each unique URL, thus when multiple people import
+  # the same URL, there will only be one Source record.
+  #
+  # The :reimport flag is given special handling: If the original Source record
+  # has this set to true, it will never be set back to false by this method.
+  # The intent behind this is that if one person wants this Source reimported,
+  # the reimporting shouldn't be disabled by someone else manually importing it
+  # without setting the reimport flag. If someone really wants to turn off
+  # reimporting, they should edit the source.
+  def self.find_or_create_from(attrs={})
+    return new(attrs) unless attrs[:url]
+
+    source = find_or_create_by_url(attrs[:url])
+    source.reimport = true if attrs.delete(:reimport)
+    source.attributes = attrs
+    source.save if source.changed?
+    source
+  end
+
+  # Create events for this source. Returns the events created. URL must be set
+  # for this source for this to work.
+  def create_events!(opts={})
+    save!
+    events = to_events(opts).select(&:valid?)
+    events.reject!(&:old?) if opts[:skip_old]
+    events.each(&:save!)
+    events
+  end
+
+  # Normalize the URL.
+  def url=(value)
+    url = URI.parse(value.strip)
+    url.scheme = 'http' unless ['http','https','ftp'].include?(url.scheme) || url.scheme.nil?
+    write_attribute(:url, url.scheme.nil? ? 'http://'+value.strip : url.to_s)
+  rescue URI::InvalidURIError
+    false
+  end
+
+  # Returns an Array of Event objects that were read from this source.
+  #
+  # Options:
+  # * :url -- URL of data to import. Defaults to record's #url attribute.
+  # * :skip_old -- Should old events be skipped? Default is true.
+  def to_events(opts={})
+    raise ActiveRecord::RecordInvalid, self unless valid?
+
+    self.imported_at = Time.now
+    opts[:url] ||= self.url
+    opts[:source] = self
+    Source::Parser.to_events(opts)
+  end
+
+  # Return the name of the source, which can be its title or URL.
+  def name
+    [title, url].detect(&:present?)
+  end
+
+  private
+
+  # Ensure that the URL for this source is valid.
+  def assert_url
+    URI.parse(url)
+  rescue URI::InvalidURIError
+    errors.add :url, "has invalid format"
+    false
+  end
+end
+
+end

data/app/models/calagator/source/importer.rb

@@ -0,0 +1,46 @@
+module Calagator
+
+class Source < ActiveRecord::Base
+  class Importer < Struct.new(:source, :events)
+    def initialize params
+      self.source = Source.find_or_create_from(params)
+    end
+
+    def import
+      return unless source.valid?
+      self.events = source.create_events!
+
+      self.events.present?
+
+    rescue Source::Parser::NotFound
+      add_error "No events found at remote site. Is the event identifier in the URL correct?"
+    rescue Source::Parser::HttpAuthenticationRequiredError
+      add_error "Couldn't import events, remote site requires authentication."
+    rescue OpenURI::HTTPError
+      add_error "Couldn't download events, remote site may be experiencing connectivity problems."
+    rescue Errno::EHOSTUNREACH
+      add_error "Couldn't connect to remote site."
+    rescue SocketError
+      add_error "Couldn't find IP address for remote site. Is the URL correct?"
+    rescue Exception => e
+      add_error "Unknown error: #{e}"
+    end
+
+    def failure_message
+      if events.nil?
+        "Unable to import: #{source.errors.full_messages.to_sentence}"
+      else
+        "Unable to find any upcoming events to import from this source"
+      end
+    end
+
+    private
+
+    def add_error message
+      source.errors.add :base, message
+      nil
+    end
+  end
+end
+
+end

data/app/models/calagator/source/parser.rb

@@ -0,0 +1,128 @@
+require "net/http"
+require "net/https"
+require "open-uri"
+
+# == Source::Parser
+#
+# A hierarchy of classes that provide a way to parse different source formats and return hCalendar events.
+# The base class for all format-specific parsers. Do not use instances of this class
+# directly, use a subclass of Parser to do the parsing instead.
+module Calagator
+
+class Source::Parser < Struct.new(:opts)
+  # Return an Array of unsaved Event instances.
+  #
+  # Options: (these vary between specific parsers)
+  # * :url - URL string to read as parser input.
+  # * :content - String to read as parser input.
+  def self.to_events(opts)
+    # Return events from the first parser that suceeds
+    events = matched_parsers(opts[:url]).lazy.collect { |parser|
+      parser.new(opts).to_events
+    }.detect(&:present?)
+
+    events || []
+  end
+
+  def self.matched_parsers(url)
+    # start with the parser that matches the given URL
+    parsers.sort_by do |parser|
+      match = parser.url_pattern.present? && url.try(:match, parser.url_pattern)
+      match ? 0 : 1
+    end
+  end
+  private_class_method :matched_parsers
+
+  cattr_accessor(:parsers) { SortedSet.new }
+
+  def self.inherited(subclass)
+    parsers << subclass
+  end
+
+  class_attribute :label, :url_pattern
+
+  # Returns an Array of sorted string labels for the parsers.
+  def self.labels
+    parsers.map { |p| p.label.to_s }.sort_by(&:downcase)
+  end
+
+  def self.read_url(url)
+    RestClient.get(url).to_str
+  rescue RestClient::Unauthorized
+    raise Source::Parser::HttpAuthenticationRequiredError.new
+  end
+
+  def to_events
+    raise NotImplementedError
+  end
+
+  def self.<=>(other)
+    # use site-specific parsers first, then generics alphabetically
+    if self.url_pattern && !other.url_pattern
+      -1
+    elsif !self.url_pattern && other.url_pattern
+      1
+    else
+      self.label <=> other.label
+    end
+  end
+
+  private
+
+  def event_or_duplicate(event)
+    duplicates = event.find_exact_duplicates
+    if duplicates.present?
+      duplicates.first.progenitor
+    else
+      event
+    end
+  end
+
+  def venue_or_duplicate(venue)
+    duplicates = venue.find_exact_duplicates
+    if duplicates.present?
+      duplicates.first.progenitor
+    else
+      venue_machine_tag_name = venue.tag_list.find { |t|
+        # Match 2 in the MACHINE_TAG_PATTERN is the predicate
+        ActsAsTaggableOn::Tag::VENUE_PREDICATES.include? t.match(ActsAsTaggableOn::Tag::MACHINE_TAG_PATTERN)[2]
+      }
+      matched_venue = Venue.tagged_with(venue_machine_tag_name).first
+
+      if matched_venue.present?
+        matched_venue.progenitor
+      else
+        venue
+      end
+    end
+  end
+
+  def to_events_api_helper(url, error_key="error", &block)
+    # Extract +event_id+ from :url using +url_pattern+.
+    event_id = url[self.class.url_pattern, 1]
+    return false unless event_id # Give up unless we find the identifier.
+
+    # Get URL and params for using the API.
+    url, params = *block.call(event_id)
+
+    # Get data from the API.
+    data = RestClient.get(url, params: params, accept: "json").to_str
+    data = JSON.parse(data)
+
+    # Stop if API tells us there's an error.
+    raise Source::Parser::NotFound, error if error = data[error_key]
+
+    data['event_id'] = event_id
+    data
+  end
+end
+
+end
+
+require 'calagator/source/parser/not_found'
+require 'calagator/source/parser/plancast'
+require 'calagator/source/parser/meetup'
+require 'calagator/source/parser/facebook'
+require 'calagator/source/parser/ical'
+require 'calagator/source/parser/hcal'
+

data/app/models/calagator/source/parser/facebook.rb

@@ -0,0 +1,67 @@
+module Calagator
+
+class Source::Parser::Facebook < Source::Parser
+  self.label = :Facebook
+
+  # NOTE: This pattern's goal is to get the Facebook event identifier in the first capture group, so the "(?:foo)" non-capturing group syntax is used to match but not capture those groups -- search the web for "ruby class rexep non-capturing" for details.
+  self.url_pattern = %r{(?x)              # Ignore regexp whitespace and comments
+    ^
+      (?:https?://)?                      # Optional http URI prefix
+      (?:
+        (?:www\.)?                        # Optional 'www.' host prefix
+        (?:
+          facebook\.com/events/           # REST-style path
+        |                                 # ...or....
+          facebook\.com/event\.php\?eid=  # GET-style path
+        )
+      |                                   # ...or...
+        graph\.facebook\.com/             # API path
+      )
+      ([^/]+)                             # Facebook event identifier to capture
+    }
+
+  def to_events
+    return unless data = to_events_api_helper(opts[:url]) do |event_id|
+      "http://graph.facebook.com/#{event_id}"
+    end
+
+    raise ::Source::Parser::HttpAuthenticationRequiredError if data['parsed_response'] === false
+
+    event = Event.new({
+      source:      opts[:source],
+      title:       data['name'],
+      description: data['description'],
+      url:         opts[:url],
+      tag_list:    "facebook:event=#{data['id']}",
+      venue:       to_venue(data),
+
+      # Facebook is sending floating times, treat them as local
+      start_time:  Time.zone.parse(data['start_time']),
+      end_time:    Time.zone.parse(data['end_time']),
+    })
+
+    [event_or_duplicate(event)]
+  end
+
+  private
+
+  def to_venue(data)
+    fields = (data['venue'] || {})
+    return if fields.blank?
+
+    venue = Venue.new({
+      source:         opts[:source],
+      title:          data['location'],
+      street_address: fields['street'],
+      locality:       fields['city'],
+      region:         fields['state'],
+      country:        fields['country'],
+      latitude:       fields['latitude'],
+      longitude:      fields['longitude'],
+    })
+    venue.geocode!
+    venue_or_duplicate(venue)
+  end
+end
+
+end