tap 0.8.0 → 0.9.0

data/lib/tap/script.rb

@@ -1,362 +1,96 @@
 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
+  #
+  # Script is a mixed bag of methods encapsulating many scripting 
+  # functions like handling options and assembling usage information.
+  module Script
+    module_function
     
-    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
+    # Parses the input string as YAML, if the string matches the YAML document 
+    # specifier (ie it begins with "---\s*\n").  Otherwise returns the string.
+    #
+    #   str = {'key' => 'value'}.to_yaml    # => "--- \nkey: value\n"
+    #   Tap::Script.parse_yaml(str)            # => {'key' => 'value'}
+    #   Tap::Script.parse_yaml("str")          # => "str"
+    def parse_yaml(str)
+      str =~ /\A---\s*\n/ ? YAML.load(str) : str
     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
+    def split_argv(argv)
+      current = []
+      current_split = []
+      splits = [current_split]
+
+      argv.each do |arg|
+        if arg =~ /\A-{2}(\+*)\z/
+          current_split << current  unless current.empty?
+          current = []
+          current_split = (splits[$1.length] ||= [])
+        else
+          current << arg
         end
-        
-        self.send(key).concat(paths)
-      end
+      end
+      
+      current_split << current unless current.empty?
+      splits.delete_if {|split| split.nil? || split.empty? }
+      splits
     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
+    def next_arg(argv)
+      index = nil
+      argv.each_with_index do |arg, i|
+        if arg !~ /\A-/
+          index = i 
+          break
         end
-
-        resolve_paths(gem_config, spec)
-        collect_gem_paths(gem_config)
       end
+      index == nil ? nil : argv.delete_at(index)
     end
     
-    def arrayify(obj) # :nodoc:
-      case obj
-      when nil then []
-      when Array then obj
-      else
-        obj.to_s.strip.empty? ? [] : [obj]
+    # 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.quiet = true
+      opts.each do |opt, value| 
+        yield(opt, value)
       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  
+    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
-    
-    # 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)
+    def usage_options(opts)
+      opt_lines = []
+      opts.each do |long, short, mode, desc|
 
-      # 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
+        if desc.kind_of?(Class) && desc.include?(Tap::Support::Configurable)
+          key = desc.configurations.opt_map(long)
+          default = PP.singleline_pp(desc.configurations.default[key], "")
+          config_attr = desc.tdoc.find_configuration_named(key.to_s)
+          desc = config_attr.desc
+        end
 
-      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 * ','}")
+        short = short == nil ? "    " : "(#{short})"
+        opt_lines << "  %-25s %s      %s" % [long, short, desc]
       end
-
-      config
+      opt_lines.join("\n")
     end
-  
   end
 end

data/lib/tap/support/aggregator.rb

@@ -0,0 +1,55 @@
+module Tap
+  module Support
+  
+    # Aggregator allows thread-safe collection of Audits, organized
+    # by Audit#_current_source.    
+    class Aggregator < Monitor
+
+      def initialize
+        super
+        clear
+      end
+      
+      # Clears self of all audits.
+      def clear
+        synchronize { self.hash = Hash.new }
+      end
+      
+      # The total number of audits recorded in self.
+      def size
+        synchronize { hash.values.inject(0) {|sum, array| sum + array.length} }
+      end
+      
+      # True if size == 0
+      def empty?
+        synchronize { hash.empty? }
+      end
+      
+      # Stores the Audit according to _result._current_source
+      def store(_result)
+        synchronize { (hash[_result._current_source] ||= []) << _result }
+      end
+      
+      # Retreives all aggregated audits for the specified source.
+      def retrieve(source)
+        synchronize { hash[source] }
+      end
+      
+      # Retreives all audits for the input sources, joined into an array.
+      def retrieve_all(*sources)
+        synchronize do
+          sources.collect {|src| hash[src] }.flatten.compact
+        end
+      end
+      
+      # Converts self to a hash of (source, audits) pairs.
+      def to_hash
+        hash.dup
+      end
+      
+      protected
+      
+      attr_accessor :hash
+    end
+  end
+end