refinerycms-pages 2.0.10 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: afa1108c7b18ea0168413156287b4dbc685b6a97
-  data.tar.gz: e24e4cc3c8d1b35b51474e7d4ff1e2e78ae0506d
+  metadata.gz: 4780e7414495d270398ae05f97f184a229536571
+  data.tar.gz: 570c24e94417d1eec341292220e105a8ee162261
 SHA512:
-  metadata.gz: 31fbc30c1a4666743cde7cbbd4d1ac9f7ebc9127504a11bdec22d93854f112a20c9706c5bed4a3222ef4762c2c64b3fea0369ab7b667e2a833cbd130ea2b4ca6
-  data.tar.gz: 0d920af2461126b770741dac6a9d0aee9afb71ced6d3cef20888f725fc94a2786702c1052b04b13338ce653f6bf5961e05538946362050263dd90d98fa2456d8
+  metadata.gz: 69fd5760bf9f85414fe6fbc03bb099b0a48009add74178c43fba435e5264ef2a1234d1b29608a2d7a32dd7a82c2710df35c46d526d907db3c0849542d91c0ce5
+  data.tar.gz: f99adadf7d2ee66c289f89789a2d0b54c1a80d1511f6a1a026dc085330b0872cdd2e4e07e91ff42eebfafb5057464cf3bf65c89b2d0926590c603c22432ec1df

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

@@ -1,24 +1,22 @@
 module Refinery
   module Admin
     class PagesController < Refinery::AdminController
-      cache_sweeper Refinery::PageSweeper
+      include Pages::InstanceMethods
+      cache_sweeper Pages::PageSweeper
 
       crudify :'refinery/page',
               :order => "lft ASC",
               :include => [:translations, :children],
               :paging => false
 
-      after_filter lambda{::Refinery::Page.expire_page_caching}, :only => [:update_positions]
-
       before_filter :load_valid_templates, :only => [:edit, :new]
-
-      before_filter :restrict_access, :only => [:create, :update, :update_positions, :destroy],
-                    :if => proc { Refinery.i18n_enabled? }
+      before_filter :restrict_access, :only => [:create, :update, :update_positions, :destroy]
+      after_filter proc { Pages::Caching.new().expire! }, :only => :update_positions
 
       def new
-        @page = Refinery::Page.new(params.except(:controller, :action, :switch_locale))
-        Refinery::Pages.default_parts_for(@page).each_with_index do |page_part, index|
-          @page.parts << Refinery::PagePart.new(:title => page_part, :position => index)
+        @page = Page.new(params.except(:controller, :action, :switch_locale))
+        Pages.default_parts_for(@page).each_with_index do |page_part, index|
+          @page.parts << PagePart.new(:title => page_part, :position => index)
         end
       end
 
@@ -42,8 +40,8 @@ module Refinery
                 redirect_to :back
               else
                 render :partial => 'save_and_continue_callback', :locals => {
-                  :new_refinery_page_path => refinery.admin_page_path(@page.uncached_nested_url),
-                  :new_page_path => refinery.preview_page_path(@page.uncached_nested_url)
+                  :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
@@ -66,8 +64,13 @@ module Refinery
 
     protected
 
+      def after_update_positions
+        find_all_pages
+        render :partial => '/refinery/admin/pages/sortable_list' and return
+      end
+
       def find_page
-        @page = Refinery::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
 
@@ -77,15 +80,18 @@ module Refinery
         return super unless action_name.to_s == 'index'
 
         # Always display the tree of pages from the default frontend locale.
-        Globalize.locale = params[:switch_locale].try(:to_sym) || Refinery::I18n.default_frontend_locale
+        if Refinery::I18n.built_in_locales.keys.map(&:to_s).include?(params[:switch_locale])
+          Globalize.locale = params[:switch_locale].try(:to_sym)
+        else
+          Globalize.locale = Refinery::I18n.default_frontend_locale
+        end
       end
 
       def load_valid_templates
-        @valid_layout_templates = Refinery::Pages.layout_template_whitelist &
-                                  Refinery::Pages.valid_templates('app', 'views', '{layouts,refinery/layouts}', '*html*')
+        @valid_layout_templates = Pages.layout_template_whitelist &
+                                  Pages.valid_templates('app', 'views', '{layouts,refinery/layouts}', '*html*')
 
-        @valid_view_templates = Refinery::Pages.view_template_whitelist &
-                                Refinery::Pages.valid_templates('app', 'views', '{pages,refinery/pages}', '*html*')
+        @valid_view_templates = Pages.valid_templates('app', 'views', '{pages,refinery/pages}', '*html*')
       end
 
       def restrict_access

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

@@ -1,5 +1,3 @@
-require 'net/http'
-
 module Refinery
   module Admin
     class PagesDialogsController < ::Refinery::Admin::DialogsController
@@ -9,21 +7,23 @@ module Refinery
       def link_to
         # Get the switch_local variable to determine the locale we're currently editing
         # Set up Globalize with our current locale
-        if ::Refinery.i18n_enabled?
-          Thread.current[:globalize_locale] = params[:switch_locale] || Refinery::I18n.default_locale
+        Globalize.locale = if params[:switch_locale].present? && Refinery::I18n.built_in_locales.keys.map(&:to_s).include?(params[:switch_locale])
+          Globalize.locale = params[:switch_locale]
+        else
+          Refinery::I18n.default_locale
         end
 
         @pages = ::Refinery::Page.roots.paginate(:page => params[:page], :per_page => ::Refinery::Page.per_page(true))
 
-        @pages = @pages.with_globalize if ::Refinery.i18n_enabled?
+        @pages = @pages.with_globalize
 
         if ::Refinery::Plugins.registered.names.include?('refinery_files')
-            @resources = Resource.paginate(:page => params[:resource_page], :per_page => Resource.per_page(true)).
-                                  order('created_at DESC')
+          @resources = Resource.paginate(:page => params[:resource_page], :per_page => Resource.per_page(true)).
+                                order('created_at DESC')
 
           # resource link
           if params[:current_link].present?
-           is_resource_link = params[:current_link].include?("/system/resources")
+            is_resource_link = params[:current_link].include?("/system/resources")
           end
         end
 
@@ -52,43 +52,6 @@ module Refinery
         end
       end
 
-      def test_url
-        result = 'failure'
-        begin
-          timeout(5) do
-            unless params[:url].blank?
-              url = URI.parse(params[:url])
-              if url.host.nil? && params[:url].start_with?('/')
-                url.host = URI.parse(request.url).host
-              end
-
-              result = case Net::HTTP.get_response(url)
-                when Net::HTTPSuccess, Net::HTTPRedirection
-                  'success'
-                end
-               
-            end
-          end
-
-        rescue
-          # be quiet
-        end
-        
-        render :json => {:result => result}
-      end
-
-      def test_email
-        if params[:email].present?
-          valid = params[:email] =~ /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i
-
-          render :json => if valid
-            {:result => 'success'}
-          else
-            {:result => 'failure'}
-          end
-        end
-      end
-
     end
   end
 end

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

@@ -0,0 +1,38 @@
+module Refinery
+  module Pages
+    module Admin
+      class PreviewController < AdminController
+        include Pages::InstanceMethods
+        include Pages::RenderOptions
+
+        before_filter :find_page
+
+        layout :layout
+
+        def show
+          render_with_templates?
+        end
+
+        protected
+        def admin?
+          false
+        end
+
+        def find_page
+          if @page = Refinery::Page.find_by_path_or_id(params[:path], params[:id])
+            # Preview existing pages
+            @page.attributes = params[:page]
+          elsif params[:page]
+            # Preview a non-persisted page
+            @page = Page.new params[:page]
+          end
+        end
+        alias_method :page, :find_page
+
+        def layout
+          'application'
+        end
+      end
+    end
+  end
+end

data/app/controllers/refinery/pages_controller.rb

@@ -1,10 +1,12 @@
 module Refinery
   class PagesController < ::ApplicationController
-    before_filter :find_page, :set_canonical, :except => [:preview]
-    before_filter :find_page_for_preview, :only => [:preview]
+    include Pages::RenderOptions
+
+    before_filter :find_page, :set_canonical
+    before_filter :error_404, :unless => :current_user_can_view_page?
 
     # Save whole Page after delivery
-    after_filter { |c| c.write_cache? }
+    after_filter :write_cache?
 
     # This action is usually accessed with the root path, normally '/'
     def home
@@ -22,37 +24,38 @@ module Refinery
     #   GET /about/mission
     #
     def show
-      if current_user_can_view_page?
-        if should_skip_to_first_child?
-          redirect_to refinery.url_for(first_live_child.url)
-        elsif page.link_url.present?
-          redirect_to page.link_url
-        else
-          if requested_friendly_id != page.friendly_id
-            redirect_to refinery.url_for(page.url), :status => 301
-          else
-            render_with_templates?
-          end
-        end
-      else
-        error_404
+      if should_skip_to_first_child?
+        redirect_to refinery.url_for(first_live_child.url) and return
+      elsif page.link_url.present?
+        redirect_to page.link_url and return
+      elsif should_redirect_to_friendly_url?
+        redirect_to refinery.url_for(page.url), :status => 301 and return
       end
-    end
 
-    def preview
-      render_with_templates?(:action => :show)
+      render_with_templates?
     end
 
   protected
 
     def requested_friendly_id
-      "#{params[:path]}/#{params[:id]}".split('/').last
+      if ::Refinery::Pages.scope_slug_by_parent
+        # Pick out last path component, or id if present
+        "#{params[:path]}/#{params[:id]}".split('/').last
+      else
+        # Remove leading and trailing slashes in path, but leave internal
+        # ones for global slug scoping
+        params[:path].to_s.gsub(%r{\A/+}, '').presence || params[:id]
+      end
     end
 
     def should_skip_to_first_child?
       page.skip_to_first_child && first_live_child
     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?
+    end
+
     def current_user_can_view_page?
       page.live? || current_refinery_user_can_access?("refinery_pages")
     end
@@ -65,21 +68,11 @@ module Refinery
       page.children.order('lft ASC').live.first
     end
 
-    def find_page_for_preview
-      if page(fallback_to_404 = false)
-        # Preview existing pages
-        @page.attributes = view_context.sanitize_hash params[:page]
-      elsif params[:page]
-        # Preview a non-persisted page
-        @page = Page.new params[:page]
-      end
-    end
-
     def find_page(fallback_to_404 = true)
       @page ||= case action_name
                 when "home"
                   Refinery::Page.where(:link_url => '/').first
-                when "show", "preview"
+                when "show"
                   Refinery::Page.find_by_path_or_id(params[:path], params[:id])
                 end
       @page || (error_404 if fallback_to_404)
@@ -87,23 +80,13 @@ module Refinery
 
     alias_method :page, :find_page
 
-    def render_with_templates?(render_options = {})
-      if Refinery::Pages.use_layout_templates && page.layout_template.present?
-        render_options[:layout] = page.layout_template
-      end
-      if Refinery::Pages.use_view_templates && page.view_template.present?
-        render_options[:action] = page.view_template
-      end
-      render render_options if render_options.any?
-    end
-
     def set_canonical
       @canonical = refinery.url_for @page.canonical if @page.present?
     end
 
     def write_cache?
       if Refinery::Pages.cache_pages_full && !refinery_user?
-        cache_page(response.body, File.join('', 'refinery', 'cache', 'pages', request.path.sub("//", "/")).to_s)
+        cache_page(response.body, File.join('', 'refinery', 'cache', 'pages', request.path).to_s)
       end
     end
   end

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

@@ -12,15 +12,24 @@ module Refinery
       end
 
       def template_options(template_type, current_page)
-        return {} if current_page.send(template_type)
-
-        if current_page.parent_id?
-          # Use Parent Template by default.
-          { :selected => current_page.parent.send(template_type) }
-        else
-          # Use Default Template (First in whitelist)
-          { :selected => Refinery::Pages.send("#{template_type}_whitelist").first }
+        html_options = { :selected => send("default_#{template_type}", current_page) }
+
+        if (template = current_page.send(template_type).presence)
+          html_options.update :selected => template
+        elsif current_page.parent_id? && !current_page.send(template_type).presence
+          template = current_page.parent.send(template_type).presence
+          html_options.update :selected => template if template
         end
+
+        html_options
+      end
+
+      def default_view_template(current_page)
+        current_page.link_url == "/" ? "home" : "show"
+      end
+
+      def default_layout_template(current_page)
+        "application"
       end
 
       # In the admin area we use a slightly different title
@@ -35,17 +44,13 @@ module Refinery
           ::I18n.t('draft', :scope => 'refinery.admin.pages.page')
         end if page.draft?
 
-        meta_information.html_safe
+        meta_information
       end
 
       # We show the title from the next available locale
       # if there is no title for the current locale
       def page_title_with_translations(page)
-        if page.title.present?
-          page.title
-        else
-          page.translations.detect {|t| t.title.present?}.title
-        end
+        page.title.presence || page.translations.detect {|t| t.title.present?}.title
       end
     end
   end

data/app/models/refinery/page.rb

@@ -1,49 +1,44 @@
 # Encoding: utf-8
-require 'refinerycms-core'
-require 'acts_as_indexed'
 require 'friendly_id'
+require 'refinery/core/base_model'
 
 module Refinery
   class Page < Core::BaseModel
     extend FriendlyId
 
-    # when collecting the pages path how is each of the pages seperated?
-    PATH_SEPARATOR = " - "
-
     translates :title, :menu_title, :custom_slug, :slug, :include => :seo_meta
 
     class Translation
       is_seo_meta
-      attr_accessible :browser_title, :meta_description, :meta_keywords
+      attr_accessible *::SeoMeta.attributes.keys, :locale
     end
 
-    attr_accessible :title
-
     # Delegate SEO Attributes to globalize3 translation
     seo_fields = ::SeoMeta.attributes.keys.map{|a| [a, :"#{a}="]}.flatten
     delegate(*(seo_fields << {:to => :translation}))
 
-    attr_accessible :id, :deletable, :link_url, :menu_match, :meta_keywords,
+    attr_accessible :id, :deletable, :link_url, :menu_match,
                     :skip_to_first_child, :position, :show_in_menu, :draft,
-                    :parts_attributes, :browser_title, :meta_description,
-                    :parent_id, :menu_title, :page_id, :layout_template,
-                    :view_template, :custom_slug, :slug
+                    :parts_attributes, :parent_id, :menu_title, :page_id,
+                    :layout_template, :view_template, :custom_slug, :slug,
+                    :title, *::SeoMeta.attributes.keys
 
-    attr_accessor :locale, :page_title, :page_menu_title # to hold temporarily
     validates :title, :presence => true
 
+    validates :custom_slug, :uniqueness => true, :allow_blank => true
+
     # Docs for acts_as_nested_set https://github.com/collectiveidea/awesome_nested_set
     # 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 :custom_slug_or_title, :use => [:reserved, :globalize, :scoped],
-                :reserved_words => %w(index new session login logout users refinery admin images wymiframe),
-                :scope => :parent
+    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
 
-    # Docs for acts_as_indexed http://github.com/dougal/acts_as_indexed
-    acts_as_indexed :fields => [:title, :meta_keywords, :meta_description,
-                                :menu_title, :browser_title, :all_page_part_content]
+    friendly_id :custom_slug_or_title, friendly_id_options
 
     has_many :parts,
              :foreign_key => :refinery_page_id,
@@ -56,10 +51,9 @@ module Refinery
     accepts_nested_attributes_for :parts, :allow_destroy => true
 
     before_save { |m| m.translation.save }
-    before_create :ensure_locale, :if => proc { ::Refinery.i18n_enabled? }
+    before_create :ensure_locale!
     before_destroy :deletable?
-    after_save :reposition_parts!, :expire_page_caching
-    after_destroy :expire_page_caching
+    after_save :reposition_parts!
 
     class << self
       # Live pages are 'allowed' to be shown in the frontend of your website.
@@ -68,13 +62,18 @@ module Refinery
         where(:draft => false)
       end
 
-      # 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.
+      # Find page by path, checking for scoping rules
       def find_by_path(path)
-        split_path = path.to_s.split('/').reject(&:blank?)
-        page = ::Refinery::Page.by_slug(split_path.shift, :parent_id => nil).first
-        page = page.children.by_slug(split_path.shift).first until page.nil? || split_path.empty?
+        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
+          page = page.children.by_slug(path.shift).first while page && path.any?
+        else
+          page = by_slug(path).first
+        end
 
         page
       end
@@ -83,7 +82,7 @@ module Refinery
       # 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 Refinery::Pages.marketable_urls && path.present?
+        if path.present?
           if path.friendly_id?
             find_by_path(path)
           else
@@ -102,10 +101,15 @@ module Refinery
         with_globalize(:title => title)
       end
 
-      # Finds pages by their slug.  See by_title
+      # 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={})
-        locales = Refinery.i18n_enabled? ? Refinery::I18n.frontend_locales.map(&:to_s) : ::I18n.locale.to_s
-        with_globalize({ :locale => locales, :slug => slug }.merge(conditions))
+        with_globalize({
+          :locale => Refinery::I18n.frontend_locales.map(&:to_s),
+          :slug => slug
+        }.merge(conditions))
       end
 
       # Shows all pages with :show_in_menu set to true, but it also
@@ -116,59 +120,26 @@ module Refinery
         where(:show_in_menu => true).with_globalize
       end
 
-      # Because pages are translated this can have a negative performance impact
-      # on your website and can introduce scaling issues. What fast_menu does is
-      # finds all of the columns necessary to render a +Refinery::Menu+ structure
-      # using only one SQL query. This has limitations, including not being able
-      # to access any other attributes of the pages but you can specify more columns
-      # by passing in an array e.g. fast_menu([:column1, :column2])
-      def fast_menu(columns = [])
-        # First, apply a filter to determine which pages to show.
-        pages = live.in_menu.order('lft ASC').includes(:translations)
-
-        # Now we only want to select particular columns to avoid any further queries.
-        # Title and menu_title are retrieved in the next block below so they are not here.
-        (menu_columns | columns).each do |column|
-          pages = pages.select(arel_table[column.to_sym])
-        end
-
-        # We have to get title and menu_title from the translations table.
-        # To avoid calling globalize3 an extra time, we get title as page_title
-        # and we get menu_title as page_menu_title.
-        # These is used in 'to_refinery_menu_item' in the Page model.
-        %w(title menu_title).each do |column|
-          pages = pages.joins(:translations).select(
-            "#{translation_class.table_name}.#{column} as page_#{column}"
-          )
-        end
-
-        pages
+      # An optimised scope containing only live pages ordered for display in a menu.
+      def fast_menu
+        live.in_menu.order(arel_table[:lft]).includes(:parent, :translations)
       end
 
       # 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)
-        globalized_conditions = {}
+        translations_conditions = {}
+        translated_attrs = translated_attribute_names.map(&:to_s) | %w(locale)
+
         conditions.keys.each do |key|
-          if (translated_attribute_names.map(&:to_s) | %w(locale)).include?(key.to_s)
-            globalized_conditions["#{self.translation_class.table_name}.#{key}"] = conditions.delete(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.
-        joins(:translations).where(globalized_conditions).where(conditions).readonly(false)
-      end
-
-      # Wraps up all the checks that we need to do to figure out whether
-      # the current frontend locale is different to the current one set by ::I18n.locale.
-      # This terminates in a false if i18n extension is not defined or enabled.
-      def different_frontend_locale?
-        ::Refinery.i18n_enabled? && ::Refinery::I18n.current_frontend_locale != ::I18n.locale
-      end
 
-      # Override this method to change which columns you want to select to render your menu.
-      # title and menu_title are always retrieved so omit these.
-      def menu_columns
-        %w(id depth parent_id lft rgt link_url menu_match slug)
+        # A join implies readonly which we don't really want.
+        where(conditions).joins(:translations).where(translations_conditions).
+                                               readonly(false)
       end
 
       # Returns how many pages per page should there be when paginating pages
@@ -176,46 +147,53 @@ module Refinery
         dialog ? Pages.pages_per_dialog : Pages.pages_per_admin_index
       end
 
-      def expire_page_caching
-        begin
-          Rails.cache.delete_matched(/.*pages.*/)
-        rescue NotImplementedError
-          Rails.cache.clear
-          warn "**** [REFINERY] The cache store you are using is not compatible with Rails.cache#delete_matched - clearing entire cache instead ***"
-        ensure
-          return true # so that other callbacks process.
+      def rebuild_with_slug_nullification!
+        rebuild_without_slug_nullification!
+        nullify_duplicate_slugs_under_the_same_parent!
+      end
+      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.
+        each do |(locale, parent_id, slug), count|
+          by_slug(slug, :locale => locale).where(:parent_id => parent_id).drop(1).each do |page|
+            page.slug = nil # kill the duplicate slug
+            page.save # regenerate the slug
+          end
         end
       end
     end
 
     def translated_to_default_locale?
-      persisted? && (!Refinery.i18n_enabled? || translations.where(:locale => Refinery::I18n.default_frontend_locale).any?)
+      persisted? && translations.where(:locale => Refinery::I18n.default_frontend_locale).any?
     end
 
     # The canonical page for this particular page.
     # Consists of:
     #   * The default locale's translated slug
     def canonical
-      Globalize.with_locale(Refinery.i18n_enabled? && Refinery::I18n.default_frontend_locale || ::I18n.locale) { url }
+      Globalize.with_locale(::Refinery::I18n.default_frontend_locale) { url }
     end
 
     # The canonical slug for this particular page.
     # This is the slug for the default frontend locale.
     def canonical_slug
-      Globalize.with_locale(Refinery.i18n_enabled? && Refinery::I18n.default_frontend_locale || ::I18n.locale) { slug }
+      Globalize.with_locale(::Refinery::I18n.default_frontend_locale) { slug }
     end
 
     # 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
+      custom_slug.presence || menu_title.presence || title.presence
     end
 
     # Am I allowed to delete this page?
     # If a link_url is set we don't want to break the link so we don't allow them to delete
     # If deletable is set to false then we don't allow this page to be deleted. These are often Refinery system pages
     def deletable?
-      deletable && link_url.blank? and menu_match.blank?
+      deletable && link_url.blank? && menu_match.blank?
     end
 
     # Repositions the child page_parts that belong to this page.
@@ -231,13 +209,7 @@ module Refinery
     def destroy
       return super if deletable?
 
-      unless Rails.env.test?
-        # give useful feedback when trying to delete from console
-        puts "This page is not deletable. Please use .destroy! if you really want it deleted "
-        puts "unset .link_url," if link_url.present?
-        puts "unset .menu_match," if menu_match.present?
-        puts "set .deletable to true" unless deletable
-      end
+      puts_destroy_help
 
       false
     end
@@ -257,73 +229,44 @@ module Refinery
       # Override default options with any supplied.
       options = {:reversed => true}.merge(options)
 
-      unless parent_id.nil?
+      if parent_id
         parts = [title, parent.path(options)]
         parts.reverse! if options[:reversed]
-        parts.join(PATH_SEPARATOR)
+        parts.join(' - ')
       else
         title
       end
     end
 
-    # When this page is rendered in the navigation, where should it link?
-    # If a custom "link_url" is set, it uses that otherwise it defaults to a normal page URL.
-    # The "link_url" is often used to link to a plugin rather than a page.
-    #
-    # For example if I had a "Contact" page I don't want it to just render a contact us page
-    # I want it to show the Inquiries form so I can collect inquiries. So I would set the "link_url"
-    # to "/contact"
     def url
-      if link_url.present?
-        link_url_localised?
-      elsif Refinery::Pages.marketable_urls
-        with_locale_param url_marketable
-      elsif to_param.present?
-        with_locale_param url_normal
-      end
+      Pages::Url.build(self)
     end
 
-    # Adds the locale key into the URI for this page's link_url attribute, unless
-    # the current locale is set as the default locale.
     def link_url_localised?
-      return link_url unless ::Refinery.i18n_enabled?
-
-      current_url = link_url
-
-      if current_url =~ %r{^/} && ::Refinery::I18n.current_frontend_locale != ::Refinery::I18n.default_frontend_locale
-        current_url = "/#{::Refinery::I18n.current_frontend_locale}#{current_url}"
-      end
-
-      current_url
+      Refinery.deprecate "Refinery::Page#link_url_localised?", :when => '2.2',
+                         :replacement => "Refinery::Pages::Url::Localised#url"
+      Pages::Url::Localised.new(self).url
     end
 
-    # Add 'marketable url' attributes into this page's url.
-    # This sets 'path' as the nested_url value and sets 'id' to nil.
-    # For example, this might evaluate to /about for the "About" page.
-    def url_marketable
-      # :id => nil is important to prevent any other params[:id] from interfering with this route.
-      url_normal.merge :path => nested_url, :id => nil
-    end
-
-    # Returns a url suitable to be used in url_for in Rails (such as link_to).
-    # For example, this might evaluate to /pages/about for the "About" page.
     def url_normal
-      {:controller => '/refinery/pages', :action => 'show', :path => nil, :id => to_param, :only_path => true}
+      Refinery.deprecate "Refinery::Page#url_normal", :when => '2.2',
+                         :replacement => "Refinery::Pages::Url::Normal#url"
+      Pages::Url::Normal.new(self).url
     end
 
-    # If the current locale is set to something other than the default locale
-    # then the :locale attribute will be set on the url hash, otherwise it won't be.
-    def with_locale_param(url_hash, locale = nil)
-      locale ||= ::Refinery::I18n.current_frontend_locale if self.class.different_frontend_locale?
-      url_hash.update :locale => locale if locale
-      url_hash
+    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 uncached_nested_url
-      [
-        parent.try(:uncached_nested_url),
-        Globalize.with_locale(slug_locale) { to_param.to_s }
-      ].compact.flatten
+    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]
+      end
     end
 
     # Returns an array with all ancestors to_param, allow with its own
@@ -332,29 +275,17 @@ module Refinery
     #
     #   ['about', 'mission']
     #
-    alias_method :nested_url, :uncached_nested_url
+    alias_method :uncached_nested_url, :nested_url
 
-    # Returns the string version of nested_url, i.e., the path that should be generated
-    # by the router
+    # Returns the string version of nested_url, i.e., the path that should be
+    # generated by the router
     def nested_path
-      Rails.cache.fetch(path_cache_key) { ['', nested_url].join('/') }
-    end
-
-    def path_cache_key(locale = Globalize.locale)
-      [cache_key(locale), 'nested_path'].join('#')
-    end
-
-    def url_cache_key(locale = Globalize.locale)
-      [cache_key(locale), 'nested_url'].join('#')
-    end
-
-    def cache_key(locale)
-      [Refinery::Core.base_cache_key, 'page', locale, id].compact.join('/')
+      ['', nested_url].join('/')
     end
 
     # Returns true if this page is "published"
     def live?
-      not draft?
+      !draft?
     end
 
     # Return true if this page can be shown in the navigation.
@@ -364,12 +295,7 @@ module Refinery
     end
 
     def not_in_menu?
-      not in_menu?
-    end
-
-    # Returns true if this page is the home page or links to it.
-    def home?
-      link_url == '/'
+      !in_menu?
     end
 
     # Returns all visible sibling pages that can be rendered for the menu
@@ -377,18 +303,15 @@ module Refinery
       siblings.reject(&:not_in_menu?)
     end
 
-    def refinery_menu_title
-      [page_menu_title, page_title, menu_title, title].detect(&:present?)
-    end
-
     def to_refinery_menu_item
       {
         :id => id,
         :lft => lft,
+        :depth => depth,
         :menu_match => menu_match,
         :parent_id => parent_id,
         :rgt => rgt,
-        :title => refinery_menu_title,
+        :title => menu_title.presence || title.presence,
         :type => self.class.name,
         :url => url
       }
@@ -404,6 +327,17 @@ module Refinery
       part_with_title(part_title).try(:body)
     end
 
+    # Accessor method to test whether a page part
+    # exists and has content for this page.
+    # Example:
+    #
+    #   ::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?
+    end
+
     # Accessor method to get a page part object from a page.
     # Example:
     #
@@ -420,44 +354,49 @@ module Refinery
       end
     end
 
-    # Used to index all the content on this page so it can be easily searched.
-    def all_page_part_content
-      parts.map(&:body).join(" ")
+  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
     end
 
-    ##
     # Protects generated slugs from title if they are in the list of reserved words
     # This applies mostly to plugin-generated pages.
     # This only kicks in when Refinery::Pages.marketable_urls is enabled.
+    # 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)
-      sluggified = slug_string.to_slug.normalize!
-      if Refinery::Pages.marketable_urls && self.class.friendly_id_config.reserved_words.include?(sluggified)
-        sluggified << "-page"
+      # 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
+        sluggified = slug_string.to_slug.normalize!
+        if Pages.marketable_urls && self.class.friendly_id_config.reserved_words.include?(sluggified)
+          sluggified << "-page"
+        end
+        sluggified
       end
-      sluggified
     end
     alias_method_chain :normalize_friendly_id, :marketable_urls
 
-    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
-    end
-
-    def expire_page_caching
-      self.class.expire_page_caching
+    def puts_destroy_help
+      puts "This page is not deletable. Please use .destroy! if you really want it deleted "
+      puts "unset .link_url," if link_url.present?
+      puts "unset .menu_match," if menu_match.present?
+      puts "set .deletable to true" unless deletable
     end
 
     def slug_locale
       return Globalize.locale if translation_for(Globalize.locale).try(:slug).present?
 
-      if Refinery.i18n_enabled? && (translations.empty? || translation_for(Refinery::I18n.default_frontend_locale).present?)
+      if translations.empty? || translation_for(Refinery::I18n.default_frontend_locale).present?
         Refinery::I18n.default_frontend_locale
       else
         translations.first.locale