add qualification to function definitions

lib/ast/function_expression.rb

@@ -1,16 +1,19 @@
 module Ast
   class FunctionExpression < Expression
-    attr_reader  :name, :params, :body
-    def initialize name, params, body
-      @name, @params, @body = name.to_sym, params, body
+    attr_reader  :name, :params, :body , :receiver
+    def initialize name, params, body , receiver = nil
+      @name = name.to_sym
+      @params =  params
+      @body = body
+      @receiver = receiver
     end
     def attributes
-      [:name, :params, :body]
+      [:name, :params, :body , :receiver]
     end
     def inspect
       self.class.name + ".new(" + name.inspect + ", ["+ 
         params.collect{|m| m.inspect }.join( ",") +"] , [" + 
-        body.collect{|m| m.inspect }.join( ",") +"] )"  
+        body.collect{|m| m.inspect }.join( ",") +"] ,"+  receiver.inspect + " )"
     end
     
     def to_s

lib/parser/function_definition.rb

@@ -3,7 +3,8 @@ module Parser
     include Parslet
     
     rule(:function_definition) {
-      keyword_def >> name.as(:function_name) >> parmeter_list >> newline >> expressions_end >> newline
+      keyword_def >> ((module_name|instance_variable|name).as(:receiver) >> str(".")).maybe >> #possibly qualified
+                  name.as(:function_name) >> parmeter_list >> newline >> expressions_end >> newline
     }
 
     rule(:parmeter_list) {

lib/parser/transform.rb

@@ -21,6 +21,7 @@ module Parser
     rule(:argument  => simple(:argument))    { argument  }
     rule(:argument_list => sequence(:argument_list)) { argument_list }
 
+    #Two rules for calls, simple and qualified. Keeps the rules simpler
     rule( :call_site => simple(:call_site), 
           :argument_list    => sequence(:argument_list)) do
            Ast::CallSiteExpression.new(call_site.name, argument_list )
@@ -49,17 +50,25 @@ module Parser
     rule(:parmeter  => simple(:parmeter))    { parmeter  }
     rule(:parmeter_list => sequence(:parmeter_list)) { parmeter_list }
 
+    # Also two rules for function definitions, unqualified and qualified
     rule(:function_name   => simple(:function_name),
          :parmeter_list => sequence(:parmeter_list),
          :expressions   => sequence(:expressions) , :end => simple(:e)) do
-            Ast::FunctionExpression.new(function_name.name, parmeter_list, expressions) 
+            Ast::FunctionExpression.new(function_name.name, parmeter_list, expressions)
           end
-    
+
+    rule(:receiver=> simple(:receiver),
+         :function_name   => simple(:function_name),
+         :parmeter_list => sequence(:parmeter_list),
+         :expressions   => sequence(:expressions) , :end => simple(:e)) do
+            Ast::FunctionExpression.new(function_name.name, parmeter_list, expressions , receiver)
+          end
+
     rule(l: simple(:l), o: simple(:o) , r: simple(:r)) do 
       Ast::OperatorExpression.new( o.to_s.strip , l ,r)
     end
     
-    #modules and classes are undertsndibly quite similar   Class < Module
+    #modules and classes are understandibly quite similar   Class < Module
     rule( :module_name => simple(:module_name) , :module_expressions => sequence(:module_expressions) , :end=>"end") do
       Ast::ModuleExpression.new(module_name , module_expressions)
     end