bahuvrihi-tap 0.10.4 → 0.10.5

data/bin/rap

@@ -0,0 +1,112 @@
+#!/usr/bin/env ruby
+# usage: rap taskname {options} [args]
+
+require "#{File.dirname(__FILE__)}/../lib/tap.rb"
+
+# setup the environment
+begin
+  env = Tap::Exe.instantiate
+rescue(Tap::Env::ConfigError)
+  # catch errors and exit gracefully
+  # (errors usu from gem loading errors)
+  puts $!.message
+  exit(1)
+end
+
+# parse super options
+require 'tap/support/super_optparse'
+Tap::Support::SuperOptionParser.new do |opts|
+  opts.on("-e", "--env [CONFIG:VALUE]", "set an env configuration") do |arg|
+    config, value = arg.split(":", 2)
+    env.config[config.to_sym] = value
+  end
+  
+  opts.on("-a", "--app [CONFIG:VALUE]", "set an app configuration") do |arg|
+    config, value = arg.split(":", 2)
+    env.app.config[config.to_sym] = value
+  end
+  
+  opts.on("-d", "set $DEBUG to true") do
+    $DEBUG = true
+  end
+end.parse!
+
+# add the DEFAULT_TASK_FILE if it exists
+task_file = File.expand_path('tapfile.rb')
+if File.exists?(task_file)
+  env.requires.unshift(task_file)
+  env.manifest(:tasks).search_paths << [Dir.pwd, task_file]
+end
+
+#
+# setup after script
+#
+
+at_exit do
+  begin
+    eval(env.after) if env.after != nil
+  rescue(Exception)
+    puts "Error in after script."
+    env.handle_error($!)
+    exit(1)
+  end
+end
+
+#
+# run before script
+#
+
+begin
+  eval(env.before) if env.before != nil
+rescue(Exception)
+  puts "Error in before script."
+  env.handle_error($!)
+  exit(1)
+end 
+
+#
+# run rap
+#
+
+module Tap
+  module Tasks
+    autoload(:Rake, 'tap/tasks/rake')
+  end
+end
+
+begin
+  env.activate
+  
+  case ARGV[0]
+  when '--help', nil, '-T'
+    puts Tap::Support::Lazydoc.usage(__FILE__)
+    puts
+    puts "===  tap tasks ==="
+    puts env.summarize(:tasks) {|const| const.document[const.name]['manifest'] }
+    puts
+    puts "=== rake tasks ==="
+    Tap::Tasks::Rake.new.enq('-T')
+    Tap::App.instance.run
+    
+    # this is not currently reached as rake exits on -T
+    puts
+    puts "version #{Tap::VERSION} -- #{Tap::WEBSITE}"
+    exit
+  else
+    queues = env.build(ARGV) {|args| Tap::Tasks::Rake }
+    ARGV.clear
+
+    if queues.empty?
+      puts "no task specified"
+      exit
+    end
+  
+    env.set_signals
+    env.run(queues)
+  end
+  
+rescue
+  env.handle_error($!)
+end
+
+exit(0)

data/bin/tap

@@ -1,4 +1,4 @@
-#!/usr/local/bin/ruby
+#!/usr/bin/env ruby
 # usage: tap <command> {options} [args]
 #
 # examples:
@@ -6,19 +6,15 @@
 #   tap run taskname --option input      # runs the 'taskname' task
 #
 # help:
-#   tap help                             # prints this help
+#   tap --help                           # prints this help
 #   tap command --help                   # prints help for 'command'
 #
 
 require "#{File.dirname(__FILE__)}/../lib/tap.rb"
-require 'tap/exe'
 
 # setup the environment
 begin
-  
-  $DEBUG = true if ARGV.delete('-d-')
   env = Tap::Exe.instantiate
-
 rescue(Tap::Env::ConfigError)
   # catch errors and exit gracefully
   # (errors usu from gem loading errors)
@@ -26,6 +22,24 @@ rescue(Tap::Env::ConfigError)
   exit(1)
 end
 
+# parse super options
+require 'tap/support/super_optparse'
+Tap::Support::SuperOptionParser.new do |opts|
+  opts.on("-e", "--env [CONFIG:VALUE]", "set an env configuration") do |arg|
+    config, value = arg.split(":", 2)
+    env.config[config.to_sym] = value
+  end
+  
+  opts.on("-a", "--app [CONFIG:VALUE]", "set an app configuration") do |arg|
+    config, value = arg.split(":", 2)
+    env.app.config[config.to_sym] = value
+  end
+  
+  opts.on("-d", "set $DEBUG to true") do
+    $DEBUG = true
+  end
+end.parse!
+
 #
 # setup after script
 #
@@ -59,10 +73,7 @@ end
 begin
   env.activate
   env.execute(ARGV) do
-    # give some help
-    require 'tap/support/command_line'
-    
-    puts Tap::Support::CommandLine.usage(__FILE__)
+    puts Tap::Support::Lazydoc.usage(__FILE__)
     puts
     puts "available commands:"
     puts env.summarize(:commands)

data/cmd/destroy.rb

@@ -12,5 +12,5 @@ name = ARGV.shift
 const = env.search(:generators, name) or raise "unknown generator: #{name}"
 
 generator_class = const.constantize
-generator, argv = generator_class.instantiate(ARGV)
+generator, argv = generator_class.parse(ARGV)
 generator.extend(Tap::Generator::Destroy).process(*argv)

data/cmd/generate.rb

@@ -12,5 +12,5 @@ name = ARGV.shift
 const = env.search(:generators, name) or raise "unknown generator: #{name}"
 
 generator_class = const.constantize
-generator, argv = generator_class.instantiate(ARGV)
+generator, argv = generator_class.parse(ARGV)
 generator.extend(Tap::Generator::Generate).process(*argv)

data/cmd/run.rb

@@ -14,15 +14,13 @@ app = Tap::App.instance
 
 dump = false
 OptionParser.new do |opts|
-  cmdline = Tap::Support::CommandLine
-  
   opts.separator ""
   opts.separator "configurations:"
   
   Tap::App.configurations.each do |receiver, key, config|
     next if receiver == Tap::Root
     
-    opts.on(*cmdline.configv(config)) do |value|
+    opts.on(*config.to_optparse_argv) do |value|
       app.send(config.writer, value)
     end
   end
@@ -31,7 +29,7 @@ OptionParser.new do |opts|
   opts.separator "options:"
 
   opts.on("-h", "--help", "Show this message") do
-    opts.banner = cmdline.usage(__FILE__)
+    opts.banner = Tap::Support::Lazydoc.usage(__FILE__)
     Tap::App.lazydoc.resolve
     puts opts
     exit
@@ -45,7 +43,7 @@ OptionParser.new do |opts|
 end.parse!(ARGV)
 
 #
-# handle options for each specified task
+# build and run the argv
 #
 
 queues = env.build(ARGV)
@@ -56,48 +54,6 @@ if queues.empty?
   exit
 end
 
-#
-# set signals 
-#
-
-# 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
-
-# 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
-    end
-  end
-end
-
-#
-# enque tasks and run!
-#
-
+env.set_signals
 env.run(queues)
 

data/cmd/server.rb

@@ -37,4 +37,6 @@ end.parse!(ARGV)
 #
 
 env.extend Tap::Support::Gems::Rack
-Rack::Handler::WEBrick.run(env, options)
+Rack::Handler::WEBrick.run(env, options) do |handler|
+  env.handler = handler
+end

data/lib/tap/constants.rb

@@ -1,7 +1,7 @@
 module Tap
   MAJOR = 0
   MINOR = 10
-  TINY = 4
+  TINY = 5
   
   VERSION="#{MAJOR}.#{MINOR}.#{TINY}" 
   WEBSITE="http://tap.rubyforge.org"

data/lib/tap/env.rb

@@ -123,12 +123,11 @@ module Tap
         manifests[name] = manifest_class
       end
       
-      # Returns the gemspecs for all installed gems with a DEFAULT_TASK_FILE
-      # or DEFAULT_CONFIG_FILE. If latest==true, then only the specs for the 
-      # most current gems will be returned.
+      # Returns the gemspecs for all installed gems with a DEFAULT_CONFIG_FILE. 
+      # If latest==true, then only the specs for the most current gems will be 
+      # returned.
       def gemspecs(latest=true)
         Support::Gems.select_gems(latest) do |spec|
-          File.exists?(File.join(spec.full_gem_path, DEFAULT_TASK_FILE)) ||
           File.exists?(File.join(spec.full_gem_path, DEFAULT_CONFIG_FILE))
         end
       end
@@ -175,16 +174,10 @@ module Tap
     @@instance = nil
     @@instances = {}
     @@manifests = {:envs => Manifest}
-
-    # The global config file path
-    GLOBAL_CONFIG_FILE = File.join(Support::Gems.user_home, ".tap.yml")
     
     # The default config file path
     DEFAULT_CONFIG_FILE = "tap.yml"
     
-    # The default task file path
-    DEFAULT_TASK_FILE = "tapfile.rb"
-    
     # The Root directory structure for self.
     attr_reader :root
     
@@ -194,16 +187,17 @@ module Tap
     # A hash of the manifests for self.
     attr_reader :manifests
     
+    # Specify files to require when self is activated.
+    config :requires, [], &c.array_or_nil
+    
     # Specify gems to load as nested Envs.  Gems may be specified 
     # by name and/or version, like 'gemname >= 1.2'; by default the 
     # latest version of the gem is selected.
     #
     # Gems are immediately loaded (via gem) through this method.
-    #--
-    # Note that the gems are resolved to gemspecs using Env.gemspec,
-    # so self.gems returns an array of gemspecs.
     config_attr :gems, [] do |input|
       check_configurable
+      specs_by_name = {}
       @gems = [*input].compact.collect do |gem_name| 
         spec = Support::Gems.gemspec(gem_name)
         
@@ -212,8 +206,20 @@ module Tap
         else Env.instance_for(spec.full_gem_path)
         end
         
-        spec
+        (specs_by_name[spec.name] ||= []) << spec
+        spec.name
       end.uniq
+      
+      # this song and dance is to ensure that the latest spec for a
+      # given gem appears first in the manifest
+      specs_by_name.each_pair do |name, specs|
+        specs_by_name[name] = specs.uniq.sort_by {|spec| spec.version }.reverse
+      end
+      
+      @gems.collect! do |name|
+        specs_by_name[name]
+      end.flatten!
+      
       reset_envs
     end
 
@@ -235,16 +241,12 @@ module Tap
     # Designate paths for discovering generators.  
     path_config :generator_paths, ["lib"]
     
-    path_manifest(:tasks, :load_paths, "**/*.rb", [DEFAULT_TASK_FILE]) do |load_path, path|
+    path_manifest(:tasks, :load_paths, "**/*.rb") do |load_path, path|
       next unless File.file?(path) && document = Support::Lazydoc.scan_doc(path, 'manifest')
       
-      document.const_names.collect do |const_name|
-        if const_name.empty?
-          key = env.root.relative_filepath(load_path, path).chomp('.rb')
-          [key, Support::Constant.new(key.camelize, path)]
-        else
-          [const_name.underscore, Support::Constant.new(const_name, path)]
-        end
+      document.default_const_name = env.root.relative_filepath(load_path, path).chomp('.rb').camelize
+      document.const_attrs.keys.collect do |const_name|
+        [const_name.underscore, Support::Constant.new(const_name, path)]
       end
     end
     
@@ -257,13 +259,9 @@ module Tap
       next unless File.file?(path) && "#{File.basename(dirname)}_generator.rb" == File.basename(path)
       
       next unless document = Support::Lazydoc.scan_doc(path, 'generator')
-      document.const_names.collect do |const_name|
-        if const_name.empty?
-          key = env.root.relative_filepath(generator_path, dirname)
-          [key, Support::Constant.new((key + '_generator').camelize, path)]
-        else
-          [const_name.underscore, Support::Constant.new(const_name, path)]
-        end
+      document.default_const_name = "#{env.root.relative_filepath(generator_path, dirname)}_generator".camelize
+      document.const_attrs.keys.collect do |const_name|
+        [const_name.underscore.chomp('_generator'), Support::Constant.new(const_name, path)]
       end
     end
     
@@ -454,6 +452,12 @@ module Tap
       end
     
       $LOAD_PATH.uniq!
+      
+      # perform requires
+      requires.each do |path|
+        require path
+      end
+      
       true
     end
     
@@ -519,10 +523,8 @@ module Tap
     # mini-matches the input pattern.  See Tap::Root.minimal_match? 
     # for details on mini-matching.
     def find(name, pattern, value_only=true)
-      manifest(name).each do |key, value|
-        return(value_only ? value : [key, value]) if Root.minimal_match?(key, pattern)
-      end
-      nil
+      return nil unless entry = manifest(name)[pattern]
+      value_only ? entry[1] : entry
     end
     
     # Like find, but searches across all envs for the matching value.
@@ -582,12 +584,8 @@ module Tap
       lines.join("\n")
     end
 
-    def inspect(brief=false)
-      brief ? "#<#{self.class}:#{object_id} root='#{root.root}'>" : super()
-    end
-    
-    def to_s
-      inspect(true)
+    def inspect
+      "#<#{self.class}:#{object_id} root='#{root.root}'>"
     end
     
     protected

data/lib/tap/exe.rb

@@ -8,16 +8,17 @@ module Tap
     class << self
       def instantiate(path=Dir.pwd, logger=Tap::App::DEFAULT_LOGGER, &block)
         app = Tap::App.instance = Tap::App.new({:root => path}, logger)
-        exe = super(app, load_config(Tap::Env::GLOBAL_CONFIG_FILE), app.logger)
+        exe = super(app, load_config(GLOBAL_CONFIG_FILE), app.logger)
         
         # add all gems if no gems are specified (Note this is VERY SLOW ~ 1/3 the overhead for tap)
         if !File.exists?(Tap::Env::DEFAULT_CONFIG_FILE)
-          exe.gems = gemspecs(true)
+          exe.gems = gemspecs(false)
         end
-      
+        
+        # add the default tap instance
         tap = instance_for("#{File.dirname(__FILE__)}/../..")
-        tap.manifest(:tasks).search_paths = tap.root.glob(:lib, "tap/tasks/*").collect do |path|
-          [tap.root[:lib], path]
+        tap.manifest(:tasks).search_paths = tap.root.glob(:lib, "tap/tasks/*").collect do |task_path|
+          [tap.root[:lib], task_path]
         end
         exe.push(tap)
         exe
@@ -33,6 +34,10 @@ module Tap
     config :after, nil
     config :aliases, {}, &c.hash_or_nil
     
+    # The global config file path
+    GLOBAL_CONFIG_FILE = File.join(Gem.user_home, ".tap.yml")
+
+    # Alias for root (Exe should have a Tap::App as root)
     def app
       root
     end
@@ -69,36 +74,61 @@ module Tap
     end
 
     def build(argv=ARGV)
-      parser = Parser.new(argv)
-      
-      # attempt lookup and instantiate the task class
-      tasks = parser.tasks.collect do |args|
+      Parser.new(argv).build(app) do |args|
         task = args.shift
-
-        const = search(:tasks, task) or raise ArgumentError, "unknown task: #{task}"
-        task_class = const.constantize or raise ArgumentError, "unknown task: #{task}"
-        task_class.instantiate(args, app)
-      end
-
-      # build the workflow
-      parser.workflow.each_with_index do |(type, target_indicies), source_index|
-        next if type == nil
+        const = search(:tasks, task) 
+        
+        task_class = case
+        when const then const.constantize 
+        when block_given?
+          args.unshift(task)
+          yield(args)
+        else nil
+        end
         
-        tasks[source_index].send(type, *target_indicies.collect {|i| tasks[i] })
+        task_class or raise ArgumentError, "unknown task: #{task}"
+        task_class.parse(args, app) do |help|
+          puts help
+          exit
+        end
       end
-
-      # build queues
-      queues = parser.rounds.collect do |round|
-        round.each do |index|
-          task, args = tasks[index]
-          task.enq(*args)
+    end
+    
+    def set_signals
+      # 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
-
-        app.queue.clear
       end
-      queues.delete_if {|queue| queue.empty? }
 
-      queues
+      # 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
+          end
+        end
+      end
     end
     
     def run(queues)