jro_apps/redmine Commit - r12407:94e3eb2b8b2d

move awesome_nested_set leaf? modification to config/initializers/10-patches.rb...

Toshi MARUYAMA -

r12407:94e3eb2b8b2d

parent child

Context file:

r12407:94e3eb2b8b2d

Collapse all files

config/initializers/10-patches.rb +13 0

             require 'active_record'
             module ActiveRecord
               class Base
                 include Redmine::I18n
                 # Translate attribute names for validation errors display
                 def self.human_attribute_name(attr, *args)
                   attr = attr.to_s.sub(/_id$/, '')
                   l("field_#{name.underscore.gsub('/', '_')}_#{attr}", :default => ["field_#{attr}".to_sym, attr])
                 end
               end
               # Undefines private Kernel#open method to allow using `open` scopes in models.
               # See Defect #11545 (http://www.redmine.org/issues/11545) for details.
               class Base
                 class << self
                   undef open
                 end
               end
               class Relation ; undef open ; end
             end
             module ActionView
               module Helpers
                 module DateHelper
                   # distance_of_time_in_words breaks when difference is greater than 30 years
                   def distance_of_date_in_words(from_date, to_date = 0, options = {})
                     from_date = from_date.to_date if from_date.respond_to?(:to_date)
                     to_date = to_date.to_date if to_date.respond_to?(:to_date)
                     distance_in_days = (to_date - from_date).abs
                     I18n.with_options :locale => options[:locale], :scope => :'datetime.distance_in_words' do |locale|
                       case distance_in_days
                         when 0..60     then locale.t :x_days,             :count => distance_in_days.round
                         when 61..720   then locale.t :about_x_months,     :count => (distance_in_days / 30).round
                         else                locale.t :over_x_years,       :count => (distance_in_days / 365).floor
                       end
                     end
                   end
                 end
               end
               class Resolver
                 def find_all(name, prefix=nil, partial=false, details={}, key=nil, locals=[])
                   cached(key, [name, prefix, partial], details, locals) do
                     if details[:formats] & [:xml, :json]
                       details = details.dup
                       details[:formats] = details[:formats].dup + [:api]
                     end
                     find_templates(name, prefix, partial, details)
                   end
                 end
               end
             end
             # Do not HTML escape text templates
             module ActionView
               class Template
                 module Handlers
                   class ERB
                     def call(template)
                       if template.source.encoding_aware?
                         # First, convert to BINARY, so in case the encoding is
                         # wrong, we can still find an encoding tag
                         # (<%# encoding %>) inside the String using a regular
                         # expression
                         template_source = template.source.dup.force_encoding("BINARY")
                         erb = template_source.gsub(ENCODING_TAG, '')
                         encoding = $2
                         erb.force_encoding valid_encoding(template.source.dup, encoding)
                         # Always make sure we return a String in the default_internal
                         erb.encode!
                       else
                         erb = template.source.dup
                       end
                       self.class.erb_implementation.new(
                         erb,
                         :trim => (self.class.erb_trim_mode == "-"),
                         :escape => template.identifier =~ /\.text/ # only escape HTML templates
                       ).src
                     end
                   end
                 end
               end
             end
             ActionView::Base.field_error_proc = Proc.new{ |html_tag, instance| html_tag || ''.html_safe }
             # HTML5: <option value=""></option> is invalid, use <option value="">&nbsp;</option> instead
             module ActionView
               module Helpers
                 class InstanceTag
                   private
                   def add_options_with_non_empty_blank_option(option_tags, options, value = nil)
                     if options[:include_blank] == true
                       options = options.dup
                       options[:include_blank] = '&nbsp;'.html_safe
                     end
                     add_options_without_non_empty_blank_option(option_tags, options, value)
                   end
                   alias_method_chain :add_options, :non_empty_blank_option
                 end
                 module FormTagHelper
                   def select_tag_with_non_empty_blank_option(name, option_tags = nil, options = {})
                     if options.delete(:include_blank)
                       options[:prompt] = '&nbsp;'.html_safe
                     end
                     select_tag_without_non_empty_blank_option(name, option_tags, options)
                   end
                   alias_method_chain :select_tag, :non_empty_blank_option
                 end
                 module FormOptionsHelper
                   def options_for_select_with_non_empty_blank_option(container, selected = nil)
                     if container.is_a?(Array)
                       container = container.map {|element| element.blank? ? ["&nbsp;".html_safe, ""] : element}
                     end
                     options_for_select_without_non_empty_blank_option(container, selected)
                   end
                   alias_method_chain :options_for_select, :non_empty_blank_option
                 end
               end
             end
             require 'mail'
             module DeliveryMethods
               class AsyncSMTP < ::Mail::SMTP
                 def deliver!(*args)
                   Thread.start do
                     super *args
                   end
                 end
               end
               class AsyncSendmail < ::Mail::Sendmail
                 def deliver!(*args)
                   Thread.start do
                     super *args
                   end
                 end
               end
               class TmpFile
                 def initialize(*args); end
                 def deliver!(mail)
                   dest_dir = File.join(Rails.root, 'tmp', 'emails')
                   Dir.mkdir(dest_dir) unless File.directory?(dest_dir)
                   File.open(File.join(dest_dir, mail.message_id.gsub(/[<>]/, '') + '.eml'), 'wb') {|f| f.write(mail.encoded) }
                 end
               end
             end
             ActionMailer::Base.add_delivery_method :async_smtp, DeliveryMethods::AsyncSMTP
             ActionMailer::Base.add_delivery_method :async_sendmail, DeliveryMethods::AsyncSendmail
             ActionMailer::Base.add_delivery_method :tmp_file, DeliveryMethods::TmpFile
             # Changes how sent emails are logged
             # Rails doesn't log cc and bcc which is misleading when using bcc only (#12090)
             module ActionMailer
               class LogSubscriber < ActiveSupport::LogSubscriber
                 def deliver(event)
                   recipients = [:to, :cc, :bcc].inject("") do |s, header|
                     r = Array.wrap(event.payload[header])
                     if r.any?
                       s << "\n  #{header}: #{r.join(', ')}"
                     end
                     s
                   end
                   info("\nSent email \"#{event.payload[:subject]}\" (%1.fms)#{recipients}" % event.duration)
                   debug(event.payload[:mail])
                 end
               end
             end
             module ActionController
               module MimeResponds
                 class Collector
                   def api(&block)
                     any(:xml, :json, &block)
                   end
                 end
               end
             end
             module ActionController
               class Base
                 # Displays an explicit message instead of a NoMethodError exception
                 # when trying to start Redmine with an old session_store.rb
                 # TODO: remove it in a later version
                 def self.session=(*args)
                   $stderr.puts "Please remove config/initializers/session_store.rb and run `rake generate_secret_token`.\n" +
                     "Setting the session secret with ActionController.session= is no longer supported in Rails 3."
                   exit 1
                 end
               end
             end
+            module CollectiveIdea
+              module Acts
+                module NestedSet
+                  module Model
+                    def leaf_with_new_record?
+                      new_record? || leaf_without_new_record?
+                    end
+                    alias_method_chain :leaf?, :new_record
+                  end
+                end
+              end
+            end

lib/plugins/awesome_nested_set/lib/awesome_nested_set/awesome_nested_set.rb +1 -1

             module CollectiveIdea #:nodoc:
               module Acts #:nodoc:
                 module NestedSet #:nodoc:
                   # 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.
                   #
                   #   item.children.create(:name => "child1")
                   #
                   # 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"
                   # * +:depth_column+ - column name for the depth data, default "depth"
                   # * +: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.
                   # * +:counter_cache+ adds a counter cache for the number of children.
                   #   defaults to false.
                   #   Example: <tt>acts_as_nested_set :counter_cache => :children_count</tt>
                   # * +:order_column+ on which column to do sorting, by default it is the left_column_name
                   #   Example: <tt>acts_as_nested_set :order_column => :position</tt>
                   #
                   # See CollectiveIdea::Acts::NestedSet::Model::ClassMethods for a list of class methods and
                   # CollectiveIdea::Acts::NestedSet::Model 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',
                       :depth_column => 'depth',
                       :dependent => :delete_all, # or :destroy
                       :polymorphic => false,
                       :counter_cache => false
                     }.merge(options)
                     if options[:scope].is_a?(Symbol) && options[:scope].to_s !~ /_id$/
                       options[:scope] = "#{options[:scope]}_id".intern
                     end
                     class_attribute :acts_as_nested_set_options
                     self.acts_as_nested_set_options = options
                     include CollectiveIdea::Acts::NestedSet::Model
                     include Columns
                     extend Columns
                     belongs_to :parent, :class_name => self.base_class.to_s,
                                         :foreign_key => parent_column_name,
                                         :counter_cache => options[:counter_cache],
                                         :inverse_of => (:children unless options[:polymorphic]),
                                         :polymorphic => options[:polymorphic]
                     has_many_children_options = {
                       :class_name => self.base_class.to_s,
                       :foreign_key => parent_column_name,
                       :order => order_column,
                       :inverse_of => (:parent unless options[:polymorphic]),
                     }
                     # Add callbacks, if they were supplied.. otherwise, we don't want them.
                     [:before_add, :after_add, :before_remove, :after_remove].each do |ar_callback|
                       has_many_children_options.update(ar_callback => options[ar_callback]) if options[ar_callback]
                     end
                     has_many :children, has_many_children_options
                     attr_accessor :skip_before_destroy
                     before_create  :set_default_left_and_right
                     before_save    :store_new_parent
                     after_save     :move_to_new_parent, :set_depth!
                     before_destroy :destroy_descendants
                     # no assignment to structure fields
                     [left_column_name, right_column_name, depth_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
                     define_model_callbacks :move
                   end
                   module Model
                     extend ActiveSupport::Concern
                     included do
                       delegate :quoted_table_name, :to => self
                     end
                     module ClassMethods
                       # Returns the first root
                       def root
                         roots.first
                       end
                       def roots
                         where(parent_column_name => nil).order(quoted_left_column_full_name)
                       end
                       def leaves
                         where("#{quoted_right_column_full_name} - #{quoted_left_column_full_name} = 1").order(quoted_left_column_full_name)
                       end
                       def valid?
                         left_and_rights_valid? && no_duplicates_for_columns? && all_roots_valid?
                       end
                       def left_and_rights_valid?
                         ## AS clause not supported in Oracle in FROM clause for aliasing table name
                         joins("LEFT OUTER JOIN #{quoted_table_name}" +
                             (connection.adapter_name.match(/Oracle/).nil? ?  " AS " : " ") +
                             "parent ON " +
                             "#{quoted_parent_column_full_name} = parent.#{primary_key}").
                         where(
                             "#{quoted_left_column_full_name} IS NULL OR " +
                             "#{quoted_right_column_full_name} IS NULL OR " +
                             "#{quoted_left_column_full_name} >= " +
                               "#{quoted_right_column_full_name} OR " +
                             "(#{quoted_parent_column_full_name} IS NOT NULL AND " +
                               "(#{quoted_left_column_full_name} <= parent.#{quoted_left_column_name} OR " +
                               "#{quoted_right_column_full_name} >= parent.#{quoted_right_column_name}))"
                         ).count == 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_full_name, quoted_right_column_full_name].all? do |column|
                           # No duplicates
                           select("#{scope_string}#{column}, COUNT(#{column})").
                               group("#{scope_string}#{column}").
                               having("COUNT(#{column}) > 1").
                               first.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_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|
                           (root.left > left && root.right > right).tap 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!(validate_nodes = true)
                         # Don't rebuild a valid tree.
                         return true if valid?
                         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
                           where(["#{quoted_parent_column_name} = ? #{scope.call(node)}", node]).
                             order(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!(:validate => validate_nodes)
                         end
                         # Find root node(s)
                         root_nodes = where("#{quoted_parent_column_name} IS NULL").
                           order(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
                       # Iterates over tree elements and determines the current level in the tree.
                       # Only accepts default ordering, odering by an other column than lft
                       # does not work. This method is much more efficent than calling level
                       # because it doesn't require any additional database queries.
                       #
                       # Example:
                       #    Category.each_with_level(Category.root.self_and_descendants) do |o, level|
                       #
                       def each_with_level(objects)
                         path = [nil]
                         objects.each do |o|
                           if o.parent_id != path.last
                             # we are on a new level, did we descend or ascend?
                             if path.include?(o.parent_id)
                               # remove wrong wrong tailing paths elements
                               path.pop while path.last != o.parent_id
                             else
                               path << o.parent_id
                             end
                           end
                           yield(o, path.length - 1)
                         end
                       end
                       # Same as each_with_level - Accepts a string as a second argument to sort the list
                       # Example:
                       #    Category.each_with_level(Category.root.self_and_descendants, :sort_by_this_column) do |o, level|
                       def sorted_each_with_level(objects, order)
                         path = [nil]
                         children = []
                           objects.each do |o|
                           children << o if o.leaf?
                           if o.parent_id != path.last
                             if !children.empty? && !o.leaf?
                               children.sort_by! &order
                               children.each { |c| yield(c, path.length-1) }
                               children = []
                             end
                             # we are on a new level, did we decent or ascent?
                             if path.include?(o.parent_id)
                               # remove wrong wrong tailing paths elements
                               path.pop while path.last != o.parent_id
                             else
                               path << o.parent_id
                             end
                           end
                           yield(o,path.length-1) if !o.leaf?
                         end
                         if !children.empty?
                           children.sort_by! &order
                           children.each { |c| yield(c, path.length-1) }
                         end
                       end
                       def associate_parents(objects)
                         if objects.all?{|o| o.respond_to?(:association)}
                           id_indexed = objects.index_by(&:id)
                           objects.each do |object|
                             if !(association = object.association(:parent)).loaded? && (parent = id_indexed[object.parent_id])
                               association.target = parent
                               association.set_inverse_instance(parent)
                             end
                           end
                         else
                           objects
                         end
                       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%'")
                     # 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
                     # Returns true if this is the end of a branch.
                     def leaf?
-                      new_record? || (persisted? && right.to_i - left.to_i == 1)
+                      persisted? && right.to_i - left.to_i == 1
                     end
                     # Returns true is this is a child node
                     def child?
                       !root?
                     end
                     # Returns root
                     def root
                       if persisted?
                         self_and_ancestors.where(parent_column_name => nil).first
                       else
                         if parent_id && current_parent = nested_set_scope.find(parent_id)
                           current_parent.root
                         else
                           self
                         end
                       end
                     end
                     # Returns the array of all parents and self
                     def self_and_ancestors
                       nested_set_scope.where([
                         "#{quoted_left_column_full_name} <= ? AND #{quoted_right_column_full_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.where(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.where("#{quoted_right_column_full_name} - #{quoted_left_column_full_name} = 1")
                     end
                     # Returns the level of this object in the tree
                     # root level is 0
                     def level
                       parent_id.nil? ? 0 : compute_level
                     end
                     # Returns a set of itself and all of its nested children
                     def self_and_descendants
                       nested_set_scope.where([
                         "#{quoted_left_column_full_name} >= ? AND #{quoted_left_column_full_name} < ?", left, right
                         # using _left_ for both sides here lets us benefit from an index on that column if one exists
                       ])
                     end
                     # Returns a set of all of its children and nested children
                     def descendants
                       without_self self_and_descendants
                     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.where(["#{quoted_left_column_full_name} < ?", left]).
                               order("#{quoted_left_column_full_name} DESC").last
                     end
                     # Find the first sibling to the right
                     def right_sibling
                       siblings.where(["#{quoted_left_column_full_name} > ?", left]).first
                     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 the child of another node with specify index (you can pass id only)
                     def move_to_child_with_index(node, index)
                       if node.children.empty?
                         move_to_child_of(node)
                       elsif node.children.count == index
                         move_to_right_of(node.children.last)
                       else
                         move_to_left_of(node.children[index])
                       end
                     end
                     # Move the node to root nodes
                     def move_to_root
                       move_to nil, :root
                     end
                     # Order children in a nested set by an attribute
                     # Can order by any attribute class that uses the Comparable mixin, for example a string or integer
                     # Usage example when sorting categories alphabetically: @new_category.move_to_ordered_child_of(@root, "name")
                     def move_to_ordered_child_of(parent, order_attribute, ascending = true)
                       self.move_to_root and return unless parent
                       left = nil # This is needed, at least for the tests.
                       parent.children.each do |n| # Find the node immediately to the left of this node.
                         if ascending
                           left = n if n.send(order_attribute) < self.send(order_attribute)
                         else
                           left = n if n.send(order_attribute) > self.send(order_attribute)
                         end
                       end
                       self.move_to_child_of(parent)
                       return unless parent.children.count > 1 # Only need to order if there are multiple children.
                       if left # Self has a left neighbor.
                         self.move_to_right_of(left)
                       else # Self is the left most node.
                         self.move_to_left_of(parent.children[0])
                       end
                     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 compute_level
                       node, nesting = self, 0
                       while (association = node.association(:parent)).loaded? && association.target
                         nesting += 1
                         node = node.parent
                       end if node.respond_to? :association
                       node == self ? ancestors.count : node.level + nesting
                     end
                     def without_self(scope)
                       scope.where(["#{self.class.quoted_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 = {})
                       options = {:order => quoted_left_column_full_name}.merge(options)
                       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.unscoped.scoped options
                     end
                     def store_new_parent
                       @move_to_new_parent_id = send("#{parent_column_name}_changed?") ? parent_id : false
                       true # force callback to return true
                     end
                     def move_to_new_parent
                       if @move_to_new_parent_id.nil?
                         move_to_root
                       elsif @move_to_new_parent_id
                         move_to_child_of(@move_to_new_parent_id)
                       end
                     end
                     def set_depth!
                       if nested_set_scope.column_names.map(&:to_s).include?(depth_column_name.to_s)
                         in_tenacious_transaction do
                           reload
                           nested_set_scope.where(:id => id).update_all(["#{quoted_depth_column_name} = ?", level])
                         end
                         self[depth_column_name.to_sym] = self.level
                       end
                     end
                     # on creation, set automatically lft and rgt to the end of the tree
                     def set_default_left_and_right
                       highest_right_row = nested_set_scope(:order => "#{quoted_right_column_full_name} desc").limit(1).lock(true).first
                       maxright = highest_right_row ? (highest_right_row[right_column_name] || 0) : 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
                     def in_tenacious_transaction(&block)
                       retry_count = 0
                       begin
                         transaction(&block)
                       rescue ActiveRecord::StatementInvalid => error
                         raise unless connection.open_transactions.zero?
                         raise unless error.message =~ /Deadlock found when trying to get lock|Lock wait timeout exceeded/
                         raise unless retry_count < 10
                         retry_count += 1
                         logger.info "Deadlock detected on retry #{retry_count}, restarting transaction"
                         sleep(rand(retry_count)*0.1) # Aloha protocol
                         retry
                       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 destroy_descendants
                       return if right.nil? || left.nil? || skip_before_destroy
                       in_tenacious_transaction do
                         reload_nested_set
                         # select the rows in the model that extend past the deletion point and apply a lock
                         nested_set_scope.where(["#{quoted_left_column_full_name} >= ?", left]).
                                               select(id).lock(true)
                         if acts_as_nested_set_options[:dependent] == :destroy
                           descendants.each do |model|
                             model.skip_before_destroy = true
                             model.destroy
                           end
                         else
                           nested_set_scope.where(["#{quoted_left_column_name} > ? AND #{quoted_right_column_name} < ?", left, right]).
                                            delete_all
                         end
                         # update lefts and rights for remaining nodes
                         diff = right - left + 1
                         nested_set_scope.where(["#{quoted_left_column_full_name} > ?", right]).update_all(
                           ["#{quoted_left_column_name} = (#{quoted_left_column_name} - ?)", diff]
                         )
                         nested_set_scope.where(["#{quoted_right_column_full_name} > ?", right]).update_all(
                           ["#{quoted_right_column_name} = (#{quoted_right_column_name} - ?)", diff]
                         )
                         reload
                         # Don't allow multiple calls to destroy to corrupt the set
                         self.skip_before_destroy = true
                       end
                     end
                     # reload left, right, and parent
                     def reload_nested_set
                       reload(
                         :select => "#{quoted_left_column_full_name}, #{quoted_right_column_full_name}, #{quoted_parent_column_full_name}",
                         :lock => true
                       )
                     end
                     def move_to(target, position)
                       raise ActiveRecord::ActiveRecordError, "You cannot move a new node" if self.new_record?
                       run_callbacks :move do
                         in_tenacious_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
                           # select the rows in the model between a and d, and apply a lock
                           self.class.base_class.select('id').lock(true).where(
                             ["#{quoted_left_column_full_name} >= :a and #{quoted_right_column_full_name} <= :d", {:a => a, :d => d}]
                           )
                           new_parent = case position
                             when :child;  target.id
                             when :root;   nil
                             else          target[parent_column_name]
                           end
                           self.nested_set_scope.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}
                           ])
                         end
                         target.reload_nested_set if target
                         self.set_depth!
                         self.descendants.each(&:save)
                         self.reload_nested_set
                       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 depth_column_name
                       acts_as_nested_set_options[:depth_column]
                     end
                     def parent_column_name
                       acts_as_nested_set_options[:parent_column]
                     end
                     def order_column
                       acts_as_nested_set_options[:order_column] || left_column_name
                     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_depth_column_name
                       connection.quote_column_name(depth_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
                     def quoted_left_column_full_name
                       "#{quoted_table_name}.#{quoted_left_column_name}"
                     end
                     def quoted_right_column_full_name
                       "#{quoted_table_name}.#{quoted_right_column_name}"
                     end
                     def quoted_parent_column_full_name
                       "#{quoted_table_name}.#{quoted_parent_column_name}"
                     end
                   end
                 end
               end
             end

test/unit/issue_nested_set_test.rb +5 0

             # Redmine - project management software
             # Copyright (C) 2006-2013  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             class IssueNestedSetTest < ActiveSupport::TestCase
               fixtures :projects, :users, :roles,
                        :trackers, :projects_trackers,
                        :issue_statuses, :issue_categories, :issue_relations,
                        :enumerations,
                        :issues
+              def test_new_record_is_leaf
+                i = Issue.new
+                assert i.leaf?
+              end
               def test_create_root_issue
                 issue1 = Issue.generate!
                 issue2 = Issue.generate!
                 issue1.reload
                 issue2.reload
                 assert_equal [issue1.id, nil, 1, 2], [issue1.root_id, issue1.parent_id, issue1.lft, issue1.rgt]
                 assert_equal [issue2.id, nil, 1, 2], [issue2.root_id, issue2.parent_id, issue2.lft, issue2.rgt]
               end
               def test_create_child_issue
                 parent = Issue.generate!
                 child =  Issue.generate!(:parent_issue_id => parent.id)
                 parent.reload
                 child.reload
                 assert_equal [parent.id, nil, 1, 4], [parent.root_id, parent.parent_id, parent.lft, parent.rgt]
                 assert_equal [parent.id, parent.id, 2, 3], [child.root_id, child.parent_id, child.lft, child.rgt]
               end
               def test_creating_a_child_in_a_subproject_should_validate
                 issue = Issue.generate!
                 child = Issue.new(:project_id => 3, :tracker_id => 2, :author_id => 1,
                                   :subject => 'child', :parent_issue_id => issue.id)
                 assert_save child
                 assert_equal issue, child.reload.parent
               end
               def test_creating_a_child_in_an_invalid_project_should_not_validate
                 issue = Issue.generate!
                 child = Issue.new(:project_id => 2, :tracker_id => 1, :author_id => 1,
                                   :subject => 'child', :parent_issue_id => issue.id)
                 assert !child.save
                 assert_not_equal [], child.errors[:parent_issue_id]
               end
               def test_move_a_root_to_child
                 parent1 = Issue.generate!
                 parent2 = Issue.generate!
                 child = Issue.generate!(:parent_issue_id => parent1.id)
                 parent2.parent_issue_id = parent1.id
                 parent2.save!
                 child.reload
                 parent1.reload
                 parent2.reload
                 assert_equal [parent1.id, 1, 6], [parent1.root_id, parent1.lft, parent1.rgt]
                 assert_equal [parent1.id, 4, 5], [parent2.root_id, parent2.lft, parent2.rgt]
                 assert_equal [parent1.id, 2, 3], [child.root_id, child.lft, child.rgt]
               end
               def test_move_a_child_to_root
                 parent1 = Issue.generate!
                 parent2 = Issue.generate!
                 child =   Issue.generate!(:parent_issue_id => parent1.id)
                 child.parent_issue_id = nil
                 child.save!
                 child.reload
                 parent1.reload
                 parent2.reload
                 assert_equal [parent1.id, 1, 2], [parent1.root_id, parent1.lft, parent1.rgt]
                 assert_equal [parent2.id, 1, 2], [parent2.root_id, parent2.lft, parent2.rgt]
                 assert_equal [child.id, 1, 2], [child.root_id, child.lft, child.rgt]
               end
               def test_move_a_child_to_another_issue
                 parent1 = Issue.generate!
                 parent2 = Issue.generate!
                 child =   Issue.generate!(:parent_issue_id => parent1.id)
                 child.parent_issue_id = parent2.id
                 child.save!
                 child.reload
                 parent1.reload
                 parent2.reload
                 assert_equal [parent1.id, 1, 2], [parent1.root_id, parent1.lft, parent1.rgt]
                 assert_equal [parent2.id, 1, 4], [parent2.root_id, parent2.lft, parent2.rgt]
                 assert_equal [parent2.id, 2, 3], [child.root_id, child.lft, child.rgt]
               end
               def test_move_a_child_with_descendants_to_another_issue
                 parent1 = Issue.generate!
                 parent2 = Issue.generate!
                 child =   Issue.generate!(:parent_issue_id => parent1.id)
                 grandchild = Issue.generate!(:parent_issue_id => child.id)
                 parent1.reload
                 parent2.reload
                 child.reload
                 grandchild.reload
                 assert_equal [parent1.id, 1, 6], [parent1.root_id, parent1.lft, parent1.rgt]
                 assert_equal [parent2.id, 1, 2], [parent2.root_id, parent2.lft, parent2.rgt]
                 assert_equal [parent1.id, 2, 5], [child.root_id, child.lft, child.rgt]
                 assert_equal [parent1.id, 3, 4], [grandchild.root_id, grandchild.lft, grandchild.rgt]
                 child.reload.parent_issue_id = parent2.id
                 child.save!
                 child.reload
                 grandchild.reload
                 parent1.reload
                 parent2.reload
                 assert_equal [parent1.id, 1, 2], [parent1.root_id, parent1.lft, parent1.rgt]
                 assert_equal [parent2.id, 1, 6], [parent2.root_id, parent2.lft, parent2.rgt]
                 assert_equal [parent2.id, 2, 5], [child.root_id, child.lft, child.rgt]
                 assert_equal [parent2.id, 3, 4], [grandchild.root_id, grandchild.lft, grandchild.rgt]
               end
               def test_move_a_child_with_descendants_to_another_project
                 parent1 = Issue.generate!
                 child =   Issue.generate!(:parent_issue_id => parent1.id)
                 grandchild = Issue.generate!(:parent_issue_id => child.id)
                 child.reload
                 child.project = Project.find(2)
                 assert child.save
                 child.reload
                 grandchild.reload
                 parent1.reload
                 assert_equal [1, parent1.id, 1, 2], [parent1.project_id, parent1.root_id, parent1.lft, parent1.rgt]
                 assert_equal [2, child.id, 1, 4], [child.project_id, child.root_id, child.lft, child.rgt]
                 assert_equal [2, child.id, 2, 3], [grandchild.project_id, grandchild.root_id, grandchild.lft, grandchild.rgt]
               end
               def test_moving_an_issue_to_a_descendant_should_not_validate
                 parent1 = Issue.generate!
                 parent2 = Issue.generate!
                 child =   Issue.generate!(:parent_issue_id => parent1.id)
                 grandchild = Issue.generate!(:parent_issue_id => child.id)
                 child.reload
                 child.parent_issue_id = grandchild.id
                 assert !child.save
                 assert_not_equal [], child.errors[:parent_issue_id]
               end
               def test_updating_a_root_issue_should_not_trigger_update_nested_set_attributes_on_parent_change
                 issue = Issue.find(Issue.generate!.id)
                 issue.parent_issue_id = ""
                 issue.expects(:update_nested_set_attributes_on_parent_change).never
                 issue.save!
               end
               def test_updating_a_child_issue_should_not_trigger_update_nested_set_attributes_on_parent_change
                 issue = Issue.find(Issue.generate!(:parent_issue_id => 1).id)
                 issue.parent_issue_id = "1"
                 issue.expects(:update_nested_set_attributes_on_parent_change).never
                 issue.save!
               end
               def test_moving_a_root_issue_should_trigger_update_nested_set_attributes_on_parent_change
                 issue = Issue.find(Issue.generate!.id)
                 issue.parent_issue_id = "1"
                 issue.expects(:update_nested_set_attributes_on_parent_change).once
                 issue.save!
               end
               def test_moving_a_child_issue_to_another_parent_should_trigger_update_nested_set_attributes_on_parent_change
                 issue = Issue.find(Issue.generate!(:parent_issue_id => 1).id)
                 issue.parent_issue_id = "2"
                 issue.expects(:update_nested_set_attributes_on_parent_change).once
                 issue.save!
               end
               def test_moving_a_child_issue_to_root_should_trigger_update_nested_set_attributes_on_parent_change
                 issue = Issue.find(Issue.generate!(:parent_issue_id => 1).id)
                 issue.parent_issue_id = ""
                 issue.expects(:update_nested_set_attributes_on_parent_change).once
                 issue.save!
               end
               def test_destroy_should_destroy_children
                 issue1 = Issue.generate!
                 issue2 = Issue.generate!
                 issue3 = Issue.generate!(:parent_issue_id => issue2.id)
                 issue4 = Issue.generate!(:parent_issue_id => issue1.id)
                 issue3.init_journal(User.find(2))
                 issue3.subject = 'child with journal'
                 issue3.save!
                 assert_difference 'Issue.count', -2 do
                   assert_difference 'Journal.count', -1 do
                     assert_difference 'JournalDetail.count', -1 do
                       Issue.find(issue2.id).destroy
                     end
                   end
                 end
                 issue1.reload
                 issue4.reload
                 assert !Issue.exists?(issue2.id)
                 assert !Issue.exists?(issue3.id)
                 assert_equal [issue1.id, 1, 4], [issue1.root_id, issue1.lft, issue1.rgt]
                 assert_equal [issue1.id, 2, 3], [issue4.root_id, issue4.lft, issue4.rgt]
               end
               def test_destroy_child_should_update_parent
                 issue = Issue.generate!
                 child1 = Issue.generate!(:parent_issue_id => issue.id)
                 child2 = Issue.generate!(:parent_issue_id => issue.id)
                 issue.reload
                 assert_equal [issue.id, 1, 6], [issue.root_id, issue.lft, issue.rgt]
                 child2.reload.destroy
                 issue.reload
                 assert_equal [issue.id, 1, 4], [issue.root_id, issue.lft, issue.rgt]
               end
               def test_destroy_parent_issue_updated_during_children_destroy
                 parent = Issue.generate!
                 Issue.generate!(:start_date => Date.today, :parent_issue_id => parent.id)
                 Issue.generate!(:start_date => 2.days.from_now, :parent_issue_id => parent.id)
                 assert_difference 'Issue.count', -3 do
                   Issue.find(parent.id).destroy
                 end
               end
               def test_destroy_child_issue_with_children
                 root = Issue.create!(:project_id => 1, :author_id => 2, :tracker_id => 1, :subject => 'root')
                 child = Issue.create!(:project_id => 1, :author_id => 2, :tracker_id => 1, :subject => 'child', :parent_issue_id => root.id)
                 leaf = Issue.create!(:project_id => 1, :author_id => 2, :tracker_id => 1, :subject => 'leaf', :parent_issue_id => child.id)
                 leaf.init_journal(User.find(2))
                 leaf.subject = 'leaf with journal'
                 leaf.save!
                 assert_difference 'Issue.count', -2 do
                   assert_difference 'Journal.count', -1 do
                     assert_difference 'JournalDetail.count', -1 do
                       Issue.find(child.id).destroy
                     end
                   end
                 end
                 root = Issue.find(root.id)
                 assert root.leaf?, "Root issue is not a leaf (lft: #{root.lft}, rgt: #{root.rgt})"
               end
               def test_destroy_issue_with_grand_child
                 parent = Issue.generate!
                 issue = Issue.generate!(:parent_issue_id => parent.id)
                 child = Issue.generate!(:parent_issue_id => issue.id)
                 grandchild1 = Issue.generate!(:parent_issue_id => child.id)
                 grandchild2 = Issue.generate!(:parent_issue_id => child.id)
                 assert_difference 'Issue.count', -4 do
                   Issue.find(issue.id).destroy
                   parent.reload
                   assert_equal [1, 2], [parent.lft, parent.rgt]
                 end
               end
               def test_parent_priority_should_be_the_highest_child_priority
                 parent = Issue.generate!(:priority => IssuePriority.find_by_name('Normal'))
                 # Create children
                 child1 = Issue.generate!(:priority => IssuePriority.find_by_name('High'), :parent_issue_id => parent.id)
                 assert_equal 'High', parent.reload.priority.name
                 child2 = Issue.generate!(:priority => IssuePriority.find_by_name('Immediate'), :parent_issue_id => child1.id)
                 assert_equal 'Immediate', child1.reload.priority.name
                 assert_equal 'Immediate', parent.reload.priority.name
                 child3 = Issue.generate!(:priority => IssuePriority.find_by_name('Low'), :parent_issue_id => parent.id)
                 assert_equal 'Immediate', parent.reload.priority.name
                 # Destroy a child
                 child1.destroy
                 assert_equal 'Low', parent.reload.priority.name
                 # Update a child
                 child3.reload.priority = IssuePriority.find_by_name('Normal')
                 child3.save!
                 assert_equal 'Normal', parent.reload.priority.name
               end
               def test_parent_dates_should_be_lowest_start_and_highest_due_dates
                 parent = Issue.generate!
                 Issue.generate!(:start_date => '2010-01-25', :due_date => '2010-02-15', :parent_issue_id => parent.id)
                 Issue.generate!(                             :due_date => '2010-02-13', :parent_issue_id => parent.id)
                 Issue.generate!(:start_date => '2010-02-01', :due_date => '2010-02-22', :parent_issue_id => parent.id)
                 parent.reload
                 assert_equal Date.parse('2010-01-25'), parent.start_date
                 assert_equal Date.parse('2010-02-22'), parent.due_date
               end
               def test_parent_done_ratio_should_be_average_done_ratio_of_leaves
                 parent = Issue.generate!
                 Issue.generate!(:done_ratio => 20, :parent_issue_id => parent.id)
                 assert_equal 20, parent.reload.done_ratio
                 Issue.generate!(:done_ratio => 70, :parent_issue_id => parent.id)
                 assert_equal 45, parent.reload.done_ratio
                 child = Issue.generate!(:done_ratio => 0, :parent_issue_id => parent.id)
                 assert_equal 30, parent.reload.done_ratio
                 Issue.generate!(:done_ratio => 30, :parent_issue_id => child.id)
                 assert_equal 30, child.reload.done_ratio
                 assert_equal 40, parent.reload.done_ratio
               end
               def test_parent_done_ratio_should_be_weighted_by_estimated_times_if_any
                 parent = Issue.generate!
                 Issue.generate!(:estimated_hours => 10, :done_ratio => 20, :parent_issue_id => parent.id)
                 assert_equal 20, parent.reload.done_ratio
                 Issue.generate!(:estimated_hours => 20, :done_ratio => 50, :parent_issue_id => parent.id)
                 assert_equal (50 * 20 + 20 * 10) / 30, parent.reload.done_ratio
               end
               def test_parent_done_ratio_with_child_estimate_to_0_should_reach_100
                 parent = Issue.generate!
                 issue1 = Issue.generate!(:parent_issue_id => parent.id)
                 issue2 = Issue.generate!(:parent_issue_id => parent.id, :estimated_hours => 0)
                 assert_equal 0, parent.reload.done_ratio
                 issue1.reload.update_attribute :status_id, 5
                 assert_equal 50, parent.reload.done_ratio
                 issue2.reload.update_attribute :status_id, 5
                 assert_equal 100, parent.reload.done_ratio
               end
               def test_parent_estimate_should_be_sum_of_leaves
                 parent = Issue.generate!
                 Issue.generate!(:estimated_hours => nil, :parent_issue_id => parent.id)
                 assert_equal nil, parent.reload.estimated_hours
                 Issue.generate!(:estimated_hours => 5, :parent_issue_id => parent.id)
                 assert_equal 5, parent.reload.estimated_hours
                 Issue.generate!(:estimated_hours => 7, :parent_issue_id => parent.id)
                 assert_equal 12, parent.reload.estimated_hours
               end
               def test_move_parent_updates_old_parent_attributes
                 first_parent = Issue.generate!
                 second_parent = Issue.generate!
                 child = Issue.generate!(:estimated_hours => 5, :parent_issue_id => first_parent.id)
                 assert_equal 5, first_parent.reload.estimated_hours
                 child.update_attributes(:estimated_hours => 7, :parent_issue_id => second_parent.id)
                 assert_equal 7, second_parent.reload.estimated_hours
                 assert_nil first_parent.reload.estimated_hours
               end
               def test_reschuling_a_parent_should_reschedule_subtasks
                 parent = Issue.generate!
                 c1 = Issue.generate!(:start_date => '2010-05-12', :due_date => '2010-05-18', :parent_issue_id => parent.id)
                 c2 = Issue.generate!(:start_date => '2010-06-03', :due_date => '2010-06-10', :parent_issue_id => parent.id)
                 parent.reload
                 parent.reschedule_on!(Date.parse('2010-06-02'))
                 c1.reload
                 assert_equal [Date.parse('2010-06-02'), Date.parse('2010-06-08')], [c1.start_date, c1.due_date]
                 c2.reload
                 assert_equal [Date.parse('2010-06-03'), Date.parse('2010-06-10')], [c2.start_date, c2.due_date] # no change
                 parent.reload
                 assert_equal [Date.parse('2010-06-02'), Date.parse('2010-06-10')], [parent.start_date, parent.due_date]
               end
               def test_project_copy_should_copy_issue_tree
                 p = Project.create!(:name => 'Tree copy', :identifier => 'tree-copy', :tracker_ids => [1, 2])
                 i1 = Issue.generate!(:project => p, :subject => 'i1')
                 i2 = Issue.generate!(:project => p, :subject => 'i2', :parent_issue_id => i1.id)
                 i3 = Issue.generate!(:project => p, :subject => 'i3', :parent_issue_id => i1.id)
                 i4 = Issue.generate!(:project => p, :subject => 'i4', :parent_issue_id => i2.id)
                 i5 = Issue.generate!(:project => p, :subject => 'i5')
                 c = Project.new(:name => 'Copy', :identifier => 'copy', :tracker_ids => [1, 2])
                 c.copy(p, :only => 'issues')
                 c.reload
                 assert_equal 5, c.issues.count
                 ic1, ic2, ic3, ic4, ic5 = c.issues.order('subject').all
                 assert ic1.root?
                 assert_equal ic1, ic2.parent
                 assert_equal ic1, ic3.parent
                 assert_equal ic2, ic4.parent
                 assert ic5.root?
               end
             end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	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