tap 0.10.1 → 0.11.0

data/lib/tap/support/manifest.rb

@@ -1,151 +1,169 @@
-require 'tap/root'
+require 'tap/support/minimap'
 
 module Tap
   module Support
+    
+    # Stores an array of paths and makes them available for lookup by
+    # minipath.  Manifests may be bound to a Tap::Env, allowing searches
+    # across a full environment (including nested environments).
+    #
+    # Manifest has a number of hooks used by subclasses like 
+    # ConstantManifest to lazily add entries as needed.
     class Manifest
       class << self
-        def normalize(key)
-          key.to_s.downcase.gsub(/\s/, "_").delete(":")
+        
+        # Interns a new manifest, overriding the minikey
+        # method with the block (the minikey method converts
+        # entries to the path used during minimap and 
+        # minimatch lookup, see Minimap).
+        def intern(*args, &block)
+          instance = new(*args)
+          if block_given?
+            instance.extend Support::Intern(:minikey)
+            instance.minikey_block = block
+          end
+          instance
         end
       end
       
       include Enumerable
+      include Minimap
+      
+      # Matches a compound manifest search key.  After the match,
+      # if the key is compound then:
+      #
+      #  $1:: env_key
+      #  $4:: key
+      #
+      # If the key is not compound, $4 is nil and $1 is the key.
+      SEARCH_REGEXP = /^(([A-z]:)?.*?)(:(.*))?$/
       
-      # An array of (key, value) entries in self.
+      # An array entries in self.
       attr_reader :entries
       
-      # An array of search_paths to identify entries.
-      attr_reader :search_paths
+      # The bound Tap::Env, or nil.
+      attr_reader :env
       
-      # The index of the search_path that will be searched
-      # next when building the manifest.
-      attr_reader :search_path_index
+      # The reader on Tap::Env accessing manifests of the
+      # same type as self. reader is set during bind.
+      attr_reader :reader
       
-      def initialize(search_paths)
-        self.search_paths = search_paths
+      # Initializes a new, unbound Manifest.
+      def initialize(entries=[])
+        @entries = entries
+        @env = nil
+        @reader = nil
       end
       
-      # Returns an array of the entries keys.
-      def keys
-        entries.collect {|(key, value)| key }
+      # Binds self to an env and reader.  The manifests returned by env.reader
+      # will be used during traversal methods like search.  Raises an error if
+      # env does not respond to reader; returns self.
+      def bind(env, reader)
+        if env == nil
+          raise ArgumentError, "env may not be nil" 
+        end
+        
+        unless env.respond_to?(reader)
+          raise ArgumentError, "env does not respond to #{reader}"
+        end
+        
+        @env = env
+        @reader = reader
+        self
       end
       
-      # Returns an array of the entries values.
-      def values
-        entries.collect {|(key, value)| value }
+      # Unbinds self from env.  Returns self.
+      def unbind
+        @env = nil
+        @reader = nil
+        self
       end
       
-      # True if entries are empty.
-      def empty?
-        entries.empty?
+      # True if the env and reader have been set.
+      def bound?
+        @env != nil && @reader != nil
       end
       
-      def search_paths=(search_paths)
-        @entries = []
-        @search_paths = search_paths
-        @search_path_index = 0
+      # A hook for dynamically building entries.  By default build simply
+      # returns self
+      def build
+        self
       end
       
-      # Clears entries and sets the search_path_index to zero.
-      def reset
-        @entries.clear
-        @search_path_index = 0
+      # A hook to flag when self is built.  By default built? returns true.
+      def built?
+        true
       end
       
-      # Builds the manifest, identifying all entries from search_paths.
-      # Returns self.
-      def build
-        each {|k, v|} unless built?
+      # A hook to reset a build.  By default reset simply returns self.
+      def reset
         self
       end
       
-      # True if all search paths have been checked for entries
-      # (ie search_path_index == search_paths.length).
-      def built?
-        @search_path_index == search_paths.length
+      # True if entries are empty.
+      def empty?
+        entries.empty?
+      end
+      
+      # Iterates over each entry entry in self.
+      def each
+        entries.each {|entry| yield(entry) }
       end
       
-      # Abstract method which should return each (key, value) entry
-      # for a given search path.  Raises a NotImplementedError
-      # if left not implemented.
-      def entries_for(search_path)
-        [[search_path, search_path]]
+      # Alias for Minimap#minimatch.
+      def [](key)
+        minimatch(key)
       end
       
-      # Adds the (key, value) pair to entries and returns the new entry.
-      # Checks that entries does not already assign key a conflicting value;
-      # raises an error if this is the case, or returns the existing entry.
+      # Search across env.each for the first entry minimatching key.
+      # A single env can be specified by using a compound key like
+      # 'env_key:key'.  Returns nil if no matching entry is found.
       #
-      # Keys are normalized using Manifest.normalize before storing.
-      def store(key, value)
-        key = Manifest.normalize(key)
-        existing = entries.find {|(k, v)| key == k } 
+      # Search raises an error unless bound?
+      def search(key)
+        raise "cannot search unless bound" unless bound?
         
-        if existing
-          if existing[1] != value
-            raise ManifestConflict.new(key, value, existing[1])
-          else
-            return existing
+        key =~ SEARCH_REGEXP
+        envs = if $4 != nil
+          # compound key, match for env
+          key = $4
+          [env.minimatch($1)].compact
+        else
+          # not a compound key, search all
+          # envs by iterating env itself
+          env
+        end
+        
+        # traverse envs looking for the first
+        # manifest entry matching key
+        envs.each do |env|
+          if result = env.send(reader).minimatch(key)
+            return result
           end
         end
         
-        new_entry = [key, value]
-        entries << new_entry
-        new_entry
+        nil
       end
       
-      # Iterates over each (key, value) entry in self, dynamically identifying entries 
-      # from search_paths if necessary.  New entries are identifed using the each_for
-      # method.
-      def each
-        entries.each do |key, path| 
-          yield(key, path) 
-        end
-        
-        unless built?
-          n_to_skip = @search_path_index
-          search_paths.each do |search_path|
-            # advance to the current search path
-            if n_to_skip > 0
-              n_to_skip -= 1
-              next
-            end
-            @search_path_index += 1
-            
-            # collect new entries and yield afterwards to ensure
-            # that all entries for the search_path get stored
-            new_entries = entries_for(*search_path)
-            next if new_entries == nil
+      def inspect(traverse=true)
+        if traverse && bound?
+          lines = []
+          env.each do |env|
+            manifest = env.send(reader).build
+            next if manifest.empty?
             
-            new_entries.each {|(key, value)| store(key, value) }
-            new_entries.each {|(key, value)| yield(key, value) }
+            lines << "== #{env.root.root}"
+            manifest.minimap.each do |mini, value| 
+              lines << "  #{mini}: #{value.inspect}"
+            end
           end
+          return lines.join("\n")
         end
-      end
-      
-      # Returns an array of (mini_key, value) pairs, matching
-      # entries by index.
-      def minimize
-        hash = {}
-        Tap::Root.minimize(keys) do |path, mini_path|
-          hash[path] = mini_path
-        end
-        
-        entries.collect {|path, value| [hash[path], value] }
-      end
-      
-      protected
-
-      # Raised when multiple paths are assigned to the same manifest key.
-      class ManifestConflict < StandardError
-        attr_reader :key, :value, :existing
         
-        def initialize(key, value, existing)
-          @key = key
-          @value = value
-          @existing = existing
-          super("attempted to store '%s': %s\nbut already was\n%s" % [key, value, existing])
+        lines = minimap.collect do |mini, value| 
+          "  #{mini}: #{value.inspect}"
         end
+        "#{self.class}:#{object_id} (#{bound? ? env.root.root : ''})\n#{lines.join("\n")}"
       end
     end
   end

data/lib/tap/support/minimap.rb

@@ -0,0 +1,90 @@
+require 'tap/root'
+
+module Tap
+  module Support
+    
+    # Minimap adds minimization and search methods to an array of paths (see 
+    # Tap::Root.minimize and Tap::Root.minimal_match?).
+    # 
+    #   paths = %w{
+    #     path/to/file-0.1.0.txt 
+    #     path/to/file-0.2.0.txt
+    #     path/to/another_file.txt
+    #   }
+    #   paths.extend Minimap
+    #
+    #   paths.minimatch('file')             # => 'path/to/file-0.1.0.txt'
+    #   paths.minimatch('file-0.2.0')       # => 'path/to/file-0.2.0.txt'
+    #   paths.minimatch('another_file')     # => 'path/to/another_file.txt'
+    #
+    # More generally, Minimap may extend any object responding to each. 
+    # Override the minikey method to convert objects into paths.
+    #
+    #   class ConstantMap < Array
+    #     include Minimap
+    #
+    #     def minikey(const)
+    #       const.underscore
+    #     end
+    #   end 
+    #
+    #   constants = ConstantMap[Tap::Support::Minimap Tap::Root]
+    #   constants.minimatch('root')         # => Tap::Root
+    #   constants.minimatch('minimap')      # => Tap::Support::Minimap
+    #
+    module Minimap
+
+      # Provides a minimized map of the entries using keys provided minikey.
+      #
+      #   paths = %w{
+      #     path/to/file-0.1.0.txt 
+      #     path/to/file-0.2.0.txt
+      #     path/to/another_file.txt
+      #   }.extend Minimap
+      #
+      #   paths.minimap
+      #   # => [
+      #   # ['file-0.1.0',  'path/to/file-0.1.0.txt'],
+      #   # ['file-0.2.0',  'path/to/file-0.2.0.txt'],
+      #   # ['another_file','path/to/another_file.txt']]
+      #
+      def minimap
+        hash = {}
+        map = []
+        each {|entry| map << (hash[minikey(entry)] = [entry]) }
+        Tap::Root.minimize(hash.keys) do |key, mini_key|
+          hash[key].unshift mini_key
+        end
+        
+        map
+      end
+      
+      # Returns the first entry whose minikey mini-matches the input, or nil if
+      # no such entry exists.
+      #
+      #   paths = %w{
+      #     path/to/file-0.1.0.txt 
+      #     path/to/file-0.2.0.txt
+      #     path/to/another_file.txt
+      #   }.extend Minimap
+      #
+      #   paths.minimatch('file-0.2.0')       # => 'path/to/file-0.2.0.txt'
+      #   paths.minimatch('file-0.3.0')       # => nil
+      #
+      def minimatch(key)
+        each do |entry| 
+          return entry if Tap::Root.minimal_match?(minikey(entry), key)
+        end
+        nil
+      end
+      
+      protected
+      
+      # A hook to convert a non-path entry into a path for minimap and
+      # minimatch.  Returns the entry by default.
+      def minikey(entry)
+        entry
+      end
+    end
+  end
+end

data/lib/tap/support/node.rb

@@ -0,0 +1,56 @@
+module Tap
+  module Support
+
+    # Represents a task node in a Schema.
+    class Node
+      
+      # An array of arguments used to instantiate
+      # the node
+      attr_accessor :argv
+      
+      # The input or source for the node.  Inputs
+      # may be a Join, nil, or an Integer.  An 
+      # Integer input indicates that the node should 
+      # be enqued to a round using argv as inputs.
+      attr_accessor :input
+      
+      # The output for the node. Output may be a
+      # a Join or nil.
+      attr_accessor :output
+
+      def initialize(argv=[], input=nil, output=nil)
+        @argv = argv
+        @input = input
+        @output = output
+      end
+      
+      # Resets the source and join to nil.
+      def globalize
+        self.input = nil
+        self.output = nil
+      end
+      
+      # True if the input and output are nil.
+      def global?
+        input == nil && output == nil
+      end
+      
+      # Returns the round for self; a round is indicated
+      # by an integer input.  If input is anything but 
+      # an integer, round returns nil.
+      def round
+        input.kind_of?(Integer) ? input : nil
+      end
+      
+      # Alias for input=
+      def round=(input)
+        self.input = input
+      end
+      
+      def inspect
+        "#<#{self.class}:#{object_id} argv=[#{argv.join(' ')}] input=#{input.inspect} output=#{output.inspect}>"
+      end
+
+    end
+  end
+end