gluttonberg-core 2.6.4 → 3.0.0

data/app/models/gluttonberg/page_localization.rb

@@ -1,118 +1,115 @@
 module Gluttonberg
+  # PageLocalization model stores meta information regarding localization of page.
   class PageLocalization < ActiveRecord::Base
+    # Mixin for managing page localization slug and path releated functionality
+    include Content::PageLocalizationSlug
+
+    self.table_name = "gb_page_localizations"
+
     belongs_to :page, :class_name => "Gluttonberg::Page"
     belongs_to :locale
-    self.table_name = "gb_page_localizations"
     belongs_to :fb_icon , :class_name => "Gluttonberg::Asset" , :foreign_key => "fb_icon_id"
 
-    attr_accessible :name, :slug, :navigation_label, :seo_title, :seo_keywords, :seo_description, :fb_icon_id, :contents, :locale_id
+    attr_accessible :name, :path , :slug, :navigation_label, :seo_title, :seo_keywords, :seo_description, :fb_icon_id, :contents, :locale_id
 
     attr_accessor :current_path
+    delegate :version, :loaded_version, :versions, :to => :first_content, :allow_nil => true
 
-    # Iterate block/content classes to just load these constants before setting up association with their localization. This is kind of hack for lazyloading
+    # Iterate block/content classes to just load these constants before 
+    # setting up association with their localization. This is kind of hack for lazyloading
     Gluttonberg::Content::Block.classes.uniq.each do |klass|
       Gluttonberg.const_get klass.name.demodulize
     end
 
+    # association for all localized contents
     Gluttonberg::Content.localizations.each do |assoc, klass|
       has_many  assoc, :class_name => klass.to_s
     end
+    
+    # Included mixins which are registered by host app for extending functionality
+    MixinManager.load_mixins(self)
 
     after_save :update_content_localizations
     attr_accessor :paths_need_recaching, :content_needs_saving
 
-    # Write an explicit setter for the slug so we can check it’s not a blank
-    # value. This stops it being overwritten with an empty string.
-    def slug=(new_slug)
-      write_attribute(:slug, new_slug) unless new_slug.blank?
-    end
 
-    # Returns an array of content localizations
+    # Returns an array of all contents (for localized contents its return content localizations)
     def contents
       @contents ||= begin
+        # First collect the localized content
+        contents_data = localized_contents
+        contents_data = [] if contents_data.blank?
+        # Then grab the content that belongs directly to the page
+        contents_data << non_localized_contents
+        unless contents_data.blank?
+          contents_data = contents_data.flatten.sort{|a,b| a.section_position <=> b.section_position}
+        end
+      end
+      @contents
+    end
+
+    def first_content
+      contents.first
+    end
+
+    # Returns an array of content localizations
+    def localized_contents
+      @localized_contents ||= begin
         # First collect the localized content
         contents_data = Gluttonberg::Content.localization_associations.inject([]) do |memo, assoc|
           memo += send(assoc).all
         end
-        # Then grab the content that belongs directly to the page
-        Gluttonberg::Content.non_localized_associations.inject(contents_data) do |memo, assoc|
-          contents_data += page.send(assoc).all
+        contents_data = contents_data.delete_if {|a| a.section_position.blank? }
+        contents_data = contents_data.sort{|a,b| a.section_position <=> b.section_position}
+      end
+      @localized_contents
+    end
+
+    # Returns an array of non localized contents
+    def non_localized_contents
+      @non_localized_contents ||= begin
+        # grab the content that belongs directly to the page
+        contents_data = Gluttonberg::Content.non_localized_associations.inject([]) do |memo, assoc|
+          memo += page.send(assoc).all
         end
+        contents_data = contents_data.delete_if {|a| a.section_position.blank? }
         contents_data = contents_data.sort{|a,b| a.section_position <=> b.section_position}
       end
-      @contents
+      @non_localized_contents
     end
 
-    # Updates each localized content record and checks their validity
+    # Updates each content record and checks their validity
     def contents=(params)
       self.content_needs_saving = true
       contents.each do |content|
-        update = params[content.association_name][content.id.to_s]
+        content_page_publishing_info(content)
+        content_association = params[content.association_name]
+        content_association = params[content.association_name.to_s] if content_association.blank?
+        update = content_association[content.id.to_s]
         content.attributes = update if update
       end
     end
 
-    def paths_need_recaching?
-      @paths_need_recaching
-    end
-
     def name_and_code
       "#{name} (#{locale.name})"
     end
 
-    def public_path
-        if Gluttonberg.localized?
-          "/#{self.locale.slug}/#{self.path}"
-        else
-          "/#{self.path}"
-        end
-    end
-
-
-    # Forces the localization to regenerate it's full path. It will firstly
-    # look to see if there is a parent page that it need to derive the path
-    # prefix from. Otherwise it will just use the slug, with a fall-back
-    # to it's page's default.
-    def regenerate_path
-
-      self.current_path = self.path
-
-      page.reload #forcing that do not take cached page object
-      slug = nil if slug.blank?
-      if page.parent_id && page.parent.home != true
-        localization = page.parent.localizations.find(:first,
-          :conditions => {
-            :locale_id  => locale_id
-          }
-        )
-        new_path = "#{localization.path}/#{self.slug || page.slug}"
-      else
-        new_path = "#{self.slug || page.slug}"
-      end
-
-      # check duplication: add id at the end if its duplicated
-      already_exist = self.class.where([ "path = ? AND page_id != ? ", new_path, page.id]).all
-      if !already_exist.blank?
-        if already_exist.length > 1 || (already_exist.length == 1 && already_exist.first.id != self.id )
-          new_path= "#{new_path}_#{already_exist.length+1}"
-        end
-      end
-      self.previous_path = self.current_path
-      write_attribute(:path, new_path)
-    end
-
-    # Regenerates and saves the path to this localization.
-    def regenerate_path!
-      regenerate_path
-      save
-    end
-
     private
 
+      # save all contents if they need saving.
       def update_content_localizations
         contents.each { |c| c.save } if self.content_needs_saving
       end
 
+      # assign publishing info to content object its required for publishing/authorization system
+      def content_page_publishing_info(content)
+        content_page = content.respond_to?(:page) ? content.page : content.parent.page
+        unless content_page.blank?
+          content_page.state = self.page.state
+          content_page._publish_status = self.page._publish_status
+          content_page.current_user_id = self.page.current_user_id
+        end
+      end
 
   end
 end

data/app/models/gluttonberg/plain_text_content.rb

@@ -1,10 +1,16 @@
 module Gluttonberg
+  # Page content for plain text field. All content/localization related functionality 
+  # is provided Content::Block mixin 
+  # Stores user input in :text column all other information is just meta information
   class PlainTextContent  < ActiveRecord::Base
     self.table_name = "gb_plain_text_contents"
 
+    attr_accessible :text
+
     include Content::Block
 
     is_localized do
+      attr_accessible :text
     end
 
   end

data/app/models/gluttonberg/repeater.rb

@@ -0,0 +1,30 @@
+module Gluttonberg
+  class Repeater < ActiveRecord::Base
+    self.table_name = "gb_repeater"
+
+    belongs_to :itemable, :polymorphic => true
+    belongs_to :repeatable, :polymorphic => true
+    
+
+    attr_accessible :itemable, :itemable_id, :itemable_type
+    attr_accessible :repeatable, :repeatable_type, :repeatable_id
+    attr_accessible :title
+    attr_accessible :position
+    
+    # Included mixins which are registered by host app for extending functionality
+    MixinManager.load_mixins(self)
+
+    def duplicate!(dup_repeatable)
+      @cloned_repeater = self.dup
+      @cloned_repeater.position = nil
+      @cloned_repeater.created_at = Time.now
+      @cloned_repeater.repeatable = dup_repeatable
+      if @cloned_repeater.save
+        @cloned_repeater
+      else
+        return nil
+      end
+    end
+
+  end
+end

data/app/models/gluttonberg/search.rb

@@ -1,64 +1,31 @@
 # encoding: utf-8
 require 'will_paginate/array'
 module Gluttonberg
+  # this class do text based searching. 
+  # It supports like query for mysql and native postgresql text based searching for postgresql
   class Search
-
-    # Iterate block/content classes to just load these constants before setting up association with their localization. This is kind of hack for lazyloading
-    Gluttonberg::Content::Block.classes.uniq.each do |klass|     
-      Gluttonberg.const_get klass.name.demodulize
-    end
-
-    # if postgresql and their is not special search engine then index data using texticle for postgresql
-    if ActiveRecord::Base.configurations[Rails.env]["adapter"] == "postgresql"
-      Rails.configuration.search_models.each do |model , columns|
-        model =  eval(model)
-        model.index do
-          columns.each do |column|
-            send(column) 
-          end
-        end        
-      end
-    end  
-    
-  
-    # if search engine is provided the use its custom methods
-    # otherwise use texticle for postgresql and like queries for mysql
-    # opts = {
-    #   :sources => [],
-    #   :published_only => true,
-    #   :per_page => 20,
-    #   :page => 1
-    # }
     def self.find(query, opts = {} )
       query= query.gsub(/[\\\!\*″′‟‛„‚”“”˝\(\)\;\:\.\@\&\=\+\$\,\/?\%\#\[\]]/, '')
       query = query.gsub(/'/, "\\\\'")
       query = query.gsub(/"/, "\\\"")
-            
-      models = {}
-      sources = opts[:sources]
+
       published_only = opts[:published_only].blank? ? true : opts[:published_only]
-      per_page = opts[:per_page].blank? ? Gluttonberg::Setting.get_setting("number_of_per_page_items") : opts[:per_page]
-      page_num = opts[:page]
-      # if sources are provided then only look in sources models. It is only required when user want to search in specified models.
-      if sources.blank?
-        models = Rails.configuration.search_models
-      else
-        sources.each do |src|
-          models[src] = Rails.configuration.search_models[src]
-        end
-      end
-      
-      case self.dbms_name
+      per_page = Gluttonberg::Setting.get_setting("number_of_per_page_items") || opts[:per_page]
+      # if sources are provided then only look in sources models. 
+      # It is only required when user want to search in specified models.
+      models = self.find_models(opts[:sources])
+
+      case Gluttonberg.dbms_name
         when "mysql"
-          find_in_mysql(query, page_num , per_page , models , published_only)
+          find_in_mysql(query, opts[:page] , per_page , models , published_only)
         when "postgresql"
-          find_in_postgresql(query, page_num , per_page, models , published_only)
+          find_in_postgresql(query, opts[:page] , per_page, models , published_only)
       end
     end
-  
+
     def self.find_in_mysql(query, page_num , per_page , models , published_only)
       results = []
-      
+
       prepared_query = "'%#{query}%'"
       models.each do |model , columns|
         conditions = ""
@@ -69,7 +36,7 @@ module Gluttonberg
         model =  eval(model) #convert class name from sting to a constant
         if published_only == true && model.respond_to?(:published)
           results << model.published.find(:all , :conditions => conditions )
-        else  
+        else
           results << model.find(:all , :conditions => conditions )
         end
       end
@@ -77,14 +44,14 @@ module Gluttonberg
       results.uniq!
       replace_contents_with_page(results).paginate(:per_page => per_page , :page => page_num )
     end
-  
+
     def self.find_in_postgresql(query, page_num , per_page , models , published_only)
       results = []
       models.each do |model , columns|
         model =  eval(model) #convert class name from sting to a constant
         if published_only == true && model.respond_to?(:published)
           results << model.published.search(query)
-        else  
+        else
           results << model.search(query)
         end
       end
@@ -92,34 +59,91 @@ module Gluttonberg
       results.uniq!
       replace_contents_with_page(results).paginate(:per_page => per_page , :page => page_num )
     end
-  
-    
-    
-    private 
-      
-      def self.dbms_name
-        adapter_name = ActiveRecord::Base.configurations[Rails.env]["adapter"]
-        if ["mysql2" , "mysql"].include?(adapter_name)
-          "mysql"
-        elsif adapter_name == "postgresql"
-          "postgresql"
-        else
-          adapter_name.to_s
+
+
+    def self.load_block_classes
+      Gluttonberg::Content::Block.classes.uniq.each do |klass|
+        Gluttonberg.const_get klass.name.demodulize
+      end
+    end
+
+    def self.index_data_using_texticle
+      if Gluttonberg.dbms_name == "postgresql"
+        Rails.configuration.search_models.each do |model , columns|
+          begin
+            model =  eval(model)
+            model.index do
+              columns.each do |column|
+                send(column)
+              end
+            end
+          rescue
+          end
         end
       end
-      
+    end
+
+    # Iterate block/content classes to just load these constants 
+    # before setting up association with their localization. 
+    # This is kind of hack for lazyloading
+    self.load_block_classes
+
+    # if postgresql and there is not special search engine 
+    # then index data using texticle for postgresql
+    self.index_data_using_texticle
+
+
+    # if search engine is provided the use its custom methods
+    # otherwise use texticle for postgresql and like queries for mysql
+    # opts = {
+    #   :sources => [],
+    #   :published_only => true,
+    #   :per_page => 20,
+    #   :page => 1
+    # }
+
+
+    private      
+
       def self.replace_contents_with_page(results)
-        # if it is localized or non locaized class then take return its parent page
+        # if it is localized or non locaized class 
+        # then take return its parent page
         results.each_with_index do |result , index|
-            if Gluttonberg::Content::Block.classes.collect{|k| [k.to_s , k.to_s + "Localization"] }.flatten.include?(result.class.name.to_s)
-              results[index] = result.parent.page
-            elsif Gluttonberg::Content::Block.classes.collect{|k| [k.to_s , k.to_s] }.flatten.include?(result.class.name.to_s)
-                results[index] = result.page
-            end
+          if self.localized_page_content?(result)
+            results[index] = result.parent.page
+          elsif self.nonlocalized_page_content?(result)
+            results[index] = result.page
+          end
         end
 
         results.uniq
       end
-  
-  end
-end  
+
+      def self.localized_page_content?(result)
+        classes = Gluttonberg::Content::Block.classes.collect do |k| 
+          [k.to_s , k.to_s + "Localization"]
+        end
+        classes.flatten.include?(result.class.name.to_s)
+      end
+
+      def self.nonlocalized_page_content?(result)
+        classes = Gluttonberg::Content::Block.classes.collect do |k| 
+          [k.to_s , k.to_s]
+        end
+        classes.flatten.include?(result.class.name.to_s)
+      end
+
+      def self.find_models(sources)
+        if sources.blank?
+          models = Rails.configuration.search_models
+        else
+          models = {}
+          sources.each do |src|
+            models[src] = Rails.configuration.search_models[src]
+          end
+        end
+        models
+      end
+
+  end #Search
+end

data/app/models/gluttonberg/select_content.rb

@@ -0,0 +1,12 @@
+module Gluttonberg
+  # Page content for select dropdown. All content related functionality 
+  # is provided Content::Block mixin 
+  # Stores user input in :text column all other information is just meta information
+  class SelectContent  < ActiveRecord::Base
+    include Content::Block
+    self.table_name = "gb_select_contents"
+    attr_accessible :text, :section_name
+    is_versioned
+    delegate :current_user_id, :to => :page
+  end
+end