calagator 0.0.1.pre1

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

@@ -0,0 +1,39 @@
+# Return a new record with fields selectively copied from the original, and
+# the start_time and end_time adjusted so that their date is set to today and
+# their time-of-day is set to the original record's time-of-day.
+module Calagator
+
+class Event < ActiveRecord::Base
+  class Cloner < Struct.new(:event)
+    def self.clone(event)
+      new(event).clone
+    end
+
+    ATTRIBUTES = [:title, :description, :venue_id, :url, :tag_list, :venue_details]
+
+    def clone
+      clone = Event.new
+      ATTRIBUTES.each do |attribute|
+        clone.send "#{attribute}=", event.send(attribute)
+      end
+      if event.start_time
+        clone.start_time = clone_time_for_today(event.start_time)
+      end
+      if event.end_time
+        clone.end_time = clone_time_for_today(event.end_time)
+      end
+      clone
+    end
+
+    private
+
+    # Return a time that's today but has the time-of-day component from the
+    # +source+ time argument.
+    def clone_time_for_today(source)
+      today = Date.today
+      Time.zone.local(today.year, today.mon, today.day, source.hour, source.min, source.sec, source.usec)
+    end
+  end
+end
+
+end

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

@@ -0,0 +1,155 @@
+# Return an iCalendar string representing an Array of Event instances.
+#
+# Arguments:
+# * :events - Event instance or array of them.
+#
+# Options:
+# * :url_helper - Lambda that accepts an Event instance and generates a URL
+#   for it if it doesn't have a URL already.
+#
+# Example:
+#   ics1 = Event::IcalRenderer.render(myevent)
+#   ics2 = Event::IcalRenderer.render(myevents, url_helper: -> (event) { event_url(event) })
+module Calagator
+
+class Event < ActiveRecord::Base
+  class IcalRenderer
+    def self.render(events, opts={})
+      output = render_icalendar(events, opts)
+      output = add_name(output)
+      output = normalize_line_endings(output)
+    end
+
+    def self.render_icalendar(events, opts)
+      RiCal.Calendar do |calendar|
+        calendar.prodid = "-//Calagator//EN"
+
+        Array(events).each do |event|
+          calendar.event do |entry|
+            new(event, opts).add_event_to(entry)
+          end
+        end
+      end.export
+    end
+
+    def self.add_name(output)
+      output.sub(/(CALSCALE:\w+)/i, "\\1\nX-WR-CALNAME:#{Calagator.title}\nMETHOD:PUBLISH")
+    end
+
+    def self.normalize_line_endings(output)
+      output.gsub(/\r?\n/,"\r\n")
+    end
+
+    attr_reader :event, :imported_from
+
+    def initialize(event, opts)
+      @event = event
+      @imported_from = opts[:url_helper].call(event).to_s if opts[:url_helper]
+    end
+
+    def add_event_to(entry)
+      fields.each do |field|
+        value = send(field)              # value = summary
+        entry.send field, value if value # entry.summary summary if summary
+      end
+    end
+
+    private
+
+    def fields
+      %w(summary description url location dtstart dtend created last_modified sequence dtstamp uid)
+    end
+
+    def summary
+      event.title || 'Untitled Event'
+    end
+
+    def description
+      parts = [
+        description_range,
+        description_description,
+        description_tags,
+        description_imported_from,
+      ].compact
+
+      parts.join if parts.any?
+    end
+
+    def description_range
+      return unless multiday?
+      time_range = TimeRangeHelper.normalize_time(event, format: :text)
+      "This event runs from #{time_range}.\n\nDescription:\n"
+    end
+
+    def description_description
+      Loofah::Helpers.strip_tags(event.description) if event.description.present?
+    end
+
+    def description_tags
+      "\n\nTags: #{event.tag_list}" if event.tag_list.present?
+    end
+
+    def description_imported_from
+      "\n\nImported from: #{imported_from}" if imported_from
+    end
+
+    def url
+      event.url if event.url.present?
+    end
+
+    def location
+      [event.venue_title, event.venue.full_address].compact.join(": ") if event.venue
+    end
+
+    def dtstart
+      if multiday?
+        event.dates.first
+      else
+        event.start_time
+      end
+    end
+
+    def dtend
+      if multiday?
+        event.dates.last + 1.day
+      else
+        event.end_time || event.start_time + 1.hour
+      end
+    end
+
+    def created
+      event.created_at if event.created_at
+    end
+
+    def last_modified
+      event.updated_at if event.updated_at
+    end
+
+    def sequence
+      # Set the iCalendar SEQUENCE, which should be increased each time an
+      # event is updated. If an admin needs to forcefully increment the
+      # SEQUENCE for all events, they can edit the "config/secrets.yml"
+      # file and set the "icalendar_sequence_offset" value to something
+      # greater than 0.
+      (SECRETS.icalendar_sequence_offset || 0) + event.versions.count
+    end
+
+    def dtstamp
+      # dtstamp and uid added because of a bug in Outlook;
+      # Outlook 2003 will not import an .ics file unless it has DTSTAMP, UID, and METHOD
+      # use created_at for DTSTAMP; if there's no created_at, use event.start_time;
+      event.created_at || event.start_time
+    end
+
+    def uid
+      imported_from
+    end
+
+    # 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
+    end
+  end
+end
+
+end

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

@@ -0,0 +1,45 @@
+module Calagator
+
+class Event < ActiveRecord::Base
+  class Overview
+    def today
+      Event.non_duplicates.within_dates(today_date, tomorrow_date)
+    end
+
+    def tomorrow
+      Event.non_duplicates.within_dates(tomorrow_date, after_tomorrow_date)
+    end
+
+    def later
+      Event.non_duplicates.within_dates(after_tomorrow_date, future_cutoff_date)
+    end
+
+    def more
+      Event.after_date(future_cutoff_date).first
+    end
+
+    def tags
+      @tags ||= Event.tag_counts_on(:tags, limit: 100, conditions: "tags_count >= 10").sort_by(&:name)
+    end
+
+    private
+
+    def today_date
+      @today_date ||= Time.zone.now.beginning_of_day
+    end
+
+    def tomorrow_date
+      today_date + 1.day
+    end
+
+    def after_tomorrow_date
+      tomorrow_date + 1.day
+    end
+
+    def future_cutoff_date
+      today_date + 2.weeks
+    end
+  end
+end
+
+end

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

@@ -0,0 +1,58 @@
+module Calagator
+
+class Event < ActiveRecord::Base
+  class Saver < Struct.new(:event, :params, :failure)
+    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.tags.reload # Reload the #tags association because its members may have been modified when #tag_list was set above.
+
+      attempt_save?
+    end
+
+    def has_new_venue?
+      return unless event.venue
+      event.venue.previous_changes["id"] == [nil, event.venue.id] && params[:venue_name].present?
+    end
+
+    private
+
+    def find_or_initialize_venue
+      if params[:event] && params[:event][:venue_id].present?
+        Venue.find(params[:event][:venue_id]).progenitor
+      else
+        Venue.find_or_initialize_by_title(params[:venue_name]).progenitor
+      end
+    end
+
+    def attempt_save?
+      !spam? && !preview? && event.save
+    end
+
+    def spam?
+      evil_robot? || too_many_links?
+    end
+
+    def evil_robot?
+      if params[:trap_field].present?
+        self.failure = "<h3>Evil Robot</h3> We didn't save this event because we think you're an evil robot. If you're really not an evil robot, look at the form instructions more carefully. If this doesn't work please file a bug report and let us know."
+      end
+    end
+
+    def too_many_links?
+      if event.description.present? && event.description.scan(/https?:\/\//i).size > 3
+        self.failure = "We allow a maximum of 3 links in a description. You have too many links."
+      end
+    end
+
+    def preview?
+      if params[:preview]
+        event.valid?
+      end
+    end
+  end
+end
+
+end

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

@@ -0,0 +1,72 @@
+module Calagator
+
+class Event < ActiveRecord::Base
+  class Search < Struct.new(:query, :tag, :order, :current)
+    def initialize attributes = {}
+      members.each do |key|
+        send "#{key}=", attributes[key]
+      end
+      self.order ||= "date"
+      validate!
+    end
+
+    # Return +events+ grouped by currentness using a data structure like:
+    #
+    #   {
+    #     :current => [ my_current_event, my_other_current_event ],
+    #     :past => [ my_past_event ],
+    #   }
+    def grouped_events
+      grouped = events.group_by(&:current?)
+      grouped = { current: grouped[true] || [], past: grouped[false] || [] }
+      grouped[:current].reverse! if order.to_s == "date"
+      grouped[:past] = [] if current
+      grouped
+    end
+
+    def current
+      ["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
+
+    def hard_failure?
+      @hard_failure
+    end
+
+    private
+
+    def validate!
+      unless %w(date name title venue score).include?(order) || order.blank?
+        @failure_message = "Unknown ordering option #{order.inspect}, sorting by date instead."
+      end
+
+      if tag.present? && order == "score"
+        @failure_message = "You cannot sort tags by score"
+      end
+
+      if [query, tag].all?(&:blank?)
+        @failure_message = "You must enter a search query"
+        @hard_failure = true
+      end
+
+      if [query, tag].all?(&:present?)
+        # TODO make it possible to search by tag and query simultaneously
+        @failure_message = "You can't search by tag and query at the same time"
+        @hard_failure = true
+      end
+    end
+  end
+end
+
+end

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

@@ -0,0 +1,28 @@
+module Calagator
+
+class Event < ActiveRecord::Base
+  class SearchEngine
+    cattr_accessor(:kind) { :sql }
+
+    def self.search(*args)
+      search_engine.search(*args)
+    end
+
+    def self.use(kind)
+      self.kind = kind
+      search_engine.configure if search_engine.respond_to?(:configure)
+    end
+
+    def self.score?
+      search_engine.score?
+    end
+
+    private_class_method
+
+    def self.search_engine
+      kind == :sunspot ? ApacheSunspot : Sql
+    end
+  end
+end
+
+end

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

@@ -0,0 +1,106 @@
+module Calagator
+
+class Event < ActiveRecord::Base
+  class SearchEngine
+    class ApacheSunspot < 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 :score. Permitted values:
+      #   * :score => Sort with most relevant matches first
+      #   * :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?
+        true
+      end
+
+      def self.configure
+        Event.searchable do
+          text :title, :default_boost => 3
+          string :title
+
+          text :description
+
+          text :tag_list, :default_boost => 3
+
+          text :url
+
+          time :start_time
+          time :end_time
+
+          text :venue_title
+          string :venue_title
+
+          boolean(:duplicate) { |event| event.duplicate? }
+        end
+      end
+
+      def self.configured?
+        Event.respond_to?(:solr_search)
+      end
+
+      def initialize(*args)
+        super
+        self.class.configure unless self.class.configured?
+      end
+
+      def all
+        current_events + past_events
+      end
+
+      private
+
+      def current_events
+        search(true)
+      end
+
+      def past_events
+        skip_old ? [] : search(false)
+      end
+
+      def search(current)
+        Event.solr_search do
+          keywords query
+          order_by *order
+          order_by :start_time, :desc
+          with :duplicate, false
+          data_accessor_for(Event).include = [:venue]
+
+          method = current ? :greater_than_or_equal_to : :less_than
+          with(:start_time).send(method, Date.yesterday.to_time)
+        end.results.take(limit)
+      end
+
+      def order
+        case opts[:order].try(:to_sym)
+        when :date
+          [:start_time, :desc]
+        when :venue, :location
+          [:venue_title, :asc]
+        when :name, :title
+          [:title, :asc]
+        else
+          [:score, :desc]
+        end
+      end
+
+      def skip_old
+        opts[:skip_old] == true
+      end
+
+      def limit
+        opts[:limit] || 50
+      end
+    end
+  end
+end
+
+end