tap 0.9.1 → 0.10.0

data/test/support/rake_test.rb

@@ -1,37 +0,0 @@
-require  File.join(File.dirname(__FILE__), '../tap_test_helper')
-
-class RakeTest < Test::Unit::TestCase
-  acts_as_tap_test
-  
-  def test_tap_with_rake
-    extended_test do
-      require 'tap/support/rake'
-      app.extend Tap::Support::Rake
-      
-      runlist = []
-      t1 = task :task => [:prerequisite] do
-        runlist << :task 
-      end
-      t2 = task :prerequisite do
-        runlist << :prerequisite
-      end
-      
-      assert_equal [], runlist
-      app.task(:task).enq
-      app.run
-      assert_equal [:prerequisite, :task], runlist
-    
-      # notice the tasks do not get re-run
-      app.task(:task).enq
-      app.run
-      assert_equal [:prerequisite, :task], runlist
-      
-      # check that Rake still works natively
-      t1.instance_variable_set("@already_invoked", false)
-      t2.instance_variable_set("@already_invoked", false)
-      
-      Rake.application.lookup(:task).invoke
-      assert_equal [:prerequisite, :task, :prerequisite, :task], runlist
-    end
-  end
-end

data/test/support/shell_utils_test.rb

@@ -1,24 +0,0 @@
-require  File.join(File.dirname(__FILE__), '../tap_test_helper')
-require 'tap/support/shell_utils'
-
-class ShellUtilsTest < Test::Unit::TestCase
-  include Tap::Support::ShellUtils
-
-  #
-  # capture_sh test
-  #
-  
-  def test_capture_sh
-    assert_equal "hello\n", capture_sh('echo hello')
-  end
-  
-  def test_capture_sh_with_block
-    was_in_block = false
-    result = capture_sh('echo hello') do |ok, status|
-      assert ok
-      was_in_block = true
-    end
-    assert_equal "hello\n", result
-    assert was_in_block
-  end
-end

data/test/support/tdoc_test.rb

@@ -1,370 +0,0 @@
-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(:c_validation, 'value')   {|value| } # c_validation
-  
-  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 :alt_c, 'value'                                                           # alt_c
-  config :alt_c_validation, 'value'  do |value|  # alt_c_validation
-  end
-  config :alt_c_without_value                                                    # alt_c_without_value
-  config :alt_c_validation_without_value   do |value|             # alt_c_validation_without_value
-  end
-  
-  # 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 ('value')"},
-    {
-     :comment=>nil,
-     :name=>"c_validation",
-     :rw=>"RW",
-     :text=>"# c_validation ('value')"},
-    {
-     :comment=>nil,
-     :name=>"c_reader",
-     :rw=>"R",
-     :text=>"# c_reader ('value')"},
-    {
-     :comment=>nil,
-     :name=>"c",
-     :rw=>nil,
-     :text=>"# c ('value')"},
-    {
-     :comment=>"# c_conventional\n",
-     :name=>"c_conventional",
-     :rw=>nil,
-     :text=>" ('value')"},
-    {
-     :comment=>nil,
-     :name=>"c_without_doc",
-     :rw=>nil,
-     :text=>" ('value')"},
-    {
-     :comment=>"# c_multiline1\n",
-     :name=>"c_multiline",
-     :rw=>nil,
-     :text=>"# c_multiline2 ('value')"},
-    {
-     :comment=>nil,
-     :name=>"alt_c",
-     :rw=>nil,
-     :text=>"# alt_c ('value')"},
-    {
-     :comment=>nil,
-     :name=>"alt_c_validation",
-     :rw=>nil,
-     :text=>"# alt_c_validation ('value')"},
-    {
-     :comment=>nil,
-     :name=>"alt_c_without_value",
-     :rw=>nil,
-     :text=>"# alt_c_without_value"},
-    {
-     :comment=>nil,
-     :name=>"alt_c_validation_without_value",
-     :rw=>nil,
-     :text=>"# alt_c_validation_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/validation_test.rb

@@ -1,54 +0,0 @@
-require  File.join(File.dirname(__FILE__), '../tap_test_helper')
-require 'tap/support/validation'
-
-class ValidationTest < Test::Unit::TestCase
-  include Tap::Support::Validation
-  
-  #
-  # validate test
-  #
-  
-  def test_validate
-    assert_equal 1, validate(1, Integer)
-    assert_raise(ValidationError) { validate(nil, Integer) }
-    assert_equal 1, validate(1, [Integer, nil])
-    assert_equal nil, validate(nil, [Integer, nil])
-    
-    assert_equal "str", validate("str", /str/)
-    assert_raise(ValidationError) { validate("str", /non/) }
-  end
-  
-  #
-  # check test
-  #
-  
-  def test_check_returns_validation_block
-    m = check(Integer)
-    assert_equal Proc, m.class
-    assert_equal 1, m.call(1)
-    assert_raise(ValidationError) { m.call(nil) }
-  end
-  
-  #
-  # yaml test
-  #
-  
-  def test_yaml_doc
-    b = yaml(Integer, nil)
-    assert_equal Proc, b.class
-    assert_equal 1, b.call(1)
-    assert_equal 1, b.call("1")
-    assert_equal nil, b.call(nil)
-    assert_raise(ValidationError) { b.call("str") }
-  end
-  
-  def test_yaml_block_loads_strings_as_yaml_and_checks_result
-    m = yaml(Integer)
-    assert_equal Proc, m.class
-    assert_equal 1, m.call(1)
-    assert_equal 1, m.call("1")
-    assert_raise(ValidationError) { m.call(nil) }
-    assert_raise(ValidationError) { m.call("str") }
-  end
-  
-end