hotdog 0.26.0 → 0.27.0

data/lib/hotdog/expression/semantics.rb

@@ -8,6 +8,10 @@ module Hotdog
       end
 
       def optimize(options={})
+        self.dup
+      end
+
+      def compact(options={})
         self
       end
 
@@ -23,7 +27,7 @@ module Hotdog
     class UnaryExpressionNode < ExpressionNode
       attr_reader :op, :expression
 
-      def initialize(op, expression)
+      def initialize(op, expression, options={})
         case (op || "not").to_s
         when "NOOP", "noop"
           @op = :NOOP
@@ -33,6 +37,7 @@ module Hotdog
           raise(SyntaxError.new("unknown unary operator: #{op.inspect}"))
         end
         @expression = expression
+        @options = {}
       end
 
       def evaluate(environment, options={})
@@ -67,21 +72,35 @@ module Hotdog
       end
 
       def optimize(options={})
-        case op
-        when :NOOP
-          optimize1(options)
-        when :NOT
-          case expression
-          when EverythingNode
-            NothingNode.new(options)
-          when NothingNode
-            EverythingNode.new(options)
+        o_self = compact(options)
+        if UnaryExpressionNode === o_self
+          case o_self.op
+          when :NOT
+            case o_self.expression
+            when EverythingNode
+              NothingNode.new(options)
+            when NothingNode
+              EverythingNode.new(options)
+            else
+              o_self.optimize1(options)
+            end
           else
-            optimize1(options)
+            o_self.optimize1(options)
           end
         else
-          @expression = expression.optimize(options)
-          self
+          o_self.optimize(options)
+        end
+      end
+
+      def compact(options={})
+        case op
+        when :NOOP
+          expression.compact(options)
+        else
+          UnaryExpressionNode.new(
+            op,
+            expression.compact(options),
+          )
         end
       end
 
@@ -93,7 +112,7 @@ module Hotdog
         {unary_op: @op.to_s, expression: @expression.dump(options)}
       end
 
-      private
+      protected
       def optimize1(options={})
         case op
         when :NOOP
@@ -102,18 +121,17 @@ module Hotdog
           if UnaryExpressionNode === expression
             case expression.op
             when :NOOP
-              @expression = expression.optimize(options)
-              optimize2(options)
+              expression.optimize(options)
             when :NOT
               expression.expression.optimize(options)
             else
-              self
+              self.dup
             end
           else
             optimize2(options)
           end
         else
-          self
+          self.dup
         end
       end
 
@@ -126,7 +144,7 @@ module Hotdog
           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
+            self.dup
           end
         when TagExpressionNode
           q = expression.maybe_query(options)
@@ -134,10 +152,10 @@ module Hotdog
           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
+            self.dup
           end
         else
-          self
+          self.dup
         end
       end
     end
@@ -145,7 +163,7 @@ module Hotdog
     class BinaryExpressionNode < ExpressionNode
       attr_reader :op, :left, :right
 
-      def initialize(op, left, right)
+      def initialize(op, left, right, options={})
         case (op || "or").to_s
         when "&&", "&", "AND", "and"
           @op = :AND
@@ -158,6 +176,7 @@ module Hotdog
         end
         @left = left
         @right = right
+        @options = {}
       end
 
       def evaluate(environment, options={})
@@ -254,59 +273,75 @@ module Hotdog
       end
 
       def optimize(options={})
-        @left = @left.optimize(options)
-        @right = @right.optimize(options)
+        o_left = @left.optimize(options)
+        o_right = @right.optimize(options)
         case op
         when :AND
-          case left
+          case o_left
           when EverythingNode
-            right
+            o_right
           when NothingNode
-            left
+            o_left
           else
-            if left == right
-              left
+            if o_left == o_right
+              o_left
             else
-              optimize1(options)
+              BinaryExpressionNode.new(
+                op,
+                o_left,
+                o_right,
+              ).optimize1(options)
             end
           end
         when :OR
-          case left
+          case o_left
           when EverythingNode
-            left
+            o_left
           when NothingNode
-            right
+            o_right
           else
-            if left == right
-              left
+            if o_left == o_right
+              o_left
             else
-              if MultinaryExpressionNode === left
-                if left.op == op
-                  left.merge(right, fallback: self)
+              if MultinaryExpressionNode === o_left
+                if o_left.op == op
+                  o_left.merge(o_right, fallback: self)
                 else
-                  optimize1(options)
+                  BinaryExpressionNode.new(
+                    op,
+                    o_left,
+                    o_right,
+                  ).optimize1(options)
                 end
               else
-                if MultinaryExpressionNode === right
-                  if right.op == op
-                    right.merge(left, fallback: self)
+                if MultinaryExpressionNode === o_right
+                  if o_right.op == op
+                    o_right.merge(o_left, fallback: self)
                   else
-                    optimize1(options)
+                    BinaryExpressionNode.new(
+                      op,
+                      o_left,
+                      o_right,
+                    ).optimize1(options)
                   end
                 else
-                  MultinaryExpressionNode.new(op, [left, right], fallback: self)
+                  MultinaryExpressionNode.new(op, [o_left, o_right], fallback: self)
                 end
               end
             end
           end
         when :XOR
-          if left == right
+          if o_left == o_right
             NothingNode.new(options)
           else
-            optimize1(options)
+            BinaryExpressionNode.new(
+              op,
+              o_left,
+              o_right,
+            ).optimize1(options)
           end
         else
-          self
+          self.dup
         end
       end
 
@@ -318,7 +353,7 @@ module Hotdog
         {left: @left.dump(options), binary_op: @op.to_s, right: @right.dump(options)}
       end
 
-      private
+      protected
       def optimize1(options)
         if TagExpressionNode === left and TagExpressionNode === right
           lq = left.maybe_query(options)
@@ -340,13 +375,13 @@ module Hotdog
                       "INTERSECT #{rq.sub(/\s*;\s*\z/, "")};"
               QueryExpressionNode.new(q, lv + rv, fallback: self)
             else
-              self
+              self.dup
             end
           else
-            self
+            self.dup
           end
         else
-          self
+          self.dup
         end
       end
     end
@@ -366,7 +401,7 @@ module Hotdog
           raise(ArgumentError.new("expressions limit exceeded: #{expressions.length} for #{sqlite_limit_compound_select}"))
         end
         @expressions = expressions
-        @fallback = options[:fallback]
+        @options = options
       end
 
       def merge(other, options={})
@@ -401,8 +436,8 @@ module Hotdog
           values = []
         end
         if values.empty?
-          if @fallback
-            @fallback.evaluate(environment, options={})
+          if @options[:fallback]
+            @options[:fallback].evaluate(environment, options={})
           else
             []
           end
@@ -420,15 +455,15 @@ module Hotdog
       def initialize(query, values=[], options={})
         @query = query
         @values = values
-        @fallback = options[:fallback]
+        @options = options
       end
       attr_reader :query
       attr_reader :values
 
       def evaluate(environment, options={})
         values = environment.execute(@query, @values).map { |row| row.first }
-        if values.empty? and @fallback
-          @fallback.evaluate(environment, options)
+        if values.empty? and @options[:fallback]
+          @options[:fallback].evaluate(environment, options)
         else
           values
         end
@@ -436,7 +471,7 @@ module Hotdog
 
       def dump(options={})
         data = {query: @query, values: @values}
-        data[:fallback] = @fallback.dump(options) if @fallback
+        data[:fallback] = @options[:fallback].dump(options) if @options[:fallback]
         data
       end
     end
@@ -444,7 +479,7 @@ module Hotdog
     class FuncallNode < ExpressionNode
       attr_reader :function, :args
 
-      def initialize(function, args)
+      def initialize(function, args, options={})
         # FIXME: smart argument handling (e.g. arity & type checking)
         case function.to_s
         when "HEAD", "head"
@@ -472,6 +507,7 @@ module Hotdog
           raise(SyntaxError.new("unknown function call: #{function}"))
         end
         @args = args
+        @options = options
       end
 
       def dump(options={})
@@ -487,36 +523,37 @@ module Hotdog
 
       def optimize(options={})
         case function
-        when :HEAD
-          @args[0] = @args[0].optimize(options)
         when :GROUP_BY
-          @args[0] = @args[0].optimize(options)
+          o_args = [@args[0].optimize(options)]
           if TagExpressionNode === args[1]
             # workaround for expressions like `ORDER_BY((environment:development),role)`
-            @args[1] = @args[1].tagname
+            o_args << @args[1].tagname
           else
-            @args[1] = @args[1]
+            o_args << @args[1]
           end
         when :ORDER_BY
-          @args[0] = @args[0].optimize(options)
+          o_args = [@args[0].optimize(options)]
           if @args[1]
             if TagExpressionNode === @args[1]
               # workaround for expressions like `ORDER_BY((environment:development),role)`
-              @args[1] = @args[1].tagname
+              o_args << @args[1].tagname
             else
-              @args[1] = @args[1]
+              o_args << @args[1]
             end
           end
-        when :REVERSE
-          @args[0] = @args[0].optimize(options)
-        when :SHUFFLE
-          @args[0] = @args[0].optimize(options)
-        when :SLICE
-          @args[0] = @args[0].optimize(options)
-        when :TAIL
-          @args[0] = @args[0].optimize(options)
+        else
+          o_args = @args.map { |arg|
+            if ExpressionNode === arg
+              arg.optimize(options)
+            else
+              arg
+            end
+          }
         end
-        self
+        FuncallNode.new(
+          @function,
+          o_args,
+        )
       end
 
       def evaluate(environment, options={})
@@ -529,7 +566,7 @@ module Hotdog
                 "INNER JOIN tags ON hosts_tags.tag_id = tags.id " \
                 "WHERE tags.name = ? AND hosts_tags.host_id IN (%s) " \
                 "GROUP BY tags.value;" % intermediate.map { "?" }.join(", ")
-          QueryExpressionNode.new(q, [args[1]] + intermediate, fallback: nil).evaluate(environment, options)
+          QueryExpressionNode.new(q, [args[1]] + intermediate).evaluate(environment, options)
         when :ORDER_BY
           intermediate = args[0].evaluate(environment, options)
           if args[1]
@@ -537,13 +574,13 @@ module Hotdog
                   "INNER JOIN tags ON hosts_tags.tag_id = tags.id " \
                   "WHERE tags.name = ? AND hosts_tags.host_id IN (%s) " \
                   "ORDER BY tags.value;" % intermediate.map { "?" }.join(", ")
-            QueryExpressionNode.new(q, [args[1]] + intermediate, fallback: nil).evaluate(environment, options)
+            QueryExpressionNode.new(q, [args[1]] + intermediate).evaluate(environment, options)
           else
             q = "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags " \
                   "INNER JOIN tags ON hosts_tags.tag_id = tags.id " \
                   "WHERE hosts_tags.host_id IN (%s) " \
                   "ORDER BY hosts_tags.host_id;" % intermediate.map { "?" }.join(", ")
-            QueryExpressionNode.new(q, intermediate, fallback: nil).evaluate(environment, options)
+            QueryExpressionNode.new(q, intermediate).evaluate(environment, options)
           end
         when :REVERSE
           args[0].evaluate(environment, options).reverse()
@@ -569,22 +606,14 @@ module Hotdog
       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(tagname, tagvalue, separator=nil)
+      def initialize(tagname, tagvalue, separator=nil, options={})
         @tagname = tagname
         @tagvalue = tagvalue
         @separator = separator
-        @fallback = nil
+        @options = options
       end
       attr_reader :tagname
       attr_reader :tagvalue
@@ -649,32 +678,11 @@ module Hotdog
             if options[:did_fallback]
               []
             else
-              if not environment.fixed_string? and @fallback
-                # avoid optimizing @fallback to prevent infinite recursion
-                values = @fallback.evaluate(environment, options.merge(did_fallback: true))
-                if values.empty?
-                  if reload(environment, options)
-                    evaluate(environment, options).tap do |values|
-                      if values.empty?
-                        environment.logger.info("no result: #{self.dump.inspect}")
-                      end
-                    end
-                  else
-                    []
-                  end
-                else
-                  values
-                end
+              if not environment.fixed_string? and @options[:fallback]
+                # avoid optimizing @options[:fallback] to prevent infinite recursion
+                @options[:fallback].evaluate(environment, options.merge(did_fallback: true))
               else
-                if reload(environment, options)
-                  evaluate(environment, options).tap do |values|
-                    if values.empty?
-                      environment.logger.info("no result: #{self.dump.inspect}")
-                    end
-                  end
-                else
-                  []
-                end
+                []
               end
             end
           else
@@ -691,8 +699,11 @@ module Hotdog
 
       def optimize(options={})
         # fallback to glob expression
-        @fallback = maybe_fallback(options)
-        self
+        self.dup.tap do |o_self|
+          o_self.instance_eval {
+            @options[:fallback] ||= maybe_fallback(options)
+          }
+        end
       end
 
       def to_glob(s)
@@ -703,24 +714,12 @@ module Hotdog
         s ? to_glob(s.to_s) : nil
       end
 
-      def reload(environment, options={})
-        $did_reload ||= false
-        if $did_reload
-          false
-        else
-          $did_reload = true
-          environment.logger.info("force reloading all hosts and tags.")
-          environment.reload(force: true)
-          true
-        end
-      end
-
       def dump(options={})
         data = {}
         data[:tagname] = tagname.to_s if tagname
         data[:separator] = separator.to_s if separator
         data[:tagvalue] = tagvalue.to_s if tagvalue
-        data[:fallback ] = @fallback.dump(options) if @fallback
+        data[:fallback] = @options[:fallback].dump(options) if @options[:fallback]
         data
       end
 
@@ -730,8 +729,8 @@ module Hotdog
     end
 
     class AnyHostNode < TagExpressionNode
-      def initialize(separator=nil)
-        super("host", nil, separator)
+      def initialize(separator=nil, options={})
+        super("host", nil, separator, options)
       end
 
       def condition(options={})
@@ -751,8 +750,8 @@ module Hotdog
     end
 
     class StringHostNode < StringExpressionNode
-      def initialize(tagvalue, separator=nil)
-        super("host", tagvalue.to_s, separator)
+      def initialize(tagvalue, separator=nil, options={})
+        super("host", tagvalue.to_s, separator, options)
       end
 
       def condition(options={})
@@ -779,8 +778,8 @@ module Hotdog
     end
 
     class StringTagNode < StringExpressionNode
-      def initialize(tagname, tagvalue, separator=nil)
-        super(tagname.to_s, tagvalue.to_s, separator)
+      def initialize(tagname, tagvalue, separator=nil, options={})
+        super(tagname.to_s, tagvalue.to_s, separator, options)
       end
 
       def condition(options={})
@@ -807,8 +806,8 @@ module Hotdog
     end
 
     class StringTagnameNode < StringExpressionNode
-      def initialize(tagname, separator=nil)
-        super(tagname.to_s, nil, separator)
+      def initialize(tagname, separator=nil, options={})
+        super(tagname.to_s, nil, separator, options)
       end
 
       def condition(options={})
@@ -835,8 +834,8 @@ module Hotdog
     end
 
     class StringTagvalueNode < StringExpressionNode
-      def initialize(tagvalue, separator=nil)
-        super(nil, tagvalue.to_s, separator)
+      def initialize(tagvalue, separator=nil, options={})
+        super(nil, tagvalue.to_s, separator, options)
       end
 
       def condition(options={})
@@ -863,8 +862,8 @@ module Hotdog
     end
 
     class StringHostOrTagNode < StringExpressionNode
-      def initialize(tagname, separator=nil)
-        super(tagname.to_s, nil, separator)
+      def initialize(tagname, separator=nil, options={})
+        super(tagname.to_s, nil, separator, options)
       end
 
       def condition(options={})
@@ -896,14 +895,14 @@ module Hotdog
         data[:tagname_glob] = tagname.to_s if tagname
         data[:separator] = separator.to_s if separator
         data[:tagvalue_glob] = tagvalue.to_s if tagvalue
-        data[:fallback] = @fallback.dump(options) if @fallback
+        data[:fallback] = @options[:fallback].dump(options) if @options[:fallback]
         data
       end
     end
 
     class GlobHostNode < GlobExpressionNode
-      def initialize(tagvalue, separator=nil)
-        super("host", tagvalue.to_s, separator)
+      def initialize(tagvalue, separator=nil, options={})
+        super("host", tagvalue.to_s, separator, options)
       end
 
       def condition(options={})
@@ -930,8 +929,8 @@ module Hotdog
     end
 
     class GlobTagNode < GlobExpressionNode
-      def initialize(tagname, tagvalue, separator=nil)
-        super(tagname.to_s, tagvalue.to_s, separator)
+      def initialize(tagname, tagvalue, separator=nil, options={})
+        super(tagname.to_s, tagvalue.to_s, separator, options)
       end
 
       def condition(options={})
@@ -958,8 +957,8 @@ module Hotdog
     end
 
     class GlobTagnameNode < GlobExpressionNode
-      def initialize(tagname, separator=nil)
-        super(tagname.to_s, nil, separator)
+      def initialize(tagname, separator=nil, options={})
+        super(tagname.to_s, nil, separator, options)
       end
 
       def condition(options={})
@@ -986,8 +985,8 @@ module Hotdog
     end
 
     class GlobTagvalueNode < GlobExpressionNode
-      def initialize(tagvalue, separator=nil)
-        super(nil, tagvalue.to_s, separator)
+      def initialize(tagvalue, separator=nil, options={})
+        super(nil, tagvalue.to_s, separator, options)
       end
 
       def condition(options={})
@@ -1014,8 +1013,8 @@ module Hotdog
     end
 
     class GlobHostOrTagNode < GlobExpressionNode
-      def initialize(tagname, separator=nil)
-        super(tagname.to_s, nil, separator)
+      def initialize(tagname, separator=nil, options={})
+        super(tagname.to_s, nil, separator, options)
       end
 
       def condition(options={})
@@ -1047,18 +1046,18 @@ module Hotdog
         data[:tagname_regexp] = tagname.to_s if tagname
         data[:separator] = separator.to_s if separator
         data[:tagvalue_regexp] = tagvalue.to_s if tagvalue
-        data[:fallback] = @fallback.dump(options) if @fallback
+        data[:fallback] = @options[:fallback].dump(options) if @options[:fallback]
         data
       end
     end
 
     class RegexpHostNode < RegexpExpressionNode
-      def initialize(tagvalue, separator=nil)
+      def initialize(tagvalue, separator=nil, options={})
         case tagvalue
         when /\A\/(.*)\/\z/
           tagvalue = $1
         end
-        super("host", tagvalue, separator)
+        super("host", tagvalue, separator, options)
       end
 
       def condition(options={})
@@ -1075,7 +1074,7 @@ module Hotdog
     end
 
     class RegexpTagNode < RegexpExpressionNode
-      def initialize(tagname, tagvalue, separator=nil)
+      def initialize(tagname, tagvalue, separator=nil, options={})
         case tagname
         when /\A\/(.*)\/\z/
           tagname = $1
@@ -1084,7 +1083,7 @@ module Hotdog
         when /\A\/(.*)\/\z/
           tagvalue = $1
         end
-        super(tagname, tagvalue, separator)
+        super(tagname, tagvalue, separator, options)
       end
 
       def condition(options={})
@@ -1101,12 +1100,12 @@ module Hotdog
     end
 
     class RegexpTagnameNode < RegexpExpressionNode
-      def initialize(tagname, separator=nil)
+      def initialize(tagname, separator=nil, options={})
         case tagname
         when /\A\/(.*)\/\z/
           tagname = $1
         end
-        super(tagname.to_s, nil, separator)
+        super(tagname.to_s, nil, separator, options)
       end
 
       def condition(options={})
@@ -1123,12 +1122,12 @@ module Hotdog
     end
 
     class RegexpTagvalueNode < RegexpExpressionNode
-      def initialize(tagvalue, separator=nil)
+      def initialize(tagvalue, separator=nil, options={})
         case tagvalue
         when /\A\/(.*)\/\z/
           tagvalue = $1
         end
-        super(nil, tagvalue.to_s, separator)
+        super(nil, tagvalue.to_s, separator, options)
       end
 
       def condition(options={})
@@ -1145,8 +1144,8 @@ module Hotdog
     end
 
     class RegexpHostOrTagNode < RegexpExpressionNode
-      def initialize(tagname, separator=nil)
-        super(tagname, separator)
+      def initialize(tagname, separator=nil, options={})
+        super(tagname, nil, separator, options)
       end
 
       def condition(options={})