tap 0.18.0 → 0.19.0

data/lib/tap/signals/help.rb

@@ -0,0 +1,40 @@
+require 'tap/signals'
+
+module Tap
+  module Signals
+    class Help < Signal
+      
+      def call(args)
+        argv = convert_to_array(args, ['sig'])
+        argv.empty? ? list : desc(*argv)
+      end
+      
+      def list
+        signals = obj.class.signals
+        width = signals.keys.collect {|key| key.length }.max
+        
+        lines = []
+        signals.each_pair do |key, signal|
+          next if key.empty?
+          
+          desc = signal.desc.to_s
+          desc = " # #{desc}" unless desc.empty?
+          lines << "  /#{key.ljust(width)}#{desc}"
+        end
+        
+        "signals: (#{obj.class})\n#{lines.join("\n")}"
+      end
+      
+      def desc(sig)
+        clas = obj.signal(sig).class
+        
+        if clas.respond_to?(:desc)
+          desc = clas.desc
+          "#{clas} -- #{desc.to_s}\n#{desc.wrap}"
+        else
+          "#{clas} -- no help available"
+        end
+      end
+    end
+  end
+end

data/lib/tap/signals/module_methods.rb

@@ -0,0 +1,20 @@
+require 'tap/signals/class_methods'
+
+module Tap
+  module Signals
+    module ModuleMethods
+      module_function
+    
+      # Extends including classes with Configurable::ClassMethods
+      def included(base)
+        base.extend ClassMethods
+        base.extend ModuleMethods unless base.kind_of?(Class)
+
+        # initialize any class variables
+        ClassMethods.initialize(base)
+      end
+    end
+  
+    extend ModuleMethods
+  end
+end

data/lib/tap/signals/signal.rb

@@ -0,0 +1,68 @@
+module Tap
+  module Signals
+    
+    # Signal attaches an object and allows a specific method to be triggered
+    # through a standard interface.
+    class Signal
+      class << self
+        # A description of self
+        attr_accessor :desc
+      end
+      
+      # The object receiving signals through self.
+      attr_reader :obj
+      
+      attr_reader :block
+      
+      def initialize(obj, &block)
+        @obj = obj
+        @block = block
+      end
+      
+      # Calls process with the input args and returns the result.  This method
+      # is a hook for subclasses.
+      def call(args)
+        process(args)
+      end
+      
+      # Simply returns the input args.  This method is a hook for subclasses.
+      def process(args)
+        args
+      end
+      
+      protected
+      
+      def convert_to_array(obj, signature=[], options=false)
+        return obj if obj.kind_of?(Array)
+        
+        argv = signature.collect {|key| obj[key] }
+        
+        if options
+          opts = {}
+          (obj.keys - signature).each do |key|
+            opts[key] = obj[key]
+          end
+          
+          argv << opts
+        end
+        
+        argv
+      end
+      
+      def convert_to_hash(obj, signature=[], remainder=nil)
+        return obj if obj.kind_of?(Hash)
+        
+        args, argh = obj, {}
+        signature.each do |key|
+          argh[key] = args.shift
+        end
+        
+        if remainder
+          argh[remainder] = args
+        end
+        
+        argh
+      end
+    end
+  end
+end

data/lib/tap/task.rb

@@ -1,6 +1,5 @@
 require 'tap/joins'
 require 'tap/root'
-require 'tap/env/string_ext'
 
 module Tap
   class App
@@ -121,48 +120,16 @@ module Tap
   #     end
   #   end
   #
-  class Task
+  class Task < App::Api
     include App::Node
-    include Configurable
     
     class << self
-      def inherited(child) # :nodoc:
-        unless child.instance_variable_defined?(:@source_file)
-          caller[0] =~ Lazydoc::CALLER_REGEXP
-          child.instance_variable_set(:@source_file, File.expand_path($1)) 
-        end
-        super
-      end
-      
-      # Parses the argv into an instance of self.  By default parse 
-      # parses an argh then calls instantiate, but there is no requirement
-      # that this occurs in subclasses.
-      #
-      # ==== Block Overrides
-      #
-      # For convenience, parse will yield the internal ConfigParser to the
-      # block, if given.  This functionality was added to Task so they are
-      # more flexible in executable files but it is not a part of the API
-      # requirements for parse/parse!.
-      #
-      def parse(argv=ARGV, app=Tap::App.instance, &block) # :yields: opts
-        parse!(argv.dup, app, &block)
-      end
       
-      # Same as parse, but removes arguments destructively.
-      def parse!(argv=ARGV, app=Tap::App.instance) # :yields: opts
-        opts = ConfigParser.new
-        
-        unless configurations.empty?
-          opts.separator "configurations:"
-          opts.add(configurations)
-          opts.separator ""
-        end
-        
-        opts.separator "options:"
+      def parser
+        opts = super
         
         # add option to print help
-        opts.on("--help", "Print this help") do
+        opts.on!("--help", "Print this help") do
           lines = desc.kind_of?(Lazydoc::Comment) ? desc.wrap(77, 2, nil) : []
           lines.collect! {|line| "  #{line}"}
           unless lines.empty?
@@ -172,30 +139,37 @@ module Tap
           end
 
           puts "#{self}#{desc.empty? ? '' : ' -- '}#{desc.to_s}"
-          puts lines.join("\n")
+          puts help
           puts "usage: tap run -- #{to_s.underscore} #{args}"
           puts          
           puts opts
           exit
         end
         
+        opts.on('--enque', 'Manually enques self') do
+          opts['enque'] = true
+        end
+        
         # add option to specify a config file
         opts.on('--config FILE', 'Specifies a config file') do |config_file|
           opts.config.merge!(load_config(config_file))
         end
         
-        yield(opts) if block_given?
+        opts
+      end
+      
+      # Same as parse, but removes arguments destructively.
+      def parse!(argv=ARGV, app=Tap::App.instance)
+        parser = self.parser
         
         # (note defaults are not added so they will not
         # conflict with string keys from a config file)
-        argv = opts.parse!(argv, :add_defaults => false)
+        argv = parser.parse!(argv, :add_defaults => false)
+        enque = parser.config.delete('enque')
+        instance = build({'config' => parser.nested_config}, app)
         
-        instantiate({:config => opts.nested_config}, app)
-      end
-      
-      # Instantiates an instance of self and returns an instance of self.
-      def instantiate(argh={}, app=Tap::App.instance)
-        new(argh[:config] || {}, app)
+        instance.enq(*argv) if enque
+        [instance, argv]
       end
       
       # Recursively loads path into a nested configuration file.
@@ -301,37 +275,19 @@ module Tap
       end
     end
     
-    instance_variable_set(:@source_file, __FILE__)
-    
-    lazy_attr :desc, 'task'
     lazy_attr :args, :process
     lazy_register :process, Lazydoc::Arguments
     
-    ###############################################################
-    # [depreciated] manifest will be removed at 1.0
-    lazy_attr :manifest
-    def self.desc(resolve=true)
-      comment = const_attrs['task'] ||= self.manifest
-      resolve && comment.kind_of?(Lazydoc::Comment) ? comment.resolve : comment
-    end
-    def self.manifest
-      # :::-
-      #"warn manifest is depreciated, use ::task instead"
-      # :::+
-      const_attrs['manifest'] ||= Lazydoc::Subject.new(nil, lazydoc)
-    end
-    ###############################################################
+    signal :enq
     
-    # The App receiving self during enq
-    attr_reader :app
-
     # Initializes a new Task.
     def initialize(config={}, app=Tap::App.instance)
-      @app = app
       @joins = []
-      
-      # initialize configs
-      initialize_config(config)
+      super
+    end
+    
+    def associations
+      [nil, joins]
     end
     
     # Auditing method call.  Resolves dependencies, executes method_name,
@@ -425,8 +381,8 @@ module Tap
     end
     
     # Logs the inputs to the application logger (via app.log)
-    def log(action, msg="", level=Logger::INFO)
-      app.log(action, msg, level)
+    def log(action, msg=nil, level=Logger::INFO)
+      app.log(action, msg, level) { yield }
     end
     
     # Provides an abbreviated version of the default inspect, with only
@@ -434,12 +390,5 @@ module Tap
     def inspect
       "#<#{self.class.to_s}:#{object_id} #{config.to_hash.inspect} >"
     end
-    
-    def to_hash
-      {
-        :class => self.class,
-        :config => config.to_hash
-      }
-    end
   end
 end

data/lib/tap/tasks/dump.rb

@@ -53,6 +53,12 @@ module Tap
       def dump(input, io)
         io.puts input.to_s
       end
+      
+      def to_spec
+        spec = super
+        spec['config'].delete('output') if output == $stdout
+        spec
+      end
     end
   end
 end

data/lib/tap/tasks/load.rb

@@ -30,26 +30,6 @@ module Tap
     #     end
     #   end
     #
-    # Load subclasses may be constructed to reque itself in cases where objects
-    # are sequentially loaded from the same io.  Load will reque until the
-    # complete? method returns true.  An example is a prompt task:
-    #
-    #   class Prompt < Tap::Tasks::Load
-    #     config :exit_seq, "\n"
-    #
-    #     def load(io)
-    #       if io.eof?
-    #         nil
-    #       else
-    #         io.readline
-    #       end
-    #     end
-    #
-    #     def complete?(io, line)
-    #       line == nil || line == exit_seq
-    #     end
-    #   end
-    #
     # If the use_close configuration is specified, load will close io upon
     # completion.  Files opened by load are always closed upon completion.
     #
@@ -59,20 +39,14 @@ module Tap
       config :use_close, false, :long => :close, &c.flag   # Close the input when complete
       
       # Loads data from io.  Process will open the input io object, load
-      # a result, then check to see if the loading is complete (using the
-      # complete? method).  Unless loading is complete, process will enque
-      # io to self.  Process will close io when loading is complete, provided
+      # a result.  Process will close io when loading is complete, provided
       # use_close or file is specified.
       def process(io=$stdin)
         io = open(io)
         result = load(io)
         
-        if complete?(io, result)
-          if use_close || file
-            close(io)
-          end
-        else
-          enq(io)
+        if use_close || file
+          close(io)
         end
         
         result
@@ -80,13 +54,12 @@ module Tap
       
       # Opens the io; specifically this means:
       #
-      # * Opening a File (file true)
       # * Creating a StringIO for String inputs
       # * Opening an IO for integer file descriptors
       # * Returning all other objects
       #
       def open(io)
-        return(io.kind_of?(File) ? io : File.open(io)) if file
+        return open_file(io) if file
         
         case io
         when String
@@ -98,6 +71,11 @@ module Tap
         end
       end
       
+      # Opens io as a File.
+      def open_file(io)
+        io.kind_of?(File) ? io : File.open(io)
+      end
+      
       # Loads data from io using io.read.  Load is intended as a hook
       # for subclasses.
       def load(io)
@@ -108,12 +86,6 @@ module Tap
       def close(io)
         io.close
       end
-      
-      # Returns true by default.  Override in subclasses to allow recurrent 
-      # loading (see process).
-      def complete?(io, last)
-        true
-      end
     end
   end
 end

data/lib/tap/templater.rb

@@ -116,13 +116,24 @@ module Tap
         
         nest(nesting, indent, line_sep) { yield }
       end
+      
+      def indent(indent, str)
+        lines = str.kind_of?(Array) ? str : str.split("\n")
+        lines.collect! {|line| "#{indent}#{line}" }
+        lines.join("\n")
+      end
     end
     
     class << self
       
       # Builds the erb template with the specified attributes.
       def build(template,  attributes={}, filename=nil)
-        new(template, attributes, filename).build
+        new(template).build(attributes, filename)
+      end
+      
+      # Builds the erb template file with the specified attributes.
+      def build_file(path, attributes={})
+        self.build(File.read(path), attributes, path)
       end
     end
     

data/lib/tap/version.rb

@@ -1,6 +1,6 @@
 module Tap
   MAJOR = 0
-  MINOR = 18
+  MINOR = 19
   TINY = 0
   
   VERSION="#{MAJOR}.#{MINOR}.#{TINY}" 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tap
 version: !ruby/object:Gem::Version 
-  version: 0.18.0
+  version: 0.19.0
 platform: ruby
 authors: 
 - Simon Chiang
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-17 00:00:00 -06:00
+date: 2009-12-05 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.5.0
+        version: 0.6.0
     version: 
 description: 
 email: simon.a.chiang@gmail.com
@@ -33,7 +33,6 @@ extra_rdoc_files:
 - MIT-LICENSE
 - History
 - doc/API
-- doc/Class Reference
 - doc/Examples/Command Line
 - doc/Examples/Workflow
 files: 
@@ -42,43 +41,50 @@ files:
 - cmd/run.rb
 - lib/tap.rb
 - lib/tap/app.rb
+- lib/tap/app/api.rb
 - lib/tap/app/node.rb
 - lib/tap/app/queue.rb
 - lib/tap/app/stack.rb
 - lib/tap/app/state.rb
-- lib/tap/version.rb
-- lib/tap/tasks/dump.rb
 - lib/tap/env.rb
 - lib/tap/env/constant.rb
+- lib/tap/env/context.rb
 - lib/tap/env/gems.rb
 - lib/tap/env/manifest.rb
 - lib/tap/env/minimap.rb
 - lib/tap/env/string_ext.rb
-- lib/tap/exe.rb
+- lib/tap/intern.rb
 - lib/tap/join.rb
 - lib/tap/joins.rb
 - lib/tap/joins/switch.rb
 - lib/tap/joins/sync.rb
 - lib/tap/middleware.rb
-- lib/tap/tasks/load.rb
+- lib/tap/middlewares/debugger.rb
+- lib/tap/parser.rb
+- lib/tap/prompt.rb
 - lib/tap/root.rb
 - lib/tap/root/utils.rb
 - lib/tap/root/versions.rb
-- lib/tap/schema.rb
-- lib/tap/schema/parser.rb
-- lib/tap/schema/utils.rb
-- lib/tap/intern.rb
-- lib/tap/templater.rb
+- lib/tap/signals.rb
+- lib/tap/signals/class_methods.rb
+- lib/tap/signals/help.rb
+- lib/tap/signals/module_methods.rb
+- lib/tap/signals/signal.rb
 - lib/tap/task.rb
+- lib/tap/tasks/dump.rb
+- lib/tap/tasks/load.rb
+- lib/tap/templater.rb
+- lib/tap/version.rb
 - README
 - MIT-LICENSE
 - History
 - doc/API
-- doc/Class Reference
 - doc/Examples/Command Line
 - doc/Examples/Workflow
 has_rdoc: true
 homepage: http://tap.rubyforge.org
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --main
@@ -104,9 +110,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: tap
-rubygems_version: 1.3.1
+rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: A configurable, distributable workflow framework.
 test_files: []