kenma 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4ede02761e159c70e342821d38b8cea9d672e09b7c92ce66b9c21d20933e2b0a
+  data.tar.gz: 7a905f6782bc2189df6568ee2ea4c69a5ac5a2ca09da7b49b007094053d0bb1d
+SHA512:
+  metadata.gz: bc4f726c242c41f70d66496585bfe5eac8b79426887e1806f17783f7b714e762e0da817fbcbc5d8d49390c58429b587cb07cebe993bae8058a5874ca91f32aa7
+  data.tar.gz: f21744fcc6f3dddef6c7768277b0fb9fb45607c43d06328162ee27bb5c9159c8fbb7506db2bd0c36583fca5b3b3b3fd88a5b155d039a2256097fa3e0e7e81a62

data/.github/workflows/kenma.yml

@@ -0,0 +1,23 @@
+name: Ruby CI
+
+on: [push, pull_request]
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        ruby-version: [2.6.4, 2.7.0, 2.7.2, 3.0.1]
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Ruby ${{ matrix.ruby-version }}
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+      - name: Install dependencies
+        run: bundle install
+      - name: Run tests
+        run: bundle exec rake

data/.github/workflows/main.yml

@@ -0,0 +1,18 @@
+name: Ruby
+
+on: [push,pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 3.0.1
+    - name: Run the default task
+      run: |
+        gem install bundler -v 2.2.15
+        bundle install
+        bundle exec rake

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in kenma.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"
+gem "super_diff"
+gem "rensei", github: "osyo-manga/gem-rensei", branch: :master

data/README.md

@@ -0,0 +1,119 @@
+[![Ruby CI](https://github.com/osyo-manga/gem-kenma/actions/workflows/kenma.yml/badge.svg)](https://github.com/osyo-manga/gem-kenma/actions/workflows/kenma.yml)
+
+# Kenma
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'kenma'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install kenma
+
+## Usage
+
+### Macro function
+
+```ruby
+require "kenma"
+
+using Kenma::Refine::Source
+
+# Define Macro module
+module CatMacro
+  using Kenma::Macroable
+
+  # Define Macro function
+  # Macro function is
+  #   input  -> RubyVM::AST::Node
+  #   output -> RubyVM::AST::Node
+  def cat!(num = ast { 1 })
+    # ast return AST::Node in block
+    # $num is bind variable `num`
+    ast { "にゃーん" * $num }
+  end
+  macro_function :cat!
+end
+
+body = proc {
+  use_macro! CatMacro
+  puts cat!
+  puts cat!(3)
+}
+# Apply Macro functions
+puts Kenma.compile_of(body).source
+# => begin puts(("にゃーん" * 1)); puts(("にゃーん" * 3)); end
+```
+
+### Macro defines
+
+```ruby
+require "kenma"
+
+using Kenma::Refine::Source
+using Kenma::Refine::Nodable
+
+# Macro module
+#   defined macros in
+#   priority is
+#     node macro > function macro > pattern macro
+module MyMacro
+  using Kenma::Macroable
+
+  # Node macro
+  # Replace the AST of a specific node with the AST of the return value
+  def frozen_string(str_node, parent_node)
+    ast { $str_node.freeze }
+  end
+  macro_node :STR, :frozen_string
+
+  # Function macro
+  # Replace the AST from which the function is called with the AST of the return value
+  def cat!(num_not = ast { 1 })
+    ast { "にゃーん" * $num_not }
+  end
+  macro_function :cat!
+
+  # Pattern macro
+  # Replace the AST that matches the pattern with the AST of the return value
+  def frozen(node, name:, value:)
+    ast { $name = $value.freeze }
+  end
+  macro_pattern pat { $name = $value }, :frozen
+end
+
+
+body = proc {
+  use_macro! MyMacro
+
+  "にゃーん" # => "にゃーん".freeze
+
+  puts cat!     # => puts "にゃーん"
+  puts cat!(3)  # => puts "にゃーん" * 3
+
+  value = [1, 2, 3]  # => value = [1, 2, 3].freeze
+}
+
+result = Kenma.compile_of(body)
+puts result.source
+# => begin "にゃーん".freeze(); puts(("にゃーん" * 1)); puts(("にゃーん" * 3)); (value = [1, 2, 3].freeze()); end
+```
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/osyo-manga/gem-kenma.

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kenma"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/bundle_install_all.sh

@@ -0,0 +1,9 @@
+#!/bin/bash -ex
+RBENV_VERSION=2.6.4 bundle install
+RBENV_VERSION=2.7.0 bundle install
+RBENV_VERSION=2.7.2 bundle install
+RBENV_VERSION=2.7.3 bundle install
+RBENV_VERSION=2.7.4 bundle install
+RBENV_VERSION=3.0.0 bundle install
+RBENV_VERSION=3.0.1 bundle install
+RBENV_VERSION=3.1.0-dev bundle install

data/kenma.gemspec

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "lib/kenma/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "kenma"
+  spec.version       = Kenma::VERSION
+  spec.authors       = ["manga_osyo"]
+  spec.email         = ["manga.osyo@gmail.com"]
+
+  spec.summary       = "AST Macro in Ruby"
+  spec.description   = "AST Macro in Ruby"
+  spec.homepage      = "https://github.com/osyo-manga/gem-kenma"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, checkout our
+  # guide at: https://bundler.io/guides/creating_gem.html
+
+  spec.add_dependency "rensei", "~> 0.2.0"
+end

data/lib/kenma/iteration.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "./refine/nodable.rb"
+
+module Kenma
+  module Iteration
+    using Kenma::Refine::Nodable
+
+    KENMA_ITERATION_MACRO_EMPTY_NODE = Object.new.freeze
+    private_constant :KENMA_ITERATION_MACRO_EMPTY_NODE
+
+    module_function
+
+    def each_node(node, &block)
+      return Enumerator.new { |y|
+        each_node(node) { |node|
+          y << node
+        }
+      } unless block
+      return node unless node.node?
+
+      node.children.map { |node|
+        each_node(node) { |child| block.call(child, node) }
+      }
+      block.call(node) if block
+    end
+
+    def convert_node(node, parent = nil, &block)
+      return node unless node.node?
+
+      children = node.children
+      converted_children = children
+        .map { |child| convert_node(child, node) { |node, parent| block.call(node, parent) || KENMA_ITERATION_MACRO_EMPTY_NODE } }
+        .reject { |it| KENMA_ITERATION_MACRO_EMPTY_NODE == it }
+
+      if converted_children == children
+        node
+      else
+        [node.type, converted_children]
+      end.then { |node| block.call(node, parent) }
+    end
+
+    def find_convert_node(node, pat, &block)
+      convert_node(node) { |node|
+        if result = pat === node
+          block.call(node, **result)
+        else
+          node
+        end
+      }
+    end
+  end
+end

data/lib/kenma/macro/basic.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "../macroable.rb"
+
+module Kenma
+  module Macro
+    module Basic
+      using Kenma::Macroable
+      using Kenma::Refine::Source
+      using Kenma::Refine::Nodable
+
+      def symbolify!(args)
+        [:LIT, [args.source.to_sym]]
+      end
+      macro_function :symbolify!
+
+      def stringify!(args)
+        if args.respond_to?(:source)
+          [:STR, [args.source]]
+        else
+          [:STR, [args.to_s]]
+        end
+      end
+      macro_function :stringify!
+
+      def unstringify!(args)
+        RubyVM::AbstractSyntaxTree.parse(bind.eval(args.source)).children.last
+      end
+      macro_function :unstringify!
+
+      def node_bind!(args)
+        bind.eval(args.source)
+      end
+      macro_function :node_bind!
+
+      def eval!(args)
+        data = bind.eval(args.source)
+        RubyVM::AbstractSyntaxTree.parse(data.inspect).children.last
+      end
+      macro_function :eval!
+
+      # $node
+      def NODE_GVAR(node, parent)
+        name = node.children.first.to_s.delete_prefix("$").to_sym
+        if bind.local_variable_defined?(name)
+          bind.local_variable_get(name)
+        else
+          node
+        end
+      end
+
+      # $left = right
+      def NODE_GASGN(node, parent)
+        left, right = node.children
+        name = left.to_s.delete_prefix("$").to_sym
+        if bind.local_variable_defined?(name)
+          [:GASGN, [bind.local_variable_get(name), right]]
+        else
+          node
+        end
+      end
+    end
+  end
+end

data/lib/kenma/macro/frozen_constant.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "../macroable.rb"
+require_relative "./macro_node.rb"
+
+module Kenma
+  module Macro
+    module FrozenConstant
+      using Kenma::Macroable
+
+      def _frozen_constant_decl(node, parent)
+        left, right = node.children
+        ast { $left = $right.freeze }
+      end
+      macro_node :CDECL, :_frozen_constant_decl
+    end
+  end
+end

data/lib/kenma/macro/frozen_string_literal.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "../macroable.rb"
+
+module Kenma
+  module Macro
+    module FrozenStringLiteral
+      using Kenma::Macroable
+
+      def frozen_string(node, parent)
+        ast { $node.freeze }
+      end
+      macro_node :STR, :frozen_string
+    end
+  end
+end

data/lib/kenma/macro/macro_function.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "../macroable.rb"
+require_relative "./macro_node.rb"
+
+module Kenma
+  module Macroable
+    refine Module do
+      def macro_function(name)
+        macro_functions << name
+        module_function name
+        extend Kenma::Macroable
+      end
+
+      def macro_functions
+        @macro_functions ||= []
+      end
+    end
+  end
+
+  module Macro
+    module MacroFunction
+      using Kenma::Macroable
+      using Kenma::Refine::Source
+
+      using Module.new {
+        refine MacroFunction do
+          using Kenma::Macroable
+          def macro_functions
+            singleton_class.ancestors.grep(Kenma::Macroable).map(&:macro_functions).inject([], &:+)
+          end
+
+          def send_macro_function(method_name, args, &block)
+            converted_args = compile(args)
+            send(method_name, *converted_args&.children&.compact, &block)
+          end
+        end
+      }
+
+      private
+
+      def _FCALL_send_macro_function(node, parent)
+        return node if parent&.type == :ITER
+        method_name, args = node.children
+        if macro_functions.include?(method_name)
+          send_macro_function(method_name, args)
+        else
+          node
+        end
+      end
+      macro_node :FCALL, :_FCALL_send_macro_function
+
+      def _ITER_send_macro_function(node, parent)
+        fcall, scope = node.children
+        method_name, args = fcall.children
+        if macro_functions.include?(method_name)
+          send_macro_function(method_name, args) { scope }
+        else
+          node
+        end
+      end
+      macro_node :ITER, :_ITER_send_macro_function
+    end
+  end
+end

data/lib/kenma/macro/macro_node.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "../macroable.rb"
+
+module Kenma
+  module Macroable
+    refine Module do
+      def macro_node(node_type, name)
+        define_method("NODE_#{node_type}") { |node, parent|
+          send(name, node, parent)
+        }
+      end
+    end
+  end
+end

data/lib/kenma/macro/macro_pattern.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative "../macroable.rb"
+require_relative "./macro_node.rb"
+
+module Kenma
+  using Kenma::Refine::Nodable
+
+  class PatternCapture < Struct.new(:pat_node)
+    def initialize(pat_node)
+      self.pat_node = pat_node
+    end
+
+    def match(node)
+      _match(node, pat_node)
+    end
+    alias_method :===, :match
+
+    private
+
+    def _match(node, pat)
+      return {} if node == pat
+      return nil if node.nil? || pat.nil?
+      return nil if !node.node? || !pat.node?
+
+      if pat.type == :GASGN && node.type.to_s =~ /ASGN|CDECL/
+        match_result = _match(node.children.last, pat.children.last)
+        if match_result
+          tag = pat.children.first.to_s.delete_prefix("$").to_sym
+          { tag => node.children.first }.merge(_match(node.children.last, pat.children.last))
+        else
+          nil
+        end
+      elsif pat.type == :GVAR
+        tag = pat.children.first.to_s.delete_prefix("$").to_sym
+        { tag => node }
+      # Add Support: pat { [*$node] } === ast { [a, b, c] } # => { node: [a, b, c] }
+      # Not Support: pat { [$first, *$node] } === ast { [a, b, c] } # => nil
+      elsif pat.type === :SPLAT && pat.children.first.type == :GVAR
+        tag = pat.children.first.children.first.to_s.delete_prefix("$").to_sym
+        { tag => node }
+      elsif node.type == pat.type && node.children.size == pat.children.size
+        node.children.zip(pat.children).inject({}) { |result, (src, pat)|
+          if match_result = _match(src, pat)
+            result.merge(match_result)
+          else
+            break nil
+          end
+        }
+      else
+        nil
+      end
+    end
+  end
+
+  module Macroable
+    refine Kernel do
+      def pat(&block)
+        pat_node(RubyVM::AbstractSyntaxTree.of(block).children.last)
+      end
+
+      def pat_node(node)
+        PatternCapture.new(node)
+      end
+    end
+
+    refine Module do
+      def macro_pattern(pattern, name)
+        macro_patterns[name] = pattern
+        extend Kenma::Macroable
+      end
+
+      def macro_patterns
+        @macro_patterns ||= {}
+      end
+    end
+  end
+
+  module Macro
+    module MacroPattern
+      using Kenma::Macroable
+      using Kenma::Refine::Source
+
+      using Module.new {
+        refine MacroPattern do
+          using Kenma::Macroable
+          def macro_patterns
+            singleton_class.ancestors.grep(Kenma::Macroable).map(&:macro_patterns).inject({}, &:merge)
+          end
+        end
+      }
+
+      def node_missing(node, parent)
+        macro = macro_patterns.lazy.reverse_each.map { |name, pat| [name, pat.match(node)] }.find { |name, captured| captured }
+        if macro
+          if macro[1].empty?
+            send(macro[0], node)
+          else
+            send(macro[0], node, **macro[1])
+          end
+        else
+          super(node, parent)
+        end
+      end
+    end
+  end
+end

data/lib/kenma/macro/use_macro.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "../macroable.rb"
+require_relative "./macro_function.rb"
+
+module Kenma
+  module Macro
+    module UseMacro
+      using Kenma::Macroable
+      using Kenma::Refine::Nodable
+      using Kenma::Refine::Source
+
+      def initialize(context = {})
+        super
+        extend *use_macros.reverse unless use_macros.empty?
+      end
+
+      def use_macro!(node)
+        macro_mod = bind.eval(node.source)
+        use_macros << macro_mod
+        extend macro_mod
+        nil
+      end
+      macro_function :use_macro!
+
+      private
+
+      def use_macro(mod)
+
+      end
+
+      def use_macros
+        scope_context[:use_macros] ||= []
+      end
+
+      def scope_context_switch(context, &block)
+        super(context) { |converter|
+          converter.extend *use_macros.reverse unless use_macros.empty?
+          block.call(converter)
+        }
+      end
+    end
+  end
+end

data/lib/kenma/macroable.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "./node_converter.rb"
+require_relative "./refine/node_to_a.rb"
+
+module Kenma
+  module Macroable
+    refine Kernel do
+      def ast(context = {}, &body)
+        bind = body.binding unless context[:bind]
+        node = RubyVM::AbstractSyntaxTree.of(body).children.last
+        Kenma.compile(node, { bind: bind }.merge(context))
+      end
+    end
+
+    # TODO: duplicate Reifne::Nodable
+    refine Array do
+      def type; self[0]; end
+      def children; self[1]; end
+    end
+  end
+end

data/lib/kenma/node_converter.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "./refine/source.rb"
+require_relative "./refine/nodable.rb"
+require_relative "./refine/node_iteration.rb"
+
+module Kenma
+  class NodeConverter
+    using Kenma::Refine::Source
+    using Kenma::Refine::Nodable
+
+    def initialize(context = {})
+      @scope_context = context
+    end
+
+    def convert(node)
+      _convert(node) { |node, parent|
+        method_name = "NODE_#{node.type}"
+        send_node(method_name, node, parent)
+      }
+    end
+
+    private
+
+    KENMA_MACRO_EMPTY_NODE = Object.new.freeze
+    private_constant :KENMA_MACRO_EMPTY_NODE
+
+    attr_reader :bind
+    attr_reader :scope_context
+
+    def bind
+      scope_context[:bind]
+    end
+
+    def scope_context_switch(context, &block)
+      self.class.new(scope_context.merge(context)).then(&block)
+    end
+
+    def _convert(node, &block)
+      return node unless node.node?
+
+      if node.type == :SCOPE
+        return scope_context_switch(scope_context) { |converter|
+          children = [*node.children.take(node.children.size-1), converter.convert(node.children.last)]
+                      .reject { |it| KENMA_MACRO_EMPTY_NODE == it }
+          send_node(:NODE_SCOPE, [:SCOPE, children], node)
+        }
+      end
+
+      children = node.children
+      converted_children = children
+        .map { |node| _convert(node) { |child| block.call(child, node) || KENMA_MACRO_EMPTY_NODE } }
+        .reject { |it| KENMA_MACRO_EMPTY_NODE == it }
+
+      if converted_children == children
+        node
+      else
+        [node.type, converted_children]
+      end.then { |node| block.call(node, nil) }
+    end
+
+    def send_node(method_name, node, parent)
+      if respond_to?(method_name, true)
+        result = send(method_name, node, parent)
+        if result == node
+          node_missing(node, parent)
+        else
+          result
+        end
+      else
+        node_missing(node, parent)
+      end
+    end
+
+    def node_missing(node, parent)
+      node
+    end
+  end
+end

data/lib/kenma/pre_processor.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "./node_converter.rb"
+require_relative "./macro/use_macro.rb"
+require_relative "./macro/basic.rb"
+require_relative "./macro/macro_function.rb"
+require_relative "./macro/macro_node.rb"
+require_relative "./macro/macro_pattern.rb"
+
+module Kenma
+  class PreProcessor < Kenma::NodeConverter
+    include Macro::UseMacro
+    include Macro::Basic
+    include Macro::MacroFunction
+    include Macro::MacroPattern
+
+    alias_method :compile, :convert
+
+    def self.compile(node, context = {})
+      new(context).compile(node)
+    end
+
+    def self.compile_of(body, context = {})
+      bind = body.binding unless context[:bind]
+      compile(RubyVM::AbstractSyntaxTree.of(body), { bind: bind }.merge(context))
+    end
+  end
+end

data/lib/kenma/refine/nodable.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "rensei"
+
+module Kenma
+  module Refine
+    module Nodable
+      refine Object do
+        def node?; false; end
+      end
+
+      refine RubyVM::AbstractSyntaxTree::Node do
+        def node?
+          true
+        end
+      end
+
+      refine Hash do
+        def type; self[:type]; end
+
+        def children; self[:children]; end
+
+        def node?; !empty?; end
+      end
+
+      refine Array do
+        def type; self[0]; end
+
+        def children; self[1]; end
+
+        def node?
+          self.size == 2 &&
+          self[0].kind_of?(Symbol) && self[0] == self[0].upcase &&
+          self[1].kind_of?(Array)
+        end
+      end
+    end
+  end
+end

data/lib/kenma/refine/node_iteration.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "rensei"
+require_relative "./nodable.rb"
+require_relative "../iteration.rb"
+
+module Kenma
+  module Refine
+    module NodeIteration
+      def each_node(&block)
+        Kenma::Iteration.each_node(self, &block)
+      end
+
+      def convert_node(&block)
+        Kenma::Iteration.convert_node(self, &block)
+      end
+
+      def find_convert_node(pat, &block)
+        Kenma::Iteration.find_convert_node(self, pat, &block)
+      end
+
+      refine Array do
+        include Kenma::Refine::NodeIteration
+      end
+
+      refine RubyVM::AbstractSyntaxTree::Node do
+        include Kenma::Refine::NodeIteration
+      end
+    end
+  end
+end

data/lib/kenma/refine/node_to_a.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "rensei"
+require_relative "./nodable.rb"
+
+module Kenma
+  module Refine
+    module NodeToArray
+      refine RubyVM::AbstractSyntaxTree::Node do
+        using Module.new {
+          [
+            Object,
+            NilClass,
+            FalseClass,
+            TrueClass,
+            String,
+            Hash,
+            Array,
+            Symbol,
+            Numeric,
+            Regexp,
+          ].each { |klass|
+            refine klass do
+              def to_a(*)
+                self
+              end
+            end
+
+          }
+        }
+
+        def to_a
+          [type, children.map { |it| it.to_a }]
+        end
+      end
+
+      refine Array do
+        using Module.new {
+          [
+            Object,
+            NilClass,
+            FalseClass,
+            TrueClass,
+            String,
+            Hash,
+            Symbol,
+            Numeric,
+            Regexp,
+          ].each { |klass|
+            refine klass do
+              def to_a(*)
+                self
+              end
+            end
+
+          }
+        }
+
+        using NodeToArray
+
+        def to_a(*)
+          map { |it| it.to_a }
+        end
+      end
+    end
+  end
+end

data/lib/kenma/refine/source.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "rensei"
+
+module Kenma
+  module Refine
+    module Source
+      refine RubyVM::AbstractSyntaxTree::Node do
+        if RUBY_VERSION >= "3.1.0"
+          def source
+            super.tap { |it|
+              break Rensei.unparse(self) if it.nil?
+            }
+          end
+        else
+          def source
+            Rensei.unparse(self)
+          end
+        end
+      end
+
+      refine Hash do
+        def source; Rensei.unparse(self.dup); end
+      end
+
+      refine Array do
+        def source; Rensei.unparse(self.dup); end
+      end
+    end
+  end
+end

data/lib/kenma/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Kenma
+  VERSION = "0.1.0"
+end

data/lib/kenma.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "./kenma/version"
+require_relative "./kenma/pre_processor.rb"
+require_relative "./kenma/iteration.rb"
+
+module Kenma
+  using Kenma::Refine::Source
+
+  def self.compile(body, context = {})
+    PreProcessor.compile(body, context)
+  end
+
+  def self.compile_of(body, context = {})
+    PreProcessor.compile_of(body, context)
+  end
+
+  def self.macro_eval(context = {}, &body)
+    body.binding.eval Kenma.compile_of(body).source
+  end
+end

data/rake_spec_all.sh

@@ -0,0 +1,6 @@
+#!/bin/bash -ex
+RBENV_VERSION=2.6.4 bundle exec rake spec
+RBENV_VERSION=2.7.0 bundle exec rake spec
+RBENV_VERSION=2.7.2 bundle exec rake spec
+RBENV_VERSION=3.0.1 bundle exec rake spec
+RBENV_VERSION=3.1.0-dev bundle exec rake spec

data/sample/chaining_comparison_operators_macro.rb

@@ -0,0 +1,56 @@
+# a < b < c
+# ↓
+# a < b && b < c
+require "kenma"
+
+using Kenma::Refine::Source
+
+module ChainingComparisonOperatorsMacro
+  using Kenma::Macroable
+  using Kenma::Refine::NodeToArray
+
+  def chaining_comparison_operators(node, parent)
+    case node.to_a
+    in [:OPCALL, [[:OPCALL, [left, op1, [:LIST, [middle, nil]]]], op2, [:LIST, [right, nil]]]]
+      ast { $left.send(eval!(op1), $middle) && $middle.send(eval!(op2), $right) }
+    else
+      node
+    end
+  end
+  macro_node :OPCALL, :chaining_comparison_operators
+end
+
+body = proc {
+  use_macro! ChainingComparisonOperatorsMacro
+
+  0 <= value < 10
+}
+
+result = Kenma.compile_of(body)
+puts result.source
+
+body = proc {
+  use_macro! ChainingComparisonOperatorsMacro
+
+  def check(value)
+    # to 0 <= input && input < 10
+    if 0 <= value < 10
+      "OK"
+    else
+      "NG"
+    end
+  end
+  check(10)
+
+  puts check(5)   # => "OK"
+  puts check(20)  # => "NG"
+}
+result = Kenma.compile_of(body)
+puts result.source
+# => begin def check(value)
+#      (if (0.send(:<=, value) && value.send(:<, 10))
+#      "OK"
+#    else
+#      "NG"
+#    end)
+#    end; check(10); puts(check(5)); puts(check(20)); end

data/sample/debug_macro.rb

@@ -0,0 +1,24 @@
+# debug! 1 + 2
+# ↓
+# puts "1 + 2 # => #{1 + 2}"
+require "kenma"
+
+using Kenma::Refine::Source
+
+module DebugMacro
+  using Kenma::Macroable
+
+  def debug!(expr)
+    ast { puts "#{stringify! $expr} # => #{$expr}" }
+  end
+  macro_function :debug!
+end
+
+body = proc {
+  use_macro! DebugMacro
+
+  debug! 1 + 2 + 3
+  debug! [1, 2, 3].map { _1 + _1 }
+}
+puts Kenma.compile_of(body).source
+# => begin puts("#{"((1 + 2) + 3)"} # => #{((1 + 2) + 3)}"); puts("#{"[1, 2, 3].map() { (_1 + _1) }"} # => #{[1, 2, 3].map() { (_1 + _1) }}"); end

data/sample/multi_using_macro.rb

@@ -0,0 +1,26 @@
+require "kenma"
+
+using Kenma::Refine::Source
+
+module MultiUsingMacro
+  using Kenma::Macroable
+  using Kenma::Refine::NodeToArray
+
+  def using(*args)
+    args.compact.inject(ast { {} }) { |result, name|
+      ast { $result; using $name }
+    }
+  end
+  macro_function :using
+end
+
+
+body = proc {
+  use_macro! MultiUsingMacro
+
+  using Hoge, Foo, Bar
+}
+
+result = Kenma.compile_of(body)
+puts result.source
+# => begin begin begin {}; using(Hoge); end; using(Foo); end; using(Bar); end;

data/sample/shorthand_hash_literal_macro.rb

@@ -0,0 +1,24 @@
+require "kenma"
+
+using Kenma::Refine::Source
+
+module ShorthandHashLiteralMacro
+  using Kenma::Macroable
+
+  def shorthand_hash_literal(node, args:)
+    args.children.compact.inject(ast { {} }) { |result, name|
+      ast { $result.merge({ symbolify!($name) => $name }) }
+    }
+  end
+  macro_pattern pat { ![*$args] }, :shorthand_hash_literal
+end
+
+body = proc {
+  use_macro! ShorthandHashLiteralMacro
+
+  ![a, b, c]
+}
+
+result = Kenma.compile_of(body)
+puts result.source
+# => {}.merge({ a: a }).merge({ b: b }).merge({ c: c });

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: kenma
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- manga_osyo
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-09-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rensei
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+description: AST Macro in Ruby
+email:
+- manga.osyo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/kenma.yml"
+- ".github/workflows/main.yml"
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- bundle_install_all.sh
+- kenma.gemspec
+- lib/kenma.rb
+- lib/kenma/iteration.rb
+- lib/kenma/macro/basic.rb
+- lib/kenma/macro/frozen_constant.rb
+- lib/kenma/macro/frozen_string_literal.rb
+- lib/kenma/macro/macro_function.rb
+- lib/kenma/macro/macro_node.rb
+- lib/kenma/macro/macro_pattern.rb
+- lib/kenma/macro/use_macro.rb
+- lib/kenma/macroable.rb
+- lib/kenma/node_converter.rb
+- lib/kenma/pre_processor.rb
+- lib/kenma/refine/nodable.rb
+- lib/kenma/refine/node_iteration.rb
+- lib/kenma/refine/node_to_a.rb
+- lib/kenma/refine/source.rb
+- lib/kenma/version.rb
+- rake_spec_all.sh
+- sample/chaining_comparison_operators_macro.rb
+- sample/debug_macro.rb
+- sample/multi_using_macro.rb
+- sample/shorthand_hash_literal_macro.rb
+homepage: https://github.com/osyo-manga/gem-kenma
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.0.dev
+signing_key:
+specification_version: 4
+summary: AST Macro in Ruby
+test_files: []