refinerycms-pages 2.1.5 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7ca74af9b5248a8313eba585323664f7421241c9
-  data.tar.gz: a6940067a4a5686a4045cea92e156185cb2ba370
+  metadata.gz: 2bdcbfb6ced22f015c509108b4cdf43b28a2fb99
+  data.tar.gz: f1c3faf991e0c23fa346ed0461d5cf3759139bb0
 SHA512:
-  metadata.gz: a2b2acb0803208475af177019dc732e90ab5c29c6ea16ba8113bfe8c972f2b2918bed991de0bfbdec5c1b16dbb54b04b6c58ffb17f7cda8d38dc515f3216bdee
-  data.tar.gz: fd54a6aaad887e98d79ce2485ba77d53294b7f7397cb2ee2be1da52182c05ce5ef35b80a0f93a01edc1fb86a690b7153b9f5627fd273828f1dc3d87efb0fc93b
+  metadata.gz: 7dbd0c97774895a794dd88fd3114f8d601ebfca7de61771b9b60714b7614a4482511bf4e123da675eac832802c222a1539013c46806dd86ea575e7cbebfe102b
+  data.tar.gz: fd285907905d48ccbeaaacbebe163f5d101d25b5198c347ba2a427ee9c123d1541f362afeb8d2eb42ab0a6c97ca1baf6aa8511adababa9e0bdddf42522b63f54

data/app/controllers/refinery/admin/page_parts_controller.rb

@@ -4,7 +4,7 @@ module Refinery
 
       def new
         render :partial => '/refinery/admin/pages/page_part_field', :locals => {
-                 :part => ::Refinery::PagePart.new(:title => params[:title], :body => params[:body]),
+                 :part => ::Refinery::PagePart.new(new_page_part_params),
                  :new_part => true,
                  :part_index => params[:part_index]
                }
@@ -21,6 +21,11 @@ module Refinery
         end
       end
 
+      protected
+        def new_page_part_params
+          params.permit(:title, :slug, :body)
+        end
+
     end
   end
 end

data/app/controllers/refinery/admin/pages_controller.rb

@@ -1,22 +1,18 @@
 module Refinery
   module Admin
     class PagesController < Refinery::AdminController
-      include Pages::InstanceMethods
-      cache_sweeper Pages::PageSweeper
+      prepend Pages::InstanceMethods
 
       crudify :'refinery/page',
-              :order => "lft ASC",
               :include => [:translations, :children],
               :paging => false
 
-      before_filter :load_valid_templates, :only => [:edit, :new, :create]
-      before_filter :restrict_access, :only => [:create, :update, :update_positions, :destroy]
-      after_filter proc { Pages::Caching.new().expire! }, :only => :update_positions
+      helper_method :valid_layout_templates, :valid_view_templates
 
       def new
-        @page = Page.new(params.except(:controller, :action, :switch_locale))
+        @page = Page.new(new_page_params)
         Pages.default_parts_for(@page).each_with_index do |page_part, index|
-          @page.parts << PagePart.new(:title => page_part, :position => index)
+          @page.parts << PagePart.new(:title => page_part, :slug => page_part, :position => index)
         end
       end
 
@@ -26,43 +22,38 @@ module Refinery
       end
 
       def update
-        if @page.update_attributes(params[:page])
-          flash.notice = t(
-            'refinery.crudify.updated',
-            :what => "'#{@page.title}'"
-          )
-
-          unless from_dialog?
-            unless params[:continue_editing] =~ /true|on|1/
-              redirect_back_or_default(refinery.admin_pages_path)
-            else
-              unless request.xhr?
-                redirect_to :back
-              else
-                render :partial => 'save_and_continue_callback', :locals => {
-                  :new_refinery_page_path => refinery.admin_page_path(@page.nested_url),
-                  :new_page_path => refinery.pages_admin_preview_page_path(@page.nested_url)
-                }
-              end
-            end
-          else
+        if @page.update_attributes(page_params)
+          flash.notice = t('refinery.crudify.updated', what: "'#{@page.title}'")
+
+          if from_dialog?
             self.index
             @dialog_successful = true
             render :index
+          else
+            if params[:continue_editing] =~ /true|on|1/
+              if request.xhr?
+                render partial: 'save_and_continue_callback',
+                       locals: save_and_continue_locals(@page)
+              else
+                redirect_to :back
+              end
+            else
+              redirect_back_or_default(refinery.admin_pages_path)
+            end
           end
         else
-          unless request.xhr?
-            render :action => 'edit'
-          else
+          if request.xhr?
             render :partial => '/refinery/admin/error_messages', :locals => {
               :object => @page,
               :include_object_name => true
             }
+          else
+            render 'edit'
           end
         end
       end
 
-    protected
+      protected
 
       def after_update_positions
         find_all_pages
@@ -70,12 +61,12 @@ module Refinery
       end
 
       def find_page
-        @page = Page.find_by_path_or_id(params[:path], params[:id])
+        @page = Page.find_by_path_or_id!(params[:path], params[:id])
       end
       alias_method :page, :find_page
 
       # We can safely assume ::Refinery::I18n is defined because this method only gets
-      # Invoked when the before_filter from the plugin is run.
+      # Invoked when the before_action from the plugin is run.
       def globalize!
         return super unless action_name.to_s == 'index'
 
@@ -87,23 +78,40 @@ module Refinery
         end
       end
 
-      def load_valid_templates
-        @valid_layout_templates = Pages.layout_template_whitelist &
-                                  Pages.valid_templates('app', 'views', '{layouts,refinery/layouts}', '*html*')
+      def valid_layout_templates
+        Pages.layout_template_whitelist & Pages.valid_templates(*Pages.layout_templates_pattern)
+      end
+
+      def valid_view_templates
+        Pages.valid_templates(*Pages.view_templates_pattern)
+      end
 
-        @valid_view_templates = Pages.valid_templates('app', 'views', '{pages,refinery/pages}', '*html*')
+      def page_params
+        params.require(:page).permit(permitted_page_params)
       end
 
-      def restrict_access
-        if current_refinery_user.has_role?(:translator) && !current_refinery_user.has_role?(:superuser) &&
-             (params[:switch_locale].blank? || params[:switch_locale] == Refinery::I18n.default_frontend_locale.to_s)
-          flash[:error] = t('translator_access', :scope => 'refinery.admin.pages')
-          redirect_to refinery.admin_pages_path
-        end
+      def new_page_params
+        params.permit(:parent_id, :view_template, :layout_template)
+      end
+
+      private
 
-        return true
+      def permitted_page_params
+        [
+          :browser_title, :draft, :link_url, :menu_title, :meta_description,
+          :parent_id, :skip_to_first_child, :show_in_menu, :title, :view_template,
+          :layout_template, :custom_slug, parts_attributes: [:id, :title, :slug, :body, :position]
+        ]
       end
 
+      def save_and_continue_locals(page)
+        nested_url = page.nested_url
+        {
+          new_refinery_edit_page_path: refinery.admin_edit_page_path(nested_url),
+          new_refinery_page_path: refinery.admin_page_path(nested_url),
+          new_page_path: refinery.pages_admin_preview_page_path(nested_url)
+        }
+      end
     end
   end
 end

data/app/controllers/refinery/pages/admin/preview_controller.rb

@@ -8,7 +8,7 @@ module Refinery
         include Refinery::Admin::BaseController
         include Pages::RenderOptions
 
-        skip_before_filter :error_404, :set_canonical
+        skip_before_action :error_404, :set_canonical
 
         layout :layout
 
@@ -17,6 +17,7 @@ module Refinery
         end
 
         protected
+
         def admin?
           false
         end
@@ -24,10 +25,10 @@ module Refinery
         def find_page
           if @page = Refinery::Page.find_by_path_or_id(params[:path], params[:id])
             # Preview existing pages
-            @page.attributes = params[:page]
+            @page.attributes = page_params
           elsif params[:page]
             # Preview a non-persisted page
-            @page = Page.new params[:page]
+            @page = Page.new page_params
           end
         end
         alias_method :page, :find_page
@@ -35,6 +36,14 @@ module Refinery
         def layout
           'application'
         end
+
+        def page_params
+          params.require(:page).permit(
+            :browser_title, :draft, :link_url, :menu_title, :meta_description,
+            :parent_id, :skip_to_first_child, :show_in_menu, :title, :view_template,
+            :layout_template, parts_attributes: [:id, :title, :body, :position]
+          )
+        end
       end
     end
   end

data/app/controllers/refinery/pages_controller.rb

@@ -2,11 +2,11 @@ module Refinery
   class PagesController < ::ApplicationController
     include Pages::RenderOptions
 
-    before_filter :find_page, :set_canonical
-    before_filter :error_404, :unless => :current_user_can_view_page?
+    before_action :find_page, :set_canonical
+    before_action :error_404, :unless => :current_user_can_view_page?
 
     # Save whole Page after delivery
-    after_filter :write_cache?
+    after_action :write_cache?
 
     # This action is usually accessed with the root path, normally '/'
     def home
@@ -53,15 +53,14 @@ module Refinery
     end
 
     def should_redirect_to_friendly_url?
-      requested_friendly_id != page.friendly_id || ::Refinery::Pages.scope_slug_by_parent && params[:path].present? && params[:path].match(page.root.slug).nil?
+      requested_friendly_id != page.friendly_id || (
+        ::Refinery::Pages.scope_slug_by_parent &&
+        params[:path].present? && params[:path].match(page.root.slug).nil?
+      )
     end
 
     def current_user_can_view_page?
-      page.live? || current_refinery_user_can_access?("refinery_pages")
-    end
-
-    def current_refinery_user_can_access?(plugin)
-      refinery_user? && current_refinery_user.authorized_plugins.include?(plugin)
+      page.live? || authorisation_manager.allow?(:plugin, "refinery_pages")
     end
 
     def first_live_child
@@ -71,9 +70,9 @@ module Refinery
     def find_page(fallback_to_404 = true)
       @page ||= case action_name
                 when "home"
-                  Refinery::Page.where(:link_url => '/').first
+                  Refinery::Page.find_by(link_url: '/')
                 when "show"
-                  Refinery::Page.find_by_path_or_id(params[:path], params[:id])
+                  Refinery::Page.friendly.find_by_path_or_id(params[:path], params[:id])
                 end
       @page || (error_404 if fallback_to_404)
     end
@@ -85,7 +84,8 @@ module Refinery
     end
 
     def write_cache?
-      if Refinery::Pages.cache_pages_full && !refinery_user?
+      # Don't cache the page with the site bar showing.
+      if Refinery::Pages.cache_pages_full && !authorisation_manager.allow?(:read, :site_bar)
         cache_page(response.body, File.join('', 'refinery', 'cache', 'pages', request.path).to_s)
       end
     end

data/app/helpers/refinery/admin/pages_helper.rb

@@ -3,12 +3,12 @@ module Refinery
     module PagesHelper
       def parent_id_nested_set_options(current_page)
         pages = []
-        nested_set_options(::Refinery::Page, current_page) {|page| pages << page}
+        nested_set_options(::Refinery::Page, current_page) { |page| pages << page}
         # page.title needs the :translations association, doing something like
         # nested_set_options(::Refinery::Page.includes(:translations), page) doesn't work, yet.
         # See https://github.com/collectiveidea/awesome_nested_set/pull/123
-        ActiveRecord::Associations::Preloader.new(pages, :translations).run
-        pages.map {|page| ["#{'-' * page.level} #{page.title}", page.id]}
+        ActiveRecord::Associations::Preloader.new.preload(pages, :translations)
+        pages.map { |page| ["#{'-' * page.level} #{page.title}", page.id]}
       end
 
       def template_options(template_type, current_page)
@@ -50,8 +50,9 @@ module Refinery
       # We show the title from the next available locale
       # if there is no title for the current locale
       def page_title_with_translations(page)
-        page.title.presence || page.translations.detect {|t| t.title.present?}.title
+        page.title.presence || page.translations.detect { |t| t.title.present?}.title
       end
+
     end
   end
 end

data/app/helpers/refinery/pages/content_pages_helper.rb

@@ -18,9 +18,14 @@ module Refinery
       # so avoid common layout names such as :header, :footer, etc.
       def render_content_presenter(content_page, options = {})
         content_page.hide_sections(options[:hide_sections]) if options[:hide_sections]
-        content_page.fetch_template_overrides {|section_id| content_for(section_id)}
+        content_page.fetch_template_overrides { |section_id| content_for(section_id)}
         content_page.to_html(options[:can_use_fallback])
       end
+
+      # Compiles the default menu.
+      def refinery_menu_pages
+        Refinery::Menu.new Refinery::Page.fast_menu
+      end
     end
   end
 end

data/app/models/refinery/page.rb

@@ -2,6 +2,7 @@
 require 'friendly_id'
 require 'refinery/core/base_model'
 require 'refinery/pages/url'
+require 'refinery/pages/finder'
 
 module Refinery
   class Page < Core::BaseModel
@@ -11,18 +12,35 @@ module Refinery
 
     class Translation
       is_seo_meta
-      attr_accessible *::SeoMeta.attributes.keys, :locale
+
+      def self.seo_fields
+        ::SeoMeta.attributes.keys.map{ |a| [a, :"#{a}="]}.flatten
+      end
     end
 
-    # Delegate SEO Attributes to globalize translation
-    seo_fields = ::SeoMeta.attributes.keys.map{|a| [a, :"#{a}="]}.flatten
-    delegate(*(seo_fields << {:to => :translation}))
+    class FriendlyIdOptions
+      def self.options
+        # Docs for friendly_id https://github.com/norman/friendly_id
+        friendly_id_options = {
+          use: [:reserved],
+          reserved_words: Refinery::Pages.friendly_id_reserved_words
+        }
+        if ::Refinery::Pages.scope_slug_by_parent
+          friendly_id_options[:use] << :scoped
+          friendly_id_options.merge!(scope: :parent)
+        end
+        friendly_id_options[:use] << :globalize
+        friendly_id_options
+      end
+    end
 
-    attr_accessible :id, :deletable, :link_url, :menu_match,
-                    :skip_to_first_child, :position, :show_in_menu, :draft,
-                    :parts_attributes, :parent_id, :menu_title, :page_id,
-                    :layout_template, :view_template, :custom_slug, :slug,
-                    :title, *::SeoMeta.attributes.keys
+    # If title changes tell friendly_id to regenerate slug when saving record
+    def should_generate_new_friendly_id?
+      changes.keys.include?("title") || changes.keys.include?("custom_slug")
+    end
+
+    # Delegate SEO Attributes to globalize translation
+    delegate(*(Translation.seo_fields << {:to => :translation}))
 
     validates :title, :presence => true
 
@@ -32,30 +50,19 @@ module Refinery
     # rather than :delete_all we want :destroy
     acts_as_nested_set :dependent => :destroy
 
-    # Docs for friendly_id http://github.com/norman/friendly_id
-    friendly_id_options = {:use => [:reserved, :globalize], :reserved_words => %w(index new session login logout users refinery admin images wymiframe)}
-    if ::Refinery::Pages.scope_slug_by_parent
-      friendly_id_options[:use] << :scoped
-      friendly_id_options.merge!(:scope => :parent)
-    end
-
-    friendly_id :custom_slug_or_title, friendly_id_options
+    friendly_id :custom_slug_or_title, FriendlyIdOptions.options
 
-    has_many :parts,
-             :foreign_key => :refinery_page_id,
+    has_many :parts, -> {
+      scope = order('position ASC')
+      scope = scope.includes(:translations) if ::Refinery::PagePart.respond_to?(:translation_class)
+      scope
+    },       :foreign_key => :refinery_page_id,
              :class_name => '::Refinery::PagePart',
-             :order => 'position ASC',
              :inverse_of => :page,
-             :dependent => :destroy,
-             :include => ((:translations) if ::Refinery::PagePart.respond_to?(:translation_class))
+             :dependent => :destroy
 
     accepts_nested_attributes_for :parts, :allow_destroy => true
 
-    before_save do |m|
-      m.translation.globalized_model = self
-      m.translation.save if m.translation.new_record?
-    end
-    before_create :ensure_locale!
     before_destroy :deletable?
     after_save :reposition_parts!
 
@@ -68,36 +75,27 @@ module Refinery
 
       # Find page by path, checking for scoping rules
       def find_by_path(path)
-        if ::Refinery::Pages.scope_slug_by_parent
-          # With slugs scoped to the parent page we need to find a page by its full path.
-          # For example with about/example we would need to find 'about' and then its child
-          # called 'example' otherwise it may clash with another page called /example.
-          path = path.split('/').select(&:present?)
-          page = by_slug(path.shift, :parent_id => nil).first
-          while page && path.any? do
-            slug_or_id = path.shift
-            page = page.children.by_slug(slug_or_id).first || page.children.find(slug_or_id)
-          end
-        else
-          page = by_slug(path).first
-        end
-
-        page
+        Pages::Finder.by_path(path)
       end
 
       # Helps to resolve the situation where you have a path and an id
       # and if the path is unfriendly then a different finder method is required
       # than find_by_path.
       def find_by_path_or_id(path, id)
-        if path.present?
-          if path.friendly_id?
-            find_by_path(path)
-          else
-            find(path)
-          end
-        elsif id.present?
-          find(id)
-        end
+        Pages::Finder.by_path_or_id(path, id)
+      end
+
+      # Helps to resolve the situation where you have a path and an id
+      # and if the path is unfriendly then a different finder method is required
+      # than find_by_path.
+      #
+      # raise ActiveRecord::RecordNotFound if not found.
+      def find_by_path_or_id!(path, id)
+        page = find_by_path_or_id(path, id)
+
+        raise ActiveRecord::RecordNotFound unless page
+
+        page
       end
 
       # Finds pages by their title.  This method is necessary because pages
@@ -105,18 +103,15 @@ module Refinery
       # pages table thus requiring us to find the attribute on the translations table
       # and then join to the pages table again to return the associated record.
       def by_title(title)
-        with_globalize(:title => title)
+        Pages::Finder.by_title(title)
       end
 
       # Finds pages by their slug.  This method is necessary because pages
       # are translated which means the slug attribute does not exist on the
       # pages table thus requiring us to find the attribute on the translations table
       # and then join to the pages table again to return the associated record.
-      def by_slug(slug, conditions={})
-        with_globalize({
-          :locale => Refinery::I18n.frontend_locales.map(&:to_s),
-          :slug => slug
-        }.merge(conditions))
+      def by_slug(slug, conditions = {})
+        Pages::Finder.by_slug(slug, conditions)
       end
 
       # Shows all pages with :show_in_menu set to true, but it also
@@ -134,19 +129,7 @@ module Refinery
 
       # Wrap up the logic of finding the pages based on the translations table.
       def with_globalize(conditions = {})
-        conditions = {:locale => ::Globalize.locale.to_s}.merge(conditions)
-        translations_conditions = {}
-        translated_attrs = translated_attribute_names.map(&:to_s) | %w(locale)
-
-        conditions.keys.each do |key|
-          if translated_attrs.include? key.to_s
-            translations_conditions["#{self.translation_class.table_name}.#{key}"] = conditions.delete(key)
-          end
-        end
-
-        # A join implies readonly which we don't really want.
-        where(conditions).joins(:translations).where(translations_conditions).
-                                               readonly(false)
+        Pages::Finder.with_globalize(conditions)
       end
 
       # Returns how many pages per page should there be when paginating pages
@@ -161,6 +144,7 @@ module Refinery
       alias_method_chain :rebuild!, :slug_nullification
 
       protected
+
       def nullify_duplicate_slugs_under_the_same_parent!
         t_slug = translation_class.arel_table[:slug]
         joins(:translations).group(:locale, :parent_id, t_slug).having(t_slug.count.gt(1)).count.
@@ -174,7 +158,7 @@ module Refinery
     end
 
     def translated_to_default_locale?
-      persisted? && translations.where(:locale => Refinery::I18n.default_frontend_locale).any?
+      persisted? && translations.any?{ |t| t.locale == Refinery::I18n.default_frontend_locale}
     end
 
     # The canonical page for this particular page.
@@ -193,7 +177,8 @@ module Refinery
     # Returns in cascading order: custom_slug or menu_title or title depending on
     # which attribute is first found to be present for this page.
     def custom_slug_or_title
-      custom_slug.presence || menu_title.presence || title.presence
+      (Refinery::Pages.use_custom_slugs && custom_slug.presence) ||
+        menu_title.presence || title.presence
     end
 
     # Am I allowed to delete this page?
@@ -207,7 +192,7 @@ module Refinery
     # This ensures that they are in the correct 0,1,2,3,4... etc order.
     def reposition_parts!
       reload.parts.each_with_index do |part, index|
-        part.update_attributes :position => index
+        part.update_columns position: index
       end
     end
 
@@ -223,56 +208,32 @@ module Refinery
 
     # If you want to destroy a page that is set to be not deletable this is the way to do it.
     def destroy!
-      self.menu_match = nil
-      self.link_url = nil
-      self.deletable = true
+      self.update_attributes(:menu_match => nil, :link_url => nil, :deletable => true)
 
-      destroy
+      self.destroy
     end
 
-    # Used for the browser title to get the full path to this page
-    # It automatically prints out this page title and all of it's parent page titles joined by a PATH_SEPARATOR
-    def path(options = {})
-      # Override default options with any supplied.
-      options = {:reversed => true}.merge(options)
+    # Returns the full path to this page.
+    # This automatically prints out this page title and all parent page titles.
+    # The result is joined by the path_separator argument.
+    def path(path_separator: ' - ', ancestors_first: true)
+      return title if root?
 
-      if parent_id
-        parts = [title, parent.path(options)]
-        parts.reverse! if options[:reversed]
-        parts.join(' - ')
-      else
-        title
-      end
+      chain = ancestors_first ? self_and_ancestors : self_and_ancestors.reverse
+      chain.map(&:title).join(path_separator)
     end
 
     def url
       Pages::Url.build(self)
     end
 
-    def link_url_localised?
-      Refinery.deprecate "Refinery::Page#link_url_localised?", :when => '2.2',
-                         :replacement => "Refinery::Pages::Url::Localised#url"
-      Pages::Url::Localised.new(self).url
-    end
-
-    def url_normal
-      Refinery.deprecate "Refinery::Page#url_normal", :when => '2.2',
-                         :replacement => "Refinery::Pages::Url::Normal#url"
-      Pages::Url::Normal.new(self).url
-    end
-
-    def url_marketable
-      Refinery.deprecate "Refinery::Page#url_marketable", :when => '2.2',
-                         :replacement => "Refinery::Pages::Url::Marketable#url"
-      Pages::Url::Marketable.new(self).url
-    end
-
     def nested_url
-      globalized_slug = Globalize.with_locale(slug_locale) { to_param.to_s }
-      if ::Refinery::Pages.scope_slug_by_parent
-        [parent.try(:nested_url), globalized_slug].compact.flatten
-      else
-        [globalized_slug]
+      Globalize.with_locale(slug_locale) do
+        if ::Refinery::Pages.scope_slug_by_parent && !root?
+          self_and_ancestors.includes(:translations).map(&:to_param)
+        else
+          [to_param.to_s]
+        end
       end
     end
 
@@ -330,8 +291,8 @@ module Refinery
     #    ::Refinery::Page.first.content_for(:body)
     #
     # Will return the body page part of the first page.
-    def content_for(part_title)
-      part_with_title(part_title).try(:body)
+    def content_for(part_slug)
+      part_with_slug(part_slug).try(:body)
     end
 
     # Accessor method to test whether a page part
@@ -341,34 +302,27 @@ module Refinery
     #   ::Refinery::Page.first.content_for?(:body)
     #
     # Will return true if the page has a body page part and it is not blank.
-    def content_for?(part_title)
-      content_for(part_title).present?
+    def content_for?(part_slug)
+      content_for(part_slug).present?
     end
 
     # Accessor method to get a page part object from a page.
     # Example:
     #
-    #    ::Refinery::Page.first.part_with_title(:body)
+    #    ::Refinery::Page.first.part_with_slug(:body)
     #
-    # Will return the Refinery::PagePart object with that title using the first page.
-    def part_with_title(part_title)
+    # Will return the Refinery::PagePart object with that slug using the first page.
+    def part_with_slug(part_slug)
       # self.parts is usually already eager loaded so we can now just grab
       # the first element matching the title we specified.
       self.parts.detect do |part|
-        part.title.present? and # protecting against the problem that occurs when have nil title
-        part.title == part_title.to_s or
-        part.title.downcase.gsub(" ", "_") == part_title.to_s.downcase.gsub(" ", "_")
+        part.slug_matches?(part_slug)
       end
     end
 
-  private
-
-    # Make sures that a translation exists for this page.
-    # The translation is set to the default frontend locale.
-    def ensure_locale!
-      if self.translations.empty?
-        self.translations.build(:locale => Refinery::I18n.default_frontend_locale)
-      end
+    def part_with_title(part_title)
+      Refinery.deprecate("Refinery::Page#part_with_title", when: "3.1", replacement: "part_with_slug")
+      part_with_slug(part_title.to_s.parameterize.underscore)
     end
 
     # Protects generated slugs from title if they are in the list of reserved words
@@ -377,21 +331,41 @@ module Refinery
     # Also check for global scoping, and if enabled, allow slashes in slug.
     #
     # Returns the sluggified string
-    def normalize_friendly_id_with_marketable_urls(slug_string)
-      # If we are scoping by parent, no slashes are allowed. Otherwise, slug is potentially
-      # a custom slug that contains a custom route to the page.
-      if !Pages.scope_slug_by_parent && slug_string.include?('/')
-        slug_string.sub!(%r{^/*}, '').sub!(%r{/*$}, '') # Remove leading and trailing slashes, but allow internal
-        slug_string.split('/').select(&:present?).map {|s| normalize_friendly_id_with_marketable_urls(s) }.join('/')
-      else
+    def normalize_friendly_id(slug_string)
+      FriendlyIdPath.normalize_friendly_id(slug_string)
+    end
+
+    private
+
+    class FriendlyIdPath
+      def self.normalize_friendly_id_path(slug_string)
+        # Remove leading and trailing slashes, but allow internal
+        slug_string
+          .sub(%r{^/*}, '')
+          .sub(%r{/*$}, '')
+          .split('/')
+          .select(&:present?)
+          .map { |slug| self.normalize_friendly_id(slug) }.join('/')
+      end
+
+      def self.normalize_friendly_id(slug_string)
+        # If we are scoping by parent, no slashes are allowed. Otherwise, slug is
+        # potentially a custom slug that contains a custom route to the page.
+        if !Pages.scope_slug_by_parent && slug_string.include?('/')
+          self.normalize_friendly_id_path(slug_string)
+        else
+          self.protected_slug_string(slug_string)
+        end
+      end
+
+      def self.protected_slug_string(slug_string)
         sluggified = slug_string.to_slug.normalize!
-        if Pages.marketable_urls && self.class.friendly_id_config.reserved_words.include?(sluggified)
+        if Pages.marketable_urls && Refinery::Pages.friendly_id_reserved_words.include?(sluggified)
           sluggified << "-page"
         end
         sluggified
       end
     end
-    alias_method_chain :normalize_friendly_id, :marketable_urls
 
     def puts_destroy_help
       puts "This page is not deletable. Please use .destroy! if you really want it deleted "
@@ -401,9 +375,9 @@ module Refinery
     end
 
     def slug_locale
-      return Globalize.locale if translation_for(Globalize.locale).try(:slug).present?
+      return Globalize.locale if translation_for(Globalize.locale, false).try(:slug).present?
 
-      if translations.empty? || translation_for(Refinery::I18n.default_frontend_locale).present?
+      if translations.empty? || translation_for(Refinery::I18n.default_frontend_locale, false).present?
         Refinery::I18n.default_frontend_locale
       else
         translations.first.locale