maccro 0.1.0

data/lib/maccro/dsl/assign.rb

@@ -0,0 +1,100 @@
+require_relative "node"
+
+module Maccro
+  module DSL
+    class MultiAssignment < Node
+      def type; :MASGN; end
+      def self.match?(node); node.type == :MASGN ; end
+    end
+
+    class LocalVariableAssignment < Node
+      def type; :LASGN; end
+      def self.match?(node); node.type == :LASGN ; end
+    end
+
+    class DynamicVariableAssignmentOutOfScope < Node
+      # x = 1; 1.times{ x = 1 }
+      def type; :DASGN; end
+      def self.match?(node); node.type == :DASGN ; end
+    end
+
+    class DynamicVariableAssignmentCurrentScope < Node
+      # 1.times{ x = 1 }
+      def type; :DASGN_CUPR; end
+      def self.match?(node); node.type == :DASGN_CUPR ; end
+    end
+
+    class InstanceVariableAssignment < Node
+      def type; :IASGN; end
+      def self.match?(node); node.type == :IASGN ; end
+    end
+
+    class ClassVariableAssignment < Node
+      def type; :CVASGN; end
+      def self.match?(node); node.type == :CVASGN ; end
+    end
+
+    class GlobalVariableAssignment < Node
+      def type; :GASGN; end
+      def self.match?(node); node.type == :GASGN ; end
+    end
+
+    class AttributeAssignment < Node
+      # x[1] = 1
+      # x.a = 1
+      def type; :ATTRASGN; end
+      def self.match?(node); node.type == :ATTRASGN ; end
+    end
+
+    class ArrayAssignmentWithOperator < Node
+      # x[1] += 1
+      def type; :OP_ASGN1; end
+      def self.match?(node); node.type == :OP_ASGN1 ; end
+    end
+
+    class AttributeAssignmentWithOperator < Node
+      # x.a += 1
+      def type; :OP_ASGN2; end
+      def self.match?(node); node.type == :OP_ASGN2 ; end
+    end
+
+    class AndAssignment < Node
+      # x &&= y
+      def type; :OP_ASGN_AND; end
+      def self.match?(node); node.type == :OP_ASGN_AND ; end
+    end
+
+    class OrAssignment < Node
+      # x ||= y
+      def type; :OP_ASGN_OR; end
+      def self.match?(node); node.type == :OP_ASGN_OR ; end
+    end
+
+    class ConstantDeclaration < Node
+      def type; :CDECL; end
+      def self.match?(node); node.type == :CDECL ; end
+    end
+
+    class ConstantDeclarationWithOperator < Node
+      # A::B ||= 1
+      # A::B += 1
+      def type; :OP_CDECL; end
+      def self.match?(node); node.type == :OP_CDECL ; end
+    end
+
+    class Assignment < Node
+      SUB_TYPES = [
+        MultiAssignment, LocalVariableAssignment,
+        DynamicVariableAssignmentOutOfScope, DynamicVariableAssignmentCurrentScope,
+        InstanceVariableAssignment, ClassVariableAssignment, GlobalVariableAssignment,
+        AttributeAssignment, ArrayAssignmentWithOperator, AttributeAssignmentWithOperator,
+        AndAssignment, OrAssignment,
+        ConstantDeclaration, ConstantDeclarationWithOperator,
+      ].freeze
+
+      def self.match?(node)
+        SUB_TYPES.any?{|s| s.match?(node) }
+      end
+    end
+  end
+end

data/lib/maccro/dsl/expression.rb

@@ -0,0 +1,166 @@
+require_relative "node"
+require_relative "value"
+require_relative "assign"
+
+module Maccro
+  module DSL
+    class IfExp < Node
+      def type; :IF; end
+      def self.match?(node); node.type == :IF; end
+    end
+
+    class UnlessExp < Node
+      def type; :UNLESS; end
+      def self.match?(node); node.type == :UNLESS; end
+    end
+
+    class CaseExp < Node
+      def type; :MACCRO_CASE; end
+      def self.match?(node)
+        node.type == :CASE || node.type == :CASE2
+      end
+    end
+
+    # class BeginExp < Node
+    #   # TODO: getting source of begin node DOES drop the beggining "begin" and tailing "end"
+    #   def type; :"BEGIN"; end
+    #   def self.match?(node); node.type == :"BEGIN"; end
+    # end
+
+    # class RescueExp < Node
+    #   # TODO: getting source of rescue node DOES drop the beggining "begin" and tailing "end"
+    #   def type; :"RESCUE"; end
+    #   def self.match?(node); node.type == :"RESCUE"; end
+    # end
+
+    class AndExp < Node
+      def type; :AND; end
+      def self.match?(node); node.type == :AND; end
+    end
+
+    class OrExp < Node
+      def type; :OR; end
+      def self.match?(node); node.type == :OR; end
+    end
+
+    class CallExp < Node
+      def type; :CALL; end
+      def self.match?(node); node.type == :CALL; end
+    end
+
+    class OperatorCallExp < Node
+      def type; :OPCALL; end
+      def self.match?(node); node.type == :OPCALL; end
+    end
+
+    class SafeCallExp < Node
+      # x&.foo(1)
+      def type; :QCALL; end
+      def self.match?(node); node.type == :QCALL; end
+    end
+
+    class FunctionCallExp < Node
+      def type; :FCALL; end
+      def self.match?(node); node.type == :FCALL; end
+    end
+
+    class VCallExp < Node
+      # function call without arguments
+      def type; :VCALL; end
+      def self.match?(node); node.type == :VCALL; end
+    end
+
+    class SuperExp < Node
+      # super or super without arguments
+      def type; :MACCRO_SUPER; end
+      def self.match?(node)
+        node.type == :SUPER || node.type == :ZSUPER
+      end
+    end
+
+    class YieldExp < Node
+      def type; :YIELD; end
+      def self.match?(node); node.type == :YIELD; end
+    end
+
+    class MatchExp < Node
+      # MATCH:  /.../ without `=~` (matches to $_ implicitly)
+      # MATCH2: /.../ =~ "..." (left side)
+      # MATCH3: "..." =~ /.../ (right side)
+      def type; :MACCRO_MATCH; end
+      def self.match?(node)
+        t = node.type
+        t == :MATCH || t == :MATCH2 || t == :MATCH3
+      end
+    end
+
+    class DefineMethod < Node
+      def type; :DEFN; end
+      def self.match?(node); node.type == :DEFN; end
+    end
+
+    class DefineSingletonMethod < Node
+      def type; :DEFS; end
+      def self.match?(node); node.type == :DEFS; end
+    end
+
+    class Colon2Exp < Node
+      def type; :COLON2; end
+      def self.match?(node); node.type == :COLON2; end
+    end
+
+    class Colon3Exp < Node
+      # top level reference (::A)
+      def type; :COLON3; end
+      def self.match?(node); node.type == :COLON3; end
+    end
+
+    class Dot2Exp < Node
+      # range constructor (inclusive)
+      def type; :DOT2; end
+      def self.match?(node); node.type == :DOT2; end
+    end
+
+    class Dot3Exp < Node
+      # range constructor (exclusive)
+      def type; :DOT3; end
+      def self.match?(node); node.type == :DOT3; end
+    end
+
+    class Flip2Exp < Node
+      # flip-flop (inclusive)
+      def type; :FLIP2; end
+      def self.match?(node); node.type == :FLIP2; end
+    end
+
+    class Flip3Exp < Node
+      # flip-flop (exclusive)
+      def type; :FLIP3; end
+      def self.match?(node); node.type == :FLIP3; end
+    end
+
+    class DefinedExp < Node
+      def type; :DEFINED; end
+      def self.match?(node); node.type == :DEFINED; end
+    end
+
+    class Expression < Node
+      SUB_TYPES = [
+        Value, Assignment,
+        IfExp, UnlessExp, CaseExp,
+        # BeginExp, RescueExp,
+        AndExp, OrExp,
+        CallExp, OperatorCallExp, SafeCallExp, FunctionCallExp, VCallExp,
+        SuperExp, YieldExp,
+        MatchExp,
+        DefineMethod, DefineSingletonMethod,
+        Colon2Exp, Colon3Exp, Dot2Exp, Dot3Exp, Flip2Exp, Flip3Exp,
+        DefinedExp,
+      ].freeze
+
+      def self.match?(node)
+        SUB_TYPES.any?{|s| s.match?(node) }
+      end
+    end
+  end
+end

data/lib/maccro/dsl/literal.rb

@@ -0,0 +1,121 @@
+require_relative "node"
+
+module Maccro
+  module DSL
+    class Literal < Node
+      # integer, float, symbol, regex, ...
+      def type; :LIT; end
+      def self.match?(node); node.type == :LIT; end
+    end
+
+    class DSymbol < Node
+      # symbol with string interpolation
+      def type; :DSYM; end
+      def self.match?(node); node.type == :DSYM; end
+    end
+
+    class Symbol < Node
+      def type; :LIT; end
+      def self.match?(node)
+        (node.type == :LIT && node.children[0].is_a?(::Symbol)) || DSymbol.match?(node)
+      end
+    end
+
+    class Number < Node
+      def type; :LIT; end
+      def self.match?(node)
+        node.type == :LIT && node.children[0].is_a?(::Numeric)
+      end
+    end
+
+    class RegexpCompiledOnce < Node
+      # regex with RE_OPTION_ONCE (see new_regexp() in parse.y)
+      def type; :ONCE; end
+      def self.match?(node); node.type == :ONCE; end
+    end
+
+    class DRegexp < Node
+      # regex with string interpolation
+      def type; :DREGX; end
+      def self.match?(node); node.type == :DREGX; end
+    end
+
+    class RegularExpression < Node
+      def type; :LIT; end
+      def self.match?(node)
+        node.type == :LIT && node.children[0].is_a?(Regexp)
+      end
+    end
+
+    class FString < Node
+      # string literal without interpolation
+      def type; :STR; end
+      def self.match?(node); node.type == :STR; end
+    end
+
+    class DString < Node
+      # string literal with interpolation ?
+      def type; :DSTR; end
+      def self.match?(node); node.type == :DSTR; end
+    end
+
+    class XString < Node
+      # string from back quote: `...`
+      # is it a literal?
+      def type; :XSTR; end
+      def self.match?(node); node.type == :XSTR; end
+    end
+
+    class DXString < Node
+      # string from back quote with string interpolation: `... #{..} ...`
+      # is it a literal?
+      def type; :DXSTR; end
+      def self.match?(node); node.type == :DXSTR; end
+    end
+
+    class String < Node
+      SUB_TYPES = [FString, DString, XString, DXString].freeze
+
+      def type; :MACCRO_STRING; end
+
+      def self.match?(node)
+        SUB_TYPES.any?{|s| s.match?(node) }
+      end
+    end
+
+    class NilValue < Node
+      def type; :NIL; end
+      def self.match?(node); node.type == :NIL; end
+    end
+
+    class TrueValue < Node
+      def type; :TRUE; end
+      def self.match?(node); node.type == :TRUE; end
+    end
+
+    class FalseValue < Node
+      def type; :FALSE; end
+      def self.match?(node); node.type == :FALSE; end
+    end
+
+    class Lambda < Node
+      def type; :LAMBDA; end
+      def self.match?(node); node.type == :LAMBDA; end
+    end
+
+    class Array < Node
+      # ARRAY and ZARRAY
+      def type; :MACCRO_ARRAY; end
+      def self.match?(node)
+        node.type == :ARRAY || node.type == :ZARRAY
+      end
+    end
+
+    class Hash < Node
+      # HASH may be a hash literal, or keyword argument assignment `"a: 1" of f(a: 1)`
+      # HASH(nd_alen == 0) is a keyword argument assignment, but no way to get it via AST::Node
+      def type; :HASH; end
+      def self.match?(node); node.type == :HASH; end
+    end
+  end
+end

data/lib/maccro/dsl/node.rb

@@ -0,0 +1,89 @@
+require_relative '../code_range'
+
+module Maccro
+  module DSL
+    module ASTNodeWrapper
+      def children
+        @child_nodes ||= super
+      end
+
+      def to_code_range
+        CodeRange.from_node(self)
+      end
+
+      def match?(node)
+        return false unless node.is_a?(ASTNodeWrapper)
+        return false if node.type != self.type
+        self.children.each_with_index do |c, i|
+          if c.is_a?(ASTNodeWrapper)
+            return false unless c.match?(node.children[i])
+          else
+            return false unless c == node.children[i]
+          end
+        end
+        # same type, all children match with others
+        true
+      end
+
+      def capture(ast, placeholders)
+        self.children.each_with_index do |c, i|
+          if c.is_a?(ASTNodeWrapper)
+            c.capture(ast.children[i], placeholders)
+          end
+        end
+      end
+    end
+
+    class Node
+      attr_reader :name, :first_lineno, :first_column, :last_lineno, :last_column
+
+      include ASTNodeWrapper
+
+      def initialize(name, code_range)
+        @name = name
+        @code_range = code_range
+        @first_lineno = code_range.first_lineno
+        @first_column = code_range.first_column
+        @last_lineno = code_range.last_lineno
+        @last_column = code_range.last_column
+      end
+
+      def to_code_range
+        @code_range
+      end
+
+      def type
+        :MACCRO_NODE
+      end
+
+      def children
+        []
+      end
+
+      def match?(node)
+        # literals are not Node in any cases
+        return false unless node.respond_to?(:type)
+
+        if self.class.respond_to?(:match?)
+          self.class.match?(node)
+        else
+          super
+        end
+      end
+
+      def capture(ast, placeholders)
+        placeholders[@name] = ast.to_code_range
+      end
+    end
+
+    class AnyNode < Node
+      def match?(node)
+        true
+      end
+
+      def capture(ast, placeholders)
+        placeholders[:__target__] = ast
+      end
+    end
+  end
+end