trusty-cms 1.0.0

data/app/controllers/admin/pages_controller.rb

@@ -0,0 +1,89 @@
+class Admin::PagesController < Admin::ResourceController
+  before_filter :initialize_meta_rows_and_buttons, :only => [:new, :edit, :create, :update]
+  before_filter :count_deleted_pages, :only => [:destroy]
+  
+  class PreviewStop < ActiveRecord::Rollback
+    def message
+      'Changes not saved!'
+    end
+  end
+
+  responses do |r|
+    r.plural.js do
+      @level = params[:level].to_i
+      @template_name = 'index'
+      self.models = Page.find(params[:page_id]).children.all
+      response.headers['Content-Type'] = 'text/html;charset=utf-8'
+      render :action => 'children.html.haml', :layout => false
+    end
+  end
+
+  def index
+    @homepage = Page.find_by_parent_id(nil)
+    response_for :plural
+  end
+
+  def new
+    @page = self.model = model_class.new_with_defaults(trusty_config)
+    assign_page_attributes
+    response_for :new
+  end
+  
+  def preview
+    render_preview
+  rescue PreviewStop => exception
+    render :text => exception.message unless @performed_render
+  end
+
+  private
+    def assign_page_attributes
+      if params[:page_id].blank?
+        self.model.slug = '/'
+      end
+      self.model.parent_id = params[:page_id]
+    end
+
+    def model_class
+      if Page.descendants.any? { |d| d.to_s == params[:page_class] }
+        params[:page_class].constantize
+      elsif params[:page_id]
+        Page.find(params[:page_id]).children
+      else
+        Page
+      end
+    end
+      
+    def render_preview
+      Page.transaction do
+        page_class = Page.descendants.include?(model_class) ? model_class : Page
+        if request.referer =~ %r{/admin/pages/(\d+)/edit}
+          page = Page.find($1).becomes(page_class)
+          page.update_attributes(params[:page])
+          page.published_at ||= Time.now
+        else
+          page = page_class.new(params[:page])
+          page.published_at = page.updated_at = page.created_at = Time.now
+          page.parent = Page.find($1) if request.referer =~ %r{/admin/pages/(\d+)/children/new}
+        end
+        page.pagination_parameters = pagination_parameters
+        process_with_exception(page)
+      end
+    end
+    
+    def process_with_exception(page)
+      page.process(request, response)
+      @performed_render = true
+      raise PreviewStop
+    end
+
+    def count_deleted_pages
+      @count = model.children.count + 1
+    end
+
+    def initialize_meta_rows_and_buttons
+      @buttons_partials ||= []
+      @meta ||= []
+      @meta << {:field => "slug", :type => "text_field", :args => [{:class => 'textbox', :maxlength => 100}]}
+      @meta << {:field => "breadcrumb", :type => "text_field", :args => [{:class => 'textbox', :maxlength => 160}]}
+    end
+end

data/app/controllers/admin/preferences_controller.rb

@@ -0,0 +1,46 @@
+class Admin::PreferencesController < ApplicationController
+  before_filter :load_user
+
+  def initialize
+    @controller_name = 'user'
+    @template_name = 'preferences'
+  end
+
+  def show
+    set_standard_body_style
+    render :edit
+  end
+
+  def edit
+    render
+  end
+
+  def update
+    if valid_params?
+      if @user.update_attributes(params[:user])
+        redirect_to admin_configuration_path
+      else
+        flash[:error] = t('preferences_controller.error_updating')
+        render :edit
+      end
+    else
+      announce_bad_data
+      render :edit
+    end
+  end
+
+  private
+
+  def load_user
+    @user = current_user
+  end
+
+  def valid_params?
+    hash = (params[:user] || {}).symbolize_keys
+    (hash.keys - User.unprotected_attributes).size == 0
+  end
+
+  def announce_bad_data
+    flash[:error] = 'Bad form data.'
+  end
+end

data/app/controllers/admin/references_controller.rb

@@ -0,0 +1,7 @@
+class Admin::ReferencesController < ApplicationController
+  def show
+    respond_to do |format|
+      format.any { render :action => params[:type], :content_type => "text/html", :layout => false }
+    end
+  end
+end

data/app/controllers/admin/resource_controller.rb

@@ -0,0 +1,245 @@
+require 'trusty_cms/resource_responses'
+require 'will_paginate'
+class Admin::ResourceController < ApplicationController
+  extend TrustyCms::ResourceResponses
+  
+  helper_method :model, :current_object, :models, :current_objects, :model_symbol, :plural_model_symbol, :model_class, :model_name, :plural_model_name
+  before_filter :populate_format
+  before_filter :never_cache
+  before_filter :load_models, :only => :index
+  before_filter :load_model, :only => [:new, :create, :edit, :update, :remove, :destroy]
+  after_filter :clear_model_cache, :only => [:create, :update, :destroy]
+
+  cattr_reader :paginated
+  cattr_accessor :default_per_page, :will_paginate_options
+  
+  responses do |r|
+    # Equivalent respond_to block for :plural responses:
+    # respond_to do |wants|
+    #   wants.xml { render :xml => models }
+    #   wants.json { render :json => models }
+    #   wants.any
+    # end
+    r.plural.publish(:xml, :json) { render format_symbol => models }
+
+    r.singular.publish(:xml, :json) { render format_symbol => model }
+    r.singular.default { redirect_to edit_model_path if action_name == "show" }
+    
+    r.not_found.publish(:xml, :json) { head :not_found }
+    r.not_found.default { announce_not_found; redirect_to :action => "index" }
+
+    r.invalid.publish(:xml, :json) { render format_symbol => model.errors, :status => :unprocessable_entity }
+    r.invalid.default { announce_validation_errors; render :action => template_name }
+
+    r.stale.publish(:xml, :json) { head :conflict }
+    r.stale.default { announce_update_conflict; render :action => template_name }
+
+    r.create.publish(:xml, :json) { render format_symbol => model, :status => :created, :location => url_for(:format => format_symbol, :id => model) }
+    r.create.default { redirect_to continue_url(params) }
+
+    r.update.publish(:xml, :json) { head :ok }
+    r.update.default { redirect_to continue_url(params) }
+
+    r.destroy.publish(:xml, :json) { head :deleted }
+    r.destroy.default { redirect_to continue_url(params) }
+  end
+
+  def index
+    response_for :plural
+  end
+
+  [:show, :new, :edit, :remove].each do |action|
+    class_eval %{
+      def #{action}                # def show
+        response_for :singular     #   response_for :singular
+      end                          # end
+    }, __FILE__, __LINE__
+  end
+
+  [:create, :update].each do |action|
+    class_eval %{
+      def #{action}                                       # def create
+        model.update_attributes!(params[model_symbol])    #   model.update_attributes!(params[model_symbol])
+        response_for :#{action}                           #   response_for :create
+      end                                                 # end
+    }, __FILE__, __LINE__
+  end
+
+  def destroy
+    model.destroy
+    response_for :destroy
+  end
+  
+  def self.model_class(model_class = nil)
+    @model_class ||= (model_class || self.controller_name).to_s.singularize.camelize.constantize
+  end
+
+  # call paginate_models to declare that will_paginate should be used in the index view
+  # options specified here are accessible in the view by calling will_paginate_options
+  # eg.
+  #
+  # Class MyController < Admin::ResourceController
+  #   paginate_models :per_page => 100
+
+  def self.paginate_models(options={})
+    @@paginated = true
+    @@will_paginate_options = options.slice(:class, :previous_label, :next_label, :inner_window, :outer_window, :separator, :container).merge(:param_name => :p)
+    @@default_per_page = options[:per_page]
+  end
+
+  # returns a hash of options that can be passed to will_paginate
+  # the @pagination_for@ helper method calls @will_paginate_options@ unless other options are supplied.
+  #
+  # pagination_for(@events)
+  
+  def will_paginate_options
+    self.class.will_paginate_options || {}
+  end
+  helper_method :will_paginate_options
+
+  # a convenience method that returns true if paginate_models has been called on this controller class
+  # and can be used to make display decisions in controller and view
+  def paginated?
+    self.class.paginated == true && params[:pp] != 'all'
+  end
+  helper_method :paginated?
+
+  # return a hash of page and per_page that can be used to build a will_paginate collection
+  # the per_page figure can be set in several ways:
+  # request parameter > declared by paginate_models > default set in config entry @admin.pagination.per_page@ > overall default of 50
+  def pagination_parameters
+    pp = params[:pp] || TrustyCms.config['admin.pagination.per_page']
+    pp = (self.class.default_per_page || 50) if pp.blank?
+    {
+      :page => (params[:p] || 1).to_i, 
+      :per_page => pp.to_i
+    }
+  end
+
+  protected
+
+    def rescue_action(exception)
+      case exception
+      when ActiveRecord::RecordInvalid
+        response_for :invalid
+      when ActiveRecord::StaleObjectError
+        response_for :stale
+      when ActiveRecord::RecordNotFound
+        response_for :not_found
+      else
+        super
+      end
+    end
+    
+    def model_class
+      self.class.model_class
+    end
+
+    def model
+      instance_variable_get("@#{model_symbol}") || load_model
+    end
+    alias :current_object :model
+    def model=(object)
+      instance_variable_set("@#{model_symbol}", object)
+    end
+    def load_model
+      self.model = if params[:id]
+        model_class.find(params[:id])
+      else
+        model_class.new()
+      end
+    end
+
+    def models
+      instance_variable_get("@#{plural_model_symbol}") || load_models
+    end
+    alias :current_objects :models
+    def models=(objects)
+      instance_variable_set("@#{plural_model_symbol}", objects)
+    end
+    def load_models
+      self.models = paginated? ? model_class.paginate(pagination_parameters) : model_class.all
+    end
+
+    def model_name
+      model_class.name
+    end
+    def plural_model_name
+      model_name.pluralize
+    end
+    alias :models_name :plural_model_name
+
+    def model_symbol
+      model_name.underscore.intern
+    end
+    def plural_model_symbol
+      model_name.pluralize.underscore.intern
+    end
+    alias :models_symbol :plural_model_symbol
+
+    def humanized_model_name
+      t(model_name.underscore.downcase)
+    end
+
+    def continue_url(options)
+      options[:redirect_to] || (params[:continue] ? {:action => 'edit', :id => model.id} : index_page_for_model)
+    end
+    
+    def index_page_for_model
+      parts = {:action => "index"}
+      if paginated? && model && i = model_class.all.index(model)
+        p = (i / pagination_parameters[:per_page].to_i) + 1
+        parts[:p] = p if p && p > 1
+      end
+      parts
+    end
+
+    def edit_model_path
+      method = "edit_admin_#{model_name.underscore}_path"
+      send method.to_sym, params[:id]
+    end
+
+    def announce_validation_errors
+      flash.now[:error] = t("resource_controller.validation_errors")
+    end
+
+    def announce_removed
+      ActiveSupport::Deprecation.warn("announce_removed is no longer encouraged in TrustyCms 0.9.x.", caller)
+      flash[:notice] = t("resource_controller.removed", :humanized_model_name => humanized_model_name)    
+    end
+    
+    def announce_not_found
+      flash[:notice] = t("resource_controller.not_found", :humanized_model_name => humanized_model_name)    
+    end
+
+    def announce_update_conflict
+      flash.now[:error] =  t("resource_controller.update_conflict", :humanized_model_name => humanized_model_name)  
+    end
+
+    def clear_model_cache
+      TrustyCms::Cache.clear if defined?(TrustyCms::Cache)
+    end
+
+    def format_symbol
+      format.to_sym
+    end
+
+    def format
+      params[:format] || 'html'
+    end
+    
+    
+    # I would like to set this to expires_in(1.minute, :private => true) to allow for more fluid navigation
+    # but the annoyance for concurrent authors would be too great.
+    def never_cache
+      expires_now
+    end
+    
+    # Assist with user agents that cause improper content-negotiation
+    # warn "Remove default HTML format, Accept header no longer used. (#{__FILE__}: #{__LINE__})" if Rails.version !~ /^2\.1/
+    def populate_format
+      params[:format] ||= 'html' unless request.xhr?
+    end
+    
+    
+end

data/app/controllers/admin/users_controller.rb

@@ -0,0 +1,40 @@
+class Admin::UsersController < Admin::ResourceController
+  paginate_models
+  only_allow_access_to :index, :show, :new, :create, :edit, :update, :remove, :destroy,
+    :when => :admin,
+    :denied_url => { :controller => 'pages', :action => 'index' },
+    :denied_message => 'You must have administrative privileges to perform this action.'
+
+  before_filter :ensure_deletable, :only => [:remove, :destroy]
+  
+  def show
+    redirect_to edit_admin_user_path(params[:id])
+  end
+  
+  def update
+    user_params = params[model_symbol]
+    if user_params && user_params['admin'] == false && model == current_user
+      user_params.delete('admin')
+      annouce_cannot_remove_self_from_admin_role
+    end
+    model.update_attributes!(user_params)
+    response_for :update
+  end
+  
+  def ensure_deletable
+    if current_user.id.to_s == params[:id].to_s
+      announce_cannot_delete_self
+      redirect_to admin_users_url
+    end
+  end
+  
+  private
+  
+    def announce_cannot_delete_self
+      flash[:error] = t('users_controller.cannot_delete_self')
+    end  
+    
+    def annouce_cannot_remove_self_from_admin_role
+      flash[:error] = 'You cannot remove yourself from the admin role.'
+    end
+end

data/app/controllers/admin/welcome_controller.rb

@@ -0,0 +1,48 @@
+class Admin::WelcomeController < ApplicationController
+  no_login_required
+  before_filter :never_cache
+  skip_before_filter :verify_authenticity_token
+  
+  def index
+    redirect_to admin_pages_url
+  end
+  
+  def login
+    if request.post?
+      @username_or_email = params[:username_or_email]
+      password = params[:password]
+      announce_invalid_user unless self.current_user = User.authenticate(@username_or_email, password)
+    end
+    if current_user
+      if params[:remember_me]
+        current_user.remember_me
+        set_session_cookie
+      end
+      redirect_to (session[:return_to] || welcome_url)
+      session[:return_to] = nil
+    end
+  end
+  
+  def logout
+    request.cookies[:session_token] = { :expires => 1.day.ago.utc }
+    self.current_user.forget_me if self.current_user
+    self.current_user = nil
+    announce_logged_out
+    redirect_to login_url
+  end
+  
+  private
+  
+    def never_cache
+      expires_now
+    end
+  
+    def announce_logged_out
+      flash[:notice] = t('welcome_controller.logged_out')
+    end
+    
+    def announce_invalid_user
+      flash.now[:error] = t('welcome_controller.invalid_user')
+    end
+    
+end

data/app/controllers/application_controller.rb

@@ -0,0 +1,114 @@
+#require_dependency 'trusty_cms'
+require 'login_system'
+
+class ApplicationController < ActionController::Base
+  include LoginSystem
+  # TODO: Add an ActionView::PathSet.new([paths]) for all extension view paths
+  prepend_view_path ("#{TRUSTY_CMS_ROOT}/app/views")
+  
+  protect_from_forgery
+
+  before_filter :set_current_user
+  before_filter :set_timezone
+  before_filter :set_user_locale
+  before_filter :set_javascripts_and_stylesheets
+  before_filter :force_utf8_params if RUBY_VERSION =~ /1\.9/
+  before_filter :set_standard_body_style, :only => [:new, :edit, :update, :create]
+
+  attr_accessor :trusty_config, :cache
+  attr_reader :pagination_parameters
+  helper_method :pagination_parameters
+  
+  def initialize
+    super
+    @trusty_config = TrustyCms::Config
+  end
+  
+  # helpers to include additional assets from actions or views
+  helper_method :include_stylesheet, :include_javascript
+  
+  def include_stylesheet(sheet)
+    @stylesheets << sheet
+  end
+  
+  def include_javascript(script)
+    @javascripts << script
+  end
+
+  def template_name
+    case self.action_name
+    when 'index'
+      'index'
+    when 'new','create'
+      'new'
+    when 'show'
+      'show'
+    when 'edit', 'update'
+      'edit'
+    when 'remove', 'destroy'
+      'remove'
+    else
+      self.action_name
+    end
+  end
+    
+  def rescue_action_in_public(exception)
+    case exception
+      when ActiveRecord::RecordNotFound, ActionController::UnknownController, ActionController::UnknownAction, ActionController::RoutingError
+        render :template => "site/not_found", :status => 404
+      else
+        super
+    end
+  end
+  
+  private
+  
+    def set_current_user
+      UserActionObserver.instance.current_user = current_user
+    end  
+        
+    def set_user_locale      
+      I18n.locale = current_user && !current_user.locale.blank? ? current_user.locale : TrustyCms::Config['default_locale']
+    end
+
+    def set_timezone
+      Time.zone = TrustyCms::Config['local.timezone'] != nil && TrustyCms::Config['local.timezone'].empty? ? Time.zone_default : TrustyCms::Config['local.timezone']
+    end
+  
+    def set_javascripts_and_stylesheets
+      @stylesheets ||= []
+      @stylesheets.concat %w(admin/main)
+      @javascripts ||= []
+    end
+
+    def set_standard_body_style
+      @body_classes ||= []
+      @body_classes.concat(%w(reversed))
+    end
+    
+    # When using TrustyCms with Ruby 1.9, the strings that come in from forms are ASCII-8BIT encoded.
+    # That causes problems, especially when using special chars and with certain DBs, like DB2
+    # That's why we force the encoding of the params to UTF-8
+    # That's what's happening in Rails 3, too: https://github.com/rails/rails/commit/25215d7285db10e2c04d903f251b791342e4dd6a
+    #
+    # See http://stackoverflow.com/questions/8268778/rails-2-3-9-encoding-of-query-parameters
+    # See https://rails.lighthouseapp.com/projects/8994/tickets/4807
+    # See http://jasoncodes.com/posts/ruby19-rails2-encodings (thanks for the following code, Jason!)
+    def force_utf8_params      
+      traverse = lambda do |object, block|
+        if object.kind_of?(Hash)
+          object.each_value { |o| traverse.call(o, block) }
+        elsif object.kind_of?(Array)
+          object.each { |o| traverse.call(o, block) }
+        else
+          block.call(object)
+        end
+        object
+      end
+      force_encoding = lambda do |o|
+        o.force_encoding(Encoding::UTF_8) if o.respond_to?(:force_encoding)
+      end
+      traverse.call(params, force_encoding)
+    end
+    
+end

data/app/controllers/site_controller.rb

@@ -0,0 +1,97 @@
+require 'trusty_cms/pagination/controller'
+class SiteController < ApplicationController
+  include TrustyCms::Pagination::Controller
+
+  skip_filter :verify_authenticity_token
+  no_login_required
+
+  def self.cache_timeout=(val)
+    TrustyCms::PageResponseCacheDirector.cache_timeout=(val)
+  end
+  def self.cache_timeout
+    TrustyCms::PageResponseCacheDirector.cache_timeout
+  end
+
+  def show_page
+    url = params[:url]
+    if Array === url
+      url = url.join('/')
+    else
+      url = url.to_s
+    end
+    if @page = find_page(url)
+      batch_page_status_refresh if (url == "/" || url == "")
+      process_page(@page)
+      set_cache_control
+      @performed_render ||= true
+    else
+      render :template => 'site/not_found', :status => 404
+    end
+  rescue Page::MissingRootPageError
+    redirect_to welcome_url
+  end
+
+  def cacheable_request?
+    (request.head? || request.get?) && live?
+  end
+  hide_action :cacheable_request?
+
+  def set_expiry(time, options={})
+    expires_in time, options
+  end
+  hide_action :set_expiry
+
+  def set_etag(val)
+    headers['ETag'] = val
+  end
+  hide_action :set_expiry
+
+  private
+    def batch_page_status_refresh
+      @changed_pages = []
+      @pages = Page.where({:status_id => Status[:scheduled].id})
+      @pages.each do |page|
+        if page.published_at <= Time.now
+           page.status_id = Status[:published].id
+           page.save
+           @changed_pages << page.id
+        end
+      end
+
+      expires_in nil, :private=>true, "no-cache" => true if @changed_pages.length > 0
+    end
+
+    def set_cache_control
+      response_cache_director(@page).set_cache_control
+    end
+
+    def response_cache_director(page)
+      klass_name = "TrustyCms::#{page.class}ResponseCacheDirector"
+      begin
+        klass = klass_name.constantize
+      rescue NameError, LoadError
+        director_klass = "TrustyCms::PageResponseCacheDirector"
+        eval(%Q{class #{klass_name} < #{director_klass}; end}, TOPLEVEL_BINDING)
+        klass = director_klass.constantize
+      end
+      klass.new(page, self)
+    end
+
+    def find_page(url)
+      found = Page.find_by_path(url, live?)
+      found if found and (found.published? or dev?)
+    end
+
+    def process_page(page)
+      page.pagination_parameters = pagination_parameters
+      page.process(request, response)
+    end
+
+    def dev?
+      request.host == @trusty_config['dev.host'] || request.host =~ /^dev\./
+    end
+
+    def live?
+      not dev?
+    end
+end