polyfill 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ce45400dde62a6c4481017080a3770fe3557619e
-  data.tar.gz: 29d853335b679ed69d51df345786021e8919b121
+  metadata.gz: 3b944cddd5bba115b1c21189a683eebfb41d3e85
+  data.tar.gz: d1069d216c3850bbb3687c1f39251403150c6912
 SHA512:
-  metadata.gz: 2f9a80ce2cc37783a1060d403317eb5e142c6c1a97a81057fc4123c9c7d8e7fcf6fcbec1f40d130d43ef8ad737df0db2f55c09b62f2a10de674d815d88b01f2d
-  data.tar.gz: e465ec4b46c0ba099cfd5121402e6366eeca20991f6c00d03656127b0cfb6fe36159f5fd87d955655282e0bc076025d69a1622e10357f81996c7e3bd2ec6525b
+  metadata.gz: 4b8fa7d1486148b1b305244ec0002fec739faa019e437f5163738ba0055d9ce0fe1ee1548a48fddc19ef628bdfada326b8fac6031ff5fda4497119943a54936b
+  data.tar.gz: 5f6f3e9a641cc20f9e9d06c420506b55084b1b379da2a90bd3509ea35f107422126bc8084edd22a1bcad2f0ba7706c6d4962439895450d934da18f8a7a51914c

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+# [0.9.0][] (2017-05-05)
+
+## Added
+
+ - v2.2 Enumerable#max
+ - v2.2 Enumerable#max_by
+ - v2.2 Enumerable#min
+ - v2.2 Enumerable#min_by
+ - v2.2 Vector#@+
+ - Polyfill.get can now be used with `prepend`
+
+## Fixed
+
+ - Enumerable should add to Matrix and Vector as well
+
 # [0.8.0][] (2017-04-27)
 
 ## Changed
@@ -141,6 +156,7 @@
  - v2.4 String#concat?
  - v2.4 String#prepend?
 
+[0.9.0]: https://github.com/AaronLasseigne/polyfill/compare/v0.8.0...v0.9.0
 [0.8.0]: https://github.com/AaronLasseigne/polyfill/compare/v0.7.0...v0.8.0
 [0.7.0]: https://github.com/AaronLasseigne/polyfill/compare/v0.6.0...v0.7.0
 [0.6.0]: https://github.com/AaronLasseigne/polyfill/compare/v0.5.0...v0.6.0

data/README.md

@@ -33,7 +33,7 @@ See the [implementation table](#implementation-table) for specifics about what h
 Add it to your Gemfile:
 
 ```ruby
-gem 'polyfill', '0.8.0'
+gem 'polyfill', '0.9.0'
 ```
 
 Or install it manually:
@@ -95,7 +95,7 @@ using Polyfill(native: true, Numeric: :all)
 Prior to Ruby 2.4, refinements do not work on Modules. When using a polyfill
 on a module it will instead refine the core classes that use the module. If
 you're building your own class, it will not receive the polyfill. Instead,
-you can `include` (or `extend`) in a polyfill with `Polyfill.get`.
+you can `include` (or `extend` or `prepend`) in a polyfill with `Polyfill.get`.
 
 ```ruby
 class Foo
@@ -316,10 +316,10 @@ end
 | Binding     | #local_variables                        | No          |
 |             | #receiver                               | No          |
 | Dir         | #fileno                                 | No          |
-| Enumerable  | #max                                    | No          |
-|             | #max_by                                 | No          |
-|             | #min                                    | No          |
-|             | #min_by                                 | No          |
+| Enumerable  | #max                                    | Yes         |
+|             | #max_by                                 | Yes         |
+|             | #min                                    | Yes         |
+|             | #min_by                                 | Yes         |
 |             | #slice_after                            | Yes         |
 |             | #slice_when                             | Yes         |
 | Etc         | .confstr                                | No          |
@@ -371,7 +371,7 @@ end
 | TSort       | .each_strongly_connected_component      | No          |
 |             | .each_strongly_connected_component_from | No          |
 |             | .tsort_each                             | No          |
-| Vector      | #+@                                     | No          |
+| Vector      | #+@                                     | Yes         |
 |             | #-@                                     | No          |
 |             | #angle_with                             | No          |
 |             | .basis                                  | No          |

data/lib/polyfill.rb

@@ -1,31 +1,18 @@
-require 'ipaddr'
-require 'stringio'
 require 'polyfill/version'
-require 'polyfill/utils'
+require 'polyfill/internal_utils'
 
 module Polyfill
-  module Parcel; end
+  module Module; end
 
   def get(module_name, methods, options = {})
-    if Object.const_get(module_name.to_s).is_a?(Class)
+    if Object.const_get(module_name.to_s, false).is_a?(Class)
       raise ArgumentError, "#{module_name} is a class not a module"
     end
 
     #
     # parse options
     #
-    versions = {
-      '2.2' => Polyfill::V2_2,
-      '2.3' => Polyfill::V2_3,
-      '2.4' => Polyfill::V2_4
-    }
-    desired_version = options.delete(:version) || versions.keys.max
-    unless versions.keys.include?(desired_version)
-      raise ArgumentError, "invalid value for keyword version: #{desired_version}"
-    end
-    versions.reject! do |version_number, _|
-      version_number > desired_version
-    end
+    versions = InternalUtils.polyfill_versions_to_use(options.delete(:version))
 
     unless options.empty?
       raise ArgumentError, "unknown keyword: #{options.first[0]}"
@@ -34,75 +21,47 @@ module Polyfill
     #
     # find all polyfills for the module across all versions
     #
-    module_names = module_name.to_s.split('::')
-    current_ruby_version = RUBY_VERSION[/\A(\d+\.\d+)/, 1]
-
-    modules_with_updates = []
-    modules = []
-    versions.each do |version_number, version_module|
-      begin
-        final_module = module_names
-          .reduce(version_module) do |current_mod, name|
-          current_mod.const_get(name, false)
-        end
-
-        modules_with_updates << final_module
-
-        next if version_number <= current_ruby_version
-
-        modules << final_module.clone
-      rescue NameError
-        nil
-      end
-    end
-
-    if modules_with_updates.empty?
-      raise ArgumentError, %Q("#{module_name}" has no updates)
-    end
+    modules_with_updates, modules = InternalUtils.modules_to_use(module_name, versions)
 
     #
     # remove methods that were not requested
     #
-    methods_with_updates = modules_with_updates.flat_map(&:instance_methods).uniq
-    requested_methods = methods == :all ? methods_with_updates : methods
-
-    unless (leftovers = (requested_methods - methods_with_updates)).empty?
-      raise ArgumentError, %Q("##{leftovers.first}" is not a valid method on #{module_name} or has no updates)
-    end
+    requested_methods = InternalUtils.methods_to_keep(modules_with_updates, methods, '#', module_name)
 
     modules.each do |instance_module|
-      instance_module.instance_methods.each do |name|
-        instance_module.send(:remove_method, name) unless requested_methods.include?(name)
-      end
+      InternalUtils.keep_only_these_methods!(instance_module, requested_methods)
     end
 
     #
     # build the module to return
     #
-    mod = Module.new
+    InternalUtils.create_module do |mod|
+      # make sure the methods get added if this module is included
+      mod.singleton_class.send(:define_method, :included) do |base|
+        modules.each do |module_to_add|
+          base.include module_to_add unless module_to_add.instance_methods.empty?
+        end
+      end
 
-    # make sure the methods get added if this module is included
-    mod.singleton_class.send(:define_method, :included) do |base|
-      modules.each do |module_to_add|
-        base.include module_to_add unless module_to_add.instance_methods.empty?
+      # make sure the methods get added if this module is extended
+      mod.singleton_class.send(:define_method, :extended) do |base|
+        modules.each do |module_to_add|
+          base.extend module_to_add unless module_to_add.instance_methods.empty?
+        end
       end
-    end
 
-    # make sure the methods get added if this module is extended
-    mod.singleton_class.send(:define_method, :extended) do |base|
-      modules.each do |module_to_add|
-        base.extend module_to_add unless module_to_add.instance_methods.empty?
+      # make sure the methods get added if this module is prepended
+      mod.singleton_class.send(:define_method, :prepended) do |base|
+        modules.each do |module_to_add|
+          base.prepend module_to_add unless module_to_add.instance_methods.empty?
+        end
       end
     end
-
-    Polyfill::Parcel.const_set("O#{mod.object_id}", mod)
   end
   module_function :get
 end
 
 def Polyfill(options = {}) # rubocop:disable Style/MethodName
-  mod = Module.new
-
   #
   # parse options
   #
@@ -116,21 +75,12 @@ def Polyfill(options = {}) # rubocop:disable Style/MethodName
       0
     end
   end
-  others = others.to_h
-
-  versions = {
-    '2.2' => Polyfill::V2_2,
-    '2.3' => Polyfill::V2_3,
-    '2.4' => Polyfill::V2_4
-  }
-  desired_version = others.delete(:version) || versions.keys.max
-  unless versions.keys.include?(desired_version)
-    raise ArgumentError, "invalid value for keyword version: #{desired_version}"
-  end
-  versions.reject! do |version_number, _|
-    version_number > desired_version
+  objects.each do |object_name, _|
+    Object.const_get(object_name.to_s, false)
   end
+  others = others.to_h
 
+  versions = Polyfill::InternalUtils.polyfill_versions_to_use(others.delete(:version))
   native = others.delete(:native) { false }
 
   unless others.empty?
@@ -138,160 +88,136 @@ def Polyfill(options = {}) # rubocop:disable Style/MethodName
   end
 
   #
-  # useful var
+  # build the module to return
   #
-  current_ruby_version = RUBY_VERSION[/\A(\d+\.\d+)/, 1]
-
-  objects.each do |full_name, methods|
-    #
-    # find all polyfills for the object across all versions
-    #
-    object_module_names = full_name.to_s.split('::')
-
-    object_modules = versions
-      .map do |version_number, version_module|
+  Polyfill::InternalUtils.create_module do |mod|
+    objects.each do |object_name, methods|
+      #
+      # find all polyfills for the object across all versions
+      #
+      modules_with_updates, instance_modules = Polyfill::InternalUtils.modules_to_use(object_name, versions)
+
+      class_modules_with_updates = modules_with_updates.map do |module_with_updates|
         begin
-          final_module = object_module_names
-            .reduce(version_module) do |current_mod, name|
-              current_mod.const_get(name, false)
-            end
-
-          [version_number, final_module]
+          module_with_updates.const_get(:ClassMethods, false)
         rescue NameError
           nil
         end
-      end
-      .compact
-
-    if object_modules.empty?
-      raise ArgumentError, %Q("#{full_name}" is not a valid object or has no updates)
-    end
+      end.compact
+      class_modules = instance_modules.map do |module_with_updates|
+        begin
+          module_with_updates.const_get(:ClassMethods, false).clone
+        rescue NameError
+          nil
+        end
+      end.compact
 
-    #
-    # get all class modules and instance modules from the polyfills
-    #
-    class_modules = object_modules.map do |version_number, object_module|
-      begin
-        [version_number, object_module.const_get(:ClassMethods, false).clone]
-      rescue NameError
-        nil
+      #
+      # get all requested class and instance methods
+      #
+      if methods != :all && (method_name = methods.find { |method| method !~ /\A[.#]/ })
+        raise ArgumentError, %Q("#{method_name}" must start with a "." if it's a class method or "#" if it's an instance method)
       end
-    end.compact
-    instance_modules = object_modules.map do |version_number, object_module|
-      [version_number, object_module.clone]
-    end
-
-    #
-    # get all requested class and instance methods
-    #
-    if methods != :all && (method_name = methods.find { |method| method !~ /\A[.#]/ })
-      raise ArgumentError, %Q("#{method_name}" must start with a "." if it's a class method or "#" if it's an instance method)
-    end
 
-    all_methods_for = lambda do |modules|
-      modules.flat_map { |_, m| m.instance_methods }.uniq
-    end
-    available_class_methods = all_methods_for.call(class_modules)
-    available_instance_methods = all_methods_for.call(instance_modules)
-
-    select_and_clean = lambda do |leader|
-      methods.select { |method| method.start_with?(leader) }.map { |method| method[1..-1].to_sym }
-    end
-    requested_class_methods = methods == :all ? available_class_methods : select_and_clean.call('.')
-    requested_instance_methods = methods == :all ? available_instance_methods : select_and_clean.call('#')
-
-    unless (leftovers = (requested_class_methods - available_class_methods)).empty?
-      raise ArgumentError, %Q(".#{leftovers.first}" is not a valid method on #{full_name} or has no updates)
-    end
-    unless (leftovers = (requested_instance_methods - available_instance_methods)).empty?
-      raise ArgumentError, %Q("##{leftovers.first}" is not a valid method on #{full_name} or has no updates)
-    end
+      instance_methods, class_methods =
+        if methods == :all
+          [:all, :all]
+        else
+          methods
+            .partition { |m| m.start_with?('#') }
+            .map { |method_list| method_list.map { |name| name[1..-1].to_sym } }
+        end
 
-    #
-    # get the class(es) to refine
-    #
-    base_class = object_modules.first.last.name.sub(/\APolyfill::V\d_\d::/, '')
-    base_classes =
-      case base_class
-      when 'Comparable'
-        %w[Numeric String Time]
-      when 'Enumerable'
-        %w[Array Dir Enumerator Hash IO Range StringIO Struct]
-      when 'Kernel'
-        %w[Object]
-      else
-        [base_class]
+      requested_instance_methods =
+        Polyfill::InternalUtils.methods_to_keep(modules_with_updates, instance_methods, '#', object_name)
+      requested_class_methods =
+        Polyfill::InternalUtils.methods_to_keep(class_modules_with_updates, class_methods, '.', object_name)
+
+      #
+      # get the class(es) to refine
+      #
+      base_object = object_name.to_s
+      base_objects =
+        case base_object
+        when 'Comparable'
+          %w[Numeric String Time]
+        when 'Enumerable'
+          %w[Array Dir Enumerator Hash IO Matrix Range StringIO Struct Vector]
+        when 'Kernel'
+          %w[Object]
+        else
+          [base_object]
+        end
+      base_objects.select! do |klass|
+        begin
+          Object.const_get(klass, false)
+        rescue NameError
+          false
+        end
       end
 
-    #
-    # refine in class methods
-    #
-    class_modules.each do |version_number, class_module|
-      next if version_number <= current_ruby_version
+      #
+      # refine in class methods
+      #
+      class_modules.each do |class_module|
+        Polyfill::InternalUtils.keep_only_these_methods!(class_module, requested_class_methods)
 
-      class_module.instance_methods.each do |name|
-        class_module.send(:remove_method, name) unless requested_class_methods.include?(name)
-      end
+        next if class_module.instance_methods.empty?
 
-      next if class_module.instance_methods.empty?
+        mod.module_exec(requested_class_methods) do |methods_added|
+          base_objects.each do |klass|
+            refine Object.const_get(klass, false).singleton_class do
+              include class_module
 
-      mod.module_exec(requested_class_methods) do |methods_added|
-        base_classes.each do |klass|
-          refine Object.const_get(klass).singleton_class do
-            include class_module
+              if native
+                Polyfill::InternalUtils.ignore_warnings do
+                  define_method :respond_to? do |name, include_all = false|
+                    return true if methods_added.include?(name)
 
-            if native
-              Polyfill::Utils.ignore_warnings do
-                define_method :respond_to? do |name, include_all = false|
-                  return true if methods_added.include?(name)
+                    super(name, include_all)
+                  end
 
-                  super(name, include_all)
-                end
+                  define_method :__send__ do |name, *args, &block|
+                    return super(name, *args, &block) unless methods_added.include?(name)
 
-                define_method :__send__ do |name, *args, &block|
-                  return super(name, *args, &block) unless methods_added.include?(name)
-
-                  class_module.instance_method(name).bind(self).call(*args, &block)
+                    class_module.instance_method(name).bind(self).call(*args, &block)
+                  end
+                  alias_method :send, :__send__
                 end
-                alias_method :send, :__send__
               end
             end
           end
         end
       end
-    end
-
-    #
-    # refine in instance methods
-    #
-    instance_modules.each do |version_number, instance_module|
-      next if version_number <= current_ruby_version
 
-      instance_module.instance_methods.each do |name|
-        instance_module.send(:remove_method, name) unless requested_instance_methods.include?(name)
-      end
+      #
+      # refine in instance methods
+      #
+      instance_modules.each do |instance_module|
+        Polyfill::InternalUtils.keep_only_these_methods!(instance_module, requested_instance_methods)
 
-      next if instance_module.instance_methods.empty?
+        next if instance_module.instance_methods.empty?
 
-      mod.module_exec(requested_instance_methods) do |methods_added|
-        base_classes.each do |klass|
-          refine Object.const_get(klass) do
-            include instance_module
+        mod.module_exec(requested_instance_methods) do |methods_added|
+          base_objects.each do |klass|
+            refine Object.const_get(klass, false) do
+              include instance_module
 
-            if native
-              Polyfill::Utils.ignore_warnings do
-                define_method :respond_to? do |name, include_all = false|
-                  return super(name, include_all) unless methods_added.include?(name)
+              if native
+                Polyfill::InternalUtils.ignore_warnings do
+                  define_method :respond_to? do |name, include_all = false|
+                    return super(name, include_all) unless methods_added.include?(name)
 
-                  true
-                end
+                    true
+                  end
 
-                define_method :__send__ do |name, *args, &block|
-                  return super(name, *args, &block) unless methods_added.include?(name)
+                  define_method :__send__ do |name, *args, &block|
+                    return super(name, *args, &block) unless methods_added.include?(name)
 
-                  instance_module.instance_method(name).bind(self).call(*args, &block)
+                    instance_module.instance_method(name).bind(self).call(*args, &block)
+                  end
+                  alias_method :send, :__send__
                 end
-                alias_method :send, :__send__
               end
             end
           end
@@ -299,8 +225,6 @@ def Polyfill(options = {}) # rubocop:disable Style/MethodName
       end
     end
   end
-
-  Polyfill::Parcel.const_set("O#{mod.object_id}", mod)
 end
 
 require 'polyfill/v2_2'

data/lib/polyfill/internal_utils.rb

@@ -0,0 +1,93 @@
+module Polyfill
+  module InternalUtils
+    VERSIONS = {
+      '2.2' => 'V2_2',
+      '2.3' => 'V2_3',
+      '2.4' => 'V2_4'
+    }.freeze
+    private_constant :VERSIONS
+
+    def current_ruby_version
+      @current_ruby_version ||= RUBY_VERSION[/\A(\d+\.\d+)/, 1]
+    end
+    module_function :current_ruby_version
+
+    def ignore_warnings
+      orig = $VERBOSE
+      $VERBOSE = nil
+
+      yield
+
+      $VERBOSE = orig
+    end
+    module_function :ignore_warnings
+
+    def polyfill_versions_to_use(desired_version = nil)
+      desired_version = VERSIONS.keys.max if desired_version.nil?
+
+      unless VERSIONS.keys.include?(desired_version)
+        raise ArgumentError, "invalid value for keyword version: #{desired_version}"
+      end
+
+      VERSIONS
+        .reject { |version, _| version > desired_version }
+        .map { |version, mod| [version, Polyfill.const_get(mod, false)] }
+        .to_h
+    end
+    module_function :polyfill_versions_to_use
+
+    def keep_only_these_methods!(mod, whitelist)
+      mod.instance_methods.each do |name|
+        mod.send(:remove_method, name) unless whitelist.include?(name)
+      end
+    end
+    module_function :keep_only_these_methods!
+
+    def modules_to_use(module_name, versions)
+      modules_with_updates = []
+      modules = []
+
+      versions.each do |version_number, version_module|
+        begin
+          final_module = version_module.const_get(module_name.to_s, false)
+
+          modules_with_updates << final_module
+
+          next if version_number <= InternalUtils.current_ruby_version
+
+          modules << final_module.clone
+        rescue NameError
+          nil
+        end
+      end
+
+      if modules_with_updates.empty?
+        raise ArgumentError, %Q("#{module_name}" has no updates)
+      end
+
+      [modules_with_updates, modules]
+    end
+    module_function :modules_to_use
+
+    def methods_to_keep(modules, methods, lead_symbol, module_name)
+      methods_with_updates = modules.flat_map(&:instance_methods).uniq
+      requested_methods = methods == :all ? methods_with_updates : methods
+
+      unless (leftovers = (requested_methods - methods_with_updates)).empty?
+        raise ArgumentError, %Q("#{lead_symbol}#{leftovers.first}" is not a valid method on #{module_name} or has no updates)
+      end
+
+      requested_methods
+    end
+    module_function :methods_to_keep
+
+    def create_module
+      mod = ::Module.new
+
+      yield(mod)
+
+      Polyfill::Module.const_set("M#{mod.object_id}", mod)
+    end
+    module_function :create_module
+  end
+end

data/lib/polyfill/v2_2.rb

@@ -1,9 +1,8 @@
 require_relative 'v2_2/enumerable'
 require_relative 'v2_2/kernel'
+require_relative 'v2_2/vector'
 
 module Polyfill
   module V2_2
-    include Enumerable
-    include Kernel
   end
 end

data/lib/polyfill/v2_2/enumerable.rb

@@ -1,6 +1,42 @@
 module Polyfill
   module V2_2
     module Enumerable
+      def max(n = nil)
+        return block_given? ? super(&::Proc.new) : super() if n.nil? || n == 1
+
+        raise ArgumentError, "negative size (#{n})" if n < 0
+
+        (block_given? ? sort(&::Proc.new) : sort).last(n).reverse
+      end
+
+      def max_by(n = nil)
+        if n.nil? || n == 1 || !block_given?
+          return block_given? ? super(&::Proc.new) : super()
+        end
+
+        raise ArgumentError, "negative size (#{n})" if n < 0
+
+        sort_by(&::Proc.new).last(n).reverse
+      end
+
+      def min(n = nil)
+        return block_given? ? super(&::Proc.new) : super() if n.nil? || n == 1
+
+        raise ArgumentError, "negative size (#{n})" if n < 0
+
+        (block_given? ? sort(&::Proc.new) : sort).first(n)
+      end
+
+      def min_by(n = nil)
+        if n.nil? || n == 1 || !block_given?
+          return block_given? ? super(&::Proc.new) : super()
+        end
+
+        raise ArgumentError, "negative size (#{n})" if n < 0
+
+        sort_by(&::Proc.new).first(n)
+      end
+
       def slice_after(pattern = nil)
         raise ArgumentError, 'both pattern and block are given' if pattern && block_given?
         raise ArgumentError, 'wrong number of arguments (given 0, expected 1)' if !pattern && !block_given?

data/lib/polyfill/v2_2/vector.rb

@@ -0,0 +1,9 @@
+module Polyfill
+  module V2_2
+    module Vector
+      def +@
+        self
+      end
+    end
+  end
+end

data/lib/polyfill/v2_3.rb

@@ -8,12 +8,5 @@ require_relative 'v2_3/struct'
 
 module Polyfill
   module V2_3
-    include Array
-    include Hash
-    include Enumerable
-    include Enumerator::Lazy
-    include Kernel
-    include String
-    include Struct
   end
 end

data/lib/polyfill/v2_4.rb

@@ -21,26 +21,5 @@ require_relative 'v2_4/pathname'
 
 module Polyfill
   module V2_4
-    include Array
-    include Comparable
-    include Dir
-    include Enumerable
-    include Enumerator::Lazy
-    include File
-    include Float
-    include Hash
-    include Integer
-    include IO
-    include Kernel
-    include MatchData
-    include Numeric
-    include Object
-    include Regexp
-    include String
-    include StringIO
-    include Symbol
-
-    include IPAddr
-    include Pathname
   end
 end

data/lib/polyfill/version.rb

@@ -1,3 +1,3 @@
 module Polyfill
-  VERSION = '0.8.0'.freeze
+  VERSION = '0.9.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polyfill
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Aaron Lasseigne
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-04-27 00:00:00.000000000 Z
+date: 2017-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -86,10 +86,11 @@ files:
 - bin/console
 - bin/setup
 - lib/polyfill.rb
-- lib/polyfill/utils.rb
+- lib/polyfill/internal_utils.rb
 - lib/polyfill/v2_2.rb
 - lib/polyfill/v2_2/enumerable.rb
 - lib/polyfill/v2_2/kernel.rb
+- lib/polyfill/v2_2/vector.rb
 - lib/polyfill/v2_3.rb
 - lib/polyfill/v2_3/array.rb
 - lib/polyfill/v2_3/enumerable.rb

data/lib/polyfill/utils.rb

@@ -1,13 +0,0 @@
-module Polyfill
-  module Utils
-    def ignore_warnings
-      orig = $VERBOSE
-      $VERBOSE = nil
-
-      yield
-
-      $VERBOSE = orig
-    end
-    module_function :ignore_warnings
-  end
-end