rake 10.1.0.beta.1 → 10.1.0.beta.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6f3ce12012d73dcdfd6cfec09c9c7d22d8d84600
-  data.tar.gz: deb2ee15747c685e35e5b29e244ee7a2a9ca55e6
+  metadata.gz: 3ff5ebacea4245cd96c888f824a9163986e69fdc
+  data.tar.gz: 70037bb8d8e6983e39fcea75475ccf96cf2a8223
 SHA512:
-  metadata.gz: 7e1fdf44fc33efa1018d1b936044c6eca8144ae03c7a9a2354f1a1731268ff0f9589c4bf3bd70f2fff41e5813aba982c0ab157514dab3ab0f913550f5ba12d52
-  data.tar.gz: 0a102b012351cf09af99924d9e78e48c3f07c091a39ab063304fc4c83a1dcb8490ebfed724efe77f86d7873ec90244cc1beb685534aa4d4c1e678c06fed3758f
+  metadata.gz: 0574f0908a532f8d382c5f4bb70182c55812e9866314e6c332cf22a577e3a63c4edde103eb47afee2703da689af8b39e3a78695b6fabfc5177f03b99f92e8917
+  data.tar.gz: cef1c1ec7ae6fd72e762baf4e9c27baea8fd4cac8bc68fbbf0e1ebb3238472071811c6d121da26d444766db3cd01e70ad4b16df60fe5d247470951f72761386b

data/Rakefile

@@ -364,7 +364,7 @@ end
 
 load 'xforge.rf' if File.exist?('xforge.rf')
 
-desc "Where is the current directory.  This task displays\nthe current rake directory"
+desc "Where is the current directory.  This task displays the current rake directory"
 task :where_am_i do
   puts Rake.original_dir
 end

data/lib/rake.rb

@@ -40,6 +40,8 @@ require 'rake/ext/time'
 
 require 'rake/win32'
 
+require 'rake/linked_list'
+require 'rake/scope'
 require 'rake/task_argument_error'
 require 'rake/rule_recursion_overflow_error'
 require 'rake/rake_module'

data/lib/rake/dsl_definition.rb

@@ -116,6 +116,7 @@ module Rake
     end
 
     # Describe the next rake task.
+    # Duplicate descriptions are discarded.
     #
     # Example:
     #   desc "Run the Unit Tests"

data/lib/rake/file_list.rb

@@ -219,7 +219,7 @@ module Rake
     private :resolve_add
 
     def resolve_exclude
-      reject! { |fn| exclude?(fn) }
+      reject! { |fn| excluded_from_list?(fn) }
       self
     end
     private :resolve_exclude
@@ -341,13 +341,19 @@ module Rake
     # Add matching glob patterns.
     def add_matching(pattern)
       FileList.glob(pattern).each do |fn|
-        self << fn unless exclude?(fn)
+        self << fn unless excluded_from_list?(fn)
       end
     end
     private :add_matching
 
-    # Should the given file name be excluded?
-    def exclude?(fn)
+    # Should the given file name be excluded from the list?
+    #
+    # NOTE: This method was formally named "exclude?", but Rails
+    # introduced an exclude? method as an array method and setup a
+    # conflict with file list. We renamed the method to avoid
+    # confusion. If you were using "FileList#exclude?" in your user
+    # code, you will need to update.
+    def excluded_from_list?(fn)
       return true if @exclude_patterns.any? do |pat|
         case pat
         when Regexp

data/lib/rake/invocation_chain.rb

@@ -3,44 +3,48 @@ module Rake
   ####################################################################
   # InvocationChain tracks the chain of task invocations to detect
   # circular dependencies.
-  class InvocationChain
-    def initialize(value, tail)
-      @value = value
-      @tail = tail
-    end
+  class InvocationChain < LinkedList
 
-    def member?(obj)
-      @value == obj || @tail.member?(obj)
+    # Is the invocation already in the chain?
+    def member?(invocation)
+      head == invocation || tail.member?(invocation)
     end
 
-    def append(value)
-      if member?(value)
-        fail RuntimeError, "Circular dependency detected: #{to_s} => #{value}"
+    # Append an invocation to the chain of invocations. It is an error
+    # if the invocation already listed.
+    def append(invocation)
+      if member?(invocation)
+        fail RuntimeError, "Circular dependency detected: #{to_s} => #{invocation}"
       end
-      self.class.new(value, self)
+      conj(invocation)
     end
 
+    # Convert to string, ie: TOP => invocation => invocation
     def to_s
-      "#{prefix}#{@value}"
+      "#{prefix}#{head}"
     end
 
-    def self.append(value, chain)
-      chain.append(value)
+    # Class level append.
+    def self.append(invocation, chain)
+      chain.append(invocation)
     end
 
     private
 
     def prefix
-      "#{@tail.to_s} => "
+      "#{tail.to_s} => "
     end
 
-    class EmptyInvocationChain
+    # Null object for an empty chain.
+    class EmptyInvocationChain < LinkedList::EmptyLinkedList
+      @parent = InvocationChain
+
       def member?(obj)
         false
       end
 
-      def append(value)
-        InvocationChain.new(value, self)
+      def append(invocation)
+        conj(invocation)
       end
 
       def to_s

data/lib/rake/linked_list.rb

@@ -0,0 +1,103 @@
+module Rake
+
+  # Polylithic linked list structure used to implement several data
+  # structures in Rake.
+  class LinkedList
+    include Enumerable
+
+    attr_reader :head, :tail
+
+    def initialize(head, tail=EMPTY)
+      @head = head
+      @tail = tail
+    end
+
+    # Polymorphically add a new element to the head of a list. The
+    # type of head node will be the same list type has the tail.
+    def conj(item)
+      self.class.cons(item, self)
+    end
+
+    # Is the list empty?
+    def empty?
+      false
+    end
+
+    # Lists are structurally equivalent.
+    def ==(other)
+      current = self
+      while ! current.empty? && ! other.empty?
+        return false if current.head != other.head
+        current = current.tail
+        other = other.tail
+      end
+      current.empty? && other.empty?
+    end
+
+    # Convert to string: LL(item, item...)
+    def to_s
+      items = map { |item| item.to_s }.join(", ")
+      "LL(#{items})"
+    end
+
+    # Same as +to_s+, but with inspected items.
+    def inspect
+      items = map { |item| item.inspect }.join(", ")
+      "LL(#{items})"
+    end
+
+    # For each item in the list.
+    def each
+      current = self
+      while ! current.empty?
+        yield(current.head)
+        current = current.tail
+      end
+      self
+    end
+
+    # Make a list out of the given arguments. This method is
+    # polymorphic
+    def self.make(*args)
+      result = empty
+      args.reverse_each do |item|
+        result = cons(item, result)
+      end
+      result
+    end
+
+    # Cons a new head onto the tail list.
+    def self.cons(head, tail)
+      new(head, tail)
+    end
+
+    # The standard empty list class for the given LinkedList class.
+    def self.empty
+      self::EMPTY
+    end
+
+    # Represent an empty list, using the Null Object Pattern.
+    #
+    # When inheriting from the LinkedList class, you should implement
+    # a type specific Empty class as well. Make sure you set the class
+    # instance variable @parent to the assocated list class (this
+    # allows conj, cons and make to work polymorphically).
+    class EmptyLinkedList < LinkedList
+      @parent = LinkedList
+
+      def initialize
+      end
+
+      def empty?
+        true
+      end
+
+      def self.cons(head, tail)
+        @parent.cons(head, tail)
+      end
+    end
+
+    EMPTY = EmptyLinkedList.new
+  end
+
+end

data/lib/rake/scope.rb

@@ -0,0 +1,42 @@
+module Rake
+  class Scope < LinkedList
+
+    # Path for the scope.
+    def path
+      map { |item| item.to_s }.reverse.join(":")
+    end
+
+    # Path for the scope + the named path.
+    def path_with_task_name(task_name)
+      "#{path}:#{task_name}"
+    end
+
+    # Trim +n+ innermost scope levels from the scope. In no case will
+    # this trim beyond the toplevel scope.
+    def trim(n)
+      result = self
+      while n > 0 && ! result.empty?
+        result = result.tail
+        n -= 1
+      end
+      result
+    end
+
+    # Scope lists always end with an EmptyScope object. See Null
+    # Object Pattern)
+    class EmptyScope < EmptyLinkedList
+      @parent = Scope
+
+      def path
+        ""
+      end
+
+      def path_with_task_name(task_name)
+        task_name
+      end
+    end
+
+    # Singleton null object for an empty scope.
+    EMPTY = EmptyScope.new
+  end
+end

data/lib/rake/task.rb

@@ -21,13 +21,6 @@ module Rake
     # Application owning this task.
     attr_accessor :application
 
-    # Comment for this task.  Restricted to a single line of no more than 50
-    # characters.
-    attr_reader :comment
-
-    # Full text of the (possibly multi-line) comment.
-    attr_reader :full_comment
-
     # Array of nested namespaces names used for task lookup by this task.
     attr_reader :scope
 
@@ -91,8 +84,7 @@ module Rake
       @prerequisites   = []
       @actions         = []
       @already_invoked = false
-      @full_comment    = nil
-      @comment         = nil
+      @comments        = []
       @lock            = Monitor.new
       @application     = app
       @scope           = app.current_scope
@@ -159,8 +151,7 @@ module Rake
 
     # Clear the existing comments on a rake task.
     def clear_comments
-      @full_comment = nil
-      @comment = nil
+      @comments = []
       self
     end
 
@@ -266,27 +257,42 @@ module Rake
       add_comment(comment) if comment && ! comment.empty?
     end
 
-    # Writing to the comment attribute is the same as adding a description.
-    def comment=(description)
-      add_description(description)
+    def add_comment(comment)
+      @comments << comment unless @comments.include?(comment)
     end
+    private :add_comment
 
-    # Add a comment to the task.  If a comment already exists, separate
-    # the new comment with " / ".
-    def add_comment(comment)
-      if @full_comment
-        @full_comment << " / "
-      else
-        @full_comment = ''
-      end
-      @full_comment << comment
-      if @full_comment =~ /\A([^.]+?\.)( |$)/
-        @comment = $1
+    # Full collection of comments. Multiple comments are separated by
+    # newlines.
+    def full_comment
+      transform_comments("\n")
+    end
+
+    # First line (or sentence) of all comments. Multiple comments are
+    # separated by a "/".
+    def comment
+      transform_comments(" / ") { |c| first_sentence(c) }
+    end
+
+    # Transform the list of comments as specified by the block and
+    # join with the separator.
+    def transform_comments(separator, &block)
+      if @comments.empty?
+        nil
       else
-        @comment = @full_comment
+        block ||= lambda { |c| c }
+        @comments.map(&block).join(separator)
       end
     end
-    private :add_comment
+    private :transform_comments
+
+    # Get the first sentence in a string. The sentence is terminated
+    # by the first period or the end of the line. Decimal points do
+    # not count as periods.
+    def first_sentence(string)
+      string.split(/\.[ \t]|\.$|\n/).first
+    end
+    private :first_sentence
 
     # Set the names of the arguments for this task. +args+ should be
     # an array of symbols, one for each argument name.
@@ -359,7 +365,8 @@ module Rake
       # this kind of task.  Generic tasks will accept the scope as
       # part of the name.
       def scope_name(scope, task_name)
-        (scope + [task_name]).join(':')
+#        (scope + [task_name]).join(':')
+        scope.path_with_task_name(task_name)
       end
 
     end # class << Rake::Task

data/lib/rake/task_manager.rb

@@ -10,14 +10,14 @@ module Rake
       super
       @tasks = Hash.new
       @rules = Array.new
-      @scope = Array.new
+      @scope = Scope.make
       @last_description = nil
     end
 
     def create_rule(*args, &block)
-      pattern, _, deps = resolve_args(args)
+      pattern, args, deps = resolve_args(args)
       pattern = Regexp.new(Regexp.quote(pattern) + '$') if String === pattern
-      @rules << [pattern, deps, block]
+      @rules << [pattern, args, deps, block]
     end
 
     def define_task(task_class, *args, &block)
@@ -116,9 +116,9 @@ module Rake
     def enhance_with_matching_rule(task_name, level=0)
       fail Rake::RuleRecursionOverflowError,
         "Rule Recursion Too Deep" if level >= 16
-      @rules.each do |pattern, extensions, block|
+      @rules.each do |pattern, args, extensions, block|
         if pattern.match(task_name)
-          task = attempt_rule(task_name, extensions, block, level)
+          task = attempt_rule(task_name, args, extensions, block, level)
           return task if task
         end
       end
@@ -136,7 +136,7 @@ module Rake
     # List of all the tasks defined in the given scope (and its
     # sub-scopes).
     def tasks_in_scope(scope)
-      prefix = scope.join(":")
+      prefix = scope.path
       tasks.select { |t|
         /^#{prefix}:/ =~ t.name
       }
@@ -157,10 +157,10 @@ module Rake
       initial_scope ||= @scope
       task_name = task_name.to_s
       if task_name =~ /^rake:/
-        scopes = []
+        scopes = Scope.make
         task_name = task_name.sub(/^rake:/, '')
       elsif task_name =~ /^(\^+)/
-        scopes = initial_scope[0, initial_scope.size - $1.size]
+        scopes = initial_scope.trim($1.size)
         task_name = task_name.sub(/^(\^+)/, '')
       else
         scopes = initial_scope
@@ -170,12 +170,12 @@ module Rake
 
     # Lookup the task name
     def lookup_in_scope(name, scope)
-      n = scope.size
-      while n >= 0
-        tn = (scope[0, n] + [name]).join(':')
+      loop do
+        tn = scope.path_with_task_name(name)
         task = @tasks[tn]
         return task if task
-        n -= 1
+        break if scope.empty?
+        scope = scope.tail
       end
       nil
     end
@@ -184,19 +184,19 @@ module Rake
     # Return the list of scope names currently active in the task
     # manager.
     def current_scope
-      @scope.dup
+      @scope
     end
 
     # Evaluate the block in a nested namespace named +name+.  Create
     # an anonymous namespace if +name+ is nil.
     def in_namespace(name)
       name ||= generate_name
-      @scope.push(name)
+      @scope = Scope.new(name, @scope)
       ns = NameSpace.new(self, @scope)
       yield(ns)
       ns
     ensure
-      @scope.pop
+      @scope = @scope.tail
     end
 
     private
@@ -232,7 +232,7 @@ module Rake
     end
 
     # Attempt to create a rule given the list of prerequisites.
-    def attempt_rule(task_name, extensions, block, level)
+    def attempt_rule(task_name, args, extensions, block, level)
       sources = make_sources(task_name, extensions)
       prereqs = sources.map { |source|
         trace_rule level, "Attempting Rule #{task_name} => #{source}"
@@ -247,7 +247,7 @@ module Rake
           return nil
         end
       }
-      task = FileTask.define_task({task_name => prereqs}, &block)
+      task = FileTask.define_task(task_name, {args => prereqs}, &block)
       task.sources = prereqs
       task
     end

data/lib/rake/version.rb

@@ -1,5 +1,5 @@
 module Rake
-  VERSION = '10.1.0.beta.1'
+  VERSION = '10.1.0.beta.2'
 
   module Version # :nodoc: all
     MAJOR, MINOR, BUILD, *OTHER = Rake::VERSION.split '.'

data/test/test_rake_file_list.rb

@@ -166,7 +166,7 @@ class TestRakeFileList < Rake::TestCase
   def test_excluding_via_block
     fl = FileList['a.c', 'b.c', 'xyz.c']
     fl.exclude { |fn| fn.pathmap('%n') == 'xyz' }
-    assert fl.exclude?("xyz.c"), "Should exclude xyz.c"
+    assert fl.excluded_from_list?("xyz.c"), "Should exclude xyz.c"
     assert_equal ['a.c', 'b.c'], fl
   end
 
@@ -404,24 +404,24 @@ class TestRakeFileList < Rake::TestCase
 
   def test_exclude_with_alternate_file_seps
     fl = FileList.new
-    assert fl.exclude?("x/CVS/y")
-    assert fl.exclude?("x\\CVS\\y")
-    assert fl.exclude?("x/.svn/y")
-    assert fl.exclude?("x\\.svn\\y")
-    assert fl.exclude?("x/core")
-    assert fl.exclude?("x\\core")
+    assert fl.excluded_from_list?("x/CVS/y")
+    assert fl.excluded_from_list?("x\\CVS\\y")
+    assert fl.excluded_from_list?("x/.svn/y")
+    assert fl.excluded_from_list?("x\\.svn\\y")
+    assert fl.excluded_from_list?("x/core")
+    assert fl.excluded_from_list?("x\\core")
   end
 
   def test_add_default_exclude_list
     fl = FileList.new
     fl.exclude(/~\d+$/)
-    assert fl.exclude?("x/CVS/y")
-    assert fl.exclude?("x\\CVS\\y")
-    assert fl.exclude?("x/.svn/y")
-    assert fl.exclude?("x\\.svn\\y")
-    assert fl.exclude?("x/core")
-    assert fl.exclude?("x\\core")
-    assert fl.exclude?("x/abc~1")
+    assert fl.excluded_from_list?("x/CVS/y")
+    assert fl.excluded_from_list?("x\\CVS\\y")
+    assert fl.excluded_from_list?("x/.svn/y")
+    assert fl.excluded_from_list?("x\\.svn\\y")
+    assert fl.excluded_from_list?("x/core")
+    assert fl.excluded_from_list?("x\\core")
+    assert fl.excluded_from_list?("x/abc~1")
   end
 
   def test_basic_array_functions

data/test/test_rake_functional.rb

@@ -68,7 +68,7 @@ class TestRakeFunctional < Rake::TestCase
 
     rake "--describe"
 
-    assert_match %r{^rake a\n *A / A2 *$}m, @out
+    assert_match %r{^rake a\n *A\n *A2 *$}m, @out
     assert_match %r{^rake b\n *B *$}m, @out
     assert_match %r{^rake d\n *x{80}}m, @out
     refute_match %r{^rake c\n}m, @out

data/test/test_rake_invocation_chain.rb

@@ -1,11 +1,12 @@
 require File.expand_path('../helper', __FILE__)
 
 class TestRakeInvocationChain < Rake::TestCase
+  include Rake
 
   def setup
     super
 
-    @empty = Rake::InvocationChain::EMPTY
+    @empty = InvocationChain.empty
 
     @first_member = "A"
     @second_member = "B"
@@ -13,7 +14,19 @@ class TestRakeInvocationChain < Rake::TestCase
     @two = @one.append(@second_member)
   end
 
-  def test_append
+  def test_conj_on_invocation_chains
+    list = InvocationChain.empty.conj("B").conj("A")
+    assert_equal InvocationChain.make("A", "B"), list
+    assert_equal InvocationChain, list.class
+  end
+
+  def test_make_on_invocation_chains
+    assert_equal @empty, InvocationChain.make()
+    assert_equal @one, InvocationChain.make(@first_member)
+    assert_equal @two, InvocationChain.make(@second_member, @first_member)
+  end
+
+  def test_append_with_one_argument
     chain = @empty.append("A")
 
     assert_equal 'TOP => A', chain.to_s # HACK
@@ -49,4 +62,3 @@ class TestRakeInvocationChain < Rake::TestCase
   end
 
 end
-

data/test/test_rake_linked_list.rb

@@ -0,0 +1,84 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestLinkedList < Rake::TestCase
+  include Rake
+
+  def test_empty_list
+    empty = LinkedList::EMPTY
+    assert empty.empty?, "should be empty"
+  end
+
+  def test_list_with_one_item
+    list = LinkedList.make(:one)
+    assert ! list.empty?, "should not be empty"
+    assert_equal :one, list.head
+    assert_equal LinkedList::EMPTY, list.tail
+  end
+
+  def test_make_with_no_arguments
+    empty = LinkedList.make()
+    assert_equal LinkedList::EMPTY, empty
+  end
+
+  def test_make_with_one_argument
+    list = LinkedList.make(:one)
+    assert ! list.empty?
+    assert_equal :one, list.head
+    assert_equal LinkedList::EMPTY, list.tail
+  end
+
+  def test_make_with_two_arguments
+    list = LinkedList.make(:one, :two)
+    assert ! list.empty?
+    assert_equal :one, list.head
+    assert_equal :two, list.tail.head
+    assert_equal LinkedList::EMPTY, list.tail.tail
+  end
+
+  def test_list_with_several_items
+    list = LinkedList.make(:one, :two, :three)
+
+    assert ! list.empty?, "should not be empty"
+    assert_equal :one, list.head
+    assert_equal :two, list.tail.head
+    assert_equal :three, list.tail.tail.head
+    assert_equal LinkedList::EMPTY, list.tail.tail.tail
+  end
+
+  def test_lists_are_structurally_equivalent
+    list = LinkedList.make(1, 2, 3)
+    same = LinkedList.make(1, 2, 3)
+    diff = LinkedList.make(1, 2, 4)
+    short = LinkedList.make(1, 2)
+
+    assert_equal list, same
+    refute_equal list, diff
+    refute_equal list, short
+    refute_equal short, list
+  end
+
+  def test_converstion_to_string
+    list = LinkedList.make(:one, :two, :three)
+    assert_equal "LL(one, two, three)", list.to_s
+    assert_equal "LL()", LinkedList.make().to_s
+  end
+
+  def test_converstion_with_inspect
+    list = LinkedList.make(:one, :two, :three)
+    assert_equal "LL(:one, :two, :three)", list.inspect
+    assert_equal "LL()", LinkedList.make().inspect
+  end
+
+  def test_lists_are_enumerable
+    list = LinkedList.make(1, 2, 3)
+    new_list = list.map { |item| item + 10 }
+    expected = [11, 12, 13]
+    assert_equal expected, new_list
+  end
+
+  def test_conjunction
+    list = LinkedList.make.conj("C").conj("B").conj("A")
+    assert_equal LinkedList.make("A", "B", "C"), list
+  end
+
+end

data/test/test_rake_rules.rb

@@ -323,4 +323,40 @@ class TestRakeRules < Rake::TestCase
     assert_raises(RuntimeError) do Task['a'].invoke end
   end
 
+  def test_string_rule_with_args
+    delete_file(OBJFILE)
+    create_file(SRCFILE)
+    rule '.o', [:a] => SRCFILE do |t, args|
+      assert_equal 'arg', args.a
+    end
+    Task[OBJFILE].invoke('arg')
+  end
+
+  def test_regex_rule_with_args
+    delete_file(OBJFILE)
+    create_file(SRCFILE)
+    rule(/.o$/, [:a] => SRCFILE) do |t, args|
+      assert_equal 'arg', args.a
+    end
+    Task[OBJFILE].invoke('arg')
+  end
+
+  def test_string_rule_with_args_and_lambda_prereq
+    delete_file(OBJFILE)
+    create_file(SRCFILE)
+    rule '.o', [:a] => [lambda{SRCFILE}]do |t, args|
+      assert_equal 'arg', args.a
+    end
+    Task[OBJFILE].invoke('arg')
+  end
+
+  def test_regex_rule_with_args_and_lambda_prereq
+    delete_file(OBJFILE)
+    create_file(SRCFILE)
+    rule(/.o$/, [:a] => [lambda{SRCFILE}]) do |t, args|
+      assert_equal 'arg', args.a
+    end
+    Task[OBJFILE].invoke('arg')
+  end
+
 end

data/test/test_rake_scope.rb

@@ -0,0 +1,44 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakeScope < Rake::TestCase
+  include Rake
+
+  def test_path_against_empty_scope
+    scope = Scope.make
+    assert_equal scope, Scope::EMPTY
+    assert_equal scope.path, ""
+  end
+
+  def test_path_against_one_element
+    scope = Scope.make(:one)
+    assert_equal "one", scope.path
+  end
+
+  def test_path_against_two_elements
+    scope = Scope.make(:inner, :outer)
+    assert_equal "outer:inner", scope.path
+  end
+
+  def test_path_with_task_name
+    scope = Scope.make(:inner, :outer)
+    assert_equal "outer:inner:task", scope.path_with_task_name("task")
+  end
+
+  def test_path_with_task_name_against_empty_scope
+    scope = Scope.make
+    assert_equal "task", scope.path_with_task_name("task")
+  end
+
+  def test_conj_against_two_elements
+    scope = Scope.make.conj("B").conj("A")
+    assert_equal Scope.make("A", "B"), scope
+  end
+
+  def test_trim
+    scope = Scope.make("A", "B")
+    assert_equal scope, scope.trim(0)
+    assert_equal scope.tail, scope.trim(1)
+    assert_equal scope.tail.tail, scope.trim(2)
+    assert_equal scope.tail.tail, scope.trim(3)
+  end
+end

data/test/test_rake_task.rb

@@ -308,6 +308,24 @@ class TestRakeTask < Rake::TestCase
   end
 
 
+  def test_comments_with_sentences
+    desc "Comment 1. Comment 2."
+    t = task(:t, :name, :rev)
+    assert_equal "Comment 1", t.comment
+  end
+
+  def test_comments_with_tabbed_sentences
+    desc "Comment 1.\tComment 2."
+    t = task(:t, :name, :rev)
+    assert_equal "Comment 1", t.comment
+  end
+
+  def test_comments_with_decimal_points
+    desc "Revision 1.2.3."
+    t = task(:t, :name, :rev)
+    assert_equal "Revision 1.2.3", t.comment
+  end
+
   def test_extended_comments
     desc %{
       This is a comment.
@@ -318,7 +336,7 @@ class TestRakeTask < Rake::TestCase
     }
     t = task(:t, :name, :rev)
     assert_equal "[name,rev]", t.arg_description
-    assert_equal "This is a comment.", t.comment
+    assert_equal "This is a comment", t.comment
     assert_match(/^\s*name -- Name/, t.full_comment)
     assert_match(/^\s*rev  -- Software/, t.full_comment)
     assert_match(/\A\s*This is a comment\.$/, t.full_comment)
@@ -332,9 +350,21 @@ class TestRakeTask < Rake::TestCase
     assert_equal "line one / line two", t.comment
   end
 
-  def test_settable_comments
+  def test_duplicate_comments
+    desc "line one"
     t = task(:t)
-    t.comment = "HI"
-    assert_equal "HI", t.comment
+    desc "line one"
+    task(:t)
+    assert_equal "line one", t.comment
+  end
+
+  def test_interspersed_duplicate_comments
+    desc "line one"
+    t = task(:t)
+    desc "line two"
+    task(:t)
+    desc "line one"
+    task(:t)
+    assert_equal "line one / line two", t.comment
   end
 end

data/test/test_rake_task_manager.rb

@@ -93,7 +93,7 @@ class TestRakeTaskManager < Rake::TestCase
         bb = @tm.define_task(Rake::Task, :bb)
         bot_z = @tm.define_task(Rake::Task, :z)
 
-        assert_equal ["a", "b"], @tm.current_scope
+        assert_equal Rake::Scope.make("b", "a"), @tm.current_scope
 
         assert_equal bb, @tm["a:b:bb"]
         assert_equal aa, @tm["a:aa"]
@@ -101,10 +101,11 @@ class TestRakeTaskManager < Rake::TestCase
         assert_equal bot_z, @tm["z"]
         assert_equal mid_z, @tm["^z"]
         assert_equal top_z, @tm["^^z"]
+        assert_equal top_z, @tm["^^^z"] # Over the top
         assert_equal top_z, @tm["rake:z"]
       end
 
-      assert_equal ["a"], @tm.current_scope
+      assert_equal Rake::Scope.make("a"), @tm.current_scope
 
       assert_equal bb, @tm["a:b:bb"]
       assert_equal aa, @tm["a:aa"]
@@ -113,14 +114,15 @@ class TestRakeTaskManager < Rake::TestCase
       assert_equal aa, @tm["aa"]
       assert_equal mid_z, @tm["z"]
       assert_equal top_z, @tm["^z"]
+      assert_equal top_z, @tm["^^z"] # Over the top
       assert_equal top_z, @tm["rake:z"]
     end
 
-    assert_equal [], @tm.current_scope
+    assert_equal Rake::Scope.make, @tm.current_scope
 
-    assert_equal [], xx.scope
-    assert_equal ['a'], aa.scope
-    assert_equal ['a', 'b'], bb.scope
+    assert_equal Rake::Scope.make, xx.scope
+    assert_equal Rake::Scope.make('a'), aa.scope
+    assert_equal Rake::Scope.make('b', 'a'), bb.scope
   end
 
   def test_lookup_with_explicit_scopes
@@ -133,11 +135,11 @@ class TestRakeTaskManager < Rake::TestCase
         t3 = @tm.define_task(Rake::Task, :t)
       end
     end
-    assert_equal t1, @tm[:t, []]
-    assert_equal t2, @tm[:t, ["a"]]
-    assert_equal t3, @tm[:t, ["a", "b"]]
-    assert_equal s,  @tm[:s, ["a", "b"]]
-    assert_equal s,  @tm[:s, ["a"]]
+    assert_equal t1, @tm[:t, Rake::Scope.make]
+    assert_equal t2, @tm[:t, Rake::Scope.make("a")]
+    assert_equal t3, @tm[:t, Rake::Scope.make("b", "a")]
+    assert_equal s,  @tm[:s, Rake::Scope.make("b", "a")]
+    assert_equal s,  @tm[:s, Rake::Scope.make("a")]
   end
 
   def test_correctly_scoped_prerequisites_are_invoked

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rake
 version: !ruby/object:Gem::Version
-  version: 10.1.0.beta.1
+  version: 10.1.0.beta.2
 platform: ruby
 authors:
 - Jim Weirich
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-26 00:00:00.000000000 Z
+date: 2013-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -105,6 +105,7 @@ files:
 - lib/rake/gempackagetask.rb
 - lib/rake/invocation_chain.rb
 - lib/rake/invocation_exception_mixin.rb
+- lib/rake/linked_list.rb
 - lib/rake/loaders/makefile.rb
 - lib/rake/multi_task.rb
 - lib/rake/name_space.rb
@@ -120,6 +121,7 @@ files:
 - lib/rake/ruby182_test_unit_fix.rb
 - lib/rake/rule_recursion_overflow_error.rb
 - lib/rake/runtest.rb
+- lib/rake/scope.rb
 - lib/rake/task.rb
 - lib/rake/task_argument_error.rb
 - lib/rake/task_arguments.rb
@@ -152,6 +154,7 @@ files:
 - test/test_rake_ftp_file.rb
 - test/test_rake_functional.rb
 - test/test_rake_invocation_chain.rb
+- test/test_rake_linked_list.rb
 - test/test_rake_makefile_loader.rb
 - test/test_rake_multi_task.rb
 - test/test_rake_name_space.rb
@@ -164,6 +167,7 @@ files:
 - test/test_rake_reduce_compat.rb
 - test/test_rake_require.rb
 - test/test_rake_rules.rb
+- test/test_rake_scope.rb
 - test/test_rake_task.rb
 - test/test_rake_task_argument_parsing.rb
 - test/test_rake_task_arguments.rb