chef-resource 0.2.2

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'stove/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+Stove::RakeTask.new
+
+task default: :spec

data/files/lib/chef_resource.rb

@@ -0,0 +1,24 @@
+require 'chef_resource/version'
+require 'chef_resource/constants'
+
+module ChefResource
+  #
+  # Print a list of values with a conjunction like 'and' or 'or'
+  #
+  # @param conjunction [String] A word like 'and' or 'or'
+  # @param separator [String] A separator like ', ' or '; '
+  # @param *values A list of values to join with `to_s`
+  # @return the list, joined with the separator
+  # @example
+  #   english_list(1, 2, 3, 4) #=> "1, 2, 3 and 4"
+  def self.english_list(*values, conjunction: 'and', separator: ', ')
+    case values.size
+    when 0
+      nil
+    when 1
+      values[0].to_s
+    else
+      "#{values[0..-2].join(separator)} #{conjunction} #{values[-1]}"
+    end
+  end
+end

data/files/lib/chef_resource/camel_case.rb

@@ -0,0 +1,23 @@
+module ChefResource
+  module CamelCase
+    # foo_bar/baz_bonk -> FooBar::BazBonk
+    def self.from_snake_case(snake_case)
+      snake_case.to_s.split('/').map do |str|
+        str.split('_').map { |s| s.capitalize }.join('')
+      end.join('::')
+    end
+
+    # FooBar::BazBonk -> foo_bar/baz_bonk
+    if RUBY_VERSION.to_f >= 2
+      UPPERCASE_SPLIT = Regexp.new('(?=\p{Lu})')
+    else
+      UPPERCASE_SPLIT = Regexp.new('(?=[A-Z])')
+    end
+
+    def self.to_snake_case(camel_case)
+      camel_case.to_s.split('::').map do |str|
+        str.split(UPPERCASE_SPLIT).map { |s| s.downcase! }.join('_')
+      end.join('/')
+    end
+  end
+end

data/files/lib/chef_resource/chef.rb

@@ -0,0 +1,102 @@
+#
+# This file includes all the monkeypatches to Chef.  (They are fairly minimal,
+# and generally designed to only affect ChefResource cookbooks, as well as to allow
+# other cookbooks to use resources defined in ChefResource cookbooks.)
+#
+
+#
+# Redefine Chef's DelayedEvaluator (same basic def, with added goodies
+# for cache and instance_eval)
+#
+
+require 'chef_resource/lazy_proc'
+require 'chef/mixin/params_validate' # for DelayedEvaluator
+
+Chef.send(:remove_const, :DelayedEvaluator)
+Chef.const_set(:DelayedEvaluator, ChefResource::LazyProc)
+
+#
+# Add "ChefResource.define", "Chef.resource" and "ChefResource.defaults"
+#
+
+require 'chef_resource/chef_dsl/resource_definition_dsl'
+
+class Chef
+  extend ChefResource::ChefDSL::ResourceDefinitionDSL
+end
+
+#
+# Add "define" "resource" and "defaults" directly to ChefResource recipes/ and resource DSLs
+#
+
+require 'chef_resource/chef_dsl/chef_recipe'
+require 'chef/recipe'
+
+class Chef
+  class Recipe
+    def self.new(cookbook_name, recipe_name, run_context)
+      if run_context
+        cookbook = run_context.cookbook_collection[cookbook_name]
+        if cookbook.metadata.dependencies.has_key?('resource') && !(self <= ChefResource::ChefDSL::ChefRecipe)
+          return ChefResource::ChefDSL::ChefRecipe.new(cookbook_name, recipe_name, run_context)
+        end
+      end
+      super
+    end
+  end
+end
+
+#
+# Turn "resources/" into ChefResource resources in ChefResource cookbooks
+#
+
+require 'chef/run_context/cookbook_compiler'
+require 'chef_resource/chef_dsl/chef_cookbook_compiler'
+
+class Chef
+  class RunContext
+    class CookbookCompiler
+      prepend ChefResource::ChefDSL::ChefCookbookCompiler
+    end
+  end
+end
+
+#
+# Support new-style resources in Chef recipes by adding a method to update the
+# list of definitions when resources are defined
+#
+
+require 'chef_resource/chef_dsl/resource_container_module'
+require 'chef/dsl/recipe'
+require 'chef/resource'
+
+class Chef
+  class Resource
+    extend ChefResource::ChefDSL::ResourceContainerModule
+    def self.recipe_dsl_module
+      Chef::DSL::Recipe
+    end
+  end
+end
+
+
+#
+# Build ChefResource resources all special-like
+#
+
+require 'chef_resource/chef_dsl/chef_recipe_dsl_extensions'
+require 'chef/dsl/recipe'
+require 'chef/recipe'
+require 'chef/resource/lwrp_base'
+
+class Chef
+  module DSL::Recipe
+    prepend ChefResource::ChefDSL::ChefRecipeDSLExtensions
+  end
+  class Recipe
+    prepend ChefResource::ChefDSL::ChefRecipeDSLExtensions
+  end
+  class Resource::LWRPBase
+    prepend ChefResource::ChefDSL::ChefRecipeDSLExtensions
+  end
+end

data/files/lib/chef_resource/chef_dsl/chef_cookbook_compiler.rb

@@ -0,0 +1,44 @@
+require 'chef/resource'
+require 'chef/log'
+require 'chef/mixin/convert_to_class_name'
+require 'chef_resource/chef'
+
+module ChefResource
+  module ChefDSL
+    module ChefCookbookCompiler
+      def depends_on_resource_cookbook?(cookbook_name)
+        cookbook_collection[cookbook_name].metadata.dependencies.has_key?('resource')
+      end
+
+      # After compiling libraries, we update the resource collection
+      def compile_libraries
+        super
+        Chef::Resource.update_resource_definition_methods!
+      end
+
+      def compile_lwrps
+        super
+        Chef::Resource.update_resource_definition_methods!
+      end
+
+      def load_lwrp_resource(cookbook_name, filename)
+        if depends_on_resource_cookbook?(cookbook_name)
+          begin
+            Chef::Log.debug("Loading cookbook #{cookbook_name}'s resources from #{filename}")
+            resource_name = Chef::Mixin::ConvertToClassName.filename_to_qualified_string(cookbook_name, filename)
+            resource_class = Chef.resource resource_name do
+              class_eval IO.read(filename), filename
+            end
+            Chef::Log.debug("Loaded contents of #{filename} into a resource named #{resource_name} defined in #{resource_class.name}")
+            @events.lwrp_file_loaded(filename)
+          rescue Exception => e
+            @events.lwrp_file_load_failed(filename, e)
+            raise
+          end
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/files/lib/chef_resource/chef_dsl/chef_recipe.rb

@@ -0,0 +1,10 @@
+require 'chef/recipe'
+require 'chef_resource/chef_dsl/resource_definition_dsl'
+
+module ChefResource
+  module ChefDSL
+    class ChefRecipe < Chef::Recipe
+      include ChefResource::ChefDSL::ResourceDefinitionDSL
+    end
+  end
+end

data/files/lib/chef_resource/chef_dsl/chef_recipe_dsl_extensions.rb

@@ -0,0 +1,84 @@
+require 'chef_resource/resource'
+
+module ChefResource
+  module ChefDSL
+    module ChefRecipeDSLExtensions
+      #
+      # Allow ChefResource resources to be declared with a different syntax:
+      #
+      # declare_resource(:resource, ..., created_at)
+      # declare_resource(ResourceClass, ..., created_at)
+      #
+      # Which translates to open() in the end.
+      #
+      def declare_resource(type, *identity, created_at, &update_block)
+        resource_class = resource_class_for(type)
+
+        # Handle normal resources
+        if !resource_class.is_a?(ChefResource::Resource)
+          case identity.size
+          when 0
+            name, created_at = created_at, caller[0]
+          when 1
+            name = identity[0]
+          else
+            raise ArgumentError, "wrong number of arguments (#{identity.size+1} for 1..2)"
+          end
+          return super(type, name, created_at, &update_block)
+        end
+
+        # ChefResource resources!
+        resource = buildbuild_resource_v2(resource_class, *identity, created_at, &update_block)
+        run_context.resource_collection.insert(resource,
+          resource_type: resource_class.dsl_name,
+          instance_name: resource.resource_identity_string)
+      end
+
+      def build_resource(type, *identity, created_at, &update_block)
+        resource_class = resource_class_for(type)
+        if !resource_class.is_a?(ChefResource::Resource)
+          # Handle normal resources
+          case identity.size
+          when 0
+            name, created_at = created_at, caller[0]
+          when 1
+            name = identity[0]
+          else
+            raise ArgumentError, "wrong number of arguments (#{identity.size+1} for 1..2)"
+          end
+          return super(type, name, created_at, &update_block)
+        end
+
+        # ChefResource!
+        buildbuild_resource_v2(resource_class, *identity, created_at, &update_block)
+      end
+
+      def buildbuild_resource_v2(resource_class, *identity, created_at, &update_block)
+        resource = resource_class.open(*identity)
+        resource.run_context = run_context
+        resource.cookbook_name = cookbook_name
+        resource.recipe_name = recipe_name
+        resource.source_line = created_at
+        resource.declared_type = resource_class.dsl_name
+        # Determine whether this resource is being created in the context of an enclosing Provider
+        resource.enclosing_provider = self.is_a?(Chef::Provider) ? self : nil
+        resource.params = @params
+
+        # Evaluate resource attribute DSL
+        resource.instance_eval(&update_block) if block_given?
+
+        # Freeze resource
+        resource.resource_fully_defined
+
+        # Run optional resource hook
+        resource.after_created
+
+        resource
+      end
+
+      def resource_class_for(type)
+        type.is_a?(Class) ? type : super
+      end
+    end
+  end
+end

data/files/lib/chef_resource/chef_dsl/chef_resource_base.rb

@@ -0,0 +1,12 @@
+require 'chef/resource'
+require 'chef_resource/chef_dsl/chef_resource_extensions'
+require 'chef_resource/chef_dsl/chef_resource_class_extensions'
+
+module ChefResource
+  module ChefDSL
+    class ChefResourceBase < Chef::Resource
+      include ChefResourceExtensions
+      extend ChefResourceClassExtensions
+    end
+  end
+end

data/files/lib/chef_resource/chef_dsl/chef_resource_class_extensions.rb

@@ -0,0 +1,30 @@
+require 'chef_resource/resource/struct_resource'
+require 'chef_resource/resource/struct_resource_type'
+require 'chef_resource/camel_case'
+require 'chef/dsl/recipe'
+require 'chef/resource'
+
+module ChefResource
+  module ChefDSL
+    #
+    # Define properties on the type itself
+    #
+    module ChefResourceClassExtensions
+      # We are a StructResource (so that we can use "property" for properties
+      # of the ChefResource class itself) and a StructResourceType (because
+      # Chef Resources are traditionally structs).
+      include ChefResource::Resource::StructResource
+      include ChefResource::Resource::StructResourceType
+      extend ChefResource::Resource::StructResourceType
+
+      #
+      # recipe do
+      #   ...
+      # end
+      #
+      def recipe(&recipe_block)
+        define_method(:update_resource, &recipe_block)
+      end
+    end
+  end
+end

data/files/lib/chef_resource/chef_dsl/chef_resource_extensions.rb

@@ -0,0 +1,224 @@
+require 'chef/resource_collection'
+require 'chef/runner'
+require 'chef/dsl/recipe'
+require 'chef_resource/resource/struct_resource'
+require 'chef_resource/chef_dsl/chef_resource_log'
+require 'chef_resource/chef_dsl/chef_recipe_dsl_extensions'
+require 'chef_resource/types'
+
+module ChefResource
+  module ChefDSL
+    module ChefResourceExtensions
+      include Chef::DSL::Recipe
+      include ChefResource::ChefDSL::ChefRecipeDSLExtensions
+      include ChefResource::Resource::StructResource
+
+      #
+      # We don't set name, and we expect our run_context to be set elsewhere.
+      #
+      def initialize
+        super(nil, nil)
+      end
+
+      #
+      # Returns a super-friendly string showing this struct.
+      #
+      # @param only [Symbol] Which values to include. Default: `:only_known`. One of:
+      #   - :only_known :: Values explicitly set by the user or current values.
+      #     If the current value has not been loaded, this will NOT load it or
+      #     show any of those values.
+      #   - :only_changed :: Values which the user has set and which have
+      #     actually changed from their current or default value.
+      #   - :only_explicit :: Values explicitly set by the user.
+      #   - :all :: All values, including default values.
+      #
+      def to_text(only=:only_known)
+        # return "suppressed sensitive resource output" if sensitive
+        text = self.class.dsl_name + "(\"#{name}\") do\n"
+        text << "  # Declared in #{@source_line}\n"
+        results = to_h(only)
+        results_width = results.keys.map { |k| k.size }.max
+        results.each do |name, value|
+          text << "  #{name.to_s.ljust(results_width)} "
+          if value.respond_to?(:to_text)
+            lines = value.to_text.lines
+            text << lines.map do |line|
+              "#{line}#{line.end_with?("\n") ? "" : "\n"}"
+            end.join("  ")
+          else
+            text << "#{value.inspect}\n"
+          end
+        end
+        [@not_if, @only_if].flatten.each do |conditional|
+          text << "  #{conditional.to_text}\n"
+        end
+        text << "end\n"
+      end
+
+      #
+      # Returns this struct as a string with <resource_name name: value name: value name
+      #
+      # @param only [Symbol] Which values to include. Default: `:only_known`. One of:
+      #   - :only_known :: Values explicitly set by the user or current values.
+      #     If the current value has not been loaded, this will NOT load it or
+      #     show any of those values.
+      #   - :only_changed :: Values which the user has set and which have
+      #     actually changed from their current or default value.
+      #   - :only_explicit :: Values explicitly set by the user.
+      #   - :all :: All values, including default values.
+      #
+      def inspect(only=:only_known)
+        to_h(only).inject("<#{to_s}") do |str, (name, value)|
+          str << " #{name}: #{value.inspect}"
+        end << ">"
+      end
+
+      #
+      # No such thing as a provider, yo.  (Also not supporting
+      # multiple actions yet.)
+      #
+      def provider_for_action(action)
+        self
+      end
+
+      #
+      # Mimic Chef::Provider.run_action
+      #
+      # This is where we do the work to get rid of Providers!
+      #
+      # NOTE: both Chef::Resource and Chef::Provider have a
+      # run_action.  In fact, they can both technically take a single-argument
+      # form.  However, in practice in Chef, Chef::Provider.run_action() is the
+      # only method ever called.  So we say that if we are passed multiple args,
+      # it is the Resource version ("super") and if we are passed only one arg,
+      # it is the Provider version.
+      #
+      def run_action(*args)
+        if args.size > 0
+          return super
+        end
+
+        # Call update.
+        log.update_started
+        begin
+
+          # Enable update to run its own resources, inline.
+
+          # Executes the given block in a temporary run_context with its own
+          # resource collection. After the block is executed, any resources
+          # declared inside are converged, and if any are updated, the
+          # new_resource will be marked updated.
+          saved_run_context = @run_context
+          temp_run_context = @run_context.dup
+          @run_context = temp_run_context
+          @run_context.resource_collection = Chef::ResourceCollection.new
+
+          update_resource
+
+          Chef::Runner.new(@run_context).converge
+        rescue
+          log.update_failed($!)
+          raise
+        ensure
+          @run_context = saved_run_context
+          if temp_run_context.resource_collection.any? {|r| r.updated? }
+            updated_by_last_action(true)
+          end
+        end
+        log.update_succeeded
+      end
+
+      #
+      # This is how we support inline resources that can access their parent
+      # resource's data: enclosing_provider is how Chef delegates to our scope.
+      #
+      def build_resource(*args, &block)
+        parent = self
+        super(*args) do
+          self.enclosing_provider = parent
+          instance_eval(&block) if block
+        end
+      end
+
+      #
+      # The name of this resource type.  Just calls self.class.resource_name.
+      #
+      def resource_name
+        self.class.dsl_name
+      end
+
+      #
+      # We only support one action, presently.  Hardcode it.
+      #
+      def action
+        [ :update ]
+      end
+
+      #
+      # Subtle difference from ChefResource::Resource::StructResource.reopen_resource:
+      # this method passes the name and run_context into the resource constructor
+      # (since Resource requires that).
+      #
+      def reopen_resource
+        resource = super
+        resource.run_context = run_context
+        resource.cookbook_name = cookbook_name
+        resource.recipe_name = recipe_name
+        resource.source_line = source_line
+        resource.declared_type = declared_type
+        resource.enclosing_provider = enclosing_provider
+        resource.params = params
+        resource
+      end
+
+      def to_s
+        "#{self.class.dsl_name}[#{resource_identity_string}]"
+      end
+
+      #
+      # For our short_name, we just grab #to_s, which outputs the right notification
+      # syntax.
+      #
+      def resource_short_name
+        to_s
+      end
+
+      #
+      # Log to Chef!
+      #
+      def log(*args)
+        @resource_log ||= ChefResourceLog.new(self)
+        super
+      end
+
+      #
+      # Make damn sure we're not doing the whole silly cloning thing
+      #
+      def load_from(*args)
+        raise NotImplementedError, "load_from is not implemented on ChefResource resources."
+      end
+
+      #
+      # Take an action that will update the resource.
+      #
+      # @param description [String] The action being taken.
+      # @yield A block that will perform the actual update.
+      # @raise Any error raised by the block is passed through.
+      #
+      def take_action(description, &action_block)
+        if Chef::Config[:why_run]
+          log.action_skipped(description)
+        else
+          log.action_started(description)
+          begin
+            instance_eval(&action_block)
+          rescue
+            log.action_failed($!)
+            raise
+          end
+          log.action_succeeded
+        end
+      end
+    end
+  end
+end