Module: SymetrieCom::Acts::NestedSet::InstanceMethods

By default, records are compared and sorted using the left column.

Deprecated. Adds a child to this object in the tree. If this object hasn‘t been initialized, it gets set up as a root node.

This method exists only for compatibility and will be removed in future versions.

all_children(scope = {})

Returns all children and nested children. Pass :exclude => item, or id, or [items or id] to exclude one or more items and all of their descendants.

all_children_count(scope = nil)

Returns the number of nested children of this object.

all_children_through(other, scope = {})

All children until the other is reached - excluding self

ancestors(scope = {})

Returns an array of all parents, starting with the root.

ancestors_and_self_through(other, scope = {})

All nodes between two nodes, those nodes included in effect all ancestors until the other is reached

ancestors_through(other, scope = {})

Ancestors until the other is reached - excluding self

check_full_tree()

Checks the left/right indexes of the entire tree that this node belongs to, returning the number of records checked. Throws ActiveRecord::ActiveRecordError if it finds a problem. This method is needed because check_subtree alone cannot find gaps between virtual roots, orphaned nodes or endless loops.

check_subtree()

Checks the left/right indexes of one node and all descendants. Throws ActiveRecord::ActiveRecordError if it finds a problem.

child?()

Deprecated. Returns true if this is a child node

child_by_id(id, scope = {})

Returns the child for the requested id within the scope of its children, otherwise nil

child_of?(parent, scope = {})

Tests wether self is within scope of parent

children(scope = {})

Returns this record‘s immediate children.

children?(scope = {})

children_by_id(*args)

Returns a child collection for the requested ids within the scope of its children, otherwise empty array

children_count(scope= {})

destroy_descendants(

On destruction, delete all children and shift the lft/rgt values back to the left so the counts still work.

direct_child_by_id(id, scope = {})

Returns the child for the requested id within the scope of its immediate children, otherwise nil

direct_child_of?(parent, scope = {})

Tests wether self is within immediate scope of parent

direct_children(scope = {})

Alias for children

direct_children_by_id(*args)

Returns a child collection for the requested ids within the scope of its immediate children, otherwise empty array

first?(scope = {})

Alias for first_sibling?

first_sibling(scope = {})

Returns first siblings amongst it‘s siblings.

first_sibling?(scope = {})

full_set(scope = {})

Returns itself and all nested children. Pass :exclude => item, or id, or [items or id] to exclude one or more items and all of their descendants.

full_set_through(other, scope = {})

All children until the other is reached - including self

higher_item(num = 1, scope = {})

Alias for previous_sibling

insert_at(target, index = :last, scope = {})

Insert a node at a specific position among the children of target.

last?(scope = {})

Alias for last_sibling?

last_sibling(scope = {})

Returns last siblings amongst it‘s siblings.

last_sibling?(scope = {})

leaves(scope = {})

Returns this record‘s terminal children (nodes without children).

leaves_count(scope = {})

Returns the count of this record‘s terminal children (nodes without children).

level(scope = {})

Returns the level of this object in the tree, root level being 0.

lower_item(num = 1, scope = {})

Alias for next_sibling

move_higher()

Moves a node one down amongst its siblings. Does nothing if it‘s already the last sibling.

move_lower()

Moves a node one up amongst its siblings. Does nothing if it‘s already the first sibling.

move_to_bottom()

Moves a node one to be the last amongst its siblings. Does nothing if it‘s already the last sibling.

move_to_child_of(target)

Make this node a child of target (you can pass an object or just an id). Unsaved changes in either object will be lost. Raises ActiveRecord::ActiveRecordError if it encounters a problem.

move_to_left_of(target)

Move this node to the left of target (you can pass an object or just an id). Unsaved changes in either object will be lost. Raises ActiveRecord::ActiveRecordError if it encounters a problem.

move_to_position(index, scope = {})

Moves a node to a certain position amongst its siblings.

move_to_right_of(target)

Move this node to the right of target (you can pass an object or just an id). Unsaved changes in either object will be lost. Raises ActiveRecord::ActiveRecordError if it encounters a problem.

move_to_top()

Moves a node one to be the first amongst its siblings. Does nothing if it‘s already the first sibling.

next_sibling(num = 1, scope = {})

Returns next sibling of node or nil if there is none.

next_siblings(scope = {})

Returns all siblings to the right of self, in ascending order, so the first sibling is the one closest to the right of self

parent()

Returns this record‘s parent.

previous_sibling(num = 1, scope = {})

Returns previous sibling of node or nil if there is none.

previous_siblings(scope = {})

Returns all siblings to the left of self, in descending order, so the first sibling is the one closest to the left of self

renumber_full_tree()

Re-calculate the left/right values of all nodes in this record‘s tree. Can be used to convert an ordinary tree into a nested set.

reorder_children(*ids)

Reorder children according to an array of ids

root(scope = {})

Returns this record‘s root ancestor.

root?()

Deprecated. Returns true if this is a root node.

roots(scope = {})

Returns the root or virtual roots of this record‘s tree (a tree cannot have more than one real root). See the explanation of virtual roots in the README.

self_and_ancestors(scope = {})

Returns an array of all parents plus self, starting with the root.

self_and_siblings(scope = {})

Returns all the children of this node‘s parent, including self.

self_and_siblings_through(other, scope = {})

All siblings until the other is reached - including self

set_left_right(

On creation, automatically add the new node to the right of all existing nodes in this tree.

sibling_condition()

This takes care of valid queries when called on a root node

siblings(scope = {})

Returns all the children of this node‘s parent, except self.