chef 10.34.6-x86-mingw32 → 11.6.2-x86-mingw32

data/lib/chef/mixin/language_include_attribute.rb

@@ -6,9 +6,9 @@
 # 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.
@@ -16,46 +16,20 @@
 # limitations under the License.
 #
 
-require 'chef/log'
+require 'chef/dsl/include_attribute'
+require 'chef/mixin/deprecation'
 
 class Chef
   module Mixin
-    module LanguageIncludeAttribute
-
-      # Loads the attribute file specified by the short name of the
-      # file, e.g., loads specified cookbook's
-      #   "attributes/mailservers.rb"
-      # if passed
-      #   "mailservers"
-      def include_attribute(*fully_qualified_attribute_short_filenames)
-        if self.kind_of?(Chef::Node)
-          node = self
-        else
-          node = @node
-        end
-
-        fully_qualified_attribute_short_filenames.flatten.each do |fully_qualified_attribute_short_filename|
-          if node.run_state[:seen_attributes].has_key?(fully_qualified_attribute_short_filename)
-            Chef::Log.debug("I am not loading attribute file #{fully_qualified_attribute_short_filename}, because I have already seen it.")
-            next
-          end
 
-          Chef::Log.debug("Loading Attribute #{fully_qualified_attribute_short_filename}")
-          node.run_state[:seen_attributes][fully_qualified_attribute_short_filename] = true
+    # DEPRECATED: This is just here for compatibility, use
+    # Chef::DSL::IncludeAttribute instead.
 
-          if amatch = fully_qualified_attribute_short_filename.match(/(.+?)::(.+)/)
-            cookbook_name = amatch[1].to_sym
-            node.load_attribute_by_short_filename(amatch[2], cookbook_name)
-          else
-            cookbook_name = fully_qualified_attribute_short_filename.to_sym
-            node.load_attribute_by_short_filename("default", cookbook_name)
-          end
-        end
-        true
-      end
+    deprecate_constant(:LanguageIncludeAttribute, Chef::DSL::IncludeAttribute, <<-EOM)
+Chef::Mixin::LanguageIncludeAttribute is deprecated. Use
+Chef::DSL::IncludeAttribute instead.
+EOM
 
-    end
   end
 end
-      
 

data/lib/chef/mixin/language_include_recipe.rb

@@ -16,43 +16,17 @@
 # limitations under the License.
 #
 
-require 'chef/log'
+require 'chef/dsl/include_recipe'
+require 'chef/mixin/deprecation'
 
 class Chef
   module Mixin
-    module LanguageIncludeRecipe
 
-      def include_recipe(*recipe_names)
-        result_recipes = Array.new
-        recipe_names.flatten.each do |recipe_name|
-          if node.run_state[:seen_recipes].has_key?(recipe_name) or node.run_state[:seen_recipes].has_key?(recipe_name + "::default")
-            Chef::Log.debug("I am not loading #{recipe_name}, because I have already seen it.")
-            next
-          end
+    deprecate_constant(:LanguageIncludeRecipe, Chef::DSL::IncludeRecipe, <<-EOM)
+Chef::Mixin::LanguageIncludeRecipe is deprecated, use Chef::DSL::IncludeRecipe
+instead.
+EOM
 
-          result_recipes << load_recipe(recipe_name)
-        end
-        result_recipes
-      end
-
-      def load_recipe(recipe_name)
-        Chef::Log.debug("Loading Recipe #{recipe_name} via include_recipe")
-        node.run_state[:seen_recipes][recipe_name] = true
-
-        cookbook_name, recipe_short_name = Chef::Recipe.parse_recipe_name(recipe_name)
-
-        run_context = self.is_a?(Chef::RunContext) ? self : self.run_context
-        cookbook = run_context.cookbook_collection[cookbook_name]
-        cookbook.load_recipe(recipe_short_name, run_context)
-      end
-
-
-      def require_recipe(*args)
-        Chef::Log.warn("require_recipe is deprecated and will be removed in a future release, please use include_recipe")
-        include_recipe(*args)
-      end
-
-    end
   end
 end
-      
+

data/lib/chef/mixin/params_validate.rb

@@ -83,9 +83,6 @@ class Chef
 
       def set_or_return(symbol, arg, validation)
         iv_symbol = "@#{symbol.to_s}".to_sym
-        map = {
-          symbol => validation
-        }
         if arg == nil && self.instance_variable_defined?(iv_symbol) == true
           ivar = self.instance_variable_get(iv_symbol)
           if(ivar.is_a?(DelayedEvaluator))

data/lib/chef/mixin/recipe_definition_dsl_core.rb

@@ -17,70 +17,19 @@
 # limitations under the License.
 #
 
-require 'chef/resource'
-require 'chef/resource_platform_map'
-require 'chef/mixin/convert_to_class_name'
-require 'chef/mixin/language'
+###
+# NOTE: This file and constant are here only for backwards compatibility.
+# New code should use Chef::DSL::Recipe instead.
+#
+# This constant (module name) will eventually be deprecated and then removed.
+###
 
-#--
-# UGH. this is a circular require that will cause an uninitialized constant
-# error, but this file really does depend on Chef::Recipe. oh well.
-# require 'chef/recipe'
+require 'chef/mixin/deprecation'
 
 class Chef
   module Mixin
-    module RecipeDefinitionDSLCore
-
-      include Chef::Mixin::ConvertToClassName
-      include Chef::Mixin::Language
-
-      def method_missing(method_symbol, *args, &block)
-        # If we have a definition that matches, we want to use that instead.  This should
-        # let you do some really crazy over-riding of "native" types, if you really want
-        # to.
-        if run_context.definitions.has_key?(method_symbol)
-          # This dupes the high level object, but we still need to dup the params
-          new_def = run_context.definitions[method_symbol].dup
-          new_def.params = new_def.params.dup
-          new_def.node = run_context.node
-          # This sets up the parameter overrides
-          new_def.instance_eval(&block) if block
-          new_recipe = Chef::Recipe.new(cookbook_name, @recipe_name, run_context)
-          new_recipe.params = new_def.params
-          new_recipe.params[:name] = args[0]
-          new_recipe.instance_eval(&new_def.recipe)
-        else
-          # Otherwise, we're rocking the regular resource call route.
-
-          # Checks the new platform => short_name => resource mapping initially
-          # then fall back to the older approach (Chef::Resource.const_get) for
-          # backward compatibility
-          resource_class = Chef::Resource.resource_for_node(method_symbol, run_context.node)
-
-          super unless resource_class
-          raise ArgumentError, "You must supply a name when declaring a #{method_symbol} resource" unless args.size > 0
-
-          # If we have a resource like this one, we want to steal its state
-          args << run_context
-          resource = resource_class.new(*args)
-          resource.source_line = caller[0]
-          resource.load_prior_resource
-          resource.cookbook_name = cookbook_name
-          resource.recipe_name = @recipe_name
-          resource.params = @params
-          # Determine whether this resource is being created in the context of an enclosing Provider
-          resource.enclosing_provider = self.is_a?(Chef::Provider) ? self : nil
-          # Evaluate resource attribute DSL
-          resource.instance_eval(&block) if block
-
-          # Run optional resource hook
-          resource.after_created
-
-          run_context.resource_collection.insert(resource)
-          resource
-        end
-      end
-
-    end
+    deprecate_constant(:RecipeDefinitionDSLCore, Chef::DSL::Recipe, <<-EOM)
+Chef::Mixin::RecipeDefinitionDSLCore is deprecated. Use Chef::DSL::Recipe instead.
+EOM
   end
 end

data/lib/chef/mixin/securable.rb

@@ -59,9 +59,17 @@ class Chef
         )
       end
 
-      # TODO should this be separated into different files?
-      if RUBY_PLATFORM =~ /mswin|mingw|windows/
 
+      #==WindowsMacros
+      # Defines methods for adding attributes to a chef resource to describe
+      # Windows file security metadata.
+      #
+      # This module is meant to be used to extend a class (instead of
+      # `include`-ing). A class is automatically extended with this module when
+      # it includes WindowsSecurableAttributes.
+      # --
+      # TODO should this be separated into different files?
+      module WindowsMacros
         # === rights_attribute
         # "meta-method" for dynamically creating rights attributes on resources.
         #
@@ -99,7 +107,7 @@ class Chef
         # * `:applies_to_self` (optional): Boolean
         # * `:one_level_deep` (optional): Boolean
         #
-        def self.rights_attribute(name)
+        def rights_attribute(name)
 
           # equivalent to something like:
           # def rights(permissions=nil, principals=nil, args_hash=nil)
@@ -160,10 +168,13 @@ class Chef
             )
           end
         end
+      end
+
+      #==WindowsSecurableAttributes
+      # Defines #inherits to describe Windows file security ACLs on the
+      # including class
+      module WindowsSecurableAttributes
 
-        # create a default 'rights' attribute
-        rights_attribute(:rights)
-        rights_attribute(:deny_rights)
 
         def inherits(arg=nil)
           set_or_return(
@@ -172,8 +183,22 @@ class Chef
             :kind_of => [ TrueClass, FalseClass ]
           )
         end
+      end
 
-      end # Windows-specific
+      if RUBY_PLATFORM =~ /mswin|mingw|windows/
+        include WindowsSecurableAttributes
+      end
+
+      # Callback that fires when included; will extend the including class
+      # with WindowsMacros and define #rights and #deny_rights on it.
+      def self.included(including_class)
+        if RUBY_PLATFORM =~ /mswin|mingw|windows/
+          including_class.extend(WindowsMacros)
+          # create a default 'rights' attribute
+          including_class.rights_attribute(:rights)
+          including_class.rights_attribute(:deny_rights)
+        end
+      end
 
     end
   end

data/lib/chef/mixin/template.rb

@@ -6,9 +6,9 @@
 # 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.
@@ -22,53 +22,183 @@ require 'erubis'
 class Chef
   module Mixin
     module Template
-      
+
+      # A compatibility wrapper around IO.binread so it works on Ruby 1.8.7.
+      # --
+      # Used in the TemplateContext class, but that method namespace is shared
+      # with user code, so we want to avoid adding methods there when possible.
+      def self.binread(file)
+        if IO.respond_to?(:binread)
+          IO.binread(file)
+        else
+          File.open(file, "rb") {|f| f.read }
+        end
+      end
+
+      # == ChefContext
+      # ChefContext was previously used to mix behavior into Erubis::Context so
+      # that it would be available to templates. This behavior has now moved to
+      # TemplateContext, but this module is still mixed in to the
+      # TemplateContext class so that any user code that modified ChefContext
+      # will continue to work correctly.
       module ChefContext
+      end
+
+      # == TemplateContext
+      # TemplateContext is the base context class for all templates in Chef. It
+      # defines user-facing extensions to the base Erubis::Context to provide
+      # enhanced features. Individual instances of TemplateContext can be
+      # extended to add logic to a specific template.
+      #
+      class TemplateContext < Erubis::Context
+
+        include ChefContext
+
+        attr_reader :_extension_modules
+
+        def initialize(variables)
+          super
+          @_extension_modules = []
+        end
+
+        ###
+        # USER FACING API
+        ###
+
+        # Returns the current node object, or raises an error if it's not set.
+        # Provides API consistency, allowing users to reference the node object
+        # by the bare `node` everywhere.
         def node
           return @node if @node
           raise "Could not find a value for node. If you are explicitly setting variables in a template, " +
                 "include a node variable if you plan to use it."
         end
-      end
-      
-      ::Erubis::Context.send(:include, ChefContext)
-      
-      # Render a template with Erubis.  Takes a template as a string, and a 
-      # context hash.  
-      def render_template(template, context)
-        begin
-          eruby = Erubis::Eruby.new(template)
-          output = eruby.evaluate(context)
-        rescue Object => e
-          raise TemplateError.new(e, template, context)
+
+        #
+        # Takes the name of the partial, plus a hash of options. Returns a
+        # string that contains the result of the evaluation of the partial.
+        #
+        # All variables from the parent template will be propagated down to
+        # the partial, unless you pass the +variables+ option (see below).
+        #
+        # Valid options are:
+        #
+        # :local:: If true then the partial name will be interpreted as the
+        #          path to a file on the local filesystem; if false (the
+        #          default) it will be looked up in the cookbook according to
+        #          the normal rules for templates.
+        # :source:: If specified then the partial will be looked up with this
+        #           name or path (according to the +local+ option) instead of
+        #           +partial_name+.
+        # :cookbook:: Search for the partial in the provided cookbook instead
+        #             of the cookbook that contains the top-level template.
+        # :variables:: A Hash of variable_name => value that will be made
+        #              available to the partial. If specified, none of the
+        #              variables from the master template will be, so if you
+        #              need them you will need to propagate them explicitly.
+        #
+        def render(partial_name, options = {})
+          raise "You cannot render partials in this context" unless @template_finder
+
+          partial_variables = options.delete(:variables) || _public_instance_variables
+          partial_context = self.class.new(partial_variables)
+          partial_context._extend_modules(@_extension_modules)
+
+          template_location = @template_finder.find(partial_name, options)
+          _render_template(Mixin::Template.binread(template_location), partial_context)
         end
-        Tempfile.open("chef-rendered-template") do |tempfile|
-          tempfile.print(output)
-          tempfile.close
-          yield tempfile
+
+        def render_template(template_location)
+          _render_template(Mixin::Template.binread(template_location), self)
+        end
+
+        def render_template_from_string(template)
+          _render_template(template, self)
+        end
+
+        ###
+        # INTERNAL PUBLIC API
+        ###
+
+        def _render_template(template, context)
+          # CHEF-2991
+          # Erubis always emits unix line endings during template
+          # rendering. This results in automatic conversion of windows
+          # line endings to linux line endings if the original template
+          # contains windows line endings. In order to fix this we
+          # determine the line ending style of the template before
+          # rendering and convert the line endings of the output if needed
+          # If template contains any windows line endings we emit
+          # the template result with windows line endings.
+          windows_line_endings = template.include? "\r\n"
+
+          begin
+            eruby = Erubis::Eruby.new(template)
+            output = eruby.evaluate(context)
+          rescue Object => e
+            raise TemplateError.new(e, template, context)
+          end
+
+          if windows_line_endings
+            # Convert line endings from "\n" -> "\r\n". Also converts
+            # "\r\n" -> "\r\n".
+            # This makes the regex match on all of "\r\n", so we don't
+            # accidentally convert "\r\n" -> "\r\r\n".
+            output = output.gsub(/\r?\n/,"\r\n")
+          end
+
+          output
+        end
+
+        def _extend_modules(module_names)
+          module_names.each do |mod|
+            context_methods = [:node, :render, :render_template, :render_template_from_string]
+            context_methods.each do |core_method|
+              if mod.method_defined?(core_method) or mod.private_method_defined?(core_method)
+                Chef::Log.warn("Core template method `#{core_method}' overridden by extension module #{mod}")
+              end
+            end
+            extend(mod)
+            @_extension_modules << mod
+          end
+        end
+
+        # Collects instance variables set on the current object as a Hash
+        # suitable for creating a new TemplateContext. Instance variables that
+        # are only valid for this specific instance are omitted from the
+        # collection.
+        def _public_instance_variables
+          all_ivars = instance_variables
+          all_ivars.delete(:@_extension_modules)
+          all_ivars.inject({}) do |ivar_map, ivar_symbol_name|
+            value = instance_variable_get(ivar_symbol_name)
+            name_without_at = ivar_symbol_name.to_s[1..-1].to_sym
+            ivar_map[name_without_at] = value
+            ivar_map
+          end
         end
       end
-      
+
       class TemplateError < RuntimeError
         attr_reader :original_exception, :context
         SOURCE_CONTEXT_WINDOW = 2
-        
+
         def initialize(original_exception, template, context)
           @original_exception, @template, @context = original_exception, template, context
         end
-        
+
         def message
           @original_exception.message
         end
-        
+
         def line_number
           @line_number ||= $1.to_i if original_exception.backtrace.find {|line| line =~ /\(erubis\):(\d+)/ }
         end
-        
+
         def source_location
           "on line ##{line_number}"
         end
-        
+
         def source_listing
           @source_listing ||= begin
             lines = @template.split(/\n/)
@@ -89,7 +219,7 @@ class Chef
             output.join("\n")
           end
         end
-        
+
         def to_s
           "\n\n#{self.class} (#{message}) #{source_location}:\n\n" +
             "#{source_listing}\n\n  #{original_exception.backtrace.join("\n  ")}\n\n"