polyfill 0.6.0 → 0.7.0

data/lib/polyfill/v2_4/file.rb

@@ -1,9 +1,11 @@
-require_relative 'file/class'
-
 module Polyfill
   module V2_4
     module File
-      include Class
+      module ClassMethods
+        def empty?(file_name)
+          zero?(file_name)
+        end
+      end
     end
   end
 end

data/lib/polyfill/v2_4/float.rb

@@ -1,9 +1,44 @@
-require_relative 'float/instance'
-
 module Polyfill
   module V2_4
     module Float
-      include Instance
+      def ceil(ndigits = 0)
+        ndigits = ndigits.to_int
+        return super() if ndigits == 0
+
+        if ndigits > 0
+          place = 10**ndigits
+          (self * place).ceil / place.to_f
+        else
+          place = 10**-ndigits
+          (self / place).ceil * place
+        end
+      end
+
+      def floor(ndigits = 0)
+        ndigits = ndigits.to_int
+        return super() if ndigits == 0
+
+        if ndigits > 0
+          place = 10**ndigits
+          (self * place).floor / place.to_f
+        else
+          place = 10**-ndigits
+          (self / place).floor * place
+        end
+      end
+
+      def truncate(ndigits = 0)
+        ndigits = ndigits.to_int
+        return super() if ndigits == 0
+
+        if ndigits > 0
+          place = 10**ndigits
+          (self * place).truncate / place.to_f
+        else
+          place = 10**-ndigits
+          (self / place).truncate * place
+        end
+      end
     end
   end
 end

data/lib/polyfill/v2_4/hash.rb

@@ -1,9 +1,41 @@
-require_relative 'hash/instance'
-
 module Polyfill
   module V2_4
     module Hash
-      include Instance
+      def compact
+        reject { |_, v| v.nil? }
+      end
+
+      def compact!
+        reject! { |_, v| v.nil? }
+      end
+
+      def transform_values
+        unless block_given?
+          return ::Enumerator.new(keys.size) do |yielder|
+            each_with_object({}) do |(k, v), acc|
+              acc[k] = yielder.yield(v)
+            end
+          end
+        end
+
+        each_with_object({}) do |(k, v), acc|
+          acc[k] = yield(v)
+        end
+      end
+
+      def transform_values!
+        unless block_given?
+          return ::Enumerator.new(keys.size) do |yielder|
+            replace(each_with_object({}) do |(k, v), acc|
+              acc[k] = yielder.yield(v)
+            end)
+          end
+        end
+
+        replace(each_with_object({}) do |(k, v), acc|
+          acc[k] = yield(v)
+        end)
+      end
     end
   end
 end

data/lib/polyfill/v2_4/i_p_addr.rb

@@ -1,9 +1,17 @@
-require_relative 'i_p_addr/instance'
-
 module Polyfill
   module V2_4
     module IPAddr
-      include Instance
+      def ==(*)
+        super
+      rescue
+        false
+      end
+
+      def <=>(*)
+        super
+      rescue
+        nil
+      end
     end
   end
 end

data/lib/polyfill/v2_4/integer.rb

@@ -1,9 +1,59 @@
-require_relative 'integer/instance'
-
 module Polyfill
   module V2_4
     module Integer
-      include Instance
+      def ceil(ndigits = 0)
+        ndigits = ndigits.to_int
+        return super() if ndigits == 0
+        return to_f if ndigits > 0
+
+        place = 10**-ndigits
+        (to_f / place).ceil * place
+      end
+
+      def digits(base = 10)
+        base = base.to_int
+        raise Math::DomainError, 'out of domain' if self < 0
+        raise ArgumentError, 'negative radix' if base < 0
+        raise ArgumentError, "invalid radix #{base}" if base < 2
+
+        acc = []
+        remainder = self
+        while remainder > 0
+          remainder, value = remainder.divmod(base)
+          acc.push(value)
+        end
+        acc
+      end
+
+      def floor(ndigits = 0)
+        ndigits = ndigits.to_int
+        return super() if ndigits == 0
+        return to_f if ndigits > 0
+
+        place = 10**-ndigits
+        (to_f / place).floor * place
+      end
+
+      def round(ndigits = 0, half: nil)
+        unless [nil, :down, :even, :up, 'down', 'even', 'up'].include?(half)
+          raise ArgumentError, "invalid rounding mode: #{half}"
+        end
+        ndigits = ndigits.to_int
+        return super() if ndigits == 0
+        return to_f if ndigits > 0
+
+        place = 10**-ndigits
+        (to_f / place).round * place
+      end
+
+      def truncate(ndigits = 0)
+        ndigits = ndigits.to_int
+        return super() if ndigits == 0
+        return to_f if ndigits > 0
+
+        place = 10**-ndigits
+        (to_f / place).truncate * place
+      end
     end
   end
 end

data/lib/polyfill/v2_4/io.rb

@@ -1,11 +1,173 @@
-require_relative 'io/class'
-require_relative 'io/instance'
+require 'English'
 
 module Polyfill
   module V2_4
     module IO
-      include Class
-      include Instance
+      module ClassMethods
+        def foreach(name, *args)
+          hash, others = args.partition { |arg| arg.is_a?(::Hash) }
+          chomps = hash[0] && hash[0][:chomp]
+
+          unless block_given?
+            return super(name, *others) unless chomps
+
+            separator = others.find do |other|
+              other.respond_to?(:to_str)
+            end || $INPUT_RECORD_SEPARATOR
+
+            return ::Enumerator.new do |yielder|
+              super(name, *others) do |line|
+                yielder.yield(line.chomp(separator))
+              end
+            end
+          end
+
+          block =
+            if chomps
+              separator = others.find do |other|
+                other.respond_to?(:to_str)
+              end || $INPUT_RECORD_SEPARATOR
+
+              proc do |line|
+                yield(line.chomp(separator))
+              end
+            else
+              ::Proc.new
+            end
+
+          super(name, *others, &block)
+        end
+
+        def readlines(file_name, *args)
+          hash, others = args.partition { |arg| arg.is_a?(::Hash) }
+
+          inputs = super(file_name, *others)
+
+          if hash[0] && hash[0][:chomp]
+            separator = others.find do |other|
+              other.respond_to?(:to_str)
+            end || $INPUT_RECORD_SEPARATOR
+
+            inputs.each { |input| input.chomp!(separator) }
+          end
+
+          inputs
+        end
+      end
+
+      def each_line(*args)
+        hash, others = args.partition { |arg| arg.is_a?(::Hash) }
+        chomps = hash[0] && hash[0][:chomp]
+
+        unless block_given?
+          return super(*others) unless chomps
+
+          separator = others.find do |other|
+            other.respond_to?(:to_str)
+          end || $INPUT_RECORD_SEPARATOR
+          return ::Enumerator.new do |yielder|
+            super(*others) do |line|
+              yielder.yield(line.chomp(separator))
+            end
+          end
+        end
+
+        block =
+          if chomps
+            separator = others.find do |other|
+              other.respond_to?(:to_str)
+            end || $INPUT_RECORD_SEPARATOR
+
+            proc do |line|
+              yield(line.chomp(separator))
+            end
+          else
+            ::Proc.new
+          end
+
+        super(*others, &block)
+      end
+
+      def gets(*args)
+        hash, others = args.partition { |arg| arg.is_a?(::Hash) }
+
+        input = super(*others)
+
+        if !input.nil? && hash[0] && hash[0][:chomp]
+          separator = others.find do |other|
+            other.respond_to?(:to_str)
+          end || $INPUT_RECORD_SEPARATOR
+
+          input.chomp!(separator)
+        end
+
+        input
+      end
+
+      def lines(*args)
+        hash, others = args.partition { |arg| arg.is_a?(::Hash) }
+        chomps = hash[0] && hash[0][:chomp]
+
+        unless block_given?
+          return super(*others) unless chomps
+
+          separator = others.find do |other|
+            other.respond_to?(:to_str)
+          end || $INPUT_RECORD_SEPARATOR
+          return ::Enumerator.new do |yielder|
+            super(*others) do |line|
+              yielder.yield(line.chomp(separator))
+            end
+          end
+        end
+
+        block =
+          if chomps
+            separator = others.find do |other|
+              other.respond_to?(:to_str)
+            end || $INPUT_RECORD_SEPARATOR
+
+            proc do |line|
+              yield(line.chomp(separator))
+            end
+          else
+            ::Proc.new
+          end
+
+        super(*others, &block)
+      end
+
+      def readline(*args)
+        hash, others = args.partition { |arg| arg.is_a?(::Hash) }
+
+        input = super(*others)
+
+        if hash[0] && hash[0][:chomp]
+          separator = others.find do |other|
+            other.respond_to?(:to_str)
+          end || $INPUT_RECORD_SEPARATOR
+
+          input.chomp!(separator)
+        end
+
+        input
+      end
+
+      def readlines(*args)
+        hash, others = args.partition { |arg| arg.is_a?(::Hash) }
+
+        inputs = super(*others)
+
+        if hash[0] && hash[0][:chomp]
+          separator = others.find do |other|
+            other.respond_to?(:to_str)
+          end || $INPUT_RECORD_SEPARATOR
+
+          inputs.each { |input| input.chomp!(separator) }
+        end
+
+        inputs
+      end
     end
   end
 end

data/lib/polyfill/v2_4/match_data.rb

@@ -1,9 +1,17 @@
-require_relative 'match_data/instance'
-
 module Polyfill
   module V2_4
     module MatchData
-      include Instance
+      def named_captures
+        names.each_with_object({}) do |name, acc|
+          acc[name] = self[name]
+        end
+      end
+
+      def values_at(*indexes)
+        indexes.each_with_object([]) do |index, acc|
+          acc.push(self[index])
+        end
+      end
     end
   end
 end

data/lib/polyfill/v2_4/numeric.rb

@@ -1,9 +1,21 @@
-require_relative 'numeric/instance'
-
 module Polyfill
   module V2_4
     module Numeric
-      include Instance
+      def clone(freeze: true) # rubocop:disable Lint/UnusedMethodArgument
+        self
+      end
+
+      def dup
+        self
+      end
+
+      def finite?
+        true
+      end
+
+      def infinite?
+        nil
+      end
     end
   end
 end

data/lib/polyfill/v2_4/object.rb

@@ -1,9 +1,15 @@
-require_relative 'object/instance'
-
 module Polyfill
   module V2_4
     module Object
-      include Instance
+      def clone(freeze: true)
+        return super() if freeze
+
+        cloned = dup
+        (singleton_class.ancestors - self.class.ancestors).drop(1).each do |ancestor|
+          cloned.extend(ancestor)
+        end
+        cloned
+      end
     end
   end
 end

data/lib/polyfill/v2_4/pathname.rb

@@ -1,9 +1,13 @@
-require_relative 'pathname/instance'
-
 module Polyfill
   module V2_4
     module Pathname
-      include Instance
+      def empty?
+        if directory?
+          children.empty?
+        else
+          zero?
+        end
+      end
     end
   end
 end