calagator 1.0.0.rc2 → 1.0.0.rc3

data/app/helpers/calagator/application_helper.rb

@@ -34,35 +34,23 @@ module ApplicationHelper
     time.strftime(format).gsub(/\*0*/,'').html_safe
   end
 
-  def self.source_code_version_raw
-    # Return a string describing the source code version being used
-    return "" unless system("git status 2>&1 >/dev/null")
-    " - Git timestamp: #{`git log -1 --format=format:"%ad" 2>&1`}"
-  rescue Errno::ENOENT
-    # Fail quietly if that didn't work; we don't want to get in the way.
-    ""
-  end
-
-  Calagator::ApplicationController::SOURCE_CODE_VERSION = self.source_code_version_raw
-
+  # Return a string describing the source code version being used
   def source_code_version
-    Calagator::ApplicationController::SOURCE_CODE_VERSION
+    Calagator::VERSION
   end
 
   # returns html markup with source (if any), imported/created time, and - if modified - modified time
   def datestamp(item)
-    stamp = "This item was "
-    if item.source.nil?
-      stamp << "added directly to #{Calagator.title}"
+    source = if item.source.nil?
+      "added directly to #{Calagator.title}"
     else
-      stamp << "imported from " << link_to(truncate(item.source.name, :length => 40), url_for(item.source))
+      "imported from #{link_to truncate(item.source.name, length: 40), url_for(item.source)}"
     end
-    stamp << " <br />" << content_tag(:strong, normalize_time(item.created_at, :format => :html) )
-    if item.updated_at > item.created_at
-      stamp << " and last updated <br />" << content_tag(:strong, normalize_time(item.updated_at, :format => :html) )
+    created = " <br /><strong>#{normalize_time(item.created_at, format: :html)}</strong>"
+    updated = if item.updated_at > item.created_at
+      " and last updated <br /><strong>#{normalize_time(item.updated_at, format: :html)}</strong>"
     end
-    stamp << "."
-    stamp.html_safe
+    raw "This item was #{source}#{created}#{updated}."
   end
 
   # Caches +block+ in view only if the +condition+ is true.
@@ -75,50 +63,10 @@ module ApplicationHelper
     end
   end
 
-  # Insert a chunk of +javascript+ into the page, and execute it when the document is ready.
-  def insert_javascript(javascript)
-    content_for(:javascript_insert) do
-      (<<-HERE).html_safe
-        <script>
-          $(document).ready(function() {
-            #{javascript}
-          });
-        </script>
-      HERE
-    end
-  end
-
-  # Focus cursor on DOM element specified by +xpath_query+ using JavaScript, e.g.:
-  #
-  #   <% focus_on '#search_field' %>
-  def focus_on(xpath_query)
-    insert_javascript "$('#{xpath_query}').focus();"
-  end
-
-  # Set the first tabindex to DOM element specified by +xpath_query+.
-  def tabindex_on(xpath_query)
-    #insert_javascript "$('#{xpath_query}')[0].tabindex = 1;"
-    #insert_javascript "$('#{xpath_query}')[0].attributes['tabindex'] = 1;"
-    # TODO Figure out how to set tabindex, because neither of these work right.
-  end
-
-  # Returns a string with safely encoded entities thanks to #h, while preserving any existing HTML entities.
-  def cleanse(string)
-    return escape_once(string)
-  end
-
   def subnav_class_for(controller_name, action_name)
-    return [
-      "#{controller.controller_name}_#{controller.action_name}_subnav",
-      controller.controller_name == controller_name && controller.action_name == action_name ?
-        "active" :
-        nil
-    ].compact.join(" ")
-  end
-
-  # CGI escape a string-like object. The issue is that CGI::escape fails if used on a RailsXss SafeBuffer: https://github.com/rails/rails_xss/issues/8
-  def cgi_escape(data)
-    return CGI::escape(data.to_str)
+    css_class = "#{controller.controller_name}_#{controller.action_name}_subnav"
+    css_class += " active" if [controller.controller_name, controller.action_name] == [controller_name, action_name]
+    css_class
   end
 end
 

data/app/helpers/calagator/events_helper.rb

@@ -3,12 +3,20 @@ module Calagator
 module EventsHelper
   include TimeRangeHelper # provides normalize_time
 
-  def today_tomorrow_or_weekday(record)
-    if record.ongoing?
-      "Started #{record.start_time.strftime('%A')}"
-    else
-      record.start_time.strftime('%A')
-    end
+  def today_tomorrow_or_weekday(event)
+    output = event.start_time.strftime('%A')
+    output = "Started #{output}" if event.ongoing?
+    output
+  end
+
+  # Cast date to_date unless date is undefined
+  def format_event_date(date)
+    date ? date.to_date : ""
+  end
+
+  # Cast date to time unless date is undefined
+  def format_event_time(date)
+    date ? date.strftime('%I:%M %p') : ""
   end
 
 # calculate rowspans for an array of events
@@ -30,11 +38,11 @@ module EventsHelper
       previous_start_time = event.start_time
     end
 
-    return rowspans
+    rowspans
   end
 
   def google_maps_url(address)
-    return "http://maps.google.com/maps?q=#{cgi_escape(address)}"
+    "http://maps.google.com/maps?q=#{URI.encode(address)}"
   end
 
   #---[ Event sorting ]----------------------------------------------------
@@ -52,8 +60,6 @@ module EventsHelper
   def events_sort_label(key)
     if key.present? or @tag.present?
       sanitize " by <strong>#{sorting_label_for(key, @tag.present?)}.</strong>"
-    else
-      nil
     end
   end
 
@@ -80,7 +86,7 @@ module EventsHelper
       raise ArgumentError, "Unknown option(s): #{unknown.inspect}"
     end
 
-    return filter.present? ?
+    filter.present? ?
       search_events_url(common.merge(filter)) :
       events_url(common)
   end
@@ -91,29 +97,29 @@ module EventsHelper
   #
   # @see #_events_feed_linker for details on parameters and exceptions.
   def google_events_subscription_link(filter={})
-    link = _events_feed_linker(filter, :format => "ics")
-    return "#{GOOGLE_EVENT_SUBSCRIBE_BASE}#{CGI::escape(link)}"
+    link = _events_feed_linker(filter, format: "ics")
+    "#{GOOGLE_EVENT_SUBSCRIBE_BASE}#{CGI.escape(link)}"
   end
 
   # Returns an iCalendar subscription URL.
   #
   # @see #_events_feed_linker for details on parameters and exceptions.
   def icalendar_feed_link(filter={})
-    return _events_feed_linker(filter, :protocol => "webcal", :format => "ics")
+    _events_feed_linker(filter, protocol: "webcal", format: "ics")
   end
 
   # Returns an iCalendar export URL.
   #
   # @see #_events_feed_linker for details on parameters and exceptions.
   def icalendar_export_link(filter={})
-    return _events_feed_linker(filter, :format => "ics")
+    _events_feed_linker(filter, format: "ics")
   end
 
   # Returns an ATOM subscription URL.
   #
   # @see #_events_feed_linker for details on parameters and exceptions.
   def atom_feed_link(filter={})
-    return _events_feed_linker(filter, :format => "atom")
+    _events_feed_linker(filter, format: "atom")
   end
 
   #--[ Sharing buttons ]-----------------------------------------
@@ -124,11 +130,11 @@ module EventsHelper
     lengths = tweet_text_sizer(event)
 
     result = []
-    result << "#{truncate(event.title, :length => lengths[:title])} -"
+    result << "#{truncate(event.title, length: lengths[:title])} -"
     result << event.start_time.strftime("%I:%M%p %m.%d.%Y") # "04:00PM 08.01.2012"
-    result << "@ #{truncate(event.venue.title, :length => lengths[:venue])}" if event.venue
+    result << "@ #{truncate(event.venue.title, length: lengths[:venue])}" if event.venue
 
-    return result.join(" ")
+    result.join(" ")
   end
 
   # Will increase the maximum length of either the event title or venue

data/app/helpers/calagator/mapping_helper.rb

@@ -5,10 +5,6 @@ module MappingHelper
     Calagator.mapping_provider || 'stamen'
   end
 
-  def map_tiles
-    Calagator.mapping_tiles || 'terrain'
-  end
-
   def leaflet_js
     Rails.env.production? ? ["http://cdnjs.cloudflare.com/ajax/libs/leaflet/0.7.3/leaflet.js"] : ["leaflet"]
   end
@@ -29,75 +25,87 @@ module MappingHelper
     leaflet_js + map_provider_dependencies
   end
 
-  def map(locatable_items, options = {})
+  def map(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',
-          prefix: 'fa',
-          markerColor: '#{Calagator.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
+    Map.new(items, self, options).render
   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
+  class Map < Struct.new(:items, :context, :options)
+    def render
+      return if locatable_items.empty?
+      args = js_args.to_json[1...-1] # "splat" arguments by removing wrapping square brackets
+      map_div + context.javascript_tag("map(#{args});")
+    end
 
-  def map_markers(locatable_items)
-    Array(locatable_items).map { |locatable_item|
-      location = locatable_item.location
+    private
+
+    def js_args
+      [
+        layer_constructor,
+        map_tiles,
+        div_id,
+        center,
+        zoom,
+        marker_color,
+        markers,
+        should_fit_bounds
+      ]
+    end
 
-      if location
-        latitude = location[0]
-        longitude = location[1]
-        title = locatable_item.title
-        popup = link_to(locatable_item.title, locatable_item)
+    def map_div
+      context.content_tag(:div, "", id: div_id)
+    end
+
+    def div_id
+      options[:id] || 'map'
+    end
 
-        "L.marker([#{latitude}, #{longitude}], {title: '#{j title}', icon: venueIcon}).bindPopup('#{j popup}')"
-      end
-    }.compact
+    def zoom
+      options[:zoom] || 14
+    end
+
+    def center
+      (options[:center] || locatable_items.first.location).map(&:to_f)
+    end
+
+    def should_fit_bounds
+      locatable_items.count > 1 && options[:center].blank?
+    end
+
+    def markers
+      Array(locatable_items).map do |locatable_item|
+        next unless location = locatable_item.location
+        {
+          latitude: location[0],
+          longitude: location[1],
+          title: locatable_item.title,
+          popup: context.link_to(locatable_item.title, locatable_item)
+        }
+      end.compact
+    end
+
+    def marker_color
+      Calagator.mapping_marker_color
+    end
+
+    def locatable_items
+      @locatable_items ||= Array(items).select {|i| i.location.present? }
+    end
+
+    def layer_constructor
+      constructor_map = {
+        "stamen"  => "L.StamenTileLayer",
+        "mapbox"  => "L.mapbox.tileLayer",
+        "esri"    => "L.esri.basemapLayer",
+        "google"  => "L.Google",
+        "leaflet" => "L.tileLayer",
+      }
+      constructor_map[context.map_provider]
+    end
+
+    def map_tiles
+      Calagator.mapping_tiles || 'terrain'
+    end
   end
 end
 

data/app/helpers/calagator/tags_helper.rb

@@ -2,40 +2,59 @@ 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
+    model.tags.sort_by(&:name).map do |tag|
+      TagLink.new(model.class.table_name, tag, self).render
+    end.join(', ').html_safe
   end
 
-  def tag_link(type, tag, link_class=nil)
-    internal_url = "/#{type.pluralize}/tag/#{tag.name}"
+  class TagLink < Struct.new(:class_name, :tag, :context)
+    def render
+      context.link_to text, url, class: css_class
+    end
 
-    link_classes = [link_class, "p-category"]
-    link_classes << "external #{tag.machine_tag[:namespace]} #{tag.machine_tag[:predicate]}" if tag.machine_tag[:url]
+    private
 
-    link_text = [tag_icon(tag.name), escape_once(tag.name)].compact.join(' ').html_safe
+    def text
+      icon = TagIcon.new(tag.name, context)
+      [icon.exists? && icon.image_tag, context.escape_once(tag.name)].compact.join(' ').html_safe
+    end
 
-    link_to link_text, (tag.machine_tag[:url] || internal_url), :class => link_classes.compact.join(' ')
-  end
-  private :tag_link
+    def url
+      machine_tag.url || "/#{class_name}/tag/#{tag.name}"
+    end
 
-  def icon_exists_for?(tag_name)
-    !!Rails.application.assets["tag_icons/#{tag_name}.png"]
-  end
+    def css_class
+      classes = ["p-category"]
+      classes += ["external", machine_tag.namespace, machine_tag.predicate] if machine_tag.url
+      classes.join(' ')
+    end
 
-  def tag_icon(tag_name)
-    if icon_exists_for?(tag_name)
-      image_tag(asset_path("tag_icons/#{tag_name}.png"), title: tag_name)
+    def machine_tag
+      tag.machine_tag
     end
   end
 
-  def get_tag_icon_links(event)
+  def display_tag_icons(event)
     event.tag_list.map do |tag_name|
-      icon = tag_icon(tag_name)
-      link_to(icon, tag_events_path(tag_name)) if icon
-    end
+      icon = TagIcon.new(tag_name, self)
+      link_to(icon.image_tag, tag_events_path(tag_name)) if icon.exists?
+    end.join(' ').html_safe
   end
 
-  def display_tag_icons(event)
-    get_tag_icon_links(event).join(' ').html_safe
+  class TagIcon < Struct.new(:name, :context)
+    def image_tag
+      context.image_tag(image_path, title: name)
+    end
+
+    def exists?
+      Rails.application.assets[image_path]
+    end
+
+    private
+
+    def image_path
+      "tag_icons/#{name}.png"
+    end
   end
 end
 

data/app/models/calagator/event.rb

@@ -27,6 +27,7 @@ require "calagator/url_prefixer"
 require "paper_trail"
 require "loofah-activerecord"
 require "loofah/activerecord/xss_foliate"
+require "active_model/sequential_validator"
 
 # == Event
 #
@@ -39,7 +40,8 @@ class Event < ActiveRecord::Base
   has_paper_trail
   acts_as_taggable
 
-  xss_foliate :strip => [:title], :sanitize => [:description, :venue_details]
+  xss_foliate strip: [:title, :description, :venue_details]
+
   include DecodeHtmlEntitiesHack
 
   # Associations
@@ -47,21 +49,22 @@ class Event < ActiveRecord::Base
   belongs_to :source
 
   # Validations
-  validates_presence_of :title, :start_time
-  validate :end_time_later_than_start_time
+  validates :title, :description, :url, blacklist: true
+  validates :start_time, :end_time, sequential: true
+  validates :title, :start_time, presence: true
   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
+  before_destroy { !locked } # prevent locked events from being destroyed
 
   # Duplicates
   include DuplicateChecking
   duplicate_checking_ignores_attributes    :source_id, :version, :venue_id
   duplicate_squashing_ignores_associations :tags, :base_tags, :taggings
+  duplicate_finding_scope -> { future.order(:id) }
+  after_squashing_duplicates ->(master) { master.venue.try(:update_events_count!) }
 
   # Named scopes
   scope :after_date, lambda { |date|
@@ -69,12 +72,12 @@ class Event < ActiveRecord::Base
   }
   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)",
+    where("(events.start_time >= :time) OR (events.end_time IS NOT NULL AND events.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)
+    where("start_time < :time", :time => time).order(start_time: :desc)
   }
   scope :future, lambda { on_or_after_date(Time.zone.today) }
   scope :past, lambda { before_date(Time.zone.today) }
@@ -85,39 +88,21 @@ class Event < ActiveRecord::Base
     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').references(:venues)
-      else # when 'date', nil
-        order('start_time')
+  scope :ordered_by_ui_field, lambda { |ui_field|
+    scope = case ui_field
+    when 'name'
+      order('lower(events.title)')
+    when 'venue'
+      includes(:venue).order('lower(venues.title)').references(:venues)
+    else
+      all
     end
+    scope.order('start_time')
   }
 
   #---[ 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
@@ -141,13 +126,14 @@ class Event < ActiveRecord::Base
   end
 
   def time_for(value)
-    value = value.join(' ') if value.kind_of?(Array)
     value = value.to_s if value.kind_of?(Date)
     value = Time.zone.parse(value) if value.kind_of?(String) # this will throw ArgumentError if invalid
     value
   end
   private :time_for
 
+  #---[ Lock toggling ]---------------------------------------------------
+
   def lock_editing!
     update_attribute(:locked, true)
   end
@@ -156,26 +142,8 @@ class Event < ActiveRecord::Base
     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
@@ -184,61 +152,24 @@ class Event < ActiveRecord::Base
     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
+    return unless end_time && start_time
+    (start_time..end_time).cover?(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
+    return 0 unless end_time && start_time
+    (end_time - start_time)
   end
 end