rubymacros 0.1.5 → 0.1.6

data/example/with_wrap.rb

@@ -1,3 +1,22 @@
+=begin
+    rubymacros - a macro preprocessor for ruby
+    Copyright (C) 2008, 2016  Caleb Clausen
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+=end
+
 require 'macro'
+require 'regxform'
 Macro.require 'example/with'
 

data/lib/macro.rb

@@ -1,6 +1,6 @@
 =begin
     rubymacros - a macro preprocessor for ruby
-    Copyright (C) 2008  Caleb Clausen
+    Copyright (C) 2008, 2016  Caleb Clausen
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU Lesser General Public License as published by
@@ -16,9 +16,12 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 =end
 
-require 'rubygems'
+begin require 'rubygems'
+rescue Exception; #do nothing; hope we don't need it
+end
 require 'redparse'
 require "macro/form"
+require "macro/node"
 require "macro/version"
 
 class Object # :nodoc:
@@ -34,6 +37,7 @@ class Macro
     n=RedParse::const_get(k)
     self::const_set k,n if Module===n and RedParse::Node>=n
   }
+  ListInNode=RedParse::ListInNode #Node helper module
   #...and token classes from RubyLexer
   RubyLexer::constants.each{|k| 
     t=RubyLexer::const_get(k)
@@ -66,9 +70,10 @@ class Macro
     [''].concat($:).each{|pre|
       pre+="/" unless %r{(\A|/)\Z}===pre
       if File.exist? finally=pre+filename
-        code=File.open(finally){|fd| fd.read }
-        #code="::Module.new do\n#{code}\nend\n" if wrap
-        tree=Macro.expand(parse(code,filename),filename)
+        tree=File.open(finally){|code|
+          #code="::Module.new do\n#{code}\nend\n" if wrap
+          Macro.expand(parse(code,finally),filename)
+        }
 
         tree.load filename,wrap
         return true
@@ -77,6 +82,33 @@ class Macro
     raise LoadError, "no such file to load -- "+filename
   end
 
+  def Macro.delete(name,context=::Object)
+    Thread.current[:Macro_being_undefined]="macro_"+name
+    class<<context; remove_method(Thread.current[:Macro_being_undefined]); end
+    if context==::Object
+      Macro::GLOBALS.delete name.to_sym
+    end
+    Thread.current[:Macro_being_undefined]=nil
+  end
+
+  def Macro.list(*contexts)
+    contexts=[::Object] if contexts.empty?
+    contexts.map{|ctx| ctx.singleton_methods.grep(/\Amacro_/) }.flatten.map{|ctx| ctx.to_s.gsub!(/\Amacro_/,'') }
+  end
+
+  class ::Module
+    def macros
+      Macro.list(self)
+    end
+  end
+
+  def Macro.delete_all!(*contexts)
+    contexts=[::Object] if contexts.empty?
+    contexts.each{|ctx|
+      Macro.list(ctx).each{|mac| Macro.delete mac,ctx }
+    }
+  end
+
   #like Kernel#eval, but allows macros (and forms) as well.
   #beware: default for second argument is currently broken.
   #best practice is to pass an explicit binding (see
@@ -91,8 +123,9 @@ class Macro
   #binding should default to Binding.of_caller, but byellgch
     
     lvars=binding ? ::Kernel.eval("local_variables()",binding) : []
-    tree=Macro.expand(parse(code,file,line,lvars),file)
-    tree.eval binding||::Object.new_binding,file,line
+    code=Macro.parse(code,file,line,lvars) unless Node===code
+    tree=Macro.expand(code,file)
+    tree.eval binding,file,line
   end
 
   # A helper for Macro.eval which returns a RedParse tree for the given
@@ -113,7 +146,7 @@ class Macro
     if Binding===lvars
       lvars=eval "local_variables", lvars
     end
-    RedParseWithMacros.new(code,file,line,lvars).parse
+    ::RedParse::WithMacros.new(code,file,line,lvars).parse
   end
 
   UNCOPYABLE= #Symbol|Numeric|true|false|nil|
@@ -126,12 +159,18 @@ class Macro
   def Macro.quote obj
     #result=
     case obj
-      when Symbol,Numeric: LiteralNode[obj]
-      when true,false,nil: VarLikeNode[obj.inspect]
-      when String: 
+      when Symbol,Numeric; LiteralNode[obj]
+      when true,false,nil; VarLikeNode[obj.inspect]
+      when String
         obj=obj.gsub(/['\\]/){|ch| '\\'+ch }
         StringNode[obj,{:@open=>"'", :@close=>"'"}]
 
+      when Reg::Formula
+        Reg::Deferred.defang! obj
+
+      when Reg::Reg
+        obj
+
       # TODO: The following is dead code and should be removed
       else 
         #result=:(::Macro::QuotedStore[^QuotedStore.size])
@@ -154,12 +193,12 @@ class Macro
     return result if result
     result=
     case obj
-      when Symbol,Numeric,true,false,nil: return obj
-      when String: seen[obj.__id__]=obj.dup
-      when Array: 
+      when Symbol,Numeric,true,false,nil; return obj
+      when String; seen[obj.__id__]=obj.dup
+      when Array 
         seen[obj.__id__]=dup=obj.dup
         dup.map!{|x| copy x,seen}
-      when Hash:
+      when Hash
         result={}
         seen[obj.__id__]=result
         obj.each_pair{|k,v| 
@@ -167,7 +206,7 @@ class Macro
         }
         result
       when Module,Proc,IO,Method,
-           UnboundMethod,Thread,Continuation: 
+           UnboundMethod,Thread,Continuation
         return obj
       else
         obj.dup
@@ -200,7 +239,7 @@ class Macro
   #
   def Macro.postpone node,session
       return node #disable postponement
-
+=begin was
       filename=session[:filename]
       unless session[:@modpath_unsure]
         modpath=ConstantNode[nil,*session[:@modpath]] 
@@ -226,6 +265,7 @@ class Macro
              HashLiteralNode[LiteralNode[:@expand_in_defs], VarLikeNode["true"]], Macro.quote(filename)],
           nil,nil]
       return CallNode[expanded,evalname,[Macro.quote( filename )],nil,nil]
+=end
   end
 
   class Node
@@ -350,7 +390,10 @@ class Macro
     end
     session[:@modpath]||=[]
     session[:filename]||=filename
-    String===tree and tree=parse(tree)
+    filename||="(eval)"
+    case tree
+    when String,IO; tree=parse(tree,filename)
+    end
     fail unless macros.__id__==Macro::GLOBALS.__id__      #for now
     tree.walk{|parent,i,subi,node|
       is_node=Node===node
@@ -369,7 +412,19 @@ class Macro
 
         if newnode
           return newnode unless parent #replacement at top level
-          subi ? parent[i][subi]=newnode : parent[i]=newnode
+          if subi 
+            target,index=parent[i],subi
+          else
+            target,index=parent,i
+          end
+          if JustNilNode===newnode and target.class==::Array ||
+            case target
+            when UndefNode,AssigneeList,SequenceNode; true
+            end
+            target.delete_at index
+          else
+            target[index]=newnode
+          end
           fail if recurse
         end 
       else
@@ -387,7 +442,7 @@ class Macro
 
         #varargs, &args and receivers are not allowed in macro definitions (yet)
         fail "macro receivers not supported yet" if receiver
-        if Node===args
+        if args
           last=args
 #        else
 #          last=args.last
@@ -398,8 +453,21 @@ class Macro
         #macros can't be settors
         fail "macro settors are not allowed" if /=$/===name
 
+        self.args||=[]
+        args.unshift VarNode.allocate.replace(["receiver"])
+        self.walk{|parent,i,subi,node| #replace self kw in body with receiver var instead
+          if VarLikeNode===node and node.ident=="self"
+            if subi
+              parent[i][subi]=VarNode.allocate.replace(["receiver"])
+            else
+              parent[i]=VarNode.allocate.replace(["receiver"])
+            end
+          end
+          true
+        }
+
           #macro definitions need to be dealt with in 2 steps: registration and activation
-        name=self.name
+#        name=self.name
         self[1]="macro_"+name unless /^macro_/===name
         node=MethodNode[*self]  #convert macro node to a method def node
         huh(node.receiver) if node.receiver
@@ -409,15 +477,15 @@ class Macro
         #disable postponement (delayed macros) ... i think they're not necessary
         expand=proc{|x| Node===x ? Macro.expand(x,macros,session) : x}
         node.receiver= expand[node.receiver]
-        node.args.map! &expand if node.args
+        node.args.map!( &expand )if node.args
         node.body= expand[node.body]
-        node.rescues.map! &expand if node.rescues
+        node.rescues.map!( &expand )if node.rescues
         node.ensure_= expand[node.ensure_]
         node.else_= expand[node.else_]
-        node.eval
+        node.eval(nil,session[:filename])
         macros[name.to_sym]=::Object.method("macro_"+name)
         return node,false
-
+=begin was
         #node.eval #no, not here....
 
         newnode=Macro.postpone node, session
@@ -441,6 +509,7 @@ class Macro
         #newnode=RedParse::VarLikeNode["nil", {:@value=>false,}]
         #subi ? parent[i][subi]=newnode : parent[i]=newnode          
         return newnode,false #dont keep recursing
+=end
     end
   end
 
@@ -478,12 +547,12 @@ class Macro
       #if this callsite names a macro, then it is a macro
       #macro=macros[name.to_sym]=::Object.method(macro) if String===macro
       #refuse macro calls with receivers, blocks, varargs, or &args: not supported yet
-      fail "macro receivers not supported yet" if receiver
       fail "macro blocky args not supported yet" if UnOpNode===args.last and args.last.ident=="&@"
       fail "macro varargs calls not supported yet" if UnaryStarNode===args.last
       fail if args.class!=Array
+      args.unshift receiver||VarLikeNode.allocate.replace(["self"])
       if block
-        newnode=macro.call *args do |*bparams|
+        newnode=macro.call( *args )do |*bparams|
                   if !blockparams
                     block
                   else
@@ -494,28 +563,31 @@ class Macro
                   end
                 end
       else
-        newnode=macro.call *args
+        newnode=macro.call( *args )
       end
       #subi ? parent[i][subi]=newnode : parent[i]=newnode
 
       # and keep recursing, no matter what, by all means!!
-      newnode||=NopNode.new
-      newnode=Macro.expand newnode,macros,session #just do it here
-      newnode=OneLineParenedNode[newnode] #disable newlines in macro text
+      if newnode
+        newnode=Macro.expand newnode,macros,session #just do it here
+        newnode=OneLineParenedNode[newnode] #disable newlines in macro text
+      else
+        newnode=JustNilNode.new
+      end
       return newnode,false                        #and not in caller
-     end
-   end
+    end
+  end
 
-   #postpone macro expansion in methods til method defn is executed
-   class MethodNode
+  #postpone macro expansion in methods til method defn is executed
+  class MethodNode
      def old_macro_expand(macros,session)
        if session[:@expand_in_defs]
          session[:@expand_in_defs]=false
            expand=proc{|x| Node===x ? Macro.expand(x,macros,session) : x}
            self.receiver= expand[receiver]
-           args.map! &expand if args
+           args.map!( &expand )if args
            self.body= expand[body]
-           rescues.map! &expand if rescues
+           rescues.map!( &expand )if rescues
            self.ensure_= expand[ensure_]
            self.else_= expand[else_]
          session[:@expand_in_defs]=true
@@ -527,17 +599,17 @@ class Macro
      def macro_expand(macros,session)
        expand=proc{|x| Node===x ? Macro.expand(x,macros,session) : x}
        self.receiver= expand[receiver]
-       args.map! &expand if args
+       args.map!( &expand )if args
        self.body= expand[body]
-       rescues.map! &expand if rescues
+       rescues.map!( &expand )if rescues
        self.ensure_= expand[ensure_]
        self.else_= expand[else_]
        return self,false
      end
-   end
+  end
 
-   #disable macro definitions within classes and modules
-   module DisableMacros
+  #disable macro definitions within classes and modules
+  module DisableMacros
      def macro_expand(macros,session)
         old_unsure=session[:@modpath_unsure]
         old_namespace_type=session[:@namespace_type]
@@ -558,7 +630,7 @@ class Macro
         else
           unwind=1
         end
-        session[:@modpath].push *name
+        session[:@modpath].push( *name )
 
         map!{|n| 
             case n
@@ -579,25 +651,32 @@ class Macro
 
         return nil,false #halt further recursion: already done
      end
-   end
-   class ModuleNode; include DisableMacros; end
-   class ClassNode; include DisableMacros; end
+  end
+  class ModuleNode; include DisableMacros; end
+  class ClassNode; include DisableMacros; end
 
-   class MetaClassNode
+  class MetaClassNode
      def macro_expand(macros,session)
         old_unsure=session[:@modpath_unsure]
         session[:@modpath_unsure]=true
-        map!{|n| Macro.expand(n,macros,session) if n}
+        map!{|n| 
+            case n
+            when nil
+            when Node; Macro.expand(n,macros,session)
+            when Array; n.map!{|nn| Macro.expand(nn,macros,session) }
+            else fail
+            end
+        }
         session[:@modpath_unsure]=old_unsure
 
         return nil,false #halt further recursion: already done
      end
-   end
+  end
 
-   #postpone macro expansion (and definition) in forms until they are evaled
-   #(or returned from a macro)
-   #but not in form parameters
-   class FormNode < ValueNode
+  #postpone macro expansion (and definition) in forms until they are evaled
+  #(or returned from a macro)
+  #but not in form parameters
+  class FormNode < ValueNode
      def macro_expand(macros,session)
        #return text.to_sexp({})
    
@@ -632,9 +711,9 @@ class Macro
        end
        return result
      end
-   end
+  end
 
-   class FormParameterNode<ValueNode
+  class FormEscapeNode<ValueNode
      # Convert this node to an S-expression
      #
      # +session+:: the context in which this macro is being processed
@@ -643,7 +722,7 @@ class Macro
        nest=session[:form_nest_level]||1
        carets=0
        node=self
-       while FormParameterNode===node
+       while FormEscapeNode===node
          node=node.text
          carets+=1
        end
@@ -655,9 +734,9 @@ class Macro
      end
 
      def image
-        "^"+first.image
+        "^"+body.image
      end
-   end
+  end
 
   class MacroNode < ValueNode
     param_names(:defword_,:receiver,:name,:args,:semi_,:body,:rescues,:elses,:ensures,:endword_)
@@ -702,7 +781,7 @@ class Macro
     alias ensure_ ensures
     alias ensure ensures
 
-    # Performs the reverse of a parse operation (turns the node into a
+    # Performs the reverse of a parse operation (turns the MacroNode into a
     # string)
     #
     # +o+:: a list of options for unparse
@@ -717,7 +796,7 @@ class Macro
         result+=")"
       end
       result+=unparse_nl(body,o)+body.unparse(o) if body
-      result+=rescues.map{|resc| resc.unparse o}.to_s
+      result+=rescues.map{|resc| resc.unparse o}.to_s if rescues
       result+=unparse_nl(else_,o)+"else "+else_.unparse( o )+"\n" if else_
       result+=unparse_nl(ensure_,o)+"ensure "+ensure_.unparse( o )+"\n" if ensure_
       result+=";end"
@@ -727,7 +806,8 @@ class Macro
 
   class OneLineParenedNode < ParenedNode
     #hacky way to get unparser to not emit newlines in most cases
-    def unparse(o=default_parse_options)
+    #I think this isn't necessary now that forms (and subnodes) have their linenums zeroed on creation
+    def unparse(o=default_unparse_options)
       old_linenum=o[:linenum]
       o[:linenum]=2**128
       result=super(o)
@@ -737,22 +817,146 @@ class Macro
     end
   end
 
-  class RedParseWithMacros < RedParse
+  class JustNilNode<ValueNode
+    def unparse(o=default_unparse_options)
+      "nil"
+    end
+  end
+
+  class ::RubyLexer
+
+    module MacroMixin
+      #-----------------------------------
+      #def FUNCLIKE_KEYWORDS(orig=nil) #was
+      #  /(?:#{orig||super}|^v$)/
+      #end
+
+      #-----------------------------------
+      def rubylexer_modules_init 
+        super
+        
+        @unary_or_binary_chars.add '^'
+        @always_binary_chars.remove '^'
+
+      #  @FUNCLIKE_KEYWORDS=FUNCLIKE_KEYWORDS @FUNCLIKE_KEYWORDS unless @FUNCLIKE_KEYWORDS==="v" #was
+      end
+      #def keyword_v(*args,&block) _keyword_funclike(*args,&block) end #was
+
+      def keyword_macro(*args)
+        keywords_def(*args)
+      end
+
+      #-----------------------------------
+      def method_params?
+        lasttok=last_token_maybe_implicit #last_operative_token
+        return super unless lasttok
+        case lasttok.ident
+        when ';'
+          if VContext===@parsestack.last
+            @parsestack.pop
+            true
+          #else super  #need this here...? I think not ....
+          end
+        when ')'
+          @moretokens<<KeywordToken.new("<doubled-parens>")
+          @parsestack.pop if VContext===@parsestack.last
+          true
+        when '.'
+          true
+        else super
+        end
+      end
+
+      #-----------------------------------
+      def keyword_v(str,offset,result)
+        result[0]=OperatorToken.new("v",offset)
+        @parsestack<<VContext.new(@linenum)
+        return result
+      end
+
+      #-----------------------------------
+      def symbol_or_op(ch) #is this even needed?
+        startpos= input_position
+        if readahead(2)==":("
+          result= OperatorToken.new(read(1), startpos)
+          result.unary=true
+          return result
+        end
+        super
+      end
+ 
+      #-----------------------------------
+      def caret(ch) #match /^=?/ (^ or ^=) (maybe unary ^ too) #is this even needed?
+        if @last_token_maybe_implicit&&@last_token_maybe_implicit.ident=='(' or 
+          unary_op_expected?(ch)
+          result=OperatorToken.new(read(1),input_position)
+          result.unary=true
+          result
+        else
+          super
+        end
+      end
+
+      #-----------------------------------
+      def callsite_symbol(x) #is this even needed?
+        return if nextchar==?(
+        super
+      end
+    end
+
+    module NestedContexts
+      class VContext<NestedContext
+        def initialize(linenum)
+          super("v","",linenum)
+        end
+        def see evt,lexer
+          lexer.parsestack.pop if evt==:semi and lexer.readahead(1)!='('
+        end
+      end
+    end
+
+  end
+
+  module ::RedParse::MacroMixin
+    RedParse.constants.each{|k|
+      const_set k, RedParse::const_get(k)
+    }
+
+    def redparse_modules_init
+      if defined? @lexer and @lexer.respond_to? :enable_macros!
+        @lexer.enable_macros!
+        @lexer.extend ::RubyLexer::MacroMixin
+        @lexer.rubylexer_modules_init
+      end
+      # binary
+      @unary_or_binary_op=/^([\^:]|#@unary_or_binary_op)$/
+
+
+      super
+    end
+
     def PRECEDENCE
       result=super
-      return result.merge({"^@"=>result["+@"]})
+      return result.merge({"^@"=>result["+@"], "v"=>result[";"]})
     end
+
     def RULES
+      @@soft_nl||=KW(';')&-{:not_real? =>false}
       [
         -[KW('macro'), KW(beginsendsmatcher).~.*, KW('end'), KW(/^(do|\{)$/).~.la]>>MisparsedNode
       ]+super+[
-        -[Op('^@'), Expr, lower_op()]>>FormParameterNode,
-        -[Op(':@'), (ParenedNode&-{:size=>1})|(VarLikeNode&-{:ident=>"nil"})]>>FormNode,
+        -['<+', Expr, '+>']>>FormEscapeNode, 
+        -[Op('v'), Expr, lower_op()]>>FormEscapeNode, 
+        -[Op('v'), Expr, /^;$|^<doubled-parens>$/, '(', Expr.-, ')']>>FormEscapeNode, #constructor needs update
+        -[Op('v'), Expr, ';', KW('(').~.la]>>FormEscapeNode,
+        -[Op('v'), Expr, @@soft_nl.la]>>:shift,
+        -[Op('^@'), Expr, lower_op()]>>FormEscapeNode,
+        -[Op(':@'), (ParenedNode&-{:size=>(0..1)})|(SequenceNode&-{:size=>0})]>>FormNode,
         -['macro', CallSiteNode, KW(';'),
            Expr.-, RescueNode.*, ElseNode.-, EnsureNode.-,
           'end'
          ]>>MacroNode,
-        -[ParenedNode, '(', Expr.-, ')', BlockNode.-, KW('do').~.la]>>CallNode,
+        -[ '(', Expr.-, ')', '<doubled-parens>', '(', Expr.-, ')', BlockNode.-, KW('do').~.la]>>CallNode, #constructor needs update
       ]
     end
     def wants_semi_context
@@ -768,14 +972,45 @@ class Macro
       return @bem||=/#{super}|^macro$/ 
     end
 
-    def initialize(*args)
-      super
-      @lexer.enable_macros! if @lexer.respond_to? :enable_macros!
+    def reduce_withs_directory
+      "macro"
+    end
 
-      # Add ^ to the list of operators that could be either unary or
-      # binary
-      @unary_or_binary_op=/^([\^:]|#@unary_or_binary_op)$/o
+    def rubyoperatorlist
+      super+%w[:@ ^@ v] 
+    end
+
+    def rubykeywordlist
+      super+%w[macro v]
+    end
+
+    def addl_node_containers; [::Macro] end
+
+    def initialize(*args,&block)
+      super
     end
   end
+  Macro_ParserMixin=::RedParse::MacroMixin #old name
+
+  class ::RedParse::WithMacros < RedParse
+    include ::RedParse::MacroMixin
+  end
+  RedParseWithMacros=::RedParse::WithMacros #old name
 end
 
+#hacks to allow you to use macros within irb sessions.
+#I wonder how portable this is to rubinius, jruby, mri 1.9, etc
+module IRB
+  class WorkSpace
+    def evaluate(context, statements, file = __FILE__, line = __LINE__)
+      Macro.eval(statements, @binding, file, line)
+    end
+  end
+  ::RubyLex::ENINDENT_CLAUSE<<"macro"
+  module ::RubyToken
+    def_token(:TkMACRO,        TkId,  "macro",    EXPR_FNAME)
+  end
+  def IRB.require(file)
+    Macro.require(file)
+  end
+end if defined? IRB