guesswhat 0.1.0

data/vendor/bundle/gems/rake-10.5.0/lib/rake/file_list.rb

@@ -0,0 +1,428 @@
+require 'rake/cloneable'
+require 'rake/file_utils_ext'
+require 'rake/pathmap'
+
+
+module Rake
+
+  ##
+  # A FileList is essentially an array with a few helper methods defined to
+  # make file manipulation a bit easier.
+  #
+  # FileLists are lazy.  When given a list of glob patterns for possible files
+  # to be included in the file list, instead of searching the file structures
+  # to find the files, a FileList holds the pattern for latter use.
+  #
+  # This allows us to define a number of FileList to match any number of
+  # files, but only search out the actual files when then FileList itself is
+  # actually used.  The key is that the first time an element of the
+  # FileList/Array is requested, the pending patterns are resolved into a real
+  # list of file names.
+  #
+  class FileList
+
+    include Cloneable
+
+    # == Method Delegation
+    #
+    # The lazy evaluation magic of FileLists happens by implementing all the
+    # array specific methods to call +resolve+ before delegating the heavy
+    # lifting to an embedded array object (@items).
+    #
+    # In addition, there are two kinds of delegation calls.  The regular kind
+    # delegates to the @items array and returns the result directly.  Well,
+    # almost directly.  It checks if the returned value is the @items object
+    # itself, and if so will return the FileList object instead.
+    #
+    # The second kind of delegation call is used in methods that normally
+    # return a new Array object.  We want to capture the return value of these
+    # methods and wrap them in a new FileList object.  We enumerate these
+    # methods in the +SPECIAL_RETURN+ list below.
+
+    # List of array methods (that are not in +Object+) that need to be
+    # delegated.
+    ARRAY_METHODS = (Array.instance_methods - Object.instance_methods).
+      map { |n| n.to_s }
+
+    # List of additional methods that must be delegated.
+    MUST_DEFINE = %w[inspect <=>]
+
+    # List of methods that should not be delegated here (we define special
+    # versions of them explicitly below).
+    MUST_NOT_DEFINE = %w[to_a to_ary partition * <<]
+
+    # List of delegated methods that return new array values which need
+    # wrapping.
+    SPECIAL_RETURN = %w[
+      map collect sort sort_by select find_all reject grep
+      compact flatten uniq values_at
+      + - & |
+    ]
+
+    DELEGATING_METHODS = (ARRAY_METHODS + MUST_DEFINE - MUST_NOT_DEFINE).
+      map { |s| s.to_s }.sort.uniq
+
+    # Now do the delegation.
+    DELEGATING_METHODS.each do |sym|
+      if SPECIAL_RETURN.include?(sym)
+        ln = __LINE__ + 1
+        class_eval %{
+          def #{sym}(*args, &block)
+            resolve
+            result = @items.send(:#{sym}, *args, &block)
+            self.class.new.import(result)
+          end
+        }, __FILE__, ln
+      else
+        ln = __LINE__ + 1
+        class_eval %{
+          def #{sym}(*args, &block)
+            resolve
+            result = @items.send(:#{sym}, *args, &block)
+            result.object_id == @items.object_id ? self : result
+          end
+        }, __FILE__, ln
+      end
+    end
+
+    # Create a file list from the globbable patterns given.  If you wish to
+    # perform multiple includes or excludes at object build time, use the
+    # "yield self" pattern.
+    #
+    # Example:
+    #   file_list = FileList.new('lib/**/*.rb', 'test/test*.rb')
+    #
+    #   pkg_files = FileList.new('lib/**/*') do |fl|
+    #     fl.exclude(/\bCVS\b/)
+    #   end
+    #
+    def initialize(*patterns)
+      @pending_add = []
+      @pending = false
+      @exclude_patterns = DEFAULT_IGNORE_PATTERNS.dup
+      @exclude_procs = DEFAULT_IGNORE_PROCS.dup
+      @items = []
+      patterns.each { |pattern| include(pattern) }
+      yield self if block_given?
+    end
+
+    # Add file names defined by glob patterns to the file list.  If an array
+    # is given, add each element of the array.
+    #
+    # Example:
+    #   file_list.include("*.java", "*.cfg")
+    #   file_list.include %w( math.c lib.h *.o )
+    #
+    def include(*filenames)
+      # TODO: check for pending
+      filenames.each do |fn|
+        if fn.respond_to? :to_ary
+          include(*fn.to_ary)
+        else
+          @pending_add << Rake.from_pathname(fn)
+        end
+      end
+      @pending = true
+      self
+    end
+    alias :add :include
+
+    # Register a list of file name patterns that should be excluded from the
+    # list.  Patterns may be regular expressions, glob patterns or regular
+    # strings.  In addition, a block given to exclude will remove entries that
+    # return true when given to the block.
+    #
+    # Note that glob patterns are expanded against the file system. If a file
+    # is explicitly added to a file list, but does not exist in the file
+    # system, then an glob pattern in the exclude list will not exclude the
+    # file.
+    #
+    # Examples:
+    #   FileList['a.c', 'b.c'].exclude("a.c") => ['b.c']
+    #   FileList['a.c', 'b.c'].exclude(/^a/)  => ['b.c']
+    #
+    # If "a.c" is a file, then ...
+    #   FileList['a.c', 'b.c'].exclude("a.*") => ['b.c']
+    #
+    # If "a.c" is not a file, then ...
+    #   FileList['a.c', 'b.c'].exclude("a.*") => ['a.c', 'b.c']
+    #
+    def exclude(*patterns, &block)
+      patterns.each do |pat|
+        @exclude_patterns << Rake.from_pathname(pat)
+      end
+      @exclude_procs << block if block_given?
+      resolve_exclude unless @pending
+      self
+    end
+
+    # Clear all the exclude patterns so that we exclude nothing.
+    def clear_exclude
+      @exclude_patterns = []
+      @exclude_procs = []
+      self
+    end
+
+    # A FileList is equal through array equality.
+    def ==(array)
+      to_ary == array
+    end
+
+    # Return the internal array object.
+    def to_a
+      resolve
+      @items
+    end
+
+    # Return the internal array object.
+    def to_ary
+      to_a
+    end
+
+    # Lie about our class.
+    def is_a?(klass)
+      klass == Array || super(klass)
+    end
+    alias kind_of? is_a?
+
+    # Redefine * to return either a string or a new file list.
+    def *(other)
+      result = @items * other
+      case result
+      when Array
+        FileList.new.import(result)
+      else
+        result
+      end
+    end
+
+    def <<(obj)
+      resolve
+      @items << Rake.from_pathname(obj)
+      self
+    end
+
+    # Resolve all the pending adds now.
+    def resolve
+      if @pending
+        @pending = false
+        @pending_add.each do |fn| resolve_add(fn) end
+        @pending_add = []
+        resolve_exclude
+      end
+      self
+    end
+
+    def resolve_add(fn) # :nodoc:
+      case fn
+      when %r{[*?\[\{]}
+        add_matching(fn)
+      else
+        self << fn
+      end
+    end
+    private :resolve_add
+
+    def resolve_exclude # :nodoc:
+      reject! { |fn| excluded_from_list?(fn) }
+      self
+    end
+    private :resolve_exclude
+
+    # Return a new FileList with the results of running +sub+ against each
+    # element of the original list.
+    #
+    # Example:
+    #   FileList['a.c', 'b.c'].sub(/\.c$/, '.o')  => ['a.o', 'b.o']
+    #
+    def sub(pat, rep)
+      inject(FileList.new) { |res, fn| res << fn.sub(pat, rep) }
+    end
+
+    # Return a new FileList with the results of running +gsub+ against each
+    # element of the original list.
+    #
+    # Example:
+    #   FileList['lib/test/file', 'x/y'].gsub(/\//, "\\")
+    #      => ['lib\\test\\file', 'x\\y']
+    #
+    def gsub(pat, rep)
+      inject(FileList.new) { |res, fn| res << fn.gsub(pat, rep) }
+    end
+
+    # Same as +sub+ except that the original file list is modified.
+    def sub!(pat, rep)
+      each_with_index { |fn, i| self[i] = fn.sub(pat, rep) }
+      self
+    end
+
+    # Same as +gsub+ except that the original file list is modified.
+    def gsub!(pat, rep)
+      each_with_index { |fn, i| self[i] = fn.gsub(pat, rep) }
+      self
+    end
+
+    # Apply the pathmap spec to each of the included file names, returning a
+    # new file list with the modified paths.  (See String#pathmap for
+    # details.)
+    def pathmap(spec=nil)
+      collect { |fn| fn.pathmap(spec) }
+    end
+
+    # Return a new FileList with <tt>String#ext</tt> method applied to
+    # each member of the array.
+    #
+    # This method is a shortcut for:
+    #
+    #    array.collect { |item| item.ext(newext) }
+    #
+    # +ext+ is a user added method for the Array class.
+    def ext(newext='')
+      collect { |fn| fn.ext(newext) }
+    end
+
+    # Grep each of the files in the filelist using the given pattern. If a
+    # block is given, call the block on each matching line, passing the file
+    # name, line number, and the matching line of text.  If no block is given,
+    # a standard emacs style file:linenumber:line message will be printed to
+    # standard out.  Returns the number of matched items.
+    def egrep(pattern, *options)
+      matched = 0
+      each do |fn|
+        begin
+          open(fn, "r", *options) do |inf|
+            count = 0
+            inf.each do |line|
+              count += 1
+              if pattern.match(line)
+                matched += 1
+                if block_given?
+                  yield fn, count, line
+                else
+                  puts "#{fn}:#{count}:#{line}"
+                end
+              end
+            end
+          end
+        rescue StandardError => ex
+          $stderr.puts "Error while processing '#{fn}': #{ex}"
+        end
+      end
+      matched
+    end
+
+    # Return a new file list that only contains file names from the current
+    # file list that exist on the file system.
+    def existing
+      select { |fn| File.exist?(fn) }
+    end
+
+    # Modify the current file list so that it contains only file name that
+    # exist on the file system.
+    def existing!
+      resolve
+      @items = @items.select { |fn| File.exist?(fn) }
+      self
+    end
+
+    # FileList version of partition.  Needed because the nested arrays should
+    # be FileLists in this version.
+    def partition(&block)       # :nodoc:
+      resolve
+      result = @items.partition(&block)
+      [
+        FileList.new.import(result[0]),
+        FileList.new.import(result[1]),
+      ]
+    end
+
+    # Convert a FileList to a string by joining all elements with a space.
+    def to_s
+      resolve
+      self.join(' ')
+    end
+
+    # Add matching glob patterns.
+    def add_matching(pattern)
+      FileList.glob(pattern).each do |fn|
+        self << fn unless excluded_from_list?(fn)
+      end
+    end
+    private :add_matching
+
+    # Should the given file name be excluded from the list?
+    #
+    # NOTE: This method was formerly named "exclude?", but Rails
+    # introduced an exclude? method as an array method and setup a
+    # conflict with file list. We renamed the method to avoid
+    # confusion. If you were using "FileList#exclude?" in your user
+    # code, you will need to update.
+    def excluded_from_list?(fn)
+      return true if @exclude_patterns.any? do |pat|
+        case pat
+        when Regexp
+          fn =~ pat
+        when /[*?]/
+          File.fnmatch?(pat, fn, File::FNM_PATHNAME)
+        else
+          fn == pat
+        end
+      end
+      @exclude_procs.any? { |p| p.call(fn) }
+    end
+
+    DEFAULT_IGNORE_PATTERNS = [
+      /(^|[\/\\])CVS([\/\\]|$)/,
+      /(^|[\/\\])\.svn([\/\\]|$)/,
+      /\.bak$/,
+      /~$/
+    ]
+    DEFAULT_IGNORE_PROCS = [
+      proc { |fn| fn =~ /(^|[\/\\])core$/ && ! File.directory?(fn) }
+    ]
+
+    def import(array) # :nodoc:
+      @items = array
+      self
+    end
+
+    class << self
+      # Create a new file list including the files listed. Similar to:
+      #
+      #   FileList.new(*args)
+      def [](*args)
+        new(*args)
+      end
+
+      # Get a sorted list of files matching the pattern. This method
+      # should be preferred to Dir[pattern] and Dir.glob(pattern) because
+      # the files returned are guaranteed to be sorted.
+      def glob(pattern, *args)
+        Dir.glob(pattern, *args).sort
+      end
+    end
+  end
+end
+
+module Rake
+  class << self
+
+    # Yield each file or directory component.
+    def each_dir_parent(dir)    # :nodoc:
+      old_length = nil
+      while dir != '.' && dir.length != old_length
+        yield(dir)
+        old_length = dir.length
+        dir = File.dirname(dir)
+      end
+    end
+
+    # Convert Pathname and Pathname-like objects to strings;
+    # leave everything else alone
+    def from_pathname(path)    # :nodoc:
+      path = path.to_path if path.respond_to?(:to_path)
+      path = path.to_str if path.respond_to?(:to_str)
+      path
+    end
+  end
+end # module Rake

data/vendor/bundle/gems/rake-10.5.0/lib/rake/file_task.rb

@@ -0,0 +1,46 @@
+require 'rake/task.rb'
+require 'rake/early_time'
+
+module Rake
+
+  # A FileTask is a task that includes time based dependencies.  If any of a
+  # FileTask's prerequisites have a timestamp that is later than the file
+  # represented by this task, then the file must be rebuilt (using the
+  # supplied actions).
+  #
+  class FileTask < Task
+
+    # Is this file task needed?  Yes if it doesn't exist, or if its time stamp
+    # is out of date.
+    def needed?
+      ! File.exist?(name) || out_of_date?(timestamp) || @application.options.build_all
+    end
+
+    # Time stamp for file task.
+    def timestamp
+      if File.exist?(name)
+        File.mtime(name.to_s)
+      else
+        Rake::LATE
+      end
+    end
+
+    private
+
+    # Are there any prerequisites with a later time than the given time stamp?
+    def out_of_date?(stamp)
+      @prerequisites.any? { |n| application[n, @scope].timestamp > stamp }
+    end
+
+    # ----------------------------------------------------------------
+    # Task class methods.
+    #
+    class << self
+      # Apply the scope to the task name according to the rules for this kind
+      # of task.  File based tasks ignore the scope when creating the name.
+      def scope_name(scope, task_name)
+        Rake.from_pathname(task_name)
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rake-10.5.0/lib/rake/file_utils.rb

@@ -0,0 +1,128 @@
+require 'rbconfig'
+require 'fileutils'
+
+#--
+# This a FileUtils extension that defines several additional commands to be
+# added to the FileUtils utility functions.
+module FileUtils
+  # Path to the currently running Ruby program
+  RUBY = ENV['RUBY'] || File.join(
+    RbConfig::CONFIG['bindir'],
+    RbConfig::CONFIG['ruby_install_name'] + RbConfig::CONFIG['EXEEXT']).
+    sub(/.*\s.*/m, '"\&"')
+
+  OPT_TABLE['sh']  = %w(noop verbose)
+  OPT_TABLE['ruby'] = %w(noop verbose)
+
+  # Run the system command +cmd+.  If multiple arguments are given the command
+  # is run directly (without the shell, same semantics as Kernel::exec and
+  # Kernel::system).
+  #
+  # It is recommended you use the multiple argument form over interpolating
+  # user input for both usability and security reasons.  With the multiple
+  # argument form you can easily process files with spaces or other shell
+  # reserved characters in them.  With the multiple argument form your rake
+  # tasks are not vulnerable to users providing an argument like
+  # <code>; rm # -rf /</code>.
+  #
+  # If a block is given, upon command completion the block is called with an
+  # OK flag (true on a zero exit status) and a Process::Status object.
+  # Without a block a RuntimeError is raised when the command exits non-zero.
+  #
+  # Examples:
+  #
+  #   sh 'ls -ltr'
+  #
+  #   sh 'ls', 'file with spaces'
+  #
+  #   # check exit status after command runs
+  #   sh %{grep pattern file} do |ok, res|
+  #     if ! ok
+  #       puts "pattern not found (status = #{res.exitstatus})"
+  #     end
+  #   end
+  #
+  def sh(*cmd, &block)
+    options = (Hash === cmd.last) ? cmd.pop : {}
+    shell_runner = block_given? ? block : create_shell_runner(cmd)
+    set_verbose_option(options)
+    options[:noop] ||= Rake::FileUtilsExt.nowrite_flag
+    Rake.rake_check_options options, :noop, :verbose
+    Rake.rake_output_message cmd.join(" ") if options[:verbose]
+
+    unless options[:noop]
+      res = rake_system(*cmd)
+      status = $?
+      status = Rake::PseudoStatus.new(1) if !res && status.nil?
+      shell_runner.call(res, status)
+    end
+  end
+
+  def create_shell_runner(cmd) # :nodoc:
+    show_command = cmd.join(" ")
+    show_command = show_command[0, 42] + "..." unless $trace
+    lambda do |ok, status|
+      ok or
+        fail "Command failed with status (#{status.exitstatus}): " +
+        "[#{show_command}]"
+    end
+  end
+  private :create_shell_runner
+
+  def set_verbose_option(options) # :nodoc:
+    unless options.key? :verbose
+      options[:verbose] =
+        (Rake::FileUtilsExt.verbose_flag == Rake::FileUtilsExt::DEFAULT) ||
+        Rake::FileUtilsExt.verbose_flag
+    end
+  end
+  private :set_verbose_option
+
+  def rake_system(*cmd) # :nodoc:
+    Rake::AltSystem.system(*cmd)
+  end
+  private :rake_system
+
+  # Run a Ruby interpreter with the given arguments.
+  #
+  # Example:
+  #   ruby %{-pe '$_.upcase!' <README}
+  #
+  def ruby(*args, &block)
+    options = (Hash === args.last) ? args.pop : {}
+    if args.length > 1
+      sh(*([RUBY] + args + [options]), &block)
+    else
+      sh("#{RUBY} #{args.first}", options, &block)
+    end
+  end
+
+  LN_SUPPORTED = [true]
+
+  #  Attempt to do a normal file link, but fall back to a copy if the link
+  #  fails.
+  def safe_ln(*args)
+    if ! LN_SUPPORTED[0]
+      cp(*args)
+    else
+      begin
+        ln(*args)
+      rescue StandardError, NotImplementedError
+        LN_SUPPORTED[0] = false
+        cp(*args)
+      end
+    end
+  end
+
+  # Split a file path into individual directory names.
+  #
+  # Example:
+  #   split_all("a/b/c") =>  ['a', 'b', 'c']
+  #
+  def split_all(path)
+    head, tail = File.split(path)
+    return [tail] if head == '.' || tail == '/'
+    return [head, tail] if head == '/'
+    return split_all(head) + [tail]
+  end
+end