formol 0.0.4

data/app/controllers/formol/admin/categories_controller.rb

@@ -0,0 +1,60 @@
+module Formol
+  class Admin::CategoriesController < Admin::AdminController
+    respond_to :html, :except => [:sort]
+    respond_to :js,   :only   => [:sort]
+    
+    def index
+      categories
+    end
+    
+    def new
+      category
+    end
+    
+    def create
+      if category.save
+        respond_with(category, :status => :created, :location => admin_categories_path)
+      else
+        respond_with(category, :status => :unprocessable_entity) do |format|
+          format.html { render :new }
+        end
+      end
+    end
+    
+    def edit
+      category
+    end
+    
+    def update
+      if category.update_attributes(params[:category])
+        respond_with(category, :location => admin_categories_path)
+      else
+        respond_with(category) do |format|
+          format.html { render :edit }
+        end
+      end
+    end
+    
+    def destroy
+      category.destroy
+      
+      respond_with(category, :location => admin_categories_path)
+    end
+    
+    def sort
+      Formol::Category.sort(params[:categories])
+      
+      render :nothing => true, :status => :ok
+    end
+    
+    protected
+    
+    def categories
+      @categories ||= Formol::Category.ready_for_listing.all
+    end
+    
+    def category
+      @category ||= (params[:id].present? ? Formol::Category.find(params[:id]) : Formol::Category.new(params[:category]))
+    end
+  end
+end

data/app/controllers/formol/admin/forums_controller.rb

@@ -0,0 +1,56 @@
+module Formol
+  class Admin::ForumsController < Admin::AdminController
+    include Controllers::Nested::HasParentCategory
+    
+    respond_to :html, :except => [:reorganize]
+    respond_to :js,   :only   => [:reorganize]
+    
+    def new
+      forum
+      
+      respond_with(forum)
+    end
+    
+    def create
+      if forum.save
+        respond_with(forum, :status => :created, :location => admin_categories_path)
+      else
+        respond_with(forum, :status => :unprocessable_entity) do |format|
+          format.html { render :new }
+        end
+      end
+    end
+    
+    def edit
+      forum
+    end
+    
+    def update
+      if forum.update_attributes(params[:forum])
+        respond_with(forum, :location => admin_categories_path)
+      else
+        respond_with(forum) do |format|
+          format.html { render :edit }
+        end
+      end
+    end
+    
+    def destroy
+      forum.destroy
+      
+      respond_with(forum, :location => admin_categories_path)
+    end
+    
+    def reorganize
+      Formol::Forum.reorganize(params[:forums], params[:category_id])
+      
+      render :nothing => true, :status => :ok
+    end
+    
+    protected
+    
+    def forum
+       @forum ||= (params[:id].present? ? category.forums.find(params[:id]) : category.forums.new(params[:forum]))
+    end
+  end
+end

data/app/controllers/formol/application_controller.rb

@@ -0,0 +1,47 @@
+module Formol
+  class ApplicationController < ::ApplicationController
+    def per_page
+      25
+    end
+    
+    helper_method :per_page
+    helper_method :current_formol_user
+    
+    def topic_post_page_number(topic, post)
+      #topic.posts.index is maybe not the most optimized
+      ((topic.posts(true).index(post) + 1).to_f / per_page.to_f).ceil
+    end
+    
+    def paginated_forum_topic_post_path(forum, topic, post)
+      opts = {
+        :anchor => "formol_post_#{post.id}"
+      }
+      
+      page = topic_post_page_number(topic, post)
+      
+      opts[:page] = page if page > 1
+      
+      forum_topic_path(forum, topic, opts)
+    end
+    
+    helper_method :paginated_forum_topic_post_path
+    
+    def topic_last_page_number(topic)
+      (topic.posts_count.to_f / per_page.to_f).ceil
+    end
+    
+    def last_page_forum_topic_path(forum, topic, post)
+      opts = {
+        :anchor => "formol_post_#{post.id}"
+      }
+      
+      page = topic_last_page_number(topic)
+      
+      opts[:page] = page if page > 1
+      
+      forum_topic_path(forum, topic, opts)
+    end
+    
+    helper_method :last_page_forum_topic_path
+  end
+end

data/app/controllers/formol/categories_controller.rb

@@ -0,0 +1,21 @@
+module Formol
+  class CategoriesController < ApplicationController
+    respond_to :html
+    
+    def index
+      formol_authorize!(current_formol_user, :read_category)
+      
+      @categories = Formol::Category.ready_for_listing
+      
+      respond_with(@categories)
+    end
+    
+    def show
+      formol_authorize!(current_formol_user, :read_category)
+      
+      @category = Formol::Category.find(params[:id])
+      
+      respond_with(@category)
+    end
+  end
+end

data/app/controllers/formol/forums_controller.rb

@@ -0,0 +1,19 @@
+module Formol
+  class ForumsController < ApplicationController
+    respond_to :html
+    
+    def show
+      formol_authorize!(current_formol_user, :read_forum)
+      
+      @topics = forum.topics.ready_for_listing.page(params[:page]).per_page(per_page)
+      
+      respond_with(forum)
+    end
+    
+    protected
+    
+    def forum
+      @forum ||= Formol::Forum.find(params[:id])
+    end
+  end
+end

data/app/controllers/formol/poll_votes_controller.rb

@@ -0,0 +1,23 @@
+module Formol
+  class PollVotesController < ApplicationController
+    include Controllers::Nested::HasParentTopic
+    
+    def create
+      formol_authorize!(current_formol_user, :vote_poll, topic)
+      
+      poll.vote(current_formol_user, params['poll']['poll_vote_ids'])
+    rescue Formol::Poll::PollException => e
+      flash[:error] = t(e.message)
+    ensure
+      respond_to do |format|
+        format.html { redirect_to [topic.forum, topic] }
+      end
+    end
+    
+    protected
+    
+    def poll
+      @poll ||= topic.poll
+    end
+  end
+end

data/app/controllers/formol/posts_controller.rb

@@ -0,0 +1,71 @@
+module Formol
+  class PostsController < ApplicationController
+    include Controllers::Nested::HasParentTopic
+    
+    respond_to :html
+    
+    def show
+      formol_authorize!(current_formol_user, :read_topic)
+      
+      post
+      
+      #respond_with location doesn't work here :/
+      respond_with(post) do |format|
+        format.html { redirect_to paginated_forum_topic_post_path(post.topic.forum, post.topic, post) }
+      end
+    end
+    
+    def new
+      formol_authorize!(current_formol_user, :create_post, topic)
+      
+      post(:quote_id => params[:quote], :user => current_formol_user)
+    end
+    
+    def create
+      formol_authorize!(current_formol_user, :create_post, topic)
+      
+      post(:user => current_formol_user)
+      
+      if post.save
+        #post.topic(true) needed to handle counter increment
+        respond_with(post, :status => :created, :location => last_page_forum_topic_path(topic.forum, post.topic(true), post))
+      else
+        respond_with(post, :status => :unprocessable_entity) do |format|
+          format.html { render :new }
+        end
+      end
+    end
+    
+    def edit
+      formol_authorize!(current_formol_user, :edit_post, post)
+      
+      post
+    end
+    
+    def update
+      formol_authorize!(current_formol_user, :edit_post, post)
+      
+      if post.update_attributes(params[:post])
+        respond_with(post, :location => paginated_forum_topic_post_path(topic.forum, topic, post))
+      else
+        respond_with(post) do |format|
+          format.html { render :edit }
+        end
+      end
+    end
+    
+    def destroy
+      formol_authorize!(current_formol_user, :destroy_post)
+      
+      post.destroy
+      
+      respond_with(post, :location => [topic.forum, topic])
+    end
+    
+    protected
+    
+    def post(attrs = {})
+      @post ||= (params[:id].present? ? topic.posts.find(params[:id]) : topic.posts.new(attrs.merge(params[:post] || {})))
+    end
+  end
+end

data/app/controllers/formol/preferences_controller.rb

@@ -0,0 +1,32 @@
+module Formol
+  class PreferencesController < ApplicationController
+    respond_to :html
+    
+    def show
+      preference
+      
+      respond_with(preference)
+    end
+    
+    def update
+      if preference.update_attributes(params[:user_preference])
+        respond_with(preference) do |format|
+          format.html { redirect_to preference_path }
+        end
+      # No wrong case to test for now
+      # just lower coverage
+      # 
+      #else
+      #  respond_with(preference) do |format|
+      #    format.html { render :show }
+      #  end
+      end
+    end
+    
+    protected
+    
+    def preference
+      @preference ||= current_formol_user.preference
+    end
+  end
+end

data/app/controllers/formol/subscriptions_controller.rb

@@ -0,0 +1,29 @@
+module Formol
+  class SubscriptionsController < ApplicationController
+    include Formol::Controllers::Nested::HasParentTopic
+    
+    def create
+      formol_authorize!(current_formol_user, :subscribe_topic)
+      
+      topic.register_subscriber(current_formol_user)
+      
+      respond_to do |format|
+        format.js { render :nothing => true, :status => :ok }
+      end
+    rescue ActiveRecord::RecordInvalid
+      respond_to do |format|
+        format.js { render :nothing => true, :status => :unprocessable_entity }
+      end
+    end
+    
+    def destroy
+      formol_authorize!(current_formol_user, :subscribe_topic)
+      
+      topic.unregister_subscriber(current_formol_user)
+      
+      respond_to do |format|
+        format.js { render :nothing => true, :status => :ok }
+      end
+    end
+  end
+end

data/app/controllers/formol/topics_controller.rb

@@ -0,0 +1,91 @@
+module Formol
+  class TopicsController < ApplicationController
+    include Controllers::Nested::HasParentForum
+    
+    respond_to :html
+    
+    def show
+      formol_authorize!(current_formol_user, :read_topic)
+      
+      topic.view!
+      topic.track_for_user!(current_formol_user)
+        
+      @posts = topic.posts.ready_for_listing.page(params[:page]).per_page(per_page)
+      
+      respond_with(topic)
+    end
+    
+    def new
+      formol_authorize!(current_formol_user, :create_topic)
+      
+      topic.posts.build(:register_user_as_subscriber => true)
+      
+      unless topic.poll
+        topic.build_poll
+        topic.poll.options.build
+      end
+      
+      respond_with(topic)
+    end
+  
+    def create
+      formol_authorize!(current_formol_user, :create_topic)
+      
+      topic.user = current_formol_user
+      
+      if topic.save
+        respond_with(topic, :location => [forum, topic])
+      else
+        unless topic.poll
+          topic.build_poll
+          topic.poll.options.build
+        end
+        
+        respond_with(topic, :status => :unprocessable_entity) do |format|
+          format.html { render :new }
+        end
+      end
+    end
+    
+    def edit
+      formol_authorize!(current_formol_user, :edit_topic, topic)
+      
+      respond_with(topic)
+    end
+    
+    def update
+      formol_authorize!(current_formol_user, :edit_topic, topic)
+      
+      if topic.update_attributes(params[:topic])
+        respond_with(topic, :location => [forum, topic])
+      else 
+        respond_with(topic) do |format|
+          format.html { render :edit }
+        end
+      end
+    end
+    
+    def destroy
+      formol_authorize!(current_formol_user, :destroy_topic)
+      
+      topic.destroy
+      
+      respond_with(topic, :location => forum)
+    end
+  
+    protected
+    
+    def topic
+      @topic ||= if params[:id].present?
+        if request.get?
+          forum.topics.ready_for_breadcrumb.includes(:poll => { :options => :votes }).find(params[:id])
+        else 
+          # never eager load anything for update (brokes validates on associations)
+          forum.topics.find(params[:id])
+        end
+      else
+        forum.topics.new(params[:topic])
+      end
+    end
+  end
+end

data/app/helpers/formol/admin/categories_helper.rb

@@ -0,0 +1,4 @@
+module Formol
+  module Admin::CategoriesHelper
+  end
+end

data/app/helpers/formol/admin/forums_helper.rb

@@ -0,0 +1,4 @@
+module Formol
+  module Admin::ForumsHelper
+  end
+end

data/app/helpers/formol/application_helper.rb

@@ -0,0 +1,35 @@
+module Formol
+  module ApplicationHelper
+    def breadcrumb_for(record)
+      items = [[t('home'), root_path]]
+      
+      klass = record.class.to_s
+      
+      case klass
+        when 'Formol::Category'
+          items << [record.label, category_path(record)]
+        when 'Formol::Forum'
+          items << [record.category.label, category_path(record.category)]
+          items << [record.label, forum_path(record)]
+        when 'Formol::Topic'
+          items << [record.forum.category.label, category_path(record.forum.category)]
+          items << [record.forum.label, forum_path(record.forum)]
+          items << [record.title, forum_topic_path(record.forum, record)]
+      end
+      
+      content_tag(:ul, :class => 'breadcrumb') do
+        items.each do |(text, path)|
+          concat(content_tag(:li, :class => 'item'){ link_to(text, path) })
+        end
+      end
+    end
+    
+    # When you want to link to last post, you don't need to calculate position
+    # of last post (wich need to load all topic's posts).
+    # Last post is obviously on last page, you can rely then on posts_count in 
+    # topic object
+    def link_to_last_post(forum, topic, post, text = nil)
+      link_to (text || '>'), last_page_forum_topic_path(forum, topic, post), :title => t('formol.posts.last_post.go_to_last')
+    end
+  end
+end

data/app/helpers/formol/categories_helper.rb

@@ -0,0 +1,15 @@
+module Formol
+  module CategoriesHelper
+    def formol_forum_klass(forum, user)
+      klasses = []
+      
+      if user.present?
+        klasses << (user.has_read_forum?(forum) ? 'read' : 'unread')
+      else
+        klasses << 'read'
+      end
+      
+      klasses.join(' ')
+    end
+  end
+end

data/app/helpers/formol/forums_helper.rb

@@ -0,0 +1,19 @@
+module Formol
+  module ForumsHelper
+    def formol_topic_klass(topic, user)
+      klasses = []
+      
+      klasses << 'pinned' if topic.pinned
+      klasses << 'locked' if topic.locked
+      
+      unless user.blank?
+        klasses << (user.has_read_topic?(topic) ? 'read' : 'unread')
+      else
+        klasses << 'read'
+      end
+      
+      
+      klasses.join(' ')
+    end
+  end
+end

data/app/helpers/formol/poll_votes_helper.rb

@@ -0,0 +1,4 @@
+module Formol
+  module PollVotesHelper
+  end
+end

data/app/helpers/formol/posts_helper.rb

@@ -0,0 +1,27 @@
+module Formol
+  module PostsHelper
+    def link_to_post_position(post, index)
+      idx = ((params[:page] || 1) - 1) * per_page + index + 1
+      
+      return link_to "##{idx}", "#formol_post_#{post.id}"
+    end
+    
+    def link_to_last_fives_post_position(post, topic, index)
+      idx = topic.posts_count - index
+      
+      return link_to "##{idx}", "#formol_post_#{post.id}"
+    end
+    
+    def display_avatars?(user)
+      return true unless user
+      
+      user.preference.display_avatars?
+    end
+    
+    def display_signatures?(user, post)
+      s = post.display_signature? && !post.user.preference.signature.blank?
+      
+      (s && user ? user.preference.display_signatures? : s)
+    end
+  end
+end

data/app/helpers/formol/preferences_helper.rb

@@ -0,0 +1,4 @@
+module Formol
+  module PreferencesHelper
+  end
+end

data/app/helpers/formol/subscriptions_helper.rb

@@ -0,0 +1,4 @@
+module Formol
+  module SubscriptionsHelper
+  end
+end

data/app/helpers/formol/topics_helper.rb

@@ -0,0 +1,27 @@
+module Formol
+  module TopicsHelper
+    include PostsHelper
+    
+    def link_to_subscription(topic, user)
+      subscriber = topic.subscriber?(user)
+      method = subscriber ? :delete : :post
+      text = t('formol.topics.show.' + (subscriber ? 'unsubscribe' : 'subscribe'))
+      switch_text = t('formol.topics.show.' + (subscriber ? 'subscribe' : 'unsubscribe'))
+      
+      link_to text, topic_subscriptions_path(topic),  :method => method, 
+                                                      :remote => true,
+                                                      :'data-switch-text' => switch_text
+    end
+    
+    def attach_poll_checkbox(topic)
+      %{<input type="checkbox" name="topic[attach_poll]" id="topic_attach_poll" value="1" #{'checked="checked"' if topic.attach_poll} />}.html_safe
+    end
+    
+    def display_poll_form?(poll, topic, user)
+      !poll.expired? && 
+      !topic.locked? && 
+      formol_authorized?(user, :vote_poll, topic) && 
+      !poll.voted?(user)
+    end
+  end
+end

data/app/mailers/formol/subscription_mailer.rb

@@ -0,0 +1,13 @@
+module Formol
+  class SubscriptionMailer < ActionMailer::Base
+    default :from => Formol.config.email_from
+    
+    def topic_reply(post, subscriber)
+      @post = post
+      
+      mail( :to       => subscriber.email, 
+            :subject  => "New reply: #{post.topic.title}", 
+            :layout   => 'formol/mail')
+    end
+  end
+end

data/app/models/formol/category.rb

@@ -0,0 +1,42 @@
+module Formol
+  class Category < ActiveRecord::Base
+    #Modules
+    include RankedModel
+    
+    #Associations
+    has_many  :forums,  :dependent  => :destroy,
+                        :order      => 'formol_forums.position'
+    
+    #Validations
+    validates :label, :presence   =>  true,
+                      :length     =>  { :in             => 3..32,
+                                        :allow_blank    => true },
+                      :uniqueness =>  { :case_sensitive => false,
+                                        :allow_blank    => true }
+                    
+    #Normalization
+    normalize_attributes  :label,  :with => [:squish, :blank]
+    
+    #Sorting
+    ranks :position
+    
+    #Scopes
+    class << self
+      # return categories conveniently ordered and eager-loaded for listing
+      def ready_for_listing
+        includes(:forums => { :last_post => [:user, :topic] }).rank(:position)
+      end
+    end
+    
+    #Business
+    class << self
+      # Sorts categories from an array of ids
+      def sort(category_ids)
+        #TODO: should maybe optimize this?
+        (category_ids || []).each_with_index do |category_id, index|
+          find(category_id).update_attribute(:position, index)
+        end
+      end
+    end
+  end
+end