chef 12.4.0.rc.0-universal-mingw32 → 12.4.0.rc.2-universal-mingw32

data/lib/chef/provider/service/init.rb

@@ -18,6 +18,7 @@
 
 require 'chef/provider/service/simple'
 require 'chef/mixin/command'
+require 'chef/platform/service_helpers'
 
 class Chef
   class Provider

data/lib/chef/provider/service/macosx.rb

@@ -28,8 +28,8 @@ class Chef
     class Service
       class Macosx < Chef::Provider::Service::Simple
 
-        provides :service, os: "darwin"
         provides :macosx_service, os: "darwin"
+        provides :service, os: "darwin"
 
         def self.gather_plist_dirs
           locations = %w{/Library/LaunchAgents

data/lib/chef/provider/service/windows.rb

@@ -25,7 +25,6 @@ if RUBY_PLATFORM =~ /mswin|mingw32|windows/
 end
 
 class Chef::Provider::Service::Windows < Chef::Provider::Service
-
   provides :service, os: "windows"
   provides :windows_service, os: "windows"
 

data/lib/chef/provider/user.rb

@@ -23,6 +23,7 @@ require 'etc'
 class Chef
   class Provider
     class User < Chef::Provider
+      provides :user
 
       include Chef::Mixin::Command
 
@@ -208,7 +209,6 @@ class Chef
       def unlock_user
         raise NotImplementedError
       end
-
     end
   end
 end

data/lib/chef/provider/user/aix.rb

@@ -18,9 +18,10 @@ class Chef
   class Provider
     class User
       class Aix < Chef::Provider::User::Useradd
+        provides :user, platform: %w(aix)
 
         UNIVERSAL_OPTIONS = [[:comment, "-c"], [:gid, "-g"], [:shell, "-s"], [:uid, "-u"]]
-        
+
         def create_user
           super
           add_password
@@ -88,7 +89,7 @@ class Chef
             end
           end
         end
-          
+
       end
     end
   end

data/lib/chef/provider/user/pw.rb

@@ -22,6 +22,7 @@ class Chef
   class Provider
     class User
       class Pw < Chef::Provider::User
+        provides :user, platform: %w(freebsd)
 
         def load_current_resource
           super

data/lib/chef/provider/user/solaris.rb

@@ -22,6 +22,8 @@ class Chef
   class Provider
     class User
       class Solaris < Chef::Provider::User::Useradd
+        provides :user, platform: %w(omnios solaris2)
+
         UNIVERSAL_OPTIONS = [[:comment, "-c"], [:gid, "-g"], [:shell, "-s"], [:uid, "-u"]]
 
         attr_writer :password_file

data/lib/chef/provider/user/useradd.rb

@@ -23,6 +23,7 @@ class Chef
   class Provider
     class User
       class Useradd < Chef::Provider::User
+        provides :user
 
         UNIVERSAL_OPTIONS = [[:comment, "-c"], [:gid, "-g"], [:password, "-p"], [:shell, "-s"], [:uid, "-u"]]
 

data/lib/chef/provider_resolver.rb

@@ -24,88 +24,25 @@ class Chef
   # Provider Resolution
   # ===================
   #
-  # When you type `service 'myservice' { action :restart }` in a recipe, a whole
-  # string of events happens eventually leading to convergence.  The overview of
-  # that process is described in `Chef::DSL::Recipe`.  Provider resolution is
-  # the process of taking a Resource object and an action, and determining the
-  # Provider class that should be instantiated to handle the action.
+  # Provider resolution is the process of taking a Resource object and an
+  # action, and determining the Provider class that should be instantiated to
+  # handle the action.
   #
-  # The process happens in three steps:
-  #
-  # Explicit Provider on the Resource
-  # ---------------------------------
   # If the resource has its `provider` set, that is used.
   #
-  # Dynamic Provider Matches
-  # ------------------------
-  # In this stage, we call `provides?` to see if the Provider supports the
-  # resource on this platform, and then we call `supports?` to determine if it
-  # can handle the action.  It's a little more complicated than that, though:
-  #
-  # ### Provider.provides?
-  #
-  # First, we go through all known provider classes (all descendants of
-  # `Chef::Provider`), and call `provides?(node, resource)` to determine if it
-  # supports this action for this resource on this OS.  We get a list of all
-  # matches.
-  #
-  # #### Defining provides
-  #
-  # The typical way of getting `provides?` is for the Provider class to call
-  # `provides :name`.
-  #
-  # The Provider may pass the OS, platform family, platform, and platform version
-  # to `provides`, and they will be matched against the values in the `node`
-  # object.  The Provider may also pass a block, which allows for custom logic
-  # to decide whether it provides the resource or not.
-  #
-  # Some Providers also override `provides?` with custom logic.
-  #
-  # ### Provider.supports?
-  #
-  # Once we have the list of willing providers, we filter it by calling their
-  # `supports?(resource, action)` method to see if they support the specific
-  # action (`:create`, `:delete`) or not.
-  #
-  # If no provider supports the specific action, we fall back to the full list
-  # of matches from step 1.  (TODO The comment says it's for why run.  I'm not
-  # sure what that means specifically yet.)
-  #
-  # ### Priority lists: Chef.get_provider_priority_array
+  # Otherwise, we take the lists of Providers that have registered as
+  # providing the DSL through `provides :dsl_name, <filters>` or
+  # `Chef.set_resource_priority_array :dsl_name, <filters>`.  We filter each
+  # list of Providers through:
   #
-  # Once we have the list of matches, we look at `Chef.get_provider_priority_array(node, resource)`
-  # to see if anyone has set a *priority list*.  This method takes
-  # the the first matching priority list for this OS (which is the last list
-  # that was registered).
+  # 1. The filters it was registered with (such as `os: 'linux'` or
+  #    `platform_family: 'debian'`)
+  # 2. `provides?(node, resource)`
+  # 3. `supports?(resource, action)`
   #
-  # If any of our matches are on the priority list, we take the first one.
-  #
-  # If there is no priority list or no matches on it, we take the first result
-  # alphabetically by class name.
-  #
-  # Chef::Platform Provider Map
-  # ---------------------------
-  # If we still have no matches, we try `Chef::Platform.find_provider_for_node(node, resource)`.
-  # This does two new things:
-  #
-  # ### System Provider Map
-  #
-  # The system provider map is a large Hash loaded during `require` time,
-  # which shows system-specific providers by os/platform, and platform_version.
-  # It keys off of `node[:platform] || node[:os]`, and `node[:platform_version]
-  # || node[:os_version] || node[:os_release]`.  The version uses typical gem
-  # constraints like > and <=.
-  #
-  # The first platform+version match wins over the first platform-only match,
-  # which wins over the default.
-  #
-  # ### Chef::Provider::FooBar
-  #
-  # As a last resort, if there are *still* no classes, the system transforms the
-  # DSL name `foo_bar` into `Chef::Provider::FooBar`, and returns the class if
-  # it is there and descends from `Chef::Provider`.
-  #
-  # NOTE: this behavior is now deprecated.
+  # Anything that passes the filter and returns `true` to provides and supports,
+  # is considered a match.  The first matching Provider in the *most recently
+  # registered list* is selected and returned.
   #
   class ProviderResolver
 
@@ -119,33 +56,14 @@ class Chef
       @action = action
     end
 
-    # return a deterministically sorted list of Chef::Provider subclasses
-    def providers
-      @providers ||= Chef::Provider.descendants
-    end
-
     def resolve
       maybe_explicit_provider(resource) ||
         maybe_dynamic_provider_resolution(resource, action) ||
         maybe_chef_platform_lookup(resource)
     end
 
-    # this cut looks at if the provider can handle the resource type on the node
-    def enabled_handlers
-      @enabled_handlers ||=
-        providers.select do |klass|
-          # NB: this is different from resource_resolver which must pass a resource_name
-          # FIXME: deprecate this and normalize on passing resource_name here
-          klass.provides?(node, resource)
-        end.sort {|a,b| a.to_s <=> b.to_s }
-    end
-
-    # this cut looks at if the provider can handle the specific resource and action
-    def supported_handlers
-      @supported_handlers ||=
-        enabled_handlers.select do |klass|
-          klass.supports?(resource, action)
-        end
+    def provided_by?(provider_class)
+      prioritized_handlers.include?(provider_class)
     end
 
     private
@@ -158,40 +76,37 @@ class Chef
 
     # try dynamically finding a provider based on querying the providers to see what they support
     def maybe_dynamic_provider_resolution(resource, action)
-      # log this so we know what providers will work for the generic resource on the node (early cut)
-      Chef::Log.debug "providers for generic #{resource.resource_name} resource enabled on node include: #{enabled_handlers}"
-
-      # what providers were excluded by machine state (late cut)
-      Chef::Log.debug "providers that refused resource #{resource} were: #{enabled_handlers - supported_handlers}"
-      Chef::Log.debug "providers that support resource #{resource} include: #{supported_handlers}"
-
-      # if none of the providers specifically support the resource, we still need to pick one of the providers that are
-      # enabled on the node to handle the why-run use case.
-      handlers = supported_handlers.empty? ? enabled_handlers : supported_handlers
-      Chef::Log.debug "no providers supported the resource, falling back to enabled handlers" if supported_handlers.empty?
-
-      if handlers.count >= 2
-        # this magic stack ranks the providers by where they appear in the provider_priority_map, it is mostly used
-        # to pick amongst N different ways to start init scripts on different debian/ubuntu systems.
-        priority_list = [ get_priority_array(node, resource.resource_name) ].flatten.compact
-        handlers = handlers.sort_by { |x| i = priority_list.index x; i.nil? ? Float::INFINITY : i }
-        if priority_list.index(handlers.first).nil?
-          # if we had more than one and we picked one with a precidence of infinity that means that the resource_priority_map
-          # entry for this resource is missing -- we should probably raise here and force resolution of the ambiguity.
-          Chef::Log.warn "Ambiguous provider precedence: #{handlers}, please use Chef.set_provider_priority_array to provide determinism"
-        end
-        handlers = [ handlers.first ]
+      Chef::Log.debug "Providers for generic #{resource.resource_name} resource enabled on node include: #{enabled_handlers}"
+
+      # Get all the handlers in the priority bucket
+      handlers = prioritized_handlers
+
+      # Narrow it down to handlers that return `true` to `provides?`
+      # TODO deprecate this and don't bother calling--the fact that they said
+      # `provides` should be enough.  But we need to do it right now because
+      # some classes implement additional handling.
+      enabled_handlers = prioritized_handlers.select { |handler| handler.provides?(node, resource) }
+
+      # Narrow it down to handlers that return `true` to `supports?`
+      # TODO deprecate this and allow actions to be passed as a filter to
+      # `provides` so we don't have to have two separate things.
+      supported_handlers = enabled_handlers.select { |handler| handler.supports?(resource, action) }
+      if supported_handlers.empty?
+        # if none of the providers specifically support the resource, we still need to pick one of the providers that are
+        # enabled on the node to handle the why-run use case. FIXME we should only do this in why-run mode then.
+        Chef::Log.debug "No providers responded true to `supports?` for action #{action} on resource #{resource}, falling back to enabled handlers so we can return something anyway."
+        handler = enabled_handlers.first
+      else
+        handler = supported_handlers.first
       end
 
-      Chef::Log.debug "providers that survived replacement include: #{handlers}"
-
-      raise Chef::Exceptions::AmbiguousProviderResolution.new(resource, handlers) if handlers.count >= 2
-
-      Chef::Log.debug "dynamic provider resolver FAILED to resolve a provider" if handlers.empty?
-
-      return nil if handlers.empty?
+      if handler
+        Chef::Log.debug "Provider for action #{action} on resource #{resource} is #{handler}"
+      else
+        Chef::Log.debug "Dynamic provider resolver FAILED to resolve a provider for action #{action} on resource #{resource}"
+      end
 
-      handlers[0]
+      handler
     end
 
     # try the old static lookup of providers by platform
@@ -199,13 +114,51 @@ class Chef
       Chef::Platform.find_provider_for_node(node, resource)
     end
 
-    # dep injection hooks
-    def get_priority_array(node, resource_name)
-      provider_priority_map.get_priority_array(node, resource_name)
-    end
-
     def provider_priority_map
       Chef::Platform::ProviderPriorityMap.instance
     end
+
+    def prioritized_handlers
+      @prioritized_handlers ||=
+        provider_priority_map.list_handlers(node, resource.resource_name).flatten(1).uniq
+    end
+
+    module Deprecated
+      # return a deterministically sorted list of Chef::Provider subclasses
+      def providers
+        @providers ||= Chef::Provider.descendants
+      end
+
+      # this cut looks at if the provider can handle the resource type on the node
+      def enabled_handlers
+        @enabled_handlers ||=
+          providers.select do |klass|
+            # NB: this is different from resource_resolver which must pass a resource_name
+            # FIXME: deprecate this and normalize on passing resource_name here
+            klass.provides?(node, resource)
+          end.sort {|a,b| a.to_s <=> b.to_s }
+      end
+
+      # this cut looks at if the provider can handle the specific resource and action
+      def supported_handlers
+        @supported_handlers ||=
+          enabled_handlers.select do |klass|
+            klass.supports?(resource, action)
+          end
+      end
+
+      # If there are no providers for a DSL, we search through the
+      def prioritized_handlers
+        @prioritized_handlers ||= super || begin
+          result = providers.select { |handler| handler.provides?(node, resource) }.sort_by(:name)
+          if !result.empty?
+            Chef::Log.deprecation("#{resource.resource_name.to_sym} is marked as providing DSL #{method_symbol}, but provides #{resource.resource_name.to_sym.inspect} was never called!")
+            Chef::Log.deprecation("In Chef 13, this will break: you must call provides to mark the names you provide, even if you also override provides? yourself.")
+          end
+          result
+        end
+      end
+    end
+    prepend Deprecated
   end
 end

data/lib/chef/resource.rb

@@ -34,9 +34,12 @@ require 'chef/platform'
 require 'chef/resource/resource_notification'
 require 'chef/provider_resolver'
 require 'chef/resource_resolver'
+require 'set'
 
 require 'chef/mixin/deprecation'
 require 'chef/mixin/provides'
+require 'chef/mixin/shell_out'
+require 'chef/mixin/powershell_out'
 
 class Chef
   class Resource
@@ -51,6 +54,12 @@ class Chef
     include Chef::DSL::RebootPending
     extend Chef::Mixin::Provides
 
+    # This lets user code do things like `not_if { shell_out!("command") }`
+    include Chef::Mixin::ShellOut
+    include Chef::Mixin::PowershellOut
+
+    NULL_ARG = Object.new
+
     #
     # The node the current Chef run is using.
     #
@@ -82,7 +91,6 @@ class Chef
       run_context.resource_collection.find(*args)
     end
 
-
     #
     # Resource User Interface (for users)
     #
@@ -101,8 +109,8 @@ class Chef
       @before = nil
       @params = Hash.new
       @provider = nil
-      @allowed_actions = [ :nothing ]
-      @action = :nothing
+      @allowed_actions = self.class.allowed_actions.to_a
+      @action = self.class.default_action
       @updated = false
       @updated_by_last_action = false
       @supports = {}
@@ -163,19 +171,24 @@ class Chef
     # @param arg [Array[Symbol], Symbol] A list of actions (e.g. `:create`)
     # @return [Array[Symbol]] the list of actions.
     #
+    attr_accessor :action
     def action(arg=nil)
       if arg
-        action_list = arg.kind_of?(Array) ? arg : [ arg ]
-        action_list = action_list.collect { |a| a.to_sym }
-        action_list.each do |action|
+        if arg.is_a?(Array)
+          arg = arg.map { |a| a.to_sym }
+        else
+          arg = arg.to_sym
+        end
+        Array(arg).each do |action|
           validate(
             { action: action },
-            { action: { kind_of: Symbol, equal_to: @allowed_actions } }
+            { action: { kind_of: Symbol, equal_to: allowed_actions } }
           )
         end
-        @action = action_list
+        self.action = arg
       else
-        @action
+        # Pull the action from the class if it's not set
+        @action || self.class.default_action
       end
     end
 
@@ -183,8 +196,7 @@ class Chef
     # Sets up a notification that will run a particular action on another resource
     # if and when *this* resource is updated by an action.
     #
-    # If the action does nothing--does not update this resource, the
-    # notification never triggers.)
+    # If the action does not update this resource, the notification never triggers.
     #
     # Only one resource may be specified per notification.
     #
@@ -600,7 +612,7 @@ class Chef
     #
 
     def to_s
-      "#{@resource_name}[#{@name}]"
+      "#{resource_name}[#{name}]"
     end
 
     def to_text
@@ -761,6 +773,12 @@ class Chef
     #   have.
     #
     attr_accessor :allowed_actions
+    def allowed_actions(value=NULL_ARG)
+      if value != NULL_ARG
+        self.allowed_actions = value
+      end
+      @allowed_actions
+    end
 
     #
     # Whether or not this resource was updated during an action.  If multiple
@@ -819,23 +837,15 @@ class Chef
     end
 
     #
-    # The DSL name of this resource (e.g. `package` or `yum_package`)
-    #
-    # @return [String] The DSL name of this resource.
-    def self.dsl_name
-      Chef::Log.deprecation "Resource.dsl_name is deprecated and will be removed in Chef 11.  Use resource.resource_name instead."
-      if name
-        name = self.name.split('::')[-1]
-        convert_to_snake_case(name)
-      end
-    end
-
+    # The display name of this resource type, for printing purposes.
     #
-    # The name of this resource (e.g. `file`)
+    # Will be used to print out the resource in messages, e.g. resource_name[name]
     #
-    # @return [String] The name of this resource.
+    # @return [Symbol] The name of this resource type (e.g. `:execute`).
     #
-    attr_reader :resource_name
+    def resource_name
+      @resource_name || self.class.resource_name
+    end
 
     #
     # Sets a list of capabilities of the real resource.  For example, `:remount`
@@ -867,6 +877,66 @@ class Chef
       nil
     end
 
+    #
+    # The DSL name of this resource (e.g. `package` or `yum_package`)
+    #
+    # @return [String] The DSL name of this resource.
+    #
+    # @deprecated Use resource_name instead.
+    #
+    def self.dsl_name
+      Chef::Log.deprecation "Resource.dsl_name is deprecated and will be removed in Chef 13.  Use resource_name instead."
+      if name
+        name = self.name.split('::')[-1]
+        convert_to_snake_case(name)
+      end
+    end
+
+    #
+    # The display name of this resource type, for printing purposes.
+    #
+    # This also automatically calls "provides" to provide DSL with the given
+    # name.
+    #
+    # resource_name defaults to your class name.
+    #
+    # Call `resource_name nil` to remove the resource name (and any
+    # corresponding DSL).
+    #
+    # @param value [Symbol] The desired name of this resource type (e.g.
+    #   `execute`), or `nil` if this class is abstract and has no resource_name.
+    #
+    # @return [Symbol] The name of this resource type (e.g. `:execute`).
+    #
+    def self.resource_name(name=NULL_ARG)
+      # Setter
+      if name != NULL_ARG
+        remove_canonical_dsl
+
+        # Set the resource_name and call provides
+        if name
+          name = name.to_sym
+          # If our class is not already providing this name, provide it.
+          if !Chef::ResourceResolver.list(name).include?(self)
+            provides name, canonical: true
+          end
+          @resource_name = name
+        else
+          @resource_name = nil
+        end
+      else
+        # set resource_name automatically if it's not set
+        if !instance_variable_defined?(:@resource_name) && self.name
+          resource_name convert_to_snake_case(self.name.split('::')[-1])
+        end
+      end
+
+      @resource_name
+    end
+    def self.resource_name=(name)
+      resource_name(name)
+    end
+
     #
     # The module where Chef should look for providers for this resource.
     # The provider for `MyResource` will be looked up using
@@ -881,11 +951,70 @@ class Chef
     #     # ...other stuff
     #   end
     #
+    # @deprecated Use `provides` on the provider, or `provider` on the resource, instead.
+    #
     def self.provider_base(arg=nil)
-      @provider_base ||= arg
-      @provider_base ||= Chef::Provider
+      if arg
+        Chef::Log.deprecation("Resource.provider_base is deprecated and will be removed in Chef 13. Use provides on the provider, or provider on the resource, instead.")
+      end
+      @provider_base ||= arg || Chef::Provider
+    end
+
+    #
+    # The list of allowed actions for the resource.
+    #
+    # @param actions [Array<Symbol>] The list of actions to add to allowed_actions.
+    #
+    # @return [Arrau<Symbol>] The list of actions, as symbols.
+    #
+    def self.allowed_actions(*actions)
+      @allowed_actions ||=
+        if superclass.respond_to?(:allowed_actions)
+          superclass.allowed_actions.dup
+        else
+          [ :nothing ]
+        end
+      @allowed_actions |= actions
+    end
+    def self.allowed_actions=(value)
+      @allowed_actions = value
     end
 
+    #
+    # The action that will be run if no other action is specified.
+    #
+    # Setting default_action will automatially add the action to
+    # allowed_actions, if it isn't already there.
+    #
+    # Defaults to :nothing.
+    #
+    # @param action_name [Symbol,Array<Symbol>] The default action (or series
+    #   of actions) to use.
+    #
+    # @return [Symbol,Array<Symbol>] The default actions for the resource.
+    #
+    def self.default_action(action_name=NULL_ARG)
+      unless action_name.equal?(NULL_ARG)
+        if action_name.is_a?(Array)
+          @default_action = action_name.map { |arg| arg.to_sym }
+        else
+          @default_action = action_name.to_sym
+        end
+
+        self.allowed_actions |= Array(@default_action)
+      end
+
+      if @default_action
+        @default_action
+      elsif superclass.respond_to?(:default_action)
+        superclass.default_action
+      else
+        :nothing
+      end
+    end
+    def self.default_action=(action_name)
+      default_action(action_name)
+    end
 
     #
     # Internal Resource Interface (for Chef)
@@ -961,10 +1090,31 @@ class Chef
       # NOTE: that we do not support unregistering classes as descendents like
       # we used to for LWRP unloading because that was horrible and removed in
       # Chef-12.
+      # @deprecated
+      # @api private
       alias :resource_classes :descendants
+      # @deprecated
+      # @api private
       alias :find_subclass_by_name :find_descendants_by_name
     end
 
+    # @deprecated
+    # @api private
+    # We memoize a sorted version of descendants so that resource lookups don't
+    # have to sort all the things, all the time.
+    # This was causing performance issues in test runs, and probably in real
+    # life as well.
+    @@sorted_descendants = nil
+    def self.sorted_descendants
+      @@sorted_descendants ||= descendants.sort_by { |x| x.to_s }
+    end
+    def self.inherited(child)
+      super
+      @sorted_descendants = nil
+      child.resource_name
+    end
+
+
     # If an unknown method is invoked, determine whether the enclosing Provider's
     # lexical scope can fulfill the request. E.g. This happens when the Resource's
     # block invokes new_resource.
@@ -976,12 +1126,32 @@ class Chef
       end
     end
 
-    def self.provides(name, *args, &block)
-      result = super
+    #
+    # Mark this resource as providing particular DSL.
+    #
+    # Resources have an automatic DSL based on their resource_name, equivalent to
+    # `provides :resource_name` (providing the resource on all OS's).  If you
+    # declare a `provides` with the given resource_name, it *replaces* that
+    # provides (so that you can provide your resource DSL only on certain OS's).
+    #
+    def self.provides(name, **options, &block)
+      name = name.to_sym
+
+      # `provides :resource_name, os: 'linux'`) needs to remove the old
+      # canonical DSL before adding the new one.
+      if @resource_name && name == @resource_name
+        remove_canonical_dsl
+      end
+
+      result = Chef.set_resource_priority_array(name, self, options, &block)
       Chef::DSL::Resources.add_resource_dsl(name)
       result
     end
 
+    def self.provides?(node, resource)
+      Chef::ResourceResolver.resolve(resource, node: node).provided_by?(self)
+    end
+
     # Helper for #notifies
     def validate_resource_spec!(resource_spec)
       run_context.resource_collection.validate_lookup_spec!(resource_spec)
@@ -1111,15 +1281,13 @@ class Chef
     # === Returns
     # <Chef::Resource>:: returns the proper Chef::Resource class
     def self.resource_for_node(short_name, node)
-      klass = Chef::ResourceResolver.new(node, short_name).resolve
+      klass = Chef::ResourceResolver.resolve(short_name, node: node)
       raise Chef::Exceptions::NoSuchResourceType.new(short_name, node) if klass.nil?
       klass
     end
 
     #
-    # Returns the class of a Chef::Resource based on the short name
-    # Only returns the *canonical* class with the given name, not the one that
-    # would be picked by the ResourceResolver.
+    # Returns the class with the given resource_name.
     #
     # ==== Parameters
     # short_name<Symbol>:: short_name of the resource (ie :directory)
@@ -1127,49 +1295,73 @@ class Chef
     # === Returns
     # <Chef::Resource>:: returns the proper Chef::Resource class
     #
-    # @deprecated Chef::Resource::FooBar will no longer mean anything special in
-    #   Chef 13.  Use `resource_for_node` instead.
     def self.resource_matching_short_name(short_name)
-      begin
-        rname = convert_to_class_name(short_name.to_s)
-        result = Chef::Resource.const_get(rname)
-        if result <= Chef::Resource
-          Chef::Log.deprecation("Class Chef::Resource::#{rname} does not declare 'provides #{short_name.inspect}'.")
-          Chef::Log.deprecation("This will no longer work in Chef 13: you must use 'provides' to provide DSL.")
-          result
-        end
-      rescue NameError
-        nil
-      end
+      Chef::ResourceResolver.resolve(short_name, canonical: true)
     end
 
-    # Implement deprecated LWRP class
-    module DeprecatedLWRPClass
-      # @api private
-      def register_deprecated_lwrp_class(resource_class, class_name)
-        if Chef::Resource.const_defined?(class_name, false)
-          Chef::Log.warn "#{class_name} already exists!  Cannot create deprecation class for #{resource_class}"
-        else
-          deprecated_constants[class_name.to_sym] = resource_class
-        end
+    # @api private
+    def self.register_deprecated_lwrp_class(resource_class, class_name)
+      if Chef::Resource.const_defined?(class_name, false)
+        Chef::Log.warn "#{class_name} already exists!  Deprecation class overwrites #{resource_class}"
+        Chef::Resource.send(:remove_const, class_name)
       end
 
-      def const_missing(class_name)
-        if deprecated_constants[class_name.to_sym]
-          Chef::Log.deprecation("Using an LWRP by its name (#{class_name}) directly is no longer supported in Chef 12 and will be removed.  Use Chef::Resource.resource_for_node(node, name) instead.")
-          deprecated_constants[class_name.to_sym]
-        else
-          raise NameError, "uninitialized constant Chef::Resource::#{class_name}"
+      # In order to generate deprecation warnings when you use Chef::Resource::MyLwrp,
+      # we make a special subclass (identical in nearly all respects) of the
+      # actual LWRP.  When you say any of these, a deprecation warning will be
+      # generated:
+      #
+      # - Chef::Resource::MyLwrp.new(...)
+      # - resource.is_a?(Chef::Resource::MyLwrp)
+      # - resource.kind_of?(Chef::Resource::MyLwrp)
+      # - case resource
+      #   when Chef::Resource::MyLwrp
+      #   end
+      #
+      resource_subclass = class_eval <<-EOM, __FILE__, __LINE__+1
+        class Chef::Resource::#{class_name} < resource_class
+          resource_name nil # we do not actually provide anything
+          def initialize(*args, &block)
+            Chef::Log.deprecation("Using an LWRP by its name (#{class_name}) directly is no longer supported in Chef 13 and will be removed.  Use Chef::Resource.resource_for_node(node, name) instead.")
+            super
+          end
+          def self.resource_name(*args)
+            if args.empty?
+              @resource_name ||= superclass.resource_name
+            else
+              super
+            end
+          end
+          self
+        end
+      EOM
+      # Make case, is_a and kind_of work with the new subclass, for backcompat.
+      # Any subclass of Chef::Resource::ResourceClass is already a subclass of resource_class
+      # Any subclass of resource_class is considered a subclass of Chef::Resource::ResourceClass
+      resource_class.class_eval do
+        define_method(:is_a?) do |other|
+          other.is_a?(Module) && other === self
+        end
+        define_method(:kind_of?) do |other|
+          other.is_a?(Module) && other === self
         end
       end
-
-      private
-
-      def deprecated_constants
-        @deprecated_constants ||= {}
+      resource_subclass.class_eval do
+        define_singleton_method(:===) do |other|
+          Chef::Log.deprecation("Using an LWRP by its name (#{class_name}) directly is no longer supported in Chef 13 and will be removed.  Use Chef::Resource.resource_for_node(node, name) instead.")
+          # resource_subclass is a superclass of all resource_class descendants.
+          if self == resource_subclass && other.class <= resource_class
+            return true
+          end
+          super(other)
+        end
       end
+      deprecated_constants[class_name.to_sym] = resource_subclass
+    end
+
+    def self.deprecated_constants
+      @deprecated_constants ||= {}
     end
-    extend DeprecatedLWRPClass
 
     # @api private
     def lookup_provider_constant(name, action=:nothing)
@@ -1183,5 +1375,19 @@ class Chef
         end
       end
     end
+
+    private
+
+    def self.remove_canonical_dsl
+      if @resource_name
+        remaining = Chef.resource_priority_map.delete_canonical(@resource_name, self)
+        if !remaining
+          Chef::DSL::Resources.remove_resource_dsl(@resource_name)
+        end
+      end
+    end
   end
 end
+
+# Requiring things at the bottom breaks cycles
+require 'chef/chef_class'