Kenma

gem 'kenma'

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

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