puppet 4.4.2-x86-mingw32 → 4.5.0-x86-mingw32

data/lib/puppet/pops/types/p_runtime_type.rb

@@ -0,0 +1,102 @@
+module Puppet::Pops
+module Types
+
+# @api public
+class PRuntimeType < PAnyType
+  TYPE_NAME_OR_PATTERN = PVariantType.new([PStringType::NON_EMPTY, PTupleType.new([PRegexpType::DEFAULT, PStringType::NON_EMPTY])])
+
+  attr_reader :runtime, :name_or_pattern
+
+  # Creates a new instance of a Runtime type
+  #
+  # @param runtime [String] the name of the runtime, e.g. 'ruby'
+  # @param name_or_pattern [String,Array(Regexp,String)] name of runtime or two patterns, mapping Puppet name => runtime name
+  # @api public
+  def initialize(runtime, name_or_pattern)
+    unless runtime.nil? || runtime.is_a?(Symbol)
+      runtime = TypeAsserter.assert_instance_of("Runtime 'runtime'", PStringType::NON_EMPTY, runtime).to_sym
+    end
+    @runtime = runtime
+    @name_or_pattern = TypeAsserter.assert_instance_of("Runtime 'name_or_pattern'", TYPE_NAME_OR_PATTERN, name_or_pattern, true)
+  end
+
+  def hash
+    @runtime.hash ^ @name_or_pattern.hash
+  end
+
+  def eql?(o)
+    self.class == o.class && @runtime == o.runtime && @name_or_pattern == o.name_or_pattern
+  end
+
+  def instance?(o, guard = nil)
+    assignable?(TypeCalculator.infer(o), guard)
+  end
+
+  def iterable?(guard = nil)
+    if @runtime == :ruby && !runtime_type_name.nil?
+      begin
+        c = ClassLoader.provide(self)
+        return c < Iterable unless c.nil?
+      rescue ArgumentError
+      end
+    end
+    false
+  end
+
+  def iterable_type(guard = nil)
+    iterable?(guard) ? PIterableType.new(self) : nil
+  end
+
+  # @api private
+  def runtime_type_name
+    @name_or_pattern.is_a?(String) ? @name_or_pattern : nil
+  end
+
+  # @api private
+  def class_or_module
+    raise "Only ruby classes or modules can be produced by this runtime, got '#{runtime}" unless runtime == :ruby
+    raise 'A pattern based Runtime type cannot produce a class or module' if @name_or_pattern.is_a?(Array)
+    com = ClassLoader.provide(self)
+    raise "The name #{@name_or_pattern} does not represent a ruby class or module" if com.nil?
+    com
+  end
+
+  # @api private
+  def from_puppet_name(puppet_name)
+    if @name_or_pattern.is_a?(Array)
+      substituted = puppet_name.sub(*@name_or_pattern)
+      substituted == puppet_name ? nil : PRuntimeType.new(@runtime, substituted)
+    else
+      nil
+    end
+  end
+
+  DEFAULT = PRuntimeType.new(nil, nil)
+  RUBY = PRuntimeType.new(:ruby, nil)
+
+  protected
+
+  # Assignable if o's has the same runtime and the runtime name resolves to
+  # a class that is the same or subclass of t1's resolved runtime type name
+  # @api private
+  def _assignable?(o, guard)
+    return false unless o.is_a?(PRuntimeType)
+    return false unless @runtime == o.runtime
+    return true if @name_or_pattern.nil? # t1 is wider
+
+    onp = o.name_or_pattern
+    return true if @name_or_pattern == onp
+    return false unless @name_or_pattern.is_a?(String) && onp.is_a?(String)
+
+    # NOTE: This only supports Ruby, must change when/if the set of runtimes is expanded
+    begin
+      c1 = ClassLoader.provide(self)
+      c2 = ClassLoader.provide(o)
+      c1.is_a?(Module) && c2.is_a?(Module) && !!(c2 <= c1)
+    rescue ArgumentError
+      false
+    end
+  end
+end
+end
+end

data/lib/puppet/pops/types/p_sem_ver_range_type.rb

@@ -0,0 +1,164 @@
+module Puppet::Pops
+module Types
+
+# An unparameterized type that represents all VersionRange instances
+#
+# @api public
+class PSemVerRangeType < PScalarType
+  # Check if a version is included in a version range. The version can be a string or
+  # a `Semantic::SemVer`
+  #
+  # @param range [Semantic::VersionRange] the range to match against
+  # @param version [Semantic::Version,String] the version to match
+  # @return [Boolean] `true` if the range includes the given version
+  #
+  # @api public
+  def self.include?(range, version)
+    case version
+    when Semantic::Version
+      range.include?(version)
+    when String
+      begin
+        range.include?(Semantic::Version.parse(version))
+      rescue Semantic::Version::ValidationFailure
+        false
+      end
+    else
+      false
+    end
+  end
+
+  # Checks if range _a_ is a sub-range of (i.e. completely covered by) range _b_
+  # @param a [Semantic::VersionRange] the first range
+  # @param b [Semantic::VersionRange] the second range
+  #
+  # @return [Boolean] `true` if _a_ is completely covered by _b_
+  def self.covered_by?(a, b)
+    b.begin <= a.begin && (b.end > a.end || b.end == a.end && (!b.exclude_end? || a.exclude_end?))
+  end
+
+  # Merge two ranges so that the result matches all versions matched by both. A merge
+  # is only possible when the ranges are either adjacent or have an overlap.
+  #
+  # @param a [Semantic::VersionRange] the first range
+  # @param b [Semantic::VersionRange] the second range
+  # @return [Semantic::VersionRange,nil] the result of the merge
+  #
+  # @api public
+  def self.merge(a, b)
+    if a.include?(b.begin) || b.include?(a.begin)
+      max = [a.end, b.end].max
+      exclude_end = false
+      if a.exclude_end?
+        exclude_end = max == a.end && (max > b.end || b.exclude_end?)
+      elsif b.exclude_end?
+        exclude_end = max == b.end && (max > a.end || a.exclude_end?)
+      end
+      Semantic::VersionRange.new([a.begin, b.begin].min, max, exclude_end)
+    elsif a.exclude_end? && a.end == b.begin
+      # Adjacent, a before b
+      Semantic::VersionRange.new(a.begin, b.end, b.exclude_end?)
+    elsif b.exclude_end? && b.end == a.begin
+      # Adjacent, b before a
+      Semantic::VersionRange.new(b.begin, a.end, a.exclude_end?)
+    else
+      # No overlap
+      nil
+    end
+  end
+
+  def instance?(o, guard = nil)
+    o.is_a?(Semantic::VersionRange)
+  end
+
+  def eql?(o)
+    self.class == o.class
+  end
+
+  def hash?
+    super ^ @version_range.hash
+  end
+
+  def self.new_function(_, loader)
+    range_expr = "\\A#{range_pattern}\\Z"
+    @@new_function ||= Puppet::Functions.create_loaded_function(:new_VersionRange, loader) do
+      local_types do
+        type 'SemVerRangeString = String[1]'
+        type 'SemVerRangeHash = Struct[{min=>Variant[default,SemVer],Optional[max]=>Variant[default,SemVer],Optional[exclude_max]=>Boolean}]'
+      end
+
+      # Constructs a VersionRange from a String with a format specified by
+      #
+      # https://github.com/npm/node-semver#range-grammar
+      #
+      # The logical or || operator is not implemented since it effectively builds
+      # an array of ranges that may be disparate. The {{Semantic::VersionRange}} inherits
+      # from the standard ruby range. It must be possible to describe that range in terms
+      # of min, max, and exclude max.
+      #
+      # The Puppet Version type is parameterized and accepts multiple ranges so creating such
+      # constraints is still possible. It will just require several parameters rather than one
+      # parameter containing the '||' operator.
+      #
+      dispatch :from_string do
+        param 'SemVerRangeString', :str
+      end
+
+      # Constructs a VersionRange from a min, and a max version. The Boolean argument denotes
+      # whether or not the max version is excluded or included in the range. It is included by
+      # default.
+      #
+      dispatch :from_versions do
+        param 'Variant[default,SemVer]', :min
+        param 'Variant[default,SemVer]', :max
+        optional_param 'Boolean', :exclude_max
+      end
+
+      # Same as #from_versions but each argument is instead given in a Hash
+      #
+      dispatch :from_hash do
+        param 'SemVerRangeHash', :hash_args
+      end
+
+      def from_string(str)
+        Semantic::VersionRange.parse(str)
+      end
+
+      def from_versions(min, max = :default, exclude_max = false)
+        min = Semantic::Version::MIN if min == :default
+        max = Semantic::Version::MAX if max == :default
+        Semantic::VersionRange.new(min, max, exclude_max)
+      end
+
+      def from_hash(hash)
+        from_versions(hash['min'], hash.fetch('max') { :default }, hash.fetch('exclude_max') { false })
+      end
+    end
+  end
+
+  DEFAULT = PSemVerRangeType.new
+
+  protected
+
+  def _assignable?(o, guard)
+    self == o
+  end
+
+  def self.range_pattern
+    part = '(?<part>[0-9A-Za-z-]+)'
+    parts = "(?<parts>#{part}(?:\\.\\g<part>)*)"
+
+    qualifier = "(?:-#{parts})?(?:\\+\\g<parts>)?"
+
+    xr = '(?<xr>[xX*]|0|[1-9][0-9]*)'
+    partial = "(?<partial>#{xr}(?:\\.\\g<xr>(?:\\.\\g<xr>#{qualifier})?)?)"
+
+    hyphen = "(?:#{partial}\\s+-\\s+\\g<partial>)"
+    simple = "(?<simple>(?:<|>|>=|<=|~|\\^)?\\g<partial>)"
+
+    "#{hyphen}|#{simple}(?:\\s+\\g<simple>)*"
+  end
+  private_class_method :range_pattern
+end
+end
+end

data/lib/puppet/pops/types/p_sem_ver_type.rb

@@ -0,0 +1,113 @@
+module Puppet::Pops
+module Types
+
+# A Puppet Language Type that exposes the {{Semantic::Version}} and {{Semantic::VersionRange}}.
+# The version type is parameterized with version ranges.
+#
+# @api public
+class PSemVerType < PScalarType
+  attr_reader :ranges
+
+  def initialize(*ranges)
+    ranges = ranges.map { |range| range.is_a?(Semantic::VersionRange) ? range : Semantic::VersionRange.parse(range) }
+    ranges = merge_ranges(ranges) if ranges.size > 1
+    @ranges = ranges
+  end
+
+  def instance?(o, guard = nil)
+    o.is_a?(Semantic::Version) && (@ranges.empty? || @ranges.any? {|range| range.include?(o) })
+  end
+
+  def eql?(o)
+    self.class == o.class && @ranges == o.ranges
+  end
+
+  def hash?
+    super ^ @ranges.hash
+  end
+
+  # @api private
+  def self.new_function(_, loader)
+    @@new_function ||= Puppet::Functions.create_loaded_function(:new_Version, loader) do
+      local_types do
+        type 'PositiveInteger = Integer[0,default]'
+        type 'SemVerQualifier = Pattern[/\A(?<part>[0-9A-Za-z-]+)(?:\.\g<part>)*\Z/]'
+        type 'SemVerString = String[1]'
+        type 'SemVerHash = Struct[{major=>PositiveInteger,minor=>PositiveInteger,patch=>PositiveInteger,Optional[prerelease]=>SemVerQualifier,Optional[build]=>SemVerQualifier}]'
+      end
+
+      # Creates a SemVer from a string as specified by http://semver.org/
+      #
+      dispatch :from_string do
+        param 'SemVerString', :str
+      end
+
+      # Creates a SemVer from integers, prerelease, and build arguments
+      #
+      dispatch :from_args do
+        param 'PositiveInteger', :major
+        param 'PositiveInteger', :minor
+        param 'PositiveInteger', :patch
+        optional_param 'SemVerQualifier', :prerelease
+        optional_param 'SemVerQualifier', :build
+      end
+
+      # Same as #from_args but each argument is instead given in a Hash
+      #
+      dispatch :from_hash do
+        param 'SemVerHash', :hash_args
+      end
+
+      def from_string(str)
+        Semantic::Version.parse(str)
+      end
+
+      def from_args(major, minor, patch, prerelease = nil, build = nil)
+        Semantic::Version.new(major, minor, patch, prerelease, build)
+      end
+
+      def from_hash(hash)
+        Semantic::Version.new(hash['major'], hash['minor'], hash['patch'], hash['prerelease'], hash['build'])
+      end
+    end
+  end
+
+  DEFAULT = PSemVerType.new
+
+  protected
+
+  def _assignable?(o, guard)
+    return false unless o.class == self.class
+    return true if @ranges.empty?
+    return false if o.ranges.empty?
+
+    # All ranges in o must be covered by at least one range in self
+    o.ranges.all? do |o_range|
+      @ranges.any? do |range|
+        PSemVerRangeType.covered_by?(o_range, range)
+      end
+    end
+  end
+
+  # @api private
+  def merge_ranges(ranges)
+    result = []
+    until ranges.empty?
+      unmerged = []
+      x = ranges.pop
+      result << ranges.inject(x) do |memo, y|
+        merged = PSemVerRangeType.merge(memo, y)
+        if merged.nil?
+          unmerged << y
+        else
+          memo = merged
+        end
+        memo
+      end
+      ranges = unmerged
+    end
+    result.reverse!
+  end
+end
+end
+end

data/lib/puppet/pops/types/puppet_object.rb

@@ -0,0 +1,21 @@
+module Puppet::Pops
+module Types
+
+# Marker module for implementations that are mapped to Object types
+# @api public
+module PuppetObject
+  # Returns all classes that includes this module
+  def self.descendants
+    ObjectSpace.each_object(Class).select { |klass| klass < self }
+  end
+
+  # Returns the Puppet Type for this instance. The implementing class must
+  # add the {#_ptype} as a class method.
+  #
+  # @return [PObjectType] the type
+  def _ptype
+    self.class._ptype
+  end
+end
+end
+end

data/lib/puppet/pops/types/ruby_generator.rb

@@ -0,0 +1,258 @@
+module Puppet::Pops
+module Types
+
+# @api private
+class RubyGenerator < TypeFormatter
+  def remove_common_namespace(namespace_segments, name)
+    segments = name.split(TypeFormatter::NAME_SEGMENT_SEPARATOR)
+    namespace_segments.size.times do |idx|
+      break if segments.empty? || namespace_segments[idx] != segments[0]
+      segments.shift
+    end
+    segments
+  end
+
+  def namespace_relative(namespace_segments, name)
+    remove_common_namespace(namespace_segments, name).join(TypeFormatter::NAME_SEGMENT_SEPARATOR)
+  end
+
+  def create_class(obj)
+    @dynamic_classes ||= Hash.new do |hash, key|
+      rp = key.resolved_parent
+      parent_class = rp.is_a?(PObjectType) ? create_class(rp) : Object
+      class_def = ''
+      class_body(key, EMPTY_ARRAY, class_def)
+      cls = Class.new(parent_class)
+      cls.class_eval(class_def)
+      cls.define_singleton_method(:_ptype) { return key }
+      hash[key] = cls
+    end
+    @dynamic_classes[obj]
+  end
+
+  def module_definition(types, comment)
+    object_types, aliased_types = types.partition { |type| type.is_a?(PObjectType) }
+    impl_names = implementation_names(object_types)
+
+    # extract common implementation module prefix
+    common_prefix = []
+    segmented_names = impl_names.map { |impl_name| impl_name.split(TypeFormatter::NAME_SEGMENT_SEPARATOR) }
+    segments = segmented_names[0]
+    segments.size.times do |idx|
+      segment = segments[idx]
+      break unless segmented_names.all? { |sn| sn[idx] == segment }
+      common_prefix << segment
+    end
+
+    # Create class definition of all contained types
+    bld = ''
+    start_module(common_prefix, comment, bld)
+    class_names = []
+    object_types.each_with_index do |type, index|
+      class_names << class_definition(type, common_prefix, bld, impl_names[index])
+      bld << "\n"
+    end
+
+    aliases = Hash[aliased_types.map { |type| [type.name, type.resolved_type] }]
+    end_module(common_prefix, aliases, class_names, bld)
+    bld
+  end
+
+  def start_module(common_prefix, comment, bld)
+    bld << '# ' << comment << "\n"
+    common_prefix.each { |cp| bld << 'module ' << cp << "\n" }
+  end
+
+  def end_module(common_prefix, aliases, class_names, bld)
+    # Emit registration of contained type aliases
+    unless aliases.empty?
+      bld << "Puppet::Pops::Pcore.register_aliases({\n"
+      aliases.each { |name, type| bld << "  '" << name << "' => " << TypeFormatter.string(type.to_s) << "\n" }
+      bld.chomp!(",\n")
+      bld << "})\n\n"
+    end
+
+    # Emit registration of contained types
+    unless class_names.empty?
+      bld << "Puppet::Pops::Pcore.register_implementations(\n"
+      class_names.each { |class_name| bld << '  ' << class_name << ",\n" }
+      bld.chomp!(",\n")
+      bld << ")\n\n"
+    end
+    bld.chomp!("\n")
+
+    common_prefix.size.times { bld << "end\n" }
+  end
+
+  def implementation_names(object_types)
+    object_types.map do |type|
+      ir = Loaders.implementation_registry
+      impl_name = ir.module_name_for_type(type)
+      raise Puppet::Error, "Unable to create an instance of #{type.name}. No mapping exists to runtime object" if impl_name.nil?
+      impl_name[0]
+    end
+  end
+
+  def class_definition(obj, namespace_segments, bld, class_name)
+    module_segments = remove_common_namespace(namespace_segments, class_name)
+    leaf_name = module_segments.pop
+    module_segments.each { |segment| bld << 'module ' << segment << "\n" }
+    bld << 'class ' << leaf_name
+    segments = class_name.split(TypeFormatter::NAME_SEGMENT_SEPARATOR)
+
+    unless obj.parent.nil?
+      ir = Loaders.implementation_registry
+      parent_impl = ir.module_name_for_type(obj.parent)
+      raise Puppet::Error, "Unable to create an instance of #{obj.parent.name}. No mapping exists to runtime object" if parent_impl.nil?
+      bld << ' < ' << namespace_relative(segments, parent_impl[0])
+    end
+
+    bld << "\n"
+    bld << "  def self._plocation\n"
+    bld << "    loc = Puppet::Util.path_to_uri(\"\#{__FILE__}\")\n"
+    bld << "    URI(\"#\{loc}?line=#\{__LINE__.to_i - 3}\")\n"
+    bld << "  end\n"
+
+    bld << "\n"
+    bld << "  def self._ptype\n"
+    bld << '    @_ptype ||= ' << namespace_relative(segments, obj.class.name) << ".new('" << obj.name << "',\n"
+    bld << TypeFormatter.new.ruby_string('ref', 3, obj.i12n_hash(false)) << "    )\n"
+    bld << "  end\n"
+
+    class_body(obj, segments, bld)
+
+    bld << "end\n"
+    module_segments.size.times { bld << "end\n" }
+    module_segments << leaf_name
+    module_segments.join(TypeFormatter::NAME_SEGMENT_SEPARATOR)
+  end
+
+  def class_body(obj, segments, bld)
+    if obj.parent.nil?
+      bld << "\n  include " << namespace_relative(segments, Puppet::Pops::Types::PuppetObject.name) << "\n\n" # marker interface
+      bld << "  def self.ref(type_string)\n"
+      bld << '    ' << namespace_relative(segments, Puppet::Pops::Types::PTypeReferenceType.name) << ".new(type_string)\n"
+      bld << "  end\n"
+    end
+
+    # Output constants
+    constants, others = obj.attributes(true).values.partition { |a| a.kind == PObjectType::ATTRIBUTE_KIND_CONSTANT }
+    constants = constants.select { |ca| ca.container.equal?(obj) }
+    unless constants.empty?
+      constants.each { |ca| bld << "\n  def self." << ca.name << "\n    _ptype['" << ca.name << "'].value\n  end\n" }
+      constants.each { |ca| bld << "\n  def " << ca.name << "\n    self.class." << ca.name << "\n  end\n" }
+    end
+
+    init_params = others.reject { |a| a.kind == PObjectType::ATTRIBUTE_KIND_DERIVED }
+    opt, non_opt = init_params.partition { |ip| ip.value? }
+
+    # Output type safe hash constructor
+    bld << "\n  def self.from_hash(i12n)\n"
+    bld << '    from_asserted_hash(' << namespace_relative(segments, TypeAsserter.name) << '.assert_instance_of('
+    bld << "'" << obj.label << " initializer', _ptype.i12n_type, i12n))\n  end\n\n  def self.from_asserted_hash(i12n)\n    new(\n"
+    non_opt.each { |ip| bld << "      i12n['" << ip.name << "'],\n" }
+    opt.each { |ip| bld << "      i12n.fetch('" << ip.name << "') { _ptype['" << ip.name << "'].value },\n" }
+    bld.chomp!(",\n")
+    bld << ")\n  end\n"
+
+    # Output type safe constructor
+    bld << "\n  def self.create"
+    if init_params.empty?
+      bld << "\n    new"
+    else
+      bld << '('
+      non_opt.each { |ip| bld << ip.name << ', ' }
+      opt.each { |ip| bld << ip.name << ' = ' << "_ptype['#{ip.name}'].value" << ', ' }
+      bld.chomp!(', ')
+      bld << ")\n"
+      bld << '    ta = ' << namespace_relative(segments, TypeAsserter.name) << "\n"
+      bld << "    attrs = _ptype.attributes(true)\n"
+      init_params.each do |a|
+        bld << "    ta.assert_instance_of('" << a.container.name << '[' << a.name << ']'
+        bld << "', attrs['" << a.name << "'].type, " << a.name << ")\n"
+      end
+      bld << '    new('
+      non_opt.each { |a| bld << a.name << ', ' }
+      opt.each { |a| bld << a.name << ', ' }
+      bld.chomp!(', ')
+      bld << ')'
+    end
+    bld << "\n  end\n"
+
+    # Output initializer
+    bld << "\n  def initialize"
+    unless init_params.empty?
+      bld << '('
+      non_opt.each { |ip| bld << ip.name << ', ' }
+      opt.each { |ip| bld << ip.name << ' = ' << "_ptype['#{ip.name}'].value" << ', ' }
+      bld.chomp!(', ')
+      bld << ')'
+      unless obj.parent.nil?
+        bld << "\n    super"
+        super_args = (non_opt + opt).select { |ip| !ip.container.equal?(obj) }
+        unless super_args.empty?
+          bld << '('
+          super_args.each { |ip| bld << ip.name << ', ' }
+          bld.chomp!(', ')
+          bld << ')'
+        end
+      end
+    end
+    bld << "\n"
+
+    init_params.each { |a| bld << '    @' << a.name << ' = ' << a.name << "\n" if a.container.equal?(obj) }
+    bld << "  end\n\n"
+
+    # Output attr_readers
+    others.each do |a|
+      next unless a.container.equal?(obj)
+      if a.kind == PObjectType::ATTRIBUTE_KIND_DERIVED || a.kind == PObjectType::ATTRIBUTE_KIND_GIVEN_OR_DERIVED
+        bld << '  def ' << a.name << "\n"
+        bld << "    raise Puppet::Error, \"no method is implemented for derived attribute #{a.label}\"\n"
+        bld << "  end\n"
+      else
+        bld << '  attr_reader :' << a.name << "\n"
+      end
+    end
+
+    # Output function placeholders
+    obj.functions(false).each_value do |func|
+      bld << "\n  def " << func.name << "(*args)\n"
+      bld << "    # Placeholder for #{func.type}\n"
+      bld << "    raise Puppet::Error, \"no method is implemented for #{func.label}\"\n"
+      bld << "  end\n"
+    end
+
+    # output hash and equality
+    include_class = obj.include_class_in_equality?
+    if obj.equality.nil?
+      eq_names = obj.attributes(false).values.select { |a| a.kind != PObjectType::ATTRIBUTE_KIND_CONSTANT }.map(&:name)
+    else
+      eq_names = obj.equality
+    end
+
+    unless eq_names.empty? && !include_class
+      bld << "\n  def hash\n    "
+      bld << 'super.hash ^ ' unless obj.parent.nil?
+      if eq_names.empty?
+        bld << "self.class.hash\n"
+      else
+        bld << '['
+        bld << 'self.class, ' if include_class
+        eq_names.each { |eqn| bld << '@' << eqn << ', ' }
+        bld.chomp!(', ')
+        bld << "].hash\n"
+      end
+      bld << "  end\n"
+
+      bld << "\n  def eql?(o)\n"
+      bld << "    super.eql?(o) &&\n" unless obj.parent.nil?
+      bld << "    self.class.eql?(o.class) &&\n" if include_class
+      eq_names.each { |eqn| bld << '    @' << eqn << '.eql?(o.' <<  eqn << ") &&\n" }
+      bld.chomp!(" &&\n")
+      bld << "\n  end\n"
+    end
+  end
+end
+end
+end