calagator 0.0.1.pre1

data/app/controllers/calagator/sources_controller.rb

@@ -0,0 +1,94 @@
+module Calagator
+
+class SourcesController < ApplicationController
+  # POST /import
+  # POST /import.xml
+  def import
+    @importer = Source::Importer.new(params[:source])
+    respond_to do |format|
+      if @importer.import
+        format.html { redirect_to events_path, flash: { success: render_to_string(layout: false) } }
+        format.xml  { render xml: @importer.source, events: @importer.events }
+      else
+        format.html { redirect_to new_source_path(url: @importer.source.url), flash: { failure: @importer.failure_message } }
+        format.xml  { render xml: @importer.source.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+  
+  # GET /sources
+  # GET /sources.xml
+  def index
+    @sources = Source.listing
+
+    respond_to do |format|
+      format.html { @sources = @sources.paginate(page: params[:page], per_page: params[:per_page]) }
+      format.xml  { render xml: @sources }
+    end
+  end
+
+  # GET /sources/1
+  # GET /sources/1.xml
+  def show
+    @source = Source.find(params[:id], include: [:events, :venues])
+    respond_to do |format|
+      format.html # show.html.erb
+      format.xml  { render xml: @source }
+    end
+  rescue ActiveRecord::RecordNotFound => error
+    flash[:failure] = error.to_s if params[:id] != "import"
+    redirect_to new_source_path
+  end
+
+  # GET /sources/new
+  def new
+    @source = Source.new
+    @source.url = params[:url] if params[:url].present?
+  end
+
+  # GET /sources/1/edit
+  def edit
+    @source = Source.find(params[:id])
+  end
+
+  # POST /sources
+  # POST /sources.xml
+  def create
+    @source = Source.new
+    create_or_update
+  end
+
+  # PUT /sources/1
+  # PUT /sources/1.xml
+  def update
+    @source = Source.find(params[:id])
+    create_or_update
+  end
+
+  def create_or_update
+    respond_to do |format|
+      if @source.update_attributes(params[:source])
+        format.html { redirect_to @source, notice: 'Source was successfully saved.' }
+        format.xml  { render xml: @source, status: :created, location: @source }
+      else
+        format.html { render action: @source.new_record? ? "new" : "edit" }
+        format.xml  { render xml: @source.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+  private :create_or_update
+
+  # DELETE /sources/1
+  # DELETE /sources/1.xml
+  def destroy
+    @source = Source.find(params[:id])
+    @source.destroy
+
+    respond_to do |format|
+      format.html { redirect_to sources_url }
+      format.xml  { head :ok }
+    end
+  end
+end
+
+end

data/app/controllers/calagator/venues_controller.rb

@@ -0,0 +1,133 @@
+require "calagator/duplicate_checking/controller_actions"
+
+module Calagator
+
+class VenuesController < ApplicationController
+  # Provides #duplicates and #squash_many_duplicates
+  include DuplicateChecking::ControllerActions
+  require_admin only: [:duplicates, :squash_many_duplicates]
+
+  # GET /venues
+  # GET /venues.xml
+  def index
+    @search = Venue::Search.new(params)
+    @venues = @search.venues
+
+    respond_to do |format|
+      format.html # index.html.erb
+      format.kml  # index.kml.erb
+      format.xml  { render :xml  => @venues }
+      format.json { render :json => @venues, :callback => params[:callback] }
+      format.js   { render :json => @venues, :callback => params[:callback] }
+    end
+  end
+
+  def autocomplete
+    @venues = Venue
+      .non_duplicates
+      .in_business
+      .where(["LOWER(title) LIKE ?", "%#{params[:term]}%".downcase])
+      .order('LOWER(title)')
+
+    respond_to do |format|
+      format.json { render :json => @venues, :callback => params[:callback] }
+    end
+  end
+
+  # GET /venues/map
+  def map
+    @venues = Venue.non_duplicates.in_business
+  end
+
+  # GET /venues/1
+  # GET /venues/1.xml
+  def show
+    @venue = Venue.find(params[:id], include: :source)
+
+    return redirect_to @venue.duplicate_of if @venue.duplicate?
+
+    respond_to do |format|
+      format.html
+      format.xml  { render xml: @venue }
+      format.json { render json: @venue, callback: params[:callback] }
+      format.ics  { render ics: @venue.events.order("start_time ASC").non_duplicates }
+    end
+
+  rescue ActiveRecord::RecordNotFound => e
+    flash[:failure] = e.to_s
+    redirect_to venues_path
+  end
+
+  # GET /venues/new
+  # GET /venues/new.xml
+  def new
+    @venue = Venue.new
+    render layout: params[:layout] != "false"
+  end
+
+  # GET /venues/1/edit
+  def edit
+    @venue = Venue.find(params[:id])
+  end
+
+  # POST /venues
+  # POST /venues.xml
+  def create
+    @venue = Venue.new
+    create_or_update
+  end
+
+  # PUT /venues/1
+  # PUT /venues/1.xml
+  def update
+    @venue = Venue.find(params[:id])
+    create_or_update
+  end
+
+  def create_or_update
+    @venue.attributes = params[:venue]
+    respond_to do |format|
+      if !evil_robot? && @venue.save
+        format.html { redirect_to from_event || @venue, flash: { success: "Venue was successfully saved." } }
+        format.xml  { render xml: @venue, status: :created, location: @venue }
+      else
+        format.html { render action: @venue.new_record? ? "new" : "edit" }
+        format.xml  { render xml: @venue.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /venues/1
+  # DELETE /venues/1.xml
+  def destroy
+    @venue = Venue.find(params[:id])
+
+    if @venue.events.any?
+      message = "Cannot destroy venue that has associated events, you must reassociate all its events first."
+      respond_to do |format|
+        format.html { redirect_to @venue, flash: { failure: message } }
+        format.xml  { render xml: message, status: :unprocessable_entity }
+      end
+    else
+      @venue.destroy
+      respond_to do |format|
+        format.html { redirect_to venues_path, flash: { success: %("#{@venue.title}" has been deleted) } }
+        format.xml  { head :ok }
+      end
+    end
+  end
+
+  private
+
+  def evil_robot?
+    if params[:trap_field].present?
+      flash[:failure] = "<h3>Evil Robot</h3> We didn't save this venue 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 from_event
+    Event.find_by_id(params[:from_event])
+  end
+end
+
+end

data/app/controllers/calagator/versions_controller.rb

@@ -0,0 +1,20 @@
+module Calagator
+
+class VersionsController < ApplicationController
+  def edit
+    @version = Version.find(params[:id])
+    @record = @version.next.try(:reify) || @version.item || @version.reify
+
+    singular = @record.class.name.singularize.underscore.split("/").last
+    plural = @record.class.name.pluralize.underscore.split("/").last
+    self.instance_variable_set("@#{singular}", @record)
+
+    if request.xhr?
+      render :partial => "calagator/#{plural}/form", :locals => { singular.to_sym =>  @record }
+    else
+      render "calagator/#{plural}/edit", :locals => { singular.to_sym =>  @record }
+    end
+  end
+end
+
+end

data/app/helpers/calagator/application_helper.rb

@@ -0,0 +1,128 @@
+# Methods added to this helper will be available to all templates in the application.
+module Calagator
+
+module ApplicationHelper
+  include TimeRangeHelper
+
+  # Returns HTML string of an event or venue description for display in a view.
+  def format_description(string)
+    sanitize(auto_link(upgrade_br(markdown(string))))
+  end
+
+  def markdown(text)
+    BlueCloth.new(text, :relaxed => true).to_html
+  end
+
+  # Return a HTML string with the BR tags converted to XHTML compliant markup.
+  def upgrade_br(content)
+    content.gsub('<br>','<br />')
+  end
+
+  FLASH_TYPES = [:success, :failure]
+
+  def render_flash
+    FLASH_TYPES.map{|type|
+      next unless flash[type].present?
+      content_tag(:div, :class => "flash #{type} flash_#{type}") do
+        "#{type == :failure ? 'ERROR: ' : ''}#{flash[type]}".html_safe
+      end
+    }.compact.join.html_safe
+  end
+
+  def datetime_format(time,format)
+    format = format.gsub(/(%[dHImU])/,'*\1')
+    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
+
+  def source_code_version
+    Calagator::ApplicationController::SOURCE_CODE_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}"
+    else
+      stamp << "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) )
+    end
+    stamp << "."
+    stamp.html_safe
+  end
+
+  # Caches +block+ in view only if the +condition+ is true.
+  # http://skionrails.wordpress.com/2008/05/22/conditional-fragment-caching/
+  def cache_if(condition, name={}, &block)
+    if condition
+      cache(name, &block)
+    else
+      block.call
+    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
+
+  # String name of the mobile preference cookie's name, e.g. "calagator_mobile".
+  MOBILE_COOKIE_NAME = "#{SECRETS.session_name}_mobile"
+
+  # 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)
+  end
+end
+
+end

data/app/helpers/calagator/events_helper.rb

@@ -0,0 +1,184 @@
+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
+  end
+
+# calculate rowspans for an array of events
+# argument:  array of events
+# returns:  rowspans, an array in which each entry corresponds to an event in events;
+# each entry is number of rows spanned by today_tomorrow_weekday entry, if any, to left of event
+# entry will be > 0 for first event of day, 0 for other events
+  def calculate_rowspans(events)
+    previous_start_time = nil
+    rowspans = Array.new(events.size, 0)
+    first_event_of_day = 0
+
+    events.each_with_index do |event, index|
+      new_day = previous_start_time.nil? || (previous_start_time.to_date != event.start_time.to_date)
+      if new_day
+        first_event_of_day = index
+      end
+      rowspans[first_event_of_day] += 1
+      previous_start_time = event.start_time
+    end
+
+    return rowspans
+  end
+
+  def google_maps_url(address)
+    return "http://maps.google.com/maps?q=#{cgi_escape(address)}"
+  end
+
+  #---[ Event sorting ]----------------------------------------------------
+
+  # Return a link for sorting by +key+ (e.g., "name").
+  def events_sort_link(key)
+    if key.present?
+      link_to(sorting_label_for(key, @tag.present?), url_for(params.merge(:order => key)))
+    else
+      link_to('Default', url_for(params.tap { |o| o.delete :order }))
+    end
+  end
+
+  # Return a human-readable label describing what the sorting +key+ is.
+  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
+
+  #---[ Feed links ]------------------------------------------------------
+
+  # Returns a URL for an events feed.
+  #
+  # @param [Hash] filter Options for filtering. If values are defined, returns
+  #   a link to all events. If a :query is defined, returns a link to search
+  #   events' text by that query. If a :tag is defined, returns a link to search
+  #   events with that tag.
+  # @param [Hash] common Options for the URL helper, such as :protocol, :format
+  #   and such.
+  #
+  # @raise [ArgumentError] Raised if given invalid filter options.
+  #
+  # @return [String] URL
+  def _events_feed_linker(filter={}, common={})
+    # Delete blank filter options because this method is typically called with
+    # both a :tag and :query filter, but only one will actually be set.
+    filter.delete_if { |key, value| value.blank? }
+
+    if (unknown = filter.keys - [:query, :tag]).present?
+      raise ArgumentError, "Unknown option(s): #{unknown.inspect}"
+    end
+
+    return filter.present? ?
+      search_events_url(common.merge(filter)) :
+      events_url(common)
+  end
+
+  GOOGLE_EVENT_SUBSCRIBE_BASE = "http://www.google.com/calendar/render?cid="
+
+  # Returns a Google Calendar subscription URL.
+  #
+  # @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)}"
+  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")
+  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")
+  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")
+  end
+
+  #--[ Sharing buttons ]-----------------------------------------
+
+  # Tweet button text
+
+  def tweet_text(event)
+    lengths = tweet_text_sizer(event)
+
+    result = []
+    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
+
+    return result.join(" ")
+  end
+
+  # Will increase the maximum length of either the event title or venue
+  # if one of the two is shorter than the maximum: 46
+
+  def tweet_text_sizer(event)
+    title_length = event.title.length
+    venue_length = (event.venue.try(:title) || "").length
+    title_length = tweet_length(title_length, venue_length)
+    venue_length = tweet_length(venue_length, title_length)
+    { title: title_length, venue: title_length }
+  end
+  private :tweet_text_sizer
+
+  def tweet_length length_a, length_b
+    if length_a > 46
+      length_a = 46
+      length_a += (46-length_b) if length_b < 46
+    end
+    length_a
+  end
+  private :tweet_length
+
+  def shareable_event_url(event)
+    event_url(event) if event.persisted?
+  end
+
+  #---[ Sort labels ]-------------------------------------------
+
+  # Return the label for the +sorting_key+ (e.g. 'score'). Optionally set the
+  # +is_searching_by_tag+, to constrain options available for tag searches.
+  def sorting_label_for(sorting_key=nil, is_searching_by_tag=false)
+    sorting_key = sorting_key.to_s
+    if sorting_key.present? and SORTING_LABELS.has_key?(sorting_key)
+      SORTING_LABELS[sorting_key]
+    elsif is_searching_by_tag
+      SORTING_LABELS['date']
+    else
+      SORTING_LABELS['score']
+    end
+  end
+
+  # Labels displayed for sorting options:
+  SORTING_LABELS = {
+    'name'  => 'Event Name',
+    'venue' => 'Location',
+    'score' => 'Relevance',
+    'date'  => 'Date',
+  }
+  private_constant :SORTING_LABELS
+end
+
+end