tap 0.12.4 → 0.17.0

data/lib/tap/support/constant_manifest.rb

@@ -1,126 +0,0 @@
-require 'tap/support/manifest'
-require 'tap/support/constant'
-
-module Tap
-  module Support
-    
-    # :startdoc:::-
-    #
-    # ConstantManifest builds a manifest of Constant entries using Lazydoc.
-    #
-    # Lazydoc can quickly scan files for constant attributes, and thereby
-    # identify constants based upon a flag like the '::manifest' attribute used
-    # to identify task classes.  ConstantManifest registers paths that will be
-    # scanned for a specific resource, and lazily builds the references to load
-    # them as necessary.
-    # 
-    # :startdoc:::+
-    class ConstantManifest < Support::Manifest
-      
-      # The attribute identifying constants in a file
-      attr_reader :const_attr
-      
-      # An array of registered (root, [paths]) pairs
-      # that will be searched for const_attr
-      attr_reader :search_paths
-      
-      # The current index of search_paths
-      attr_reader :search_path_index
-      
-      # The current index of paths
-      attr_reader :path_index
-      
-      # Initializes a new ConstantManifest that will identify constants
-      # using the specified constant attribute.
-      def initialize(const_attr)
-        @const_attr = const_attr
-        @search_paths = []
-        @search_path_index = 0
-        @path_index = 0
-        super([])
-      end
-      
-      # Registers the files matching pattern under dir.  Returns self.
-      def register(dir, pattern)
-        paths = Dir.glob(File.join(dir, pattern)).select {|file| File.file?(file) }
-        search_paths << [dir, paths.sort]
-        self
-      end
-      
-      # Searches all paths for entries and adds them to self.  Returns self.
-      def build
-        each {|entry| } unless built?
-        self
-      end
-      
-      # True if there are no more paths to search 
-      # (ie search_path_index == search_paths.length)
-      def built?
-        search_path_index == search_paths.length
-      end
-      
-      # Sets search_path_index and path_index to zero and clears entries.
-      # Returns self.
-      def reset
-        @search_paths.each {|path| Lazydoc[path].resolved = false }
-        @entries.clear
-        @search_path_index = 0
-        @path_index = 0
-        super
-      end
-      
-      # Yields each Constant entry to the block.  Unless built?, each
-      # lazily iterates over search_paths to look for new entries.
-      def each
-        entries.each do |entry|
-          yield(entry)
-        end
-        
-        search_paths[search_path_index, search_paths.length - search_path_index].each do |(path_root, paths)|
-          paths[path_index, paths.length - path_index].each do |path|
-            new_entries = resolve(path_root, path)
-            entries.concat(new_entries)
-            
-            @path_index += 1
-            new_entries.each {|entry| yield(entry) }
-          end
-          
-          @search_path_index += 1
-          @path_index = 0
-        end unless built?
-      end
-      
-      protected
-      
-      def minikey(const) # :nodoc:
-        const.path
-      end
-      
-      # Scans path for constants having const_attr, and initializes Constant
-      # objects for each.   If the document has no default_const_name set,
-      # resolve will set the default_const_name based on the relative
-      # filepath from path_root to path.
-      def resolve(path_root, path) # :nodoc:
-        entries = []
-        document = nil
-        
-        Lazydoc::Document.scan(File.read(path), const_attr) do |const_name, key, value|
-          if document == nil
-            relative_path = Root.relative_filepath(path_root, path).chomp(File.extname(path))
-            document = Lazydoc.register_file(path, relative_path.camelize)
-          end
-          
-          const_name = document.default_const_name if const_name.empty? 
-          comment = Lazydoc::Subject.new(nil, document)
-          comment.value = value
-          
-          document[const_name][key] = comment
-          entries << Constant.new(const_name, path)
-        end
-        
-        entries
-      end
-      
-    end
-  end
-end

data/lib/tap/support/dependencies.rb

@@ -1,54 +0,0 @@
-require 'tap/support/dependency'
-
-module Tap
-  module Support
-    
-    # Dependencies tracks Executable dependencies and results, and provides
-    # for thread-safe resolution of dependencies.
-    class Dependencies < Monitor
-      
-      # Initializes a new Dependencies
-      def initialize
-        super 
-        @resolve_stack = []
-      end
-      
-      # Thread-safe registration of instance as a dependency.  During
-      # registration, instance is extended with the Dependency module.
-      # Returns self.
-      def register(instance)
-        synchronize do
-          unless instance.kind_of?(Dependency)
-            instance.extend Dependency
-          end
-        end
-        self
-      end
-      
-      # Thread-safe resolution of the instance.  Resolve checks for
-      # circular dependencies, then yields control to the block,
-      # which is responsible for the actual resolution.
-      def resolve(instance)
-        synchronize do
-          if @resolve_stack.include?(instance)
-            raise CircularDependencyError.new(@resolve_stack)
-          end
-          
-          # mark the results at the index to prevent
-          # infinite loops with circular dependencies
-          @resolve_stack.push instance
-          yield()
-          @resolve_stack.pop
-        end
-        self
-      end
-      
-      # Raised when Dependencies#resolve detects a circular dependency.
-      class CircularDependencyError < StandardError
-        def initialize(resolve_stack)
-          super "circular dependency: [#{resolve_stack.join(', ')}]"
-        end
-      end
-    end
-  end
-end

data/lib/tap/support/dependency.rb

@@ -1,44 +0,0 @@
-module Tap
-  module Support
-    
-    # Constrains an Executable to only _execute once, and provides several
-    # methods making the Executable behave like a Dependency.
-    module Dependency
-      
-      # The audited result of self
-      attr_accessor :_result
-      
-      def self.extended(base) # :nodoc:
-        base.instance_variable_set(:@_result, nil)
-      end
-      
-      # Conditional _execute; only calls method_name if
-      # resolved? is false (thus assuring self will only
-      # be executed once).
-      #
-      # Returns _result.
-      def _execute(*args)
-        app.dependencies.resolve(self) do
-          @_result = super
-        end unless resolved?
-        _result
-      end
-      
-      # Alias for _execute().
-      def resolve
-        _execute
-      end
-      
-      # True if _result is non-nil.
-      def resolved?
-        @_result != nil
-      end
-      
-      # Resets the dependency by setting _result to nil.
-      def reset
-        @_result = nil
-      end
-      
-    end
-  end
-end

data/lib/tap/support/executable.rb

@@ -1,198 +0,0 @@
-require 'tap/support/audit'
-require 'tap/support/joins'
-
-module Tap
-  module Support
-    
-    # Executable wraps objects to make them executable by App.
-    module Executable
-      
-      # The App receiving self during enq
-      attr_reader :app
-      
-      # The method called during _execute
-      attr_reader :method_name
-    
-      # The block called when _execute completes
-      attr_reader :on_complete_block
-      
-      # An array of dependency indicies that will be resolved on _execute
-      attr_reader :dependencies
-      
-      public
-      
-      # Extends obj with Executable and sets up all required variables.  The
-      # specified method will be called on _execute.
-      def self.initialize(obj, method_name, app=App.instance, dependencies=[], &on_complete_block)
-        obj.extend Executable
-        obj.instance_variable_set(:@app, app)
-        obj.instance_variable_set(:@method_name, method_name)
-        obj.instance_variable_set(:@on_complete_block, on_complete_block)
-        obj.instance_variable_set(:@dependencies, dependencies)
-        obj
-      end
-      
-      # Enqueues self to app with the inputs. The number of inputs provided
-      # should match the number of inputs for the method_name method.
-      def enq(*inputs)
-        app.queue.enq(self, inputs)
-        self
-      end
-      
-      # Sets a block to receive the results of _execute.  Raises an error if
-      # an on_complete_block is already set.  Override the existing 
-      # on_complete_block by specifying override = true.
-      #
-      # Note: the block recieves an audited result and not the result
-      # itself (see Audit for more information).
-      def on_complete(override=false, &block) # :yields: _result
-        unless on_complete_block == nil || override
-          raise "on_complete_block already set: #{self}" 
-        end
-        @on_complete_block = block
-        self
-      end
-      
-      # Sets a sequence workflow pattern for the tasks; each task
-      # enques the next task with it's results, starting with self.
-      def sequence(*tasks, &block) # :yields: _result
-        options = tasks[-1].kind_of?(Hash) ? tasks.pop : {}
-        
-        current_task = self
-        tasks.each do |next_task|
-          Join.new(options).join([current_task], [next_task], &block)
-          current_task = next_task
-        end
-      end
-
-      # Sets a fork workflow pattern for self; each target will enque the
-      # results of self.
-      def fork(*targets, &block) # :yields: _result
-        options = targets[-1].kind_of?(Hash) ? targets.pop : {}
-        Join.new(options).join([self], targets, &block)
-      end
-
-      # Sets a simple merge workflow pattern for the source tasks. Each 
-      # source enques self with it's result; no synchronization occurs, 
-      # nor are results grouped before being enqued.
-      def merge(*sources, &block) # :yields: _result
-        options = sources[-1].kind_of?(Hash) ? sources.pop : {}
-        Join.new(options).join(sources, [self], &block)
-      end
-
-      # Sets a synchronized merge workflow for the source tasks.  Results 
-      # from each source are collected and enqued as a single group to
-      # self.  The collective results are not enqued until all sources
-      # have completed.  See Joins::SyncMerge.
-      def sync_merge(*sources, &block) # :yields: _result
-        options = sources[-1].kind_of?(Hash) ? sources.pop : {}
-        Joins::SyncMerge.new(options).join(sources, [self], &block)
-      end
-
-      # Sets a switch workflow pattern for self.  On complete, switch yields
-      # the audited result to the block and the block should return the index
-      # of the target to enque with the results. No target will be enqued if
-      # the index is false or nil.  An error is raised if no target can be
-      # found for the specified index. See Joins::Switch.
-      def switch(*targets, &block) # :yields: _result
-        options = targets[-1].kind_of?(Hash) ? targets.pop : {}
-        Joins::Switch.new(options).join([self], targets, &block)
-      end
-      
-      # Adds the dependencies to self.  Dependencies are resolved during
-      # _execute through resolve_dependencies.
-      def depends_on(*dependencies)
-        raise ArgumentError, "cannot depend on self" if dependencies.include?(self)
-        
-        dependencies.each do |dependency|
-          app.dependencies.register(dependency)
-          self.dependencies << dependency unless self.dependencies.include?(dependency)
-        end
-        
-        self
-      end
-      
-      # Resolves dependencies. (See Dependency#resolve).
-      def resolve_dependencies
-        dependencies.each {|dependency| dependency.resolve }
-        self
-      end
-      
-      # Resets dependencies so they will be re-resolved on
-      # resolve_dependencies. (See Dependency#reset).
-      def reset_dependencies
-        dependencies.each {|dependency| dependency.reset }
-        self
-      end
-      
-      # Auditing method call.  Resolves dependencies, executes method_name,
-      # and sends the audited result to the on_complete_block (if set).
-      #
-      # Returns the audited result.
-      def _execute(*inputs)
-        resolve_dependencies
-        
-        previous = []
-        inputs.collect! do |input| 
-          if input.kind_of?(Audit) 
-            previous << input
-            input.value
-          else
-            previous << Audit.new(nil, input)
-            input
-          end
-        end
-         
-        audit = Audit.new(self, send(method_name, *inputs), app.audit ? previous : nil)
-        if complete_block = on_complete_block || app.on_complete_block
-          complete_block.call(audit)
-        else 
-          app.aggregator.store(audit)
-        end
-        
-        audit
-      end
-      
-      # Calls _execute with the inputs and returns the non-audited result.
-      def execute(*inputs)
-        _execute(*inputs).value
-      end
-      
-      # Raises a TerminateError if app.state == State::TERMINATE.
-      # check_terminate may be called at any time to provide a 
-      # breakpoint in long-running processes.
-      def check_terminate
-        if app.state == App::State::TERMINATE
-          raise App::TerminateError.new
-        end
-      end
-      
-    end
-  end
-end
-
-# Tap extends Object with <tt>_method</tt> to generate executable methods
-# that can be enqued by Tap::App and incorporated into workflows.
-#
-#   array = []
-#   push_to_array = array._method(:push)
-#
-#   task = Tap::Task.new  
-#   task.sequence(push_to_array)
-#
-#   task.enq(1).enq(2,3)
-#   task.app.run
-#
-#   array   # => [[1],[2,3]]
-#
-class Object
-  
-  # Initializes a Tap::Support::Executable using the object returned by
-  # Object#method(method_name).
-  #
-  # Returns nil if Object#method returns nil.
-  def _method(method_name, app=Tap::App.instance)
-    return nil unless m = method(method_name)
-    Tap::Support::Executable.initialize(m, :call, app)
-  end
-end

data/lib/tap/support/executable_queue.rb

@@ -1,125 +0,0 @@
-require 'tap/support/executable'
-
-module Tap
-  module Support
-    
-    # ExecutableQueue allows thread-safe enqueing and dequeing of Executable
-    # methods and inputs for execution.
-    class ExecutableQueue < Monitor
-      
-      # Creates a new ExecutableQueue
-      def initialize
-        super
-        @rounds = [[]]
-      end
-      
-      # Clears self and returns an array of the enqueued methods and inputs,
-      # organized by round.
-      def clear
-        synchronize do
-          current, @rounds = @rounds, [[]]
-          current
-        end
-      end
-      
-      # Returns the number of enqueued methods
-      def size
-        synchronize do
-          size = 0 
-          @rounds.each {|round| size += round.length }
-          size
-        end
-      end
-      
-      # True if no methods are enqueued
-      def empty?
-        synchronize { size == 0 }
-      end
-      
-      def has?(entry)
-        synchronize do
-          entry_id = entry.object_id
-          
-          @rounds.each do |round|
-            round.each do |enqued_entry|
-              return true if entry_id == enqued_entry.object_id
-            end
-          end
-          false
-        end
-      end
-      
-      # Enqueues the method and inputs. Raises an error if the  
-      # method is not an Executable.
-      def enq(method, inputs)
-        synchronize do
-          check_method(method)
-          queue.push [method, inputs]
-        end
-      end
-      
-      # Enqueues the method and inputs, but to the top of the queue.
-      # Raises an error if the method is not an Executable.
-      def unshift(method, inputs)
-        synchronize do
-          check_method(method)
-          queue.unshift [method, inputs]
-        end
-      end
-      
-      # Dequeues the next method and inputs as an array like
-      # [method, inputs]. Returns nil if the queue is empty.
-      def deq
-        synchronize { queue.shift }
-      end
-      
-      # Enques an array of [method, inputs] entries as a round.  Rounds are
-      # dequeued completely before the next round is dequeued.
-      def concat(round)
-        synchronize do
-          round.each do |method, inputs|
-            check_method(method)
-          end
-          
-          @rounds << round
-        end
-      end
-      
-      # Converts self to an array.  If flatten is specified, all rounds are
-      # concatenated into a single array.
-      def to_a(flatten=true)
-        synchronize do
-          if flatten
-            array = []
-            @rounds.each {|round| array.concat(round) }
-            array
-          else
-            @rounds.collect {|round| round.dup}
-          end
-        end
-      end
-      
-      protected
-      
-      # Returns the active round.
-      def queue # :nodoc:
-        while @rounds.length > 1
-          queue = @rounds[0]
-          
-          if queue.empty?
-            @rounds.shift
-          else
-            return queue
-          end
-        end
-        
-        @rounds[0]
-      end
-      
-      # Checks if the input method is extended with Executable
-      def check_method(method) # :nodoc:
-        raise "not executable: #{method.inspect}" unless method.kind_of?(Executable)
-      end
-    end 
-  end
-end