maccro 0.1.0

data/lib/maccro.rb

@@ -0,0 +1,147 @@
+require_relative "./maccro/version"
+
+require_relative "./maccro/dsl"
+require_relative "./maccro/rule"
+require_relative "./maccro/code_util"
+
+require_relative "./maccro/kernel_ext"
+
+module Maccro
+  @@dic = {}
+  @@trace_global = nil
+
+  def self.register(name, before, after, under: nil, safe_reference: false)
+    # Maccro.register(:double_less_than, 'e1 < e2 < e3', 'e1 < e2 && e2 < e3')
+    # Maccro.register(:double_greater_than, 'e1 > e2 > e3', 'e1 > e2 && e2 > e3')
+    # Maccro.register(:double_greater_than, 'e1 < e2 < e3', 'e1 < e2 && e2 < e3', safe_reference: true)
+    # Maccro.register(:activerecord_where_equal, 'v1 = v2', 'v1 => v2', under: 'e.where($TARGET)')
+    if safe_reference
+      raise NotImplementedError, "TODO: implement it"
+    end      
+    @@dic[name] = Rule.new(name, before, after, under: under, safe_reference: safe_reference)
+  end
+
+  # TODO: apply_to_proc (that supports the list of local variables)
+
+  def self.apply(mojule, method, rules: @@dic, verbose: false, from_trace: false, get_code: false)
+    # Maccro.apply(X, X.instance_method(:yay), verbose: true)
+    if !method.source_location
+      raise "Native method can't be redefined"
+    end
+
+    ast = CodeUtil.proc_to_ast(method)
+    if !ast
+      if from_trace
+        # unknown and unexpected loaded ruby code (which many not have visible source)
+        return
+      else
+        raise "Failed to load AST nodes - source file may be invisible: #{method}"
+      end
+    end
+    # This node should be SCOPE node (just under DEFN or DEFS)
+    # But its code range is equal to code range of DEFN/DEFS
+    CodeUtil.extend_tree_with_wrapper(ast)
+
+    is_singleton_method = (mojule != method.owner)
+
+    first_lineno = ast.first_lineno
+    first_column = ast.first_column
+
+    iseq = nil
+    path = nil
+    source = nil
+    rewrite_method_code_range = nil
+
+    rewrite_happens = false
+    first_time = true
+
+    while rewrite_happens || first_time
+      rewrite_happens = false
+      first_time = false
+
+      rules.each_pair do |_name, this_rule|
+        try_once = ->(rule) {
+          matched = rule.match(ast)
+          next unless matched
+
+          if !source || !path || !iseq
+            source, path, iseq = CodeUtil.get_source_path_iseq(method)
+          end
+
+          source = matched.rewrite(source)
+          ast = CodeUtil.get_method_node(CodeUtil.parse_to_ast(source), method.name, first_lineno, first_column, singleton_method: is_singleton_method)
+          CodeUtil.extend_tree_with_wrapper(ast)
+          rewrite_method_code_range = CodeRange.from_node(ast)
+          rewrite_happens = true
+          try_once.call(this_rule)
+        }
+        try_once.call(this_rule)
+
+        break if rewrite_happens # to retry all rules
+      end
+    end
+
+    if source && path && rewrite_method_code_range
+      eval_source = (" " * first_column) + rewrite_method_code_range.get(source) # restore the original indentation
+      return eval_source if get_code
+      puts eval_source if verbose
+      CodeUtil.suppress_warning do
+        mojule.module_eval(eval_source, path, first_lineno)
+      end
+    end
+  end
+
+  # TODO: check visibility: private method is still private method even after module_eval?
+
+  def self.enable(target: nil, path: nil, rules: nil)
+    if target || path
+      enable_trace(target: target, path: path, rule_names: rules)
+    else
+      if rules
+        raise "Cannot enable globally with specific rules"
+      end
+      enable_trace(globally: true)
+    end
+  end
+
+  def self.enable_trace(target: nil, path: nil, globally: false, rule_names: nil)
+    if globally && @@trace_global
+      return nil
+    end
+
+    if rule_names
+      rules = rule_names.map{|n| [n, @@dic[n]] }.to_h
+    else
+      rules = @@dic
+    end
+
+    trace = TracePoint.new(:end) do |tp|
+      current_location = tp.path
+      next unless globally || target == tp.self || path == current_location
+
+      this = tp.self
+
+      methods = (
+        this.instance_methods(false).map{|m| this.instance_method(m) } +
+        this.private_instance_methods(false).map{|m| this.instance_method(m) } +
+
+        # NameError: undefined singleton method `provides?' for `Bundler::RubygemsIntegration::Legacy'
+        this.singleton_methods.map{|m| this.singleton_method(m) rescue nil }.compact
+      )
+
+      methods.each do |method|
+        source_location = method.source_location
+        next if !source_location # native method
+        next if source_location.first == '-e'
+        next if source_location.first != current_location # methods defined in other file
+        Maccro.apply(this, method, rules: rules, from_trace: true)
+      end
+    end
+
+    if globally
+      @@trace_global = trace
+    end
+    trace.enable
+    nil
+  end
+end

data/lib/maccro/builtin.rb

@@ -0,0 +1,105 @@
+require "maccro"
+
+module Maccro
+  module Builtin
+    RULES = {
+      # [before, after (, options)]
+      # options:
+      #  * under
+      #  * safe_reference
+
+      # continuing less/greater-than or equal-to
+      less_than_2: ['e1 < e2 < e3', '(e1 < e2 && e2 < e3)'],
+      less_than_or_equal_to_2: ['e1 <= e2 <= e3', '(e1 <= e2 && e2 <= e3)'],
+      less_than_and_equal_to_a: ['e1 <= e2 < e3', '(e1 <= e2 && e2 < e3)'],
+      less_than_and_equal_to_b: ['e1 < e2 <= e3', '(e1 < e2 && e2 <= e3)'],
+      greater_than_2: ['e1 > e2 > e3', '(e1 > e2 && e2 > e3)'],
+      greater_than_or_equal_to_2: ['e1 >= e2 >= e3', '(e1 >= e2 && e2 >= e3)'],
+      greater_than_and_equal_to_a: ['e1 >= e2 > e3', '(e1 >= e2 && e2 > e3)'],
+      greater_than_and_equal_to_b: ['e1 > e2 >= e3', '(e1 > e2 && e2 >= e3)'],
+
+      # mathematic intervals
+      open_interval: ['e1 < e2 < e3', '(e1 < e2 && e2 < e3)'],
+      closed_interval: ['e1 <= e2 <= e3', '(e1 <= e2 && e2 <= e3)'],
+      left_closed_interval: ['e1 <= e2 < e3', '(e1 <= e2 && e2 < e3)'],
+      right_closed_interval: ['e1 < e2 <= e3', '(e1 < e2 && e2 <= e3)'],
+
+      # ActiveRecord utilities
+      ar_where_in_range_exclusive: ['e1 <= y1 < e2', '{y1 => [(e1)...(e2)]}', {under: 'e1.where($TARGET)'}],
+      ar_where_in_range_inclusive: ['e1 <= y1 <= e2', '{y1 => [(e1)..(e2)]}', {under: 'e1.where($TARGET)'}],
+      ar_where_equal_to: ['y1 == e1', '{y1 => e1}', {under: 'e1.where($TARGET)'}],
+      ar_where_not_equal_to: ['y1 != e1', '["#{y1} != ?", e1]', {under: 'e1.where($TARGET)'}],
+      ar_where_larger_than: ['y1 > e1', '["#{y1} > ?", e1]', {under: 'e1.where($TARGET)'}],
+      ar_where_larger_than_or_equal_to: ['y1 >= e1', '["#{y1} >= ?", e1]', {under: 'e1.where($TARGET)'}],
+      ar_where_less_than: ['y1 < e1', '["#{y1} < ?", e1]', {under: 'e1.where($TARGET)'}],
+      ar_where_less_than_or_equal_to: ['y1 <= e1', '["#{y1} <= ?", e1]', {under: 'e1.where($TARGET)'}],
+      # TODO: and-or mixed query
+      ar_and_chain_5: ['e1.where((e2 && e3 and e4 and e5 and e6 and e7))', 'e1.where(e2).where(e3).where(e4).where(e5).where(e6).where(e7)'],
+      ar_and_chain_4: ['e1.where((e2 and e3 and e4 and e5 and e6))', 'e1.where(e2).where(e3).where(e4).where(e5).where(e6)'],
+      ar_and_chain_3: ['e1.where((e2 and e3 and e4 and e5))', 'e1.where(e2).where(e3).where(e4).where(e5)'],
+      ar_and_chain_2: ['e1.where((e2 and e3 and e4))', 'e1.where(e2).where(e3).where(e4)'],
+      ar_and_chain_1: ['e1.where((e2 and e3))', 'e1.where(e2).where(e3)'],
+      ar_or_chain_5: ['e1.where((e2 or e3 or e4 or e5 or e6 or e7))', 'e1.where(e2).or(e1.where(e3)).or(e1.where(e4)).or(e1.where(e5)).or(e1.where(e6)).or(e1.where(e7))'],
+      ar_or_chain_4: ['e1.where((e2 or e3 or e4 or e5 or e6))', 'e1.where(e2).or(e1.where(e3)).or(e1.where(e4)).or(e1.where(e5)).or(e1.where(e6))'],
+      ar_or_chain_3: ['e1.where((e2 or e3 or e4 or e5))', 'e1.where(e2).or(e1.where(e3)).or(e1.where(e4)).or(e1.where(e5))'],
+      ar_or_chain_2: ['e1.where((e2 or e3 or e4))', 'e1.where(e2).or(e1.where(e3)).or(e1.where(e4))'],
+      ar_or_chain_1: ['e1.where((e2 or e3))', 'e1.where(e2).or(e1.where(e3))'],
+    }.freeze
+
+    RULE_GROUPS = {
+      inequality_operators: [
+        :less_than_2, :less_than_or_equal_to_2, :less_than_and_equal_to_a, :less_than_and_equal_to_b,
+        :greater_than_2, :greater_than_or_equal_to_2, :greater_than_and_equal_to_a, :greater_than_and_equal_to_b,
+      ],
+
+      mathematic_intervals: [:open_interval, :closed_interval, :left_closed_interval, :right_closed_interval],
+
+      activerecord_utilities: [
+        :ar_where_in_range_exclusive, :ar_where_in_range_inclusive,
+        :ar_where_equal_to, :ar_where_not_equal_to,
+        :ar_where_larger_than, :ar_where_larger_than_or_equal_to, :ar_where_less_than, :ar_where_less_than_or_equal_to,
+        :ar_and_chain_5, :ar_and_chain_4, :ar_and_chain_3, :ar_and_chain_2, :ar_and_chain_1,
+        :ar_or_chain_5, :ar_or_chain_4, :ar_or_chain_3, :ar_or_chain_2, :ar_or_chain_1,
+      ]
+    }.freeze
+
+    def self.rule(name)
+      return nil unless RULES.has_key?(name)
+      before, after, options = RULES.fetch(name)
+      options ||= {}
+      Rule.new(name, before, after, under: options.fetch(:under, nil), safe_reference: options.fetch(:safe_reference, false))
+    end
+
+    def self.rules(*names)
+      rules = {}
+      names.each do |name|
+        if RULES.has_key?(name)
+          rules[name] = rule(name)
+        elsif RULE_GROUPS.has_key?(name)
+          RULE_GROUPS[name].each do |n|
+            rules[n] = rule(n)
+          end
+        end
+      end
+      rules
+    end
+
+    def self.register(name)
+      if RULES.has_key?(name)
+        before, after, options = RULES.fetch(name)
+        options ||= {}
+        Maccro.register(name, before, after, under: options.fetch(:under, nil), safe_reference: options.fetch(:safe_reference, false))
+      elsif RULE_GROUPS.has_key?(name)
+        RULE_GROUPS[name].each do |rule_name|
+          register(rule_name)
+        end
+      end
+    end
+
+    def self.register_all
+      RULES.each_key do |name|
+        register(name)
+      end
+    end
+  end
+end

data/lib/maccro/code_range.rb

@@ -0,0 +1,63 @@
+require_relative 'code_util'
+
+module Maccro
+  class CodeRange
+    def self.from_node(ast)
+      CodeRange.new(ast.first_lineno, ast.first_column, ast.last_lineno, ast.last_column)
+    end
+
+    attr_reader :first_lineno, :first_column, :last_lineno, :last_column
+
+    def initialize(first_lineno, first_column, last_lineno, last_column)
+      @first_lineno = first_lineno
+      @first_column = first_column
+      @last_lineno = last_lineno
+      @last_column = last_column
+    end
+
+    def ==(other)
+      @first_lineno == other.first_lineno &&
+        @first_column == other.first_column &&
+        @last_lineno == other.last_lineno &&
+        @last_column == other.last_column
+    end
+
+    def <=>(other)
+      if @first_lineno < other.first_lineno
+        -1
+      elsif @first_lineno == other.first_lineno
+        if @first_column < other.first_column
+          -1
+        elsif @first_column == other.first_column
+          if @last_lineno < other.last_lineno
+            -1
+          elsif @last_lineno == other.last_lineno
+            if @last_column < other.last_column
+              -1
+            elsif @last_column == other.last_column
+              0
+            else # @last_column > other.last_column
+              1
+            end
+          else # @last_lineno > other.last_lineno
+            1
+          end
+        else # @first_column > other.first_column
+          1
+        end
+      else # @first_lineno > other.first_lineno
+        1
+      end
+    end
+
+    def source(path)
+      source = File.open(path){|f| f.read } # open as binary?
+      get(source)
+    end
+
+    def get(source)
+      range = CodeUtil.code_range_to_range(source, self)
+      source[range]
+    end
+  end
+end

data/lib/maccro/code_util.rb

@@ -0,0 +1,106 @@
+module Maccro
+  module CodeUtil
+    def self.code_position_to_index(source, lineno, column)
+      source_lines = source.lines # including newline at the end of line
+      if source_lines.size < lineno
+        raise "too few lines for specified position: lineno:#{lineno}, column:#{column}"
+      end
+      counter = 1
+      index = 0
+      while counter < lineno
+        index += source_lines.shift.size
+        counter += 1
+      end
+      if source_lines.empty?
+        raise "too few lines for specified position: lineno:#{lineno}, column:#{column}"
+      end
+      # column is 0 origin
+      if source_lines.first.size < 1
+        raise "empty line at the end of source"
+      end
+      if source_lines.first.size < column
+        raise "too few chars in the line for specified position: lineno:#{lineno}, column:#{column}"
+      end
+      return index + column
+    end
+
+    def self.code_range_to_range(source, code_range)
+      begin_index = code_position_to_index(source, code_range.first_lineno, code_range.first_column)
+      end_index = code_position_to_index(source, code_range.last_lineno, code_range.last_column)
+      Range.new(begin_index, end_index, true) # exclude end char
+    end
+
+    def self.code_range_to_code(source, code_range)
+      source[code_range_to_range(source, code_range)]
+    end
+
+    def self.suppress_warning
+      v = $VERBOSE
+      $VERBOSE = nil
+      yield
+    ensure
+      $VERBOSE = v
+    end
+
+    def self.parse_to_ast(code)
+      suppress_warning do
+        RubyVM::AbstractSyntaxTree.parse(code)
+      end
+    end
+
+    def self.proc_to_ast(block)
+      suppress_warning do
+        RubyVM::AbstractSyntaxTree.of(block)
+      end
+    end
+
+    def self.proc_to_iseq(block)
+      RubyVM::InstructionSequence.of(block)
+    end
+
+    def self.extend_tree_with_wrapper(tree)
+      return unless tree.is_a?(RubyVM::AbstractSyntaxTree::Node)
+      tree.extend Maccro::DSL::ASTNodeWrapper unless tree.is_a?(Maccro::DSL::ASTNodeWrapper)
+      tree.children.each do |c|
+        extend_tree_with_wrapper(c)
+      end
+    end
+
+    def self.get_source_path_iseq(method)
+      iseq ||= CodeUtil.proc_to_iseq(method)
+      if !iseq
+        raise "Native methods can't be redefined"
+      end
+      path ||= iseq.absolute_path
+      if !path # STDIN or -e
+        raise "Methods from stdin or -e can't be redefined"
+      end
+      source ||= File.read(path)
+
+      return source, path, iseq
+    end
+
+    def self.get_method_node(node, method_name, lineno, column, singleton_method: false)
+      if singleton_method
+        # TODO: consider receiver filter
+        # 0: (SELF@57:6-57:10)
+        dig_method_node(node, :DEFS, 1, method_name, lineno, column)
+      else
+        dig_method_node(node, :DEFN, 0, method_name, lineno, column)
+      end
+    end
+
+    def self.dig_method_node(node, def_type, method_name_index, method_name, lineno, column)
+      return nil unless node.is_a?(RubyVM::AbstractSyntaxTree::Node)
+      if node.type == def_type && node.children[method_name_index] == method_name && node.first_lineno == lineno && node.first_column == column
+        return node
+      elsif node.respond_to?(:children)
+        node.children.each do |n|
+          r = dig_method_node(n, def_type, method_name_index, method_name, lineno, column)
+          return r if r
+        end
+      end
+      nil
+    end
+  end
+end

data/lib/maccro/dsl.rb

@@ -0,0 +1,182 @@
+require_relative 'dsl/node'
+require_relative 'dsl/literal'
+require_relative 'dsl/value'
+require_relative 'dsl/assign'
+require_relative 'dsl/expression'
+require_relative 'code_util'
+
+module Maccro
+  module DSL
+    def self.matcher(code_snippet)
+      ast = CodeUtil.parse_to_ast(code_snippet)
+      # Top level node should be SCOPE, and children[2] will be the first expression node
+      return ast_node_to_dsl_node(ast.children[2])
+    end
+
+    def self.ast_node_to_dsl_node(ast_node)
+      unless ast_node.is_a?(RubyVM::AbstractSyntaxTree::Node)
+        if ast_node.is_a?(Array)
+          ast_node.times do |i|
+            ast_node[i] = ast_node_to_dsl_node(ast_node[i])
+          end
+        end
+        return ast_node
+      end
+
+      # ast_node.is_a?(RubyVM::AbstractSyntaxTree::Node)
+      ast_node.extend ASTNodeWrapper
+      if is_placeholder?(ast_node)
+        return placeholder_to_matcher_node(ast_node)
+      end
+
+      ast_node.children.each_with_index do |n, i|
+        ast_node.children[i] = ast_node_to_dsl_node(n)
+      end
+      ast_node
+    end
+
+    def self.is_placeholder?(node)
+      if node.type == :VCALL && placeholder_name?(node.children.first)
+        true
+      elsif node.type == :GVAR && node.children.first == :'$TARGET'
+        true
+      else
+        false
+      end
+    end
+
+    def self.placeholder_name?(sym)
+      # Expression: "eN"
+      # Value: "vN"
+      # String: "sN"
+      # Symbol: "yN"
+      # Number: "nN"
+      # Regular expression: "rN"
+      # N index is 1 origin
+      (sym.to_s =~ /^[evsynr][1-9]\d*$/).!.!
+    end
+
+    def self.placeholder_to_matcher_node(placeholder_node)
+      name = placeholder_node.children.first.to_s
+      nodeClass = case name
+                  when '$TARGET' then AnyNode
+                  when /^s([1-9]\d*)$/ then String
+                  when /^y([1-9]\d*)$/ then Symbol
+                  when /^n([1-9]\d*)$/ then Number
+                  when /^r([1-9]\d*)$/ then RegularExpression
+                  when /^v([1-9]\d*)$/ then Value
+                  when /^e([1-9]\d*)$/ then Expression
+                  else
+                    raise "BUG: unregistered placeholder name `#{name}`"
+                  end
+      nodeClass.new(name, placeholder_node.to_code_range)
+    end
+  end
+end
+
+###
+# List of AST nodes: from node_children() in ast.c
+
+# ASGN means Assignment
+
+# BLOCK
+# IF (expression)
+# UNLESS (expression)
+# CASE (expression)
+# CASE2 (expression)
+# WHEN
+# WHILE
+# UNTIL
+# ITER
+# FOR
+# FOR_MASGN
+# BREAK
+# NEXT
+# RETURN
+# REDO
+# RETRY
+# BEGIN (expression)
+# RESCUE
+# RESBODY
+# ENSURE
+# AND (expression)
+# OR  (expression)
+# MASGN      (assign)
+# LASGN      (assign)
+# DASGN      (assign)
+# DASGN_CUPR (assign)
+# IASGN      (assign)
+# CVASGN     (assign)
+# GASGN      (assign)
+# CDECL      (assign)
+# OP_ASGN1    (assign)
+# OP_ASGN2    (assign)
+# OP_ASGN_AND (assign)
+# OP_ASGN_OR  (assign)
+# OP_CDECL    (assign)
+# CALL   (expression)
+# OPCALL (expression)
+# QCALL  (expression)
+# FCALL  (expression)
+# VCALL  (expression)
+# SUPER  (expression)
+# ZSUPER (expression)
+# ARRAY  (value)
+# VALUES [return arguments]
+# ZARRAY (value)
+# HASH   (value)
+# YIELD (expression)
+# LVAR (value)
+# DVAR (value)
+# IVAR (value)
+# CONST (value)
+# CVAR (value)
+# GVAR (value)
+# NTH_REF (value)
+# BACK_REF (value)
+# MATCH  (expression)
+# MATCH2 (expression)
+# MATCH3 (expression)
+# LIT (value)
+# STR (value)
+# XSTR (value)
+# ONCE (value)
+# DSTR (value)
+# DXSTR (value)
+# DREGX (value)
+# DSYM (value)
+# EVSTR [String interpolation (in string literals)]
+# ARGSCAT
+# AGSPUSH
+# SPLAT
+# BLOCK_PASS
+# DEFN (expression)
+# DEFS (expression)
+# ALIAS
+# VALIAS
+# UNDEF
+# CLASS
+# MODULE
+# SCLASS
+# COLON2 (expression)
+# COLON3 (expression)
+# DOT2  (expression)
+# DOT3  (expression)
+# FLIP2 (expression)
+# FLIP3 (expression)
+# SELF  (value)
+# NIL   (value)
+# TRUE  (value)
+# FALSE (value)
+# ERRINFO
+# DEFINED (expression)
+# POSTEXE
+# ATTRASGN (assign)
+# LAMBDA (value)
+# OPT_ARG
+# KW_ARG
+# POSTARG
+# ARGS
+# SCOPE
+# ARGS_AUX
+# LAST