warbler 2.0.0 → 2.0.1

data/spec/sample_bundler/vendor/bundle/jruby/2.3.0/gems/rake-10.5.0/lib/rake/contrib/sys.rb

@@ -0,0 +1,4 @@
+# TODO: Remove in Rake 11
+
+fail "ERROR: 'rake/contrib/sys' is obsolete and no longer supported. " +
+  "Use 'FileUtils' instead."

data/spec/sample_bundler/vendor/bundle/jruby/2.3.0/gems/rake-10.5.0/lib/rake/cpu_counter.rb

@@ -0,0 +1,125 @@
+module Rake
+
+  # Based on a script at:
+  #   http://stackoverflow.com/questions/891537/ruby-detect-number-of-cpus-installed
+  class CpuCounter # :nodoc: all
+    def self.count
+      new.count_with_default
+    end
+
+    def count_with_default(default=4)
+      count || default
+    rescue StandardError
+      default
+    end
+
+    begin
+      require 'etc'
+    rescue LoadError
+    else
+      if Etc.respond_to?(:nprocessors)
+        def count
+          return Etc.nprocessors
+        end
+      end
+    end
+  end
+end
+
+unless Rake::CpuCounter.method_defined?(:count)
+  Rake::CpuCounter.class_eval <<-'end;', __FILE__, __LINE__+1
+    require 'rbconfig'
+
+    # TODO: replace with IO.popen using array-style arguments in Rake 11
+    require 'open3'
+
+    def count
+      if defined?(Java::Java)
+        count_via_java_runtime
+      else
+        case RbConfig::CONFIG['host_os']
+        when /darwin9/
+          count_via_hwprefs_cpu_count
+        when /darwin/
+          count_via_hwprefs_thread_count || count_via_sysctl
+        when /linux/
+          count_via_cpuinfo
+        when /bsd/
+          count_via_sysctl
+        when /mswin|mingw/
+          count_via_win32
+        else
+          # Try everything
+          count_via_win32 ||
+            count_via_sysctl ||
+            count_via_hwprefs_thread_count ||
+            count_via_hwprefs_cpu_count ||
+            count_via_cpuinfo
+        end
+      end
+    end
+
+    def count_via_java_runtime
+      Java::Java.lang.Runtime.getRuntime.availableProcessors
+    rescue StandardError
+      nil
+    end
+
+    def count_via_win32
+      require 'win32ole'
+      wmi = WIN32OLE.connect("winmgmts://")
+      cpu = wmi.ExecQuery("select NumberOfCores from Win32_Processor") # TODO count hyper-threaded in this
+      cpu.to_enum.first.NumberOfCores
+    rescue StandardError, LoadError
+      nil
+    end
+
+    def count_via_cpuinfo
+      open('/proc/cpuinfo') { |f| f.readlines }.grep(/processor/).size
+    rescue StandardError
+      nil
+    end
+
+    def count_via_hwprefs_thread_count
+      run 'hwprefs', 'thread_count'
+    end
+
+    def count_via_hwprefs_cpu_count
+      run 'hwprefs', 'cpu_count'
+    end
+
+    def count_via_sysctl
+      run 'sysctl', '-n', 'hw.ncpu'
+    end
+
+    def run(command, *args)
+      cmd = resolve_command(command)
+      if cmd
+        Open3.popen3 cmd, *args do |inn, out, err,|
+          inn.close
+          err.read
+          out.read.to_i
+        end
+      else
+        nil
+      end
+    end
+
+    def resolve_command(command)
+      look_for_command("/usr/sbin", command) ||
+        look_for_command("/sbin", command) ||
+        in_path_command(command)
+    end
+
+    def look_for_command(dir, command)
+      path = File.join(dir, command)
+      File.exist?(path) ? path : nil
+    end
+
+    def in_path_command(command)
+      Open3.popen3 'which', command do |_, out,|
+        out.eof? ? nil : command
+      end
+    end
+  end;
+end

data/spec/sample_bundler/vendor/bundle/jruby/2.3.0/gems/rake-10.5.0/lib/rake/default_loader.rb

@@ -0,0 +1,14 @@
+module Rake
+
+  # Default Rakefile loader used by +import+.
+  class DefaultLoader
+
+    ##
+    # Loads a rakefile into the current application from +fn+
+
+    def load(fn)
+      Rake.load_rakefile(File.expand_path(fn))
+    end
+  end
+
+end

data/spec/sample_bundler/vendor/bundle/jruby/2.3.0/gems/rake-10.5.0/lib/rake/dsl_definition.rb

@@ -0,0 +1,201 @@
+# Rake DSL functions.
+require 'rake/file_utils_ext'
+
+module Rake
+
+  ##
+  # DSL is a module that provides #task, #desc, #namespace, etc.  Use this
+  # when you'd like to use rake outside the top level scope.
+  #
+  # For a Rakefile you run from the command line this module is automatically
+  # included.
+
+  module DSL
+
+    #--
+    # Include the FileUtils file manipulation functions in the top
+    # level module, but mark them private so that they don't
+    # unintentionally define methods on other objects.
+    #++
+
+    include FileUtilsExt
+    private(*FileUtils.instance_methods(false))
+    private(*FileUtilsExt.instance_methods(false))
+
+    private
+
+    # :call-seq:
+    #   task task_name
+    #   task task_name: dependencies
+    #   task task_name, arguments => dependencies
+    #   task task_name, argument[, argument ...], :needs: dependencies
+    #
+    # Declare a basic task.  The +task_name+ is always the first argument.  If
+    # the task name contains a ":" it is defined in that namespace.
+    #
+    # The +dependencies+ may be a single task name or an Array of task names.
+    # The +argument+ (a single name) or +arguments+ (an Array of names) define
+    # the arguments provided to the task.
+    #
+    # The task, argument and dependency names may be either symbols or
+    # strings.
+    #
+    # A task with a single dependency:
+    #
+    #   task clobber: %w[clean] do
+    #     rm_rf "html"
+    #   end
+    #
+    # A task with an argument and a dependency:
+    #
+    #   task :package, [:version] => :test do |t, args|
+    #     # ...
+    #   end
+    #
+    # To invoke this task from the command line:
+    #
+    #   $ rake package[1.2.3]
+    #
+    # Alternate definition:
+    #
+    #   task :package, :version, needs: :test do |t, args|
+    #     # ...
+    #   end
+    #
+    def task(*args, &block) # :doc:
+      Rake::Task.define_task(*args, &block)
+    end
+
+    # Declare a file task.
+    #
+    # Example:
+    #   file "config.cfg" => ["config.template"] do
+    #     open("config.cfg", "w") do |outfile|
+    #       open("config.template") do |infile|
+    #         while line = infile.gets
+    #           outfile.puts line
+    #         end
+    #       end
+    #     end
+    #  end
+    #
+    def file(*args, &block) # :doc:
+      Rake::FileTask.define_task(*args, &block)
+    end
+
+    # Declare a file creation task.
+    # (Mainly used for the directory command).
+    def file_create(*args, &block)
+      Rake::FileCreationTask.define_task(*args, &block)
+    end
+
+    # Declare a set of files tasks to create the given directories on
+    # demand.
+    #
+    # Example:
+    #   directory "testdata/doc"
+    #
+    def directory(*args, &block) # :doc:
+      result = file_create(*args, &block)
+      dir, _ = *Rake.application.resolve_args(args)
+      dir = Rake.from_pathname(dir)
+      Rake.each_dir_parent(dir) do |d|
+        file_create d do |t|
+          mkdir_p t.name unless File.exist?(t.name)
+        end
+      end
+      result
+    end
+
+    # Declare a task that performs its prerequisites in
+    # parallel. Multitasks does *not* guarantee that its prerequisites
+    # will execute in any given order (which is obvious when you think
+    # about it)
+    #
+    # Example:
+    #   multitask deploy: %w[deploy_gem deploy_rdoc]
+    #
+    def multitask(*args, &block) # :doc:
+      Rake::MultiTask.define_task(*args, &block)
+    end
+
+    # Create a new rake namespace and use it for evaluating the given
+    # block.  Returns a NameSpace object that can be used to lookup
+    # tasks defined in the namespace.
+    #
+    # Example:
+    #
+    #   ns = namespace "nested" do
+    #     # the "nested:run" task
+    #     task :run
+    #   end
+    #   task_run = ns[:run] # find :run in the given namespace.
+    #
+    # Tasks can also be defined in a namespace by using a ":" in the task
+    # name:
+    #
+    #   task "nested:test" do
+    #     # ...
+    #   end
+    #
+    def namespace(name=nil, &block) # :doc:
+      name = name.to_s if name.kind_of?(Symbol)
+      name = name.to_str if name.respond_to?(:to_str)
+      unless name.kind_of?(String) || name.nil?
+        raise ArgumentError, "Expected a String or Symbol for a namespace name"
+      end
+      Rake.application.in_namespace(name, &block)
+    end
+
+    # Declare a rule for auto-tasks.
+    #
+    # Example:
+    #  rule '.o' => '.c' do |t|
+    #    sh 'cc', '-o', t.name, t.source
+    #  end
+    #
+    def rule(*args, &block) # :doc:
+      Rake::Task.create_rule(*args, &block)
+    end
+
+    # Describes the next rake task.  Duplicate descriptions are discarded.
+    # Descriptions are shown with <code>rake -T</code> (up to the first
+    # sentence) and <code>rake -D</code> (the entire description).
+    #
+    # Example:
+    #   desc "Run the Unit Tests"
+    #   task test: [:build]
+    #     # ... run tests
+    #   end
+    #
+    def desc(description) # :doc:
+      Rake.application.last_description = description
+    end
+
+    # Import the partial Rakefiles +fn+.  Imported files are loaded
+    # _after_ the current file is completely loaded.  This allows the
+    # import statement to appear anywhere in the importing file, and yet
+    # allowing the imported files to depend on objects defined in the
+    # importing file.
+    #
+    # A common use of the import statement is to include files
+    # containing dependency declarations.
+    #
+    # See also the --rakelibdir command line option.
+    #
+    # Example:
+    #   import ".depend", "my_rules"
+    #
+    def import(*fns) # :doc:
+      fns.each do |fn|
+        Rake.application.add_import(fn)
+      end
+    end
+  end
+  extend FileUtilsExt
+end
+
+# Extend the main object with the DSL commands. This allows top-level
+# calls to task, etc. to work from a Rakefile without polluting the
+# object inheritance tree.
+self.extend Rake::DSL

data/spec/sample_bundler/vendor/bundle/jruby/2.3.0/gems/rake-10.5.0/lib/rake/early_time.rb

@@ -0,0 +1,21 @@
+module Rake
+
+  # EarlyTime is a fake timestamp that occurs _before_ any other time value.
+  class EarlyTime
+    include Comparable
+    include Singleton
+
+    ##
+    # The EarlyTime always comes before +other+!
+
+    def <=>(other)
+      -1
+    end
+
+    def to_s # :nodoc:
+      "<EARLY TIME>"
+    end
+  end
+
+  EARLY = EarlyTime.instance
+end

data/spec/sample_bundler/vendor/bundle/jruby/2.3.0/gems/rake-10.5.0/lib/rake/ext/core.rb

@@ -0,0 +1,25 @@
+class Module
+  # Check for an existing method in the current class before extending.  If
+  # the method already exists, then a warning is printed and the extension is
+  # not added.  Otherwise the block is yielded and any definitions in the
+  # block will take effect.
+  #
+  # Usage:
+  #
+  #   class String
+  #     rake_extension("xyz") do
+  #       def xyz
+  #         ...
+  #       end
+  #     end
+  #   end
+  #
+  def rake_extension(method) # :nodoc:
+    if method_defined?(method)
+      $stderr.puts "WARNING: Possible conflict with Rake extension: " +
+        "#{self}##{method} already exists"
+    else
+      yield
+    end
+  end
+end

data/spec/sample_bundler/vendor/bundle/jruby/2.3.0/gems/rake-10.5.0/lib/rake/ext/module.rb

@@ -0,0 +1,2 @@
+
+# TODO: remove in Rake 11

data/spec/sample_bundler/vendor/bundle/jruby/2.3.0/gems/rake-10.5.0/lib/rake/ext/pathname.rb

@@ -0,0 +1,25 @@
+require 'rake/ext/core'
+require 'pathname'
+
+class Pathname
+
+  rake_extension("ext") do
+    # Return a new Pathname with <tt>String#ext</tt> applied to it.
+    #
+    # This Pathname extension comes from Rake
+    def ext(newext='')
+      Pathname.new(Rake.from_pathname(self).ext(newext))
+    end
+  end
+
+  rake_extension("pathmap") do
+    # Apply the pathmap spec to the Pathname, returning a
+    # new Pathname with the modified paths.  (See String#pathmap for
+    # details.)
+    #
+    # This Pathname extension comes from Rake
+    def pathmap(spec=nil, &block)
+      Pathname.new(Rake.from_pathname(self).pathmap(spec, &block))
+    end
+  end
+end

data/spec/sample_bundler/vendor/bundle/jruby/2.3.0/gems/rake-10.5.0/lib/rake/ext/string.rb

@@ -0,0 +1,175 @@
+require 'rake/ext/core'
+
+class String
+
+  rake_extension("ext") do
+    # Replace the file extension with +newext+.  If there is no extension on
+    # the string, append the new extension to the end.  If the new extension
+    # is not given, or is the empty string, remove any existing extension.
+    #
+    # +ext+ is a user added method for the String class.
+    #
+    # This String extension comes from Rake
+    def ext(newext='')
+      return self.dup if ['.', '..'].include? self
+      if newext != ''
+        newext = "." + newext unless newext =~ /^\./
+      end
+      self.chomp(File.extname(self)) << newext
+    end
+  end
+
+  rake_extension("pathmap") do
+    # Explode a path into individual components.  Used by +pathmap+.
+    #
+    # This String extension comes from Rake
+    def pathmap_explode
+      head, tail = File.split(self)
+      return [self] if head == self
+      return [tail] if head == '.' || tail == '/'
+      return [head, tail] if head == '/'
+      return head.pathmap_explode + [tail]
+    end
+    protected :pathmap_explode
+
+    # Extract a partial path from the path.  Include +n+ directories from the
+    # front end (left hand side) if +n+ is positive.  Include |+n+|
+    # directories from the back end (right hand side) if +n+ is negative.
+    #
+    # This String extension comes from Rake
+    def pathmap_partial(n)
+      dirs = File.dirname(self).pathmap_explode
+      partial_dirs =
+        if n > 0
+          dirs[0...n]
+        elsif n < 0
+          dirs.reverse[0...-n].reverse
+        else
+          "."
+        end
+      File.join(partial_dirs)
+    end
+    protected :pathmap_partial
+
+    # Perform the pathmap replacement operations on the given path. The
+    # patterns take the form 'pat1,rep1;pat2,rep2...'.
+    #
+    # This String extension comes from Rake
+    def pathmap_replace(patterns, &block)
+      result = self
+      patterns.split(';').each do |pair|
+        pattern, replacement = pair.split(',')
+        pattern = Regexp.new(pattern)
+        if replacement == '*' && block_given?
+          result = result.sub(pattern, &block)
+        elsif replacement
+          result = result.sub(pattern, replacement)
+        else
+          result = result.sub(pattern, '')
+        end
+      end
+      result
+    end
+    protected :pathmap_replace
+
+    # Map the path according to the given specification.  The specification
+    # controls the details of the mapping.  The following special patterns are
+    # recognized:
+    #
+    # <tt>%p</tt> :: The complete path.
+    # <tt>%f</tt> :: The base file name of the path, with its file extension,
+    #                but without any directories.
+    # <tt>%n</tt> :: The file name of the path without its file extension.
+    # <tt>%d</tt> :: The directory list of the path.
+    # <tt>%x</tt> :: The file extension of the path.  An empty string if there
+    #                is no extension.
+    # <tt>%X</tt> :: Everything *but* the file extension.
+    # <tt>%s</tt> :: The alternate file separator if defined, otherwise use #
+    #                the standard file separator.
+    # <tt>%%</tt> :: A percent sign.
+    #
+    # The <tt>%d</tt> specifier can also have a numeric prefix (e.g. '%2d').
+    # If the number is positive, only return (up to) +n+ directories in the
+    # path, starting from the left hand side.  If +n+ is negative, return (up
+    # to) +n+ directories from the right hand side of the path.
+    #
+    # Examples:
+    #
+    #   'a/b/c/d/file.txt'.pathmap("%2d")   => 'a/b'
+    #   'a/b/c/d/file.txt'.pathmap("%-2d")  => 'c/d'
+    #
+    # Also the <tt>%d</tt>, <tt>%p</tt>, <tt>%f</tt>, <tt>%n</tt>,
+    # <tt>%x</tt>, and <tt>%X</tt> operators can take a pattern/replacement
+    # argument to perform simple string substitutions on a particular part of
+    # the path.  The pattern and replacement are separated by a comma and are
+    # enclosed by curly braces.  The replacement spec comes after the %
+    # character but before the operator letter.  (e.g. "%{old,new}d").
+    # Multiple replacement specs should be separated by semi-colons (e.g.
+    # "%{old,new;src,bin}d").
+    #
+    # Regular expressions may be used for the pattern, and back refs may be
+    # used in the replacement text.  Curly braces, commas and semi-colons are
+    # excluded from both the pattern and replacement text (let's keep parsing
+    # reasonable).
+    #
+    # For example:
+    #
+    #    "src/org/onestepback/proj/A.java".pathmap("%{^src,class}X.class")
+    #
+    # returns:
+    #
+    #    "class/org/onestepback/proj/A.class"
+    #
+    # If the replacement text is '*', then a block may be provided to perform
+    # some arbitrary calculation for the replacement.
+    #
+    # For example:
+    #
+    #   "/path/to/file.TXT".pathmap("%X%{.*,*}x") { |ext|
+    #      ext.downcase
+    #   }
+    #
+    # Returns:
+    #
+    #  "/path/to/file.txt"
+    #
+    # This String extension comes from Rake
+    def pathmap(spec=nil, &block)
+      return self if spec.nil?
+      result = ''
+      spec.scan(/%\{[^}]*\}-?\d*[sdpfnxX%]|%-?\d+d|%.|[^%]+/) do |frag|
+        case frag
+        when '%f'
+          result << File.basename(self)
+        when '%n'
+          result << File.basename(self).ext
+        when '%d'
+          result << File.dirname(self)
+        when '%x'
+          result << File.extname(self)
+        when '%X'
+          result << self.ext
+        when '%p'
+          result << self
+        when '%s'
+          result << (File::ALT_SEPARATOR || File::SEPARATOR)
+        when '%-'
+          # do nothing
+        when '%%'
+          result << "%"
+        when /%(-?\d+)d/
+          result << pathmap_partial($1.to_i)
+        when /^%\{([^}]*)\}(\d*[dpfnxX])/
+          patterns, operator = $1, $2
+          result << pathmap('%' + operator).pathmap_replace(patterns, &block)
+        when /^%/
+          fail ArgumentError, "Unknown pathmap specifier #{frag} in '#{spec}'"
+        else
+          result << frag
+        end
+      end
+      result
+    end
+  end
+
+end