chef-zero 0.9

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,194 @@
+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}"
+        puts error
+        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

data/lib/chef_zero/version.rb

@@ -0,0 +1,3 @@
+module ChefZero
+  VERSION = '0.9'
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: chef-zero
+version: !ruby/object:Gem::Version
+  version: '0.9'
+  prerelease: 
+platform: ruby
+authors:
+- John Keiser
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: chef
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Self-contained, easy-setup, fast-start in-memory Chef server for testing
+  and solo setup purposes
+email: jkeiser@opscode.com
+executables:
+- chef-zero
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+- LICENSE
+files:
+- LICENSE
+- README.rdoc
+- Rakefile
+- lib/chef_zero/cookbook_data.rb
+- lib/chef_zero/data_normalizer.rb
+- lib/chef_zero/endpoints/actor_endpoint.rb
+- lib/chef_zero/endpoints/actors_endpoint.rb
+- lib/chef_zero/endpoints/authenticate_user_endpoint.rb
+- lib/chef_zero/endpoints/cookbook_endpoint.rb
+- lib/chef_zero/endpoints/cookbook_version_endpoint.rb
+- lib/chef_zero/endpoints/cookbooks_base.rb
+- lib/chef_zero/endpoints/cookbooks_endpoint.rb
+- lib/chef_zero/endpoints/data_bag_endpoint.rb
+- lib/chef_zero/endpoints/data_bag_item_endpoint.rb
+- lib/chef_zero/endpoints/data_bags_endpoint.rb
+- lib/chef_zero/endpoints/environment_cookbook_endpoint.rb
+- lib/chef_zero/endpoints/environment_cookbook_versions_endpoint.rb
+- lib/chef_zero/endpoints/environment_cookbooks_endpoint.rb
+- lib/chef_zero/endpoints/environment_endpoint.rb
+- lib/chef_zero/endpoints/environment_nodes_endpoint.rb
+- lib/chef_zero/endpoints/environment_recipes_endpoint.rb
+- lib/chef_zero/endpoints/environment_role_endpoint.rb
+- lib/chef_zero/endpoints/file_store_file_endpoint.rb
+- lib/chef_zero/endpoints/node_endpoint.rb
+- lib/chef_zero/endpoints/not_found_endpoint.rb
+- lib/chef_zero/endpoints/principal_endpoint.rb
+- lib/chef_zero/endpoints/rest_list_endpoint.rb
+- lib/chef_zero/endpoints/rest_object_endpoint.rb
+- lib/chef_zero/endpoints/role_endpoint.rb
+- lib/chef_zero/endpoints/role_environments_endpoint.rb
+- lib/chef_zero/endpoints/sandbox_endpoint.rb
+- lib/chef_zero/endpoints/sandboxes_endpoint.rb
+- lib/chef_zero/endpoints/search_endpoint.rb
+- lib/chef_zero/endpoints/searches_endpoint.rb
+- lib/chef_zero/rest_base.rb
+- lib/chef_zero/rest_error_response.rb
+- lib/chef_zero/rest_request.rb
+- lib/chef_zero/router.rb
+- lib/chef_zero/server.rb
+- lib/chef_zero/solr/query/binary_operator.rb
+- lib/chef_zero/solr/query/phrase.rb
+- lib/chef_zero/solr/query/range_query.rb
+- lib/chef_zero/solr/query/regexpable_query.rb
+- lib/chef_zero/solr/query/subquery.rb
+- lib/chef_zero/solr/query/term.rb
+- lib/chef_zero/solr/query/unary_operator.rb
+- lib/chef_zero/solr/solr_doc.rb
+- lib/chef_zero/solr/solr_parser.rb
+- lib/chef_zero/version.rb
+- lib/chef_zero.rb
+- bin/chef-zero
+homepage: http://www.opscode.com
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Self-contained, easy-setup, fast-start in-memory Chef server for testing
+  and solo setup purposes
+test_files: []