ruby-next 0.3.0 → 0.4.0

data/lib/ruby-next/commands/nextify.rb

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-require "pathname"
-
-module RubyNext
-  module Commands
-    class Nextify < Base
-      using RubyNext
-
-      attr_reader :lib_path, :paths, :out_path, :min_version, :single_version
-
-      def run
-        log "RubyNext core strategy: #{RubyNext::Core.strategy}"
-        paths.each do |path|
-          contents = File.read(path)
-          transpile path, contents
-        end
-      end
-
-      def parse!(args)
-        print_help = false
-        @min_version = MIN_SUPPORTED_VERSION
-        @single_version = false
-
-        optparser = base_parser do |opts|
-          opts.banner = "Usage: ruby-next nextify DIRECTORY_OR_FILE [options]"
-
-          opts.on("-o", "--output=OUTPUT", "Specify output directory or file or stdout") do |val|
-            @out_path = val
-          end
-
-          opts.on("--min-version=VERSION", "Specify the minimum Ruby version to support") do |val|
-            @min_version = Gem::Version.new(val)
-          end
-
-          opts.on("--single-version", "Only create one version of a file (for the earliest Ruby version)") do
-            @single_version = true
-          end
-
-          opts.on("--enable-method-reference", "Enable reverted method reference syntax (requires custom parser)") do
-            require "ruby-next/language/rewriters/method_reference"
-            Language.rewriters << Language::Rewriters::MethodReference
-          end
-
-          opts.on("--[no-]refine", "Do not inject `using RubyNext`") do |val|
-            Core.strategy = :core_ext unless val
-          end
-
-          opts.on("-h", "--help", "Print help") do
-            print_help = true
-          end
-        end
-
-        @lib_path = args[0]
-
-        if print_help
-          $stdout.puts optparser.help
-          exit 0
-        end
-
-        unless lib_path&.then(&File.method(:exist?))
-          $stdout.puts optparser.help
-          exit 2
-        end
-
-        optparser.parse!(args)
-
-        @paths =
-          if File.directory?(lib_path)
-            Dir[File.join(lib_path, "**/*.rb")]
-          elsif File.file?(lib_path)
-            [lib_path].tap do |_|
-              @lib_path = File.dirname(lib_path)
-            end
-          end
-      end
-
-      private
-
-      def transpile(path, contents, version: min_version)
-        rewriters = Language.rewriters.select { |rw| rw.unsupported_version?(version) }
-
-        context = Language::TransformContext.new
-        new_contents = Language.transform contents, context: context, rewriters: rewriters
-
-        return unless context.dirty?
-
-        versions = context.sorted_versions
-        version = versions.shift
-
-        # First, store already transpiled contents in the minimum required version dir
-        save new_contents, path, version
-
-        return if versions.empty? || single_version?
-
-        # Then, generate the source code for the next version
-        transpile path, contents, version: version
-      end
-
-      def save(contents, path, version)
-        return $stdout.puts(contents) if out_path == "stdout"
-
-        paths = [Pathname.new(path).relative_path_from(Pathname.new(lib_path))]
-
-        paths.unshift(version.segments[0..1].join(".")) unless single_version?
-
-        next_path =
-          if out_path
-            if out_path.end_with?(".rb")
-              out_path
-            else
-              File.join(out_path, *paths)
-            end
-          else
-            File.join(
-              lib_path,
-              RUBY_NEXT_DIR,
-              *paths
-            )
-          end
-
-        FileUtils.mkdir_p File.dirname(next_path)
-
-        File.write(next_path, contents)
-
-        log "Generated: #{next_path}"
-      end
-
-      alias single_version? single_version
-    end
-  end
-end

data/lib/ruby-next/core.rb

@@ -1,182 +0,0 @@
-# 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?
-          contents = contents.sub(/^(\s*[^#\s].*)/, 'using RubyNext;\1')
-        else
-          contents.sub!(/^(\s*[^#\s].*)/, 'using RubyNext;\1')
-        end
-        contents
-      end
-
-      def patches
-        @patches ||= Patches.new
-      end
-    end
-
-    # Use refinements by default
-    self.strategy = :refine
-  end
-end
-
-require_relative "core/kernel/then"
-
-require_relative "core/proc/compose"
-
-require_relative "core/enumerable/tally"
-require_relative "core/enumerable/filter"
-require_relative "core/enumerable/filter_map"
-
-require_relative "core/enumerator/produce"
-
-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
-# 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

@@ -1,21 +0,0 @@
-# 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,25 +0,0 @@
-# frozen_string_literal: true
-
-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
-  RUBY
-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
-  RUBY
-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
-  RUBY
-end

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

@@ -1,17 +0,0 @@
-# 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,25 +0,0 @@
-# frozen_string_literal: true
-
-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!`
-RubyNext::Core.patch Array, method: :filter!, version: "2.6" do
-  <<~RUBY
-    alias filter select
-    alias filter! select!
-  RUBY
-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,38 +0,0 @@
-# frozen_string_literal: true
-
-# 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
-  RUBY
-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
-  RUBY
-end