tap 0.19.0 → 1.3.0

data/cmd/console.rb

@@ -1,43 +0,0 @@
-# usage: tap console [options]
-#
-# Opens up an IRB session with the Tap environment initialized as specified
-# in tap.yml. Access a Tap::App instance through 'app' and the execution
-# environment through 'env'.  For example:
-#
-#   % tap console
-#   >> app.env[:dump]
-#   => Tap::Tasks::Dump
-#   >> app.info
-#   => "state: 0 (READY) queue: 0"
-#   >> 
-#
-
-ConfigParser.new do |opts|
-  opts.separator ""
-  opts.separator "options:"
-
-  opts.on("-h", "--help", "Show this message") do
-    puts Lazydoc.usage(__FILE__)
-    puts opts
-    exit
-  end
-end.parse!(ARGV)
-
-require "irb"
-
-def app
-  @app ||= Tap::App.instance
-end
-
-IRB.start
-
-# Handles a bug in IRB that causes exit to throw :IRB_EXIT
-# and consequentially make a warning message, even on a 
-# clean exit.  This module resets exit to the original 
-# aliased method.
-module CleanExit # :nodoc:
-  def exit(ret = 0)
-    __exit__(ret)
-  end
-end
-IRB.CurrentContext.extend CleanExit

data/cmd/manifest.rb

@@ -1,118 +0,0 @@
-# usage: tap manifest [options] [filter]
-#
-# Prints a manifest of all resources in the current tap environment.  Env
-# keys may be provided to select a specific set of environments to list.
-#
-#   % tap manifest
-#   % tap manifest tap-tasks
-#
-options = {}
-ConfigParser.new do |opts|
-  
-  opts.separator ""
-  opts.separator "options:"
-
-  opts.on("-h", "--help", "Show this message") do
-    puts Lazydoc.usage(__FILE__)
-    puts opts
-    exit
-  end
-end.parse!(ARGV)
-
-template = %Q{<% unless manifests.empty? %>
-#{'-' * 80}
-<%= (env_key + ':').ljust(width) %> (<%= env.root.root %>)
-<% manifests.each do |type, entries| %>
-  <%= type %>
-<%   entries.each do |key, paths| %>
-    <%= key.ljust(width) %> (<%= paths.join(', ') %>)
-<%   end %>
-<% end %>
-<% end %>
-}
-
-# filter envs to manifest
-env = Tap::App.instance.env
-env_keys = env.minihash(true)
-filter = if ARGV.empty?
-  env_keys.keys
-else
-  ARGV.collect do |name| 
-    env.minimatch(name) or raise "could not find an env matching: #{name}"
-  end
-end
-
-# build the summary
-constants = env.constants
-summary = env.inspect(template, :width => 10) do |templater, globals|
-  current = templater.env
-  manifests = []
-  templater.manifests = manifests
-  next unless filter.include?(current)
-  
-  # determine the width of the keys
-  width = globals[:width]
-  env_key = env_keys[current]
-  templater.env_key = env_key
-  width = env_key.length if width < env_key.length
-  
-  # build up the entries for each type of resource
-  types = {}
-  constants.entries(current).minimap.each do |key, const|
-    paths = const.require_paths.collect do |path|
-      current.root.relative_path(:root, path) || path
-    end.uniq
-    
-    width = key.length if width < key.length
-    
-    const.types.keys.each do |type|
-      (types[type] ||= []) << [key, paths]
-    end
-  end
-  
-  manifests.concat types.to_a.sort_by {|type, minimap| type }
-  globals[:width] = width
-end
-puts summary
-
-if ARGV.empty?
-  templaters = []
-  visited = []
-  globals = env.recursive_inject([nil, nil]) do |(leader, last), current|
-    current_leader = if leader
-      leader.to_s + (last == current ? "`- " : "|- ")
-    else
-      ""
-    end
-    
-    templaters << Tap::Templater.new("<%= leader %><%= env_key %> \n", 
-      :env_key => env_keys[current],
-      :leader => current_leader
-    )
-    
-    if leader
-      leader += (last == current ? '    ' : '|   ')
-    else
-      leader = ""
-    end
-    
-    visited << current
-    current.envs.reverse_each do |e|
-      unless visited.include?(e)
-        last = e
-        break
-      end
-    end
-    
-    [leader, last]
-  end
-
-  tree = templaters.collect do |templater|
-    templater.build
-  end.join
-
-  puts '-' * 80
-  puts
-  puts tree
-  puts
-end

data/cmd/run.rb

@@ -1,145 +0,0 @@
-# usage: tap run [args] [options] -- [SCHEMA]
-#
-# examples:
-#   tap run --help                     Prints this help
-#   tap run -- task --help             Prints help for task
-#   tap run -- load hello --: dump     Say hello
-#
-
-app = Tap::App.instance
-
-opts = {}
-parser = ConfigParser.bind(app.config) do |psr|
-  psr.separator ""
-  psr.separator "configurations:"
-  
-  psr.add Tap::App.configurations
-  
-  psr.separator ""
-  psr.separator "options:"
-  
-  psr.on("-h", "--help", "Show this message") do
-    puts Lazydoc.usage(__FILE__)
-    puts psr
-    exit(0)
-  end
-  
-  psr.on('-s', '--serialize', 'Serialize the workflow') do
-    opts[:serialize] = true
-  end
-  
-  psr.on('-t', '--manifest', 'Print a list of available resources') do
-    constants = app.env.constants
-    
-    tasks, joins, middleware = %w{task join middleware}.collect do |type|
-      constants.summarize do |constant|
-        constant.types[type]
-      end
-    end
-    
-    unless tasks.empty? 
-      puts "=== tasks ===" unless middleware.empty? && joins.empty?
-      puts tasks
-    end
-
-    unless joins.empty?
-      puts "=== joins ===" unless tasks.empty? && middleware.empty?
-      puts joins
-    end
-    
-    unless middleware.empty?
-      puts "=== middleware ===" unless tasks.empty? && joins.empty?
-      puts middleware
-    end
-    
-    exit(0)
-  end
-  
-  psr.on('-T', '--tasks', 'Print a list of available tasks') do
-    constants = app.env.constants
-    tasks = constants.summarize do |constant|
-      constant.types['task']
-    end
-    
-    puts tasks
-    exit(0)
-  end
-  
-  psr.on('-u', '--quick-queue', 'Removes thread-safety from queue') do
-    mod = Module.new do
-      def synchronize
-        yield
-      end
-    end
-    app.queue.extend(mod)
-  end
-end
-
-#
-# build and run
-#
-
-# Traps interrupt the normal flow of the program and so I assume thread safety
-# is an issue (ex if the INT occurs during an enque and a signal specifies
-# another enque). A safer way to go is to enque the prompt... when the prompt
-# is executed the app won't be be doing anything else so thread safety
-# shouldn't be an issue.
-Signal.trap('INT') do
-  puts
-  puts "Interrupt!  Signals from an interruption are not thread-safe."
-  
-  require 'tap/prompt'
-  prompt = Tap::Prompt.new
-  call_prompt = true
-  3.times do
-    print "Wait for thread-safe break? (y/n): "
-    
-    case gets.strip
-    when /^y(es)?$/i
-      puts "waiting for break..."
-      app.queue.unshift(prompt, [])
-      call_prompt = false
-      break
-      
-    when /^no?$/i
-      break
-    end
-  end
-  
-  if call_prompt
-    prompt.call
-  end
-end
-
-begin
-  loop do
-    break if ARGV.empty?
-    parser.scan(ARGV, 
-      :option_break => Tap::Parser::BREAK,
-      :keep_break => true
-    ) do |path|
-      YAML.load_file(path).each do |spec|
-        app.call(spec)
-      end
-    end
-
-    break if ARGV.empty?
-    ARGV.replace app.call('sig' => 'parse', 'args' => ARGV)
-  end
-  
-  if opts[:serialize]
-    YAML.dump(app.serialize, $stdout)
-    exit(0)
-  end
-  
-  opts = nil
-  parser = nil
-  app.run
-  
-rescue
-  raise if app.debug?
-  puts $!.message
-  exit(1)
-end
-
-exit(0)

data/doc/Examples/Workflow

@@ -1,40 +0,0 @@
-= Workflow Examples
-
-=== Sequence
-
-A simple sequence using the --: syntax.
-
-  % tap run -- load 'goodnight moon' --: dump
-  goodnight moon
-  
-=== Sequence (canonical)
-
-The more canonical way of specifying a sequence.
-
-  % tap run -- load 'goodnight moon' -- dump --[0][1]
-  goodnight moon
-
-=== Fork
-
-Multiple outputs for a single input.
-
-  % tap run -- load 'goodnight moon' -- dump -- dump --[0][1,2]
-  goodnight moon
-  goodnight moon
-  
-=== Merge
-
-Multiple inputs for a single output; note that as seen in the output, dump
-receives the inputs in serial, whenever they happen to be ready.
-
-  % tap run -- load goodnight -- load moon -- dump --[0,1][2]
-  goodnight
-  moon
-
-=== Synchronized Merge
-
-Similar to a merge, but the results of each input are collected into an array
-before being passed to dump. The printout is: ['goodnight', 'moon'].to_s
-
-  % tap run -- load goodnight -- load moon -- dump --[0,1][2].sync
-  goodnightmoon

data/lib/tap/app/node.rb

@@ -1,29 +0,0 @@
-module Tap
-  class App
-    
-    # Node adds the node API[link:files/doc/API.html] to objects responding
-    # to call.  Additional helper methods are added to simplify the
-    # construction of workflows; they are not required by the API.
-    module Node
-
-      # The joins called when call completes
-      attr_accessor :joins
-      
-      # Interns a new node by extending the block with Node. 
-      def self.intern(&block)
-        block.extend self
-      end
-      
-      # Sets up required variables for extended objects.
-      def self.extended(obj) # :nodoc:
-        obj.instance_variable_set(:@joins, [])
-      end
-      
-      # Sets the block as a join for self.
-      def on_complete(&block) # :yields: result
-        self.joins << block if block
-        self
-      end
-    end
-  end
-end

data/lib/tap/env/context.rb

@@ -1,61 +0,0 @@
-module Tap
-  class Env
-    
-    # Context instances track information shared by a set of Env instances, for
-    # instance cached manifest data.  Caching cross-env data in a shared space
-    # simplifies managment of this data, especially when dumping and loading it
-    # from a static file.
-    #
-    # Contexts also ensure that only one env in initialized to a given
-    # directory (at least among envs that share the same context). This
-    # prevents errors that arise when one env eventually nests itself.
-    class Context
-      
-      # A hash of cached manifest data
-      attr_reader :cache
-      
-      # The config file basename
-      attr_reader :basename
-      
-      # An array of Env instances registered with self
-      attr_reader :instances
-      
-      # Initializes a new Context.  Options can specify a cache or a basename.
-      def initialize(options={})
-        options = {
-          :cache => {},
-          :basename => nil
-        }.merge(options)
-        
-        @cache = options[:cache]
-        @basename = options[:basename]
-        @instances = []
-      end
-      
-      # Registers env with self by adding env to instances.  Raises an error
-      # if instances contains an env with the same root directory.
-      def register(env)
-        path = env.root.root
-        
-        if instance(path)
-          raise "context already has an env for: #{path}"
-        end
-        
-        instances << env
-        self
-      end
-      
-      # Gets the instance for the directory currently in instances, or nil
-      # if such an instance does not exist.
-      def instance(dir)
-        instances.find {|env| env.root.root == dir }
-      end
-      
-      # Returns the config filepath for the directory (ie basename under dir).
-      # If basename is nil, then config_file always return nil.
-      def config_file(dir)
-        basename ? File.join(dir, basename) : nil
-      end
-    end
-  end
-end

data/lib/tap/env/gems.rb

@@ -1,63 +0,0 @@
-require 'rubygems'
-
-module Tap
-  class Env
-  
-    # Methods for working with {RubyGems}[http://www.rubygems.org/].
-    module Gems
-      module_function
-    
-      # Returns the gemspec for the specified gem.  A gem version 
-      # can be specified in the name, like 'gem >= 1.2'.  The gem
-      # is not activated by this method.
-      def gemspec(gem_name)
-        return gem_name if gem_name.kind_of?(Gem::Specification)
-        
-        dependency = if gem_name.kind_of?(Gem::Dependency)
-          gem_name
-        else
-          # figure the version of the gem, by default >= 0.0.0
-          gem_name.to_s =~ /^([^~<=>]*)(.*)$/
-          name, version = $1.strip, $2
-          return nil if name.empty?
-          version = Gem::Requirement.default if version.empty?
-      
-          # note the last gem matching the dependency requirements
-          # is the latest matching gem
-          Gem::Dependency.new(name, version)
-        end
-        
-        Gem.source_index.search(dependency).last
-      end
-    
-      # Selects gem specs for which the block returns true.  If
-      # latest is specified, only the latest version of each
-      # gem will be passed to the block.
-      def select_gems(latest=true)
-        specs = latest ?
-          Gem.source_index.latest_specs :
-          Gem.source_index.gems.collect {|(name, spec)| spec }
-        
-        # this song and dance is to ensure that specs are sorted
-        # by name (ascending) then version (descending) so that
-        # the latest version of a spec appears first
-        specs_by_name = {}
-        specs.each do |spec|
-          next unless !block_given? || yield(spec) 
-          (specs_by_name[spec.name] ||= []) << spec
-        end
-        
-        specs = []
-        specs_by_name.keys.sort.each do |name|
-          specs_by_name[name].sort_by do |spec| 
-            spec.version
-          end.reverse_each do |spec|
-            specs << spec
-          end
-        end
-        
-        specs
-      end
-    end
-  end
-end