ruby-next-core 0.2.0 → 0.3.0

data/lib/ruby-next/core.rb

@@ -1,8 +1,121 @@
 # frozen_string_literal: true
 
+require "set"
+
 module RubyNext
   module Core
+    # Patch contains the extension implementation
+    # and meta information (e.g., Ruby version).
+    class Patch
+      attr_reader :refineables, :name, :mod, :method_name, :version, :body, :singleton, :core_ext, :supported, :native, :location
+
+      # Create a new patch for module/class (mod)
+      # with the specified uniq name
+      #
+      # `core_ext` defines the strategy for core extensions:
+      #    - :patch — extend class directly
+      #    - :prepend — extend class by prepending a module (e.g., when needs `super`)
+      def initialize(mod = nil, method:, name: nil, version:, supported: nil, native: nil, location: nil, refineable: mod, core_ext: :patch, singleton: nil)
+        @mod = mod
+        @method_name = method
+        @version = version
+        if method_name && mod
+          @supported = supported.nil? ? mod.method_defined?(method_name) : supported
+          # define whether running Ruby has a native implementation for this method
+          # for that, we check the source_location (which is nil for C defined methods)
+          @native = native.nil? ? (supported? && mod.instance_method(method_name).source_location.nil?) : native
+        end
+        @singleton = singleton
+        @refineables = Array(refineable)
+        @body = yield
+        @core_ext = core_ext
+        @location = location || build_location(caller_locations(1, 5))
+        @name = name || build_module_name
+      end
+
+      def prepend?
+        core_ext == :prepend
+      end
+
+      def core_ext?
+        !mod.nil?
+      end
+
+      alias supported? supported
+      alias native? native
+      alias singleton? singleton
+
+      def to_module
+        Module.new.tap do |ext|
+          ext.module_eval(body, *location)
+
+          RubyNext::Core.const_set(name, ext)
+        end
+      end
+
+      private
+
+      def build_module_name
+        mod_name = singleton? ? singleton.name : mod.name
+        camelized_method_name = method_name.to_s.split("_").map(&:capitalize).join
+
+        "#{mod_name}#{camelized_method_name}".gsub(/\W/, "")
+      end
+
+      def build_location(trace_locations)
+        # The caller_locations behaviour depends on implementaion,
+        # e.g. in JRuby https://github.com/jruby/jruby/issues/6055
+        while trace_locations.first.label != "patch"
+          trace_locations.shift
+        end
+
+        trace_location = trace_locations[1]
+
+        [trace_location.absolute_path, trace_location.lineno + 2]
+      end
+    end
+
+    # Registry for patches
+    class Patches
+      attr_reader :extensions, :refined
+
+      def initialize
+        @names = Set.new
+        @extensions = Hash.new { |h, k| h[k] = [] }
+        @refined = Hash.new { |h, k| h[k] = [] }
+      end
+
+      # Register new patch
+      def <<(patch)
+        raise ArgumentError, "Patch already registered: #{patch.name}" if @names.include?(patch.name)
+        @names << patch.name
+        @extensions[patch.mod] << patch if patch.core_ext?
+        patch.refineables.each { |r| @refined[r] << patch } unless patch.native?
+      end
+    end
+
     class << self
+      STRATEGIES = %i[refine core_ext].freeze
+
+      attr_reader :strategy
+
+      def strategy=(val)
+        raise ArgumentError, "Unknown strategy: #{val}. Available: #{STRATEGIES.join(",")}" unless STRATEGIES.include?(val)
+        @strategy = val
+      end
+
+      def refine?
+        strategy == :refine
+      end
+
+      def core_ext?
+        strategy == :core_ext
+      end
+
+      def patch(*args, **kwargs, &block)
+        patches << Patch.new(*args, **kwargs, &block)
+      end
+
       # Inject `using RubyNext` at the top of the source code
       def inject!(contents)
         if contents.frozen?
@@ -12,7 +125,14 @@ module RubyNext
         end
         contents
       end
+
+      def patches
+        @patches ||= Patches.new
+      end
     end
+
+    # Use refinements by default
+    self.strategy = :refine
   end
 end
 
@@ -30,5 +150,33 @@ require_relative "core/array/difference_union_intersection"
 
 require_relative "core/hash/merge"
 
+require_relative "core/string/split"
+
+require_relative "core/unboundmethod/bind_call"
+
+require_relative "core/time/floor"
+require_relative "core/time/ceil"
+
 # Core extensions required for pattern matching
-require_relative "core/pattern_matching"
+# Required for pattern matching with refinements
+unless defined?(NoMatchingPatternError)
+  class NoMatchingPatternError < RuntimeError
+  end
+end
+
+require_relative "core/constants/no_matching_pattern_error"
+require_relative "core/array/deconstruct"
+require_relative "core/hash/deconstruct_keys"
+require_relative "core/struct/deconstruct"
+require_relative "core/struct/deconstruct_keys"
+
+# Generate refinements
+RubyNext.module_eval do
+  RubyNext::Core.patches.refined.each do |mod, patches|
+    refine mod do
+      patches.each do |patch|
+        module_eval(patch.body, *patch.location)
+      end
+    end
+  end
+end

data/lib/ruby-next/core/array/deconstruct.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+RubyNext::Core.patch Array, method: :deconstruct, version: "2.7" do
+  <<~RUBY
+    def deconstruct
+      self
+    end
+  RUBY
+end
+
+# We need to hack `respond_to?` in Ruby 2.5, since it's not working with refinements
+if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.6")
+  RubyNext::Core.patch refineable: Array, name: "ArrayRespondToDeconstruct", method: :deconstruct, version: "2.7" do
+    <<~RUBY
+      def respond_to?(mid, *)
+        return true if mid == :deconstruct
+        super
+      end
+    RUBY
+  end
+end

data/lib/ruby-next/core/array/difference_union_intersection.rb

@@ -1,31 +1,25 @@
 # frozen_string_literal: true
 
-unless [].respond_to?(:union)
-  RubyNext.module_eval do
-    refine Array do
-      def union(*others)
-        others.reduce(Array.new(self).uniq) { |acc, arr| acc | arr }
-      end
+RubyNext::Core.patch Array, method: :union, version: "2.6" do
+  <<~RUBY
+    def union(*others)
+      others.reduce(Array.new(self).uniq) { |acc, arr| acc | arr }
     end
-  end
+  RUBY
 end
 
-unless [].respond_to?(:difference)
-  RubyNext.module_eval do
-    refine Array do
-      def difference(*others)
-        others.reduce(Array.new(self)) { |acc, arr| acc - arr }
-      end
+RubyNext::Core.patch Array, method: :difference, version: "2.6" do
+  <<~RUBY
+    def difference(*others)
+      others.reduce(Array.new(self)) { |acc, arr| acc - arr }
     end
-  end
+  RUBY
 end
 
-unless [].respond_to?(:intersection)
-  RubyNext.module_eval do
-    refine Array do
-      def intersection(*others)
-        others.reduce(Array.new(self)) { |acc, arr| acc & arr }
-      end
+RubyNext::Core.patch Array, method: :intersection, version: "2.7" do
+  <<~RUBY
+    def intersection(*others)
+      others.reduce(Array.new(self)) { |acc, arr| acc & arr }
     end
-  end
+  RUBY
 end

data/lib/ruby-next/core/constants/no_matching_pattern_error.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# Special patch to define the error constant in generated files
+RubyNext::Core.patch Object,
+  name: "NoMatchingPatternError",
+  method: nil,
+  refineable: [],
+  version: "2.7",
+  # avoid defining the constant twice, 'causae it's already included in core
+  # we only use the contents in `ruby-next core_ext`.
+  supported: true,
+  location: [__FILE__, __LINE__ + 2] do
+  <<~RUBY
+    class NoMatchingPatternError < RuntimeError
+    end
+  RUBY
+end

data/lib/ruby-next/core/enumerable/filter.rb

@@ -1,23 +1,25 @@
 # frozen_string_literal: true
 
-unless [].respond_to?(:filter)
-  RubyNext.module_eval do
-    refine Enumerable do
-      alias filter select
-    end
+RubyNext::Core.patch Enumerable, method: :filter, version: "2.6" do
+  <<~RUBY
+    alias filter select
+  RUBY
+end
 
-    # Refine Array seprately, 'cause refining modules is vulnerable to prepend:
-    # - https://bugs.ruby-lang.org/issues/13446
-    #
-    # Also, Array also have `filter!`
-    refine Array do
-      alias filter select
-      alias filter! select!
-    end
+# Refine Array seprately, 'cause refining modules is vulnerable to prepend:
+# - https://bugs.ruby-lang.org/issues/13446
+#
+# Also, Array also have `filter!`
+RubyNext::Core.patch Array, method: :filter!, version: "2.6" do
+  <<~RUBY
+    alias filter select
+    alias filter! select!
+  RUBY
+end
 
-    refine Hash do
-      alias filter select
-      alias filter! select!
-    end
-  end
+RubyNext::Core.patch Hash, method: :filter!, version: "2.6" do
+  <<~RUBY
+    alias filter select
+    alias filter! select!
+  RUBY
 end

data/lib/ruby-next/core/enumerable/filter_map.rb

@@ -1,50 +1,38 @@
 # frozen_string_literal: true
 
-unless [].respond_to?(:filter_map)
-  module RubyNext
-    module Core
-      module EnumerableFilterMap
-        def filter_map
-          if block_given?
-            result = []
-            each do |element|
-              res = yield element
-              result << res if res
-            end
-            result
-          else
-            Enumerator.new do |yielder|
-              result = []
-              each do |element|
-                res = yielder.yield element
-                result << res if res
-              end
-              result
-            end
+# Refine Array seprately, 'cause refining modules is vulnerable to prepend:
+# - https://bugs.ruby-lang.org/issues/13446
+RubyNext::Core.patch Enumerable, method: :filter_map, version: "2.7", refineable: [Enumerable, Array] do
+  <<~RUBY
+    def filter_map
+      if block_given?
+        result = []
+        each do |element|
+          res = yield element
+          result << res if res
+        end
+        result
+      else
+        Enumerator.new do |yielder|
+          result = []
+          each do |element|
+            res = yielder.yield element
+            result << res if res
           end
+          result
         end
       end
     end
-  end
-
-  RubyNext.module_eval do
-    refine Enumerable do
-      include RubyNext::Core::EnumerableFilterMap
-    end
+  RUBY
+end
 
-    refine Enumerator::Lazy do
-      def filter_map
-        Enumerator::Lazy.new(self) do |yielder, *values|
-          result = yield(*values)
-          yielder << result if result
-        end
+RubyNext::Core.patch Enumerator::Lazy, method: :filter_map, version: "2.7" do
+  <<~RUBY
+    def filter_map
+      Enumerator::Lazy.new(self) do |yielder, *values|
+        result = yield(*values)
+        yielder << result if result
       end
     end
-
-    # Refine Array seprately, 'cause refining modules is vulnerable to prepend:
-    # - https://bugs.ruby-lang.org/issues/13446
-    refine Array do
-      include RubyNext::Core::EnumerableFilterMap
-    end
-  end
+  RUBY
 end

data/lib/ruby-next/core/enumerable/tally.rb

@@ -1,28 +1,14 @@
 # frozen_string_literal: true
 
-unless [].respond_to?(:tally)
-  module RubyNext
-    module Core
-      module EnumerableTally
-        def tally
-          each_with_object({}) do |v, acc|
-            acc[v] ||= 0
-            acc[v] += 1
-          end
-        end
+# Refine Array seprately, 'cause refining modules is vulnerable to prepend:
+# - https://bugs.ruby-lang.org/issues/13446
+RubyNext::Core.patch Enumerable, method: :tally, version: "2.7", refineable: [Enumerable, Array] do
+  <<~RUBY
+    def tally
+      each_with_object({}) do |v, acc|
+        acc[v] ||= 0
+        acc[v] += 1
       end
     end
-  end
-
-  RubyNext.module_eval do
-    refine Enumerable do
-      include RubyNext::Core::EnumerableTally
-    end
-
-    # Refine Array seprately, 'cause refining modules is vulnerable to prepend:
-    # - https://bugs.ruby-lang.org/issues/13446
-    refine Array do
-      include RubyNext::Core::EnumerableTally
-    end
-  end
+  RUBY
 end

data/lib/ruby-next/core/enumerator/produce.rb

@@ -1,22 +1,20 @@
 # frozen_string_literal: true
 
-unless Enumerator.respond_to?(:produce)
-  RubyNext.module_eval do
-    refine Enumerator.singleton_class do
-      # Based on https://github.com/zverok/enumerator_generate
-      def produce(*rest, &block)
-        raise ArgumentError, "wrong number of arguments (given #{rest.size}, expected 0..1)" if rest.size > 1
-        raise ArgumentError, "No block given" unless block
+RubyNext::Core.patch Enumerator.singleton_class, method: :produce, singleton: Enumerator, version: "2.7" do
+  <<~'RUBY'
+    # Based on https://github.com/zverok/enumerator_generate
+    def produce(*rest, &block)
+      raise ArgumentError, "wrong number of arguments (given #{rest.size}, expected 0..1)" if rest.size > 1
+      raise ArgumentError, "No block given" unless block
 
-        Enumerator.new(Float::INFINITY) do |y|
-          val = rest.empty? ? yield() : rest.pop
+      Enumerator.new(Float::INFINITY) do |y|
+        val = rest.empty? ? yield() : rest.pop
 
-          loop do
-            y << val
-            val = yield(val)
-          end
+        loop do
+          y << val
+          val = yield(val)
         end
       end
     end
-  end
+  RUBY
 end