hotdog 0.24.0 → 0.25.0

data/spec/optimizer/regexp_expression_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+require "hotdog/application"
+require "hotdog/commands"
+require "hotdog/commands/search"
+require "parslet"
+
+describe "tag regexp expression" do
+  it "interprets tag regexp with host" do
+    expr = Hotdog::Expression::RegexpHostNode.new("foo", ":")
+    expect(expr.optimize.dump).to eq({
+      tagname_regexp: "host",
+       separator: ":",
+       tagvalue_regexp: "foo",
+    })
+  end
+
+  it "interprets tag regexp with tagname and tagvalue" do
+    expr = Hotdog::Expression::RegexpTagNode.new("foo", "bar", ":")
+    expect(expr.optimize.dump).to eq({
+      tagname_regexp: "foo",
+      separator: ":",
+      tagvalue_regexp: "bar",
+    })
+  end
+
+  it "interprets tag regexp with tagname with separator" do
+    expr = Hotdog::Expression::RegexpTagnameNode.new("foo", ":")
+    expect(expr.optimize.dump).to eq({
+      tagname_regexp: "foo",
+      separator: ":",
+    })
+  end
+
+  it "interprets tag regexp with tagname without separator" do
+    expr = Hotdog::Expression::RegexpHostOrTagNode.new("foo", nil)
+    expect(expr.optimize.dump).to eq({
+      tagname_regexp: "foo",
+    })
+  end
+
+  it "interprets tag regexp with tagvalue with separator" do
+    expr = Hotdog::Expression::RegexpTagvalueNode.new("foo", ":")
+    expect(expr.optimize.dump).to eq({
+      separator: ":",
+      tagvalue_regexp: "foo",
+    })
+  end
+
+  it "interprets tag regexp with tagvalue without separator" do
+    expr = Hotdog::Expression::RegexpTagvalueNode.new("foo", nil)
+    expect(expr.optimize.dump).to eq({
+      tagvalue_regexp: "foo",
+    })
+  end
+end

data/spec/optimizer/string_expression_spec.rb

@@ -0,0 +1,105 @@
+require "spec_helper"
+require "hotdog/application"
+require "hotdog/commands"
+require "hotdog/commands/search"
+require "parslet"
+
+describe "tag expression" do
+  it "interprets tag with host" do
+    expr = Hotdog::Expression::StringHostNode.new("foo", ":")
+    expect(expr.optimize.dump).to eq({
+      tagname: "host",
+      separator: ":",
+      tagvalue: "foo",
+      fallback: {
+        query: [
+          "SELECT hosts.id AS host_id FROM hosts",
+          "WHERE LOWER(hosts.name) GLOB LOWER(?);",
+        ].join(" "),
+        values: ["*foo*"],
+      },
+    })
+  end
+
+  it "interprets tag with tagname and tagvalue" do
+    expr = Hotdog::Expression::StringTagNode.new("foo", "bar", ":")
+    expect(expr.optimize.dump).to eq({
+      tagname: "foo",
+      separator: ":",
+      tagvalue: "bar",
+      fallback: {
+        query: [
+          "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
+          "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+          "WHERE LOWER(tags.name) GLOB LOWER(?) AND LOWER(tags.value) GLOB LOWER(?);",
+        ].join(" "),
+        values: ["*foo*", "*bar*"],
+      },
+    })
+  end
+
+  it "interprets tag with tagname with separator" do
+    expr = Hotdog::Expression::StringTagnameNode.new("foo", ":")
+    expect(expr.optimize.dump).to eq({
+      tagname: "foo",
+      separator: ":",
+      fallback: {
+        query: [
+          "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
+          "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+          "WHERE LOWER(tags.name) GLOB LOWER(?);",
+        ].join(" "),
+        values: ["*foo*"],
+      }
+    })
+  end
+
+  it "interprets tag with tagname without separator" do
+    expr = Hotdog::Expression::StringHostOrTagNode.new("foo", nil)
+    expect(expr.optimize.dump).to eq({
+      tagname: "foo",
+      fallback: {
+        query: [
+          "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
+          "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
+          "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+          "WHERE LOWER(hosts.name) GLOB LOWER(?) OR LOWER(tags.name) GLOB LOWER(?) OR LOWER(tags.value) GLOB LOWER(?);",
+        ].join(" "),
+        values: ["*foo*", "*foo*", "*foo*"],
+      },
+    })
+  end
+
+  it "interprets tag with tagvalue with separator" do
+    expr = Hotdog::Expression::StringTagvalueNode.new("foo", ":")
+    expect(expr.optimize.dump).to eq({
+      tagvalue: "foo",
+      separator: ":",
+      fallback: {
+        query: [
+          "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
+          "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
+          "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+          "WHERE LOWER(hosts.name) GLOB LOWER(?) OR LOWER(tags.value) GLOB LOWER(?);",
+        ].join(" "),
+        values: ["*foo*", "*foo*"],
+      },
+    })
+  end
+
+  it "interprets tag with tagvalue without separator" do
+    expr = Hotdog::Expression::StringTagvalueNode.new("foo", nil)
+    expect(expr.optimize.dump).to eq({
+      tagvalue: "foo",
+      fallback: {
+        query: [
+          "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
+          "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
+          "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+          "WHERE LOWER(hosts.name) GLOB LOWER(?) OR LOWER(tags.value) GLOB LOWER(?);",
+        ].join(" "),
+        values: ["*foo*", "*foo*"],
+      },
+    })
+  end
+end

data/spec/optimizer/unary_expression_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+require "hotdog/application"
+require "hotdog/commands"
+require "hotdog/commands/search"
+require "parslet"
+
+describe "unary expression" do
+  it "should be everything" do
+    expr = Hotdog::Expression::UnaryExpressionNode.new("NOT", Hotdog::Expression::NothingNode.new())
+    expect(expr.optimize.dump).to eq({
+      query: "SELECT id AS host_id FROM hosts;",
+      values: [],
+    })
+  end
+
+  it "should be nothing" do
+    expr = Hotdog::Expression::UnaryExpressionNode.new("NOT", Hotdog::Expression::EverythingNode.new())
+    expect(expr.optimize.dump).to eq({
+      query: "SELECT NULL AS host_id WHERE host_id NOT NULL;",
+      values: [],
+    })
+  end
+end

data/spec/parser/parser_spec.rb

@@ -15,287 +15,287 @@ describe "parser" do
   end
 
   it "parses ':foo'" do
-    expect(cmd.parse(":foo")).to eq({separator: ":", tag_value: "foo"})
+    expect(cmd.parse(":foo")).to eq({separator: ":", tagvalue: "foo"})
   end
 
   it "parses ':foo*'" do
-    expect(cmd.parse(":foo*")).to eq({separator: ":", tag_value_glob: "foo*"})
+    expect(cmd.parse(":foo*")).to eq({separator: ":", tagvalue_glob: "foo*"})
   end
 
   it "parses ':/foo/'" do
-    expect(cmd.parse(":/foo/")).to eq({separator: ":", tag_value_regexp: "/foo/"})
+    expect(cmd.parse(":/foo/")).to eq({separator: ":", tagvalue_regexp: "/foo/"})
   end
 
   it "parses 'foo'" do
-    expect(cmd.parse("foo")).to eq({tag_name: "foo"})
+    expect(cmd.parse("foo")).to eq({tagname: "foo"})
   end
 
   it "parses 'foo:bar'" do
-    expect(cmd.parse("foo:bar")).to eq({tag_name: "foo", separator: ":", tag_value: "bar"})
+    expect(cmd.parse("foo:bar")).to eq({tagname: "foo", separator: ":", tagvalue: "bar"})
   end
 
   it "parses 'foo: bar'" do
-    expect(cmd.parse("foo:bar")).to eq({tag_name: "foo", separator: ":", tag_value: "bar"})
+    expect(cmd.parse("foo:bar")).to eq({tagname: "foo", separator: ":", tagvalue: "bar"})
   end
 
   it "parses 'foo :bar'" do
-    expect(cmd.parse("foo:bar")).to eq({tag_name: "foo", separator: ":", tag_value: "bar"})
+    expect(cmd.parse("foo:bar")).to eq({tagname: "foo", separator: ":", tagvalue: "bar"})
   end
 
   it "parses 'foo : bar'" do
-    expect(cmd.parse("foo:bar")).to eq({tag_name: "foo", separator: ":", tag_value: "bar"})
+    expect(cmd.parse("foo:bar")).to eq({tagname: "foo", separator: ":", tagvalue: "bar"})
   end
 
   it "parses 'foo:bar*'" do
-    expect(cmd.parse("foo:bar*")).to eq({tag_name: "foo", separator: ":", tag_value_glob: "bar*"})
+    expect(cmd.parse("foo:bar*")).to eq({tagname: "foo", separator: ":", tagvalue_glob: "bar*"})
   end
 
   it "parses 'foo*'" do
-    expect(cmd.parse("foo*")).to eq({tag_name_glob: "foo*"})
+    expect(cmd.parse("foo*")).to eq({tagname_glob: "foo*"})
   end
 
   it "parses 'foo*:bar'" do
-    expect(cmd.parse("foo*:bar")).to eq({tag_name_glob: "foo*", separator: ":", tag_value: "bar"})
+    expect(cmd.parse("foo*:bar")).to eq({tagname_glob: "foo*", separator: ":", tagvalue: "bar"})
   end
 
   it "parses 'foo*:bar*'" do
-    expect(cmd.parse("foo*:bar*")).to eq({tag_name_glob: "foo*", separator: ":", tag_value_glob: "bar*"})
+    expect(cmd.parse("foo*:bar*")).to eq({tagname_glob: "foo*", separator: ":", tagvalue_glob: "bar*"})
   end
 
   it "parses '/foo/'" do
-    expect(cmd.parse("/foo/")).to eq({tag_name_regexp: "/foo/"})
+    expect(cmd.parse("/foo/")).to eq({tagname_regexp: "/foo/"})
   end
 
   it "parses '/foo/:/bar/'" do
-    expect(cmd.parse("/foo/:/bar/")).to eq({tag_name_regexp: "/foo/", separator: ":", tag_value_regexp: "/bar/"})
+    expect(cmd.parse("/foo/:/bar/")).to eq({tagname_regexp: "/foo/", separator: ":", tagvalue_regexp: "/bar/"})
   end
 
   it "parses '(foo)'" do
-    expect(cmd.parse("(foo)")).to eq({tag_name: "foo"})
+    expect(cmd.parse("(foo)")).to eq({tagname: "foo"})
   end
 
   it "parses '( foo )'" do
-    expect(cmd.parse("( foo )")).to eq({tag_name: "foo"})
+    expect(cmd.parse("( foo )")).to eq({tagname: "foo"})
   end
 
   it "parses ' ( foo ) '" do
-    expect(cmd.parse(" ( foo ) ")).to eq({tag_name: "foo"})
+    expect(cmd.parse(" ( foo ) ")).to eq({tagname: "foo"})
   end
 
   it "parses '((foo))'" do
-    expect(cmd.parse("((foo))")).to eq({tag_name: "foo"})
+    expect(cmd.parse("((foo))")).to eq({tagname: "foo"})
   end
 
   it "parses '(( foo ))'" do
-    expect(cmd.parse("(( foo ))")).to eq({tag_name: "foo"})
+    expect(cmd.parse("(( foo ))")).to eq({tagname: "foo"})
   end
 
   it "parses ' ( ( foo ) ) '" do
-    expect(cmd.parse("( ( foo ) )")).to eq({tag_name: "foo"})
+    expect(cmd.parse("( ( foo ) )")).to eq({tagname: "foo"})
   end
 
-  it "parses 'tag_name with prefix and'" do
-    expect(cmd.parse("android")).to eq({tag_name: "android"})
+  it "parses 'tagname with prefix and'" do
+    expect(cmd.parse("android")).to eq({tagname: "android"})
   end
 
-  it "parses 'tag_name with infix and'" do
-    expect(cmd.parse("islander")).to eq({tag_name: "islander"})
+  it "parses 'tagname with infix and'" do
+    expect(cmd.parse("islander")).to eq({tagname: "islander"})
   end
 
-  it "parses 'tag_name with suffix and'" do
-    expect(cmd.parse("mainland")).to eq({tag_name: "mainland"})
+  it "parses 'tagname with suffix and'" do
+    expect(cmd.parse("mainland")).to eq({tagname: "mainland"})
   end
 
-  it "parses 'tag_name with prefix or'" do
-    expect(cmd.parse("oreo")).to eq({tag_name: "oreo"})
+  it "parses 'tagname with prefix or'" do
+    expect(cmd.parse("oreo")).to eq({tagname: "oreo"})
   end
 
-  it "parses 'tag_name with infix or'" do
-    expect(cmd.parse("category")).to eq({tag_name: "category"})
+  it "parses 'tagname with infix or'" do
+    expect(cmd.parse("category")).to eq({tagname: "category"})
   end
 
-  it "parses 'tag_name with suffix or'" do
-    expect(cmd.parse("imperator")).to eq({tag_name: "imperator"})
+  it "parses 'tagname with suffix or'" do
+    expect(cmd.parse("imperator")).to eq({tagname: "imperator"})
   end
 
-  it "parses 'tag_name with prefix not'" do
-    expect(cmd.parse("nothing")).to eq({tag_name: "nothing"})
+  it "parses 'tagname with prefix not'" do
+    expect(cmd.parse("nothing")).to eq({tagname: "nothing"})
   end
 
-  it "parses 'tag_name with infix not'" do
-    expect(cmd.parse("annotation")).to eq({tag_name: "annotation"})
+  it "parses 'tagname with infix not'" do
+    expect(cmd.parse("annotation")).to eq({tagname: "annotation"})
   end
 
-  it "parses 'tag_name with suffix not'" do
-    expect(cmd.parse("forgetmenot")).to eq({tag_name: "forgetmenot"})
+  it "parses 'tagname with suffix not'" do
+    expect(cmd.parse("forgetmenot")).to eq({tagname: "forgetmenot"})
   end
 
   it "parses 'foo bar'" do
-    expect(cmd.parse("foo bar")).to eq({left: {tag_name: "foo"}, binary_op: nil, right: {tag_name: "bar"}})
+    expect(cmd.parse("foo bar")).to eq({left: {tagname: "foo"}, binary_op: nil, right: {tagname: "bar"}})
   end
 
   it "parses 'foo bar baz'" do
-    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"}}})
+    expect(cmd.parse("foo bar baz")).to eq({left: {tagname: "foo"}, binary_op: nil, right: {left: {tagname: "bar"}, binary_op: nil, right: {tagname: "baz"}}})
   end
 
   it "parses 'not foo'" do
-    expect(cmd.parse("not foo")).to eq({unary_op: "not", expression: {tag_name: "foo"}})
+    expect(cmd.parse("not foo")).to eq({unary_op: "not", expression: {tagname: "foo"}})
   end
 
   it "parses '! foo'" do
-    expect(cmd.parse("! foo")).to eq({unary_op: "!", expression: {tag_name: "foo"}})
+    expect(cmd.parse("! foo")).to eq({unary_op: "!", expression: {tagname: "foo"}})
   end
 
   it "parses '~ foo'" do
-    expect(cmd.parse("~ foo")).to eq({unary_op: "~", expression: {tag_name: "foo"}})
+    expect(cmd.parse("~ foo")).to eq({unary_op: "~", expression: {tagname: "foo"}})
   end
 
   it "parses 'not(not foo)'" do
-    expect(cmd.parse("not(not foo)")).to eq({unary_op: "not", expression: {unary_op: "not", expression: {tag_name: "foo"}}})
+    expect(cmd.parse("not(not foo)")).to eq({unary_op: "not", expression: {unary_op: "not", expression: {tagname: "foo"}}})
   end
 
   it "parses '!(!foo)'" do
-    expect(cmd.parse("!(!foo)")).to eq({unary_op: "!", expression: {unary_op: "!", expression: {tag_name: "foo"}}})
+    expect(cmd.parse("!(!foo)")).to eq({unary_op: "!", expression: {unary_op: "!", expression: {tagname: "foo"}}})
   end
 
   it "parses '~(~foo)'" do
-    expect(cmd.parse("~(~foo)")).to eq({unary_op: "~", expression: {unary_op: "~", expression: {tag_name: "foo"}}})
+    expect(cmd.parse("~(~foo)")).to eq({unary_op: "~", expression: {unary_op: "~", expression: {tagname: "foo"}}})
   end
 
   it "parses 'not not foo'" do
-    expect(cmd.parse("not not foo")).to eq({unary_op: "not", expression: {unary_op: "not", expression: {tag_name: "foo"}}})
+    expect(cmd.parse("not not foo")).to eq({unary_op: "not", expression: {unary_op: "not", expression: {tagname: "foo"}}})
   end
 
   it "parses '!!foo'" do
-    expect(cmd.parse("!! foo")).to eq({unary_op: "!", expression: {unary_op: "!", expression: {tag_name: "foo"}}})
+    expect(cmd.parse("!! foo")).to eq({unary_op: "!", expression: {unary_op: "!", expression: {tagname: "foo"}}})
   end
 
   it "parses '! ! foo'" do
-    expect(cmd.parse("!! foo")).to eq({unary_op: "!", expression: {unary_op: "!", expression: {tag_name: "foo"}}})
+    expect(cmd.parse("!! foo")).to eq({unary_op: "!", expression: {unary_op: "!", expression: {tagname: "foo"}}})
   end
 
   it "parses '~~foo'" do
-    expect(cmd.parse("~~ foo")).to eq({unary_op: "~", expression: {unary_op: "~", expression: {tag_name: "foo"}}})
+    expect(cmd.parse("~~ foo")).to eq({unary_op: "~", expression: {unary_op: "~", expression: {tagname: "foo"}}})
   end
 
   it "parses '~ ~ foo'" do
-    expect(cmd.parse("~~ foo")).to eq({unary_op: "~", expression: {unary_op: "~", expression: {tag_name: "foo"}}})
+    expect(cmd.parse("~~ foo")).to eq({unary_op: "~", expression: {unary_op: "~", expression: {tagname: "foo"}}})
   end
 
   it "parses 'foo and bar'" do
-    expect(cmd.parse("foo and bar")).to eq({left: {tag_name: "foo"}, binary_op: "and", right: {tag_name: "bar"}})
+    expect(cmd.parse("foo and bar")).to eq({left: {tagname: "foo"}, binary_op: "and", right: {tagname: "bar"}})
   end
 
   it "parses 'foo and bar and baz'" do
-    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"}}})
+    expect(cmd.parse("foo and bar and baz")).to eq({left: {tagname: "foo"}, binary_op: "and", right: {left: {tagname: "bar"}, binary_op: "and", right: {tagname: "baz"}}})
   end
 
   it "parses 'foo&bar'" do
-    expect(cmd.parse("foo&bar")).to eq({left: {tag_name: "foo"}, binary_op: "&", right: {tag_name: "bar"}})
+    expect(cmd.parse("foo&bar")).to eq({left: {tagname: "foo"}, binary_op: "&", right: {tagname: "bar"}})
   end
 
   it "parses 'foo & bar'" do
-    expect(cmd.parse("foo & bar")).to eq({left: {tag_name: "foo"}, binary_op: "&", right: {tag_name: "bar"}})
+    expect(cmd.parse("foo & bar")).to eq({left: {tagname: "foo"}, binary_op: "&", right: {tagname: "bar"}})
   end
 
   it "parses 'foo&bar&baz'" do
-    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"}}})
+    expect(cmd.parse("foo & bar & baz")).to eq({left: {tagname: "foo"}, binary_op: "&", right: {left: {tagname: "bar"}, binary_op: "&", right: {tagname: "baz"}}})
   end
 
   it "parses 'foo & bar & baz'" do
-    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"}}})
+    expect(cmd.parse("foo & bar & baz")).to eq({left: {tagname: "foo"}, binary_op: "&", right: {left: {tagname: "bar"}, binary_op: "&", right: {tagname: "baz"}}})
   end
 
   it "parses 'foo&&bar'" do
-    expect(cmd.parse("foo&&bar")).to eq({left: {tag_name: "foo"}, binary_op: "&&", right: {tag_name: "bar"}})
+    expect(cmd.parse("foo&&bar")).to eq({left: {tagname: "foo"}, binary_op: "&&", right: {tagname: "bar"}})
   end
 
   it "parses 'foo && bar'" do
-    expect(cmd.parse("foo && bar")).to eq({left: {tag_name: "foo"}, binary_op: "&&", right: {tag_name: "bar"}})
+    expect(cmd.parse("foo && bar")).to eq({left: {tagname: "foo"}, binary_op: "&&", right: {tagname: "bar"}})
   end
 
   it "parses 'foo&&bar&&baz'" do
-    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"}}})
+    expect(cmd.parse("foo&&bar&&baz")).to eq({left: {tagname: "foo"}, binary_op: "&&", right: {left: {tagname: "bar"}, binary_op: "&&", right: {tagname: "baz"}}})
   end
 
   it "parses 'foo && bar && baz'" do
-    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"}}})
+    expect(cmd.parse("foo && bar && baz")).to eq({left: {tagname: "foo"}, binary_op: "&&", right: {left: {tagname: "bar"}, binary_op: "&&", right: {tagname: "baz"}}})
   end
 
   it "parses 'foo or bar'" do
-    expect(cmd.parse("foo or bar")).to eq({left: {tag_name: "foo"}, binary_op: "or", right: {tag_name: "bar"}})
+    expect(cmd.parse("foo or bar")).to eq({left: {tagname: "foo"}, binary_op: "or", right: {tagname: "bar"}})
   end
 
   it "parses 'foo or bar or baz'" do
-    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"}}})
+    expect(cmd.parse("foo or bar or baz")).to eq({left: {tagname: "foo"}, binary_op: "or", right: {left: {tagname: "bar"}, binary_op: "or", right: {tagname: "baz"}}})
   end
 
   it "parses 'foo|bar'" do
-    expect(cmd.parse("foo|bar")).to eq({left: {tag_name: "foo"}, binary_op: "|", right: {tag_name: "bar"}})
+    expect(cmd.parse("foo|bar")).to eq({left: {tagname: "foo"}, binary_op: "|", right: {tagname: "bar"}})
   end
 
   it "parses 'foo | bar'" do
-    expect(cmd.parse("foo | bar")).to eq({left: {tag_name: "foo"}, binary_op: "|", right: {tag_name: "bar"}})
+    expect(cmd.parse("foo | bar")).to eq({left: {tagname: "foo"}, binary_op: "|", right: {tagname: "bar"}})
   end
 
   it "parses 'foo|bar|baz'" do
-    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"}}})
+    expect(cmd.parse("foo|bar|baz")).to eq({left: {tagname: "foo"}, binary_op: "|", right: {left: {tagname: "bar"}, binary_op: "|", right: {tagname: "baz"}}})
   end
 
   it "parses 'foo | bar | baz'" do
-    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"}}})
+    expect(cmd.parse("foo | bar | baz")).to eq({left: {tagname: "foo"}, binary_op: "|", right: {left: {tagname: "bar"}, binary_op: "|", right: {tagname: "baz"}}})
   end
 
   it "parses 'foo||bar'" do
-    expect(cmd.parse("foo||bar")).to eq({left: {tag_name: "foo"}, binary_op: "||", right: {tag_name: "bar"}})
+    expect(cmd.parse("foo||bar")).to eq({left: {tagname: "foo"}, binary_op: "||", right: {tagname: "bar"}})
   end
 
   it "parses 'foo || bar'" do
-    expect(cmd.parse("foo || bar")).to eq({left: {tag_name: "foo"}, binary_op: "||", right: {tag_name: "bar"}})
+    expect(cmd.parse("foo || bar")).to eq({left: {tagname: "foo"}, binary_op: "||", right: {tagname: "bar"}})
   end
 
   it "parses 'foo||bar||baz'" do
-    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"}}})
+    expect(cmd.parse("foo||bar||baz")).to eq({left: {tagname: "foo"}, binary_op: "||", right: {left: {tagname: "bar"}, binary_op: "||", right: {tagname: "baz"}}})
   end
 
   it "parses 'foo || bar || baz'" do
-    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"}}})
+    expect(cmd.parse("foo || bar || baz")).to eq({left: {tagname: "foo"}, binary_op: "||", right: {left: {tagname: "bar"}, binary_op: "||", right: {tagname: "baz"}}})
   end
 
   it "parses '(foo and bar) or baz'" do
-    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"}})
+    expect(cmd.parse("(foo and bar) or baz")).to eq({left: {left: {tagname: "foo"}, binary_op: "and", right: {tagname: "bar"}}, binary_op: "or", right: {tagname: "baz"}})
   end
 
   it "parses 'foo and (bar or baz)'" do
-    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"}}})
+    expect(cmd.parse("foo and (bar or baz)")).to eq({left: {tagname: "foo"}, binary_op: "and", right: {left: {tagname: "bar"}, binary_op: "or", right: {tagname: "baz"}}})
   end
 
   it "parses 'not foo and bar'" do
-    expect(cmd.parse("not foo and bar")).to eq({unary_op: "not", expression: {left: {tag_name: "foo"}, binary_op: "and", right: {tag_name: "bar"}}})
+    expect(cmd.parse("not foo and bar")).to eq({unary_op: "not", expression: {left: {tagname: "foo"}, binary_op: "and", right: {tagname: "bar"}}})
   end
 
   it "parses '! foo and bar'" do
-    expect(cmd.parse("! foo and bar")).to eq({left: {unary_op: "!", expression: {tag_name: "foo"}}, binary_op: "and", right: {tag_name: "bar"}})
+    expect(cmd.parse("! foo and bar")).to eq({left: {unary_op: "!", expression: {tagname: "foo"}}, binary_op: "and", right: {tagname: "bar"}})
   end
 
   it "parses 'not foo && bar'" do
-    expect(cmd.parse("not foo && bar")).to eq({unary_op: "not", expression: {left: {tag_name: "foo"}, binary_op: "&&", right: {tag_name: "bar"}}})
+    expect(cmd.parse("not foo && bar")).to eq({unary_op: "not", expression: {left: {tagname: "foo"}, binary_op: "&&", right: {tagname: "bar"}}})
   end
 
   it "parses '! foo && bar'" do
-    expect(cmd.parse("! foo && bar")).to eq({left: {unary_op: "!", expression: {tag_name: "foo"}}, binary_op: "&&", right: {tag_name: "bar"}})
+    expect(cmd.parse("! foo && bar")).to eq({left: {unary_op: "!", expression: {tagname: "foo"}}, binary_op: "&&", right: {tagname: "bar"}})
   end
 
   it "parses 'f(x)'" do
-    expect(cmd.parse("f(x)")).to eq({funcall: "f", funcall_args: {funcall_args_head: {tag_name: "x"}}})
+    expect(cmd.parse("f(x)")).to eq({funcall: "f", funcall_args: {funcall_args_head: {tagname: "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\""}}}})
+    expect(cmd.parse("f(x, \"y\")")).to eq({funcall: "f", funcall_args: {funcall_args_head: {tagname: "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/"}}}}})
+    expect(cmd.parse("f(x, \"y\", /z/)")).to eq({funcall: "f", funcall_args: {funcall_args_head: {tagname: "x"}, funcall_args_tail: {funcall_args_head: {string: "\"y\""}, funcall_args_tail: {funcall_args_head: {regexp: "/z/"}}}}})
   end
 
   it "parses 'g ( 12345 )'" do
@@ -315,11 +315,11 @@ describe "parser" do
   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"}}}})
+    expect(cmd.parse("foo and bar(y)")).to eq({binary_op: "and", left: {tagname: "foo"}, right: {funcall: "bar", funcall_args: {funcall_args_head: {tagname: "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"}}}})
+    expect(cmd.parse("foo(x) and bar(y)")).to eq({binary_op: "and", left: {funcall: "foo", funcall_args: {funcall_args_head: {tagname: "x"}}}, right: {funcall: "bar", funcall_args: {funcall_args_head: {tagname: "y"}}}})
   end
 
   it "is unable to parse ' '" do