effective_pages 2.0.8 → 3.0.2

data/app/helpers/effective_menus_helper.rb

@@ -1,156 +1,51 @@
+# frozen_string_literal: true
 module EffectiveMenusHelper
-  def render_menu(menu, options = {}, &block)
-    menu = Effective::Menu.find_by_title(menu.to_s) if menu.kind_of?(String) || menu.kind_of?(Symbol)
-    return "<ul class='nav navbar-nav'><li>Menu '#{menu}' does not exist</li></ul>".html_safe if !menu.present?
 
-    if (effectively_editting? && EffectivePages.authorized?(controller, :edit, menu) rescue false)
-      options[:menu_id] = menu.id
-      form_for(menu, :url => '/') { |form| options[:form] = form }
-    end
-
-    menu_items = menu.menu_items
-
-    if menu.new_record?
-      menu_items = menu_items.to_a.sort! { |a, b| a.lft <=> b.lft }
-    end
+  def render_menu(name, options = {}, &block)
+    name = name.to_s
+    menu = Array(EffectivePages.menus).find { |menu| menu.to_s == name }
 
-    if block_given? && options[:form].blank?
-      render_menu_items(menu_items, options) { yield }
-    else
-      render_menu_items(menu_items, options)
+    if menu.blank?
+      raise("unable to find menu #{name}. Please add it to config/initializers/effective_pages.rb")
     end
 
-    # if options[:for_editor]
-    #else
-    #  Rails.cache.fetch(menu) { render_menu_items(menu.menu_items, options) }
-    #end
+    content_tag(:ul, options) { render('effective/pages/menu', menu: menu) }
   end
 
-  def render_menu_items(items, options = {}, &block)
-    if options[:form].present? && options[:form].kind_of?(ActionView::Helpers::FormBuilder) == false
-      raise 'Expecting ActionView::Helpers::FormBuilder object for :form => option'
-    end
-
-    html = ''
-
-    if options[:form]
-      html << "<ul class='nav navbar-nav effective-menu #{options[:class]}'"
-        html << " data-effective-menu-id='#{options[:menu_id] || 0}'"
-        html << " data-effective-menu-expand-html=\"#{render(:partial => 'admin/menu_items/expand').gsub('"', "'").gsub("\n", '').gsub('  ', '')}\""
-        html << " data-effective-menu-new-html=\"#{render(:partial => 'admin/menu_items/new', :locals => { :item => Effective::MenuItem.new(), :form => options[:form] }).gsub('"', "'").gsub("\n", '').gsub('  ', '').gsub('[0]', '[:new]').gsub('_0_', '_:new_')}\""
+  def render_breadcrumbs(menu, page = @page, root: 'Home')
+    return breadcrumbs_root_url(page, root: root) if request.path == '/'
+    return breadcrumbs_fallback(page, root: root) unless page.kind_of?(Effective::Page)
 
-        maxdepth = ((options[:maxdepth].presence || EffectivePages.menu[:maxdepth].presence).to_i rescue 0)
-        html << " data-effective-menu-maxdepth='#{maxdepth}'" if maxdepth > 0
+    parents = [page.menu_parent].compact
 
-      html << ">"
-    else
-      html << "<ul class='nav navbar-nav#{' ' + options[:class].to_s if options[:class].present?}'>"
+    content_tag(:ol, class: 'breadcrumb') do
+      (
+        [content_tag(:li, link_to(root, root_path, title: root), class: 'breadcrumb-item')] +
+        parents.map do |page|
+          url = (page.menu_url.presence || effective_pages.page_path(page))
+          content_tag(:li, link_to(page, url, title: page.title), class: 'breadcrumb-item')
+        end +
+        [content_tag(:li, page, class: 'breadcrumb-item active', 'aria-current': 'page')]
+      ).join.html_safe
     end
-
-    stack = [items.to_a.first] # A stack to keep track of rgt values.
-    skip_to_lft = 0 # This lets us skip over nodes we don't have visible_for? permission to see
-
-    items.each_with_index do |item, index|
-      next if index == 0 # We always skip the first Root node
-
-      # This allows us to skip over nodes we don't have permission to view
-      next if item.lft < skip_to_lft
-      if options[:form].blank? && !item.visible_for?(defined?(current_user) ? current_user : nil)
-        skip_to_lft = item.rgt + 1
-        next
-      end
-
-      if stack.size > 1
-        html << "<ul class='dropdown-menu'>" if (item.rgt < stack.last.rgt) # Level down?
-
-        while item.rgt > stack.last.rgt # Level up?
-          stack.pop
-          html << "</ul></li>" if (item.rgt > stack.last.rgt)
-        end
-      end
-
-      # Render the <li>...</li> with carets only on top level dropdowns, not sub dropdowns
-      html << render_menu_item(item, stack.size == 1, options)
-
-      stack.push(item)
-    end
-
-    while stack.size > 0
-      item = stack.pop
-
-      if stack.size == 0 # Very last one
-        html << render(:partial => 'admin/menu_items/actions') if options[:form]
-        html << (capture(&block) || '') if block_given? && !options[:form]
-        html << '</ul>'
-      elsif item.leaf? == false
-        html << '</ul></li>'
-      end
-    end
-
-    html.html_safe
   end
 
-  private
-
-  # This is where we actually build out an li item
-  def render_menu_item(item, caret, options)
-    html = ""
-
-    url = (
-      if item.menuable.kind_of?(Effective::Page)
-        effective_pages.page_path(item.menuable)
-      elsif item.divider?
-        nil
-      elsif (item.special || '').end_with?('_path')
-        self.send(item.special) rescue nil
-      elsif item.url.present?
-        item.url
-      end
-    ).presence || '#'
+  alias_method :render_breadcrumb, :render_breadcrumbs
 
-    classes = (item.classes || '').split(' ')
-    classes << 'active' if EffectivePages.menu[:apply_active_class] && request.try(:fullpath) == url
-    classes << 'divider' if item.divider?
-    classes << 'dropdown' if item.dropdown?
-    classes = classes.join(' ')
-
-    if item.leaf?
-      html << (classes.present? ? "<li class='#{classes}'>" : "<li>")
-
-      if !item.divider? || options[:form] # Show the URL in edit mode, but not normally
-        html << render_menu_item_anchor_tag(item, caret, url)
-      end
-
-      if options[:form]
-        html << render(:partial => 'admin/menu_items/item', :locals => { :item => item, :form => options[:form] })
-      end
-
-      html << "</li>"
-    else
-      html << (classes.present? ? "<li class='#{classes}'>" : "<li>")
-      html << render_menu_item_anchor_tag(item, caret, url)
-
-      if options[:form]
-        html << render(:partial => 'admin/menu_items/item', :locals => { :item => item, :form => options[:form] })
-      end
+  def breadcrumbs_root_url(page = @page, root: 'Home')
+    content_tag(:ol, class: 'breadcrumb') do
+      content_tag(:li, root, class: 'breadcrumb-item active', 'aria-current': 'page')
     end
-
-    html
   end
 
-  def render_menu_item_anchor_tag(item, caret, url)
-    new_window_html = (item.new_window? ? " target='_blank'" : "")
+  def breadcrumbs_fallback(page = @page, root: 'Home')
+    label = (page if page.kind_of?(Effective::Page)) || @page_title || 'Here'
 
-    if item.special == 'destroy_user_session_path'
-      "<a href='#{url}' data-method='delete' data-no-turbolink='true'>#{item.title}</a>"
-    elsif item.dropdown?
-      ''.tap do |html|
-        html << "<a href='#{url}' data-toggle='dropdown'#{new_window_html}>#{item.title}"
-        html << "<span class='caret'></span>" if caret
-        html << "</a>"
-      end
-    else
-      "<a href='#{url}'#{new_window_html}>#{item.title}</a>"
+    content_tag(:ol, class: 'breadcrumb') do
+      [
+        content_tag(:li, link_to(root, root_path, title: root), class: 'breadcrumb-item'),
+        content_tag(:li, label, class: 'breadcrumb-item active', 'aria-current': 'page')
+      ].join.html_safe
     end
   end
 

data/app/helpers/effective_pages_helper.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 module EffectivePagesHelper
 
   def effective_pages_body_classes
     [
       params[:controller].to_s.parameterize,
       params[:action],
-      ((user_signed_in? ? 'signed-in'.freeze : 'not-signed-in'.freeze) rescue nil),
-      (@page.template rescue nil),
+      (user_signed_in? ? 'signed-in' : 'not-signed-in'),
+      (@page.template if @page && @page.respond_to?(:template)),
       @body_classes
     ].compact.join(' ')
   end

data/app/models/effective/page.rb

@@ -1,27 +1,55 @@
 module Effective
   class Page < ActiveRecord::Base
+    attr_accessor :current_user
+
+    # These parent / children are for the menu as well
+    belongs_to :menu_parent, class_name: 'Effective::Page', optional: true
+
+    has_many :menu_children, -> { Effective::Page.menuable }, class_name: 'Effective::Page',
+      foreign_key: :menu_parent_id, inverse_of: :menu_parent
+
     acts_as_role_restricted
-    acts_as_regionable
     acts_as_slugged
+    has_many_rich_texts
 
-    has_many :menu_items, as: :menuable, dependent: :destroy
+    log_changes if respond_to?(:log_changes)
 
     self.table_name = EffectivePages.pages_table_name.to_s
 
-    # structure do
-    #   title             :string
-    #   meta_description  :string
+    effective_resource do
+      title             :string
+      meta_description  :string
+
+      draft             :boolean
+
+      layout            :string
+      template          :string
+
+      slug              :string
+
+      # Menu stuff
+      menu              :boolean
+      menu_name         :string
 
-    #   draft             :boolean
+      menu_url          :string
+      menu_position     :integer
 
-    #   layout            :string
-    #   template          :string
+      # Access
+      roles_mask        :integer
+      authenticate_user :boolean
 
-    #   slug              :string
-    #   roles_mask        :integer
+      timestamps
+    end
 
-    #   timestamps
-    # end
+    before_validation(if: -> { menu? && menu_position.blank? }) do
+      self.menu_position = (self.class.where(menu_parent: menu_parent).maximum(:menu_position) || -1) + 1
+    end
+
+    validate(if: -> { menu_url.present? }) do
+      unless menu_url.start_with?('http://') || menu_url.start_with?('https://') || menu_url.start_with?('/')
+        self.errors.add(:menu_url, "must start with http(s):// or /")
+      end
+    end
 
     validates :title, presence: true, length: { maximum: 255 }
     validates :meta_description, presence: true, length: { maximum: 150 }
@@ -29,11 +57,27 @@ module Effective
     validates :layout, presence: true
     validates :template, presence: true
 
-    scope :drafts, -> { where(draft: true) }
+    validates :menu_name, if: -> { menu? && EffectivePages.menus.present? },
+      presence: true, inclusion: { in: EffectivePages.menus.map(&:to_s) }
+
+    # validates :menu_position, if: -> { menu? },
+    #   presence: true, uniqueness: { scope: [:menu_name, :menu_parent_id] }
+
+    scope :deep, -> { includes(:menu_parent, menu_children: :menu_parent) }
+
+    scope :draft, -> { where(draft: true) }
     scope :published, -> { where(draft: false) }
     scope :sorted, -> { order(:title) }
+    scope :on_menu, -> { where(menu: true) }
     scope :except_home, -> { where.not(title: 'Home') }
 
+    scope :menuable, -> { where(menu: true).order(:menu_position) }
+    scope :menu_deep, -> { includes(:menu_parent, :menu_children) }
+
+    scope :for_menu, -> (name) { menuable.where(menu_name: name) }
+    scope :for_menu_root, -> (name) { for_menu(name).menu_deep.root_level }
+    scope :root_level, -> { where(menu_parent_id: nil) }
+
     def to_s
       title
     end
@@ -43,24 +87,23 @@ module Effective
     end
 
     # Returns a duplicated post object, or throws an exception
-    def duplicate!
+    def duplicate
       Page.new(attributes.except('id', 'updated_at', 'created_at')).tap do |page|
         page.title = page.title + ' (Copy)'
         page.slug = page.slug + '-copy'
-        page.draft = true
 
-        regions.each do |region|
-          page.regions.build(region.attributes.except('id', 'updated_at', 'created_at'))
+        rich_texts.each do |rt|
+          page.send("rich_text_#{rt.name}=", rt.body)
         end
 
-        page.save!
+        page.draft = true
       end
     end
 
+    def duplicate!
+      duplicate.tap { |page| page.save! }
+    end
+
   end
 
 end
-
-
-
-

data/app/views/admin/menus/index.html.haml

@@ -1,3 +1,11 @@
-%h1.effective-admin-heading= @page_title
+%h1= @page_title
 
-= render_datatable(@datatable)
+%p
+  Click Reorder to drag & drop reorder the menu.
+  Edit an item to reorder its children items.
+
+- EffectivePages.menus.each do |menu|
+  %h2 #{menu.to_s.titleize} Menu
+  - datatable = EffectivePagesMenuDatatable.new(menu: menu)
+  = render_datatable(datatable, simple: true, inline: true)
+  %hr

data/app/views/admin/pages/_form.html.haml

@@ -1,32 +1,27 @@
-= effective_form_with(model: page, url: (page.persisted? ? effective_pages.admin_page_path(page.id) : effective_pages.admin_pages_path)) do |f|
-  = f.text_field :title, hint: 'The title of your page.', input_html: { maxlength: 255 }
+- if inline_datatable? && inline_datatable.attributes[:menu]
+  - menu = inline_datatable.attributes[:menu]
+  - datatable = EffectivePagesMenuDatatable.new(menu: menu, menu_parent_id: page.id)
 
-  - if (templates = EffectivePages.templates).length == 1
-    = f.hidden_field :template, value: templates.first
-  - else
-    = f.select :template, templates
+  = render '/admin/pages/form_menu', page: page
 
-  - if (layouts = EffectivePages.layouts).length == 1
-    = f.hidden_field :layout, value: layouts.first
-  - else
-    = f.select :layout, layouts
+  - if datatable.present?(self)
+    %h3 Children
+    = render_datatable(datatable, simple: true, inline: true)
 
-  - if f.object.persisted? || f.object.errors.include?(:slug)
-    - current_url = (effective_pages.page_url(f.object) rescue nil)
-    = f.text_field :slug, hint: "The slug controls this page's internet address. Be careful, changing the slug will break links that other websites may have to the old address.<br>#{('This page is currently reachable via ' + link_to(current_url.gsub(f.object.slug, '<strong>' + f.object.slug + '</strong>').html_safe, current_url)) if current_url }".html_safe
+- else
+  = tabs do
+    = tab 'Page' do
+      = render '/admin/pages/form_page', page: page
 
-  = f.text_field :meta_description, hint: "A one or two sentence summary of this page. Appears on Google search results underneath the page title.", input_html: { maxlength: 150 }
+    - if page.persisted?
+      = tab 'Content' do
+        = render '/admin/pages/form_content', page: page
 
-  = render partial: '/admin/pages/additional_fields', locals: { page: page, form: f, f: f }
+      = tab 'Menu' do
+        = render '/admin/pages/form_menu', page: page
 
-  = f.check_box :draft, label: 'Save this page as a draft.  It will not be accessible on the website.'
+      = tab 'Access' do
+        = render '/admin/pages/form_access', page: page
 
-  - if defined?(EffectiveRoles) and f.object.respond_to?(:roles) && EffectivePages.use_effective_roles
-    = render partial: '/admin/pages/roles', locals: { page: page, form: f, f: f }
-
-  = f.submit do
-    = f.save 'Save'
-    = f.save 'Save and Edit Content', class: 'btn btn-secondary'
-    = f.save 'Save and View', class: 'btn btn-secondary'
-    - if f.object.persisted?
-      = f.save 'Duplicate', class: 'btn btn-info'
+      = tab 'Logs' do
+        = render_datatable(page.log_changes_datatable, inline: true, namespace: :admin)

data/app/views/admin/pages/_form_access.html.haml

@@ -0,0 +1,10 @@
+= effective_form_with(model: page, url: page.persisted? ? effective_pages.admin_page_path(page.id) : effective_pages.admin_pages_path) do |f|
+  = f.check_box :authenticate_user, label: 'Yes, the user must be be signed in to view this page'
+
+  - if EffectivePages.use_effective_roles
+    = f.checks :roles, EffectiveRoles.roles_collection(f.object)
+
+  %p.text-hint
+    * leave blank for a regular public page that anyone can view
+
+  = f.submit

data/app/views/admin/pages/_form_content.html.haml

@@ -0,0 +1,3 @@
+= effective_form_with(model: page, url: page.persisted? ? effective_pages.admin_page_path(page.id) : effective_pages.admin_pages_path) do |f|
+  = render '/admin/pages/rich_text_areas', page: page, f: f
+  = effective_submit(f)

data/app/views/admin/pages/_form_menu.html.haml

@@ -0,0 +1,16 @@
+= effective_form_with(model: page, url: page.persisted? ? effective_pages.admin_page_path(page.id) : effective_pages.admin_pages_path) do |f|
+  = f.check_box :menu, label: 'Yes, display this page on the menu'
+
+  = f.show_if :menu, true do
+
+    - if (menus = EffectivePages.menus).length > 1
+      = f.select :menu_name, menus
+    - else
+      = f.hidden_field :menu_name, value: menus.first
+
+    = f.text_field :menu_url, label: "Redirect to path or url instead of displaying page",
+      hint: "Must start with http(s):// or /"
+
+    = f.select :menu_parent_id, Effective::Page.menuable.root_level, placeholder: 'None. Top level menu.'
+
+  = f.submit

data/app/views/admin/pages/_form_page.html.haml

@@ -0,0 +1,31 @@
+= effective_form_with(model: page, url: page.persisted? ? effective_pages.admin_page_path(page.id) : effective_pages.admin_pages_path) do |f|
+  = f.text_field :title, hint: 'The title of your page.'
+
+  = f.check_box :draft,
+    label: 'Save this page as a draft. It will not be accessible on the website.'
+
+  = f.text_field :meta_description,
+    hint: "A one or two sentence summary of this page. Appears on Google search results underneath the page title.",
+    input_html: { maxlength: 150 }
+
+  - if (layouts = EffectivePages.layouts).length > 1
+    = f.select :layout, layouts
+  - else
+    = f.hidden_field :layout, value: layouts.first
+
+  - if (templates = EffectivePages.templates).length > 1
+    = f.select :template, templates
+  - else
+    = f.hidden_field :template, value: templates.first
+
+  - if f.object.persisted? || f.object.errors.include?(:slug)
+    - current_url = (effective_pages.page_url(f.object) rescue nil)
+    = f.text_field :slug, hint: "The slug controls this page's internet address. Be careful, changing the slug will break links that other websites may have to the old address.<br>#{('This page is currently reachable via ' + link_to(current_url.gsub(f.object.slug, '<strong>' + f.object.slug + '</strong>').html_safe, current_url)) if current_url }".html_safe
+
+  = render partial: '/admin/pages/additional_fields', locals: { page: page, form: f, f: f }
+
+  -# This is for duplicate
+  - if f.object.new_record? && f.object.rich_texts.present?
+    = render partial: '/admin/pages/rich_text_areas', locals: { page: page, form: f, f: f }
+
+  = effective_submit(f)