calagator 1.0.0.rc2 → 1.0.0.rc3

data/app/models/calagator/event/browse.rb

@@ -0,0 +1,91 @@
+module Calagator
+  class Event < ActiveRecord::Base
+    class Browse < Struct.new(:order, :date, :time)
+      def initialize(attributes={})
+        members.each do |key|
+          send "#{key}=", attributes[key]
+        end
+      end
+
+      def events
+        @events ||= sort.filter_by_date.filter_by_time.scope
+      end
+
+      def start_date
+        date_for(:start).strftime('%Y-%m-%d')
+      end
+
+      def end_date
+        date_for(:end).strftime('%Y-%m-%d')
+      end
+
+      def start_time
+        time_for(:start).strftime('%I:%M %p') if time_for(:start)
+      end
+
+      def end_time
+        time_for(:end).strftime('%I:%M %p') if time_for(:end)
+      end
+
+      def errors
+        @errors ||= []
+      end
+
+      def default?
+        values.all?(&:blank?)
+      end
+
+      protected
+
+      def scope
+        @scope ||= Event.non_duplicates.includes(:venue, :tags)
+      end
+
+      def sort
+        @scope = scope.ordered_by_ui_field(order)
+        self
+      end
+
+      def filter_by_date
+        @scope = if date
+          scope.within_dates(date_for(:start), date_for(:end))
+        else
+          scope.future
+        end
+        self
+      end
+
+      def filter_by_time
+        @scope = after_time if time_for(:start)
+        @scope = before_time if time_for(:end)
+        self
+      end
+
+      private
+
+      def default_date_for(kind)
+        kind == :start ? Time.zone.today : Time.zone.today + 3.months
+      end
+
+      def date_for(kind)
+        return default_date_for(kind) unless date.present?
+        Date.parse(date[kind])
+      rescue NoMethodError, ArgumentError, TypeError
+        errors << "Can't filter by an invalid #{kind} date."
+        default_date_for(kind)
+      end
+
+      def time_for(kind)
+        Time.zone.parse(time[kind]) rescue nil
+      end
+
+      def before_time
+        scope.select { |event| event.end_time.hour <= time_for(:end).hour }
+      end
+
+      def after_time
+        scope.select { |event| event.start_time.hour >= time_for(:start).hour }
+      end
+    end
+  end
+end

data/app/models/calagator/event/ical_renderer.rb

@@ -100,12 +100,12 @@ class Event < ActiveRecord::Base
     end
 
     def location
-      [event.venue_title, event.venue.full_address].compact.join(": ") if event.venue
+      [event.venue.title, event.venue.full_address].compact.join(": ") if event.venue
     end
 
     def dtstart
       if multiday?
-        event.dates.first
+        event.start_time.to_date
       else
         event.start_time
       end
@@ -113,7 +113,7 @@ class Event < ActiveRecord::Base
 
     def dtend
       if multiday?
-        event.dates.last + 1.day
+        event.end_time.to_date + 1.day
       else
         event.end_time || event.start_time + 1.hour
       end
@@ -149,7 +149,7 @@ class Event < ActiveRecord::Base
 
     # Treat any event with a duration of at least 20 hours as a multiday event.
     def multiday?
-      event.dates.size > 1 && event.duration.seconds > 20.hours
+      event.duration.seconds > 20.hours
     end
   end
 end

data/app/models/calagator/event/saver.rb

@@ -5,8 +5,8 @@ class Event < ActiveRecord::Base
     def save
       event.attributes = params[:event] || {}
       event.venue      = find_or_initialize_venue
-      event.start_time = [ params[:start_date], params[:start_time] ]
-      event.end_time   = [ params[:end_date], params[:end_time] ]
+      event.start_time = [ params[:start_date], params[:start_time] ].join(' ')
+      event.end_time   = [ params[:end_date], params[:end_time] ].join(' ')
       event.tags.reload # Reload the #tags association because its members may have been modified when #tag_list was set above.
 
       attempt_save?

data/app/models/calagator/event/search.rb

@@ -10,6 +10,10 @@ class Event < ActiveRecord::Base
       validate!
     end
 
+    def events
+      @events ||= perform_search
+    end
+
     # Return +events+ grouped by currentness using a data structure like:
     #
     #   {
@@ -28,14 +32,6 @@ class Event < ActiveRecord::Base
       ["1", "true"].include?(super)
     end
 
-    def events
-      @events ||= if tag
-        Event.search_tag(tag, order: order, current: current)
-      else
-        Event.search(query, order: order, skip_old: current)
-      end
-    end
-
     def failure_message
       @failure_message
     end
@@ -46,6 +42,20 @@ class Event < ActiveRecord::Base
 
     private
 
+    def perform_search
+      if hard_failure?
+        []
+      elsif tag
+        Event.search_tag(tag, order: order, current: current)
+      else
+        Event.search(query, order: order, skip_old: current)
+      end
+    rescue ActiveRecord::StatementInvalid => e
+      @failure_message = "There was an error completing your search."
+      @hard_failure = true
+      []
+    end
+
     def validate!
       unless %w(date name title venue score).include?(order) || order.blank?
         @failure_message = "Unknown ordering option #{order.inspect}, sorting by date instead."

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

@@ -36,8 +36,8 @@ class Event < ActiveRecord::Base
           time :start_time
           time :end_time
 
-          text :venue_title
-          string :venue_title
+          text(:venue_title) { venue.try(:title) }
+          string(:venue_title) { venue.try(:title) }
 
           boolean(:duplicate) { |event| event.duplicate? }
         end

data/app/models/calagator/source.rb

@@ -9,7 +9,6 @@
 #  imported_at :datetime
 #  created_at  :datetime
 #  updated_at  :datetime
-#  reimport    :boolean
 #
 
 # == Source
@@ -39,12 +38,9 @@ class Source < ActiveRecord::Base
 
   # Create events for this source. Returns the events created. URL must be set
   # for this source for this to work.
-  def create_events!(opts={})
+  def create_events!
     save!
-    events = to_events(opts).select(&:valid?)
-    events.reject!(&:old?) if opts[:skip_old]
-    events.each(&:save!)
-    events
+    to_events.select{ |event| event.valid? && !event.old? }.each(&:save!)
   end
 
   # Normalize the URL.
@@ -57,17 +53,10 @@ class Source < ActiveRecord::Base
   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={})
+  def to_events
     raise ActiveRecord::RecordInvalid, self unless valid?
-
     self.imported_at = Time.now
-    opts[:url] ||= self.url
-    opts[:source] = self
-    Source::Parser.to_events(opts)
+    Source::Parser.to_events(url: url, source: self)
   end
 
   # Return the name of the source, which can be its title or URL.

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

@@ -9,16 +9,12 @@ require "open-uri"
 # directly, use a subclass of Parser to do the parsing instead.
 module Calagator
 
-class Source::Parser < Struct.new(:opts)
+class Source::Parser < Struct.new(:url, :source)
   # 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)
+  def self.to_events(url: nil, source: nil)
     # Return events from the first parser that suceeds
-    events = matched_parsers(opts[:url]).lazy.collect { |parser|
-      parser.new(opts).to_events
+    events = matched_parsers(url).lazy.collect { |parser|
+      parser.new(url, source).to_events
     }.detect(&:present?)
 
     events || []
@@ -83,10 +79,9 @@ class Source::Parser < Struct.new(:opts)
     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]
-      }
+      venue_machine_tag_name = venue.tag_list.find do |tag_name|
+        MachineTag.new(tag_name).venue?
+      end
       matched_venue = Venue.tagged_with(venue_machine_tag_name).first
 
       if matched_venue.present?

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

@@ -3,7 +3,10 @@ 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.
+  # 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
@@ -21,17 +24,21 @@ class Source::Parser::Facebook < Source::Parser
     }
 
   def to_events
-    return unless data = to_events_api_helper(opts[:url]) do |event_id|
-      "http://graph.facebook.com/#{event_id}"
+    return unless data = to_events_api_helper(url) do |event_id|
+      raise Calagator::Source::Parser::HttpAuthenticationRequiredError unless Calagator.facebook_access_token.present?
+      [
+        "https://graph.facebook.com/#{event_id}",
+        { access_token: Calagator.facebook_access_token }
+      ]
     end
 
-    raise ::Source::Parser::HttpAuthenticationRequiredError if data['parsed_response'] === false
+    raise Calagator::Source::Parser::HttpAuthenticationRequiredError if data['parsed_response'] === false
 
     event = Event.new({
-      source:      opts[:source],
+      source:      source,
       title:       data['name'],
       description: data['description'],
-      url:         opts[:url],
+      url:         url,
       tag_list:    "facebook:event=#{data['id']}",
       venue:       to_venue(data),
 
@@ -50,7 +57,7 @@ class Source::Parser::Facebook < Source::Parser
     return if fields.blank?
 
     venue = Venue.new({
-      source:         opts[:source],
+      source:         source,
       title:          data['location'],
       street_address: fields['street'],
       locality:       fields['city'],

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

@@ -23,7 +23,7 @@ class Source::Parser::Hcal < Source::Parser
   def to_events
     hcals.map do |hcal|
       event = Event.new
-      event.source = opts[:source]
+      event.source = source
       EVENT_TO_HCALENDAR_FIELD_MAP.each do |field, mofo_field|
         next unless hcal.respond_to?(mofo_field)
         next unless value = decoded_field(hcal, mofo_field)
@@ -43,7 +43,7 @@ class Source::Parser::Hcal < Source::Parser
     when :dtstart
       HTMLEntities.new.decode(raw_field)
     when :location
-      to_venue(opts.merge(:value => raw_field))
+      to_venue(raw_field)
     else
       raw_field
     end
@@ -60,10 +60,10 @@ class Source::Parser::Hcal < Source::Parser
   #
   # Options:
   # * :value -- hCard or string location
-  def to_venue(opts)
+  def to_venue(value)
     venue = Venue.new
-    venue.source = opts[:source]
-    case raw = opts[:value]
+    venue.source = source
+    case raw = value
     when String
       venue.title = raw
     when HCard
@@ -99,7 +99,7 @@ class Source::Parser::Hcal < Source::Parser
   end
 
   def hcals
-    content = self.class.read_url(opts[:url])
+    content = self.class.read_url(url)
     something = hCalendar.find(:text => content)
     something.is_a?(hCalendar) ? [something] : something
   end

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

@@ -1,3 +1,5 @@
+require "calagator/vcalendar"
+
 # == Source::Parser::Ical
 #
 # Reads iCalendar events.
@@ -13,172 +15,84 @@ module Calagator
 class Source::Parser::Ical < Source::Parser
   self.label = :iCalendar
 
-  VENUE_CONTENT_RE = /^BEGIN:VVENUE$.*?^END:VVENUE$/m
-
-  # Override Base::read_url to handle "webcal" scheme addresses.
+  # Override Source::Parser.read_url to handle "webcal" scheme addresses.
   def self.read_url(url)
-    super(url.gsub(/^webcal:/, 'http:'))
+    url.gsub!(/^webcal:/, 'http:')
+    super
   end
 
   def to_events
-    return false unless calendars = content_calendars
-
-    events = calendars.flat_map do |calendar|
-      calendar.events.map do |component|
-        next if skip_old? and old?(component)
-        component_to_event(component, calendar)
-      end
-    end
-
-    events.compact.uniq do |event|
-      [event.attributes, event.venue.try(:attributes)]
-    end
+    return false unless vcalendars
+    current_vevents = vcalendars.flat_map(&:vevents).reject(&:old?)
+    current_events = current_vevents.map { |vevent| to_event(vevent) }
+    dedup(current_events)
   end
 
   private
 
-  def skip_old?
-    # Skip old events by default
-    true unless opts[:skip_old] == false
+  def vcalendars
+    @vcalendars ||= VCalendar.parse(raw_ical)
   end
 
-  def old?(component)
-    cutoff = Time.now.yesterday
-    (component.dtend || component.dtstart).to_time < cutoff
+  def raw_ical
+    self.class.read_url(url)
   end
 
-  def content_calendars
-    content = self.class.read_url(opts[:url]).gsub(/\r\n/, "\n")
-    content = munge_gmt_dates(content)
-    RiCal.parse_string(content)
-  rescue Exception => e
-    if e.message =~ /Invalid icalendar file/
-      false # Invalid data, give up.
-    else
-      raise e # Unknown error, we should care.
-    end
+  def to_event(vevent)
+    event = EventMapper.new(vevent).to_event
+    event.venue = VenueMapper.new(vevent.vvenue, vevent.location).to_venue
+    event.source = source
+    event
   end
 
-  def component_to_event(component, calendar)
-    event = Event.new({
-      source:      opts[:source],
-      title:       component.summary,
-      description: component.description,
-      url:         component.url,
-    })
-
-    dates_for_tz(component, event)
-
-    event.venue = to_venue(content_venue(component, calendar), opts.merge(fallback: component.location))
-    event_or_duplicate(event)
+  def dedup(events)
+    events.map do |event|
+      event = event_or_duplicate(event)
+      event.venue = venue_or_duplicate(event.venue) if event.venue
+      event
+    end.uniq
   end
 
-  def content_venue(component, calendar)
-    content_venues = calendar.to_s.scan(VENUE_CONTENT_RE)
-
-    # finding the event venue id - VVENUE=V0-001-001423875-1@eventful.com
-    venue_uid = component.location_property.params["VVENUE"]
-    # finding in the content_venues array an item matching the uid
-    venue_uid ? content_venues.find{|content_venue| content_venue.match(/^UID:#{venue_uid}$/m)} : nil
-  rescue Exception => e
-    # Ignore
-    Rails.logger.info("Source::Parser::Ical.to_events : Failed to parse content_venue for event -- #{e}")
-    nil
-  end
-
-  # Helper to set the start and end dates correctly depending on whether it's a floating or fixed timezone
-  def dates_for_tz(component, event)
-    if component.dtstart_property.tzid
-      event.start_time  = component.dtstart
-      event.end_time    = component.dtend
-    else
-      event.start_time  = Time.zone.parse(component.dtstart_property.value)
-      if component.dtend_property
-        event.end_time = Time.zone.parse(component.dtend_property.value)
-      else
-        if component.duration
-          event.end_time = component.duration_property.add_to_date_time_value(event.start_time)
-        else
-          event.end_time = event.start_time
-        end
-      end
+  # Converts a VEvent instance into an Event
+  class EventMapper < Struct.new(:vevent)
+    def to_event
+      Event.new({
+        title:       vevent.summary,
+        description: vevent.description,
+        url:         vevent.url,
+        start_time:  vevent.start_time,
+        end_time:    vevent.end_time,
+      })
     end
   end
 
-  def munge_gmt_dates(content)
-    content.gsub(/;TZID=GMT:(.*)/, ':\1Z')
-  end
-
-  # Return an Venue extracted from an iCalendar input.
-  #
-  # Arguments:
-  # * value - String with iCalendar data to parse which contains a VVENUE item.
-  #
-  # Options:
-  # * :fallback - String to use as the title for the location if the +value+ doesn't contain a VVENUE.
-  def to_venue(value, opts={})
-    venue = Venue.new
-
-    # VVENUE entries are considered just Vcards,
-    # treating them as such.
-    if vcard_hash = vcard_hash_from_value(value)
-      venue.attributes = {
-        title:          vcard_hash['NAME'],
-        street_address: vcard_hash['ADDRESS'],
-        locality:       vcard_hash['CITY'],
-        region:         vcard_hash['REGION'],
-        postal_code:    vcard_hash['POSTALCODE'],
-        country:        vcard_hash['COUNTRY'],
-      }
-      venue.latitude, venue.longitude = vcard_hash['GEO'].split(/;/).map(&:to_f)
-
-    elsif opts[:fallback].present?
-      venue.title = opts[:fallback]
-    else
-      return nil
+  # Converts a VVenue instance into a Venue
+  class VenueMapper < Struct.new(:vvenue, :fallback)
+    def to_venue
+      from_vvenue or from_fallback or return
     end
 
-    venue.geocode!
-    venue_or_duplicate(venue)
-  end
-
-  def vcard_hash_from_value(value)
-    value ||= ""
-    return unless data = value.scan(VENUE_CONTENT_RE).first
-
-    # Only use first vcard of a VVENUE
-    vcard = RiCal.parse_string(data).first
-
-    # Extract all properties, including non-standard ones, into an array of "KEY;meta-qualifier:value" strings
-    vcard_lines = vcard.export_properties_to(StringIO.new(''))
-
-    # Turn a String-like object into an Enumerable.
-    vcard_lines = vcard_lines.respond_to?(:lines) ? vcard_lines.lines : vcard_lines
-
-    hash_from_vcard_lines(vcard_lines)
-  end
-
-  # Return hash parsed from VCARD lines.
-  #
-  # Arguments:
-  # * vcard_lines - Array of "KEY;meta-qualifier:value" strings.
-  def hash_from_vcard_lines(vcard_lines)
-    vcard_lines.reduce({}) do |vcard_hash, vcard_line|
-      if matcher = vcard_line.match(/^([^;]+?)(;[^:]*?)?:(.*)$/)
-        _, key, qualifier, value = *matcher
-
-        if qualifier
-          # Add entry for a key and its meta-qualifier
-          vcard_hash["#{key}#{qualifier}"] = value
-
-          # Add fallback entry for a key from the matching meta-qualifier, e.g. create key "foo" from contents of key with meta-qualifier "foo;bar".
-          vcard_hash[key] ||= value
-        else
-          # Add entry for a key without a meta-qualifier.
-          vcard_hash[key] = value
-        end
+    private
+
+    def from_vvenue
+      return unless vvenue
+      Venue.new({
+        title:          vvenue.name,
+        street_address: vvenue.address,
+        locality:       vvenue.city,
+        region:         vvenue.region,
+        postal_code:    vvenue.postalcode,
+        country:        vvenue.country,
+        latitude:       vvenue.latitude,
+        longitude:      vvenue.longitude,
+      }) do |venue|
+        venue.geocode!
       end
-      vcard_hash
+    end
+
+    def from_fallback
+      return unless fallback.present?
+      Venue.new(title: fallback)
     end
   end
 end