poise 2.2.3 → 2.3.0

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

@@ -48,8 +48,9 @@ module Poise
 
         def after_created
           super
-          # Register
-          Poise::Helpers::Subresources::DefaultContainers.register!(self, run_context)
+          # Register as a default container if needed.
+          Poise::Helpers::Subresources::DefaultContainers.register!(self, run_context) if self.class.container_default
+          # Add all internal subresources to the resource collection.
           unless @subresources.empty?
             Chef::Log.debug("[#{self}] Adding subresources to collection:")
             # Because after_create is run before adding the container to the resource collection
@@ -113,8 +114,13 @@ module Poise
             end
             resource << super(type, sub_name, created_at) do
               # Apply the correct parent before anything else so it is available
-              # in after_created for the subresource.
-              parent(self_) if respond_to?(:parent)
+              # in after_created for the subresource. It might raise
+              # NoMethodError is there isn't a real parent.
+              begin
+                parent(self_) if respond_to?(:parent)
+              rescue NoMethodError
+                # This space left intentionally blank.
+              end
               # Run the resource block.
               instance_exec(&block) if block
             end
@@ -147,13 +153,34 @@ module Poise
           def container_namespace(val=nil)
             @container_namespace = val unless val.nil?
             if @container_namespace.nil?
-              # Not set here, look at the superclass of true by default for backwards compat.
-              superclass.respond_to?(:container_namespace) ? superclass.container_namespace : true
+              # Not set here, look at the superclass or true by default for backwards compat.
+              Poise::Utils.ancestor_send(self, :container_namespace, default: true)
             else
               @container_namespace
             end
           end
 
+          # @overload container_default()
+          #   Get the default mode for this resource. If false, this resource
+          #   class will not be used for default container lookups. Defaults to
+          #   true.
+          #   @since 2.3.0
+          #   @return [Boolean]
+          # @overload container_default(val)
+          #   Set the default mode for this resource.
+          #   @since 2.3.0
+          #   @param val [Boolean] Default mode to set.
+          #   @return [Boolean]
+          def container_default(val=nil)
+            @container_default = val unless val.nil?
+            if @container_default.nil?
+              # Not set here, look at the superclass or true by default for backwards compat.
+              Poise::Utils.ancestor_send(self, :container_default, default: true)
+            else
+              @container_default
+            end
+          end
+
           def included(klass)
             super
             klass.extend(ClassMethods)

data/lib/poise/resource.rb

@@ -39,14 +39,16 @@ module Poise
     include Poise::Helpers::OptionCollector
     include Poise::Helpers::ResourceCloning
     include Poise::Helpers::ResourceName
+    include Poise::Helpers::ResourceSubclass
     include Poise::Helpers::TemplateContent
 
     # @!classmethods
     module ClassMethods
-      def poise_subresource_container(namespace=nil)
+      def poise_subresource_container(namespace=nil, default=nil)
         include Poise::Helpers::Subresources::Container
         # false is a valid value.
         container_namespace(namespace) unless namespace.nil?
+        container_default(default) unless default.nil?
       end
 
       def poise_subresource(parent_type=nil, parent_optional=nil, parent_auto=nil)

data/lib/poise/subcontext/resource_collection.rb

@@ -40,7 +40,10 @@ module Poise
         @parent.lookup(resource)
       end
 
-      # Iterate and expand all nested contexts
+      # Iterate over all resources, expanding parent context in order.
+      #
+      # @param block [Proc] Iteration block
+      # @return [void]
       def recursive_each(&block)
         if @parent
           if @parent.respond_to?(:recursive_each)
@@ -51,6 +54,22 @@ module Poise
         end
         each(&block)
       end
+
+      # Iterate over all resources in reverse order.
+      #
+      # @since 2.3.0
+      # @param block [Proc] Iteration block
+      # @return [void]
+      def reverse_recursive_each(&block)
+        reverse_each(&block)
+        if @parent
+          if @parent.respond_to?(:recursive_each)
+            @parent.reverse_recursive_each(&block)
+          else
+            @parent.reverse_each(&block)
+          end
+        end
+      end
     end
   end
 end

data/lib/poise/utils.rb

@@ -43,7 +43,6 @@ module Poise
         if ver.respond_to?(:halite_root)
           # The join is there because ../poise-ruby/lib starts with ../poise so
           # we want a trailing /.
-          Chef::Log.debug("")
           if filename.start_with?(File.join(ver.halite_root, ''))
             Chef::Log.debug("[Poise] Found matching halite_root in #{name}: #{ver.halite_root.inspect}")
             possibles[ver.halite_root] = name
@@ -53,7 +52,7 @@ module Poise
             ver.segment_filenames(seg).each do |file|
               # Put this behind an environment variable because it is verbose
               # even for normal debugging-level output.
-              Chef::Log.debug("[Poise] Checking #{seg} in #{name}: #{file.inspect}") if ENV['POISE_DEBUG']
+              Chef::Log.debug("[Poise] Checking #{seg} in #{name}: #{file.inspect}") if ENV['POISE_DEBUG'] || run_context.node['POISE_DEBUG']
               if file == filename
                 Chef::Log.debug("[Poise] Found matching #{seg} in #{name}: #{file.inspect}")
                 possibles[file] = name
@@ -70,14 +69,17 @@ module Poise
     # Try to find an ancestor to call a method on.
     #
     # @since 2.2.3
+    # @since 2.3.0
+    #   Added ignore parameter.
     # @param obj [Object] Self from the caller.
     # @param msg [Symbol] Method to try to call.
     # @param args [Array<Object>] Method arguments.
     # @param default [Object] Default return value if no valid ancestor exists.
+    # @param ignore [Array<Object>] Return value to ignore when scanning ancesors.
     # @return [Object]
     # @example
     #   val = @val || Poise::Utils.ancestor_send(self, :val)
-    def ancestor_send(obj, msg, *args, default: nil)
+    def ancestor_send(obj, msg, *args, default: nil, ignore: [default])
       # Class is a subclass of Module, if we get something else use its class.
       obj = obj.class unless obj.is_a?(Module)
       ancestors = []
@@ -87,11 +89,81 @@ module Poise
       end
       # Make sure we don't check obj itself.
       ancestors.concat(obj.ancestors.drop(1))
-      ancestor = ancestors.find {|mod| mod.respond_to?(msg) }
-      if ancestor
-        ancestor.send(msg, *args)
+      ancestors.each do |mod|
+        if mod.respond_to?(msg)
+          val = mod.send(msg, *args)
+          # If we get the default back, assume we should keep trying.
+          return val unless ignore.include?(val)
+        end
+      end
+      # Nothing valid found, use the default.
+      default
+    end
+
+    # Create a helper to invoke a module with some parameters.
+    #
+    # @since 2.3.0
+    # @param mod [Module] The module to wrap.
+    # @param block [Proc] The module to implement to parameterization.
+    # @return [void]
+    # @example
+    #   module MyMixin
+    #     def self.my_mixin_name(name)
+    #       # ...
+    #     end
+    #   end
+    #
+    #   Poise::Utils.parameterized_module(MyMixin) do |name|
+    #     my_mixin_name(name)
+    #   end
+    def parameterized_module(mod, &block)
+      raise Poise::Error.new("Cannot parameterize an anonymous module") unless mod.name && !mod.name.empty?
+      parent_name_parts = mod.name.split(/::/)
+      # Grab the last piece which will be the method name.
+      mod_name = parent_name_parts.pop
+      # Find the enclosing module or class object.
+      parent = parent_name_parts.inject(Object) {|memo, name| memo.const_get(name) }
+      # Object is a special case since we need #define_method instead.
+      method_type = if parent == Object
+        :define_method
       else
-        default
+        :define_singleton_method
+      end
+      # Scoping hack.
+      self_ = self
+      # Construct the method.
+      parent.send(method_type, mod_name) do |*args|
+        self_.send(:check_block_arity!, block, args)
+        # Create a new anonymous module to be returned from the method.
+        Module.new do
+          # Fake the name.
+          define_singleton_method(:name) do
+            super() || mod.name
+          end
+
+          # When the stub module gets included, activate our behaviors.
+          define_singleton_method(:included) do |klass|
+            super(klass)
+            klass.send(:include, mod)
+            klass.instance_exec(*args, &block)
+          end
+        end
+      end
+    end
+
+    private
+
+    # Check that the given arguments match the given block. This is needed
+    # because Ruby will nil-pad mismatched argspecs on blocks rather than error.
+    #
+    # @since 2.3.0
+    # @param block [Proc] Block to check.
+    # @param args [Array<Object>] Arguments to check.
+    # @return [void]
+    def check_block_arity!(block, args)
+      required_args = block.arity < 0 ? ~block.arity : block.arity
+      if args.length < required_args || (block.arity >= 0 && args.length > block.arity)
+        raise ArgumentError.new("wrong number of arguments (#{args.length} for #{required_args}#{block.arity < 0 ? '+' : ''})")
       end
     end
 

data/lib/poise/utils/resource_provider_mixin.rb

@@ -48,10 +48,10 @@ module Poise
             # Cargo this .included to things which include us.
             inner_klass.extend(mod)
             # Dispatch to submodules, inner_klass is the most recent includer.
-            if inner_klass < Chef::Resource
+            if inner_klass < Chef::Resource || inner_klass.name.to_s.end_with?('::Resource')
               # Use klass::Resource to look up relative to the original module.
               inner_klass.class_exec { include klass::Resource }
-            elsif inner_klass < Chef::Provider
+            elsif inner_klass < Chef::Provider || inner_klass.name.to_s.end_with?('::Provider')
               # As above, klass::Provider.
               inner_klass.class_exec { include klass::Provider }
             end

data/lib/poise/version.rb

@@ -16,5 +16,5 @@
 
 
 module Poise
-  VERSION = '2.2.3'
+  VERSION = '2.3.0'
 end

data/test/spec/backports/not_passed_spec.rb

@@ -0,0 +1,29 @@
+#
+# 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 'spec_helper'
+
+describe Poise::Backports::NOT_PASSED do
+  it { is_expected.to be_truthy }
+  its(:to_s) { is_expected.to eq 'NOT_PASSED' }
+  its(:inspect) { is_expected.to eq 'NOT_PASSED' }
+end
+
+describe Poise::NOT_PASSED do
+  it { is_expected.to be_truthy }
+  its(:to_s) { is_expected.to eq 'NOT_PASSED' }
+  its(:inspect) { is_expected.to eq 'NOT_PASSED' }
+end

data/test/spec/helpers/chefspec_matchers_spec.rb

@@ -42,4 +42,21 @@ describe Poise::Helpers::ChefspecMatchers do
     it { is_expected.to run_poise_other('test') }
     it { expect(chef_run.poise_other('test')).to be_a Chef::Resource }
   end # /context with an explicit name
+
+  context 'with a subclass' do
+    resource(:poise_test, auto: false, step_into: false) do
+      include described_class
+      provides(:poise_other)
+      actions(:run)
+    end
+    resource(:poise_sub, parent: :poise_test, auto: false, step_into: false) do
+      provides(:poise_sub)
+    end
+    recipe do
+      poise_sub 'test'
+    end
+
+    it { is_expected.to run_poise_sub('test') }
+    it { expect(chef_run.poise_sub('test')).to be_a Chef::Resource }
+  end # /context with a subclass
 end

data/test/spec/helpers/inversion_spec.rb

@@ -269,5 +269,77 @@ describe Poise::Helpers::Inversion do
         end
       end # /context with a provider
     end # /describe .resolve_inversion_provider
+
+    describe 'provider resolution' do
+      before do
+        default_attributes['poise'] ||= {}
+        default_attributes['poise']['provider'] = 'auto'
+      end
+      resource(:poise_test_inversion, step_into: false) do
+        include Poise
+        provides(:poise_test_inversion)
+      end
+      provider(:poise_test_inversion) do
+        include described_class
+        inversion_resource(:poise_test_inversion)
+        inversion_attribute([])
+        provides(:inverted)
+        def self.provides_auto?(*args); true; end
+      end
+      provider(:poise_test_inversion_other, parent: :poise_test_inversion) do
+        provides(:other)
+      end
+      let(:test_resource) { nil }
+      subject { Chef::ProviderResolver.new(chef_run.node, test_resource, :run) }
+
+      context 'with an inversion resource' do
+        recipe(subject: false) do
+          poise_test_inversion 'test'
+        end
+        let(:test_resource) { chef_run.poise_test_inversion('test') }
+
+        its(:enabled_handlers) { is_expected.to eq [provider(:poise_test_inversion), provider(:poise_test_inversion_other)] }
+        its(:resolve) { is_expected.to eq provider(:poise_test_inversion) }
+      end # /context with an inversion resource
+
+      context 'with a resource that has no providers' do
+        resource(:poise_not_found, step_into: false)
+        recipe(subject: false) do
+          poise_not_found 'test'
+        end
+        let(:test_resource) { chef_run.find_resource(:poise_not_found, 'test') }
+
+        its(:enabled_handlers) { is_expected.to eq [] }
+        it { expect { subject.resolve }.to raise_error defined?(Chef::Exceptions::ProviderNotFound) ? Chef::Exceptions::ProviderNotFound : ArgumentError }
+      end # /context with a resource that has no providers
+
+      context 'with a subclassed resource' do
+        resource(:poise_inversion_sub, parent: :poise_test_inversion, step_into: false) do
+          provides(:poise_inversion_sub)
+        end
+        recipe(subject: false) do
+          poise_inversion_sub 'test'
+        end
+        let(:test_resource) { chef_run.find_resource(:poise_inversion_sub, 'test') }
+
+        its(:enabled_handlers) { is_expected.to eq [] }
+        it { expect { subject.resolve }.to raise_error defined?(Chef::Exceptions::ProviderNotFound) ? Chef::Exceptions::ProviderNotFound : ArgumentError }
+      end # /context with a subclassed resource
+
+      context 'with a subclassed resource using subclass_providers!' do
+        resource(:poise_inversion_subproviders, parent: :poise_test_inversion, step_into: false) do
+          include Poise::Helpers::ResourceSubclass
+          provides(:poise_inversion_subproviders)
+          subclass_providers!
+        end
+        recipe(subject: false) do
+          poise_inversion_subproviders 'test'
+        end
+        let(:test_resource) { chef_run.find_resource(:poise_inversion_subproviders, 'test') }
+
+        its(:enabled_handlers) { is_expected.to eq [provider(:poise_test_inversion), provider(:poise_test_inversion_other)] }
+        its(:resolve) { is_expected.to eq provider(:poise_test_inversion) }
+      end # /context with a subclassed resource using subclass_providers!
+    end # /describe provider resolution
   end # /describe Poise::Helpers::Inversion::Provider
 end

data/test/spec/helpers/lwrp_polyfill_spec.rb

@@ -140,6 +140,15 @@ describe Poise::Helpers::LWRPPolyfill do
 
         it { is_expected.to eq 'helper' }
       end # /context with an intermediary class
+
+      context 'with no new_resource' do
+        provider(:poise_test, auto: false) do
+          include described_class
+        end
+        subject { provider(:poise_test).new(nil, nil).load_current_resource }
+        it { is_expected.to be_a Chef::Resource }
+        it { is_expected.to_not be_a resource(:poise_test) }
+      end # context with no new_resource
     end # /describe load_current_resource override
 
     describe 'Chef::DSL::Recipe include' do

data/test/spec/helpers/option_collector_spec.rb

@@ -78,49 +78,85 @@ describe Poise::Helpers::OptionCollector do
     it { is_expected.to run_poise_test('test').with(options: {'one' => '1'}, value: 2) }
   end # /context with a normal attribute too
 
-  context 'with a parser Proc' do
-    resource(:poise_test) do
-      include Poise::Helpers::LWRPPolyfill
-      include described_class
-      attribute(:options, option_collector: true, parser: proc {|val| parse(val) })
-      def parse(val)
-        {name: val}
-      end
-    end
+  context 'with an invalid key' do
     recipe do
       poise_test 'test' do
-        options '1'
+        options do
+          one two
+        end
       end
     end
 
-    it { is_expected.to run_poise_test('test').with(options: {'name' => '1'}) }
-  end # /context with a parser Proc
+    it { expect { subject }.to raise_error NoMethodError }
+  end # /context with an invalid key
+
+  describe 'parser' do
+    context 'with a parser Proc' do
+      resource(:poise_test) do
+        include Poise::Helpers::LWRPPolyfill
+        include described_class
+        attribute(:options, option_collector: true, parser: proc {|val| parse(val) })
+        def parse(val)
+          {name: val}
+        end
+      end
+      recipe do
+        poise_test 'test' do
+          options '1'
+        end
+      end
 
-  context 'with a parser Symbol' do
-    resource(:poise_test) do
-      include Poise::Helpers::LWRPPolyfill
-      include described_class
-      attribute(:options, option_collector: true, parser: :parse)
-      def parse(val)
-        {name: val}
+      it { is_expected.to run_poise_test('test').with(options: {'name' => '1'}) }
+    end # /context with a parser Proc
+
+    context 'with a parser Symbol' do
+      resource(:poise_test) do
+        include Poise::Helpers::LWRPPolyfill
+        include described_class
+        attribute(:options, option_collector: true, parser: :parse)
+        def parse(val)
+          {name: val}
+        end
       end
-    end
+      recipe do
+        poise_test 'test' do
+          options '1'
+        end
+      end
+
+      it { is_expected.to run_poise_test('test').with(options: {'name' => '1'}) }
+    end # /context with a parser Symbol
+
+    context 'with an invalid parser' do
+      it do
+        expect do
+          resource(:poise_test).send(:attribute, :options, option_collector: true, parser: 'invalid')
+        end.to raise_error(Poise::Error)
+      end
+    end # /context with an invalid parser
+  end # /describe parser
+
+  describe 'forced_keys' do
     recipe do
       poise_test 'test' do
-        options '1'
+        options do
+          name 'foo'
+        end
       end
     end
 
-    it { is_expected.to run_poise_test('test').with(options: {'name' => '1'}) }
-  end # /context with a parser Symbol
+    context 'without forced_keys' do
+      it { is_expected.to run_poise_test('test').with(options: {}) }
+    end # /context without forced_keys
 
-  context 'with an invalid parse' do
-    it do
-      expect do
-        resource(:poise_test).send(:attribute, :options, option_collector: true, parser: 'invalid')
-      end.to raise_error(Poise::Error)
-    end
-  end # /context with an invalid parser
+    context 'with forced_keys' do
+      resource(:poise_test) do
+        include described_class
+        attribute(:options, option_collector: true, forced_keys: %i{name})
+      end
+      it { is_expected.to run_poise_test('test').with(options: {'name' => 'foo'}) }
+    end # /context with forced_keys
+  end # /describe forced_keys
 
   # TODO: Write tests for mixed symbol/string data
 end