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

data/lib/chef/node/attribute.rb

@@ -1,4 +1,4 @@
-#
+#--
 # Author:: Adam Jacob (<adam@opscode.com>)
 # Author:: AJ Christensen (<aj@opscode.com>)
 # Copyright:: Copyright (c) 2008 Opscode, Inc.
@@ -17,488 +17,382 @@
 # limitations under the License.
 #
 
+require 'chef/node/immutable_collections'
+require 'chef/node/attribute_collections'
 require 'chef/mixin/deep_merge'
 require 'chef/log'
 
 class Chef
   class Node
-    class Attribute
-      HIDDEN_ATTRIBUES = [:@override, :@attribute, :@default, :@normal, :@automatic]
-
-      attr_accessor :normal,
-                    :default,
-                    :override,
-                    :automatic,
-                    :current_normal,
-                    :current_default,
-                    :current_override,
-                    :current_automatic,
-                    :auto_vivifiy_on_read,
-                    :set_unless_value_present,
-                    :set_type
+
+    # == Attribute
+    # Attribute implements a nested key-value (Hash) and flat collection
+    # (Array) data structure supporting multiple levels of precedence, such
+    # that a given key may have multiple values internally, but will only
+    # return the highest precedence value when reading.
+    class Attribute < Mash
+
+      include Immutablize
 
       include Enumerable
 
-      def initialize(normal, default, override, automatic, state=[])
-        @normal = normal
-        @current_normal = normal
-        @default = default
-        @current_default = default
-        @override = override
-        @current_override = override
-        @automatic = automatic
-        @current_automatic = automatic
-        @current_nesting_level = state
-        @auto_vivifiy_on_read = false
-        @set_unless_value_present = false
-        @set_type = nil
-        @has_been_read = false
-      end
-
-      def attribute
-        normal
-      end
-
-      def attribute=(value)
-        normal = value
-      end
-
-      def set_type_hash
-        case @set_type
-        when :normal
-          @normal
-        when :override
-          @override
-        when :default
-          @default
-        when :automatic
-          @automatic
-        end
-      end
-
-      # Reset our internal current_nesting_level to the top of every tree
-      def reset
-        @current_normal = @normal
-        @current_default = @default
-        @current_override = @override
-        @current_automatic = @automatic
-        @has_been_read = false
-        @current_nesting_level = []
-      end
-
-      def [](key)
-        @current_nesting_level << key
-
-        # We set this to so that we can cope with ||= as a setting.
-        # See the comments in []= for more details.
-        @has_been_read = true
-
-        # If we have a set type, our destiny is to write
-        if @set_type
-          a_value = @set_type == :automatic ? value_or_descend(current_automatic, key, auto_vivifiy_on_read) : nil
-          o_value = @set_type == :override ? value_or_descend(current_override, key, auto_vivifiy_on_read) : nil
-          n_value = @set_type == :normal ? value_or_descend(current_normal, key, auto_vivifiy_on_read) : nil
-          d_value = @set_type == :default ? value_or_descend(current_default, key, auto_vivifiy_on_read) : nil
-
-          determine_value(a_value, o_value, n_value, d_value)
-        # Our destiny is only to read, so we get the full list.
-        else
-          a_value = value_or_descend(current_automatic, key)
-          o_value = value_or_descend(current_override, key)
-          n_value = value_or_descend(current_normal, key)
-          d_value = value_or_descend(current_default, key)
-
-          determine_value(a_value, o_value, n_value, d_value)
-        end
-      end
-
-      def has_key?(key)
-        return true if component_has_key?(@default,key)
-        return true if component_has_key?(@automatic,key)
-        return true if component_has_key?(@normal,key)
-        return true if component_has_key?(@override,key)
-        false
-      end
-
-      alias :attribute? :has_key?
-      alias :include?   :has_key?
-      alias :key?       :has_key?
-      alias :member?    :has_key?
-
-      def each(&block)
-        get_keys.each do |key|
-          value = determine_value(
-            get_value(automatic, key),
-            get_value(override, key),
-            get_value(normal, key),
-            get_value(default, key)
-          )
-          block.call([key, value])
-        end
-      end
-
-      def each_pair(&block)
-        get_keys.each do |key|
-          value = determine_value(
-            get_value(automatic, key),
-            get_value(override, key),
-            get_value(normal, key),
-            get_value(default, key)
-          )
-          block.call(key, value)
-        end
-      end
-
-      def each_attribute(&block)
-        get_keys.each do |key|
-          value = determine_value(
-            get_value(automatic, key),
-            get_value(override, key),
-            get_value(normal, key),
-            get_value(default, key)
-          )
-          block.call(key, value)
-        end
-      end
-
-      def each_key(&block)
-        get_keys.each do |key|
-          block.call(key)
-        end
-      end
-
-      def each_value(&block)
-        get_keys.each do |key|
-          value = determine_value(
-            get_value(automatic, key),
-            get_value(override, key),
-            get_value(normal, key),
-            get_value(default, key)
-          )
-          block.call(value)
-        end
-      end
-
-      def empty?
-        get_keys.empty?
-      end
-
-      def fetch(key, default_value=nil, &block)
-        if get_keys.include? key
-          determine_value(
-            get_value(automatic, key),
-            get_value(override, key),
-            get_value(normal, key),
-            get_value(default, key)
-          )
-        elsif default_value
-          default_value
-        elsif block_given?
-          block.call(key)
-        else
-          raise IndexError, "Key #{key} does not exist"
-        end
-      end
-
-      # Writing this method hurts me a little bit.
-      #
-      # TODO: Refactor all this stuff so this kind of horror is no longer needed
-      #
-      # We have invented a new kind of duck-typing, we call it Madoff typing.
-      # We just lie and hope we die before you recognize our scheme. :)
-      def kind_of?(klass)
-        if klass == Hash || klass == Mash || klass == Chef::Node::Attribute
-          true
-        else
-          false
-        end
-      end
-
-      def has_value?(value)
-        self.any? do |k,v|
-          value == v
-        end
-      end
-
-      alias :value? :has_value?
-
-      def index(value)
-        index = self.find do |h|
-          value == h[1]
-        end
-        index.first if index.is_a? Array || nil
-      end
-
-      def values
-        self.collect { |h| h[1] }
-      end
-
-      def size
-        self.collect{}.length
-      end
-
-      alias :length :size
-
-      def get_keys
-        keys
-      end
-
-      def keys
-        tkeys = current_automatic ? current_automatic.keys : []
-        [ current_override, current_normal, current_default ].each do |attr_hash|
-          if attr_hash
-            attr_hash.keys.each do |key|
-              tkeys << key unless tkeys.include?(key)
+      # List of the component attribute hashes, in order of precedence, low to
+      # high.
+      COMPONENTS = [
+        :@default,
+        :@env_default,
+        :@role_default,
+        :@force_default,
+        :@normal,
+        :@override,
+        :@role_override,
+        :@env_override,
+        :@force_override,
+        :@automatic
+      ].freeze
+
+      DEFAULT_COMPONENTS = [
+        :@default,
+        :@env_default,
+        :@role_default,
+        :@force_default
+      ]
+
+
+      OVERRIDE_COMPONENTS = [
+        :@override,
+        :@role_override,
+        :@env_override,
+        :@force_override
+      ]
+
+      [:all?,
+       :any?,
+       :assoc,
+       :chunk,
+       :collect,
+       :collect_concat,
+       :compare_by_identity,
+       :compare_by_identity?,
+       :count,
+       :cycle,
+       :detect,
+       :drop,
+       :drop_while,
+       :each,
+       :each_cons,
+       :each_entry,
+       :each_key,
+       :each_pair,
+       :each_slice,
+       :each_value,
+       :each_with_index,
+       :each_with_object,
+       :empty?,
+       :entries,
+       :except,
+       :fetch,
+       :find,
+       :find_all,
+       :find_index,
+       :first,
+       :flat_map,
+       :flatten,
+       :grep,
+       :group_by,
+       :has_value?,
+       :include?,
+       :index,
+       :inject,
+       :invert,
+       :key,
+       :keys,
+       :length,
+       :map,
+       :max,
+       :max_by,
+       :merge,
+       :min,
+       :min_by,
+       :minmax,
+       :minmax_by,
+       :none?,
+       :one?,
+       :partition,
+       :rassoc,
+       :reduce,
+       :reject,
+       :reverse_each,
+       :select,
+       :size,
+       :slice_before,
+       :sort,
+       :sort_by,
+       :store,
+       :symbolize_keys,
+       :take,
+       :take_while,
+       :to_a,
+       :to_hash,
+       :to_set,
+       :value?,
+       :values,
+       :values_at,
+       :zip].each do |delegated_method|
+         class_eval(<<-METHOD_DEFN)
+            def #{delegated_method}(*args, &block)
+              merged_attributes.send(:#{delegated_method}, *args, &block)
             end
-          end
-        end
-        tkeys
-      end
-
-      def get_value(data_hash, key)
-        last = nil
-
-        if @current_nesting_level.length == 0
-          if data_hash.has_key?(key) && ! data_hash[key].nil?
-            return data_hash[key]
-          else
-            return nil
-          end
-        end
-
-        0.upto(@current_nesting_level.length) do |i|
-          if i == 0
-            last = auto_vivifiy(data_hash, @current_nesting_level[i])
-          elsif i == @current_nesting_level.length
-            fk = last[@current_nesting_level[i - 1]]
-            if fk.has_key?(key) && ! fk[key].nil?
-              return fk[key]
-            else
-              return nil
-            end
-          else
-            last = auto_vivifiy(last[@current_nesting_level[i - 1]], @current_nesting_level[i])
-          end
-        end
-      end
-
-      def hash_and_not_cna?(to_check)
-        (! to_check.kind_of?(Chef::Node::Attribute)) && to_check.respond_to?(:has_key?)
-      end
-
-      def determine_value(a_value, o_value, n_value, d_value)
-        if hash_and_not_cna?(a_value)
-          value = {}
-          value = Chef::Mixin::DeepMerge.merge(value, d_value) if hash_and_not_cna?(d_value)
-          value = Chef::Mixin::DeepMerge.merge(value, n_value) if hash_and_not_cna?(n_value)
-          value = Chef::Mixin::DeepMerge.merge(value, o_value) if hash_and_not_cna?(o_value)
-          value = Chef::Mixin::DeepMerge.merge(value, a_value)
-          value
-        elsif hash_and_not_cna?(o_value)
-          value = {}
-          value = Chef::Mixin::DeepMerge.merge(value, d_value) if hash_and_not_cna?(d_value)
-          value = Chef::Mixin::DeepMerge.merge(value, n_value) if hash_and_not_cna?(n_value)
-          value = Chef::Mixin::DeepMerge.merge(value, o_value)
-          value
-        elsif hash_and_not_cna?(n_value)
-          value = {}
-          value = Chef::Mixin::DeepMerge.merge(value, d_value) if hash_and_not_cna?(d_value)
-          value = Chef::Mixin::DeepMerge.merge(value, n_value)
-          value
-        elsif hash_and_not_cna?(d_value)
-          d_value
-        else
-          return a_value if ! a_value.nil?
-          return o_value if ! o_value.nil?
-          return n_value if ! n_value.nil?
-          return d_value if ! d_value.nil?
-          return nil
-        end
-      end
-
-      def []=(key, value)
-        # If we don't have one, then we'll pretend we're normal
-        if @set_type.nil?
-          @set_type = :normal
-          warning=<<-W
-Setting attributes without specifying a precedence is deprecated and will be
-removed in Chef 11.0. To set attributes at normal precedence, change code like:
-`node["key"] = "value"` # Not this
-to:
-`node.set["key"] = "value"` # This
-
-Called from:
-W
-
-          warning_with_line_nrs = caller[0...3].inject(warning) do |msg, source_line|
-            msg << "  #{source_line}\n"
-          end
-
-          Chef::Log.warn(warning_with_line_nrs) if Chef::Config[:chef11_deprecation_warnings]
-        end
-
-        if set_unless_value_present
-          if get_value(set_type_hash, key) != nil
-            Chef::Log.debug("Not setting #{@current_nesting_level.join("/")}/#{key} to #{value.inspect} because it has a #{@set_type} value already")
-            return false
-          end
-        end
-
-        # If we have been read, and the key we are writing is the same
-        # as our parent, we have most like been ||='ed.  So we need to
-        # just rewind a bit.
-        #
-        # In practice, these objects are single use - this is just
-        # supporting one more single-use style.
-        @current_nesting_level.pop if @has_been_read && @current_nesting_level.last == key
-
-        set_value(set_type_hash, key, value)
-        value
-      end
-
-      def set_value(data_hash, key, value)
-        last = nil
-
-        # If there is no current_nesting_level, just set the value
-        if @current_nesting_level.length == 0
-          data_hash[key] = value
-          return data_hash
-        end
-
-        # Walk all the previous places we have been
-        0.upto(@current_nesting_level.length) do |i|
-          # If we are the first, we are top level, and should vivifiy the data_hash
-          if i == 0
-            last = auto_vivifiy(data_hash, @current_nesting_level[i])
-          # If we are one past the last current_nesting_level, we are adding a key to that hash with a value
-          elsif i == @current_nesting_level.length
-            last[@current_nesting_level[i - 1]][key] = value
-          # Otherwise, we're auto-vivifiy-ing an interim mash
-          else
-            last = auto_vivifiy(last[@current_nesting_level[i - 1]], @current_nesting_level[i])
-          end
-        end
-        data_hash
-      end
-
-      def auto_vivifiy_on_read?
-        auto_vivifiy_on_read
-      end
-
-      def auto_vivifiy(data_hash, key)
-        if data_hash.has_key?(key)
-          unless data_hash[key].respond_to?(:has_key?)
-            raise ArgumentError, "You tried to set a nested key, where the parent is not a hash-like object: #{@current_nesting_level.join("/")}/#{key} " unless auto_vivifiy_on_read
-          end
-        else
-          data_hash[key] = Mash.new
-        end
-        data_hash
-      end
-
-      def value_or_descend(data_hash, key, auto_vivifiy=false)
-        if auto_vivifiy
-          hash_to_vivifiy = auto_vivifiy(data_hash, key)
-          data_hash[key] = hash_to_vivifiy[key]
-        else
-          return nil if data_hash == nil
-          return nil unless data_hash.has_key?(key)
-        end
-
-        if data_hash[key].respond_to?(:has_key?)
-          cna = Chef::Node::Attribute.new(@normal, @default, @override, @automatic, @current_nesting_level)
-          cna.current_normal = current_normal.nil? ? Mash.new : current_normal[key]
-          cna.current_default   = current_default.nil? ? Mash.new : current_default[key]
-          cna.current_override  = current_override.nil? ? Mash.new : current_override[key]
-          cna.current_automatic  = current_automatic.nil? ? Mash.new : current_automatic[key]
-          cna.auto_vivifiy_on_read = auto_vivifiy_on_read
-          cna.set_unless_value_present = set_unless_value_present
-          cna.set_type = set_type
-          cna
-        else
-          data_hash[key]
-        end
-      end
-
-      # Fetches or sets the value, depending on if any arguments are given.
-      # ==== Fetching
-      # If no arguments are given, fetches the value:
-      #   node.network
-      #   => {network data}
-      # Getters will find either a string or symbol key.
-      # ==== Setting
-      # If arguments are given, a value will be set. Both normal setter and DSL
-      # style setters are allowed:
-      #   node.foo = "bar"
-      #   node.foo("bar")
-      # Both set node[:foo] = "bar"
-      def method_missing(symbol, *args)
-        if args.empty?
-          if key?(symbol)
-            self[symbol]
-          elsif key?(symbol.to_s)
-            self[symbol.to_s]
-          elsif auto_vivifiy_on_read?
-            self[symbol] = Mash.new
-            self[symbol]
-          else
-            raise ArgumentError, "Attribute #{symbol} is not defined!" unless auto_vivifiy_on_read
-          end
-        else
-          key_to_set = symbol.to_s[/^(.+)=$/, 1] || symbol
-          self[key_to_set] = (args.length == 1 ? args[0] : args)
-        end
-      end
-
-      def inspect
-        determine_value(current_automatic, current_override, current_normal, current_default)
-
-        "#<#{self.class} " << instance_variables.map{|iv|
-          iv.to_s + '=' + (HIDDEN_ATTRIBUES.include?(iv.to_sym) ? "{...}" : instance_variable_get(iv).inspect)
-        }.join(', ') << ">"
-      end
-
-      def to_hash
-        result = determine_value(current_automatic, current_override, current_normal, current_default)
-        if result.class == Hash
-          result
-        else
-          result.to_hash
-        end
-      end
-
-      def delete(key)
-        [@automatic, @override, @normal, @default].inject(nil) do |return_value, attrs|
-          deleted_value = delete_from_component(attrs, key)
-          return_value || deleted_value
-        end
-      end
-
-      def delete_from_component(component_attrs, key)
-        # get the Hash-like object at the current nesting level:
-        nested_attrs = value_at_current_nesting(component_attrs, key)
-
-        if nested_attrs.respond_to?(:delete)
-          nested_attrs.delete(key)
-        else
-          nil
-        end
-      end
-
-      def component_has_key?(component_attrs,key)
-        # get the Hash-like object at the current nesting level:
-        nested_attrs = value_at_current_nesting(component_attrs, key)
-        nested_attrs.respond_to?(:key?) && nested_attrs.key?(key)
-      end
-
-      def value_at_current_nesting(component_attrs, key)
-        @current_nesting_level.inject(component_attrs) do |subtree, intermediate_key|
-          # if the intermediate value isn't a hash or doesn't have the intermediate key,
-          # it can't have the bottom-level key we're looking for.
-          (subtree.respond_to?(:key?) && subtree[intermediate_key]) or (return false)
-        end
-      end
+         METHOD_DEFN
+       end
+
+
+       # return the cookbook level default attribute component
+       attr_reader :default
+
+       # return the role level default attribute component
+       attr_reader :role_default
+
+       # return the environment level default attribute component
+       attr_reader :env_default
+
+       # return the force_default level attribute component
+       attr_reader :force_default
+
+       # default! is the "advertised" method for force_default, but is
+       # implemented as an alias because instance variables can't (easily) have
+       # +!+ characters.
+       alias :default! :force_default
+
+       # return the "normal" level attribute component
+       attr_reader :normal
+
+       # return the cookbook level override attribute component
+       attr_reader :override
+
+       # return the role level override attribute component
+       attr_reader :role_override
+
+       # return the enviroment level override attribute component
+       attr_reader :env_override
+
+       # return the force override level attribute component
+       attr_reader :force_override
+
+       # +override!+ is the "advertised" method for +force_override+ but is
+       # implemented as an alias because instance variables can't easily have
+       # +!+ characters.
+       alias :override! :force_override
+
+       # return the automatic level attribute component
+       attr_reader :automatic
+
+       def initialize(normal, default, override, automatic)
+         @set_unless_present = false
+
+         @default = VividMash.new(self, default)
+         @env_default = VividMash.new(self, {})
+         @role_default = VividMash.new(self, {})
+         @force_default = VividMash.new(self, {})
+
+         @normal = VividMash.new(self, normal)
+
+         @override = VividMash.new(self, override)
+         @role_override = VividMash.new(self, {})
+         @env_override = VividMash.new(self, {})
+         @force_override = VividMash.new(self, {})
+
+         @automatic = VividMash.new(self, automatic)
+
+         @merged_attributes = nil
+         @combined_override = nil
+         @combined_default = nil
+       end
+
+       # Debug what's going on with an attribute. +args+ is a path spec to the
+       # attribute you're interested in. For example, to debug where the value
+       # of `node[:network][:default_interface]` is coming from, use:
+       #   debug_value(:network, :default_interface).
+       # The return value is an Array of Arrays. The first element is
+       # `["set_unless_enabled?", Boolean]`, which describes whether the
+       # attribute collection is in "set_unless" mode. The rest of the Arrays
+       # are pairs of `["precedence_level", value]`, where precedence level is
+       # the component, such as role default, normal, etc. and value is the
+       # attribute value set at that precedence level. If there is no value at
+       # that precedence level, +value+ will be the symbol +:not_present+.
+       def debug_value(*args)
+         components = COMPONENTS.map do |component|
+           ivar = instance_variable_get(component)
+           value = args.inject(ivar) do |so_far, key|
+             if so_far == :not_present
+               :not_present
+             elsif so_far.has_key?(key)
+               so_far[key]
+             else
+               :not_present
+             end
+           end
+           [component.to_s.sub(/^@/,""), value]
+         end
+         [["set_unless_enabled?", @set_unless_present]] + components
+       end
+
+       # Enables or disables `||=`-like attribute setting. See, e.g., Node#set_unless
+       def set_unless_value_present=(setting)
+         @set_unless_present = setting
+       end
+
+       # Clears merged_attributes, which will cause it to be recomputed on the
+       # next access. 
+       def reset_cache
+         @merged_attributes = nil
+         @combined_default  = nil
+         @combined_override = nil
+         @set_unless_present = false
+       end
+
+       alias :reset :reset_cache
+
+       # Set the cookbook level default attribute component to +new_data+.
+       def default=(new_data)
+         reset
+         @default = VividMash.new(self, new_data)
+       end
+
+       # Set the role level default attribute component to +new_data+
+       def role_default=(new_data)
+         reset
+         @role_default = VividMash.new(self, new_data)
+       end
+
+       # Set the environment level default attribute component to +new_data+
+       def env_default=(new_data)
+         reset
+         @env_default = VividMash.new(self, new_data)
+       end
+
+       # Set the force_default (+default!+) level attributes to +new_data+
+       def force_default=(new_data)
+         reset
+         @force_default = VividMash.new(self, new_data)
+       end
+
+       # Set the normal level attribute component to +new_data+
+       def normal=(new_data)
+         reset
+         @normal = VividMash.new(self, new_data)
+       end
+
+       # Set the cookbook level override attribute component to +new_data+
+       def override=(new_data)
+         reset
+         @override = VividMash.new(self, new_data)
+       end
+
+       # Set the role level override attribute component to +new_data+
+       def role_override=(new_data)
+         reset
+         @role_override = VividMash.new(self, new_data)
+       end
+
+       # Set the environment level override attribute component to +new_data+
+       def env_override=(new_data)
+         reset
+         @env_override = VividMash.new(self, new_data)
+       end
+
+       def force_override=(new_data)
+         reset
+         @force_override = VividMash.new(self, new_data)
+       end
+
+       def automatic=(new_data)
+         reset
+         @automatic = VividMash.new(self, new_data)
+       end
+
+       def merged_attributes
+         @merged_attributes ||= begin
+                                  components = [merge_defaults, @normal, merge_overrides, @automatic]
+                                  resolved_attrs = components.inject(Mash.new) do |merged, component|
+                                    Chef::Mixin::DeepMerge.hash_only_merge(merged, component)
+                                  end
+                                  immutablize(resolved_attrs)
+                                end
+       end
+
+       def combined_override
+         @combined_override ||= immutablize(merge_overrides)
+       end
+
+       def combined_default
+         @combined_default ||= immutablize(merge_defaults)
+       end
+
+       def [](key)
+         merged_attributes[key]
+       end
+
+       def []=(key, value)
+         merged_attributes[key] = value
+       end
+
+       def has_key?(key)
+         COMPONENTS.any? do |component_ivar|
+           instance_variable_get(component_ivar).has_key?(key)
+         end
+       end
+
+       alias :attribute? :has_key?
+       alias :member? :has_key?
+       alias :include? :has_key?
+       alias :key? :has_key?
+
+       alias :each_attribute :each
+
+       def method_missing(symbol, *args)
+         if args.empty?
+           if key?(symbol)
+             self[symbol]
+           else
+             raise NoMethodError, "Undefined method or attribute `#{symbol}' on `node'"
+           end
+         elsif symbol.to_s =~ /=$/
+           key_to_set = symbol.to_s[/^(.+)=$/, 1]
+           self[key_to_set] = (args.length == 1 ? args[0] : args)
+         else
+           raise NoMethodError, "Undefined node attribute or method `#{symbol}' on `node'"
+         end
+       end
+
+       def inspect
+         "#<#{self.class} " << (COMPONENTS + [:@merged_attributes, :@properties]).map{|iv|
+           "#{iv}=#{instance_variable_get(iv).inspect}"
+         }.join(', ') << ">"
+       end
+
+       def set_unless?
+         @set_unless_present
+       end
+
+       private
+
+       def merge_defaults
+         DEFAULT_COMPONENTS.inject(Mash.new) do |merged, component_ivar|
+           component_value = instance_variable_get(component_ivar)
+           Chef::Mixin::DeepMerge.merge(merged, component_value)
+         end
+       end
+
+       def merge_overrides
+         OVERRIDE_COMPONENTS.inject(Mash.new) do |merged, component_ivar|
+           component_value = instance_variable_get(component_ivar)
+           Chef::Mixin::DeepMerge.merge(merged, component_value)
+         end
+       end
+
 
     end
+
   end
 end