refinerycms-core 0.9.9.1

data/lib/refinery/admin/base_controller.rb

@@ -0,0 +1,111 @@
+require 'action_controller'
+require 'application_helper'
+
+module Refinery
+  module Admin
+    module BaseController
+
+      def self.included(controller)
+        controller.send :include, ::Refinery::Admin::BaseController::InstanceMethods
+        controller.send :include, ::Refinery::Admin::BaseController::ClassMethods
+      end
+
+      module ClassMethods
+        def self.included(c)
+          c.layout :layout?
+
+          c.before_filter :authenticate_user!, :restrict_plugins, :restrict_controller
+          c.after_filter :store_location?, :except => [:new, :create, :edit, :update, :destroy, :update_positions] # for redirect_back_or_default
+
+          c.helper_method :searching?, :group_by_date
+        end
+      end
+
+      module InstanceMethods
+        def admin?
+          true # we're in the admin base controller, so always true.
+        end
+
+        def searching?
+          params[:search].present?
+        end
+
+        def error_404(exception=nil)
+          if (@page = Page.find_by_menu_match("^/404$", :include => [:parts, :slugs])).present?
+            params[:action] = 'error_404'
+            # change any links in the copy to the admin_root_path
+            # and any references to "home page" to "Dashboard"
+            part_symbol = Page.default_parts.first.to_sym
+            @page[part_symbol] = @page[part_symbol].to_s.gsub(
+                                   /href=(\'|\")\/(\'|\")/, "href='#{admin_root_path}'"
+                                 ).gsub("home page", "Dashboard")
+
+            render :template => "/pages/show",
+                   :layout => layout?,
+                   :status => 404
+          else
+            # fallback to the default 404.html page.
+            render :file => Rails.root.join("public", "404.html").cleanpath.to_s,
+                   :layout => false,
+                   :status => 404
+          end
+        end
+
+      protected
+
+        def group_by_date(records)
+          new_records = []
+
+          records.each do |record|
+            key = record.created_at.strftime("%Y-%m-%d")
+            record_group = new_records.collect{|records| records.last if records.first == key }.flatten.compact << record
+            (new_records.delete_if {|i| i.first == key}) << [key, record_group]
+          end
+
+          new_records
+        end
+
+        def restrict_plugins
+          current_length = (plugins = current_user.authorized_plugins).length
+
+          # Superusers get granted access if they don't already have access.
+          if current_user.has_role?(:superuser)
+            if (plugins = plugins | ::Refinery::Plugins.registered.names).length > current_length
+              current_user.plugins = plugins
+            end
+          end
+
+          Refinery::Plugins.set_active(plugins)
+        end
+
+        def restrict_controller
+          if Refinery::Plugins.active.reject { |plugin| params[:controller] !~ Regexp.new(plugin.menu_match)}.empty?
+            warn "'#{current_user.username}' tried to access '#{params[:controller]}' but was rejected."
+            error_404
+          end
+        end
+
+        # Override method from application_controller. Not needed in this controller.
+        def find_pages_for_menu; end
+
+      private
+        def layout?
+          "admin#{"_dialog" if from_dialog?}"
+        end
+
+        # Check whether it makes sense to return the user to the last page they
+        # were at instead of the default e.g. admin_pages_url
+        # right now we just want to snap back to index actions and definitely not to dialogues.
+        def store_location?
+          store_location unless action_name !~ /index/ or request.xhr? or from_dialog?
+        end
+
+        # Override authorized? so that only users with the Refinery role can admin the website.
+        def authorized?
+          refinery_user?
+        end
+      end
+
+    end
+  end
+end

data/lib/refinery/admin_base_controller.rb

@@ -0,0 +1,5 @@
+# This is a dummy to enable updates from 0.9.8.x onward.
+module Refinery
+  class AdminBaseController < ActionController::Base
+  end
+end

data/lib/refinery/application.rb

@@ -0,0 +1,48 @@
+module Refinery
+  module Application
+    class << self
+      def refine!
+        ::ApplicationHelper.send :include, ::Refinery::ApplicationHelper
+
+        [::ApplicationController, ::Admin::BaseController].each do |c|
+          c.send :include, ::Refinery::ApplicationController
+          c.send :helper, :application
+        end
+
+        ::Admin::BaseController.send :include, ::Refinery::Admin::BaseController
+      end
+
+      def included(base)
+        self.instance_eval %(
+          def self.method_missing(method_sym, *arguments, &block)
+            #{base}.send(method_sym)
+          end
+        )
+
+        # JavaScript files you want as :defaults (application.js is always included).
+        base.config.action_view.javascript_expansions[:defaults] = %w()
+
+        # Configure the default encoding used in templates for Ruby 1.9.
+        base.config.encoding = "utf-8"
+
+        # Configure sensitive parameters which will be filtered from the log file.
+        base.config.filter_parameters += [:password, :password_confirmation]
+
+        # Specify a cache store to use
+        base.config.cache_store = :memory_store
+
+        # Include the refinery controllers and helpers dynamically
+        base.config.to_prepare do
+          ::Refinery::Application.refine!
+        end
+
+        # load in any settings that the developer wants after the initialization.
+        base.config.after_initialize do
+          if (settings = Rails.root.join('config', 'settings.rb')).exist?
+            require settings.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/refinery/application_controller.rb

@@ -0,0 +1,120 @@
+require 'action_controller'
+# require application helper so that we can include our helpers into it.
+if defined?(Rails) and !Rails.root.nil?
+  if (app_helper = Rails.root.join('app', 'helpers', 'application_helper.rb')).file?
+    require app_helper.to_s
+  end
+end
+
+module Refinery
+  module ApplicationController
+
+    def self.included(controller)
+      controller.send :include, ::Refinery::ApplicationController::InstanceMethods
+      controller.send :include, ::Refinery::ApplicationController::ClassMethods
+    end
+
+    module ClassMethods
+      def self.included(c) # Extend controller
+        c.helper_method :home_page?,
+                        :local_request?,
+                        :just_installed?,
+                        :from_dialog?,
+                        :admin?,
+                        :login?
+
+        c.protect_from_forgery # See ActionController::RequestForgeryProtection
+
+        c.send :include, Crud # basic create, read, update and delete methods
+
+        c.send :before_filter, :find_pages_for_menu,
+                               :show_welcome_page?
+
+        c.send :after_filter, :store_current_location!,
+                              :if => Proc.new {|c| c.send(:refinery_user?) rescue false }
+
+        if Refinery.rescue_not_found
+          c.send :rescue_from, ActiveRecord::RecordNotFound,
+                               ActionController::UnknownAction,
+                               ActionView::MissingTemplate,
+                               :with => :error_404
+        end
+      end
+    end
+
+    module InstanceMethods
+      def admin?
+        controller_name =~ %r{^admin/}
+      end
+
+      def error_404(exception=nil)
+        if (@page = Page.where(:menu_match => "^/404$").includes(:parts, :slugs).first).present?
+          # render the application's custom 404 page with layout and meta.
+          render :template => "/pages/show",
+                 :format => 'html',
+                 :status => 404
+        else
+          # fallback to the default 404.html page.
+          file = Rails.root.join('public', '404.html')
+          file = Refinery.roots('core').join('public', '404.html') unless file.exist?
+          render :file => file.cleanpath.to_s,
+                 :layout => false,
+                 :status => 404
+        end
+      end
+
+      def from_dialog?
+        params[:dialog] == "true" or params[:modal] == "true"
+      end
+
+      def home_page?
+        root_path == request.path
+      end
+
+      def just_installed?
+        Role[:refinery].users.empty?
+      end
+
+      def local_request?
+        Rails.env.development? or request.remote_ip =~ /(::1)|(127.0.0.1)|((192.168).*)/
+      end
+
+      def login?
+        (controller_name =~ /^(user|session)(|s)/ and not admin?) or just_installed?
+      end
+
+    protected
+
+      # get all the pages to be displayed in the site menu.
+      def find_pages_for_menu
+        @menu_pages = Page.live.in_menu.order('lft ASC')
+      end
+
+      # use a different model for the meta information.
+      def present(model)
+        presenter = (Object.const_get("#{model.class}Presenter") rescue ::Refinery::BasePresenter)
+        @meta = presenter.new(model)
+      end
+
+      # this hooks into the Rails render method.
+      def render(action = nil, options = {}, &blk)
+        present(@page) unless admin? or @meta.present?
+        super
+      end
+
+      def show_welcome_page?
+        render :template => "/welcome", :layout => "login" if just_installed? and %w(registrations).exclude?(controller_name)
+      end
+
+    private
+      def store_current_location!
+        if admin?
+          # ensure that we don't redirect to AJAX or POST/PUT/DELETE urls
+          session[:refinery_return_to] = request.path if request.get? and !request.xhr? and !from_dialog?
+        elsif defined?(@page) and @page.present?
+          session[:website_return_to] = @page.url
+        end
+      end
+    end
+  end
+end

data/lib/refinery/application_helper.rb

@@ -0,0 +1,19 @@
+# Methods added to this helper will be available to all templates in the application.
+Dir[File.expand_path('../helpers/*.rb', __FILE__).to_s].each {|helper| require helper}
+
+module Refinery
+  module ApplicationHelper
+    def self.included(base)
+      base.send :include, Refinery::Helpers::HeadHelper
+      base.send :include, Refinery::Helpers::HtmlTruncationHelper
+      base.send :include, Refinery::Helpers::ImageHelper
+      base.send :include, Refinery::Helpers::MenuHelper
+      base.send :include, Refinery::Helpers::MetaHelper
+      base.send :include, Refinery::Helpers::PaginationHelper
+      base.send :include, Refinery::Helpers::ScriptHelper
+      base.send :include, Refinery::Helpers::SiteBarHelper
+      base.send :include, Refinery::Helpers::TagHelper
+      base.send :include, Refinery::Helpers::TranslationHelper
+    end
+  end
+end

data/lib/refinery/base_presenter.rb

@@ -0,0 +1,27 @@
+class Refinery::BasePresenter
+
+  DEFAULT_FIELDS = {
+    :title              => Proc.new { |p| (p.model.class.name.titleize if p.model.present?) },
+    :path               => Proc.new { |p| p.title },
+    :browser_title      => nil,
+    :meta_description   => nil,
+    :meta_keywords      => nil
+  }
+
+  attr_reader :model
+
+  def initialize(obj)
+    @model = obj
+  end
+
+  def method_missing(method, *args)
+    if @model.respond_to? method
+      @model.send method
+    elsif DEFAULT_FIELDS.has_key? method
+      (value = DEFAULT_FIELDS[method]).is_a?(Proc) ? value.call(self) : value
+    else
+      raise NoMethodError.new("#{self.class.name} doesn't know #{method}. Define or delegate it.", method)
+    end
+  end
+
+end

data/lib/refinery/catch_all_routes.rb

@@ -0,0 +1,11 @@
+::Refinery::Application.routes.draw do
+  match '/admin(/*path)', :to => redirect {|params, request|
+    request.flash[:message] = "<p>
+      The URL '/<strong>admin</strong>#{"/#{params[:path]}" unless params[:path].blank?}' will be removed in Refinery CMS version 1.0
+      <br/>
+      Please use '/<strong>refinery</strong>#{"/#{params[:path]}" unless params[:path].blank?}' instead.
+    </p>".html_safe
+    "/refinery#{"/#{params[:path]}" unless params[:path].blank?}"
+  }
+  match '/refinery/*path' => 'admin/base#error_404'
+end

data/lib/refinery/crud.rb

@@ -0,0 +1,295 @@
+# Base methods for CRUD actions
+# Simply override any methods in your action controller you want to be customised
+# Don't forget to add:
+#   resources :plural_model_name_here
+# to your routes.rb file.
+# Full documentation about CRUD and resources go here:
+# -> http://caboo.se/doc/classes/ActionController/Resources.html#M003716
+# Example (add to your controller):
+# crudify :foo, {:title_attribute => 'name'}
+
+module Refinery
+  module Crud
+
+    def self.default_options(model_name)
+      singular_name = model_name.to_s
+      class_name = singular_name.camelize
+      plural_name = singular_name.pluralize
+      this_class = class_name.constantize.base_class
+
+      {
+        :title_attribute => "title",
+        :order => ('position ASC' if this_class.table_exists? and this_class.column_names.include?('position')),
+        :conditions => '',
+        :sortable => true,
+        :searchable => true,
+        :include => [],
+        :paging => true,
+        :search_conditions => '',
+        :redirect_to_url => "admin_#{plural_name}_url"
+      }
+    end
+
+    def self.append_features(base)
+      super
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      def crudify(model_name, options = {})
+        options = ::Refinery::Crud.default_options(model_name).merge(options)
+
+        singular_name = model_name.to_s
+        class_name = singular_name.camelize
+        plural_name = singular_name.pluralize
+
+        module_eval %(
+          prepend_before_filter :find_#{singular_name},
+                                :only => [:update, :destroy, :edit, :show]
+
+          def new
+            @#{singular_name} = #{class_name}.new
+          end
+
+          def create
+            # if the position field exists, set this object as last object, given the conditions of this class.
+            if #{class_name}.column_names.include?("position")
+              params[:#{singular_name}].merge!({
+                :position => ((#{class_name}.maximum(:position, :conditions => #{options[:conditions].inspect})||-1) + 1)
+              })
+            end
+
+            if (@#{singular_name} = #{class_name}.create(params[:#{singular_name}])).valid?
+              (request.xhr? ? flash.now : flash).notice = t(
+                'refinery.crudify.created',
+                :what => "'\#{@#{singular_name}.#{options[:title_attribute]}}'"
+              )
+
+              unless from_dialog?
+                unless params[:continue_editing] =~ /true|on|1/
+                  redirect_back_or_default(#{options[:redirect_to_url]})
+                else
+                  unless request.xhr?
+                    redirect_to :back
+                  else
+                    render :partial => "/shared/message"
+                  end
+                end
+              else
+                render :text => "<script>parent.window.location = '\#{#{options[:redirect_to_url]}}';</script>"
+              end
+            else
+              unless request.xhr?
+                render :action => 'new'
+              else
+                render :partial => "/shared/admin/error_messages",
+                       :locals => {
+                         :object => @#{singular_name},
+                         :include_object_name => true
+                       }
+              end
+            end
+          end
+
+          def edit
+            # object gets found by find_#{singular_name} function
+          end
+
+          def update
+            if @#{singular_name}.update_attributes(params[:#{singular_name}])
+              (request.xhr? ? flash.now : flash).notice = t(
+                'refinery.crudify.updated',
+                :what => "'\#{@#{singular_name}.#{options[:title_attribute]}}'"
+              )
+
+              unless from_dialog?
+                unless params[:continue_editing] =~ /true|on|1/
+                  redirect_back_or_default(#{options[:redirect_to_url]})
+                else
+                  unless request.xhr?
+                    redirect_to :back
+                  else
+                    render :partial => "/shared/message"
+                  end
+                end
+              else
+                render :text => "<script>parent.window.location = '\#{#{options[:redirect_to_url]}}';</script>"
+              end
+            else
+              unless request.xhr?
+                render :action => 'edit'
+              else
+                render :partial => "/shared/admin/error_messages",
+                       :locals => {
+                         :object => @#{singular_name},
+                         :include_object_name => true
+                       }
+              end
+            end
+          end
+
+          def destroy
+            # object gets found by find_#{singular_name} function
+            title = @#{singular_name}.#{options[:title_attribute]}
+            if @#{singular_name}.destroy
+              flash.notice = t('destroyed', :scope => 'refinery.crudify', :what => "'\#{title}'")
+            end
+
+            redirect_to #{options[:redirect_to_url]}
+          end
+
+          # Finds one single result based on the id params.
+          def find_#{singular_name}
+            @#{singular_name} = #{class_name}.find(params[:id],
+                                                   :include => #{options[:include].map(&:to_sym).inspect})
+          end
+
+          # Find the collection of @#{plural_name} based on the conditions specified into crudify
+          # It will be ordered based on the conditions specified into crudify
+          # And eager loading is applied as specified into crudify.
+          def find_all_#{plural_name}(conditions = #{options[:conditions].inspect})
+            @#{plural_name} = #{class_name}.where(conditions).includes(
+                                #{options[:include].map(&:to_sym).inspect}
+                              ).order("#{options[:order]}")
+          end
+
+          # Paginate a set of @#{plural_name} that may/may not already exist.
+          def paginate_all_#{plural_name}
+            # If we have already found a set then we don't need to again
+            find_all_#{plural_name} if @#{plural_name}.nil?
+
+            paging_options = {:page => params[:page]}
+
+            # Seems will_paginate doesn't always use the implicit method.
+            if #{class_name}.methods.map(&:to_sym).include?(:per_page)
+              paging_options.update({:per_page => #{class_name}.per_page})
+            end
+
+            @#{plural_name} = @#{plural_name}.paginate(paging_options)
+          end
+
+          # Returns a weighted set of results based on the query specified by the user.
+          def search_all_#{plural_name}
+            # First find normal results.
+            find_all_#{plural_name}(#{options[:search_conditions].inspect})
+
+            # Now get weighted results by running the query against the results already found.
+            @#{plural_name} = @#{plural_name}.with_query(params[:search])
+          end
+
+          # Ensure all methods are protected so that they should only be called
+          # from within the current controller.
+          protected :find_#{singular_name},
+                    :find_all_#{plural_name},
+                    :paginate_all_#{plural_name},
+                    :search_all_#{plural_name}
+        )
+
+        # Methods that are only included when this controller is searchable.
+        if options[:searchable]
+          if options[:paging]
+            module_eval %(
+              def index
+                search_all_#{plural_name} if searching?
+                paginate_all_#{plural_name}
+              end
+            )
+          else
+            module_eval %(
+              def index
+                unless searching?
+                  find_all_#{plural_name}
+                else
+                  search_all_#{plural_name}
+                end
+              end
+            )
+          end
+
+        else
+          if options[:paging]
+            module_eval %(
+              def index
+                paginate_all_#{plural_name}
+              end
+            )
+          else
+            module_eval %(
+              def index
+                find_all_#{plural_name}
+              end
+            )
+          end
+
+        end
+
+        if options[:sortable]
+          module_eval %(
+            def reorder
+              find_all_#{plural_name}
+            end
+
+            # Based upon http://github.com/matenia/jQuery-Awesome-Nested-Set-Drag-and-Drop
+            def update_positions
+              previous = nil
+              # The list doesn't come to us in the correct order. Frustration.
+              0.upto((newlist ||= params[:ul]).length - 1) do |index|
+                hash = newlist[index.to_s]
+                moved_item_id = hash['id'].split(/#{singular_name}\\_?/)
+                @current_#{singular_name} = #{class_name}.find_by_id(moved_item_id)
+
+                if @current_#{singular_name}.respond_to?(:move_to_root)
+                  if previous.present?
+                    @current_#{singular_name}.move_to_right_of(#{class_name}.find_by_id(previous))
+                  else
+                    @current_#{singular_name}.move_to_root
+                  end
+                else
+                  @current_#{singular_name}.update_attribute(:position, index)
+                end
+
+                if hash['children'].present?
+                  update_child_positions(hash, @current_#{singular_name})
+                end
+
+                previous = moved_item_id
+              end
+
+              #{class_name}.rebuild! if #{class_name}.respond_to?(:rebuild!)
+              render :nothing => true
+            end
+
+            def update_child_positions(node, #{singular_name})
+              0.upto(node['children'].length - 1) do |child_index|
+                child = node['children'][child_index.to_s]
+                child_id = child['id'].split(/#{singular_name}\_?/)
+                child_#{singular_name} = #{class_name}.find_by_id(child_id)
+                child_#{singular_name}.move_to_child_of(#{singular_name})
+
+                if child['children'].present?
+                  update_child_positions(child, child_#{singular_name})
+                end
+              end
+            end
+
+          )
+        end
+
+        module_eval %(
+          def self.sortable?
+            #{options[:sortable].to_s}
+          end
+
+          def self.searchable?
+            #{options[:searchable].to_s}
+          end
+        )
+
+
+      end
+
+    end
+
+  end
+end