tap 0.7.9

data/lib/tap/generator/generators/root/templates/server/lib/tasks/clear_database_prerequisites.rake

@@ -0,0 +1,5 @@
+# This clears the built-in prerequisite 'db:test:prepare' from all the test tasks, allowing
+# rails to run without a database (updated from  "Rails Recipies":http://media.pragprog.com/titles/fr_rr/NoDatabase.pdf)
+['test:units', 'test:functionals', 'test:recent', 'test:integration', 'test:uncommitted'].each do |name|
+  Rake::Task[name].prerequisites.clear
+end

data/lib/tap/generator/generators/root/templates/server/test/test_helper.rb

@@ -0,0 +1,53 @@
+ENV["RAILS_ENV" ] = "test"
+require File.expand_path(File.dirname(__FILE__) + "/../config/environment" )
+
+#################
+# Here I've copied the contents of 'test_help' so I could remove the dependencies
+# causing rails to raise errors if running without a database.
+#
+# require 'test_help'
+require_dependency 'application'
+
+# Make double-sure the RAILS_ENV is set to test,
+# so fixtures are loaded to the right database
+silence_warnings { RAILS_ENV = "test" }
+
+require 'test/unit'
+#require 'active_record/fixtures'
+require 'action_controller/test_process'
+require 'action_controller/integration'
+#require 'action_web_service/test_invoke'
+require 'breakpoint'
+
+#Test::Unit::TestCase.fixture_path = RAILS_ROOT + "/test/fixtures/"
+#ActionController::IntegrationTest.fixture_path = Test::Unit::TestCase.fixture_path
+
+#def create_fixtures(*table_names)
+#  Fixtures.create_fixtures(RAILS_ROOT + "/test/fixtures", table_names)
+#end
+#################
+
+class Test::Unit::TestCase
+  # Transactional fixtures accelerate your tests by wrapping each test method
+  # in a transaction that's rolled back on completion.  This ensures that the
+  # test database remains unchanged so your fixtures don't have to be reloaded
+  # between every test method.  Fewer database queries means faster tests.
+  #
+  # Read Mike Clark's excellent walkthrough at
+  #   http://clarkware.com/cgi/blosxom/2005/10/24#Rails10FastTesting
+  #
+  # Every Active Record database supports transactions except MyISAM tables
+  # in MySQL.  Turn off transactional fixtures in this case; however, if you
+  # don't care one way or the other, switching from MyISAM to InnoDB tables
+  # is recommended.
+  #self.use_transactional_fixtures = true
+
+  # Instantiated fixtures are slow, but give you @david where otherwise you
+  # would need people(:david).  If you don't want to migrate your existing
+  # test cases which use the @david style and don't mind the speed hit (each
+  # instantiated fixtures translates to a database query per test method),
+  # then set this back to true.
+  #self.use_instantiated_fixtures  = false
+
+  # Add more helper methods to be used by all tests here...
+end

data/lib/tap/generator/generators/root/templates/test/tap_test_helper.rb

@@ -0,0 +1,3 @@
+require 'rubygems'
+require 'tap'
+require 'tap/test'

data/lib/tap/generator/generators/root/templates/test/tap_test_suite.rb

@@ -0,0 +1,4 @@
+$:.unshift File.join(File.dirname(__FILE__), '../lib')
+
+ENV["ALL"] = true # runs all subsets (see gemdev)
+Dir.glob("./**/*_test.rb").each {|test| require test}

data/lib/tap/generator/generators/task/task_generator.rb

@@ -0,0 +1,21 @@
+module Tap::Generator::Generators
+  class TaskGenerator < Rails::Generator::NamedBase # :nodoc:
+    def initialize(*args)
+      super(*args)    
+      @destination_root  = Tap::App.instance[:root]
+      @app = Tap::App.instance
+  	end
+
+    def manifest
+      record do |m|
+        lib_path = @app.relative_filepath(:root, @app[:lib])
+        m.directory File.join(lib_path, class_path)
+        m.template "task.erb", File.join(lib_path, class_name.underscore + ".rb")
+    
+        test_path = @app.relative_filepath(:root, @app[:test])
+        m.directory File.join(test_path, class_path)
+        m.template "test.erb", File.join(test_path, class_name.underscore + "_test.rb")
+      end
+    end
+  end
+end

data/lib/tap/generator/generators/task/templates/task.erb

@@ -0,0 +1,21 @@
+# == Documentation
+#
+# === Command Line Usage
+# Replace with your command line usage instructions
+#
+class <%= class_name %> < Tap::Task
+
+  def process(input)
+    # The process logic goes here.
+    
+    # You can access configurations as symbols within the config hash
+    message = "#{config[:greeting]} #{input}!"
+    
+    # Use log to record information
+    log :message, message
+    
+    # The return of process is the task output
+    message
+  end
+  
+end

data/lib/tap/generator/generators/task/templates/test.erb

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__), '<%= '../' * class_nesting_depth %>tap_test_helper.rb') 
+require '<%= class_path.empty? ? file_name : File.join(class_path, file_name) %>'
+
+class <%= class_name %>Test < Test::Unit::TestCase
+  acts_as_tap_test 
+  
+  def test_greeting
+    t = <%= class_name %>.new nil, :greeting => 'hello'
+    
+    with_options(:quiet => true) do	
+      t.execute("from me", "to you")
+				
+      assert_equal({:greeting => 'hello'}, t.config)
+      assert_outputs(t => ["hello from me!", "hello to you!"])
+      
+      # check the audit trail for each input
+      assert_audits(t.results, 
+        0 => [[nil, 'from me'], [t, 'hello from me!']],
+        1 => [[nil, 'to you'], [t, 'hello to you!']])
+      
+      # an alternate way of checking audits
+      check_audit(t.results[1]) do
+        'to you'._from nil
+        'hello to you!'._from t
+      end
+    end
+  end
+  
+end

data/lib/tap/generator/generators/workflow/templates/task.erb

@@ -0,0 +1,16 @@
+# == Documentation
+#
+# === Command Line Usage
+# Replace with your command line usage instructions
+#
+class <%= class_name %> < Tap::Workflow
+    protected
+    
+    def workflow 
+      # Define the workflow entry and exit points,
+      # as well as the workflow logic.
+      self.entry_point = Task.new
+      
+      # app.sequence(entry_point, 'another/task')
+    end
+end

data/lib/tap/generator/generators/workflow/templates/test.erb

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), '<%= '../' * class_nesting_depth %>tap_test_helper.rb') 
+require '<%= class_path.empty? ? file_name : File.join(class_path, file_name) %>'
+
+class <%= class_name %>Test < Test::Unit::TestCase
+  acts_as_tap_test 
+  
+end

data/lib/tap/generator/generators/workflow/workflow_generator.rb

@@ -0,0 +1,21 @@
+module Tap::Generator::Generators
+  class WorkflowGenerator < Rails::Generator::NamedBase # :nodoc:
+    def initialize(*args)
+      super(*args)    
+      @destination_root  = Tap::App.instance[:root]
+      @app = Tap::App.instance
+  	end
+
+    def manifest
+      record do |m|
+        lib_path = @app.relative_filepath(:root, @app[:lib])
+        m.directory File.join(lib_path, class_path)
+        m.template "task.erb", File.join(lib_path, class_name.underscore + ".rb")
+    
+        test_path = @app.relative_filepath(:root, @app[:test])
+        m.directory File.join(test_path, class_path)
+        m.template "test.erb", File.join(test_path, class_name.underscore + "_test.rb")
+      end
+    end
+  end
+end

data/lib/tap/generator/options.rb

@@ -0,0 +1,26 @@
+module Tap
+  module Generator
+    module Options # :nodoc:
+      protected
+      
+      # Adapted from code in 'rails/rails_generator/options.rb'
+      def add_general_options!(opt)
+        opt.separator ''
+        opt.separator 'General Options:'
+        
+        opt.on('-h', '--help', 'Show this help message and quit.') { |v| options[:help] = v }
+        opt.on('-p', '--pretend', 'Run but do not make any changes.') { |v| options[:pretend] = v }
+        opt.on('-f', '--force', 'Overwrite files that already exist.') { options[:collision] = :force }
+        opt.on('-s', '--skip', 'Skip files that already exist.') { options[:collision] = :skip }
+        opt.on('-q', '--quiet', 'Suppress normal output.') { |v| options[:quiet] = v }
+        opt.on('-t', '--backtrace', 'Debugging: show backtrace on errors.') { |v| options[:backtrace] = v }
+        opt.on('-c', '--svn', 'Modify files with subversion. (Note: svn must be in path)') do
+          options[:svn] = `svn status`.inject({}) do |opt, e|
+            opt[e.chomp[7..-1]] = true
+            opt
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tap/generator/usage.rb

@@ -0,0 +1,26 @@
+require 'tap/generator/options'
+
+module Tap
+  module Generator
+    module Usage # :nodoc:
+      include Options
+      
+      protected
+      
+      # Adapted from code in 'rails/rails_generator/scripts.rb'
+      def usage_message
+        usage = "\nInstalled Generators\n"
+        Rails::Generator::Base.sources.each do |source|
+          label = source.label.to_s.capitalize
+          names = source.names
+          usage << "  #{label}: #{names.join(', ')}\n" unless names.empty?
+        end
+
+        usage << <<end_blurb
+        
+end_blurb
+        return usage
+      end
+    end
+  end
+end

data/lib/tap/root.rb

@@ -0,0 +1,275 @@
+require 'fileutils'
+require 'tap/support/versions'
+
+# string.rb is required for camelizing and underscoring strings 
+# requiring just this file rather than the full gem results in 
+# noticably faster startup
+require 'active_support/core_ext/string'
+
+module Tap
+  
+  # Most applications that utilize files allow the definition of a root directory, 
+  # allowing you to place the application directory wherever you like.  Root takes 
+  # this concept further, allowing you to define subdirectories, as well as manipulate 
+  # files and filepaths within these directories.  For example:
+  #
+  #  root = Root.new 'root_dir', :input => 'in', :output => 'out'
+  #  
+  #  # work with directories
+  #  root[:in]        # => 'root_dir/in'
+  #  root[:out]       # => 'root_dir/out'
+  #  root[:implicit]  # => 'root_dir/implicit'
+  #
+  #  # work with filepaths
+  #  fp = root.filepath(:in, 'path/to/file.txt')  # => 'root_dir/in/path/to/file.txt'
+  #  root.relative_filepath(:in, fp)              # => 'path/to/file.txt'
+  #  root.translate(fp, :in, :out)                # => 'root_dir/out/path/to/file.txt'
+  #  
+  #  # version filepaths
+  #  root.version('path/to/config.yml', 1.0)          # => 'path/to/config-1.0.yml'
+  #  root.increment('path/to/config-1.0.yml', 0.1)    # => 'path/to/config-1.1.yml'
+  #  root.deversion('path/to/config-1.1.yml')         # => ['path/to/config.yml', "1.1"]
+  #  
+  #  # work with modules...
+  #  mp = root.module_filepath(:lib, 'Some::Module')  # => 'root_dir/lib/some/module.rb'
+  #  
+  #  # loading them...
+  #  Object.const_defined?(:Some)                # => false 
+  #  root.lookup_module('Some::Module')          # => Some::Module
+  #  Some.const_defined?(:Module)                # => true
+  #
+  #  # and unloading them!
+  #  root.unload_modules                         # => ["Some::Module"]
+  #  Object.const_defined?(:Some)                # => false
+  #
+  # === Notes
+  #
+  # Root internally stores paths for both relative directories and absolute paths in a 
+  # hash for quick lookup using the dir keys.  Root keeps a separate hash for the 
+  # original directories used to create the paths, but this is not necessary for 
+  # absolute paths.  An absolute path can be distinguished from a directory by having
+  # an entry in paths but not directories.
+  class Root  
+    class << self
+      include Support::Versions
+      
+      # Returns the filepath of path relative to dir. If strict=true (the default) then 
+      # relative_filepath raises an error if the path is not relative to dir.
+      #
+      #   Root.relative_filepath('dir', "dir/path/to/file.txt")  # => "path/to/file.txt"
+      #
+      def relative_filepath(dir, path, strict=true)
+        dir = File.expand_path(dir)
+        expanded = File.expand_path(path)
+  
+        unless expanded[0...dir.length] == dir
+          raise "\n#{expanded}\nis not relative to:\n#{dir}" if strict
+          return path
+        end
+      
+        # use dir.length + 1 to remove a leading '/'.   If dir.length + 1 >= expanded.length 
+        # as in: relative_filepath('/path', '/path') then the first arg returns nil, and an 
+        # empty string is returned
+        expanded[(dir.length+1)..-1] || ""
+      end
+    
+      # Lists all unique paths matching the input glob patterns.  
+      def glob(*patterns)
+        patterns.collect do |pattern| 
+          Dir.glob(pattern)
+        end.flatten.uniq
+      end
+    
+      # Lists all unique versions of path matching the glob version patterns.  If no patterns 
+      # are specified, then all versions of path will be returned.
+      def vglob(path, *vpatterns)
+        vpatterns << "*" if vpatterns.empty?
+        vpatterns.collect do |vpattern| 
+          results = Dir.glob(version(path, vpattern)) 
+    
+          # extra work to include the default version path for any version
+          results << path if vpattern == "*" && File.exists?(path)
+          results
+        end.flatten.uniq
+      end
+       
+
+    
+      #def package(target, *filepaths)
+       # options = filepaths.pop if filepaths.last.kind_of?(Hash)
+      #end
+      
+      # glob for dirs, remove if empty.  removes dir if empty on complete
+      # OR
+      # remove files older than a certain date
+      # remove all files
+      # 
+      #def cleanup(dir)
+      #end
+      
+      # iotask?
+      def parse_by_line(path, options={}, &block)
+        str = read(path, options.merge(:as => :txt))
+        lines = str.split(/\r?\n/)
+        lines.each do |line|
+          # don't yield empty lines because they split to [] (ie [nil, nil] for the block inputs)
+          yield(line.split(/#/, 2)) unless line.empty?
+        end
+      end
+    end
+  
+    include Support::Versions
+    attr_reader :root, :directories, :paths
+    
+    # Creates a new Root with the given root, directories, and absolute
+    # paths.  By default root is the current working directory and no
+    # directories or absolute paths are specified.
+    def initialize(root=Dir.pwd, directories={}, absolute_paths={})
+      assign_paths(root, directories, absolute_paths)
+    end
+  
+    # Sets the root directory.  All paths are reassigned accordingly.
+    def root=(path)
+      assign_paths(path, directories, absolute_paths)
+    end
+  
+    # Sets the directories to those provided.  'root' and :root are reserved directory 
+    # keys and cannot be set using this method (use root= instead).
+    def directories=(dirs)
+      assign_paths(root, dirs, absolute_paths)
+    end
+    
+    # Sets the absolute paths to those provided. 'root' and :root are reserved directory 
+    # keys and cannot be set using this method (use root= instead).
+    def absolute_paths=(paths)
+      assign_paths(root, directories, paths)
+    end
+    
+    # Returns the absolute paths registered with the Root.
+    def absolute_paths
+      abs_paths = {}
+      paths.each do |dir, path| 
+        abs_paths[dir] = path unless directories.include?(dir) || dir.to_s == 'root'
+      end
+      abs_paths
+    end
+
+    # Sets the path to the specified directory, relative to the root directory.  
+    # The root directory cannot be set with this method (use root= instead). 
+    # Absolute filepaths can be set by specifying the absolute parameter.
+    #
+    #  root[:dir] = 'path/to/dir'
+    #  root[:root]      # => 'root_dir'
+    #  root[:dir]       # => 'root_dir/path/to/dir'
+    #
+    #  root[:abs, true] = '/abs/path/to/dir'  
+    #  root[:abs]       # => '/abs/path/to/dir'
+    # 
+    # Note - the syntax for setting an absolute filepath requires an odd use []=.  
+    # In fact the method recieves the arguments (:dir, true, '/abs/path/to/dir') 
+    # rather than (:dir, '/abs/path/to/dir', true), meaning that internally path 
+    # and absolute are switched when setting an absolute filepath.
+    def []=(dir, path, absolute=false)
+      raise ArgumentError, "The directory key '#{dir}' is reserved." if dir.to_s == 'root'
+  
+      # switch the paths if absolute was provided
+      unless absolute == false
+        switch = path
+        path = absolute
+        absolute = switch
+      end
+       
+      case
+      when path.nil? 
+        @directories.delete(dir)
+        @paths.delete(dir)
+      when absolute
+        @directories.delete(dir)
+        @paths[dir] = path
+      else
+        @directories[dir] = path
+        @paths[dir] = File.join(root, path)
+      end  
+    end
+  
+    # Returns the path to the specified directory.  If the path has not been set, 
+    # then the path is inferred to be 'root/dir'. 
+    def [](dir)
+      self.paths[dir] || File.join(root, dir.to_s)
+    end
+    
+    # Constructs filepaths relative to the path of the specfied directory.
+    def filepath(dir, *filename)
+      File.join(self[dir], *filename)
+    end
+  
+    # Retrieves filepath relative to the path of the specified directory.  
+    def relative_filepath(dir, filepath, strict=true)
+      Root.relative_filepath(self[dir], filepath, strict)
+    end
+  
+    # Generates a target filepath translated from the input directory to the output directory.  
+    # 
+    #   translate("/input/dir/path/to/input.txt") # => "/output/dir/path/to/input.txt"
+    def translate(filepath, input_dir, output_dir)
+      filepath(output_dir, relative_filepath(input_dir, filepath))
+    end
+  
+    # Lists all files in the specified dir matching the input patterns.  Patterns should be valid inputs
+    # for +Dir.glob+.  If no patterns are specified, lists all files/folders matching '**/*'.
+    def glob(dir, *patterns)
+      patterns << "**/*" if patterns.empty?
+      patterns.collect! {|pattern| filepath(dir, pattern)}
+      Root.glob(*patterns)
+    end
+  
+    # Lists all versions of filename in the specified dir matching the version patterns.
+    # If no patterns are specified, then all versions of filename will be returned.
+    def vglob(dir, filename, *vpatterns)
+      Root.vglob(filepath(dir, filename), *vpatterns)
+    end
+  
+    # Opens the file specfied by dir and filename, then passes the open file to the input block
+    def open(dir, filename, mode_string="r", &block)
+      File.open(filepath(dir, filename), mode_string, &block)
+    end
+  
+    # Reads the specififed file
+    def read(dir, filename)
+      File.read( filepath(dir, filename) )
+    end
+  
+    # 
+    def parse_by_line(dir, filename, options={}, &block)
+      Root.parse_by_line( filepath(dir, filename), options, &block)
+    end
+  
+    # The timestamp of the most recently modified file under dir.  Returns nil
+    # if none of the listed files are relative to dir.
+    def mtime(dir, *filenames)
+      filenames.collect do |fname| 
+        fname = relative_filepath(dir, fname, false)
+        path = filepath(dir, fname)
+      
+        File.exists?(path) ? File.mtime(path) : nil
+      end.compact.max
+    end
+  
+    # Makes all the directories specified in paths.  Parent directories are created as needed.
+    def mkpaths
+      paths.values.each { |dir| FileUtils.mkdir_p(dir) }
+    end
+    
+    private
+  
+    def assign_paths(root, directories, absolute_paths)
+      @root = root
+      @directories = {}
+      @paths = {'root' => root, :root => root}
+      
+      directories.each_pair {|dir, path| self[dir] = path }
+      absolute_paths.each_pair {|dir, path| self[dir, true] = path }
+    end  
+
+  end
+end