atreides 2.0.0

data/app/controllers/atreides/application_controller.rb

@@ -0,0 +1,93 @@
+class Atreides::ApplicationController < ApplicationController
+  helper 'atreides/application'
+
+  before_filter :current_site
+  before_filter :current_lang
+
+  private
+
+  def current_site
+    # Use subdomain as key for site
+    @current_site ||= Atreides::Site.find_by_name(request.subdomains.last) || Atreides::Site.default
+    session[:site_name] = @current_site.name
+    @current_site
+  end
+
+  def current_lang
+    @current_lang = I18n.locale = current_site.lang if I18n.available_locales.include?(current_site.lang)
+  end
+
+  def end_of_association_chain
+    assoc_name = params[:controller].split('/').last.strip.to_sym
+    if current_site.respond_to?(assoc_name)
+      current_site.send(assoc_name)
+    else
+      model_name.constantize
+    end
+  end
+
+  def store_location
+    session[:return_to] = request.fullpath
+  end
+
+  def redirect_back_or_default(default)
+    redirect_to(session[:return_to] || default)
+    session[:return_to] = nil
+  end
+
+  def cache_key
+    "#{request.url}/#{request.format.to_sym.to_s}/#{etag}/#{flash.to_s.gsub(/\W/,'')}"
+  end
+
+  def set_expires
+    expires_in 30.seconds, :private => false, :public => true
+  end
+
+  def set_fresh_when
+    if ActionController::Base.perform_caching and collection?
+      return !stale?(:etag => etag, :last_modified => last_modified, :public => true)
+    end
+  end
+
+  def etag
+    last_modified.to_i
+  end
+
+  LAST_MODIFIED_CACHE_KEY = 'site_last_modified'
+
+  def last_modified
+    # Update the cache last-modified date
+    set_last_modified(true) unless @last_modified ||= Rails.cache.read(LAST_MODIFIED_CACHE_KEY)
+    @last_modified
+  end
+
+  def set_last_modified(force = false)
+    # Don't update it unless forced to or the if the request is just a GET
+    @last_modified = Time.now.utc
+    Rails.cache.write(LAST_MODIFIED_CACHE_KEY, @last_modified) if force or !request.get?
+  end
+
+  def resource?
+    respond_to?(:resource, true) and !resource.nil?
+  end
+
+  def collection?
+    respond_to?(:collection, true) and !collection.nil? and !collection.empty?
+  end
+
+  def current_ability
+    @current_ability ||= Atreides::Ability.new(current_user)
+  end
+
+  def atreides_setup?
+    Atreides::User.admins.count > 0
+  end
+
+  def check_user_agent
+    if request.user_agent =~ /(facebookexternalhit|curl)/i
+      request.path_parameters.each do |k,v|
+        params[k.to_sym] = v
+      end
+    end
+  end
+end

data/app/controllers/atreides/comments_controller.rb

@@ -0,0 +1,43 @@
+class Atreides::CommentsController < Atreides::PublicController
+  helper "Atreides::Posts"
+  before_filter :require_user, :only => [:create, :update]
+
+  def index
+    super do |wants|
+      wants.html { head :not_found }
+      wants.json { render :json => collection.to_json }
+      wants.xml { render :xml => collection.to_xml }
+    end
+  end
+
+  def create
+    build_resource.request = request
+    super do |success, failure|
+      success.html { head :ok, :location => post_path(parent) }
+      success.js
+      failure.wants.html { head :error, :message => resource.errors.full_messages.to_sentence }
+      failure.wants.js
+    end
+  end
+
+  private
+
+  def resource
+    @comment ||= parent.comments.find params[:id]
+  end
+
+  def build_resource
+    @comment ||= Comment.new params[:comment].update(:user => current_user, :commentable => parent)
+  end
+
+  def collection
+    @comments ||= parent.comments.approved.paginate :page => params[:page]
+  end
+
+  def parent
+    @parent ||= Atreides::Post.find_by_slug!(params[:post_id]) ||
+                Atreides::Post.find(params[:post_id])
+  end
+
+  include Atreides::Extendable
+end

data/app/controllers/atreides/home_controller.rb

@@ -0,0 +1,71 @@
+class Atreides::HomeController < Atreides::PublicController
+
+  helper 'atreides/posts'
+
+  caches_page :robots
+  before_filter :collection, :only => [:index, :sitemap, :feeds]
+
+  def search
+  end
+
+  def feeds
+    respond_to do |wants|
+      wants.rss {
+        render :template => "atreides/posts/index"
+      }
+      wants.atom {
+        render :template => "atreides/posts/index"
+      }
+    end
+  end
+
+  def sitemap
+    @posts = collection
+    @countdowns = live_posts.tagged_with('countdown').limit(500)
+    @pages = Atreides::Page.published.limit(500)
+    respond_to do |wants|
+      wants.xml
+    end
+  end
+
+  def robots
+    respond_to do |wants|
+      wants.txt
+    end
+  end
+
+  def error
+    respond_to do |wants|
+      wants.html {
+        render "atreides/errors/500"
+      }
+    end
+  end
+
+  def not_found
+    respond_to do |wants|
+      wants.html {
+        render "atreides/errors/404"
+      }
+    end
+  end
+
+  private
+
+  def collection
+    @collection ||= case action_name
+      when 'sitemap'
+        live_posts.limit(500).order("updated_at desc")
+      when 'index', 'feeds'
+        live_posts.paginate :page => params[:page]
+      else
+        []
+      end
+  end
+
+  def live_posts
+    Atreides::Post.live
+  end
+
+  include Atreides::Extendable
+end

data/app/controllers/atreides/likes_controller.rb

@@ -0,0 +1,44 @@
+class Atreides::LikesController < Atreides::PublicController
+  belongs_to :page, :post
+
+  helper "Atreides::Posts"
+  before_filter :require_user, :only => [:create]
+
+  def index
+    super do |wants|
+      wants.html { head :not_found }
+      wants.json { render :json => collection.to_json }
+      wants.xml  { render :xml => collection.to_xml }
+    end
+  end
+
+  def create
+    super do |success, failure|
+      success.html { head :ok, :location => post_path(parent) }
+      success.js
+      failure.wants.html { head :error, :message => "You already liked this" }
+      failure.wants.js
+    end
+  end
+
+  private
+
+  def resource
+    @like ||= parent.likes.find params[:id]
+  end
+
+  def build_resource
+    @like ||= Like.new :user => current_user, :likeable => parent
+  end
+
+  def collection
+    @likes ||= parent.likes.paginate :page => params[:page]
+  end
+
+  def parent
+    @parent ||= Atreides::Post.find_by_slug(params[:post_id]) ||
+                Atreides::Post.find(params[:post_id])
+  end
+
+  include Atreides::Extendable
+end

data/app/controllers/atreides/pages_controller.rb

@@ -0,0 +1,34 @@
+class Atreides::PagesController < Atreides::PublicController
+
+  def show
+    track_resource_analytics
+    @page_title = resource.title
+    super
+  end
+
+  def preview
+    @page = end_of_association_chain.new(params[:page])
+    @page.id ||= 0
+    @page.published_at = 1.minute.ago
+    @page.slug = 'preview' unless @page.slug?
+    @body_classes = "page-show" # So that CSS will think it's the details page
+    respond_to do |wants|
+      wants.html {
+        render :template => "atreides/pages/show"
+      }
+    end
+  end
+
+  private
+
+  def end_of_association_chain
+    current_site.pages.live
+  end
+
+  def resource
+    @page ||= end_of_association_chain.find_by_slug(params[:page_slug]) ||
+              end_of_association_chain.find_by_slug(params[:id])
+  end
+
+  include Atreides::Extendable
+end

data/app/controllers/atreides/posts_controller.rb

@@ -0,0 +1,119 @@
+class Atreides::PostsController < Atreides::PublicController
+
+  before_filter :date, :only => [:index]
+  before_filter :resource, :only => [:gallery_params, :show, :next, :previous]
+  before_filter :featured_pics, :only => [:show]
+  before_filter :collection, :only => [:index, :tagged, :archives]
+
+  def index
+    super do |wants|
+      wants.atom
+      wants.rss
+    end
+  end
+
+  def show
+    @page_title = resource.title rescue nil
+    track_resource_analytics
+
+    super do |wants|
+      wants.xml   { render "atreides/common/slideshow" }
+    end
+  end
+
+  def preview
+    @post = end_of_association_chain.new(params[:post])
+    @post.id ||= 0
+    @post.published_at = 1.minute.ago
+    @post.slug = 'preview' unless @post.slug?
+    @body_classes = "posts-show" # So that CSS will think it's the details page
+    respond_to do |wants|
+      wants.html { render :template => "atreides/posts/show" }
+    end
+  end
+
+  def archives
+    @page_title = 'Archives'
+    respond_to do |wants|
+      wants.html { render "atreides/posts/archives" }
+      wants.js   { render "atreides/posts/archives" }
+    end
+  end
+
+  def tagged
+    @page_title = "Posts tagged #{params[:tag]}"
+    respond_to do |wants|
+      wants.html { render "atreides/posts/tagged" }
+      wants.js
+    end
+  end
+
+  def next
+    post = resource.next || resource
+    redirect_to post_path(post, post.slug)
+  end
+
+  def previous
+    post = resource.previous || resource
+    redirect_to post_path(post, post.slug)
+  end
+
+  private
+
+  def featured_pics
+    @featured_pics ||= current_site.features.live.tagged_with('sidebar')
+  end
+
+  def begin_of_association_chain
+    current_site
+  end
+
+  def end_of_association_chain
+    current_site.posts.live
+  end
+
+  def resource
+    @post ||= end_of_association_chain.find_by_id(params[:id])        ||
+              end_of_association_chain.find_by_slug(params[:slug])    || # Needed to keep permalinks alive
+              end_of_association_chain.find_by_slug(params[:id])      || # Needed to keep permalinks alive
+              end_of_association_chain.find_by_tumblr_id(params[:id]) # Needed to keep permalinks alive
+  end
+
+  def collection
+    @posts ||= case self.action_name
+    when 'index'
+      if !params[:search].blank?
+        # Normal post listing
+        @query = params[:search]
+        q = "%#{@query}%".downcase
+        end_of_association_chain.joins(:parts).where("lower(title) like ? OR lower(content_parts.body) like ?", q, q).paginate(:page => params[:page])
+      else
+        # Normal post listing
+        end_of_association_chain.paginate(:page => params[:page])
+      end
+
+    when 'tagged'
+      end_of_association_chain.tagged_with(params[:tag]).select("DISTINCT posts.id, posts.*").paginate(:page => params[:page])
+    when 'archives'
+      col = :published_at
+      conditions = if params[:month] and params[:year]
+        @date = Date.parse("#{params[:year]}-#{params[:month]}-1")
+        ["EXTRACT(MONTH from #{col}) = ? and EXTRACT(YEAR from #{col}) = ?", @date.month, @date.year]
+      else
+        []
+      end
+      end_of_association_chain.paginate(
+        :page => params[:page],
+        :conditions => conditions,
+        :order => "#{col} desc, created_at desc")
+    else
+      []
+    end
+  end
+
+  def date
+    @date ||= "1-#{params[:month]}-#{params[:year] || Date.today.year}".to_date rescue Date.today
+  end
+
+  include Atreides::Extendable
+end

data/app/controllers/atreides/public_controller.rb

@@ -0,0 +1,43 @@
+class Atreides::PublicController < Atreides::ApplicationController
+
+  unloadable
+  inherit_resources
+
+  analytical :modules => Settings.analytics_backends, :use_session_store => true
+
+  # caches_page # for making static sites
+  # around_filter :cache
+
+  # Set HTTP caching headers
+  before_filter :set_expires
+  before_filter :set_fresh_when
+  before_filter :check_user_agent
+
+  layout 'public'
+
+  if Rails.env.production? # || Rails.env.staging?
+    rescue_from 'Exception' do |exception|
+
+      Rails.logger.info "Exception: #{exception}"
+      Rails.logger.info exception.backtrace.join("\n")
+
+      case exception.class.to_s
+      when ActiveRecord::RecordNotFound.to_s
+        render :template => 'atreides/errors/404', :layout => 'public', :status => 404
+      else
+        render :template => 'atreides/errors/500', :layout => 'public', :status => 500
+      end
+    end
+  end
+
+  protected
+
+  def track_resource_analytics
+    resource.tag_list.each { |tag|
+      analytical.custom_event 'Tag', 'view', tag
+    } if resource.respond_to?(:tag_list)
+
+    analytical.custom_event 'Author', 'view', resource.author.email if resource.respond_to?(:author) && resource.author
+  end
+
+end