tap 0.9.1 → 0.10.0

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

@@ -1,32 +0,0 @@
-class <%= class_name_without_nesting %>Generator < Rails::Generator::NamedBase 
-  attr_accessor :app
-  
-  def initialize(*args)
-    super(*args) 
-    @app = Tap::App.instance   
-    @destination_root = app[:root]
-  end
-
-  def manifest
-    record do |m|
-      # Use statements like these to make directories you need.
-      # Note directories will be created relative to @destination_root (ie app[:root])
-      target_dir = 'target'
-      m.directory target_dir
-      
-      # These statements use the templates to create the following files:
-      #   templates/ruby_file.erb  =>  target_dir/class_name.rb
-      #   templates/text_file.erb  =>  target_dir/class_name.txt
-      #
-      # In templates, use class_name_without_nesting in conjunction with 
-      # the :class_nesting option to properly indent nested classes, like:
-      #
-      #   [ruby_file.erb]
-      #   class <%= class_name_without_nesting %>
-      #   end
-      #
-      m.template "ruby_file.erb", File.join(target_dir, class_name.underscore + ".rb"), :class_nesting => class_nesting
-      m.template "text_file.erb",  File.join(target_dir, class_name.underscore + ".txt")
-    end
-  end
-end

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

@@ -1 +0,0 @@
-<%= class_name %> Usage

data/lib/tap/generator/generators/root/templates/tap.yml

@@ -1,80 +0,0 @@
-######################################################
-# App Configurations:
-#
-# These are configurations that directly affect the application, 
-# including the directory structure options, and logging.
-#
-######################################################
-  
-# You can set an alternate root, but this is 
-# an odd and perhaps unwise thing to do
-#root:                         
-
-# Specify aliases for directories relative to root.  
-#directories:                  
-  #lib: path/to/lib 
-  #lib/generators: path/to/lib/generators              
-  #...
-  
-# Specify aliases for absolute paths
-#absolute_paths:                  
-  #log: /path/to/logs      
-  #...
-
-# Specify options
-#options:                      
-  #debug: true                   # full error output, increased logging
-  #quiet: true                   # supresses logging
-  #...                           # you can add your own options
-  
-# Specify logging options
-#logger:
-  #device:                       # STDOUT by default
-  #level: 1                      # [DEBUG, INFO, WARN, ERROR, FATAL, ANY]
-  #datetime_format: %H:%M:%S      # Hour:Minute:Second
-
-# Map task names to task classes here.  The example causes
-# app.task('some/task_name') to intialize a Tap::FileTask 
-# with that name.  Any number of mappings can be specified.
-#map:
-#  some/task_name: Tap::FileTask
-#  CapsAreOk: Tap::Task
-
-######################################################
-# Environment Configurations:
-#
-# These are configurations that affect the execution environment 
-# for Tap and are NOT passed to the application itself.
-#
-# All paths are resolved to the directories setup above.
-#
-######################################################
-
-# Designate load paths here for automatic loading of modules
-# through the active_support Dependencies module.  
-# load_paths are also added to $LOAD_PATH.  
-#load_paths: 
-#  - lib
-
-# Specifies load_once_paths for Dependencies.
-#load_once_paths:
-
-# Designate paths for discovering and executing commands.  
-#command_paths:
-#  - cmd
-
-# Designate paths for discovering generators.  
-#generator_paths:
-#  - lib/generators
-
-# Specify gems to add to the environment.  Versions may be specified.
-#gems: 
-#  - gem_name
-#  - gem_with_version > 1.0.0
-
-# Specify code to execute before and after Tap executes
-#before: |
-#  puts "beginning..."
-#  Tap::Env.instance.discover_gems
-#after: |
-#  puts "done!"

data/lib/tap/generator/generators/task/USAGE

@@ -1,3 +0,0 @@
-Description:
-    Generates a new Task and test files.  Pass the task name, 
-    either CamelCased or under_scored.

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

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

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

@@ -1,7 +0,0 @@
-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

@@ -1,6 +0,0 @@
-require 'tap/generator/generators/task/task_generator'
-
-module Tap::Generator::Generators
-  class WorkflowGenerator < TaskGenerator # :nodoc:
-  end
-end

data/lib/tap/generator/options.rb

@@ -1,26 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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/support/batchable_methods.rb

@@ -1,34 +0,0 @@
-module Tap
-  module Support
-    
-    # BatchableMethods encapsulates class methods related to Batchable.
-    module BatchableMethods
-      
-      # Merges the batches for the specified objects.  All objects 
-      # sharing the individual object batches will be affected, even 
-      # if they are not listed explicitly as an input.
-      #
-      #  t1 = Tap::Task.new
-      #  t2 = Tap::Task.new
-      #  t3 = t2.initialize_batch_obj
-      #
-      #  Batchable.batch(t1, t2)
-      #  t3.batch                    # => [t1,t2,t3]
-      #
-      # Returns the new batch.
-      def batch(*batchables)
-        merged = []
-        batches = batchables.collect {|batchable| batchable.batch }.uniq
-        batches.each do |batch| 
-           merged.concat(batch)
-           batch.clear
-         end
-        merged.uniq!
-        batches.each {|batch| batch.concat(merged) }
-        merged
-      end
-      
-    end
-    
-  end
-end

data/lib/tap/support/command_line_methods.rb

@@ -1,76 +0,0 @@
-module Tap
-  module Support
-    autoload(:TDoc, 'tap/support/tdoc')
-    autoload(:CommandLine, 'tap/support/command_line')
-    
-    # Under Construction
-    module CommandLineMethods
-      
-      # Returns the TDoc documentation for self. 
-      def tdoc
-        @tdoc ||= Tap::Support::TDoc[self]
-      end
-
-      # EXPERIMENTAL
-      def help(opts=configurations.to_opts) 
-        return "could not find help for '#{self}'" if tdoc == nil
-
-        sections = tdoc.comment_sections(/Description|Usage/i, true)
-        %Q{#{self}
-#{sections["Description"]}
-Usage:
-#{sections["Usage"]}
-Options:
-#{Tap::Support::CommandLine.usage_options(opts)}
-
-}
-      end
-
-      # EXPERIMENTAL
-      def argv_enq(app=App.instance, &block) 
-        if block_given?
-          @argv_enq_block = block
-          return
-        end
-        return @argv_enq_block.call(app) if @argv_enq_block ||= nil
-
-        config = {}
-        opts = configurations.to_opts
-        opts << ['--help', nil, GetoptLong::NO_ARGUMENT, "Print this help."]
-        opts << ['--debug', nil, GetoptLong::NO_ARGUMENT, "Trace execution and debug"]
-        opts << ['--use', nil, GetoptLong::REQUIRED_ARGUMENT, "Loads inputs from file."]
-        opts << ['--iterate', nil, GetoptLong::NO_ARGUMENT, "Iterates over inputs."]
-
-        iterate = false
-        Tap::Support::CommandLine.handle_options(*opts) do |opt, value|
-          case opt
-          when '--help'
-            puts help(opts)
-            exit
-
-          when '--debug'
-            app.options.debug = true
-
-          when '--use'
-            hash = YAML.load_file(value)
-            hash.values.each do |args| 
-              ARGV.concat(args)
-            end
-
-          when '--iterate'
-            iterate = true
-
-          else
-            key = configurations.opt_map(opt)
-            config[key] = YAML.load(value)
-          end
-        end
-
-        # instantiate and configure task
-        task = new(ARGV.shift, config, app)
-        iterate ? ARGV.each {|input| task.enq(input) } : task.enq(*ARGV)
-      end
-    end
-    
-  end
-end

data/lib/tap/support/configurable_methods.rb

@@ -1,224 +0,0 @@
-module Tap
-  module Support
-    
-    # ConfigurableMethods encapsulates all class methods used to declare
-    # configurations in Tasks.  ConfigurableMethods extends classes that
-    # include Tap::Support::Configurable.
-    #
-    #   class ConfigurableClass
-    #     include Configurable
-    # 
-    #     config :one, 'one'
-    #     config :two, 'two'
-    #     config :three, 'three'
-    #   end
-    #
-    #   ConfigurableClass.new.config  # => {:one => 'one', :two => 'two', :three => 'three'}
-    #
-    # See the 'Configuration' section in the Tap::Task documentation for
-    # more details on how Configurable works in practice.
-    module ConfigurableMethods
-      
-      # A Tap::Support::ClassConfiguration holding the class configurations.
-      attr_reader :configurations
-      
-      # When subclassed, the configurations are duplicated and passed to 
-      # the child class where they can be extended/modified without affecting
-      # the configurations of the parent class.
-      def inherited(child)
-        super
-        child.instance_variable_set(:@configurations, ClassConfiguration.new(child, @configurations))
-        child.instance_variable_set(:@source_files, source_files.dup)
-      end
-      
-      # EXPERIMENTAL
-      attr_reader :source_files # :nodoc:
-      
-      # EXPERIMENTAL
-      # Identifies source files for TDoc documentation.
-      def source_file(arg) # :nodoc:
-        source_files << arg
-      end
-
-      # Declares a configuration without any accessors.
-      #
-      # With no keys specified, sets config to make no  
-      # accessors for each new configuration.
-      def declare_config(*keys)
-        if keys.empty?
-          self.config_mode = :none 
-        else 
-          keys.each {|key| configurations.add(key)}
-        end
-      end
-
-      # Creates a configuration writer for the input keys.  Works like
-      # attr_writer, except the value is written to config, rather than
-      # a local variable.  In addition, the config will be validated
-      # using validate_config upon setting the value.
-      #
-      # With no keys specified, sets config to create config_writer 
-      # for each new configuration.
-      def config_writer(*keys)
-        if keys.empty?
-          self.config_mode = :config_writer 
-        else 
-          keys.each do |key|
-            configurations.add(key)
-            define_config_writer(key)
-          end
-        end
-      end
-
-      # Creates a configuration reader for the input keys.  Works like
-      # attr_reader, except the value is read from config, rather than
-      # a local variable.
-      #
-      # With no keys specified, sets config to create a config_reader 
-      # for each new configuration.
-      def config_reader(*keys)
-        if keys.empty?
-          self.config_mode = :config_reader 
-        else 
-          keys.each do |key|
-            configurations.add(key)
-            define_config_reader(key)
-          end
-        end
-      end
-
-      # Creates configuration accessors for the input keys.  Works like
-      # attr_accessor, except the value is read from and written to config, 
-      # rather than a local variable.
-      #
-      # With no keys specified, sets config to create a config_accessor 
-      # for each new configuration.
-      def config_accessor(*keys)
-        if keys.empty?
-          self.config_mode = :config_accessor 
-        else 
-          keys.each do |key|
-            configurations.add(key)
-            define_config_reader(key)
-            define_config_writer(key)
-          end
-        end
-      end
-
-      # Sets a class configuration.  Configurations are inherited, but can 
-      # be overridden or added in subclasses. Accessors are created by 
-      # default, but this behavior can be modified by use of the other
-      # config methods.  
-      #
-      #   class SampleClass
-      #     include Configurable
-      #
-      #     config :key, 'value'
-      #     config_reader
-      #     config :reader_only
-      #   end
-      #
-      #   t = SampleClass.new
-      #   t.respond_to?(:reader_only)         # => true
-      #   t.respond_to?(:reader_only=)        # => false
-      #
-      #   t.config               # => {:key => 'value', :reader_only => nil} 
-      #   t.key                  # => 'value'
-      #   t.key = 'another'
-      #   t.config               # => {:key => 'another', :reader_only => nil}
-      #
-      # A block can be specified for validation/pre-processing.  All inputs
-      # set through the config accessors, as well as the instance config= 
-      # method are processed by the block before they set the value in the
-      # config hash.  The config value will be set to the return of the block.
-      #
-      # The Tap::Support::Validation module provides methods to perform 
-      # common checks and transformations.  These can be accessed through 
-      # the class method 'c':
-      #
-      #   class ValidatingClass
-      #     include Configurable
-      # 
-      #     config :one, 'one', &c.check(String)
-      #     config :two, 'two' do |v| 
-      #       v.upcase
-      #     end
-      #   end
-      #
-      #   t = ValidatingClass.new
-      #   
-      #   # note the default values ARE processed
-      #   t.config                  # => {:one => 'one', :two => 'TWO'}
-      #   t.one = 1                 # => ValidationError
-      #   t.config = {:one => 1}    # => ValidationError
-      #
-      #   t.config = {:one => 'str', :two => 'str'}
-      #   t.config                  # => {:one => 'str', :two => 'STR'}
-      #   
-      def config(key, value=nil, &validation)
-        configurations.add(key, value, &validation)
-
-        case config_mode
-        when :config_accessor
-          define_config_writer(key)
-          define_config_reader(key)
-        when :config_writer
-          define_config_writer(key)
-        when :config_reader
-          define_config_reader(key)
-        end
-      end
-      
-      def config_merge(klass)
-        configurations.merge(klass.configurations) do |key|
-          case config_mode
-          when :config_accessor
-            define_config_writer(key)
-            define_config_reader(key)
-          when :config_writer
-            define_config_writer(key)
-          when :config_reader
-            define_config_reader(key)
-          end
-        end
-      end
-      
-      # Returns the default name for the class: class.to_s.underscore
-      def default_name
-        @default_name ||= to_s.underscore
-      end
-      
-      protected
-
-      attr_writer :config_mode
-
-      # Tracks the current configuration mode, to determine what
-      # in any accessors should be generated for the configuration.
-      # (default :config_accessor)
-      def config_mode
-        @config_mode ||= :config_accessor
-      end
-      
-      # Alias for Tap::Support::Validation
-      def c
-        Validation
-      end
-
-      private
-
-      def define_config_reader(name, key=name) # :nodoc:
-        key = key.to_sym
-        define_method(name) do
-          config[key]
-        end
-      end
-
-      def define_config_writer(name, key=name) # :nodoc:
-        key = key.to_sym
-        define_method("#{name}=") do |value|
-          set_config(key, value)
-        end
-      end
-    end
-  end
-end