refinerycms-core 1.0.11 → 2.0.0

data/lib/refinery/core/engine.rb

@@ -0,0 +1,143 @@
+module Refinery
+  module Core
+    class Engine < ::Rails::Engine
+      include 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
+        end
+
+        # Performs the Refinery inclusion process which extends the currently loaded Rails
+        # applications with Refinery's controllers and helpers. The process is wrapped by
+        # a before_inclusion and after_inclusion step that calls procs registered by the
+        # Refinery::Engine#before_inclusion and Refinery::Engine#after_inclusion class methods
+        def refinery_inclusion!
+          before_inclusion_procs.each(&:call)
+
+          [::ApplicationController, Refinery::AdminController].each do |c|
+            c.send :include, Refinery::ApplicationController
+            c.send :helper, Refinery::Core::Engine.helpers
+          end
+
+          [Refinery::UsersController, Refinery::SessionsController, Refinery::PasswordsController].each do |c|
+            c.send :helper, Refinery::Core::Engine.helpers
+          end
+
+          Refinery::AdminController.send :include, Refinery::Admin::BaseController
+
+          after_inclusion_procs.each(&:call)
+        end
+      end
+
+      config.autoload_paths += %W( #{config.root}/lib )
+
+      # We can't reload the base class because otherwise in development mode
+      # we lose any configuration that is applied to it like macros for Dragonfly.
+      config.autoload_once_paths += %W( #{config.root}/app/models/refinery/core )
+
+      # Include the refinery controllers and helpers dynamically
+      config.to_prepare &method(:refinery_inclusion!).to_proc
+
+      after_inclusion &method(:load_decorators).to_proc
+
+      # Wrap errors in spans
+      config.to_prepare do
+        ActionView::Base.field_error_proc = Proc.new do |html_tag, instance|
+          "<span class=\"fieldWithErrors\">#{html_tag}</span>".html_safe
+        end
+      end
+
+      initializer "refinery.will_paginate" do
+        WillPaginate.per_page = 20
+      end
+
+      initializer "register refinery_core plugin" do
+        Refinery::Plugin.register do |plugin|
+          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)$/
+        end
+      end
+
+      initializer "register refinery_dialogs plugin" do
+        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__)
+      end
+
+      initializer "refinery.autoload_paths" do |app|
+        app.config.autoload_paths += [
+          Rails.root.join('app', 'presenters'),
+          Rails.root.join('vendor', '**', '**', 'app', 'presenters'),
+          Refinery.roots.map{|r| r.join('**', 'app', 'presenters')}
+        ].flatten
+      end
+
+      initializer "refinery.acts_as_indexed" do
+        ActsAsIndexed.configure do |config|
+          config.index_file = Rails.root.join('tmp', 'index')
+          config.index_file_depth = 3
+          config.min_word_size = 3
+        end
+      end
+
+      # set the manifests and assets to be precompiled
+      initializer "refinery.assets.precompile" do |app|
+        app.config.assets.precompile += [
+          "refinery/*",
+          "refinery/icons/*",
+          "wymeditor/lang/*",
+          "wymeditor/skins/refinery/*",
+          "wymeditor/skins/refinery/**/*",
+          "modernizr-min.js",
+          "dd_belatedpng.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]
+      end
+
+      initializer "refinery.encoding" do |app|
+        app.config.encoding = 'utf-8'
+      end
+
+      initializer "refinery.memory_store" do |app|
+        app.config.cache_store = :memory_store
+      end
+
+      config.after_initialize do
+        Refinery.register_extension(Refinery::Core)
+      end
+    end
+  end
+end

data/lib/refinery/core.rb

@@ -0,0 +1,179 @@
+require 'rails/all'
+require 'rbconfig'
+require 'acts_as_indexed'
+require 'truncate_html'
+require 'will_paginate'
+
+module Refinery
+  WINDOWS = !!(RbConfig::CONFIG['host_os'] =~ %r!(msdos|mswin|djgpp|mingw)!) unless defined? WINDOWS
+
+  require 'refinery/errors'
+
+  autoload :Activity, 'refinery/activity'
+  autoload :ApplicationController, 'refinery/application_controller'
+  autoload :Engine, 'refinery/engine'
+  autoload :Menu, 'refinery/menu'
+  autoload :MenuItem, 'refinery/menu_item'
+  autoload :Plugin,  'refinery/plugin'
+  autoload :Plugins, 'refinery/plugins'
+  autoload :Version, 'refinery/version'
+  autoload :Crud, 'refinery/crud'
+  autoload :BasePresenter, 'refinery/base_presenter'
+
+  require 'refinery/ext/action_view/helpers/form_builder'
+  require 'refinery/ext/action_view/helpers/form_helper'
+  require 'refinery/ext/action_view/helpers/form_tag_helper'
+
+  module Admin
+    autoload :BaseController, 'refinery/admin/base_controller'
+  end
+
+  autoload :CmsGenerator, 'generators/refinery/cms/cms_generator'
+  autoload :DummyGenerator, 'generators/refinery/dummy/dummy_generator'
+  autoload :CoreGenerator, 'generators/refinery/core/core_generator'
+  autoload :EngineGenerator, 'generators/refinery/engine/engine_generator'
+
+  class << self
+    @@extensions = []
+
+    # Returns an array of modules representing currently registered Refinery Engines
+    #
+    # Example:
+    #   Refinery.extensions  =>  [Refinery::Core, Refinery::Pages]
+    def extensions
+      @@extensions
+    end
+
+    # Register an extension with Refinery
+    #
+    # Example:
+    #   Refinery.register_extension(Refinery::Core)
+    def register_extension(const)
+      return if extension_registered?(const)
+
+      validate_extension!(const)
+
+      @@extensions << const
+    end
+    alias_method :register_engine, :register_extension
+
+    # Unregister an extension from Refinery
+    #
+    # Example:
+    #   Refinery.unregister_extension(Refinery::Core)
+    def unregister_extension(const)
+      @@extensions.delete(const)
+    end
+
+    # Returns true if an extension is currently registered with Refinery
+    #
+    # Example:
+    #   Refinery.extension_registered?(Refinery::Core)
+    def extension_registered?(const)
+      @@extensions.include?(const)
+    end
+
+    # Constructs a deprecation warning message and warns with Kernel#warn
+    #
+    # Example:
+    #   Refinery.deprecate('foo') => "The use of 'foo' is deprecated"
+    #
+    # An options parameter can be specified to construct a more detailed deprecation message
+    #
+    # Options:
+    #   when - version that this deprecated feature will be removed
+    #   replacement - a replacement for what is being deprecated
+    #   caller - who called the deprecated feature
+    #
+    # Example:
+    #   Refinery.deprecate('foo', :when => 'tomorrow', :replacement => 'bar') =>
+    #       "The use of 'foo' is deprecated and will be removed at version 2.0. Please use 'bar' instead."
+    def deprecate(what, options = {})
+      # Build a warning.
+      warning = "\n-- DEPRECATION WARNING --\n"
+      warning << "The use of '#{what}' is deprecated"
+      warning << " and will be removed at version #{options[:when]}" if options[:when]
+      warning << "."
+      warning << "\nPlease use #{options[:replacement]} instead." if options[:replacement]
+
+      # See if we can trace where this happened
+      if options[:caller]
+        whos_calling = options[:caller].detect{|c| c =~ %r{#{Rails.root.to_s}}}.inspect.to_s.split(':in').first
+        warning << "\nCalled from: #{whos_calling}\n"
+      end
+
+      # Give stern talking to.
+      warn warning
+    end
+
+    def i18n_enabled?
+      !!(defined?(::Refinery::I18n) && ::Refinery::I18n.enabled?)
+    end
+
+    # Returns a Pathname to the root of the Refinery CMS project
+    def root
+      @root ||= Pathname.new(File.expand_path('../../../../', __FILE__))
+    end
+
+    # Returns an array of Pathnames pointing to the root directory of each extension that
+    # has been registered with Refinery.
+    #
+    # Example:
+    #   Refinery.roots => [#<Pathname:/Users/Reset/Code/refinerycms/core>, #<Pathname:/Users/Reset/Code/refinerycms/pages>]
+    #
+    # An optional extension_name parameter can be specified to return just the Pathname for
+    # the specified extension. This can be represented in Constant, Symbol, or String form.
+    #
+    # Example:
+    #   Refinery.roots(Refinery::Core)    =>  #<Pathname:/Users/Reset/Code/refinerycms/core>
+    #   Refinery.roots(:'refinery/core')  =>  #<Pathname:/Users/Reset/Code/refinerycms/core>
+    #   Refinery.roots("refinery/core")   =>  #<Pathname:/Users/Reset/Code/refinerycms/core>
+    def roots(extension_name = nil)
+      return @roots ||= self.extensions.map { |extension| extension.root } if extension_name.nil?
+
+      extension_name.to_s.camelize.constantize.root
+    end
+
+    def version
+      Refinery::Version.to_s
+    end
+
+    # Returns string version of url helper path. We need this to temporary support namespaces
+    # like Refinery::Image and Refinery::Blog::Post
+    #
+    # Example:
+    #   Refinery.route_for_model("Refinery::Image") => "admin_image_path"
+    #   Refinery.route_for_model(Refinery::Image, true) => "admin_images_path"
+    #   Refinery.route_for_model(Refinery::Blog::Post) => "blog_admin_post_path"
+    #   Refinery.route_for_model(Refinery::Blog::Post, true) => "blog_admin_posts_path"
+    def route_for_model(klass, plural = false)
+      parts = klass.to_s.underscore.split('/').delete_if { |p| p.blank? }
+
+      resource_name = plural ? parts[-1].pluralize : parts[-1]
+
+      if parts.size == 2
+        "admin_#{resource_name}_path"
+      elsif parts.size > 2
+        [parts[1..-2].join("_"), "admin", resource_name, "path"].join("_")
+      end
+    end
+
+    private
+      def validate_extension!(const)
+        unless const.respond_to?(:root) && const.root.is_a?(Pathname)
+          raise InvalidEngineError, "Engine must define a root accessor that returns a pathname to its root"
+        end
+      end
+  end
+
+  module Core
+    require 'refinery/core/engine'
+    require 'refinery/core/configuration'
+
+    class << self
+      def root
+        @root ||= Pathname.new(File.expand_path('../../../', __FILE__))
+      end
+    end
+  end
+end

data/lib/refinery/crud.rb

@@ -10,25 +10,26 @@
 # Full documentation about CRUD and resources go here:
 # -> http://api.rubyonrails.org/classes/ActionDispatch/Routing/Mapper/Resources.html#method-i-resources
 # Example (add to your controller):
-# crudify :foo, {:title_attribute => 'name'} for CRUD on Foo model
-# crudify 'foo/bar', :{title_attribute => 'name'} for CRUD on Foo::Bar model
+# crudify :foo, :title_attribute => 'name' for CRUD on Foo model
+# crudify :'foo/bar', :title_attribute => 'name' for CRUD on Foo::Bar model
+# Note: @singular_name will result in @foo for :foo and @bar for :'foo/bar'
 
 module Refinery
   module Crud
 
     def self.default_options(model_name)
-      class_name = model_name.to_s.include?("/") ? "::#{model_name.to_s.camelize}" : model_name.to_s.camelize
+      class_name = "#{model_name.to_s.camelize.gsub('/', '::')}".gsub('::::', '::')
       this_class = class_name.constantize.base_class
-      singular_name = model_name.to_s.underscore.gsub("/","_")
+      singular_name = ActiveModel::Naming.param_key(this_class)
       plural_name = singular_name.pluralize
 
       {
         :conditions => '',
         :include => [],
-        :order => ('position ASC' if this_class.table_exists? and this_class.column_names.include?('position')),
+        :order => ('position ASC' if this_class.table_exists? && this_class.column_names.include?('position')),
         :paging => true,
         :per_page => false,
-        :redirect_to_url => "admin_#{model_name.to_s.gsub('/', '_').pluralize}_url",
+        :redirect_to_url => "refinery.#{Refinery.route_for_model(class_name.constantize, true)}",
         :searchable => true,
         :search_conditions => '',
         :sortable => true,
@@ -54,6 +55,10 @@ module Refinery
         plural_name = options[:plural_name]
 
         module_eval %(
+          def self.crudify_options
+            #{options.inspect}
+          end
+
           prepend_before_filter :find_#{singular_name},
                                 :only => [:update, :destroy, :edit, :show]
 
@@ -63,14 +68,14 @@ module Refinery
 
           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")
+            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?
-              (request.xhr? ? flash.now : flash).notice = t(
+              flash.notice = t(
                 'refinery.crudify.created',
                 :what => "'\#{@#{singular_name}.#{options[:title_attribute]}}'"
               )
@@ -82,18 +87,19 @@ module Refinery
                   unless request.xhr?
                     redirect_to :back
                   else
-                    render :partial => "/shared/message"
+                    render :partial => '/refinery/message'
                   end
                 end
               else
-                render :text => "<script>parent.window.location = '\#{#{options[:redirect_to_url]}}';</script>"
+                self.index
+                @dialog_successful = true
+                render :index
               end
             else
               unless request.xhr?
                 render :action => 'new'
               else
-                render :partial => "/shared/admin/error_messages",
-                       :locals => {
+                render :partial => '/refinery/admin/error_messages', :locals => {
                          :object => @#{singular_name},
                          :include_object_name => true
                        }
@@ -107,7 +113,7 @@ module Refinery
 
           def update
             if @#{singular_name}.update_attributes(params[:#{singular_name}])
-              (request.xhr? ? flash.now : flash).notice = t(
+              flash.notice = t(
                 'refinery.crudify.updated',
                 :what => "'\#{@#{singular_name}.#{options[:title_attribute]}}'"
               )
@@ -119,18 +125,19 @@ module Refinery
                   unless request.xhr?
                     redirect_to :back
                   else
-                    render :partial => "/shared/message"
+                    render :partial => '/refinery/message'
                   end
                 end
               else
-                render :text => "<script>parent.window.location = '\#{#{options[:redirect_to_url]}}';</script>"
+                self.index
+                @dialog_successful = true
+                render :index
               end
             else
               unless request.xhr?
                 render :action => 'edit'
               else
-                render :partial => "/shared/admin/error_messages",
-                       :locals => {
+                render :partial => '/refinery/admin/error_messages', :locals => {
                          :object => @#{singular_name},
                          :include_object_name => true
                        }
@@ -168,17 +175,22 @@ module Refinery
             # 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]}
-
-            # Use per_page from crudify options.
-            if #{options[:per_page].present?.inspect}
-              paging_options.update({:per_page => #{options[:per_page].inspect}})
-            # Seems will_paginate doesn't always use the implicit method.
+            per_page = if #{options[:per_page].present?.inspect}
+              #{options[:per_page].inspect}
             elsif #{class_name}.methods.map(&:to_sym).include?(:per_page)
-              paging_options.update({:per_page => #{class_name}.per_page})
+              #{class_name}.per_page
             end
 
-            @#{plural_name} = @#{plural_name}.paginate(paging_options)
+            @#{plural_name} = @#{plural_name}.paginate(:page => params[:page], :per_page => per_page)
+          end
+
+          # If the controller is being accessed via an ajax request
+          # then render only the collection of items.
+          def render_partial_response?
+            if request.xhr?
+              render :text => render_to_string(:partial => '#{plural_name}', :layout => false).html_safe,
+                     :layout => 'refinery/flash' and return false
+            end
           end
 
           # Returns a weighted set of results based on the query specified by the user.
@@ -195,6 +207,7 @@ module Refinery
           protected :find_#{singular_name},
                     :find_all_#{plural_name},
                     :paginate_all_#{plural_name},
+                    :render_partial_response?,
                     :search_all_#{plural_name}
         )
 
@@ -206,7 +219,7 @@ module Refinery
                 search_all_#{plural_name} if searching?
                 paginate_all_#{plural_name}
 
-                render :partial => '#{plural_name}' if #{options[:xhr_paging].inspect} && request.xhr?
+                render_partial_response?
               end
             )
           else
@@ -217,6 +230,8 @@ module Refinery
                 else
                   search_all_#{plural_name}
                 end
+
+                render_partial_response?
               end
             )
           end
@@ -227,13 +242,14 @@ module Refinery
               def index
                 paginate_all_#{plural_name}
 
-                render :partial => '#{plural_name}' if #{options[:xhr_paging].inspect} && request.xhr?
+                render_partial_response?
               end
             )
           else
             module_eval %(
               def index
                 find_all_#{plural_name}
+                render_partial_response?
               end
             )
           end
@@ -249,36 +265,35 @@ module Refinery
             # 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}.where(:id => moved_item_id).first
-
-                if @current_#{singular_name}.respond_to?(:move_to_root)
-                  if previous.present?
-                    @current_#{singular_name}.move_to_right_of(#{class_name}.where(:id => previous).first)
+              params[:ul].each do |_, list|
+                list.each do |index, hash|
+                  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}.move_to_root
+                    @current_#{singular_name}.update_attribute(:position, index)
                   end
-                else
-                  @current_#{singular_name}.update_attribute(:position, index)
-                end
 
-                if hash['children'].present?
-                  update_child_positions(hash, @current_#{singular_name})
-                end
+                  if hash['children'].present?
+                    update_child_positions(hash, @current_#{singular_name})
+                  end
 
-                previous = moved_item_id
+                  previous = moved_item_id
+                end
               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]
+            def update_child_positions(_node, #{singular_name})
+              _node['children']['0'].each do |_, child|
                 child_id = child['id'].split(/#{singular_name}\_?/)
                 child_#{singular_name} = #{class_name}.where(:id => child_id).first
                 child_#{singular_name}.move_to_child_of(#{singular_name})
@@ -288,21 +303,26 @@ module Refinery
                 end
               end
             end
-
           )
         end
 
         module_eval %(
-          def self.sortable?
-            #{options[:sortable].to_s}
-          end
+          class << self
+            def pageable?
+              #{options[:paging].to_s}
+            end
+            alias_method :paging?, :pageable?
 
-          def self.searchable?
-            #{options[:searchable].to_s}
+            def sortable?
+              #{options[:sortable].to_s}
+            end
+
+            def searchable?
+              #{options[:searchable].to_s}
+            end
           end
         )
 
-
       end
 
     end

data/lib/refinery/engine.rb

@@ -1,19 +1,63 @@
-require 'rails/engine'
+require 'active_support/concern'
 
 module Refinery
   module Engine
-    class << self
-      def included(base)
-        base.module_eval do
-          class << self
-            def refinery
-              ::Refinery.config
-            end
-          end
+    extend ActiveSupport::Concern
 
-          def refinery
-            self.class.refinery
-          end
+    module ClassMethods
+      def after_inclusion_procs #:nodoc:
+        @@after_inclusion_procs ||= []
+      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
+      end
+
+      def before_inclusion_procs #:nodoc:
+        @@before_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
     end