tap 0.19.0 → 1.3.0

data/lib/tap/tasks/singleton.rb

@@ -0,0 +1,35 @@
+require 'tap/task'
+
+module Tap
+  module Tasks
+    class Singleton < Tap::Task
+      class << self
+        def cache
+          @cache ||= {}
+        end
+        
+        def new(*args)
+          obj = super
+          cache[obj.signature] ||= obj
+        end
+      end
+      
+      attr_reader :cache
+      attr_reader :signature
+      
+      def initialize(config={}, app=Tap::App.current)
+        @signature = [config.dup, app].freeze
+        super(config, app)
+        reset
+      end
+      
+      def call(input)
+        cache.has_key?(input) ? cache[input] : cache[input] = super
+      end
+      
+      def reset
+        @cache = {}
+      end
+    end
+  end
+end

data/lib/tap/tasks/stream.rb

@@ -0,0 +1,64 @@
+require 'tap/tasks/load'
+
+module Tap
+  module Tasks
+    
+    # Stream recurrently loads data from $stdin by requeing self until an
+    # end-of-file is reached.  This behavior is useful for creating tasks
+    # that load a bit of data from an IO, send it into a workflow, and then
+    # repeat.
+    #
+    # The eof cutoff can be modified using complete? method.  Streaming will
+    # stop when complete? returns true.  For instance, this is a prompt task:
+    #
+    #   class Prompt < Tap::Tasks::Stream
+    #     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
+    #
+    class Stream < Load
+      
+      # 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
+      # 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
+          reque(io)
+        end
+        
+        result
+      end
+      
+      # Returns true by default.  Override in subclasses to allow recurrent 
+      # loading (see process).
+      def complete?(io, last)
+        io.eof?
+      end
+      
+      # Reques self with io to the top of the queue.
+      def reque(io)
+        app.pq(self, [io])
+      end
+    end
+  end
+end

data/lib/tap/utils.rb

@@ -0,0 +1,83 @@
+require 'tempfile'
+
+module Tap
+  
+  #
+  # == Windows 
+  # MSDOS has command line length limits specific to the version of Windows being
+  # run (from http://www.ss64.com/nt/cmd.html):
+  #
+  # Windows NT:: 256 characters
+  # Windows 2000::  2046 characters
+  # Windows XP:: 8190 characters
+  #
+  # Commands longer than these limits fail, usually with something like: 'the input
+  # line is too long'
+  module Utils
+    module_function
+    
+    def shellsplit(line, comment="#")
+      words = []
+      field = ''
+      line.scan(/\G\s*(?>([^\s\\\'\"]+)|'([^\']*)'|"((?:[^\"\\]|\\.)*)"|(\\.?)|(\S))(\s|\z)?/m) do
+        |word, sq, dq, esc, garbage, sep|
+        raise ArgumentError, "Unmatched double quote: #{line.inspect}" if garbage
+        break if word == comment
+        field << (word || sq || (dq || esc).gsub(/\\(?=.)/, ''))
+        if sep
+          words << field
+          field = ''
+        end
+      end
+      words
+    end
+    
+    # Sets the specified ENV variables and returns the *current* env.
+    # If replace is true, current ENV variables are replaced; otherwise
+    # the new env variables are simply added to the existing set.
+    def set_env(env={}, replace=false)
+      current_env = {}
+      ENV.each_pair do |key, value|
+        current_env[key] = value
+      end
+      
+      ENV.clear if replace
+      
+      env.each_pair do |key, value|
+        if value.nil?
+          ENV.delete(key)
+        else
+          ENV[key] = value
+        end
+      end if env
+      
+      current_env
+    end
+    
+    # Sets the specified ENV variables for the duration of the block.
+    # If replace is true, current ENV variables are replaced; otherwise
+    # the new env variables are simply added to the existing set.
+    #
+    # Returns the block return.
+    def with_env(env={}, replace=false)
+      current_env = nil
+      begin
+        current_env = set_env(env, replace)
+        yield
+      ensure
+        if current_env
+          set_env(current_env, true)
+        end
+      end
+    end
+    
+    def sh_escape(str)
+      str.to_s.gsub("'", "\\\\'").gsub(";", '\\;')
+    end
+    
+    # Run the command with system and raise an error if it fails.
+    def sh(*cmd)
+      system(*cmd) or raise "Command failed with status (#{$?.exitstatus}): [#{cmd.join(' ')}]"
+    end
+  end
+end

data/lib/tap/version.rb

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

data/lib/tap/workflow.rb

@@ -0,0 +1,124 @@
+require 'tap/task'
+
+module Tap
+  class Workflow < Task
+    class << self
+      protected
+      
+      # Defines a task subclass with the specified configurations and process
+      # block. During initialization the subclass is instantiated and made
+      # accessible through the name method.  
+      #
+      # Defined tasks may be configured during through config, or directly
+      # through the instance; in effect you get tasks with nested configs which
+      # can greatly facilitate workflows.
+      #
+      #   class AddALetter < Tap::Task
+      #     config :letter, 'a'
+      #     def process(input); input << letter; end
+      #   end
+      #
+      #   class AlphabetSoup < Tap::Task
+      #     define :a, AddALetter, {:letter => 'a'}
+      #     define :b, AddALetter, {:letter => 'b'}
+      #     define :c, AddALetter, {:letter => 'c'}
+      #
+      #     def process
+      #       sequence(a, b, c)
+      #       [a, c]
+      #     end
+      #   end
+      #
+      #   AlphabetSoup.new.process            # => 'abc'
+      #
+      #   i = AlphabetSoup.new(:a => {:letter => 'x'}, :b => {:letter => 'y'}, :c => {:letter => 'z'})
+      #   i.process                           # => 'xyz'
+      #
+      #   i.config[:a] = {:letter => 'p'}
+      #   i.config[:b][:letter] = 'q'
+      #   i.c.letter = 'r'
+      #   i.process                           # => 'pqr'
+      #
+      # ==== Usage
+      #
+      # Define is basically the equivalent of:
+      #
+      #   class Sample < Tap::Task
+      #     Name = baseclass.subclass(config, &block)
+      #     
+      #     # accesses an instance of Name
+      #     attr_reader :name
+      #
+      #     # register name as a config, but with a
+      #     # non-standard reader and writer
+      #     config :name, {}, {:reader => :name_config, :writer => :name_config=}.merge(options)
+      #
+      #     # reader for name.config
+      #     def name_config; ...; end
+      #
+      #     # reconfigures name with input
+      #     def name_config=(input); ...; end
+      #
+      #     def initialize(*args)
+      #       super
+      #       @name = Name.new(config[:name])
+      #     end
+      #   end
+      #
+      # Note the following:
+      # * define will set a constant like name.camelize
+      # * the block defines the process method in the subclass
+      # * three methods are created by define: name, name_config, name_config=
+      #
+      def define(name, baseclass=Tap::Task, configs={}, options={}, &block)
+        # define the subclass
+        subclass = Class.new(baseclass)
+        configs.each_pair do |key, value|
+          subclass.send(:config, key, value)
+        end
+
+        if block_given?
+          # prevent lazydoc registration of the process method
+          subclass.registered_methods.delete(:process)
+          subclass.send(:define_method, :process, &block)
+        end
+
+        # register documentation
+        # TODO: register subclass in documentation
+        options[:desc] ||= Lazydoc.register_caller(Lazydoc::Trailer, 1)
+
+        # add the configuration
+        nest(name, subclass, {:const_name => name.to_s.camelize}.merge!(options))
+      end
+    end
+    
+    attr_reader :entry_point
+    attr_reader :exit_point
+    
+    def initialize(config={}, app=Tap::App.current)
+      super
+      @entry_point, @exit_point = process
+    end
+    
+    def call(input)
+      output = nil
+      
+      if exit_point
+        joins = exit_point.joins
+      
+        collector = lambda do |result|
+          output = result
+          joins.delete(collector)
+        end
+      
+        joins << collector 
+      end
+      
+      if entry_point
+        app.exe(entry_point, input)
+      end
+      
+      output
+    end
+  end
+end

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: tap
 version: !ruby/object:Gem::Version 
-  version: 0.19.0
+  prerelease: false
+  segments: 
+  - 1
+  - 3
+  - 0
+  version: 1.3.0
 platform: ruby
 authors: 
 - Simon Chiang
@@ -9,19 +14,37 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-05 00:00:00 -07:00
+date: 2010-05-02 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: configurable
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 7
+        - 0
+        version: 0.7.0
   type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: tap-test
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 6
+        - 0
         version: 0.6.0
-    version: 
+  type: :development
+  version_requirements: *id002
 description: 
 email: simon.a.chiang@gmail.com
 executables: 
@@ -33,54 +56,64 @@ extra_rdoc_files:
 - MIT-LICENSE
 - History
 - doc/API
+- doc/Workflow Syntax
+- doc/Ruby to Ruby
 - doc/Examples/Command Line
-- doc/Examples/Workflow
+- doc/Examples/Tapfile
+- doc/Configuration
 files: 
-- cmd/console.rb
-- cmd/manifest.rb
-- cmd/run.rb
+- bin/tapexe
 - 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/declarations.rb
+- lib/tap/declarations/context.rb
+- lib/tap/declarations/description.rb
 - lib/tap/env.rb
+- lib/tap/env/cache.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/path.rb
 - lib/tap/env/string_ext.rb
-- lib/tap/intern.rb
 - lib/tap/join.rb
-- lib/tap/joins.rb
+- lib/tap/joins/gate.rb
 - lib/tap/joins/switch.rb
 - lib/tap/joins/sync.rb
 - lib/tap/middleware.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/signal.rb
 - lib/tap/signals.rb
 - lib/tap/signals/class_methods.rb
+- lib/tap/signals/configure.rb
 - lib/tap/signals/help.rb
+- lib/tap/signals/load.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/tasks/list.rb
+- lib/tap/tasks/prompt.rb
+- lib/tap/tasks/singleton.rb
+- lib/tap/tasks/signal.rb
+- lib/tap/tasks/stream.rb
 - lib/tap/templater.rb
+- lib/tap/utils.rb
 - lib/tap/version.rb
+- lib/tap/workflow.rb
+- tap.yml
 - README
 - MIT-LICENSE
 - History
 - doc/API
+- doc/Workflow Syntax
+- doc/Ruby to Ruby
 - doc/Examples/Command Line
-- doc/Examples/Workflow
+- doc/Examples/Tapfile
+- doc/Configuration
 has_rdoc: true
 homepage: http://tap.rubyforge.org
 licenses: []
@@ -99,18 +132,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: tap
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: A configurable, distributable workflow framework.