newline fiddling in the parser yields goods results

lib/parser/control.rb

@@ -2,13 +2,13 @@ module Parser
   module Control
     include Parslet
     rule(:conditional) do
-      keyword_if >> left_parenthesis >> expression.as(:conditional) >> right_parenthesis >> newline >>
-        expressions_else.as(:if_true) >> expressions_end.as(:if_false)
+      keyword_if >> left_parenthesis >> (simple_expression|operator_expression).as(:conditional) >> right_parenthesis >> newline >>
+        expressions_else.as(:if_true) >> newline >> expressions_end.as(:if_false)
       end
     
     rule(:while_do) do
-      keyword_while  >> left_parenthesis >> expression.as(:while_cond)  >> right_parenthesis >> 
-                                                                    keyword_do >> newline >> 
+      keyword_while  >> left_parenthesis >> (simple_expression|operator_expression).as(:while_cond)  >>
+                                          right_parenthesis >> keyword_do >> newline >>
                               expressions_end.as(:body)
     end
   end

lib/parser/expression.rb

@@ -3,10 +3,11 @@ module Parser
     include Parslet
     
     rule(:simple_expression) { function_call | integer | string | name }
-    rule(:expression) { (while_do | conditional | simple_expression ) >> newline.maybe }
+
+    rule(:expression) { (while_do | conditional | operator_expression | function_call ) >> newline }
 
     def delimited_expressions( delimit )
-      ( (delimit.absent? >> (operator_expression | expression)).repeat(1)).as(:expressions) >> delimit >> newline.maybe
+      ( (delimit.absent? >> expression).repeat(1)).as(:expressions) >> delimit
     end
 
     rule(:expressions_do)     { delimited_expressions(keyword_do) }

lib/parser/function_definition.rb

@@ -3,7 +3,7 @@ module Parser
     include Parslet
     
     rule(:function_definition) {
-      keyword_def >> name.as(:function_definition) >> parmeter_list >> newline >> expressions_end
+      keyword_def >> name.as(:function_name) >> parmeter_list >> newline >> expressions_end >> newline
     }
 
     rule(:parmeter_list) {

lib/parser/operators.rb

@@ -23,7 +23,7 @@ module Parser
   
     #infix doing the heavy lifting here, 
     # is defined as an expressions and array of [atoms,priority,binding] triples
-    rule(:operator_expression) do infix_expression(expression,  
+    rule(:operator_expression) do infix_expression(simple_expression,
                                      [exponent, 120, :left] ,
                                      [multiply, 120, :left] ,
                                      [plus, 110, :left],

lib/parser/transform.rb

@@ -33,10 +33,10 @@ module Parser
     rule(:parmeter  => simple(:parmeter))    { parmeter  }
     rule(:parmeter_list => sequence(:parmeter_list)) { parmeter_list }
 
-    rule(:function_definition   => simple(:function_definition),
+    rule(:function_name   => simple(:function_name),
          :parmeter_list => sequence(:parmeter_list),
          :expressions   => sequence(:expressions) , :end => simple(:e)) do
-            Ast::FunctionExpression.new(function_definition.name, parmeter_list, expressions) 
+            Ast::FunctionExpression.new(function_name.name, parmeter_list, expressions) 
           end
     
     rule(l: simple(:l), o: simple(:o) , r: simple(:r)) do