gluttonberg-core 2.6.4 → 3.0.0

data/lib/gluttonberg/components.rb

@@ -1,27 +1,55 @@
 module Gluttonberg
-  # This module allows custom controllers to be registered wtih Gluttonberg’s
-  # administration. Typically, these controllers will be registered in the
-  # application’s before_app_loads block.
+  # This module allows a developer to configure backend main and sub menues
   module Components
     @@components  = {}
     @@routes      = {}
     @@nav_entries = nil
     @@main_nav_entries = []
     @@registered  = nil
+    @@cleared = false
+    @@can_custom_model_list  = []
     Component     = Struct.new(:name, :label , :admin_url, :only_for_super_admin )
 
-    # Registers a controller — or set of controllers — based on the URLs
-    # specified in the routes.
-    #
-    #   Components.register(:forum, :label => "Forum", :admin_url => url) do |scope|
-    #     scope.resources(:posts)
-    #     scope.resources(:threads)
-    #   end
-    def self.register(name, opts = {}, &routes)
-      @@components[name] = opts
-      @@routes[name] = routes if block_given?
+    def self.clear_main_nav
+      @@main_nav_entries = []
+      @@cleared = true
+    end
+
+    def self.init_main_nav
+      unless @@cleared
+        Gluttonberg::Components.register_for_main_nav("Dashboard", "/admin", :can_model_name => "Gluttonberg::Page")
+        Gluttonberg::Components.register_for_main_nav("Content", "/admin/pages", :can_model_name => "Gluttonberg::Page")
+        Gluttonberg::Components.register_for_main_nav("Library", "/admin/assets/all/page/1", :can_model_name => "Gluttonberg::Asset")
+        Gluttonberg::Components.register_for_main_nav("Members", "/admin/membership/members", :can_model_name => "Gluttonberg::Member")
+        Gluttonberg::Components.register_for_main_nav("Settings", "/admin/configurations", :can_model_name => "Gluttonberg::Setting")
+      end
+    end
+
+    def self.register_for_main_nav(name , url, opts = {})
+      opts[:enabled] = true if opts[:enabled].blank?
+      opts[:only_for_super_admin] = false if opts[:only_for_super_admin].blank?
+      self.add_to_can_model_list(opts[:can_model_name])
+      if @@main_nav_entries.index{|entry| entry[0] == name}.blank?
+        @@main_nav_entries << [name , url, opts]
+      end
     end
 
+    # Returns an array of components that have been given a nav_label —
+    # the label implicitly registers them as nav entries. Components without
+    # a label won’t turn up.
+    def self.main_nav_entries
+      @@main_nav_entries
+    end
+
+    def self.can_custom_model_list
+      @@can_custom_model_list
+    end
+
+    # Registers a controller
+    def self.register(name, opts = {})
+      self.add_to_can_model_list(opts[:can_model_name])
+      @@components[name] = opts
+    end
 
     # Returns a hash of the registered components, keyed to their label.
     def self.registered
@@ -34,7 +62,6 @@ module Gluttonberg
     def self.nav_entries(section_name="")
       temp = @@components.find_all{|k,v| (section_name.blank? && (!v.has_key?(:section_name) || v[:section_name].blank?)) || (!section_name.blank? && v[:section_name] == section_name) }
       nav_entries = temp.collect do |k, v|
-
         url = if v[:admin_url]
           if v[:admin_url].is_a? Symbol
             v[:admin_url]
@@ -42,22 +69,18 @@ module Gluttonberg
             v[:admin_url]
           end
         end
-        [v[:label], k, url , v[:only_for_super_admin]]
+        [v[:label], k, url , v[:only_for_super_admin], v[:can_model_name]]
       end
     end
 
-
-   def self.register_for_main_nav(name , url , only_for_super_admin = false )
-      @@main_nav_entries << [name , url , only_for_super_admin]
+    def self.section_name_for_controller(controllername)
+      component = @@components[controllername.to_sym]
+      component.blank? ? nil : component[:section_name]
     end
 
-   # Returns an array of components that have been given a nav_label —
-    # the label implicitly registers them as nav entries. Components without
-    # a label won’t turn up.
-    def self.main_nav_entries
-      @@main_nav_entries
+    def self.add_to_can_model_list(model_name)
+      @@can_custom_model_list << model_name if !model_name.blank? && !["Gluttonberg::Page", "Gluttonberg::Asset", "Gluttonberg::Member", "Gluttonberg::Setting", "Gluttonberg::Gallery", ].include?(model_name)
     end
 
-
   end
 end

data/lib/gluttonberg/content.rb

@@ -9,6 +9,16 @@ require File.join(content, "content", "versioning")
 require File.join(content, "content", "clean_html")
 require File.join(content, "content", "import_export_csv")
 require File.join(content, "content", "despamilator")
+require File.join(content, "content", "page_repairer")
+require File.join(content, "content", "page_duplicate")
+require File.join(content, "content", "page_finder")
+require File.join(content, "content", "page_localization_slug")
+require File.join(content, "content", "default_template_file")
+require File.join(content, "content", "page_description_info")
+require File.join(content, "content", "page_children")
+require File.join(content, "content", "home_page_info")
+require File.join(content, "content", "page_components")
+require File.join(content, "content", "validations")
 
 module Gluttonberg
   # The content module contains a whole bunch classes and mixins related to the
@@ -63,5 +73,10 @@ module Gluttonberg
     def self.localization_associations
       @@localization_associations
     end
+
+    def self.actual_content_classes
+      Gluttonberg::Content::Block.classes
+      @@localization_classes + Block.classes.select {|c| !c.localized? }   
+    end
   end
 end

data/lib/gluttonberg/content/block.rb

@@ -4,34 +4,26 @@ module Gluttonberg
     # block. A content block is a class that can be associated with a section
     # on in a page description.
     module Block
+      extend ActiveSupport::Concern
       # A collection of the classes which have this module included in it.
       @classes = []
 
       # This included hook is used to declare the various properties and class
       # ivars we need.
-      def self.included(klass)
-
-        klass.class_eval do
-          extend Block::ClassMethods
-          include Block::InstanceMethods
-
-          cattr_accessor :localized, :label, :content_type, :association_name
-          @localized = false
-
-          attr_reader :current_localization
-
-          belongs_to :page
-
-          # Generate the various names to be used in associations
-          type = self.name.demodulize.underscore
-          self.association_name = type.pluralize.to_sym
-          self.content_type = type.to_sym
-          # Let's generate a label from the class — this might be over-ridden later
-          self.label = type.humanize
-
-        end
-
-
+      included do
+        cattr_accessor :localized, :label, :content_type, :association_name
+        @localized = false
+        attr_reader :current_localization
+
+        belongs_to :page
+        delegate :state, :_publish_status, :state_changed?, :to => :page
+
+        # Generate the various names to be used in associations
+        type = self.name.demodulize.underscore
+        self.association_name = type.pluralize.to_sym
+        self.content_type = type.to_sym
+        # Let's generate a label from the class — this might be over-ridden later
+        self.label = type.humanize
       end
 
       # register content classes. We can do this inside included block, but in rails lazyloading behavior it is not properly working.
@@ -55,36 +47,7 @@ module Gluttonberg
         def is_localized(&blk)
           self.localized = true
           self.attr_accessible :section_name
-
-          # Generate the localization model
-          class_name = "#{self.name.demodulize}Localization"
-          storage_name = "gb_#{class_name.tableize}"
-          localized_model = Class.new(ActiveRecord::Base)
-          foreign_key = self.name.foreign_key
-          localized_model.table_name = storage_name
-          Gluttonberg.const_set(class_name, localized_model)
-
-          # Mix in our base set of properties and methods
-          localized_model.send(:include, Gluttonberg::Content::BlockLocalization)
-          # Generate additional properties from the block passed in
-          localized_model.class_eval(&blk)
-          # Store the name so we can easily access it without having to look
-          # at this parent class
-          localized_model.content_type = self.content_type
-
-          # Tell the content module that we are localized
-          localized_model.association_name = "#{self.content_type}_localizations"
-          Gluttonberg::Content.register_localization( "#{self.content_type}_localizations".to_sym , localized_model)
-
-          # Set up the associations
-          has_many :localizations, :class_name => Gluttonberg.const_get(class_name).to_s  , :foreign_key => "#{self.content_type}_id" , :dependent => :destroy
-          localized_model.belongs_to(:parent, :class_name => self.name , :foreign_key => "#{self.content_type}_id")
-
-          localized_model.attr_accessible :text, :parent, :page_localization
-          localized_model.is_versioned
-
-          localized_model.clean_html([:text])
-
+          create_localization_model(&blk)
         end
 
         # Does this class have an associated localization class.
@@ -99,49 +62,100 @@ module Gluttonberg
           results.each { |r| r.load_localization(page_localization_id) }
           results
         end
+
+        private
+          def create_localization_model(&blk)
+            # Generate the localization model
+            class_name = "#{self.name.demodulize}Localization"
+            storage_name = "gb_#{class_name.tableize}"
+            localized_model = Class.new(ActiveRecord::Base)
+            foreign_key = self.name.foreign_key
+            localized_model.table_name = storage_name
+            Gluttonberg.const_set(class_name, localized_model)
+
+            # Mix in our base set of properties and methods
+            localized_model.send(:include, Gluttonberg::Content::BlockLocalization)
+            
+            # Store the name so we can easily access it without having to look
+            # at this parent class
+            localized_model.content_type = self.content_type
+
+            # Tell the content module that we are localized
+            localized_model.association_name = "#{self.content_type}_localizations".to_sym
+            Gluttonberg::Content.register_localization( localized_model.association_name , localized_model)
+
+            add_code_to_localization_model(localized_model, class_name, &blk)
+          end
+
+          def add_code_to_localization_model(localized_model, class_name, &blk)
+            # Generate additional properties from the block passed in
+            localized_model.class_eval(&blk)
+
+            # Set up the associations
+            has_many :localizations, :class_name => Gluttonberg.const_get(class_name).to_s  , :foreign_key => "#{self.content_type}_id" , :dependent => :destroy
+            localized_model.belongs_to(:parent, :class_name => self.name , :foreign_key => "#{self.content_type}_id")
+
+            localized_model.attr_accessible :text, :parent, :page_localization
+            localized_model.is_versioned
+            localized_model.delegate :current_user_id, :to => :page
+
+            localized_model.clean_html([:text])
+          end
       end
 
-      module InstanceMethods
-        # Returns the section this content instance is associated with. It does
-        # this by looking at the associated page, it’s description then the
-        # matching section.
-        def section
-          @section ||= page.description.sections[section_name.to_sym]
-        end
+      # Returns the section this content instance is associated with. It does
+      # this by looking at the associated page, it’s description then the
+      # matching section.
+      def section
+        @section ||= page.description.sections[section_name.to_sym]
+      end
 
-        # Checks to see if this content class has localized properties.
-        def localized?
-          self.class.localized?
-        end
+      # Checks to see if this content class has localized properties.
+      def localized?
+        self.class.localized?
+      end
 
-        # The name of the generated association. This is the association that
-        def association_name
-          self.class.association_name
-        end
+      # The name of the generated association. This is the association that
+      def association_name
+        self.class.association_name
+      end
 
 
-        def section_label
-          section[:label]
-        end
+      def section_label
+        section[:label]
+      end
 
-        def section_position
-          section[:position]
+      def select_options_data
+        unless section[:select_options_data].blank?
+          section[:select_options_data].call
+        else
+          []
         end
+      end
 
-        # Content type is simply the inflected version of the content class
-        # name, e.g. FooContent becomes :foo_content
-        def content_type
-          self.class.content_type
+      def select_options_default_value
+        unless section[:select_options_default_value].blank?
+          section[:select_options_default_value].call
         end
+      end
 
-        # Loads a localized version based on the specified page localization,
-        # then stashes it in an accessor
-        def load_localization(id_or_model)
-          if localized?
-            localization_id = id_or_model.is_a?(Numeric) ? id_or_model : id_or_model.id
-            conditions = {:page_localization_id => localization_id, :"#{self.class.content_type}_id" => id}
-            @current_localization = localizations.find(:first , :conditions => conditions)
-          end
+      def section_position
+        section[:position] if section
+      end
+
+      # Content type is simply the inflected version of the content class
+      # name, e.g. FooContent becomes :foo_content
+      def content_type
+        self.class.content_type
+      end
+
+      # Loads a localized version based on the specified page localization,
+      # then stashes it in an accessor
+      def load_localization(id_or_model)
+        if localized?
+          localization_id = id_or_model.is_a?(Numeric) ? id_or_model : id_or_model.id
+          conditions = {:page_localization_id => localization_id, :"#{self.class.content_type}_id" => id}
+          @current_localization = localizations.find(:first , :conditions => conditions)
         end
       end
     end

data/lib/gluttonberg/content/block_localization.rb

@@ -6,12 +6,11 @@ module Gluttonberg
     # 
     # These just defer to the parent class.
     module BlockLocalization
-      def self.included(klass)
-        klass.class_eval do
-          class << self; attr_accessor :content_type, :association_name end
-          
-          belongs_to :page_localization
-        end
+      extend ActiveSupport::Concern
+      included do
+        cattr_accessor :content_type, :association_name
+        belongs_to :page_localization
+        delegate :state, :_publish_status, :state_changed?, :to => :page, :allow_nil => true
       end
       
       def association_name
@@ -23,16 +22,20 @@ module Gluttonberg
       end
       
       def section_name
-        parent.section[:name]
+        parent.section[:name] if parent && parent.section
       end
       
       def section_position
-        parent.section[:position]
+        parent.section[:position] if parent && parent.section
       end
       
       def section_label
         parent.section[:label] unless parent.blank?
       end
+
+      def page
+        self.page_localization.page
+      end
     end
   end
 end

data/lib/gluttonberg/content/clean_html.rb

@@ -1,18 +1,12 @@
 module Gluttonberg
   module Content
-
+    # This mixin provides helper methods which are used to clean html
     module CleanHtml
-
+      extend ActiveSupport::Concern
       def self.setup
         ::ActiveRecord::Base.send :include, Gluttonberg::Content::CleanHtml
       end
 
-      def self.included(klass)
-        klass.class_eval do
-          extend  ClassMethods
-        end
-      end
-
       module ClassMethods
         def clean_html(cols)
           class_eval <<-EOV
@@ -29,12 +23,13 @@ module Gluttonberg
             str = self.removeStyle(str)
             str = self.removeMetaTag(str)
             str = removeEmptyTag(str)
+            str = removeDuplicatedBreaks(str)
           end
           str
         end
 
         def removeEmptyTag(str)
-          removeList = [/<blockquote>[\s]*<\/blockquote>/, /<p>[\s]*<\/p>/,/<div>[\s]*<\/div>/,/<span>[\s]*<\/span>/, /<h1>[\s]*<\/h1>/, /<h2>[\s]*<\/h2>/, /<h3>[\s]*<\/h3>/, /<h4>[\s]*<\/h4>/, /<h5>[\s]*<\/h5>/, /<h6>[\s]*<\/h6>/ , /<br[\s]*\/>/ , /<br[\s]*>/]
+          removeList = [/<blockquote>[\s]*<\/blockquote>/, /<p>[\s]*<\/p>/,/<div>[\s]*<\/div>/,/<span>[\s]*<\/span>/, /<h1>[\s]*<\/h1>/, /<h2>[\s]*<\/h2>/, /<h3>[\s]*<\/h3>/, /<h4>[\s]*<\/h4>/, /<h5>[\s]*<\/h5>/, /<h6>[\s]*<\/h6>/]
           removeList.each do |r|
             str = str.gsub(r,"")
           end
@@ -42,6 +37,10 @@ module Gluttonberg
           str
         end
 
+        def removeDuplicatedBreaks(str)
+          str.gsub(/((<br[\s]*\/>[\s]*)|(<br[\s]*>[\s]*))+/,'<br/>')
+        end
+
         def removeStyle(str)
           removeList = [/style=\"[\sA-Za-z0-9.,-;:]*\"/]
           removeList.each do |r|
@@ -61,12 +60,10 @@ module Gluttonberg
         end
       end
 
-      module InstanceMethods
-        def clean_all_html_content
-          unless self.class.html_columns_list.blank?
-            self.class.html_columns_list.each do |field|
-              write_attribute(field , self.class.clean_tags(read_attribute(field)) )
-            end
+      def clean_all_html_content
+        unless self.class.html_columns_list.blank?
+          self.class.html_columns_list.each do |field|
+            write_attribute(field , self.class.clean_tags(read_attribute(field)) )
           end
         end
       end