jro_apps/redmine Commit - r2797:531eb6555777

1

module CollectiveIdea #:nodoc:

1

module CollectiveIdea #:nodoc:

2

module Acts #:nodoc:

2

module Acts #:nodoc:

3

module NestedSet #:nodoc:

3

module NestedSet #:nodoc:

4

def self.included(base)

4

def self.included(base)

5

base.extend(SingletonMethods)

5

base.extend(SingletonMethods)

6

end

6

end

7

8

# This acts provides Nested Set functionality. Nested Set is a smart way to implement

8

# This acts provides Nested Set functionality. Nested Set is a smart way to implement

9

# an _ordered_ tree, with the added feature that you can select the children and all of their

9

# an _ordered_ tree, with the added feature that you can select the children and all of their

10

# descendants with a single query. The drawback is that insertion or move need some complex

10

# descendants with a single query. The drawback is that insertion or move need some complex

11

# sql queries. But everything is done here by this module!

11

# sql queries. But everything is done here by this module!

12

#

12

#

13

# Nested sets are appropriate each time you want either an orderd tree (menus,

13

# Nested sets are appropriate each time you want either an orderd tree (menus,

14

# commercial categories) or an efficient way of querying big trees (threaded posts).

14

# commercial categories) or an efficient way of querying big trees (threaded posts).

15

#

15

#

16

# == API

16

# == API

17

#

17

#

18

# Methods names are aligned with acts_as_tree as much as possible, to make replacment from one

18

# Methods names are aligned with acts_as_tree as much as possible, to make replacment from one

19

# by another easier, except for the creation:

19

# by another easier, except for the creation:

20

#

20

#

21

# in acts_as_tree:

21

# in acts_as_tree:

22

# item.children.create(:name => "child1")

22

# item.children.create(:name => "child1")

23

#

23

#

24

# in acts_as_nested_set:

24

# in acts_as_nested_set:

25

# # adds a new item at the "end" of the tree, i.e. with child.left = max(tree.right)+1

25

# # adds a new item at the "end" of the tree, i.e. with child.left = max(tree.right)+1

26

# child = MyClass.new(:name => "child1")

26

# child = MyClass.new(:name => "child1")

27

# child.save

27

# child.save

28

# # now move the item to its right place

28

# # now move the item to its right place

29

# child.move_to_child_of my_item

29

# child.move_to_child_of my_item

30

#

30

#

31

# You can pass an id or an object to:

31

# You can pass an id or an object to:

32

# * <tt>#move_to_child_of</tt>

32

# * <tt>#move_to_child_of</tt>

33

# * <tt>#move_to_right_of</tt>

33

# * <tt>#move_to_right_of</tt>

34

# * <tt>#move_to_left_of</tt>

34

# * <tt>#move_to_left_of</tt>

35

#

35

#

36

module SingletonMethods

36

module SingletonMethods

37

# Configuration options are:

37

# Configuration options are:

38

#

38

#

39

# * +:parent_column+ - specifies the column name to use for keeping the position integer (default: parent_id)

39

# * +:parent_column+ - specifies the column name to use for keeping the position integer (default: parent_id)

40

# * +:left_column+ - column name for left boundry data, default "lft"

40

# * +:left_column+ - column name for left boundry data, default "lft"

41

# * +:right_column+ - column name for right boundry data, default "rgt"

41

# * +:right_column+ - column name for right boundry data, default "rgt"

42

# * +:scope+ - restricts what is to be considered a list. Given a symbol, it'll attach "_id"

42

# * +:scope+ - restricts what is to be considered a list. Given a symbol, it'll attach "_id"

43

# (if it hasn't been already) and use that as the foreign key restriction. You

43

# (if it hasn't been already) and use that as the foreign key restriction. You

44

# can also pass an array to scope by multiple attributes.

44

# can also pass an array to scope by multiple attributes.

45

# Example: <tt>acts_as_nested_set :scope => [:notable_id, :notable_type]</tt>

45

# Example: <tt>acts_as_nested_set :scope => [:notable_id, :notable_type]</tt>

46

# * +:dependent+ - behavior for cascading destroy. If set to :destroy, all the

46

# * +:dependent+ - behavior for cascading destroy. If set to :destroy, all the

47

# child objects are destroyed alongside this object by calling their destroy

47

# child objects are destroyed alongside this object by calling their destroy

48

# method. If set to :delete_all (default), all the child objects are deleted

48

# method. If set to :delete_all (default), all the child objects are deleted

49

# without calling their destroy method.

49

# without calling their destroy method.

50

#

50

#

51

# See CollectiveIdea::Acts::NestedSet::ClassMethods for a list of class methods and

51

# See CollectiveIdea::Acts::NestedSet::ClassMethods for a list of class methods and

52

# CollectiveIdea::Acts::NestedSet::InstanceMethods for a list of instance methods added

52

# CollectiveIdea::Acts::NestedSet::InstanceMethods for a list of instance methods added

53

# to acts_as_nested_set models

53

# to acts_as_nested_set models

54

def acts_as_nested_set(options = {})

54

def acts_as_nested_set(options = {})

55

options = {

55

options = {

56

:parent_column => 'parent_id',

56

:parent_column => 'parent_id',

57

:left_column => 'lft',

57

:left_column => 'lft',

58

:right_column => 'rgt',

58

:right_column => 'rgt',

59

:order => 'id',

59

:order => 'id',

60

:dependent => :delete_all, # or :destroy

60

:dependent => :delete_all, # or :destroy

61

}.merge(options)

61

}.merge(options)

62

63

if options[:scope].is_a?(Symbol) && options[:scope].to_s !~ /_id$/

63

if options[:scope].is_a?(Symbol) && options[:scope].to_s !~ /_id$/

64

options[:scope] = "#{options[:scope]}_id".intern

64

options[:scope] = "#{options[:scope]}_id".intern

65

end

65

end

66

67

write_inheritable_attribute :acts_as_nested_set_options, options

67

write_inheritable_attribute :acts_as_nested_set_options, options

68

class_inheritable_reader :acts_as_nested_set_options

68

class_inheritable_reader :acts_as_nested_set_options

69

70

include Comparable

70

include Comparable

71

include Columns

71

include Columns

72

include InstanceMethods

72

include InstanceMethods

73

extend Columns

73

extend Columns

74

extend ClassMethods

74

extend ClassMethods

75

76

# no bulk assignment

76

# no bulk assignment

77

attr_protected left_column_name.intern,

77

attr_protected left_column_name.intern,

78

right_column_name.intern,

78

right_column_name.intern,

79

parent_column_name.intern

79

parent_column_name.intern

80

81

before_create :set_default_left_and_right

81

before_create :set_default_left_and_right

82

before_destroy :prune_from_tree

82

before_destroy :prune_from_tree

83

84

# no assignment to structure fields

84

# no assignment to structure fields

85

[left_column_name, right_column_name, parent_column_name].each do |column|

85

[left_column_name, right_column_name, parent_column_name].each do |column|

86

module_eval <<-"end_eval", __FILE__, __LINE__

86

module_eval <<-"end_eval", __FILE__, __LINE__

87

def #{column}=(x)

87

def #{column}=(x)

88

raise ActiveRecord::ActiveRecordError, "Unauthorized assignment to #{column}: it's an internal field handled by acts_as_nested_set code, use move_to_* methods instead."

88

raise ActiveRecord::ActiveRecordError, "Unauthorized assignment to #{column}: it's an internal field handled by acts_as_nested_set code, use move_to_* methods instead."

89

end

89

end

90

end_eval

90

end_eval

91

end

91

end

92

93

named_scope :roots, :conditions => {parent_column_name => nil}, :order => quoted_left_column_name

93

named_scope :roots, :conditions => {parent_column_name => nil}, :order => quoted_left_column_name

94

named_scope :leaves, :conditions => "#{quoted_right_column_name} - #{quoted_left_column_name} = 1", :order => quoted_left_column_name

94

named_scope :leaves, :conditions => "#{quoted_right_column_name} - #{quoted_left_column_name} = 1", :order => quoted_left_column_name

95

if self.respond_to?(:define_callbacks)

95

if self.respond_to?(:define_callbacks)

96

define_callbacks("before_move", "after_move")

96

define_callbacks("before_move", "after_move")

97

end

97

end

98

99

100

end

100

end

101

102

end

102

end

103

104

module ClassMethods

104

module ClassMethods

105

106

# Returns the first root

106

# Returns the first root

107

def root

107

def root

108

roots.find(:first)

108

roots.find(:first)

109

end

109

end

110

111

def valid?

111

def valid?

112

left_and_rights_valid? && no_duplicates_for_columns? && all_roots_valid?

112

left_and_rights_valid? && no_duplicates_for_columns? && all_roots_valid?

113

end

113

end

114

115

def left_and_rights_valid?

115

def left_and_rights_valid?

116

count(

116

count(

117

:joins => "LEFT OUTER JOIN #{quoted_table_name} AS parent ON " +

117

:joins => "LEFT OUTER JOIN #{quoted_table_name} AS parent ON " +

118

"#{quoted_table_name}.#{quoted_parent_column_name} = parent.#{primary_key}",

118

"#{quoted_table_name}.#{quoted_parent_column_name} = parent.#{primary_key}",

119

:conditions =>

119

:conditions =>

120

"#{quoted_table_name}.#{quoted_left_column_name} IS NULL OR " +

120

"#{quoted_table_name}.#{quoted_left_column_name} IS NULL OR " +

121

"#{quoted_table_name}.#{quoted_right_column_name} IS NULL OR " +

121

"#{quoted_table_name}.#{quoted_right_column_name} IS NULL OR " +

122

"#{quoted_table_name}.#{quoted_left_column_name} >= " +

122

"#{quoted_table_name}.#{quoted_left_column_name} >= " +

123

"#{quoted_table_name}.#{quoted_right_column_name} OR " +

123

"#{quoted_table_name}.#{quoted_right_column_name} OR " +

124

"(#{quoted_table_name}.#{quoted_parent_column_name} IS NOT NULL AND " +

124

"(#{quoted_table_name}.#{quoted_parent_column_name} IS NOT NULL AND " +

125

"(#{quoted_table_name}.#{quoted_left_column_name} <= parent.#{quoted_left_column_name} OR " +

125

"(#{quoted_table_name}.#{quoted_left_column_name} <= parent.#{quoted_left_column_name} OR " +

126

"#{quoted_table_name}.#{quoted_right_column_name} >= parent.#{quoted_right_column_name}))"

126

"#{quoted_table_name}.#{quoted_right_column_name} >= parent.#{quoted_right_column_name}))"

127

) == 0

127

) == 0

128

end

128

end

129

130

def no_duplicates_for_columns?

130

def no_duplicates_for_columns?

131

scope_string = Array(acts_as_nested_set_options[:scope]).map do |c|

131

scope_string = Array(acts_as_nested_set_options[:scope]).map do |c|

132

connection.quote_column_name(c)

132

connection.quote_column_name(c)

133

end.push(nil).join(", ")

133

end.push(nil).join(", ")

134

[quoted_left_column_name, quoted_right_column_name].all? do |column|

134

[quoted_left_column_name, quoted_right_column_name].all? do |column|

135

# No duplicates

135

# No duplicates

136

find(:first,

136

find(:first,

137

:select => "#{scope_string}#{column}, COUNT(#{column})",

137

:select => "#{scope_string}#{column}, COUNT(#{column})",

138

:group => "#{scope_string}#{column}

138

:group => "#{scope_string}#{column}

139

HAVING COUNT(#{column}) > 1").nil?

139

HAVING COUNT(#{column}) > 1").nil?

140

end

140

end

141

end

141

end

142

143

# Wrapper for each_root_valid? that can deal with scope.

143

# Wrapper for each_root_valid? that can deal with scope.

144

def all_roots_valid?

144

def all_roots_valid?

145

if acts_as_nested_set_options[:scope]

145

if acts_as_nested_set_options[:scope]

146

roots(:group => scope_column_names).group_by{|record| scope_column_names.collect{|col| record.send(col.to_sym)}}.all? do |scope, grouped_roots|

146

roots(:group => scope_column_names).group_by{|record| scope_column_names.collect{|col| record.send(col.to_sym)}}.all? do |scope, grouped_roots|

147

each_root_valid?(grouped_roots)

147

each_root_valid?(grouped_roots)

148

end

148

end

149

else

149

else

150

each_root_valid?(roots)

150

each_root_valid?(roots)

151

end

151

end

152

end

152

end

153

154

def each_root_valid?(roots_to_validate)

154

def each_root_valid?(roots_to_validate)

155

left = right = 0

155

left = right = 0

156

roots_to_validate.all? do |root|

156

roots_to_validate.all? do |root|

157

returning(root.left > left && root.right > right) do

157

returning(root.left > left && root.right > right) do

158

left = root.left

158

left = root.left

159

right = root.right

159

right = root.right

160

end

160

end

161

end

161

end

162

end

162

end

163

164

# Rebuilds the left & rights if unset or invalid. Also very useful for converting from acts_as_tree.

164

# Rebuilds the left & rights if unset or invalid. Also very useful for converting from acts_as_tree.

165

def rebuild!

165

def rebuild!

166

# Don't rebuild a valid tree.

166

# Don't rebuild a valid tree.

167

return true if valid?

167

return true if valid?

168

169

scope = lambda{}

169

scope = lambda{|node|}

170

if acts_as_nested_set_options[:scope]

170

if acts_as_nested_set_options[:scope]

171

scope = lambda{|node|

171

scope = lambda{|node|

172

scope_column_names.inject(""){|str, column_name|

172

scope_column_names.inject(""){|str, column_name|

173

str << "AND #{connection.quote_column_name(column_name)} = #{connection.quote(node.send(column_name.to_sym))} "

173

str << "AND #{connection.quote_column_name(column_name)} = #{connection.quote(node.send(column_name.to_sym))} "

174

}

174

}

175

}

175

}

176

end

176

end

177

indices = {}

177

indices = {}

178

179

set_left_and_rights = lambda do |node|

179

set_left_and_rights = lambda do |node|

180

# set left

180

# set left

181

node[left_column_name] = indices[scope.call(node)] += 1

181

node[left_column_name] = indices[scope.call(node)] += 1

182

# find

182

# find

183

find(:all, :conditions => ["#{quoted_parent_column_name} = ? #{scope.call(node)}", node], :order => "#{quoted_left_column_name}, #{quoted_right_column_name}, #{acts_as_nested_set_options[:order]}").each{|n| set_left_and_rights.call(n) }

183

find(:all, :conditions => ["#{quoted_parent_column_name} = ? #{scope.call(node)}", node], :order => "#{quoted_left_column_name}, #{quoted_right_column_name}, #{acts_as_nested_set_options[:order]}").each{|n| set_left_and_rights.call(n) }

184

# set right

184

# set right

185

node[right_column_name] = indices[scope.call(node)] += 1

185

node[right_column_name] = indices[scope.call(node)] += 1

186

node.save!

186

node.save!

187

end

187

end

188

189

# Find root node(s)

189

# Find root node(s)

190

root_nodes = find(:all, :conditions => "#{quoted_parent_column_name} IS NULL", :order => "#{quoted_left_column_name}, #{quoted_right_column_name}, #{acts_as_nested_set_options[:order]}").each do |root_node|

190

root_nodes = find(:all, :conditions => "#{quoted_parent_column_name} IS NULL", :order => "#{quoted_left_column_name}, #{quoted_right_column_name}, #{acts_as_nested_set_options[:order]}").each do |root_node|

191

# setup index for this scope

191

# setup index for this scope

192

indices[scope.call(root_node)] ||= 0

192

indices[scope.call(root_node)] ||= 0

193

set_left_and_rights.call(root_node)

193

set_left_and_rights.call(root_node)

194

end

194

end

195

end

195

end

196

end

196

end

197

198

# Mixed into both classes and instances to provide easy access to the column names

198

# Mixed into both classes and instances to provide easy access to the column names

199

module Columns

199

module Columns

200

def left_column_name

200

def left_column_name

201

acts_as_nested_set_options[:left_column]

201

acts_as_nested_set_options[:left_column]

202

end

202

end

203

204

def right_column_name

204

def right_column_name

205

acts_as_nested_set_options[:right_column]

205

acts_as_nested_set_options[:right_column]

206

end

206

end

207

208

def parent_column_name

208

def parent_column_name

209

acts_as_nested_set_options[:parent_column]

209

acts_as_nested_set_options[:parent_column]

210

end

210

end

211

212

def scope_column_names

212

def scope_column_names

213

Array(acts_as_nested_set_options[:scope])

213

Array(acts_as_nested_set_options[:scope])

214

end

214

end

215

216

def quoted_left_column_name

216

def quoted_left_column_name

217

connection.quote_column_name(left_column_name)

217

connection.quote_column_name(left_column_name)

218

end

218

end

219

220

def quoted_right_column_name

220

def quoted_right_column_name

221

connection.quote_column_name(right_column_name)

221

connection.quote_column_name(right_column_name)

222

end

222

end

223

224

def quoted_parent_column_name

224

def quoted_parent_column_name

225

connection.quote_column_name(parent_column_name)

225

connection.quote_column_name(parent_column_name)

226

end

226

end

227

228

def quoted_scope_column_names

228

def quoted_scope_column_names

229

scope_column_names.collect {|column_name| connection.quote_column_name(column_name) }

229

scope_column_names.collect {|column_name| connection.quote_column_name(column_name) }

230

end

230

end

231

end

231

end

232

233

# Any instance method that returns a collection makes use of Rails 2.1's named_scope (which is bundled for Rails 2.0), so it can be treated as a finder.

233

# Any instance method that returns a collection makes use of Rails 2.1's named_scope (which is bundled for Rails 2.0), so it can be treated as a finder.

234

#

234

#

235

# category.self_and_descendants.count

235

# category.self_and_descendants.count

236

# category.ancestors.find(:all, :conditions => "name like '%foo%'")

236

# category.ancestors.find(:all, :conditions => "name like '%foo%'")

237

module InstanceMethods

237

module InstanceMethods

238

# Value of the parent column

238

# Value of the parent column

239

def parent_id

239

def parent_id

240

self[parent_column_name]

240

self[parent_column_name]

241

end

241

end

242

243

# Value of the left column

243

# Value of the left column

244

def left

244

def left

245

self[left_column_name]

245

self[left_column_name]

246

end

246

end

247

248

# Value of the right column

248

# Value of the right column

249

def right

249

def right

250

self[right_column_name]

250

self[right_column_name]

251

end

251

end

252

253

# Returns true if this is a root node.

253

# Returns true if this is a root node.

254

def root?

254

def root?

255

parent_id.nil?

255

parent_id.nil?

256

end

256

end

257

258

def leaf?

258

def leaf?

259

right - left == 1

259

right - left == 1

260

end

260

end

261

262

# Returns true is this is a child node

262

# Returns true is this is a child node

263

def child?

263

def child?

264

!parent_id.nil?

264

!parent_id.nil?

265

end

265

end

266

267

# order by left column

267

# order by left column

268

def <=>(x)

268

def <=>(x)

269

left <=> x.left

269

left <=> x.left

270

end

270

end

271

272

# Redefine to act like active record

272

# Redefine to act like active record

273

def ==(comparison_object)

273

def ==(comparison_object)

274

comparison_object.equal?(self) ||

274

comparison_object.equal?(self) ||

275

(comparison_object.instance_of?(self.class) &&

275

(comparison_object.instance_of?(self.class) &&

276

comparison_object.id == id &&

276

comparison_object.id == id &&

277

!comparison_object.new_record?)

277

!comparison_object.new_record?)

278

end

278

end

279

280

# Returns root

280

# Returns root

281

def root

281

def root

282

self_and_ancestors.find(:first)

282

self_and_ancestors.find(:first)

283

end

283

end

284

285

# Returns the immediate parent

285

# Returns the immediate parent

286

def parent

286

def parent

287

nested_set_scope.find_by_id(parent_id) if parent_id

287

nested_set_scope.find_by_id(parent_id) if parent_id

288

end

288

end

289

290

# Returns the array of all parents and self

290

# Returns the array of all parents and self

291

def self_and_ancestors

291

def self_and_ancestors

292

nested_set_scope.scoped :conditions => [

292

nested_set_scope.scoped :conditions => [

293

"#{self.class.table_name}.#{quoted_left_column_name} <= ? AND #{self.class.table_name}.#{quoted_right_column_name} >= ?", left, right

293

"#{self.class.table_name}.#{quoted_left_column_name} <= ? AND #{self.class.table_name}.#{quoted_right_column_name} >= ?", left, right

294

]

294

]

295

end

295

end

296

297

# Returns an array of all parents

297

# Returns an array of all parents

298

def ancestors

298

def ancestors

299

without_self self_and_ancestors

299

without_self self_and_ancestors

300

end

300

end

301

302

# Returns the array of all children of the parent, including self

302

# Returns the array of all children of the parent, including self

303

def self_and_siblings

303

def self_and_siblings

304

nested_set_scope.scoped :conditions => {parent_column_name => parent_id}

304

nested_set_scope.scoped :conditions => {parent_column_name => parent_id}

305

end

305

end

306

307

# Returns the array of all children of the parent, except self

307

# Returns the array of all children of the parent, except self

308

def siblings

308

def siblings

309

without_self self_and_siblings

309

without_self self_and_siblings

310

end

310

end

311

312

# Returns a set of all of its nested children which do not have children

312

# Returns a set of all of its nested children which do not have children

313

def leaves

313

def leaves

314

descendants.scoped :conditions => "#{self.class.table_name}.#{quoted_right_column_name} - #{self.class.table_name}.#{quoted_left_column_name} = 1"

314

descendants.scoped :conditions => "#{self.class.table_name}.#{quoted_right_column_name} - #{self.class.table_name}.#{quoted_left_column_name} = 1"

315

end

315

end

316

317

# Returns the level of this object in the tree

317

# Returns the level of this object in the tree

318

# root level is 0

318

# root level is 0

319

def level

319

def level

320

parent_id.nil? ? 0 : ancestors.count

320

parent_id.nil? ? 0 : ancestors.count

321

end

321

end

322

323

# Returns a set of itself and all of its nested children

323

# Returns a set of itself and all of its nested children

324

def self_and_descendants

324

def self_and_descendants

325

nested_set_scope.scoped :conditions => [

325

nested_set_scope.scoped :conditions => [

326

"#{self.class.table_name}.#{quoted_left_column_name} >= ? AND #{self.class.table_name}.#{quoted_right_column_name} <= ?", left, right

326

"#{self.class.table_name}.#{quoted_left_column_name} >= ? AND #{self.class.table_name}.#{quoted_right_column_name} <= ?", left, right

327

]

327

]

328

end

328

end

329

330

# Returns a set of all of its children and nested children

330

# Returns a set of all of its children and nested children

331

def descendants

331

def descendants

332

without_self self_and_descendants

332

without_self self_and_descendants

333

end

333

end

334

335

# Returns a set of only this entry's immediate children

335

# Returns a set of only this entry's immediate children

336

def children

336

def children

337

nested_set_scope.scoped :conditions => {parent_column_name => self}

337

nested_set_scope.scoped :conditions => {parent_column_name => self}

338

end

338

end

339

340

def is_descendant_of?(other)

340

def is_descendant_of?(other)

341

other.left < self.left && self.left < other.right && same_scope?(other)

341

other.left < self.left && self.left < other.right && same_scope?(other)

342

end

342

end

343

344

def is_or_is_descendant_of?(other)

344

def is_or_is_descendant_of?(other)

345

other.left <= self.left && self.left < other.right && same_scope?(other)

345

other.left <= self.left && self.left < other.right && same_scope?(other)

346

end

346

end

347

348

def is_ancestor_of?(other)

348

def is_ancestor_of?(other)

349

self.left < other.left && other.left < self.right && same_scope?(other)

349

self.left < other.left && other.left < self.right && same_scope?(other)

350

end

350

end

351

352

def is_or_is_ancestor_of?(other)

352

def is_or_is_ancestor_of?(other)

353

self.left <= other.left && other.left < self.right && same_scope?(other)

353

self.left <= other.left && other.left < self.right && same_scope?(other)

354

end

354

end

355

356

# Check if other model is in the same scope

356

# Check if other model is in the same scope

357

def same_scope?(other)

357

def same_scope?(other)

358

Array(acts_as_nested_set_options[:scope]).all? do |attr|

358

Array(acts_as_nested_set_options[:scope]).all? do |attr|

359

self.send(attr) == other.send(attr)

359

self.send(attr) == other.send(attr)

360

end

360

end

361

end

361

end

362

363

# Find the first sibling to the left

363

# Find the first sibling to the left

364

def left_sibling

364

def left_sibling

365

siblings.find(:first, :conditions => ["#{self.class.table_name}.#{quoted_left_column_name} < ?", left],

365

siblings.find(:first, :conditions => ["#{self.class.table_name}.#{quoted_left_column_name} < ?", left],

366

:order => "#{self.class.table_name}.#{quoted_left_column_name} DESC")

366

:order => "#{self.class.table_name}.#{quoted_left_column_name} DESC")

367

end

367

end

368

369

# Find the first sibling to the right

369

# Find the first sibling to the right

370

def right_sibling

370

def right_sibling

371

siblings.find(:first, :conditions => ["#{self.class.table_name}.#{quoted_left_column_name} > ?", left])

371

siblings.find(:first, :conditions => ["#{self.class.table_name}.#{quoted_left_column_name} > ?", left])

372

end

372

end

373

374

# Shorthand method for finding the left sibling and moving to the left of it.

374

# Shorthand method for finding the left sibling and moving to the left of it.

375

def move_left

375

def move_left

376

move_to_left_of left_sibling

376

move_to_left_of left_sibling

377

end

377

end

378

379

# Shorthand method for finding the right sibling and moving to the right of it.

379

# Shorthand method for finding the right sibling and moving to the right of it.

380

def move_right

380

def move_right

381

move_to_right_of right_sibling

381

move_to_right_of right_sibling

382

end

382

end

383

384

# Move the node to the left of another node (you can pass id only)

384

# Move the node to the left of another node (you can pass id only)

385

def move_to_left_of(node)

385

def move_to_left_of(node)

386

move_to node, :left

386

move_to node, :left

387

end

387

end

388

389

# Move the node to the left of another node (you can pass id only)

389

# Move the node to the left of another node (you can pass id only)

390

def move_to_right_of(node)

390

def move_to_right_of(node)

391

move_to node, :right

391

move_to node, :right

392

end

392

end

393

394

# Move the node to the child of another node (you can pass id only)

394

# Move the node to the child of another node (you can pass id only)

395

def move_to_child_of(node)

395

def move_to_child_of(node)

396

move_to node, :child

396

move_to node, :child

397

end

397

end

398

399

# Move the node to root nodes

399

# Move the node to root nodes

400

def move_to_root

400

def move_to_root

401

move_to nil, :root

401

move_to nil, :root

402

end

402

end

403

404

def move_possible?(target)

404

def move_possible?(target)

405

self != target && # Can't target self

405

self != target && # Can't target self

406

same_scope?(target) && # can't be in different scopes

406

same_scope?(target) && # can't be in different scopes

407

# !(left..right).include?(target.left..target.right) # this needs tested more

407

# !(left..right).include?(target.left..target.right) # this needs tested more

408

# detect impossible move

408

# detect impossible move

409

!((left <= target.left && right >= target.left) or (left <= target.right && right >= target.right))

409

!((left <= target.left && right >= target.left) or (left <= target.right && right >= target.right))

410

end

410

end

411

412

def to_text

412

def to_text

413

self_and_descendants.map do |node|

413

self_and_descendants.map do |node|

414

"#{'*'*(node.level+1)} #{node.id} #{node.to_s} (#{node.parent_id}, #{node.left}, #{node.right})"

414

"#{'*'*(node.level+1)} #{node.id} #{node.to_s} (#{node.parent_id}, #{node.left}, #{node.right})"

415

end.join("\n")

415

end.join("\n")

416

end

416

end

417

418

protected

418

protected

419

420

def without_self(scope)

420

def without_self(scope)

421

scope.scoped :conditions => ["#{self.class.table_name}.#{self.class.primary_key} != ?", self]

421

scope.scoped :conditions => ["#{self.class.table_name}.#{self.class.primary_key} != ?", self]

422

end

422

end

423

424

# All nested set queries should use this nested_set_scope, which performs finds on

424

# All nested set queries should use this nested_set_scope, which performs finds on

425

# the base ActiveRecord class, using the :scope declared in the acts_as_nested_set

425

# the base ActiveRecord class, using the :scope declared in the acts_as_nested_set

426

# declaration.

426

# declaration.

427

def nested_set_scope

427

def nested_set_scope

428

options = {:order => quoted_left_column_name}

428

options = {:order => quoted_left_column_name}

429

scopes = Array(acts_as_nested_set_options[:scope])

429

scopes = Array(acts_as_nested_set_options[:scope])

430

options[:conditions] = scopes.inject({}) do |conditions,attr|

430

options[:conditions] = scopes.inject({}) do |conditions,attr|

431

conditions.merge attr => self[attr]

431

conditions.merge attr => self[attr]

432

end unless scopes.empty?

432

end unless scopes.empty?

433

self.class.base_class.scoped options

433

self.class.base_class.scoped options

434

end

434

end

435

436

# on creation, set automatically lft and rgt to the end of the tree

436

# on creation, set automatically lft and rgt to the end of the tree

437

def set_default_left_and_right

437

def set_default_left_and_right

438

maxright = nested_set_scope.maximum(right_column_name) || 0

438

maxright = nested_set_scope.maximum(right_column_name) || 0

439

# adds the new node to the right of all existing nodes

439

# adds the new node to the right of all existing nodes

440

self[left_column_name] = maxright + 1

440

self[left_column_name] = maxright + 1

441

self[right_column_name] = maxright + 2

441

self[right_column_name] = maxright + 2

442

end

442

end

443

444

# Prunes a branch off of the tree, shifting all of the elements on the right

444

# Prunes a branch off of the tree, shifting all of the elements on the right

445

# back to the left so the counts still work.

445

# back to the left so the counts still work.

446

def prune_from_tree

446

def prune_from_tree

447

return if right.nil? || left.nil?

447

return if right.nil? || left.nil?

448

diff = right - left + 1

448

diff = right - left + 1

449

450

delete_method = acts_as_nested_set_options[:dependent] == :destroy ?

450

delete_method = acts_as_nested_set_options[:dependent] == :destroy ?

451

:destroy_all : :delete_all

451

:destroy_all : :delete_all

452

453

self.class.base_class.transaction do

453

self.class.base_class.transaction do

454

nested_set_scope.send(delete_method,

454

nested_set_scope.send(delete_method,

455

["#{quoted_left_column_name} > ? AND #{quoted_right_column_name} < ?",

455

["#{quoted_left_column_name} > ? AND #{quoted_right_column_name} < ?",

456

left, right]

456

left, right]

457

)

457

)

458

nested_set_scope.update_all(

458

nested_set_scope.update_all(

459

["#{quoted_left_column_name} = (#{quoted_left_column_name} - ?)", diff],

459

["#{quoted_left_column_name} = (#{quoted_left_column_name} - ?)", diff],

460

["#{quoted_left_column_name} >= ?", right]

460

["#{quoted_left_column_name} >= ?", right]

461

)

461

)

462

nested_set_scope.update_all(

462

nested_set_scope.update_all(

463

["#{quoted_right_column_name} = (#{quoted_right_column_name} - ?)", diff],

463

["#{quoted_right_column_name} = (#{quoted_right_column_name} - ?)", diff],

464

["#{quoted_right_column_name} >= ?", right]

464

["#{quoted_right_column_name} >= ?", right]

465

)

465

)

466

end

466

end

467

end

467

end

468

469

# reload left, right, and parent

469

# reload left, right, and parent

470

def reload_nested_set

470

def reload_nested_set

471

reload(:select => "#{quoted_left_column_name}, " +

471

reload(:select => "#{quoted_left_column_name}, " +

472

"#{quoted_right_column_name}, #{quoted_parent_column_name}")

472

"#{quoted_right_column_name}, #{quoted_parent_column_name}")

473

end

473

end

474

475

def move_to(target, position)

475

def move_to(target, position)

476

raise ActiveRecord::ActiveRecordError, "You cannot move a new node" if self.new_record?

476

raise ActiveRecord::ActiveRecordError, "You cannot move a new node" if self.new_record?

477

return if callback(:before_move) == false

477

return if callback(:before_move) == false

478

transaction do

478

transaction do

479

if target.is_a? self.class.base_class

479

if target.is_a? self.class.base_class

480

target.reload_nested_set

480

target.reload_nested_set

481

elsif position != :root

481

elsif position != :root

482

# load object if node is not an object

482

# load object if node is not an object

483

target = nested_set_scope.find(target)

483

target = nested_set_scope.find(target)

484

end

484

end

485

self.reload_nested_set

485

self.reload_nested_set

486

487

unless position == :root || move_possible?(target)

487

unless position == :root || move_possible?(target)

488

raise ActiveRecord::ActiveRecordError, "Impossible move, target node cannot be inside moved tree."

488

raise ActiveRecord::ActiveRecordError, "Impossible move, target node cannot be inside moved tree."

489

end

489

end

490

491

bound = case position

491

bound = case position

492

when :child; target[right_column_name]

492

when :child; target[right_column_name]

493

when :left; target[left_column_name]

493

when :left; target[left_column_name]

494

when :right; target[right_column_name] + 1

494

when :right; target[right_column_name] + 1

495

when :root; 1

495

when :root; 1

496

else raise ActiveRecord::ActiveRecordError, "Position should be :child, :left, :right or :root ('#{position}' received)."

496

else raise ActiveRecord::ActiveRecordError, "Position should be :child, :left, :right or :root ('#{position}' received)."

497

end

497

end

498

499

if bound > self[right_column_name]

499

if bound > self[right_column_name]

500

bound = bound - 1

500

bound = bound - 1

501

other_bound = self[right_column_name] + 1

501

other_bound = self[right_column_name] + 1

502

else

502

else

503

other_bound = self[left_column_name] - 1

503

other_bound = self[left_column_name] - 1

504

end

504

end

505

506

# there would be no change

506

# there would be no change

507

return if bound == self[right_column_name] || bound == self[left_column_name]

507

return if bound == self[right_column_name] || bound == self[left_column_name]

508

509

# we have defined the boundaries of two non-overlapping intervals,

509

# we have defined the boundaries of two non-overlapping intervals,

510

# so sorting puts both the intervals and their boundaries in order

510

# so sorting puts both the intervals and their boundaries in order

511

a, b, c, d = [self[left_column_name], self[right_column_name], bound, other_bound].sort

511

a, b, c, d = [self[left_column_name], self[right_column_name], bound, other_bound].sort

512

513

new_parent = case position

513

new_parent = case position

514

when :child; target.id

514

when :child; target.id

515

when :root; nil

515

when :root; nil

516

else target[parent_column_name]

516

else target[parent_column_name]

517

end

517

end

518

519

self.class.base_class.update_all([

519

self.class.base_class.update_all([

520

"#{quoted_left_column_name} = CASE " +

520

"#{quoted_left_column_name} = CASE " +

521

"WHEN #{quoted_left_column_name} BETWEEN :a AND :b " +

521

"WHEN #{quoted_left_column_name} BETWEEN :a AND :b " +

522

"THEN #{quoted_left_column_name} + :d - :b " +

522

"THEN #{quoted_left_column_name} + :d - :b " +

523

"WHEN #{quoted_left_column_name} BETWEEN :c AND :d " +

523

"WHEN #{quoted_left_column_name} BETWEEN :c AND :d " +

524

"THEN #{quoted_left_column_name} + :a - :c " +

524

"THEN #{quoted_left_column_name} + :a - :c " +

525

"ELSE #{quoted_left_column_name} END, " +

525

"ELSE #{quoted_left_column_name} END, " +

526

"#{quoted_right_column_name} = CASE " +

526

"#{quoted_right_column_name} = CASE " +

527

"WHEN #{quoted_right_column_name} BETWEEN :a AND :b " +

527

"WHEN #{quoted_right_column_name} BETWEEN :a AND :b " +

528

"THEN #{quoted_right_column_name} + :d - :b " +

528

"THEN #{quoted_right_column_name} + :d - :b " +

529

"WHEN #{quoted_right_column_name} BETWEEN :c AND :d " +

529

"WHEN #{quoted_right_column_name} BETWEEN :c AND :d " +

530

"THEN #{quoted_right_column_name} + :a - :c " +

530

"THEN #{quoted_right_column_name} + :a - :c " +

531

"ELSE #{quoted_right_column_name} END, " +

531

"ELSE #{quoted_right_column_name} END, " +

532

"#{quoted_parent_column_name} = CASE " +

532

"#{quoted_parent_column_name} = CASE " +

533

"WHEN #{self.class.base_class.primary_key} = :id THEN :new_parent " +

533

"WHEN #{self.class.base_class.primary_key} = :id THEN :new_parent " +

534

"ELSE #{quoted_parent_column_name} END",

534

"ELSE #{quoted_parent_column_name} END",

535

{:a => a, :b => b, :c => c, :d => d, :id => self.id, :new_parent => new_parent}

535

{:a => a, :b => b, :c => c, :d => d, :id => self.id, :new_parent => new_parent}

536

], nested_set_scope.proxy_options[:conditions])

536

], nested_set_scope.proxy_options[:conditions])

537

end

537

end

538

target.reload_nested_set if target

538

target.reload_nested_set if target

539

self.reload_nested_set

539

self.reload_nested_set

540

callback(:after_move)

540

callback(:after_move)

541

end

541

end

542

543

end

543

end

544

545

end

545

end

546

end

546

end

547

end

547

end

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages

             module CollectiveIdea #:nodoc:
               module Acts #:nodoc:
                 module NestedSet #:nodoc:
                   def self.included(base)
                     base.extend(SingletonMethods)
                   end
                   # This acts provides Nested Set functionality. Nested Set is a smart way to implement
                   # an _ordered_ tree, with the added feature that you can select the children and all of their
                   # descendants with a single query. The drawback is that insertion or move need some complex
                   # sql queries. But everything is done here by this module!
                   #
                   # Nested sets are appropriate each time you want either an orderd tree (menus,
                   # commercial categories) or an efficient way of querying big trees (threaded posts).
                   #
                   # == API
                   #
                   # Methods names are aligned with acts_as_tree as much as possible, to make replacment from one
                   # by another easier, except for the creation:
                   #
                   # in acts_as_tree:
                   #   item.children.create(:name => "child1")
                   #
                   # in acts_as_nested_set:
                   #   # adds a new item at the "end" of the tree, i.e. with child.left = max(tree.right)+1
                   #   child = MyClass.new(:name => "child1")
                   #   child.save
                   #   # now move the item to its right place
                   #   child.move_to_child_of my_item
                   #
                   # You can pass an id or an object to:
                   # * <tt>#move_to_child_of</tt>
                   # * <tt>#move_to_right_of</tt>
                   # * <tt>#move_to_left_of</tt>
                   #
                   module SingletonMethods
                     # Configuration options are:
                     #
                     # * +:parent_column+ - specifies the column name to use for keeping the position integer (default: parent_id)
                     # * +:left_column+ - column name for left boundry data, default "lft"
                     # * +:right_column+ - column name for right boundry data, default "rgt"
                     # * +:scope+ - restricts what is to be considered a list. Given a symbol, it'll attach "_id"
                     #   (if it hasn't been already) and use that as the foreign key restriction. You
                     #   can also pass an array to scope by multiple attributes.
                     #   Example: <tt>acts_as_nested_set :scope => [:notable_id, :notable_type]</tt>
                     # * +:dependent+ - behavior for cascading destroy. If set to :destroy, all the
                     #   child objects are destroyed alongside this object by calling their destroy
                     #   method. If set to :delete_all (default), all the child objects are deleted
                     #   without calling their destroy method.
                     #
                     # See CollectiveIdea::Acts::NestedSet::ClassMethods for a list of class methods and
                     # CollectiveIdea::Acts::NestedSet::InstanceMethods for a list of instance methods added
                     # to acts_as_nested_set models
                     def acts_as_nested_set(options = {})
                       options = {
                         :parent_column => 'parent_id',
                         :left_column => 'lft',
                         :right_column => 'rgt',
                         :order => 'id',
                         :dependent => :delete_all, # or :destroy
                       }.merge(options)
                       if options[:scope].is_a?(Symbol) && options[:scope].to_s !~ /_id$/
                         options[:scope] = "#{options[:scope]}_id".intern
                       end
                       write_inheritable_attribute :acts_as_nested_set_options, options
                       class_inheritable_reader :acts_as_nested_set_options
                       include Comparable
                       include Columns
                       include InstanceMethods
                       extend Columns
                       extend ClassMethods
                       # no bulk assignment
                       attr_protected  left_column_name.intern,
                                       right_column_name.intern,
                                       parent_column_name.intern
                       before_create :set_default_left_and_right
                       before_destroy :prune_from_tree
                       # no assignment to structure fields
                       [left_column_name, right_column_name, parent_column_name].each do |column|
                         module_eval <<-"end_eval", __FILE__, __LINE__
                           def #{column}=(x)
                             raise ActiveRecord::ActiveRecordError, "Unauthorized assignment to #{column}: it's an internal field handled by acts_as_nested_set code, use move_to_* methods instead."
                           end
                         end_eval
                       end
                       named_scope :roots, :conditions => {parent_column_name => nil}, :order => quoted_left_column_name
                       named_scope :leaves, :conditions => "#{quoted_right_column_name} - #{quoted_left_column_name} = 1", :order => quoted_left_column_name
                       if self.respond_to?(:define_callbacks)
                         define_callbacks("before_move", "after_move")
                       end
                     end
                   end
                   module ClassMethods
                     # Returns the first root
                     def root
                       roots.find(:first)
                     end
                     def valid?
                       left_and_rights_valid? && no_duplicates_for_columns? && all_roots_valid?
                     end
                     def left_and_rights_valid?
                       count(
                         :joins => "LEFT OUTER JOIN #{quoted_table_name} AS parent ON " +
                           "#{quoted_table_name}.#{quoted_parent_column_name} = parent.#{primary_key}",
                         :conditions =>
                           "#{quoted_table_name}.#{quoted_left_column_name} IS NULL OR " +
                           "#{quoted_table_name}.#{quoted_right_column_name} IS NULL OR " +
                           "#{quoted_table_name}.#{quoted_left_column_name} >= " +
                             "#{quoted_table_name}.#{quoted_right_column_name} OR " +
                           "(#{quoted_table_name}.#{quoted_parent_column_name} IS NOT NULL AND " +
                             "(#{quoted_table_name}.#{quoted_left_column_name} <= parent.#{quoted_left_column_name} OR " +
                             "#{quoted_table_name}.#{quoted_right_column_name} >= parent.#{quoted_right_column_name}))"
                       ) == 0
                     end
                     def no_duplicates_for_columns?
                       scope_string = Array(acts_as_nested_set_options[:scope]).map do |c|
                         connection.quote_column_name(c)
                       end.push(nil).join(", ")
                       [quoted_left_column_name, quoted_right_column_name].all? do |column|
                         # No duplicates
                         find(:first,
                           :select => "#{scope_string}#{column}, COUNT(#{column})",
                           :group => "#{scope_string}#{column}
                             HAVING COUNT(#{column}) > 1").nil?
                       end
                     end
                     # Wrapper for each_root_valid? that can deal with scope.
                     def all_roots_valid?
                       if acts_as_nested_set_options[:scope]
                         roots(:group => scope_column_names).group_by{|record| scope_column_names.collect{|col| record.send(col.to_sym)}}.all? do |scope, grouped_roots|
                           each_root_valid?(grouped_roots)
                         end
                       else
                         each_root_valid?(roots)
                       end
                     end
                     def each_root_valid?(roots_to_validate)
                       left = right = 0
                       roots_to_validate.all? do |root|
                         returning(root.left > left && root.right > right) do
                           left = root.left
                           right = root.right
                         end
                       end
                     end
                     # Rebuilds the left & rights if unset or invalid.  Also very useful for converting from acts_as_tree.
                     def rebuild!
                       # Don't rebuild a valid tree.
                       return true if valid?
-                      scope = lambda{}
+                      scope = lambda{|node|}
                       if acts_as_nested_set_options[:scope]
                         scope = lambda{|node|
                           scope_column_names.inject(""){|str, column_name|
                             str << "AND #{connection.quote_column_name(column_name)} = #{connection.quote(node.send(column_name.to_sym))} "
                           }
                         }
                       end
                       indices = {}
                       set_left_and_rights = lambda do |node|
                         # set left
                         node[left_column_name] = indices[scope.call(node)] += 1
                         # find
                         find(:all, :conditions => ["#{quoted_parent_column_name} = ? #{scope.call(node)}", node], :order => "#{quoted_left_column_name}, #{quoted_right_column_name}, #{acts_as_nested_set_options[:order]}").each{|n| set_left_and_rights.call(n) }
                         # set right
                         node[right_column_name] = indices[scope.call(node)] += 1
                         node.save!
                       end
                       # Find root node(s)
                       root_nodes = find(:all, :conditions => "#{quoted_parent_column_name} IS NULL", :order => "#{quoted_left_column_name}, #{quoted_right_column_name}, #{acts_as_nested_set_options[:order]}").each do |root_node|
                         # setup index for this scope
                         indices[scope.call(root_node)] ||= 0
                         set_left_and_rights.call(root_node)
                       end
                     end
                   end
                   # Mixed into both classes and instances to provide easy access to the column names
                   module Columns
                     def left_column_name
                       acts_as_nested_set_options[:left_column]
                     end
                     def right_column_name
                       acts_as_nested_set_options[:right_column]
                     end
                     def parent_column_name
                       acts_as_nested_set_options[:parent_column]
                     end
                     def scope_column_names
                       Array(acts_as_nested_set_options[:scope])
                     end
                     def quoted_left_column_name
                       connection.quote_column_name(left_column_name)
                     end
                     def quoted_right_column_name
                       connection.quote_column_name(right_column_name)
                     end
                     def quoted_parent_column_name
                       connection.quote_column_name(parent_column_name)
                     end
                     def quoted_scope_column_names
                       scope_column_names.collect {|column_name| connection.quote_column_name(column_name) }
                     end
                   end
                   # Any instance method that returns a collection makes use of Rails 2.1's named_scope (which is bundled for Rails 2.0), so it can be treated as a finder.
                   #
                   #   category.self_and_descendants.count
                   #   category.ancestors.find(:all, :conditions => "name like '%foo%'")
                   module InstanceMethods
                     # Value of the parent column
                     def parent_id
                       self[parent_column_name]
                     end
                     # Value of the left column
                     def left
                       self[left_column_name]
                     end
                     # Value of the right column
                     def right
                       self[right_column_name]
                     end
                     # Returns true if this is a root node.
                     def root?
                       parent_id.nil?
                     end
                     def leaf?
                       right - left == 1
                     end
                     # Returns true is this is a child node
                     def child?
                       !parent_id.nil?
                     end
                     # order by left column
                     def <=>(x)
                       left <=> x.left
                     end
                     # Redefine to act like active record
                     def ==(comparison_object)
                       comparison_object.equal?(self) ||
                         (comparison_object.instance_of?(self.class) &&
                           comparison_object.id == id &&
                           !comparison_object.new_record?)
                     end
                     # Returns root
                     def root
                       self_and_ancestors.find(:first)
                     end
                     # Returns the immediate parent
                     def parent
                       nested_set_scope.find_by_id(parent_id) if parent_id
                     end
                     # Returns the array of all parents and self
                     def self_and_ancestors
                       nested_set_scope.scoped :conditions => [
                         "#{self.class.table_name}.#{quoted_left_column_name} <= ? AND #{self.class.table_name}.#{quoted_right_column_name} >= ?", left, right
                       ]
                     end
                     # Returns an array of all parents
                     def ancestors
                       without_self self_and_ancestors
                     end
                     # Returns the array of all children of the parent, including self
                     def self_and_siblings
                       nested_set_scope.scoped :conditions => {parent_column_name => parent_id}
                     end
                     # Returns the array of all children of the parent, except self
                     def siblings
                       without_self self_and_siblings
                     end
                     # Returns a set of all of its nested children which do not have children
                     def leaves
                       descendants.scoped :conditions => "#{self.class.table_name}.#{quoted_right_column_name} - #{self.class.table_name}.#{quoted_left_column_name} = 1"
                     end
                     # Returns the level of this object in the tree
                     # root level is 0
                     def level
                       parent_id.nil? ? 0 : ancestors.count
                     end
                     # Returns a set of itself and all of its nested children
                     def self_and_descendants
                       nested_set_scope.scoped :conditions => [
                         "#{self.class.table_name}.#{quoted_left_column_name} >= ? AND #{self.class.table_name}.#{quoted_right_column_name} <= ?", left, right
                       ]
                     end
                     # Returns a set of all of its children and nested children
                     def descendants
                       without_self self_and_descendants
                     end
                     # Returns a set of only this entry's immediate children
                     def children
                       nested_set_scope.scoped :conditions => {parent_column_name => self}
                     end
                     def is_descendant_of?(other)
                       other.left < self.left && self.left < other.right && same_scope?(other)
                     end
                     def is_or_is_descendant_of?(other)
                       other.left <= self.left && self.left < other.right && same_scope?(other)
                     end
                     def is_ancestor_of?(other)
                       self.left < other.left && other.left < self.right && same_scope?(other)
                     end
                     def is_or_is_ancestor_of?(other)
                       self.left <= other.left && other.left < self.right && same_scope?(other)
                     end
                     # Check if other model is in the same scope
                     def same_scope?(other)
                       Array(acts_as_nested_set_options[:scope]).all? do |attr|
                         self.send(attr) == other.send(attr)
                       end
                     end
                     # Find the first sibling to the left
                     def left_sibling
                       siblings.find(:first, :conditions => ["#{self.class.table_name}.#{quoted_left_column_name} < ?", left],
                         :order => "#{self.class.table_name}.#{quoted_left_column_name} DESC")
                     end
                     # Find the first sibling to the right
                     def right_sibling
                       siblings.find(:first, :conditions => ["#{self.class.table_name}.#{quoted_left_column_name} > ?", left])
                     end
                     # Shorthand method for finding the left sibling and moving to the left of it.
                     def move_left
                       move_to_left_of left_sibling
                     end
                     # Shorthand method for finding the right sibling and moving to the right of it.
                     def move_right
                       move_to_right_of right_sibling
                     end
                     # Move the node to the left of another node (you can pass id only)
                     def move_to_left_of(node)
                       move_to node, :left
                     end
                     # Move the node to the left of another node (you can pass id only)
                     def move_to_right_of(node)
                       move_to node, :right
                     end
                     # Move the node to the child of another node (you can pass id only)
                     def move_to_child_of(node)
                       move_to node, :child
                     end
                     # Move the node to root nodes
                     def move_to_root
                       move_to nil, :root
                     end
                     def move_possible?(target)
                       self != target && # Can't target self
                       same_scope?(target) && # can't be in different scopes
                       # !(left..right).include?(target.left..target.right) # this needs tested more
                       # detect impossible move
                       !((left <= target.left && right >= target.left) or (left <= target.right && right >= target.right))
                     end
                     def to_text
                       self_and_descendants.map do |node|
                         "#{'*'*(node.level+1)} #{node.id} #{node.to_s} (#{node.parent_id}, #{node.left}, #{node.right})"
                       end.join("\n")
                     end
                   protected
                     def without_self(scope)
                       scope.scoped :conditions => ["#{self.class.table_name}.#{self.class.primary_key} != ?", self]
                     end
                     # All nested set queries should use this nested_set_scope, which performs finds on
                     # the base ActiveRecord class, using the :scope declared in the acts_as_nested_set
                     # declaration.
                     def nested_set_scope
                       options = {:order => quoted_left_column_name}
                       scopes = Array(acts_as_nested_set_options[:scope])
                       options[:conditions] = scopes.inject({}) do |conditions,attr|
                         conditions.merge attr => self[attr]
                       end unless scopes.empty?
                       self.class.base_class.scoped options
                     end
                     # on creation, set automatically lft and rgt to the end of the tree
                     def set_default_left_and_right
                       maxright = nested_set_scope.maximum(right_column_name) || 0
                       # adds the new node to the right of all existing nodes
                       self[left_column_name] = maxright + 1
                       self[right_column_name] = maxright + 2
                     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_from_tree
                       return if right.nil? || left.nil?
                       diff = right - left + 1
                       delete_method = acts_as_nested_set_options[:dependent] == :destroy ?
                         :destroy_all : :delete_all
                       self.class.base_class.transaction do
                         nested_set_scope.send(delete_method,
                           ["#{quoted_left_column_name} > ? AND #{quoted_right_column_name} < ?",
                             left, right]
                         )
                         nested_set_scope.update_all(
                           ["#{quoted_left_column_name} = (#{quoted_left_column_name} - ?)", diff],
                           ["#{quoted_left_column_name} >= ?", right]
                         )
                         nested_set_scope.update_all(
                           ["#{quoted_right_column_name} = (#{quoted_right_column_name} - ?)", diff],
                           ["#{quoted_right_column_name} >= ?", right]
                         )
                       end
                     end
                     # reload left, right, and parent
                     def reload_nested_set
                       reload(:select => "#{quoted_left_column_name}, " +
                         "#{quoted_right_column_name}, #{quoted_parent_column_name}")
                     end
                     def move_to(target, position)
                       raise ActiveRecord::ActiveRecordError, "You cannot move a new node" if self.new_record?
                       return if callback(:before_move) == false
                       transaction do
                         if target.is_a? self.class.base_class
                           target.reload_nested_set
                         elsif position != :root
                           # load object if node is not an object
                           target = nested_set_scope.find(target)
                         end
                         self.reload_nested_set
                         unless position == :root || move_possible?(target)
                           raise ActiveRecord::ActiveRecordError, "Impossible move, target node cannot be inside moved tree."
                         end
                         bound = case position
                           when :child;  target[right_column_name]
                           when :left;   target[left_column_name]
                           when :right;  target[right_column_name] + 1
                           when :root;   1
                           else raise ActiveRecord::ActiveRecordError, "Position should be :child, :left, :right or :root ('#{position}' received)."
                         end
                         if bound > self[right_column_name]
                           bound = bound - 1
                           other_bound = self[right_column_name] + 1
                         else
                           other_bound = self[left_column_name] - 1
                         end
                         # there would be no change
                         return if bound == self[right_column_name] || bound == self[left_column_name]
                         # 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 = [self[left_column_name], self[right_column_name], bound, other_bound].sort
                         new_parent = case position
                           when :child;  target.id
                           when :root;   nil
                           else          target[parent_column_name]
                         end
                         self.class.base_class.update_all([
                           "#{quoted_left_column_name} = CASE " +
                             "WHEN #{quoted_left_column_name} BETWEEN :a AND :b " +
                               "THEN #{quoted_left_column_name} + :d - :b " +
                             "WHEN #{quoted_left_column_name} BETWEEN :c AND :d " +
                               "THEN #{quoted_left_column_name} + :a - :c " +
                             "ELSE #{quoted_left_column_name} END, " +
                           "#{quoted_right_column_name} = CASE " +
                             "WHEN #{quoted_right_column_name} BETWEEN :a AND :b " +
                               "THEN #{quoted_right_column_name} + :d - :b " +
                             "WHEN #{quoted_right_column_name} BETWEEN :c AND :d " +
                               "THEN #{quoted_right_column_name} + :a - :c " +
                             "ELSE #{quoted_right_column_name} END, " +
                           "#{quoted_parent_column_name} = CASE " +
                             "WHEN #{self.class.base_class.primary_key} = :id THEN :new_parent " +
                             "ELSE #{quoted_parent_column_name} END",
                           {:a => a, :b => b, :c => c, :d => d, :id => self.id, :new_parent => new_parent}
                         ], nested_set_scope.proxy_options[:conditions])
                       end
                       target.reload_nested_set if target
                       self.reload_nested_set
                       callback(:after_move)
                     end
                   end
                 end
               end
             end