acts_as_nested_interval 0.2.0.pre → 0.2.0.pre2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7ca996b586ce5012168cde429320be3243c3d709
-  data.tar.gz: f8b4566aa2f030c896d1675ec0bad92eb717eeee
+  metadata.gz: d0b2b592385c77289fa506e90644ef852fba8e8f
+  data.tar.gz: a3c26bcb5485afb6922d413cb821137d2f8e9abd
 SHA512:
-  metadata.gz: 1bda1e75d4f062d0220336ea18320b826f5b789e5db7f496fa3e9541bf35287919510fd170cfabbd1db4e4910e49d155319329027991699fe697313da078c4cb
-  data.tar.gz: 60ddeeecca41bb1f7b549f0d62e23a24e9aa832e8ad3870843b204cccf5bb14e6c6e2919a0393ff8709b0cb49e26c031df4e7bb2575aa6ec77e2a76ebf3c5dc2
+  metadata.gz: 8143a530d3281764572e7d7c48309225c3a7754298e23f36d61efd19bfe337fda61e49b56f8d96681786021b3124e9c899fb526fbe02783adbb87b1a76470a58
+  data.tar.gz: 5695037b46285612a58e79b1832d23d6632c861d1d5374516c75ec22bf1cc252df215e44c21b59f5176c468b48be222cf0380f2de22a5470372fb060a8d5f318

data/README.md

@@ -77,6 +77,8 @@ Example:
 
 ```ruby
 class Region < ActiveRecord::Base
+  include ActsAsNestedInterval
+
   acts_as_nested_interval
 end
 

data/lib/acts_as_nested_interval/callbacks.rb

@@ -17,7 +17,7 @@ module ActsAsNestedInterval
 
     # Creates record.
     def create_nested_interval
-      if read_attribute(nested_interval_foreign_key).nil?
+      if read_attribute(nested_interval.foreign_key).nil?
         set_nested_interval_for_top
       else
         set_nested_interval *parent.lock!.next_child_lft
@@ -27,10 +27,10 @@ module ActsAsNestedInterval
     # Updates record, updating descendants if parent association updated,
     # in which case caller should first acquire table lock.
     def update_nested_interval
-      changed = send(:"#{nested_interval_foreign_key}_changed?")
+      changed = send(:"#{nested_interval.foreign_key}_changed?")
       if !changed
-        db_self = self.class.find(id, :lock => true)
-        write_attribute(nested_interval_foreign_key, db_self.read_attribute(nested_interval_foreign_key))
+        db_self = self.class.find(id).lock!
+        write_attribute(nested_interval.foreign_key, db_self.read_attribute(nested_interval.foreign_key))
         set_nested_interval db_self.lftp, db_self.lftq
       else
         # No locking in this case -- caller should have acquired table lock.

data/lib/acts_as_nested_interval/class_methods.rb

@@ -21,7 +21,7 @@ module ActsAsNestedInterval
       update_subtree = ->(node){
         node.create_nested_interval
         node.save
-        node.class.unscoped.where(nested_interval_foreign_key => node.id).find_each &update_subtree
+        node.class.unscoped.where(nested_interval.foreign_key => node.id).find_each &update_subtree
       }
       unscoped.roots.find_each &update_subtree
 

data/lib/acts_as_nested_interval/configuration.rb

@@ -0,0 +1,35 @@
+module ActsAsNestedInterval
+  class Configuration
+
+    attr_reader :foreign_key, :dependent, :scope_columns
+
+    # multiple_roots - allow more than one root
+    def initialize( model, virtual_root: false, foreign_key: :parent_id, dependent: :restrict_with_exception, scope_columns: [] )
+      @multiple_roots = !!virtual_root
+      @foreign_key = foreign_key
+      @dependent = dependent
+      @scope_columns = *scope_columns
+
+      check_model_columns( model )
+    end
+
+    def multiple_roots?
+      @multiple_roots
+    end
+
+    def fraction_cache?
+      @fraction_cache
+    end
+
+    private
+
+    def check_model_columns( model )
+      if missing_column = Constants::REQUIRED_COLUMNS.detect { |col| !model.columns_hash.has_key?( col.to_s ) }
+        raise Constants::MissingColumn.new( missing_column )
+      end
+
+      @fraction_cache = [:lft, :rgt].all? { |col| model.columns_hash.has_key?( col.to_s ) }
+    end
+
+  end
+end

data/lib/acts_as_nested_interval/constants.rb

@@ -0,0 +1,8 @@
+module ActsAsNestedInterval
+  module Constants
+    # Required fields by gem
+    REQUIRED_COLUMNS = [:rgtp, :rgtq, :lftp, :lftq]
+
+    class MissingColumn < Exception; end
+  end
+end

data/lib/acts_as_nested_interval/instance_methods.rb

@@ -5,9 +5,7 @@ module ActsAsNestedInterval
     # selectively define #descendants according to table features
     included do
       
-      #alias_method :parent_changed?, :"#{ nested_interval_foreign_key }_changed?"
-
-      if columns_hash["lft"]
+      if nested_interval.fraction_cache?
 
         def descendants
           #quoted_table_name = self.class.quoted_table_name
@@ -18,31 +16,31 @@ module ActsAsNestedInterval
           nested_interval_scope.where( "lftp > :lftp AND lft BETWEEN :lft AND :rgt", lftp: lftp, rgt: rgt, lft: lft )
         end
         
-      elsif nested_interval_lft_index
+      #elsif nested_interval_lft_index
         
-        def descendants
-          quoted_table_name = self.class.quoted_table_name
-          nested_interval_scope.where <<-SQL
-              #{lftp} < #{quoted_table_name}.lftp AND 
-              1.0 * #{quoted_table_name}.lftp / #{quoted_table_name}.lftq BETWEEN 
-                #{1.0 * lftp / lftq} AND
-                #{1.0 * rgtp / rgtq}
-          SQL
-        end
+        #def descendants
+          #quoted_table_name = self.class.quoted_table_name
+          #nested_interval_scope.where <<-SQL
+              ##{lftp} < #{quoted_table_name}.lftp AND 
+              #1.0 * #{quoted_table_name}.lftp / #{quoted_table_name}.lftq BETWEEN 
+                ##{1.0 * lftp / lftq} AND
+                ##{1.0 * rgtp / rgtq}
+          #SQL
+        #end
         
-      elsif connection.adapter_name == "MySQL"
+      #elsif connection.adapter_name == "MySQL"
         
-        def descendants
-          quoted_table_name = self.class.quoted_table_name
-          nested_interval_scope.where <<-SQL
-              ( #{quoted_table_name}.lftp != #{rgtp} OR 
-                #{quoted_table_name}.lftq != #{rgtq}
-              ) AND
-              #{quoted_table_name}.lftp BETWEEN 
-                1 + #{quoted_table_name}.lftq * #{lftp} DIV #{lftq} AND 
-                #{quoted_table_name}.lftq * #{rgtp} DIV #{rgtq}
-          SQL
-        end
+        #def descendants
+          #quoted_table_name = self.class.quoted_table_name
+          #nested_interval_scope.where <<-SQL
+              #( #{quoted_table_name}.lftp != #{rgtp} OR 
+                ##{quoted_table_name}.lftq != #{rgtq}
+              #) AND
+              ##{quoted_table_name}.lftp BETWEEN 
+                #1 + #{quoted_table_name}.lftq * #{lftp} DIV #{lftq} AND 
+                ##{quoted_table_name}.lftq * #{rgtp} DIV #{rgtq}
+          #SQL
+        #end
         
       else
         
@@ -71,7 +69,7 @@ module ActsAsNestedInterval
     end
     
     def set_nested_interval_for_top
-      if self.class.virtual_root
+      if nested_interval.multiple_roots?
         set_nested_interval(*next_root_lft)
       else
         set_nested_interval 0, 1
@@ -80,7 +78,7 @@ module ActsAsNestedInterval
 
     def nested_interval_scope
       conditions = {}
-      nested_interval_scope_columns.each do |column_name|
+      nested_interval.scope_columns.each do |column_name|
         conditions[column_name] = send(column_name)
       end
       self.class.where conditions
@@ -88,18 +86,18 @@ module ActsAsNestedInterval
 
     # Rewrite method
     def update_nested_interval_move
-      return if self.class.readonly_attributes.include?(nested_interval_foreign_key.to_sym) # Fix issue #9
+      return if self.class.readonly_attributes.include?(nested_interval.foreign_key.to_sym) # Fix issue #9
       begin
         db_self = self.class.find(id)
-        db_parent = self.class.find(read_attribute(nested_interval_foreign_key))
+        db_parent = self.class.find(read_attribute(nested_interval.foreign_key))
         if db_self.ancestor_of?(db_parent)
-          errors.add nested_interval_foreign_key, "is descendant"
+          errors.add nested_interval.foreign_key, "is descendant"
           raise ActiveRecord::RecordInvalid, self
         end
       rescue ActiveRecord::RecordNotFound => e # root
       end
       
-      if read_attribute(nested_interval_foreign_key).nil? # root move
+      if read_attribute(nested_interval.foreign_key).nil? # root move
         set_nested_interval_for_top
       else # child move
         set_nested_interval *parent.next_child_lft

data/lib/acts_as_nested_interval/version.rb

@@ -1,3 +1,3 @@
 module ActsAsNestedInterval
-  VERSION = "0.2.0.pre"
+  VERSION = "0.2.0.pre2"
 end

data/lib/acts_as_nested_interval.rb

@@ -6,6 +6,8 @@
 
 require 'acts_as_nested_interval/core_ext/integer'
 require 'acts_as_nested_interval/version'
+require 'acts_as_nested_interval/constants'
+require 'acts_as_nested_interval/configuration'
 require 'acts_as_nested_interval/callbacks'
 require 'acts_as_nested_interval/instance_methods'
 require 'acts_as_nested_interval/class_methods'
@@ -25,33 +27,41 @@ module ActsAsNestedInterval
     # * <tt>:virtual_root</tt> -- whether to compute root's interval as in an upper root (default false)
     # * <tt>:dependent</tt> -- dependency between the parent node and children nodes (default :restrict)
     def acts_as_nested_interval(options = {})
-      cattr_accessor :nested_interval_foreign_key
-      cattr_accessor :nested_interval_scope_columns
+      # Refactored
+      # TODO: table_exists?
+      cattr_accessor :nested_interval
+
+      self.nested_interval = Configuration.new( self, **options )
+
+      if nested_interval.fraction_cache?
+        scope :preorder, -> { order(rgt: :desc, lftp: :asc) }
+      else
+        scope :preorder, -> { order('1.0 * rgtp / rgtq DESC, lftp ASC') }
+      end
+      # When?
+      #scope :preorder, -> { order('nested_interval_rgt(lftp, lftq) DESC, lftp ASC') }
+
+
+      # OLD CODE
+      #cattr_accessor :nested_interval_foreign_key
+      #cattr_accessor :nested_interval_scope_columns
       cattr_accessor :nested_interval_lft_index
-      cattr_accessor :nested_interval_dependent
+      #cattr_accessor :nested_interval_dependent
 
       cattr_accessor :virtual_root
       self.virtual_root = !!options[:virtual_root]
 
-      self.nested_interval_foreign_key = options[:foreign_key] || :parent_id
-      self.nested_interval_scope_columns = Array(options[:scope_columns])
+      #self.nested_interval_foreign_key = options[:foreign_key] || :parent_id
+      #self.nested_interval_scope_columns = Array(options[:scope_columns])
       self.nested_interval_lft_index = options[:lft_index]
-      self.nested_interval_dependent = options[:dependent] || :restrict_with_exception
+      #self.nested_interval_dependent = options[:dependent] || :restrict_with_exception
 
-      belongs_to :parent, class_name: name, foreign_key: nested_interval_foreign_key
-      has_many :children, class_name: name, foreign_key: nested_interval_foreign_key,
-        dependent: nested_interval_dependent
-      scope :roots, -> { where(nested_interval_foreign_key => nil) }
+      belongs_to :parent, class_name: name, foreign_key: nested_interval.foreign_key
+      has_many :children, class_name: name, foreign_key: nested_interval.foreign_key,
+        dependent: nested_interval.dependent
+      scope :roots, -> { where(nested_interval.foreign_key => nil) }
 
       if self.table_exists? # Fix problem with migrating without table
-        if columns_hash["rgt"]
-          scope :preorder, -> { order('rgt DESC, lftp ASC') }
-        elsif columns_hash["rgtp"] && columns_hash["rgtq"]
-          scope :preorder, -> { order('1.0 * rgtp / rgtq DESC, lftp ASC') }
-        else
-          scope :preorder, -> { order('nested_interval_rgt(lftp, lftq) DESC, lftp ASC') }
-        end
-
         include ActsAsNestedInterval::InstanceMethods
         include ActsAsNestedInterval::Callbacks
         extend ActsAsNestedInterval::ClassMethods

data/test/acts_as_nested_interval_test.rb

@@ -1,5 +1,9 @@
 require 'test_helper'
 
+def set_virtual_root( value )
+  Region.nested_interval.instance_eval("@multiple_roots = #{ value }")
+end
+
 class ActsAsNestedIntervalTest < ActiveSupport::TestCase
   def test_modular_inverse
     assert_equal [nil, 1, 5, nil, 7, 2, nil, 4, 8], (0...9).map { |k| k.inverse(9) }
@@ -195,7 +199,7 @@ class ActsAsNestedIntervalTest < ActiveSupport::TestCase
   end
 
   def test_virtual_root_order
-    Region.virtual_root = true
+    set_virtual_root( true )
     r1 = Region.create name: "1"
     r2 = Region.create name: "2"
     r3 = Region.create name: "3"
@@ -204,7 +208,7 @@ class ActsAsNestedIntervalTest < ActiveSupport::TestCase
   end
   
   def test_virtual_root_allocation
-    Region.virtual_root = true
+    set_virtual_root( true )
     r1 = Region.create name: "Europe"
     r2 = Region.create name: "Romania", :parent => r1
     r3 = Region.create name: "Asia"
@@ -215,7 +219,7 @@ class ActsAsNestedIntervalTest < ActiveSupport::TestCase
   end
   
   def test_rebuild_nested_interval_tree
-    Region.virtual_root = true
+    set_virtual_root( true )
     r1 = Region.create name: "Europe"
     r2 = Region.create name: "Romania", parent: r1
     r3 = Region.create name: "Asia"
@@ -227,7 +231,7 @@ class ActsAsNestedIntervalTest < ActiveSupport::TestCase
   end
   
   def test_root_update_keeps_interval
-    Region.virtual_root = true
+    set_virtual_root( true )
     r1 = Region.create name: "Europe"
     r2 = Region.create name: "Romania", parent: r1
     r3 = Region.create name: "Asia"
@@ -239,7 +243,7 @@ class ActsAsNestedIntervalTest < ActiveSupport::TestCase
   end
   
   def test_move_to_root_recomputes_interval
-    Region.virtual_root = true
+    set_virtual_root( true )
     r1 = Region.create name: "Europe"
     r2 = Region.create name: "Romania", parent: r1
     r3 = Region.create name: "Asia"

data/test/dummy/db/schema.rb

@@ -13,9 +13,6 @@
 
 ActiveRecord::Schema.define(version: 20121004204252) do
 
-  # These are extensions that must be enabled in order to support this database
-  enable_extension "plpgsql"
-
   create_table "regions", force: true do |t|
     t.boolean "fiction",                             default: false, null: false
     t.integer "region_id"

data/test/dummy/log/development.log

@@ -15,3 +15,18 @@ Migrating to ChangeIntervalPrecision (20121004204252)
   SQL (1.0ms)  INSERT INTO "schema_migrations" ("version") VALUES ($1)  [["version", "20121004204252"]]
    (17.3ms)  COMMIT
   ActiveRecord::SchemaMigration Load (0.9ms)  SELECT "schema_migrations".* FROM "schema_migrations"
+   (1710.7ms)  CREATE TABLE `schema_migrations` (`version` varchar(255) NOT NULL) ENGINE=InnoDB
+   (119.1ms)  CREATE UNIQUE INDEX `unique_schema_migrations`  ON `schema_migrations` (`version`) 
+  ActiveRecord::SchemaMigration Load (0.9ms)  SELECT `schema_migrations`.* FROM `schema_migrations`
+Migrating to CreateRegions (20120302143528)
+   (87.2ms)  CREATE TABLE `regions` (`id` int(11) auto_increment PRIMARY KEY, `fiction` tinyint(1) DEFAULT 0 NOT NULL, `region_id` int(11), `lftp` int(11) NOT NULL, `lftq` int(11) NOT NULL, `rgtp` int(11) NOT NULL, `rgtq` int(11) NOT NULL, `lft` float NOT NULL, `rgt` float NOT NULL, `name` varchar(255) NOT NULL) ENGINE=InnoDB
+   (0.4ms)  BEGIN
+  SQL (0.9ms)  INSERT INTO `schema_migrations` (`version`) VALUES ('20120302143528')
+   (23.7ms)  COMMIT
+Migrating to ChangeIntervalPrecision (20121004204252)
+   (157.5ms)  ALTER TABLE `regions` CHANGE `lft` `lft` decimal(31,30) NOT NULL
+   (102.6ms)  ALTER TABLE `regions` CHANGE `rgt` `rgt` decimal(31,30) NOT NULL
+   (0.5ms)  BEGIN
+  SQL (1.4ms)  INSERT INTO `schema_migrations` (`version`) VALUES ('20121004204252')
+   (23.8ms)  COMMIT
+  ActiveRecord::SchemaMigration Load (0.8ms)  SELECT `schema_migrations`.* FROM `schema_migrations`