windows-pr 1.2.4 → 1.2.5

data/vendor/bundle/ruby/2.2.0/gems/rake-11.2.2/lib/rake/backtrace.rb

@@ -0,0 +1,23 @@
+module Rake
+  module Backtrace # :nodoc: all
+    SYS_KEYS  = RbConfig::CONFIG.keys.grep(/(?:[a-z]prefix|libdir)\z/)
+    SYS_PATHS = RbConfig::CONFIG.values_at(*SYS_KEYS).uniq +
+      [ File.join(File.dirname(__FILE__), "..") ]
+
+    SUPPRESSED_PATHS = SYS_PATHS.
+      map { |s| s.gsub("\\", "/") }.
+      map { |f| File.expand_path(f) }.
+      reject { |s| s.nil? || s =~ /^ *$/ }
+    SUPPRESSED_PATHS_RE = SUPPRESSED_PATHS.map { |f| Regexp.quote(f) }.join("|")
+    SUPPRESSED_PATHS_RE << "|^org\\/jruby\\/\\w+\\.java" if
+      Object.const_defined?(:RUBY_ENGINE) and RUBY_ENGINE == 'jruby'
+
+    SUPPRESS_PATTERN = %r!(\A(#{SUPPRESSED_PATHS_RE})|bin/rake:\d+)!i
+
+    def self.collapse(backtrace)
+      pattern = Rake.application.options.suppress_backtrace_pattern ||
+                SUPPRESS_PATTERN
+      backtrace.reject { |elem| elem =~ pattern }
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/rake-11.2.2/lib/rake/clean.rb

@@ -0,0 +1,76 @@
+# The 'rake/clean' file defines two file lists (CLEAN and CLOBBER) and
+# two rake tasks (:clean and :clobber).
+#
+# [:clean] Clean up the project by deleting scratch files and backup
+#          files.  Add files to the CLEAN file list to have the :clean
+#          target handle them.
+#
+# [:clobber] Clobber all generated and non-source files in a project.
+#            The task depends on :clean, so all the clean files will
+#            be deleted as well as files in the CLOBBER file list.
+#            The intent of this task is to return a project to its
+#            pristine, just unpacked state.
+
+require 'rake'
+
+# :stopdoc:
+
+module Rake
+  module Cleaner
+    extend FileUtils
+
+    module_function
+
+    def cleanup_files(file_names)
+      file_names.each do |file_name|
+        cleanup(file_name)
+      end
+    end
+
+    def cleanup(file_name, opts={})
+      begin
+        rm_r file_name, opts
+      rescue StandardError => ex
+        puts "Failed to remove #{file_name}: #{ex}" unless file_already_gone?(file_name)
+      end
+    end
+
+    def file_already_gone?(file_name)
+      return false if File.exist?(file_name)
+
+      path = file_name
+      prev = nil
+
+      while path = File.dirname(path)
+        return false if cant_be_deleted?(path)
+        break if [prev, "."].include?(path)
+        prev = path
+      end
+      true
+    end
+    private_class_method :file_already_gone?
+
+    def cant_be_deleted?(path_name)
+      File.exist?(path_name) &&
+        (!File.readable?(path_name) || !File.executable?(path_name))
+    end
+    private_class_method :cant_be_deleted?
+  end
+end
+
+CLEAN = ::Rake::FileList["**/*~", "**/*.bak", "**/core"]
+CLEAN.clear_exclude.exclude { |fn|
+  fn.pathmap("%f").downcase == 'core' && File.directory?(fn)
+}
+
+desc "Remove any temporary products."
+task :clean do
+  Rake::Cleaner.cleanup_files(CLEAN)
+end
+
+CLOBBER = ::Rake::FileList.new
+
+desc "Remove any generated files."
+task :clobber => [:clean] do
+  Rake::Cleaner.cleanup_files(CLOBBER)
+end

data/vendor/bundle/ruby/2.2.0/gems/rake-11.2.2/lib/rake/cloneable.rb

@@ -0,0 +1,16 @@
+module Rake
+  ##
+  # Mixin for creating easily cloned objects.
+
+  module Cloneable # :nodoc:
+    # The hook that is invoked by 'clone' and 'dup' methods.
+    def initialize_copy(source)
+      super
+      source.instance_variables.each do |var|
+        src_value  = source.instance_variable_get(var)
+        value = src_value.clone rescue src_value
+        instance_variable_set(var, value)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/rake-11.2.2/lib/rake/contrib/compositepublisher.rb

@@ -0,0 +1,21 @@
+module Rake
+
+  # Manage several publishers as a single entity.
+  class CompositePublisher
+    def initialize
+      @publishers = []
+    end
+
+    # Add a publisher to the composite.
+    def add(pub)
+      @publishers << pub
+    end
+
+    # Upload all the individual publishers.
+    def upload
+      @publishers.each { |p| p.upload }
+    end
+  end
+
+end
+

data/vendor/bundle/ruby/2.2.0/gems/rake-11.2.2/lib/rake/contrib/ftptools.rb

@@ -0,0 +1,137 @@
+# = Tools for FTP uploading.
+#
+# This file is still under development and is not released for general
+# use.
+
+require 'date'
+require 'net/ftp'
+require 'rake/file_list'
+
+module Rake # :nodoc:
+
+  class FtpFile # :nodoc: all
+    attr_reader :name, :size, :owner, :group, :time
+
+    def self.date
+      @date_class ||= Date
+    end
+
+    def self.time
+      @time_class ||= Time
+    end
+
+    def initialize(path, entry)
+      @path = path
+      @mode, _, @owner, @group, size, d1, d2, d3, @name = entry.split(' ')
+      @size = size.to_i
+      @time = determine_time(d1, d2, d3)
+    end
+
+    def path
+      File.join(@path, @name)
+    end
+
+    def directory?
+      @mode[0] == ?d
+    end
+
+    def mode
+      parse_mode(@mode)
+    end
+
+    def symlink?
+      @mode[0] == ?l
+    end
+
+    private # --------------------------------------------------------
+
+    def parse_mode(m)
+      result = 0
+      (1..9).each do |i|
+        result = 2 * result + ((m[i] == ?-) ? 0 : 1)
+      end
+      result
+    end
+
+    def determine_time(d1, d2, d3)
+      now = self.class.time.now
+      if /:/ !~ d3
+        result = Time.parse("#{d1} #{d2} #{d3}")
+      else
+        result = Time.parse("#{d1} #{d2} #{now.year} #{d3}")
+        result = Time.parse("#{d1} #{d2} #{now.year - 1} #{d3}") if
+          result > now
+      end
+      result
+    end
+  end
+
+  ##
+  # Manage the uploading of files to an FTP account.
+  class FtpUploader # :nodoc:
+
+    # Log uploads to standard output when true.
+    attr_accessor :verbose
+
+    class << FtpUploader
+      # Create an uploader and pass it to the given block as +up+.
+      # When the block is complete, close the uploader.
+      def connect(path, host, account, password)
+        up = self.new(path, host, account, password)
+        begin
+          yield(up)
+        ensure
+          up.close
+        end
+      end
+    end
+
+    # Create an FTP uploader targeting the directory +path+ on +host+
+    # using the given account and password.  +path+ will be the root
+    # path of the uploader.
+    def initialize(path, host, account, password)
+      @created = Hash.new
+      @path = path
+      @ftp = Net::FTP.new(host, account, password)
+      makedirs(@path)
+      @ftp.chdir(@path)
+    end
+
+    # Create the directory +path+ in the uploader root path.
+    def makedirs(path)
+      route = []
+      File.split(path).each do |dir|
+        route << dir
+        current_dir = File.join(route)
+        if @created[current_dir].nil?
+          @created[current_dir] = true
+          $stderr.puts "Creating Directory  #{current_dir}" if @verbose
+          @ftp.mkdir(current_dir) rescue nil
+        end
+      end
+    end
+
+    # Upload all files matching +wildcard+ to the uploader's root
+    # path.
+    def upload_files(wildcard)
+      FileList.glob(wildcard).each do |fn|
+        upload(fn)
+      end
+    end
+
+    # Close the uploader.
+    def close
+      @ftp.close
+    end
+
+    private # --------------------------------------------------------
+
+    # Upload a single file to the uploader's root path.
+    def upload(file)
+      $stderr.puts "Uploading #{file}" if @verbose
+      dir = File.dirname(file)
+      makedirs(dir)
+      @ftp.putbinaryfile(file, file) unless File.directory?(file)
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/rake-11.2.2/lib/rake/contrib/sshpublisher.rb

@@ -0,0 +1,60 @@
+require 'rake/dsl_definition'
+require 'rake/contrib/compositepublisher'
+
+module Rake
+  # Publish an entire directory to an existing remote directory using
+  # SSH.
+  class SshDirPublisher
+    include Rake::DSL
+
+    # Creates an SSH publisher which will scp all files in +local_dir+ to
+    # +remote_dir+ on +host+
+
+    def initialize(host, remote_dir, local_dir)
+      @host = host
+      @remote_dir = remote_dir
+      @local_dir = local_dir
+    end
+
+    # Uploads the files
+
+    def upload
+      sh "scp", "-rq", "#{@local_dir}/*", "#{@host}:#{@remote_dir}"
+    end
+  end
+
+  # Publish an entire directory to a fresh remote directory using SSH.
+  class SshFreshDirPublisher < SshDirPublisher
+
+    # Uploads the files after removing the existing remote directory.
+
+    def upload
+      sh "ssh", @host, "rm", "-rf", @remote_dir rescue nil
+      sh "ssh", @host, "mkdir",     @remote_dir
+      super
+    end
+  end
+
+  # Publish a list of files to an existing remote directory.
+  class SshFilePublisher
+    include Rake::DSL
+
+    # Creates an SSH publisher which will scp all +files+ in +local_dir+ to
+    # +remote_dir+ on +host+.
+
+    def initialize(host, remote_dir, local_dir, *files)
+      @host = host
+      @remote_dir = remote_dir
+      @local_dir = local_dir
+      @files = files
+    end
+
+    # Uploads the files
+
+    def upload
+      @files.each do |fn|
+        sh "scp", "-q", "#{@local_dir}/#{fn}", "#{@host}:#{@remote_dir}"
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/rake-11.2.2/lib/rake/cpu_counter.rb

@@ -0,0 +1,106 @@
+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'
+
+    def count
+      if defined?(Java::Java)
+        count_via_java_runtime
+      else
+        case RbConfig::CONFIG['host_os']
+        when /linux/
+          count_via_cpuinfo
+        when /darwin|bsd/
+          count_via_sysctl
+        when /mswin|mingw/
+          count_via_win32
+        else
+          # Try everything
+          count_via_win32 ||
+          count_via_sysctl ||
+          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_sysctl
+      run 'sysctl', '-n', 'hw.ncpu'
+    end
+
+    def run(command, *args)
+      cmd = resolve_command(command)
+      if cmd
+        IO.popen [cmd, *args] do |io|
+          io.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)
+      IO.popen ['which', command] do |io|
+        io.eof? ? nil : command
+      end
+    end
+  end;
+end