formol 0.0.4

data/app/models/formol/forum.rb

@@ -0,0 +1,77 @@
+module Formol
+  class Forum < ActiveRecord::Base
+    #Modules
+    include RankedModel
+    include Tracking
+    
+    #Security
+    attr_protected :posts_count, :topics_count
+    
+    #Associations
+    belongs_to  :category
+    belongs_to  :last_post, :class_name => 'Formol::Post'
+    
+    has_many    :topics,    :dependent  => :destroy
+    has_many    :posts,     :through    => :topics
+                          
+    #Validations
+    validates :category,    :presence   => true
+    validates :label,       :presence   => true,
+                            :length     => {  :in             => 3..32,
+                                              :allow_blank    => true },
+                            :uniqueness => {  :scope          => :category_id,
+                                              :case_sensitive => false,
+                                              :allow_blank    => true }
+    validates :description, :length     => {  :maximum        => 128,
+                                              :allow_blank    => true }
+                        
+    #Normalization
+    normalize_attribute :label,       :with => [:squish, :blank]
+    normalize_attribute :description
+    
+    #Sorting
+    ranks :position, :with_same => :category_id
+    
+    #Scopes
+    class << self
+      # this scope eager loads conveniently topic for using it in breadcrumb
+      def ready_for_breadcrumb
+        includes(:category)
+      end
+      
+      # return all unread forums for a given user
+      def unread(user)
+        unread_scope_base(user)
+        .select('DISTINCT formol_forums.id')
+        .joins(:topics => :last_post)
+      end
+    end
+    
+    #Business
+    class << self
+      # Sorts topics from an array of ids and sets the new category
+      def reorganize(forum_ids, category_id = nil)
+        category = Formol::Category.find(category_id) if category_id
+        
+        #TODO: should maybe optimize this?
+        (forum_ids || []).each_with_index do |forum_id, index|
+          attr = { :position => index }
+          attr[:category] = category if category_id
+          
+          find(forum_id).update_attributes(attr)
+        end
+      end
+    end
+    
+    # Register a post being the last one of the current forum
+    def register_last_post(post)
+      update_attribute(:last_post, post)
+    end
+    
+    # Unregister a post by re-assigning last post.
+    # Needed when a post is destroyed
+    def unregister_last_post
+      update_attributes!(:last_post => posts.order('formol_posts.id').last)
+    end
+  end
+end

data/app/models/formol/poll/option.rb

@@ -0,0 +1,20 @@
+module Formol
+  class Poll::Option < ActiveRecord::Base
+    #Security
+    attr_protected  :poll_id
+    
+    #Associations
+    belongs_to :poll
+    
+    has_many :votes
+    
+    #Validations
+    validates :poll,    :presence => true
+    validates :answer,  :presence => true,
+                        :length   => {  :maximum      => 32,
+                                        :allow_blank  => true }
+                                      
+    #Normalization
+    normalize_attribute :answer,  :with => [:squish, :blank]
+  end
+end

data/app/models/formol/poll/vote.rb

@@ -0,0 +1,32 @@
+module Formol
+  class Poll::Vote < ActiveRecord::Base
+    #Security
+    attr_protected :voter_id, :option_id
+    
+    #Associations
+    belongs_to :option, :counter_cache  => true
+    belongs_to :voter,  :class_name     => Formol.config.user_class
+    
+    has_one :poll, :through => :option
+    
+    #Validations
+    validates :option,  :presence => true
+    validates :voter,   :presence => true
+    
+    #Callbacks
+    after_create  :increment_poll_votes_count
+    after_destroy :decrement_poll_votes_count
+    
+    private
+    
+    #Callbacks methods
+    
+    def increment_poll_votes_count
+      Formol::Poll.increment_counter(:votes_count, poll.id)
+    end
+    
+    def decrement_poll_votes_count
+      Formol::Poll.decrement_counter(:votes_count, poll.id)
+    end
+  end
+end

data/app/models/formol/poll.rb

@@ -0,0 +1,107 @@
+module Formol
+  class Poll < ActiveRecord::Base
+    #Exceptions
+    class PollException < Exception; end
+    class TooManyVotesError < PollException; end
+    class UserAlreadyVoter < PollException; end
+    class NoOptionProvided < PollException; end
+    class TopicLockedError < PollException; end
+    class PollExpiredError < PollException; end
+    
+    #Security
+    attr_protected  :topic_id
+    attr_readonly   :topic_id
+    
+    #Virtual attributes
+    attr_accessor :poll_vote_ids #to not conflict with has_many :votes
+    
+    #Default values
+    default_value_for :duration,    1.week.to_i
+    default_value_for :max_options, 1 #default to single mode
+    
+    #Associations
+    belongs_to  :topic
+    
+    has_many  :options
+    has_many  :votes,   :through    => :options
+    has_many  :voters,  :through    => :votes,
+                        :class_name => Formol.config.user_class,
+                        :uniq       => true
+
+    #Nested attributes
+    accepts_nested_attributes_for :options, :limit => 20
+                      
+    #Validations
+    validates :topic,       :presence     => true
+    validates :question,    :presence     => true,
+                            :length       => {  :in                     => 5..64,
+                                                :allow_blank            => true }
+    validates :duration,    :presence     => true,
+                            :numericality => {  :only_integer           => true,
+                                                :greater_than           => 0,
+                                                :less_than              => 3.months.to_i,
+                                                :allow_blank            => true }
+    validates :max_options, :presence     => true,
+                            :numericality => {  :only_integer           => true,
+                                                :greater_than           => 0,
+                                                :less_than_or_equal_to  => Proc.new{ |p| p.options.length },
+                                                :allow_blank            => true }
+    validates :options,     :length       => { :in                      => 1..20 }
+    
+    #Normalization
+    normalize_attribute :question,  :with => [:squish, :blank]
+    
+    #Callbacks
+    before_validation :setup_options_assoc, :on => :create
+    
+    #Business methods
+    
+    def multiple?
+      max_options > 1
+    end
+    
+    def single?
+      !multiple?
+    end
+    
+    def expired?
+      expires_at < Time.now
+    end
+    
+    def expires_at
+      created_at + duration.to_i
+    end
+    
+    def voted?(user)
+      voters.include?(user)
+    end
+    
+    def vote(user, option_ids)
+      option_ids = [option_ids] unless option_ids.respond_to?(:each)
+      option_ids.reject!(&:blank?)
+      option_ids.compact!
+      
+      raise NoOptionProvided.new if option_ids.empty?
+      raise TooManyVotesError.new if option_ids.length > max_options
+      raise UserAlreadyVoter.new if voted?(user)
+      raise TopicLockedError.new if topic.locked?
+      raise PollExpiredError.new if expired?
+      
+      options.find(option_ids).to_a.each do |option| #?
+        option.votes.create!(:voter => user)
+      end
+    end
+    
+    private
+    
+    #Callback methods
+    
+    # set poll for each options
+    # AR doesn't do it by itself and it ruins validations
+    def setup_options_assoc
+      options.each do |o|
+        o.poll = self
+      end
+    end
+  end
+end

data/app/models/formol/post.rb

@@ -0,0 +1,162 @@
+module Formol
+  class Post < ActiveRecord::Base
+    #Security
+    attr_protected :topic_id, :user_id, :created_by_topic
+    
+    #Virtual attributes
+    attr_accessor :created_by_topic, :quote_id, :register_user_as_subscriber
+    
+    #Default values
+    default_value_for :created_by_topic, false
+    default_value_for :display_signature do |p|
+      p.user ? p.user.preference.use_signature : true
+    end
+    
+    #Associations
+    belongs_to  :topic, :touch          => true,
+                        :counter_cache  => true
+    belongs_to  :user,  :class_name     => Formol.config.user_class,
+                        :counter_cache  => :formol_posts_count
+    
+    has_one     :forum, :through        => :topic
+    
+    #Validations
+    validates :topic,   :presence => true
+    validates :user,    :presence => true
+    #Length is set with a minimum of 2 to allow posts with simple "ok" answer
+    #Length is set with a maximum of 50 000 because 50Kb is enough for a non
+    #binary forum
+    validates :content, :presence => true,
+                        :length   => {  :in           => 2..50_000,
+                                        :allow_blank  => true }
+                                      
+    validate  :validates_topic_not_locked
+    
+    #Normalization
+    normalize_attribute :content, :with => [:strip, :blank]
+    
+    #Callbacks
+    after_initialize  :feed_content_with_quote
+    
+    after_save        :register_author_as_subscriber
+    after_create      :increment_forum_counter_cache,
+                      :register_as_last_post_on_topic,
+                      :register_as_last_post_on_forum
+    after_destroy     :decrement_forum_counter_cache,
+                      :unregister_as_last_post_on_topic,
+                      :unregister_as_last_post_on_forum
+    
+    #Scopes
+    class << self
+      # scope for ordering posts conveniently for listing views
+      # order by id (no order is random with mysql)
+      def ordered_for_listing
+        order('formol_posts.id ASC')
+      end
+      
+      # scope to get posts conveniently prepared for listing
+      def ready_for_listing
+        ordered_for_listing.includes(:topic, { :user => :preference })
+      end
+      
+      # scope to get last five posts with reverse ordering
+      # usefull to have a little history when replying to a topic
+      def last_fives
+        order('formol_posts.id DESC').limit(5).includes(:user)
+      end
+    end
+    
+    #Business methods
+    
+    # Read accessor for 'register_user_as_subscriber'
+    def register_user_as_subscriber(force_recompute = false)
+      if @register_user_as_subscriber.nil? || force_recompute
+        @register_user_as_subscriber = compute_register_subscribing
+      end
+      
+      @register_user_as_subscriber
+    end
+    
+    private
+    
+    # Convert 'register_user_as_subscriber' to boolean
+    def register_user_as_subscriber?
+      [true, '1', 'true'].include?(register_user_as_subscriber)
+    end
+    
+    #Callback methods
+    
+    # Registers author as subscriber if he's not already
+    def register_author_as_subscriber
+      if register_user_as_subscriber? 
+        topic.register_subscriber(user) unless topic.subscriber?(user)
+      else
+        topic.unregister_subscriber(user) if topic.subscriber?(user)
+      end
+    end
+    
+    # Validates topic is not locked
+    # If topic is locked, it will add an error on base (not on topic)
+    # This validation does not trigger on first post
+    def validates_topic_not_locked
+      errors.add(:base, :topic_locked) if topic.locked? && !created_by_topic
+    end
+    
+    # Holds counter cache on Forum till AR does not support it on has_one
+    def increment_forum_counter_cache
+      Formol::Forum.increment_counter(:posts_count, forum.id) if forum.present?
+    end
+    
+    # Holds counter cache on Forum till AR does not support it on has_one
+    def decrement_forum_counter_cache
+      Formol::Forum.decrement_counter(:posts_count, forum.id) if forum.present?
+    end
+    
+    # Feed content with quote's content
+    # If you're trying to pass quote_id in a POST, your content will be wiped
+    # Too bad!
+    def feed_content_with_quote
+      return true if quote_id.blank?
+      
+      q = topic.posts.find(quote_id)
+      formatter = Formol.config.formatter.new
+
+      # Extract and agnostize it
+      content_with_quote = "> **#{q.user.display_name} #{I18n.t('.wrote')}:**\n>\n"
+      content_with_quote << formatter.quote(q.content)
+      
+      self.content = content_with_quote
+      self.content << "\n\n" #use '<<' to skip normalize_attribute
+      self.content
+    end
+    
+    # Register current post being the last of its topic
+    def register_as_last_post_on_topic
+      topic.register_last_post(self)
+    end
+    
+    # Unregister current post being the last of its topic
+    def unregister_as_last_post_on_topic
+      topic.unregister_last_post if topic.last_post == self
+    end
+    
+    # Register current post being the last post of its forum
+    def register_as_last_post_on_forum
+      forum.register_last_post(self)
+    end
+    
+    # Unregister current post being the last of its forum
+    def unregister_as_last_post_on_forum
+      forum.unregister_last_post if forum.last_post == self
+    end
+    
+    # Computes 'register_user_as_subscriber
+    def compute_register_subscribing
+      if topic && user
+        topic.subscriber?(user)
+      else
+        false
+      end
+    end
+  end
+end

data/app/models/formol/post_observer.rb

@@ -0,0 +1,9 @@
+module Formol
+  class PostObserver < ActiveRecord::Observer
+    def after_create(post)
+      post.topic.subscribers.each do |subscriber|
+        SubscriptionMailer.topic_reply(post, subscriber).deliver
+      end
+    end
+  end
+end

data/app/models/formol/topic/subscription.rb

@@ -0,0 +1,16 @@
+module Formol
+  class Topic::Subscription < ActiveRecord::Base
+    #Security
+    attr_protected :subscriber_id, :topic_id
+    
+    #Associations
+    belongs_to  :subscriber,  :class_name => Formol.config.user_class
+    belongs_to  :topic
+    
+    #Validations
+    validates :subscriber,      :presence   => true
+    validates :topic,           :presence   => true
+    validates :subscriber_id,   :uniqueness => {  :scope        => :topic_id,
+                                                  :allow_blank  => true }
+  end
+end

data/app/models/formol/topic/track.rb

@@ -0,0 +1,57 @@
+module Formol
+  class Topic::Track < ActiveRecord::Base
+    #Security
+    attr_protected  :user_id, :topic_id, :forum_id, :marked_at
+    attr_readonly   :user_id, :topic_id, :forum_id
+    
+    #Association
+    belongs_to :user,   :class_name => Formol.config.user_class
+    belongs_to :topic
+    belongs_to :forum
+
+    #Validations
+    validates :user_id,   :presence => true
+    validates :topic_id,  :presence => true
+    validates :forum_id,  :presence => true
+    validates :marked_at, :presence => true
+    
+    #Callbacks
+    before_validation :assign_forum,    :on => :create
+    before_validation :touch_marked_at
+    
+    #Business methods
+    
+    class << self
+      # mark a given topic for a given user
+      # if track already exists, it will be updated otherwhise it will be created
+      # handle nil user if forum is browsed without being connected
+      def mark_topic_for_user(topic, user)
+        return nil if user.nil?
+        
+        track = find_or_initialize_by_topic_id_and_user_id(topic.id, user.id)
+        track.mark
+        
+        track
+      end
+    end
+    
+    def mark
+      save
+    end
+    
+    private
+    
+    #Callback methods
+    
+    # assigns forum from topic
+    # convenient to know if a forum is read or not
+    def assign_forum
+      self.forum = topic.forum if topic
+    end
+    
+    # assigns current time to marked_at
+    def touch_marked_at
+      self.marked_at = Time.now
+    end
+  end
+end

data/app/models/formol/topic.rb

@@ -0,0 +1,185 @@
+module Formol
+  class Topic < ActiveRecord::Base
+    #Modules
+    include Tracking
+    
+    #Security
+    attr_protected  :forum_id, :user_id, :first_post_id, :last_post_id, 
+                    :posts_count, :views_count
+                  
+    #Virtual attributes
+    attr_accessor :attach_poll
+    
+    #Default values
+    default_value_for :attach_poll, false
+
+    #Associations
+    belongs_to  :forum,         :counter_cache  => true
+    belongs_to  :user,          :class_name     => Formol.config.user_class
+    belongs_to  :first_post,    :class_name     => 'Formol::Post'
+    belongs_to  :last_post,     :class_name     => 'Formol::Post'
+    
+    has_many    :posts,         :dependent      => :destroy
+    has_many    :subscriptions, :dependent      => :destroy
+    has_many    :subscribers,   :through        => :subscriptions
+    
+    has_one     :poll
+    
+    #Nested attributes
+    accepts_nested_attributes_for :posts, :limit => 1
+    accepts_nested_attributes_for :poll
+    
+    #Validations
+    validates :title,       :presence   => true,
+                            :length     => {  :in           => 3..48,
+                                              :allow_blank  => true }
+    validates :forum,       :presence   => true
+    validates :user,        :presence   => true
+    validates :posts,       :presence   => true
+    validates :first_post,  :presence   => true
+    
+    #Normalization
+    normalize_attribute :title, :with => [:squish, :blank]
+    
+    #Callbacks
+    before_validation :setup_first_post_assoc,  :on => :create
+    before_validation :setup_poll_assoc,        :on => :create
+    before_validation :reject_poll_if_needed
+    
+    #Scopes
+    class << self
+      # scope for ordering topics conveniently for listing views
+      # order by updated_at and id
+      # id is used as discard if two topics have been updated at the same second
+      def ordered_for_listing
+        order('formol_topics.pinned DESC').
+        order('formol_topics.updated_at DESC').
+        order('formol_topics.id DESC')
+      end
+      
+      # scope to get topics conveniently prepared for listing
+      def ready_for_listing
+        ordered_for_listing.includes(:user, { :last_post => :user }, :posts)
+      end
+      
+      # this scope eager loads conveniently topic for using it in breadcrumb
+      def ready_for_breadcrumb
+        includes(:forum => :category)
+      end
+      
+      # return all unread topics for a given forum and a given user
+      # A topic is unread if it's
+      # * tracked for given user and marked_at is after last post's created_at
+      # * not tracked and created after user registered
+      def unread(user, opts = {})
+        unread_scope_base(user, opts)
+        .select('formol_topics.id')
+        .joins(:last_post)
+      end
+    end
+    
+    #Business methods
+    
+    # Increments views counter
+    def view!
+      # Use class method instead of instance to avoid concurrence problems
+      self.class.increment_counter(:views_count, id)
+    end
+    
+    # Track current topic for a given user
+    def track_for_user!(user)
+      Track.mark_topic_for_user(self, user)
+    end
+    
+    # Return if one post is the first post or not
+    # Should be in Formol::Post class but while :inverse_of does not work
+    # on has_many, optimization is easier in this sense
+    def first_post?(post)
+      post == first_post
+    end
+    
+    # Register a post being the last one of the current topic
+    def register_last_post(post)
+      update_attribute(:last_post, post)
+    end
+
+    # Unregister a post by re-assigning last post.
+    # Needed when a post is destroyed
+    def unregister_last_post
+      update_attribute(:last_post, posts(true).last)
+    end
+    
+    # Register a subscriber to the current topic
+    def register_subscriber(subscriber)
+      subscriptions.create!(:subscriber => subscriber, :topic => self)
+    end
+    
+    # Remove a user from subscribers
+    def unregister_subscriber(subscriber)
+      #subscriptions.where(:subscriber_id => subscriber.id).try(:destroy)
+      subscribers.destroy(subscriber)
+    end
+    
+    # Tells if a user has subscribed (or not) to the current topic
+    def subscriber?(user)
+      subscriptions.where(:subscriber_id => user.id).exists?
+    end
+    
+    private
+    
+    #Callback methods
+    
+    # Setup poll association
+    def setup_poll_assoc
+      poll.topic = self if poll
+    end
+    
+    # Setup first post's associations
+    def setup_first_post_assoc
+      #register first post
+      self.first_post = posts.first
+      
+      set_first_post_topic
+      set_first_post_user
+      set_first_post_created_by_topic
+    end
+    
+    # Set the first post's user
+    # It's just the same as topics
+    def set_first_post_user
+      # done with 'each' and not 'first' to avoid empty association
+      posts.each do |p|
+        p.user = self.user
+      end
+    end
+    
+    # Set the first post's topic
+    # If not, nested attributes triggers presence validation of topic in 
+    # post model and this last fails
+    def set_first_post_topic
+      # done with 'each' and not 'first' to avoid empty association
+      # if association is empty or contains more than 1 post, 
+      # validations handle it, not this method
+      posts.each do |p|
+        p.topic = self
+      end
+    end
+    
+    # Inform first post's topic it's the first one
+    # Needed to not perform 'locked' validation
+    def set_first_post_created_by_topic
+      # done with 'each' and not 'first' to avoid empty association
+      # if association is empty or contains more than 1 post, 
+      # validations handle it, not this method
+      posts.each do |p|
+        p.created_by_topic = true
+      end
+    end
+    
+    # Reject poll if attach_poll is false
+    # Needed because poll's default values perform validations
+    def reject_poll_if_needed
+      self.poll = nil if poll && !attach_poll
+    end
+  end
+end