tap 0.7.9 → 0.8.0

data/test/test/test_assert_expected_result_files/expected/task/name/a.txt

@@ -0,0 +1 @@
+acontent

data/test/test/test_assert_expected_result_files/expected/task/name/b.txt

@@ -0,0 +1 @@
+bcontent

data/test/test/test_assert_expected_result_files/input/a.txt

@@ -0,0 +1 @@
+a

data/test/test/test_assert_expected_result_files/input/b.txt

@@ -0,0 +1 @@
+b

data/test/test/test_file_task_test/expected/one.txt

@@ -0,0 +1 @@
+processed file one

data/test/test/test_file_task_test/expected/two.txt

@@ -0,0 +1 @@
+processed file two

data/test/test/test_file_task_test/input/one.txt

@@ -0,0 +1 @@
+file one

data/test/test/test_file_task_test/input/two.txt

@@ -0,0 +1 @@
+file two

data/test/test_test.rb

@@ -11,7 +11,6 @@ class TestSetupTest < Test::Unit::TestCase
 	#
 	
 	def test_setup_with_options
-		assert runlist.empty?
 		assert_equal @app, app
 		assert_equal Tap::App.instance, app
 		assert_equal File.expand_path("./alt/root"), File.expand_path(app[:root])
@@ -20,6 +19,7 @@ class TestSetupTest < Test::Unit::TestCase
 end
 
 class TestTest < Test::Unit::TestCase
+	include TapTestMethods
 	acts_as_tap_test 
 	
 	#
@@ -225,9 +225,149 @@ class TestTest < Test::Unit::TestCase
 	# with options 
 	#
 	
-	def test_with_options_executes_block_having_set_options_for_app
-		#app
+	def test_with_options_doc
+	  app = Tap::App.new(:options => {:one => 1, :two => 2})
+    
+    with_options({:one => 'one'}, app) do 
+       assert_equal({:one => 'one', :two => 2}, app.options.marshal_dump)
+    end
+    assert_equal({:one => 1, :two => 2}, app.options.marshal_dump)
+	end
+	
+	def test_with_options_merges_new_options_with_existing_for_block
+	  app.options.one = 1
+	  app.options.two = 2
+	  
+		assert_equal({:one => 1, :two => 2}, app.options.marshal_dump)
+		with_options(:one => 'one') do
+		  assert_equal({:one => 'one', :two => 2}, app.options.marshal_dump)
+		end
+		assert_equal({:one => 1, :two => 2}, app.options.marshal_dump)
+	end
+	
+	def test_with_options_does_not_merge_if_merge_with_existing_is_false
+	  app.options.one = 1
+	  app.options.two = 2
+	  
+		assert_equal({:one => 1, :two => 2}, app.options.marshal_dump)
+		with_options({:one => 'one'}, app, false) do
+		  assert_equal({:one => 'one'}, app.options.marshal_dump)
+		end
+		assert_equal({:one => 1, :two => 2}, app.options.marshal_dump)
 	end
 	
+	
+	#
+	# with config 
+	#
+	
+	def test_with_config_doc
+     app = Tap::App.new(:directories => {:dir => 'dir', :alt => 'alt_dir'})
+     tmp_config = {
+       :directories => {:alt => 'another', :new => 'new_dir'},
+       :options => {:one => 1}}
+    
+     with_config(tmp_config, app) do 
+       assert_equal({:dir => 'dir', :alt => 'another', :new => 'new_dir'}, app.directories)        
+       assert_equal({:one => 1}, app.options.marshal_dump)
+     end
+     assert_equal({:dir => 'dir', :alt => 'alt_dir'}, app.directories)
+     assert_equal({}, app.options.marshal_dump)
+	end
+	
+	def test_with_config_merges_new_config_with_existing_for_block
+	  config = {
+	    :root => File.expand_path("root"),
+	    :directories => {:dir => 'dir', :alt => 'alt_dir'},
+	    :options => {:one => 1, :two => 2}}
+	  logger_config ={
+      :device => app.logger.logdev.dev,
+      :level => app.logger.level,
+      :datetime_format => app.logger.datetime_format}
+      
+	  full_config = config.merge(
+  	  :absolute_paths => {},
+  	  :logger => logger_config) 
+	  modified_config = {
+	    :root => File.expand_path("root"),
+	    :directories => {:dir => 'another', :new => 'new_dir', :alt => 'alt_dir'},
+	    :options => {:one => 'one', :two => 2},
+	    :absolute_paths => {:abs => File.expand_path('abs')},
+	    :logger => logger_config}
+	  
+	  app.reconfigure(full_config)
+ 
+		assert_equal(full_config, app.config)
+		with_config(
+		  :directories => {:dir => 'another', :new => 'new_dir'},
+		  :options => {:one => 'one'},
+		  :absolute_paths => {:abs => 'abs'}
+		) do
+		  assert_equal(modified_config, app.config)
+		end
+		assert_equal(full_config, app.config)
+	end
+	
+	def test_with_config_does_not_merge_if_merge_with_existing_is_false
+	  config = {
+	    :root => File.expand_path("root"),
+	    :directories => {:dir => 'dir', :alt => 'alt_dir'},
+	    :options => {:one => 1, :two => 2}}
+	  logger_config ={
+      :device => app.logger.logdev.dev,
+      :level => app.logger.level,
+      :datetime_format => app.logger.datetime_format}
+      
+	  full_config = config.merge(
+  	  :absolute_paths => {},
+  	  :logger => logger_config) 
+	  modified_config = {
+	    :root => File.expand_path("root"),
+	    :directories => {:dir => 'another', :new => 'new_dir'},
+	    :options => {:one => 'one'},
+	    :absolute_paths => {:abs => File.expand_path('abs')},
+	    :logger => logger_config}
+	  
+	  app.reconfigure(full_config)
+ 
+		assert_equal(full_config, app.config)
+		with_config(
+		  {:directories => {:dir => 'another', :new => 'new_dir'},
+		  :options => {:one => 'one'},
+		  :absolute_paths => {:abs => 'abs'}},
+		  app,
+		  false
+		) do
+		  assert_equal(modified_config, app.config)
+		end
+		assert_equal(full_config, app.config)
+	end
+
+  #
+  # assert_expected_result_files
+  #
+  
+  def test_assert_expected_result_files
+    t = Tap::FileTask.new("task/name") do |task, input_file|
+      output_file = task.filepath(:data, File.basename(input_file))
+      content = "#{File.read(input_file)}content"
+      
+      assert_equal method_filepath(:output, "task/name", File.basename(input_file)), output_file
+      
+      task.prepare(output_file)
+      File.open(output_file, "wb") {|f| f << content}
+      output_file
+    end
+    
+    was_in_block=false
+    assert_expected_result_files(t) do |output_files|
+      was_in_block = true
+      assert_equal [method_filepath(:output, "task/name/a.txt"), method_filepath(:output, "task/name/b.txt")], output_files
+      output_files
+    end
+    
+    assert was_in_block
+  end
+  
 end
 

data/test/workflow_test.rb

@@ -2,6 +2,8 @@ require File.join(File.dirname(__FILE__), 'tap_test_helper')
 require 'tap/workflow'
 
 class WorkflowTest < Test::Unit::TestCase
+	include TapTestMethods
+	
 	acts_as_tap_test
 	
   def test_workflow_raises_error_if_no_task_block_is_provided

data/vendor/rails_generator.rb

@@ -0,0 +1,56 @@
+#--
+# Copyright (c) 2004 Jeremy Kemper
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+#########################################################################
+#--
+# Added to Tap by Simon Chiang so that rails doesn't need to be installed
+# for access to generators.  A minor modification was required to remove 
+# a dependency on ActiveRecord, and the addition of the activesupport
+# path was removed below.  The default rails generators were also removed.
+#
+# Changes:
+#  commented out path addition below
+#  modified 'rails_generator/base' line 231 
+#  removed 'rails_generator/generators'
+#++
+
+$:.unshift(File.dirname(__FILE__))
+#$:.unshift(File.dirname(__FILE__) + "/../../activesupport/lib")
+
+begin
+  require 'active_support'  
+rescue LoadError
+  require 'rubygems'
+  gem 'activesupport'
+end
+
+require 'rails_generator/base'
+require 'rails_generator/lookup'
+require 'rails_generator/commands'
+
+Rails::Generator::Base.send(:include, Rails::Generator::Lookup)
+Rails::Generator::Base.send(:include, Rails::Generator::Commands)
+
+# Set up a default logger for convenience.
+require 'rails_generator/simple_logger'
+Rails::Generator::Base.logger = Rails::Generator::SimpleLogger.new(STDOUT)

data/vendor/rails_generator/base.rb

@@ -0,0 +1,263 @@
+require File.dirname(__FILE__) + '/options'
+require File.dirname(__FILE__) + '/manifest'
+require File.dirname(__FILE__) + '/spec'
+require File.dirname(__FILE__) + '/generated_attribute'
+
+module Rails
+  # Rails::Generator is a code generation platform tailored for the Rails
+  # web application framework.  Generators are easily invoked within Rails
+  # applications to add and remove components such as models and controllers.
+  # New generators are easy to create and may be distributed as RubyGems,
+  # tarballs, or Rails plugins for inclusion system-wide, per-user, 
+  # or per-application.
+  #
+  # For actual examples see the rails_generator/generators directory in the
+  # Rails source (or the +railties+ directory if you have frozen the Rails
+  # source in your application).
+  #
+  # Generators may subclass other generators to provide variations that
+  # require little or no new logic but replace the template files.
+  #
+  # For a RubyGem, put your generator class and templates in the +lib+
+  # directory. For a Rails plugin, make a +generators+ directory at the 
+  # root of your plugin.
+  #
+  # The layout of generator files can be seen in the built-in 
+  # +controller+ generator:
+  #   
+  #   generators/
+  #     controller/
+  #       controller_generator.rb
+  #       templates/
+  #         controller.rb
+  #         functional_test.rb
+  #         helper.rb
+  #         view.rhtml
+  #
+  # The directory name (+controller+) matches the name of the generator file
+  # (controller_generator.rb) and class (+ControllerGenerator+). The files
+  # that will be copied or used as templates are stored in the +templates+
+  # directory.
+  #
+  # The filenames of the templates don't matter, but choose something that
+  # will be self-explatatory since you will be referencing these in the 
+  # +manifest+ method inside your generator subclass.
+  #
+  # 
+  module Generator
+    class GeneratorError < StandardError; end
+    class UsageError < GeneratorError; end
+
+
+    # The base code generator is bare-bones.  It sets up the source and
+    # destination paths and tells the logger whether to keep its trap shut.
+    #
+    # It's useful for copying files such as stylesheets, images, or 
+    # javascripts.
+    #
+    # For more comprehensive template-based passive code generation with
+    # arguments, you'll want Rails::Generator::NamedBase. 
+    #
+    # Generators create a manifest of the actions they perform then hand
+    # the manifest to a command which replays the actions to do the heavy
+    # lifting (such as checking for existing files or creating directories
+    # if needed). Create, destroy, and list commands are included.  Since a
+    # single manifest may be used by any command, creating new generators is
+    # as simple as writing some code templates and declaring what you'd like
+    # to do with them.
+    #
+    # The manifest method must be implemented by subclasses, returning a
+    # Rails::Generator::Manifest.  The +record+ method is provided as a
+    # convenience for manifest creation.  Example:
+    #
+    #   class StylesheetGenerator < Rails::Generator::Base
+    #     def manifest
+    #       record do |m|
+    #         m.directory('public/stylesheets')
+    #         m.file('application.css', 'public/stylesheets/application.css')
+    #       end
+    #     end
+    #   end
+    #
+    # See Rails::Generator::Commands::Create for a list of methods available
+    # to the manifest.
+    class Base
+      include Options
+
+      # Declare default options for the generator.  These options
+      # are inherited to subclasses.
+      default_options :collision => :ask, :quiet => false
+
+      # A logger instance available everywhere in the generator.
+      cattr_accessor :logger
+
+      # Every generator that is dynamically looked up is tagged with a
+      # Spec describing where it was found.
+      class_inheritable_accessor :spec
+
+      attr_reader :source_root, :destination_root, :args
+
+      def initialize(runtime_args, runtime_options = {})
+        @args = runtime_args
+        parse!(@args, runtime_options)
+
+        # Derive source and destination paths.
+        @source_root = options[:source] || File.join(spec.path, 'templates')
+        if options[:destination]
+          @destination_root = options[:destination]
+        elsif defined? ::RAILS_ROOT
+          @destination_root = ::RAILS_ROOT
+        end
+
+        # Silence the logger if requested.
+        logger.quiet = options[:quiet]
+
+        # Raise usage error if help is requested.
+        usage if options[:help]
+      end
+
+      # Generators must provide a manifest.  Use the +record+ method to create
+      # a new manifest and record your generator's actions.
+      def manifest
+        raise NotImplementedError, "No manifest for '#{spec.name}' generator."
+      end
+
+      # Return the full path from the source root for the given path.
+      # Example for source_root = '/source':
+      #   source_path('some/path.rb') == '/source/some/path.rb'
+      #
+      # The given path may include a colon ':' character to indicate that
+      # the file belongs to another generator.  This notation allows any
+      # generator to borrow files from another.  Example:
+      #   source_path('model:fixture.yml') = '/model/source/path/fixture.yml'
+      def source_path(relative_source)
+        # Check whether we're referring to another generator's file.
+        name, path = relative_source.split(':', 2)
+
+        # If not, return the full path to our source file.
+        if path.nil?
+          File.join(source_root, name)
+
+        # Otherwise, ask our referral for the file.
+        else
+          # FIXME: this is broken, though almost always true.  Others'
+          # source_root are not necessarily the templates dir.
+          File.join(self.class.lookup(name).path, 'templates', path)
+        end
+      end
+
+      # Return the full path from the destination root for the given path.
+      # Example for destination_root = '/dest':
+      #   destination_path('some/path.rb') == '/dest/some/path.rb'
+      def destination_path(relative_destination)
+        File.join(destination_root, relative_destination)
+      end
+
+      protected
+        # Convenience method for generator subclasses to record a manifest.
+        def record
+          Rails::Generator::Manifest.new(self) { |m| yield m }
+        end
+
+        # Override with your own usage banner.
+        def banner
+          "Usage: #{$0} #{spec.name} [options]"
+        end
+
+        # Read USAGE from file in generator base path.
+        def usage_message
+          File.read(File.join(spec.path, 'USAGE')) rescue ''
+        end
+    end
+
+
+    # The base generator for named components: models, controllers, mailers,
+    # etc.  The target name is taken as the first argument and inflected to
+    # singular, plural, class, file, and table forms for your convenience.
+    # The remaining arguments are aliased to +actions+ as an array for 
+    # controller and mailer convenience.
+    #
+    # Several useful local variables and methods are populated in the 
+    # +initialize+ method. See below for a list of Attributes and
+    # External Aliases available to both the manifest and to all templates.    
+    #
+    # If no name is provided, the generator raises a usage error with content
+    # optionally read from the USAGE file in the generator's base path.
+    #
+    # For example, the +controller+ generator takes the first argument as 
+    # the name of the class and subsequent arguments as the names of
+    # actions to be generated:
+    #
+    #   ./script/generate controller Article index new create
+    #
+    # See Rails::Generator::Base for a discussion of manifests, 
+    # Rails::Generator::Commands::Create for methods available to the manifest,
+    # and Rails::Generator for a general discussion of generators.
+    class NamedBase < Base
+      attr_reader   :name, :class_name, :singular_name, :plural_name, :table_name
+      attr_reader   :class_path, :file_path, :class_nesting, :class_nesting_depth
+      alias_method  :file_name,  :singular_name
+      alias_method  :actions, :args
+
+      def initialize(runtime_args, runtime_options = {})
+        super
+
+        # Name argument is required.
+        usage if runtime_args.empty?
+
+        @args = runtime_args.dup
+        base_name = @args.shift
+        assign_names!(base_name)
+      end
+
+      protected
+        # Override with your own usage banner.
+        def banner
+          "Usage: #{$0} #{spec.name} #{spec.name.camelize}Name [options]"
+        end
+    
+        def attributes
+          @attributes ||= @args.collect do |attribute|
+            Rails::Generator::GeneratedAttribute.new(*attribute.split(":"))
+          end
+        end
+
+
+      private
+        def assign_names!(name)
+          @name = name
+          base_name, @class_path, @file_path, @class_nesting, @class_nesting_depth = extract_modules(@name)
+          @class_name_without_nesting, @singular_name, @plural_name = inflect_names(base_name) 
+          # Modified: such that ActiveRecord::Base is not needed.  Default is plural_name.
+          #@table_name = ActiveRecord::Base.pluralize_table_names ? plural_name : singular_name
+          @table_name = plural_name
+          if @class_nesting.empty?
+            @class_name = @class_name_without_nesting
+          else
+            @table_name = @class_nesting.underscore << "_" << @table_name
+            @class_name = "#{@class_nesting}::#{@class_name_without_nesting}"
+          end
+        end
+
+        # Extract modules from filesystem-style or ruby-style path:
+        #   good/fun/stuff
+        #   Good::Fun::Stuff
+        # produce the same results.
+        def extract_modules(name)
+          modules = name.include?('/') ? name.split('/') : name.split('::')
+          name    = modules.pop
+          path    = modules.map { |m| m.underscore }
+          file_path = (path + [name.underscore]).join('/')
+          nesting = modules.map { |m| m.camelize }.join('::')
+          [name, path, file_path, nesting, modules.size]
+        end
+
+        def inflect_names(name)
+          camel  = name.camelize
+          under  = camel.underscore
+          plural = under.pluralize
+          [camel, under, plural]
+        end
+    end
+  end
+end