maccro 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8015c1a7ab5cb06c29416d9801752700847984f780bed543684ad447adbc62a9
-  data.tar.gz: 35f530a6eb5ce1de62d16764088939eec432e409769a78e3a2ad79f9cdcb682a
+  metadata.gz: 3e54cc161c036cb372e37f06ad44e852c16cca5e59a9733c2c18f790b1c94e90
+  data.tar.gz: 710e14885e1133eff4c47c02206859497a447399b837e76c66374088f0a89fe1
 SHA512:
-  metadata.gz: 749783b767f55fe27e8097dd3954dc3a4bf20d430f7874e71fbc825fdbf77718592e374480e4dddb761f50718fe61370163623273a93829b58a61be5dd98f8d1
-  data.tar.gz: 6a8d9a2e6a7ae910127bc91cc5941afabe4faf4015056117683886eb9923cfdac8b3dccf12336f302bc8781294c8bfe8bd35c4562672f3b9fc59721777d601ea
+  metadata.gz: 60a16df8c0f7c4411a31bb3485b92fb3a1c851ce5a8ac099989a318c770a4a3e6cc098b01aef89dd98c1dfe32ffb99f1fbc7569b93e4ce15da429227c058e5e3
+  data.tar.gz: 348bad681d4495b8b61529a8b936e0f03d88bd85e841ea41e0a39706e5452d7e484267271707c83b7d6ecd8a3f1c88aab5c2140baed3c572a74f52081b32837b

data/README.md

@@ -3,10 +3,11 @@
 Maccro is a library to introduce macro (dynamic code rewriting), written in Ruby 100%.
 
 ```ruby
+require "maccro"
 # name, before, after
 Maccro.register(:double_less_than, 'e1 < e2 < e3', 'e1 < e2 && e2 < e3')
 
-# This rewrites this code
+# This rewrites the code below
 class Foo
   def foo(v)
     if 1 < v < 2
@@ -27,6 +28,41 @@ class Foo
 end
 ```
 
+Another example is about ActiveRecord queries.
+
+```ruby
+require "maccro/builtin"
+Maccro::Builtin.register(:activerecord_utilities)
+Maccro.enable(path: __FILE__)
+
+# This rewrites the code below
+class Users < ApplicationRecord
+  def not_admin_or_under_20_age_users
+    Users.where(:priv != "admin || :age < 20)
+  end
+end
+
+# To this automatically
+class Users < ApplicationRecord
+  def not_admin_or_under_20_age_users
+    Users.where('priv != ?', "admin").or(Users.where('age < ?', 20))
+  end
+end
+```
+
+Maccro also provides methods to rewrite any code in blocks:
+
+```ruby
+require "maccro"
+Maccro.register(:double_less_than, 'e1 < e2 < e3', 'e1 < e2 && e2 < e3')
+
+does_sandwitch_one = ->(a, b){ a < 1 < b }
+Maccro.rewrite(does_sandwitch_one).call(0, 2) #=> true
+
+# or execute the block parameter immediately
+Maccro.execute{ 0 < 1 < 2 } #=> true
+```
+
 Maccro comes from "Macro" and "Makkuro"(means "pure black" in Japanese).
 
 ### Why Maccro?
@@ -40,15 +76,13 @@ Maccro comes from "Macro" and "Makkuro"(means "pure black" in Japanese).
 Maccro can:
 
 * run with Ruby 2.6 or later
-* rewrite code, only written in methods using `def` keyword, in `module` or `class`
+* rewrite code, only written in methods using `def` keyword, in `module` or `class`, or blocks
 * not rewrite singleton methods, which are used just after definition
 * not rewrite methods from command line option (`-e`) or REPLs (irb/pry)
 
 Maccro features below are not supported yet:
 
 * Non-idempotent method calls
-* Proc rewrite and local variable name matching (currntly, local variable name in before/after could be referred as VCALL)
-* Specifying a type of literal by placeholders
 * Handling method visibilities
 * Rewriting singleton methods with non-self receiver
 * Placeholder validation
@@ -59,7 +93,7 @@ Maccro features below are not supported yet:
 Maccro users do:
 * register rules how to rewrite methods, with code patterns
   * or use built-in rules
-* apply a set of registered rules to a method
+* apply a set of registered rules to a method, or to a block
 * enable automatic applying to a module/class or to a file, or globally
 
 ### Terminology
@@ -158,10 +192,10 @@ Types of placeholders are defined by alphabetic chars:
   * defining methods and singleton methods
   * double and trible colon `::` and `:::`
   * dots and flip-flop
-
-* TODO: implement placeholder for strings
-* TODO: implement placeholder for symbols
-* TODO: implement placeholder for numbers
+* `s`: strings
+* `y`: symbols
+* `n`: numbers
+* `r`: regular expressions
 
 #### Using a placeholder twice (or more)
 
@@ -327,6 +361,8 @@ $ ruby -rmaccro/rewrite_the_world file_to_run.rb
 
 #### `Maccro#register(name, before, after, **kwarg_options)`
 
+Register a macro rule to the global dictionary.
+
 * name: a symbol to represents the rule
 * before: a string of Ruby code which matches to be rewritten
 * after: a string of Ruby code which replaces the matched part
@@ -336,11 +372,31 @@ $ ruby -rmaccro/rewrite_the_world file_to_run.rb
 
 #### `Maccro#apply(module, method, **kwarg_options)`
 
+Apply the registered rules (or a set of rules specified) to a method.
+
 * module: a module/class, the applied method is defined in
 * method: a method object (an instance method or a singleton method)
 * kwarg_options:
   * rules: an array of symbols of rule names (default: all registered rules)
 
+#### `Maccro#rewrite(proc=nil, **kwarg_options, &block)`
+
+Rewrite a specified proc object by the registered rules (or a set of rules specified) and return the updated (rewritten) proc object.
+
+* proc: a Proc object to be rewritten (exclusive with `block`)
+* block: a block parameter to be rewritten (exclusive with `proc`)
+* kwarg_options:
+  * rules: an array of symbols of rule names (default: all registered rules)
+
+#### `Maccro#execute(proc=nil, **kwarg_options, &block)`
+
+Rewrite a specified proc object and call it immediately. The proc must be with no arguments.
+
+* proc: a Proc object to be rewritten (exclusive with `block`), which must be with no arguments
+* block: a block parameter to be rewritten (exclusive with `proc`), which must be with no arguments
+* kwarg_options:
+  * rules: an array of symbols of rule names (default: all registered rules)
+
 #### `Maccro#enable(**kwarg_options)`
 
 * kwarg_options:

data/lib/maccro.rb

@@ -1,5 +1,6 @@
 require_relative "./maccro/version"
 
+require_relative "./maccro/impl"
 require_relative "./maccro/dsl"
 require_relative "./maccro/rule"
 require_relative "./maccro/code_util"
@@ -21,10 +22,46 @@ module Maccro
     @@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.clear!
+    @@dic = {}
+  end
+
+  def self.execute(block=nil, rules: @@dic, verbose: false, get_code: false, &block_param)
+    block = block_param if !block && block_param
+    if block.arity > 0
+      raise "Block with parameters can't be executed via Maccro"
+    end
+
+    rewrite(block, rules: rules, verbose: verbose, get_code: get_code).call
+  end
+
+  # Maccro.rewrite(->(){ ... }).call(args)
+  def self.rewrite(block=nil, rules: @@dic, verbose: false, get_code: false, &block_param)
+    block = block_param if !block && block_param
+    if !block.source_location
+      raise "Native block can't be rewritten"
+    end
+
+    ast = CodeUtil.proc_to_ast(block)
+    if !ast
+      raise "Failed to load AST nodes - source file may be invisible"
+    end
+    source, _ = CodeUtil.get_source_path(block)
+    ast, source = Impl.update_by_rules(ast, source, rules) do |src, lineno, column|
+      CodeUtil.get_proc_node(CodeUtil.parse_to_ast(src), lineno, column)
+    end
+    eval_source = if ast.type == :SCOPE
+                    CodeUtil.convert_scope_to_lambda(CodeRange.from_node(ast).get(source))
+                  else
+                    CodeRange.from_node(ast).get(source)
+                  end
+    return eval_source if get_code
+    puts eval_source if verbose
+    block.binding.eval(eval_source)
+  end
 
+  # Maccro.apply(X, X.instance_method(:yay), verbose: true)
   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
@@ -40,53 +77,29 @@ module Maccro
     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
+    source, path = CodeUtil.get_source_path(method)
+    # The reason to get the entire source code is to capture/rewrite
+    # the exact code snippet using CodeRange (positions in the entire file)
 
-    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
+    ast, source = Impl.update_by_rules(ast, source, rules) do |src, lineno, column|
+      CodeUtil.get_method_node(CodeUtil.parse_to_ast(src), method.name, lineno, column, singleton_method: is_singleton_method)
     end
 
+    # required to restore code positions of the method definition
+    first_lineno = ast.first_lineno
+    first_column = ast.first_column
+
+    rewrite_method_code_range = CodeRange.from_node(ast)
     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)
+        mojule.module_eval(eval_source, path, ast.first_lineno)
       end
     end
   end

data/lib/maccro/code_util.rb

@@ -66,18 +66,75 @@ module Maccro
       end
     end
 
-    def self.get_source_path_iseq(method)
-      iseq ||= CodeUtil.proc_to_iseq(method)
+    def self.convert_scope_to_lambda(scope_source)
+      raise "Scope source must start with '{'" unless scope_source.start_with?('{')
+      raise "Scope source must end with '}'" unless scope_source.end_with?('}')
+
+      if m = scope_source.match(/^\{\s*\|(.*)\|/o)
+        matched_source = m[0]
+        args_source = m[1]
+        return "->(#{args_source})" + scope_source.sub(matched_source, '{')
+      end
+
+      "->" + scope_source
+    end
+
+    def self.get_source_path(block)
+      iseq = CodeUtil.proc_to_iseq(block)
       if !iseq
         raise "Native methods can't be redefined"
       end
-      path ||= iseq.absolute_path
+      path = iseq.absolute_path
       if !path # STDIN or -e
         raise "Methods from stdin or -e can't be redefined"
       end
-      source ||= File.read(path)
+      source = File.read(path)
+
+      return source, path
+    end
+
+    def self.get_proc_node(node, lineno, column)
+      return nil unless node.type == :SCOPE
+      dig_proc_node(node, lineno, column)
+    end
+
+    def self.dig_proc_node(node, lineno, column)
+      return nil unless node.is_a?(RubyVM::AbstractSyntaxTree::Node)
+      is_target_scope = ->(n){ n.type == :SCOPE && n.first_lineno == lineno && n.first_column == column }
+
+      case node.type
+      when :LAMBDA # ->(){ }
+        if is_target_scope.call(node.children[0])
+          return node
+        end
+      when :ITER # method call with block (iterator?)
+        # lambda{}, proc{}
+        if node.children[0].type == :FCALL \
+           && (node.children[0].children[0] == :lambda || node.children[0].children[0] == :proc) \
+           && is_target_scope.call(node.children[1])
+          return node
+        # Kernel.lambda, Kernel.proc{}, Proc.new{}
+        elsif node.children[0].type == :CALL \
+              && node.children[0].children[0].type == :CONST \
+              && (node.children[0].children[0].children[0] == :Kernel && (node.children[0].children[1] == :lambda || node.children[0].children[1] == :proc) \
+                  || node.children[0].children[0].children[0] == :Proc && node.children[0].children[1] == :new ) \
+              && is_target_scope.call(node.children[1])
+          return node
+        end
+      when :SCOPE # for block parameters
+        if is_target_scope.call(node)
+          return node
+        end
+      end
 
-      return source, path, iseq
+      if node.respond_to?(:children)
+        node.children.each do |n|
+          r = dig_proc_node(n, lineno, column)
+          return r if r
+        end
+      end
+
+      nil
     end
 
     def self.get_method_node(node, method_name, lineno, column, singleton_method: false)

data/lib/maccro/impl.rb

@@ -0,0 +1,34 @@
+module Maccro
+  module Impl
+    # for internal use
+    def self.update_by_rules(ast, source, rules)
+      CodeUtil.extend_tree_with_wrapper(ast)
+
+      rewrite_happens = false
+      first_time = true
+
+      while rewrite_happens || first_time
+        rewrite_happens = false
+        first_time = false
+
+        try_once = ->(rule) {
+          matched = rule.match(ast)
+          next unless matched
+
+          source = matched.rewrite(source)
+          ast = yield source, ast.first_lineno, ast.first_column
+          CodeUtil.extend_tree_with_wrapper(ast)
+          rewrite_happens = true
+          try_once.call(rule)
+        }
+
+        rules.each_pair do |_name, this_rule|
+          try_once.call(this_rule)
+          break if rewrite_happens # to retry all rules
+        end
+      end
+
+      return ast, source
+    end
+  end
+end

data/lib/maccro/version.rb

@@ -1,3 +1,3 @@
 module Maccro
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: maccro
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - TAGOMORI Satoshi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-04-19 00:00:00.000000000 Z
+date: 2019-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -76,6 +76,7 @@ files:
 - lib/maccro/dsl/literal.rb
 - lib/maccro/dsl/node.rb
 - lib/maccro/dsl/value.rb
+- lib/maccro/impl.rb
 - lib/maccro/kernel_ext.rb
 - lib/maccro/matched.rb
 - lib/maccro/rewrite_the_world.rb