chef 14.15.6-universal-mingw32 → 15.0.293-universal-mingw32

data/lib/chef/resource_collection/resource_collection_serialization.rb

@@ -1,68 +1,68 @@
-#
-# Author:: Tyler Ball (<tball@chef.io>)
-# Copyright:: Copyright 2014-2018, Chef Software 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
-#
-#     http://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 "chef/json_compat"
-
-class Chef
-  class ResourceCollection
-    module ResourceCollectionSerialization
-      # Serialize this object as a hash
-      def to_h
-        instance_vars = Hash.new
-        instance_variables.each do |iv|
-          instance_vars[iv] = instance_variable_get(iv)
-        end
-        {
-            "json_class" => self.class.name,
-            "instance_vars" => instance_vars,
-        }
-      end
-
-      alias_method :to_hash, :to_h
-
-      def to_json(*a)
-        Chef::JSONCompat.to_json(to_hash, *a)
-      end
-
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      module ClassMethods
-        def from_hash(o)
-          collection = new()
-          o["instance_vars"].each do |k, v|
-            collection.instance_variable_set(k.to_sym, v)
-          end
-          collection
-        end
-
-        def from_json(j)
-          from_hash(Chef::JSONCompat.parse(j))
-        end
-      end
-
-      def is_chef_resource!(arg)
-        unless arg.kind_of?(Chef::Resource)
-          raise ArgumentError, "Cannot insert a #{arg.class} into a resource collection: must be a subclass of Chef::Resource"
-        end
-        true
-      end
-    end
-  end
-end
+#
+# Author:: Tyler Ball (<tball@chef.io>)
+# Copyright:: Copyright 2014-2018, Chef Software 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
+#
+#     http://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_relative "../json_compat"
+
+class Chef
+  class ResourceCollection
+    module ResourceCollectionSerialization
+      # Serialize this object as a hash
+      def to_h
+        instance_vars = Hash.new
+        instance_variables.each do |iv|
+          instance_vars[iv] = instance_variable_get(iv)
+        end
+        {
+            "json_class" => self.class.name,
+            "instance_vars" => instance_vars,
+        }
+      end
+
+      alias_method :to_hash, :to_h
+
+      def to_json(*a)
+        Chef::JSONCompat.to_json(to_hash, *a)
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def from_hash(o)
+          collection = new()
+          o["instance_vars"].each do |k, v|
+            collection.instance_variable_set(k.to_sym, v)
+          end
+          collection
+        end
+
+        def from_json(j)
+          from_hash(Chef::JSONCompat.parse(j))
+        end
+      end
+
+      def is_chef_resource!(arg)
+        unless arg.kind_of?(Chef::Resource)
+          raise ArgumentError, "Cannot insert a #{arg.class} into a resource collection: must be a subclass of Chef::Resource"
+        end
+        true
+      end
+    end
+  end
+end

data/lib/chef/resource_collection/resource_list.rb

@@ -1,106 +1,106 @@
-#
-# Author:: Tyler Ball (<tball@chef.io>)
-# Copyright:: Copyright 2014-2016, Chef Software, 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
-#
-#     http://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 "chef/resource"
-require "chef/resource_collection/stepable_iterator"
-require "chef/resource_collection/resource_collection_serialization"
-require "forwardable"
-
-# This class keeps the list of all known Resources in the order they are to be executed in.  It also keeps a pointer
-# to the most recently executed resource so we can add resources-to-execute after this point.
-class Chef
-  class ResourceCollection
-    class ResourceList
-      include ResourceCollection::ResourceCollectionSerialization
-      include Enumerable
-      extend Forwardable
-
-      attr_reader :iterator
-
-      attr_reader :resources
-      private :resources
-      # Delegate direct access methods to the @resources array
-      # 4 extra methods here are not included in the Enumerable's instance methods
-      direct_access_methods = Enumerable.instance_methods + [ :[], :each, :each_index, :empty? ]
-      def_delegators :resources, *(direct_access_methods)
-
-      def initialize
-        @resources = Array.new
-        @insert_after_idx = nil
-      end
-
-      # @param resource [Chef::Resource] The resource to insert
-      # If @insert_after_idx is nil, we are not currently executing a converge so the Resource is appended to the
-      # end of the list.  If @insert_after_idx is NOT nil, we ARE currently executing a converge so the resource
-      # is inserted into the middle of the list after the last resource that was converged.  If it is called multiple
-      # times (when an LWRP contains multiple resources) it keeps track of that.  See this example ResourceList:
-      # [File1, LWRP1, File2] # The iterator starts and points to File1.  It is executed and @insert_after_idx=0
-      # [File1, LWRP1, File2] # The iterator moves to LWRP1.  It is executed and @insert_after_idx=1
-      # [File1, LWRP1, Service1, File2] # The LWRP execution inserts Service1 and @insert_after_idx=2
-      # [File1, LWRP1, Service1, Service2, File2] # The LWRP inserts Service2 and @insert_after_idx=3.  The LWRP
-      #     finishes executing
-      # [File1, LWRP1, Service1, Service2, File2] # The iterator moves to Service1 since it is the next non-executed
-      #     resource.  The execute_each_resource call below resets @insert_after_idx=2
-      # If Service1 was another LWRP, it would insert its resources between Service1 and Service2.  The iterator keeps
-      # track of executed resources and @insert_after_idx keeps track of where the next resource to insert should be.
-      def insert(resource)
-        is_chef_resource!(resource)
-        if @insert_after_idx
-          @resources.insert(@insert_after_idx += 1, resource)
-        else
-          @resources << resource
-        end
-      end
-
-      def delete(key)
-        raise ArgumentError, "Must pass a Chef::Resource or String to delete" unless key.is_a?(String) || key.is_a?(Chef::Resource)
-        key = key.to_s
-        ret = @resources.reject! { |r| r.to_s == key }
-        if ret.nil?
-          raise Chef::Exceptions::ResourceNotFound, "Cannot find a resource matching #{key} (did you define it first?)"
-        end
-        ret
-      end
-
-      # @deprecated - can be removed when it is removed from resource_collection.rb
-      def []=(index, resource)
-        @resources[index] = resource
-      end
-
-      def all_resources
-        @resources
-      end
-
-      # FIXME: yard with @yield
-      def execute_each_resource
-        @iterator = ResourceCollection::StepableIterator.for_collection(@resources)
-        @iterator.each_with_index do |resource, idx|
-          @insert_after_idx = idx
-          yield resource
-        end
-      end
-
-      def self.from_hash(o)
-        collection = new()
-        resources = o["instance_vars"]["@resources"].map { |r| Chef::Resource.from_hash(r) }
-        collection.instance_variable_set(:@resources, resources)
-        collection
-      end
-    end
-  end
-end
+#
+# Author:: Tyler Ball (<tball@chef.io>)
+# Copyright:: Copyright 2014-2019, Chef Software 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
+#
+#     http://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_relative "../resource"
+require_relative "stepable_iterator"
+require_relative "resource_collection_serialization"
+require "forwardable"
+
+# This class keeps the list of all known Resources in the order they are to be executed in.  It also keeps a pointer
+# to the most recently executed resource so we can add resources-to-execute after this point.
+class Chef
+  class ResourceCollection
+    class ResourceList
+      include ResourceCollection::ResourceCollectionSerialization
+      include Enumerable
+      extend Forwardable
+
+      attr_reader :iterator
+
+      attr_reader :resources
+      private :resources
+      # Delegate direct access methods to the @resources array
+      # 4 extra methods here are not included in the Enumerable's instance methods
+      direct_access_methods = Enumerable.instance_methods + [ :[], :each, :each_index, :empty? ]
+      def_delegators :resources, *(direct_access_methods)
+
+      def initialize
+        @resources = Array.new
+        @insert_after_idx = nil
+      end
+
+      # @param resource [Chef::Resource] The resource to insert
+      # If @insert_after_idx is nil, we are not currently executing a converge so the Resource is appended to the
+      # end of the list.  If @insert_after_idx is NOT nil, we ARE currently executing a converge so the resource
+      # is inserted into the middle of the list after the last resource that was converged.  If it is called multiple
+      # times (when an LWRP contains multiple resources) it keeps track of that.  See this example ResourceList:
+      # [File1, LWRP1, File2] # The iterator starts and points to File1.  It is executed and @insert_after_idx=0
+      # [File1, LWRP1, File2] # The iterator moves to LWRP1.  It is executed and @insert_after_idx=1
+      # [File1, LWRP1, Service1, File2] # The LWRP execution inserts Service1 and @insert_after_idx=2
+      # [File1, LWRP1, Service1, Service2, File2] # The LWRP inserts Service2 and @insert_after_idx=3.  The LWRP
+      #     finishes executing
+      # [File1, LWRP1, Service1, Service2, File2] # The iterator moves to Service1 since it is the next non-executed
+      #     resource.  The execute_each_resource call below resets @insert_after_idx=2
+      # If Service1 was another LWRP, it would insert its resources between Service1 and Service2.  The iterator keeps
+      # track of executed resources and @insert_after_idx keeps track of where the next resource to insert should be.
+      def insert(resource)
+        is_chef_resource!(resource)
+        if @insert_after_idx
+          @resources.insert(@insert_after_idx += 1, resource)
+        else
+          @resources << resource
+        end
+      end
+
+      def delete(key)
+        raise ArgumentError, "Must pass a Chef::Resource or String to delete" unless key.is_a?(String) || key.is_a?(Chef::Resource)
+        key = key.to_s
+        ret = @resources.reject! { |r| r.to_s == key }
+        if ret.nil?
+          raise Chef::Exceptions::ResourceNotFound, "Cannot find a resource matching #{key} (did you define it first?)"
+        end
+        ret
+      end
+
+      # @deprecated - can be removed when it is removed from resource_collection.rb
+      def []=(index, resource)
+        @resources[index] = resource
+      end
+
+      def all_resources
+        @resources
+      end
+
+      # FIXME: yard with @yield
+      def execute_each_resource
+        @iterator = ResourceCollection::StepableIterator.for_collection(@resources)
+        @iterator.each_with_index do |resource, idx|
+          @insert_after_idx = idx
+          yield resource
+        end
+      end
+
+      def self.from_hash(o)
+        collection = new()
+        resources = o["instance_vars"]["@resources"].map { |r| Chef::Resource.from_hash(r) }
+        collection.instance_variable_set(:@resources, resources)
+        collection
+      end
+    end
+  end
+end

data/lib/chef/resource_collection/resource_set.rb

@@ -1,200 +1,200 @@
-#
-# Author:: Tyler Ball (<tball@chef.io>)
-# Copyright:: Copyright 2014-2017, Chef Software 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
-#
-#     http://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 "chef/resource"
-require "chef/resource_collection/resource_collection_serialization"
-
-class Chef
-  class ResourceCollection
-    class ResourceSet
-      include ResourceCollection::ResourceCollectionSerialization
-
-      # Matches a multiple resource lookup specification,
-      # e.g., "service[nginx,unicorn]"
-      MULTIPLE_RESOURCE_MATCH = /^(.+)\[(.+?),(.+)\]$/
-
-      # Matches a single resource lookup specification,
-      # e.g., "service[nginx]"
-      SINGLE_RESOURCE_MATCH = /^(.+)\[(.*)\]$/
-
-      # Matches e.g. "apt_update" with no name
-      NAMELESS_RESOURCE_MATCH = /^([^\[\]\s]+)$/
-
-      def initialize
-        @resources_by_key = Hash.new
-      end
-
-      def keys
-        @resources_by_key.keys
-      end
-
-      def insert_as(resource, resource_type = nil, instance_name = nil)
-        is_chef_resource!(resource)
-        resource_type ||= resource.resource_name
-        instance_name ||= resource.name
-        key = create_key(resource_type, instance_name)
-        @resources_by_key[key] = resource
-      end
-
-      def lookup(key)
-        raise ArgumentError, "Must pass a Chef::Resource or String to lookup" unless key.is_a?(String) || key.is_a?(Chef::Resource)
-        key = key.to_s
-        res = @resources_by_key[key]
-        unless res
-          raise Chef::Exceptions::ResourceNotFound, "Cannot find a resource matching #{key} (did you define it first?)"
-        end
-        res
-      end
-
-      def delete(key)
-        raise ArgumentError, "Must pass a Chef::Resource or String to delete" unless key.is_a?(String) || key.is_a?(Chef::Resource)
-        key = key.to_s
-        res = @resources_by_key.delete(key)
-
-        if res == @resources_by_key.default
-          raise Chef::Exceptions::ResourceNotFound, "Cannot find a resource matching #{key} (did you define it first?)"
-        end
-        res
-      end
-
-      # Find existing resources by searching the list of existing resources.  Possible
-      # forms are:
-      #
-      # find(:file => "foobar")
-      # find(:file => [ "foobar", "baz" ])
-      # find("file[foobar]", "file[baz]")
-      # find("file[foobar,baz]")
-      #
-      # Returns the matching resource, or an Array of matching resources.
-      #
-      # Raises an ArgumentError if you feed it bad lookup information
-      # Raises a Runtime Error if it can't find the resources you are looking for.
-      def find(*args)
-        results = Array.new
-        args.each do |arg|
-          case arg
-            when Hash
-              results << find_resource_by_hash(arg)
-            when String
-              results << find_resource_by_string(arg)
-            else
-              msg = "arguments to #{self.class.name}#find should be of the form :resource => 'name' or 'resource[name]'"
-              raise Chef::Exceptions::InvalidResourceSpecification, msg
-          end
-        end
-        flat_results = results.flatten
-        flat_results.length == 1 ? flat_results[0] : flat_results
-      end
-
-      # @deprecated
-      # resources is a poorly named, but we have to maintain it for back
-      # compat.
-      alias_method :resources, :find
-
-      # Returns true if +query_object+ is a valid string for looking up a
-      # resource, or raises InvalidResourceSpecification if not.
-      # === Arguments
-      # * query_object should be a string of the form
-      # "resource_type[resource_name]", a single element Hash (e.g., :service =>
-      # "apache2"), or a Chef::Resource (this is the happy path). Other arguments
-      # will raise an exception.
-      # === Returns
-      # * true returns true for all valid input.
-      # === Raises
-      # * Chef::Exceptions::InvalidResourceSpecification for all invalid input.
-      def validate_lookup_spec!(query_object)
-        case query_object
-          when Chef::Resource
-            true
-          when SINGLE_RESOURCE_MATCH, MULTIPLE_RESOURCE_MATCH, NAMELESS_RESOURCE_MATCH
-            true
-          when Hash
-            true
-          when String
-            raise Chef::Exceptions::InvalidResourceSpecification,
-                  "The string `#{query_object}' is not valid for resource collection lookup. Correct syntax is `resource_type[resource_name]'"
-          else
-            raise Chef::Exceptions::InvalidResourceSpecification,
-                  "The object `#{query_object.inspect}' is not valid for resource collection lookup. " +
-              "Use a String like `resource_type[resource_name]' or a Chef::Resource object"
-        end
-      end
-
-      def self.from_hash(o)
-        collection = new()
-        rl = o["instance_vars"]["@resources_by_key"]
-        resources = rl.merge(rl) { |k, r| Chef::Resource.from_hash(r) }
-        collection.instance_variable_set(:@resources_by_key, resources)
-        collection
-      end
-
-      private
-
-      def create_key(resource_type, instance_name)
-        "#{resource_type}[#{instance_name}]"
-      end
-
-      def find_resource_by_hash(arg)
-        results = Array.new
-        arg.each do |resource_type, name_list|
-          instance_names = name_list.kind_of?(Array) ? name_list : [ name_list ]
-          instance_names.each do |instance_name|
-            results << lookup(create_key(resource_type, instance_name))
-          end
-        end
-        results
-      end
-
-      def find_resource_by_string(arg)
-        begin
-          if arg =~ SINGLE_RESOURCE_MATCH
-            resource_type = $1
-            name = $2
-            return [ lookup(create_key(resource_type, name)) ]
-          end
-        rescue Chef::Exceptions::ResourceNotFound => e
-          if arg =~ MULTIPLE_RESOURCE_MATCH
-            begin
-              results = Array.new
-              resource_type = $1
-              arg =~ /^.+\[(.+)\]$/
-              resource_list = $1
-              resource_list.split(",").each do |instance_name|
-                results << lookup(create_key(resource_type, instance_name))
-              end
-              Chef.deprecated(:multiresource_match, "The resource_collection multi-resource syntax is deprecated")
-              return results
-            rescue  Chef::Exceptions::ResourceNotFound
-              raise e
-            end
-          else
-            raise e
-          end
-        end
-
-        if arg =~ NAMELESS_RESOURCE_MATCH
-          resource_type = $1
-          name = ""
-          return [ lookup(create_key(resource_type, name)) ]
-        end
-
-        raise ArgumentError, "Bad string format #{arg}, you must have a string like resource_type[name]!"
-      end
-    end
-  end
-end
+#
+# Author:: Tyler Ball (<tball@chef.io>)
+# Copyright:: Copyright 2014-2017, Chef Software 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
+#
+#     http://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_relative "../resource"
+require_relative "resource_collection_serialization"
+
+class Chef
+  class ResourceCollection
+    class ResourceSet
+      include ResourceCollection::ResourceCollectionSerialization
+
+      # Matches a multiple resource lookup specification,
+      # e.g., "service[nginx,unicorn]"
+      MULTIPLE_RESOURCE_MATCH = /^(.+)\[(.+?),(.+)\]$/.freeze
+
+      # Matches a single resource lookup specification,
+      # e.g., "service[nginx]"
+      SINGLE_RESOURCE_MATCH = /^(.+)\[(.*)\]$/.freeze
+
+      # Matches e.g. "apt_update" with no name
+      NAMELESS_RESOURCE_MATCH = /^([^\[\]\s]+)$/.freeze
+
+      def initialize
+        @resources_by_key = Hash.new
+      end
+
+      def keys
+        @resources_by_key.keys
+      end
+
+      def insert_as(resource, resource_type = nil, instance_name = nil)
+        is_chef_resource!(resource)
+        resource_type ||= resource.resource_name
+        instance_name ||= resource.name
+        key = create_key(resource_type, instance_name)
+        @resources_by_key[key] = resource
+      end
+
+      def lookup(key)
+        raise ArgumentError, "Must pass a Chef::Resource or String to lookup" unless key.is_a?(String) || key.is_a?(Chef::Resource)
+        key = key.to_s
+        res = @resources_by_key[key]
+        unless res
+          raise Chef::Exceptions::ResourceNotFound, "Cannot find a resource matching #{key} (did you define it first?)"
+        end
+        res
+      end
+
+      def delete(key)
+        raise ArgumentError, "Must pass a Chef::Resource or String to delete" unless key.is_a?(String) || key.is_a?(Chef::Resource)
+        key = key.to_s
+        res = @resources_by_key.delete(key)
+
+        if res == @resources_by_key.default
+          raise Chef::Exceptions::ResourceNotFound, "Cannot find a resource matching #{key} (did you define it first?)"
+        end
+        res
+      end
+
+      # Find existing resources by searching the list of existing resources.  Possible
+      # forms are:
+      #
+      # find(:file => "foobar")
+      # find(:file => [ "foobar", "baz" ])
+      # find("file[foobar]", "file[baz]")
+      # find("file[foobar,baz]")
+      #
+      # Returns the matching resource, or an Array of matching resources.
+      #
+      # Raises an ArgumentError if you feed it bad lookup information
+      # Raises a Runtime Error if it can't find the resources you are looking for.
+      def find(*args)
+        results = Array.new
+        args.each do |arg|
+          case arg
+            when Hash
+              results << find_resource_by_hash(arg)
+            when String
+              results << find_resource_by_string(arg)
+            else
+              msg = "arguments to #{self.class.name}#find should be of the form :resource => 'name' or 'resource[name]'"
+              raise Chef::Exceptions::InvalidResourceSpecification, msg
+          end
+        end
+        flat_results = results.flatten
+        flat_results.length == 1 ? flat_results[0] : flat_results
+      end
+
+      # @deprecated
+      # resources is a poorly named, but we have to maintain it for back
+      # compat.
+      alias_method :resources, :find
+
+      # Returns true if +query_object+ is a valid string for looking up a
+      # resource, or raises InvalidResourceSpecification if not.
+      # === Arguments
+      # * query_object should be a string of the form
+      # "resource_type[resource_name]", a single element Hash (e.g., :service =>
+      # "apache2"), or a Chef::Resource (this is the happy path). Other arguments
+      # will raise an exception.
+      # === Returns
+      # * true returns true for all valid input.
+      # === Raises
+      # * Chef::Exceptions::InvalidResourceSpecification for all invalid input.
+      def validate_lookup_spec!(query_object)
+        case query_object
+          when Chef::Resource
+            true
+          when SINGLE_RESOURCE_MATCH, MULTIPLE_RESOURCE_MATCH, NAMELESS_RESOURCE_MATCH
+            true
+          when Hash
+            true
+          when String
+            raise Chef::Exceptions::InvalidResourceSpecification,
+                  "The string `#{query_object}' is not valid for resource collection lookup. Correct syntax is `resource_type[resource_name]'"
+          else
+            raise Chef::Exceptions::InvalidResourceSpecification,
+                  "The object `#{query_object.inspect}' is not valid for resource collection lookup. " +
+              "Use a String like `resource_type[resource_name]' or a Chef::Resource object"
+        end
+      end
+
+      def self.from_hash(o)
+        collection = new()
+        rl = o["instance_vars"]["@resources_by_key"]
+        resources = rl.merge(rl) { |k, r| Chef::Resource.from_hash(r) }
+        collection.instance_variable_set(:@resources_by_key, resources)
+        collection
+      end
+
+      private
+
+      def create_key(resource_type, instance_name)
+        "#{resource_type}[#{instance_name}]"
+      end
+
+      def find_resource_by_hash(arg)
+        results = Array.new
+        arg.each do |resource_type, name_list|
+          instance_names = name_list.kind_of?(Array) ? name_list : [ name_list ]
+          instance_names.each do |instance_name|
+            results << lookup(create_key(resource_type, instance_name))
+          end
+        end
+        results
+      end
+
+      def find_resource_by_string(arg)
+        begin
+          if arg =~ SINGLE_RESOURCE_MATCH
+            resource_type = $1
+            name = $2
+            return [ lookup(create_key(resource_type, name)) ]
+          end
+        rescue Chef::Exceptions::ResourceNotFound => e
+          if arg =~ MULTIPLE_RESOURCE_MATCH
+            begin
+              results = Array.new
+              resource_type = $1
+              arg =~ /^.+\[(.+)\]$/
+              resource_list = $1
+              resource_list.split(",").each do |instance_name|
+                results << lookup(create_key(resource_type, instance_name))
+              end
+              Chef.deprecated(:multiresource_match, "The resource_collection multi-resource syntax is deprecated")
+              return results
+            rescue  Chef::Exceptions::ResourceNotFound
+              raise e
+            end
+          else
+            raise e
+          end
+        end
+
+        if arg =~ NAMELESS_RESOURCE_MATCH
+          resource_type = $1
+          name = ""
+          return [ lookup(create_key(resource_type, name)) ]
+        end
+
+        raise ArgumentError, "Bad string format #{arg}, you must have a string like resource_type[name]!"
+      end
+    end
+  end
+end