hotdog 0.12.0 → 0.13.0

data/spec/parser/regexp_expression_spec.rb

@@ -10,7 +10,7 @@ describe "tag regexp expression" do
   }
 
   it "interprets tag regexp with host" do
-    expr = Hotdog::Commands::Search::RegexpHostNode.new("foo", ":")
+    expr = Hotdog::Expression::RegexpHostNode.new("foo", ":")
     q = [
       "SELECT hosts.id AS host_id FROM hosts",
         "WHERE hosts.name REGEXP ?;",
@@ -19,11 +19,11 @@ describe "tag regexp expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({identifier_regexp: "host", separator: ":", attribute_regexp: "foo"})
+    expect(expr.dump).to eq({tag_name_regexp: "host", separator: ":", tag_value_regexp: "foo"})
   end
 
-  it "interprets tag regexp with identifier and attribute" do
-    expr = Hotdog::Commands::Search::RegexpTagNode.new("foo", "bar", ":")
+  it "interprets tag regexp with tag_name and tag_value" do
+    expr = Hotdog::Expression::RegexpTagNode.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 regexp expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({identifier_regexp: "foo", separator: ":", attribute_regexp: "bar"})
+    expect(expr.dump).to eq({tag_name_regexp: "foo", separator: ":", tag_value_regexp: "bar"})
   end
 
-  it "interprets tag regexp with identifier with separator" do
-    expr = Hotdog::Commands::Search::RegexpTagNameNode.new("foo", ":")
+  it "interprets tag regexp with tag_name with separator" do
+    expr = Hotdog::Expression::RegexpTagNameNode.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 regexp expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({identifier_regexp: "foo", separator: ":"})
+    expect(expr.dump).to eq({tag_name_regexp: "foo", separator: ":"})
   end
 
-  it "interprets tag regexp with identifier without separator" do
-    expr = Hotdog::Commands::Search::RegexpNode.new("foo", nil)
+  it "interprets tag regexp with tag_name without separator" do
+    expr = Hotdog::Expression::RegexpNode.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 regexp expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({identifier_regexp: "foo"})
+    expect(expr.dump).to eq({tag_name_regexp: "foo"})
   end
 
-  it "interprets tag regexp with attribute with separator" do
-    expr = Hotdog::Commands::Search::RegexpTagValueNode.new("foo", ":")
+  it "interprets tag regexp with tag_value with separator" do
+    expr = Hotdog::Expression::RegexpTagValueNode.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 regexp expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({separator: ":", attribute_regexp: "foo"})
+    expect(expr.dump).to eq({separator: ":", tag_value_regexp: "foo"})
   end
 
-  it "interprets tag regexp with attribute without separator" do
-    expr = Hotdog::Commands::Search::RegexpTagValueNode.new("foo", nil)
+  it "interprets tag regexp with tag_value without separator" do
+    expr = Hotdog::Expression::RegexpTagValueNode.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 regexp expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({attribute_regexp: "foo"})
+    expect(expr.dump).to eq({tag_value_regexp: "foo"})
   end
 
   it "empty tag regexp" do
-    expr = Hotdog::Commands::Search::RegexpExpressionNode.new(nil, nil, nil)
+    expr = Hotdog::Expression::RegexpExpressionNode.new(nil, nil, nil)
     expect {
       expr.evaluate(cmd)
     }.to raise_error(NotImplementedError)

data/spec/parser/string_expression_spec.rb

@@ -10,7 +10,7 @@ describe "tag expression" do
   }
 
   it "interprets tag with host" do
-    expr = Hotdog::Commands::Search::StringHostNode.new("foo", ":")
+    expr = Hotdog::Expression::StringHostNode.new("foo", ":")
     q = [
       "SELECT hosts.id AS host_id FROM hosts",
         "WHERE hosts.name = ?;",
@@ -19,11 +19,11 @@ describe "tag expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({identifier: "host", separator: ":", attribute: "foo"})
+    expect(expr.dump).to eq({tag_name: "host", separator: ":", tag_value: "foo"})
   end
 
-  it "interprets tag with identifier and attribute" do
-    expr = Hotdog::Commands::Search::StringTagNode.new("foo", "bar", ":")
+  it "interprets tag with tag_name and tag_value" do
+    expr = Hotdog::Expression::StringTagNode.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 expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({identifier: "foo", separator: ":", attribute: "bar"})
+    expect(expr.dump).to eq({tag_name: "foo", separator: ":", tag_value: "bar"})
   end
 
-  it "interprets tag with identifier with separator" do
-    expr = Hotdog::Commands::Search::StringTagNameNode.new("foo", ":")
+  it "interprets tag with tag_name with separator" do
+    expr = Hotdog::Expression::StringTagNameNode.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 expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({identifier: "foo", separator: ":"})
+    expect(expr.dump).to eq({tag_name: "foo", separator: ":"})
   end
 
-  it "interprets tag with identifier without separator" do
-    expr = Hotdog::Commands::Search::StringNode.new("foo", nil)
+  it "interprets tag with tag_name without separator" do
+    expr = Hotdog::Expression::StringNode.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 expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({identifier: "foo"})
+    expect(expr.dump).to eq({tag_name: "foo"})
   end
 
-  it "interprets tag with attribute with separator" do
-    expr = Hotdog::Commands::Search::StringTagValueNode.new("foo", ":")
+  it "interprets tag with tag_value with separator" do
+    expr = Hotdog::Expression::StringTagValueNode.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 expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({separator: ":", attribute: "foo"})
+    expect(expr.dump).to eq({separator: ":", tag_value: "foo"})
   end
 
-  it "interprets tag with attribute without separator" do
-    expr = Hotdog::Commands::Search::StringTagValueNode.new("foo", nil)
+  it "interprets tag with tag_value without separator" do
+    expr = Hotdog::Expression::StringTagValueNode.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 expression" do
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
-    expect(expr.dump).to eq({attribute: "foo"})
+    expect(expr.dump).to eq({tag_value: "foo"})
   end
 
   it "empty tag" do
-    expr = Hotdog::Commands::Search::StringExpressionNode.new(nil, nil, nil)
+    expr = Hotdog::Expression::StringExpressionNode.new(nil, nil, nil)
     expect {
       expr.evaluate(cmd)
     }.to raise_error(NotImplementedError)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hotdog
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Yamashita Yuu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-07 00:00:00.000000000 Z
+date: 2016-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -182,6 +182,9 @@ files:
 - lib/hotdog/commands/tags.rb
 - lib/hotdog/commands/up.rb
 - lib/hotdog/commands/version.rb
+- lib/hotdog/expression.rb
+- lib/hotdog/expression/semantics.rb
+- lib/hotdog/expression/syntax.rb
 - lib/hotdog/formatters.rb
 - lib/hotdog/formatters/csv.rb
 - lib/hotdog/formatters/json.rb