tap 0.12.4 → 0.17.0

data/lib/tap/{support → env}/string_ext.rb

@@ -1,5 +1,5 @@
 module Tap
-  module Support
+  class Env
     
     # StringExt provides two common string transformations, camelize and
     # underscore. StringExt is automatically included in String.
@@ -56,5 +56,5 @@ module Tap
 end
 
 class String # :nodoc:
-  include Tap::Support::StringExt
+  include Tap::Env::StringExt
 end

data/lib/tap/exe.rb

@@ -1,106 +1,91 @@
 require 'tap/env'
-require 'tap/app'
-require 'tap/support/schema'
+require 'tap/task'
+require 'tap/schema'
 
 module Tap
-  class Exe < Env
-    class << self
-      def setup(argv=ARGV)
-        if argv[-1] == '-d-'
-          argv.pop
-          $DEBUG = true 
-        end
-        
-        instantiate
+  module Exe
+    
+    # Adapted from Gem.find_home
+    # def self.user_home
+    #   ['HOME', 'USERPROFILE'].each do |homekey|
+    #     return ENV[homekey] if ENV[homekey]
+    #   end
+    # 
+    #   if ENV['HOMEDRIVE'] && ENV['HOMEPATH'] then
+    #     return "#{ENV['HOMEDRIVE']}#{ENV['HOMEPATH']}"
+    #   end
+    # 
+    #   begin
+    #     File.expand_path("~")
+    #   rescue
+    #     File::ALT_SEPARATOR ? "C:/" : "/"
+    #   end
+    # end
+
+    # Setup an execution environment.
+    def self.setup(options={}, argv=ARGV, env=ENV)
+      if argv[-1] == "-d-"
+        argv.pop
+        $DEBUG = true 
       end
       
-      def instantiate(path_or_root=Dir.pwd)
-        exe = super
-        
-        # add all gems if no gems are specified (Note this is VERY SLOW ~ 1/3 the overhead for tap)
-        exe.gems = :all if !File.exists?(Tap::Env::DEFAULT_CONFIG_FILE)
-  
-        # add the default tap instance
-        exe.push Env.instantiate("#{File.dirname(__FILE__)}/../..")
-        exe
-      end
+      options = {
+        :dir => Dir.pwd,
+        :config_file => CONFIG_FILE
+      }.merge(options)
       
-      def load_config(path)
-        super(GLOBAL_CONFIG_FILE).merge super(path)
-      end
+      # load configurations
+      dir = options.delete(:dir)
+      config_file = options.delete(:config_file)
+      user_config_file = config_file ? File.join(dir, config_file) : nil
       
-      # Adapted from Gem.find_home
-      def user_home
-        ['HOME', 'USERPROFILE'].each do |homekey|
-          return ENV[homekey] if ENV[homekey]
+      user = Env.load_config(user_config_file)
+      global = {}
+      env.each_pair do |key, value|
+        if key =~ /\ATAP_(.*)\z/
+          global[$1.downcase] = value
         end
+      end
       
-        if ENV['HOMEDRIVE'] && ENV['HOMEPATH'] then
-          return "#{ENV['HOMEDRIVE']}#{ENV['HOMEPATH']}"
-        end
-
-        begin
-          File.expand_path("~")
-        rescue
-          File::ALT_SEPARATOR ? "C:/" : "/"
-        end
+      config = {
+        'root' => dir,
+        'gems' => :all
+      }.merge(global).merge(user).merge(options)
+      
+      # keys must be symbolize as they are immediately 
+      # used to initialize the Env configs
+      config = config.inject({}) do |options, (key, value)|
+        options[key.to_sym || key] = value
+        options
       end
-    end
-    
-    config :before, nil
-    config :after, nil
-    
-    # Specify files to require when self is activated.
-    config :requires, [], &c.array_or_nil
-    
-    # Specify files to load when self is activated.
-    config :loads, [], &c.array_or_nil
-    config :aliases, {}, &c.hash_or_nil
-    
-    # The global home directory
-    GLOBAL_HOME = File.join(Exe.user_home, ".tap")
-    
-    # The global config file path
-    GLOBAL_CONFIG_FILE = File.join(GLOBAL_HOME, "tap.yml")
-    
-    def activate
-      if super      
       
-        # perform requires
-        requires.each do |path|
-          require path
-        end
+      # instantiate
+      exe = Env.new(config, :basename => config_file).extend(Exe)
       
-        # perform loads
-        loads.each do |path|
-          load path
-        end
+      exe.register('command') do |env|
+        env.root.glob(:cmd, "**/*.rb")
       end
-    end
-    
-    def handle_error(err)
-      case
-      when $DEBUG
-        puts err.message
-        puts
-        puts err.backtrace
-      else puts err.message
+      
+      # add the tap env if necessary
+      unless exe.any? {|env| env.root.root == TAP_HOME }
+        exe.push Env.new(TAP_HOME, exe.context) 
       end
+      
+      exe
     end
     
-    def execute(argv=ARGV)
-      command = argv.shift.to_s
-      
-      if aliases && aliases.has_key?(command)
-        aliases[command].reverse_each {|arg| argv.unshift(arg)}
-        command = argv.shift
-      end
-
-      case command  
+    # The config file path
+    CONFIG_FILE = "tap.yml"
+    
+    # The home directory for Tap
+    TAP_HOME = File.expand_path("#{File.dirname(__FILE__)}/../..")
+    
+    def launch(argv=ARGV)
+      case command = argv.shift.to_s  
       when '', '--help'
         yield
       else
-        if path = commands.search(command)
+        if path = seek('command', command)
           load path # run the command, if it exists
         else
           puts "Unknown command: '#{command}'"
@@ -110,61 +95,64 @@ module Tap
     end
     
     def build(schema, app=Tap::App.instance)
-      schema.build(app) do |args|
-        task = args.shift
-        const = tasks.search(task) 
-        
-        task_class = case
-        when const then const.constantize 
-        when block_given?
-          args.unshift(task)
-          yield(args)
-        else nil
+      schema.resolve! do |type, id, data|
+        klass = self[type][id]
+        if !klass && block_given?
+          klass = yield(type, id, data)
         end
         
-        task_class or raise ArgumentError, "unknown task: #{task}"
-        task_class.parse(args, app) do |help|
-          puts help
-          exit
-        end
+        klass || id
       end
+      schema.validate!
+      schema.build(app)
     end
     
-    def set_signals(app=Tap::App.instance)
+    def set_signals(app)
       # info signal -- Note: some systems do 
       # not support the INFO signal 
       # (windows, fedora, at least)
       signals = Signal.list.keys
-      if signals.include?("INFO")
-        Signal.trap("INFO") do
-          puts app.info
-        end
-      end
+      Signal.trap("INFO") do
+        puts app.info
+      end if signals.include?("INFO")
 
       # interuption signal
-      if signals.include?("INT")
-        Signal.trap("INT") do
-          puts " interrupted!"
-          # prompt for decision
-          while true
-            print "stop, terminate, exit, or resume? (s/t/e/r):"
-            case gets.strip
-            when /s(top)?/i 
-              app.stop
-              break
-            when /t(erminate)?/i 
-              app.terminate
-              break
-            when /e(xit)?/i 
-              exit
-            when /r(esume)?/i 
-              break
-            else
-              puts "unexpected response..."
-            end
+      Signal.trap("INT") do
+        puts " interrupted!"
+        # prompt for decision
+        while true
+          print "stop, terminate, exit, or resume? (s/t/e/r):"
+          case gets.strip
+          when /s(top)?/i 
+            app.stop
+            break
+          when /t(erminate)?/i 
+            app.terminate
+            break
+          when /e(xit)?/i 
+            exit
+          when /r(esume)?/i 
+            break
+          else
+            puts "unexpected response..."
           end
         end
+      end if signals.include?("INT")
+    end
+    
+    def run(schemas, app=Tap::App.instance, &block)
+      schemas = [schemas] unless schemas.kind_of?(Array)
+      schemas.each do |schema|
+        build(schema, app, &block)
+      end
+      
+      if app.queue.empty?
+        raise "no nodes specified"
       end
+
+      set_signals(app)
+      app.run
     end
+    
   end
 end

data/lib/tap/join.rb

@@ -0,0 +1,175 @@
+require 'tap/app'
+require 'tap/support/intern'
+
+module Tap
+  class App
+    # Generates a join between the inputs and outputs.
+    def join(inputs, outputs, config={}, klass=Join, &block)
+      klass.new(config, self).join(inputs, outputs, &block)
+    end
+  end
+  
+  # :startdoc::join a simple, unsyncrhonized, multi-way join
+  #
+  # Join defines an unsynchronized, multi-way join where n inputs send their
+  # results to m outputs.  Flags can augment how the results are passed, in
+  # particular for array results.
+  #
+  class Join
+    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 array like [inputs, outputs, instance] where
+      # inputs and outputs implicitly define the inputs and output for the
+      # instance.  By default parse parses an argh then calls instantiate,
+      # but there is no requirement that this occurs in subclasses.
+      def parse(argv=ARGV, app=Tap::App.instance)
+        parse!(argv.dup, app)
+      end
+      
+      # Same as parse, but removes arguments destructively.
+      def parse!(argv=ARGV, app=Tap::App.instance)
+        opts = ConfigParser.new
+        opts.separator "configurations:"
+        opts.add(configurations)
+        
+        args = opts.parse!(argv, :add_defaults => false)
+        
+        instantiate({
+          :config => opts.nested_config,
+          :args => args
+        }, app)
+      end
+      
+      # Instantiates an instance of self and return an array like [inputs,
+      # outputs, instance].
+      def instantiate(argh, app=Tap::App.instance)
+        new(argh[:config] || {}, app)
+      end
+      
+      # Instantiates a new join with the input arguments and overrides
+      # call with the block.  The block will be called with the join
+      # instance and result.
+      #
+      # Simply instantiates a new join if no block is given.
+      def intern(config={}, app=Tap::App.instance, &block) # :yields: join, result
+        instance = new(config, app)
+        if block_given?
+          instance.extend Support::Intern(:call)
+          instance.call_block = block
+        end
+        instance
+      end
+      
+      protected
+      
+      def parse_array(obj) # :nodoc:
+        case obj
+        when nil then []
+        when Array then obj
+        else
+          obj.split(",").collect {|str| str.to_i }
+        end
+      end
+    end
+    include Configurable
+    
+    lazy_attr :desc, 'join'
+    
+    # Causes the targets to be enqued rather than executed immediately.
+    config :enq, false, :short => 'q', &c.flag
+    
+    # Splats the result to the outputs, allowing a many-to-one join
+    # from the perspective of the results.
+    #
+    #   # results: [1,2,3]
+    #   # outputs: call(*inputs)
+    #   app.execute(output, *result)
+    #
+    config :splat, false, :short => 's', &c.flag
+    
+    # Iterates the results to the outputs, allowing a many-to-one join
+    # from the perspective of the results.  Non-array results are converted
+    # to arrays using to_ary:
+    #
+    #   # results: [1,2,3]
+    #   # outputs: call(input)
+    #   result.to_ary.each {|r| app.execute(output, r) }
+    #
+    # Iterate may be combined with splat:
+    #
+    #   # results: [[1,2],3]
+    #   # outputs: call(*inputs)
+    #   result.to_ary.each {|r| app.execute(output, *r) }
+    #
+    config :iterate, false, :short => 'i', &c.flag
+    
+    # The App receiving self during enq
+    attr_accessor :app
+    
+    # An array of input nodes, or nil if the join has not been set.
+    attr_reader :inputs
+    
+    # An array of output nodes, or nil if the join has not been set.
+    attr_reader :outputs
+    
+    # Initializes a new join with the specified configuration.
+    def initialize(config={}, app=Tap::App.instance)
+      @app = app
+      @inputs = nil
+      @outputs = nil
+      initialize_config(config)
+    end
+    
+    # Sets self as a join between the inputs and outputs.
+    def join(inputs, outputs)
+      @inputs.each do |input|
+        input.joins.delete(self)
+      end if @inputs
+      
+      @inputs = inputs
+      
+      inputs.each do |input|
+        input.joins << self
+      end if inputs
+      
+      @outputs = outputs
+      self
+    end
+    
+    # Executes the join logic for self, which by default passes the result to
+    # each output.
+    def call(result)
+      outputs.each do |output|
+        dispatch(output, result)
+      end
+    end
+    
+    protected
+    
+    # Dispatches the results to the node.
+    def dispatch(node, result) # :nodoc:
+      mode = enq ? :enq : :execute
+      if iterate
+        result.to_ary.each {|r| execute(mode, node, r) }
+      else
+        execute(mode, node, result)
+      end
+    end
+    
+    # Executes the node with the input results.
+    def execute(mode, node, result) # :nodoc:
+      if splat
+        app.send(mode, node, *result)
+      else
+        app.send(mode, node, result)
+      end
+    end
+  end
+end