ruby-next-core 0.2.0

data/lib/ruby-next/cli.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "ruby-next"
+require "ruby-next/language"
+
+require "ruby-next/commands/base"
+require "ruby-next/commands/nextify"
+
+module RubyNext
+  # Command line interface for RubyNext
+  class CLI
+    class << self
+      attr_accessor :verbose
+    end
+
+    self.verbose = false
+
+    COMMANDS = {
+      "nextify" => Commands::Nextify
+    }.freeze
+
+    def initialize
+    end
+
+    def run(args = ARGV)
+      maybe_print_version(args)
+
+      command = args.shift
+
+      raise "Command must be specified!" unless command
+
+      COMMANDS.fetch(command) do
+        raise "Unknown command: #{command}. Available commands: #{COMMANDS.keys.join(",")}"
+      end.run(args)
+    end
+
+    private
+
+    def maybe_print_version(args)
+      args = args.dup
+      begin
+        OptionParser.new do |opts|
+          opts.banner = "Usage: ruby-next COMMAND [options]"
+
+          opts.on("-v", "--version", "Print version") do
+            STDOUT.puts RubyNext::VERSION
+            exit 0
+          end
+        end.parse!(args)
+      rescue OptionParser::InvalidOption
+        # skip and pass all args to the command's parser
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module RubyNext
+  module Commands
+    class Base
+      class << self
+        def run(args)
+          new(args).run
+        end
+      end
+
+      def initialize(args)
+        parse! args
+      end
+
+      def parse!(*)
+        raise NotImplementedError
+      end
+
+      def run
+        raise NotImplementedError
+      end
+
+      def log(msg)
+        return unless CLI.verbose
+        $stdout.puts msg
+      end
+
+      def base_parser
+        OptionParser.new do |opts|
+          yield opts
+
+          opts.on("-V", "Turn on verbose mode") do
+            CLI.verbose = true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+
+using RubyNext
+
+module RubyNext
+  module Commands
+    class Nextify < Base
+      attr_reader :lib_path, :paths, :out_path, :min_version, :single_version
+
+      def run
+        paths.each do |path|
+          contents = File.read(path)
+          transpile path, contents
+        end
+      end
+
+      def parse!(args)
+        @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
+        end
+
+        @lib_path = args[0]
+
+        unless lib_path&.then(&File.method(:exist?))
+          $stdout.puts optparser.help
+          exit 0
+        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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Core
+    class << self
+      # 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
+    end
+  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"
+
+# Core extensions required for pattern matching
+require_relative "core/pattern_matching"

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

@@ -0,0 +1,31 @@
+# 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
+    end
+  end
+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
+    end
+  end
+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
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+unless [].respond_to?(:filter)
+  RubyNext.module_eval do
+    refine Enumerable do
+      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!`
+    refine Array do
+      alias filter select
+      alias filter! select!
+    end
+
+    refine Hash do
+      alias filter select
+      alias filter! select!
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# 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
+          end
+        end
+      end
+    end
+  end
+
+  RubyNext.module_eval do
+    refine Enumerable do
+      include RubyNext::Core::EnumerableFilterMap
+    end
+
+    refine Enumerator::Lazy do
+      def filter_map
+        Enumerator::Lazy.new(self) do |yielder, *values|
+          result = yield(*values)
+          yielder << result if result
+        end
+      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
+end

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

@@ -0,0 +1,28 @@
+# 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
+      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
+end

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

@@ -0,0 +1,22 @@
+# 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
+
+        Enumerator.new(Float::INFINITY) do |y|
+          val = rest.empty? ? yield() : rest.pop
+
+          loop do
+            y << val
+            val = yield(val)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby-next/core/hash/merge.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+unless {}.method(:merge).arity == -1
+  RubyNext.module_eval do
+    refine Hash do
+      def merge(*others)
+        return super if others.size == 1
+        return dup if others.size == 0
+
+        merge(others.shift).tap do |new_h|
+          others.each { |h| new_h.merge!(h) }
+        end
+      end
+    end
+  end
+end

data/lib/ruby-next/core/kernel/then.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+unless Object.new.respond_to?(:then)
+  RubyNext.module_eval do
+    # Refine object, 'cause refining modules (Kernel) is vulnerable to prepend:
+    # - https://bugs.ruby-lang.org/issues/13446
+    # - Rails added `Kernel.prepend` in 6.1: https://github.com/rails/rails/commit/3124007bd674dcdc9c3b5c6b2964dfb7a1a0733c
+    refine Object do
+      alias then yield_self
+    end
+  end
+end