tap 0.19.0 → 1.3.0

data/lib/tap/env/cache.rb

@@ -0,0 +1,87 @@
+require 'tap/env/path'
+
+autoload(:Gem, 'rubygems')
+autoload(:RbConfig, 'rbconfig')
+module Tap
+  class Env
+    class Cache
+      attr_reader :cache_home
+      
+      def initialize(dir=Dir.pwd, debug=false)
+        @cache_home = File.expand_path("#{RbConfig::CONFIG['RUBY_INSTALL_NAME']}/#{RUBY_VERSION}", dir)
+        @debug = debug
+      end
+      
+      def select(dependencies)
+        if dependencies.kind_of?(String)
+          dependencies = dependencies.split(':')
+        end
+        
+        paths = []
+        dependencies.collect! do |dep|
+          dep.kind_of?(String) ? dep.split(',', 2) : dep
+        end.each do |(pattern, version_requirements)|
+          pattern = Regexp.new(pattern) if pattern.kind_of?(String)
+          paths.concat search(pattern, version_requirements)
+        end
+        
+        paths.uniq!
+        paths
+      end
+      
+      def search(pattern, version_requirements)
+        dependency = Gem::Dependency.new(pattern, version_requirements)
+        
+        sources = {}
+        Gem.source_index.search(dependency).sort_by do |spec|
+          spec.version
+        end.reverse_each do |spec|
+          sources[spec.name] ||= spec
+        end
+        
+        paths = []
+        sources.values.sort_by do |spec|
+          spec.name
+        end.each do |spec|
+          unless File.exists? File.expand_path(Path::FILE, spec.full_gem_path)
+            next
+          end
+          
+          path = File.join(cache_home, spec.full_name)
+          gem_path = spec.full_gem_path
+          
+          unless FileUtils.uptodate?(path, [gem_path, __FILE__])
+            unless File.exists?(cache_home)
+              FileUtils.mkdir_p(cache_home)
+            end
+            
+            if @debug 
+              $stderr.puts(App::LOG_FORMAT % [' ', nil, :generate, spec.full_name])
+            end
+            
+            File.open(path, 'w') do |io|
+              io << generate(spec)
+            end
+          end
+          
+          paths << path
+        end
+        
+        paths
+      end
+      
+      def generate(spec)
+        lines = Env.generate(
+          :dir => spec.full_gem_path, 
+          :pathfile => File.expand_path(Path::FILE, spec.full_gem_path),
+          :load_paths => false)
+        
+        lines.unshift "# Generated for #{spec.full_name} on #{Time.now}.  Do not edit."
+        lines << "activate #{spec.name} #{spec.version}"
+        lines.uniq!
+        lines.sort!
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/tap/env/constant.rb

@@ -1,4 +1,5 @@
 require 'tap/env/string_ext'
+require 'tap/root'
 
 module Tap
   class Env
@@ -8,11 +9,11 @@ module Tap
     # it doesn't exist, constantize requires require_path and tries again.
     #
     #   Object.const_defined?(:Net)                      # => false
-    #   $".include?('net/http')                          # => false
+    #   $".grep(/net\/http.rb$/).empty?                  # => true
     #
     #   http = Constant.new('Net::HTTP', 'net/http.rb')
     #   http.constantize                                 # => Net::HTTP
-    #   $".include?('net/http.rb')                       # => true
+    #   $".grep(/net\/http.rb$/).empty?                  # => false
     #
     # === Unloading
     #
@@ -84,33 +85,39 @@ module Tap
           const
         end
         
-        # Scans the directory and pattern for constants and adds them to the
-        # constants hash by name.
-        def scan(dir, pattern="**/*.rb", constants={})
-          if pattern.include?("..")
-            raise "patterns cannot include relative paths: #{pattern.inspect}"
-          end
+        # Scans the directory and pattern for constants.
+        def scan(dir, pattern="**/*.rb")
+          constants = {}
           
-          # note changing dir here makes require paths relative to load_path,
-          # hence they can be directly converted into a default_const_name
-          # rather than first performing Root.relative_path
-          Dir.chdir(dir) do
-            Dir.glob(pattern).each do |path| 
-              default_const_name = path.chomp(File.extname(path)).camelize
-
-              # scan for constants
-              Lazydoc::Document.scan(File.read(path)) do |const_name, type, summary|
-                const_name = default_const_name if const_name.empty?
-
-                constant = (constants[const_name] ||= Constant.new(const_name))
-                constant.register_as(type, summary)
-                constant.require_paths << path
+          root = Root.new(dir)
+          root.glob(pattern).each do |path|
+            Lazydoc::Document.scan(File.read(path)) do |const_name, type, summary|
+              require_path = root.relative_path(path)
+              
+              if const_name.empty?
+                extname = File.extname(path)
+                const_name = require_path.chomp(extname).camelize
               end
+              
+              constant = (constants[const_name] ||= new(const_name))
+              constant.register_as(type, summary)
+              constant.require_paths << require_path
             end
           end
-          
+
+          constants = constants.values
+          constants.each {|constant| constant.require_paths.uniq! }
           constants
         end
+        
+        def cast(obj)
+          case obj
+          when String   then new(obj)
+          when Module   then new(obj.to_s)
+          when Constant then obj
+          else raise ArgumentError, "not a constant or constant name: #{obj.inspect}"
+          end
+        end
       
         private
       
@@ -129,9 +136,12 @@ module Tap
         end
       end
     
-      # Matches a valid constant
+      # Matches a valid constant.  After the match:
+      #
+      #   $1:: The unqualified constant (ex 'Const' for '::Const')
+      #
       CONST_REGEXP = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/
-    
+      
       # The full constant name
       attr_reader :const_name
     
@@ -142,21 +152,24 @@ module Tap
       # A hash of (type, summary) pairs used to classify self.
       attr_reader :types
     
-      # Initializes a new Constant with the specified constant name,
-      # require_path, and comment.  The const_name should be a valid
-      # constant name.
+      # Initializes a new Constant with the specified constant name, and
+      # require_paths.  Raises an error if const_name is not valid.
       def initialize(const_name, *require_paths)
-        @const_name = const_name
-        @require_paths = require_paths
         @types = {}
+        @const_name = normalize(const_name)
+        @require_paths = require_paths
+      end
+      
+      def relative_path
+        @relative_path ||= const_name.underscore
       end
     
       # Returns the underscored const_name.
       #
-      #   Constant.new("Const::Name").path           # => 'const/name'
+      #   Constant.new("Const::Name").path           # => '/const/name'
       #
       def path
-        @path ||= const_name.underscore
+        @path ||= "/#{relative_path}"
       end
     
       # Returns the basename of path.
@@ -169,10 +182,10 @@ module Tap
     
       # Returns the path, minus the basename of path.
       #
-      #   Constant.new("Const::Name").dirname        # => 'const'
+      #   Constant.new("Const::Name").dirname        # => '/const'
       #
       def dirname
-        @dirname ||= (dirname = File.dirname(path)) == "." ? "" : dirname
+        @dirname ||= File.dirname(path)
       end
     
       # Returns the name of the constant, minus nesting.
@@ -206,12 +219,17 @@ module Tap
         another.const_name == self.const_name &&
         another.require_paths == self.require_paths
       end
+      
+      # Peforms comparison of the const_name of self vs another.
+      def <=>(another)
+        const_name <=> another.const_name
+      end
     
       # Registers the type and summary with self.  Raises an error if self is
       # already registerd as the type and override is false.
       def register_as(type, summary=nil, override=false)
-        if types.include?(type) && !override
-          raise "already registered as a #{type.inspect}"
+        if types.include?(type) && types[type] != summary && !override
+          raise "already registered as a #{type.inspect} (#{const_name})"
         end
         
         types[type] = summary
@@ -250,8 +268,10 @@ module Tap
       
         if const.const_defined?(name)
           require_paths.each do |require_path|
-            path = File.extname(require_path).empty? ? "#{require_path}.rb" : require_path
-            $".delete(path)
+            require_path = File.extname(require_path).empty? ? "#{require_path}.rb" : require_path
+            regexp = /#{require_path}$/
+            
+            $".delete_if {|path| path =~ regexp }
           end if unrequire
         
           return const.send(:remove_const, name)
@@ -259,7 +279,19 @@ module Tap
       
         nil
       end
-    
+      
+      def path_match?(head, tail=nil)
+        (head.nil? || head.empty? || head_match(head)) && (tail.nil? || tail.empty? || tail_match(tail))
+      end
+      
+      def type_match?(type)
+        case type
+        when nil   then true
+        when Array then type.any? {|t| types.has_key?(t) } 
+        else types.has_key?(type)
+        end
+      end
+      
       # Returns a string like:
       #
       #   "#<Tap::Env::Constant:object_id Const::Name (require_path)>"
@@ -272,6 +304,29 @@ module Tap
       def to_s
         const_name
       end
+      
+      private
+      
+      def normalize(const_name) # :nodoc:
+        case const_name
+        when Module       then const_name.to_s
+        when CONST_REGEXP then $1
+        else raise NameError, "#{const_name.inspect} is not a valid constant name!"
+        end
+      end
+      
+      def head_match(head) # :nodoc:
+        index = path.index(head)
+        index == (head[0] == ?/ ? 0 : 1) && begin
+          match_end = index + head.length
+          (match_end == path.length || path[match_end] == ?/)
+        end
+      end
+      
+      def tail_match(tail) # :nodoc:
+        index = path.rindex(tail)
+        index && (index + tail.length) == path.length && (index == 0 || path[index-1] == ?/)
+      end
     end
   end
 end

data/lib/tap/env/path.rb

@@ -0,0 +1,71 @@
+module Tap
+  class Env
+    class Path
+      class << self
+        
+        # Splits the path string along ':' boundaries and expands each
+        # resulting fragments relative to dir.  Duplicate paths are removed. 
+        # Returns the resulting paths.
+        #
+        # An array of pre-split paths may also be provided as an input.
+        def split(str, dir=Dir.pwd)
+          paths = str.kind_of?(String) ? str.split(':') : str
+          paths.collect! {|path| File.expand_path(path, dir) } if dir
+          paths.uniq!
+          paths
+        end
+        
+        def join(paths)
+          paths.join(':')
+        end
+        
+        def load(path_file)
+          Root.trivial?(path_file) ? {} : (YAML.load_file(path_file) || {})
+        end
+        
+        def escape(str)
+          "'#{str.gsub("'", "\\\\'")}'"
+        end
+      end
+      
+      FILE = 'tap.yml'
+      
+      # The path base.
+      attr_reader :base
+      
+      # A mapping of types to paths.
+      attr_reader :map
+      
+      # Creates a new Path relative to the base.
+      def initialize(base, map={})
+        @base = File.expand_path(base)
+        @map = {}
+        
+        map.each_pair {|type, paths| self[type] = paths }
+      end
+      
+      # Returns an array of expanded paths associated with the type; by
+      # default the type expanded under base.
+      def [](type)
+        map[type] ||= [File.expand_path(type.to_s, base)]
+      end
+      
+      # Sets the path for the type.  Paths are split and expanded relative to
+      # base (see Path.split).
+      def []=(type, paths)
+        map[type] = Path.split(paths, base)
+      end
+      
+      def ==(another)
+        another.kind_of?(Path) &&
+        base == another.base &&
+        map == another.map
+      end
+      
+      # Returns the base path.
+      def to_s
+        base
+      end
+    end
+  end
+end

data/lib/tap/join.rb

@@ -1,15 +1,7 @@
-require 'tap/app'
-require 'tap/intern'
+require 'tap/app/api'
 
 module Tap
-  class App
-    # Generates a join between the inputs and outputs.
-    def join(inputs, outputs, config={}, klass=Join, &block)
-      klass.new(config, self).join(inputs, outputs, &block)
-    end
-  end
-  
-  # :startdoc::join an unsyncrhonized, multi-way join
+  # :startdoc::join unsyncrhonized multi-way join
   #
   # Join defines an unsynchronized, multi-way join where n inputs send their
   # results to m outputs.  Flags can augment how the results are passed, in
@@ -17,34 +9,7 @@ module Tap
   #
   class Join < App::Api
     class << self
-      
-      # Instantiates a new join with the input arguments and overrides
-      # call with the block.  The block will be called with the join
-      # instance and result.
-      #
-      # Simply instantiates a new join if no block is given.
-      def intern(config={}, app=Tap::App.instance, &block) # :yields: join, result
-        instance = new(config, app)
-        if block_given?
-          instance.extend Intern(:call)
-          instance.call_block = block
-        end
-        instance
-      end
-      
-      def parse!(argv=ARGV, app=Tap::App.instance)
-        parser = self.parser
-        argv = parser.parse!(argv, :add_defaults => false)
-        instance = build({
-          'config' => parser.nested_config,
-          'inputs' => argv.shift,
-          'outputs' => argv.shift
-        }, app)
-        
-        [instance, argv]
-      end
-      
-      def build(spec={}, app=Tap::App.instance)
+      def build(spec={}, app=Tap::App.current)
         inputs = resolve(spec['inputs']) do |var|
           app.get(var) or raise "missing join input: #{var}"
         end
@@ -58,6 +23,14 @@ module Tap
       
       protected
       
+      def convert_to_spec(parser, args)
+        {
+          'config' => parser.nested_config,
+          'inputs' => args.shift,
+          'outputs' => args.shift
+        }
+      end
+      
       def resolve(refs) # :nodoc:
         refs = case refs
         when String then parse_indicies(refs)
@@ -83,34 +56,23 @@ module Tap
     end
     
     # Causes the outputs to be enqued rather than executed immediately.
-    config :enq, false, :short => 'q', &c.flag      # Enque output nodes
+    config :enq, false, :short => 'q', &c.flag      # Enque output tasks
     
-    # Splats the result to the outputs, allowing a many-to-one join
-    # from the perspective of the results.
-    #
-    #   # results: [1,2,3]
-    #   # outputs: call(*inputs)
-    #   app.execute(output, *result)
-    #
-    config :splat, false, :short => 's', &c.flag    # Splat results to outputs
+    # Converts each result into a one-member array before being passed onto
+    # outputs. Arrayify occurs before iterate and combined the two flags
+    # cancel.
+    config :arrayify, false, :short => 'a', &c.flag # Arrayify results
     
-    # Iterates the results to the outputs, allowing a many-to-one join
-    # from the perspective of the results.  Non-array results are converted
-    # to arrays using to_ary:
+    # Iterates the results to the outputs.  Non-array results are converted to
+    # arrays using to_ary:
     #
     #   # results: [1,2,3]
     #   # outputs: call(input)
-    #   result.to_ary.each {|r| app.execute(output, r) }
-    #
-    # Iterate may be combined with splat:
-    #
-    #   # results: [[1,2],3]
-    #   # outputs: call(*inputs)
-    #   result.to_ary.each {|r| app.execute(output, *r) }
+    #   result.to_ary.each {|r| app.exe(output, r) }
     #
     config :iterate, false, :short => 'i', &c.flag  # Iterate results to outputs
     
-    signal :join do |sig, (inputs, outputs)|
+    signal :join do |sig, (inputs, outputs)|        # join app objects
       app = sig.obj.app
       
       inputs = resolve(inputs) do |var|
@@ -124,14 +86,14 @@ module Tap
       [inputs, outputs]
     end
     
-    # An array of input nodes, or nil if the join has not been set.
+    # An array of input tasks, or nil if the join has not been set.
     attr_reader :inputs
     
-    # An array of output nodes, or nil if the join has not been set.
+    # An array of output tasks, or nil if the join has not been set.
     attr_reader :outputs
     
     # Initializes a new join with the specified configuration.
-    def initialize(config={}, app=Tap::App.instance)
+    def initialize(config={}, app=Tap::App.current)
       @inputs = nil
       @outputs = nil
       super
@@ -143,6 +105,12 @@ module Tap
         input.joins.delete(self)
       end if @inputs
       
+      inputs.each do |input|
+        unless input.respond_to?(:joins)
+          raise "input does not support joins: #{input.inspect}"
+        end
+      end
+      
       @inputs = inputs
       
       inputs.each do |input|
@@ -157,7 +125,7 @@ module Tap
     # each output.
     def call(result)
       outputs.each do |output|
-        dispatch(output, result)
+        exe(output, result)
       end
     end
     
@@ -167,29 +135,25 @@ module Tap
     
     def to_spec
       spec = super
-      spec['inputs'] = inputs.collect {|node| app.var(node) }
-      spec['outputs'] = outputs.collect {|node| app.var(node) }
+      spec['inputs'] = inputs.collect {|task| app.var(task) }
+      spec['outputs'] = outputs.collect {|task| app.var(task) }
       spec
     end
     
     protected
     
-    # Dispatches the results to the node.
-    def dispatch(node, result) # :nodoc:
-      mode = enq ? :enq : :execute
-      if iterate
-        result.to_ary.each {|r| execute(mode, node, r) }
-      else
-        execute(mode, node, result)
+    # Executes the task with the input results.
+    def exe(task, result) # :nodoc:
+      mode = enq ? :enq : :exe
+      
+      if arrayify
+        result = [result]
       end
-    end
-    
-    # Executes the node with the input results.
-    def execute(mode, node, result) # :nodoc:
-      if splat
-        app.send(mode, node, *result)
+      
+      if iterate
+        result.to_ary.each {|item| app.send(mode, task, item) }
       else
-        app.send(mode, node, result)
+        app.send(mode, task, result)
       end
     end
   end