backports 3.0.3 → 3.1.0

data/lib/backports/1.9.2/random.rb

@@ -1 +1 @@
-autoload :Random, File.expand_path(File.dirname(__FILE__) + "/random/load")
+autoload :Random, "backports/extra/random/load"

data/lib/backports/1.9.2/stdlib.rb

@@ -1 +1 @@
-Backports::StdLib.extend_relative
+Backports::StdLib.extend_relative

data/lib/backports/1.9.2/stdlib/matrix.rb

@@ -14,7 +14,6 @@
 require "e2mmap.rb"
 
 module ExceptionForMatrix # :nodoc:
-  extend Exception2MessageMapper
   def_e2message(TypeError, "wrong argument type %s (expected %s)")
   def_e2message(ArgumentError, "Wrong # of arguments(%d for %d)")
 
@@ -118,6 +117,7 @@ end
 # * #to_s
 # * #inspect
 #
+Backports.suppress_verbose_warnings do
 class Matrix
   include Enumerable
   include ExceptionForMatrix
@@ -186,7 +186,7 @@ class Matrix
     row_size = CoercionHelper.coerce_to_int(row_size)
     column_size = CoercionHelper.coerce_to_int(column_size)
     raise ArgumentError if row_size < 0 || column_size < 0
-    return to_enum :build, row_size, column_size unless block_given?
+    return to_enum(:build, row_size, column_size) unless block_given?
     rows = Array.new(row_size) do |i|
       Array.new(column_size) do |j|
         yield i, j
@@ -401,7 +401,7 @@ class Matrix
   #   Matrix[ [1,2], [3,4] ].each(:strict_lower).to_a # => [3]
   #
   def each(which = :all) # :yield: e
-    return to_enum :each, which unless block_given?
+    return to_enum(:each, which) unless block_given?
     last = column_size - 1
     case which
     when :all
@@ -462,7 +462,7 @@ class Matrix
   #     #    4 at 1, 1
   #
   def each_with_index(which = :all) # :yield: e, row, column
-    return to_enum :each_with_index, which unless block_given?
+    return to_enum(:each_with_index, which) unless block_given?
     last = column_size - 1
     case which
     when :all
@@ -527,7 +527,7 @@ class Matrix
   def index(*args)
     raise ArgumentError, "wrong number of arguments(#{args.size} for 0-2)" if args.size > 2
     which = (args.size == 2 || SELECTORS.include?(args.last)) ? args.pop : :all
-    return to_enum :find_index, which, *args unless block_given? || args.size == 1
+    return to_enum(:find_index, which, *args) unless block_given? || args.size == 1
     if args.size == 1
       value = args.first
       each_with_index(which) do |e, row_index, col_index|
@@ -809,7 +809,7 @@ class Matrix
       rows = @rows.collect {|row|
         row.collect {|e| e * m }
       }
-      return new_matrix rows, column_size
+      return new_matrix(rows, column_size)
     when Vector
       m = self.class.column_vector(m)
       r = self * m
@@ -824,7 +824,7 @@ class Matrix
           end
         }
       }
-      return new_matrix rows, m.column_size
+      return new_matrix(rows, m.column_size)
     else
       return apply_through_coercion(m, __method__)
     end
@@ -896,7 +896,7 @@ class Matrix
       rows = @rows.collect {|row|
         row.collect {|e| e / other }
       }
-      return new_matrix rows, column_size
+      return new_matrix(rows, column_size)
     when Matrix
       return self * other.inverse
     else
@@ -1868,3 +1868,4 @@ class Vector
     "Vector" + @elements.inspect
   end
 end
+end

data/lib/backports/1.9.2/stdlib/set.rb

@@ -10,4 +10,4 @@ class Set
     to_a.each { |o| @hash.delete(o) unless yield(o) }
     self
   end unless method_defined? :keep_if
-end
+end

data/lib/backports/1.9.3.rb

@@ -1,5 +1,3 @@
 # require this file to load all the backports up to Ruby 1.9.3
-
-require File.expand_path(File.dirname(__FILE__) + "/tools")
-Backports.require_relative "1.9.2"
-Backports.require_relative_dir "1.9.3"
+require 'backports/1.9.2'
+Backports.require_relative_dir

data/lib/backports/1.9.3/file.rb

@@ -1,14 +1,3 @@
-module File::Constants
-  platform = RUBY_PLATFORM
-  platform = RbConfig::CONFIG['host_os'] if platform == 'java'
-  NULL =  case platform
-          when /mswin|mingw/i
-            'NUL'
-          when /amiga/i
-            'NIL:'
-          when /openvms/i
-            'NL:'
-          else
-            '/dev/null'
-          end unless const_defined?(:NULL)
-end
+require 'backports/tools'
+
+Backports.require_relative_dir

data/lib/backports/1.9.3/file/null.rb

@@ -0,0 +1,16 @@
+unless File.const_defined? :NULL
+  module File::Constants
+    platform = RUBY_PLATFORM
+    platform = RbConfig::CONFIG['host_os'] if platform == 'java'
+    NULL =  case platform
+            when /mswin|mingw/i
+              'NUL'
+            when /amiga/i
+              'NIL:'
+            when /openvms/i
+              'NL:'
+            else
+              '/dev/null'
+            end
+  end
+end

data/lib/backports/1.9.3/io.rb

@@ -1,32 +1,3 @@
-class IO
-  # Standard in Ruby 1.9.3 See official documentation[http://ruby-doc.org/core-1.9.3/IO.html#method-i-advise]
-  # We're only for a platform not implementing advise, so we return nil.
-  def advise(advice, offset=0, len=0)
-    case advice
-    when  :normal,
-          :sequential,
-          :random,
-          :willneed,
-          :dontneed,
-          :noreuse
-      return nil
-    when Symbol
-      raise NotImplementedError, "Unsupported advice #{advice}"
-    else
-      raise TypeError, "advice must be a Symbol"
-    end
-  end unless method_defined? :advise
-end
-  
-class << IO
-  # Standard in Ruby 1.9.3 See official documentation[http://ruby-doc.org/core-1.9.3/IO.html#method-c-write]
-  def write(name, string, offset = nil, options = Backports::Undefined)
-    Backports.write(false, name, string, offset, options)
-  end unless method_defined? :write
+require 'backports/tools'
 
-  # Standard in Ruby 1.9.3 See official documentation[http://ruby-doc.org/core-1.9.3/IO.html#method-c-binwrite]
-  # This method does support an options hash, see http://bugs.ruby-lang.org/issues/5782
-  def binwrite(name, string, offset = nil, options = Backports::Undefined)
-    Backports.write(true, name, string, offset, options)
-  end unless method_defined? :binwrite
-end
+Backports.require_relative_dir

data/lib/backports/1.9.3/io/advise.rb

@@ -0,0 +1,24 @@
+unless IO.method_defined? :advise
+  require 'backports/tools'
+
+  class IO
+    def advise(advice, offset=0, len=0)
+      raise RangeError if Backports.coerce_to_int(offset) >= 1<<31
+      raise RangeError if Backports.coerce_to_int(len) >= 1<<31
+      raise IOError if closed?
+      case advice
+      when  :normal,
+            :sequential,
+            :random,
+            :willneed,
+            :dontneed,
+            :noreuse
+        return nil
+      when Symbol
+        raise NotImplementedError, "Unsupported advice #{advice}"
+      else
+        raise TypeError, "advice must be a Symbol"
+      end
+    end
+  end
+end

data/lib/backports/1.9.3/io/binwrite.rb

@@ -0,0 +1,7 @@
+unless IO.respond_to? :binwrite
+  require 'backports/tools'
+
+  def IO.binwrite(name, string, offset = nil, options = Backports::Undefined)
+    Backports.write(true, name, string, offset, options)
+  end
+end

data/lib/backports/1.9.3/io/write.rb

@@ -0,0 +1,7 @@
+unless IO.respond_to? :write
+  require 'backports/tools'
+
+  def IO.write(name, string, offset = nil, options = Backports::Undefined)
+    Backports.write(false, name, string, offset, options)
+  end
+end

data/lib/backports/1.9.3/string.rb

@@ -1,39 +1,3 @@
-class String
-  # Standard in Ruby 1.9.3 See official documentation[http://ruby-doc.org/core-1.9.3/String.html#byteslice]
-  def byteslice(start, len = Backports::Undefined)
-    # Argument parsing & checking
-    if Backports::Undefined == len
-      if start.is_a?(Range)
-        range = start
-        start = Backports.coerce_to_int(range.begin)
-        start += bytesize if start < 0
-        last = Backports.coerce_to_int(range.end)
-        last += bytesize if last < 0
-        last += 1 unless range.exclude_end?
-        len = last - start
-      else
-        start = Backports.coerce_to_int(start)
-        start += bytesize if start < 0
-        len = 1
-        return if start >= bytesize
-      end
-    else
-      start = Backports.coerce_to_int(start)
-      start += bytesize if start < 0
-      len = Backports.coerce_to_int(len)
-      return if len < 0
-    end
-    return if start < 0 || start > bytesize
-    len = 0 if len < 0
-    # Actual implementation:
-    str = unpack("@#{start}a#{len}").first
-    str = dup.replace(str) unless self.instance_of?(String) # Must return subclass
-    str.force_encoding(encoding)
-  end unless method_defined? :byteslice
+require 'backports/tools'
 
-  # Standard in Ruby 1.9.3 See official documentation[http://ruby-doc.org/core-1.9.3/String.html#method-i-prepend]
-  def prepend(other_str)
-    replace Backports.coerce_to_str(other_str) + self
-    self
-  end unless method_defined? :prepend
-end
+Backports.require_relative_dir

data/lib/backports/1.9.3/string/byteslice.rb

@@ -0,0 +1,36 @@
+unless String.method_defined? :byteslice
+  require 'backports/tools'
+
+  class String
+    def byteslice(start, len = Backports::Undefined)
+      # Argument parsing & checking
+      if Backports::Undefined == len
+        if start.is_a?(Range)
+          range = start
+          start = Backports.coerce_to_int(range.begin)
+          start += bytesize if start < 0
+          last = Backports.coerce_to_int(range.end)
+          last += bytesize if last < 0
+          last += 1 unless range.exclude_end?
+          len = last - start
+        else
+          start = Backports.coerce_to_int(start)
+          start += bytesize if start < 0
+          len = 1
+          return if start >= bytesize
+        end
+      else
+        start = Backports.coerce_to_int(start)
+        start += bytesize if start < 0
+        len = Backports.coerce_to_int(len)
+        return if len < 0
+      end
+      return if start < 0 || start > bytesize
+      len = 0 if len < 0
+      # Actual implementation:
+      str = unpack("@#{start}a#{len}").first
+      str = dup.replace(str) unless self.instance_of?(String) # Must return subclass
+      str.force_encoding(encoding)
+    end
+  end
+end

data/lib/backports/1.9.3/string/prepend.rb

@@ -0,0 +1,10 @@
+unless String.method_defined? :prepend
+  require 'backports/tools'
+
+  class String
+    def prepend(other_str)
+      replace Backports.coerce_to_str(other_str) + self
+      self
+    end
+  end
+end

data/lib/backports/1.9.rb

@@ -1,4 +1,2 @@
 # require this file to load all the backports of Ruby 1.9.x
-
-require File.expand_path(File.dirname(__FILE__) + "/tools")
-Backports.require_relative "1.9.3"
+require 'backports/1.9.3'

data/lib/backports/2.0.0.rb

@@ -1,5 +1,3 @@
 # require this file to load all the backports up to Ruby 2.0.0
-
-require File.expand_path(File.dirname(__FILE__) + "/tools")
-Backports.require_relative "1.9"
-Backports.require_relative_dir "2.0.0"
+require 'backports/1.9'
+Backports.require_relative_dir

data/lib/backports/2.0.0/array.rb

@@ -1,30 +1,3 @@
-class Array
-  def bsearch
-    return to_enum(__method__) unless block_given?
-    from = 0
-    to   = size - 1
-    satisfied = nil
-    while from <= to do
-      midpoint = (from + to).div(2)
-      result = yield(cur = self[midpoint])
-      case result
-      when Numeric
-        return cur if result == 0
-        result = result < 0
-      when true
-        satisfied = cur
-      when nil, false
-        # nothing to do
-      else
-        raise TypeError, "wrong argument type #{result.class} (must be numeric, true, false or nil)"
-      end
+require 'backports/tools'
 
-      if result
-        to = midpoint - 1
-      else
-        from = midpoint + 1
-      end
-    end
-    satisfied
-  end unless method_defined? :bsearch
-end
+Backports.require_relative_dir

data/lib/backports/2.0.0/array/bsearch.rb

@@ -0,0 +1,32 @@
+unless Array.method_defined? :bsearch
+  class Array
+    def bsearch
+      return to_enum(__method__) unless block_given?
+      from = 0
+      to   = size - 1
+      satisfied = nil
+      while from <= to do
+        midpoint = (from + to).div(2)
+        result = yield(cur = self[midpoint])
+        case result
+        when Numeric
+          return cur if result == 0
+          result = result < 0
+        when true
+          satisfied = cur
+        when nil, false
+          # nothing to do
+        else
+          raise TypeError, "wrong argument type #{result.class} (must be numeric, true, false or nil)"
+        end
+
+        if result
+          to = midpoint - 1
+        else
+          from = midpoint + 1
+        end
+      end
+      satisfied
+    end
+  end
+end

data/lib/backports/2.0.0/enumerable.rb

@@ -1,12 +1,3 @@
-unless Enumerable.method_defined? :lazy
-  module Enumerable
-    def lazy
-      klass = Enumerator::Lazy.send :class_variable_get, :@@lazy_with_no_block # Note: class_variable_get is private in 1.8
-      Enumerator::Lazy.new(klass.new(self, :each, []))
-    end
-  end
+require 'backports/tools'
 
-  class Enumerator
-    require_relative 'enumerator/lazy'
-  end
-end
+Backports.require_relative_dir

data/lib/backports/2.0.0/enumerable/lazy.rb

@@ -0,0 +1,216 @@
+unless Enumerable.method_defined? :lazy
+  require 'backports/tools'
+  require 'backports/1.9.1/enumerator/new'
+
+  module Enumerable
+    def lazy
+      klass = Enumerator::Lazy.send :class_variable_get, :@@lazy_with_no_block # Note: class_variable_get is private in 1.8
+      Enumerator::Lazy.new(klass.new(self, :each, []))
+    end
+  end
+
+  class Enumerator
+    class Yielder
+      # Current API for Lazy Enumerator does not provide an easy way
+      # to handle internal state. We "cheat" and use yielder to hold it for us.
+      # A new yielder is created when generating or after a `rewind`.
+      # This way we avoid issues like http://bugs.ruby-lang.org/issues/7691
+      # or http://bugs.ruby-lang.org/issues/7696
+      attr_accessor :backports_memo
+    end
+
+    class Lazy < Enumerator
+      @@done = :__backports_lazy_enumeration_done__   # used internally to bail out of an iteration
+      @@lazy_with_no_block = Struct.new(:object, :method, :args) # used internally to create lazy without block
+
+      def initialize(obj)
+        if obj.is_a?(@@lazy_with_no_block)
+          @inspect_info = obj
+          return super(@receiver = obj.object, @method = obj.method || :each, * @args = obj.args)
+        end
+        raise ArgumentError, "must supply a block" unless block_given?
+        @receiver = obj
+        super() do |yielder, *args|
+          catch @@done do
+            obj.each(*args) do |*x|
+              yield yielder, *x
+            end
+          end
+        end
+      end
+
+      alias_method :force, :to_a
+
+      def lazy
+        self
+      end
+
+      def to_enum(method = :each, *args)
+        Lazy.new(@@lazy_with_no_block.new(self, method, args))
+      end
+      alias_method :enum_for, :to_enum
+
+      def inspect
+        suff = ''
+        suff << ":#{@method}" unless @method.nil? || @method == :each
+        suff << "(#{@args.inspect[1...-1]})" if @args && !@args.empty?
+        "#<#{self.class}: #{@receiver.inspect}#{suff}>"
+      end
+
+      {
+        :slice_before => //,
+        :with_index => [],
+        :cycle => [],
+        :each_with_object => 42,
+        :each_slice => 42,
+        :each_entry => [],
+        :each_cons => 42,
+      }.each do |method, args|
+        next unless Enumerator.method_defined? method
+        unless [].lazy.send(method, *args).is_a?(Lazy) # Nothing to do if already backported, since it would use to_enum...
+          module_eval <<-EOT, __FILE__, __LINE__ + 1
+            def #{method}(*args)                                     # def cycle(*args)
+              return to_enum(:#{method}, *args) unless block_given?  #   return to_enum(:cycle, *args) unless block_given?
+              super                                                  #   super
+            end                                                      # end
+          EOT
+        end
+      end
+
+      def chunk(*)
+        super.lazy
+      end if Enumerable.method_defined?(:chunk) && ![].lazy.chunk{}.is_a?(Lazy)
+
+      def map
+        raise ArgumentError, "tried to call lazy map without a block" unless block_given?
+        Lazy.new(self) do |yielder, *values|
+          yielder << yield(*values)
+        end.__set_inspect :map
+      end
+      alias_method :collect, :map
+
+      def select
+        raise ArgumentError, "tried to call lazy select without a block" unless block_given?
+        Lazy.new(self) do |yielder, *values|
+          values = values.first unless values.size > 1
+          yielder.yield values if yield values
+        end.__set_inspect :select
+      end
+      alias_method :find_all, :select
+
+      def reject
+        raise ArgumentError, "tried to call lazy reject without a block" unless block_given?
+        Lazy.new(self) do |yielder, *values|
+          values = values.first unless values.size > 1
+          yielder.yield(values) unless yield values
+        end.__set_inspect :reject
+      end
+
+      def grep(pattern)
+        if block_given?
+          # Split for performance
+          Lazy.new(self) do |yielder, *values|
+            values = values.first unless values.size > 1
+            yielder.yield(yield(values)) if pattern === values
+          end
+        else
+          Lazy.new(self) do |yielder, *values|
+            values = values.first unless values.size > 1
+            yielder.yield(values) if pattern === values
+          end
+        end.__set_inspect :grep, [pattern]
+      end
+
+      def drop(n)
+        n = Backports::coerce_to_int(n)
+        Lazy.new(self) do |yielder, *values|
+          data = yielder.backports_memo ||= {:remain => n}
+          if data[:remain] > 0
+            data[:remain] -= 1
+          else
+            yielder.yield(*values)
+          end
+        end.__set_inspect :drop, [n]
+      end
+
+      def drop_while
+        raise ArgumentError, "tried to call lazy drop_while without a block" unless block_given?
+        Lazy.new(self) do |yielder, *values|
+          data = yielder.backports_memo ||= {:dropping => true}
+          yielder.yield(*values) unless data[:dropping] &&= yield(*values)
+        end.__set_inspect :drop_while
+      end
+
+      def take(n)
+        n = Backports::coerce_to_int(n)
+        raise ArgumentError, 'attempt to take negative size' if n < 0
+        Lazy.new(n == 0 ? [] : self) do |yielder, *values|
+          data = yielder.backports_memo ||= {:remain => n}
+          yielder.yield(*values)
+          throw @@done if (data[:remain] -= 1) == 0
+        end.__set_inspect :take, [n], self
+      end
+
+      def take_while
+        raise ArgumentError, "tried to call lazy take_while without a block" unless block_given?
+        Lazy.new(self) do |yielder, *values|
+          throw @@done unless yield(*values)
+          yielder.yield(*values)
+        end.__set_inspect :take_while
+      end
+
+      def flat_map
+        raise ArgumentError, "tried to call lazy flat_map without a block" unless block_given?
+        Lazy.new(self) do |yielder, *values|
+          result = yield(*values)
+          ary = Backports.is_array?(result)
+          if ary || (result.respond_to?(:each) && result.respond_to?(:force))
+            (ary || result).each{|x| yielder << x }
+          else
+            yielder << result
+          end
+        end.__set_inspect :flat_map
+      end
+      alias_method :collect_concat, :flat_map
+
+      def zip(*args)
+        return super if block_given?
+        arys = args.map{ |arg| Backports.is_array?(arg) }
+        if arys.all?
+          # Handle trivial case of multiple array arguments separately
+          # by avoiding Enumerator#next for efficiency & compatibility
+          Lazy.new(self) do |yielder, *values|
+            data = yielder.backports_memo ||= {:iter => 0}
+            values = values.first unless values.size > 1
+            yielder << arys.map{|ary| ary[data[:iter]]}.unshift(values)
+            data[:iter] += 1
+          end
+        else
+          args.each do |a|
+            raise TypeError, "wrong argument type #{a.class} (must respond to :each)" unless a.respond_to? :each
+          end
+          Lazy.new(self) do |yielder, *values|
+            enums = yielder.backports_memo ||= args.map(&:to_enum)
+            values = values.first unless values.size > 1
+            others = enums.map do |arg|
+              begin
+                arg.next
+              rescue StopIteration
+                nil
+              end
+            end
+            yielder << others.unshift(values)
+          end
+        end.__set_inspect :zip, args
+      end
+
+      protected
+      def __set_inspect(method, args = nil, receiver = nil)
+        @method = method
+        @args = args
+        @receiver = receiver if receiver
+        self
+      end
+    end
+  end
+end