Fixed operator parsing

- Fixed parsing of word operators (and, or..)
- Fixed tests
- Optimized parser_extensions performance
- Removed redundant code

lib/spoon/parser.rb

@@ -95,7 +95,7 @@ def initialize
     # Matches everything that starts with '#' until end of line
     # example: # abc
     rule(:comment) {
-      sym("#") >>
+      str("#") >>
       stop
     }
 
@@ -117,7 +117,7 @@ def initialize
       (
         chain_value >>
         (
-          op(".") >>
+          trim(str(".")) >>
           chain_value
         ).repeat(1)
       ).as(:chain)
@@ -135,6 +135,7 @@ def initialize
     # example: return a, b, c
     rule(:ret) {
       key("return") >>
+      space.maybe >>
       parens(expression_list).maybe.as(:return)
     }
 
@@ -158,7 +159,7 @@ def initialize
     # example: (a, b)
     rule(:parameter_list) {
       parameter >> (
-        op(",") >>
+        trim(str(",")) >>
         parameter
       ).repeat
     }
@@ -168,7 +169,7 @@ def initialize
     rule(:parameter) {
       word.as(:name) >>
       (
-        op("=") >>
+        trim(str("=")) >>
         expression.as(:value)
       ).maybe
     }
@@ -178,36 +179,30 @@ def initialize
     rule(:expression_list) {
       expression >>
       (
-        op(",") >>
+        trim(str(",")) >>
         expression
       ).repeat
     }
 
     # Matches operator
     rule(:operator) {
       (
-        whitespace.maybe >>
-        match['\+\-\*\/%\^><\|&='].as(:op) >>
-        whitespace.maybe
-      ) |
-      op(
-        [
-          "or",
-          "and",
-          "is",
-          "isnt",
-          "<=",
-          ">=",
-          "!=",
-          "==",
-          "+=",
-          "-=",
-          "*=",
-          "/=",
-          "%=",
-          "or=",
-          "and="
-        ]
+        str("<=") |
+        str(">=") |
+        str("!=") |
+        str("==") |
+        str("+=") |
+        str("-=") |
+        str("*=") |
+        str("/=") |
+        str("%=") |
+        str("and=") |
+        str("or=") |
+        key("or") |
+        key("and") |
+        key("is") |
+        key("isnt") |
+        match['\+\-\*\/%\^><\|&=']
       ).as(:op)
     }
 
@@ -216,7 +211,7 @@ def initialize
     rule(:closure) {
       (
         parens(parameter_list.as(:parameters)).maybe >>
-        op("->") >>
+        trim(str("->")) >>
         body.as(:body)
       ).as(:closure)
     }
@@ -227,7 +222,7 @@ def initialize
         statement |
         (
           value.as(:left) >>
-          operator >>
+          trim(operator) >>
           value.as(:right)
         ) | value
       ) >> endofline.maybe
@@ -238,6 +233,7 @@ def initialize
     rule(:function) {
       (
         key("function") >>
+        space.maybe >>
         word.as(:name) >>
         space.maybe >>
         function_body
@@ -258,12 +254,14 @@ def initialize
     rule(:condition) {
       (
         key("if") >>
+        space.maybe >>
         parens(expression.as(:body)) >>
         space.maybe >>
         body.as(:if_true) >>
         (
           space.maybe >>
           key("else") >>
+          space.maybe >>
           body.as(:if_false)
         ).maybe
       ).as(:condition)

lib/spoon/util/parser_extensions.rb

@@ -5,60 +5,26 @@ module Spoon
   module Util
     # Monkey-patch the parser to include some common methods
     class Parslet::Parser
-      # Stores string as key, matches it and then skips space after it
-      private def store_keyword(value)
-        @keywords = [] if @keywords.nil?
-        @keywords.push value unless @keywords.include? value
-
-        str(value)
+      def initialize
+        super
+        @keywords = []
       end
 
       # Matches only if you are not trying to match any previously stored key
       rule(:skip_key) {
-        if @keywords.nil? or @keywords.empty?
-          always_match
-        else
-          result = str(@keywords.first).absent?
-
-          for keyword in @keywords
-            result = result >> str(keyword).absent?
-          end
+        result = str(@keywords.first).absent?
 
-          result
+        for keyword in @keywords
+          result = result >> str(keyword).absent?
         end
-      }
 
-      # Matches string and skips space after it
-      def sym(value)
-        if value.kind_of?(Array)
-          result = str(value.first)
-          value.each { |val| result |= str(val) }
-          result >> space.maybe
-        else
-          str(value) >> space.maybe
-        end
-      end
+        result
+      }
 
-      # Matches keyword and skips space after it
+      # Stores string as key and matches it
       def key(value)
-        if value.kind_of?(Array)
-          result = store_keyword(value.first)
-          value.each { |val| result |= store_keyword(val) }
-          result >> space.maybe
-        else
-          store_keyword(value) >> space.maybe
-        end
-      end
-
-      # Matches string or keyword, based on if it is word or not
-      def op(value)
-        if value.kind_of?(Array)
-          result = whitespace.maybe >> (/\w/.match(value.first) ? key(value.first) : sym(value.first))
-          value.each { |val| result |= (/\w/.match(val) ? key(val) : sym(val)) }
-          result >> whitespace.maybe
-        else
-          trim(/\w/.match(value) ? key(value) : sym(value))
-        end
+        @keywords.push value unless @keywords.include? value
+        str(value)
       end
 
       # Trims all whitespace around value

spec/parser_spec.rb

@@ -2,6 +2,11 @@
 
 describe Spoon::Parser do
   let(:parser) { Spoon::Parser.new }
+  context "block parsing" do
+    subject { parser.block }
+
+    it { should parse "\n  return this\n  return that\n" }
+  end
 
   context "call parsing" do
     subject { parser.call }
@@ -66,12 +71,6 @@
     it { should_not parse "function test me it he" }
   end
 
-  context "indent parsing" do
-    subject { parser }
-
-    it { should parse "function hello(a)\n  return this\n  return that\n" }
-  end
-
   context "number parsing" do
     subject { parser.number }