hancock_cms_pages 1.0.0 → 1.0.2

data/lib/hancock/pages/models/blockset.rb

@@ -11,15 +11,62 @@ module Hancock::Pages
       included do
         manual_slug :name
 
-        def self.manager_can_add_actions
+        def render(view = Hancock::Pages::PagesController.new, content = "")
+          if view.is_a?(Hash)
+            view, content = view[:view] || Hancock::Pages::PagesController.new, view[:content]
+          end
+          Hancock::Pages.config.renderer_lib_extends.each do |lib_extends|
+            unless view.class < lib_extends
+              if view.respond_to?(:prepend)
+                view.prepend lib_extends
+              else
+                view.extend lib_extends
+              end
+            end
+          end
+
+          ret = content
+          if use_wrapper
+            _attrs = {
+              class: wrapper_class,
+              id: wrapper_id
+            }.merge(wrapper_attributes)
+            ret = view.content_tag wrapper_tag, ret, _attrs
+          end
+          ret = yield ret if block_given?
+          return ret
+        end
+
+        def wrapper_attributes=(val)
+          if val.is_a? (String)
+            begin
+              begin
+                self[:wrapper_attributes] = JSON.parse(val)
+              rescue
+                self[:wrapper_attributes] = YAML.load(val)
+              end
+            rescue
+            end
+          elsif val.is_a?(Hash)
+            self[:wrapper_attributes] = val
+          else
+            self[:wrapper_attributes] = wrapper_attributes
+          end
+        end
+
+      end
+
+
+      class_methods do
+        def manager_can_add_actions
           ret = [:sort_embedded]
           # ret += [:multiple_file_upload, :sort_embedded] if Hancock::Pages.mongoid?
           ret << :model_settings if Hancock::Pages.config.model_settings_support
-          ret << :model_accesses if Hancock::Pages.config.user_abilities_support
+          # ret << :model_accesses if Hancock::Pages.config.user_abilities_support
           ret += [:comments, :model_comments] if Hancock::Pages.config.ra_comments_support
           ret.freeze
         end
-        def self.rails_admin_add_visible_actions
+        def rails_admin_add_visible_actions
           ret = [:sort_embedded]
           # ret += [:multiple_file_upload, :sort_embedded] if Hancock::Pages.mongoid?
           ret << :model_settings if Hancock::Pages.config.model_settings_support
@@ -29,41 +76,6 @@ module Hancock::Pages
         end
       end
 
-
-      def render(view, content = "")
-        if view.is_a?(Hash)
-          view, content = view[:view], view[:content]
-        end
-        ret = content
-        if use_wrapper
-          _attrs = {
-            class: wrapper_class,
-            id: wrapper_id
-          }.merge(wrapper_attributes)
-          ret = view.content_tag wrapper_tag, ret, _attrs
-        end
-        ret = yield ret if block_given?
-        return ret
-      end
-
-      def wrapper_attributes=(val)
-        if val.is_a? (String)
-          begin
-            begin
-              self[:wrapper_attributes] = JSON.parse(val)
-            rescue
-              self[:wrapper_attributes] = YAML.load(val)
-            end
-          rescue
-          end
-        elsif val.is_a?(Hash)
-          self[:wrapper_attributes] = val
-        else
-          self[:wrapper_attributes] = wrapper_attributes
-        end
-      end
-
-
     end
   end
 end

data/lib/hancock/pages/models/menu.rb

@@ -6,41 +6,50 @@ module Hancock::Pages
       include Hancock::Enableable
       include ManualSlug
 
-      include Hancock::Cacheable
+      if Hancock::Pages.config.cache_support
+        include Hancock::Cache::Cacheable
+      end
 
       include Hancock::Pages.orm_specific('Menu')
 
       included do
-        def self.default_cache_keys
-          ['menus']
-        end
 
         manual_slug :name
 
-        def self.manager_can_add_actions
+        def page_class
+          self.class.page_class
+        end
+      end
+
+      class_methods do
+        if Hancock::Pages.config.cache_support
+          def default_cache_keys
+            ['menus']
+          end
+        end
+
+        def page_class
+          Hancock::Pages::Page
+        end
+
+        def manager_can_add_actions
           ret = []
           # ret += [:multiple_file_upload, :sort_embedded] if Hancock::Pages.mongoid?
           ret << :model_settings if Hancock::Pages.config.model_settings_support
-          ret << :model_accesses if Hancock::Pages.config.user_abilities_support
+          # ret << :model_accesses if Hancock::Pages.config.user_abilities_support
+          ret << :hancock_touch if Hancock::Pages.config.cache_support
           ret += [:comments, :model_comments] if Hancock::Pages.config.ra_comments_support
           ret.freeze
         end
-        def self.rails_admin_add_visible_actions
+        def rails_admin_add_visible_actions
           ret = []
           # ret += [:multiple_file_upload, :sort_embedded] if Hancock::Pages.mongoid?
           ret << :model_settings if Hancock::Pages.config.model_settings_support
           ret << :model_accesses if Hancock::Pages.config.user_abilities_support
+          ret << :hancock_touch if Hancock::Pages.config.cache_support
           ret += [:comments, :model_comments] if Hancock::Pages.config.ra_comments_support
           ret.freeze
         end
-
-        def self.page_class
-          Hancock::Pages::Page
-        end
-
-        def page_class
-          self.class.page_class
-        end
       end
 
     end

data/lib/hancock/pages/models/mongoid/block.rb

@@ -15,6 +15,19 @@ module Hancock::Pages
           field :render_file, type: Boolean, default: true
           embedded_in :blockset, inverse_of: :blocks, class_name: "Hancock::Pages::Blockset"
 
+          validates_inclusion_of :file_path, in: proc {
+            # Settings.hancock_pages_blocks_whitelist.lines.map(&:strip).compact
+            # Hancock::Pages.whitelist_as_array.compact
+            (Hancock::Pages.whitelist_as_array - Hancock::Pages.blacklist_as_array).compact
+          }, allow_blank: true
+          # validates_inclusion_of :file_path, in: proc {
+          #   Hancock::Pages::Blockset.settings.blocks_whitelist.lines.map(&:strip).compact
+          # }, allow_blank: true
+
+          def self.find(id)
+            find_through(Hancock::Pages::Blockset, 'blocks', id)
+          end
+
           hancock_cms_html_field :content, type: String, localize: Hancock::Pages.config.localize, default: ""
 
           field :use_wrapper, type: Boolean, default: false

data/lib/hancock/pages/models/mongoid/blockset.rb

@@ -5,6 +5,8 @@ module Hancock::Pages
         extend ActiveSupport::Concern
 
         included do
+          index({enabled: 1, name: 1}, {background: true})
+
           field :name, type: String, default: "", overwrite: true
 
           embeds_many :blocks, inverse_of: :blockset, class_name: "Hancock::Pages::Block"
@@ -16,6 +18,7 @@ module Hancock::Pages
           field :wrapper_id, type: String, default: ""
           field :wrapper_attributes, type: Hash, default: {}
         end
+        
       end
     end
   end

data/lib/hancock/pages/models/mongoid/menu.rb

@@ -5,11 +5,14 @@ module Hancock::Pages
         extend ActiveSupport::Concern
 
         included do
-          has_and_belongs_to_many :pages, inverse_of: :menus, class_name: "Hancock::Pages::Page"
+          index({enabled: 1, name: 1}, {background: true})
+
+          has_and_belongs_to_many :pages, inverse_of: :menus, class_name: "Hancock::Pages::Page", index: true
           alias_method :items, :pages
 
           field :name, type: String, default: "", overwrite: true
         end
+        
       end
     end
   end

data/lib/hancock/pages/models/mongoid/page.rb

@@ -7,24 +7,30 @@ module Hancock::Pages
         include Hancock::HtmlField
 
         included do
+          index({enabled: 1, lft: 1, menu_ids: 1}, {background: true})
+          index({parent_id: 1}, {background: true})
+          index({hancock_connectable_id: 1, hancock_connectable_type: 1}, {background: true})
+          index({enabled: 1, fullpath: 1}, {background: true})
+
           scope :connected, -> {
-            where(:connectable_id.ne => nil)
+            where(:hancock_connectable_id.ne => nil)
           }
           scope :unconnected, -> (except_this = nil) {
             if except_this
               where({"$or" =>[
-                {:connectable_id => nil},
+                {:hancock_connectable_id => nil},
                 {"$and" => [
-                  {connectable_type: except_this.class.to_param},
-                  {connectable_id: except_this._id}
+                  {hancock_connectable_type: except_this.class.to_param},
+                  {hancock_connectable_id: except_this._id}
                 ]}
               ]})
             else
-              where(:connectable_id => nil)
+              where(:hancock_connectable_id => nil)
             end
           }
 
           field :name, type: String, localize: Hancock::Pages.config.localize, default: ""
+          field :layout_name, type: String, default: "application"
 
           field :regexp, type: String, default: ""
           field :redirect, type: String, default: ""
@@ -32,11 +38,18 @@ module Hancock::Pages
           hancock_cms_html_field :content, type: String, localize: Hancock::Pages.config.localize, default: ""
           field :fullpath, type: String, default: ""
 
-          has_and_belongs_to_many :menus, inverse_of: :pages, class_name: "Hancock::Pages::Menu"
+          field :use_wrapper, type: Boolean, default: false
+          field :wrapper_tag, type: String, default: ""
+          field :wrapper_class, type: String, default: ""
+          field :wrapper_id, type: String, default: ""
+          field :wrapper_attributes, type: Hash, default: {}
+
+          has_and_belongs_to_many :menus, inverse_of: :pages, class_name: "Hancock::Pages::Menu", index: true
 
           scope :sorted, -> { order_by([:lft, :asc]) }
           scope :menu, ->(menu_id) { enabled.sorted.where(menu_ids: menu_id) }
         end
+
       end
     end
   end

data/lib/hancock/pages/models/page.rb

@@ -10,6 +10,13 @@ module Hancock::Pages
         include Hancock::Seo::SitemapDataField
       end
 
+      if Hancock::Pages.config.cache_support
+        include Hancock::Cache::Cacheable
+      end
+      if Hancock::Pages.config.insertions_support
+        include Hancock::InsertionField
+      end
+
       include Hancock::Pages.orm_specific('Page')
 
       # if Hancock.config.search_enabled
@@ -28,130 +35,229 @@ module Hancock::Pages
 
 
         if Hancock.rails4?
-          belongs_to :connectable, polymorphic: true
+          belongs_to :hancock_connectable, polymorphic: true
         else
-          belongs_to :connectable, polymorphic: true, optional: true
-        end
-
-        def self.goto_hancock
-          self.where(connectable_type: /^Enjoy/).all.map { |s|
-            s.connectable_type = s.connectable_type.sub("Enjoy", "Hancock");
-            s.save
-          }
+          belongs_to :hancock_connectable, polymorphic: true, optional: true
         end
 
         before_save do
-          self.connectable_id = nil   if self.connectable_type.nil?
-          self.connectable_type = nil if self.connectable_id.nil?
+          self.hancock_connectable_id = nil   if self.hancock_connectable_id.nil?
+          self.hancock_connectable_type = nil if self.hancock_connectable_type.nil?
           self
         end
 
-        def self.manager_can_add_actions
-          ret = [:nested_set]
-          # ret += [:multiple_file_upload, :sort_embedded] if Hancock::Pages.mongoid?
-          ret << :model_settings if Hancock::Pages.config.model_settings_support
-          ret << :model_accesses if Hancock::Pages.config.user_abilities_support
-          ret += [:comments, :model_comments] if Hancock::Pages.config.ra_comments_support
-          ret.freeze
+        if Hancock::Pages.config.insertions_support
+          insertions_for(:excerpt_html)
+          insertions_for(:content_html)
         end
-        def self.rails_admin_add_visible_actions
-          ret = [:nested_set]
-          # ret += [:multiple_file_upload, :sort_embedded] if Hancock::Pages.mongoid?
-          ret << :model_settings if Hancock::Pages.config.model_settings_support
-          ret << :model_accesses if Hancock::Pages.config.user_abilities_support
-          ret += [:comments, :model_comments] if Hancock::Pages.config.ra_comments_support
-          ret.freeze
+        def page_excerpt(view = Hancock::Pages::PagesController.new)
+          if @excerpt_used.nil?
+            if excerpt.nil?
+              @excerpt_used = true
+              ''
+            else
+              view.extend ActionView::Helpers::TagHelper
+              view.extend ActionView::Context
+              # {{BS|%blockset_name%}}
+              # excerpt.gsub(/\{\{(.*?)\}\}/) do
+              _excerpt = excerpt.gsub(/\{\{BS\|(.*?)\}\}/) do
+                bs = Hancock::Pages::Blockset.enabled.where(name: $1).first
+                if bs
+                  begin
+                    view.render_blockset(bs, called_from: {object: self, method: :page_excerpt})
+                  rescue Exception => exception
+                    if Hancock::Pages.config.verbose_render
+                      Rails.logger.error exception.message
+                      Rails.logger.error exception.backtrace.join("\n")
+                      puts exception.message
+                      puts exception.backtrace.join("\n")
+                    end
+                    Raven.capture_exception(exception) if Hancock::Pages.config.raven_support
+                  end
+                end
+
+              # {{self.%insertion%}}
+              end.gsub(/(\{\{self\.(.*?)\}\})/) do
+                if Hancock::Pages.config.insertions_support
+                  get_insertion($2)
+                else
+                  $1
+                end
+
+              # {{"some_text"}} #temporary disabled - need tests
+              # {{"some_text"}}
+              # end.gsub(/\{\{(\'|\"|&quot;|&#39;)(.*?)(\1)\}\}/) do
+              #   $2
+
+              # {{%ns%.%key%}}
+              end.gsub(/\{\{(([^\.]*?)\.)?(.*?)\}\}/) do
+                (Settings and !$3.nil? and $2 != "self") ? Settings.ns($2).get($3).val : "" #temp
+              end
+              @excerpt_used = true
+              _excerpt
+            end
+          else
+            ''
+          end
         end
-      end
 
-      def page_h1
-        _ret = seo ? seo.h1 : nil
-        _ret = name   if _ret.blank?
-        _ret = title  if _ret.blank?
-        _ret
-      end
+        def page_content(view = Hancock::Pages::PagesController.new)
+          if @content_used.nil?
+            if content.nil?
+              @content_used = true
+              ''
+            else
+              view.extend ActionView::Helpers::TagHelper
+              view.extend ActionView::Context
 
-      def get_fullpath
-        redirect.blank? ? fullpath : redirect
-      end
+              # {{BS|%blockset_name%}}
+              # content.gsub(/\{\{(.*?)\}\}/) do
+              _content = content.gsub(/\{\{BS\|(.*?)\}\}/) do
+                bs = Hancock::Pages::Blockset.enabled.where(name: $1).first
+                if bs
+                  begin
+                    view.render_blockset(bs, called_from: {object: self, method: :page_content})
+                  rescue Exception => exception
+                    if Hancock::Pages.config.verbose_render
+                      Rails.logger.error exception.message
+                      Rails.logger.error exception.backtrace.join("\n")
+                      puts exception.message
+                      puts exception.backtrace.join("\n")
+                    end
+                    Raven.capture_exception(exception) if Hancock::Pages.config.raven_support
+                  end
+                end
 
+              # {{self.%insertion%}}
+              end.gsub(/(\{\{self\.(.*?)\}\})/) do
+                if Hancock::Pages.config.insertions_support
+                  get_insertion($2)
+                else
+                  $1
+                end
 
-      def has_excerpt?
-        @excerpt_used.nil? && !excerpt.blank?
-      end
+              # {{"some_text"}} #temporary disabled - need tests
+              # end.gsub(/\{\{(['"])(.*?)(\1)\}\}/) do
+              # end.gsub(/\{\{(\'|\"|&quot;|&#39;)(.*?)(\1)\}\}/) do
+              #   $2
 
-      def page_excerpt
-        if @excerpt_used.nil?
-          @excerpt_used = true
-          if excerpt.nil?
-            ''
-          else
-            # excerpt.gsub(/\{\{(.*?)\}\}/) do
-            excerpt.gsub(/\{\{(([^\.]*?)\.)?(.*?)\}\}/) do
-              (Settings and !$3.nil?) ? Settings.ns($2).get($3).val : "" #temp
+              # {{%ns%.%key%}}
+              end.gsub(/\{\{(([^\.]*?)\.)?(.*?)\}\}/) do
+                ((Settings and !$3.nil? and $2 != "self") ? Settings.ns($2).get($3).val : "") rescue "" #temp
+              end
             end
+            @content_used = true
+            _content
+          else
+            ''
           end
-        else
-          ''
         end
-      end
 
+        def page_h1
+          _ret = seo ? seo.h1 : nil
+          _ret = name   if _ret.blank?
+          _ret = title  if _ret.blank?
+          _ret
+        end
+
+        def get_fullpath
+          redirect.blank? ? fullpath : redirect
+        end
 
-      def has_content?
-        @content_used.nil? && !content.blank?
-      end
+        def has_excerpt?
+          @excerpt_used.nil? && !excerpt.blank?
+        end
 
-      def page_content
-        if @content_used.nil?
-          @content_used = true
-          if content.nil?
-            ''
+
+        def has_content?
+          @content_used.nil? && !content.blank?
+        end
+
+        def is_current?(url)
+          if fullpath == '/'
+            url == '/'
           else
-            # content.gsub(/\{\{(.*?)\}\}/) do
-            content.gsub(/\{\{(([^\.]*?)\.)?(.*?)\}\}/) do
-              (Settings and !$3.nil?) ? Settings.ns($2).get($3).val : "" #temp
+            url.match(clean_regexp)
+          end
+        end
+
+        def regexp_prefix
+          Hancock::Pages.config.localize ? "(?:#{I18n.available_locales.map { |l| "\\/#{l}"}.join("|")})?" : ""
+        end
+
+        def clean_regexp
+          if regexp.blank?
+            /^#{regexp_prefix}#{Regexp.escape(fullpath)}$/
+          else
+            begin
+              /#{regexp}/
+            rescue
+              # not a valid regexp - treat as literal search string
+              /#{Regexp.escape(regexp)}/
             end
           end
-        else
-          ''
         end
-      end
 
-      def is_current?(url)
-        if fullpath == '/'
-          url == '/'
-        else
-          url.match(clean_regexp)
+        def nav_options
+          nav_options_default.merge(nav_options_additions)
         end
-      end
 
-      def regexp_prefix
-        Hancock::Pages.config.localize ? "(?:#{I18n.available_locales.map { |l| "\\/#{l}"}.join("|")})?" : ""
-      end
+        def nav_options_default
+          {highlights_on: clean_regexp}
+        end
 
-      def clean_regexp
-        if regexp.blank?
-          /^#{regexp_prefix}#{Regexp.escape(fullpath)}$/
-        else
-          begin
-            /#{regexp}/
-          rescue
-            # not a valid regexp - treat as literal search string
-            /#{Regexp.escape(regexp)}/
+        def nav_options_additions
+          {}
+        end
+
+        def wrapper_attributes=(val)
+          if val.is_a? (String)
+            begin
+              begin
+                self[:wrapper_attributes] = JSON.parse(val)
+              rescue
+                self[:wrapper_attributes] = YAML.load(val)
+              end
+            rescue
+            end
+          elsif val.is_a?(Hash)
+            self[:wrapper_attributes] = val
+          else
+            self[:wrapper_attributes] = wrapper_attributes
           end
         end
-      end
 
-      def nav_options
-        nav_options_default.merge(nav_options_additions)
       end
 
-      def nav_options_default
-        {highlights_on: clean_regexp}
-      end
 
-      def nav_options_additions
-        {}
+      class_methods do
+
+        def goto_hancock
+          self.where(hancock_connectable_type: /^Enjoy/).all.map { |s|
+            s.hancock_connectable_type = s.hancock_connectable_type.sub("Enjoy", "Hancock");
+            s.save
+          }
+        end
+
+        def manager_can_add_actions
+          ret = [:nested_set]
+          # ret += [:multiple_file_upload, :sort_embedded] if Hancock::Pages.mongoid?
+          ret << :model_settings if Hancock::Pages.config.model_settings_support
+          # ret << :model_accesses if Hancock::Pages.config.user_abilities_support
+          ret << :hancock_touch if Hancock::Pages.config.cache_support
+          ret += [:comments, :model_comments] if Hancock::Pages.config.ra_comments_support
+          ret.freeze
+        end
+        def rails_admin_add_visible_actions
+          ret = [:nested_set]
+          # ret += [:multiple_file_upload, :sort_embedded] if Hancock::Pages.mongoid?
+          ret << :model_settings if Hancock::Pages.config.model_settings_support
+          ret << :model_accesses if Hancock::Pages.config.user_abilities_support
+          ret << :hancock_touch if Hancock::Pages.config.cache_support
+          ret += [:comments, :model_comments] if Hancock::Pages.config.ra_comments_support
+          ret.freeze
+        end
+
       end
 
     end