hotdog 0.24.0 → 0.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8498a1d399ef913b9d29a76bb4dcd3b934383d3a
-  data.tar.gz: 306372f50dbf1bb056f4668dab2e4877a10b5023
+  metadata.gz: a6cb5a21b306e4a1d4ba2ed3f56a32bccede9d3e
+  data.tar.gz: db352cb8caf7b6204b5af04cae89ade3bb3225a3
 SHA512:
-  metadata.gz: 77f1c40c00c9ac3d1893eeeee77cf4be3b1ce7d10713a2336cf8a74a6a62e3823f4bebacec432737533984971bf279a1dea15f1f3be6c0c7ff13ddce7d496c16
-  data.tar.gz: 57f0780c11d1d3e2822f68adee9918ea630b153b9f1d33ad56bb6350323f92e9779fafbe69ddc93a25f1bd5d028a8b6d65e15b124a2083fd6ff4aa746a191237
+  metadata.gz: 2f34769acd4326c2d965fee9e69587af995d1764e00318531e8d36fab9020f520aaa4cb57d5950a95938a895ac3359a4800cdae089673c59f5c280f1d16a4611
+  data.tar.gz: cbcafc9311ea4f8384f57065324c104d0948bc8f95ad0e5108a4479d319e603e2501a8cc25b89c00057fbdd0777585b6b5621e43ed1695b07091e6faa27dc1b5

data/lib/hotdog/commands.rb

@@ -89,8 +89,8 @@ module Hotdog
         else
           if 0 < tags.length
             fields = tags.map { |tag|
-              tag_name, _tag_value = split_tag(tag)
-              tag_name
+              tagname, _tagvalue = split_tag(tag)
+              tagname
             }
             get_hosts_fields(host_ids, fields)
           else
@@ -99,7 +99,7 @@ module Hotdog
                 fields = [
                   @options[:primary_tag],
                   "host",
-                ] + get_fields(host_ids).reject { |tag_name| tag_name == @options[:primary_tag] }
+                ] + get_fields(host_ids).reject { |tagname| tagname == @options[:primary_tag] }
                 get_hosts_fields(host_ids, fields)
               else
                 fields = [
@@ -152,9 +152,9 @@ module Hotdog
           end
         end
 
-        result = fields.map { |tag_name|
-          tag_value = field_values.fetch(tag_name.downcase, nil)
-          display_tag(tag_name, tag_value)
+        result = fields.map { |tagname|
+          tagvalue = field_values.fetch(tagname.downcase, nil)
+          display_tag(tagname, tagvalue)
         }
         [result, fields]
       end
@@ -171,8 +171,8 @@ module Hotdog
                   "INNER JOIN tags ON hosts_tags.tag_id = tags.id " \
                     "WHERE hosts_tags.host_id IN (%s) AND tags.name = ? " \
                       "GROUP BY hosts_tags.host_id, tags.name ORDER BY hosts_tags.host_id;" % host_ids.map { "?" }.join(", ")
-            r = execute(q, host_ids + [field]).map { |tag_name, tag_value|
-              [display_tag(tag_name, tag_value)]
+            r = execute(q, host_ids + [field]).map { |tagname, tagvalue|
+              [display_tag(tagname, tagvalue)]
             }
             if r.empty?
               host_ids.map { [nil] }
@@ -184,12 +184,12 @@ module Hotdog
         [result, [field]]
       end
 
-      def display_tag(tag_name, tag_value)
-        if tag_value
-          if tag_value.empty?
-            tag_name # use `tag_name` as `tag_value` for the tags without any values
+      def display_tag(tagname, tagvalue)
+        if tagvalue
+          if tagvalue.empty?
+            tagname # use `tagname` as `tagvalue` for the tags without any values
           else
-            tag_value
+            tagvalue
           end
         else
           nil
@@ -398,15 +398,15 @@ module Hotdog
       end
 
       def split_tag(tag)
-        tag_name, tag_value = tag.split(":", 2)
-        [tag_name, tag_value || ""]
+        tagname, tagvalue = tag.split(":", 2)
+        [tagname, tagvalue || ""]
       end
 
-      def join_tag(tag_name, tag_value)
-        if tag_value.to_s.empty?
-          tag_name
+      def join_tag(tagname, tagvalue)
+        if tagvalue.to_s.empty?
+          tagname
         else
-          "#{tag_name}:#{tag_value}"
+          "#{tagname}:#{tagvalue}"
         end
       end
 

data/lib/hotdog/commands/search.rb

@@ -66,16 +66,16 @@ module Hotdog
           case
           when n[:left] && n[:right] then drilldown.(n[:left]) + drilldown.(n[:right])
           when n[:expression] then drilldown.(n[:expression])
-          when n[:tag_name] then [n[:tag_name]]
+          when n[:tagname] then [n[:tagname]]
           else []
           end
         }
         if options[:display_search_tags]
-          tag_names = drilldown.call(node).map(&:to_s)
+          tagnames = drilldown.call(node).map(&:to_s)
           if options[:primary_tag]
-            tags = [options[:primary_tag]] + tag_names
+            tags = [options[:primary_tag]] + tagnames
           else
-            tags = tag_names
+            tags = tagnames
           end
         else
           tags = nil

data/lib/hotdog/commands/tags.rb

@@ -9,16 +9,16 @@ module Hotdog
           show_tags(result)
         else
           tags = args.map { |tag| split_tag(tag) }
-          if tags.all? { |_tag_name, tag_value| tag_value.empty? }
+          if tags.all? { |_tagname, tagvalue| tagvalue.empty? }
             result = tags.each_slice(SQLITE_LIMIT_COMPOUND_SELECT).flat_map { |tags|
               q = "SELECT value FROM tags " \
-                    "WHERE %s;" % tags.map { |tag_name, _tag_value| glob?(tag_name) ? "LOWER(name) GLOB LOWER(?)" : "name = ?" }.join(" OR ")
-              execute(q, tags.map { |tag_name, _tag_value| tag_name }).map { |value| [value] }
+                    "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|
               q = "SELECT value FROM tags " \
-                    "WHERE %s;" % tags.map { |tag_name, tag_value| (glob?(tag_name) or glob?(tag_value)) ? "( LOWER(name) GLOB LOWER(?) AND LOWER(value) GLOB LOWER(?) )" : "( name = ? AND value = ? )" }.join(" OR ")
+                    "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] }
             }
           end

data/lib/hotdog/expression.rb

@@ -63,100 +63,100 @@ module Hotdog
       rule(unary_op: simple(:unary_op), expression: simple(:expression)) {
         UnaryExpressionNode.new(unary_op, expression)
       }
-      rule(tag_name_regexp: simple(:tag_name_regexp), separator: simple(:separator), tag_value_regexp: simple(:tag_value_regexp)) {
-        if "/host/" == tag_name_regexp
-          RegexpHostNode.new(tag_value_regexp, separator)
+      rule(tagname_regexp: simple(:tagname_regexp), separator: simple(:separator), tagvalue_regexp: simple(:tagvalue_regexp)) {
+        if "/host/" == tagname_regexp
+          RegexpHostNode.new(tagvalue_regexp, separator)
         else
-          RegexpTagNode.new(tag_name_regexp, tag_value_regexp, separator)
+          RegexpTagNode.new(tagname_regexp, tagvalue_regexp, separator)
         end
       }
-      rule(tag_name_regexp: simple(:tag_name_regexp), separator: simple(:separator)) {
-        if "/host/" == tag_name_regexp
+      rule(tagname_regexp: simple(:tagname_regexp), separator: simple(:separator)) {
+        if "/host/" == tagname_regexp
           EverythingNode.new()
         else
-          RegexpTagNameNode.new(tag_name_regexp, separator)
+          RegexpTagnameNode.new(tagname_regexp, separator)
         end
       }
-      rule(tag_name_regexp: simple(:tag_name_regexp)) {
-        if "/host/" == tag_name_regexp
+      rule(tagname_regexp: simple(:tagname_regexp)) {
+        if "/host/" == tagname_regexp
           EverythingNode.new()
         else
-          RegexpHostOrTagNode.new(tag_name_regexp)
+          RegexpHostOrTagNode.new(tagname_regexp)
         end
       }
-      rule(tag_name_glob: simple(:tag_name_glob), separator: simple(:separator), tag_value_glob: simple(:tag_value_glob)) {
-        if "host" == tag_name_glob
-          GlobHostNode.new(tag_value_glob, separator)
+      rule(tagname_glob: simple(:tagname_glob), separator: simple(:separator), tagvalue_glob: simple(:tagvalue_glob)) {
+        if "host" == tagname_glob
+          GlobHostNode.new(tagvalue_glob, separator)
         else
-          GlobTagNode.new(tag_name_glob, tag_value_glob, separator)
+          GlobTagNode.new(tagname_glob, tagvalue_glob, separator)
         end
       }
-      rule(tag_name_glob: simple(:tag_name_glob), separator: simple(:separator), tag_value: simple(:tag_value)) {
-        if "host" == tag_name_glob
-          GlobHostNode.new(tag_value, separator)
+      rule(tagname_glob: simple(:tagname_glob), separator: simple(:separator), tagvalue: simple(:tagvalue)) {
+        if "host" == tagname_glob
+          GlobHostNode.new(tagvalue, separator)
         else
-          GlobTagNode.new(tag_name_glob, tag_value, separator)
+          GlobTagNode.new(tagname_glob, tagvalue, separator)
         end
       }
-      rule(tag_name_glob: simple(:tag_name_glob), separator: simple(:separator)) {
-        if "host" == tag_name_glob
+      rule(tagname_glob: simple(:tagname_glob), separator: simple(:separator)) {
+        if "host" == tagname_glob
           EverythingNode.new()
         else
-          GlobTagNameNode.new(tag_name_glob, separator)
+          GlobTagnameNode.new(tagname_glob, separator)
         end
       }
-      rule(tag_name_glob: simple(:tag_name_glob)) {
-        if "host" == tag_name_glob
+      rule(tagname_glob: simple(:tagname_glob)) {
+        if "host" == tagname_glob
           EverythingNode.new()
         else
-          GlobHostOrTagNode.new(tag_name_glob)
+          GlobHostOrTagNode.new(tagname_glob)
         end
       }
-      rule(tag_name: simple(:tag_name), separator: simple(:separator), tag_value_glob: simple(:tag_value_glob)) {
-        if "host" == tag_name
-          GlobHostNode.new(tag_value_glob, separator)
+      rule(tagname: simple(:tagname), separator: simple(:separator), tagvalue_glob: simple(:tagvalue_glob)) {
+        if "host" == tagname
+          GlobHostNode.new(tagvalue_glob, separator)
         else
-          GlobTagNode.new(tag_name, tag_value_glob, separator)
+          GlobTagNode.new(tagname, tagvalue_glob, separator)
         end
       }
-      rule(tag_name: simple(:tag_name), separator: simple(:separator), tag_value: simple(:tag_value)) {
-        if "host" == tag_name
-          StringHostNode.new(tag_value, separator)
+      rule(tagname: simple(:tagname), separator: simple(:separator), tagvalue: simple(:tagvalue)) {
+        if "host" == tagname
+          StringHostNode.new(tagvalue, separator)
         else
-          StringTagNode.new(tag_name, tag_value, separator)
+          StringTagNode.new(tagname, tagvalue, separator)
         end
       }
-      rule(tag_name: simple(:tag_name), separator: simple(:separator)) {
-        if "host" == tag_name
+      rule(tagname: simple(:tagname), separator: simple(:separator)) {
+        if "host" == tagname
           EverythingNode.new()
         else
-          StringTagNameNode.new(tag_name, separator)
+          StringTagnameNode.new(tagname, separator)
         end
       }
-      rule(tag_name: simple(:tag_name)) {
-        if "host" == tag_name
+      rule(tagname: simple(:tagname)) {
+        if "host" == tagname
           EverythingNode.new()
         else
-          StringHostOrTagNode.new(tag_name)
+          StringHostOrTagNode.new(tagname)
         end
       }
-      rule(separator: simple(:separator), tag_value_regexp: simple(:tag_value_regexp)) {
-        RegexpTagValueNode.new(tag_value_regexp, separator)
+      rule(separator: simple(:separator), tagvalue_regexp: simple(:tagvalue_regexp)) {
+        RegexpTagvalueNode.new(tagvalue_regexp, separator)
       }
-      rule(tag_value_regexp: simple(:tag_value_regexp)) {
-        RegexpTagValueNode.new(tag_value_regexp)
+      rule(tagvalue_regexp: simple(:tagvalue_regexp)) {
+        RegexpTagvalueNode.new(tagvalue_regexp)
       }
-      rule(separator: simple(:separator), tag_value_glob: simple(:tag_value_glob)) {
-        GlobTagValueNode.new(tag_value_glob, separator)
+      rule(separator: simple(:separator), tagvalue_glob: simple(:tagvalue_glob)) {
+        GlobTagvalueNode.new(tagvalue_glob, separator)
       }
-      rule(tag_value_glob: simple(:tag_value_glob)) {
-        GlobTagValueNode.new(tag_value_glob)
+      rule(tagvalue_glob: simple(:tagvalue_glob)) {
+        GlobTagvalueNode.new(tagvalue_glob)
       }
-      rule(separator: simple(:separator), tag_value: simple(:tag_value)) {
-        StringTagValueNode.new(tag_value, separator)
+      rule(separator: simple(:separator), tagvalue: simple(:tagvalue)) {
+        StringTagvalueNode.new(tagvalue, separator)
       }
-      rule(tag_value: simple(:tag_value)) {
-        StringTagValueNode.new(tag_value)
+      rule(tagvalue: simple(:tagvalue)) {
+        StringTagvalueNode.new(tagvalue)
       }
     end
   end

data/lib/hotdog/expression/semantics.rb

@@ -14,6 +14,10 @@ module Hotdog
       def dump(options={})
         {}
       end
+
+      def ==(other)
+        self.dump == other.dump
+      end
     end
 
     class UnaryExpressionNode < ExpressionNode
@@ -272,7 +276,7 @@ module Hotdog
           end
         when :XOR
           if left == right
-            []
+            NothingNode.new(options)
           else
             optimize1(options)
           end
@@ -355,7 +359,7 @@ module Hotdog
               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|
-                  q = query_without_condition.sub(/\s*;\s*\z/, "") + " WHERE " + expressions.map { |expression| "( %s )" % expression.condition(options) }.join(" OR ") + ";"
+                  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 }
                 }
               else
@@ -461,7 +465,7 @@ module Hotdog
           @args[0] = @args[0].optimize(options)
           if TagExpressionNode === args[1]
             # workaround for expressions like `ORDER_BY((environment:development),role)`
-            @args[1] = @args[1].tag_name
+            @args[1] = @args[1].tagname
           else
             @args[1] = @args[1]
           end
@@ -470,7 +474,7 @@ module Hotdog
           if @args[1]
             if TagExpressionNode === @args[1]
               # workaround for expressions like `ORDER_BY((environment:development),role)`
-              @args[1] = @args[1].tag_name
+              @args[1] = @args[1].tagname
             else
               @args[1] = @args[1]
             end
@@ -535,7 +539,7 @@ module Hotdog
 
     class NothingNode < QueryExpressionNode
       def initialize(options={})
-        super("SELECT NULL AS host_id WHERE host_id NOT NULL", [], options)
+        super("SELECT NULL AS host_id WHERE host_id NOT NULL;", [], options)
       end
 
       def evaluate(environment, options={})
@@ -548,22 +552,22 @@ module Hotdog
     end
 
     class TagExpressionNode < ExpressionNode
-      def initialize(tag_name, tag_value, separator=nil)
-        @tag_name = tag_name
-        @tag_value = tag_value
+      def initialize(tagname, tagvalue, separator=nil)
+        @tagname = tagname
+        @tagvalue = tagvalue
         @separator = separator
         @fallback = nil
       end
-      attr_reader :tag_name
-      attr_reader :tag_value
+      attr_reader :tagname
+      attr_reader :tagvalue
       attr_reader :separator
 
-      def tag_name?
-        !(tag_name.nil? or tag_name.to_s.empty?)
+      def tagname?
+        !(tagname.nil? or tagname.to_s.empty?)
       end
 
-      def tag_value?
-        !(tag_value.nil? or tag_value.to_s.empty?)
+      def tagvalue?
+        !(tagvalue.nil? or tagvalue.to_s.empty?)
       end
 
       def separator?
@@ -573,7 +577,7 @@ module Hotdog
       def maybe_query(options={})
         query_without_condition = maybe_query_without_condition(options)
         if query_without_condition
-          query_without_condition.sub(/\s*;\s*\z/, "") + " WHERE " + condition(options) + ";"
+          query_without_condition.sub(/\s*;\s*\z/, " WHERE #{condition(options)};")
         else
           nil
         end
@@ -654,7 +658,7 @@ module Hotdog
       end
 
       def ==(other)
-        self.class == other.class and @tag_name == other.tag_name and @tag_value == other.tag_value
+        self.class == other.class and @tagname == other.tagname and @tagvalue == other.tagvalue
       end
 
       def optimize(options={})
@@ -685,9 +689,9 @@ module Hotdog
 
       def dump(options={})
         data = {}
-        data[:tag_name] = tag_name.to_s if tag_name
+        data[:tagname] = tagname.to_s if tagname
         data[:separator] = separator.to_s if separator
-        data[:tag_value] = tag_value.to_s if tag_value
+        data[:tagvalue] = tagvalue.to_s if tagvalue
         data[:fallback ] = @fallback.dump(options) if @fallback
         data
       end
@@ -719,8 +723,8 @@ module Hotdog
     end
 
     class StringHostNode < StringExpressionNode
-      def initialize(tag_value, separator=nil)
-        super("host", tag_value.to_s, separator)
+      def initialize(tagvalue, separator=nil)
+        super("host", tagvalue.to_s, separator)
       end
 
       def condition(options={})
@@ -732,11 +736,11 @@ module Hotdog
       end
 
       def condition_values(options={})
-        [tag_value]
+        [tagvalue]
       end
 
       def maybe_fallback(options={})
-        fallback = GlobHostNode.new(to_glob(tag_value), separator)
+        fallback = GlobHostNode.new(to_glob(tagvalue), separator)
         query = fallback.maybe_query(options)
         if query
           QueryExpressionNode.new(query, fallback.condition_values(options))
@@ -747,8 +751,8 @@ module Hotdog
     end
 
     class StringTagNode < StringExpressionNode
-      def initialize(tag_name, tag_value, separator=nil)
-        super(tag_name.to_s, tag_value.to_s, separator)
+      def initialize(tagname, tagvalue, separator=nil)
+        super(tagname.to_s, tagvalue.to_s, separator)
       end
 
       def condition(options={})
@@ -760,11 +764,11 @@ module Hotdog
       end
 
       def condition_values(options={})
-        [tag_name, tag_value]
+        [tagname, tagvalue]
       end
 
       def maybe_fallback(options={})
-        fallback = GlobTagNode.new(to_glob(tag_name), to_glob(tag_value), separator)
+        fallback = GlobTagNode.new(to_glob(tagname), to_glob(tagvalue), separator)
         query = fallback.maybe_query(options)
         if query
           QueryExpressionNode.new(query, fallback.condition_values(options))
@@ -774,9 +778,9 @@ module Hotdog
       end
     end
 
-    class StringTagNameNode < StringExpressionNode
-      def initialize(tag_name, separator=nil)
-        super(tag_name.to_s, nil, separator)
+    class StringTagnameNode < StringExpressionNode
+      def initialize(tagname, separator=nil)
+        super(tagname.to_s, nil, separator)
       end
 
       def condition(options={})
@@ -788,11 +792,11 @@ module Hotdog
       end
 
       def condition_values(options={})
-        [tag_name]
+        [tagname]
       end
 
       def maybe_fallback(options={})
-        fallback = GlobTagNameNode.new(to_glob(tag_name), separator)
+        fallback = GlobTagnameNode.new(to_glob(tagname), separator)
         query = fallback.maybe_query(options)
         if query
           QueryExpressionNode.new(query, fallback.condition_values(options))
@@ -802,9 +806,9 @@ module Hotdog
       end
     end
 
-    class StringTagValueNode < StringExpressionNode
-      def initialize(tag_value, separator=nil)
-        super(nil, tag_value.to_s, separator)
+    class StringTagvalueNode < StringExpressionNode
+      def initialize(tagvalue, separator=nil)
+        super(nil, tagvalue.to_s, separator)
       end
 
       def condition(options={})
@@ -816,11 +820,11 @@ module Hotdog
       end
 
       def condition_values(options={})
-        [tag_value, tag_value]
+        [tagvalue, tagvalue]
       end
 
       def maybe_fallback(options={})
-        fallback = GlobTagValueNode.new(to_glob(tag_value), separator)
+        fallback = GlobTagvalueNode.new(to_glob(tagvalue), separator)
         query = fallback.maybe_query(options)
         if query
           QueryExpressionNode.new(query, fallback.condition_values(options))
@@ -831,8 +835,8 @@ module Hotdog
     end
 
     class StringHostOrTagNode < StringExpressionNode
-      def initialize(tag_name, separator=nil)
-        super(tag_name.to_s, nil, separator)
+      def initialize(tagname, separator=nil)
+        super(tagname.to_s, nil, separator)
       end
 
       def condition(options={})
@@ -844,11 +848,11 @@ module Hotdog
       end
 
       def condition_values(options={})
-        [tag_name, tag_name, tag_name]
+        [tagname, tagname, tagname]
       end
 
       def maybe_fallback(options={})
-        fallback = GlobHostOrTagNode.new(to_glob(tag_name), separator)
+        fallback = GlobHostOrTagNode.new(to_glob(tagname), separator)
         query = fallback.maybe_query(options)
         if query
           QueryExpressionNode.new(query, fallback.condition_values(options))
@@ -861,17 +865,17 @@ module Hotdog
     class GlobExpressionNode < TagExpressionNode
       def dump(options={})
         data = {}
-        data[:tag_name_glob] = tag_name.to_s if tag_name
+        data[:tagname_glob] = tagname.to_s if tagname
         data[:separator] = separator.to_s if separator
-        data[:tag_value_glob] = tag_value.to_s if tag_value
+        data[:tagvalue_glob] = tagvalue.to_s if tagvalue
         data[:fallback] = @fallback.dump(options) if @fallback
         data
       end
     end
 
     class GlobHostNode < GlobExpressionNode
-      def initialize(tag_value, separator=nil)
-        super("host", tag_value.to_s, separator)
+      def initialize(tagvalue, separator=nil)
+        super("host", tagvalue.to_s, separator)
       end
 
       def condition(options={})
@@ -883,11 +887,11 @@ module Hotdog
       end
 
       def condition_values(options={})
-        [tag_value]
+        [tagvalue]
       end
 
       def maybe_fallback(options={})
-        fallback = GlobHostNode.new(to_glob(tag_value), separator)
+        fallback = GlobHostNode.new(to_glob(tagvalue), separator)
         query = fallback.maybe_query(options)
         if query
           QueryExpressionNode.new(query, fallback.condition_values(options))
@@ -898,8 +902,8 @@ module Hotdog
     end
 
     class GlobTagNode < GlobExpressionNode
-      def initialize(tag_name, tag_value, separator=nil)
-        super(tag_name.to_s, tag_value.to_s, separator)
+      def initialize(tagname, tagvalue, separator=nil)
+        super(tagname.to_s, tagvalue.to_s, separator)
       end
 
       def condition(options={})
@@ -911,11 +915,11 @@ module Hotdog
       end
 
       def condition_values(options={})
-        [tag_name, tag_value]
+        [tagname, tagvalue]
       end
 
       def maybe_fallback(options={})
-        fallback = GlobTagNode.new(to_glob(tag_name), to_glob(tag_value), separator)
+        fallback = GlobTagNode.new(to_glob(tagname), to_glob(tagvalue), separator)
         query = fallback.maybe_query(options)
         if query
           QueryExpressionNode.new(query, fallback.condition_values(options))
@@ -925,9 +929,9 @@ module Hotdog
       end
     end
 
-    class GlobTagNameNode < GlobExpressionNode
-      def initialize(tag_name, separator=nil)
-        super(tag_name.to_s, nil, separator)
+    class GlobTagnameNode < GlobExpressionNode
+      def initialize(tagname, separator=nil)
+        super(tagname.to_s, nil, separator)
       end
 
       def condition(options={})
@@ -939,11 +943,11 @@ module Hotdog
       end
 
       def condition_values(options={})
-        [tag_name]
+        [tagname]
       end
 
       def maybe_fallback(options={})
-        fallback = GlobTagNameNode.new(to_glob(tag_name), separator)
+        fallback = GlobTagnameNode.new(to_glob(tagname), separator)
         query = fallback.maybe_query(options)
         if query
           QueryExpressionNode.new(query, fallback.condition_values(options))
@@ -953,9 +957,9 @@ module Hotdog
       end
     end
 
-    class GlobTagValueNode < GlobExpressionNode
-      def initialize(tag_value, separator=nil)
-        super(nil, tag_value.to_s, separator)
+    class GlobTagvalueNode < GlobExpressionNode
+      def initialize(tagvalue, separator=nil)
+        super(nil, tagvalue.to_s, separator)
       end
 
       def condition(options={})
@@ -967,11 +971,11 @@ module Hotdog
       end
 
       def condition_values(options={})
-        [tag_value, tag_value]
+        [tagvalue, tagvalue]
       end
 
       def maybe_fallback(options={})
-        fallback = GlobTagValueNode.new(to_glob(tag_value), separator)
+        fallback = GlobTagvalueNode.new(to_glob(tagvalue), separator)
         query = fallback.maybe_query(options)
         if query
           QueryExpressionNode.new(query, fallback.condition_values(options))
@@ -982,8 +986,8 @@ module Hotdog
     end
 
     class GlobHostOrTagNode < GlobExpressionNode
-      def initialize(tag_name, separator=nil)
-        super(tag_name.to_s, nil, separator)
+      def initialize(tagname, separator=nil)
+        super(tagname.to_s, nil, separator)
       end
 
       def condition(options={})
@@ -995,11 +999,11 @@ module Hotdog
       end
 
       def condition_values(options={})
-        [tag_name, tag_name, tag_name]
+        [tagname, tagname, tagname]
       end
 
       def maybe_fallback(options={})
-        fallback = GlobHostOrTagNode.new(to_glob(tag_name), separator)
+        fallback = GlobHostOrTagNode.new(to_glob(tagname), separator)
         query = fallback.maybe_query(options)
         if query
           QueryExpressionNode.new(query, fallback.condition_values(options))
@@ -1012,21 +1016,21 @@ module Hotdog
     class RegexpExpressionNode < TagExpressionNode
       def dump(options={})
         data = {}
-        data[:tag_name_regexp] = tag_name.to_s if tag_name
+        data[:tagname_regexp] = tagname.to_s if tagname
         data[:separator] = separator.to_s if separator
-        data[:tag_value_regexp] = tag_value.to_s if tag_value
+        data[:tagvalue_regexp] = tagvalue.to_s if tagvalue
         data[:fallback] = @fallback.dump(options) if @fallback
         data
       end
     end
 
     class RegexpHostNode < RegexpExpressionNode
-      def initialize(tag_value, separator=nil)
-        case tag_value
+      def initialize(tagvalue, separator=nil)
+        case tagvalue
         when /\A\/(.*)\/\z/
-          tag_value = $1
+          tagvalue = $1
         end
-        super("host", tag_value, separator)
+        super("host", tagvalue, separator)
       end
 
       def condition(options={})
@@ -1038,21 +1042,21 @@ module Hotdog
       end
 
       def condition_values(options={})
-        [tag_value]
+        [tagvalue]
       end
     end
 
     class RegexpTagNode < RegexpExpressionNode
-      def initialize(tag_name, tag_value, separator=nil)
-        case tag_name
+      def initialize(tagname, tagvalue, separator=nil)
+        case tagname
         when /\A\/(.*)\/\z/
-          tag_name = $1
+          tagname = $1
         end
-        case tag_value
+        case tagvalue
         when /\A\/(.*)\/\z/
-          tag_value = $1
+          tagvalue = $1
         end
-        super(tag_name, tag_value, separator)
+        super(tagname, tagvalue, separator)
       end
 
       def condition(options={})
@@ -1064,17 +1068,17 @@ module Hotdog
       end
 
       def condition_values(options={})
-        [tag_name, tag_value]
+        [tagname, tagvalue]
       end
     end
 
-    class RegexpTagNameNode < RegexpExpressionNode
-      def initialize(tag_name, separator=nil)
-        case tag_name
+    class RegexpTagnameNode < RegexpExpressionNode
+      def initialize(tagname, separator=nil)
+        case tagname
         when /\A\/(.*)\/\z/
-          tag_name = $1
+          tagname = $1
         end
-        super(tag_name.to_s, nil, separator)
+        super(tagname.to_s, nil, separator)
       end
 
       def condition(options={})
@@ -1086,17 +1090,17 @@ module Hotdog
       end
 
       def condition_values(options={})
-        [tag_name]
+        [tagname]
       end
     end
 
-    class RegexpTagValueNode < RegexpExpressionNode
-      def initialize(tag_value, separator=nil)
-        case tag_value
+    class RegexpTagvalueNode < RegexpExpressionNode
+      def initialize(tagvalue, separator=nil)
+        case tagvalue
         when /\A\/(.*)\/\z/
-          tag_value = $1
+          tagvalue = $1
         end
-        super(nil, tag_value.to_s, separator)
+        super(nil, tagvalue.to_s, separator)
       end
 
       def condition(options={})
@@ -1108,13 +1112,13 @@ module Hotdog
       end
 
       def condition_values(options={})
-        [tag_value, tag_value]
+        [tagvalue, tagvalue]
       end
     end
 
     class RegexpHostOrTagNode < RegexpExpressionNode
-      def initialize(tag_name, separator=nil)
-        super(tag_name, separator)
+      def initialize(tagname, separator=nil)
+        super(tagname, separator)
       end
 
       def condition(options={})
@@ -1126,7 +1130,7 @@ module Hotdog
       end
 
       def condition_values(options={})
-        [tag_name, tag_name, tag_name]
+        [tagname, tagname, tagname]
       end
     end
   end