tap-tasks 0.2.0 → 0.3.0

data/History

@@ -1,3 +1,11 @@
+== 0.3.0 / 2009-06-17
+
+* added load/dump csv tasks
+* updated glob task with include/exclude filters
+* updated load/yaml with stream loading
+* removed argv task
+* removed FileTask
+
 == 0.2.0 / 2009-05-25
 
 Updates for use with Tap-0.17.0

data/lib/tap/tasks/dump/csv.rb

@@ -0,0 +1,30 @@
+require 'tap/tasks/dump'
+require 'csv'
+
+module Tap
+  module Tasks
+    class Dump
+      
+      # :startdoc::task dumps data as csv
+      #
+      # Dumps arrays as CSV data.  Each array passed to dump will be formatted
+      # into a single line of csv, ie multiple dumps build the csv results.
+      # Non-array objects are converted to arrays using to_ary.
+      #
+      #   % tap run -- load/yaml ["a", "b", "c"] --: dump/csv
+      #   a,b,c
+      #
+      class Csv < Dump
+        
+        config :col_sep, ",", &c.string    # The column separator (",")
+        config :row_sep, "\n", &c.string   # The row separator ("\n")
+        
+        # Dumps the data to io as CSV.  Data is converted to an array using
+        # to_ary.
+        def dump(data, io)
+          io << CSV.generate_line(data.to_ary, col_sep) + row_sep
+        end
+      end
+    end
+  end
+end

data/lib/tap/tasks/dump/inspect.rb

@@ -2,7 +2,7 @@ require 'tap/tasks/dump'
 
 module Tap
   module Tasks
-    class Dump < Tap::Task
+    class Dump
       
       # :startdoc::task inspect and dump an object
       #

data/lib/tap/tasks/dump/yaml.rb

@@ -2,7 +2,7 @@ require 'tap/tasks/dump'
 
 module Tap
   module Tasks
-    class Dump < Tap::Task
+    class Dump
       
       # :startdoc::task dumps data as YAML
       #

data/lib/tap/tasks/glob.rb

@@ -9,23 +9,39 @@ module Tap
     #
     #   % tap run -- glob * --: dump/yaml
     #
+    # A variety of filters are available as configurations.
+    #
+    # == Glob Expansion
+    #
+    # NOTE that glob patterns are normally expanded on the command line,
+    # meaning the task will receive an array of files and not glob patterns.
+    # Usually this doesn't make a difference in the task results, but it can
+    # slow down launch times.
+    #
+    # To glob within the task and not the command line, quote the glob.
+    #
+    #   % tap run -- glob '*' --: dump/yaml
+    #
     class Glob < Tap::Task
       
-      config :filters, [], &c.list(&c.regexp)     # regexp filters for results
-      config :unique, true, &c.switch             # ensure results are unique
-      config :files, true, &c.switch              # glob for files
-      config :dirs, false, &c.switch              # glob for directories
+      config :includes, [/./], :long => :include, &c.list(&c.regexp)  # Regexp include filters
+      config :excludes, [], :long => :exclude, &c.list(&c.regexp)     # Regexp exclude filters
+      config :unique, true, &c.switch             # Ensure results are unique
+      config :files, true, &c.switch              # Glob for files
+      config :dirs, false, &c.switch              # Glob for directories
       
       def process(*patterns)
         results = []
         patterns.each do |pattern|
           Dir[pattern].each do |path|
-            next if !files && File.file?(path)
-            next if !dirs && File.directory?(path)
+            next if files == false && File.file?(path)
+            next if dirs == false  && File.directory?(path)
             
             case path
-            when *filters then next
-            else results << path
+            when *excludes
+              next
+            when *includes
+              results << path
             end
           end
         end

data/lib/tap/tasks/load/csv.rb

@@ -0,0 +1,48 @@
+require 'tap/tasks/load'
+require 'csv'
+
+module Tap
+  module Tasks
+    class Load
+      
+      # :startdoc::task reads csv data
+      #
+      # Load CSV data as an array of arrays, selecting the specified rows and
+      # columns.
+      # 
+      #   % tap run -- load/csv 'a,b,c.d,e,f' --row-sep '.' --: inspect
+      #   [["a", "b", "c"], ["d", "e", "f"]]
+      # 
+      # Note this task is quite inefficient in that it will load all data
+      # before making a selection; large files or edge selections may benefit
+      # from an alternate task.
+      #
+      class Csv < Load
+        
+        config :columns, nil, &c.range_or_nil   # Specify a range of columns
+        config :rows, nil, &c.range_or_nil      # Specify a range of rows
+        
+        config :col_sep, nil, &c.string_or_nil  # The column separator (",")
+        config :row_sep, nil, &c.string_or_nil  # The row separator ("\r\n" or "\n")
+        
+        # Loads the io data as CSV, into an array of arrays.
+        def load(io)
+          data = CSV.parse(io.read, col_sep, row_sep)
+          
+          if rows
+            data = data[rows]
+          end
+          
+          if columns
+            data.collect! do |cols|
+              cols[columns]
+            end
+          end
+          
+          data
+        end
+        
+      end 
+    end
+  end
+end

data/lib/tap/tasks/load/yaml.rb

@@ -2,7 +2,7 @@ require 'tap/tasks/load'
 
 module Tap
   module Tasks
-    class Load < Tap::Task
+    class Load
       
       # :startdoc::task loads data as YAML
       #
@@ -14,10 +14,37 @@ module Tap
       #
       class Yaml < Load
         
+        config :stream, false, &c.flag   # Load documents from a stream
+        
         # Loads data from io as YAML.
         def load(io)
-          YAML.load(io)
+          if stream
+            load_stream(io)
+          else
+            YAML.load(io)
+          end
+        end
+        
+        def load_stream(io)          
+          lines = []
+          while !io.eof?
+            line = io.readline
+
+            if line =~ /^---/ && !lines.empty?
+              io.pos = io.pos - line.length
+              break
+            else
+              lines << line
+            end
+          end
+
+          YAML.load(lines.join)
+        end
+        
+        def complete?(io, last)
+          !stream || io.eof?
         end
+        
       end
     end
   end

data/lib/tap/tasks/prompt.rb

@@ -0,0 +1,42 @@
+require 'tap/tasks/load'
+
+module Tap
+  module Tasks
+    # :startdoc::task an input prompt
+    #
+    # Prompt reads lines from the input until the exit sequence is reached
+    # or the source io is closed.  This is effectively an echo:
+    #
+    #   % tap run -- prompt --: dump
+    #   >
+    #
+    class Prompt < Load
+      config :prompt, "> ", &c.string_or_nil    # The prompt sequence
+      config :exit_seq, "\n", &c.string_or_nil  # The prompt exit sequence
+      config :terminal, $stdout, &c.io_or_nil   # The terminal IO
+      
+      configurations[:use_close].default = true
+      
+      def load(io)
+        open_io(terminal) do |terminal|
+          terminal.print prompt
+        end if prompt
+        
+        if io.eof?
+          nil
+        else
+          io.readline
+        end
+      end
+  
+      def complete?(io, line)
+        line == nil || line == exit_seq
+      end
+      
+      def close(io)
+        super
+        app.terminate
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tap-tasks
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Simon Chiang
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-25 00:00:00 -06:00
+date: 2009-06-17 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.17.0
+        version: 0.18.0
     version: 
 - !ruby/object:Gem::Dependency 
   name: tap-test
@@ -30,7 +30,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.1.0
+        version: 0.2.0
     version: 
 description: 
 email: simon.a.chiang@gmail.com
@@ -43,13 +43,13 @@ extra_rdoc_files:
 - README
 - MIT-LICENSE
 files: 
-- lib/tap/tasks/file_task/shell_utils.rb
-- lib/tap/tasks/argv.rb
+- lib/tap/tasks/dump/csv.rb
 - lib/tap/tasks/dump/inspect.rb
 - lib/tap/tasks/dump/yaml.rb
 - lib/tap/tasks/load/yaml.rb
+- lib/tap/tasks/load/csv.rb
 - lib/tap/tasks/glob.rb
-- lib/tap/tasks/file_task.rb
+- lib/tap/tasks/prompt.rb
 - tap.yml
 - History
 - README

data/lib/tap/tasks/argv.rb

@@ -1,30 +0,0 @@
-require 'tap/task'
-
-module Tap
-  module Tasks
-    # :startdoc::task provides a handle to ARGV
-    #
-    # Simply returns ARGV.  This task can be a useful hook when executing
-    # saved workflows via run (given that all arguments after the workflow
-    # file are preserved in ARGV).
-    #
-    #   # [workflow.yml]
-    #   # - - argv
-    #   # - - dump/yaml
-    #   # - 0[1]
-    #
-    #   % tap run -w workflow.yml a b c
-    #   ---
-    #   - a
-    #   - b
-    #   - c
-    #   
-    class Argv < Tap::Task
-      
-      # Simply returns ARGV.
-      def process
-        ARGV
-      end
-    end
-  end
-end

data/lib/tap/tasks/file_task.rb

@@ -1,383 +0,0 @@
-require 'tap/tasks/file_task/shell_utils'
-
-module Tap
-  module Tasks
-    # FileTask is a base class for tasks that work with a file system.  FileTask
-    # tracks changes it makes so they may be rolled back to their original state.
-    # Rollback automatically occurs on an execute error.
-    #
-    #   File.open("file.txt", "w") {|file| file << "original content"}
-    #  
-    #   t = FileTask.intern do |task, raise_error|
-    #     task.mkdir_p("some/dir")              # marked for rollback
-    #     task.prepare("file.txt") do |file|    # marked for rollback
-    #       file << "new content"
-    #     end
-    #
-    #     # raise an error to start rollback
-    #     raise "error!" if raise_error
-    #   end
-    #
-    #   begin
-    #     t.execute(true)
-    #   rescue
-    #     $!.message                            # => "error!"
-    #     File.exists?("some/dir")              # => false
-    #     File.read("file.txt")                 # => "original content"
-    #   end
-    #
-    #   t.execute(false)
-    #   File.exists?("some/dir")                # => true
-    #   File.read("file.txt")                   # => "new content"
-    #
-    class FileTask < Task
-      include ShellUtils
-      
-      # The backup directory
-      config_attr :backup_dir, 'backup'            # The backup directory
-    
-      # A flag indicating whether or track changes
-      # for rollback on execution error
-      config :rollback_on_error, true, &c.switch   # Rollback changes on error
-    
-      def initialize(config={}, app=Tap::App.instance)
-        super
-        @actions = []
-      end
-    
-      # Initializes a copy that will rollback independent of self.
-      def initialize_copy(orig)
-        super
-        @actions = []
-      end
-    
-      # Returns the path, exchanging the extension with extname.  
-      # A false or nil extname removes the extension, while true 
-      # preserves the existing extension (and effectively does
-      # nothing).
-      #
-      #   t = FileTask.new
-      #   t.basepath('path/to/file.txt')           # => 'path/to/file'
-      #   t.basepath('path/to/file.txt', '.html')  # => 'path/to/file.html'
-      #
-      #   t.basepath('path/to/file.txt', false)    # => 'path/to/file'
-      #   t.basepath('path/to/file.txt', true)     # => 'path/to/file.txt'
-      #
-      # Compare to basename.
-      def basepath(path, extname=false)
-        case extname
-        when false, nil then path.chomp(File.extname(path))
-        when true then path
-        else Root::Utils.exchange(path, extname)
-        end
-      end
-    
-      # Returns the basename of path, exchanging the extension 
-      # with extname.  A false or nil extname removes the
-      # extension, while true preserves the existing extension.
-      #
-      #   t = FileTask.new
-      #   t.basename('path/to/file.txt')           # => 'file.txt'
-      #   t.basename('path/to/file.txt', '.html')  # => 'file.html'
-      #
-      #   t.basename('path/to/file.txt', false)    # => 'file'
-      #   t.basename('path/to/file.txt', true)     # => 'file.txt'
-      #
-      # Compare to basepath.
-      def basename(path, extname=true)
-        basepath(File.basename(path), extname)
-      end
-    
-      # Constructs a filepath using the dir and the specified paths.
-      #
-      #   t = FileTask.new
-      #   t.filepath('data', "result.txt")      # => File.expand_path("data/tap/tasks/file_task/result.txt")
-      #
-      def filepath(dir, *paths)
-        File.expand_path(File.join(dir, *paths))
-      end
-    
-      # Makes a backup filepath relative to backup_dir by using name, the
-      # basename of filepath, and an index. 
-      #
-      #   t = FileTask.new({:backup_dir => "/backup"}, "name")
-      #   t.backup_filepath("path/to/file.txt", time)     # => "/backup/name/file.0.txt"
-      #   
-      def backup_filepath(path)
-        extname = File.extname(path)
-        backup_path = filepath(backup_dir, File.basename(path).chomp(extname))
-        next_indexed_path(backup_path, 0, extname)
-      end
-
-      # Returns true if all of the targets are up to date relative to all of the
-      # listed sources. Single values or arrays can be provided for both targets
-      # and sources.
-      #
-      # Returns false (ie 'not up to date') if app.force is true.
-      #
-      #--
-      # TODO: add check vs date reference (ex config_file date)
-      def uptodate?(targets, sources=[])
-        if app && app.force
-          log_basename(:force, targets)
-          false
-        else
-          targets = [targets] unless targets.kind_of?(Array)
-          sources = [sources] unless sources.kind_of?(Array)
-        
-          targets.each do |target|
-            return false unless FileUtils.uptodate?(target, sources)
-          end 
-          true
-        end
-      end
-    
-      # Makes a backup of path to backup_filepath(path) and returns the backup path.
-      # If backup_using_copy is true, the backup is a copy of path, otherwise the
-      # file or directory at path is moved to the backup path.  Raises an error if
-      # the backup path already exists.
-      #
-      # Backups are restored on rollback.
-      #
-      #   file = "file.txt"
-      #   File.open(file, "w") {|f| f << "file content"}
-      #
-      #   t = FileTask.new
-      #   backup_file = t.backup(file)
-      #       
-      #   File.exists?(file)                       # => false
-      #   File.exists?(backup_file)                # => true
-      #   File.read(backup_file)                   # => "file content"
-      #
-      #   File.open(file, "w") {|f| f << "new content"}
-      #   t.rollback
-      #
-      #   File.exists?(file)                       # => true
-      #   File.exists?(backup_file   )             # => false
-      #   File.read(file)                          # => "file content"
-      #
-      def backup(path, backup_using_copy=false)
-        return nil unless File.exists?(path)
-        
-        source = File.expand_path(path)
-        target = backup_filepath(source)
-        raise "backup already exists: #{target}" if File.exists?(target)
-      
-        mkdir_p File.dirname(target)
-      
-        log :backup, "#{source} to #{target}", Logger::DEBUG
-        if backup_using_copy
-          FileUtils.cp(source, target)
-        else
-          FileUtils.mv(source, target)
-        end
-      
-        actions << [:backup, source, target]
-        target
-      end
-    
-      # Creates a directory and all its parent directories. Directories created
-      # by mkdir_p removed on rollback.
-      def mkdir_p(dir)
-        dir = File.expand_path(dir)
-        
-        dirs = []
-        while !File.exists?(dir)
-          dirs.unshift(dir)
-          dir = File.dirname(dir)
-        end
-        
-        dirs.each {|d| mkdir(d) }
-      end
-    
-      # Creates a directory. Directories created by mkdir removed on rollback.
-      def mkdir(dir)
-        dir = File.expand_path(dir)
-      
-        unless File.exists?(dir)
-          log :mkdir, dir, Logger::DEBUG
-          FileUtils.mkdir(dir)
-          actions << [:make, dir]
-        end
-      end
-    
-      # Prepares the path by backing up any existing file and ensuring that
-      # the parent directory for path exists.  If a block is given, a file
-      # is opened and yielded to it (as in File.open).  Prepared paths are
-      # removed and the backups restored on rollback.
-      #
-      # Returns the expanded path.
-      def prepare(path, backup_using_copy=false) 
-        raise "not a file: #{path}" if File.directory?(path)
-        path = File.expand_path(path)
-
-        if File.exists?(path)
-         # backup or remove existing files
-          backup(path, backup_using_copy)
-        else
-          # ensure the parent directory exists
-          # for non-existant files 
-          mkdir_p File.dirname(path)
-        end
-        log :prepare, path, Logger::DEBUG
-        actions << [:make, path]
-      
-        if block_given?
-          File.open(path, "w") {|file| yield(file) }
-        end
-      
-        path
-      end
-    
-      # Removes a file.  If a directory is provided, it's contents are removed
-      # recursively.  Files and directories removed by rm_r are restored
-      # upon an execution error.
-      def rm_r(path) 
-        path = File.expand_path(path)
-      
-        backup(path, false)
-        log :rm_r, path, Logger::DEBUG
-      end
-    
-      # Removes an empty directory.  Directories removed by rmdir are restored
-      # upon an execution error.
-      def rmdir(dir)
-        dir = File.expand_path(dir)
-      
-        unless Root::Utils.empty?(dir)
-          raise "not an empty directory: #{dir}"
-        end
-      
-        backup(dir, false)
-        log :rmdir, dir, Logger::DEBUG
-      end
-    
-      # Removes a file.  Directories cannot be removed by this method.
-      # Files removed by rm are restored upon an execution error.
-      def rm(path) 
-        path = File.expand_path(path)
-      
-        unless File.file?(path)
-          raise "not a file: #{path}"
-        end
-      
-        backup(path, false)
-        log :rm, path, Logger::DEBUG
-      end
-    
-      # Copies source to target.  Files and directories copied by cp are
-      # restored upon an execution error.
-      def cp(source, target)
-        target = File.join(target, File.basename(source)) if File.directory?(target)
-        prepare(target)
-      
-        log :cp, "#{source} to #{target}", Logger::DEBUG
-        FileUtils.cp(source, target)
-      end
-    
-      # Copies source to target.  If source is a directory, the contents
-      # are copied recursively.  If target is a directory, copies source
-      # to target/source.  Files and directories copied by cp are restored
-      # upon an execution error.
-      def cp_r(source, target)
-        target = File.join(target, File.basename(source)) if File.directory?(target)
-        prepare(target)
-      
-        log :cp_r, "#{source} to #{target}", Logger::DEBUG
-        FileUtils.cp_r(source, target)
-      end
-    
-      # Moves source to target.  Files and directories moved by mv are
-      # restored upon an execution error.
-      def mv(source, target, backup_source=true)
-        backup(source, true) if backup_source
-        prepare(target)
-      
-        log :mv, "#{source} to #{target}", Logger::DEBUG
-        FileUtils.mv(source, target)
-      end
-    
-      # Rolls back any actions capable of being rolled back.
-      #
-      # Rollback is forceful.  For instance if you make a folder using
-      # mkdir, rollback will remove the folder and all files within it
-      # even if they were not added by self.
-      def rollback
-        while !actions.empty?
-          action, source, target = actions.pop
-
-          case action
-          when :make
-            log :rollback, "#{source}", Logger::DEBUG
-            FileUtils.rm_r(source)
-          when :backup
-            log :rollback, "#{target} to #{source}", Logger::DEBUG
-            dir = File.dirname(source)
-            FileUtils.mkdir_p(dir) unless File.exists?(dir)
-            FileUtils.mv(target, source, :force => true)
-          else
-            raise "unknown action: #{[action, source, target].inspect}"
-          end
-        end
-      end
-    
-      # Removes backup files. Cleanup cannot be rolled back and prevents
-      # rollback of actions up to when cleanup is called.  If cleanup_dirs
-      # is true, empty directories containing the backup files will be
-      # removed.
-      def cleanup(cleanup_dirs=true)
-        actions.each do |action, source, target|
-          if action == :backup
-            log :cleanup, target, Logger::DEBUG
-            FileUtils.rm_r(target) if File.exists?(target)
-            cleanup_dir(File.dirname(target)) if cleanup_dirs
-          end
-        end
-        actions.clear
-      end
-    
-      # Removes the directory if empty, and all empty parent directories. This
-      # method cannot be rolled back.
-      def cleanup_dir(dir)
-        while Root::Utils.empty?(dir)
-          log :rmdir, dir, Logger::DEBUG
-          FileUtils.rmdir(dir)
-          dir = File.dirname(dir)
-        end
-      end
-    
-      # Logs the given action, with the basenames of the input paths.  
-      def log_basename(action, paths, level=Logger::INFO)
-        msg = [paths].flatten.collect {|path| File.basename(path) }.join(',')
-        log(action, msg, level)
-      end
-    
-      def call(*_inputs)
-        actions.clear
-      
-        begin
-          super
-        rescue(Exception)
-          rollback if rollback_on_error
-          raise
-        end
-      end
-    
-      protected
-    
-      # An array tracking actions (backup, rm, mv, etc) performed by self,
-      # allowing rollback on an execution error.  Not intended to be
-      # modified manually.
-      attr_reader :actions
-    
-      private 
-
-      # utility method for backup_filepath; increments index until the
-      # path base.indexext does not exist.
-      def next_indexed_path(base, index, ext) # :nodoc:
-        path = sprintf('%s.%d%s', base, index, ext)
-        File.exists?(path) ? next_indexed_path(base, index + 1, ext) : path
-      end
-    end
-  end
-end

data/lib/tap/tasks/file_task/shell_utils.rb

@@ -1,71 +0,0 @@
-require 'tap/task'
-autoload(:Tempfile, 'tempfile')
-
-module Tap
-  module Tasks
-    class FileTask < Tap::Task
-      
-      # Provides several shell utility methods for calling programs.
-      #
-      # == 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 ShellUtils
-
-        # Run the system command +cmd+, passing the result to the block, if given.
-        # Raises an error if the command fails. Uses the same semantics as 
-        # Kernel::exec and Kernel::system.
-        #
-        # Based on FileUtils#sh from Rake.
-        def sh(*cmd) # :yields: ok, status
-          ok = system(*cmd)
-
-          if block_given?
-            yield(ok, $?)
-          else
-            ok or raise "Command failed with status (#{$?.exitstatus}): [#{ cmd.join(' ')}]"
-          end
-        end
-      
-        # Runs the system command +cmd+ using sh, redirecting the output to the 
-        # specified file path.  Uses the redirection command:
-        #
-        #   "> \"#{path}\" 2>&1 #{cmd}"
-        #
-        # This redirection has been tested on Windows, OS X, and Fedora.  See 
-        # http://en.wikipedia.org/wiki/Redirection_(Unix) for pointers on
-        # redirection.  This style of redirection SHOULD NOT be used with
-        # commands that contain other redirections.  
-        def redirect_sh(cmd, path, &block) # :yields: ok, status
-          sh( "> \"#{path}\" 2>&1 #{cmd}", &block)
-        end
-      
-        # Runs the system command +cmd+ and returns the output as a string.
-        def capture_sh(cmd, quiet=false, &block) # :yields: ok, status, tempfile_path
-          tempfile = Tempfile.new('shell_utils')
-          tempfile.close
-          redirect_sh(cmd, tempfile.path) do |ok, status|
-            if block_given?
-              yield(ok, $?, tempfile.path)
-            else
-              ok or raise %Q{Command failed with status (#{$?.exitstatus}): [#{cmd}]
--------------- command output -------------------
-#{File.read(tempfile.path)}
--------------------------------------------------
-}
-            end
-          end
-        
-          quiet == true ? "" : File.read(tempfile.path)
-        end
-      end
-    end
-  end
-end