refinerycms-core 2.1.5 → 3.0.0

data/lib/refinery/cli.rb

@@ -6,8 +6,8 @@ module Refinery
 
     no_tasks do
       def source_paths
-        Refinery::Plugins.registered.pathnames.map{|p|
-          %w(app vendor).map{|dir| p.join(dir, @override_kind[:dir])}
+        Refinery::Plugins.registered.pathnames.map{ |p|
+          %w(app vendor).map{ |dir| p.join(dir, @override_kind[:dir])}
         }.flatten.uniq
       end
     end
@@ -44,7 +44,7 @@ module Refinery
         :desc => 'javascript',
       },
       :stylesheet => {
-        :glob => '*.css{,.scss}',
+        :glob => '*.{s,}css',
         :dir => 'assets/stylesheets',
         :desc => 'stylesheet',
       },
@@ -58,20 +58,24 @@ module Refinery
         end
       end
 
-      puts "You didn't specify anything valid to override. Here are some examples:"
-      {
-        :view => ['pages/home', 'refinery/pages/home', '**/*menu', '_menu_branch'],
-        :javascript => %w(admin refinery/site_bar wymeditor**/{**/}*),
-        :stylesheet => %w(home refinery/site_bar),
-        :controller => %w(pages),
-        :model => %w(page refinery/page),
-        :helper => %w(site_bar refinery/site_bar_helper),
-        :presenter => %w(refinery/page_presenter)
-      }.each do |type, examples|
-        examples.each do |example|
-          puts "rake refinery:override #{type}=#{example}"
+      handle_invalid_override_input
+    end
+
+    desc "override_list", "lists files that you can override from any Refinery extension that you are using into your application"
+    def override_list(env)
+      OVERRIDES.keys.each do |kind|
+        which = env[kind.to_s] || (kind if env['type'] == kind.to_s)
+        if which.present? && @override_kind = OVERRIDES[kind]
+          matcher = [
+            "{refinery#{File::SEPARATOR},}", (which.presence || "**/*"), @override_kind[:glob]
+          ].flatten.join
+
+          puts find_relative_matches(matcher).sort.join("\n")
+          return
         end
       end
+
+      handle_invalid_override_list_input
     end
 
     desc "uncrudify", "shows you the code that your controller using crudify is running for a given action"
@@ -91,11 +95,11 @@ module Refinery
         abort "#{controller_class_name} is not defined"
       end
 
-      crud_lines = Refinery.roots(:'refinery/core').join('lib', 'refinery', 'crud.rb').read
+      crud_lines = Refinery.roots('refinery/core').join('lib', 'refinery', 'crud.rb').read
       if (matches = crud_lines.scan(/(\ +)(def #{action}.+?protected)/m).first).present? &&
          (method_lines = "#{matches.last.split(%r{^#{matches.first}end}).first.strip}\nend".split("\n")).many?
         indent = method_lines.second.index %r{[^ ]}
-        crud_method = method_lines.join("\n").gsub /^#{" " * indent}/, "  "
+        crud_method = method_lines.join("\n").gsub(/^#{" " * indent}/, "  ")
 
         crud_options = controller_class.try(:crudify_options) || {}
         crud_method.gsub! '#{options[:redirect_to_url]}', crud_options[:redirect_to_url].to_s
@@ -131,15 +135,46 @@ module Refinery
     end
 
     def find_matches(pattern)
-      Set.new source_paths.map {|path| Dir[path.join(pattern)] }.flatten
+      Set.new source_paths.map { |path| Dir[path.join(pattern)] }.flatten
     end
 
     def find_relative_matches(pattern)
-      find_matches(pattern).map {|match| strip_source_paths(match) }
+      find_matches(pattern).map { |match| strip_source_paths(match) }
     end
 
     def strip_source_paths(match)
       match.gsub Regexp.new(source_paths.join('\/?|')), ''
     end
+
+    def handle_invalid_override_input
+      puts "You didn't specify anything valid to override. Here are some examples:"
+      input_examples.each do |type, examples|
+        examples.each do |example|
+          puts "rake refinery:override #{type}=#{example}"
+        end
+      end
+    end
+
+    def handle_invalid_override_list_input
+      puts "You didn't specify a valid type to list overrides for.  Here are some examples:"
+      input_examples.each do |type, examples|
+        puts "\nrake refinery:override:list type=#{type}"
+        examples.each do |example|
+          puts "rake refinery:override:list #{type}=#{example}"
+        end
+      end
+    end
+
+    def input_examples
+      {
+        :view => ['pages/home', 'refinery/pages/home', 'layouts/application'],
+        :javascript => %w(admin refinery/site_bar refinery**/{**/}*),
+        :stylesheet => %w(home refinery/site_bar),
+        :controller => %w(pages),
+        :model => %w(page refinery/page),
+        :helper => %w(site_bar refinery/site_bar_helper),
+        :presenter => %w(refinery/page_presenter)
+      }.freeze
+    end
   end
 end

data/lib/refinery/core.rb

@@ -2,9 +2,11 @@ require File.expand_path('../../refinery', __FILE__)
 require 'truncate_html'
 require 'will_paginate'
 require 'refinery/i18n'
+require 'zilch/authorisation'
 
 module Refinery
   module Core
+    require 'refinery/core/default_route'
     require 'refinery/core/engine'
     require 'refinery/core/configuration'
 
@@ -20,3 +22,6 @@ end
 # see https://github.com/refinery/refinerycms/issues/2273
 require 'decorators'
 require 'jquery-rails'
+require 'jquery-ui-rails'
+require 'sass-rails'
+require 'coffee-rails'

data/lib/refinery/core/authorisation_adapter.rb

@@ -0,0 +1,11 @@
+module Refinery
+  module Core
+    class AuthorisationAdapter < Zilch::Authorisation::Adapters::Default
+
+      def current_user
+        @current_user ||= Refinery::Core::NilUser.new
+      end
+
+    end
+  end
+end

data/lib/refinery/core/authorisation_manager.rb

@@ -0,0 +1,14 @@
+require "zilch/authorisation/authorisation_manager"
+require "refinery/core/authorisation_adapter"
+
+module Refinery
+  module Core
+    class AuthorisationManager < Zilch::Authorisation::AuthorisationManager
+
+      def default_adapter
+        @default_adapter ||= Refinery::Core::AuthorisationAdapter.new
+      end
+
+    end
+  end
+end

data/lib/refinery/core/configuration.rb

@@ -4,11 +4,12 @@ module Refinery
 
     config_accessor :rescue_not_found, :s3_backend, :base_cache_key, :site_name,
                     :google_analytics_page_code, :authenticity_token_on_frontend,
-                    :dragonfly_secret,
-                    :wymeditor_whitelist_tags, :javascripts, :stylesheets,
+                    :dragonfly_secret, :javascripts, :stylesheets, :mounted_path,
                     :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
+                    :dragonfly_custom_backend_class, :dragonfly_custom_backend_opts,
+                    :visual_editor_javascripts, :visual_editor_stylesheets,
+                    :plugin_priority, :refinery_logout_path
 
     self.rescue_not_found = false
     self.s3_backend = false
@@ -17,7 +18,6 @@ module Refinery
     self.google_analytics_page_code = "UA-xxxxxx-x"
     self.authenticity_token_on_frontend = false
     self.dragonfly_secret = Array.new(24) { rand(256) }.pack('C*').unpack('H*').first
-    self.wymeditor_whitelist_tags = {}
     self.javascripts = []
     self.stylesheets = []
     self.s3_bucket_name = ENV['S3_BUCKET']
@@ -26,8 +26,12 @@ module Refinery
     self.s3_secret_access_key = ENV['S3_SECRET']
     self.force_ssl = false
     self.backend_route = "refinery"
+    self.mounted_path = "/"
     self.dragonfly_custom_backend_class = ''
     self.dragonfly_custom_backend_opts = {}
+    self.visual_editor_javascripts = []
+    self.visual_editor_stylesheets = []
+    self.plugin_priority = []
 
     def config.register_javascript(name)
       self.javascripts << name
@@ -37,12 +41,25 @@ module Refinery
       self.stylesheets << Stylesheet.new(*args)
     end
 
+    def config.register_visual_editor_javascript(name)
+      self.visual_editor_javascripts << name
+    end
+
+    def config.register_visual_editor_stylesheet(*args)
+      self.visual_editor_stylesheets << Stylesheet.new(*args)
+    end
+
     class << self
       def backend_route
         # prevent / at the start.
         config.backend_route.to_s.gsub(%r{\A/}, '')
       end
 
+      # See https://github.com/refinery/refinerycms/issues/2740
+      def backend_path
+        [mounted_path.gsub(%r{/\z}, ''), backend_route].join("/")
+      end
+
       def clear_javascripts!
         self.javascripts = []
       end
@@ -62,6 +79,10 @@ module Refinery
       def site_name
         ::I18n.t('site_name', :scope => 'refinery.core.config', :default => config.site_name)
       end
+
+      def wymeditor_whitelist_tags=(tags)
+        raise "Please ensure refinerycms-wymeditor is being used and use Refinery::Wymeditor.whitelist_tags instead of Refinery::Core.wymeditor_whitelist_tags"
+      end
     end
 
     # wrapper for stylesheet registration

data/lib/refinery/core/default_route.rb

@@ -0,0 +1,16 @@
+module Refinery
+  module Core
+    class DefaultRoute
+
+      class << self
+        def load
+          Refinery::Core::Engine.routes.draw do
+            namespace :admin, :path => Refinery::Core.backend_route do
+              root :to => ::Refinery::Plugins.registered.in_menu.first.url
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/refinery/core/engine.rb

@@ -7,31 +7,31 @@ module Refinery
       engine_name :refinery
 
       class << self
-        # 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
         # 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)
+          before_inclusion_procs.each(&:call).tap do |c|
+            c.clear if Rails.application.config.cache_classes
+          end
 
           Refinery.include_once(::ApplicationController, Refinery::ApplicationController)
           ::ApplicationController.send :helper, Refinery::Core::Engine.helpers
 
-          after_inclusion_procs.each(&:call)
+          after_inclusion_procs.each(&:call).tap do |c|
+            c.clear if Rails.application.config.cache_classes
+          end
+
+          # Register all decorators from app/decorators/ and registered plugins' paths.
+          Decorators.register! Rails.root, Refinery::Plugins.registered.pathnames
         end
       end
 
       config.autoload_paths += %W( #{config.root}/lib )
 
       # Include the refinery controllers and helpers dynamically
-      config.to_prepare &method(:refinery_inclusion!).to_proc
-
-      after_inclusion &method(:register_decorators!).to_proc
+      config.to_prepare(&method(:refinery_inclusion!).to_proc)
 
       # Wrap errors in spans
       config.to_prepare do
@@ -44,7 +44,7 @@ module Refinery
         WillPaginate.per_page = 20
       end
 
-      initializer "register refinery_core plugin" do
+      before_inclusion do
         Refinery::Plugin.register do |plugin|
           plugin.pathname = root
           plugin.name = 'refinery_core'
@@ -53,9 +53,7 @@ module Refinery
           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'
@@ -75,21 +73,42 @@ module Refinery
         app.config.autoload_paths += [
           Rails.root.join('app', 'presenters'),
           Rails.root.join('vendor', '**', '**', 'app', 'presenters'),
-          Refinery.roots.map{|r| r.join('**', 'app', 'presenters')}
+          Refinery.roots.map{ |r| r.join('**', 'app', 'presenters')}
         ].flatten
       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",
-          "admin.js"
-        ]
+      # set assets to be precompiled
+      config.to_prepare do
+
+        # scripts
+        Rails.application.config.assets.precompile += %w(
+          refinery/*.js
+          refinery/icons/*
+          modernizr-min.js
+          admin.js
+        )
+
+        # stylesheets
+        Rails.application.config.assets.precompile += %w(
+          refinery/refinery.css
+          refinery/formatting.css
+          refinery/site_bar.css
+          refinery/theme.css
+        )
+
+        # images
+        Rails.application.config.assets.precompile += %w(
+          refinery/images/*
+        )
+
+        # fonts
+        Rails.application.config.assets.precompile += %w(
+          font-awesome/fontawesome-webfont.eot
+          font-awesome/fontawesome-webfont.woff2
+          font-awesome/fontawesome-webfont.woff
+          font-awesome/fontawesome-webfont.ttf
+          font-awesome/fontawesome-webfont.svg
+        )
       end
 
       # active model fields which may contain sensitive data to filter

data/lib/refinery/core/nil_user.rb

@@ -0,0 +1,42 @@
+require 'zilch/authorisation/nil_user'
+require 'refinery/plugins'
+
+module Refinery
+  module Core
+    class NilUser < Zilch::Authorisation::NilUser
+      # The default NilUser has all roles and can access all plugins.
+      # Should be overridden in authentication solutions.
+      def has_role?(role)
+        true
+      end
+
+      # Returns all plugins that the user has access to, that are currently
+      # loaded in the system.
+      # For NilUser, this returns all registered plugins.
+      # Should be overridden in authentication solutions
+      def active_plugins
+        Refinery::Plugins.registered
+      end
+
+      # Returns all registered plugins.
+      # Should be overridden in authentication solutions.
+      def plugins
+        Refinery::Plugins.registered
+      end
+
+      # Returns true.
+      # Should be overridden in authentication solutions.
+      # A real solution might be: `Refinery::Plugins.active.names.include?(name)`
+      def has_plugin?(name)
+        true
+      end
+
+      # Returns a URL to the first plugin with a URL in the menu. Used for
+      # admin users' root admin url.
+      # Should be overridden in authentication solutions.
+      def landing_url
+        active_plugins.first_url_in_menu
+      end
+    end
+  end
+end

data/lib/refinery/crud.rb

@@ -34,7 +34,6 @@ module Refinery
         :search_conditions => '',
         :sortable => true,
         :title_attribute => "title",
-        :xhr_paging => false,
         :class_name => class_name,
         :singular_name => singular_name,
         :plural_name => plural_name
@@ -50,6 +49,7 @@ module Refinery
 
       def crudify(model_name, options = {})
         options = ::Refinery::Crud.default_options(model_name).merge(options)
+        Refinery.deprecate :xhr_paging, when: '3.1' if options[:xhr_paging]
         class_name = options[:class_name]
         singular_name = options[:singular_name]
         plural_name = options[:plural_name]
@@ -59,16 +59,16 @@ module Refinery
             #{options.inspect}
           end
 
-          prepend_before_filter :find_#{singular_name},
+          prepend_before_action :find_#{singular_name},
                                 :only => [:update, :destroy, :edit, :show]
-          prepend_before_filter :merge_position_into_params!, :only => :create
+          prepend_before_action :merge_position_into_params!, :only => :create
 
           def new
             @#{singular_name} = #{class_name}.new
           end
 
           def create
-            if (@#{singular_name} = #{class_name}.create(params[:#{singular_name}])).valid?
+            if (@#{singular_name} = #{class_name}.create(#{singular_name}_params)).valid?
               flash.notice = t(
                 'refinery.crudify.created',
                 :what => "'\#{@#{singular_name}.#{options[:title_attribute]}}'"
@@ -85,7 +85,7 @@ module Refinery
           end
 
           def update
-            if @#{singular_name}.update_attributes(params[:#{singular_name}])
+            if @#{singular_name}.update_attributes(#{singular_name}_params)
               flash.notice = t(
                 'refinery.crudify.updated',
                 :what => "'\#{@#{singular_name}.#{options[:title_attribute]}}'"
@@ -109,24 +109,29 @@ module Refinery
 
           # 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})
+            @#{singular_name} = find_#{singular_name}_scope.find(params[:id])
+          end
+
+          def find_#{singular_name}_scope
+            _finder_scope = #{class_name}.includes(#{options[:include].map(&:to_sym).inspect})
+            _finder_scope = _finder_scope.friendly if _finder_scope.respond_to?(:friendly)
+            _finder_scope
           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]}")
+            @#{plural_name} = find_#{singular_name}_scope
+                                .where(conditions)
+                                .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)
+                position: ((#{class_name}.where(#{options[:conditions].inspect}).maximum(:position)||-1) + 1)
               })
             end
           end
@@ -204,14 +209,20 @@ module Refinery
             @#{plural_name} = @#{plural_name}.with_query(params[:search])
           end
 
+          def #{singular_name}_params
+            raise "Please override #{singular_name}_params with your desired parameter security."
+          end
+
           # Ensure all methods are protected so that they should only be called
           # from within the current controller.
           protected :find_#{singular_name},
+                    :find_#{singular_name}_scope,
                     :find_all_#{plural_name},
                     :paginate_all_#{plural_name},
                     :paginate_per_page,
                     :render_partial_response?,
                     :search_all_#{plural_name},
+                    :#{singular_name}_params,
                     :redirect_url,
                     :create_or_update_successful,
                     :create_or_update_unsuccessful,
@@ -220,7 +231,7 @@ module Refinery
 
         # Methods that are only included when this controller is searchable.
         if options[:searchable]
-          if options[:paging] || options[:xhr_paging]
+          if options[:paging]
             module_eval %(
               def index
                 search_all_#{plural_name} if searching?
@@ -232,10 +243,10 @@ module Refinery
           else
             module_eval %(
               def index
-                unless searching?
-                  find_all_#{plural_name}
-                else
+                if searching?
                   search_all_#{plural_name}
+                else
+                  find_all_#{plural_name}
                 end
 
                 render_partial_response?
@@ -244,7 +255,7 @@ module Refinery
           end
 
         else
-          if options[:paging] || options[:xhr_paging]
+          if options[:paging]
             module_eval %(
               def index
                 paginate_all_#{plural_name}
@@ -269,22 +280,22 @@ module Refinery
               find_all_#{plural_name}
             end
 
-            # Based upon http://github.com/matenia/jQuery-Awesome-Nested-Set-Drag-and-Drop
+            # Based upon https://github.com/matenia/jQuery-Awesome-Nested-Set-Drag-and-Drop
             def update_positions
               previous = nil
               params[:ul].each do |_, list|
                 list.each do |index, hash|
-                  moved_item_id = hash['id'][/\\d+$/]
+                  moved_item_id = hash['id'][/\\d+\\z/]
                   @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
+                    elsif !@current_#{singular_name}.root?
                       @current_#{singular_name}.move_to_root
                     end
                   else
-                    @current_#{singular_name}.update_attributes :position => index
+                    @current_#{singular_name}.update_columns position: index
                   end
 
                   if hash['children'].present?
@@ -302,10 +313,14 @@ module Refinery
 
             def update_child_positions(_node, #{singular_name})
               list = _node['children']['0']
-              list.sort_by {|k, v| k.to_i}.map { |item| item[1] }.each_with_index do |child, index|
+              child_positions_changed = false
+              list.sort_by { |k, v| k.to_i}.map { |item| item[1] }.each_with_index do |child, index|
                 child_id = child['id'].split(/#{singular_name}\_?/).reject(&:empty?).first
                 child_#{singular_name} = #{class_name}.where(:id => child_id).first
-                child_#{singular_name}.move_to_child_of(#{singular_name})
+                child_positions_changed ||= #{singular_name}.children[index] != child_#{singular_name}
+                if child_positions_changed
+                  child_#{singular_name}.move_to_child_of(#{singular_name})
+                end
 
                 if child['children'].present?
                   update_child_positions(child, child_#{singular_name})
@@ -324,20 +339,16 @@ module Refinery
         module_eval %(
           class << self
             def pageable?
-              #{options[:paging].to_s} || #{options[:xhr_paging].to_s}
+              #{options[:paging]}
             end
             alias_method :paging?, :pageable?
 
-            def xhr_pageable?
-              #{options[:xhr_paging].to_s}
-            end
-
             def sortable?
-              #{options[:sortable].to_s}
+              #{options[:sortable]}
             end
 
             def searchable?
-              #{options[:searchable].to_s}
+              #{options[:searchable]}
             end
           end
         )