SoundSoftware Code Site

# Redmine - project management software

# Copyright (C) 2006-2012  Jean-Philippe Lang

# Copyright (C) 2007  Patrick Aljord patcito@ŋmail.com

#

# 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 'redmine/scm/adapters/git_adapter'

class Repository::Git < Repository

  attr_protected :root_url

  validates_presence_of :url

  def self.human_attribute_name(attribute_key_name, *args)

    attr_name = attribute_key_name.to_s

    if attr_name == "url"

      attr_name = "path_to_repository"

    end

    super(attr_name, *args)

  end

  def self.scm_adapter_class

    Redmine::Scm::Adapters::GitAdapter

  end

  def self.scm_name

    'Git'

  end

  def report_last_commit

    extra_report_last_commit

  end

  def extra_report_last_commit

    return false if extra_info.nil?

    v = extra_info["extra_report_last_commit"]

    return false if v.nil?

    v.to_s != '0'

  end

  def supports_directory_revisions?

    true

  end

  def supports_revision_graph?

    true

  end

  def repo_log_encoding

    'UTF-8'

  end

  # Returns the identifier for the given git changeset

  def self.changeset_identifier(changeset)

    changeset.scmid

  end

  # Returns the readable identifier for the given git changeset

  def self.format_changeset_identifier(changeset)

    changeset.revision[0, 8]

  end

  def branches

    scm.branches

  end

  def tags

    scm.tags

  end

  def default_branch

    scm.default_branch

  rescue Exception => e

    logger.error "git: error during get default branch: #{e.message}"

    nil

  end

  def find_changeset_by_name(name)

    if name.present?

      changesets.where(:revision => name.to_s).first ||

        changesets.where('scmid LIKE ?', "#{name}%").first

    end

  end

  def entries(path=nil, identifier=nil)

    entries = scm.entries(path, identifier, :report_last_commit => extra_report_last_commit)

    load_entries_changesets(entries)

    entries

  end

  # With SCMs that have a sequential commit numbering,

  # such as Subversion and Mercurial,

  # Redmine is able to be clever and only fetch changesets

  # going forward from the most recent one it knows about.

  #

  # However, Git does not have a sequential commit numbering.

  #

  # In order to fetch only new adding revisions,

  # Redmine needs to save "heads".

  #

  # In Git and Mercurial, revisions are not in date order.

  # Redmine Mercurial fixed issues.

  #    * Redmine Takes Too Long On Large Mercurial Repository

  #      http://www.redmine.org/issues/3449

  #    * Sorting for changesets might go wrong on Mercurial repos

  #      http://www.redmine.org/issues/3567

  #

  # Database revision column is text, so Redmine can not sort by revision.

  # Mercurial has revision number, and revision number guarantees revision order.

  # Redmine Mercurial model stored revisions ordered by database id to database.

  # So, Redmine Mercurial model can use correct ordering revisions.

  #

  # Redmine Mercurial adapter uses "hg log -r 0:tip --limit 10"

  # to get limited revisions from old to new.

  # But, Git 1.7.3.4 does not support --reverse with -n or --skip.

  #

  # The repository can still be fully reloaded by calling #clear_changesets

  # before fetching changesets (eg. for offline resync)

  def fetch_changesets

    scm_brs = branches

    return if scm_brs.nil? || scm_brs.empty?

    h1 = extra_info || {}

    h  = h1.dup

    repo_heads = scm_brs.map{ |br| br.scmid }

    h["heads"] ||= []

    prev_db_heads = h["heads"].dup

    if prev_db_heads.empty?

      prev_db_heads += heads_from_branches_hash

    end

    return if prev_db_heads.sort == repo_heads.sort

    h["db_consistent"]  ||= {}

    if changesets.count == 0

      h["db_consistent"]["ordering"] = 1

      merge_extra_info(h)

      self.save

    elsif ! h["db_consistent"].has_key?("ordering")

      h["db_consistent"]["ordering"] = 0

      merge_extra_info(h)

      self.save

    end

    save_revisions(prev_db_heads, repo_heads)

  end

  def save_revisions(prev_db_heads, repo_heads)

    h = {}

    opts = {}

    opts[:reverse]  = true

    opts[:excludes] = prev_db_heads

    opts[:includes] = repo_heads

    revisions = scm.revisions('', nil, nil, opts)

    return if revisions.blank?

    # Make the search for existing revisions in the database in a more sufficient manner

    #

    # Git branch is the reference to the specific revision.

    # Git can *delete* remote branch and *re-push* branch.

    #

    #  $ git push remote :branch

    #  $ git push remote branch

    #

    # After deleting branch, revisions remain in repository until "git gc".

    # On git 1.7.2.3, default pruning date is 2 weeks.

    # So, "git log --not deleted_branch_head_revision" return code is 0.

    #

    # After re-pushing branch, "git log" returns revisions which are saved in database.

    # So, Redmine needs to scan revisions and database every time.

    #

    # This is replacing the one-after-one queries.

    # Find all revisions, that are in the database, and then remove them from the revision array.

    # Then later we won't need any conditions for db existence.

    # Query for several revisions at once, and remove them from the revisions array, if they are there.

    # Do this in chunks, to avoid eventual memory problems (in case of tens of thousands of commits).

    # If there are no revisions (because the original code's algorithm filtered them),

    # then this part will be stepped over.

    # We make queries, just if there is any revision.

    limit = 100

    offset = 0

    revisions_copy = revisions.clone # revisions will change

    while offset < revisions_copy.size

      recent_changesets_slice = changesets.find(

                                     :all,

                                     :conditions => [

                                        'scmid IN (?)',

                                        revisions_copy.slice(offset, limit).map{|x| x.scmid}

                                      ]

                                    )

      # Subtract revisions that redmine already knows about

      recent_revisions = recent_changesets_slice.map{|c| c.scmid}

      revisions.reject!{|r| recent_revisions.include?(r.scmid)}

      offset += limit

    end

    revisions.each do |rev|

      transaction do

        # There is no search in the db for this revision, because above we ensured,

        # that it's not in the db.

        save_revision(rev)

      end

    end

    h["heads"] = repo_heads.dup

    merge_extra_info(h)

    self.save

  end

  private :save_revisions

  def save_revision(rev)

    parents = (rev.parents || []).collect{|rp| find_changeset_by_name(rp)}.compact

    changeset = Changeset.create(

              :repository   => self,

              :revision     => rev.identifier,

              :scmid        => rev.scmid,

              :committer    => rev.author,

              :committed_on => rev.time,

              :comments     => rev.message,

              :parents      => parents

              )

    unless changeset.new_record?

      rev.paths.each { |change| changeset.create_change(change) }

    end

    changeset

  end

  private :save_revision

  def heads_from_branches_hash

    h1 = extra_info || {}

    h  = h1.dup

    h["branches"] ||= {}

    h['branches'].map{|br, hs| hs['last_scmid']}

  end

  def latest_changesets(path,rev,limit=10)

    revisions = scm.revisions(path, nil, rev, :limit => limit, :all => false)

    return [] if revisions.nil? || revisions.empty?

    changesets.find(

      :all,

      :conditions => [

        "scmid IN (?)",

        revisions.map!{|c| c.scmid}

      ],

      :order => 'committed_on DESC'

    )

  end

  def clear_extra_info_of_changesets

    return if extra_info.nil?

    v = extra_info["extra_report_last_commit"]

    write_attribute(:extra_info, nil)

    h = {}

    h["extra_report_last_commit"] = v

    merge_extra_info(h)

    self.save

  end

  private :clear_extra_info_of_changesets

end

# Redmine - project management software

# Copyright (C) 2006-2012  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 RoutingMyTest < ActionController::IntegrationTest

  def test_my

    ["get", "post"].each do |method|

      assert_routing(

          { :method => method, :path => "/my/account" },

          { :controller => 'my', :action => 'account' }

        )

    end

    ["get", "post"].each do |method|

      assert_routing(

          { :method => method, :path => "/my/account/destroy" },

          { :controller => 'my', :action => 'destroy' }

        )

    end

    assert_routing(

        { :method => 'get', :path => "/my/page" },

        { :controller => 'my', :action => 'page' }

      )

    assert_routing(

        { :method => 'get', :path => "/my" },

        { :controller => 'my', :action => 'index' }

      )

    assert_routing(

        { :method => 'post', :path => "/my/reset_rss_key" },

        { :controller => 'my', :action => 'reset_rss_key' }

      )

    assert_routing(

        { :method => 'post', :path => "/my/reset_api_key" },

        { :controller => 'my', :action => 'reset_api_key' }

      )

    ["get", "post"].each do |method|

      assert_routing(

          { :method => method, :path => "/my/password" },

          { :controller => 'my', :action => 'password' }

        )

    end

    assert_routing(

        { :method => 'get', :path => "/my/page_layout" },

        { :controller => 'my', :action => 'page_layout' }

      )

    assert_routing(

        { :method => 'post', :path => "/my/add_block" },

        { :controller => 'my', :action => 'add_block' }

      )

    assert_routing(

        { :method => 'post', :path => "/my/remove_block" },

        { :controller => 'my', :action => 'remove_block' }

      )

    assert_routing(

        { :method => 'post', :path => "/my/order_blocks" },

        { :controller => 'my', :action => 'order_blocks' }

      )

  end

end

Return-Path: <jsmith@somenet.foo>

Received: from osiris ([127.0.0.1])

	by OSIRIS

	with hMailServer ; Sun, 22 Jun 2008 12:28:07 +0200

Message-ID: <000501c8d452$a95cd7e0$0a00a8c0@osiris>

From: "John Smith" <jsmith@somenet.foo>

To: <redmine@somenet.foo>

Subject: New ticket on a given project

Date: Sun, 22 Jun 2008 12:28:07 +0200

MIME-Version: 1.0

Content-Type: text/plain;

	format=flowed;

	charset="iso-8859-1";

	reply-type=original

Content-Transfer-Encoding: 7bit

X-Priority: 3

X-MSMail-Priority: Normal

X-Mailer: Microsoft Outlook Express 6.00.2900.2869

X-MimeOLE: Produced By Microsoft MimeOLE V6.00.2900.2869

Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Maecenas imperdiet 

turpis et odio. Integer eget pede vel dolor euismod varius. Phasellus 

blandit eleifend augue. Nulla facilisi. Duis id diam. Class aptent taciti 

sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. In 

in urna sed tellus aliquet lobortis. Morbi scelerisque tortor in dolor. Cras 

sagittis odio eu lacus. Aliquam sem tortor, consequat sit amet, vestibulum 

id, iaculis at, lectus. Fusce tortor libero, congue ut, euismod nec, luctus 

eget, eros. Pellentesque tortor enim, feugiat in, dignissim eget, tristique 

sed, mauris. Pellentesque habitant morbi tristique senectus et netus et 

malesuada fames ac turpis egestas. Quisque sit amet libero. In hac habitasse 

platea dictumst.

Nulla et nunc. Duis pede. Donec et ipsum. Nam ut dui tincidunt neque 

sollicitudin iaculis. Duis vitae dolor. Vestibulum eget massa. Sed lorem. 

Nullam volutpat cursus erat. Cras felis dolor, lacinia quis, rutrum et, 

dictum et, ligula. Sed erat nibh, gravida in, accumsan non, placerat sed, 

massa. Sed sodales, ante fermentum ultricies sollicitudin, massa leo 

pulvinar dui, a gravida orci mi eget odio. Nunc a lacus.

Project: onlinestore

Tracker: Feature request

category: Stock management

assigned to: miscuser9@foo.bar

priority: foo

done ratio: x

start date: some day 

due date: never

# Redmine - project management software

# Copyright (C) 2006-2012  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.

class MailHandlerController < ActionController::Base

  before_filter :check_credential

  # Submits an incoming email to MailHandler

  def index

    options = params.dup

    email = options.delete(:email)

    if MailHandler.receive(email, options)

      render :nothing => true, :status => :created

    else

      render :nothing => true, :status => :unprocessable_entity

    end

  end

  private

  def check_credential

    User.current = nil

    unless Setting.mail_handler_api_enabled? && params[:key].to_s == Setting.mail_handler_api_key

      render :text => 'Access denied. Incoming emails WS is disabled or key is invalid.', :status => 403

    end

  end

end

# Redmine - project management software

# Copyright (C) 2006-2012  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.

module Redmine

  module Helpers

    class TimeReport

      attr_reader :criteria, :columns, :from, :to, :hours, :total_hours, :periods

      def initialize(project, issue, criteria, columns, from, to)

        @project = project

        @issue = issue

        @criteria = criteria || []

        @criteria = @criteria.select{|criteria| available_criteria.has_key? criteria}

        @criteria.uniq!

        @criteria = @criteria[0,3]

        @columns = (columns && %w(year month week day).include?(columns)) ? columns : 'month'

        @from = from

        @to = to

        run

      end

      def available_criteria

        @available_criteria || load_available_criteria

      end

      private

      def run

        unless @criteria.empty?

          scope = TimeEntry.visible.spent_between(@from, @to)

          if @issue

            scope = scope.on_issue(@issue)

          elsif @project

            scope = scope.on_project(@project, Setting.display_subprojects_issues?)

          end

          time_columns = %w(tyear tmonth tweek spent_on)

          @hours = []

          scope.sum(:hours, :include => :issue, :group => @criteria.collect{|criteria| @available_criteria[criteria][:sql]} + time_columns).each do |hash, hours|

            h = {'hours' => hours}

            (@criteria + time_columns).each_with_index do |name, i|

              h[name] = hash[i]

            end

            @hours << h

          end

          @hours.each do |row|

            case @columns

            when 'year'

              row['year'] = row['tyear']

            when 'month'

              row['month'] = "#{row['tyear']}-#{row['tmonth']}"

            when 'week'

              row['week'] = "#{row['tyear']}-#{row['tweek']}"

            when 'day'

              row['day'] = "#{row['spent_on']}"

            end

          end

          if @from.nil?

            min = @hours.collect {|row| row['spent_on']}.min

            @from = min ? min.to_date : Date.today

          end

          if @to.nil?

            max = @hours.collect {|row| row['spent_on']}.max

            @to = max ? max.to_date : Date.today

          end

          @total_hours = @hours.inject(0) {|s,k| s = s + k['hours'].to_f}

          @periods = []

          # Date#at_beginning_of_ not supported in Rails 1.2.x

          date_from = @from.to_time

          # 100 columns max

          while date_from <= @to.to_time && @periods.length < 100

            case @columns

            when 'year'

              @periods << "#{date_from.year}"

              date_from = (date_from + 1.year).at_beginning_of_year

            when 'month'

              @periods << "#{date_from.year}-#{date_from.month}"

              date_from = (date_from + 1.month).at_beginning_of_month

            when 'week'

              @periods << "#{date_from.year}-#{date_from.to_date.cweek}"

              date_from = (date_from + 7.day).at_beginning_of_week

            when 'day'

              @periods << "#{date_from.to_date}"

              date_from = date_from + 1.day

            end

          end

        end

      end

      def load_available_criteria

        @available_criteria = { 'project' => {:sql => "#{TimeEntry.table_name}.project_id",

                                              :klass => Project,

                                              :label => :label_project},

                                 'status' => {:sql => "#{Issue.table_name}.status_id",

                                              :klass => IssueStatus,

                                              :label => :field_status},

                                 'version' => {:sql => "#{Issue.table_name}.fixed_version_id",

                                              :klass => Version,

                                              :label => :label_version},

                                 'category' => {:sql => "#{Issue.table_name}.category_id",

                                                :klass => IssueCategory,

                                                :label => :field_category},

                                 'member' => {:sql => "#{TimeEntry.table_name}.user_id",

                                             :klass => User,

                                             :label => :label_member},

                                 'tracker' => {:sql => "#{Issue.table_name}.tracker_id",

                                              :klass => Tracker,

                                              :label => :label_tracker},

                                 'activity' => {:sql => "#{TimeEntry.table_name}.activity_id",

                                               :klass => TimeEntryActivity,

                                               :label => :label_activity},

                                 'issue' => {:sql => "#{TimeEntry.table_name}.issue_id",

                                             :klass => Issue,

                                             :label => :label_issue}

                               }

        # Add list and boolean custom fields as available criteria

        custom_fields = (@project.nil? ? IssueCustomField.for_all : @project.all_issue_custom_fields)

        custom_fields.select {|cf| %w(list bool).include? cf.field_format }.each do |cf|

          @available_criteria["cf_#{cf.id}"] = {:sql => "(SELECT c.value FROM #{CustomValue.table_name} c WHERE c.custom_field_id = #{cf.id} AND c.customized_type = 'Issue' AND c.customized_id = #{Issue.table_name}.id ORDER BY c.value LIMIT 1)",

                                                 :format => cf.field_format,

                                                 :label => cf.name}

        end if @project

        # Add list and boolean time entry custom fields

        TimeEntryCustomField.find(:all).select {|cf| %w(list bool).include? cf.field_format }.each do |cf|

          @available_criteria["cf_#{cf.id}"] = {:sql => "(SELECT c.value FROM #{CustomValue.table_name} c WHERE c.custom_field_id = #{cf.id} AND c.customized_type = 'TimeEntry' AND c.customized_id = #{TimeEntry.table_name}.id ORDER BY c.value LIMIT 1)",

                                                 :format => cf.field_format,

                                                 :label => cf.name}

        end

        # Add list and boolean time entry activity custom fields

        TimeEntryActivityCustomField.find(:all).select {|cf| %w(list bool).include? cf.field_format }.each do |cf|

          @available_criteria["cf_#{cf.id}"] = {:sql => "(SELECT c.value FROM #{CustomValue.table_name} c WHERE c.custom_field_id = #{cf.id} AND c.customized_type = 'Enumeration' AND c.customized_id = #{TimeEntry.table_name}.activity_id ORDER BY c.value LIMIT 1)",

                                                 :format => cf.field_format,

                                                 :label => cf.name}

        end

        @available_criteria

      end

    end

  end

end

class InsertBuiltinRoles < ActiveRecord::Migration

  def self.up

    Role.reset_column_information

    nonmember = Role.new(:name => 'Non member', :position => 0)

    nonmember.builtin = Role::BUILTIN_NON_MEMBER

    nonmember.save

    anonymous = Role.new(:name => 'Anonymous', :position => 0)

    anonymous.builtin = Role::BUILTIN_ANONYMOUS

    anonymous.save

  end

  def self.down

    Role.destroy_all 'builtin <> 0'

  end

end

require File.dirname(__FILE__) + '/test_helper'

class Note < ActiveRecord::Base

  acts_as_nested_set :scope => [:notable_id, :notable_type]

end

class AwesomeNestedSetTest < Test::Unit::TestCase

  class Default < ActiveRecord::Base

    acts_as_nested_set

    self.table_name = 'categories'

  end

  class Scoped < ActiveRecord::Base

    acts_as_nested_set :scope => :organization

    self.table_name = 'categories'

  end

  def test_left_column_default

    assert_equal 'lft', Default.acts_as_nested_set_options[:left_column]

  end

  def test_right_column_default

    assert_equal 'rgt', Default.acts_as_nested_set_options[:right_column]

  end

  def test_parent_column_default

    assert_equal 'parent_id', Default.acts_as_nested_set_options[:parent_column]

  end

  def test_scope_default

    assert_nil Default.acts_as_nested_set_options[:scope]

  end

  def test_left_column_name

    assert_equal 'lft', Default.left_column_name

    assert_equal 'lft', Default.new.left_column_name

  end

  def test_right_column_name

    assert_equal 'rgt', Default.right_column_name

    assert_equal 'rgt', Default.new.right_column_name

  end

  def test_parent_column_name

    assert_equal 'parent_id', Default.parent_column_name

    assert_equal 'parent_id', Default.new.parent_column_name

  end

  def test_quoted_left_column_name

    quoted = Default.connection.quote_column_name('lft')

    assert_equal quoted, Default.quoted_left_column_name

    assert_equal quoted, Default.new.quoted_left_column_name

  end

  def test_quoted_right_column_name

    quoted = Default.connection.quote_column_name('rgt')

    assert_equal quoted, Default.quoted_right_column_name

    assert_equal quoted, Default.new.quoted_right_column_name

  end

  def test_left_column_protected_from_assignment

    assert_raises(ActiveRecord::ActiveRecordError) { Category.new.lft = 1 }

  end

  def test_right_column_protected_from_assignment

    assert_raises(ActiveRecord::ActiveRecordError) { Category.new.rgt = 1 }

  end

  def test_parent_column_protected_from_assignment

    assert_raises(ActiveRecord::ActiveRecordError) { Category.new.parent_id = 1 }

  end

  def test_colums_protected_on_initialize

    c = Category.new(:lft => 1, :rgt => 2, :parent_id => 3)

    assert_nil c.lft

    assert_nil c.rgt

    assert_nil c.parent_id

  end

  def test_scoped_appends_id

    assert_equal :organization_id, Scoped.acts_as_nested_set_options[:scope]

  end

  def test_roots_class_method

    assert_equal Category.find_all_by_parent_id(nil), Category.roots

  end

  def test_root_class_method

    assert_equal categories(:top_level), Category.root

  end

  def test_root

    assert_equal categories(:top_level), categories(:child_3).root

  end

  def test_root?

    assert categories(:top_level).root?

    assert categories(:top_level_2).root?

  end

  def test_leaves_class_method

    assert_equal Category.find(:all, :conditions => "#{Category.right_column_name} - #{Category.left_column_name} = 1"), Category.leaves

    assert_equal Category.leaves.count, 4

    assert (Category.leaves.include? categories(:child_1))

    assert (Category.leaves.include? categories(:child_2_1))

    assert (Category.leaves.include? categories(:child_3))

    assert (Category.leaves.include? categories(:top_level_2))

  end

  def test_leaf

    assert categories(:child_1).leaf?

    assert categories(:child_2_1).leaf?

    assert categories(:child_3).leaf?

    assert categories(:top_level_2).leaf?

    assert !categories(:top_level).leaf?

    assert !categories(:child_2).leaf?

  end

  def test_parent

    assert_equal categories(:child_2), categories(:child_2_1).parent

  end

  def test_self_and_ancestors

    child = categories(:child_2_1)

    self_and_ancestors = [categories(:top_level), categories(:child_2), child]

    assert_equal self_and_ancestors, child.self_and_ancestors

  end

  def test_ancestors

    child = categories(:child_2_1)

    ancestors = [categories(:top_level), categories(:child_2)]

    assert_equal ancestors, child.ancestors

  end

  def test_self_and_siblings

    child = categories(:child_2)

    self_and_siblings = [categories(:child_1), child, categories(:child_3)]

    assert_equal self_and_siblings, child.self_and_siblings

    assert_nothing_raised do

      tops = [categories(:top_level), categories(:top_level_2)]

      assert_equal tops, categories(:top_level).self_and_siblings

    end

  end

  def test_siblings

    child = categories(:child_2)

    siblings = [categories(:child_1), categories(:child_3)]

    assert_equal siblings, child.siblings

  end

  def test_leaves

    leaves = [categories(:child_1), categories(:child_2_1), categories(:child_3), categories(:top_level_2)]

    assert categories(:top_level).leaves, leaves

  end

  def test_level

    assert_equal 0, categories(:top_level).level

    assert_equal 1, categories(:child_1).level

    assert_equal 2, categories(:child_2_1).level

  end

  def test_has_children?

    assert categories(:child_2_1).children.empty?

    assert !categories(:child_2).children.empty?

    assert !categories(:top_level).children.empty?

  end

  def test_self_and_descendents

    parent = categories(:top_level)

    self_and_descendants = [parent, categories(:child_1), categories(:child_2),

      categories(:child_2_1), categories(:child_3)]

    assert_equal self_and_descendants, parent.self_and_descendants

    assert_equal self_and_descendants, parent.self_and_descendants.count

  end

  def test_descendents

    lawyers = Category.create!(:name => "lawyers")

    us = Category.create!(:name => "United States")

    us.move_to_child_of(lawyers)

    patent = Category.create!(:name => "Patent Law")

    patent.move_to_child_of(us)

    lawyers.reload

    assert_equal 1, lawyers.children.size

    assert_equal 1, us.children.size

    assert_equal 2, lawyers.descendants.size

  end

  def test_self_and_descendents

    parent = categories(:top_level)

    descendants = [categories(:child_1), categories(:child_2),

      categories(:child_2_1), categories(:child_3)]

    assert_equal descendants, parent.descendants

  end

  def test_children

    category = categories(:top_level)

    category.children.each {|c| assert_equal category.id, c.parent_id }

  end

  def test_is_or_is_ancestor_of?

    assert categories(:top_level).is_or_is_ancestor_of?(categories(:child_1))

    assert categories(:top_level).is_or_is_ancestor_of?(categories(:child_2_1))

    assert categories(:child_2).is_or_is_ancestor_of?(categories(:child_2_1))

    assert !categories(:child_2_1).is_or_is_ancestor_of?(categories(:child_2))

    assert !categories(:child_1).is_or_is_ancestor_of?(categories(:child_2))

    assert categories(:child_1).is_or_is_ancestor_of?(categories(:child_1))

  end

  def test_is_ancestor_of?

    assert categories(:top_level).is_ancestor_of?(categories(:child_1))

    assert categories(:top_level).is_ancestor_of?(categories(:child_2_1))

    assert categories(:child_2).is_ancestor_of?(categories(:child_2_1))

    assert !categories(:child_2_1).is_ancestor_of?(categories(:child_2))

    assert !categories(:child_1).is_ancestor_of?(categories(:child_2))

    assert !categories(:child_1).is_ancestor_of?(categories(:child_1))

  end

  def test_is_or_is_ancestor_of_with_scope

    root = Scoped.root

    child = root.children.first

    assert root.is_or_is_ancestor_of?(child)

    child.update_attribute :organization_id, 'different'

    assert !root.is_or_is_ancestor_of?(child)

  end

  def test_is_or_is_descendant_of?

    assert categories(:child_1).is_or_is_descendant_of?(categories(:top_level))

    assert categories(:child_2_1).is_or_is_descendant_of?(categories(:top_level))

    assert categories(:child_2_1).is_or_is_descendant_of?(categories(:child_2))

    assert !categories(:child_2).is_or_is_descendant_of?(categories(:child_2_1))

    assert !categories(:child_2).is_or_is_descendant_of?(categories(:child_1))

    assert categories(:child_1).is_or_is_descendant_of?(categories(:child_1))

  end

  def test_is_descendant_of?

    assert categories(:child_1).is_descendant_of?(categories(:top_level))

    assert categories(:child_2_1).is_descendant_of?(categories(:top_level))

    assert categories(:child_2_1).is_descendant_of?(categories(:child_2))

    assert !categories(:child_2).is_descendant_of?(categories(:child_2_1))

    assert !categories(:child_2).is_descendant_of?(categories(:child_1))

    assert !categories(:child_1).is_descendant_of?(categories(:child_1))

  end

  def test_is_or_is_descendant_of_with_scope

    root = Scoped.root

    child = root.children.first

    assert child.is_or_is_descendant_of?(root)

    child.update_attribute :organization_id, 'different'

    assert !child.is_or_is_descendant_of?(root)

  end

  def test_same_scope?

    root = Scoped.root

    child = root.children.first

    assert child.same_scope?(root)

    child.update_attribute :organization_id, 'different'

    assert !child.same_scope?(root)

  end

  def test_left_sibling

    assert_equal categories(:child_1), categories(:child_2).left_sibling

    assert_equal categories(:child_2), categories(:child_3).left_sibling

  end

  def test_left_sibling_of_root

    assert_nil categories(:top_level).left_sibling

  end

  def test_left_sibling_without_siblings

    assert_nil categories(:child_2_1).left_sibling

  end

  def test_left_sibling_of_leftmost_node

    assert_nil categories(:child_1).left_sibling

  end

  def test_right_sibling

    assert_equal categories(:child_3), categories(:child_2).right_sibling

    assert_equal categories(:child_2), categories(:child_1).right_sibling

  end

  def test_right_sibling_of_root

    assert_equal categories(:top_level_2), categories(:top_level).right_sibling

    assert_nil categories(:top_level_2).right_sibling

  end

  def test_right_sibling_without_siblings

    assert_nil categories(:child_2_1).right_sibling

  end

  def test_right_sibling_of_rightmost_node

    assert_nil categories(:child_3).right_sibling

  end

  def test_move_left

    categories(:child_2).move_left

    assert_nil categories(:child_2).left_sibling

    assert_equal categories(:child_1), categories(:child_2).right_sibling

    assert Category.valid?

  end

  def test_move_right

    categories(:child_2).move_right

    assert_nil categories(:child_2).right_sibling

    assert_equal categories(:child_3), categories(:child_2).left_sibling

    assert Category.valid?

  end

  def test_move_to_left_of

    categories(:child_3).move_to_left_of(categories(:child_1))

    assert_nil categories(:child_3).left_sibling

    assert_equal categories(:child_1), categories(:child_3).right_sibling

    assert Category.valid?

  end

  def test_move_to_right_of

    categories(:child_1).move_to_right_of(categories(:child_3))

    assert_nil categories(:child_1).right_sibling

    assert_equal categories(:child_3), categories(:child_1).left_sibling

    assert Category.valid?

  end

  def test_move_to_root

    categories(:child_2).move_to_root

    assert_nil categories(:child_2).parent

    assert_equal 0, categories(:child_2).level

    assert_equal 1, categories(:child_2_1).level

    assert_equal 1, categories(:child_2).left

    assert_equal 4, categories(:child_2).right

    assert Category.valid?

  end

  def test_move_to_child_of

    categories(:child_1).move_to_child_of(categories(:child_3))

    assert_equal categories(:child_3).id, categories(:child_1).parent_id

    assert Category.valid?

  end

  def test_move_to_child_of_appends_to_end

    child = Category.create! :name => 'New Child'

    child.move_to_child_of categories(:top_level)

    assert_equal child, categories(:top_level).children.last

  end

  def test_subtree_move_to_child_of

    assert_equal 4, categories(:child_2).left

    assert_equal 7, categories(:child_2).right

    assert_equal 2, categories(:child_1).left

    assert_equal 3, categories(:child_1).right

    categories(:child_2).move_to_child_of(categories(:child_1))

    assert Category.valid?

    assert_equal categories(:child_1).id, categories(:child_2).parent_id

    assert_equal 3, categories(:child_2).left

    assert_equal 6, categories(:child_2).right

    assert_equal 2, categories(:child_1).left

    assert_equal 7, categories(:child_1).right    

  end

  def test_slightly_difficult_move_to_child_of

    assert_equal 11, categories(:top_level_2).left

    assert_equal 12, categories(:top_level_2).right

    # create a new top-level node and move single-node top-level tree inside it.

    new_top = Category.create(:name => 'New Top')

    assert_equal 13, new_top.left

    assert_equal 14, new_top.right

    categories(:top_level_2).move_to_child_of(new_top)

    assert Category.valid?

    assert_equal new_top.id, categories(:top_level_2).parent_id

    assert_equal 12, categories(:top_level_2).left

    assert_equal 13, categories(:top_level_2).right

    assert_equal 11, new_top.left

    assert_equal 14, new_top.right    

  end

  def test_difficult_move_to_child_of

    assert_equal 1, categories(:top_level).left

    assert_equal 10, categories(:top_level).right

    assert_equal 5, categories(:child_2_1).left

    assert_equal 6, categories(:child_2_1).right

    # create a new top-level node and move an entire top-level tree inside it.

    new_top = Category.create(:name => 'New Top')

    categories(:top_level).move_to_child_of(new_top)

    categories(:child_2_1).reload

    assert Category.valid?  

    assert_equal new_top.id, categories(:top_level).parent_id

    assert_equal 4, categories(:top_level).left

    assert_equal 13, categories(:top_level).right

    assert_equal 8, categories(:child_2_1).left

    assert_equal 9, categories(:child_2_1).right    

  end

  #rebuild swaps the position of the 2 children when added using move_to_child twice onto same parent

  def test_move_to_child_more_than_once_per_parent_rebuild

    root1 = Category.create(:name => 'Root1')

    root2 = Category.create(:name => 'Root2')

    root3 = Category.create(:name => 'Root3')

    root2.move_to_child_of root1

    root3.move_to_child_of root1

    output = Category.roots.last.to_text

    Category.update_all('lft = null, rgt = null')

    Category.rebuild!

    assert_equal Category.roots.last.to_text, output

  end

  # doing move_to_child twice onto same parent from the furthest right first

  def test_move_to_child_more_than_once_per_parent_outside_in

    node1 = Category.create(:name => 'Node-1')

    node2 = Category.create(:name => 'Node-2')

    node3 = Category.create(:name => 'Node-3')

    node2.move_to_child_of node1

    node3.move_to_child_of node1

    output = Category.roots.last.to_text

    Category.update_all('lft = null, rgt = null')

    Category.rebuild!

    assert_equal Category.roots.last.to_text, output

  end

  def test_valid_with_null_lefts

    assert Category.valid?

    Category.update_all('lft = null')

    assert !Category.valid?

  end

  def test_valid_with_null_rights

    assert Category.valid?

    Category.update_all('rgt = null')

    assert !Category.valid?

  end

  def test_valid_with_missing_intermediate_node

    # Even though child_2_1 will still exist, it is a sign of a sloppy delete, not an invalid tree.

    assert Category.valid?

    Category.delete(categories(:child_2).id)

    assert Category.valid?

  end

  def test_valid_with_overlapping_and_rights

    assert Category.valid?

    categories(:top_level_2)['lft'] = 0

    categories(:top_level_2).save

    assert !Category.valid?

  end

  def test_rebuild

    assert Category.valid?

    before_text = Category.root.to_text

    Category.update_all('lft = null, rgt = null')

    Category.rebuild!

    assert Category.valid?

    assert_equal before_text, Category.root.to_text

  end

  def test_move_possible_for_sibling

    assert categories(:child_2).move_possible?(categories(:child_1))

  end

  def test_move_not_possible_to_self

    assert !categories(:top_level).move_possible?(categories(:top_level))

  end

  def test_move_not_possible_to_parent

    categories(:top_level).descendants.each do |descendant|

      assert !categories(:top_level).move_possible?(descendant)

      assert descendant.move_possible?(categories(:top_level))

    end

  end

  def test_is_or_is_ancestor_of?

    [:child_1, :child_2, :child_2_1, :child_3].each do |c|

      assert categories(:top_level).is_or_is_ancestor_of?(categories(c))

    end

    assert !categories(:top_level).is_or_is_ancestor_of?(categories(:top_level_2))

  end

  def test_left_and_rights_valid_with_blank_left

    assert Category.left_and_rights_valid?

    categories(:child_2)[:lft] = nil

    categories(:child_2).save(false)

    assert !Category.left_and_rights_valid?

  end

  def test_left_and_rights_valid_with_blank_right

    assert Category.left_and_rights_valid?

    categories(:child_2)[:rgt] = nil

    categories(:child_2).save(false)

    assert !Category.left_and_rights_valid?

  end

  def test_left_and_rights_valid_with_equal

    assert Category.left_and_rights_valid?

    categories(:top_level_2)[:lft] = categories(:top_level_2)[:rgt]

    categories(:top_level_2).save(false)

    assert !Category.left_and_rights_valid?

  end

  def test_left_and_rights_valid_with_left_equal_to_parent

    assert Category.left_and_rights_valid?

    categories(:child_2)[:lft] = categories(:top_level)[:lft]

    categories(:child_2).save(false)

    assert !Category.left_and_rights_valid?

  end

  def test_left_and_rights_valid_with_right_equal_to_parent

    assert Category.left_and_rights_valid?

    categories(:child_2)[:rgt] = categories(:top_level)[:rgt]

    categories(:child_2).save(false)

    assert !Category.left_and_rights_valid?

  end

  def test_moving_dirty_objects_doesnt_invalidate_tree

    r1 = Category.create

    r2 = Category.create

    r3 = Category.create

    r4 = Category.create

    nodes = [r1, r2, r3, r4]

    r2.move_to_child_of(r1)

    assert Category.valid?

    r3.move_to_child_of(r1)

    assert Category.valid?

    r4.move_to_child_of(r2)

    assert Category.valid?

  end

  def test_multi_scoped_no_duplicates_for_columns?

    assert_nothing_raised do

      Note.no_duplicates_for_columns?

    end

  end

  def test_multi_scoped_all_roots_valid?

    assert_nothing_raised do

      Note.all_roots_valid?

    end

  end

  def test_multi_scoped

    note1 = Note.create!(:body => "A", :notable_id => 2, :notable_type => 'Category')

    note2 = Note.create!(:body => "B", :notable_id => 2, :notable_type => 'Category')

    note3 = Note.create!(:body => "C", :notable_id => 2, :notable_type => 'Default')

    assert_equal [note1, note2], note1.self_and_siblings

    assert_equal [note3], note3.self_and_siblings

  end

  def test_multi_scoped_rebuild

    root = Note.create!(:body => "A", :notable_id => 3, :notable_type => 'Category')

    child1 = Note.create!(:body => "B", :notable_id => 3, :notable_type => 'Category')

    child2 = Note.create!(:body => "C", :notable_id => 3, :notable_type => 'Category')

    child1.move_to_child_of root

    child2.move_to_child_of root

    Note.update_all('lft = null, rgt = null')

    Note.rebuild!

    assert_equal Note.roots.find_by_body('A'), root

    assert_equal [child1, child2], Note.roots.find_by_body('A').children

  end

  def test_same_scope_with_multi_scopes

    assert_nothing_raised do

      notes(:scope1).same_scope?(notes(:child_1))

    end

    assert notes(:scope1).same_scope?(notes(:child_1))

    assert notes(:child_1).same_scope?(notes(:scope1))

    assert !notes(:scope1).same_scope?(notes(:scope2))

  end

  def test_quoting_of_multi_scope_column_names

    assert_equal ["\"notable_id\"", "\"notable_type\""], Note.quoted_scope_column_names

  end

  def test_equal_in_same_scope

    assert_equal notes(:scope1), notes(:scope1)

    assert_not_equal notes(:scope1), notes(:child_1)

  end

  def test_equal_in_different_scopes

    assert_not_equal notes(:scope1), notes(:scope2)

  end

end