chef-zero 4.2.3 → 4.3.0

data/lib/chef_zero/solr/query/subquery.rb

@@ -1,37 +1,37 @@
-module ChefZero
-  module Solr
-    module Query
-      class Subquery
-        def initialize(subquery)
-          @subquery = subquery
-        end
-
-        attr_reader :subquery
-
-        def to_s
-          "(#{subquery})"
-        end
-
-        def literal_string
-          subquery.literal_string
-        end
-
-        def regexp
-          subquery.regexp
-        end
-
-        def regexp_string
-          subquery.regexp_string
-        end
-
-        def matches_doc?(doc)
-          subquery.matches_doc?(doc)
-        end
-
-        def matches_values?(values)
-          subquery.matches_values?(values)
-        end
-      end
-    end
-  end
-end
+module ChefZero
+  module Solr
+    module Query
+      class Subquery
+        def initialize(subquery)
+          @subquery = subquery
+        end
+
+        attr_reader :subquery
+
+        def to_s
+          "(#{subquery})"
+        end
+
+        def literal_string
+          subquery.literal_string
+        end
+
+        def regexp
+          subquery.regexp
+        end
+
+        def regexp_string
+          subquery.regexp_string
+        end
+
+        def matches_doc?(doc)
+          subquery.matches_doc?(doc)
+        end
+
+        def matches_values?(values)
+          subquery.matches_values?(values)
+        end
+      end
+    end
+  end
+end

data/lib/chef_zero/solr/query/term.rb

@@ -1,45 +1,45 @@
-require 'chef_zero/solr/query/regexpable_query'
-
-module ChefZero
-  module Solr
-    module Query
-      class Term < RegexpableQuery
-        def initialize(term)
-          # Get rid of escape characters, turn * and ? into .* and . for regex, and
-          # escape everything that needs escaping
-          literal_string = ""
-          regexp_string = ""
-          index = 0
-          while index < term.length
-            if term[index] == '*'
-              regexp_string << "#{WORD_CHARACTER}*"
-              literal_string = nil
-              index += 1
-            elsif term[index] == '?'
-              regexp_string << WORD_CHARACTER
-              literal_string = nil
-              index += 1
-            elsif term[index] == '~'
-              raise "~ unsupported"
-            else
-              if term[index] == '\\'
-                index = index+1
-                if index >= term.length
-                  raise "Backslash at end of string '#{term}'"
-                end
-              end
-              literal_string << term[index] if literal_string
-              regexp_string << Regexp.escape(term[index])
-              index += 1
-            end
-          end
-          super(regexp_string, literal_string)
-        end
-
-        def to_s
-          "Term(#{regexp_string})"
-        end
-      end
-    end
-  end
-end
+require 'chef_zero/solr/query/regexpable_query'
+
+module ChefZero
+  module Solr
+    module Query
+      class Term < RegexpableQuery
+        def initialize(term)
+          # Get rid of escape characters, turn * and ? into .* and . for regex, and
+          # escape everything that needs escaping
+          literal_string = ""
+          regexp_string = ""
+          index = 0
+          while index < term.length
+            if term[index] == '*'
+              regexp_string << "#{WORD_CHARACTER}*"
+              literal_string = nil
+              index += 1
+            elsif term[index] == '?'
+              regexp_string << WORD_CHARACTER
+              literal_string = nil
+              index += 1
+            elsif term[index] == '~'
+              raise "~ unsupported"
+            else
+              if term[index] == '\\'
+                index = index+1
+                if index >= term.length
+                  raise "Backslash at end of string '#{term}'"
+                end
+              end
+              literal_string << term[index] if literal_string
+              regexp_string << Regexp.escape(term[index])
+              index += 1
+            end
+          end
+          super(regexp_string, literal_string)
+        end
+
+        def to_s
+          "Term(#{regexp_string})"
+        end
+      end
+    end
+  end
+end

data/lib/chef_zero/solr/query/unary_operator.rb

@@ -1,43 +1,43 @@
-module ChefZero
-  module Solr
-    module Query
-      class UnaryOperator
-        def initialize(operator, operand)
-          @operator = operator
-          @operand = operand
-        end
-
-        def to_s
-          "#{operator} #{operand}"
-        end
-
-        attr_reader :operator
-        attr_reader :operand
-
-        def matches_doc?(doc)
-          case @operator
-          when '-'
-          when 'NOT'
-            !operand.matches_doc?(doc)
-          when '+'
-            # TODO This operator uses relevance to eliminate other, unrelated
-            # expressions.  +a OR b means "if it has b but not a, don't return it"
-            raise "+ not supported yet, because it is hard."
-          end
-        end
-
-        def matches_values?(values)
-          case @operator
-          when '-'
-          when 'NOT'
-            !operand.matches_values?(values)
-          when '+'
-            # TODO This operator uses relevance to eliminate other, unrelated
-            # expressions.  +a OR b means "if it has b but not a, don't return it"
-            raise "+ not supported yet, because it is hard."
-          end
-        end
-      end
-    end
-  end
-end
+module ChefZero
+  module Solr
+    module Query
+      class UnaryOperator
+        def initialize(operator, operand)
+          @operator = operator
+          @operand = operand
+        end
+
+        def to_s
+          "#{operator} #{operand}"
+        end
+
+        attr_reader :operator
+        attr_reader :operand
+
+        def matches_doc?(doc)
+          case @operator
+          when '-'
+          when 'NOT'
+            !operand.matches_doc?(doc)
+          when '+'
+            # TODO This operator uses relevance to eliminate other, unrelated
+            # expressions.  +a OR b means "if it has b but not a, don't return it"
+            raise "+ not supported yet, because it is hard."
+          end
+        end
+
+        def matches_values?(values)
+          case @operator
+          when '-'
+          when 'NOT'
+            !operand.matches_values?(values)
+          when '+'
+            # TODO This operator uses relevance to eliminate other, unrelated
+            # expressions.  +a OR b means "if it has b but not a, don't return it"
+            raise "+ not supported yet, because it is hard."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chef_zero/solr/solr_doc.rb

@@ -1,53 +1,53 @@
-module ChefZero
-  module Solr
-    # This does what expander does, flattening the json doc into keys and values
-    # so that solr can search them.
-    class SolrDoc
-      def initialize(json, id)
-        @json = json
-        @id = id
-      end
-
-      def [](key)
-        matching_values { |match_key| match_key == key }
-      end
-
-      def matching_values(&block)
-        result = []
-        key_values(nil, @json) do |key, value|
-          if block.call(key)
-            result << value.to_s
-          end
-        end
-        # Handle manufactured value(s)
-        if block.call('X_CHEF_id_CHEF_X')
-          result << @id.to_s
-        end
-
-        result.uniq
-      end
-
-      private
-
-      def key_values(key_so_far, value, &block)
-        if value.is_a?(Hash)
-          value.each_pair do |child_key, child_value|
-            block.call(child_key, child_value.to_s)
-            if key_so_far
-              new_key = "#{key_so_far}_#{child_key}"
-              key_values(new_key, child_value, &block)
-            else
-              key_values(child_key, child_value, &block) if child_value.is_a?(Hash) || child_value.is_a?(Array)
-            end
-          end
-        elsif value.is_a?(Array)
-          value.each do |child_value|
-            key_values(key_so_far, child_value, &block)
-          end
-        else
-          block.call(key_so_far || 'text', value.to_s)
-        end
-      end
-    end
-  end
-end
+module ChefZero
+  module Solr
+    # This does what expander does, flattening the json doc into keys and values
+    # so that solr can search them.
+    class SolrDoc
+      def initialize(json, id)
+        @json = json
+        @id = id
+      end
+
+      def [](key)
+        matching_values { |match_key| match_key == key }
+      end
+
+      def matching_values(&block)
+        result = []
+        key_values(nil, @json) do |key, value|
+          if block.call(key)
+            result << value.to_s
+          end
+        end
+        # Handle manufactured value(s)
+        if block.call('X_CHEF_id_CHEF_X')
+          result << @id.to_s
+        end
+
+        result.uniq
+      end
+
+      private
+
+      def key_values(key_so_far, value, &block)
+        if value.is_a?(Hash)
+          value.each_pair do |child_key, child_value|
+            block.call(child_key, child_value.to_s)
+            if key_so_far
+              new_key = "#{key_so_far}_#{child_key}"
+              key_values(new_key, child_value, &block)
+            else
+              key_values(child_key, child_value, &block) if child_value.is_a?(Hash) || child_value.is_a?(Array)
+            end
+          end
+        elsif value.is_a?(Array)
+          value.each do |child_value|
+            key_values(key_so_far, child_value, &block)
+          end
+        else
+          block.call(key_so_far || 'text', value.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/chef_zero/solr/solr_parser.rb

@@ -1,203 +1,203 @@
-require 'chef_zero/solr/query/binary_operator'
-require 'chef_zero/solr/query/unary_operator'
-require 'chef_zero/solr/query/term'
-require 'chef_zero/solr/query/phrase'
-require 'chef_zero/solr/query/range_query'
-require 'chef_zero/solr/query/subquery'
-
-module ChefZero
-  module Solr
-    class SolrParser
-      def initialize(query_string)
-        @query_string = query_string
-        @index = 0
-      end
-
-      def parse
-        read_expression
-      end
-
-      #
-      # Tokenization
-      #
-      def peek_token
-        @next_token ||= parse_token
-      end
-
-      def next_token
-        result = peek_token
-        @next_token = nil
-        result
-      end
-
-      def parse_token
-        # Skip whitespace
-        skip_whitespace
-        return nil if eof?
-
-        # Operators
-        operator = peek_operator_token
-        if operator
-          @index+=operator.length
-          operator
-        else
-          # Everything that isn't whitespace or an operator, is part of a term
-          # (characters plus backslashed escaped characters)
-          start_index = @index
-          begin
-            if @query_string[@index] == '\\'
-              @index+=1
-            end
-            @index+=1 if !eof?
-          end while !eof? && peek_term_token
-          @query_string[start_index..@index-1]
-        end
-      end
-
-      def skip_whitespace
-        if @query_string[@index] =~ /\s/
-          whitespace = /\s+/.match(@query_string, @index) || peek
-          @index += whitespace[0].length
-        end
-      end
-
-      def peek_term_token
-        return nil if @query_string[@index] =~ /\s/
-        op = peek_operator_token
-        return !op || op == '-'
-      end
-
-      def peek_operator_token
-        if ['"', '+', '-', '!', '(', ')', '{', '}', '[', ']', '^', ':'].include?(@query_string[@index])
-          return @query_string[@index]
-        else
-          result = @query_string[@index..@index+1]
-          if ['&&', '||'].include?(result)
-            return result
-          end
-        end
-        nil
-      end
-
-      def eof?
-        !@next_token && @index >= @query_string.length
-      end
-
-      # Parse tree creation
-      def read_expression
-        result = read_single_expression
-        # Expression is over when we hit a close paren or eof
-        # (peek_token has the side effect of skipping whitespace for us, so we
-        # really know if we're at eof or not)
-        until peek_token == ')' || eof?
-          operator = peek_token
-          if binary_operator?(operator)
-            next_token
-          else
-            # If 2 terms are next to each other, the default operator is OR
-            operator = 'OR'
-          end
-          next_expression = read_single_expression
-
-          # Build the operator, taking precedence into account
-          if result.is_a?(Query::BinaryOperator) &&
-             binary_operator_precedence(operator) > binary_operator_precedence(result.operator)
-            # a+b*c -> a+(b*c)
-            new_right = Query::BinaryOperator.new(result.right, operator, next_expression)
-            result = Query::BinaryOperator.new(result.left, result.operator, new_right)
-          else
-            # a*b+c -> (a*b)+c
-            result = Query::BinaryOperator.new(result, operator, next_expression)
-          end
-        end
-        result
-      end
-
-      def parse_error(token, str)
-        raise "Error on token '#{token}' at #{@index} of '#{@query_string}': #{str}"
-      end
-
-      def read_single_expression
-        token = next_token
-        # If EOF, we have a problem Houston
-        if !token
-          parse_error(nil, "Expected expression!")
-
-        # If it's an unary operand, build that
-        elsif unary_operator?(token)
-          operand = read_single_expression
-          # TODO We rely on all unary operators having higher precedence than all
-          # binary operators.  Check if this is the case.
-          Query::UnaryOperator.new(token, operand)
-
-        # If it's the start of a phrase, read the terms in the phrase
-        elsif token == '"'
-          # Read terms until close "
-          phrase_terms = []
-          until (term = next_token) == '"'
-            phrase_terms << Query::Term.new(term)
-          end
-          Query::Phrase.new(phrase_terms)
-
-        # If it's the start of a range query, build that
-        elsif token == '{' || token == '['
-          left = next_token
-          parse_error(left, "Expected left term in range query") if !left
-          to = next_token
-          parse_error(left, "Expected TO in range query") if to != "TO"
-          right = next_token
-          parse_error(right, "Expected left term in range query") if !right
-          end_range = next_token
-          parse_error(right, "Expected end range '#{end_range}") if !['}', ']'].include?(end_range)
-          Query::RangeQuery.new(left, right, token == '[', end_range == ']')
-
-        elsif token == '('
-          subquery = read_expression
-          close_paren = next_token
-          parse_error(close_paren, "Expected ')'") if close_paren != ')'
-          Query::Subquery.new(subquery)
-
-        # If it's the end of a closure, raise an exception
-        elsif ['}',']',')'].include?(token)
-          parse_error(token, "Unexpected end paren")
-
-        # If it's a binary operator, raise an exception
-        elsif binary_operator?(token)
-          parse_error(token, "Unexpected binary operator")
-
-        # Otherwise it's a term.
-        else
-          term = Query::Term.new(token)
-          if peek_token == ':'
-            Query::BinaryOperator.new(term, next_token, read_single_expression)
-          else
-            term
-          end
-        end
-      end
-
-      def unary_operator?(token)
-        [ 'NOT', '+', '-' ].include?(token)
-      end
-
-      def binary_operator?(token)
-        [ 'AND', 'OR', '^', ':'].include?(token)
-      end
-
-      def binary_operator_precedence(token)
-        case token
-        when '^'
-          4
-        when ':'
-          3
-        when 'AND'
-          2
-        when 'OR'
-          1
-        end
-      end
-
-      DEFAULT_FIELD = 'text'
-    end
-  end
-end
+require 'chef_zero/solr/query/binary_operator'
+require 'chef_zero/solr/query/unary_operator'
+require 'chef_zero/solr/query/term'
+require 'chef_zero/solr/query/phrase'
+require 'chef_zero/solr/query/range_query'
+require 'chef_zero/solr/query/subquery'
+
+module ChefZero
+  module Solr
+    class SolrParser
+      def initialize(query_string)
+        @query_string = query_string
+        @index = 0
+      end
+
+      def parse
+        read_expression
+      end
+
+      #
+      # Tokenization
+      #
+      def peek_token
+        @next_token ||= parse_token
+      end
+
+      def next_token
+        result = peek_token
+        @next_token = nil
+        result
+      end
+
+      def parse_token
+        # Skip whitespace
+        skip_whitespace
+        return nil if eof?
+
+        # Operators
+        operator = peek_operator_token
+        if operator
+          @index+=operator.length
+          operator
+        else
+          # Everything that isn't whitespace or an operator, is part of a term
+          # (characters plus backslashed escaped characters)
+          start_index = @index
+          begin
+            if @query_string[@index] == '\\'
+              @index+=1
+            end
+            @index+=1 if !eof?
+          end while !eof? && peek_term_token
+          @query_string[start_index..@index-1]
+        end
+      end
+
+      def skip_whitespace
+        if @query_string[@index] =~ /\s/
+          whitespace = /\s+/.match(@query_string, @index) || peek
+          @index += whitespace[0].length
+        end
+      end
+
+      def peek_term_token
+        return nil if @query_string[@index] =~ /\s/
+        op = peek_operator_token
+        return !op || op == '-'
+      end
+
+      def peek_operator_token
+        if ['"', '+', '-', '!', '(', ')', '{', '}', '[', ']', '^', ':'].include?(@query_string[@index])
+          return @query_string[@index]
+        else
+          result = @query_string[@index..@index+1]
+          if ['&&', '||'].include?(result)
+            return result
+          end
+        end
+        nil
+      end
+
+      def eof?
+        !@next_token && @index >= @query_string.length
+      end
+
+      # Parse tree creation
+      def read_expression
+        result = read_single_expression
+        # Expression is over when we hit a close paren or eof
+        # (peek_token has the side effect of skipping whitespace for us, so we
+        # really know if we're at eof or not)
+        until peek_token == ')' || eof?
+          operator = peek_token
+          if binary_operator?(operator)
+            next_token
+          else
+            # If 2 terms are next to each other, the default operator is OR
+            operator = 'OR'
+          end
+          next_expression = read_single_expression
+
+          # Build the operator, taking precedence into account
+          if result.is_a?(Query::BinaryOperator) &&
+             binary_operator_precedence(operator) > binary_operator_precedence(result.operator)
+            # a+b*c -> a+(b*c)
+            new_right = Query::BinaryOperator.new(result.right, operator, next_expression)
+            result = Query::BinaryOperator.new(result.left, result.operator, new_right)
+          else
+            # a*b+c -> (a*b)+c
+            result = Query::BinaryOperator.new(result, operator, next_expression)
+          end
+        end
+        result
+      end
+
+      def parse_error(token, str)
+        raise "Error on token '#{token}' at #{@index} of '#{@query_string}': #{str}"
+      end
+
+      def read_single_expression
+        token = next_token
+        # If EOF, we have a problem Houston
+        if !token
+          parse_error(nil, "Expected expression!")
+
+        # If it's an unary operand, build that
+        elsif unary_operator?(token)
+          operand = read_single_expression
+          # TODO We rely on all unary operators having higher precedence than all
+          # binary operators.  Check if this is the case.
+          Query::UnaryOperator.new(token, operand)
+
+        # If it's the start of a phrase, read the terms in the phrase
+        elsif token == '"'
+          # Read terms until close "
+          phrase_terms = []
+          until (term = next_token) == '"'
+            phrase_terms << Query::Term.new(term)
+          end
+          Query::Phrase.new(phrase_terms)
+
+        # If it's the start of a range query, build that
+        elsif token == '{' || token == '['
+          left = next_token
+          parse_error(left, "Expected left term in range query") if !left
+          to = next_token
+          parse_error(left, "Expected TO in range query") if to != "TO"
+          right = next_token
+          parse_error(right, "Expected left term in range query") if !right
+          end_range = next_token
+          parse_error(right, "Expected end range '#{end_range}") if !['}', ']'].include?(end_range)
+          Query::RangeQuery.new(left, right, token == '[', end_range == ']')
+
+        elsif token == '('
+          subquery = read_expression
+          close_paren = next_token
+          parse_error(close_paren, "Expected ')'") if close_paren != ')'
+          Query::Subquery.new(subquery)
+
+        # If it's the end of a closure, raise an exception
+        elsif ['}',']',')'].include?(token)
+          parse_error(token, "Unexpected end paren")
+
+        # If it's a binary operator, raise an exception
+        elsif binary_operator?(token)
+          parse_error(token, "Unexpected binary operator")
+
+        # Otherwise it's a term.
+        else
+          term = Query::Term.new(token)
+          if peek_token == ':'
+            Query::BinaryOperator.new(term, next_token, read_single_expression)
+          else
+            term
+          end
+        end
+      end
+
+      def unary_operator?(token)
+        [ 'NOT', '+', '-' ].include?(token)
+      end
+
+      def binary_operator?(token)
+        [ 'AND', 'OR', '^', ':'].include?(token)
+      end
+
+      def binary_operator_precedence(token)
+        case token
+        when '^'
+          4
+        when ':'
+          3
+        when 'AND'
+          2
+        when 'OR'
+          1
+        end
+      end
+
+      DEFAULT_FIELD = 'text'
+    end
+  end
+end