tap 0.8.0 → 0.9.0

data/lib/tap/cmd/run.rb

@@ -0,0 +1,156 @@
+# = 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'
+env = Tap::Env.instance
+app = Tap::App.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 "Options:"
+    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
+#
+rounds = Tap::Script.split_argv(ARGV).collect do |argv|
+  argv.each do |args|
+    ARGV.clear  
+    ARGV.concat(args)
+   
+    td = Tap::Script.next_arg(ARGV)
+    case td
+    when 'rake', nil  
+      # remove --help as this will print the Rake help
+      ARGV.delete_if do |arg|
+        if arg == "--help"
+          env.log(:warn, "ignoring --help config for rake command") 
+          true
+        else
+          false
+        end
+      end
+      next if ARGV.empty?
+      
+      rake = env.rake_setup
+    
+      # takes the place of rake.top_level
+      if rake.options.show_tasks
+        rake.display_tasks_and_comments
+        exit
+      elsif rake.options.show_prereqs
+        rake.display_prerequisites
+        exit
+      else
+        rake.top_level_tasks.each do |task_name| 
+          app.task(task_name).enq
+        end
+      end
+      
+    else  
+      begin
+        # attempt lookup the task class
+        task_class = app.task_class(td)
+      rescue(Tap::App::LookupError)
+      end
+
+      # unless a Tap::Task was found, treat the
+      # args as a specification for Rake.
+      if task_class == nil || !task_class.include?(Tap::Support::Configurable)
+        args.unshift('rake')
+        redo
+      end
+    
+      # now let the class handle the argv
+      ARGV.collect! {|str| Tap::Script.parse_yaml(str) }
+      ARGV.unshift(td)
+      task_class.argv_enq(app)
+    end
+  end
+
+  app.queue.clear
+end
+ARGV.clear
+
+rounds.delete_if {|round| round.empty? }
+if rounds.empty?
+  puts "no task specified"
+  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
+  
+  puts "ctl-i prints information"
+end
+
+# interuption signal
+if signals.include?("INT")
+  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"
+end
+
+#
+# enque tasks and run!
+#
+puts "beginning run..."
+rounds.each_with_index do |queue, i|
+  app.queue.concat(queue)
+  app.run
+end

data/lib/tap/constants.rb

@@ -0,0 +1,4 @@
+module Tap
+  VERSION="0.9.0" 
+  WEBSITE="http://tap.rubyforge.org"
+end

data/lib/tap/dump.rb

@@ -0,0 +1,57 @@
+module Tap
+  # == Description
+  # A primitive dump task (still in development) to print  
+  # application results to a file or IO.  The results are
+  # printed in a tap-readable format allowing the use of
+  # dumped results as inputs to other tasks.
+  #
+  # Usually dump is used as the final task in a round of
+  # tasks executed through 'tap run'.
+  # === Usage
+  #   % tap run -- [your tasks] --+ dump filepath
+  #
+  # If no filepath is specified, the results are printed
+  # to stdout.
+  #
+  class Dump < Tap::FileTask
+    
+    config :datetime_format, '%Y-%m-%d %H:%M:%S'
+    config :print_audit, true
+    config :print_date, true
+    
+    #config :overwrite
+    
+    def process(target=$stdout)
+      case target
+      when IO then dump_to(target)
+      else
+        log_basename(:dump, target)
+        prepare(target)
+        File.open(target, "wb") {|file| dump_to(file) }
+      end
+    end
+    
+    def dump_to(io)
+      trails = []
+      results = {}
+      app.aggregator.to_hash.each_pair do |src, _results|
+        name = src.respond_to?(:name) ? src.name : ''
+
+        results["#{name} (#{src.object_id})"] = _results.collect {|_audit| _audit._current }
+        _results.each {|_audit| trails << _audit._to_s }
+      end
+      
+      if print_audit
+        io.puts "# audit:"
+        trails.each {|trail| io.puts "# #{trail.gsub("\n", "\n# ")}"}
+      end
+        
+      if print_date
+        io.puts "# date: #{Time.now.strftime(datetime_format)}"
+      end
+        
+      YAML::dump(results, io)
+    end
+    
+  end
+end

data/lib/tap/env.rb

@@ -0,0 +1,316 @@
+require 'tap/root'
+require 'singleton'
+autoload(:PP, "pp")
+
+module Tap
+
+  # == Under Construction
+  #
+  # Env manages configuration of the Tap execution environment, including the 
+  # specification of gems that should be available through the tap command.
+  class Env
+    
+    # A variety of configuration loading/handling methods for use in 
+    # conjuction with Tap::Env, to aid in configuring the running
+    # environment for Tap.
+    module Configuration 
+      module_function
+      
+      # Templates the input filepath using ERB then loads it as YAML.  
+      # Returns an empty hash if the file doesn't exist, or loads to
+      # nil or false (as for an empty file).  Raises an error if the
+      # filepath doesn't load to a hash.
+      def read_config(filepath)
+        return {} if !File.exists?(filepath) || File.directory?(filepath)
+        
+        input = ERB.new(File.read(filepath)).result
+        config = YAML.load(input)
+      
+        case config
+        when Hash then config
+        when nil, false then {}
+        else
+          raise "expected hash from config file: #{filepath}"
+        end
+      end
+      
+      # Partitions a configuration hash into environment, execution,
+      # and application configurations, as determined by ENV_CONFIG_KEYS
+      # and EXE_CONFIG_KEYS.  All non-env, non-exe configurations are
+      # considered application configurations.
+      def partition_configs(hash, *sets)
+        partitions = Array.new(sets.length + 1) { Hash.new }
+
+        hash.each_pair do |key, value|
+          index = 0
+          sets.each do |keys|
+            break if keys.include?(key)
+            index += 1
+          end
+          
+          partitions[index][key] = value
+        end
+        
+        partitions
+      end
+      
+      # Joins the input configuration hashes, concatenating
+      # values for matching keys.  Values will be made into
+      # arrays if they are not so already; duplicate values
+      # are removed from the result on a key-per-key basis. 
+      def join_configs(*configs)
+        merge = {}
+        configs.each do |hash|
+          hash.each_pair do |key, values|
+            values = [values] unless values.kind_of?(Array)
+            (merge[key] ||= []).concat(values)
+          end
+        end
+        merge.values.each {|values| values.uniq! }
+        merge
+      end
+    end
+    
+    include Configuration
+    include Singleton
+    
+    DEFAULT_CONFIG_FILE = "tap.yml"
+    
+    # Currently these are ALWAYS included.
+    DEFAULT_CONFIG = {
+      "load_paths" => ["lib"],
+      "load_once_paths" => [],
+      "config_paths" => [],
+      "command_paths" => ["cmd"],
+      "gems" => [],
+      "generator_paths" => ["lib/generators"]
+    }
+    
+    attr_reader :config
+    attr_accessor :logger
+
+    def initialize
+      @config = nil
+      @logger = nil
+      # @on_handle_unknown_configs = nil
+      reset
+    end
+    
+    def debug_setup
+      $DEBUG = true
+      logger.level = Logger::DEBUG
+    end
+    
+    def rails_setup(app=Tap::App.instance)
+      Object.const_set('RAILS_ROOT', app.root)
+      Object.const_set('RAILS_DEFAULT_LOGGER', app.logger)
+      Dependencies.log_activity = app.debug?
+    end
+    
+    def rake_setup(argv=ARGV, app=Tap::App.instance)
+      Tap::Support.autoload(:Rake, 'tap/support/rake')
+
+      # setup
+      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
+    
+      # run as if from command line using argv
+      current_argv = ARGV.dup
+      begin
+        ARGV.concat(argv)
+        
+        # now follow the same protocol as 
+        # in run, handling options
+        rake.init
+        rake.load_rakefile
+      ensure
+        ARGV.clear
+        ARGV.concat(current_argv)
+      end
+      
+      rake
+    end
+    
+    # Resets Env.  Load paths (load_paths and load_once_paths) are
+    # not reset unless dependencies==true; in which case Dependencies
+    # are cleared before load paths are cleared.  The load paths added
+    # to $LOAD_PATH are not cleared.
+    #
+    # Generally not recommended.
+    def reset
+      unless @config == nil
+        $LOAD_PATH.delete_if {|path| config['load_paths'].include?(path) }
+      
+        Dependencies.clear
+        Dependencies.load_paths.delete_if {|path| config['load_paths'].include?(path) }
+        Dependencies.load_once_paths.delete_if {|path| config['load_once_paths'].include?(path) }
+      end
+      
+      @config = {}
+      DEFAULT_CONFIG.keys.each do |key|
+        @config[key] = []
+      end
+    end
+
+    # Logs the action and message at the input level (default INFO).
+    # Logging is suppressed if no logger is set.
+    def log(action, msg="", level=Logger::INFO)
+      logger.add(level, msg, action.to_s) if logger
+    end
+    
+    # Configures the specified App using the configurations in config_file.
+    # Loading of environement configurations occcurs via load_env_config;
+    # all environment paths are resolved using the app, after the app has
+    # been configured. 
+    
+    # Loads environment configurations from the specified path. If a directory 
+    # is given as path, then the DEFAULT_CONFIG_FILE relative to that location 
+    # will be loaded.  The loading cycle recurses as specified by the configurations.
+    #
+    # Configuration paths are expanded relative to the parent directory
+    # of the loaded file.  Raises an error if non-env configuration are 
+    # found (as determined by Tap::Env::Configurtion::ENV_CONFIG_KEYS).
+    def load_config(path, root=Tap::Root.new, &block)
+      path = File.join(path, DEFAULT_CONFIG_FILE) if File.directory?(path)
+      path = File.expand_path(path)
+
+      # prevent infinite looping
+      config_paths = config['config_paths']
+      return false if config_paths.include?(path)
+      
+      # load config
+      log(:load_config, path, Logger::DEBUG)
+      config_paths << path
+      
+      config = read_config(path)
+      config['root'] = File.dirname(path) unless config['root']
+      
+      configure(config, root) do |configured_root, other_configs|
+        if block_given?
+          yield(configured_root, path, other_configs)
+        else
+          log(:warn, "ignoring configs: #{path} (#{other_configs.keys.join(',')})", Logger::WARN) 
+        end
+      end
+      
+    end
+    
+    def configure(config, root=Tap::Root.new, &block)
+      root_configs, env_configs, other_configs = partition_configs(config, ['root', 'directories', 'absolute_paths'], DEFAULT_CONFIG.keys)
+      env_configs = join_configs(DEFAULT_CONFIG, env_configs) 
+      
+      # assign root configs
+      root.send(:assign_paths,
+        root_configs['root'] || root.root, 
+        root_configs['directories'] || root.directories, 
+        root_configs['absolute_paths'] || root.absolute_paths)
+      
+      # handle unknown configs (handle before setting 
+      # env configs in case the configs modify root)
+      unless other_configs.empty?
+        if block_given?
+          yield(root, other_configs)
+        else
+          log(:warn, "ignoring configs: (#{other_configs.keys.join(',')})", Logger::WARN) 
+        end
+      end
+        
+      # load gems and configurations 
+      gem_paths = env_configs.delete('gems').collect do |gem_name| 
+        full_gem_path(gem_name)
+      end
+      config_paths = env_configs.delete('config_paths') + gem_paths
+      config_paths.each {|path| load_config(root[path], &block) }
+      
+      # assign env configs
+      env_configs.each_pair do |key, value|
+        case key
+        when 'load_paths' 
+          assign_paths(root, value, self.config[key], $LOAD_PATH, Dependencies.load_paths)
+        when 'load_once_paths'
+          assign_paths(root, value, self.config[key], Dependencies.load_once_paths)
+        when /_paths$/ 
+          assign_paths(root, value, self.config[key])
+        else
+          handle_unknown_config(key, value)
+        end
+      end
+
+      true
+    end
+    
+    # Loads env configurations from a gem, specifically from
+    # gemspec.full_gem_path.  A gem version can be specified
+    # in the name, like 'gem >= 1.2'.
+    def full_gem_path(gem_name)
+      # figure the version of the gem, by default >= 0.0.0
+      gem_name =~ /^([^<=>]*)(.*)$/
+      name, version = $1, $2
+      version = ">= 0.0.0" if version.empty?
+
+      # load the gem and get the spec
+      gem(name, version)
+      spec = Gem.loaded_specs[name]
+      
+      if spec == nil
+        log(:warn, "unknown gem: #{gem_name}", Logger::WARN)
+      end
+      
+      spec.full_gem_path
+    end
+    
+    def load_gem(gem_name)
+      load_config(full_gem_path(gem_name))
+    end
+    
+    # Searches for and returns all .rb files under each of the command_paths
+    # as well as the default tap commands.  Commands with conflicting names
+    # raise an error; however, user commands are allowed to override the
+    # default tap commands and will NOT raise an error.
+    def commands
+      commands = {}
+      config['command_paths'].each do |path|
+        pattern = File.join(path, "**/*.rb")
+        
+        Dir.glob(pattern).each do |file|
+          cmd = Tap::App.relative_filepath(path, file).chomp(".rb")
+          raise "command name confict: #{cmd}" if commands.include?(cmd)
+          commands[cmd] = file
+        end
+      end
+
+      # allow all other scripts to override default scripts
+      # (hence do this second)
+      tap_command_dir = File.expand_path(File.join( File.dirname(__FILE__), "cmd"))
+      Dir.glob( tap_command_dir + "/**/*.rb" ).each do |file|
+        cmd = Tap::App.relative_filepath(tap_command_dir, file).chomp(".rb")
+        commands[cmd] = file unless commands.include?(cmd)
+      end
+
+      commands
+    end
+    
+    protected
+    
+    def assign_paths(root, paths, *targets)
+      paths = paths.collect {|path| root[path]}
+      targets.each do |array|
+        paths.reverse_each do |path| 
+          array.unshift(path)
+        end
+        array.uniq!
+      end
+    end
+    
+    def handle_unknown_config(key, value)
+      raise "unknown env config: #{key}"
+    end
+  end
+end