chef-zero 1.4.0.alpha-x86-mingw32

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

@@ -0,0 +1,23 @@
+require 'chef_zero/solr/query/regexpable_query'
+
+module ChefZero
+  module Solr
+    module Query
+      class Phrase < RegexpableQuery
+        def initialize(terms)
+          # Phrase is terms separated by whitespace
+          if terms.size == 0 && terms[0].literal_string
+            literal_string = terms[0].literal_string
+          else
+            literal_string = nil
+          end
+          super(terms.map { |term| term.regexp_string }.join("#{NON_WORD_CHARACTER}+"), literal_string)
+        end
+
+        def to_s
+          "Phrase(\"#{@regexp_string}\")"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module ChefZero
+  module Solr
+    module Query
+      class RangeQuery
+        def initialize(from, to, from_inclusive, to_inclusive)
+          @from = from
+          @to = to
+          @from_inclusive = from_inclusive
+          @to_inclusive = to_inclusive
+        end
+
+        def to_s
+          "#{@from_inclusive ? '[' : '{'}#{@from} TO #{@to}#{@to_inclusive ? '[' : '{'}"
+        end
+
+        def matches?(key, value)
+          case @from <=> value
+          when -1
+            return false
+          when 0
+            return false if !@from_inclusive
+          end
+          case @to <=> value
+          when 1
+            return false
+          when 0
+            return false if !@to_inclusive
+          end
+          return true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module ChefZero
+  module Solr
+    module Query
+      class RegexpableQuery
+        def initialize(regexp_string, literal_string)
+          @regexp_string = regexp_string
+          # Surround the regexp with word boundaries
+          @regexp = Regexp.new("(^|#{NON_WORD_CHARACTER})#{regexp_string}($|#{NON_WORD_CHARACTER})", true)
+          @literal_string = literal_string
+        end
+
+        attr_reader :literal_string
+        attr_reader :regexp_string
+        attr_reader :regexp
+
+        def matches_doc?(doc)
+          value = doc[DEFAULT_FIELD]
+          return value ? matches_values?([value]) : false
+        end
+        def matches_values?(values)
+          values.any? { |value| !@regexp.match(value).nil? }
+        end
+
+        WORD_CHARACTER = "[A-Za-z0-9@._':]"
+        NON_WORD_CHARACTER = "[^A-Za-z0-9@._':]"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module ChefZero
+  module Solr
+    module Query
+      class Subquery
+        def initialize(subquery)
+          @subquery = subquery
+        end
+
+        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

@@ -0,0 +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

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

@@ -0,0 +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

data/lib/chef_zero/solr/solr_doc.rb

@@ -0,0 +1,62 @@
+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)
+        values = matching_values { |match_key| match_key == key }
+        values[0]
+      end
+
+      def matching_values(&block)
+        result = {}
+        key_values(nil, @json) do |key, value|
+          if block.call(key)
+            if result.has_key?(key)
+              result[key] << value.to_s
+            else
+              result[key] = value.to_s.clone
+            end
+          end
+        end
+        # Handle manufactured value(s)
+        if block.call('X_CHEF_id_CHEF_X')
+          if result.has_key?('X_CHEF_id_CHEF_X')
+            result['X_CHEF_id_CHEF_X'] << @id.to_s
+          else
+            result['X_CHEF_id_CHEF_X'] = @id.to_s.clone
+          end
+        end
+
+        result.values
+      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

@@ -0,0 +1,193 @@
+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 until eof? || @query_string[@index] =~ /\s/ || peek_operator_token
+          @query_string[start_index..@index-1]
+        end
+      end
+
+      def skip_whitespace
+        if @query_string[@index] =~ /\s/
+          whitespace = /\s+/.match(@query_string, @index)
+          @index += whitespace[0].length
+        end
+      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)
+        error = "Error on token '#{token}' at #{@index} of '#{@query_string}': #{str}"
+        raise error
+      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 '#{expected_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
+          Query::Term.new(token)
+        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