gluttonberg-core 2.6.4 → 3.0.0

data/lib/gluttonberg/content/slug_management.rb

@@ -12,15 +12,38 @@ module Gluttonberg
           include InstanceMethods
 
           before_validation :slug_management
-          class << self;  attr_accessor :slug_source_field_name end
+          class << self;  attr_accessor :slug_source_field_name, :slug_scope end
           attr_accessor :current_slug
 
-
         end
       end
 
       module ClassMethods
+        def self.check_for_duplication(slug, object, potential_duplicates)
+          unless potential_duplicates.blank?
+            if potential_duplicates.length > 1 || (potential_duplicates.length == 1 && potential_duplicates.first.id != object.id )
+              number = potential_duplicates.length+1
+              begin
+                slug = "#{self.slug_without_postfix(slug)}-#{number}"
+                number += 1
+              end while object.find_potential_duplicates(slug).map{|o| o.slug}.include?(slug)
+            end
+          end
+          slug
+        end
+
+        def self.slug_without_postfix(slug)
+          temp_slug = slug
 
+          unless temp_slug.blank?
+            slug_tokens = temp_slug.split("-")
+            if slug_tokens.last.to_i.to_s == slug_tokens.last && slug_tokens.length > 1
+              slug_tokens = slug_tokens[0..-2]
+              temp_slug = slug_tokens.join("-")
+            end
+          end
+          temp_slug
+        end
       end
 
       module InstanceMethods
@@ -39,17 +62,17 @@ module Gluttonberg
         end
 
         def slug=(new_slug)
-          #if you're changing this regex, make sure to change the one in /javascripts/slug_management.js too
-          # utf-8 special chars are fixed for new ruby 1.9.2
-          unless new_slug.blank?
-            new_slug = new_slug.to_s.downcase.gsub(/\s/, '_').gsub(/[\!\*'"″′‟‛„‚”“”˝\(\)\;\:\.\@\&\=\+\$\,\/?\%\#\[\]]/, '')
-            new_slug = new_slug.gsub('__','_') # remove consective underscores
-            new_slug = new_slug.gsub(/_$/,'') # remove trailing underscore
-          end
+          current_slug = self.slug
+          new_slug = new_slug.to_s.sluglize unless new_slug.blank?
+          new_slug = unique_slug(new_slug)
           write_attribute(:slug, new_slug)
+          if self.respond_to?(:previous_slug) && self.slug_changed? && self.slug != current_slug
+            write_attribute(:previous_slug, current_slug)
+          end
+          new_slug
         end
 
-        protected
+        #protected
         # Checks If slug is blank then tries to set slug using following logic
         # if slug_field_name is set then use its value and make it slug
         # otherwise checks for name column
@@ -58,29 +81,54 @@ module Gluttonberg
           def slug_management
             if self.slug.blank?
               if self.class.slug_source_field_name.blank?
-                if self.respond_to?(:name)
-                  self.class.slug_source_field_name= :name
-                  self.slug= self.name
-                elsif self.respond_to?(:title)
-                  self.class.slug_source_field_name= :title
-                  self.slug= self.title
-                else
-                  self.class.slug_source_field_name= :id
-                  self.slug= self.id.to_s
-                end
-              else
-                self.slug= self.send(self.class.slug_source_field_name)
+                self.get_slug_source
               end
+              self.slug= self.send(self.class.slug_source_field_name)
             end #slug.blank
+            self.fix_duplicated_slug
+          end
+
+          def fix_duplicated_slug
             # check duplication: add id at the end if its duplicated
-            already_exist = self.class.where(:slug => self.slug).all
-            if !already_exist.blank?
-              if already_exist.length > 1 || (already_exist.length == 1 && already_exist.first.id != self.id )
-                self.slug= "#{self.slug}_#{already_exist.length+1}"
+            potential_duplicates = find_potential_duplicates(self.slug)
+
+            unless potential_duplicates.blank?
+              if potential_duplicates.length > 1 || (potential_duplicates.length == 1 && potential_duplicates.first.id != self.id )
+                number = potential_duplicates.length+1
+                begin
+                  self.slug = "#{slug_without_postfix(self.slug)}-#{number}"
+                  number += 1
+                end while find_potential_duplicates(slug).map{|o| o.slug}.include?(slug)
               end
             end
           end
 
+          def unique_slug(slug)
+            # check duplication: add id at the end if its duplicated
+            potential_duplicates = find_potential_duplicates(slug)
+            Content::SlugManagement::ClassMethods.check_for_duplication(slug, self, potential_duplicates)
+          end
+
+          def slug_without_postfix(slug)
+            Content::SlugManagement::ClassMethods.slug_without_postfix(slug)
+          end
+
+          def find_potential_duplicates(slug)
+            unless self.class.where(["slug = ? ", slug]).first.blank?
+              temp_slug = slug_without_postfix(slug)
+              potential_duplicates = self.class.where(["slug = ? OR slug = ? OR slug like ? ", slug, temp_slug, "#{temp_slug}-%"])
+              
+              unless self.class.slug_scope.blank?
+                potential_duplicates = potential_duplicates.where(self.class.slug_scope => self.send(self.class.slug_scope) )
+              end
+              potential_duplicates = potential_duplicates.all
+              potential_duplicates = potential_duplicates.find_all{|obj| obj.id != self.id}
+              potential_duplicates
+            else
+              []
+            end
+          end
+
       end
 
     end

data/lib/gluttonberg/content/validations.rb

@@ -0,0 +1,58 @@
+module Gluttonberg
+  module Content
+    # A mixin which allows any arbitrary model to have default validations
+    module Validations
+      extend ActiveSupport::Concern
+
+      def self.setup
+        ::ActiveRecord::Base.send :include, Gluttonberg::Content::Validations
+      end
+
+      # it validates all columns values using max limit from database schema
+      def max_field_length
+        self.class.columns.each do |column|
+          if column.type == :string &&  !column.limit.blank?
+            val = self.send(column.name)
+            if !val.blank? and val.length > column.limit
+              errors.add(column.name, "is too long (maximum is #{column.limit} characters)")
+            end
+          end
+        end
+      end
+
+      # it validates all integer columns values - database schema
+      def integer_values
+        self.class.columns.each do |column|
+          if column.type == :integer
+            before_type_cast = :"#{column.name}_before_type_cast"
+            raw_value = self.send(before_type_cast) if self.respond_to?(before_type_cast)
+            raw_value ||= self.send(column.name)
+            unless raw_value.blank?
+              raw_value = raw_value.to_i if raw_value.to_s =~ /\A[+-]?\d+\Z/
+              unless raw_value.is_a? Integer
+                errors.add(column.name, "is not an integer number")
+              end
+            end
+          end
+        end
+      end
+
+      # it validates all decimal columns values - database schema
+      def decimal_values
+        self.class.columns.each do |column|
+          if column.type == :decimal && !column.precision.blank? && !column.scale.blank?
+            before_type_cast = :"#{column.name}_before_type_cast"
+            raw_value = self.send(before_type_cast) if self.respond_to?(before_type_cast)
+            raw_value ||= self.send(column.name)
+            unless raw_value.blank?
+              unless raw_value.to_s =~ /^\A[+-]?\d{1,#{column.precision}}(\.?\d{0,#{column.scale}})?$/
+                errors.add(column.name, "is not a decimal number")
+              end
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/gluttonberg/content/versioning.rb

@@ -1,43 +1,61 @@
 module Gluttonberg
   module Content
-    # A mixin which allows for any arbitrary model to have multiple versions. It will 
-    # generate the versioning models and add methods for creating, managing and 
+    # A mixin which allows for any arbitrary model to have multiple versions. It will
+    # generate the versioning models and add methods for creating, managing and
     # retrieving different versions of a record.
     # In reality this is behaving like a wrapper on acts_as_versioned
     module Versioning
-      
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :current_user_id
+      end
+
       def self.setup
         ::ActiveRecord::Base.send :include, Gluttonberg::Content::Versioning
       end
-      
-      def self.included(klass)
-        klass.class_eval do
-          extend  ClassMethods
-          include InstanceMethods          
-        end
+
+      def versioned?
+        self.class.versioned?
       end
-      
+
       module ClassMethods
-        
         def is_versioned(options = {}, &extension)
           excluded_columns = options.delete(:non_versioned_columns)
-          acts_as_versioned( options.merge( :limit => Gluttonberg::Setting.get_setting("number_of_revisions") ) , &extension )   
-          self.non_versioned_columns << excluded_columns 
+          acts_as_versioned( options.merge( :limit => Gluttonberg::Setting.get_setting("number_of_revisions") ) , &extension )
+          self.non_versioned_columns << ['state' ,'published_at', 'user_id', 'locale_id', 'position']
+          self.non_versioned_columns << excluded_columns
           self.non_versioned_columns.flatten!
+          include OverrideActsAsVersioned
         end
-        
+
         def versioned?
           self.respond_to?(:versioned_class_name)
         end
-        
       end
-      
-      module InstanceMethods
-        def versioned?
-          self.class.versioned?
-        end
+
+      module OverrideActsAsVersioned
+        
+        # Clears old revisions if a limit is set with the :limit option in <tt>acts_as_versioned</tt>.
+        # Override this method to set your own criteria for clearing old versions.
+        def clear_old_versions
+          update_from_gb_versioning_settings
+          return if self.class.max_version_limit == 0
+          excess_baggage = send(self.class.version_column).to_i - self.class.max_version_limit
+          if excess_baggage > 0
+            self.class.versioned_class.delete_all ["#{self.class.version_column} <= ? and #{self.class.versioned_foreign_key} = ?", excess_baggage, id]
+          end
+        end 
+
+        def update_from_gb_versioning_settings
+          if self.class.max_version_limit == 0
+           tmp_number_of_revisions = Gluttonberg::Setting.get_setting("number_of_revisions")
+           self.class.max_version_limit = tmp_number_of_revisions.to_i unless tmp_number_of_revisions.blank?
+          end
+        end 
+
       end
-      
+
     end
   end
-end  
+end

data/lib/gluttonberg/drag_tree.rb

@@ -112,7 +112,6 @@ module Gluttonberg
     def self.setup
       ::ActiveRecord::Base.send :include, Gluttonberg::DragTree::ActiveRecord
       ::ActionController::Base.send  :include, Gluttonberg::DragTree::ActionController
-      #::ActionView::Helpers.send(:include,  Gluttonberg::DragTree::ActionView::Helpers)
     end
   end #DragTree
 end #Gluttonberg

data/lib/gluttonberg/drag_tree/action_controller.rb

@@ -1,12 +1,8 @@
 module Gluttonberg
   module DragTree
     module ActionController
-
-      def self.included(base)
-           base.extend(ClassMethods)
-      end
-
-
+      extend ActiveSupport::Concern
+      
       module ClassMethods
         def drag_tree(model_class, options = {})
           self.send(:include, Gluttonberg::DragTree::ActionController::ControllerHelperClassMethods)
@@ -16,45 +12,61 @@ module Gluttonberg
       end # class methods
 
       module ControllerHelperClassMethods
-        def self.included(klass)
-          klass.class_eval do
-            @drag_tree_model_class = nil
-            @drag_tree_route_name = nil
+        extend ActiveSupport::Concern
+        included do
+          @drag_tree_model_class = nil
+          @drag_tree_route_name = nil
+        end
+        module ClassMethods
+          def drag_class
+            @drag_tree_model_class
+          end
 
-            def klass.drag_class
-              @drag_tree_model_class
-            end
+          def set_drag_tree(model_class, options = {})
+            @drag_tree_route_name = options[:route_name] if options[:route_name]
+            @drag_tree_model_class = model_class
+          end
 
-            def klass.set_drag_tree(model_class, options = {})
-              @drag_tree_route_name = options[:route_name] if options[:route_name]
-              @drag_tree_model_class = model_class
+          def drag_tree_route_name
+            if @drag_tree_route_name then
+              @drag_tree_route_name
+            else
+              "#{self.controller_name}/move_node".to_sym
             end
+          end
+        end #ClassMethods
 
-            def klass.drag_tree_route_name
-              if @drag_tree_route_name then
-                @drag_tree_route_name
-              else
-                "#{self.controller_name}/move_node".to_sym
-              end
-            end
+        def move_node
+          if params[:element_ids].blank? && params[:nestable_serialized_data].blank?
+            render :json => {:success => false}
+            return
+          end
+          if params[:element_ids]
+            save_data_for_elements(params)
+          else
+            nestable_serialized_data = JSON.parse(params[:nestable_serialized_data])
+            _update_position_for_pages(self.class.drag_class, nestable_serialized_data, nil)
+          end
+          render :json => {:success => true}
+        end
 
-            def move_node
-              if params[:element_ids].blank?
-                render :json => {:success => false}
-                return
-              end
-              ids = params[:element_ids].split(",")
-              elements = self.class.drag_class.find_by_sorted_ids(ids )
-              elements.each_with_index do |element , index|
-                attr = {:position => index + 1  }
-                element.update_attributes!( attr   )
-              end
-              render :json => {:success => true}
-            end
+        def save_data_for_elements(params)
+          ids = params[:element_ids].split(",")
+          elements = self.class.drag_class.find_by_sorted_ids(ids)
+          elements.each_with_index do |element , index|
+            element.update_attributes!({:position => index})
+          end
+        end
 
+        def _update_position_for_pages(klass, pages, parent_id=nil)
+          pages.each_with_index do |row, index|
+            klass.update(row["id"], :position => index, :parent_id => parent_id)
+            unless row["children"].blank?
+              _update_position_for_pages(klass, row["children"], row["id"])
+            end
           end
         end
-      end
+      end #ControllerHelperClassMethods
 
     end
   end #DragTree

data/lib/gluttonberg/drag_tree/action_view.rb

@@ -2,8 +2,6 @@ module Gluttonberg
   module DragTree
     module ActionView
       module Helpers
-
-
         def drag_tree_url(klass = self.class)
           controller_class = controller.class
           if controller_class.respond_to?(:drag_tree_route_name) then
@@ -13,7 +11,6 @@ module Gluttonberg
           end
         end
 
-
         def drag_tree_table_class(klass = self.class)
           # drag-tree treeTable
           controller_class = controller.class
@@ -51,10 +48,7 @@ module Gluttonberg
         def drag_tree_row_id(model)
           "node-#{model.id}"
         end
-
-
       end
-
     end
   end #DragTree
 end  #Gluttonberg

data/lib/gluttonberg/drag_tree/active_record.rb

@@ -1,96 +1,96 @@
 module Gluttonberg
   module DragTree
     module ActiveRecord
-
-      def self.included(base)
-         base.extend(ClassMethods)
-      end
-
+      extend ActiveSupport::Concern
 
       module ClassMethods
         def is_drag_tree(options = {})
           options[:flat] = true unless options.has_key?(:flat)
           self.send(:include, Gluttonberg::DragTree::ActiveRecord::ModelHelpersClassMethods)
-          if options.has_key?(:scope)
-            acts_as_list :scope => options[:scope]
-          else
-            acts_as_list
-          end
           unless options[:flat]
             acts_as_tree options
+            self.is_flat_drag_tree = false
           else
             self.make_flat_drag_tree
           end
+          self.drag_tree_scope_column = options[:scope] unless options[:scope].blank?
         end
 
         def repair_list(list)
           unless list.blank?
             list.each_with_index do |sibling , index|
-              sibling.position = index
-              sibling.save
+              sibling.update_attributes(:position => index)
             end
           end
         end
 
         def find_by_sorted_ids(new_sorted_element_ids)
           # find records in unorder list
-          elements = self.find(new_sorted_element_ids )
+          elements = self.where(:id => new_sorted_element_ids).all
           # sort it using ruby method
           sorted_elements = []
           new_sorted_element_ids.each do |id|
             id = id.to_i
             sorted_elements << elements.find{ |x| x.id == id }
           end
-          sorted_elements
+          sorted_elements.blank? ? sorted_elements : sorted_elements.uniq
         end
 
-
-
       end #module ClassMethods
 
       module ModelHelpersClassMethods
-        def self.included(klass)
-          klass.class_eval do
-            cattr_accessor :is_flat_drag_tree
-            #@is_flat_drag_tree = false
-            def klass.behaves_as_a_drag_tree
-              true
-            end
+        extend ActiveSupport::Concern
 
-            def klass.make_flat_drag_tree
-              self.is_flat_drag_tree = true
-            end
+        included do
+          cattr_accessor :is_flat_drag_tree, :drag_tree_scope_column
+          before_validation :set_position
+        end
 
-            def klass.behaves_as_a_flat_drag_tree
-              self.is_flat_drag_tree
-            end
+        module ClassMethods
+          def behaves_as_a_drag_tree
+            true
+          end
+
+          def make_flat_drag_tree
+            self.is_flat_drag_tree = true
+          end
+
+          def behaves_as_a_flat_drag_tree
+            self.is_flat_drag_tree
+          end
 
-            def klass.repair_drag_tree
-              if behaves_as_a_flat_drag_tree
-                if list_options[:scope].empty?
-                  repair_list
-                else
-                  # this is wasteful as it does a repair on every item
-                  # which means for items of the same scope they keep
-                  # getting re-repaired. :-(
-                  items = all()
-                  items.each{ |item| item.repair_list}
-                end
+          def repair_drag_tree
+            if self.drag_tree_scope_column.blank?
+              repair_list(self.all_sorted.all)
+            else
+              unique_scope_ids = self.select(self.drag_tree_scope_column).uniq.all
+              unique_scope_ids.each do |scope_id|
+                scope_id = scope_id.send(self.drag_tree_scope_column)
+                items = self.all_sorted(self.drag_tree_scope_column => scope_id).all
+                repair_list(items)
               end
-              # todo: add support for non flat trees
-            end
-            def klass.all_sorted(query={})
-              all({:order => [:position.asc]}.merge(query))
             end
-          end # class_eval
-        end #included
+          end
+          def all_sorted(query={})
+            objs = self.order("position asc")
+            objs = objs.where(query) unless query.blank?
+            objs
+          end
+        end #ClassMethods
       end #ModelHelpersClassMethods
 
+      def set_position
+        if self.position.blank?
+          if self.class.drag_tree_scope_column.blank?
+            self.position = self.class.count + 1
+          else
+            items_count = self.class.where(self.class.drag_tree_scope_column => self.send(self.class.drag_tree_scope_column)).count
+            self.position = items_count + (self.new_record? ? 0 : -1)
+          end
+        end
+      end
 
     end # ActiveRecord
 
-
-
-
   end #DragTree
 end  #Gluttonberg