calagator 0.0.1.pre1

data/app/helpers/calagator/google_event_export_helper.rb

@@ -0,0 +1,67 @@
+module Calagator
+
+module GoogleEventExportHelper
+  # Return a Google Calendar export URL.
+
+  def google_event_export_link(event)
+    GoogleEventExportLink.new(event, self).render
+  end
+
+  class GoogleEventExportLink < Struct.new(:event, :context)
+    def render
+      truncate(url + query)
+    end
+
+    private
+
+    def url
+      "http://www.google.com/calendar/event?action=TEMPLATE&trp=true&"
+    end
+
+    def query
+      fields.collect do |field|
+        send(field).to_query(field)
+      end.compact.join("&")
+    end
+
+    def fields
+      [:text, :dates, :location, :sprop, :details]
+    end
+
+    def text
+      event.title
+    end
+
+    def dates
+      google_time_format = "%Y%m%dT%H%M%SZ"
+      end_time = event.end_time || event.start_time
+      "#{event.start_time.utc.strftime(google_time_format)}/#{end_time.utc.strftime(google_time_format)}"
+    end
+
+    def location
+      location = event.venue.try(:title)
+      if address = event.venue.try(:geocode_address)
+        location += ", #{address}" if address.present?
+      end
+      location
+    end
+
+    def sprop
+      if event.url.present?
+        "website:#{event.url.sub(/^http.?:\/\//, '')}"
+      end
+    end
+
+    def details
+      "Imported from: #{context.event_url(event)} \n\n#{event.description}"
+    end
+
+    def truncate string
+      omission = "...[truncated]"
+      length = 1024 - omission.length
+      context.truncate(string, length: length, omission: omission)
+    end
+  end
+end
+
+end

data/app/helpers/calagator/mapping_helper.rb

@@ -0,0 +1,103 @@
+module Calagator
+
+module MappingHelper
+  def map_provider
+    (SECRETS.mapping && SECRETS.mapping["provider"]) || 'stamen'
+  end
+
+  def map_tiles
+    (SECRETS.mapping && SECRETS.mapping["tiles"]) || 'terrain'
+  end
+
+  def leaflet_js
+    Rails.env.production? ? ["https://d591zijq8zntj.cloudfront.net/leaflet-0.6.4/leaflet.js"] : ["leaflet"]
+  end
+
+  def map_provider_dependencies
+    {
+      "stamen" => ["http://maps.stamen.com/js/tile.stamen.js?v1.2.3"],
+      "mapbox" => ["https://api.tiles.mapbox.com/mapbox.js/v1.3.1/mapbox.standalone.js"],
+      "esri"   => ["http://cdn-geoweb.s3.amazonaws.com/esri-leaflet/0.0.1-beta.5/esri-leaflet.js"],
+      "google" => [
+        "https://maps.googleapis.com/maps/api/js?key=#{SECRETS.mapping && SECRETS.mapping["google_maps_api_key"]}&sensor=false",
+        "leaflet_google_layer",
+      ],
+    }[map_provider]
+  end
+
+  def mapping_js_includes
+    leaflet_js + map_provider_dependencies
+  end
+
+  def map(locatable_items, options = {})
+    options.symbolize_keys!
+    locatable_items = Array(locatable_items).select{|i| i.location.present? }
+
+    if locatable_items.present?
+      div_id = options[:id] || 'map'
+      map_div = content_tag(:div, "", :id => div_id)
+
+      markers = map_markers(locatable_items)
+      zoom = options[:zoom] || 14
+      center = (options[:center] || locatable_items.first.location).join(", ")
+      should_fit_bounds = locatable_items.count > 1 && options[:center].blank?
+
+      script = <<-JS
+        var layer = new #{layer_constructor}("#{map_tiles}");
+        var map = new L.Map("#{div_id}", {
+            center: new L.LatLng(#{center}),
+            zoom: #{zoom},
+            attributionControl: false
+        });
+        L.control.attribution ({
+          position: 'bottomright',
+          prefix: false
+        }).addTo(map);
+
+        map.addLayer(layer);
+
+        var venueIcon = L.AwesomeMarkers.icon({
+          icon: 'star',
+          color: '#{SECRETS.mapping['marker_color']}'
+        })
+
+        var markers = [#{markers.join(", ")}];
+        var markerGroup = L.featureGroup(markers);
+        markerGroup.addTo(map);
+      JS
+      script << "map.fitBounds(markerGroup.getBounds());" if should_fit_bounds
+
+      map_div + javascript_tag(script)
+    end
+  end
+
+  alias_method :google_map, :map
+
+  def layer_constructor
+    constructor_map = {
+      "stamen"  => "L.StamenTileLayer",
+      "mapbox"  => "L.mapbox.tileLayer",
+      "esri"    => "L.esri.basemapLayer",
+      "google"  => "L.Google",
+      "leaflet" => "L.tileLayer",
+    }
+    constructor_map[map_provider]
+  end
+
+  def map_markers(locatable_items)
+    Array(locatable_items).map { |locatable_item|
+      location = locatable_item.location
+
+      if location
+        latitude = location[0]
+        longitude = location[1]
+        title = locatable_item.title
+        popup = link_to(locatable_item.title, locatable_item)
+
+        "L.marker([#{latitude}, #{longitude}], {title: '#{j title}', icon: venueIcon}).bindPopup('#{j popup}')"
+      end
+    }.compact
+  end
+end
+
+end

data/app/helpers/calagator/sources_helper.rb

@@ -0,0 +1,10 @@
+module Calagator
+
+module SourcesHelper
+  # Return HTML with a link to the the external source URL.
+  def source_url_link(source)
+    return link_to source.url, source.url, { :rel => "nofollow", :target => "_BLANK" }
+  end
+end
+
+end

data/app/helpers/calagator/tags_helper.rb

@@ -0,0 +1,42 @@
+module Calagator
+
+module TagsHelper
+  def tag_links_for(model)
+    model.tags.sort_by(&:name).map{|tag| tag_link(model.class.model_name.human.downcase, tag)}.join(', ').html_safe
+  end
+
+  def tag_link(type, tag, link_class=nil)
+    internal_url = "/#{type.pluralize}/tag/#{tag.name}"
+
+    link_classes = [link_class, "p-category"]
+    link_classes << "external #{tag.machine_tag[:namespace]} #{tag.machine_tag[:predicate]}" if tag.machine_tag[:url]
+
+    link_text = [tag_icon(tag.name), escape_once(tag.name)].compact.join(' ').html_safe
+
+    link_to link_text, (tag.machine_tag[:url] || internal_url), :class => link_classes.compact.join(' ')
+  end
+  private :tag_link
+
+  def icon_exists_for?(tag_name)
+    !!Rails.application.assets["tag_icons/#{tag_name}.png"]
+  end
+
+  def tag_icon(tag_name)
+    if icon_exists_for?(tag_name)
+      image_tag(asset_path("tag_icons/#{tag_name}.png"), title: tag_name)
+    end
+  end
+
+  def get_tag_icon_links(event)
+    event.tag_list.map do |tag_name|
+      icon = tag_icon(tag_name)
+      link_to(icon, tag_events_path(tag_name)) if icon
+    end
+  end
+
+  def display_tag_icons(event)
+    get_tag_icon_links(event).join(' ').html_safe
+  end
+end
+
+end

data/app/helpers/calagator/time_range_helper.rb

@@ -0,0 +1,166 @@
+module Calagator
+
+module TimeRangeHelper
+  extend self
+  # Initialize with a single DateTime, a pair of DateTimes,
+  # or an object that responds_to start_time and end_time, and two options
+  # By default (unless :format => :text) include <abbr> tags for hCalendar,
+  # if a :context date is provided, omit unnecessary date parts.
+  def normalize_time(start_time, end_time=nil, format: :hcal, context: nil)
+    if end_time.nil? and start_time.respond_to?(:start_time)
+      end_time = start_time.end_time
+      start_time = start_time.start_time
+    end
+    TimeRange.new(start_time, end_time, format, context).to_s.html_safe
+  end
+
+  class TimeRange < Struct.new(:start_time, :end_time, :format, :context_date)
+    # A representation of a time or range of time that can format itself
+    # in a meaningful way. Examples:
+    # "Thursday, April 3, 2008"
+    # "Thursday, April 3, 2008 at 4pm"
+    # "Thursday, April 3, 2008 from 4:30-6pm"
+    # (context: in the list for today) "11:30am-2pm"
+    # "Thursday-Friday, April 3-5, 2008"
+    # (context: during 2008) "Thursday April 5, 2009 at 3:30pm through Friday, April 5 at 8:45pm, 2009"
+    # (same, context: during 2009) "Thursday April 5 at 3:30pm through Friday, April 5 at 8:45pm"
+    def to_s
+      [start_text, conjunction, end_text].compact.join
+    end
+
+    private
+
+    def start_text
+      part = TimePart.new(start_time, context_date, from_prefix: same_day?, no_meridian: same_meridian?)
+      part.to_s(format, "start")
+    end
+
+    def conjunction
+      return unless range?
+      if same_day?
+        format == :text ? "-" : "&ndash;"
+      else
+        " through "
+      end
+    end
+
+    def end_text
+      return unless range?
+      part = TimePart.new(end_time, context_date, time_only: same_day?)
+      part.to_s(format, "end")
+    end
+
+    def range?
+      end_time.present? && start_time != end_time
+    end
+
+    def same_day?
+      range? && start_time.to_date == end_time.to_date
+    end
+
+    def same_meridian?
+      same_day? && start_time.strftime("%p") == end_time.strftime("%p")
+    end
+  end
+
+  class TimePart
+    def initialize(time, context, time_only: false, no_meridian: false, from_prefix: false)
+      @time = time
+      @context = context
+      @parts = get_parts
+      remove_parts_implied_by_context
+      remove_day_parts if time_only
+      remove_suffix if no_meridian
+      set_at_to_from if from_prefix
+    end
+
+    attr_reader :time, :context, :parts
+
+    def to_s(format, which)
+      TimePartRenderer.new(self, format, which).to_s
+    end
+
+    private
+
+    def get_parts
+      parts = {
+        wday: time.strftime("%A"),
+        month: time.strftime("%B"),
+        day: time.day,
+        year: time.year,
+        at: "at",
+        hour: time.strftime("%l").strip,
+        min: time.strftime(":%M"),
+        suffix: time.strftime("%P"),
+      }
+      if time.min == 0
+        parts.delete(:min)
+        return parts.merge(hour: "midnight", suffix: nil) if time.hour == 0
+        return parts.merge(hour: "noon", suffix: nil) if time.hour == 12
+      end
+      parts
+    end
+
+    def remove_parts_implied_by_context
+      return unless time && context
+      parts.delete(:year) if context.year == time.year
+      [:wday, :month, :day, :at, :from].each do |key|
+        parts.delete(key)
+      end if time.to_date == context
+    end
+
+    def remove_day_parts
+      parts.keep_if { |key| [:hour, :min, :suffix].include?(key) }
+    end
+
+    def remove_suffix
+      parts.delete(:suffix)
+    end
+
+    def set_at_to_from
+      parts[:at] = "from" if parts.has_key?(:at)
+    end
+  end
+
+  class TimePartRenderer < Struct.new(:part, :format, :which)
+    PREFIXES = {
+      :hour => " ",
+      [nil, :hour] => "",
+      :year => ", ",
+      :end_hour => " ",
+      :end_year => ", ",
+      :at => " ",
+    }
+    SUFFIXES = {
+      :month => " ",
+      :wday => ", ",
+    }
+
+    def to_s
+      if format == :hcal
+        wrap_in_hcal(text, which)
+      else
+        text
+      end
+    end
+
+    private
+
+    def text
+      part.parts.reduce("") do |string, (key, value)|
+        prefix = (PREFIXES[[@last_key, key]] || PREFIXES[key])
+        suffix = SUFFIXES[key]
+        @last_key = key
+        "#{string}#{prefix}#{value}#{suffix}"
+      end
+    end
+
+    def wrap_in_hcal(string, which)
+      css_class = "dt#{which} dt-#{which}"
+      formatted_time = part.time.strftime('%Y-%m-%dT%H:%M:%S')
+      %(<time class="#{css_class}" title="#{formatted_time}" datetime="#{formatted_time}">#{string}</time>)
+    end
+  end
+end
+
+end

data/app/models/calagator/event.rb

@@ -0,0 +1,246 @@
+# == Schema Information
+# Schema version: 20110604174521
+#
+# Table name: events
+#
+#  id              :integer         not null, primary key
+#  title           :string(255)
+#  description     :text
+#  start_time      :datetime
+#  url             :string(255)
+#  created_at      :datetime
+#  updated_at      :datetime
+#  venue_id        :integer
+#  source_id       :integer
+#  duplicate_of_id :integer
+#  end_time        :datetime
+#  version         :integer
+#  rrule           :string(255)
+#  venue_details   :text
+#
+
+require "calagator/blacklist_validator"
+require "calagator/duplicate_checking"
+require "calagator/decode_html_entities_hack"
+require "calagator/strip_whitespace"
+require "calagator/url_prefixer"
+require "paper_trail"
+require "loofah-activerecord"
+require "loofah/activerecord/xss_foliate"
+
+# == Event
+#
+# A model representing a calendar event.
+
+module Calagator
+class Event < ActiveRecord::Base
+  self.table_name = "events"
+
+  attr_protected
+
+  has_paper_trail
+  acts_as_taggable
+
+  xss_foliate :strip => [:title], :sanitize => [:description, :venue_details]
+  include DecodeHtmlEntitiesHack
+
+  # Associations
+  belongs_to :venue, :counter_cache => true
+  belongs_to :source
+
+  # Validations
+  validates_presence_of :title, :start_time
+  validate :end_time_later_than_start_time
+  validates_format_of :url,
+    :with => /\Ahttps?:\/\/(\w+:?\w*@)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%@!\-\/]))?\Z/,
+    :allow_blank => true,
+    :allow_nil => true
+
+  validates :title, :description, :url, blacklist: true
+
+  before_destroy :verify_lock_status
+
+  # Duplicates
+  include DuplicateChecking
+  duplicate_checking_ignores_attributes    :source_id, :version, :venue_id
+  duplicate_squashing_ignores_associations :tags, :base_tags, :taggings
+
+  # Named scopes
+  scope :after_date, lambda { |date|
+    where(["start_time >= ?", date]).order(:start_time)
+  }
+  scope :on_or_after_date, lambda { |date|
+    time = date.beginning_of_day
+    where("(start_time >= :time) OR (end_time IS NOT NULL AND end_time > :time)",
+      :time => time).order(:start_time)
+  }
+  scope :before_date, lambda { |date|
+    time = date.beginning_of_day
+    where("start_time < :time", :time => time).order(:start_time)
+  }
+  scope :future, lambda { on_or_after_date(Time.zone.today) }
+  scope :past, lambda { before_date(Time.zone.today) }
+  scope :within_dates, lambda { |start_date, end_date|
+    if start_date == end_date
+      end_date = end_date + 1.day
+    end
+    on_or_after_date(start_date).before_date(end_date)
+  }
+
+  scope :future_with_venue, -> {
+    future.order("start_time ASC").non_duplicates.includes(:venue)
+  }
+  scope :past_with_venue, -> {
+    past.order("start_time DESC").non_duplicates.includes(:venue)
+  }
+
+  # Expand the simple sort order names from the URL into more intelligent SQL order strings
+  scope :ordered_by_ui_field, lambda{|ui_field|
+    case ui_field
+      when 'name'
+        order('lower(events.title), start_time')
+      when 'venue'
+        includes(:venue).order('lower(venues.title), start_time')
+      else # when 'date', nil
+        order('start_time')
+    end
+  }
+
+  #---[ Overrides ]-------------------------------------------------------
+
+  # Return the title but strip out any whitespace.
+  def title
+    # TODO Generalize this code so we can use it on other attributes in the different model classes. The solution should use an #alias_method_chain to make sure it's not breaking any explicit overrides for an attribute.
+    read_attribute(:title).to_s.strip
+  end
+
+  # Return description without those pesky carriage-returns.
+  def description
+    # TODO Generalize this code so we can reuse it on other attributes.
+    read_attribute(:description).to_s.gsub("\r\n", "\n").gsub("\r", "\n")
+  end
+
+  def url=(value)
+    super UrlPrefixer.prefix(value)
+  end
+
+  # Set the start_time to the given +value+, which could be a Time, Date,
+  # DateTime, String, Array of Strings, or nil.
+  def start_time=(value)
+    super time_for(value)
+  rescue ArgumentError
+    errors.add :start_time, "is invalid"
+    super nil
+  end
+
+  # Set the end_time to the given +value+, which could be a Time, Date,
+  # DateTime, String, Array of Strings, or nil.
+  def end_time=(value)
+    super time_for(value)
+  rescue ArgumentError
+    errors.add :end_time, "is invalid"
+    super nil
+  end
+
+  def time_for(value)
+    value = value.join(' ') if value.kind_of?(Array)
+    value = Time.zone.parse(value) if value.kind_of?(String) # this will throw ArgumentError if invalid
+    value
+  end
+  private :time_for
+
+  def lock_editing!
+    update_attribute(:locked, true)
+  end
+
+  def unlock_editing!
+    update_attribute(:locked, false)
+  end
+
+  #---[ Queries ]---------------------------------------------------------
+
+  # Return Hash of Events grouped by the +type+.
+  def self.find_duplicates_by_type(type='na')
+    case type.to_s.strip
+    when 'na', ''
+      { [] => future }
+    else
+      kind = %w[all any].include?(type) ? type.to_sym : type.split(',').map(&:to_sym)
+      find_duplicates_by(kind,
+        :grouped => true,
+        :where => "a.start_time >= #{connection.quote(Time.now - 1.day)}")
+    end
+  end
+
+  #---[ Searching ]-------------------------------------------------------
+
+  # NOTE: The `Event.search` method is implemented elsewhere! For example, it's
+  # added by SearchEngine::ActsAsSolr if you're using that search engine.
+
+  def self.search_tag(tag, opts={})
+    includes(:venue).tagged_with(tag).ordered_by_ui_field(opts[:order])
+  end
+
+  def self.search(query, opts={})
+    SearchEngine.search(query, opts)
+  end
+
+  #---[ Transformations ]-------------------------------------------------
+
+  def location
+    venue && venue.location
+  end
+
+  def venue_title
+    venue && venue.title
+  end
+
+  #---[ Date related ]----------------------------------------------------
+
+  # Returns an array of the dates spanned by the event.
+  def dates
+    raise ArgumentError, "can't get dates for an event with no start time" unless start_time
+    if end_time
+      (start_time.to_date..end_time.to_date).to_a
+    else
+      [start_time.to_date]
+    end
+  end
+
+  # Is this event current?
+  def current?
+    (end_time || start_time) >= Date.today.to_time
+  end
+
+  # Is this event old?
+  def old?
+    (end_time || start_time + 1.hour) <= Time.zone.now.beginning_of_day
+  end
+
+  # Did this event start before today but ends today or later?
+  def ongoing?
+    start_time < Date.today.to_time && end_time && end_time >= Date.today.to_time
+  end
+
+  def duration
+    if end_time && start_time
+      (end_time - start_time)
+    else
+      0
+    end
+  end
+
+protected
+
+  def end_time_later_than_start_time
+    if start_time && end_time && end_time < start_time
+      errors.add(:end_time, "cannot be before start")
+    end
+  end
+
+  def verify_lock_status
+    return !locked
+  end
+end
+
+end