saboteur 0.6.0 → 0.8.0

data/lib/saboteur/config.rb

@@ -1,6 +1,8 @@
 # SPDX-License-Identifier: MIT
 # frozen_string_literal: true
 
+require_relative "text"
+
 require_relative "mutation_source/builtin"
 require_relative "mutation_source/operator_registry"
 require_relative "mutation_source/hazard_guard"
@@ -20,13 +22,27 @@ module Saboteur
       "integration" => "rspec",
       "require" => [],
       "include" => ["lib/**/*.rb"],
-      "exclude" => [],
+      # Spec and test files vendored under lib/ (capybara ships its driver
+      # suite at lib/capybara/spec/**) are never mutation subjects (#504).
+      # A config's own c.exclude replaces this list wholesale.
+      "exclude" => ["lib/**/spec/**/*", "lib/**/test/**/*", "lib/**/tests/**/*",
+                    "lib/**/*_spec.rb", "lib/**/*_test.rb", "lib/**/test_*.rb"],
       "arid" => MutationSource::Builtin::DEFAULT_ARID,
       "whole_file" => [],
+      # [{ "pattern" => "app/payments/**/*", "min_score" => 95.0 }], from
+      # repeatable c.score_gate calls (#473). --threshold stays the global
+      # fallback.
+      "score_gates" => [],
       "hazard" => MutationSource::HazardGuard::DEFAULT_HAZARD,
       "allow_hazardous" => false,
-      "sandbox" => true, # true, false, or "strict": strict refuses to run without full Landlock
+      # true, false, "strict" or "seatbelt": strict refuses to run without full Landlock;
+      # seatbelt opts into the macOS Seatbelt sandbox (on Linux it behaves like true).
+      "sandbox" => true,
       "sandbox_writable" => [],
+      # off, survivors, or decisive (#476): one reordered confirmation run
+      # per new survivor (and per fresh kill in decisive); a disagreement
+      # becomes unverified, outside the score.
+      "flaky_check" => "off",
       "timeout_factor" => 3.0,
       "timeout_min" => 5.0,
       "baseline_timeout" => 300.0,
@@ -54,20 +70,28 @@ module Saboteur
       "since" => nil,
       "cache" => true,
       "incremental" => false,
+      "shard" => nil,
       "allow_focus" => false,
       "fail_fast" => false,
       "guess_tests" => false,
+      "all" => false,
+      "test_selection" => "auto",
       "matrix" => false,
       "seed" => 1,
+      "baseline_passes" => 2,
+      "max_duration" => nil,
+      "max_duration_ok" => false,
       "tests" => [],
+      "test_command" => nil,
       "fingerprint_extra" => [],
       "threshold" => nil,
       "max_timeouts" => nil,
       "max_errors" => nil
     }.freeze
 
-    INTEGER_KEYS = %w[jobs max_memory_mb max_processes max_mutants_per_method seed].freeze
+    INTEGER_KEYS = %w[jobs max_memory_mb max_processes max_mutants_per_method seed baseline_passes].freeze
     FLOAT_KEYS = %w[timeout_factor timeout_min baseline_timeout coverage_timeout].freeze
+    NILABLE_FLOAT_KEYS = %w[threshold max_duration].freeze
     THRESHOLD_RANGE = (0.0..100.0)
 
     LIST_KEYS = %w[require include exclude arid hazard sources hooks rspec_args subjects tests
@@ -96,11 +120,19 @@ module Saboteur
       hash.to_h { |key, value| [key.to_s, value] }.compact
     end
 
-    def initialize(values = {}, root: Dir.pwd)
-      @root = File.expand_path(root)
+    # Deprecations found while loading: printed by the CLI, never fatal.
+    attr_reader :deprecation_warnings
+
+    def initialize(values = {}, root: Dir.pwd, explicit: nil)
+      # Retag the root losslessly: under a non-UTF-8 locale it arrives
+      # locale-tagged, and every glob, join and expand below would mix
+      # encodings with the UTF-8 patterns from the config file (#231).
+      @root = Text.utf8_identity(File.expand_path(root))
       unknown = values.keys - DEFAULTS.keys
       raise ConfigError, "unknown config key(s): #{unknown.join(', ')}" if unknown.any?
 
+      @deprecation_warnings = deprecations(values)
+      @explicit_keys = (explicit || values.keys).map(&:to_s).freeze
       @values = DEFAULTS.merge(values)
       coerce!
       validate!
@@ -115,6 +147,26 @@ module Saboteur
       @values.fetch(key.to_s, default)
     end
 
+    # Keys the user set (config file or CLI flag) rather than relying on
+    # the default; carried through Engine's config clone so provenance
+    # survives (#296).
+    attr_reader :explicit_keys
+
+    # A copy with some values replaced or dropped, keeping which keys the
+    # user set explicitly: the replacements count as explicit, the dropped
+    # keys lose it (#296).
+    def with(values, except: [])
+      merged = to_h.except(*except).merge(values)
+      Config.new(merged, root: root, explicit: (explicit_keys - except.map(&:to_s)) | values.keys.map(&:to_s))
+    end
+
+    # Whether the user set a key (config file or CLI flag) rather than
+    # relying on the default. An explicitly requested report artifact is
+    # completion evidence, so its write failure is a hard error (#296).
+    def explicit?(key)
+      @explicit_keys.include?(key.to_s)
+    end
+
     def to_h
       @values.dup
     end
@@ -124,13 +176,30 @@ module Saboteur
       matched = self["include"].flat_map { |pattern| Dir.glob(pattern, base: root) }
       excluded = self["exclude"].flat_map { |pattern| Dir.glob(pattern, base: root) }
       (matched - excluded).select { |file| file.end_with?(".rb") }
-                          .map { |file| File.realpath(File.expand_path(file, root)) }.uniq.sort
+                          .filter_map { |file| real_source_path(file) }
+                          .uniq.sort
+    end
+
+    # A broken symlink matches Dir.glob but has no real path: dangling
+    # (ENOENT), a loop (ELOOP) or through a regular file (ENOTDIR). It is
+    # not mutation source, so it is skipped rather than crashing the run
+    # (#503). A regular file that cannot be resolved still raises.
+    def real_source_path(file)
+      path = File.expand_path(Text.utf8_identity(file), root)
+      File.realpath(path)
+    rescue SystemCallError
+      raise unless File.symlink?(path)
     end
 
     # Patterns that match no file. A pattern goes stale when files move;
     # an exclude that silently stops excluding is a hazard, so say so.
     def unmatched_patterns
       %w[include exclude].flat_map do |key|
+        # The default exclude shields (#504) match nothing on a healthy
+        # project - that is their job - so only a configured exclude can go
+        # stale enough to warn about.
+        next [] if key == "exclude" && !explicit?("exclude")
+
         self[key].select { |pattern| Dir.glob(pattern, base: root).empty? }.map { |pattern| "#{key}: #{pattern}" }
       end
     end
@@ -151,11 +220,23 @@ module Saboteur
 
     private
 
+    # An explicit guess_tests = false (config file or --no-guess-tests) used
+    # to keep the whole suite; inference is the default now, so the opt-out
+    # is --all / c.test_selection = :all. guess_tests = true is the default
+    # behavior spelled out, so it stays silent.
+    def deprecations(values)
+      return [] unless values["guess_tests"] == false
+
+      ["guess_tests = false is deprecated: inferred specs are the default and it no longer restores the " \
+       "whole suite; use --all or c.test_selection = :all to run every spec"]
+    end
+
     def coerce!
       INTEGER_KEYS.each { |key| @values[key] = Integer(@values[key]) }
       FLOAT_KEYS.each { |key| @values[key] = Float(@values[key]) }
       LIST_KEYS.each { |key| @values[key] = Array(@values[key]).map(&:to_s) }
-      @values["threshold"] = Float(@values["threshold"]) unless @values["threshold"].nil?
+      NILABLE_FLOAT_KEYS.each { |key| @values[key] = Float(@values[key]) unless @values[key].nil? }
+      @values["test_selection"] = @values["test_selection"].to_s
     rescue ArgumentError, TypeError => e
       raise ConfigError, "invalid config value: #{e.message}"
     end
@@ -164,6 +245,13 @@ module Saboteur
       raise ConfigError, "max_mutants_per_method must be > 0" unless self["max_mutants_per_method"].positive?
     end
 
+    # The unchanged-suite checks: how many, and the whole run's clock (#55, #245).
+    def validate_baseline!
+      raise ConfigError, "seed must be >= 0" if self["seed"].negative?
+      raise ConfigError, "baseline_passes must be >= 1" if self["baseline_passes"] < 1
+      raise ConfigError, "max_duration must be > 0" if self["max_duration"] && !self["max_duration"].positive?
+    end
+
     def validate_report_paths!
       json = path("json_report")
       if json && json == path("html_report")
@@ -179,8 +267,43 @@ module Saboteur
     def validate_modes!
       validate_fail_fast!
       validate_matrix!
-      validate_guess_tests!
+      validate_test_selection!
       validate_gates!
+      validate_score_gates!
+    end
+
+    # Per-path gates (#473): normalize each entry to string pattern /
+    # float floor, and fail loud on a pattern no included file matches -
+    # a gate that matches nothing would pass vacuously forever.
+    def validate_score_gates!
+      gates = self["score_gates"]
+      return if gates.empty?
+
+      normalized = gates.map { |gate| normalize_score_gate(gate) }
+      prefix = File.join(File.realpath(root), "")
+      relative = included_files.map { |file| file.delete_prefix(prefix) }
+      flags = File::FNM_PATHNAME | File::FNM_EXTGLOB
+      normalized.each do |gate|
+        next if relative.any? { |file| File.fnmatch?(gate["pattern"], file, flags) }
+
+        raise ConfigError, "score_gate #{gate['pattern']} matches no included file"
+      end
+      @values["score_gates"] = normalized
+    end
+
+    def normalize_score_gate(gate)
+      pattern = gate["pattern"].to_s
+      begin
+        floor = Float(gate["min_score"])
+      rescue ArgumentError, TypeError
+        raise ConfigError, "score_gate min_score must be between 0 and 100, got #{gate['min_score'].inspect}"
+      end
+      unless floor.finite? && floor.between?(0, 100)
+        raise ConfigError, "score_gate min_score must be between 0 and 100, got #{gate['min_score'].inspect}"
+      end
+      raise ConfigError, "score_gate pattern must not be empty" if pattern.empty?
+
+      { "pattern" => pattern, "min_score" => floor }
     end
 
     def validate_gates!
@@ -208,11 +331,32 @@ module Saboteur
       raise ConfigError, "threshold must be between 0 and 100"
     end
 
-    def validate_guess_tests!
-      return unless self["guess_tests"]
+    def validate_test_selection!
+      return if %w[auto all].include?(self["test_selection"])
+
+      raise ConfigError, "test_selection must be one of: auto, all"
+    end
+
+    # --test-command replaces the whole in-process machinery, on the
+    # EFFECTIVE config: CLI flags and config-file entries alike (#305).
+    # The command runs unsandboxed, so "strict" cannot be honored.
+    def validate_test_command!
+      command = self["test_command"]
+      # nil alone means unset: false, arrays and numbers are all rejected,
+      # never coerced and never sent to String methods (#305 QA).
+      raise ConfigError, "test_command must be a string" unless command.nil? || command.is_a?(String)
+      raise ConfigError, "test_command must not be blank" if command&.strip&.empty?
+
+      return if command.to_s.empty?
+      raise ConfigError, "test_command cannot be combined with tests" unless self["tests"].empty?
+      raise ConfigError, "test_command cannot be combined with incremental" if self["incremental"]
+      unless self["flaky_check"] == "off"
+        raise ConfigError, "test_command cannot be combined with flaky_check: an external run has no " \
+                           "in-process scheduler to rerun the decisive tests through"
+      end
+      return unless self["sandbox"] == "strict"
 
-      raise ConfigError, "guess_tests needs since" unless self["since"]
-      raise ConfigError, "guess_tests cannot be combined with tests" if self["tests"].any?
+      raise ConfigError, 'test_command runs the command unsandboxed, so sandbox "strict" cannot be honored'
     end
 
     def validate_reeval!
@@ -222,14 +366,17 @@ module Saboteur
 
     def validate!
       raise ConfigError, "jobs must be >= 1" if self["jobs"] < 1
-      unless [true, false, "strict"].include?(self["sandbox"])
-        raise ConfigError, 'sandbox must be true, false, or "strict"'
+      unless [true, false, "strict", "seatbelt"].include?(self["sandbox"])
+        raise ConfigError, 'sandbox must be true, false, "strict", or "seatbelt"'
+      end
+      unless %w[off survivors decisive].include?(self["flaky_check"])
+        raise ConfigError, "flaky_check must be one of: off, survivors, decisive"
       end
 
       validate_mutant_limit!
       validate_threshold!
       validate_modes!
-      raise ConfigError, "seed must be >= 0" if self["seed"].negative?
+      validate_baseline!
       raise ConfigError, "max_memory_mb must be > 0" unless self["max_memory_mb"].positive?
       raise ConfigError, "max_processes must be > 0" unless self["max_processes"].positive?
       raise ConfigError, "timeout_factor must be > 0" unless self["timeout_factor"].positive?
@@ -237,6 +384,7 @@ module Saboteur
 
       validate_reeval!
       validate_operator_config!
+      validate_test_command!
     end
 
     public

data/lib/saboteur/config_file.rb

@@ -26,6 +26,14 @@ module Saboteur
         end
       end
 
+      # Repeatable per-path score gates (#473), the one setting that takes
+      # arguments: c.score_gate "app/payments/**/*", min_score: 95. Values
+      # are validated later, on the effective Config.
+      def score_gate(pattern, min_score:)
+        (@values["score_gates"] ||= []) << { "pattern" => pattern, "min_score" => min_score }
+        @lines["score_gates"] = caller_locations(1, 1).first.lineno
+      end
+
       Config::INTEGER_KEYS.each do |key|
         define_method("#{key}=") do |value|
           unless value.is_a?(Integer)

data/lib/saboteur/constant_reads.rb

@@ -0,0 +1,182 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require "prism"
+require_relative "text"
+
+module Saboteur
+  # The lines where a constant is read, per file: the tests covering those
+  # lines are the ones that can observe a change to the constant's value
+  # (issue #306).
+  #
+  # Matching is lexical and honest about its edges. A bare `RULES` matches
+  # when its scope is the constant's owner or nested under it (constant
+  # lookup climbs lexical scopes) or the constant is top-level; a
+  # `Shop::RULES` path matches by its full spelling. A scope that writes its
+  # own `RULES` shadows the outer constant: reads under it resolve to the
+  # inner one and do not count. Reads reached through a superclass,
+  # `const_get`, or a compact `class Shop::Item` scope are not resolved: a
+  # constant only read that way finds no consumer here, and the run reports
+  # it as ran-at-load instead of guessing.
+  #
+  # Runtime reads (inside a def body) observe the constant when the mutant
+  # runs; load-time reads outside the constant's own file do not: the other
+  # file was loaded once with the original value and re-evaluating the
+  # constant's file does not run it again, so a read like
+  # `COPY = A::RULES` there keeps the original (#319). A capture inside a
+  # boot-time block (`1.times { COPY = A::RULES }`) is treated the same:
+  # statement-level blocks run while the file loads. That is a heuristic -
+  # a block passed to a deferring call (at_exit, define_method) runs later,
+  # but treating it as load-time errs toward dropping a constant rather
+  # than reporting a mutant nobody can observe.
+  module ConstantReads
+    Reads = Data.define(:runtime, :load, :defs)
+
+    module_function
+
+    # { "/abs/file.rb" => Reads } for the files that read the constant.
+    # runtime: def-body and block lines - a block runs when its caller runs
+    # it (an `it` block during the example), and line coverage decides
+    # whether any test reached it. load: top-level or class-body statement
+    # lines (observable only in the constant's own file, which the mutant
+    # re-evaluates). defs: the start line of each def a runtime read sits
+    # in, for the method-call counter fallback (endless defs have no line
+    # coverage). Only files whose text mentions the name are parsed.
+    def across(files, constant)
+      mention = /\b#{Regexp.escape(constant.name.to_s)}\b/
+      files.each_with_object({}) do |file, hits|
+        source = File.binread(file)
+        next unless mentions?(source, mention)
+
+        reads = reads_in(source, constant)
+        hits[file] = reads unless reads.runtime.empty? && reads.load.empty?
+      end
+    end
+
+    # The lines a mutant of the constant can be observed through: runtime
+    # reads everywhere, load reads in the constant's own file only.
+    def observable_lines(reads_by_file, constant)
+      reads_by_file.each_with_object({}) do |(file, reads), hits|
+        lines = reads.runtime.dup
+        lines.concat(reads.load) if file == constant.file
+        hits[file] = lines.uniq.sort unless lines.empty?
+      end
+    end
+
+    def mentions?(source, mention)
+      Text.utf8_identity(source).match?(mention)
+    rescue Encoding::CompatibilityError, ArgumentError
+      false
+    end
+
+    def reads_in(source, constant)
+      result = Prism.parse(source)
+      return Reads.new([], [], []) if result.failure?
+
+      out = { runtime: [], load: [], defs: [] }
+      walk(result.value, [], constant, out, in_def: nil, in_block: false, shadowed: nil)
+      Reads.new(out[:runtime].uniq.sort, out[:load].uniq.sort, out[:defs].uniq.sort)
+    end
+
+    def walk(node, nesting, constant, out, in_def:, in_block:, shadowed:, capture: false)
+      return if node.nil?
+
+      case node
+      when Prism::DefNode
+        walk(node.body, nesting, constant, out, in_def: node.location.start_line, in_block: false,
+                                                shadowed: shadowed)
+      when Prism::BlockNode, Prism::LambdaNode
+        walk(node.body, nesting, constant, out, in_def: in_def, in_block: true, capture: capture,
+                                                shadowed: shadowed)
+      when Prism::ConstantWriteNode, Prism::ConstantPathWriteNode
+        # A capture (`COPY = <expr>`): the value reads the constant once,
+        # when the write runs. Walk the value flagged as a capture so a
+        # boot-time block write (`1.times { COPY = A::RULES }`) lands in
+        # load, not runtime (#319).
+        walk(node.value, nesting, constant, out, in_def: in_def, in_block: in_block, capture: true,
+                                                 shadowed: shadowed)
+      when Prism::ConstantReadNode
+        record(node, out, in_def, in_block, capture) if !shadowed && bare_match?(node, nesting, constant)
+      when Prism::ConstantPathNode
+        # `Shop::RULES` holds no ConstantReadNode for RULES, only for Shop;
+        # match the path's full spelling.
+        record(node, out, in_def, in_block, capture) if node.slice.delete_prefix("::") == constant.id
+        walk_children(node, nesting, constant, out, in_def: in_def, in_block: in_block, capture: capture,
+                                                    shadowed: shadowed)
+      when Prism::ModuleNode, Prism::ClassNode, Prism::SingletonClassNode
+        walk_scope(node, nesting, constant, out, shadowed)
+      else
+        walk_children(node, nesting, constant, out, in_def: in_def, in_block: in_block, capture: capture,
+                                                    shadowed: shadowed)
+      end
+    end
+
+    # `class << self` joins the nesting as "<attached>.singleton_class",
+    # matching how ConstantSubjectFinder names that owner (#380); a non-self
+    # receiver or a top-level singleton has no static name and adds nothing.
+    # The shadow carries the path of the scope that set it. Entering the
+    # constant's owner scope lifts a shadow set outside it: the owner's
+    # own definition is lexically closer there (#395). A shadow set
+    # inside the owner subtree still binds below the nested scope that
+    # wrote the constant.
+    def walk_scope(node, nesting, constant, out, shadowed)
+      inner = scope_nesting(node, nesting)
+      path = inner.join("::")
+      scopes = [constant.owner.to_s]
+      shadowed = nil if shadowed && scopes.any? { |scope| path == scope || path.start_with?("#{scope}::") } &&
+                        scopes.none? { |scope| shadowed == scope || shadowed.start_with?("#{scope}::") }
+      shadowed = path if shadowed.nil? && path != scopes.first && writes_constant?(node.body, constant.name)
+      walk(node.body, inner, constant, out, in_def: nil, in_block: false, shadowed: shadowed)
+    end
+
+    def scope_nesting(node, nesting)
+      return nesting + [node.constant_path.slice.delete_prefix("::")] unless node.is_a?(Prism::SingletonClassNode)
+      return nesting unless node.expression.is_a?(Prism::SelfNode) && nesting.any?
+
+      nesting[0...-1] + ["#{nesting.last}.singleton_class"]
+    end
+
+    def walk_children(node, nesting, constant, out, in_def:, in_block:, capture:, shadowed:)
+      node.compact_child_nodes.each do |child|
+        walk(child, nesting, constant, out, in_def: in_def, in_block: in_block, capture: capture,
+                                            shadowed: shadowed)
+      end
+    end
+
+    def record(node, out, in_def, in_block, capture)
+      line = node.location.start_line
+      if in_def
+        out[:runtime] << line
+        out[:defs] << in_def
+      elsif in_block && !capture
+        out[:runtime] << line
+      else
+        # A bare statement read, or a capture in a boot-time block: both
+        # resolved while the file loaded, with the original value.
+        out[:load] << line
+      end
+    end
+
+    # A bare `RULES` reads this constant when the read's scope is the
+    # constant's owner (or its singleton scope, whose ancestry reaches the
+    # attached class) or nested under either, or it is top-level (#380).
+    def bare_match?(node, nesting, constant)
+      return false unless node.name == constant.name
+      return true if constant.owner.nil?
+
+      path = nesting.join("::")
+      [constant.owner, "#{constant.owner}.singleton_class"].any? do |scope|
+        path == scope || path.start_with?("#{scope}::")
+      end
+    end
+
+    # True when the scope body assigns the constant name at its own level
+    # (not inside a nested def or scope).
+    def writes_constant?(body, name)
+      statements = body&.body || []
+      statements.any? do |statement|
+        statement.is_a?(Prism::ConstantWriteNode) && statement.name == name
+      end
+    end
+  end
+end

data/lib/saboteur/constant_subject.rb

@@ -0,0 +1,70 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require_relative "subject"
+
+module Saboteur
+  # A constant assigned a hash or array literal, as a mutation subject
+  # (issue #306): `RULES = { ... }` or `TAGS = [ ... ]`, with an optional
+  # trailing `.freeze`. Only --since selection creates these (see
+  # Engine::SubjectSelection), and the diff scope narrows their mutants to
+  # the entries the diff changed.
+  #
+  # A constant is not a method, so the surgical def re-evaluation does not
+  # apply: mutants run by re-evaluating the whole file with the mutated
+  # assignment spliced in (Execution::Reevaluator#eval_whole_file, which
+  # silences the "already initialized constant" warning). Re-evaluation
+  # replaces the constant's object; code that reads the constant at test
+  # time sees the mutant, while anything that copied the old object at load
+  # time keeps it. consumer_lines names the reads a test can cover; the
+  # coverage map turns them into the mutant's tests.
+  class ConstantSubject < Subject
+    attr_reader :literal_node
+    # { "/abs/file.rb" => [lines reading the constant] } across the include
+    # set, filled in after selection (the finder sees one file at a time).
+    attr_accessor :consumer_lines
+    # { "/abs/file.rb" => [def start lines] }: the def each runtime read
+    # sits in, for the method-call counter fallback (endless defs have no
+    # line coverage).
+    attr_accessor :consumer_defs
+
+    def initialize(name:, owner:, file:, node:, literal_node:, file_source:, nesting:, frozen_literals:,
+                   consumer_lines: {}, consumer_defs: {})
+      super(name:, owner:, singleton: false, sclass: false, file:, node:, file_source:, nesting:,
+            frozen_literals:, sig_span: nil)
+      @literal_node = literal_node
+      @consumer_lines = consumer_lines
+      @consumer_defs = consumer_defs
+    end
+
+    # "Shop::RULES", or "RULES" at the top level. The :: separator keeps a
+    # constant's id apart from the Klass#method and Klass.method spellings.
+    def id
+      owner ? "#{owner}::#{name}" : name.to_s
+    end
+
+    # There is no method body to redefine: constants always take the
+    # whole-file evaluation path.
+    def whole_file_only?
+      true
+    end
+
+    # The assignment runs while the file loads, so its lines carry the load
+    # evidence; the reads of the constant in this file are the lines tests
+    # can cover.
+    def coverage_lines
+      ((start_line..end_line).to_a + Array(consumer_lines[file])).uniq
+    end
+
+    # Every edit sits inside the literal and is observable wherever the
+    # constant is read, so the assignment's own lines are the evidence that
+    # the edit ran (they execute at load, never inside a test).
+    def coverage_lines_for(_edit)
+      (start_line..end_line).to_a
+    end
+
+    def recovers?
+      false
+    end
+  end
+end