tap 0.19.0 → 1.3.0

data/lib/tap/intern.rb

@@ -1,50 +0,0 @@
-module Tap
-  # Generates an Intern module to override the specified method_name.  Intern
-  # modules are useful to override a tiny bit of functionality without having
-  # to generate a full subclass.
-  #
-  # An Intern module:
-  #
-  # - adds an accessor for <method_name>_block
-  # - overrides <method_name> to call the block, prepending self to
-  #   the input arguments
-  #
-  # For example:
-  #
-  #   array = [1,2,3].extend Intern(:last)
-  #
-  #   array.last             # => 3
-  #   array.last_block = lambda {|arr| arr.first }
-  #   array.last             # => 3
-  #
-  def self.Intern(method_name)
-    mod = INTERN_MODULES[method_name.to_sym]
-    return mod unless mod == nil
-
-    mod = INTERN_MODULES[method_name.to_sym] = Module.new
-    mod.module_eval %Q{
-    attr_accessor :#{method_name}_block
-
-    def #{method_name}(*inputs)
-      return super unless #{method_name}_block
-      inputs.unshift(self)
-
-      arity = #{method_name}_block.arity
-      n = inputs.length
-      unless n == arity || (arity < 0 && (-1-n) <= arity) 
-        raise ArgumentError.new("wrong number of arguments (\#{n} for \#{arity})")
-      end
-
-      #{method_name}_block.call(*inputs)
-    end
-    }
-    mod
-  end
-  
-  # An array of already-declared intern modules,
-  # keyed by method_name.
-  INTERN_MODULES = {}
-  
-  # An Intern module for :process.
-  Intern = Tap::Intern(:process)
-end

data/lib/tap/joins.rb

@@ -1,9 +0,0 @@
-require 'tap/join'
-require 'tap/joins/switch'
-require 'tap/joins/sync'
-
-module Tap
-  # A module of standard Join classes supported by Tap.
-  module Joins
-  end
-end

data/lib/tap/prompt.rb

@@ -1,36 +0,0 @@
-require 'tap/app/api'
-require 'readline'
-
-module Tap
-  
-  # :startdoc::prompt
-  #
-  # A prompt to signal a running app. Any signals that return app (ie /run
-  # /stop /terminate) will exit the prompt.
-  class Prompt < App::Api
-    
-    def call
-      puts "starting prompt (help for help):"
-      loop do
-        begin
-          line = Readline.readline('--/', true).strip
-          next if line.empty?
-
-          args = Shellwords.shellwords(line)
-          "/#{args.shift}" =~ Tap::Parser::SIGNAL
-
-          result = app.call('obj' => $1, 'sig' => $2, 'args' => args)
-          if result == app
-            break
-          else
-            puts "=> #{result}"
-          end
-        rescue
-          puts $!.message
-          puts $!.backtrace if app.debug?
-        end
-      end
-    end
-  end
-end
-    

data/lib/tap/root/utils.rb

@@ -1,220 +0,0 @@
-require 'tap/root/versions'
-autoload(:FileUtils, 'fileutils')
-
-module Tap
-  class Root
-  
-    # A variety of utility methods for working with paths.
-    module Utils
-      include Versions
-    
-      # Regexp to match a windows-style root path.
-      WIN_ROOT_PATTERN = /^[A-z]:\//
-    
-      module_function
-    
-      # Returns the path of 'path' relative to dir.  Both dir and path will
-      # be expanded to dir_string, if specified, before the relative path is
-      # determined.  Returns nil if the path is not relative to dir.
-      #
-      #   relative_path('dir', "dir/path/to/file.txt")  # => "path/to/file.txt"
-      #
-      def relative_path(dir, path, dir_string=Dir.pwd)
-        if dir_string
-          dir = File.expand_path(dir, dir_string)
-          path = File.expand_path(path, dir_string)
-        end
-        return nil unless Utils.relative?(dir, path, false)
-    
-        # use dir.length + 1 to remove a leading '/'.   If dir.length + 1 >= expanded.length 
-        # as in: relative_path('/path', '/path') then the first arg returns nil, and an 
-        # empty string is returned
-        path[(dir.chomp("/").length + 1)..-1] || ""
-      end
-    
-      # Generates a target path translated from the source_dir to the
-      # target_dir. Raises an error if the path is not relative to the
-      # source_dir.    
-      #
-      #    translate("/path/to/file.txt", "/path", "/another/path")  # => '/another/path/to/file.txt'
-      #
-      def translate(path, source_dir, target_dir)
-        unless relative_path = relative_path(source_dir, path)
-          raise ArgumentError, "\n#{path}\nis not relative to:\n#{source_dir}"
-        end
-        File.join(target_dir, relative_path)
-      end
-    
-      # Returns the path, exchanging the extension with extname.  Extname may
-      # optionally omit the leading period.
-      #
-      #   exchange('path/to/file.txt', '.html')  # => 'path/to/file.html'
-      #   exchange('path/to/file.txt', 'rb')     # => 'path/to/file.rb'
-      #
-      def exchange(path, extname)
-        "#{path.chomp(File.extname(path))}#{extname[0] == ?. ? '' : '.'}#{extname}"
-      end
-  
-      # Lists all unique paths matching the input glob patterns.  
-      def glob(*patterns)
-        Dir[*patterns].uniq
-      end
-  
-      # Lists all unique versions of path matching the glob version patterns. If
-      # no patterns are specified, then all versions of path will be returned.
-      def version_glob(path, *vpatterns)
-        paths = []
-      
-        vpatterns << "*" if vpatterns.empty?
-        vpatterns.each do |vpattern| 
-          paths.concat Dir.glob(version(path, vpattern)) 
-  
-          # extra work to include the default version path for any version
-          paths << path if vpattern == "*" && File.exists?(path)
-        end
-      
-        paths.uniq
-      end
-    
-      # Path suffix glob.  Globs along the paths for the specified suffix
-      # pattern.
-      def suffix_glob(suffix_pattern, *paths)
-        paths.collect! {|path| File.join(path, suffix_pattern) }
-        Dir[*paths].uniq
-      end
-    
-      # Like Dir.chdir but makes the directory, if necessary, when mkdir is 
-      # specified. chdir raises an error for non-existant directories, as well
-      # as non-directory inputs.
-      def chdir(dir, mkdir=false, &block)
-        dir = File.expand_path(dir)
-      
-        unless File.directory?(dir)
-          if !File.exists?(dir) && mkdir
-            FileUtils.mkdir_p(dir)
-          else
-            raise ArgumentError, "not a directory: #{dir}"
-          end
-        end
-      
-        Dir.chdir(dir, &block)
-      end
-    
-      # Prepares the input path by making the parent directory for path. If a
-      # block is given, a file is created at path and passed to it; in this
-      # way files with non-existant parent directories are readily made.
-      #
-      # Returns path.
-      def prepare(path)
-        dirname = File.dirname(path)
-        FileUtils.mkdir_p(dirname) unless File.exists?(dirname)
-        File.open(path, "w") {|io| yield(io) } if block_given?
-        path
-      end
-    
-      # The path root type indicating windows, *nix, or some unknown style of
-      # paths (:win, :nix, :unknown).
-      def path_root_type
-        @path_root_type ||= case
-        when RUBY_PLATFORM =~ /mswin/ && File.expand_path(".") =~ WIN_ROOT_PATTERN then :win 
-        when File.expand_path(".")[0] == ?/ then :nix
-        else :unknown
-        end
-      end
-    
-      # Returns true if the input path appears to be an expanded path, based on
-      # path_root_type.  
-      #
-      # If root_type == :win returns true if the path matches WIN_ROOT_PATTERN.
-      #
-      #   expanded?('C:/path')  # => true
-      #   expanded?('c:/path')  # => true
-      #   expanded?('D:/path')  # => true
-      #   expanded?('path')     # => false
-      #
-      # If root_type == :nix, then expanded? returns true if the path begins
-      # with '/'.
-      #
-      #   expanded?('/path')  # => true
-      #   expanded?('path')   # => false
-      #
-      # Otherwise expanded? always returns nil.
-      def expanded?(path, root_type=path_root_type)
-        case root_type
-        when :win 
-          path =~ WIN_ROOT_PATTERN ? true : false
-        when :nix  
-          path[0] == ?/
-        else
-          nil
-        end
-      end
-    
-      # Returns true if path is relative to dir.  Both path and dir will be
-      # expanded relative to dir_string, if specified.
-      def relative?(dir, path, dir_string=Dir.pwd)
-        if dir_string
-          dir = File.expand_path(dir, dir_string)
-          path = File.expand_path(path, dir_string)
-        end
-      
-        path.rindex(dir, 0) == 0
-      end
-    
-      # Trivial indicates when a path does not have content to load.  Returns
-      # true if the file at path is empty, non-existant, a directory, or nil.
-      def trivial?(path)
-        path == nil || !File.file?(path) || File.size(path) == 0
-      end
-    
-      # Empty returns true when dir is an existing directory that has no files.
-      def empty?(dir)
-        File.directory?(dir) && (Dir.entries(dir) - ['.', '..']).empty?
-      end
-    
-      # Returns the path segments for the given path, splitting along the path 
-      # divider.  Env paths are always represented by a string, if only an 
-      # empty string.
-      #
-      #   os          divider    example
-      #   windows     '\'        split('C:\path\to\file')  # => ["C:", "path", "to", "file"]
-      #   *nix        '/'        split('/path/to/file')    # => ["", "path", "to", "file"]
-      # 
-      # The path is always expanded relative to the expand_dir; so '.' and
-      # '..' are resolved.  However, unless expand_path == true, only the
-      # segments relative to the expand_dir are returned.  
-      #
-      # On windows (note that expanding paths allows the use of slashes or
-      # backslashes):
-      #
-      #   Dir.pwd                                          # => 'C:/'
-      #   split('path\to\..\.\to\file')                    # => ["C:", "path", "to", "file"]
-      #   split('path/to/.././to/file', false)             # => ["path", "to", "file"]
-      #
-      # On *nix (or more generally systems with '/' roots):
-      #
-      #   Dir.pwd                                          # => '/'
-      #   split('path/to/.././to/file')                    # => ["", "path", "to", "file"]
-      #   split('path/to/.././to/file', false)             # => ["path", "to", "file"]
-      #
-      def split(path, expand_path=true, expand_dir=Dir.pwd)
-        path = if expand_path
-          File.expand_path(path, expand_dir)
-        else
-          # normalize the path by expanding it, then
-          # work back to the relative path as needed
-          expanded_dir = File.expand_path(expand_dir)
-          expanded_path = File.expand_path(path, expand_dir)
-          expanded_path.index(expanded_dir) != 0 ? expanded_path : relative_path(expanded_dir, expanded_path)
-        end
-
-        segments = path.scan(/[^\/]+/)
-
-        # add back the root path as needed on *nix 
-        segments.unshift "" if path[0] == ?/
-        segments
-      end
-    
-    end
-  end
-end

data/lib/tap/root/versions.rb

@@ -1,138 +0,0 @@
-module Tap
-  class Root    
-    # Version provides methods for adding, removing, and incrementing versions
-    # at the end of paths.  Versions are all formatted like:
-    # 'path-version.extension'.
-    #
-    module Versions
-    
-      # Adds a version to the path.  Versioned paths follow the format:
-      # 'path-version.extension'.  If no version is specified, then the
-      # path is returned.
-      #
-      #   version("path/to/file.txt", 1.0)            # => "path/to/file-1.0.txt"
-      #
-      def version(path, version)
-        version = version.to_s.strip
-        if version.empty? 
-          path
-        else
-          extname = File.extname(path)
-          path.chomp(extname) + '-' + version + extname
-        end
-      end
-    
-      # Increments the version of the path by the specified increment.  
-      #
-      #   increment("path/to/file-1.0.txt", "0.0.1")  # => "path/to/file-1.0.1.txt"
-      #   increment("path/to/file.txt", 1.0)          # => "path/to/file-1.0.txt"
-      #
-      def increment(path, increment)
-        path, version = deversion(path)
-      
-        # split the version and increment into integer arrays of equal length
-        increment, version = [increment, version].collect do |vstr| 
-          begin
-            vstr.to_s.split(/\./).collect {|v| v.to_i}
-          rescue
-            raise "Bad version or increment: #{vstr}"
-          end
-        end
-      
-        if increment.length > version.length
-          version.concat Array.new(increment.length - version.length, 0)
-        end
-      
-        # add the increment to version
-        0.upto(version.length-1) do |i|
-          version[i] += (increment[i] || 0)
-        end
-
-        self.version(path, version.join("."))
-      end
-    
-      # Splits the version from the input path, then returns the path and
-      # version. If no version is specified, then the returned version will be
-      # nil.
-      #
-      #   deversion("path/to/file-1.0.txt")           # => ["path/to/file.txt", "1.0"]
-      #   deversion("path/to/file.txt")               # => ["path/to/file.txt", nil]
-      #
-      def deversion(path)
-        extname = File.extname(path)
-        extname = '' if extname =~ /^\.\d+$/
-        path =~ /^(.*)-(\d(\.?\d)*)#{extname}$/ ? [$1 + extname, $2] : [path, nil]
-      end
-    
-      # A <=> comparison for versions.  compare_versions can take strings,
-      # integers, or even arrays representing the parts of a version.
-      #
-      #   compare_versions("1.0.0", "0.9.9")          # => 1
-      #   compare_versions(1.1, 1.1)                  # => 0
-      #   compare_versions([0,9], [0,9,1])            # => -1
-      def compare_versions(a,b)
-        a, b = [a,b].collect {|item| to_integer_array(item) }
-      
-        # equalize the lengths of the integer arrays
-        d = b.length - a.length
-        case 
-        when d < 0 then b.concat Array.new(-d, 0)
-        when d > 0 then a.concat Array.new(d, 0)
-        end 
-    
-        a <=> b
-      end
-    
-      # Version unique.  Select the latest or earliest versions of each file
-      # in the array.  For paths that have no version, vniq considers any
-      # version to beat no version.  The order of paths is preserved by
-      # default, but the extra sort doing so may be turned off.
-      #
-      #   paths = [
-      #    "/path/to/two-0.0.1.txt",
-      #    "/path/to/one-0.0.1.txt",
-      #    "/path/to/one.txt",
-      #    "/path/to/two-1.0.1.txt",
-      #    "/path/to/three.txt"]
-      #
-      #   vniq(paths)
-      #   # => [
-      #   # "/path/to/one-0.0.1.txt",
-      #   # "/path/to/two-1.0.1.txt",
-      #   # "/path/to/three.txt"]
-      #
-      def vniq(array, earliest=false, preserve_order=true)
-        unique = {}
-        array.sort.each do |path|
-          base, version = deversion(path)
-          (unique[base] ||= []) << version
-        end
-      
-        results = []
-        unique.each_pair do |base, versions|
-          versions = versions.sort {|a, b| compare_versions(a,b) }
-          winner = earliest ? versions.shift : versions.pop
-          results << version(base, winner)
-        end
-      
-        results = results.sort_by do |path|
-          array.index(path)
-        end if preserve_order
-      
-        results
-      end
-    
-      private
-    
-      # Converts an input argument (typically a string or an array) to an
-      # array of integers.  Splits version string on "."
-      def to_integer_array(arg)
-        arr = case arg
-        when Array then arg
-        else arg.to_s.split('.')
-        end
-        arr.collect {|i| i.to_i}
-      end
-    end
-  end
-end