tap 0.7.9 → 0.8.0

data/test/support/tdoc_test.rb

@@ -0,0 +1,363 @@
+require  File.join(File.dirname(__FILE__), '../tap_test_helper')
+
+# = Section One
+# section one
+#
+# == Section Two
+# section two
+# line two
+class TaskDocumentation < Tap::Task
+  config :c_nodoc, 'value'                     # :nodoc:
+  config(:c_accessor, 'value')    # c_accessor
+  
+  config_reader  
+  
+  config :c_reader, 'value'             # c_reader
+  
+  declare_config  
+  
+  config :c, 'value'       # c
+  
+  # c_conventional
+  config :c_conventional, 'value'
+  config :c_without_doc, 'value'
+ 
+  # c_multiline1
+  config(:c_multiline, 'value' )     # c_multiline2
+
+  config :c_with_attr, 'value', {:key => 'value'}               # c_with_attr
+  
+  config :alt_c, 'value'                                                           # alt_c
+  config :alt_c_with_attr, 'value', :key => 'value'                    # alt_c_with_attr
+  config :alt_c_without_value                                                    # alt_c_without_value
+  
+  # declare_config
+  declare_config :declare_config
+  # confg_accessor
+  config_accessor :config_accessor
+  # config_reader
+  config_reader :config_reader
+  # config_writer
+  config_writer :config_writer 
+  
+  # multi_config_accessor
+  config_accessor :multi_config_accessor1, :multi_config_accessor2
+  
+  # attr_accessor
+  attr_accessor :attr_accessor   # ignored
+  attr_accessor :attr_accessor_without_doc
+  
+  # multi_attr_accessor
+  attr_accessor :multi_attr_accessor1, :multi_attr_accessor2
+  
+  config_accessor = [:is, :not, :documented]
+  attr_accessor = [:is, :not, :documented]
+
+  def process(input)
+    config(:is, :not, :documented)
+    config :is, :not, :documented
+    declare_config :is, :not, :documented
+  end
+
+  def config(*args)
+  end
+  
+  def declare_config(*args)
+  end
+end
+
+# nested doc
+module Nested
+  # class doc
+  class Klass
+  end
+  
+  # mod doc
+  module Mod
+  end
+end
+
+class NotATask
+  class << self
+    def config_accessor(*args)
+    end
+  end
+  
+  config = "is not documented"
+  declare_config = [:is, :not, :documented]
+  
+  config_accessor :is, :documented
+  
+  config_accessor = [:is, :not, :documented]
+end
+
+class TDocTest < Test::Unit::TestCase
+  include Tap::Test::SubsetMethods
+
+  condition(:irb_variant) { env('tdoc_with_irb') }
+  if satisfied?(:irb_variant)
+    require 'irb'
+  end
+    
+  require 'tap/support/tdoc'
+  include Tap::Support
+    
+  TDoc.document(__FILE__)
+
+  #
+  # RDoc RubyLex and RubyToken redefinition test
+  #
+  
+  def test_rubylex_and_rubytoken_redefinition   
+    filepath = __FILE__  
+    tl = RDoc::TopLevel.new(filepath)
+    stats = RDoc::Stats.new
+    options = Options.instance
+    parser = RDoc::RubyParser.new(tl, filepath, File.read(filepath), options, stats)
+    
+    assert Tap::Support::TDoc::ConfigParser.included_modules.include?(RDoc::RubyToken)
+    assert RDoc::RubyParser.included_modules.include?(RDoc::RubyToken)
+    assert_equal RDoc::RubyLex, parser.instance_variable_get("@scanner").class
+    
+    if satisfied?(:irb_variant)
+      assert_not_equal RubyToken, RDoc::RubyToken
+      assert_not_equal RubyLex, RDoc::RubyLex
+      assert RubyLex.included_modules.include?(RubyToken)
+      assert !RubyLex.included_modules.include?(RDoc::RubyLex)
+    else
+      flunk unless !Object.const_defined?(:RubyToken) || RubyToken == RDoc::RubyToken
+      flunk unless !Object.const_defined?(:RubyLex) || RubyLex == RDoc::RubyLex
+    end
+  end
+
+  #
+  # [] tests
+  #
+  
+  def test_get_class_documentation
+    c = TDoc[TaskDocumentation]
+    assert_equal RDoc::NormalClass, c.class
+    assert_equal "# = Section One\n# section one\n#\n# == Section Two\n# section two\n# line two\n", c.comment
+    
+    
+    c = TDoc[Nested]
+    assert_equal RDoc::NormalModule, c.class
+    assert_equal "# nested doc\n", c.comment
+    
+    c = TDoc[Nested::Klass]
+    assert_equal RDoc::NormalClass, c.class
+    assert_equal "# class doc\n", c.comment
+    
+    c = TDoc[Nested::Mod]
+    assert_equal RDoc::NormalModule, c.class
+    assert_equal "# mod doc\n", c.comment
+  end
+  
+  def test_get_documentation_works_for_strings_and_constants
+    assert_equal RDoc::NormalClass, TDoc[Nested::Klass].class
+    assert_equal TDoc["Nested::Klass"].object_id, TDoc[Nested::Klass].object_id
+  end
+  
+  def test_configs_are_documented
+    c = TDoc[TaskDocumentation]
+    
+    attributes = c.attributes.collect do |attribute|
+      case attribute
+      when TDoc::ConfigAttr
+      {:comment => attribute.original_comment,
+      :name => attribute.name,  
+      :rw => attribute.rw, 
+      :text => attribute.text}
+      else
+        {:comment => attribute.comment,
+        :name => attribute.name,  
+        :rw => attribute.rw, 
+        :text => attribute.text}
+      end
+    end
+    
+    expected_attributes.each_with_index do |expected, i|
+      assert_equal expected, attributes[i], "unequal attribute (index=#{i})"
+    end
+    assert_equal expected_attributes.length, attributes.length
+  end
+  
+  #
+  # accessor extensions
+  #
+  
+  def test_comment_sections
+    c = TDoc[TaskDocumentation]
+    
+    assert c.respond_to?(:comment_sections)
+    assert_equal({
+      "Section One" => "# section one\n#\n",
+      "Section Two" => "# section two\n# line two\n"},
+    c.comment_sections)
+    
+    assert_equal({
+      "Section Two" => "# section two\n# line two\n"},
+    c.comment_sections(/two/i))
+    
+    assert_equal({
+      "Section Two" => "section two\nline two"},
+    c.comment_sections(/two/i, true))
+  end
+  
+  # def test_collect_configurations
+  #   c = TDoc.document(TaskDocumentation, __FILE__)
+  #   assert_equal expected_attributes[0..-5], TDoc.collect_configurations(c)
+  # end
+  # 
+  # def test_collect_attributes
+  #   c = TDoc.document(TaskDocumentation, __FILE__)
+  #   assert_equal expected_attributes[-4..-1], TDoc.collect_attributes(c)
+  # end
+  
+  def expected_attributes 
+    @expected_attributes ||= [{
+    :comment=>nil,
+    :name=>"c_accessor",
+    :rw=>"RW",
+    :text=>"# c_accessor"},
+   {
+    :comment=>nil,
+    :name=>"c_reader",
+    :rw=>"R",
+    :text=>"# c_reader"},
+   {
+    :comment=>nil,
+    :name=>"c",
+    :rw=>nil,
+    :text=>"# c"},
+   {
+    :comment=>"# c_conventional\n",
+    :name=>"c_conventional",
+    :rw=>nil,
+    :text=>""},
+   {
+    :comment=>nil,
+    :name=>"c_without_doc",
+    :rw=>nil,
+    :text=>""},
+   {
+    :comment=>"# c_multiline1\n",
+    :name=>"c_multiline",
+    :rw=>nil,
+    :text=>"# c_multiline2"},
+   {
+    :comment=>nil,
+    :name=>"c_with_attr",
+    :rw=>nil,
+    :text=>"# c_with_attr"},
+   {
+    :comment=>nil,
+    :name=>"alt_c",
+    :rw=>nil,
+    :text=>"# alt_c"},
+   {
+    :comment=>nil,
+    :name=>"alt_c_with_attr",
+    :rw=>nil,
+    :text=>"# alt_c_with_attr"},
+   {
+    :comment=>nil,
+    :name=>"alt_c_without_value",
+    :rw=>nil,
+    :text=>"# alt_c_without_value"},
+   {
+    :comment=>"# declare_config\n",
+    :name=>"declare_config",
+    :rw=>nil,
+    :text=>""},
+   {
+    :comment=>"# confg_accessor\n",
+    :name=>"config_accessor",
+    :rw=>"RW",
+    :text=>""},
+   {
+    :comment=>"# config_reader\n",
+    :name=>"config_reader",
+    :rw=>"R",
+    :text=>""},
+   {
+    :comment=>"# config_writer\n",
+    :name=>"config_writer",
+    :rw=>"W",
+    :text=>""},
+   {
+    :comment=>"# multi_config_accessor\n",
+    :name=>"multi_config_accessor1",
+    :rw=>"RW",
+    :text=>""},
+   {
+    :comment=>"# multi_config_accessor\n",
+    :name=>"multi_config_accessor2",
+    :rw=>"RW",
+    :text=>""},
+   {
+    :comment=>"# attr_accessor\n",
+    :name=>"attr_accessor",
+    :rw=>"RW",
+    :text=>"# ignored"},
+   {
+    :comment=>nil,
+    :name=>"attr_accessor_without_doc",
+    :rw=>"RW",
+    :text=>""},
+   {
+    :comment=>"# multi_attr_accessor\n",
+    :name=>"multi_attr_accessor1",
+    :rw=>"RW",
+    :text=>""},
+   {
+    :comment=>"# multi_attr_accessor\n",
+    :name=>"multi_attr_accessor2",
+    :rw=>"RW",
+    :text=>""}]
+  end
+  
+  #
+  # NotATask documentation
+  #
+  
+  # def test_not_a_task_document
+  #   c = TDoc.document(NotATask, __FILE__)
+  #   
+  #   assert_equal RDoc::NormalClass, c.class
+  #   assert_equal "", c.comment
+  #   
+  #   attributes = c.attributes.collect do |attribute|
+  #     case attribute
+  #     when TDoc::ConfigAttr
+  #     {:comment => attribute.original_comment,
+  #     :name => attribute.name,  
+  #     :rw => attribute.rw, 
+  #     :text => attribute.text}
+  #     else
+  #       {:comment => attribute.comment,
+  #       :name => attribute.name,  
+  #       :rw => attribute.rw, 
+  #       :text => attribute.text}
+  #     end
+  #   end
+  #   
+  #   not_a_task_expected_attributes.each_with_index do |expected, i|
+  #     assert_equal expected, attributes[i], "unequal attribute (index=#{i})"
+  #   end
+  #   assert_equal not_a_task_expected_attributes.length, attributes.length
+  # end
+  
+  def not_a_task_expected_attributes 
+    @not_a_task_expected_attributes ||= [{
+    :comment=>nil,
+    :name=>"is",
+    :rw=>"RW",
+    :text=>""},
+   {
+    :comment=>nil,
+    :name=>"documented",
+    :rw=>"RW",
+    :text=>""}]
+  end
+end

data/test/support/templater_test.rb

@@ -150,10 +150,10 @@ class TemplaterTest < Test::Unit::TestCase
 	end
 	
 	def test_run_methods_raises_no_method_error_when_method_does_not_exist
-		acase_test(
+		[
 			'non_existant!', 
 			'non existant!'
-		) do |key|
+		].each do |key|
 			t = Templater.new(key => 'entry')
 			assert !t.templates.first.respond_to?(key)
 			assert_raise(NoMethodError) { t.run_methods }

data/test/support/versions_test.rb

@@ -3,6 +3,7 @@ require 'tap/support/versions'
 
 class VersionTest < Test::Unit::TestCase
 	include Tap::Support::Versions
+  include Tap::Test::SubsetMethods
 
   def test_documentation
     assert_equal "path/to/file-1.0.txt", version("path/to/file.txt", 1.0)  
@@ -68,4 +69,35 @@ class VersionTest < Test::Unit::TestCase
 		assert_equal "path/to/file-1.0", increment("path/to/file-1.0", nil)
 		assert_equal "path/to/file", increment("path/to/file", nil)
 	end
+  
+  #
+  # compare versions test
+  #
+  
+  def test_compare_versions_documentation
+    assert_equal 1, compare_versions("1.0.0", "0.9.9")             
+    assert_equal 0, compare_versions(1.1, 1.1)                             
+    assert_equal(-1,  compare_versions([0,9], [0,9,1]) )                 
+  end
+  
+  def test_compare_versions
+    [
+      ["1", "0"], 
+      ["1.1", "1.0"],
+      ["1.0", "0.9"], 
+      ["1.0.0.0", "0.9"], 
+      ["1.0", "0.9.0.0"]
+    ].each do |a,b|
+      assert_equal 1, compare_versions(a,b)
+      assert_equal 0, compare_versions(a,a)
+      assert_equal 0, compare_versions(b,b)
+      assert_equal(-1, compare_versions(b,a))
+    end
+  end
+
+  def test_compare_versions_handles_numeric_and_array_input
+    assert_equal 1, compare_versions(1, 0.9)
+    assert_equal 1, compare_versions([1,0], [0,9])
+    assert_equal 1, compare_versions(["1","0"], ["0","9"])
+  end
 end

data/test/tap_test_helper.rb

@@ -2,3 +2,42 @@ require 'rubygems'
 
 require File.dirname(__FILE__) + '/../lib/tap'
 require 'tap/test'
+
+unless defined?(TapTestMethods)
+  
+  # Some convenience methods used in testing tasks, workflows, app, etc.
+  module TapTestMethods # :nodoc:
+    attr_accessor  :runlist
+
+    # Setup clears the test using clear_tasks and assures that Tap::App.instance 
+    # is the test-specific application.
+    def setup
+      super
+      clear_runlist
+    end
+
+    # Clears all declared tasks, sets the application trace option to false, makes directories (if flagged
+    # and as needed), and clears the runlist.
+    def clear_runlist
+      # clear the attributes
+      @runlist = []
+    end
+
+    # A tracing procedure.  echo adds input to runlist then returns input.
+    def echo
+      lambda do |task, input| 
+        @runlist << input
+        input
+      end
+    end
+
+    # A tracing procedure for numeric inputs.  add_one adds the input to 
+    # runlist then returns input + 1.
+    def add_one
+      lambda do |task, input| 
+        @runlist << input
+        input += 1
+      end
+    end
+  end
+end