tap 0.19.0 → 1.3.0

data/lib/tap/tasks/dump.rb

@@ -2,33 +2,34 @@ require 'tap/task'
 
 module Tap
   module Tasks
-    # :startdoc::task the default dump task
+    # :startdoc::task dump data
     #
     # Dumps data to $stdout or a file output.
     #
-    #   % tap run -- dump content --output FILEPATH
+    #   % tap dump content --output FILEPATH
     #
     # Dump faciliates normal redirection:
     #
-    #   % tap run -- load hello --: dump | more
-    #   hello
+    #   % tap load 'goodnight moon' -: dump | more
+    #   goodnight moon
     #
-    #   % tap run -- load hello --: dump 1> results.txt
+    #   % tap load 'goodnight moon' -: dump 1> results.txt
     #   % more results.txt
-    #   hello
+    #   goodnight moon
     #
-    # Note that dumps are appended to the file.  Dump only accepts one object
-    # at a time, so joins that produce an array (like sync) need to iterate
-    # outputs to dump:
+    # Dump converts objects to strings using to_s:
     #
-    #   % tap run -- load hello -- load world -- dump --[0,1][2]i.sync
-    #   hello
-    #   world
+    #   % tap load goodnight -- load moon - dump - sync 0,1 2
+    #   ["goodnight", "moon"]
+    #       
+    #   % tap load goodnight -- load moon - dump - sync 0,1 2 -i
+    #   goodnight
+    #   moon
     #
     # :startdoc::task-
     #
-    # Dump serves as a baseclass for more complicated dumps.  A YAML dump
-    # (see {tap-tasks}[http://tap.rubyforge.org/tap-tasks]) looks like this:
+    # Dump serves as a baseclass for more complicated dumps.  A YAML dump (see
+    # {tap-tasks}[http://tap.rubyforge.org/tap-tasks]) looks like this:
     #
     #   class Yaml < Tap::Tasks::Dump
     #     def dump(obj, io)
@@ -39,7 +40,11 @@ module Tap
     class Dump < Tap::Task
       config :output, $stdout, &c.io(:<<, :puts, :print)   # The dump target file
       config :overwrite, false, &c.flag                    # Overwrite the existing target
-    
+      
+      def call(input)
+        process(input)
+      end
+      
       # The default process prints dump headers as specified in the config,
       # then append the audit value to io.
       def process(input)
@@ -48,7 +53,7 @@ module Tap
         end
         input
       end
-    
+      
       # Dumps the object to io, by default dump puts (not prints) obj.to_s.
       def dump(input, io)
         io.puts input.to_s

data/lib/tap/tasks/list.rb

@@ -0,0 +1,184 @@
+require 'tap/tasks/dump'
+
+module Tap
+  module Tasks
+    # :startdoc::task list resources
+    #
+    # Prints a list of resources registered with the application env. Any of
+    # the resources may be used in a workflow.  A list of filters may be used
+    # to limit the output; each is converted to a regexp and can match any
+    # part of the resource (path, class, desc).
+    #
+    #   % tap list join gate
+    #   join:
+    #     gate                 # collects results before the join
+    #
+    # The configurations can be used to switch the resource description.  By
+    # default env only lists resources registered as a task, join, or
+    # middleware.
+    #
+    #   % tap list join gate --class --full
+    #   join:
+    #     /tap/joins/gate      # Tap::Joins::Gate
+    #
+    class List < Dump
+      
+      config :all, false, :short => :a, &c.flag       # Shows all types
+      config :types, ['task', 'join', 'middleware'],
+        :long => :type,
+        :short => :t,
+        :reader => false,
+        &c.list(&c.string)                            # List types to show
+        
+      config :full, false, :short => :f, &c.flag      # Show full paths
+      config :path, false, :short => :p, &c.flag      # Show require path
+      config :clas, false, :long => :class,
+        :short => :c, &c.flag                         # Show class
+      
+      def call(input)
+        process manifest(*input).join("\n")
+      end
+      
+      def basis
+        app.env.constants
+      end
+      
+      def types
+        return @types unless all
+        
+        types = []
+        app.env.constants.each do |constant|
+          types.concat constant.types.keys
+        end
+        types.uniq!
+        types.sort!
+        types
+      end
+      
+      def manifest(*filters)
+        constants = filter(basis, filters)
+        
+        paths = full ? fullmap(constants) : minimap(constants)
+        constants = constants.sort_by {|constant| paths[constant] }
+        
+        descriptions = {}
+        selected_paths = []
+        selected_types = types
+        
+        selected_types.each do |type|
+          lines = []
+          constants.each do |constant|
+            next unless constant.types.include?(type)
+            
+            path = paths[constant]
+            selected_paths << path
+            lines << [path, describe(constant, type)]
+          end
+          
+          descriptions[type] = lines unless lines.empty?
+        end
+        
+        format = "  %-#{max_width(selected_paths)}s # %s"
+        
+        lines = []
+        selected_types.each do |type|
+          next unless descriptions.has_key?(type)
+          
+          lines << "#{type}:"
+          descriptions[type].each do |description|
+            lines << (format % description)
+          end
+        end
+        
+        if lines.empty?
+          lines << "(no constants match criteria)"
+        end
+        
+        lines
+      end
+      
+      def filter(constants, filters)
+        return constants if filters.empty?
+        
+        filters.collect! {|filter| Regexp.new(filter) }
+        constants = constants.select do |constant|
+          filters.all? do |filter|
+            constant.path =~ filter
+          end
+        end
+      end
+      
+      def fullmap(constants)
+        paths = {}
+        constants.each {|constant| paths[constant] = constant.path }
+        paths
+      end
+      
+      def minimap(constants)
+        paths = {}
+        constants.each do |constant|
+          paths[constant] = split(constant.path)
+        end
+        
+        minimap = {}
+        queue = constants.dup
+        while !queue.empty?
+          next_queue = []
+          queue.each do |constant|
+            path = paths[constant].shift
+            
+            if current = minimap[path]
+              next_queue << current unless current == :skip
+              next_queue << constant
+              minimap[path] = :skip
+            else
+              minimap[path] = constant
+            end
+          end
+          
+          queue = next_queue
+        end
+        
+        minimap.delete_if {|path, constant| constant == :skip }.invert
+      end
+      
+      def split(path)
+        splits = []
+        current = nil
+        path.split('/').reverse_each do |split|
+          current = current ? File.join(split, current) : split
+          splits << current
+        end
+        splits
+      end
+      
+      def describe(constant, type)
+        case
+        when clas 
+          constant.const_name
+          
+        when path
+          require_paths = constant.require_paths
+          require_paths = require_paths.collect do |path|
+            File.join(load_path(path), path)
+          end if full
+          require_paths.join(',')
+          
+        else 
+          constant.types[type]
+        end
+      end
+      
+      def load_path(path)
+        $:.find do |load_path|
+          File.exists?(File.join(load_path, path))
+        end || '?'
+      end
+      
+      def max_width(paths)
+        max = paths.collect {|path| path.length }.max
+        max.nil? || max < 20 ? 20 : max
+      end
+    end 
+  end
+end

data/lib/tap/tasks/load.rb

@@ -3,20 +3,20 @@ require 'stringio'
 
 module Tap
   module Tasks
-    # :startdoc::task the default load task
+    # :startdoc::task load data
     #
     # Loads data from $stdin.  String data may be passed directly.  Load
     # is typically used as a gateway to other tasks.
     #
-    #   % tap run -- load string --: dump
+    #   % tap load string -: dump
     #   string
     #
     # Load facilitates normal redirection:
     #
-    #   % echo goodnight moon | tap run -- load --: dump
+    #   % echo goodnight moon | tap load -: dump
     #   goodnight moon
     #
-    #   % tap run -- load --: dump < somefile.txt
+    #   % tap load -: dump < somefile.txt
     #   contents of somefile
     #
     # :startdoc::task-

data/lib/tap/tasks/prompt.rb

@@ -0,0 +1,128 @@
+require 'tap/tasks/stream'
+require 'readline'
+
+module Tap
+  module Tasks
+    # :startdoc::task open a prompt
+    #
+    # Prompt reads signals from the input until a signal that returns the app
+    # is reached (ex run/stop) or the source io is closed.
+    #
+    #   % tap prompt
+    #   /set 0 load
+    #   /set 1 dump
+    #   /build join 0 1
+    #   /enq 0 'goodnight moon'
+    #   /run
+    #   goodnight moon
+    #
+    # Prompts can be registered to a control signal (ex INT) so that that a
+    # running app may be interrupted, interrogated, or modified. This infinite
+    # loop can be stopped using ctl-C and a prompt.
+    #
+    #  % tap dump '.' - join 0 0 -q - prompt --on INT
+    #  .
+    #  .
+    #  .
+    #  (ctl-C)
+    #  /stop
+    #
+    class Prompt < Stream
+      include Tap::Utils
+      
+      config :prompt, '/', &c.string_or_nil         # The prompt sequence
+      config :terminal, $stdout, &c.io_or_nil       # The terminal IO
+      config :variable, '', &c.string_or_nil        # Assign to variable in app
+      config :on, nil, &c.string_or_nil             # Register to a SIG
+      
+      def initialize(*args)
+        super
+        trap(on) if on
+      end
+      
+      # Traps interrupt the normal flow of the program and so I assume thread
+      # safety is an issue (ex if the INT occurs during an enque and a signal
+      # specifies another enque). A safer way to go is to enque the prompt...
+      # when the prompt is executed the app won't be be doing anything else so
+      # thread safety shouldn't be an issue.
+      def trap(sig)
+        ::Signal.trap(sig) do
+          puts
+          puts "Interrupt! Signals from an interruption are not thread-safe."
+          
+          call_prompt = true
+          3.times do
+            print "Wait for thread-safe break? (y/n): "
+
+            case gets.strip
+            when /^y(es)?$/i
+              puts "waiting for break..."
+              app.pq(self, [])
+              call_prompt = false
+              break
+
+            when /^no?$/i
+              break
+            end
+          end
+
+          if call_prompt
+            call([])
+          end
+        end
+      end
+      
+      def signal(sig)
+        lambda do |spec|
+          app.build('class' => sig, 'spec' => spec) do |obj, args|
+            obj.call(args)
+          end
+        end
+      end
+      
+      def process(io=$stdin)
+        app.set(variable, self) if variable
+        
+        result = super(io)
+        unless file || result.nil? || result == app
+          open_io(terminal) do |terminal|
+            terminal.puts result
+          end
+        end
+        
+        app.set(variable, nil) if variable
+        result
+      end
+      
+      def load(io)
+        line = readline(io)
+        return nil if line.empty?
+        
+        begin
+          sig, *args = shellsplit(line)
+          app.call('sig' => sig, 'args' => args)
+        rescue
+          $!
+        end
+      end
+      
+      def readline(io)
+        if io == $stdin && terminal == $stdout
+          return Readline.readline(prompt, true)
+        end
+        
+        if prompt && !file
+          open_io(terminal) do |terminal|
+            terminal.print prompt
+          end
+        end
+        
+        io.eof? ? '' : io.readline.strip!
+      end
+      
+      def complete?(io, result)
+        result == app
+      end
+    end
+  end
+end

data/lib/tap/tasks/signal.rb

@@ -0,0 +1,42 @@
+require 'tap/task'
+
+module Tap
+  module Tasks
+    # ::task signal via a task
+    class Signal < Tap::Task
+      class << self
+        def build(spec={}, app=Tap::App.current)
+          new(spec['sig'], spec['config'], app)
+        end
+        
+        def convert_to_spec(parser, args)
+          if args.empty?
+            raise "no signal specified"
+          end
+          
+          {
+            'config' => parser.nested_config,
+            'sig'  => args.shift
+          }
+        end
+      end
+      
+      attr_accessor :sig
+      
+      def initialize(sig, config={}, app=Tap::App.current)
+        super(config, app)
+        @sig = sig
+      end
+      
+      def process(*args)
+        app.signal(sig).call(args)
+      end
+      
+      def to_spec
+        spec = super
+        spec['sig'] = sig
+        spec
+      end
+    end
+  end
+end