hotdog 0.6.1 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1b087123acdf59f344d374145bdf0915f57757f6
-  data.tar.gz: 0f22b57543b9b6d83e904d9f643eac3ccc3a6a52
+  metadata.gz: 91215663a09880593d00a5067b5f65ce3cb4b288
+  data.tar.gz: e840f3478257b84e516d4af7f6c4464cdaa7306b
 SHA512:
-  metadata.gz: 51f9b047b0bc2cf02ae5abb013d02e1c0c52e5e7530ec7b27e313663a5e2022214d578a7bb58531e1f8c6e7833de1f2b4205e8c78bd319659c4499b67eb5edf1
-  data.tar.gz: f6017f78210111e9bc19492b0a2b0724c15cfebe568e68d2902d71f5b2861428a3665caff8c25794d1ce07cbe057eb2ca05338a02a598b32b39611fd03514d9d
+  metadata.gz: 8beeb9c046d7467a48025aa7156f9b8e04c19f3923eb544086b5bec52f7cc0afddae29cad26cd699803fe0046c623e0179159917a3dc5e41b2996a0b39ae8246
+  data.tar.gz: 199c17a2d104dbb24c5135ac2cc180b9a26f594b1d2aaf9eb1870f3ba6e7b209a27b6b08d061c34598877ed385b4accb505d35ee3543f79f95554668b56b5695

data/lib/hotdog/commands/pssh.rb

@@ -44,17 +44,6 @@ module Hotdog
         end
       end
 
-      def parse_options(optparse, args=[])
-        if args.index("--")
-          @remote_command = args.slice(args.index("--") + 1, args.length).join(" ")
-          optparse.parse(args.slice(0, args.index("--")))
-        else
-          @remote_command = nil
-          optparse.parse(args)
-        end
-      end
-      attr_reader :remote_command
-
       def run(args=[], options={})
         expression = args.join(" ").strip
         if expression.empty?

data/lib/hotdog/commands/search.rb

@@ -12,7 +12,21 @@ module Hotdog
         end
       end
 
+      def parse_options(optparse, args=[])
+        if args.index("--")
+          @remote_command = args.slice(args.index("--") + 1, args.length).join(" ")
+          optparse.parse(args.slice(0, args.index("--")))
+        else
+          @remote_command = nil
+          optparse.parse(args)
+        end
+      end
+      attr_reader :remote_command
+
       def run(args=[], options={})
+        if @remote_command
+          logger.warn("ignore remote command: #{@remote_command}")
+        end
         expression = args.join(" ").strip
         if expression.empty?
           # return everything if given expression is empty
@@ -65,6 +79,7 @@ module Hotdog
       end
 
       def parse(expression)
+        logger.debug(expression)
         parser = ExpressionParser.new
         parser.parse(expression).tap do |parsed|
           logger.debug {
@@ -214,14 +229,14 @@ module Hotdog
         }
         rule(identifier_regexp: simple(:identifier_regexp), separator: simple(:separator)) {
           if "host" == identifier_regexp
-            AnyHostNode.new(separator)
+            EverythingNode.new()
           else
             RegexpTagNameNode.new(identifier_regexp.to_s, separator)
           end
         }
         rule(identifier_regexp: simple(:identifier_regexp)) {
           if "host" == identifier_regexp
-            AnyHostNode.new(separator)
+            EverythingNode.new()
           else
             RegexpNode.new(identifier_regexp.to_s)
           end
@@ -242,14 +257,14 @@ module Hotdog
         }
         rule(identifier_glob: simple(:identifier_glob), separator: simple(:separator)) {
           if "host" == identifier_glob
-            AnyHostNode.new(separator)
+            EverythingNode.new()
           else
             GlobTagNameNode.new(identifier_glob.to_s, separator)
           end
         }
         rule(identifier_glob: simple(:identifier_glob)) {
           if "host" == identifier_glob
-            AnyHostNode.new(separator)
+            EverythingNode.new()
           else
             GlobNode.new(identifier_glob.to_s)
           end
@@ -270,14 +285,14 @@ module Hotdog
         }
         rule(identifier: simple(:identifier), separator: simple(:separator)) {
           if "host" == identifier
-            AnyHostNode.new(separator)
+            EverythingNode.new()
           else
             StringTagNameNode.new(identifier.to_s, separator)
           end
         }
         rule(identifier: simple(:identifier)) {
           if "host" == identifier
-            AnyHostNode.new(separator)
+            EverythingNode.new()
           else
             StringNode.new(identifier.to_s)
           end
@@ -328,7 +343,7 @@ module Hotdog
         attr_reader :op, :expression
 
         def initialize(op, expression)
-          case op
+          case (op || "not").to_s
           when "!", "~", /\Anot\z/i
             @op = :NOT
           else
@@ -369,7 +384,14 @@ module Hotdog
           @expression = @expression.optimize(options)
           case op
           when :NOT
-            optimize1(options)
+            case expression
+            when EverythingNode
+              NothingNode.new(options)
+            when NothingNode
+              EverythingNode.new(options)
+            else
+              optimize1(options)
+            end
           else
             self
           end
@@ -398,7 +420,16 @@ module Hotdog
             if UnaryExpressionNode === expression and expression.op == :NOT
               expression.expression
             else
-              if TagExpressionNode === expression
+              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
@@ -420,7 +451,7 @@ module Hotdog
         attr_reader :op, :left, :right
 
         def initialize(op, left, right)
-          case op || "or"
+          case (op || "or").to_s
           when "&&", "&", /\Aand\z/i
             @op = :AND
           when "||", "|", /\Aor\z/i
@@ -529,30 +560,44 @@ module Hotdog
           @right = @right.optimize(options)
           case op
           when :AND
-            if left == right
+            case left
+            when EverythingNode
+              right
+            when NothingNode
               left
             else
-              optimize1(options)
+              if left == right
+                left
+              else
+                optimize1(options)
+              end
             end
           when :OR
-            if left == right
+            case left
+            when EverythingNode
+              left
+            when NothingNode
               left
             else
-              if MultinaryExpressionNode === left
-                if left.op == op
-                  left.merge(right, fallback: self)
-                else
-                  optimize1(options)
-                end
+              if left == right
+                left
               else
-                if MultinaryExpressionNode === right
-                  if right.op == op
-                    right.merge(left, fallback: self)
+                if MultinaryExpressionNode === left
+                  if left.op == op
+                    left.merge(right, fallback: self)
                   else
                     optimize1(options)
                   end
                 else
-                  MultinaryExpressionNode.new(op, [left, right], fallback: self)
+                  if MultinaryExpressionNode === right
+                    if right.op == op
+                      right.merge(left, fallback: self)
+                    else
+                      optimize1(options)
+                    end
+                  else
+                    MultinaryExpressionNode.new(op, [left, right], fallback: self)
+                  end
                 end
               end
             end
@@ -619,8 +664,8 @@ module Hotdog
         attr_reader :op, :expressions
 
         def initialize(op, expressions, options={})
-          case op
-          when :OR
+          case (op || "or").to_s
+          when "||", "|", /\Aor\z/i
             @op = :OR
           else
             raise(SyntaxError.new("unknown multinary operator: #{op.inspect}"))
@@ -686,14 +731,16 @@ module Hotdog
       end
 
       class QueryExpressionNode < ExpressionNode
-        def initialize(query, args=[], options={})
+        def initialize(query, values=[], options={})
           @query = query
-          @args = args
+          @values = values
           @fallback = options[:fallback]
         end
+        attr_reader :query
+        attr_reader :values
 
         def evaluate(environment, options={})
-          values = environment.execute(@query, @args).map { |row| row.first }
+          values = environment.execute(@query, @values).map { |row| row.first }
           if values.empty? and @fallback
             @fallback.evaluate(environment, options).tap do |values|
               if values.empty?
@@ -706,12 +753,32 @@ module Hotdog
         end
 
         def dump(options={})
-          data = {query: @query, arguments: @args}
+          data = {query: @query, values: @values}
           data[:fallback] = @fallback.dump(options) if @fallback
           data
         end
       end
 
+      class EverythingNode < QueryExpressionNode
+        def initialize(options={})
+          super("SELECT id AS host_id FROM hosts", [], options)
+        end
+      end
+
+      class NothingNode < QueryExpressionNode
+        def initialize(options={})
+          super("SELECT NULL AS host_id WHERE host_id NOT NULL", [], options)
+        end
+
+        def evaluate(environment, options={})
+          if @fallback
+            @fallback.evaluate(environment, options)
+          else
+            []
+          end
+        end
+      end
+
       class TagExpressionNode < ExpressionNode
         def initialize(identifier, attribute, separator=nil)
           @identifier = identifier
@@ -878,24 +945,6 @@ module Hotdog
         end
       end
 
-      class AnyTagNode < TagExpressionNode
-        def initialize(separator=nil)
-          super(nil, nil, separator)
-        end
-
-        def condition(options={})
-          "1"
-        end
-
-        def condition_tables(options={})
-          [:tags]
-        end
-
-        def condition_values(options={})
-          []
-        end
-      end
-
       class StringExpressionNode < TagExpressionNode
       end
 

data/lib/hotdog/commands/ssh.rb

@@ -39,17 +39,6 @@ module Hotdog
         end
       end
 
-      def parse_options(optparse, args=[])
-        if args.index("--")
-          @remote_command = args.slice(args.index("--") + 1, args.length).join(" ")
-          optparse.parse(args.slice(0, args.index("--")))
-        else
-          @remote_command = nil
-          optparse.parse(args)
-        end
-      end
-      attr_reader :remote_command
-
       def run(args=[], options={})
         expression = args.join(" ").strip
         if expression.empty?

data/lib/hotdog/version.rb

@@ -1,3 +1,3 @@
 module Hotdog
-  VERSION = "0.6.1"
+  VERSION = "0.6.2"
 end

data/spec/parser/glob_expression_spec.rb

@@ -69,10 +69,11 @@ describe "tag glob expression" do
     expr = Hotdog::Commands::Search::GlobTagValueNode.new("foo*", ":")
     q = [
       "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(tags.value) GLOB LOWER(?);",
+          "WHERE LOWER(hosts.name) GLOB LOWER(?) OR LOWER(tags.value) GLOB LOWER(?);",
     ]
-    allow(cmd).to receive(:execute).with(q.join(" "), ["foo*"]) {
+    allow(cmd).to receive(:execute).with(q.join(" "), ["foo*", "foo*"]) {
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
@@ -83,10 +84,11 @@ describe "tag glob expression" do
     expr = Hotdog::Commands::Search::GlobTagValueNode.new("foo*", nil)
     q = [
       "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(tags.value) GLOB LOWER(?);",
+          "WHERE LOWER(hosts.name) GLOB LOWER(?) OR LOWER(tags.value) GLOB LOWER(?);",
     ]
-    allow(cmd).to receive(:execute).with(q.join(" "), ["foo*"]) {
+    allow(cmd).to receive(:execute).with(q.join(" "), ["foo*", "foo*"]) {
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])

data/spec/parser/regexp_expression_spec.rb

@@ -69,10 +69,11 @@ describe "tag regexp expression" do
     expr = Hotdog::Commands::Search::RegexpTagValueNode.new("foo", ":")
     q = [
       "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 tags.value REGEXP ?;",
+          "WHERE hosts.name REGEXP ? OR tags.value REGEXP ?;",
     ]
-    allow(cmd).to receive(:execute).with(q.join(" "), ["foo"]) {
+    allow(cmd).to receive(:execute).with(q.join(" "), ["foo", "foo"]) {
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
@@ -83,10 +84,11 @@ describe "tag regexp expression" do
     expr = Hotdog::Commands::Search::RegexpTagValueNode.new("foo", nil)
     q = [
       "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 tags.value REGEXP ?;",
+          "WHERE hosts.name REGEXP ? OR tags.value REGEXP ?;",
     ]
-    allow(cmd).to receive(:execute).with(q.join(" "), ["foo"]) {
+    allow(cmd).to receive(:execute).with(q.join(" "), ["foo", "foo"]) {
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])

data/spec/parser/string_expression_spec.rb

@@ -69,10 +69,11 @@ describe "tag expression" do
     expr = Hotdog::Commands::Search::StringTagValueNode.new("foo", ":")
     q = [
       "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 tags.value = ?;",
+          "WHERE hosts.name = ? OR tags.value = ?;",
     ]
-    allow(cmd).to receive(:execute).with(q.join(" "), ["foo"]) {
+    allow(cmd).to receive(:execute).with(q.join(" "), ["foo", "foo"]) {
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])
@@ -83,10 +84,11 @@ describe "tag expression" do
     expr = Hotdog::Commands::Search::StringTagValueNode.new("foo", nil)
     q = [
       "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 tags.value = ?;",
+          "WHERE hosts.name = ? OR tags.value = ?;",
     ]
-    allow(cmd).to receive(:execute).with(q.join(" "), ["foo"]) {
+    allow(cmd).to receive(:execute).with(q.join(" "), ["foo", "foo"]) {
       [[1], [2], [3]]
     }
     expect(expr.evaluate(cmd)).to eq([1, 2, 3])

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hotdog
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.2
 platform: ruby
 authors:
 - Yamashita Yuu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-08 00:00:00.000000000 Z
+date: 2015-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler