trusty-cms 4.0.2 → 4.1.4

data/app/controllers/admin/configuration_controller.rb

@@ -1,5 +1,4 @@
 class Admin::ConfigurationController < ApplicationController
-
   # Admin::ConfigurationController handles the batch-updating of TrustyCms::Config entries.
   # It accepts any set of config name-value pairs but is accessible only to administrators.
   # Note that configuration is routed as a singular resource so we only deal with show/edit/update
@@ -8,9 +7,9 @@ class Admin::ConfigurationController < ApplicationController
   before_action :initialize_config
 
   only_allow_access_to :edit, :update,
-    :when => [:admin],
-    :denied_url => { :controller => 'admin/configuration', :action => 'show' },
-    :denied_message => 'You must have admin privileges to edit site configuration.'
+                       when: [:admin],
+                       denied_url: { controller: 'admin/configuration', action: 'show' },
+                       denied_message: 'You must have admin privileges to edit site configuration.'
 
   def show
     @user = current_user
@@ -27,24 +26,23 @@ class Admin::ConfigurationController < ApplicationController
         TrustyCms.config.transaction do
           params[:trusty_config].each_pair do |key, value|
             @trusty_config[key] = TrustyCms::Config.find_or_initialize_by(key: key)
-            @trusty_config[key].value = value      # validation sets errors on @trusty_config['key'] that the helper methods will pick up
+            @trusty_config[key].value = value # validation sets errors on @trusty_config['key'] that the helper methods will pick up
           end
-          redirect_to :action => :show
+          redirect_to action: :show
         end
       rescue ActiveRecord::RecordInvalid => e
-        flash[:error] = "Configuration error: please check the form"
-        render :action => :edit
+        flash[:error] = 'Configuration error: please check the form'
+        render action: :edit
       rescue TrustyCms::Config::ConfigError => e
         flash[:error] = "Configuration error: #{e}"
-        render :action => :edit
+        render action: :edit
       end
     end
   end
 
-protected
+  protected
 
   def initialize_config
     @trusty_config = {}
   end
-
 end

data/app/controllers/admin/extensions_controller.rb

@@ -1,8 +1,8 @@
 class Admin::ExtensionsController < ApplicationController
   only_allow_access_to :index,
-    :when => :admin,
-    :denied_url => { :controller => 'pages', :action => 'index' },
-    :denied_message => 'You must have administrative privileges to perform this action.'
+                       when: :admin,
+                       denied_url: { controller: 'pages', action: 'index' },
+                       denied_message: 'You must have administrative privileges to perform this action.'
 
   def index
     @template_name = 'index' # for Admin::RegionsHelper

data/app/controllers/admin/layouts_controller.rb

@@ -1,8 +1,7 @@
 class Admin::LayoutsController < Admin::ResourceController
   paginate_models
   only_allow_access_to :index, :show, :new, :create, :edit, :update, :remove, :destroy,
-    :when => [:designer, :admin],
-    :denied_url => { :controller => 'admin/pages', :action => 'index' },
-    :denied_message => 'You must have designer privileges to perform this action.'
-
+                       when: %i[designer admin],
+                       denied_url: { controller: 'admin/pages', action: 'index' },
+                       denied_message: 'You must have designer privileges to perform this action.'
 end

data/app/controllers/admin/page_attachments_controller.rb

@@ -2,7 +2,7 @@ class Admin::PageAttachmentsController < Admin::ResourceController
   helper 'admin/assets'
 
   def new
-    render :partial => 'attachment', :object => model
+    render partial: 'attachment', object: model
   end
 
   def load_model
@@ -10,14 +10,14 @@ class Admin::PageAttachmentsController < Admin::ResourceController
       @asset = Asset.find(params[:asset_id])
       @page = page_attachment_params[:page_id].blank? ? Page.new : Page.find_by_id(page_attachment_params[:page_id])
     rescue ActiveRecord::RecordNotFound
-      render :nothing => true, :layout => false
+      render nothing: true, layout: false
     end
-    self.model = PageAttachment.new(:asset => @asset, :page => @page)
+    self.model = PageAttachment.new(asset: @asset, page: @page)
   end
 
-private
+  private
+
   def page_attachment_params
     params.permit(:asset_id, :page_id)
   end
-
 end

data/app/controllers/admin/page_fields_controller.rb

@@ -1,10 +1,10 @@
 class Admin::PageFieldsController < Admin::ResourceController
   def create
-    self.model.attributes = page_fields_params
+    model.attributes = page_fields_params
     @controller_name = 'page'
     @template_name = 'edit'
-    render :partial => "page_field", :object => model,
-      :locals => { :page_field_counter => params[:page_field_counter].to_i}
+    render partial: 'page_field', object: model,
+           locals: { page_field_counter: params[:page_field_counter].to_i }
   end
 
   private
@@ -12,5 +12,4 @@ class Admin::PageFieldsController < Admin::ResourceController
   def page_fields_params
     params.require(:page_field).permit(:name, :content, :page_id)
   end
-
 end

data/app/controllers/admin/page_parts_controller.rb

@@ -1,16 +1,15 @@
 class Admin::PagePartsController < Admin::ResourceController
   def create
-    self.model.attributes = page_parts_params
+    model.attributes = page_parts_params
     @controller_name = 'page'
     @template_name = 'edit'
-    render :partial => "page_part", :object => model,
-      :locals => {:page_part_counter => params[:index].to_i}
+    render partial: 'page_part', object: model,
+           locals: { page_part_counter: params[:index].to_i }
   end
 
-private
+  private
 
   def page_parts_params
     params.require(:page_part).permit(:name, :filter_id, :content)
   end
-
 end

data/app/controllers/admin/pages_controller.rb

@@ -1,7 +1,7 @@
 class Admin::PagesController < Admin::ResourceController
-  before_action :initialize_meta_rows_and_buttons, :only => [:new, :edit, :create, :update]
-  before_action :count_deleted_pages, :only => [:destroy]
-  rescue_from ActiveRecord::RecordInvalid, :with => :validation_error
+  before_action :initialize_meta_rows_and_buttons, only: %i[new edit create update]
+  before_action :count_deleted_pages, only: [:destroy]
+  rescue_from ActiveRecord::RecordInvalid, with: :validation_error
 
   class PreviewStop < ActiveRecord::Rollback
     def message
@@ -13,11 +13,11 @@ class Admin::PagesController < Admin::ResourceController
     r.plural.js do
       @level = params[:level].to_i
       @index = params[:index].to_i
-      @rendered_html = ""
+      @rendered_html = ''
       @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
+      render action: 'children.html.haml', layout: false
     end
   end
 
@@ -34,8 +34,8 @@ class Admin::PagesController < Admin::ResourceController
 
   def preview
     render_preview
-  rescue PreviewStop => exception
-    render :text => exception.message unless @performed_render
+  rescue PreviewStop => e
+    render text: e.message unless @performed_render
   end
 
   def save_table_position
@@ -44,67 +44,66 @@ class Admin::PagesController < Admin::ResourceController
     head :ok
   end
 
-
   private
 
-    def validation_error(e)
-      flash[:error] = e.message
-      render :new
-    end
+  def validation_error(e)
+    flash[:error] = e.message
+    render :new
+  end
 
-    def assign_page_attributes
-      if params[:page_id].blank?
-        self.model.slug = '/'
-      end
-      self.model.parent_id = params[:page_id]
+  def assign_page_attributes
+    if params[:page_id].blank?
+      model.slug = '/'
     end
+    model.parent_id = params[:page_id]
+  end
 
-    def model_class
-      if Page.descendants.any? { |d| d.to_s == params[:page_class] }
-        verify_page_class(params[:page_class])
-      elsif params[:page_id]
-        Page.find(params[:page_id]).children
-      else
-        Page
-      end
+  def model_class
+    if Page.descendants.any? { |d| d.to_s == params[:page_class] }
+      verify_page_class(params[:page_class])
+    elsif params[:page_id]
+      Page.find(params[:page_id]).children
+    else
+      Page
     end
+  end
 
-    def render_preview
-      params.permit!
-      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)
-          layout_id = page.layout_id
-          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)
+  def render_preview
+    params.permit!
+    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)
+        layout_id = page.layout_id
+        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
-      render template: 'site/show_page', layout: false
-      raise PreviewStop
-    end
+  def process_with_exception(page)
+    page.process(request, response)
+    @performed_render = true
+    render template: 'site/show_page', layout: false
+    raise PreviewStop
+  end
 
-    def count_deleted_pages
-      @count = model.children.count + 1
-    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
+  def initialize_meta_rows_and_buttons
+    @buttons_partials ||= []
+    @meta ||= []
+    @meta << { field: 'slug', type: 'text_field', args: [{ class: 'textbox' }] }
+    @meta << { field: 'breadcrumb', type: 'text_field', args: [{ class: 'textbox' }] }
+  end
 
   def verify_page_class(page_class)
     if page_class.constantize.ancestors.include?(Page)

data/app/controllers/admin/references_controller.rb

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

data/app/controllers/admin/resource_controller.rb

@@ -5,10 +5,10 @@ class Admin::ResourceController < ApplicationController
   helper_method :model, :current_object, :models, :current_objects, :model_symbol, :plural_model_symbol, :model_class, :model_name, :plural_model_name
   before_action :populate_format
   before_action :never_cache
-  before_action :load_models, :only => :index
-  before_action :load_model, :only => [:new, :create, :edit, :update, :remove, :destroy]
-  before_action :set_owner_or_editor, :only => [:new, :create, :update]
-  after_action :clear_model_cache, :only => [:create, :update, :destroy]
+  before_action :load_models, only: :index
+  before_action :load_model, only: %i[new create edit update remove destroy]
+  before_action :set_owner_or_editor, only: %i[new create update]
+  after_action :clear_model_cache, only: %i[create update destroy]
 
   cattr_reader :paginated
   cattr_accessor :default_per_page, :will_paginate_options
@@ -23,18 +23,18 @@ class Admin::ResourceController < ApplicationController
     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.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.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.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.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.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 }
@@ -48,7 +48,7 @@ class Admin::ResourceController < ApplicationController
     response_for :plural
   end
 
-  [:show, :new, :edit, :remove].each do |action|
+  %i[show new edit remove].each do |action|
     class_eval %{
       def #{action}                # def show
         response_for :singular     #   response_for :singular
@@ -56,7 +56,7 @@ class Admin::ResourceController < ApplicationController
     }, __FILE__, __LINE__
   end
 
-  [:create, :update].each do |action|
+  %i[create update].each do |action|
     class_eval %{
       def #{action}                                       # def create
         model.update_attributes!(permitted_params[model_symbol])    #   model.update_attributes!(params[model_symbol])
@@ -71,7 +71,7 @@ class Admin::ResourceController < ApplicationController
   end
 
   def self.model_class(model_class = nil)
-    @model_class ||= (model_class || self.controller_name).to_s.singularize.camelize.constantize
+    @model_class ||= (model_class || controller_name).to_s.singularize.camelize.constantize
   end
 
   # call paginate_models to declare that will_paginate should be used in the index view
@@ -81,9 +81,9 @@ class Admin::ResourceController < ApplicationController
   # Class MyController < Admin::ResourceController
   #   paginate_models :per_page => 100
 
-  def self.paginate_models(options={})
+  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)
+    @@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
 
@@ -111,151 +111,153 @@ class Admin::ResourceController < ApplicationController
     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
+      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
+  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_class
+    self.class.model_class
+  end
 
-    def set_owner_or_editor
-      if self.model.has_attribute? :created_by_id
-        self.model.created_by_id = current_user.id if self.model.id == nil
-        self.model.updated_by_id = current_user.id
-      end
+  def set_owner_or_editor
+    if model.has_attribute? :created_by_id
+      model.created_by_id = current_user.id if model.id == nil
+      model.updated_by_id = current_user.id
     end
+  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 model
+    instance_variable_get("@#{model_symbol}") || load_model
+  end
+  alias :current_object :model
+  def model=(object)
+    instance_variable_set("@#{model_symbol}", object)
+  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
+  def load_model
+    self.model = if params[:id]
+                   model_class.find(params[:id])
+                 else
+                   model_class.new
     end
+  end
 
-    def model_name
-      model_class.name
-    end
-    def plural_model_name
-      model_name.pluralize
-    end
-    alias :models_name :plural_model_name
+  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 model_symbol
-      model_name.underscore.intern
-    end
-    def plural_model_symbol
-      model_name.pluralize.underscore.intern
-    end
-    alias :models_symbol :plural_model_symbol
+  def load_models
+    self.models = paginated? ? model_class.paginate(pagination_parameters) : model_class.all
+  end
 
-    def humanized_model_name
-      t(model_name.underscore.downcase)
-    end
+  def model_name
+    model_class.name
+  end
 
-    def continue_url(options)
-      options[:redirect_to] || (params[:continue] ? {:action => 'edit', :id => model.id} : index_page_for_model)
-    end
+  def plural_model_name
+    model_name.pluralize
+  end
+  alias :models_name :plural_model_name
 
-    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 model_symbol
+    model_name.underscore.intern
+  end
 
-    def edit_model_path
-      method = "edit_admin_#{model_name.underscore}_path"
-      send method.to_sym, params[:id]
-    end
+  def plural_model_symbol
+    model_name.pluralize.underscore.intern
+  end
+  alias :models_symbol :plural_model_symbol
 
-    def announce_validation_errors
-      flash.now[:error] = t("resource_controller.validation_errors")
-    end
+  def humanized_model_name
+    t(model_name.underscore.downcase)
+  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 continue_url(options)
+    options[:redirect_to] || (params[:continue] ? { action: 'edit', id: model.id } : index_page_for_model)
+  end
 
-    def announce_not_found
-      flash[:notice] = t("resource_controller.not_found", :humanized_model_name => humanized_model_name)
+  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 announce_update_conflict
-      flash.now[:error] =  t("resource_controller.update_conflict", :humanized_model_name => humanized_model_name)
-    end
+  def edit_model_path
+    method = "edit_admin_#{model_name.underscore}_path"
+    send method.to_sym, params[:id]
+  end
 
-    def clear_model_cache
-      Rails.cache.clear
-    end
+  def announce_validation_errors
+    flash.now[:error] = t('resource_controller.validation_errors')
+  end
 
-    def format_symbol
-      format.to_sym
-    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 format
-      params[:format] || 'html'
-    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
 
-    # 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
+  def clear_model_cache
+    Rails.cache.clear
+  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
+  def format_symbol
+    format.to_sym
+  end
 
-    def permitted_params
-      model_symbols = ActiveRecord::Base.descendants.map{|a| a.name.underscore.to_sym}
-      keys = params.keys.map{|k| k.underscore.to_sym}
-      valid_symbols = model_symbols & keys
-      valid_symbols.each do |symbol|
-        params[symbol].permit!
-      end
-      params
-    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
+
+  def permitted_params
+    model_symbols = ActiveRecord::Base.descendants.map { |a| a.name.underscore.to_sym }
+    keys = params.keys.map { |k| k.underscore.to_sym }
+    valid_symbols = model_symbols & keys
+    valid_symbols.each do |symbol|
+      params[symbol].permit!
+    end
+    params
+  end
 end