tap 0.8.0 → 0.9.0

data/lib/tap/generator/generators/package/package_generator.rb

@@ -1,38 +0,0 @@
-require 'shellwords'
-require 'pp'
-
-module Tap::Generator::Generators
-  class PackageGenerator < Rails::Generator::NamedBase # :nodoc:
-    include Shellwords
-    
-    attr_accessor :config, :argv, :package_file
-    
-    def initialize(*args)
-      super(*args)    
-      @destination_root  = Tap::App.instance[:root]
-      @app = Tap::App.instance
-  	end
-
-    def manifest
-      record do |m|
-        # read the config for the current root
-        @config = File.read Tap::Script.config_filepath(@app[:root])
-        
-        # at this point ARGV still includes the package name, 
-        # ie the commands should be argument 1  
-        # Note: it's important to setup argv this way, from a single argument,
-        # so that options can be included in the packaged arguments:
-        #   generate package raw_to_mgf "run --debug some/task"
-        # vs
-        #   generate package raw_to_mgf run --debug some/task
-        # where '--debug' is applied to generate rather than run
-        @argv = PP.singleline_pp(shellwords(ARGV[1].to_s), '')
-        
-        @package_file = class_path.empty? ? file_name : File.join(class_path, file_name)
-        filepath = "pkg/#{@package_file}.rb"
-        m.directory File.dirname(filepath)
-        m.template "package.erb", filepath
-      end
-    end
-  end
-end

data/lib/tap/generator/generators/package/templates/package.erb

@@ -1,186 +0,0 @@
-#############################################
-# HOW TO PACKAGE YOUR SCRIPT:
-# 1. Attend to the parts marked TODO
-# 2. Run rubyscript2exe as described below:
-#
-#   % rubyscript2exe <%= package_file %>.rb
-#
-# NOTES:
-# The 'rubyscript2exe' gem is required for packaging -- install using:
-#    % gem install rubyscript2exe
-#
-# The inputs you used when creating this script will supplied before 
-# the inputs you provide to the executable.  Hence if you used:
-#    % tap generate package "run --quiet some/task"
-#
-# These will be equivalent commands:
-#    % tap run --quiet some/task INPUT1 INPUT2
-#    % <%= package_file %>.exe INPUT1 INPUT2
-#
-# Feel free to adjust this script to behave as you like -- whatever this 
-# script does will be packaged into the executable. 
-#
-#############################################
-#
-# = Prompt Instructions
-# Enter an empty line to continue.
-
-require "tap"
-require "tap/script"
-
-# = TODO: add script requires
-#
-# Only what this script does will be packaged into the executable.
-# You MUST specify tasks and other files that are not loaded during
-# the 'rubyscript2exe' execution of this script.  Usually this means
-# require-ing any tasks that may get used.
-# 
-# require 'some/task'
-
-app = Tap::App.instance
-script = Tap::Script.instance
-
-# = TODO: check arguments
-# Make sure these are what you want later in this script they're unshifted
-# onto ARGV, ie they'll be hard-coded into the executable.
-script_argv = <%= argv %>
-
-# = TODO: check configurations
-#
-# This configures the packaged app the same as the current tap.yml
-# Check that the configurations look the way you want them to, or
-# set the executable to load it's own configurations, as by:
-#   config_file = Tap::Script.config_filepath(Dir.pwd)
-#   config = Tap::Script.read_config(config_file)  
-#
-app_config = %Q{<%= config.gsub(/^\s*$|^#.*$/m, '') %>}
-
-# = TODO: decide if you want to prompt when you get no inputs
-# This can be handy if you want to be able to interact with the 
-# packaged script.
-if ARGV.select {|arg| arg !~ /^-|^--/ }.empty?
-  puts Tap::Script.usage(__FILE__, "Prompt Instructions", :keep_headers => false)
-
-  while true
-    print "glob: "
-    line = gets.strip
-    break if line.empty?
-    
-    line = line[1..-2] if line =~ /^".*"$/
-    ARGV << line
-  end
-  puts
-end
-
-# nice give the user a second before you exit, especially if you have a prompt
-def exit(*args)
-	puts 
-	puts "Hit enter to exit."
-  ARGV.clear
-	gets
-	super
-end
-
-#############################################
-# These sections generally needs far less customization
-#############################################
-
-#
-# configure the app
-#
-begin
-  config = YAML.load(app_config)
-  config = {} if config == false
-  script.configure_app(config)
-rescue(Exception)
-  # catch errors and exit gracefully
-  # (errors usu from gem loading errors)
-  puts "Configuration error: #{$!.message}"
-  exit(1)
-end
-
-#
-# add modifications for rubyscript2exe 
-#
-require "rubyscript2exe"
-if RUBYSCRIPT2EXE.is_compiling?
-module Kernel
-  def exit_with_load_path_rewriting
-    [$", REQUIRE2LIB::LOADED].each do |loaded_files|
-      loaded_files.collect! do |load_path|
-        if File.expand_path(load_path) == load_path
-          $:.each do |root|
-            relative_load_path = Tap::Root.relative_filepath(File.expand_path(root), load_path, false)
-            unless relative_load_path == load_path
-              load_path = relative_load_path
-              break
-            end
-          end
-        end
-
-        load_path
-      end
-    end
-    exit_without_load_path_rewriting
-  end
-  
-  alias exit_without_load_path_rewriting exit
-  alias exit exit_with_load_path_rewriting
-end
-
-else
-  script.config.script_paths.unshift RUBYSCRIPT2EXE.appdir("../lib/script")
-  Dependencies.load_paths.unshift RUBYSCRIPT2EXE.appdir("../lib")
-  Dir.chdir(RUBYSCRIPT2EXE.exedir)
-end
-
-#
-# run before script
-#
-begin
-  eval(script.config.before.to_s)
-rescue
-  puts "Error in before script."
-  if app.options.debug
-    raise 
-  else
-    puts $!.message
-    exit(1)
-  end
-end
-
-# This is where the inputs used to create this script are unshifted
-# onto ARGV, ahead of the user inputs.  
-script_argv.reverse_each  {|arg| ARGV.unshift arg}
-  
-#
-# run the script -- note that the first argument
-# to ARGV is the script that gets run.
-#
-begin
-  load script.config.scripts[ARGV.shift]
-rescue
-  if app.options.debug
-    raise 
-  else
-    puts "Error."
-    puts $!.message
-  end
-end
-
-#
-# run after script
-#
-begin
-  eval(script.config.after.to_s) 
-rescue
-  puts "Error in after script."
-  if app.options.debug
-    raise 
-  else
-    puts $!.message
-    exit(1)
-  end
-end
-
-exit(0)

data/lib/tap/generator/generators/script/script_generator.rb

@@ -1,17 +0,0 @@
-module Tap::Generator::Generators
-  class ScriptGenerator < Rails::Generator::NamedBase # :nodoc:
-    def initialize(*args)
-      super(*args)    
-      @destination_root  = Tap::App.instance[:root]
-      @app = Tap::App.instance
-  	end
-
-    def manifest
-      record do |m|
-        script_path = @app.relative_filepath(:root, @app[:script])
-        m.directory class_path.empty? ? script_path : File.join(script_path, class_path)
-        m.template "script.erb", File.join(script_path, class_name.underscore + ".rb")
-      end
-    end
-  end
-end

data/lib/tap/script/run.rb

@@ -1,154 +0,0 @@
-# = Usage
-# tap run {options} -- {task options} task INPUTS...
-#
-# examples:
-#   tap run --help                 Prints this help
-#   tap run -- task --help         Prints help for task
-#
-
-require 'tap/script'
-
-app = Tap::App.instance
-script = Tap::Script.instance
-
-#
-# handle options
-#
-
-opts = [
-  ['--help', '-h', GetoptLong::NO_ARGUMENT, "Print this help"],
-  ['--debug', '-d', GetoptLong::NO_ARGUMENT, "Trace execution and debug"],
-  ['--force', '-f', GetoptLong::NO_ARGUMENT, "Force execution at checkpoints"],
-  ['--quiet', '-q', GetoptLong::NO_ARGUMENT, "Suppress logging"]]
-
-Tap::Script.handle_options(*opts) do |opt, value| 
-  case opt
-  when '--help'
-    puts Tap::Script.usage(__FILE__, "Usage", :keep_headers => false)
-    puts
-    puts Tap::Script.usage_options(opts)
-    exit
-    
-  when '--quiet', '--force', '--debug'
-    # simply track these have been set
-    opt =~ /^-+(\w+)/
-    app.options.send("#{$1}=", true)
-    
-  end
-end
-
-#
-# handle options for each specified task
-#
-argv = Tap::Script.split_arguments(ARGV)
-if argv.empty?
-  puts "no task specified"
-  exit
-end
-
-argv.each do |args|
-  ARGV.clear  
-  ARGV.concat(args)
-  
-  td = Tap::Script.next_arg(ARGV)
-  if td == 'rake'
-    # interpret 'rake' tds as specifications for 
-    # rake tasks and/or inputs:
-    #  tap run rake -T
-    #  tap run rake test
-    #
-    app.extend Tap::Support::Rake
-    
-    rake = Rake.application
-    options = rake.options
-    
-    # merge options down from app
-    app.options.marshal_dump.each_pair do |key, value|
-      options.send("#{key}=", value)
-    end
-    options.silent = true
-    
-    # now follow the same protocol as 
-    # in run, handling options
-    rake.init
-    rake.load_rakefile
-    
-    # takes the place of rake.top_level
-    if options.show_tasks
-      rake.display_tasks_and_comments
-      exit
-    elsif options.show_prereqs
-      rake.display_prerequisites
-      exit
-    else
-      rake.top_level_tasks.each do |task_name| 
-        task = app.task(task_name)
-        app.queue.enq(task)
-      end
-    end
-    
-    next
-  end
-  
-  # lookup the task
-  begin
-    task = (td.nil? ? nil : app.task(td))
-  rescue(Tap::App::LookupError)
-  end
-
-  # unless a Tap::Task was found, treat the
-  # args as a specification for Rake.
-  unless task.kind_of?(Tap::Task)
-    args.unshift(td) unless task == nil
-    args.unshift('rake')
-    redo
-  end
-  
-  # handle task configuration options  
-  Tap::Script.handle_task_options(task)
-
-  # queue the task with the remaining inputs
-  args = ARGV.collect! {|arg| Tap::App.parse_yaml(arg) }
-  app.queue.enq(task, *args)
-end
-ARGV.clear  
-
-#
-# set signals and run!
-#
-
-# info signal -- Note: windows does  
-# not support the INFO signal
-if RUBY_PLATFORM.index('mswin').nil?
-  Signal.trap("INFO") do
-   puts app.info
-  end
-  
-  puts "ctl-i prints information"
-end
-
-# interuption signal
-Signal.trap("INT") do
-  puts " interrupted!"
-  # prompt for decision
-  while true
-    print "stop, terminate, or resume? (s/t/r):"
-    case gets.strip
-    when /s(top)?/i 
-      app.stop
-      break
-    when /t(erminate)?/i 
-      app.terminate
-      break
-    when /r(esume)?/i 
-      break
-    else
-      puts "unexpected response..."
-    end
-  end
-end
-
-puts "ctl-c interupts execution"
-puts "beginning run..."
-
-app.run

data/lib/tap/support/batch_queue.rb

@@ -1,162 +0,0 @@
-module Tap
-  module Support
-    
-    # BatchQueue allows thread-safe enqueing and dequeing of tasks and inputs for 
-    # execution.  Until the task is dequeued, additional enqueuements will aggregate  
-    # the inputs into a batch.  The queue order is determined solely by the task;
-    # all accumulated inputs are dequeued at once.
-    #
-    #   # given tasks t1 and t2:
-    #   q = BatchQueue.new
-    #   q.enq t1, 1
-    #   q.enq t2, :a,:b,:c
-    #   q.enq t1, 2,3
-    #  
-    #   q.deq      # => [t1, [1,2,3]]
-    #   q.deq      # => [t2, [:a,:b,:c]]
-    #   q.deq      # => nil
-    #
-    # All BatchQueue methods are monitored such that they may only be accessed
-    # by one thread at a time, in order to ensure that transactions are atomic.
-    class BatchQueue
-      include MonitorMixin
-      
-      # creates a new BatchQueue
-      def initialize
-        super
-        self.clear
-      end
-      
-      # Clears the BatchQueue of all tasks and inputs.
-      def clear
-        synchronize do
-          self.inputs = {}
-          self.tasks = []
-        end
-      end
-      
-      # Returns the number of enqueued tasks (same as length)
-      def size
-        tasks.length
-      end
-      
-      # Returns the number of enqueued tasks (same as size)
-      def length
-        size
-      end
-      
-      # True if no tasks are enqueued
-      def empty?
-        tasks.empty?
-      end
-      
-      # Enqueues the inputs to the task.  If the task has not already been added to the 
-      # queue, then the task will be pushed onto the queue and the inputs registered.  
-      # Otherwise, the inputs will be added to the registered inputs; the task will 
-      # not be added to the queue twice.  If the task is batched, then each task in the
-      # batch will be enqueued in order, with the same inputs (Audit inputs will be forked 
-      # for each task).
-      def enq(task, *inputs)
-        synchronize do 
-          batch = task.batch
-          batch.each do |t|
-            tasks << t unless tasks.include?(t)
-            
-            inputs = inputs.collect do |result| 
-              result.kind_of?(Support::Audit) ? result._fork : result
-            end if batch.length > 1
-            
-            self.inputs[t] = [] unless self.inputs[t]
-            self.inputs[t].concat(inputs)
-          end
-        end
-      end
-      
-      # Enqueues the task and input, then prioritizes the task to the front of the queue.
-      def priority_enq(task, *inputs)
-        synchronize do
-          enq(task, *inputs)
-          prioritize(task)
-        end
-      end
-      
-      # Moves the task to the front of the queue.  Does not queue a task if the task is not 
-      # already in the queue.  If the task is batched, then each task in the batch will be 
-      # prioritized in order.
-      def prioritize(task)
-        synchronize do 
-          task.batch.reverse_each do |t|
-            tasks.unshift(t) if tasks.delete(t)
-          end
-        end
-      end
-      
-      # Moves the task to the back of the queue.  Does not queue a task if the task is not 
-      # already in the queue.  If the task is batched, then each task in the batch will be 
-      # marginalized in order.
-      def marginalize(task)
-        synchronize do 
-          task.batch.each do |t|
-            tasks.push(t) if tasks.delete(t)
-          end
-        end
-      end
-
-      # Returns true if the task is executable with the currently registered inputs
-      # (as determined by task.executable?).
-      def executable?(task)
-        synchronize do 
-          task.executable?(inputs[task])
-        end
-      end
-
-      # Dequeues the next executable task, or the specified task (even if it is not
-      # executable).  The task and the current inputs for the task are returned in 
-      # an array like: [task, inputs]. Returns nil if the task is not in the queue.
-      def deq(task=nil)
-        synchronize do   
-          task = peek if task.nil?
-
-          if tasks.include?(task)
-            [tasks.delete(task), inputs.delete(task)]
-          else
-            nil
-          end
-        end
-      end
-      
-      # Returns the next executable task, or nil if no queued tasks are executable.
-      # The task is not dequeued.
-      def peek
-        synchronize do  
-          tasks.each do |task|
-            next unless executable?(task) 
-            return task
-          end
-          nil
-        end
-      end
-      
-      # Returns the number of executable tasks in the queue.
-      def num_executable
-        synchronize do  
-          tasks.inject(0) do |count, task|
-            executable?(task) ? count + 1 : count
-          end
-        end
-      end
-      
-      # Returns the number of non-executable tasks in the queue.
-      def num_not_executable
-        synchronize do  
-          size - num_executable
-        end
-      end
-
-      protected
-      
-      attr_accessor :inputs, :tasks
-      
-    end 
-  end
-end