refinerycms-core 2.0.10 → 2.1.0

data/lib/refinery/core/configuration.rb

@@ -4,22 +4,19 @@ module Refinery
 
     config_accessor :rescue_not_found, :s3_backend, :base_cache_key, :site_name,
                     :google_analytics_page_code, :authenticity_token_on_frontend,
-                    :menu_hide_children, :menu_css, :dragonfly_secret, :ie6_upgrade_message_enabled,
-                    :show_internet_explorer_upgrade_message, :wymeditor_whitelist_tags,
-                    :javascripts, :stylesheets, :s3_bucket_name, :s3_region, :s3_access_key_id,
-                    :s3_secret_access_key, :force_ssl
+                    :dragonfly_secret,
+                    :wymeditor_whitelist_tags, :javascripts, :stylesheets,
+                    :s3_bucket_name, :s3_region, :s3_access_key_id,
+                    :s3_secret_access_key, :force_ssl, :backend_route,
+                    :dragonfly_custom_backend_class, :dragonfly_custom_backend_opts
 
     self.rescue_not_found = false
     self.s3_backend = false
     self.base_cache_key = :refinery
     self.site_name = "Company Name"
     self.google_analytics_page_code = "UA-xxxxxx-x"
-    self.authenticity_token_on_frontend = true
-    self.menu_hide_children = false
-    self.menu_css = { :selected => "selected", :first => "first", :last => "last" }
+    self.authenticity_token_on_frontend = false
     self.dragonfly_secret = Array.new(24) { rand(256) }.pack('C*').unpack('H*').first
-    self.ie6_upgrade_message_enabled = true
-    self.show_internet_explorer_upgrade_message = false
     self.wymeditor_whitelist_tags = {}
     self.javascripts = []
     self.stylesheets = []
@@ -28,6 +25,9 @@ module Refinery
     self.s3_access_key_id = ENV['S3_KEY']
     self.s3_secret_access_key = ENV['S3_SECRET']
     self.force_ssl = false
+    self.backend_route = "refinery"
+    self.dragonfly_custom_backend_class = ''
+    self.dragonfly_custom_backend_opts = {}
 
     def config.register_javascript(name)
       self.javascripts << name
@@ -46,6 +46,14 @@ module Refinery
         self.stylesheets = []
       end
 
+      def dragonfly_custom_backend?
+        config.dragonfly_custom_backend_class.present?
+      end
+
+      def dragonfly_custom_backend_class
+        config.dragonfly_custom_backend_class.constantize if dragonfly_custom_backend?
+      end
+
       def site_name
         ::I18n.t('site_name', :scope => 'refinery.core.config', :default => config.site_name)
       end

data/lib/refinery/core/engine.rb

@@ -1,20 +1,15 @@
 module Refinery
   module Core
     class Engine < ::Rails::Engine
-      include Refinery::Engine
+      extend Refinery::Engine
 
       isolate_namespace Refinery
       engine_name :refinery
 
       class << self
-        # Require/load (based on Rails app.config) all decorators from app/decorators/
-        # and from registered plugins' paths too.
-        def load_decorators
-          [Rails.root, Refinery::Plugins.registered.pathnames].flatten.map { |p|
-            Dir[p.join('app', 'decorators', '**', '*_decorator.rb')]
-          }.flatten.uniq.each do |decorator|
-            Rails.application.config.cache_classes ? require(decorator) : load(decorator)
-          end
+        # Register all decorators from app/decorators/ and registered plugins' paths.
+        def register_decorators!
+          Decorators.register! Rails.root, Refinery::Plugins.registered.pathnames
         end
 
         # Performs the Refinery inclusion process which extends the currently loaded Rails
@@ -24,7 +19,7 @@ module Refinery
         def refinery_inclusion!
           before_inclusion_procs.each(&:call)
 
-          ::ApplicationController.send :include, Refinery::ApplicationController
+          Refinery.include_once(::ApplicationController, Refinery::ApplicationController)
           ::ApplicationController.send :helper, Refinery::Core::Engine.helpers
 
           after_inclusion_procs.each(&:call)
@@ -36,7 +31,7 @@ module Refinery
       # Include the refinery controllers and helpers dynamically
       config.to_prepare &method(:refinery_inclusion!).to_proc
 
-      after_inclusion &method(:load_decorators).to_proc
+      after_inclusion &method(:register_decorators!).to_proc
 
       # Wrap errors in spans
       config.to_prepare do
@@ -54,7 +49,6 @@ module Refinery
           plugin.pathname = root
           plugin.name = 'refinery_core'
           plugin.class_name = 'RefineryEngine'
-          plugin.version = Refinery.version
           plugin.hide_from_menu = true
           plugin.always_allow_access = true
           plugin.menu_match = /refinery\/(refinery_)?core$/
@@ -65,15 +59,16 @@ module Refinery
         Refinery::Plugin.register do |plugin|
           plugin.pathname = root
           plugin.name = 'refinery_dialogs'
-          plugin.version = Refinery.version
           plugin.hide_from_menu = true
           plugin.always_allow_access = true
           plugin.menu_match = /refinery\/(refinery_)?dialogs/
         end
       end
 
-      initializer "refinery.routes" do |app|
-        app.routes_reloader.paths << File.expand_path('../../catch_all_routes.rb', __FILE__)
+      initializer "refinery.routes", :after => :set_routes_reloader_hook do |app|
+        Refinery::Core::Engine.routes.append do
+          get "#{Refinery::Core.backend_route}/*path" => 'admin#error_404'
+        end
       end
 
       initializer "refinery.autoload_paths" do |app|
@@ -84,40 +79,19 @@ module Refinery
         ].flatten
       end
 
-      initializer "refinery.acts_as_indexed" do
-        ActiveSupport.on_load(:active_record) do
-          require 'acts_as_indexed'
-          ActsAsIndexed.configure do |config|
-            config.index_file = Rails.root.join('tmp', 'index')
-            config.index_file_depth = 3
-            config.min_word_size = 3
-          end
-        end
-      end
-
       # set the manifests and assets to be precompiled
-      initializer "refinery.assets.precompile", :group => :all do |app|
+      initializer "refinery.assets.precompile" do |app|
         app.config.assets.precompile += [
-          "home.css",
-          "formatting.css",
-          "theme.css",
-          "admin.js",
           "refinery/*",
           "refinery/icons/*",
           "wymeditor/lang/*",
           "wymeditor/skins/refinery/*",
           "wymeditor/skins/refinery/**/*",
           "modernizr-min.js",
-          "dd_belatedpng.js",
           "admin.js"
         ]
       end
 
-      # Disable asset debugging - it's a performance killer in dev mode
-      initializer "refinery.assets.pipeline" do |app|
-        app.config.assets.debug = false
-      end
-
       # active model fields which may contain sensitive data to filter
       initializer "refinery.params.filter" do |app|
         app.config.filter_parameters += [:password, :password_confirmation]
@@ -134,16 +108,6 @@ module Refinery
       config.after_initialize do
         Refinery.register_extension(Refinery::Core)
       end
-
-      # We need to reload the routes here due to how Refinery sets them up
-      # The different facets of Refinery (dashboard, pages, etc.) append/prepend routes to Core
-      # *after* Core has been loaded.
-      #
-      # So we wait until after initialization is complete to do one final reload
-      # This then makes the appended/prepended routes available to the application.
-      config.after_initialize do
-        Rails.application.routes_reloader.reload!
-      end
     end
   end
 end

data/lib/refinery/crud.rb

@@ -61,49 +61,22 @@ module Refinery
 
           prepend_before_filter :find_#{singular_name},
                                 :only => [:update, :destroy, :edit, :show]
+          prepend_before_filter :merge_position_into_params!, :only => :create
 
           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}][:position].nil?
-              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?
               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 => '/refinery/message'
-                  end
-                end
-              else
-                self.index
-                @dialog_successful = true
-                render :index
-              end
+              create_or_update_successful
             else
-              unless request.xhr?
-                render :action => 'new'
-              else
-                render :partial => '/refinery/admin/error_messages', :locals => {
-                         :object => @#{singular_name},
-                         :include_object_name => true
-                       }
-              end
+              create_or_update_unsuccessful 'new'
             end
           end
 
@@ -118,30 +91,9 @@ module Refinery
                 :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 => '/refinery/message'
-                  end
-                end
-              else
-                self.index
-                @dialog_successful = true
-                render :index
-              end
+              create_or_update_successful
             else
-              unless request.xhr?
-                render :action => 'edit'
-              else
-                render :partial => '/refinery/admin/error_messages', :locals => {
-                         :object => @#{singular_name},
-                         :include_object_name => true
-                       }
-              end
+              create_or_update_unsuccessful 'edit'
             end
           end
 
@@ -152,7 +104,7 @@ module Refinery
               flash.notice = t('destroyed', :scope => 'refinery.crudify', :what => "'\#{title}'")
             end
 
-            redirect_to #{options[:redirect_to_url]}
+            redirect_to redirect_url
           end
 
           # Finds one single result based on the id params.
@@ -170,18 +122,39 @@ module Refinery
                               ).order("#{options[:order]}")
           end
 
+          def merge_position_into_params!
+            # 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}][:position].nil?
+              params[:#{singular_name}].merge!({
+                :position => ((#{class_name}.maximum(:position, :conditions => #{options[:conditions].inspect})||-1) + 1)
+              })
+            end
+          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?
 
-            per_page = if #{options[:per_page].present?.inspect}
+            @#{plural_name} = @#{plural_name}.paginate(:page => params[:page], :per_page => paginate_per_page)
+          end
+
+          def paginate_per_page
+            if #{options[:per_page].present?.inspect}
               #{options[:per_page].inspect}
             elsif #{class_name}.methods.map(&:to_sym).include?(:per_page)
               #{class_name}.per_page
             end
+          end
 
-            @#{plural_name} = @#{plural_name}.paginate(:page => params[:page], :per_page => per_page)
+          def redirect_url
+            if params[:page].present?
+              page = params[:page].to_i rescue 1
+              page -= 1 while #{class_name}.paginate(:page => page).empty? && page > 1
+              #{options[:redirect_to_url]}(:page => page)
+            else
+              #{options[:redirect_to_url]}
+            end
           end
 
           # If the controller is being accessed via an ajax request
@@ -193,6 +166,35 @@ module Refinery
             end
           end
 
+          def create_or_update_successful
+            if from_dialog?
+              self.index
+              @dialog_successful = true
+              render :index
+            else
+              if /true|on|1/ === params[:continue_editing]
+                if request.xhr?
+                  render :partial => '/refinery/message'
+                else
+                  redirect_to :back
+                end
+              else
+                redirect_back_or_default redirect_url
+              end
+            end
+          end
+
+          def create_or_update_unsuccessful(action)
+            if request.xhr?
+              render :partial => '/refinery/admin/error_messages', :locals => {
+                       :object => @#{singular_name},
+                       :include_object_name => true
+                     }
+            else
+              render :action => action
+            end
+          end
+
           # Returns a weighted set of results based on the query specified by the user.
           def search_all_#{plural_name}
             # First find normal results.
@@ -207,13 +209,18 @@ module Refinery
           protected :find_#{singular_name},
                     :find_all_#{plural_name},
                     :paginate_all_#{plural_name},
+                    :paginate_per_page,
                     :render_partial_response?,
-                    :search_all_#{plural_name}
+                    :search_all_#{plural_name},
+                    :redirect_url,
+                    :create_or_update_successful,
+                    :create_or_update_unsuccessful,
+                    :merge_position_into_params!
         )
 
         # Methods that are only included when this controller is searchable.
         if options[:searchable]
-          if options[:paging]
+          if options[:paging] || options[:xhr_paging]
             module_eval %(
               def index
                 search_all_#{plural_name} if searching?
@@ -237,7 +244,7 @@ module Refinery
           end
 
         else
-          if options[:paging]
+          if options[:paging] || options[:xhr_paging]
             module_eval %(
               def index
                 paginate_all_#{plural_name}
@@ -266,11 +273,8 @@ module Refinery
             def update_positions
               previous = nil
               params[:ul].each do |_, list|
-                # After we drop Ruby 1.8.x support the following line can be changed back to
-                # list.each do |index, hash|
-                # because there won't be an ordering issue (see https://github.com/refinery/refinerycms/issues/1585)
-                list.sort_by {|k, v| k.to_i}.map { |item| item[1] }.each_with_index do |hash, index|
-                  moved_item_id = hash['id'].split(/#{singular_name}\_?/).reject(&:empty?).first
+                list.each do |index, hash|
+                  moved_item_id = hash['id'][/\\d+$/]
                   @current_#{singular_name} = #{class_name}.find_by_id(moved_item_id)
 
                   if @current_#{singular_name}.respond_to?(:move_to_root)
@@ -292,7 +296,8 @@ module Refinery
               end
 
               #{class_name}.rebuild! if #{class_name}.respond_to?(:rebuild!)
-              render :nothing => true
+
+              after_update_positions
             end
 
             def update_child_positions(_node, #{singular_name})
@@ -307,16 +312,26 @@ module Refinery
                 end
               end
             end
+
+            def after_update_positions
+              render :nothing => true
+            end
+
+            protected :after_update_positions
           )
         end
 
         module_eval %(
           class << self
             def pageable?
-              #{options[:paging].to_s}
+              #{options[:paging].to_s} || #{options[:xhr_paging].to_s}
             end
             alias_method :paging?, :pageable?
 
+            def xhr_pageable?
+              #{options[:xhr_paging].to_s}
+            end
+
             def sortable?
               #{options[:sortable].to_s}
             end

data/lib/refinery/engine.rb

@@ -1,65 +1,62 @@
-require 'active_support/concern'
-
 module Refinery
   module Engine
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      def after_inclusion_procs #:nodoc:
-        @@after_inclusion_procs ||= []
+    # Specify a block of code to be run after the refinery inclusion step. See
+    # Refinery::Core::Engine#refinery_inclusion for details regarding the Refinery
+    # inclusion process.
+    #
+    # Example:
+    #   module Refinery
+    #     module Images
+    #       class Engine < Rails::Engine
+    #         extend Refinery::Engine
+    #         engine_name :images
+    #
+    #         after_inclusion do
+    #           # perform something here
+    #         end
+    #       end
+    #     end
+    #   end
+    def after_inclusion(&block)
+      if block && block.respond_to?(:call)
+        after_inclusion_procs << block
+      else
+        raise 'Anything added to be called after_inclusion must be callable (respond to #call).'
       end
+    end
 
-      # Specify a block of code to be run after the refinery inclusion step. See
-      # Refinery::Core::Engine#refinery_inclusion for details regarding the Refinery
-      # inclusion process.
-      #
-      # Example:
-      #   module Refinery
-      #     module Images
-      #       class Engine < Rails::Engine
-      #         engine_name :images
-      #
-      #         after_inclusion do
-      #           # perform something here
-      #         end
-      #       end
-      #     end
-      #   end
-      def after_inclusion(&block)
-        if block && block.respond_to?(:call)
-          after_inclusion_procs << block
-        else
-          raise 'Anything added to be called after_inclusion must be callable (respond to #call).'
-        end
+    # Specify a block of code to be run before the refinery inclusion step. See
+    # Refinery::Core::Engine#refinery_inclusion for details regarding the Refinery
+    # inclusion process.
+    #
+    # Example:
+    #   module Refinery
+    #     module Images
+    #       class Engine < Rails::Engine
+    #         extend Refinery::Engine
+    #         engine_name :images
+    #
+    #         before_inclusion do
+    #           # perform something here
+    #         end
+    #       end
+    #     end
+    #   end
+    def before_inclusion(&block)
+      if block && block.respond_to?(:call)
+        before_inclusion_procs << block
+      else
+        raise 'Anything added to be called before_inclusion must be callable (respond to #call).'
       end
+    end
 
-      def before_inclusion_procs #:nodoc:
-        @@before_inclusion_procs ||= []
-      end
+    private
+    def after_inclusion_procs
+      @@after_inclusion_procs ||= []
+    end
 
-      # Specify a block of code to be run before the refinery inclusion step. See
-      # Refinery::Core::Engine#refinery_inclusion for details regarding the Refinery
-      # inclusion process.
-      #
-      # Example:
-      #   module Refinery
-      #     module Images
-      #       class Engine < Rails::Engine
-      #         engine_name :images
-      #
-      #         before_inclusion do
-      #           # perform something here
-      #         end
-      #       end
-      #     end
-      #   end
-      def before_inclusion(&block)
-        if block && block.respond_to?(:call)
-          before_inclusion_procs << block
-        else
-          raise 'Anything added to be called before_inclusion must be callable (respond to #call).'
-        end
-      end
+    def before_inclusion_procs
+      @@before_inclusion_procs ||= []
     end
   end
 end