serum-rails 0.1.0

data/spec/test_app/app/helpers/application_helper.rb

@@ -0,0 +1,180 @@
+# Methods added to this helper will be available to all templates in the application.
+# origin: RM
+module ApplicationHelper
+
+  def icon(icon, label)
+    content_tag(:span, label, :class => "#{icon}_icon")
+  end
+  
+  def page_head(options = {})
+    html = ''.html_safe
+    html << content_tag(:h1, options[:title]) if options[:title]
+    html << render_navigation(options[:navigation]) if options[:navigation]
+    if html.present?
+      content_for(:page_head) do
+        content_tag(:div, :id => 'page_head') do
+          content_tag(:div, :id => 'page_head_inner') do
+            html
+          end
+        end
+      end
+    end
+  end
+
+  def page_navigation(navigation)
+    content_for(:page_navigation, render_navigation(navigation, :id => 'page_navigation'))
+  end
+
+  def uid
+    @@next_uid ||= 0
+    @@next_uid += 1
+    "element_uid_#{@@next_uid}"
+  end
+
+  # This method is supposed to work with Tex output. Don't use HTML entities.
+  def money_amount(amount)
+    if amount.present?
+      "#{amount.with_comma(2)} €" # this includes a nbsp!
+    else
+      "–" # &dash;
+    end
+  end  
+
+  def maybe_blank(value, options = {})
+    if value.present?
+      if options[:url] && Patterns::URL.match(value)
+        link_to(value, value)
+      elsif options[:simple_format]
+        simple_format(value)
+      else
+        value
+      end
+    else
+      '&ndash;'.html_safe
+    end
+  end
+
+  def body_id(id)
+    content_for :body_id, id    
+  end
+
+  def help(message)
+    content_tag :span, "(#{h message})".html_safe, :class => 'help'
+  end
+
+  def clear
+    content_tag :div, '', :class => 'clear'
+  end
+
+  def todo(message)
+    content_tag :span, h(message), :class => 'todo'
+  end
+
+  def pagination(collection)
+    will_paginate collection, :previous_label => "&laquo; zurück", :next_label => "weiter &raquo;"
+  end
+
+  def buttons(options = {}, &block)
+    content = capture(&block)
+    if content.present?
+      content += content_tag(:div, options[:links], :class => 'links') if options[:links]
+      html = content_tag :div, content.html_safe, :class => "buttons #{options[:class]}"
+      block_called_from_erb?(block) ? concat(html) : html
+    end
+  end
+
+  def save_cancel_buttons(options = {})
+    cancel_path = options.delete(:cancel_path) || root_path
+    save_label = options.delete(:save_label) || "Save"
+    cancel_label = options.delete(:cancel_label) || "Cancel"
+    buttons(options.reverse_merge(:class => 'bar')) do
+      html = ''
+      html << submit_tag(save_label, :class => "submit", :disable_with => "Please wait...")
+      html << button_to_function(cancel_label, "location.href = '#{cancel_path}'")
+      html
+    end
+  end
+
+  def boring_create_button(options = {}, &block)
+    button = link_to(icon(:create, options[:label] || "Add"), new_object_path)
+    buttons(&prepend_html_to_block(button, block))
+  end
+  
+  def boring_delete_button(options = {}, &block)
+    link_to(icon(:delete, "Delete"), object_url, :method => :delete)
+  end
+  
+  def boring_edit_button(options = {}, &block)
+    link_to(icon(:edit, "Edit"), edit_object_url)
+  end
+
+  def prepend_html_to_block(html, block)
+    lambda do
+      concatenated = ''.html_safe
+      concatenated << html
+      concatenated << capture(&block) if block
+      concatenated
+    end
+  end
+
+  def boring_save_cancel_buttons(options = {})
+    target = translate_model_name(object)
+    deleted = object.respond_to?(:deleted?) && object.deleted?
+    links = options.delete(:links)
+    cancel_path = options.delete(:cancel_path) || collection_path
+    action = deleted ? "restore" : "delete"
+    delete_link = if options[:delete_link] && !object.new_record?
+      link_class = deleted ? "restore" : "delete"
+      label = icon(link_class, action.titleize)
+      confirm = options[:"confirm_#{link_class}"] || "#{action.titleize} this #{target}?"
+      confirm = confirm.call if confirm.respond_to?(:call)
+      link_to(label, object_url(object), :method => :delete, :confirm => confirm)
+    else
+      nil
+    end
+    save_cancel_buttons options.merge(
+      :links => "#{links} #{delete_link}".html_safe,
+      :cancel_path => cancel_path
+    )
+  end
+
+  def list
+    content_tag(:div, render('list'), :id => 'list')
+  end
+
+  def columns(&content)
+    concat(
+      content_tag(:div, capture(&content) + clear, :class => 'columns')
+    )
+  end
+
+  def column(options = {}, &content)
+    size_class = [options[:size], 'column'].compact.join('_')
+    klass = [size_class, options[:class]].join(' ')
+    content = capture(&content)
+    content = segment(:title => options[:segment], :content => content) if options[:segment]
+    html = content_tag(:div, :class => klass) do
+      content_tag(:div, content, :class => 'column_inner')
+    end
+    concat html
+  end
+
+  def segment(options = {}, &block)
+    title = options[:title]
+    html = ''
+    html << "<div class='segment #{options[:class]}' id='#{options[:id]}' data-show-for='#{options[:"data-show-for"]}'>"
+    html << "<h3 class=\"segment_title\"><span>#{title}</span></h3>" if title.present?
+    html << '<div class="segment_body">'
+    html << (options[:content] || capture(&block))
+    html << '</div>'
+    html << "</div>"
+    html = html.html_safe
+    block && block_called_from_erb?(block) ? concat(html) : html
+  end
+
+  def graceful_link_to_remote(name, options = {}, html_options = nil)
+    html_options ||= {}
+    link_to_remote(name, options, html_options.merge(:href => options[:url], :method => options[:method]))
+  end
+
+end

data/spec/test_app/app/helpers/mail_helper.rb

@@ -0,0 +1,9 @@
+# Helper methods for mailer views.
+# origin: RM
+module MailHelper
+
+  def reset_password_link(user)
+    edit_password_url(:user_id => user, :token  => user.confirmation_token, :escape => false)
+  end
+
+end

data/spec/test_app/app/helpers/tags_helper.rb

@@ -0,0 +1,16 @@
+# Helper for displaying tag clouds (not used in CaP).
+# origin: RM
+module TagsHelper
+
+  def render_tags(tags)
+    tags = tags.collect do |tag|
+      tag.respond_to?(:name) ? tag.name : tag
+    end
+    content_tag :div, :class => 'tags' do
+      tags.sort_by { |t| t.downcase }.collect do |tag|
+        content_tag :span, h(tag), :class => 'tag'
+      end.join(' ').html_safe
+    end
+  end
+
+end

data/spec/test_app/app/helpers/user_helper.rb

@@ -0,0 +1,23 @@
+# Helper methods that deal with the display of user information.
+# origin: M
+module UserHelper
+
+  def friendship_status(user, only_image = false)
+    icon, title = if current_user == user
+      [ 'icons/user-red.png', 'This is you' ]
+    elsif current_user.friends_with?(user)
+      [ 'icons/user-medium.png', 'Confirmed contact' ]
+    elsif current_user.in_contact_with?(user)
+      [ 'icons/mail.png', 'Contact request sent' ]
+    else
+      [ 'icons/user-gray_gray.png', 'No confirmed contact' ]
+    end
+
+    if only_image
+      image_tag icon, :title => title, :alt => title
+    else
+      content_tag :div, title, :class => 'friend_status', :style => "background-image: url(#{image_path icon})"
+    end
+  end
+
+end

data/spec/test_app/app/models/attendance.rb

@@ -0,0 +1,11 @@
+# Stores the fact that a user is attending a conference.
+# origin: M
+class Attendance < ActiveRecord::Base
+
+  validates_presence_of :user_id, :conference_id
+  validates_uniqueness_of :user_id, :scope => :conference_id
+
+  belongs_to :user
+  belongs_to :conference
+
+end

data/spec/test_app/app/models/category/ancestry_trait.rb

@@ -0,0 +1,23 @@
+# Provides category hierarchies.
+# origin: RM
+module Category::AncestryTrait
+  as_trait do
+
+    has_ancestry
+
+    belongs_to :mother, :class_name => 'Category'
+    before_validation :sync_mother_and_parent_id
+
+    # This method serves two purposes:
+    # 1. Cache ancestry's virtual parent_id in a real database column because that makes some queries easier
+    # 2. Allow to set parent_id by setting mother_id so code that uses association reflection works
+    def sync_mother_and_parent_id
+      if mother_id_changed?
+        self.parent_id = mother_id
+      else
+        self.mother_id = parent_id
+      end
+    end
+
+  end
+end

data/spec/test_app/app/models/category.rb

@@ -0,0 +1,25 @@
+# A single conference category.
+# origin: M
+class Category < ActiveRecord::Base
+
+  does 'category/ancestry'
+  does 'sortable', :by => :name
+  does 'indestructible'
+
+  validates_presence_of :name
+  validates_uniqueness_of :name
+
+  named_scope :by_name, :order => :name
+
+  def conferences
+    category_ids = (descendants.collect(&:id) + [id]).uniq
+    Conference.in_categories(category_ids)
+  end
+
+  def available_parents
+    (Category.all - [self]).sort.collect do |category|
+      [category.name, category.id]
+    end
+  end
+
+end

data/spec/test_app/app/models/conference/attendance_trait.rb

@@ -0,0 +1,23 @@
+# Trait to manage the attendees of a conference.
+# origin: M
+module Conference::AttendanceTrait
+  as_trait do
+
+    has_many :attendances, :dependent => :destroy
+    has_many :attendees, :through => :attendances, :source => :user
+
+    def attended_by?(user)
+      @attendee_ids ||= attendee_ids
+      @attendee_ids.include?(user.id)
+    end
+
+    def attend!(user)
+      attendees << user unless attended_by?(user)
+    end
+
+    def cancel_attendance!(user)
+      attendees.delete(user) if attended_by?(user)
+    end
+    
+  end
+end

data/spec/test_app/app/models/conference/categories_trait.rb

@@ -0,0 +1,26 @@
+# Trait to manage the categories of a conference.
+# origin: M
+module Conference::CategoriesTrait
+
+  as_trait do
+    
+    has_many :conference_categories
+    has_many :categories, :through => :conference_categories
+
+    does 'list_field', :category_list
+
+    def category_names
+      categories.collect(&:name)
+    end
+
+    def read_category_list
+      category_ids.collect(&:to_s)
+    end
+
+    def write_category_list(ids)
+      self.category_ids = ids.collect(&:to_i)
+    end
+
+  end
+
+end

data/spec/test_app/app/models/conference/icalendar_trait.rb

@@ -0,0 +1,36 @@
+require 'vpim/icalendar'
+
+# Trait to export a conference in iCalendar format.
+# origin: M
+module Conference::IcalendarTrait
+  as_trait do
+
+    def to_icalendar(viewing_user)
+      Vpim::Icalendar.create2.tap do |calendar|
+        calendar.add_event do |e|
+          e.dtstart start_date
+          e.dtend(end_date + 1.day)
+          e.summary name
+          e.description description
+          e.categories category_names
+          e.organizer visible_vcard_address(user, :for => viewing_user)
+          for attendee in attendees
+            e.add_attendee visible_vcard_address(attendee, :for => viewing_user)
+          end
+        end
+      end
+    end
+
+    private
+
+    def visible_vcard_address(user, options)
+      viewing_user = options[:for]
+      force_visible = (user == self.user) 
+      Vpim::Icalendar::Address.new.tap do |address|
+        address.cn = viewing_user.name_for(user, force_visible)
+        address.uri = viewing_user.sees_details_of?(user, force_visible) ? "mailto:#{user.email}" : NO_REPLY_EMAIL
+      end
+    end
+
+  end
+end

data/spec/test_app/app/models/conference/search_trait.rb

@@ -0,0 +1,44 @@
+# Trait to provide search functionality for conferences.
+# origin: M
+module Conference::SearchTrait
+
+  as_trait do
+
+    does 'searchable', :text_means => 'query'
+
+    named_scope :in_categories, lambda { |ids| { :conditions => ['conference_categories.category_id IN (?)', ids], :joins => :conference_categories, :group => 'conferences.id' } }
+
+    named_scope :from_date, lambda { |date| { :conditions => ['conferences.end_date >= ?', date] } }
+    named_scope :until_date, lambda { |date| { :conditions => ['conferences.start_date <= ?', date] } }
+
+    search_by :query do |query|
+      scoped :conditions => Util.like_query('CONCAT_WS(" ", conferences.name, conferences.description)', query)
+    end
+
+    search_by :from do |date_string|
+      date = Date.parse(date_string) rescue nil
+      if date
+        from_date(date)
+      else
+        self
+      end
+    end
+
+    search_by :until do |date_string|
+      date = Date.parse(date_string) rescue nil
+      if date
+        until_date(date)
+      else
+        self
+      end
+    end
+
+    search_by :cat do |category_string|
+      category_id = Category.find_by_name(category_string).andand.id
+      in_categories([category_id])
+    end
+
+
+  end
+
+end

data/spec/test_app/app/models/conference.rb

@@ -0,0 +1,24 @@
+# Models a conference.
+# origin: M
+class Conference < ActiveRecord::Base
+  does 'conference/categories'
+  does 'conference/attendance'
+  does 'conference/icalendar'
+  does 'conference/search'
+
+  belongs_to :user
+
+  validates_presence_of :name, :start_date, :end_date, :description, :address, :user_id
+
+  named_scope :by_name, :order => :name
+  named_scope :running, lambda {{ :conditions => ['start_date <= ? AND ? <= end_date', Date.today, Date.today] }}
+
+  has_attachment :logo
+
+  validate do |record|
+    if record.start_date and record.end_date and record.start_date > record.end_date
+      record.errors.add :end_date, 'must be after the start date'
+    end
+  end
+
+end

data/spec/test_app/app/models/conference_category.rb

@@ -0,0 +1,6 @@
+# Join model to store the fact that a conference is associated with a category.
+# origin: M
+class ConferenceCategory < ActiveRecord::Base
+  belongs_to :conference
+  belongs_to :category
+end

data/spec/test_app/app/models/conference_search.rb

@@ -0,0 +1,51 @@
+# Maps the conference search form to scopes provided by the conference model.
+# origin: M
+class ConferenceSearch
+
+  attr_accessor :query, :category_ids, :from, :until
+
+  def initialize(options = {})
+    @query = options[:query]
+    @category_ids = options[:category_ids] || []
+    @until = options[:until]
+    @from = options[:from]
+  end
+
+  def find
+    scope = Conference
+    if query
+      scope = scope.search(query)
+    end
+    if category_ids.present?
+      scope = scope.in_categories(category_ids)
+    end
+    if from_date
+      scope = scope.from_date(from_date)
+    elsif !until_date and (query.blank? or (!query.include?('from:') and !query.include?('to:')))
+      scope = scope.from_date(Date.today)
+    end
+    if until_date
+      scope = scope.until_date(until_date)
+    end
+    scope
+  end
+
+  # Define this method to silence deprecation warnings when we are using the non-ActiveRecord class in Rails forms.
+  def id
+    nil
+  end
+
+  def until_date
+    Date.parse(@until) rescue nil
+  end
+
+  def from_date
+    Date.parse(@from) rescue nil
+  end
+
+  def present?
+    query.present? or from_date.present? or until_date.present? or category_ids.present?
+  end
+
+
+end

data/spec/test_app/app/models/error.rb

@@ -0,0 +1,25 @@
+# Utility class to extract validation errors from ActiveRecord models in a readable fashion.
+# origin: RM
+class Error
+
+  def self.messages(object, options = {})
+    except = Set.new(options.delete(:except) || [])
+    object.errors.collect do |attribute, _|
+      message(object, attribute) unless except.include? attribute
+    end.compact
+  end
+
+  def self.message(object, attribute)
+    message = Array(object.errors.on(attribute))
+    if message.present?
+      message = message.first
+      if message.starts_with?('^')
+        message[1..-1]
+      else
+        translated_attribute = I18n.t("activerecord.attributes.#{object.class.name.underscore}.#{attribute}")
+        "#{translated_attribute} #{message}"  
+      end
+    end
+  end
+
+end

data/spec/test_app/app/models/friendship.rb

@@ -0,0 +1,14 @@
+# Stores the fact that a user is the confirmed friend of another user.
+# origin: M
+class Friendship < ActiveRecord::Base
+
+  belongs_to :user
+  belongs_to :friend, :class_name => 'User'
+
+  validates_presence_of :user_id, :friend_id
+
+  def self.import(path)
+    YAML.load(path)
+  end
+
+end

data/spec/test_app/app/models/friendship_request.rb

@@ -0,0 +1,19 @@
+# Stores the fact that a user has requested to be the friend of another user.
+# origin: M 
+class FriendshipRequest < ActiveRecord::Base
+
+  belongs_to :user
+  belongs_to :requesting_user, :class_name => 'User'
+
+  validates_presence_of :user_id, :requesting_user_id
+
+  # When a friendship request is accepted, two Friendship records are created (one for each direction).
+  def accept
+    user.friendships.create(:friend => requesting_user) and requesting_user.friendships.create(:friend => user) and destroy
+  end
+
+  def deny
+    destroy
+  end
+
+end

data/spec/test_app/app/models/invitation.rb

@@ -0,0 +1,38 @@
+# Stores the fact that a user has invited one of her friends to attend a conference.
+# origin: M
+class Invitation < ActiveRecord::Base
+
+  belongs_to :recipient, :class_name => 'User'
+  belongs_to :sender, :class_name => 'User'
+  belongs_to :conference
+
+  validates_presence_of :conference_id, :recipient_id, :sender_id
+
+  validate :recipient_must_be_a_friend
+
+  named_scope :for_recipient, lambda { |recipient| { :conditions => { :recipient_id => recipient.id }}}
+  named_scope :include_everything, :include => [:recipient, :sender, :conference]
+
+  def accept!
+    conference.attend!(recipient)
+    destroy
+  end
+
+  def dismiss!
+    destroy
+  end
+
+  private
+
+  def recipient_must_be_a_friend
+    if sender && recipient && !sender.friends.include?(recipient)
+      errors.add(:recipient_id, 'is not a confirmed contact of the invitation sender')
+    end
+    true
+  end
+
+  def self.import(path)
+    YAML.load(path)
+  end
+
+end

data/spec/test_app/app/models/member_search.rb

@@ -0,0 +1,18 @@
+# Maps the member search form to the scopes provided by the user model.
+# origin: M
+class MemberSearch
+
+  attr_reader :users, :name
+
+  def initialize(user, options = nil)
+    options ||= {} # When using params from the controller without any search query, nil will be passed. Thus, assigning a default value here.
+    @users = User.active
+    @users = @users.search(options[:name], user) if options[:name].present?
+  end
+
+  # Define this method to silence deprecation warnings when we are using the non-ActiveRecord class in Rails forms.
+  def id
+    nil
+  end
+
+end

data/spec/test_app/app/models/navigation.rb

@@ -0,0 +1,38 @@
+# Describes the navigation used by the application views.
+# Controllers can map their actions into symbols defined by this class.
+# origin: RM
+class Navigation < SimpleNavigation
+
+  navigation :main do
+    section :conferences, :label => 'Conferences', :url => lambda { conferences_path } do
+      section :browse, :label => 'Browse', :url => lambda { conferences_path }
+      section :search, :label => 'Search', :url => lambda { search_conferences_path }
+      section :invitations, :label => 'Invitations', :url => lambda { invitations_path }, :show => lambda { current_user.may_index_invitations? }
+    end
+    section :members, :label => 'Members', :url => lambda { members_path }, :show => lambda { current_user.may_index_members? } do
+      section :member_search, :label => 'Search', :url => lambda { members_path }
+      section :profile, :label => 'My profile', :url => lambda { user_path(current_user) }, :show => lambda { current_user.may_access_own_profile? }
+    end
+    section :admin_users, :label => 'Admin users', :url => lambda { admin_users_path }, :show => lambda { current_user.may_index_admin_users? } do
+      section :active_users, :label => 'Active users', :url => lambda { admin_users_path }
+      section :deleted_users, :label => 'Deleted users', :url => lambda { deleted_admin_users_path }
+    end
+    section :admin_categories, :label => 'Admin categories', :url => lambda { admin_categories_path }, :show => lambda { current_user.may_index_admin_categories? }
+  end
+
+  navigation :admin_category do
+    section :show, :label => lambda { icon(:show, 'Overview') }, :url => lambda { object_path }
+    section :edit, :label => lambda { icon(:edit, 'Edit') }, :url => lambda { edit_object_path }
+  end
+
+  navigation :conference do
+    section :show, :label => lambda { icon(:show, 'Overview') }, :url => lambda { object_path }
+    section :edit, :label => lambda { icon(:edit, 'Edit') }, :url => lambda { edit_object_path }, :show => lambda { current_user.may_update_conference?(object) }
+  end
+
+  navigation :user do
+    section :show, :label => lambda { icon(:show, 'Overview') }, :url => lambda { object_path }
+    section :edit, :label => lambda { icon(:edit, 'Edit') }, :url => lambda { edit_object_path }, :show => lambda { current_user.may_update_user?(object) }
+  end
+
+end