effective_pages 0.8.0

data/app/helpers/effective_pages_helper.rb

@@ -0,0 +1,14 @@
+module EffectivePagesHelper
+  def effective_page_header_tags(options = {})
+    @page ||= nil
+
+    [ content_tag(:title, (@page_title || options[:title] || @page.try(:title))),
+      "<meta content='#{options[:meta_description] || @page.try(:meta_description)}' name='description' />",
+    ].join("\n").html_safe
+  end
+
+  def application_root_to_effective_pages_slug
+    Rails.application.routes.routes.find { |r| r.name == 'root' and r.defaults[:controller] == 'Effective::Pages' and r.defaults[:action] == 'show' }.defaults[:id] rescue nil
+  end
+
+end

data/app/models/effective/access_denied.rb

@@ -0,0 +1,17 @@
+unless defined?(Effective::AccessDenied)
+  module Effective
+    class AccessDenied < StandardError
+      attr_reader :action, :subject
+
+      def initialize(message = nil, action = nil, subject = nil)
+        @message = message
+        @action = action
+        @subject = subject
+      end
+
+      def to_s
+        @message || I18n.t(:'unauthorized.default', :default => 'Access Denied')
+      end
+    end
+  end
+end

data/app/models/effective/datatables/menus.rb

@@ -0,0 +1,16 @@
+if defined?(EffectiveDatatables)
+  module Effective
+    module Datatables
+      class Menus < Effective::Datatable
+        table_column :id
+
+        table_column :title
+        table_column :actions, :sortable => false, :filter => false, :partial => '/admin/menus/actions'
+
+        def collection
+          Effective::Menu.all
+        end
+      end
+    end
+  end
+end

data/app/models/effective/datatables/pages.rb

@@ -0,0 +1,19 @@
+if defined?(EffectiveDatatables)
+  module Effective
+    module Datatables
+      class Pages < Effective::Datatable
+        table_column :id
+
+        table_column :title
+        table_column :slug
+        table_column :draft
+
+        table_column :actions, :sortable => false, :filter => false, :partial => '/admin/pages/actions'
+
+        def collection
+          Effective::Page.all
+        end
+      end
+    end
+  end
+end

data/app/models/effective/menu.rb

@@ -0,0 +1,152 @@
+module Effective
+  class Menu < ActiveRecord::Base
+    has_many :menu_items, :dependent => :delete_all
+
+    self.table_name = EffectivePages.menus_table_name.to_s
+    attr_protected() if Rails::VERSION::MAJOR == 3
+
+    structure do
+      title           :string, :validates => [:presence, :uniqueness]
+      timestamps
+    end
+
+    accepts_nested_attributes_for :menu_items, :allow_destroy => true
+
+    before_create do
+      if self.menu_items.find { |menu_item| menu_item.lft == 1 }.blank?
+        menu_items.build(:title => 'Home', :url => '#', :lft => 1, :rgt => 2)
+      end
+    end
+
+    def self.update_from_effective_regions!(params)
+      (params || {}).each do |menu_id, attributes|
+        menu = Effective::Menu.find(menu_id)
+
+        attributes[:menu_items_attributes].each { |_, atts| atts[:menuable_type] = 'Effective::Page' if atts[:menuable_type].blank? }
+        menu.attributes = attributes
+
+        # So when we render the menu, we don't include the Root/Home item.
+        # It has a left of 1 and a right of max(items.right)
+        right = attributes[:menu_items_attributes].map { |_, atts| atts[:rgt].to_i }.max
+        menu.menu_items.find { |menu_item| menu_item.lft == 1 }.rgt = right + 1
+
+        menu.save!
+      end
+    end
+
+    def contains?(obj)
+      menu_items.find { |menu_item| menu_item.url == obj || menu_item.menuable == obj }.present?
+    end
+
+    # This is the entry point to the DSL method for creating menu items
+    def build(&block)
+      raise 'build must be called with a block' if !block_given?
+
+      root = menu_items.build(:title => 'Home', :url => '#', :lft => 1, :rgt => 2)
+      root.parent = true
+      instance_exec(&block) # A call to dropdown or item
+      root.rgt = menu_items.map(&:rgt).max
+      self
+    end
+
+    private
+
+    def dropdown(title, options = {}, &block)
+      raise 'dropdown must be called with a block' if !block_given?
+      raise 'dropdown menu_items may not have a URL' if options.kind_of?(String) || options.kind_of?(Symbol)
+      raise 'dropdown second parameter expects a Hash' unless options.kind_of?(Hash)
+
+      prev_item = menu_items.last
+
+      if prev_item.parent == true # This came from root or dropdown
+        lft = prev_item.lft + 1 # Go down. from lft
+        rgt = prev_item.rgt + 1
+      else
+        lft = prev_item.rgt + 1 # Go accross. from rgt
+        rgt = prev_item.rgt + 2
+      end
+
+      # Make room for new item by shifting everything after me up by 2
+      menu_items.each do |item|
+        item.rgt = (item.rgt + 2) if item.rgt > (lft - 1)
+        item.lft = (item.lft + 2) if item.lft > (lft - 1)
+      end
+
+      atts = build_menu_item_attributes(title, '', options).merge({:lft => lft, :rgt => rgt})
+
+      dropdown = menu_items.build(atts)
+      dropdown.parent = true
+
+      instance_exec(&block)
+
+      # Level up
+      dropdown.rgt = menu_items.last.rgt + 1 # Level up
+      dropdown.parent = false
+      menu_items << menu_items.delete(dropdown) # Put myself on the end of the array
+    end
+
+    # The URL parameter can be:
+    # - an Effective::Page object
+    # - the symbol :divider
+    # - a symbol or string that ends with _path
+    # - or a string that is the url
+
+    def item(title, url = '#', options = {})
+      raise 'item third parameter expects a Hash' unless options.kind_of?(Hash)
+
+      prev_item = menu_items.last
+
+      if prev_item.parent == true # This came from root or dropdown
+        lft = prev_item.lft + 1 # Go down. from lft
+        rgt = prev_item.rgt + 1
+      else
+        lft = prev_item.rgt + 1 # Go accross, from rgt
+        rgt = prev_item.rgt + 2
+      end
+
+      menu_items.each do |item|
+        item.rgt = (item.rgt + 2) if item.rgt > (lft - 1)
+        item.lft = (item.lft + 2) if item.lft > (lft - 1)
+      end
+
+      atts = build_menu_item_attributes(title, url, options).merge({:lft => lft, :rgt => rgt})
+
+      menu_items.build(atts)
+    end
+
+    def divider(options = {})
+      item(:divider, :divider, options)
+    end
+
+    def build_menu_item_attributes(title, url, options)
+      options[:roles_mask] ||= 0 if (options.delete(:signed_in) || options.delete(:private))
+      options[:roles_mask] ||= -1 if (options.delete(:signed_out) || options.delete(:guest))
+
+      options[:classes] = options.delete(:class)
+
+      if title == :divider || url == :divider || options[:divider] == true
+        options[:title] = 'divider'
+        options[:special] = 'divider'
+      elsif title.kind_of?(Effective::Page)
+        options[:title] = title.title
+        options[:menuable] = title
+        options[:url] = '#'
+      elsif url.kind_of?(Effective::Page)
+        options[:title] = title.presence || url.title
+        options[:menuable] = url
+        options[:url] = '#'
+      elsif url.to_s.end_with?('_path')
+        options[:title] = title
+        options[:special] = url
+      else
+        options[:title] = title
+        options[:url] = url
+      end
+
+      options
+    end
+
+
+  end
+
+end

data/app/models/effective/menu_item.rb

@@ -0,0 +1,68 @@
+module Effective
+  class MenuItem < ActiveRecord::Base
+    attr_accessor :parent  # This gets set on the Root node and a node created by Dropdown, so the item function knows whether to go down or to go accross
+
+    belongs_to :menu, :inverse_of => :menu_items
+    belongs_to :menuable, :polymorphic => true # Optionaly belong to an object
+
+    self.table_name = EffectivePages.menu_items_table_name.to_s
+    attr_protected() if Rails::VERSION::MAJOR == 3
+
+    structure do
+      title           :string, :validates => [:presence]
+
+      url             :string
+      special         :string   # divider / search / *_path
+
+      classes         :string
+      new_window      :boolean, :default => false, :validates => [:inclusion => {:in => [true, false]}]
+      roles_mask      :integer, :default => nil # 0 is going to mean logged in, nil is going to mean public, > 0 will be future implementation of roles masking
+
+      lft             :integer, :validates => [:presence], :index => true
+      rgt             :integer, :validates => [:presence]
+    end
+
+    default_scope -> { includes(:menuable).order(:lft) }
+
+    def leaf?
+      (rgt.to_i - lft.to_i) == 1
+    end
+
+    def dropdown?
+      !leaf?
+    end
+
+    def divider?
+      leaf? && special == 'divider'
+    end
+
+    # For now it's just logged in or not?
+    # This will work with effective_roles one day...
+    def visible_for?(user)
+      can_view_page = (
+        if menuable.kind_of?(Effective::Page) && defined?(EffectiveRoles) && menuable.is_role_restricted?
+          (user.roles_match_with?(menuable) rescue false)
+        else
+          true
+        end
+      )
+
+      can_view_menu_item = (
+        if roles_mask == nil
+          true
+        elsif roles_mask == -1 # Am I logged out?
+          user.blank?
+        elsif roles_mask == 0 # Am I logged in?
+          user.present?
+        elsif roles_mask > 0 && defined?(EffectiveRoles)
+          user.present? && (user.roles_match_with?(roles_mask) rescue false)
+        else
+          false
+        end
+      )
+
+      can_view_page && can_view_menu_item
+    end
+
+  end
+end

data/app/models/effective/page.rb

@@ -0,0 +1,32 @@
+module Effective
+  class Page < ActiveRecord::Base
+    acts_as_sluggable
+    acts_as_role_restricted if defined?(EffectiveRoles)
+    acts_as_regionable if defined?(EffectiveRegions)
+
+    self.table_name = EffectivePages.pages_table_name.to_s
+
+    structure do
+      title             :string, :validates => [:presence]
+      meta_description  :string, :validates => [:presence]
+
+      draft             :boolean, :default => false
+
+      layout            :string, :default => 'application', :validates => [:presence]
+      template          :string, :validates => [:presence]
+
+      slug              :string
+      roles_mask        :integer, :default => 0
+
+      timestamps
+    end
+
+    scope :drafts, -> { where(:draft => true) }
+    scope :published, -> { where(:draft => false) }
+  end
+
+end
+
+
+
+

data/app/views/admin/menu_items/_actions.html.haml

@@ -0,0 +1,4 @@
+.actions
+  %span.add-item.glyphicon.glyphicon-plus-sign
+  %span.remove-item.glyphicon.glyphicon-trash
+

data/app/views/admin/menu_items/_expand.html.haml

@@ -0,0 +1,2 @@
+%ul.dropdown-menu
+  %li.effective-menu-expand  

data/app/views/admin/menu_items/_item.html.haml

@@ -0,0 +1,13 @@
+.menu-item
+  = form.fields_for :menu_items, item do |f|
+    = f.hidden_field :title, :autocomplete => 'off'
+    = f.hidden_field :menuable_id, :autocomplete => 'off'
+    = f.hidden_field :menuable_type, :autocomplete => 'off'
+    = f.hidden_field :url, :autocomplete => 'off'
+    = f.hidden_field :special, :autocomplete => 'off'
+    = f.hidden_field :new_window, :autocomplete => 'off'
+    = f.hidden_field :classes, :autocomplete => 'off'
+    = f.hidden_field :roles_mask, :autocomplete => 'off'
+    = f.hidden_field :lft, :autocomplete => 'off'
+    = f.hidden_field :rgt, :autocomplete => 'off'
+    = f.hidden_field :_destroy, :autocomplete => 'off'

data/app/views/admin/menu_items/_new.html.haml

@@ -0,0 +1,3 @@
+%li.new-item
+  %a{:href => ''}
+  = render :partial => 'admin/menu_items/item', :locals => {:item => item, :form => form}

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

@@ -0,0 +1,4 @@
+%span.actions
+  = link_to 'Edit', effective_pages.edit_admin_menu_path(menu)
+  = '-'
+  = link_to 'Delete', effective_pages.admin_menu_path(menu), :data => {:method => :delete, :confirm => "Are you sure?  This menu will be made unavailable."}

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

@@ -0,0 +1,9 @@
+= simple_form_for(menu, (EffectivePages.simple_form_options || {}).merge(:url => (menu.persisted? ? effective_pages.admin_menu_path(menu) : effective_pages.admin_menus_path))) do |f|
+  = f.input :title, :hint => "Give this menu a title"
+
+  .form-group
+    .col-xs-12
+      .form-group
+        .pull-right
+          = f.button :submit, 'Save'
+          = link_to 'Cancel', effective_pages.admin_menus_path

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

@@ -0,0 +1,2 @@
+%h2= @page_title
+= render :partial => 'form', :as => :menu, :object => @menu

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

@@ -0,0 +1,9 @@
+%h2= @page_title
+
+- unless @datatable.collection.length > 0
+  %p
+    There are no menus
+- else
+  = render_datatable @datatable
+
+%p= link_to 'New Menu', effective_pages.new_admin_menu_path, :class => 'btn btn-primary'

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

@@ -0,0 +1,2 @@
+%h2= @page_title
+= render :partial => 'form', :as => :menu, :object => @menu

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

@@ -0,0 +1,14 @@
+%span.actions
+  = link_to 'Visit', effective_pages.page_path(page), :target => '_blank'
+  = '-'
+  - if defined?(EffectiveRegions)
+    = link_to 'Edit Content', effective_regions.edit_path(page), 'data-no-turbolink' => true
+    = '-'
+  = link_to 'Edit', effective_pages.edit_admin_page_path(page.id)
+  = '-'
+  = link_to 'Delete', effective_pages.admin_page_path(page.id), :data => {:method => :delete, :confirm => "Are you sure?  This page will be made unavailable."}
+  / = '-'
+  / - if page.draft?
+  /   = link_to "Undraft", effective_orders.undraft_admin_page_path(page)
+  / - else
+  /   = link_to "Draft", effective_orders.draft_admin_page_path(page), :data => {:method => :delete, :confirm => "Are you sure?  This page will be made unavailable."}

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

@@ -0,0 +1,31 @@
+= simple_form_for(page, (EffectivePages.simple_form_options || {}).merge(:url => (page.persisted? ? effective_pages.admin_page_path(page.id) : effective_pages.admin_pages_path))) do |f|
+  = f.input :title, :hint => "Give this page a title"
+  = f.input :draft, :hint => "Save this page as a draft.  It will not be accessible on the website."
+
+  - if !f.object.new_record? || f.object.errors.include?(:slug)
+    - current_url = (effective_pages.page_url(f.object) rescue nil)
+    = f.input :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
+
+  = f.input :meta_description, :hint => "A one or two sentence summary of this page. Appears on Google search results underneath the page title."
+
+  - if EffectivePages.pages.length == 1
+    = f.input :template, :as => :hidden, :value => EffectivePages.pages.first
+  - else
+    = f.input :template, :as => :select, :collection => EffectivePages.pages, :include_blank => false
+
+  - if EffectivePages.layouts.length == 1
+    = f.input :layout, :as => :hidden, :value => EffectivePages.layouts.first
+  - else
+    = f.input :layout, :as => :select, :collection => EffectivePages.layouts, :include_blank => false
+
+  - if defined?(EffectiveRoles) and f.object.respond_to?(:roles)
+    = f.input :roles, :collection => EffectiveRoles.roles_collection(f.object), :as => :check_boxes, :hint => '* leave blank for a regular public page that anyone can view'
+
+  .form-group
+    .col-xs-12
+      .form-group
+        .pull-right
+          = f.button :submit, 'Save'
+          - if defined?(EffectiveRegions)
+            = f.button :submit, 'Save and Edit Content'
+          = link_to 'Cancel', effective_pages.admin_pages_path