Class: Minitest::VendoredPathExpander

Relationships & Source Files
Extension / Inclusion / Inheritance Descendants
Subclasses: PathExpander, Bisect::PathExpander
Inherits:	Object
Defined in:	lib/minitest/path_expander.rb

Overview

PathExpander helps pre-process command-line arguments expanding directories into their constituent files. It further helps by providing additional mechanisms to make specifying subsets easier with path subtraction and allowing for command-line arguments to be saved in a file.

NOTE: this is NOT an options processor. It is a path processor (basically everything else besides options). It does provide a mechanism for pre-filtering cmdline options, but not with the intent of actually processing them in PathExpander. Use OptionParser to deal with options either before or after passing ARGV through PathExpander.

Class Method Summary

.new(args, glob, path = ".") ⇒ VendoredPathExpander constructor

Create a new path expander that operates on args and expands via glob as necessary.

Instance Attribute Summary

#args rw

The args array to process.
#glob rw

The glob used to expand dirs to files.
#path rw

The path to scan if no paths are found in the initial scan.

Instance Method Summary

#expand_dirs_to_files(*dirs)

Takes an array of paths and returns an array of paths where all directories are expanded to all files found via the glob provided to PathExpander.
#filter_files(files, ignore)

A file filter mechanism similar to, but not as extensive as, .gitignore files:
#post_process
#pre_process
#process(&b)

Top-level method processes args.
#process_args

Enumerate over args passed to PathExpander and return a list of files and flags to process.
#process_file(path)

Process a file into more arguments.
#process_flags(flags)

Process over flags and treat any special ones here.

Constructor Details

.new(args, glob, path = ".") ⇒ `VendoredPathExpander`

Create a new path expander that operates on args and expands via glob as necessary. Takes an optional #path arg to fall back on if no paths are found on the initial scan (see #process_args).

[ GitHub ]

# File 'lib/minitest/path_expander.rb', line 42


def initialize args, glob, path = "."
  self.args = args
  self.glob = glob
  self.path = path
end

Instance Attribute Details

#args (rw)

The args array to process.

[ GitHub ]

# File 'lib/minitest/path_expander.rb', line 25


attr_accessor :args

#glob (rw)

The glob used to expand dirs to files.

[ GitHub ]

# File 'lib/minitest/path_expander.rb', line 30


attr_accessor :glob

#path (rw)

The path to scan if no paths are found in the initial scan.

[ GitHub ]

# File 'lib/minitest/path_expander.rb', line 35


attr_accessor :path

Instance Method Details

#expand_dirs_to_files(*dirs)

Takes an array of paths and returns an array of paths where all directories are expanded to all files found via the glob provided to PathExpander.

Paths are normalized to not have a leading “./”.

[ GitHub ]

# File 'lib/minitest/path_expander.rb', line 55


def expand_dirs_to_files *dirs
  dirs.flatten.map { |p|
    if File.directory? p then
      Dir[File.join(p, glob)].find_all { |f| File.file? f }
    else
      p
    end
  }.flatten.sort.map { |s| s.to_s.delete_prefix "./" }
end

#filter_files(files, ignore)

A file filter mechanism similar to, but not as extensive as, .gitignore files:

+ If a pattern does not contain a slash, it is treated as a shell glob. + If a pattern ends in a slash, it matches on directories (and contents). + Otherwise, it matches on relative paths.

File.fnmatch is used throughout, so glob patterns work for all 3 types.

Takes a list of files and either an io or path of ignore data and returns a list of files left after filtering.

[ GitHub ]

# File 'lib/minitest/path_expander.rb', line 194


def filter_files files, ignore
  ignore_paths = if ignore.respond_to? :read then
                   ignore.read
                 elsif File.exist? ignore then
                   File.read ignore
                 end

  if ignore_paths then
    nonglobs, globs = ignore_paths.split("\n").partition { |p| p.include? "/" }
    dirs, ifiles    = nonglobs.partition { |p| p.end_with? "/" }
    dirs            = dirs.map { |s| s.chomp "/" }

    dirs.map!   { |i| File.expand_path i }
    globs.map!  { |i| File.expand_path i }
    ifiles.map! { |i| File.expand_path i }

    only_paths = File::FNM_PATHNAME
    files = files.reject { |f|
      f = File.expand_path(f)
      dirs.any?     { |i| File.fnmatch?(i, File.dirname(f), only_paths) } ||
        globs.any?  { |i| File.fnmatch?(i, f) } ||
        ifiles.any? { |i| File.fnmatch?(i, f, only_paths) }
    }
  end

  files
end

#post_process

[ GitHub ]

# File 'lib/minitest/path_expander.rb', line 179


def post_process = nil

#pre_process

[ GitHub ]

# File 'lib/minitest/path_expander.rb', line 178


def pre_process = nil

#process(&b)

Top-level method processes args. If no block is given, immediately returns with an Enumerator for further chaining.

Otherwise, it calls #pre_process, #process_args and #process_flags, enumerates over the files, and then calls #post_process, returning self for any further chaining.

Most of the time, you’re going to provide a block to process files and do nothing more with the result. Eg:

PathExpander.new(ARGV).process do |f|
  puts "./#{f}"
end

or:

PathExpander.new(ARGV).process # => Enumerator

[ GitHub ]

# File 'lib/minitest/path_expander.rb', line 162


def process(&b)
  return enum_for(:process) unless block_given?

  pre_process

  files, flags = process_args

  args.replace process_flags flags

  files.uniq.each(&b)

  post_process

  self
end

#process_args

Enumerate over args passed to PathExpander and return a list of files and flags to process. Arguments are processed as:

-file_path: Subtract path from file to be processed.
-dir_path: Expand and subtract paths from files to be processed.
-not_a_path: Add to flags to be processed.
dir_path: Expand and add to files to be processed.
file_path: Add to files to be processed.

Add “-” (stdin) to files to be processed.

See expand_dirs_to_files for details on how expansion occurs.

Subtraction happens last, regardless of argument ordering.

If no files are found (which is not the same as having an empty file list after subtraction), then fall back to expanding on the default #path given to initialize.

[ GitHub ]

# File 'lib/minitest/path_expander.rb', line 93


def process_args
  pos_files = []
  neg_files = []
  flags     = []
  clean     = true

  root_dir = File.expand_path "/" # needed for windows paths

  args.each do |arg|
    case arg
    when /^@(.*)/ then # push back on, so they can have dirs/-/@ as well
      clean = false
      args.concat process_file $1
    when "-" then
      pos_files << arg
    when /^-(.*)/ then
      if File.exist? $1 then
        clean = false
        neg_files += expand_dirs_to_files($1)
      else
        flags << arg
      end
    else
      root_path = File.expand_path(arg) == root_dir # eg: -n /./
      if File.exist? arg and not root_path then
        clean = false
        pos_files += expand_dirs_to_files(arg)
      else
        flags << arg
      end
    end
  end

  files = pos_files - neg_files
  files += expand_dirs_to_files(self.path) if files.empty? && clean

  [files, flags]
end

#process_file(path)

Process a file into more arguments. Override this to add additional capabilities.

[ GitHub ]

# File 'lib/minitest/path_expander.rb', line 69


def process_file path
  File.readlines(path).map(&:chomp)
end

#process_flags(flags)

Process over flags and treat any special ones here. Returns an array of the flags you haven’t processed.

This version does nothing. Subclass and override for customization.

[ GitHub ]

# File 'lib/minitest/path_expander.rb', line 139


def process_flags flags
  flags
end

Class: Minitest::VendoredPathExpander

Overview

Class Method Summary

Instance Attribute Summary

Instance Method Summary

Constructor Details

.new(args, glob, path = ".") ⇒ VendoredPathExpander

Instance Attribute Details

#args (rw)

#glob (rw)

#path (rw)

Instance Method Details

#expand_dirs_to_files(*dirs)

#filter_files(files, ignore)

#post_process

#pre_process

#process(&b)

#process_args

#process_file(path)

#process_flags(flags)

.new(args, glob, path = ".") ⇒ `VendoredPathExpander`