simple_nested_set 0.0.1

data/lib/simple_nested_set/act_macro.rb

@@ -0,0 +1,42 @@
+module SimpleNestedSet
+  module ActMacro
+    def acts_as_nested_set(options = {})
+      return if acts_as_nested_set?
+
+      include SimpleNestedSet::InstanceMethods
+      extend SimpleNestedSet::ClassMethods
+
+      # TODO get callbacks working
+      # define_callbacks :move, :terminator => "result == false"
+      # before_move :init_as_node
+
+      before_validation :init_as_node
+      before_destroy :prune_branch
+      belongs_to :parent, :class_name => self.name
+      has_many :children, :foreign_key => :parent_id, :class_name => self.base_class.name
+
+      default_scope :order => :lft
+
+      klass = options[:class] || self
+      scopes = Array(options[:scope]).map { |s| s.to_s !~ /_id$/ ? :"#{s}_id" : s }
+
+      nested_set_proc = lambda do |*args|
+        args.empty? ? {} : { :conditions => nested_set.conditions(*args) }
+      end
+
+      scope :nested_set, nested_set_proc do
+        define_method(:scope_columns) { scopes }
+        define_method(:klass) { klass }
+        define_method(:conditions) { |record| scopes.inject({}) { |c, name| c.merge(name => record[name]) } }
+      end
+
+      scope :with_levels, lambda {
+        { :select => "COUNT(id) AS level" } # TODO ... ?
+      }
+    end
+
+    def acts_as_nested_set?
+      included_modules.include?(SimpleNestedSet::InstanceMethods)
+    end
+  end
+end

data/lib/simple_nested_set/class_methods.rb

@@ -0,0 +1,44 @@
+require 'active_support/core_ext/hash/slice'
+
+module SimpleNestedSet
+  module ClassMethods
+    NESTED_SET_ATTRIBUTES = [:parent_id, :left_id, :right_id]
+
+    def create(attributes)
+      with_move_by_attributes(attributes) { super }
+    end
+
+    def create!(attributes)
+      with_move_by_attributes(attributes) { super }
+    end
+
+    # Returns the single root
+    def root(*args)
+      nested_set(*args).first(:conditions => { :parent_id => nil })
+    end
+
+    # Returns roots when multiple roots (or virtual root, which is the same)
+    def roots(*args)
+      nested_set(*args).scoped(:conditions => { :parent_id => nil } )
+    end
+
+    def leaves(*args)
+      nested_set(*args).scoped(:conditions => 'lft = rgt - 1' )
+    end
+
+    protected
+
+      def with_move_by_attributes(attributes)
+        transaction do
+          nested_set_attributes = extract_nested_set_attributes!(attributes)
+          yield.tap { |record| record.send(:move_by_attributes, nested_set_attributes) }
+        end
+      end
+
+      def extract_nested_set_attributes!(attributes)
+        result = attributes.slice(*NESTED_SET_ATTRIBUTES)
+        attributes.except!(*NESTED_SET_ATTRIBUTES)
+        result
+      end
+  end
+end

data/lib/simple_nested_set/instance_methods.rb

@@ -0,0 +1,354 @@
+require 'active_support/core_ext/hash/keys'
+
+module SimpleNestedSet
+  module InstanceMethods
+    def update_attributes(attributes)
+      move_by_attributes(attributes)
+      super
+    end
+
+    def update_attributes!(attributes)
+      move_by_attributes(attributes)
+      super
+    end
+
+    # Returns true if the node has the same scope as the given node
+    def same_scope?(other)
+      nested_set.scope_columns.all? { |name| self.send(name) == other.send(name) }
+    end
+
+    # Returns the level of this object in the tree, root level is 0
+    def level
+      parent_id.nil? ? 0 : ancestors.count
+    end
+
+    # Returns true if this is a root node.
+    def root?
+      parent_id.blank?
+    end
+
+    # Returns true is this is a child node
+    def child?
+      !root?
+    end
+
+    def leaf?
+      rgt - lft == 1
+    end
+
+    # compare by left column
+    def <=>(other)
+      lft <=> other.lft
+    end
+
+    # Returns the root
+    def root
+      root? ? self : ancestors.first
+    end
+
+    # Returns the parent
+    def parent
+      nested_set.klass.find(parent_id) unless root?
+    end
+
+    def ancestor_of?(other)
+      lft < other.lft && rgt > other.rgt
+    end
+
+    def self_or_ancestor_of?(other)
+      self == other || ancestor_of?(other)
+    end
+
+    # Returns an array of all parents
+    def ancestors
+      nested_set.scoped(:conditions => "lft < #{lft} AND rgt > #{rgt}")
+    end
+
+    # Returns the array of all parents and self
+    def self_and_ancestors
+      ancestors + [self]
+    end
+
+    def descendent_of?(other)
+      lft > other.lft && rgt < other.rgt
+    end
+
+    def self_or_descendent_of?(other)
+      self == other || descendent_of?(other)
+    end
+
+    # Returns a set of all of its children and nested children.
+    def descendants
+      rgt - lft == 1 ? []  : nested_set.scoped(:conditions => ['lft > ? AND rgt < ?', lft, rgt])
+    end
+
+    # Returns a set of itself and all of its nested children.
+    def self_and_descendants
+      [self] + descendants
+    end
+
+    # Returns the number of descendents
+    def descendents_count
+      rgt > lft ? (rgt - lft - 1) / 2 : 0
+    end
+
+    # # Returns a set of only this entry's immediate children
+    # def children
+    #   rgt - lft == 1 ? []  : nested_set.scoped(:conditions => { :parent_id => id })
+    # end
+
+    # Returns a set of only this entry's immediate children including self
+    def self_and_children
+      [self] + children
+    end
+
+    # Returns true if the node has any children
+    def children?
+      descendents_count > 0
+    end
+    alias has_children? children?
+
+    # Returns the array of all children of the parent, except self
+    def siblings
+      without_self(self_and_siblings)
+    end
+
+    # Returns the array of all children of the parent, included self
+    def self_and_siblings
+      nested_set.scoped(:conditions => { :parent_id => parent_id })
+    end
+
+    # Returns the lefthand sibling
+    def previous_sibling
+      nested_set.first :conditions => { :rgt => lft - 1 }
+    end
+    alias left_sibling previous_sibling
+
+    # Returns the righthand sibling
+    def next_sibling
+      nested_set.first :conditions => { :lft => rgt + 1 }
+    end
+    alias right_sibling next_sibling
+
+    # Returns all descendents that are leaves
+    def leaves
+      rgt - lft == 1 ? []  : nested_set.scoped(:conditions => ["lft > ? AND rgt < ? AND lft = rgt - 1", lft, rgt])
+    end
+
+    # Move the node to the child of another node
+    def move_to_child_of(node)
+      node ? move_to(node, :child) : move_to_root
+    end
+
+    def move_to_root
+      move_to(nil, :root)
+    end
+
+    # moves the node to the left of its left sibling if any
+    def move_left
+      move_to_left_of(left_sibling) if left_sibling
+    end
+
+    # moves the node to the right of its right sibling if any
+    def move_right
+      move_to_right_of(right_sibling) if right_sibling
+    end
+
+    # Move the node to the left of another node
+    def move_to_left_of(node)
+      move_to(node, :left)
+    end
+
+    # Move the node to the left of another node
+    def move_to_right_of(node)
+      move_to(node, :right)
+    end
+
+    protected
+
+      def nested_set
+        @nested_set ||= self.class.nested_set(self)
+      end
+
+      def without_self(scope)
+        scope.scoped :conditions => ["#{self.class.table_name}.id <> ?", id]
+      end
+
+      # before validation set lft and rgt to the end of the tree
+      def init_as_node
+        if lft.nil? || rgt.nil?
+          max_right = nested_set.maximum(:rgt) || 0
+          self.lft = max_right + 1
+          self.rgt = max_right + 2
+        end
+      end
+
+      # Prunes a branch off of the tree, shifting all of the elements on the right
+      # back to the left so the counts still work.
+      def prune_branch
+        unless rgt.nil? || lft.nil?
+          diff = rgt - lft + 1
+          self.class.transaction {
+            nested_set.delete_all "lft > #{lft} AND rgt < #{rgt}"
+            nested_set.update_all "lft = (lft - #{diff})",   "lft >= #{rgt}"
+            nested_set.update_all "rgt = (rgt - #{diff} )",  "rgt >= #{rgt}"
+          }
+        end
+      end
+
+      # reload left, right, and parent
+      def reload_nested_set
+        reload :select => 'lft, rgt, parent_id'
+      end
+
+      def move_by_attributes(attributes)
+        return unless attributes.detect { |key, value| [:parent_id, :left_id, :right_id].include?(key.to_sym) }
+
+        attributes.symbolize_keys!
+        attributes.each { |key, value| attributes[key] = nil if value == 'null' }
+
+        parent_id = attributes[:parent_id] ? attributes[:parent_id] : self.parent_id
+        parent = parent_id.blank? ? nil : nested_set.klass.find(parent_id)
+
+        # if left_id is given but blank, set right_id to leftmost sibling
+        if attributes.has_key?(:left_id) && attributes[:left_id].blank?
+          attributes.delete(:left_id)
+          siblings = parent ? parent.children : self.class.roots(self)
+          attributes[:right_id] = siblings.first.id if siblings.first
+        end
+
+        # if right_id is given but blank, set left_id to rightmost sibling
+        if attributes.has_key?(:right_id) && attributes[:right_id].blank?
+          attributes.delete(:right_id)
+          siblings = parent ? parent.children : self.class.roots(self)
+          attributes[:left_id] = siblings.last.id if siblings.last
+        end
+
+        parent_id, left_id, right_id = [:parent_id, :left_id, :right_id].map do |key|
+          value = attributes.delete(key)
+          value.blank? ? nil : value.to_i
+        end
+
+        protect_inconsistent_move!(parent_id, left_id, right_id)
+
+        if left_id && left_id != id
+          move_to_right_of(left_id)
+        elsif right_id && right_id != id
+          move_to_left_of(right_id)
+        elsif parent_id != self.parent_id
+          move_to_child_of(parent_id)
+        end
+      end
+
+      def move_to(target, position)
+        # return if _run_before_move_callbacks == false
+
+        transaction do
+          target.reload_nested_set if target.is_a?(nested_set.klass)
+          self.reload_nested_set
+
+          target = nested_set.klass.find(target) if target && !target.is_a?(ActiveRecord::Base)
+          protect_impossible_move!(position, target) if target
+
+          bound = case position
+            when :child
+              target.rgt
+            when :left
+              target.lft
+            when :right
+              target.rgt + 1
+            when :root
+              roots = self.class.roots
+              roots.empty? ? 1 : roots.last.rgt + 1
+          end
+
+          if bound > rgt
+            bound -= 1
+            other_bound = rgt + 1
+          else
+            other_bound = lft - 1
+          end
+
+          # there would be no change
+          return if bound == rgt || bound == lft
+
+          # we have defined the boundaries of two non-overlapping intervals,
+          # so sorting puts both the intervals and their boundaries in order
+          a, b, c, d = [lft, rgt, bound, other_bound].sort
+
+          parent_id = case position
+            when :child;  target.id
+            when :root;   nil
+            else          target.parent_id
+          end
+
+          sql = <<-sql
+            lft = CASE
+              WHEN lft BETWEEN :a AND :b THEN lft + :d - :b
+              WHEN lft BETWEEN :c AND :d THEN lft + :a - :c
+              ELSE lft END,
+
+            rgt = CASE
+              WHEN rgt BETWEEN :a AND :b THEN rgt + :d - :b
+              WHEN rgt BETWEEN :c AND :d THEN rgt + :a - :c
+              ELSE rgt END,
+
+            parent_id = CASE
+              WHEN id = :id THEN :parent_id
+              ELSE parent_id END
+          sql
+          args  = { :a => a, :b => b, :c => c, :d => d, :id => id, :parent_id => parent_id }
+          nested_set.klass.update_all [sql, args], nested_set.conditions(self)
+
+          target.reload_nested_set if target
+          reload_nested_set
+
+          # _run_after_move_callbacks
+        end
+      end
+
+      def protect_impossible_move!(position, target)
+        positions = [:child, :left, :right, :root]
+        impossible_move!("Position must be one of #{positions.inspect} but is #{position.inspect}.") unless positions.include?(position)
+        impossible_move!("A new node can not be moved") if new_record?
+        impossible_move!("A node can't be moved to itself") if self == target
+        impossible_move!("A node can't be moved to a descendant of itself.") if (lft..rgt).include?(target.lft) && (lft..rgt).include?(target.rgt)
+        impossible_move!("A node can't be moved to a different scope") unless same_scope?(target)
+      end
+
+      def protect_inconsistent_move!(parent_id, left_id, right_id)
+        left = self.class.find(left_id) if left_id
+        right = self.class.find(right_id) if right_id
+
+        if left && right && (!left.right_sibling || left.right_sibling.id != right_id)
+          inconsistent_move! <<-msg
+            Both :left_id (#{left_id.inspect}) and :right_id (#{right_id.inspect}) were given but
+            :right_id (#{right_id}) does not refer to the right_sibling (#{left.right_sibling.inspect})
+            of the node referenced by :left_id (#{left.inspect})
+          msg
+        end
+
+        if left && parent_id && left.parent_id != parent_id
+          inconsistent_move! <<-msg
+            Both :left_id (#{left_id.inspect}) and :parent_id (#{parent_id.inspect}) were given but
+            left.parent_id (#{left.parent_id}) does not equal parent_id
+          msg
+        end
+
+        if right && parent_id && right.parent_id != parent_id
+          inconsistent_move! <<-msg
+            Both :right_id (#{right_id.inspect}) and :parent_id (#{parent_id.inspect}) were given but
+            right.parent_id (#{right.parent_id}) does not equal parent_id
+          msg
+        end
+      end
+
+      def inconsistent_move!(message)
+        raise InconsistentMove, "Impossible move: #{message.split("\n").map! { |line| line.strip }.join}"
+      end
+
+      def impossible_move!(message)
+        raise ImpossibleMove, "Impossible move: #{message.split("\n").map! { |line| line.strip }.join}"
+      end
+  end
+end

data/lib/simple_nested_set/version.rb

@@ -0,0 +1,3 @@
+module SimpleNestedSet
+  VERSION = "0.0.1"
+end

data/lib/simple_nested_set.rb

@@ -0,0 +1,10 @@
+module SimpleNestedSet
+  class InconsistentMove < ActiveRecord::ActiveRecordError ; end
+  class ImpossibleMove   < ActiveRecord::ActiveRecordError ; end
+
+  autoload :ActMacro,        'simple_nested_set/act_macro'
+  autoload :ClassMethods,    'simple_nested_set/class_methods'
+  autoload :InstanceMethods, 'simple_nested_set/instance_methods'
+end
+
+ActiveRecord::Base.send :extend, SimpleNestedSet::ActMacro

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification 
+name: simple_nested_set
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Sven Fuchs
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-02 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: -1848230024
+        segments: 
+        - 3
+        - 0
+        - 0
+        - beta4
+        version: 3.0.0.beta4
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: database_cleaner
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: test_declarative
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: pathname_local
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: "[description]"
+email: svenfuchs@artweb-design.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/simple_nested_set.rb
+- lib/simple_nested_set/act_macro.rb
+- lib/simple_nested_set/class_methods.rb
+- lib/simple_nested_set/instance_methods.rb
+- lib/simple_nested_set/version.rb
+has_rdoc: true
+homepage: http://github.com/svenfuchs/simple_nested_set
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: "[none]"
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: "[summary]"
+test_files: []
+