open_conference_ware 1.0.0.pre1

data/app/helpers/open_conference_ware/tracks_helper.rb

@@ -0,0 +1,9 @@
+module OpenConferenceWare
+  module TracksHelper
+    include FauxRoutesMixin
+    
+    def track_css_class(track)
+      "track-#{track.id}"
+    end
+  end
+end

data/app/helpers/open_conference_ware/user_favorites_helper.rb

@@ -0,0 +1,15 @@
+module OpenConferenceWare
+  module UserFavoritesHelper
+    # Add JavaScript to layout that populates the user's favorites and binds these controls.
+    def include_user_favorites_javascript
+      expose_to_js :favorites_path, user_favorites_path(user_id: :me)
+      run_when_dom_is_ready 'populate_user_favorites();'
+      run_when_dom_is_ready 'bind_user_favorite_controls();'
+    end
+
+    # Return link for a UserFavorite control for the given +proposal+.
+    def user_favorite_control_for(proposal)
+      return link_to(content_tag(:span, "*"), user_favorites_path(:me), class: "favorite favorite_#{proposal.id}")
+    end
+  end
+end

data/app/mailers/open_conference_ware/speaker_mailer.rb

@@ -0,0 +1,51 @@
+module OpenConferenceWare
+  class SpeakerMailer < ActionMailer::Base
+
+    # Provide ::raw_snippet_for
+    include SnippetsHelper
+
+    # Provide ::strip_tags
+    include ActionView::Helpers::SanitizeHelper
+    extend  ActionView::Helpers::SanitizeHelper::ClassMethods
+
+
+    def self.configured?
+      if !Rails.env.test? && (OpenConferenceWare.email.blank? || OpenConferenceWare.email['action_mailer'].blank? || OpenConferenceWare.email['default_from_address'] == 'test')
+        return false
+      else
+        return true
+      end
+    end
+
+    def clean_snippet(slug)
+      text = raw_snippet_for(slug)
+      text = text.gsub(/<br>/, "\n")
+      strip_tags(text)
+    end
+
+    def speaker_email(subject_snippet, body_snippet, proposal)
+      unless self.class.configured?
+        raise ArgumentError, "Email settings must be set in 'config/secrets.yml'"
+      end
+
+      @proposal = proposal
+      @body_text  = clean_snippet(body_snippet)
+
+      mail(
+        to: proposal.mailto_emails,
+        bcc: OpenConferenceWare.default_bcc_address,
+        from: OpenConferenceWare.default_from_address,
+        subject: clean_snippet(subject_snippet),
+        template_name: 'speaker_email'
+      )
+    end
+
+    def speaker_accepted_email(proposal)
+      speaker_email('proposals_acceptance_email_subject', 'proposals_acceptance_email_text', proposal)
+    end
+
+    def speaker_rejected_email(proposal)
+      speaker_email('proposals_rejected_email_subject', 'proposals_rejected_email_text', proposal)
+    end
+  end
+end

data/app/mixins/open_conference_ware/breadcrumbs_mixin.rb

@@ -0,0 +1,76 @@
+module OpenConferenceWare
+
+  # = BreadcrumbsMixin
+  #
+  # Adds breadcrumb trail to pages.
+  #
+  # == Usage
+  #
+  # In your application controller:
+  #
+  #   class Application < ActionController::Base
+  #     include BreadcrumbsMixin
+  #   end
+  #
+  # In each controller you want to add a resource-level breadcrumb:
+  #
+  #   class ThingsController < ActionController::Base
+  #     add_breadcrumb "Things", "/things"
+  #   end
+  #
+  # In each action you want to add a breadcrumb:
+  #
+  #   class ThingsController < ActionController::Base
+  #     ...
+  #
+  #     def show
+  #       ...
+  #       @thing = Thing.find(params[:id])
+  #       add_breadcrumb @thing.title, thing_path(@thing)
+  #     end
+  #   end
+  module BreadcrumbsMixin
+
+    def self.included(mixee)
+      mixee.module_eval do
+        # http://szeryf.wordpress.com/2008/06/13/easy-and-flexible-breadcrumbs-for-rails/
+
+        # Add a breadcrumb. E.g.:
+        #
+        #   add_breadcrumb('Ignite Portland', 'http://igniteportland.com/')
+        def add_breadcrumb(name, url='')
+          @breadcrumbs ||= []
+          url = eval(url) if url =~ /_path|_url|@/
+          @breadcrumbs << [name, url]
+        end
+
+        # Add multiple breadcrumbs at once. Input is an array of arrays whose
+        # elements are a name and URL. E.g.:
+        #
+        #   add_breadcrumbs([
+        #     ['Ignite Portland', 'http://igniteportland.com/'],
+        #     ['Proposals', '/proposals/'],
+        #   ])
+        def add_breadcrumbs(breadcrumbs)
+          breadcrumbs.each do |breadcrumb|
+            add_breadcrumb(*breadcrumb)
+          end
+        end
+
+        # Add breadcrumb within a controller. Accepts same arguments as #add_breadcrumb.
+        def self.add_breadcrumb(name, url='', options={})
+          before_filter(options) do |controller|
+            controller.send(:add_breadcrumb, name, url)
+          end
+        end
+
+        # Add multiple breadcrumbs within a controller. Accepts same arguments as #add_breadcrumb.
+        def self.add_breadcrumbs(breadcrumbs, options={})
+          before_filter(options) do |controller|
+            controller.send(:add_breadcrumbs, breadcrumbs)
+          end
+        end
+      end
+    end
+  end
+end

data/app/mixins/open_conference_ware/cache_lookups_mixin.rb

@@ -0,0 +1,128 @@
+module OpenConferenceWare
+
+  # = CacheLookupsMixin
+  #
+  # A mixin that provides simple caching for ActiveRecord models. It's best used
+  # for models that have relatively few records (less than a thousand) and are
+  # updated infrequently (less than once per second).
+  #
+  # == Example of usage
+  #
+  # Setup lookups for Thing:
+  #
+  #   class Thing < ActiveRecord::Base
+  #     cache_lookups_for :id, order: :created_at
+  #     ...
+  #   end
+  #
+  # Return array of things in the order they were created:
+  #   things = Thing.lookup
+  #
+  # Return a particular Thing matching ID 66:
+  #   thing = Thing.lookup(66)
+  module CacheLookupsMixin
+    def self.included(mixee)
+      mixee.send(:extend, ClassMethods)
+      mixee.class_eval do
+        # ActiveRecord model's attribute to use when asked to lookup a specific
+        # item. Defaults to :id.
+        cattr_accessor :lookup_key
+        self.lookup_key = :id
+
+        # Hash of options passed to ActiveRecord::Base.find when populating the
+        # cache. This makes it possible to add :order and filter by :condition.
+        cattr_accessor :lookup_opts
+        self.lookup_opts = {}
+      end
+    end
+
+    module ClassMethods
+      # Should lookups be cached? If the "perform_caching" Rails environment
+      # configuration setting is enabled, default to using cache.
+      #
+      # You can force caching on or off using the CACHELOOKUPS environmental
+      # variable, e.g. activate with:
+      #
+      #   CACHELOOKUPS=1 ./script/server
+      def cache_lookups?
+        if Rails.configuration.action_controller.perform_caching
+          return ENV['CACHELOOKUPS'] != '0'
+        else
+          return ENV['CACHELOOKUPS'] == '1'
+        end
+      end
+
+      # Setup the lookup caching system.
+      #
+      # Arguments:
+      # * key: The attribute you'll use as a key for doing lookups.
+      # * opts: Options to pass to ActiveRecord::Base.find.
+      def cache_lookups_for(key, opts={})
+        self.lookup_key = key
+        self.lookup_opts = opts
+      end
+
+      # Return silo that this class's values will be stored in.
+      def lookup_silo_name
+        return "#{self.name.gsub('::', '__')}_dict"
+      end
+
+      def query_one(key)
+        return self.where(self.lookup_key => key).first
+      end
+
+      def query_all
+        scope = self
+        scope = scope.order(self.lookup_opts[:order]) if self.lookup_opts[:order]
+        scope = scope.includes(*self.lookup_opts[:include]) if self.lookup_opts[:include]
+        return scope
+      end
+
+      # Return instance from cache matching +key+. If +key+ is undefined, returns
+      # array of all instances.
+      def lookup(key=nil)
+        unless self.cache_lookups?
+          return key ?
+            self.query_one(key) :
+            self.query_all
+        end
+
+        silo = self.lookup_silo_name
+        key_number = key.try(:[], '#'+to_s) if key.present?
+        ActiveRecord::Base.benchmark("Lookup: #{silo}#{key_number}") do
+          dict = self.fetch_object(silo){
+            # FIXME Exceptions within this block are silently swallowed by something. This is bad.
+            dict = Hashery::Dictionary.new
+            for record in self.query_all
+              dict[record.send(self.lookup_key)] = record
+            end
+            dict
+          }
+          return key ? dict[key.kind_of?(Symbol) ? key.to_s : key] : dict.values
+        end
+      end
+
+      def expire_cache
+        Rails.logger.info("Lookup, expiring: #{self.name}")
+        CacheWatcher.expire(/#{lookup_silo_name}_.+/)
+      end
+
+      def fetch_object(silo, &block)
+        self.revive_associations_for(self)
+        return Rails.cache.fetch(silo, &block)
+      end
+
+      def revive_associations_for(object)
+        if object.kind_of?(ActiveRecord::Base) || object.ancestors.include?(ActiveRecord::Base)
+          object.reflect_on_all_associations.each do |association|
+            name = association.class_name
+            unless object.constants.include?(name)
+              name.constantize # This line forces Rails to load this class
+            end
+          end
+        end
+      end
+    end
+
+  end
+end

data/app/mixins/open_conference_ware/faux_routes_mixin.rb

@@ -0,0 +1,83 @@
+module OpenConferenceWare
+
+  # = FauxRoutesMixin
+  #
+  # The FauxRoutesMixin generates a bunch of route helpers for the
+  # TracksController and SessionTypesController nested resources.
+  #
+  # == Examples
+  #
+  # Long-hand way of expressing "/events/:event_id/tracks/:track_id":
+  #   event_track_path(@event, @track)
+  #
+  # Faux route helper for expressing the same thing and getting Event from @event:
+  #   track_path(@track)
+  #
+  module FauxRoutesMixin
+    # FIXME this implementation is 10x more complex than it should be, but I don't know how to make it simpler
+    
+    TRACE = false
+
+    def self.included(mixee)
+      mixee.extend(Methods)
+
+      if mixee.ancestors.include?(ActionController::Base)
+        mixee.class_eval do
+          Methods.instance_methods.each do |name|
+            Rails.logger.debug("Faux route, helperized: #{name}") if TRACE
+            helper_method(name)
+          end
+        end
+      end
+    end
+
+    module Methods
+      # Create a single route for the +options+.
+      faux_route_for = lambda do |opts|
+        verb = opts[:verb] # The action prefix for the route, e.g., the "new" in "new_track".
+        noun = opts[:noun] # The singular resource to create a route for, e.g., "track".
+        item = opts[:item] # Does this verb operate on an item and need an id, e.g., "new_track" does not, but "edit_track" does.
+        for kind in %w[path url]
+          real = "#{verb ? verb+'_' : nil}event_#{noun}_#{kind}"
+          faux = "#{verb ? verb+'_' : nil}#{noun}_#{kind}"
+          msg = nil
+          if item
+            msg = "Faux route, created for item: #{faux} <= #{real}"
+            define_method(faux, proc{|item, *args| send(real, item.event, item, *args)})
+          else
+            msg = "Faux route, created for inference: #{faux} <= #{real}"
+            define_method(faux, proc{|*args|
+              event = @event
+              if ! event && self.respond_to?(:get_current_event_and_assignment_status)
+                event = self.get_current_event_and_assignment_status.first
+              end
+              raise ArgumentError, "No event found for faux route" unless event
+              send(real, event, *args)
+            })
+          end
+          Rails.logger.debug(msg) if TRACE
+        end
+      end
+
+      # Create all common routes for this +resource+.
+      faux_routes_for = lambda do |resource|
+        resource = resource.to_s.singularize
+        faux_route_for[noun: resource]
+        faux_route_for[noun: resource.pluralize]
+        faux_route_for[noun: resource, verb: "new"]
+        faux_route_for[noun: resource, item: true]
+        faux_route_for[noun: resource, verb: "edit", item: true]
+      end
+
+      # Create faux routes for the following +resources+:
+      faux_routes_for["tracks"]
+      faux_routes_for["session_types"]
+      faux_routes_for["rooms"]
+      faux_routes_for["schedule_items"]
+    end
+
+    include Methods
+    extend Methods
+
+  end
+end

data/app/mixins/open_conference_ware/normalize_url_mixin.rb

@@ -0,0 +1,40 @@
+module OpenConferenceWare
+  module NormalizeUrlMixin
+    def self.included(mixee)
+      mixee.send(:extend, ClassMethods)
+      mixee.send(:include, ClassMethods)
+    end
+
+    module ClassMethods
+      # Return a normalized URL, with the scheme prefix added, or raise an
+      # URI::InvalidURIError if invalid.
+      def normalize_url!(url)
+        uri = URI.parse(url.strip)
+        uri.scheme = 'http' unless ['http','ftp'].include?(uri.scheme) || uri.scheme.nil?
+        return URI.parse(uri.scheme.nil? ? 'http://'+url.strip : uri.to_s).normalize.to_s
+      end
+
+      # Validate that +attributes+ each contain a valid URL or are blank. If any
+      # are invalid, returns false. Invalid attributes will be marked with an
+      # ActiveRecord validation error.
+      def validate_url_attribute(*attributes)
+        valid = true
+        for attribute in [attributes].flatten
+          value = self.read_attribute(attribute)
+          next if value.blank?
+          begin
+            url = self.normalize_url!(value)
+            self.send("#{attribute}=", url)
+          rescue URI::InvalidURIError => e
+            self.errors.add(attribute, 'is invalid')
+            valid = false
+          end
+        end
+        return valid
+      end
+    end
+
+    include ClassMethods
+    extend ClassMethods
+  end
+end

data/app/mixins/open_conference_ware/public_attributes_mixin.rb

@@ -0,0 +1,62 @@
+module OpenConferenceWare
+  # = PublicAttributesMixin
+  #
+  # The PublicAttributesMixin provides a simple way to mark attributes as
+  # publicly-known and export only their data. This mixin is useful for
+  # selectively exposing attributes to AJAX methods and exporter programs where
+  # you do not want to publish confidential data, such as email addresses,
+  # passwords, etc.
+  #
+  # == Usage
+  #
+  # Include the mixin and set the public attribute names:
+  #
+  #   class User < ActiveRecord::Base
+  #     include PublicAttributesMixin
+  #     set_public_attributes :id, :first_name, :last_name
+  #   end
+  #
+  # Export data for a record:
+  #
+  #   user = User.first
+  #   puts user.public_attributes.inspect
+  #   # => {"id" => 123, "first_name" => "Bubba", "last_name" => "Smith"}
+  module PublicAttributesMixin
+    def self.included(receiver)
+      receiver.send(:cattr_accessor, :public_attribute_keys)
+      receiver.send("public_attribute_keys=", [])
+      receiver.send(:extend, ClassMethods)
+      receiver.send(:include, InstanceMethods)
+    end
+
+    module ClassMethods
+      # Set the names of public attributes. Can specify attributes using strings
+      # or symbols, and as an array or arguments.
+      def set_public_attributes(*args)
+        self.public_attribute_keys = [args].flatten.map(&:to_sym)
+      end
+    end
+
+    module InstanceMethods
+      # Return a hash of public attributes.
+      def public_attributes
+        return self.public_attribute_keys.inject({}) do |result, key|
+          result[key.to_s] = self.send(key) if self.public_attribute_keys.include?(key.to_sym)
+          result
+        end
+      end
+
+      def serializable_hash(options={})
+        if (options.keys & [:only, :except, :methods, :include]).present?
+          super(options)
+        else
+          public_attributes
+        end
+      end
+
+      def to_xml(options={})
+        serializable_hash(options).to_xml(options)
+      end
+    end
+  end
+end