chef-zero 15.0.17 → 15.0.21

data/lib/chef_zero/socketless_server_map.rb

@@ -1,93 +1,92 @@
-#
-# Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright (c) 2012 Opscode, Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "thread"
-require "singleton" unless defined?(Singleton)
-require_relative "dist"
-
-module ChefZero
-
-  class ServerNotFound < StandardError
-  end
-
-  class NoSocketlessPortAvailable < StandardError
-  end
-
-  class SocketlessServerMap
-
-    def self.request(port, request_env)
-      instance.request(port, request_env)
-    end
-
-    def self.server_on_port(port)
-      instance.server_on_port(port)
-    end
-
-    MUTEX = Mutex.new
-
-    include Singleton
-
-    def initialize
-      reset!
-    end
-
-    def reset!
-      @servers_by_port = {}
-    end
-
-    def register_port(port, server)
-      MUTEX.synchronize do
-        @servers_by_port[port] = server
-      end
-    end
-
-    def register_no_listen_server(server)
-      MUTEX.synchronize do
-        1.upto(1000) do |port|
-          unless @servers_by_port.key?(port)
-            @servers_by_port[port] = server
-            return port
-          end
-        end
-        raise NoSocketlessPortAvailable, "No socketless ports left to register"
-      end
-    end
-
-    def has_server_on_port?(port)
-      @servers_by_port.key?(port)
-    end
-
-    def server_on_port(port)
-      @servers_by_port[port]
-    end
-
-    def deregister(port)
-      MUTEX.synchronize do
-        @servers_by_port.delete(port)
-      end
-    end
-
-    def request(port, request_env)
-      server = @servers_by_port[port]
-      raise ServerNotFound, "No socketless #{ChefZero::Dist::PRODUCT} server on given port #{port.inspect}" unless server
-
-      server.handle_socketless_request(request_env)
-    end
-
-  end
-end
+#
+# Author:: Daniel DeLeo (<dan@chef.io>)
+# Copyright:: Copyright (c) 2012 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "singleton" unless defined?(Singleton)
+require_relative "dist"
+
+module ChefZero
+
+  class ServerNotFound < StandardError
+  end
+
+  class NoSocketlessPortAvailable < StandardError
+  end
+
+  class SocketlessServerMap
+
+    def self.request(port, request_env)
+      instance.request(port, request_env)
+    end
+
+    def self.server_on_port(port)
+      instance.server_on_port(port)
+    end
+
+    MUTEX = Mutex.new
+
+    include Singleton
+
+    def initialize
+      reset!
+    end
+
+    def reset!
+      @servers_by_port = {}
+    end
+
+    def register_port(port, server)
+      MUTEX.synchronize do
+        @servers_by_port[port] = server
+      end
+    end
+
+    def register_no_listen_server(server)
+      MUTEX.synchronize do
+        1.upto(1000) do |port|
+          unless @servers_by_port.key?(port)
+            @servers_by_port[port] = server
+            return port
+          end
+        end
+        raise NoSocketlessPortAvailable, "No socketless ports left to register"
+      end
+    end
+
+    def has_server_on_port?(port)
+      @servers_by_port.key?(port)
+    end
+
+    def server_on_port(port)
+      @servers_by_port[port]
+    end
+
+    def deregister(port)
+      MUTEX.synchronize do
+        @servers_by_port.delete(port)
+      end
+    end
+
+    def request(port, request_env)
+      server = @servers_by_port[port]
+      raise ServerNotFound, "No socketless #{ChefZero::Dist::PRODUCT} server on given port #{port.inspect}" unless server
+
+      server.handle_socketless_request(request_env)
+    end
+
+  end
+end

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

@@ -1,52 +1,52 @@
-module ChefZero
-  module Solr
-    module Query
-      class BinaryOperator
-        def initialize(left, operator, right)
-          @left = left
-          @operator = operator
-          @right = right
-        end
-
-        def to_s
-          "(#{left} #{operator} #{right})"
-        end
-
-        attr_reader :left
-        attr_reader :operator
-        attr_reader :right
-
-        def matches_doc?(doc)
-          case @operator
-          when "AND"
-            left.matches_doc?(doc) && right.matches_doc?(doc)
-          when "OR"
-            left.matches_doc?(doc) || right.matches_doc?(doc)
-          when "^"
-            left.matches_doc?(doc)
-          when ":"
-            if left.respond_to?(:literal_string) && left.literal_string
-              values = doc[left.literal_string]
-            else
-              values = doc.matching_values { |key| left.matches_values?([key]) }
-            end
-            right.matches_values?(values)
-          end
-        end
-
-        def matches_values?(values)
-          case @operator
-          when "AND"
-            left.matches_values?(values) && right.matches_values?(values)
-          when "OR"
-            left.matches_values?(values) || right.matches_values?(values)
-          when "^"
-            left.matches_values?(values)
-          when ":"
-            raise ": does not work inside a : or term"
-          end
-        end
-      end
-    end
-  end
-end
+module ChefZero
+  module Solr
+    module Query
+      class BinaryOperator
+        def initialize(left, operator, right)
+          @left = left
+          @operator = operator
+          @right = right
+        end
+
+        def to_s
+          "(#{left} #{operator} #{right})"
+        end
+
+        attr_reader :left
+        attr_reader :operator
+        attr_reader :right
+
+        def matches_doc?(doc)
+          case @operator
+          when "AND"
+            left.matches_doc?(doc) && right.matches_doc?(doc)
+          when "OR"
+            left.matches_doc?(doc) || right.matches_doc?(doc)
+          when "^"
+            left.matches_doc?(doc)
+          when ":"
+            if left.respond_to?(:literal_string) && left.literal_string
+              values = doc[left.literal_string]
+            else
+              values = doc.matching_values { |key| left.matches_values?([key]) }
+            end
+            right.matches_values?(values)
+          end
+        end
+
+        def matches_values?(values)
+          case @operator
+          when "AND"
+            left.matches_values?(values) && right.matches_values?(values)
+          when "OR"
+            left.matches_values?(values) || right.matches_values?(values)
+          when "^"
+            left.matches_values?(values)
+          when ":"
+            raise ": does not work inside a : or term"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,23 +1,23 @@
-require_relative "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(&:regexp_string).join("#{NON_WORD_CHARACTER}+"), literal_string)
-        end
-
-        def to_s
-          "Phrase(\"#{@regexp_string}\")"
-        end
-      end
-    end
-  end
-end
+require_relative "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(&: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

@@ -1,46 +1,46 @@
-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_values?(values)
-          values.any? do |value|
-            unless @from == "*"
-              case @from <=> value
-              when -1
-                return false
-              when 0
-                return false unless @from_inclusive
-              end
-            end
-            unless @to == "*"
-              case value <=> @to
-              when 1
-                return false
-              when 0
-                return false unless @to_inclusive
-              end
-            end
-            return true
-          end
-        end
-
-        def matches_doc?(doc)
-          matches_values?(doc[DEFAULT_FIELD])
-        end
-
-        DEFAULT_FIELD = "text".freeze
-      end
-    end
-  end
-end
+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_values?(values)
+          values.any? do |value|
+            unless @from == "*"
+              case @from <=> value
+              when -1
+                return false
+              when 0
+                return false unless @from_inclusive
+              end
+            end
+            unless @to == "*"
+              case value <=> @to
+              when 1
+                return false
+              when 0
+                return false unless @to_inclusive
+              end
+            end
+            return true
+          end
+        end
+
+        def matches_doc?(doc)
+          matches_values?(doc[DEFAULT_FIELD])
+        end
+
+        DEFAULT_FIELD = "text".freeze
+      end
+    end
+  end
+end

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

@@ -1,30 +1,30 @@
-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)
-          matches_values?(doc[DEFAULT_FIELD])
-        end
-
-        def matches_values?(values)
-          values.any? { |value| !@regexp.match(value).nil? }
-        end
-
-        DEFAULT_FIELD = "text".freeze
-        WORD_CHARACTER = "[A-Za-z0-9@._':\-]".freeze
-        NON_WORD_CHARACTER = "[^A-Za-z0-9@._':\-]".freeze
-      end
-    end
-  end
-end
+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)
+          matches_values?(doc[DEFAULT_FIELD])
+        end
+
+        def matches_values?(values)
+          values.any? { |value| !@regexp.match(value).nil? }
+        end
+
+        DEFAULT_FIELD = "text".freeze
+        WORD_CHARACTER = "[A-Za-z0-9@._':-]".freeze
+        NON_WORD_CHARACTER = "[^A-Za-z0-9@._':-]".freeze
+      end
+    end
+  end
+end

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_relative "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 += 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_relative "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 += 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