hotdog 0.25.0 → 0.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a6cb5a21b306e4a1d4ba2ed3f56a32bccede9d3e
-  data.tar.gz: db352cb8caf7b6204b5af04cae89ade3bb3225a3
+  metadata.gz: 5d13acaecbe1b4f13f6b9956f2e75cf69cfaff23
+  data.tar.gz: acdef611442f0a968b0b9810c962b25864c0b406
 SHA512:
-  metadata.gz: 2f34769acd4326c2d965fee9e69587af995d1764e00318531e8d36fab9020f520aaa4cb57d5950a95938a895ac3359a4800cdae089673c59f5c280f1d16a4611
-  data.tar.gz: cbcafc9311ea4f8384f57065324c104d0948bc8f95ad0e5108a4479d319e603e2501a8cc25b89c00057fbdd0777585b6b5621e43ed1695b07091e6faa27dc1b5
+  metadata.gz: a6f4cc4380eea63cee183a0baff9b606e40e94cdc6522e5e16e33e44acb161987d6001ebf743fa6a7f054c4ed8cc034edd8494893a4c9736be58376efbd2ad7d
+  data.tar.gz: 950a18e1686c18591e474900353f738c78cc5f568c830dd41f43b231905eebdfe3bc415fd1662d710e9ec1072e4bba3ab050886f239a20aa35e8c237f7db75e0

data/lib/hotdog/commands/down.rb

@@ -39,7 +39,8 @@ module Hotdog
           with_retry(error_handler: ->(error) { reload }) do
             if open_db
               @db.transaction do
-                hosts.each_slice(SQLITE_LIMIT_COMPOUND_SELECT) do |hosts|
+                sqlite_limit_compound_select = options[:sqlite_limit_compound_select] || SQLITE_LIMIT_COMPOUND_SELECT
+                hosts.each_slice(sqlite_limit_compound_select) do |hosts|
                   execute_db(@db, "DELETE FROM hosts_tags WHERE host_id IN ( SELECT id FROM hosts WHERE name IN (%s) );" % hosts.map { "?" }.join(", "), hosts)
                   execute_db(@db, "DELETE FROM hosts WHERE name IN (%s);" % hosts.map { "?" }.join(", "), hosts)
                 end

data/lib/hotdog/commands/hosts.rb

@@ -13,7 +13,8 @@ module Hotdog
               execute("SELECT id FROM hosts WHERE LOWER(name) GLOB LOWER(?);", [host_name]).to_a.reduce(:+) || []
             }
           else
-            result = args.each_slice(SQLITE_LIMIT_COMPOUND_SELECT).flat_map { |args|
+            sqlite_limit_compound_select = options[:sqlite_limit_compound_select] || SQLITE_LIMIT_COMPOUND_SELECT
+            result = args.each_slice(sqlite_limit_compound_select).flat_map { |args|
               execute("SELECT id FROM hosts WHERE name IN (%s);" % args.map { "?" }.join(", "), args).to_a.reduce(:+) || []
             }
           end

data/lib/hotdog/commands/pssh.rb

@@ -5,6 +5,7 @@ require "parallel"
 require "parslet"
 require "shellwords"
 require "tempfile"
+require "thread"
 require "hotdog/commands/ssh"
 
 module Hotdog
@@ -43,9 +44,10 @@ module Hotdog
               true
             }
           else
+            output_lock = Mutex.new
             stats = Parallel.map(hosts_cmdlines.each_with_index.to_a, in_threads: parallelism(hosts)) { |(host, cmdline), i|
               identifier = options[:show_identifier] ? host : nil
-              success = exec_command(identifier, cmdline, index: i, output: true, infile: (infile ? infile.path : nil))
+              success = exec_command(identifier, cmdline, index: i, output: true, infile: (infile ? infile.path : nil), output_lock: output_lock)
               if !success && options[:stop_on_error]
                 raise StopException.new
               end

data/lib/hotdog/commands/ssh.rb

@@ -3,6 +3,7 @@
 require "json"
 require "parslet"
 require "shellwords"
+require "thread"
 require "hotdog/commands/search"
 
 module Hotdog
@@ -152,42 +153,75 @@ module Hotdog
 
       def exec_command(identifier, cmdline, options={})
         output = options.fetch(:output, true)
+        output_lock = options[:output_lock] || Mutex.new
         logger.debug("execute: #{cmdline}")
         if use_color?
-          if options.key?(:index)
-            color = 31 + (options[:index] % 6)
-          else
-            color = 36
-          end
+          color = color_code(options[:index])
         else
           color = nil
         end
         if options[:infile]
-          stdin = IO.popen("cat #{Shellwords.shellescape(options[:infile])}")
-        else
-          stdin = :close
-        end
-        IO.popen(cmdline, in: stdin) do |io|
-          io.each_with_index do |s, i|
-            if output
-              if identifier
-                if color
-                  STDOUT.write("\e[0;#{color}m")
-                end
-                STDOUT.write(identifier)
-                STDOUT.write(":")
-                STDOUT.write(i.to_s)
-                STDOUT.write(":")
-                if color
-                  STDOUT.write("\e[0m")
-                end
+          cmdline = "cat #{Shellwords.shellescape(options[:infile])} | #{cmdline}"
+        end
+        cmderr, child_cmderr = IO.pipe
+        IO.popen(cmdline, in: :close, err: child_cmderr) do |cmdout|
+          i = 0
+          each_readable([cmderr, cmdout]) do |readable|
+            raw = readable.readline
+            output_lock.synchronize do
+              if readable == cmdout
+                STDOUT.puts(prettify_output(raw, i, color, identifier))
+                i += 1
+              else
+                STDERR.puts(raw)
               end
-              STDOUT.puts(s)
             end
           end
         end
         $?.success? # $? is thread-local variable
       end
+
+      private
+      def each_readable(read_list, timeout=1)
+        loop do
+          # we cannot look until IO#eof? since it will block for pipes
+          # http://ruby-doc.org/core-2.4.0/IO.html#method-i-eof-3F
+          rs = Array(IO.select(read_list, [], [], timeout)).first
+          if r = Array(rs).first
+            begin
+              yield r
+            rescue EOFError => error
+              break
+            end
+          end
+        end
+      end
+
+      def color_code(index)
+        if index
+          color = 31 + (index % 6)
+        else
+          color = 36
+        end
+      end
+
+      def prettify_output(raw, i, color, identifier)
+        buf = []
+        if identifier
+          if color
+            buf << ("\e[0;#{color}m")
+          end
+          buf << identifier
+          buf << ":"
+          buf << i.to_s
+          buf << ":"
+          if color
+            buf << "\e[0m"
+          end
+        end
+        buf << raw
+        buf.join
+      end
     end
 
     class SingularSshAlike < SshAlike

data/lib/hotdog/commands/tags.rb

@@ -9,14 +9,15 @@ module Hotdog
           show_tags(result)
         else
           tags = args.map { |tag| split_tag(tag) }
+          sqlite_limit_compound_select = options[:sqlite_limit_compound_select] || SQLITE_LIMIT_COMPOUND_SELECT
           if tags.all? { |_tagname, tagvalue| tagvalue.empty? }
-            result = tags.each_slice(SQLITE_LIMIT_COMPOUND_SELECT).flat_map { |tags|
+            result = tags.each_slice(sqlite_limit_compound_select).flat_map { |tags|
               q = "SELECT value FROM tags " \
                     "WHERE %s;" % tags.map { |tagname, _tagvalue| glob?(tagname) ? "LOWER(name) GLOB LOWER(?)" : "name = ?" }.join(" OR ")
               execute(q, tags.map { |tagname, _tagvalue| tagname }).map { |value| [value] }
             }
           else
-            result = tags.each_slice(SQLITE_LIMIT_COMPOUND_SELECT / 2).flat_map { |tags|
+            result = tags.each_slice(sqlite_limit_compound_select / 2).flat_map { |tags|
               q = "SELECT value FROM tags " \
                     "WHERE %s;" % tags.map { |tagname, tagvalue| (glob?(tagname) or glob?(tagvalue)) ? "( LOWER(name) GLOB LOWER(?) AND LOWER(value) GLOB LOWER(?) )" : "( name = ? AND value = ? )" }.join(" OR ")
               execute(q, tags).map { |value| [value] }

data/lib/hotdog/expression/semantics.rb

@@ -25,6 +25,8 @@ module Hotdog
 
       def initialize(op, expression)
         case (op || "not").to_s
+        when "NOOP", "noop"
+          @op = :NOOP
         when "!", "~", "NOT", "not"
           @op = :NOT
         else
@@ -35,6 +37,8 @@ module Hotdog
 
       def evaluate(environment, options={})
         case @op
+        when :NOOP
+          @expression.evaluate(environment, options)
         when :NOT
           values = @expression.evaluate(environment, options).tap do |values|
             environment.logger.debug("expr: #{values.length} value(s)")
@@ -46,8 +50,9 @@ module Hotdog
           else
             # workaround for "too many terms in compound SELECT"
             min, max = environment.execute("SELECT MIN(id), MAX(id) FROM hosts LIMIT 1;").first.to_a
-            (min / (SQLITE_LIMIT_COMPOUND_SELECT - 2)).upto(max / (SQLITE_LIMIT_COMPOUND_SELECT - 2)).flat_map { |i|
-              range = ((SQLITE_LIMIT_COMPOUND_SELECT - 2) * i)...((SQLITE_LIMIT_COMPOUND_SELECT - 2) * (i + 1))
+            sqlite_limit_compound_select = options[:sqlite_limit_compound_select] || SQLITE_LIMIT_COMPOUND_SELECT
+            (min / (sqlite_limit_compound_select - 2)).upto(max / (sqlite_limit_compound_select - 2)).flat_map { |i|
+              range = ((sqlite_limit_compound_select - 2) * i)...((sqlite_limit_compound_select - 2) * (i + 1))
               selected = values.select { |n| range === n }
               q = "SELECT id FROM hosts " \
                     "WHERE ? <= id AND id < ? AND id NOT IN (%s);"
@@ -62,8 +67,9 @@ module Hotdog
       end
 
       def optimize(options={})
-        @expression = @expression.optimize(options)
         case op
+        when :NOOP
+          optimize1(options)
         when :NOT
           case expression
           when EverythingNode
@@ -74,6 +80,7 @@ module Hotdog
             optimize1(options)
           end
         else
+          @expression = expression.optimize(options)
           self
         end
       end
@@ -89,30 +96,45 @@ module Hotdog
       private
       def optimize1(options={})
         case op
+        when :NOOP
+          expression.optimize(options)
         when :NOT
-          if UnaryExpressionNode === expression and expression.op == :NOT
-            expression.expression
-          else
-            case expression
-            when QueryExpressionNode
-              q = expression.query
-              v = expression.values
-              if q and v.length <= SQLITE_LIMIT_COMPOUND_SELECT
-                QueryExpressionNode.new("SELECT id AS host_id FROM hosts EXCEPT #{q.sub(/\s*;\s*\z/, "")};", v)
-              else
-                self
-              end
-            when TagExpressionNode
-              q = expression.maybe_query(options)
-              v = expression.condition_values(options)
-              if q and v.length <= SQLITE_LIMIT_COMPOUND_SELECT
-                QueryExpressionNode.new("SELECT id AS host_id FROM hosts EXCEPT #{q.sub(/\s*;\s*\z/, "")};", v)
-              else
-                self
-              end
+          if UnaryExpressionNode === expression
+            case expression.op
+            when :NOOP
+              @expression = expression.optimize(options)
+              optimize2(options)
+            when :NOT
+              expression.expression.optimize(options)
             else
               self
             end
+          else
+            optimize2(options)
+          end
+        else
+          self
+        end
+      end
+
+      def optimize2(options={})
+        sqlite_limit_compound_select = options[:sqlite_limit_compound_select] || SQLITE_LIMIT_COMPOUND_SELECT
+        case expression
+        when QueryExpressionNode
+          q = expression.query
+          v = expression.values
+          if q and v.length <= sqlite_limit_compound_select
+            QueryExpressionNode.new("SELECT id AS host_id FROM hosts EXCEPT #{q.sub(/\s*;\s*\z/, "")};", v)
+          else
+            self
+          end
+        when TagExpressionNode
+          q = expression.maybe_query(options)
+          v = expression.condition_values(options)
+          if q and v.length <= sqlite_limit_compound_select
+            QueryExpressionNode.new("SELECT id AS host_id FROM hosts EXCEPT #{q.sub(/\s*;\s*\z/, "")};", v)
+          else
+            self
           end
         else
           self
@@ -155,8 +177,9 @@ module Hotdog
             else
               # workaround for "too many terms in compound SELECT"
               min, max = environment.execute("SELECT MIN(id), MAX(id) FROM hosts LIMIT 1;").first.to_a
-              (min / ((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 2)).upto(max / ((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 2)).flat_map { |i|
-                range = (((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 2) * i)...(((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 2) * (i + 1))
+              sqlite_limit_compound_select = options[:sqlite_limit_compound_select] || SQLITE_LIMIT_COMPOUND_SELECT
+              (min / ((sqlite_limit_compound_select - 2) / 2)).upto(max / ((sqlite_limit_compound_select - 2) / 2)).flat_map { |i|
+                range = (((sqlite_limit_compound_select - 2) / 2) * i)...(((sqlite_limit_compound_select - 2) / 2) * (i + 1))
                 left_selected = left_values.select { |n| range === n }
                 right_selected = right_values.select { |n| range === n }
                 q = "SELECT id FROM hosts " \
@@ -182,8 +205,9 @@ module Hotdog
             else
               # workaround for "too many terms in compound SELECT"
               min, max = environment.execute("SELECT MIN(id), MAX(id) FROM hosts LIMIT 1;").first.to_a
-              (min / ((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 2)).upto(max / ((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 2)).flat_map { |i|
-                range = (((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 2) * i)...(((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 2) * (i + 1))
+              sqlite_limit_compound_select = options[:sqlite_limit_compound_select] || SQLITE_LIMIT_COMPOUND_SELECT
+              (min / ((sqlite_limit_compound_select - 2) / 2)).upto(max / ((sqlite_limit_compound_select - 2) / 2)).flat_map { |i|
+                range = (((sqlite_limit_compound_select - 2) / 2) * i)...(((sqlite_limit_compound_select - 2) / 2) * (i + 1))
                 left_selected = left_values.select { |n| range === n }
                 right_selected = right_values.select { |n| range === n }
                 q = "SELECT id FROM hosts " \
@@ -209,8 +233,9 @@ module Hotdog
             else
               # workaround for "too many terms in compound SELECT"
               min, max = environment.execute("SELECT MIN(id), MAX(id) FROM hosts LIMIT 1;").first.to_a
-              (min / ((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 4)).upto(max / ((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 4)).flat_map { |i|
-                range = (((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 4) * i)...(((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 4) * (i + 1))
+              sqlite_limit_compound_select = options[:sqlite_limit_compound_select] || SQLITE_LIMIT_COMPOUND_SELECT
+              (min / ((sqlite_limit_compound_select - 2) / 4)).upto(max / ((sqlite_limit_compound_select - 2) / 4)).flat_map { |i|
+                range = (((sqlite_limit_compound_select - 2) / 4) * i)...(((sqlite_limit_compound_select - 2) / 4) * (i + 1))
                 left_selected = left_values.select { |n| range === n }
                 right_selected = right_values.select { |n| range === n }
                 q = "SELECT id FROM hosts " \
@@ -300,7 +325,8 @@ module Hotdog
           lv = left.condition_values(options)
           rq = right.maybe_query(options)
           rv = right.condition_values(options)
-          if lq and rq and lv.length + rv.length <= SQLITE_LIMIT_COMPOUND_SELECT
+          sqlite_limit_compound_select = options[:sqlite_limit_compound_select] || SQLITE_LIMIT_COMPOUND_SELECT
+          if lq and rq and lv.length + rv.length <= sqlite_limit_compound_select
             case op
             when :AND
               q = "#{lq.sub(/\s*;\s*\z/, "")} INTERSECT #{rq.sub(/\s*;\s*\z/, "")};"
@@ -335,8 +361,9 @@ module Hotdog
         else
           raise(SyntaxError.new("unknown multinary operator: #{op.inspect}"))
         end
-        if SQLITE_LIMIT_COMPOUND_SELECT < expressions.length
-          raise(ArgumentError.new("expressions limit exceeded: #{expressions.length} for #{SQLITE_LIMIT_COMPOUND_SELECT}"))
+        sqlite_limit_compound_select = options[:sqlite_limit_compound_select] || SQLITE_LIMIT_COMPOUND_SELECT
+        if sqlite_limit_compound_select < expressions.length
+          raise(ArgumentError.new("expressions limit exceeded: #{expressions.length} for #{sqlite_limit_compound_select}"))
         end
         @expressions = expressions
         @fallback = options[:fallback]
@@ -358,7 +385,8 @@ module Hotdog
               query_without_condition = expressions.first.maybe_query_without_condition(options)
               if query_without_condition
                 condition_length = expressions.map { |expression| expression.condition_values(options).length }.max
-                expressions.each_slice(SQLITE_LIMIT_COMPOUND_SELECT / condition_length).flat_map { |expressions|
+                sqlite_limit_compound_select = options[:sqlite_limit_compound_select] || SQLITE_LIMIT_COMPOUND_SELECT
+                expressions.each_slice(sqlite_limit_compound_select / condition_length).flat_map { |expressions|
                   q = query_without_condition.sub(/\s*;\s*\z/, " WHERE #{expressions.map { |expression| "( %s )" % expression.condition(options) }.join(" OR ")};")
                   environment.execute(q, expressions.flat_map { |expression| expression.condition_values(options) }).map { |row| row.first }
                 }

data/lib/hotdog/version.rb

@@ -1,3 +1,3 @@
 module Hotdog
-  VERSION = "0.25.0"
+  VERSION = "0.26.0"
 end

data/spec/optimizer/unary_expression_spec.rb

@@ -5,7 +5,7 @@ require "hotdog/commands/search"
 require "parslet"
 
 describe "unary expression" do
-  it "should be everything" do
+  it "NOT nothing should return 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;",
@@ -13,11 +13,316 @@ describe "unary expression" do
     })
   end
 
-  it "should be nothing" do
+  it "NOT everything should return 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
+
+  it "NOT NOT nothing should return nothing" do
+    expr = Hotdog::Expression::UnaryExpressionNode.new(
+      "NOT",
+      Hotdog::Expression::UnaryExpressionNode.new(
+        "NOT",
+        Hotdog::Expression::NothingNode.new(),
+      ),
+    )
+    expect(expr.optimize.dump).to eq({
+      query: "SELECT NULL AS host_id WHERE host_id NOT NULL;",
+      values: [],
+    })
+  end
+
+  it "NOT NOT everything should return everything" do
+    expr = Hotdog::Expression::UnaryExpressionNode.new(
+      "NOT",
+      Hotdog::Expression::UnaryExpressionNode.new(
+        "NOT",
+        Hotdog::Expression::EverythingNode.new(),
+      ),
+    )
+    expect(expr.optimize.dump).to eq({
+      query: "SELECT id AS host_id FROM hosts;",
+      values: [],
+    })
+  end
+
+  it "NOT NOT NOT nothing should return everything" do
+    expr = Hotdog::Expression::UnaryExpressionNode.new(
+      "NOT",
+      Hotdog::Expression::UnaryExpressionNode.new(
+        "NOT",
+        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 "NOT NOT NOT everything should return nothing" do
+    expr = Hotdog::Expression::UnaryExpressionNode.new(
+      "NOT",
+      Hotdog::Expression::UnaryExpressionNode.new(
+        "NOT",
+        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
+
+  it "NOT host should return everything except the host" do
+    expr = Hotdog::Expression::UnaryExpressionNode.new(
+      "NOT",
+      Hotdog::Expression::StringHostNode.new("foo", ":"),
+    )
+    expect(expr.optimize.dump).to eq({
+      query: "SELECT id AS host_id FROM hosts EXCEPT SELECT hosts.id AS host_id FROM hosts WHERE hosts.name = ?;",
+      values: ["foo"],
+    })
+  end
+
+  it "NOT NOT host should return the host" do
+    expr = Hotdog::Expression::UnaryExpressionNode.new(
+      "NOT",
+      Hotdog::Expression::UnaryExpressionNode.new(
+        "NOT",
+        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 "NOT NOT NOT host should return everything except the host" do
+    expr = Hotdog::Expression::UnaryExpressionNode.new(
+      "NOT",
+      Hotdog::Expression::UnaryExpressionNode.new(
+        "NOT",
+        Hotdog::Expression::UnaryExpressionNode.new(
+          "NOT",
+          Hotdog::Expression::StringHostNode.new("foo", ":"),
+        ),
+      ),
+    )
+    expect(expr.optimize.dump).to eq({
+      query: "SELECT id AS host_id FROM hosts EXCEPT SELECT hosts.id AS host_id FROM hosts WHERE hosts.name = ?;",
+      values: ["foo"],
+    })
+  end
+
+  it "NOOP host should return the host" do
+    expr = Hotdog::Expression::UnaryExpressionNode.new(
+      "NOOP",
+      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 "NOOP NOOP host should return the host" do
+    expr = Hotdog::Expression::UnaryExpressionNode.new(
+      "NOOP",
+      Hotdog::Expression::UnaryExpressionNode.new(
+        "NOOP",
+        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 "NOOP NOOP NOOP host should return the host" do
+    expr = Hotdog::Expression::UnaryExpressionNode.new(
+      "NOOP",
+      Hotdog::Expression::UnaryExpressionNode.new(
+        "NOOP",
+        Hotdog::Expression::UnaryExpressionNode.new(
+          "NOOP",
+          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 "NOT NOOP NOOP host should return everything except the host" do
+    expr = Hotdog::Expression::UnaryExpressionNode.new(
+      "NOT",
+      Hotdog::Expression::UnaryExpressionNode.new(
+        "NOOP",
+        Hotdog::Expression::UnaryExpressionNode.new(
+          "NOOP",
+          Hotdog::Expression::StringHostNode.new("foo", ":"),
+        ),
+      ),
+    )
+    expect(expr.optimize.dump).to eq({
+      query: "SELECT id AS host_id FROM hosts EXCEPT SELECT hosts.id AS host_id FROM hosts WHERE hosts.name = ?;",
+      values: ["foo"],
+    })
+  end
+
+  it "NOOP NOT NOOP host should return everything except the host" do
+    expr = Hotdog::Expression::UnaryExpressionNode.new(
+      "NOOP",
+      Hotdog::Expression::UnaryExpressionNode.new(
+        "NOT",
+        Hotdog::Expression::UnaryExpressionNode.new(
+          "NOOP",
+          Hotdog::Expression::StringHostNode.new("foo", ":"),
+        ),
+      ),
+    )
+    expect(expr.optimize.dump).to eq({
+      query: "SELECT id AS host_id FROM hosts EXCEPT SELECT hosts.id AS host_id FROM hosts WHERE hosts.name = ?;",
+      values: ["foo"],
+    })
+  end
+
+  it "NOOP NOOP NOT host should return everything except the host" do
+    expr = Hotdog::Expression::UnaryExpressionNode.new(
+      "NOOP",
+      Hotdog::Expression::UnaryExpressionNode.new(
+        "NOOP",
+        Hotdog::Expression::UnaryExpressionNode.new(
+          "NOT",
+          Hotdog::Expression::StringHostNode.new("foo", ":"),
+        ),
+      ),
+    )
+    expect(expr.optimize.dump).to eq({
+      query: "SELECT id AS host_id FROM hosts EXCEPT SELECT hosts.id AS host_id FROM hosts WHERE hosts.name = ?;",
+      values: ["foo"],
+    })
+  end
+
+  it "NOOP NOT NOT host should return everything except the host" do
+    expr = Hotdog::Expression::UnaryExpressionNode.new(
+      "NOT",
+      Hotdog::Expression::UnaryExpressionNode.new(
+        "NOT",
+        Hotdog::Expression::UnaryExpressionNode.new(
+          "NOOP",
+          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 "NOT NOOP NOT host should return everything except the host" do
+    pending("optimization of 2+ depth unary expression is not yet supported")
+    expr = Hotdog::Expression::UnaryExpressionNode.new(
+      "NOT",
+      Hotdog::Expression::UnaryExpressionNode.new(
+        "NOOP",
+        Hotdog::Expression::UnaryExpressionNode.new(
+          "NOT",
+          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 "NOT NOT NOOP host should return everything except the host" do
+    expr = Hotdog::Expression::UnaryExpressionNode.new(
+      "NOT",
+      Hotdog::Expression::UnaryExpressionNode.new(
+        "NOT",
+        Hotdog::Expression::UnaryExpressionNode.new(
+          "NOOP",
+          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
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hotdog
 version: !ruby/object:Gem::Version
-  version: 0.25.0
+  version: 0.26.0
 platform: ruby
 authors:
 - Yamashita Yuu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-22 00:00:00.000000000 Z
+date: 2017-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler