tap 0.7.9 → 0.8.0

data/lib/tap/script.rb

@@ -0,0 +1,362 @@
+require 'getoptlong'
+require 'singleton'
+autoload(:PP, "pp")
+
+module Tap
+  module Support
+    autoload(:TDoc, 'tap/support/tdoc')
+  end
+
+  # == UNDER CONSTRUCTION
+  class ScriptConfig < OpenStruct
+    class << self
+      def defaults
+        {:gems => [], 
+        :load_once_paths => [], 
+        :load_paths => ["lib"],
+        :script_paths => ["script"]}
+      end
+      
+      def spec_filepath(dir=nil)
+        dir == nil ? "tapspec.yml" : File.join(dir, "tapspec.yml")
+      end
+    end
+    
+    def initialize(config={}, app=Tap::App.instance)
+      super(
+        :gemspecs => [], 
+        :load_once_paths => [], 
+        :load_paths => [],
+        :script_paths => [])
+        
+      config = ScriptConfig.defaults.merge(config)
+      resolve_paths(config, app)
+      collect_gem_paths(config)
+
+      # add additional configurations
+      config.each_pair do |key, value|
+        next if self.respond_to?(key)
+        self.send("#{key}=", value)
+      end 
+      
+      self.load_once_paths.uniq!
+      self.load_paths.uniq!
+      self.script_paths.uniq!
+    end
+    
+    def scripts
+      scripts = {}
+      self.script_paths.each do |dir|
+        Dir.glob(File.expand_path(File.join(dir, "**/*.rb"))).each do |file|
+          script = Tap::App.relative_filepath(dir, file).chomp(".rb")
+          raise "script name confict: #{script}" if scripts.include?(script)
+          scripts[script] = file
+        end
+      end
+
+      # allow gem scripts to overrride default scripts
+      # (hence do this second)
+      script_dir = File.expand_path(File.join( File.dirname(__FILE__), "script"))
+      Dir.glob( script_dir + "/**/*.rb" ).each do |file|
+        script = Tap::App.relative_filepath(script_dir, file).chomp(".rb")
+        scripts[script] = file unless scripts.include?(script)
+      end
+
+      scripts
+    end
+    
+    protected
+    
+    # Resolve configuration paths, :load_paths, :load_once_paths, :script_paths,
+    # to full paths using the provided app, or by expanding the paths relative to
+    # the full_gem_path of the provided gemspec. 
+    def resolve_paths(config, app_or_gemspec) # :nodoc:
+      # resolve and collect paths
+      [:load_paths, :load_once_paths, :script_paths].each do |key|
+        paths = arrayify(config[key])
+        
+        paths.collect! do |path|
+          case app_or_gemspec
+          when Tap::App 
+            app_or_gemspec.filepath(path)
+          when Gem::Specification
+            expanded = File.expand_path(path, app_or_gemspec.full_gem_path)
+            unless expanded.index(app_or_gemspec.full_gem_path) == 0
+              raise "'#{path}' for '#{app_or_gemspec.name}' resolves to a non-gem directory"
+            end
+            expanded
+          end
+        end
+        
+        self.send(key).concat(paths)
+      end
+    end
+    
+    # Recursively collects paths from the gems specfied in config[:gems],
+    # using tap specification file for the gem as determined by 
+    # ScriptConfig#spec_filepath 
+    def collect_gem_paths(config) # :nodoc:
+      arrayify(config[:gems]).each do |string|
+        # figure the version of the gem, by default >= 0.0.0
+        string =~ /^([^<=>]*)(.*)$/
+        gem_name, version = $1, $2
+        version = ">= 0.0.0" if version.empty?
+
+        # load the gem and get the spec
+        gem(gem_name, version)
+        spec = Gem.loaded_specs[gem_name]
+
+        # prevent an infinite loop...
+        next if self.gemspecs.include?(spec)
+        self.gemspecs << spec
+
+        # load gem config from the spec, if possible,
+        # otherwise use the defaults for the gem
+        tap_spec_file = ScriptConfig.spec_filepath(spec.full_gem_path)
+        gem_config = if File.exists?(tap_spec_file)
+          YAML.load_file(tap_spec_file).symbolize_keys 
+        else
+          ScriptConfig.defaults
+        end
+
+        resolve_paths(gem_config, spec)
+        collect_gem_paths(gem_config)
+      end
+    end
+    
+    def arrayify(obj) # :nodoc:
+      case obj
+      when nil then []
+      when Array then obj
+      else
+        obj.to_s.strip.empty? ? [] : [obj]
+      end
+    end
+  end
+  
+  # == UNDER CONSTRUCTION
+  #
+  # Script is a mixed bag of methods encapsulating many scripting 
+  # functions like reconfiguring an application, handling options 
+  # and assembling usage information. 
+  class Script
+    
+    class << self
+      def config_filepath(dir=nil)
+        dir == nil ? "tap.yml" : File.join(dir, "tap.yml")
+      end
+
+      def read_config(config_file)
+        config = if File.exists?(config_file)
+          config_str = ERB.new( File.read(config_file) ).result
+          config = config_str.empty? ? {} : YAML.load(config_str)
+          config == false ? {} : config
+        else
+          {}
+        end
+
+        unless config.kind_of?(Hash)
+          raise "cannot parse file contents into a hash using YAML: #{config_file}"
+        end
+
+        config.symbolize_keys
+      end
+      
+      def split_arguments(argv, separator_regexp=/^-{2}$/)
+        splits = []
+        current = []
+        argv.each do |arg|
+          if arg =~ separator_regexp
+            splits << current unless current.empty?
+            current = []
+          else
+            current << arg
+          end
+        end
+        splits << current unless current.empty?
+        splits
+      end
+      
+      def next_arg(argv)
+        index = nil
+        argv.each_with_index do |arg, i|
+          if arg !~ /^-/
+            index = i 
+            break
+          end
+        end
+        index == nil ? nil : argv.delete_at(index)
+      end
+      
+      def usage(program_file, *sections)
+        options = sections.last.kind_of?(Hash) ? sections.pop : {}
+        options = {:keep_headers => true}.merge(options)
+        comment = Support::TDoc.usage(program_file, sections, options[:keep_headers])
+        comment.rstrip + "\n"
+      end
+      
+      def usage_options(opts)
+        opt_lines = ["Options:\n"]
+        opts.each do |long, short, mode, desc|
+          short = short == nil ? "    " : "(#{short})"
+          opt_lines << "  %-25s %s      %s" % [long, short, desc]
+        end
+        opt_lines.join("\n")
+      end
+      
+      # Handles options using GetoptLong, and passes each option and
+      # value in ARGV to the block. 
+      #
+      #--
+      # expect [long, <short>, type, desc]
+      #++
+      def handle_options(*options)
+        options = options.collect do |opt|
+          opt = opt[0..-2]
+          opt.compact
+        end
+
+        opts = GetoptLong.new(*options)
+        opts.each do |opt, value| 
+          yield(opt, value)
+        end
+      end
+           
+      def handle_task_options(task)
+        return task.handle_options if task.respond_to?(:handle_options)
+        
+        config = {}
+        opt_map = {}
+        opts = task.class.configurations.collect do |declaration_class, key, value, attributes|
+          long, short, opt_type, desc = config_to_opt(key, value, attributes)
+          opt_map[long] = key
+          [long, short, opt_type, desc]
+        end
+        opts << ['--help', '-h', GetoptLong::NO_ARGUMENT, "Print this help."]
+
+        handle_options(*opts) do |opt, value|
+          case opt
+          when '--help'
+            class_doc = Tap::Support::TDoc[task.class]
+            if class_doc == nil
+              puts "could not find help for '#{task.class}'" 
+              exit
+            end
+            
+            sections = class_doc.comment_sections(/Description|Usage/i, true)
+            opt_lines = opts.collect do |long, short, opt_type, desc|
+              key = opt_map[long]
+              default = PP.singleline_pp(task.class.configurations.default[key], "")
+              config_attr = class_doc.find_configuration_named(key.to_s)
+              
+              short = "(#{short})" unless short.to_s.empty?
+              if desc == nil && config_attr != nil
+                desc = config_attr.desc + " (#{default})" 
+              end
+              
+              "  %-25s %-5s %s" % [long, short, desc]
+            end
+            
+            puts %Q{#{task.class.to_s}
+#{sections["Description"]}
+
+Usage:
+#{sections["Usage"]}
+
+Options:
+#{opt_lines.join("\n")}}
+            exit
+
+          else
+            key = opt_map[opt]
+            config[key] = YAML.load(value)
+          end
+        end
+
+        # reconfigure task
+        task.batch.each do |t|
+          t.config = config
+        end
+      end
+
+      protected
+      
+      def config_to_opt(key, value, attributes)
+        attributes = {
+          :long => key,
+          :short => nil,
+          :opt_type => GetoptLong::REQUIRED_ARGUMENT,
+          :desc => nil
+        }.merge(attributes)
+        
+        long = attributes[:long]
+        attributes[:long] = "--#{long}" unless long =~ /^-{2}/
+        
+        short = attributes[:short].to_s
+        attributes[:short] = "-#{short}" unless short.empty? || short =~ /^-/
+        
+        [attributes[:long], attributes[:short], attributes[:opt_type], attributes[:desc]]
+      end
+    end
+    
+    include Singleton
+    
+    attr_accessor :config
+    
+    def reset
+      self.config = nil  
+    end
+    
+    # Configures the app with the input configurations.   
+    def configure_app(app_config={}, app=Tap::App.instance)
+      app_config = app_config ? app_config.symbolize_keys : {}
+
+      # partition script_config from config
+      script_config = ScriptConfig.defaults
+      script_config_keys = script_config.keys
+      app_config.delete_if do |key, value| 
+        if script_config_keys.include?(key)
+          script_config[key] = value
+          true
+        else
+          false
+        end
+      end
+       
+      # reconfigure the current app with remaining keys
+      # this must be done first so load paths can be 
+      # resolved using the most current app config
+      app.reconfigure(app_config) do |key, value|
+        # collect unknown options
+        script_config[key] = value
+      end
+       
+      # define the config, using the newly configured app
+      self.config = ScriptConfig.new(script_config, app)
+
+      # add load paths to system load paths
+      # echos Rail::Initializer.set_load_path
+      tap_gem_dir = File.expand_path(File.dirname(__FILE__) + "/..")
+      config.load_paths.unshift(tap_gem_dir)
+      config.load_paths.reverse_each do |dir| 
+        $LOAD_PATH.unshift(dir) #if File.directory?(dir) 
+      end
+      $LOAD_PATH.uniq!
+
+      # set Dependencies load paths and freeze setting of load_paths
+      # echos Rail::Initializer.set_autoload_paths
+      Dependencies.load_once_paths = config.load_once_paths
+      Dependencies.load_paths = config.load_paths
+
+      extra = Dependencies.load_once_paths - Dependencies.load_paths
+      unless extra.empty?
+        raise(
+          "load_once_paths must be a subset of the load_paths.\n" +
+          "Extra items in load_once_paths: #{extra * ','}")
+      end
+
+      config
+    end
+  
+  end
+end

data/lib/tap/script/console.rb

@@ -1,3 +1,31 @@
+# = Usage
+# tap console {options}
+#
+# = Description
+# Opens up an IRB session with Tap initialized with configurations 
+# in tap.yml. Access the Tap::App.instance through 'app'
+#
+
+require 'tap/script'
+
+#
+# handle options
+#
+
+opts = [
+  ['--help', '-h', GetoptLong::NO_ARGUMENT, "Print this help."]]
+  
+Tap::Script.handle_options(*opts) do |opt, value| 
+  case opt
+  when '--help'
+    puts Tap::Script.usage(__FILE__, "Usage", "Description", :keep_headers => false)
+    puts
+    puts Tap::Script.usage_options(opts)
+    exit
+
+  end
+end
+
 require "irb"
 
 def app

data/lib/tap/script/destroy.rb

@@ -1,8 +1,20 @@
-require 'tap/generator'
+begin
+  $:.unshift File.dirname(__FILE__) + "/../../../vendor"
+  require 'tap/generator'
+rescue(LoadError)
+  puts "The 'rails' gem is required for destroyers -- install using:"
+  puts "  % gem install rails"
+  exit
+end
+
 Rails::Generator::Base.use_tap_sources!
 
 require 'rails_generator/scripts/destroy'
 generator = ARGV.shift
+
+# Ensure help is printed if help is the first argument
+generator = nil if generator == '--help' || generator == '-h'
+
 script = Rails::Generator::Scripts::Destroy.new
 script.extend Tap::Generator::Usage
 script.run(ARGV, :generator => generator)

data/lib/tap/script/generate.rb

@@ -1,8 +1,20 @@
-require 'tap/generator'
+begin
+  $:.unshift File.dirname(__FILE__) + "/../../../vendor"
+  require 'tap/generator'
+rescue(LoadError)
+  puts "The 'rails' gem is required for generators -- install using:"
+  puts "  % gem install rails"
+  exit
+end
+
 Rails::Generator::Base.use_tap_sources!
 
 require 'rails_generator/scripts/generate'
 generator = ARGV.shift
+
+# Ensure help is printed if help is the first argument
+generator = nil if generator == '--help' || generator == '-h'
+
 script = Rails::Generator::Scripts::Generate.new
 script.extend Tap::Generator::Usage
 script.run(ARGV, :generator => generator)

data/lib/tap/script/run.rb

@@ -1,86 +1,130 @@
+# = 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
-task_config = {}
+script = Tap::Script.instance
 
 #
 # handle options
 #
-require 'getoptlong'
 
-opts = GetoptLong.new(
-['--app-config', '-a', GetoptLong::REQUIRED_ARGUMENT],# "Specifies an application config file"],
-['--config', '-c', GetoptLong::REQUIRED_ARGUMENT],# "Specifies configurations for the task."],
-['--quiet', '-q', GetoptLong::NO_ARGUMENT],# "Suppresses logging"],
-['--force', '-f', GetoptLong::NO_ARGUMENT],# "Force execution at checkpoints."],
-['--debug', '-d', GetoptLong::NO_ARGUMENT],# "Trace execution and debug."],
-['--help', '-h', GetoptLong::OPTIONAL_ARGUMENT])#, "Display help for app, or specified task."])
+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"]]
 
-opts.each do |opt, value| 
+Tap::Script.handle_options(*opts) do |opt, value| 
   case opt
   when '--help'
-    puts "help!"
-    exit
-  
-    if value.empty?
-      help
-    else
-      task = task(value)
-      puts task.class.help
-      puts "Default Config:"
-      puts task.class.default_config.stringify_keys.to_yaml
-    end
-  
-  when '--usage'
-    puts "usage!"
+    puts Tap::Script.usage(__FILE__, "Usage", :keep_headers => false)
+    puts
+    puts Tap::Script.usage_options(opts)
     exit
-  
-  when '--app-config'
-    config = Tap::App.parse_yaml(value)
-    if config.kind_of?(String)
-      raise "application config file does not exist: #{config}" unless File.exists?(config)
-      config = Tap::App.read_erb_yaml(config)
-    end
-    app.reconfigure(config)
-  
-  when '--config'
-    task_config = Tap::App.parse_yaml(value)
-    if task_config.kind_of?(String)
-      raise "task config file does not exist: #{config}" unless File.exists?(config)
-      task_config = Tap::App.read_erb_yaml(config)
-    end
-
+    
   when '--quiet', '--force', '--debug'
     # simply track these have been set
     opt =~ /^-+(\w+)/
     app.options.send("#{$1}=", true)
-  
-  else
-    puts "unknown option: #{opt}"
-    exit
+    
   end
 end
 
 #
-# gather arguments 
-# (be sure to clear for gets during interruption)
-
-if ARGV.empty?
+# handle options for each specified task
+#
+argv = Tap::Script.split_arguments(ARGV)
+if argv.empty?
   puts "no task specified"
   exit
 end
 
-td = ARGV.shift
-args = ARGV.collect {|arg| Tap::App.parse_yaml(arg) }
-ARGV.clear  
+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)
 
-task = app.task(td, task_config)
+  # 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
-Signal.trap("INFO") do
- puts app.info
+# 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
@@ -104,8 +148,7 @@ Signal.trap("INT") do
   end
 end
 
-puts "ctl-i prints information"
 puts "ctl-c interupts execution"
 puts "beginning run..."
 
-app.run(task, *args)
+app.run