polyfill 0.6.0 → 0.7.0

data/lib/polyfill/v2_4/integer/instance/floor.rb

@@ -1,28 +0,0 @@
-module Polyfill
-  module V2_4
-    module Integer
-      module Instance
-        module Floor
-          module Method
-            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
-          end
-
-          refine ::Integer do
-            include Method
-          end
-
-          def self.included(base)
-            base.include Method
-          end
-        end
-      end
-    end
-  end
-end

data/lib/polyfill/v2_4/integer/instance/round.rb

@@ -1,31 +0,0 @@
-module Polyfill
-  module V2_4
-    module Integer
-      module Instance
-        module Round
-          module Method
-            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
-          end
-
-          refine ::Integer do
-            include Method
-          end
-
-          def self.included(base)
-            base.include Method
-          end
-        end
-      end
-    end
-  end
-end

data/lib/polyfill/v2_4/integer/instance/truncate.rb

@@ -1,28 +0,0 @@
-module Polyfill
-  module V2_4
-    module Integer
-      module Instance
-        module Truncate
-          module Method
-            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
-
-          refine ::Integer do
-            include Method
-          end
-
-          def self.included(base)
-            base.include Method
-          end
-        end
-      end
-    end
-  end
-end

data/lib/polyfill/v2_4/io/class.rb

@@ -1,13 +0,0 @@
-require_relative 'class/foreach'
-require_relative 'class/readlines'
-
-module Polyfill
-  module V2_4
-    module IO
-      module Class
-        include Foreach
-        include Readlines
-      end
-    end
-  end
-end

data/lib/polyfill/v2_4/io/class/foreach.rb

@@ -1,55 +0,0 @@
-require 'English'
-
-module Polyfill
-  module V2_4
-    module IO
-      module Class
-        module Foreach
-          module Method
-            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
-          end
-
-          refine ::IO.singleton_class do
-            include Method
-          end
-
-          def self.included(base)
-            base.include Method
-          end
-        end
-      end
-    end
-  end
-end

data/lib/polyfill/v2_4/io/class/readlines.rb

@@ -1,37 +0,0 @@
-require 'English'
-
-module Polyfill
-  module V2_4
-    module IO
-      module Class
-        module Readlines
-          module Method
-            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
-
-          refine ::IO.singleton_class do
-            include Method
-          end
-
-          def self.included(base)
-            base.include Method
-          end
-        end
-      end
-    end
-  end
-end

data/lib/polyfill/v2_4/io/instance.rb

@@ -1,19 +0,0 @@
-require_relative 'instance/each_line'
-require_relative 'instance/gets'
-require_relative 'instance/lines'
-require_relative 'instance/readline'
-require_relative 'instance/readlines'
-
-module Polyfill
-  module V2_4
-    module IO
-      module Instance
-        include EachLine
-        include Gets
-        include Lines
-        include Readline
-        include Readlines
-      end
-    end
-  end
-end

data/lib/polyfill/v2_4/io/instance/each_line.rb

@@ -1,54 +0,0 @@
-require 'English'
-
-module Polyfill
-  module V2_4
-    module IO
-      module Instance
-        module EachLine
-          module Method
-            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
-          end
-
-          refine ::IO do
-            include Method
-          end
-
-          def self.included(base)
-            base.include Method
-          end
-        end
-      end
-    end
-  end
-end

data/lib/polyfill/v2_4/io/instance/gets.rb

@@ -1,37 +0,0 @@
-require 'English'
-
-module Polyfill
-  module V2_4
-    module IO
-      module Instance
-        module Gets
-          module Method
-            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
-          end
-
-          refine ::IO do
-            include Method
-          end
-
-          def self.included(base)
-            base.include Method
-          end
-        end
-      end
-    end
-  end
-end

data/lib/polyfill/v2_4/io/instance/lines.rb

@@ -1,54 +0,0 @@
-require 'English'
-
-module Polyfill
-  module V2_4
-    module IO
-      module Instance
-        module Lines
-          module Method
-            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
-          end
-
-          refine ::IO do
-            include Method
-          end
-
-          def self.included(base)
-            base.include Method
-          end
-        end
-      end
-    end
-  end
-end

data/lib/polyfill/v2_4/io/instance/readline.rb

@@ -1,37 +0,0 @@
-require 'English'
-
-module Polyfill
-  module V2_4
-    module IO
-      module Instance
-        module Readline
-          module Method
-            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
-          end
-
-          refine ::IO do
-            include Method
-          end
-
-          def self.included(base)
-            base.include Method
-          end
-        end
-      end
-    end
-  end
-end

data/lib/polyfill/v2_4/io/instance/readlines.rb

@@ -1,37 +0,0 @@
-require 'English'
-
-module Polyfill
-  module V2_4
-    module IO
-      module Instance
-        module Readlines
-          module Method
-            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
-
-          refine ::IO do
-            include Method
-          end
-
-          def self.included(base)
-            base.include Method
-          end
-        end
-      end
-    end
-  end
-end