rubymacros 0.1.4 → 0.1.5

data/History.txt

@@ -1,3 +1,15 @@
+=== 0.1.5 / 2009-07-04
+* 4 Major Enhancements:
+  * all macros are now immediate, not delayed
+  * macro calls can accept blocks
+  * macro calls need not be inside a method
+  * form escapes can stand in for a method name in callsites
+* 4 Minor Enhancements:
+  * macros can expand to nop by returning nil
+  * form escapes whose value is a symbol become callsites now
+  * forms can now be catenated together with + in the obvious way
+  * HashLiteralNode can be treated somewhat like a real hash, using #get
+
 === 0.1.4 / 2009-05-21
 * 1 Major Enhancement:
   * line numbers are now preserved in preprocessed code; 

data/Rakefile

@@ -19,8 +19,7 @@ require 'lib/macro/version.rb'
 
    readme=open("README.txt")
    readme.readline("\n== DESCRIPTION:")
-   readme.readline("\n\n")
-   desc=readme.readline("\n\n")
+   desc=readme.readline("\n==")
  
    hoe=Hoe.new("rubymacros", Macro::VERSION) do |_|
      _.author = "Caleb Clausen"

data/TODO

@@ -4,6 +4,9 @@ macro options
   precedence for operator macros
   hygienic vs unhygienic
 
+need to insert extra parens around form params
+  except only if it stands in for an rvalue...
+  not if its an lvalue, mvalue, cvalue, etc (bvalue?)
 static selector namespaces?
 
 other types of macro:

data/example/assert.rb

@@ -1,18 +1,14 @@
 #this file uses macros! won't parse in normal ruby
-$Debug=1
-if $Debug
-  macro assert(cond)
-    if RedParse::OpNode===cond and /\A[=!]=\Z/===cond.op
-      left,op,right=*cond
-      :(fail 'expected '+^left.unparse+"(==#{^left}) to be "+
-             ^op+" "+^right.unparse+"(==#{^right})" unless ^cond)    
-    else
-      :(fail "expected #{:(^^cond)}, but was not true" unless ^cond)
+macro assert(cond)
+    if $Debug
+      if RedParse::OpNode===cond and /\A[=!]=\Z/===cond.op
+        left,op,right=*cond
+        :(fail 'expected '+^left.unparse+"(==#{^left}) to be "+
+               ^op+" "+^right.unparse+"(==#{^right})" unless ^cond)    
+      else
+        :(fail "expected #{:(^^cond)}, but was not true" unless ^cond)
+      end
     end
-  end
-else
-  macro assert(cond)
-  end
 end
 
 
@@ -29,7 +25,7 @@ def test_assert
     assert(a==b) #oops, fails. msg="expected a(==1) to be == b(==2)"
   rescue Exception=>e
     assert("expected a(==1) to be == b(==2)"== e.message) #better be ok
-  else fail
+  else puts "exception expected but was not seen"
   end
 
   begin
@@ -37,6 +33,6 @@ def test_assert
   rescue Exception=>e
     assert("expected nil, but was not true"== e.message) #better be ok
     #ok, that message didn't make a lot of sense...
-  else fail
+  else puts "exception expected but was not seen"
   end
 end

data/example/assert_wrap.rb

@@ -1,4 +1,5 @@
 require 'macro'
+$Debug=1
 Macro.require 'example/assert'
 
 test_assert

data/lib/macro.rb

@@ -16,16 +16,11 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 =end
 
-#$:.unshift "../redparse/lib"
-#warn "$: hacked up to find latest redparse"
-
 require 'rubygems'
 require 'redparse'
 require "macro/form"
 require "macro/version"
 
-warn "need to insert extra parens around form params"
-
 class Object # :nodoc:
   #as close as I can get to an empty binding (used below in Macro.eval)
   def Object.new_binding() # :nodoc:
@@ -204,6 +199,8 @@ class Macro
   # +session+:: the context in which this macro is being processed
   #
   def Macro.postpone node,session
+      return node #disable postponement
+
       filename=session[:filename]
       unless session[:@modpath_unsure]
         modpath=ConstantNode[nil,*session[:@modpath]] 
@@ -409,8 +406,19 @@ class Macro
         node[0]=ParenedNode[ConstantNode[nil,"Object"]] #all macros are global for now... til we get scoped macros
         #sets receiver
 
+        #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.body= expand[node.body]
+        node.rescues.map! &expand if node.rescues
+        node.ensure_= expand[node.ensure_]
+        node.else_= expand[node.else_]
+        node.eval
+        macros[name.to_sym]=::Object.method("macro_"+name)
+        return node,false
+
         #node.eval #no, not here....
-#        macros[name.to_sym]=self.name
 
         newnode=Macro.postpone node, session
 
@@ -471,14 +479,27 @@ class 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 blocks not supported yet" if block or blockparams
-      fail "macro block args not supported yet" if UnOpNode===args.last and args.last.ident=="&@"
+      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
-      newnode=macro.call *args
+      if block
+        newnode=macro.call *args do |*bparams|
+                  if !blockparams
+                    block
+                  else
+                    bparams=KWCallNode["nil"] if bparams.empty?
+                    #warning: scoping rules for lvars in blocks not enforced here
+                    #(rather serious violation of variable hygiene)
+                    ParenedNode[ AssignNode[MultiAssign[*blockparams],'=',bparams]+block ]
+                  end
+                end
+      else
+        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
       return newnode,false                        #and not in caller
@@ -487,7 +508,7 @@ class Macro
 
    #postpone macro expansion in methods til method defn is executed
    class MethodNode
-     def macro_expand(macros,session)
+     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}
@@ -503,6 +524,16 @@ class Macro
          return Macro.postpone(self,session),false
        end
      end
+     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
+       self.body= expand[body]
+       rescues.map! &expand if rescues
+       self.ensure_= expand[ensure_]
+       self.else_= expand[else_]
+       return self,false
+     end
    end
 
    #disable macro definitions within classes and modules
@@ -622,6 +653,10 @@ class Macro
          return super
        end
      end
+
+     def image
+        "^"+first.image
+     end
    end
 
   class MacroNode < ValueNode
@@ -641,6 +676,25 @@ class Macro
           fail "unrecognized method header: #{header}"
         end
         @data=replace [receiver,header,args,body,rescues,else_,ensure_]
+
+=begin hmm, maybe not a good idea....
+        #quote parameters to yield within macro
+        walk{|cntr,i,subi,item|
+          case item
+          when KWCallNode;
+            if item.name=="yield" 
+              raise ArgumentError if item.block or item.blockparams
+              if item.params
+                raise ArgumentError if UnAmpNode===item.params.last
+                item.params.map!{|param| FormNode.new(nil,ParenedNode[param]) }
+              end
+              false
+            else true
+            end
+          else true
+          end
+        }
+=end
     end
 
     alias else_ elses
@@ -698,6 +752,7 @@ class Macro
            Expr.-, RescueNode.*, ElseNode.-, EnsureNode.-,
           'end'
          ]>>MacroNode,
+        -[ParenedNode, '(', Expr.-, ')', BlockNode.-, KW('do').~.la]>>CallNode,
       ]
     end
     def wants_semi_context

data/lib/macro/form.rb

@@ -48,6 +48,11 @@ class Macro
       rebuild_transform
     end
 
+    def initialize_ivars
+      rebuild_transform
+      super
+    end
+
     # Initialize the transform and create all the form escapes that are
     # used in this form
     def rebuild_transform
@@ -114,15 +119,20 @@ class Macro
       ":("+text.unparse(o)+")"
     end
 
-    # Called when the form is evaluated to ensure that the abstract form
-    # in the parse tree is a concrete form that can be modified (makes a
+    # Called when the form is evaluated to convert the abstract form
+    # of the parse tree into a concrete form that can be modified (makes a
     # copy of the form).
     #
     # +transform+:: the transform to use in the deep copy
     #
     def reify transform
       transform.each_pair{|k,v|
-        transform[k]=Macro.quote(v) unless Node===v or VarNameToken===v
+        case v
+        when Node; next
+        when Symbol; v=CallNode[nil,v.to_s]
+        else v=Macro.quote v
+        end
+        transform[k]=v
       }
       deep_copy(transform)
     end
@@ -161,17 +171,13 @@ class Macro
     #   RedParse::SomeNodeType[ some transform of code ]
     #
     def parses_like
-      # TODO: either split this into mulitple lines or multiple methods
-      # possibly formname() should return the ConstantNode portion of
-      # the below expression (so that we have one "name" for the form
-      # instead of two representations of the same name)
-      CallSiteNode[CallSiteNode[ConstantNode[nil,"Macro","Names",formname], "reify", [@transform],nil,nil], "text", nil,nil,nil]
-      #:(::Macro::Names::^(formname).reify.text)
+      CallSiteNode[CallSiteNode[formname, "reify", [@transform]], "text"]
+      #:(^(formname).reify(^@transform).text)
     end
     
     # Lazily evaluate the name of the form and return it
     def formname
-      @formname ||= ::Macro::Names.request(self)
+      @formname ||= ConstantNode[nil,"Macro","Names",::Macro::Names.request(self)]
     end
   end
 

data/lib/macro/version.rb

@@ -18,5 +18,5 @@
 
 
 class Macro
-  VERSION="0.1.4"
+  VERSION="0.1.5"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rubymacros
 version: !ruby/object:Gem::Version 
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors: 
 - Caleb Clausen
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-22 00:00:00 -07:00
+date: 2009-07-07 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,7 +32,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 1.12.2
     version: 
-description: Macros are programmed in ruby itself. And since parse trees are represented  in RedParse format, they're easier to use (programatically) and more object-oriented than other available ruby parsetree formats. (RedParse Node format  is actually designed to be straightforward to use and to represent the  structure of ruby source code very closely.)
+description: RubyMacros is a lisp-like macro pre-processor for Ruby. More than just a  purely textual substitution scheme, RubyMacros can manipulate and morph  Ruby parse trees (in the form of RedParse Nodes) at parse time in just about  any way you see fit.   Macros are programmed in ruby itself. And since parse trees are represented  in RedParse format, they're easier to use (programatically) and more object-oriented than other available ruby parsetree formats. (RedParse Node format  is actually designed to be straightforward to use and to represent the  structure of ruby source code very closely.)  ==
 email: rubymacros-owner @at@ inforadical .dot. net
 executables: []
 
@@ -97,6 +97,6 @@ rubyforge_project: rubymacros
 rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
-summary: Macros are programmed in ruby itself.
+summary: RubyMacros is a lisp-like macro pre-processor for Ruby.
 test_files: 
 - test/test_all.rb