gluttonberg-core 2.6.4 → 3.0.0

data/lib/gluttonberg/content/localization.rb

@@ -4,29 +4,60 @@ module Gluttonberg
     # generate the localization models and add methods for creating and
     # retrieving localized versions of a record.
     module Localization
-      # The included hook is used to create a bunch of class ivars we need to
-      # store various bits of configuration.
-      def self.included(klass)
-        klass.class_eval do
-          extend  Model::ClassMethods
-          include Model::InstanceMethods
-          cattr_accessor :localized, :localized_model, :localized_model_name, :localized_fields, :locale;
-          self.localized = false
-          self.localized_fields = []
-        end
+      extend ActiveSupport::Concern
+
+      included do
+        cattr_accessor :localized, :localized_model, :localized_model_name, :localized_fields, :locale, :parent_key;
+        self.localized = false
+        self.localized_fields = []
       end
+      
+      module ClassMethods
+        def is_localized(opts={}, &blk)
+          # Why yes, this is localized.
+          self.localized = true
+          self.parent_key = (opts[:parent_key] || :parent_id)
+
+          # Create the localization model
+          create_localization_model(&blk)
+        end
 
-      # This module gets mixed into the class that includes the localization module
-      module Model
-        module ClassMethods
-          def is_localized(&blk)
+        def localized?
+          self.localized
+        end
 
-            # Why yes, this is localized.
-            self.localized = true
+        # Returns a new instance of the model, with a localization instance
+        # already assigned to it based on the options passed in.
+        #
+        # The options include the attributes for the both new model and its localization.
+        def new_with_localization(attrs={})
+          new_model = new
+          default_localization = nil
+          # new localization object for all locales.
+          Gluttonberg::Locale.all.each do |locale|
+            loc = self.localized_model.new(:locale_id => locale.id)
+            new_model.instance_variable_set(:@current_localization, loc)
+            new_model.localizations << loc
+            loc.parent = new_model
+            #update current object and current localization
+            attrs.each do |name, value|
+              new_model.send("#{name}=", value)
+            end
+            if locale.default?
+               default_localization = loc
+            end
+          end
 
-            # Create the localization model
+          # make default localization as default
+          default_localization = new_model.localizations.first if default_localization.blank?
+          new_model.instance_variable_set(:@current_localization, default_localization)
+          new_model
+        end
+
+        private
+
+          def create_localization_model(&blk)
             class_name = self.name + "Localization"
-            table_name = class_name.tableize
             # Check to see if the localization is inside a constant
             target = Object
             if class_name.index("::")
@@ -40,21 +71,30 @@ module Gluttonberg
             self.localized_model = Class.new(ActiveRecord::Base)
             target.const_set(class_name, self.localized_model)
             self.localized_model_name = class_name
-            self.localized_model.table_name = table_name
+            self.localized_model.table_name = class_name.tableize
 
+            add_code_to_localization_model(&blk)
+          end
+
+          def add_code_to_localization_model(&blk)
             # Add the properties declared in the block, and sprinkle in our own mixins
             self.localized_model.class_eval(&blk)
             self.localized_model.send(:include, ModelLocalization)
 
+            self.localized_model.attr_accessible :locale_id , self.parent_key
+
+            create_acccessors_for_localization_model
+            set_associations_for_localization_model
+            set_hooks_for_localization_model
+          end
+
+          def create_acccessors_for_localization_model
             # For each property on the localization model, create an accessor on
             # the parent model, without over-writing any of the existing methods.
-            exclusions = [:id, :created_at, :updated_at, :locale_id , :parent_id]
+            exclusions = [:id, :created_at, :updated_at, :locale_id , self.parent_key]
             localized_properties = self.localized_model.column_names.reject { |p| exclusions.include? p }
             non_localized_properties = self.column_names.reject { |p| exclusions.include? p }
 
-            self.localized_model.attr_accessible :locale_id , :parent_id
-
-
             localized_properties.each do |prop|
               self.localized_fields << prop
               # Create the accessor that points to the localized version
@@ -69,161 +109,110 @@ module Gluttonberg
                 }
               end
             end
+          end
 
-            #---------TODO cleaning html code
-            #@localized_model.clean_html([:text])#(@localized_fields.map{|c|c.to_sym})
-
+          def set_associations_for_localization_model
             # Associate the model and it’s localization
-            has_many  :localizations, :class_name => self.localized_model.name.to_s, :foreign_key => :parent_id, :dependent => :destroy
-            has_one  :default_localization, :class_name => self.localized_model.name.to_s, :foreign_key => :parent_id , :conditions => ["locale_id = ?", Locale.first_default.id]
-            self.localized_model.belongs_to(:parent, :class_name => self.name, :foreign_key => :parent_id)
+            has_many  :localizations, :class_name => self.localized_model.name.to_s, :foreign_key => self.parent_key, :dependent => :destroy
+            has_one  :default_localization, :class_name => self.localized_model.name.to_s, :foreign_key => self.parent_key, :conditions =>  proc { ["locale_id = ?", Locale.first_default.id] }
+            self.localized_model.belongs_to(:parent, :class_name => self.name, :foreign_key => self.parent_key)
+          end
 
+          def set_hooks_for_localization_model
             # Set up validations for when we update in the presence of a localization
             after_validation  :validate_current_localization
             after_save    :save_current_localization
-
-          end
-
-          def localized?
-            self.localized
           end
+        end
 
-          # Returns a new instance of the model, with a localization instance
-          # already assigned to it based on the options passed in.
-          #
-          # The options include the attributes for the both new model and its localization.
-          def new_with_localization(attrs={})
-            new_model = new
-            default_localization = nil
-            # new localization object for all locales.
-            Gluttonberg::Locale.all.each do |locale|
-              loc = self.localized_model.new(:locale_id => locale.id)
-              new_model.instance_variable_set(:@current_localization, loc)
-              new_model.localizations << loc
-              new_model.attributes = attrs #update current object and current localization
-              if locale.default?
-                 default_localization = loc
-              end
-            end
-
-            # make default localization as default
-            default_localization = new_model.localizations.first if default_localization.blank?
-            new_model.instance_variable_set(:@current_localization, default_localization)
-            new_model
-          end
-
-
-          # def all_with_localization(opts)
-          #   fallback = check_for_fallback(opts)
-          #   localization_opts = extract_localization_conditions(opts)
-          #   matches = all(prefix_localized_fields(opts))
-          #   matches.each { |match| match.load_localization(localization_opts, fallback || false) }
-          #   matches
-          # end
-
-          # def first_with_localization(opts)
-          #   fallback = check_for_fallback(opts)
-          #   localization_opts = extract_localization_conditions(opts)
-          #   match = first(prefix_localized_fields(opts))
-          #   if match
-          #     match.load_localization(localization_opts, fallback || false)
-          #     match
-          #   end
-          # end
-
-          private
-
+        # InstanceMethods
+        def localized?
+          self.class.localized?
         end
 
-        module InstanceMethods
-          def localized?
-            self.class.is_localized?
+        # returns current localization if current localization does not exist then init it with default localization
+        def current_localization
+          if @current_localization.blank?
+            @current_localization = self.default_localization
+            @current_localization.parent = self unless @current_localization.blank?
           end
+          @current_localization
+        end
 
-          # returns current localization if current localization does not exist then init it with default localization
-          def current_localization
-            if @current_localization.blank?
-              @current_localization = self.default_localization
-            end
-            @current_localization
-          end
+        def current_localization=(localization)
+          self.instance_variable_set(:@current_localization, localization)
+        end
 
-          def current_localization=(localization)
-            self.instance_variable_set(:@current_localization, localization)
+        # load locaization for given locale (locale id or locale objects both are acceptable)
+        # if localization for given locale does not exist then create localization for it
+        # and if creation of localization failed then return default localization
+        def load_localization(locale, fallback = true)
+          opts = {}
+          opts[:locale_id] = locale.kind_of?(Gluttonberg::Locale) ? locale.id: locale
+          opts[self.parent_key] = self.id
+          # Go and find the localization
+          self.current_localization = nil
+          self.current_localization = self.class.localized_model.where(opts).first
+          if @current_localization.blank? && !locale.blank?
+            self.current_localization = self.create_localization(locale)
           end
-
-          # load locaization for given locale (locale id or locale objects both are acceptable)
-          # if localization for given locale does not exist then create localization for it
-          # and if creation of localization failed then return default localization
-          def load_localization(locale, fallback = true)
-            opts = {}
-            opts[:locale_id] = locale.kind_of?(Gluttonberg::Locale) ? locale.id: locale
-            opts[:parent_id] = self.id
-            # Go and find the localization
-            self.current_localization = nil
-            self.current_localization = self.class.localized_model.where(opts).first
-            if @current_localization.blank? && !locale.blank?
-              self.current_localization = self.create_localization(locale)
-            end
-            # Check to see if we missed the load and if we also need the fallback
-            if self.current_localization.blank? && fallback
-              self.current_localization = self.default_localization
-            end
-            self.current_localization
+          # Check to see if we missed the load and if we also need the fallback
+          if self.current_localization.blank? && fallback
+            self.current_localization = self.default_localization
           end
+          self.current_localization.parent = self unless self.current_localization.blank?
+          self.current_localization
+        end
 
 
 
-          # create localization for given locale (locale id or object both are acceptable) if it does not exist
-          def create_localization(locale)
-            locale_id = locale.kind_of?(Gluttonberg::Locale) ? locale.id: locale
-            unless locale.blank?
-              loc = self.class.localized_model.where(:locale_id => locale_id, :parent_id => self.id).first
-              if loc.blank?
-                tmp_current = self.current_localization
-                tmp_attributes = tmp_current.attributes
-                tmp_attributes[:locale_id] = locale_id
-                loc = self.class.localized_model.new(:locale_id => locale_id)
-                loc.attributes = tmp_attributes
-                if loc.save
-                  loc
-                else
-                  nil
-                end
+        # create localization for given locale (locale id or object both are acceptable) if it does not exist
+        def create_localization(locale)
+          locale_id = locale.kind_of?(Gluttonberg::Locale) ? locale.id: locale
+          unless locale.blank?
+            loc = self.class.localized_model.where(:locale_id => locale_id, self.parent_key => self.id).first
+            if loc.blank?
+              tmp_attributes = {}
+              unless self.current_localization.blank?
+                tmp_attributes = self.current_localization.attributes
+              end
+              tmp_attributes[:locale_id] = locale_id
+              loc = self.class.localized_model.new(:locale_id => locale_id)
+              loc.attributes = tmp_attributes
+              if loc.save
+                loc
+              else
+                nil
               end
             end
-          end #create_localization
+          end
+        end #create_localization
 
 
-          private
+        private
 
-          # Validates the current_localization. If it is invalid, it's errors
-          # are appended to the model's own errors.
-          def validate_current_localization
-            if current_localization
-              unless current_localization.valid?
-                current_localization.errors.each { |name, error| errors.add(name, error) }
-              end
+        # Validates the current_localization. If it is invalid, it's errors
+        # are appended to the model's own errors.
+        def validate_current_localization
+          if current_localization
+            unless current_localization.valid?
+              current_localization.errors.each { |name, error| errors.add(name, error) }
             end
           end
+        end
 
-          def save_current_localization
-            if current_localization && current_localization.changed?
-              current_localization.save
-            end
+        def save_current_localization
+          if current_localization && current_localization.changed?
+            current_localization.save
           end
-
         end
-      end
+      
 
       # This module is used when dynamically creating the localization class.
       module ModelLocalization
-        # This included hook is used to declare base properties like the id and
-        # to set up associations to the dialect and locale
-        def self.included(klass)
-          klass.class_eval do
-            belongs_to :locale,   :class_name => "Gluttonberg::Locale"
-          end
+        extend ActiveSupport::Concern
+        included do
+          belongs_to :locale,   :class_name => "Gluttonberg::Locale"
         end
 
         def locale_name
@@ -232,4 +221,4 @@ module Gluttonberg
       end
     end # Localization
   end # Content
-end # Gluttonberg
+end # Gluttonberg

data/lib/gluttonberg/content/page_children.rb

@@ -0,0 +1,36 @@
+module Gluttonberg
+  module Content
+    # Mixin which extends functionality of pages model for handling page childrens
+    module PageChildren
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def fix_children_count
+          self.all.each do |page|
+            self.reset_counters(page.id, :children)
+          end
+        end
+      end
+
+      def grand_child_of?(page)
+        if self.parent_id.blank? || page.blank?
+          false
+        else
+          self.parent_id == page.id || self.parent.grand_child_of?(page)
+        end
+      end
+
+      def grand_parent_of?(page)
+        page.grand_child_of?(self)
+      end
+
+      def number_of_children
+        if self.respond_to?(:children_count)
+          self.children_count
+        else
+          self.children.count
+        end
+      end
+    end #PageChildren
+  end
+end

data/lib/gluttonberg/content/page_components.rb

@@ -0,0 +1,23 @@
+module Gluttonberg
+  module Content
+    module PageComponents
+      extend ActiveSupport::Concern
+      included do
+        include Content::Publishable
+        include Content::SlugManagement
+        include Content::PageFinder
+        include Content::DefaultTemplateFile
+        include Content::PageDescriptionInfo
+        include Content::PageChildren
+        include Content::HomePageInfo
+
+        # Generate the associations for the block/content classes
+        Content::Block.classes.each do |klass|
+          has_many klass.association_name, :class_name => klass.name, :dependent => :destroy
+        end
+
+        MixinManager.load_mixins(self)
+      end #included
+    end # PageComponents
+  end
+end

data/lib/gluttonberg/content/page_description_info.rb

@@ -0,0 +1,55 @@
+module Gluttonberg
+  module Content
+    # Mixin which provides page description related funtionality to page model
+    module PageDescriptionInfo
+      extend ActiveSupport::Concern
+
+      # Returns the PageDescription associated with this page.
+      def description
+        @description = PageDescription[self.description_name.to_sym] if self.description_name
+        @description
+      end
+
+      # Returns the page_options set in the PageDescription
+      def page_options
+        @page_options = description.options[:page_options]
+        @page_options
+      end
+
+      # Returns the name of the view template specified for this page —
+      # determined via the associated PageDescription
+      def view
+        self.description if @description.blank?
+        @description[:view] if @description
+      end
+
+      # Returns the name of the layout template specified for this page —
+      # determined via the associated PageDescription
+      def layout
+        self.description if @description.blank?
+        @description[:layout] if @description
+      end
+
+      def redirect_required?
+        self.description.redirection_required?
+      end
+
+      def redirect_url
+        self.description.redirect_url(self,{})
+      end
+
+      # Indicates if the page is used as a mount point for a public-facing
+      # controller, e.g. a blog, message board etc.
+      def rewrite_required?
+        self.description.rewrite_required?
+      end
+
+      # Takes a path and rewrites it to point at an alternate route. The idea
+      # being that this path points to a controller.
+      def generate_rewrite_path(path)
+        path.gsub(current_localization.path, self.description.rewrite_route)
+      end
+    
+    end #PageDescriptionInfo
+  end
+end