poise 2.2.3 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5906280e0c3c8e0555e6a255dad854a6a68f2d11
-  data.tar.gz: 611ffdede3b4f1021e18d88299172aea3239890d
+  metadata.gz: 9346bbce570e141a731a72396f1d1ce0e6da5bae
+  data.tar.gz: 5a0d996080b83353b59eee2484b657613472d12c
 SHA512:
-  metadata.gz: 075e7d9b3aecce2cc748430ca9bca6e3a33b3db88aa63701fb42269b1254b4f2e7915843bbafb85c239729d1b2c23b6bc775db7bc297435b9555f7a77f31b2d3
-  data.tar.gz: f1aa2c2a67df267725169799a924df19f2f16f3927b2ec492b891886eff5aff00be251a5bbbe23d4421e146a902fe687ae936c17257a6ee469d7fecb2343b714
+  metadata.gz: f53889732b8ffe28dd15938fcb24d87686e4dfc984b3b44807fdbffe3412e0dce62263efa200faf3617f7bfe9beb4b6873a4121d2fbee92adf7477452110e735
+  data.tar.gz: d06c1b67c3bb6fd46edc21794cd1e28af06d89938e973da7dddeccf1f0eced60ef32295d14b78e6d927e4d8299dbdbdebd49b24c27308097746563b7b880ba32

data/.gitignore

@@ -1,4 +1,5 @@
 Gemfile.lock
+Berksfile.lock
 test/gemfiles/*.lock
 .kitchen/
 .kitchen.local.yml

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## v2.3.0
+
+* New helper: `ResourceSubclass`, a helper for subclassing a resource while
+  still using the providers as the base class.
+* New feature: Non-default containers. Use `container_default: false` to mark
+  a container class as ineligible for default lookup.
+* New feature: parent attribute defaults. You can set a `parent_default` to
+  provide a default value for the parent of a resource. This supports the
+  `lazy { }` helper as with normal default values.
+* New feature: use `forced_keys: [:name]` on an option collector property to
+  force keys that would otherwise be clobbered by resource methods.
+* Can enable verbose logging mode via a node attribute in addition to an
+  environment variable.
+
 ## v2.2.3
 
 * Add `ancestor_send` utility method for use in other helpers.

data/Gemfile

@@ -29,5 +29,3 @@ end
 
 dev_gem 'halite'
 dev_gem 'poise-boiler'
-
-gem 'kitchen-docker', github: 'portertech/kitchen-docker'

data/lib/poise.rb

@@ -22,7 +22,9 @@ require 'poise/utils/resource_provider_mixin'
 
 module Poise
   include Poise::Utils::ResourceProviderMixin
+  autoload :Backports, 'poise/backports'
   autoload :Helpers, 'poise/helpers'
+  autoload :NOT_PASSED, 'poise/backports/not_passed'
   autoload :Provider, 'poise/provider'
   autoload :Resource, 'poise/resource'
   autoload :Subcontext, 'poise/subcontext'
@@ -57,7 +59,7 @@ def Poise(options={})
     # Resource-specific options.
     if klass < Chef::Resource
       klass.poise_subresource(options[:parent], options[:parent_optional], options[:parent_auto]) if options[:parent]
-      klass.poise_subresource_container(options[:container_namespace]) if options[:container]
+      klass.poise_subresource_container(options[:container_namespace], options[:container_default]) if options[:container]
       klass.poise_fused if options[:fused]
       klass.poise_inversion(options[:inversion_options_resource]) if options[:inversion]
     end

data/lib/poise/backports.rb

@@ -0,0 +1,27 @@
+#
+# Copyright 2015, Noah Kantrowitz
+#
+# 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.
+#
+
+
+module Poise
+  # Backported features from Chef to be able to use them with older versions.
+  #
+  # @since 2.3.0
+  module Backports
+    autoload :NOT_PASSED, 'poise/backports/not_passed'
+  end
+
+  autoload :NOT_PASSED, 'poise/backports/not_passed'
+end

data/lib/poise/backports/not_passed.rb

@@ -0,0 +1,52 @@
+#
+# Copyright 2015, Noah Kantrowitz
+#
+# 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.
+#
+
+begin
+  require 'chef/constants'
+rescue LoadError
+  # This space left intentionally blank.
+end
+
+
+module Poise
+  module Backports
+    # A sentinel value for optional arguments where nil is a valid value.
+    # @since 2.3.0
+    # @!parse NOT_PASSED = Object.new
+    NOT_PASSED = if defined?(Chef::NOT_PASSED)
+       Chef::NOT_PASSED
+    else
+      # Copyright 2015, Chef Software Inc.
+      # Used under Apache License, Version 2.0.
+      Object.new.tap do |not_passed|
+        def not_passed.to_s
+          "NOT_PASSED"
+        end
+        def not_passed.inspect
+          to_s
+        end
+        not_passed.freeze
+      end
+    end
+
+  end
+
+  # An alias to {Backports::NOT_PASSED} to avoid typing so much.
+  #
+  # @since 2.3.0
+  # @see Backports::NOT_PASSED
+  NOT_PASSED = Backports::NOT_PASSED
+end

data/lib/poise/helpers.rb

@@ -28,6 +28,7 @@ module Poise
     autoload :OptionCollector, 'poise/helpers/option_collector'
     autoload :ResourceCloning, 'poise/helpers/resource_cloning'
     autoload :ResourceName, 'poise/helpers/resource_name'
+    autoload :ResourceSubclass, 'poise/helpers/resource_subclass'
     autoload :Subresources, 'poise/helpers/subresources'
     autoload :TemplateContent, 'poise/helpers/template_content'
   end

data/lib/poise/helpers/chefspec_matchers.rb

@@ -62,6 +62,10 @@ module Poise
         # @see Resource::ResourceName.provides
         def provides(name, *args, &block)
           ChefSpec.define_matcher(name) if defined?(ChefSpec)
+          # Call #actions here to grab any actions from a parent class.
+          actions.each do |action|
+            ChefspecMatchers.create_matcher(name, action)
+          end
           super(name, *args, &block)
         end
 
@@ -72,7 +76,7 @@ module Poise
           super.tap do |actions|
             actions.each do |action|
               ChefspecMatchers.create_matcher(resource_name, action)
-            end
+            end if resource_name
           end
         end
 

data/lib/poise/helpers/inversion.rb

@@ -19,6 +19,7 @@ require 'chef/node_map'
 require 'chef/provider'
 require 'chef/resource'
 
+require 'poise/backports'
 require 'poise/helpers/defined_in'
 require 'poise/error'
 require 'poise/helpers/inversion/options_resource'
@@ -117,6 +118,9 @@ module Poise
               define_singleton_method(:name) do
                 "#{enclosing_class}::OptionsResource"
               end
+              define_singleton_method(:inversion_resource_class) do
+                enclosing_class
+              end
               provides(options_resource_name)
               inversion_resource(name)
             end
@@ -126,6 +130,9 @@ module Poise
               define_singleton_method(:name) do
                 "#{enclosing_class}::OptionsProvider"
               end
+              define_singleton_method(:inversion_resource_class) do
+                enclosing_class
+              end
               provides(options_resource_name)
             end
           end
@@ -170,40 +177,48 @@ module Poise
         module ClassMethods
           # @overload inversion_resource()
           #   Return the inversion resource name for this class.
-          #   @return [Symbol]
+          #   @return [Symbo, nill]
           # @overload inversion_resource(val)
           #   Set the inversion resource name for this class. You can pass either
           #   a symbol in DSL format or a resource class that uses Poise. This
           #   name is used to determine which resources the inversion provider is
           #   a candidate for.
           #   @param val [Symbol, Class] Name to set.
-          #   @return [Symbol]
-          def inversion_resource(val=nil)
-            if val
+          #   @return [Symbol, nil]
+          def inversion_resource(val=Poise::NOT_PASSED)
+            if val != Poise::NOT_PASSED
               val = val.resource_name if val.is_a?(Class)
               Chef::Log.debug("[#{self.name}] Setting inversion resource to #{val}")
               @poise_inversion_resource = val.to_sym
             end
-            @poise_inversion_resource || (superclass.respond_to?(:inversion_resource) ? superclass.inversion_resource : nil)
+            if defined?(@poise_inversion_resource)
+              @poise_inversion_resource
+            else
+              Poise::Utils.ancestor_send(self, :inversion_resource, default: nil)
+            end
           end
 
           # @overload inversion_attribute()
           #   Return the inversion attribute name(s) for this class.
-          #   @return [Array<String>]
+          #   @return [Array<String>, nil]
           # @overload inversion_attribute(val)
           #   Set the inversion attribute name(s) for this class. This is
           #   used by {.resolve_inversion_attribute} to load configuration data
           #   from node attributes. To specify a nested attribute pass an array
           #   of strings corresponding to the keys.
           #   @param val [String, Array<String>] Attribute path.
-          #   @return [Array<String>]
-          def inversion_attribute(val=nil)
-            if val
+          #   @return [Array<String>, nil]
+          def inversion_attribute(val=Poise::NOT_PASSED)
+            if val != Poise::NOT_PASSED
               # Coerce to an array of strings.
               val = Array(val).map {|name| name.to_s }
               @poise_inversion_attribute = val
             end
-            @poise_inversion_attribute || (superclass.respond_to?(:inversion_attribute) ? superclass.inversion_attribute : nil)
+            if defined?(@poise_inversion_attribute)
+              @poise_inversion_attribute
+            else
+              Poise::Utils.ancestor_send(self, :inversion_attribute, default: nil)
+            end
           end
 
           # Default attribute paths to check for inversion options. Based on
@@ -235,6 +250,7 @@ module Poise
           def resolve_inversion_attribute(node)
             # Default to using just the name of the cookbook.
             attribute_names = inversion_attribute || default_inversion_attributes(node)
+            return {} if attribute_names.empty?
             attribute_names.inject(node) do |memo, key|
               memo[key] || begin
                 raise Poise::Error.new("Attribute #{key} not set when expanding inversion attribute for #{self.name}: #{memo}")
@@ -257,13 +273,13 @@ module Poise
               # Class-level defaults.
               opts.update(default_inversion_options(node, resource))
               # Resource options for all providers.
-              opts.update(resource.options)
+              opts.update(resource.options) if resource.respond_to?(:options)
               # Global provider from node attributes.
               opts.update(provider: attrs['provider']) if attrs['provider']
               # Attribute options for all providers.
               opts.update(attrs['options']) if attrs['options']
               # Resource options for this provider.
-              opts.update(resource.options(provides))
+              opts.update(resource.options(provides)) if resource.respond_to?(:options)
               # Attribute options for this resource name.
               opts.update(attrs[resource.name]) if attrs[resource.name]
               # Options resource options for all providers.
@@ -323,7 +339,14 @@ module Poise
           # @return [Boolean]
           def provides?(node, resource)
             raise Poise::Error.new("Inversion resource name not set for #{self.name}") unless inversion_resource
-            return false unless resource.resource_name == inversion_resource
+            resource_name_equivalents = {resource.resource_name => true}
+            # If subclass_providers! might be in play, check for those names too.
+            if resource.class.respond_to?(:subclass_resource_equivalents)
+              resource.class.subclass_resource_equivalents.each do |name|
+                resource_name_equivalents[name] = true
+              end
+            end
+            return false unless resource_name_equivalents[inversion_resource]
             provider_name = resolve_inversion_provider(node, resource)
             Chef::Log.debug("[#{resource}] Checking provides? on #{self.name}. Got provider_name #{provider_name.inspect}")
             provider_name == provides.to_s || ( provider_name == 'auto' && provides_auto?(node, resource) )

data/lib/poise/helpers/option_collector.rb

@@ -44,18 +44,25 @@ module Poise
       class OptionEvalContext
         attr_reader :_options
 
-        def initialize(parent)
+        def initialize(parent, forced_keys)
           @parent = parent
+          @forced_keys = forced_keys
           @_options = {}
         end
 
         def method_missing(method_sym, *args, &block)
+          # Deal with forced keys.
+          if @forced_keys.include?(method_sym)
+            @_options[method_sym] = args.first || block if !args.empty? || block
+            return @_options[method_sym]
+          end
+          # Try the resource context.
           @parent.send(method_sym, *args, &block)
         rescue NameError
           # Even though method= in the block will set a variable instead of
           # calling method_missing, still try to cope in case of self.method=.
           method_sym = method_sym.to_s.chomp('=').to_sym
-          if args.length > 0 || block
+          if !args.empty? || block
             @_options[method_sym] = args.first || block
           elsif !@_options.include?(method_sym)
             # We haven't seen this name before, re-raise the NameError.
@@ -86,8 +93,12 @@ module Poise
         # @param parser [Proc, Symbol] Optional parser method. If a symbol it is
         #   called as a method on self. Takes a non-hash value and returns a
         #   hash of its parsed representation.
-        def option_collector_attribute(name, default: {}, parser: nil)
+        # @param forced_keys [Array<Symbol>, Set<Symbol>] Method names that will be forced
+        #   to be options rather than calls to the parent resource.
+        def option_collector_attribute(name, default: {}, parser: nil, forced_keys: Set.new)
           raise Poise::Error.new("Parser must be a Proc or Symbol: #{parser.inspect}") if parser && !(parser.is_a?(Proc) || parser.is_a?(Symbol))
+          # Cast to a set at definition time.
+          forced_keys = Set.new(forced_keys) unless forced_keys.is_a?(Set)
           # Unlike LWRPBase.attribute, I don't care about Ruby 1.8. Worlds tiniest violin.
           define_method(name.to_sym) do |arg=nil, &block|
             iv_sym = :"@#{name}"
@@ -110,7 +121,7 @@ module Poise
               value.update(arg)
             end
             if block
-              ctx = OptionEvalContext.new(self)
+              ctx = OptionEvalContext.new(self, forced_keys)
               ctx.instance_exec(&block)
               value.update(ctx._options)
             end

data/lib/poise/helpers/resource_name.rb

@@ -61,7 +61,7 @@ module Poise
             end
           end
           # Store the name for later.
-          @provides_name = name
+          @provides_name ||= name
           # Call the original if present. The defined? is for old Chef.
           super(name, *args, &block) if defined?(super)
         end

data/lib/poise/helpers/resource_subclass.rb

@@ -0,0 +1,81 @@
+#
+# Copyright 2015, Noah Kantrowitz
+#
+# 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 'poise/error'
+require 'poise/helpers/resource_name'
+
+
+module Poise
+  module Helpers
+    # A resource mixin to help subclass existing resources.
+    #
+    # @since 2.3.0
+    module ResourceSubclass
+      include ResourceName
+
+      module ClassMethods
+        def subclass_providers!(superclass_resource_name=nil)
+          resource_name = self.resource_name
+          superclass_resource_name ||= if superclass.respond_to?(:resource_name)
+            superclass.resource_name
+          elsif superclass.respond_to?(:dsl_name)
+            superclass.dsl_name
+          else
+            raise Poise::Error.new("Unable to determine superclass resource name for #{superclass}. Please specify name manually via subclass_providers!('name').")
+          end.to_sym
+          # Deal with the node maps.
+          node_maps = {}
+          node_maps['handler map'] = Chef.provider_handler_map if defined?(Chef.provider_handler_map)
+          node_maps['priority map'] = Chef.provider_priority_map if defined?(Chef.provider_priority_map)
+          # Patch anything in the descendants tracker.
+          Chef::Provider.descendants.each do |provider|
+            node_maps["#{provider} node map"] = provider.node_map if defined?(provider.node_map)
+          end if defined?(Chef::Provider.descendants)
+          node_maps.each do |map_name, node_map|
+            map = node_map.respond_to?(:map, true) ? node_map.send(:map) : node_map.instance_variable_get(:@map)
+            if map.include?(superclass_resource_name)
+              Chef::Log.debug("[#{self}] Copying provider mapping in #{map_name} from #{superclass_resource_name} to #{resource_name}")
+              map[resource_name] = map[superclass_resource_name].dup
+            end
+          end
+          # Add any needed equivalent names.
+          if superclass.respond_to?(:subclass_resource_equivalents)
+            subclass_resource_equivalents.concat(superclass.subclass_resource_equivalents)
+          else
+            subclass_resource_equivalents << superclass_resource_name
+          end
+        end
+
+        # An array of names for the resources this class is equivalent to for
+        # the purposes of provider resolution.
+        #
+        # @return [Array<Symbol>]
+        def subclass_resource_equivalents
+          @subclass_resource_names ||= [resource_name.to_sym]
+        end
+
+        # @api private
+        def included(klass)
+          super
+          klass.extend(ClassMethods)
+        end
+      end
+
+      extend ClassMethods
+    end
+
+  end
+end

data/lib/poise/helpers/subresources/child.rb

@@ -61,7 +61,7 @@ module Poise
           if self.class.parent_type == true
             raise NoMethodError.new("undefined method `parent' for #{self}")
           end
-          _parent(:parent, self.class.parent_type, self.class.parent_optional, self.class.parent_auto, *args)
+          _parent(:parent, self.class.parent_type, self.class.parent_optional, self.class.parent_auto, self.class.parent_default, *args)
         end
 
         # Register ourself with parents in case this is not a nested resource.
@@ -71,7 +71,7 @@ module Poise
           super
           self.class.parent_attributes.each_key do |name|
             parent = self.send(name)
-            parent.register_subresource(self) if parent
+            parent.register_subresource(self) if parent && parent.respond_to?(:register_subresource)
           end
         end
 
@@ -81,7 +81,7 @@ module Poise
         #
         # @since 2.0.0
         # @see #parent
-        def _parent(name, parent_type, parent_optional, parent_auto, *args)
+        def _parent(name, parent_type, parent_optional, parent_auto, parent_default, *args)
           # Allow using a DSL symbol as the parent type.
           if parent_type.is_a?(Symbol)
             parent_type = Chef::Resource.resource_for_node(parent_type, node)
@@ -96,7 +96,18 @@ module Poise
             else
               if val.is_a?(String) && !val.include?('[')
                 raise Poise::Error.new("Cannot use a string #{name} without defining a parent type") if parent_type == Chef::Resource
-                val = "#{parent_type.resource_name}[#{val}]"
+                # Try to find the most recent instance of parent_type with a
+                # matching name. This takes subclassing parent_type into account.
+                found_val = nil
+                iterator = run_context.resource_collection.respond_to?(:recursive_each) ? :recursive_each : :each
+                # This will find the last matching value due to overwriting
+                # found_val as it goes. Will be the nearest match.
+                run_context.resource_collection.public_send(iterator) do |res|
+                  found_val = res if res.is_a?(parent_type) && res.name == val
+                end
+                # If found_val is nil, fall back to using lookup even though
+                # it won't work with subclassing, better than nothing?
+                val = found_val || "#{parent_type.resource_name}[#{val}]"
               end
               if val.is_a?(String) || val.is_a?(Hash)
                 parent = @run_context.resource_collection.find(val)
@@ -109,7 +120,14 @@ module Poise
             end
             parent_ref = ParentRef.new(parent)
           elsif !parent_ref || !parent_ref.resource
-            if parent_auto
+            if parent_default
+              parent = if parent_default.is_a?(Chef::DelayedEvaluator)
+                instance_eval(&parent_default)
+              else
+                parent_default
+              end
+            end
+            if !parent && parent_auto
               # Automatic sibling lookup for sequential composition.
               # Find the last instance of the parent class as the default parent.
               # This is super flaky and should only be a last resort.
@@ -121,6 +139,7 @@ module Poise
           else
             parent = parent_ref.resource
           end
+          raise Poise::Error.new("Cannot set the #{name} of #{self} to itself") if parent.equal?(self)
           # Store the ivar back.
           instance_variable_set(:"@#{name}", parent_ref)
           # Return the actual resource.
@@ -141,7 +160,9 @@ module Poise
               # Setting to true shouldn't actually do anything if a type was already set.
               @parent_type = type unless type == true && !@parent_type.nil?
             end
-            @parent_type || Poise::Utils.ancestor_send(self, :parent_type, default: Chef::Resource)
+            # First ancestor_send looks for a non-true && non-default value,
+            # second one is to check for default vs true if no real value is found.
+            @parent_type || Poise::Utils.ancestor_send(self, :parent_type, ignore: [Chef::Resource, true]) || Poise::Utils.ancestor_send(self, :parent_type, default: Chef::Resource)
           end
 
           # @overload parent_optional()
@@ -180,6 +201,26 @@ module Poise
             end
           end
 
+          # @overload parent_default()
+          #   Get the default value for the default parent link on this resource.
+          #   @since 2.3.0
+          #   @return [Object, Chef::DelayedEvaluator]
+          # @overload parent_default(val)
+          #   Set the default value for the default parent link on this resource.
+          #   @since 2.3.0
+          #   @param val [Object, Chef::DelayedEvaluator] Default value to set.
+          #   @return [Object, Chef::DelayedEvaluator]
+          def parent_default(*args)
+            unless args.empty?
+              @parent_default = args.first
+            end
+            if defined?(@parent_default)
+              @parent_default
+            else
+              Poise::Utils.ancestor_send(self, :parent_default)
+            end
+          end
+
           # Create a new kind of parent link.
           #
           # @since 2.0.0
@@ -189,11 +230,11 @@ module Poise
           # @param optional [Boolean] If the parent is optional.
           # @param auto [Boolean] If the parent is auto-detected.
           # @return [void]
-          def parent_attribute(name, type: Chef::Resource, optional: false, auto: true)
+          def parent_attribute(name, type: Chef::Resource, optional: false, auto: true, default: nil)
             name = :"parent_#{name}"
             (@parent_attributes ||= {})[name] = type
             define_method(name) do |*args|
-              _parent(name, type, optional, auto, *args)
+              _parent(name, type, optional, auto, default, *args)
             end
           end
 
@@ -204,7 +245,7 @@ module Poise
           def parent_attributes
             {}.tap do |attrs|
               # Grab superclass's attributes if possible.
-              attrs.update(superclass.parent_attributes) if superclass.respond_to?(:parent_attributes)
+              attrs.update(Poise::Utils.ancestor_send(self, :parent_attributes, default: {}))
               # Local default parent.
               attrs[:parent] = parent_type
               # Extra locally defined parents.