backports 3.0.3 → 3.1.0

data/lib/backports/2.0.0/enumerator.rb

@@ -0,0 +1,3 @@
+require 'backports/tools'
+
+Backports.require_relative_dir

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

@@ -1,203 +1 @@
-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
-      @method = caller[1][/`([^']*)'/, 1]
-      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 == :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|
-      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 unless [].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
-    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
-    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
-    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([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([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
-    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([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
-    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
-    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(args)
-    end
-
-    protected
-    def __set_inspect(args, receiver = nil)
-      @args = args
-      @receiver = receiver if receiver
-      self
-    end
-  end
-end
+require 'backports/2.0.0/enumerable/lazy'

data/lib/backports/2.0.0/env.rb

@@ -0,0 +1,3 @@
+require 'backports/tools'
+
+Backports.require_relative_dir

data/lib/backports/2.0.0/env/to_h.rb

@@ -0,0 +1,5 @@
+unless ENV.respond_to? :to_h
+  class << ENV
+    alias_method :to_h, :to_hash
+  end
+end

data/lib/backports/2.0.0/hash.rb

@@ -1,19 +1,3 @@
-class Hash
-  def to_h
-    self
-  end unless method_defined? :to_h
+require 'backports/tools'
 
-  if (({}.default_proc = nil) rescue true)
-    def default_proc_with_nil=(proc)
-      if proc == nil
-        self.default = nil
-        self
-      else
-        self.default_proc_without_nil=(proc)
-      end
-    end
-    Backports.alias_method_chain(self, :default_proc=, :nil)
-  end
-end
-
-Backports.alias_method(ENV.singleton_class, :to_h, :to_hash)
+Backports.require_relative_dir

data/lib/backports/2.0.0/hash/default_proc.rb

@@ -0,0 +1,16 @@
+if (({}.default_proc = nil) rescue true)
+  require 'backports/tools'
+  require 'backports/1.9.1/hash/default_proc'
+
+  class Hash
+    def default_proc_with_nil=(proc)
+      if proc == nil
+        self.default = nil
+        self
+      else
+        self.default_proc_without_nil=(proc)
+      end
+    end
+    Backports.alias_method_chain(self, :default_proc=, :nil)
+  end
+end

data/lib/backports/2.0.0/hash/to_h.rb

@@ -0,0 +1,7 @@
+unless Hash.method_defined? :to_h
+  class Hash
+    def to_h
+      self.class == Hash ? self : {}.replace(self)
+    end
+  end
+end

data/lib/backports/2.0.0/nil.rb

@@ -0,0 +1,3 @@
+require 'backports/tools'
+
+Backports.require_relative_dir

data/lib/backports/2.0.0/nil/to_h.rb

@@ -0,0 +1,7 @@
+unless NilClass.method_defined? :to_h
+  class NilClass
+    def to_h
+      {}
+    end
+  end
+end

data/lib/backports/2.0.0/range.rb

@@ -1,49 +1,3 @@
-class Range
-  def bsearch
-    return to_enum(__method__) unless block_given?
-    from = self.begin
-    to   = self.end
-    unless from.is_a?(Numeric) && to.is_a?(Numeric)
-      raise TypeError, "can't do binary search for #{from.class}"
-    end
+require 'backports/tools'
 
-    midpoint = nil
-    if from.is_a?(Integer) && to.is_a?(Integer)
-      convert = Proc.new{ midpoint }
-    else
-      map = Proc.new do |pk, unpk, nb|
-        result, = [nb.abs].pack(pk).unpack(unpk)
-        nb < 0 ? -result : result
-      end.curry
-      i2f = map['q', 'D']
-      f2i = map['D', 'q']
-      from = f2i[from.to_f]
-      to = f2i[to.to_f]
-      convert = Proc.new{ i2f[midpoint] }
-    end
-    to -= 1 if exclude_end?
-    satisfied = nil
-    while from <= to do
-      midpoint = (from + to).div(2)
-      result = yield(cur = convert.call)
-      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 unless method_defined? :bsearch
-end
+Backports.require_relative_dir

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

@@ -0,0 +1,49 @@
+unless Range.method_defined? :bsearch
+  class Range
+    def bsearch
+      return to_enum(:bsearch) unless block_given?
+      from = self.begin
+      to   = self.end
+      unless from.is_a?(Numeric) && to.is_a?(Numeric)
+        raise TypeError, "can't do binary search for #{from.class}"
+      end
+
+      midpoint = nil
+      if from.is_a?(Integer) && to.is_a?(Integer)
+        convert = Proc.new{ midpoint }
+      else
+        map = Proc.new do |pk, unpk, nb|
+          result, = [nb.abs].pack(pk).unpack(unpk)
+          nb < 0 ? -result : result
+        end
+        from = map['D', 'q', to.to_f]
+        to   = map['D', 'q', to.to_f]
+        convert = Proc.new{ map['q', 'D', midpoint] }
+      end
+      to -= 1 if exclude_end?
+      satisfied = nil
+      while from <= to do
+        midpoint = (from + to).div(2)
+        result = yield(cur = convert.call)
+        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/stdlib/abbrev.rb

@@ -0,0 +1 @@
+# For testing purposes only, see _backport_guards_test

data/lib/backports/2.0.0/stdlib/fake_stdlib_lib.rb

@@ -0,0 +1 @@
+# For testing purposes only, see _backport_guards_test

data/lib/backports/2.0.0/stdlib/ostruct.rb

@@ -17,7 +17,7 @@ class OpenStruct
   end unless method_defined? :hash
 
   def each_pair
-    return to_enum __method__ unless block_given?
+    return to_enum(:each_pair) unless block_given?
     @table.each_pair{|p| yield p}
   end unless method_defined? :each_pair
 

data/lib/backports/2.0.0/struct.rb

@@ -1,7 +1,3 @@
-class Struct
-	def to_h
-    Hash[
-      self.class.members.each{|m| [m.to_sym, self[m]]}
-    ]
-  end unless method_defined? :to_h
-end
+require 'backports/tools'
+
+Backports.require_relative_dir

data/lib/backports/2.0.0/struct/to_h.rb

@@ -0,0 +1,9 @@
+unless Struct.method_defined? :to_h
+  class Struct
+    def to_h
+      h = {}
+      self.class.members.each{|m| h[m.to_sym] = self[m]}
+      h
+    end
+  end
+end

data/lib/backports/2.0.rb

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

data/lib/backports/basic_object.rb

@@ -12,42 +12,42 @@
 #    (they will only be undefined whenever a subclass of BasicObject is created)
 # Because of all the fineprint, BasicObject must be required explicitely
 
-require File.expand_path(File.dirname(__FILE__) + "/tools")
-Backports.require_relative '1.8.7'
+unless Kernel.const_defined? :BasicObject
 
-class BasicObject
-  KEEP = %w[== equal? ! != instance_eval instance_exec __send__]
-  KEEP.concat KEEP.map { |e| e.to_sym }
+  class BasicObject
+    KEEP = %w[== equal? ! != instance_eval instance_exec __send__]
+    KEEP.concat KEEP.map { |e| e.to_sym }
 
-  # undefine almost all instance methods
-  begin
-    old_verbose, $VERBOSE = $VERBOSE, nil # silence the warning for undefining __id__
-    (instance_methods - KEEP).each do |method|
-      undef_method method
+    # undefine almost all instance methods
+    begin
+      old_verbose, $VERBOSE = $VERBOSE, nil # silence the warning for undefining __id__
+      (instance_methods - KEEP).each do |method|
+        undef_method method
+      end
+    ensure
+      $VERBOSE = old_verbose
     end
-  ensure
-    $VERBOSE = old_verbose
-  end
 
-  class << self
-    def === (cmp)
-      true
-    end
+    class << self
+      def === (cmp)
+        true
+      end
 
-    # Let's try to keep things clean, in case methods have been added to Object
-    # either directly or through an included module.
-    # We'll do this whenever a class is derived from BasicObject
-    # Ideally, we'd do this by trapping Object.method_added
-    # and M.method_added for any module M included in Object or a submodule
-    # Seems really though to get right, but pull requests welcome ;-)
-    def inherited(sub)
-      BasicObject.class_eval do
-        (instance_methods - KEEP).each do |method|
-          if Object.method_defined?(method) && instance_method(method).owner == Object.instance_method(method).owner
-            undef_method method
+      # Let's try to keep things clean, in case methods have been added to Object
+      # either directly or through an included module.
+      # We'll do this whenever a class is derived from BasicObject
+      # Ideally, we'd do this by trapping Object.method_added
+      # and M.method_added for any module M included in Object or a submodule
+      # Seems really though to get right, but pull requests welcome ;-)
+      def inherited(sub)
+        BasicObject.class_eval do
+          (instance_methods - KEEP).each do |method|
+            if Object.method_defined?(method) && instance_method(method).owner == Object.instance_method(method).owner
+              undef_method method
+            end
           end
         end
       end
     end
   end
-end unless Kernel.const_defined? :BasicObject
+end