hotdog 0.12.0 → 0.13.0

data/lib/hotdog/expression/syntax.rb

@@ -0,0 +1,176 @@
+#!/usr/bin/env ruby
+
+require "parslet"
+
+module Hotdog
+  module Expression
+    class ExpressionParser < Parslet::Parser
+      root(:expression)
+      rule(:expression) {
+        ( expression0 \
+        )
+      }
+      rule(:expression0) {
+        ( expression1.as(:left) >> spacing.maybe >> binary_op.as(:binary_op) >> spacing.maybe >> expression.as(:right) \
+        | expression1 \
+        )
+      }
+      rule(:expression1) {
+        ( unary_op.as(:unary_op) >> spacing >> expression.as(:expression) \
+        | unary_op.as(:unary_op) >> spacing.maybe >> str('(') >> spacing.maybe >> expression.as(:expression) >> spacing.maybe >> str(')') \
+        | expression2 \
+        )
+      }
+      rule(:expression2) {
+        ( expression3.as(:left) >> spacing.maybe.as(:binary_op) >> expression.as(:right) \
+        | expression3 \
+        )
+      }
+      rule(:expression3) {
+        ( expression4.as(:left) >> spacing.maybe >> str('&&').as(:binary_op) >> spacing.maybe >> expression.as(:right) \
+        | expression4.as(:left) >> spacing.maybe >> str('||').as(:binary_op) >> spacing.maybe >> expression.as(:right) \
+        | expression4.as(:left) >> spacing.maybe >> str('&').as(:binary_op) >> spacing.maybe >> expression.as(:right) \
+        | expression4.as(:left) >> spacing.maybe >> str(',').as(:binary_op) >> spacing.maybe >> expression.as(:right) \
+        | expression4.as(:left) >> spacing.maybe >> str('^').as(:binary_op) >> spacing.maybe >> expression.as(:right) \
+        | expression4.as(:left) >> spacing.maybe >> str('|').as(:binary_op) >> spacing.maybe >> expression.as(:right) \
+        | expression4 \
+        )
+      }
+      rule(:expression4) {
+        ( str('!').as(:unary_op) >> spacing.maybe >> primary.as(:expression) >> spacing.maybe \
+        | str('~').as(:unary_op) >> spacing.maybe >> primary.as(:expression) >> spacing.maybe \
+        | str('!').as(:unary_op) >> spacing.maybe >> expression.as(:expression) \
+        | str('~').as(:unary_op) >> spacing.maybe >> expression.as(:expression) \
+        | spacing.maybe >> primary >> spacing.maybe \
+        )
+      }
+      rule(:binary_op) {
+        ( str('AND') \
+        | str('OR') \
+        | str('XOR') \
+        | str('and') \
+        | str('or') \
+        | str('xor') \
+        )
+      }
+      rule(:unary_op) {
+        ( str('NOT') \
+        | str('not') \
+        )
+      }
+      rule(:funcall) {
+        ( funcall_identifier.as(:funcall) >> spacing.maybe >> str('(') >> spacing.maybe >> str(')') \
+        | funcall_identifier.as(:funcall) >> spacing.maybe >> str('(') >> spacing.maybe >> funcall_args.as(:funcall_args) >> spacing.maybe >> str(')') \
+        )
+      }
+      rule(:funcall_identifier) {
+        ( binary_op.absent? >> unary_op.absent? >> match('[A-Z_a-z]') >> match('[0-9A-Z_a-z]').repeat(0) \
+        | binary_op >> match('[0-9A-Z_a-z]').repeat(1) \
+        | unary_op >> match('[0-9A-Z_a-z]').repeat(1) \
+        )
+      }
+      rule(:funcall_args) {
+        ( funcall_arg.as(:funcall_args_head) >> spacing.maybe >> str(',') >> spacing.maybe >> funcall_args.as(:funcall_args_tail) \
+        | funcall_arg.as(:funcall_args_head) \
+        )
+      }
+      rule(:funcall_arg) {
+        ( float.as(:float) \
+        | integer.as(:integer) \
+        | string.as(:string) \
+        | regexp.as(:regexp) \
+        | primary \
+        )
+      }
+      rule(:float) {
+        ( match('[0-9]').repeat(1) >> str('.') >> match('[0-9]').repeat(1) \
+        )
+      }
+      rule(:integer) {
+        ( match('[1-9]').repeat(1) >> match('[0-9]').repeat(0) \
+        )
+      }
+      rule(:string) {
+        ( str('"') >> (str('"').absent? >> any).repeat(0) >> str('"') \
+        | str("'") >> (str("'").absent? >> any).repeat(0) >> str("'") \
+        )
+      }
+      rule(:regexp) {
+        ( str('/') >> (str('/').absent? >> any).repeat(0) >> str('/') \
+        )
+      }
+      rule(:primary) {
+        ( str('(') >> expression >> str(')') \
+        | funcall \
+        | tag \
+        )
+      }
+      rule(:tag) {
+        ( regexp.as(:tag_name_regexp) >> separator.as(:separator) >> regexp.as(:tag_value_regexp) \
+        | regexp.as(:tag_name_regexp) >> separator.as(:separator) \
+        | regexp.as(:tag_name_regexp) \
+        | tag_name_glob.as(:tag_name_glob) >> separator.as(:separator) >> tag_value_glob.as(:tag_value_glob) \
+        | tag_name_glob.as(:tag_name_glob) >> separator.as(:separator) >> tag_value.as(:tag_value) \
+        | tag_name_glob.as(:tag_name_glob) >> separator.as(:separator) \
+        | tag_name_glob.as(:tag_name_glob) \
+        | tag_name.as(:tag_name) >> separator.as(:separator) >> tag_value_glob.as(:tag_value_glob) \
+        | tag_name.as(:tag_name) >> separator.as(:separator) >> tag_value.as(:tag_value) \
+        | tag_name.as(:tag_name) >> separator.as(:separator) \
+        | tag_name.as(:tag_name) \
+        | separator.as(:separator) >> regexp.as(:tag_value_regexp) \
+        | separator.as(:separator) >> tag_value_glob.as(:tag_value_glob) \
+        | separator.as(:separator) >> tag_value.as(:tag_value) \
+        | tag_value_regexp.as(:tag_value_regexp) \
+        | tag_value_glob.as(:tag_value_glob) \
+        | tag_value.as(:tag_value) \
+        )
+      }
+      rule(:tag_name_regexp) {
+        ( regexp \
+        )
+      }
+      rule(:tag_value_regexp) {
+        ( regexp \
+        )
+      }
+      rule(:tag_name_glob) {
+        ( binary_op.absent? >> unary_op.absent? >> tag_name.repeat(0) >> (glob_char >> tag_name.maybe).repeat(1) \
+        | binary_op >> (glob_char >> tag_name.maybe).repeat(1) \
+        | unary_op >> (glob_char >> tag_name.maybe).repeat(1) \
+        )
+      }
+      rule(:tag_value_glob) {
+        ( binary_op.absent? >> unary_op.absent? >> tag_value.repeat(0) >> (glob_char >> tag_value.maybe).repeat(1) \
+        | binary_op >> (glob_char >> tag_value.maybe).repeat(1) \
+        | unary_op >> (glob_char >> tag_value.maybe).repeat(1) \
+        )
+      }
+      rule(:tag_name) {
+        ( binary_op.absent? >> unary_op.absent? >> match('[A-Z_a-z]') >> match('[-./0-9A-Z_a-z]').repeat(0) \
+        | binary_op >> match('[-./0-9A-Z_a-z]').repeat(1) \
+        | unary_op >> match('[-./0-9A-Z_a-z]').repeat(1) \
+        )
+      }
+      rule(:tag_value) {
+        ( binary_op.absent? >> unary_op.absent? >> match('[-./0-9:A-Z_a-z]').repeat(1) \
+        | binary_op >> match('[-./0-9:A-Z_a-z]').repeat(1) \
+        | unary_op >> match('[-./0-9:A-Z_a-z]').repeat(1) \
+        )
+      }
+      rule(:separator) {
+        ( str(':') \
+        | str('=') \
+        )
+      }
+      rule(:glob_char) {
+        ( str('*') | str('?') | str('[') | str(']') )
+      }
+      rule(:spacing) {
+        ( match('[\t\n\r ]').repeat(1) \
+        )
+      }
+    end
+  end
+end
+
+# vim:set ft=ruby :

data/lib/hotdog/version.rb

@@ -1,3 +1,3 @@
 module Hotdog
-  VERSION = "0.12.0"
+  VERSION = "0.13.0"
 end

data/spec/parser/glob_expression_spec.rb

@@ -10,7 +10,7 @@ describe "tag glob expression" do
   }
 
   it "interprets tag glob with host" do
-    expr = Hotdog::Commands::Search::GlobHostNode.new("foo*", ":")
+    expr = Hotdog::Expression::GlobHostNode.new("foo*", ":")
     q = [
       "SELECT hosts.id AS host_id FROM hosts",
         "WHERE LOWER(hosts.name) GLOB LOWER(?);",
@@ -19,11 +19,11 @@ describe "tag glob expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({identifier_glob: "host", separator: ":", attribute_glob: "foo*"})
+    expect(expr.dump).to eq({tag_name_glob: "host", separator: ":", tag_value_glob: "foo*"})
   end
 
-  it "interprets tag glob with identifier and attribute" do
-    expr = Hotdog::Commands::Search::GlobTagNode.new("foo*", "bar*", ":")
+  it "interprets tag glob with tag_name and tag_value" do
+    expr = Hotdog::Expression::GlobTagNode.new("foo*", "bar*", ":")
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
@@ -33,11 +33,11 @@ describe "tag glob expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({identifier_glob: "foo*", separator: ":", attribute_glob: "bar*"})
+    expect(expr.dump).to eq({tag_name_glob: "foo*", separator: ":", tag_value_glob: "bar*"})
   end
 
-  it "interprets tag glob with identifier with separator" do
-    expr = Hotdog::Commands::Search::GlobTagNameNode.new("foo*", ":")
+  it "interprets tag glob with tag_name with separator" do
+    expr = Hotdog::Expression::GlobTagNameNode.new("foo*", ":")
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
@@ -47,11 +47,11 @@ describe "tag glob expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({identifier_glob: "foo*", separator: ":"})
+    expect(expr.dump).to eq({tag_name_glob: "foo*", separator: ":"})
   end
 
-  it "interprets tag glob with identifier without separator" do
-    expr = Hotdog::Commands::Search::GlobNode.new("foo*", nil)
+  it "interprets tag glob with tag_name without separator" do
+    expr = Hotdog::Expression::GlobNode.new("foo*", nil)
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
@@ -62,11 +62,11 @@ describe "tag glob expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({identifier_glob: "foo*"})
+    expect(expr.dump).to eq({tag_name_glob: "foo*"})
   end
 
-  it "interprets tag glob with attribute with separator" do
-    expr = Hotdog::Commands::Search::GlobTagValueNode.new("foo*", ":")
+  it "interprets tag glob with tag_value with separator" do
+    expr = Hotdog::Expression::GlobTagValueNode.new("foo*", ":")
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
@@ -77,11 +77,11 @@ describe "tag glob expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({separator: ":", attribute_glob: "foo*"})
+    expect(expr.dump).to eq({separator: ":", tag_value_glob: "foo*"})
   end
 
-  it "interprets tag glob with attribute without separator" do
-    expr = Hotdog::Commands::Search::GlobTagValueNode.new("foo*", nil)
+  it "interprets tag glob with tag_value without separator" do
+    expr = Hotdog::Expression::GlobTagValueNode.new("foo*", nil)
     q = [
       "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
         "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
@@ -92,11 +92,11 @@ describe "tag glob expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({attribute_glob: "foo*"})
+    expect(expr.dump).to eq({tag_value_glob: "foo*"})
   end
 
   it "empty tag glob" do
-    expr = Hotdog::Commands::Search::GlobExpressionNode.new(nil, nil, nil)
+    expr = Hotdog::Expression::GlobExpressionNode.new(nil, nil, nil)
     expect {
       expr.evaluate(cmd)
     }.to raise_error(NotImplementedError)

data/spec/parser/parser_spec.rb

@@ -15,275 +15,311 @@ describe "parser" do
   end
 
   it "parses ':foo'" do
-    expect(cmd.parse(":foo")).to eq({separator: ":", attribute: "foo"})
+    expect(cmd.parse(":foo")).to eq({separator: ":", tag_value: "foo"})
   end
 
   it "parses ':foo*'" do
-    expect(cmd.parse(":foo*")).to eq({separator: ":", attribute_glob: "foo*"})
+    expect(cmd.parse(":foo*")).to eq({separator: ":", tag_value_glob: "foo*"})
   end
 
   it "parses ':/foo/'" do
-    expect(cmd.parse(":/foo/")).to eq({separator: ":", attribute_regexp: "foo"})
+    expect(cmd.parse(":/foo/")).to eq({separator: ":", tag_value_regexp: "/foo/"})
   end
 
   it "parses 'foo'" do
-    expect(cmd.parse("foo")).to eq({identifier: "foo"})
+    expect(cmd.parse("foo")).to eq({tag_name: "foo"})
   end
 
   it "parses 'foo:bar'" do
-    expect(cmd.parse("foo:bar")).to eq({identifier: "foo", separator: ":", attribute: "bar"})
+    expect(cmd.parse("foo:bar")).to eq({tag_name: "foo", separator: ":", tag_value: "bar"})
   end
 
   it "parses 'foo: bar'" do
-    expect(cmd.parse("foo:bar")).to eq({identifier: "foo", separator: ":", attribute: "bar"})
+    expect(cmd.parse("foo:bar")).to eq({tag_name: "foo", separator: ":", tag_value: "bar"})
   end
 
   it "parses 'foo :bar'" do
-    expect(cmd.parse("foo:bar")).to eq({identifier: "foo", separator: ":", attribute: "bar"})
+    expect(cmd.parse("foo:bar")).to eq({tag_name: "foo", separator: ":", tag_value: "bar"})
   end
 
   it "parses 'foo : bar'" do
-    expect(cmd.parse("foo:bar")).to eq({identifier: "foo", separator: ":", attribute: "bar"})
+    expect(cmd.parse("foo:bar")).to eq({tag_name: "foo", separator: ":", tag_value: "bar"})
   end
 
   it "parses 'foo:bar*'" do
-    expect(cmd.parse("foo:bar*")).to eq({identifier: "foo", separator: ":", attribute_glob: "bar*"})
+    expect(cmd.parse("foo:bar*")).to eq({tag_name: "foo", separator: ":", tag_value_glob: "bar*"})
   end
 
   it "parses 'foo*'" do
-    expect(cmd.parse("foo*")).to eq({identifier_glob: "foo*"})
+    expect(cmd.parse("foo*")).to eq({tag_name_glob: "foo*"})
   end
 
   it "parses 'foo*:bar'" do
-    expect(cmd.parse("foo*:bar")).to eq({identifier_glob: "foo*", separator: ":", attribute: "bar"})
+    expect(cmd.parse("foo*:bar")).to eq({tag_name_glob: "foo*", separator: ":", tag_value: "bar"})
   end
 
   it "parses 'foo*:bar*'" do
-    expect(cmd.parse("foo*:bar*")).to eq({identifier_glob: "foo*", separator: ":", attribute_glob: "bar*"})
+    expect(cmd.parse("foo*:bar*")).to eq({tag_name_glob: "foo*", separator: ":", tag_value_glob: "bar*"})
   end
 
   it "parses '/foo/'" do
-    expect(cmd.parse("/foo/")).to eq({identifier_regexp: "foo"})
+    expect(cmd.parse("/foo/")).to eq({tag_name_regexp: "/foo/"})
   end
 
   it "parses '/foo/:/bar/'" do
-    expect(cmd.parse("/foo/:/bar/")).to eq({identifier_regexp: "foo", separator: ":", attribute_regexp: "bar"})
+    expect(cmd.parse("/foo/:/bar/")).to eq({tag_name_regexp: "/foo/", separator: ":", tag_value_regexp: "/bar/"})
   end
 
   it "parses '(foo)'" do
-    expect(cmd.parse("(foo)")).to eq({identifier: "foo"})
+    expect(cmd.parse("(foo)")).to eq({tag_name: "foo"})
   end
 
   it "parses '( foo )'" do
-    expect(cmd.parse("( foo )")).to eq({identifier: "foo"})
+    expect(cmd.parse("( foo )")).to eq({tag_name: "foo"})
   end
 
   it "parses ' ( foo ) '" do
-    expect(cmd.parse(" ( foo ) ")).to eq({identifier: "foo"})
+    expect(cmd.parse(" ( foo ) ")).to eq({tag_name: "foo"})
   end
 
   it "parses '((foo))'" do
-    expect(cmd.parse("((foo))")).to eq({identifier: "foo"})
+    expect(cmd.parse("((foo))")).to eq({tag_name: "foo"})
   end
 
   it "parses '(( foo ))'" do
-    expect(cmd.parse("(( foo ))")).to eq({identifier: "foo"})
+    expect(cmd.parse("(( foo ))")).to eq({tag_name: "foo"})
   end
 
   it "parses ' ( ( foo ) ) '" do
-    expect(cmd.parse("( ( foo ) )")).to eq({identifier: "foo"})
+    expect(cmd.parse("( ( foo ) )")).to eq({tag_name: "foo"})
   end
 
-  it "parses 'identifier with prefix and'" do
-    expect(cmd.parse("android")).to eq({identifier: "android"})
+  it "parses 'tag_name with prefix and'" do
+    expect(cmd.parse("android")).to eq({tag_name: "android"})
   end
 
-  it "parses 'identifier with infix and'" do
-    expect(cmd.parse("islander")).to eq({identifier: "islander"})
+  it "parses 'tag_name with infix and'" do
+    expect(cmd.parse("islander")).to eq({tag_name: "islander"})
   end
 
-  it "parses 'identifier with suffix and'" do
-    expect(cmd.parse("mainland")).to eq({identifier: "mainland"})
+  it "parses 'tag_name with suffix and'" do
+    expect(cmd.parse("mainland")).to eq({tag_name: "mainland"})
   end
 
-  it "parses 'identifier with prefix or'" do
-    expect(cmd.parse("oreo")).to eq({identifier: "oreo"})
+  it "parses 'tag_name with prefix or'" do
+    expect(cmd.parse("oreo")).to eq({tag_name: "oreo"})
   end
 
-  it "parses 'identifier with infix or'" do
-    expect(cmd.parse("category")).to eq({identifier: "category"})
+  it "parses 'tag_name with infix or'" do
+    expect(cmd.parse("category")).to eq({tag_name: "category"})
   end
 
-  it "parses 'identifier with suffix or'" do
-    expect(cmd.parse("imperator")).to eq({identifier: "imperator"})
+  it "parses 'tag_name with suffix or'" do
+    expect(cmd.parse("imperator")).to eq({tag_name: "imperator"})
   end
 
-  it "parses 'identifier with prefix not'" do
-    expect(cmd.parse("nothing")).to eq({identifier: "nothing"})
+  it "parses 'tag_name with prefix not'" do
+    expect(cmd.parse("nothing")).to eq({tag_name: "nothing"})
   end
 
-  it "parses 'identifier with infix not'" do
-    expect(cmd.parse("annotation")).to eq({identifier: "annotation"})
+  it "parses 'tag_name with infix not'" do
+    expect(cmd.parse("annotation")).to eq({tag_name: "annotation"})
   end
 
-  it "parses 'identifier with suffix not'" do
-    expect(cmd.parse("forgetmenot")).to eq({identifier: "forgetmenot"})
+  it "parses 'tag_name with suffix not'" do
+    expect(cmd.parse("forgetmenot")).to eq({tag_name: "forgetmenot"})
   end
 
   it "parses 'foo bar'" do
-    expect(cmd.parse("foo bar")).to eq({left: {identifier: "foo"}, binary_op: nil, right: {identifier: "bar"}})
+    expect(cmd.parse("foo bar")).to eq({left: {tag_name: "foo"}, binary_op: nil, right: {tag_name: "bar"}})
   end
 
   it "parses 'foo bar baz'" do
-    expect(cmd.parse("foo bar baz")).to eq({left: {identifier: "foo"}, binary_op: nil, right: {left: {identifier: "bar"}, binary_op: nil, right: {identifier: "baz"}}})
+    expect(cmd.parse("foo bar baz")).to eq({left: {tag_name: "foo"}, binary_op: nil, right: {left: {tag_name: "bar"}, binary_op: nil, right: {tag_name: "baz"}}})
   end
 
   it "parses 'not foo'" do
-    expect(cmd.parse("not foo")).to eq({unary_op: "not", expression: {identifier: "foo"}})
+    expect(cmd.parse("not foo")).to eq({unary_op: "not", expression: {tag_name: "foo"}})
   end
 
   it "parses '! foo'" do
-    expect(cmd.parse("! foo")).to eq({unary_op: "!", expression: {identifier: "foo"}})
+    expect(cmd.parse("! foo")).to eq({unary_op: "!", expression: {tag_name: "foo"}})
   end
 
   it "parses '~ foo'" do
-    expect(cmd.parse("~ foo")).to eq({unary_op: "~", expression: {identifier: "foo"}})
+    expect(cmd.parse("~ foo")).to eq({unary_op: "~", expression: {tag_name: "foo"}})
   end
 
   it "parses 'not(not foo)'" do
-    expect(cmd.parse("not(not foo)")).to eq({unary_op: "not", expression: {unary_op: "not", expression: {identifier: "foo"}}})
+    expect(cmd.parse("not(not foo)")).to eq({unary_op: "not", expression: {unary_op: "not", expression: {tag_name: "foo"}}})
   end
 
   it "parses '!(!foo)'" do
-    expect(cmd.parse("!(!foo)")).to eq({unary_op: "!", expression: {unary_op: "!", expression: {identifier: "foo"}}})
+    expect(cmd.parse("!(!foo)")).to eq({unary_op: "!", expression: {unary_op: "!", expression: {tag_name: "foo"}}})
   end
 
   it "parses '~(~foo)'" do
-    expect(cmd.parse("~(~foo)")).to eq({unary_op: "~", expression: {unary_op: "~", expression: {identifier: "foo"}}})
+    expect(cmd.parse("~(~foo)")).to eq({unary_op: "~", expression: {unary_op: "~", expression: {tag_name: "foo"}}})
   end
 
   it "parses 'not not foo'" do
-    expect(cmd.parse("not not foo")).to eq({unary_op: "not", expression: {unary_op: "not", expression: {identifier: "foo"}}})
+    expect(cmd.parse("not not foo")).to eq({unary_op: "not", expression: {unary_op: "not", expression: {tag_name: "foo"}}})
   end
 
   it "parses '!!foo'" do
-    expect(cmd.parse("!! foo")).to eq({unary_op: "!", expression: {unary_op: "!", expression: {identifier: "foo"}}})
+    expect(cmd.parse("!! foo")).to eq({unary_op: "!", expression: {unary_op: "!", expression: {tag_name: "foo"}}})
   end
 
   it "parses '! ! foo'" do
-    expect(cmd.parse("!! foo")).to eq({unary_op: "!", expression: {unary_op: "!", expression: {identifier: "foo"}}})
+    expect(cmd.parse("!! foo")).to eq({unary_op: "!", expression: {unary_op: "!", expression: {tag_name: "foo"}}})
   end
 
   it "parses '~~foo'" do
-    expect(cmd.parse("~~ foo")).to eq({unary_op: "~", expression: {unary_op: "~", expression: {identifier: "foo"}}})
+    expect(cmd.parse("~~ foo")).to eq({unary_op: "~", expression: {unary_op: "~", expression: {tag_name: "foo"}}})
   end
 
   it "parses '~ ~ foo'" do
-    expect(cmd.parse("~~ foo")).to eq({unary_op: "~", expression: {unary_op: "~", expression: {identifier: "foo"}}})
+    expect(cmd.parse("~~ foo")).to eq({unary_op: "~", expression: {unary_op: "~", expression: {tag_name: "foo"}}})
   end
 
   it "parses 'foo and bar'" do
-    expect(cmd.parse("foo and bar")).to eq({left: {identifier: "foo"}, binary_op: "and", right: {identifier: "bar"}})
+    expect(cmd.parse("foo and bar")).to eq({left: {tag_name: "foo"}, binary_op: "and", right: {tag_name: "bar"}})
   end
 
   it "parses 'foo and bar and baz'" do
-    expect(cmd.parse("foo and bar and baz")).to eq({left: {identifier: "foo"}, binary_op: "and", right: {left: {identifier: "bar"}, binary_op: "and", right: {identifier: "baz"}}})
+    expect(cmd.parse("foo and bar and baz")).to eq({left: {tag_name: "foo"}, binary_op: "and", right: {left: {tag_name: "bar"}, binary_op: "and", right: {tag_name: "baz"}}})
   end
 
   it "parses 'foo&bar'" do
-    expect(cmd.parse("foo&bar")).to eq({left: {identifier: "foo"}, binary_op: "&", right: {identifier: "bar"}})
+    expect(cmd.parse("foo&bar")).to eq({left: {tag_name: "foo"}, binary_op: "&", right: {tag_name: "bar"}})
   end
 
   it "parses 'foo & bar'" do
-    expect(cmd.parse("foo & bar")).to eq({left: {identifier: "foo"}, binary_op: "&", right: {identifier: "bar"}})
+    expect(cmd.parse("foo & bar")).to eq({left: {tag_name: "foo"}, binary_op: "&", right: {tag_name: "bar"}})
   end
 
   it "parses 'foo&bar&baz'" do
-    expect(cmd.parse("foo & bar & baz")).to eq({left: {identifier: "foo"}, binary_op: "&", right: {left: {identifier: "bar"}, binary_op: "&", right: {identifier: "baz"}}})
+    expect(cmd.parse("foo & bar & baz")).to eq({left: {tag_name: "foo"}, binary_op: "&", right: {left: {tag_name: "bar"}, binary_op: "&", right: {tag_name: "baz"}}})
   end
 
   it "parses 'foo & bar & baz'" do
-    expect(cmd.parse("foo & bar & baz")).to eq({left: {identifier: "foo"}, binary_op: "&", right: {left: {identifier: "bar"}, binary_op: "&", right: {identifier: "baz"}}})
+    expect(cmd.parse("foo & bar & baz")).to eq({left: {tag_name: "foo"}, binary_op: "&", right: {left: {tag_name: "bar"}, binary_op: "&", right: {tag_name: "baz"}}})
   end
 
   it "parses 'foo&&bar'" do
-    expect(cmd.parse("foo&&bar")).to eq({left: {identifier: "foo"}, binary_op: "&&", right: {identifier: "bar"}})
+    expect(cmd.parse("foo&&bar")).to eq({left: {tag_name: "foo"}, binary_op: "&&", right: {tag_name: "bar"}})
   end
 
   it "parses 'foo && bar'" do
-    expect(cmd.parse("foo && bar")).to eq({left: {identifier: "foo"}, binary_op: "&&", right: {identifier: "bar"}})
+    expect(cmd.parse("foo && bar")).to eq({left: {tag_name: "foo"}, binary_op: "&&", right: {tag_name: "bar"}})
   end
 
   it "parses 'foo&&bar&&baz'" do
-    expect(cmd.parse("foo&&bar&&baz")).to eq({left: {identifier: "foo"}, binary_op: "&&", right: {left: {identifier: "bar"}, binary_op: "&&", right: {identifier: "baz"}}})
+    expect(cmd.parse("foo&&bar&&baz")).to eq({left: {tag_name: "foo"}, binary_op: "&&", right: {left: {tag_name: "bar"}, binary_op: "&&", right: {tag_name: "baz"}}})
   end
 
   it "parses 'foo && bar && baz'" do
-    expect(cmd.parse("foo && bar && baz")).to eq({left: {identifier: "foo"}, binary_op: "&&", right: {left: {identifier: "bar"}, binary_op: "&&", right: {identifier: "baz"}}})
+    expect(cmd.parse("foo && bar && baz")).to eq({left: {tag_name: "foo"}, binary_op: "&&", right: {left: {tag_name: "bar"}, binary_op: "&&", right: {tag_name: "baz"}}})
   end
 
   it "parses 'foo or bar'" do
-    expect(cmd.parse("foo or bar")).to eq({left: {identifier: "foo"}, binary_op: "or", right: {identifier: "bar"}})
+    expect(cmd.parse("foo or bar")).to eq({left: {tag_name: "foo"}, binary_op: "or", right: {tag_name: "bar"}})
   end
 
   it "parses 'foo or bar or baz'" do
-    expect(cmd.parse("foo or bar or baz")).to eq({left: {identifier: "foo"}, binary_op: "or", right: {left: {identifier: "bar"}, binary_op: "or", right: {identifier: "baz"}}})
+    expect(cmd.parse("foo or bar or baz")).to eq({left: {tag_name: "foo"}, binary_op: "or", right: {left: {tag_name: "bar"}, binary_op: "or", right: {tag_name: "baz"}}})
   end
 
   it "parses 'foo|bar'" do
-    expect(cmd.parse("foo|bar")).to eq({left: {identifier: "foo"}, binary_op: "|", right: {identifier: "bar"}})
+    expect(cmd.parse("foo|bar")).to eq({left: {tag_name: "foo"}, binary_op: "|", right: {tag_name: "bar"}})
   end
 
   it "parses 'foo | bar'" do
-    expect(cmd.parse("foo | bar")).to eq({left: {identifier: "foo"}, binary_op: "|", right: {identifier: "bar"}})
+    expect(cmd.parse("foo | bar")).to eq({left: {tag_name: "foo"}, binary_op: "|", right: {tag_name: "bar"}})
   end
 
   it "parses 'foo|bar|baz'" do
-    expect(cmd.parse("foo|bar|baz")).to eq({left: {identifier: "foo"}, binary_op: "|", right: {left: {identifier: "bar"}, binary_op: "|", right: {identifier: "baz"}}})
+    expect(cmd.parse("foo|bar|baz")).to eq({left: {tag_name: "foo"}, binary_op: "|", right: {left: {tag_name: "bar"}, binary_op: "|", right: {tag_name: "baz"}}})
   end
 
   it "parses 'foo | bar | baz'" do
-    expect(cmd.parse("foo | bar | baz")).to eq({left: {identifier: "foo"}, binary_op: "|", right: {left: {identifier: "bar"}, binary_op: "|", right: {identifier: "baz"}}})
+    expect(cmd.parse("foo | bar | baz")).to eq({left: {tag_name: "foo"}, binary_op: "|", right: {left: {tag_name: "bar"}, binary_op: "|", right: {tag_name: "baz"}}})
   end
 
   it "parses 'foo||bar'" do
-    expect(cmd.parse("foo||bar")).to eq({left: {identifier: "foo"}, binary_op: "||", right: {identifier: "bar"}})
+    expect(cmd.parse("foo||bar")).to eq({left: {tag_name: "foo"}, binary_op: "||", right: {tag_name: "bar"}})
   end
 
   it "parses 'foo || bar'" do
-    expect(cmd.parse("foo || bar")).to eq({left: {identifier: "foo"}, binary_op: "||", right: {identifier: "bar"}})
+    expect(cmd.parse("foo || bar")).to eq({left: {tag_name: "foo"}, binary_op: "||", right: {tag_name: "bar"}})
   end
 
   it "parses 'foo||bar||baz'" do
-    expect(cmd.parse("foo||bar||baz")).to eq({left: {identifier: "foo"}, binary_op: "||", right: {left: {identifier: "bar"}, binary_op: "||", right: {identifier: "baz"}}})
+    expect(cmd.parse("foo||bar||baz")).to eq({left: {tag_name: "foo"}, binary_op: "||", right: {left: {tag_name: "bar"}, binary_op: "||", right: {tag_name: "baz"}}})
   end
 
   it "parses 'foo || bar || baz'" do
-    expect(cmd.parse("foo || bar || baz")).to eq({left: {identifier: "foo"}, binary_op: "||", right: {left: {identifier: "bar"}, binary_op: "||", right: {identifier: "baz"}}})
+    expect(cmd.parse("foo || bar || baz")).to eq({left: {tag_name: "foo"}, binary_op: "||", right: {left: {tag_name: "bar"}, binary_op: "||", right: {tag_name: "baz"}}})
   end
 
   it "parses '(foo and bar) or baz'" do
-    expect(cmd.parse("(foo and bar) or baz")).to eq({left: {left: {identifier: "foo"}, binary_op: "and", right: {identifier: "bar"}}, binary_op: "or", right: {identifier: "baz"}})
+    expect(cmd.parse("(foo and bar) or baz")).to eq({left: {left: {tag_name: "foo"}, binary_op: "and", right: {tag_name: "bar"}}, binary_op: "or", right: {tag_name: "baz"}})
   end
 
   it "parses 'foo and (bar or baz)'" do
-    expect(cmd.parse("foo and (bar or baz)")).to eq({left: {identifier: "foo"}, binary_op: "and", right: {left: {identifier: "bar"}, binary_op: "or", right: {identifier: "baz"}}})
+    expect(cmd.parse("foo and (bar or baz)")).to eq({left: {tag_name: "foo"}, binary_op: "and", right: {left: {tag_name: "bar"}, binary_op: "or", right: {tag_name: "baz"}}})
   end
 
   it "parses 'not foo and bar'" do
-    expect(cmd.parse("not foo and bar")).to eq({unary_op: "not", expression: {left: {identifier: "foo"}, binary_op: "and", right: {identifier: "bar"}}})
+    expect(cmd.parse("not foo and bar")).to eq({unary_op: "not", expression: {left: {tag_name: "foo"}, binary_op: "and", right: {tag_name: "bar"}}})
   end
 
   it "parses '! foo and bar'" do
-    expect(cmd.parse("! foo and bar")).to eq({left: {unary_op: "!", expression: {identifier: "foo"}}, binary_op: "and", right: {identifier: "bar"}})
+    expect(cmd.parse("! foo and bar")).to eq({left: {unary_op: "!", expression: {tag_name: "foo"}}, binary_op: "and", right: {tag_name: "bar"}})
   end
 
   it "parses 'not foo && bar'" do
-    expect(cmd.parse("not foo && bar")).to eq({unary_op: "not", expression: {left: {identifier: "foo"}, binary_op: "&&", right: {identifier: "bar"}}})
+    expect(cmd.parse("not foo && bar")).to eq({unary_op: "not", expression: {left: {tag_name: "foo"}, binary_op: "&&", right: {tag_name: "bar"}}})
   end
 
   it "parses '! foo && bar'" do
-    expect(cmd.parse("! foo && bar")).to eq({left: {unary_op: "!", expression: {identifier: "foo"}}, binary_op: "&&", right: {identifier: "bar"}})
+    expect(cmd.parse("! foo && bar")).to eq({left: {unary_op: "!", expression: {tag_name: "foo"}}, binary_op: "&&", right: {tag_name: "bar"}})
+  end
+
+  it "parses 'f(x)'" do
+    expect(cmd.parse("f(x)")).to eq({funcall: "f", funcall_args: {funcall_args_head: {tag_name: "x"}}})
+  end
+
+  it "parses 'f(x, \"y\")'" do
+    expect(cmd.parse("f(x, \"y\")")).to eq({funcall: "f", funcall_args: {funcall_args_head: {tag_name: "x"}, funcall_args_tail: {funcall_args_head: {string: "\"y\""}}}})
+  end
+
+  it "parses 'f(x, \"y\", /z/)'" do
+    expect(cmd.parse("f(x, \"y\", /z/)")).to eq({funcall: "f", funcall_args: {funcall_args_head: {tag_name: "x"}, funcall_args_tail: {funcall_args_head: {string: "\"y\""}, funcall_args_tail: {funcall_args_head: {regexp: "/z/"}}}}})
+  end
+
+  it "parses 'g ( 12345 )'" do
+    expect(cmd.parse("g ( 12345 )")).to eq({funcall: "g", funcall_args: {funcall_args_head: {integer: "12345"}}})
+  end
+
+  it "parses 'g ( 12345 , 3.1415 )'" do
+    expect(cmd.parse("g ( 12345 , 3.1415 )")).to eq({funcall: "g", funcall_args: {funcall_args_head: {integer: "12345"}, funcall_args_tail: {funcall_args_head: {float: "3.1415"}}}})
+  end
+
+  it "parses 'f()'" do
+    expect(cmd.parse("f()")).to eq({funcall: "f"})
+  end
+
+  it "parses 'g(f())'" do
+    expect(cmd.parse("g(f())")).to eq({funcall: "g", funcall_args: {funcall_args_head: {funcall: "f"}}})
+  end
+
+  it "parses 'foo and bar(y)'" do
+    expect(cmd.parse("foo and bar(y)")).to eq({binary_op: "and", left: {tag_name: "foo"}, right: {funcall: "bar", funcall_args: {funcall_args_head: {tag_name: "y"}}}})
+  end
+
+  it "parses 'foo(x) and bar(y)'" do
+    expect(cmd.parse("foo(x) and bar(y)")).to eq({binary_op: "and", left: {funcall: "foo", funcall_args: {funcall_args_head: {tag_name: "x"}}}, right: {funcall: "bar", funcall_args: {funcall_args_head: {tag_name: "y"}}}})
   end
 
   it "is unable to parse ' '" do