openvox 7.37.1 → 8.19.0

data/lib/puppet/parser/compiler.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'forwardable'
 
 require_relative '../../puppet/node'
@@ -22,16 +24,16 @@ class Puppet::Parser::Compiler
     node.environment.check_for_reparse
 
     errors = node.environment.validation_errors
-    if !errors.empty?
+    unless errors.empty?
       errors.each { |e| Puppet.err(e) } if errors.size > 1
       errmsg = [
         _("Compilation has been halted because: %{error}") % { error: errors.first },
-        _("For more information, see https://puppet.com/docs/puppet/latest/environments_about.html"),
+        _("For more information, see https://puppet.com/docs/puppet/latest/environments_about.html")
       ]
       raise(Puppet::Error, errmsg.join(' '))
     end
 
-    new(node, :code_id => code_id).compile {|resulting_catalog| resulting_catalog.to_resource }
+    new(node, :code_id => code_id).compile(&:to_resource)
   rescue Puppet::ParseErrorWithIssue => detail
     detail.node = node.name
     Puppet.log_exception(detail)
@@ -77,8 +79,8 @@ class Puppet::Parser::Compiler
     # Note that this will fail if the resource is not unique.
     @catalog.add_resource(resource)
 
-    if not resource.class? and resource[:stage]
-      #TRANSLATORS "stage" is a keyword in Puppet and should not be translated
+    if !resource.class? and resource[:stage]
+      # TRANSLATORS "stage" is a keyword in Puppet and should not be translated
       raise ArgumentError, _("Only classes can set 'stage'; normal resources like %{resource} cannot change run stage") % { resource: resource }
     end
 
@@ -114,13 +116,13 @@ class Puppet::Parser::Compiler
   def_delegator :@catalog, :classes, :classlist
 
   def with_context_overrides(description = '', &block)
-    Puppet.override( @context_overrides , description, &block)
+    Puppet.override(@context_overrides, description, &block)
   end
 
   # Compiler our catalog.  This mostly revolves around finding and evaluating classes.
   # This is the main entry into our catalog.
   def compile
-    Puppet.override( @context_overrides , _("For compiling %{node}") % { node: node.name }) do
+    Puppet.override(@context_overrides, _("For compiling %{node}") % { node: node.name }) do
       @catalog.environment_instance = environment
 
       # Set the client's parameters into the top scope.
@@ -128,7 +130,7 @@ class Puppet::Parser::Compiler
 
       Puppet::Util::Profiler.profile(_("Compile: Created settings scope"), [:compiler, :create_settings_scope]) { create_settings_scope }
 
-      #TRANSLATORS "main" is a function name and should not be translated
+      # TRANSLATORS "main" is a function name and should not be translated
       Puppet::Util::Profiler.profile(_("Compile: Evaluated main"), [:compiler, :evaluate_main]) { evaluate_main }
 
       Puppet::Util::Profiler.profile(_("Compile: Evaluated AST node"), [:compiler, :evaluate_ast_node]) { evaluate_ast_node }
@@ -162,11 +164,11 @@ class Puppet::Parser::Compiler
   end
 
   # Constructs the overrides for the context
-  def context_overrides()
+  def context_overrides
     {
       :current_environment => environment,
-      :global_scope => @topscope,             # 4x placeholder for new global scope
-      :loaders  => @loaders,                  # 4x loaders
+      :global_scope => @topscope, # 4x placeholder for new global scope
+      :loaders => @loaders, # 4x loaders
     }
   end
 
@@ -184,12 +186,12 @@ class Puppet::Parser::Compiler
   # parameters won't conflict even if the class has already been included.
   def evaluate_node_classes
     if @node.classes.is_a? Hash
-      classes_with_params, classes_without_params = @node.classes.partition {|name,params| params and !params.empty?}
+      classes_with_params, classes_without_params = @node.classes.partition { |_name, params| params and !params.empty? }
 
       # The results from Hash#partition are arrays of pairs rather than hashes,
       # so we have to convert to the forms evaluate_classes expects (Hash, and
       # Array of class names)
-      classes_with_params = Hash[classes_with_params]
+      classes_with_params = classes_with_params.to_h
       classes_without_params.map!(&:first)
     else
       classes_with_params = {}
@@ -205,7 +207,7 @@ class Puppet::Parser::Compiler
   # @api private
   def evaluate_ast_node
     krt = environment.known_resource_types
-    return unless krt.nodes? #ast_nodes?
+    return unless krt.nodes? # ast_nodes?
 
     # Now see if we can find the node.
     astnode = nil
@@ -214,7 +216,7 @@ class Puppet::Parser::Compiler
       break if astnode
     end
 
-    unless (astnode ||= krt.node("default"))
+    unless astnode ||= krt.node("default")
       raise Puppet::ParseError, _("Could not find node statement with name 'default' or '%{names}'") % { names: node.names.join(", ") }
     end
 
@@ -234,10 +236,11 @@ class Puppet::Parser::Compiler
   #
   def evaluate_classes(classes, scope, lazy_evaluate = true)
     raise Puppet::DevError, _("No source for scope passed to evaluate_classes") unless scope.source
+
     class_parameters = nil
     # if we are a param class, save the classes hash
     # and transform classes to be the keys
-    if classes.class == Hash
+    if classes.instance_of?(Hash)
       class_parameters = classes
       classes = classes.keys
     end
@@ -248,14 +251,14 @@ class Puppet::Parser::Compiler
 
     if class_parameters
       resources = ensure_classes_with_parameters(scope, hostclasses, class_parameters)
-      if !lazy_evaluate
+      unless lazy_evaluate
         resources.each(&:evaluate)
       end
 
       resources
     else
       already_included, newly_included = ensure_classes_without_parameters(scope, hostclasses)
-      if !lazy_evaluate
+      unless lazy_evaluate
         newly_included.each(&:evaluate)
       end
 
@@ -342,18 +345,15 @@ class Puppet::Parser::Compiler
     exceptwrap do
       Puppet::Util::Profiler.profile(_("Evaluated definitions"), [:compiler, :evaluate_definitions]) do
         urs = unevaluated_resources.each do |resource|
-          begin
-            resource.evaluate
-          rescue Puppet::Pops::Evaluator::PuppetStopIteration => detail
-            # needs to be handled specifically as the error has the file/line/position where this
-            # occurred rather than the resource
-            fail(Puppet::Pops::Issues::RUNTIME_ERROR, detail, {:detail => detail.message}, detail)
-
-          rescue Puppet::Error => e
-            # PuppetError has the ability to wrap an exception, if so, use the wrapped exception's
-            # call stack instead
-            fail(Puppet::Pops::Issues::RUNTIME_ERROR, resource, {:detail => e.message}, e.original || e)
-          end
+          resource.evaluate
+        rescue Puppet::Pops::Evaluator::PuppetStopIteration => detail
+          # needs to be handled specifically as the error has the file/line/position where this
+          # occurred rather than the resource
+          fail(Puppet::Pops::Issues::RUNTIME_ERROR, detail, { :detail => detail.message }, detail)
+        rescue Puppet::Error => e
+          # PuppetError has the ability to wrap an exception, if so, use the wrapped exception's
+          # call stack instead
+          fail(Puppet::Pops::Issues::RUNTIME_ERROR, resource, { :detail => e.message }, e.original || e)
         end
         !urs.empty?
       end
@@ -411,7 +411,7 @@ class Puppet::Parser::Compiler
   def fail_on_unevaluated_overrides
     remaining = @resource_overrides.values.flatten.collect(&:ref)
 
-    if !remaining.empty?
+    unless remaining.empty?
       raise Puppet::ParseError, _("Could not find resource(s) %{resources} for overriding") % { resources: remaining.join(', ') }
     end
   end
@@ -422,7 +422,7 @@ class Puppet::Parser::Compiler
   #
   def fail_on_unevaluated_resource_collections
     remaining = @collections.collect(&:unresolved_resources).flatten.compact
-    if !remaining.empty?
+    unless remaining.empty?
       raise Puppet::ParseError, _("Failed to realize virtual resources %{resources}") % { resources: remaining.join(', ') }
     end
   end
@@ -455,7 +455,7 @@ class Puppet::Parser::Compiler
   def add_resource_metaparams
     main = catalog.resource(:class, :main)
     unless main
-      #TRANSLATORS "main" is a function name and should not be translated
+      # TRANSLATORS "main" is a function name and should not be translated
       raise _("Couldn't find main")
     end
 
@@ -482,14 +482,14 @@ class Puppet::Parser::Compiler
   def metaparams_as_data(resource, params)
     data = nil
     params.each do |param|
-      unless resource[param].nil?
-        # Because we could be creating a hash for every resource,
-        # and we actually probably don't often have any data here at all,
-        # we're optimizing a bit by only creating a hash if there's
-        # any data to put in it.
-        data ||= {}
-        data[param] = resource[param]
-      end
+      next if resource[param].nil?
+
+      # Because we could be creating a hash for every resource,
+      # and we actually probably don't often have any data here at all,
+      # we're optimizing a bit by only creating a hash if there's
+      # any data to put in it.
+      data ||= {}
+      data[param] = resource[param]
     end
     data
   end
@@ -529,7 +529,7 @@ class Puppet::Parser::Compiler
     # It cannot survive the initvars method, and is later reinstated
     # as part of compiling...
     #
-    Puppet.override( @context_overrides , _("For initializing compiler")) do
+    Puppet.override(@context_overrides, _("For initializing compiler")) do
       # THE MAGIC STARTS HERE ! This triggers parsing, loading etc.
       @catalog.version = environment.known_resource_types.version
       @loaders.pre_load
@@ -541,7 +541,7 @@ class Puppet::Parser::Compiler
     @resources = []
 
     # Make sure any external node classes are in our class list
-    if @node.classes.class == Hash
+    if @node.classes.instance_of?(Hash)
       @catalog.add_class(*@node.classes.keys)
     else
       @catalog.add_class(*@node.classes)
@@ -563,6 +563,7 @@ class Puppet::Parser::Compiler
       # case a custom node terminus has done any mucking about with
       # node.parameters.
       next if param.to_s == 'environment'
+
       # Ensure node does not leak Symbol instances in general
       @topscope[param.to_s] = value.is_a?(Symbol) ? value.to_s : value
     end
@@ -579,7 +580,7 @@ class Puppet::Parser::Compiler
     @topscope.set_facts(facts_hash)
   end
 
-  SETTINGS = 'settings'.freeze
+  SETTINGS = 'settings'
 
   def create_settings_scope
     settings_type = create_settings_type

data/lib/puppet/parser/e4_parser_adapter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../puppet/pops'
 
 module Puppet
@@ -6,7 +8,6 @@ module Parser
 # and makes use of the new evaluator.
 #
 class E4ParserAdapter
-
   def initialize
     @file = ''
     @string = ''
@@ -19,17 +20,17 @@ class E4ParserAdapter
   end
 
   def parse(string = nil)
-    self.string= string if string
+    self.string = string if string
     parser = Pops::Parser::EvaluatingParser.singleton
     model =
-    if @use == :string
-      # Parse with a source_file to set in created AST objects (it was either given, or it may be unknown
-      # if caller did not set a file and the present a string.
-      #
-      parser.parse_string(@string, @file || "unknown-source-location")
-    else
-      parser.parse_file(@file)
-    end
+      if @use == :string
+        # Parse with a source_file to set in created AST objects (it was either given, or it may be unknown
+        # if caller did not set a file and the present a string.
+        #
+        parser.parse_string(@string, @file || "unknown-source-location")
+      else
+        parser.parse_file(@file)
+      end
 
     # the parse_result may be
     # * empty / nil (no input)
@@ -40,12 +41,12 @@ class E4ParserAdapter
     Pops::Model::AstTransformer.new(@file).merge_location(args, model)
 
     ast_code =
-    if model.is_a? Pops::Model::Program
-      AST::PopsBridge::Program.new(model, args)
-    else
-      args[:value] = model
-      AST::PopsBridge::Expression.new(args)
-    end
+      if model.is_a? Pops::Model::Program
+        AST::PopsBridge::Program.new(model, args)
+      else
+        args[:value] = model
+        AST::PopsBridge::Expression.new(args)
+      end
 
     # Create the "main" class for the content - this content will get merged with all other "main" content
     AST::Hostclass.new('', :code => ast_code)

data/lib/puppet/parser/files.rb

@@ -1,5 +1,6 @@
-module Puppet::Parser::Files
+# frozen_string_literal: true
 
+module Puppet::Parser::Files
   module_function
 
   # Return a list of manifests as absolute filenames matching the given
@@ -28,9 +29,10 @@ module Puppet::Parser::Files
   #   * modulename/filename selector: a file is found in the file directory
   #     of the named module.
   #
-  # In the second case a nil is returned if there isn't a file found. In the
-  # first case (absolute path), there is no existence check done and so the
-  # path will be returned even if there isn't a file available.
+  # The check for file existence is performed on the node compiling the
+  # manifest. A node running "puppet apply" compiles its own manifest, but
+  # a node running "puppet agent" depends on the configured puppetserver
+  # for compiling. In either case, a nil is returned if no file is found.
   #
   # @param template [String] the file selector
   # @param environment [Puppet::Node::Environment] the environment in which to search
@@ -38,7 +40,7 @@ module Puppet::Parser::Files
   #
   # @api private
   def find_file(file, environment)
-    find_in_module(file, environment) do |mod,module_file|
+    find_in_module(file, environment) do |mod, module_file|
       mod.file(module_file)
     end
   end
@@ -59,7 +61,7 @@ module Puppet::Parser::Files
   #
   # @api private
   def find_template(template, environment)
-    find_in_module(template, environment) do |mod,template_file|
+    find_in_module(template, environment) do |mod, template_file|
       mod.template(template_file)
     end
   end

data/lib/puppet/parser/functions/assert_type.rb

@@ -1,60 +1,62 @@
-Puppet::Parser::Functions::newfunction(
+# frozen_string_literal: true
+
+Puppet::Parser::Functions.newfunction(
   :assert_type,
   :type => :rvalue,
   :arity => -3,
-  :doc => <<DOC
-Returns the given value if it is of the given
-[data type](https://puppet.com/docs/puppet/latest/lang_data.html), or
-otherwise either raises an error or executes an optional two-parameter
-[lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html).
+  :doc => <<~DOC
+    Returns the given value if it is of the given
+    [data type](https://puppet.com/docs/puppet/latest/lang_data.html), or
+    otherwise either raises an error or executes an optional two-parameter
+    [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html).
 
-The function takes two mandatory arguments, in this order:
+    The function takes two mandatory arguments, in this order:
 
-1. The expected data type.
-2. A value to compare against the expected data type.
+    1. The expected data type.
+    2. A value to compare against the expected data type.
 
-**Example**: Using `assert_type`
+    **Example**: Using `assert_type`
 
-~~~ puppet
-$raw_username = 'Amy Berry'
+    ~~~ puppet
+    $raw_username = 'Amy Berry'
 
-# Assert that $raw_username is a non-empty string and assign it to $valid_username.
-$valid_username = assert_type(String[1], $raw_username)
+    # Assert that $raw_username is a non-empty string and assign it to $valid_username.
+    $valid_username = assert_type(String[1], $raw_username)
 
-# $valid_username contains "Amy Berry".
-# If $raw_username was an empty string or a different data type, the Puppet run would
-# fail with an "Expected type does not match actual" error.
-~~~
+    # $valid_username contains "Amy Berry".
+    # If $raw_username was an empty string or a different data type, the Puppet run would
+    # fail with an "Expected type does not match actual" error.
+    ~~~
 
-You can use an optional lambda to provide enhanced feedback. The lambda takes two
-mandatory parameters, in this order:
+    You can use an optional lambda to provide enhanced feedback. The lambda takes two
+    mandatory parameters, in this order:
 
-1. The expected data type as described in the function's first argument.
-2. The actual data type of the value.
+    1. The expected data type as described in the function's first argument.
+    2. The actual data type of the value.
 
-**Example**: Using `assert_type` with a warning and default value
+    **Example**: Using `assert_type` with a warning and default value
 
-~~~ puppet
-$raw_username = 'Amy Berry'
+    ~~~ puppet
+    $raw_username = 'Amy Berry'
 
-# Assert that $raw_username is a non-empty string and assign it to $valid_username.
-# If it isn't, output a warning describing the problem and use a default value.
-$valid_username = assert_type(String[1], $raw_username) |$expected, $actual| {
-  warning( "The username should be \'${expected}\', not \'${actual}\'. Using 'anonymous'." )
-  'anonymous'
-}
+    # Assert that $raw_username is a non-empty string and assign it to $valid_username.
+    # If it isn't, output a warning describing the problem and use a default value.
+    $valid_username = assert_type(String[1], $raw_username) |$expected, $actual| {
+      warning( "The username should be \'${expected}\', not \'${actual}\'. Using 'anonymous'." )
+      'anonymous'
+    }
 
-# $valid_username contains "Amy Berry".
-# If $raw_username was an empty string, the Puppet run would set $valid_username to
-# "anonymous" and output a warning: "The username should be 'String[1, default]', not
-# 'String[0, 0]'. Using 'anonymous'."
-~~~
+    # $valid_username contains "Amy Berry".
+    # If $raw_username was an empty string, the Puppet run would set $valid_username to
+    # "anonymous" and output a warning: "The username should be 'String[1, default]', not
+    # 'String[0, 0]'. Using 'anonymous'."
+    ~~~
 
-For more information about data types, see the
-[documentation](https://puppet.com/docs/puppet/latest/lang_data.html).
+    For more information about data types, see the
+    [documentation](https://puppet.com/docs/puppet/latest/lang_data.html).
 
-- Since 4.0.0
-DOC
-) do |args|
+    - Since 4.0.0
+  DOC
+) do |_args|
   Puppet::Parser::Functions::Error.is4x('assert_type')
 end

data/lib/puppet/parser/functions/binary_file.rb

@@ -1,24 +1,26 @@
-Puppet::Parser::Functions::newfunction(
+# frozen_string_literal: true
+
+Puppet::Parser::Functions.newfunction(
   :binary_file,
   :type => :rvalue,
   :arity => 1,
-:doc => <<-DOC
-Loads a binary file from a module or file system and returns its contents as a Binary.
+  :doc => <<~DOC
+    Loads a binary file from a module or file system and returns its contents as a Binary.
 
-The argument to this function should be a `<MODULE NAME>/<FILE>`
-reference, which will load `<FILE>` from a module's `files`
-directory. (For example, the reference `mysql/mysqltuner.pl` will load the
-file `<MODULES DIRECTORY>/mysql/files/mysqltuner.pl`.)
+    The argument to this function should be a `<MODULE NAME>/<FILE>`
+    reference, which will load `<FILE>` from a module's `files`
+    directory. (For example, the reference `mysql/mysqltuner.pl` will load the
+    file `<MODULES DIRECTORY>/mysql/files/mysqltuner.pl`.)
 
-This function also accepts an absolute file path that allows reading
-binary file content from anywhere on disk.
+    This function also accepts an absolute file path that allows reading
+    binary file content from anywhere on disk.
 
-An error is raised if the given file does not exists.
+    An error is raised if the given file does not exists.
 
-To search for the existence of files, use the `find_file()` function.
+    To search for the existence of files, use the `find_file()` function.
 
-- since 4.8.0
-DOC
-) do |args|
+    - since 4.8.0
+  DOC
+) do |_args|
   Puppet::Parser::Functions::Error.is4x('binary_file')
 end

data/lib/puppet/parser/functions/break.rb

@@ -1,39 +1,41 @@
-Puppet::Parser::Functions::newfunction(
+# frozen_string_literal: true
+
+Puppet::Parser::Functions.newfunction(
   :break,
   :arity => 0,
-  :doc => <<-DOC
-Breaks the innermost iteration as if it encountered an end of input.
-This function does not return to the caller.
+  :doc => <<~DOC
+    Breaks the innermost iteration as if it encountered an end of input.
+    This function does not return to the caller.
 
-The signal produced to stop the iteration bubbles up through
-the call stack until either terminating the innermost iteration or
-raising an error if the end of the call stack is reached.
+    The signal produced to stop the iteration bubbles up through
+    the call stack until either terminating the innermost iteration or
+    raising an error if the end of the call stack is reached.
 
-The break() function does not accept an argument.
+    The break() function does not accept an argument.
 
-**Example:** Using `break`
+    **Example:** Using `break`
 
-```puppet
-$data = [1,2,3]
-notice $data.map |$x| { if $x == 3 { break() } $x*10 }
-```
+    ```puppet
+    $data = [1,2,3]
+    notice $data.map |$x| { if $x == 3 { break() } $x*10 }
+    ```
 
-Would notice the value `[10, 20]`
+    Would notice the value `[10, 20]`
 
-**Example:** Using a nested `break`
+    **Example:** Using a nested `break`
 
-```puppet
-function break_if_even($x) {
-  if $x % 2 == 0 { break() }
-}
-$data = [1,2,3]
-notice $data.map |$x| { break_if_even($x); $x*10 }
-```
-Would notice the value `[10]`
+    ```puppet
+    function break_if_even($x) {
+      if $x % 2 == 0 { break() }
+    }
+    $data = [1,2,3]
+    notice $data.map |$x| { break_if_even($x); $x*10 }
+    ```
+    Would notice the value `[10]`
 
-* Also see functions `next` and `return`
-* Since 4.8.0
-DOC
-) do |args|
+    * Also see functions `next` and `return`
+    * Since 4.8.0
+  DOC
+) do |_args|
   Puppet::Parser::Functions::Error.is4x('break')
 end

data/lib/puppet/parser/functions/contain.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 # Called within a class definition, establishes a containment
 # relationship with another class
 
-Puppet::Parser::Functions::newfunction(
+Puppet::Parser::Functions.newfunction(
   :contain,
   :arity => -2,
   :doc => "Contain one or more classes inside the current class. If any of

data/lib/puppet/parser/functions/create_resources.rb

@@ -1,6 +1,8 @@
-Puppet::Parser::Functions::newfunction(:create_resources, :arity => -3, :doc => <<-'ENDHEREDOC') do |args|
+# frozen_string_literal: true
+
+Puppet::Parser::Functions.newfunction(:create_resources, :arity => -3, :doc => <<-'ENDHEREDOC') do |args|
     Converts a hash into a set of resources and adds them to the catalog.
-    
+
     **Note**: Use this function selectively. It's generally better to write resources in
      [Puppet](https://puppet.com/docs/puppet/latest/lang_resources.html), as
      resources created with `create_resource` are difficult to read and troubleshoot.
@@ -50,17 +52,19 @@ Puppet::Parser::Functions::newfunction(:create_resources, :arity => -3, :doc =>
     data binding and Puppet default value expressions are considered (in that order) for the
     final value of a parameter (just as when setting a parameter to `undef` in a Puppet language
     resource declaration).
-  ENDHEREDOC
+ENDHEREDOC
   if Puppet[:tasks]
     raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
       Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING,
-      {:operation => 'create_resources'})
+      { :operation => 'create_resources' }
+    )
   end
 
   raise ArgumentError, (_("create_resources(): wrong number of arguments (%{count}; must be 2 or 3)") % { count: args.length }) if args.length > 3
-  raise ArgumentError, (_('create_resources(): second argument must be a hash')) unless args[1].is_a?(Hash)
+  raise ArgumentError, _('create_resources(): second argument must be a hash') unless args[1].is_a?(Hash)
+
   if args.length == 3
-    raise ArgumentError, (_('create_resources(): third argument, if provided, must be a hash')) unless args[2].is_a?(Hash)
+    raise ArgumentError, _('create_resources(): third argument, if provided, must be a hash') unless args[2].is_a?(Hash)
   end
 
   type, instances, defaults = args
@@ -89,22 +93,22 @@ Puppet::Parser::Functions::newfunction(:create_resources, :arity => -3, :doc =>
 
   instances.map do |title, params|
     # Add support for iteration if title is an array
-    resource_titles = title.is_a?(Array) ? title  : [title]
+    resource_titles = title.is_a?(Array) ? title : [title]
     Puppet::Pops::Evaluator::Runtime3ResourceSupport.create_resources(
       file, line,
       self,
       virtual, exported,
       type_name,
       resource_titles,
-      defaults.merge(params).map do |name, value|
+      defaults.merge(params).filter_map do |name, value|
         value = nil if value == :undef
         Puppet::Parser::Resource::Param.new(
-          :name   => name,
-          :value  => value, # wide open to various data types, must be correct
-          :source => self.source, # TODO: support :line => line, :file => file,
-          :add    => false
+          :name => name,
+          :value => value, # wide open to various data types, must be correct
+          :source => source, # TODO: support :line => line, :file => file,
+          :add => false
         )
-      end.compact
-      )
+      end
+    )
   end.flatten.compact
 end