tryouts 3.7.0 → 4.0.0.pre1

data/lib/tryouts/parsers/shared_methods.rb

@@ -1,4 +1,6 @@
 # lib/tryouts/parsers/shared_methods.rb
+#
+# frozen_string_literal: true
 
 require_relative '../parser_warning'
 
@@ -208,12 +210,21 @@ class Tryouts
       # Process classified test blocks into domain objects
       def process_test_blocks(classified_blocks)
         setup_blocks    = classified_blocks.filter { |block| block[:type] == :setup }
-        test_blocks     = classified_blocks.filter { |block| block[:type] == :test }
         teardown_blocks = classified_blocks.filter { |block| block[:type] == :teardown }
 
+        # Test cases and orphan blocks stay interleaved in source order: the
+        # executor runs them sequentially and an orphan executed out of position
+        # would corrupt the shared-context local-variable timeline.
+        test_cases = classified_blocks.filter_map do |block|
+          case block[:type]
+          when :test then build_test_case(block)
+          when :orphan then build_orphan_block(block)
+          end
+        end
+
         testrun = Testrun.new(
           setup: build_setup(setup_blocks),
-          test_cases: test_blocks.map { |block| build_test_case(block) },
+          test_cases: test_cases,
           teardown: build_teardown(teardown_blocks),
           source_file: @source_path,
           metadata: { parsed_at: @parsed_at, parser: parser_type },
@@ -233,6 +244,7 @@ class Tryouts
           code: extract_pure_code_from_blocks(setup_blocks),
           line_range: calculate_block_range(setup_blocks),
           path: @source_path,
+          first_code_line: first_code_line(collect_code_tokens(setup_blocks)),
         )
       end
 
@@ -243,22 +255,29 @@ class Tryouts
           code: extract_pure_code_from_blocks(teardown_blocks),
           line_range: calculate_block_range(teardown_blocks),
           path: @source_path,
+          first_code_line: first_code_line(collect_code_tokens(teardown_blocks)),
+        )
+      end
+
+      # Orphan blocks (code with no description and no expectations, sandwiched
+      # between real test cases) are collected for execution instead of being
+      # silently dropped. Comment-only blocks carry no executable code and
+      # produce nothing.
+      def build_orphan_block(block)
+        code = extract_pure_code_from_blocks([block])
+        return nil if code.strip.empty?
+
+        OrphanBlock.new(
+          code: code,
+          line_range: calculate_block_range([block]),
+          path: @source_path,
+          first_code_line: first_code_line(collect_code_tokens([block])),
         )
       end
 
       # Modern Ruby 3.4+ pattern matching for robust code extraction
       def extract_pure_code_from_blocks(blocks)
-        blocks
-          .flat_map { |block| block[:code] }
-          .filter_map do |token|
-            case token
-            in { type: :code, content: String => content }
-              content
-            else
-              nil
-            end
-          end
-          .join("\n")
+        extract_code_content(collect_code_tokens(blocks))
       end
 
       def calculate_block_range(blocks)
@@ -271,17 +290,47 @@ class Tryouts
         line_ranges.first.first..line_ranges.last.last
       end
 
+      # Code keeps the spacing it had in the source: every comment or blank line
+      # between two statements becomes an empty line here. Paired with
+      # `first_code_line` as the eval start line, that makes each statement in a
+      # multi-line block report its true source location in a backtrace. Joining
+      # the code lines alone would collapse the gaps and drift by however many
+      # lines were dropped.
       def extract_code_content(code_tokens)
+        positioned = positioned_code_tokens(code_tokens)
+        return '' if positioned.empty?
+
+        base  = positioned.first.first
+        lines = []
+
+        positioned.each { |line, content| lines[line - base] = content }
+        lines.map { |content| content || '' }.join("\n")
+      end
+
+      # 0-based source line of the block's first executable line, which is not
+      # the same as its start_line: a block opens at its description or leading
+      # comment, and only the code lines are ever evaluated.
+      def first_code_line(code_tokens)
+        positioned_code_tokens(code_tokens).first&.first
+      end
+
+      def collect_code_tokens(blocks)
+        blocks.flat_map { |block| block[:code] }
+      end
+
+      # [line, content] pairs for executable lines only, in source order. The
+      # tokenizer emits at most one :code token per physical line.
+      def positioned_code_tokens(code_tokens)
         code_tokens
           .filter_map do |token|
             case token
-            in { type: :code, content: String => content }
-              content
+            in { type: :code, content: String => content, line: Integer => line }
+              [line, content]
             else
               nil
             end
           end
-          .join("\n")
+          .sort_by(&:first)
       end
 
       def parse_ruby_line(line)
@@ -342,7 +391,7 @@ class Tryouts
                        in { expectations: Array => exps } if !exps.empty?
                          :test
                        else
-                         :preamble
+                         :orphan
                        end
 
           block.merge(type: block_type, end_line: calculate_end_line(block))
@@ -375,6 +424,7 @@ class Tryouts
           TestCase.new(
             description: desc,
             code: extract_code_content(code_tokens),
+            first_code_line: first_code_line(code_tokens),
             expectations: exp_tokens.map do |token|
               type = case token[:type]
                      when :exception_expectation then :exception

data/lib/tryouts/test_batch.rb

@@ -1,5 +1,8 @@
-# lib/tryouts/testbatch.rb
+# lib/tryouts/test_batch.rb
+#
+# frozen_string_literal: true
 
+require 'monitor'
 require 'stringio'
 require_relative 'expectation_evaluators/registry'
 
@@ -22,6 +25,17 @@ class Tryouts
 
   # Modern TestBatch using Ruby 3.4+ patterns and formatter system
   class TestBatch
+    # $stdout/$stderr are process-global, not Fiber- or thread-local. Under
+    # --parallel (Concurrent::ThreadPoolExecutor), concurrent redirects would
+    # clobber each other and could leave $stdout pointing at a dead StringIO
+    # process-wide. Every redirect path (capture_output for setup/teardown and
+    # each test, plus execute_with_output_capture) synchronizes on this lock so
+    # the redirect/execute/restore window is serialized across threads.
+    #
+    # A Monitor (reentrant) is required because execute_with_output_capture runs
+    # nested inside capture_output; a plain Mutex would self-deadlock.
+    OUTPUT_CAPTURE_MONITOR = Monitor.new
+
     attr_reader :testrun, :failed_count, :container, :status, :results, :formatter, :output_manager
 
     def initialize(testrun, **options)
@@ -37,6 +51,12 @@ class Tryouts
       @start_time      = nil
       @test_case_count = 0
       @setup_failed    = false
+      @orphan_failed   = false
+
+      # Shared-context mode evaluates every block against this one reused
+      # Binding so local variables persist across blocks like a plain Ruby
+      # script. Fresh-context mode keeps per-container instance_eval isolation.
+      @binding = options[:shared_context] ? acquire_container_binding(@container) : nil
       @line_spec       = options[:line_spec]  # For output filtering only
 
       # Setup container for fresh context mode - preserves @instance_variables from setup
@@ -60,7 +80,7 @@ class Tryouts
       return false if empty?
 
       @start_time      = Time.now
-      @test_case_count = test_cases.size
+      @test_case_count = @testrun.total_tests
 
       @output_manager&.execution_phase(@test_case_count)
       @output_manager&.info("Context: #{@options[:shared_context] ? 'shared' : 'fresh'}", 1)
@@ -93,6 +113,16 @@ class Tryouts
 
       idx               = 0
       execution_results = test_cases.map do |test_case|
+        # Orphan blocks run for side effects only, in source order. A raise
+        # aborts the batch like a setup failure: every subsequent test's
+        # context is suspect.
+        if test_case.is_a?(OrphanBlock)
+          execute_orphan_block(test_case)
+          break if @orphan_failed
+
+          next
+        end
+
         @output_manager&.trace("Test #{idx + 1}/#{@test_case_count}: #{test_case.description}", 2)
         idx += 1
 
@@ -132,6 +162,14 @@ class Tryouts
         error_result
       end
 
+      if @orphan_failed
+        @output_manager&.error('Stopping batch execution due to orphan code block failure')
+        @status = :failed
+        @failed_count += 1
+        finalize_results(execution_results || [])
+        return false
+      end
+
       # Used for a separate purpose then execution_phase.
       # e.g. the quiet formatter prints a newline after all test dots
       @output_manager&.file_end(path, context: @options[:shared_context] ? :shared : :fresh)
@@ -171,6 +209,29 @@ class Tryouts
 
     private
 
+    # Must be its own method, never inlined at a call site, and must use
+    # instance_eval on a STRING, not a block. A block literal fixes
+    # Module.nesting to wherever it is lexically written ([Tryouts::TestBatch]
+    # here), which would make every container's `class Foo` definitions land in
+    # one shared namespace across files. instance_eval(string) instead sets the
+    # default definee to the receiver's own singleton class, preserving the
+    # per-container class/def isolation that instance_eval(code_string) gives.
+    def acquire_container_binding(container)
+      container.instance_eval('binding', __FILE__, __LINE__)
+    end
+
+    # Evaluate a block of test code against the given container. Shared-context
+    # mode reuses the one Binding acquired at initialization; each block is
+    # still its own eval call (individually rescuable and timeoutable), only
+    # the state that persists between calls changes.
+    def eval_code(container, code, path, line)
+      if @binding && container.equal?(@container)
+        @binding.eval(code, path, line)
+      else
+        container.instance_eval(code, path, line)
+      end
+    end
+
     # Pattern matching for execution strategy selection
     def execute_single_test(test_case, before_test_hook = nil)
       before_test_hook&.call(test_case)
@@ -244,8 +305,7 @@ class Tryouts
         begin
           code  = test_case.code
           path  = test_case.path
-          range = test_case.line_range
-          container.instance_eval(code, path, range.first + 1)
+          eval_code(container, code, path, test_case.eval_start_line)
         rescue SystemStackError, NoMemoryError, SecurityError, ScriptError => ex
           # Handle system-level exceptions that don't inherit from StandardError
           # ScriptError includes: LoadError, SyntaxError, NotImplementedError
@@ -260,9 +320,9 @@ class Tryouts
         build_test_result(test_case, caught_exception, expectations_result)
       else
         # Regular execution for non-exception tests with timing and output capture
-        code  = test_case.code
-        path  = test_case.path
-        range = test_case.line_range
+        code       = test_case.code
+        path       = test_case.path
+        start_line = test_case.eval_start_line
 
         # Check if we need output capture for any expectations
         needs_output_capture = test_case.expectations.any?(&:output?)
@@ -270,9 +330,9 @@ class Tryouts
         result_value, _, _, _, expectations_result =
           execute_with_timeout(test_timeout, test_case) do
             if needs_output_capture
-              # Execute with output capture using Fiber-local isolation
+              # Execute with output capture (serialized process-global redirect)
               result_value, execution_time_ns, stdout_content, stderr_content =
-                execute_with_output_capture(container, code, path, range)
+                execute_with_output_capture(container, code, path, start_line)
 
               expectations_result = evaluate_expectations(
                 test_case, result_value, container, execution_time_ns, stdout_content, stderr_content
@@ -281,7 +341,7 @@ class Tryouts
             else
               # Regular execution with timing capture only
               execution_start_ns = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
-              result_value       = container.instance_eval(code, path, range.first + 1)
+              result_value       = eval_code(container, code, path, test_case.eval_start_line)
               execution_end_ns   = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
               execution_time_ns  = execution_end_ns - execution_start_ns
 
@@ -306,37 +366,37 @@ class Tryouts
       build_error_result(test_case, StandardError.new("Test terminated by #{ex.class}: #{ex.message}"))
     end
 
-    # Execute test code with Fiber-based stdout/stderr capture
-    def execute_with_output_capture(container, code, path, range)
-      # Fiber-local storage for output redirection
-      original_stdout = $stdout
-      original_stderr = $stderr
-
+    # Execute test code while capturing its stdout/stderr.
+    #
+    # $stdout/$stderr are process-global. The redirect below mutates them for the
+    # whole process, so OUTPUT_CAPTURE_MONITOR serializes this section to keep
+    # concurrent --parallel runs from corrupting each other's output or leaving a
+    # dangling StringIO behind. See OUTPUT_CAPTURE_MONITOR for details.
+    def execute_with_output_capture(container, code, path, start_line)
       # Create StringIO objects for capturing output
       captured_stdout = StringIO.new
       captured_stderr = StringIO.new
 
-      begin
-        # Redirect output streams using Fiber-local variables
-        Fiber.new do
+      OUTPUT_CAPTURE_MONITOR.synchronize do
+        original_stdout = $stdout
+        original_stderr = $stderr
+
+        begin
           $stdout = captured_stdout
           $stderr = captured_stderr
 
           # Execute with timing capture
           execution_start_ns = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
-          result_value       = container.instance_eval(code, path, range.first + 1)
+          result_value       = eval_code(container, code, path, start_line)
           execution_end_ns   = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
           execution_time_ns  = execution_end_ns - execution_start_ns
 
-          [result_value, execution_time_ns]
-        end.resume.tap do |result_value, execution_time_ns|
-          # Return captured content along with result
-          return [result_value, execution_time_ns, captured_stdout.string, captured_stderr.string]
+          [result_value, execution_time_ns, captured_stdout.string, captured_stderr.string]
+        ensure
+          # Always restore original streams
+          $stdout = original_stdout
+          $stderr = original_stderr
         end
-      ensure
-        # Always restore original streams
-        $stdout = original_stdout
-        $stderr = original_stderr
       end
     end
 
@@ -426,6 +486,49 @@ class Tryouts
       end
     end
 
+    # Orphan blocks are setup-like glue between test cases: silent on success
+    # (no pass/fail, not counted in tallies), a file-level error on failure.
+    # In fresh-context mode they run against the setup container so their
+    # @instance_variables propagate to subsequent tests' fresh copies.
+    def execute_orphan_block(orphan)
+      return if orphan.code.strip.empty?
+
+      target = if shared_context?
+                 @container
+               else
+                 @setup_container ||= Object.new
+               end
+
+      @output_manager&.info("Running orphan code block (#{orphan.path}:#{orphan.line_range.first + 1})", 2)
+
+      captured_output = capture_output do
+        eval_code(target, orphan.code, orphan.path, orphan.eval_start_line)
+      end
+
+      @output_manager&.setup_output(captured_output) if captured_output && !captured_output.empty?
+    rescue StandardError => ex
+      @orphan_failed = true
+      if @global_tally && @global_tally[:aggregator]
+        @global_tally[:aggregator].add_infrastructure_failure(
+          :orphan, @testrun.source_file, ex.message, ex
+        )
+      end
+
+      Tryouts.debug "Orphan code block failed (#{ex.class}): #{ex.message}"
+      Tryouts.trace ex.backtrace
+
+      @output_manager&.error("Orphan code block failed (#{orphan.path}:#{orphan.line_range.first + 1}): #{ex.message}")
+    rescue SystemExit, SignalException => ex
+      @orphan_failed = true
+      if @global_tally && @global_tally[:aggregator]
+        @global_tally[:aggregator].add_infrastructure_failure(
+          :orphan, @testrun.source_file, "Orphan block terminated by #{ex.class}: #{ex.message}", ex
+        )
+      end
+
+      @output_manager&.error("Orphan code block terminated by #{ex.class}: #{ex.message}")
+    end
+
     # Global setup execution for shared context mode
     def execute_global_setup
       setup = @testrun.setup
@@ -435,7 +538,7 @@ class Tryouts
 
         # Capture setup output instead of letting it print directly
         captured_output = capture_output do
-          @container.instance_eval(setup.code, setup.path, setup.line_range.first + 1)
+          eval_code(@container, setup.code, setup.path, setup.eval_start_line)
         end
 
         @output_manager&.setup_output(captured_output) if captured_output && !captured_output.empty?
@@ -487,7 +590,7 @@ class Tryouts
 
         # Capture setup output instead of letting it print directly
         captured_output = capture_output do
-          @setup_container.instance_eval(setup.code, setup.path, setup.line_range.first + 1)
+          @setup_container.instance_eval(setup.code, setup.path, setup.eval_start_line)
         end
 
         @output_manager&.setup_output(captured_output) if captured_output && !captured_output.empty?
@@ -536,7 +639,7 @@ class Tryouts
 
         # Capture teardown output instead of letting it print directly
         captured_output = capture_output do
-          @container.instance_eval(teardown.code, teardown.path, teardown.line_range.first + 1)
+          eval_code(@container, teardown.code, teardown.path, teardown.eval_start_line)
         end
 
         @output_manager&.teardown_output(captured_output) if captured_output && !captured_output.empty?
@@ -612,19 +715,28 @@ class Tryouts
       Tryouts::CLI::LineSpecParser.matches?(test_case, @line_spec)
     end
 
+    # Redirects the process-global $stdout/$stderr to StringIO for the duration of
+    # the block. This is the outer capture used by setup, teardown, and every test
+    # (execute_with_output_capture nests inside it for output-expectation tests).
+    # Synchronizes on OUTPUT_CAPTURE_MONITOR so the redirect/restore window is
+    # serialized across --parallel threads that share these process-global streams.
     def capture_output
-      old_stdout = $stdout
-      old_stderr = $stderr
-      $stdout    = StringIO.new
-      $stderr    = StringIO.new
-
-      yield
-
-      captured = $stdout.string + $stderr.string
-      captured.empty? ? nil : captured
-    ensure
-      $stdout = old_stdout
-      $stderr = old_stderr
+      OUTPUT_CAPTURE_MONITOR.synchronize do
+        old_stdout = $stdout
+        old_stderr = $stderr
+        $stdout    = StringIO.new
+        $stderr    = StringIO.new
+
+        begin
+          yield
+
+          captured = $stdout.string + $stderr.string
+          captured.empty? ? nil : captured
+        ensure
+          $stdout = old_stdout
+          $stderr = old_stderr
+        end
+      end
     end
 
     def handle_batch_error(exception)

data/lib/tryouts/test_case.rb

@@ -1,9 +1,28 @@
-# lib/tryouts/testcase.rb
+# lib/tryouts/test_case.rb
+#
+# frozen_string_literal: true
 
 # Modern data structures using Ruby 3.2+ Data classes
 class Tryouts
+  # A block is evaluated starting at its first executable line, not at its
+  # line_range.first: a block opens at its description or a leading comment,
+  # while the extracted code begins at the first statement. Getting this wrong
+  # misattributes every backtrace line in the block. Hand-built blocks (e.g.
+  # translator fixtures) may omit first_code_line and fall back to the start.
+  module EvalAnchor
+    def eval_start_line
+      (first_code_line || line_range.first) + 1
+    end
+  end
+
   # Core data structures
-  TestCase = Data.define(:description, :code, :expectations, :line_range, :path, :source_lines, :first_expectation_line) do
+  TestCase = Data.define(:description, :code, :expectations, :line_range, :path, :source_lines, :first_expectation_line, :first_code_line) do
+    include EvalAnchor
+
+    def initialize(first_code_line: nil, **rest)
+      super
+    end
+
     def empty?
       code.empty?
     end
@@ -55,25 +74,54 @@ class Tryouts
     def stderr? = pipe == 2
   end
 
-  Setup = Data.define(:code, :line_range, :path) do
+  Setup = Data.define(:code, :line_range, :path, :first_code_line) do
+    include EvalAnchor
+
+    def initialize(first_code_line: nil, **rest)
+      super
+    end
+
+    def empty?
+      code.empty?
+    end
+  end
+
+  # Code with no description and no expectations that sits between test cases.
+  # Executed in source order for its side effects, but never evaluated against
+  # expectations and never counted in test tallies.
+  OrphanBlock = Data.define(:code, :line_range, :path, :first_code_line) do
+    include EvalAnchor
+
+    def initialize(first_code_line: nil, **rest)
+      super
+    end
+
     def empty?
       code.empty?
     end
   end
 
-  Teardown = Data.define(:code, :line_range, :path) do
+  Teardown = Data.define(:code, :line_range, :path, :first_code_line) do
+    include EvalAnchor
+
+    def initialize(first_code_line: nil, **rest)
+      super
+    end
+
     def empty?
       code.empty?
     end
   end
 
+  # test_cases is a single ordered array of TestCase | OrphanBlock — the
+  # interleaving order is load-bearing for shared-context local-variable state.
   Testrun = Data.define(:setup, :test_cases, :teardown, :source_file, :metadata, :warnings) do
     def total_tests
-      test_cases.size
+      test_cases.count { |tc| tc.is_a?(TestCase) }
     end
 
     def empty?
-      test_cases.empty?
+      total_tests.zero?
     end
   end
 

data/lib/tryouts/test_executor.rb

@@ -1,4 +1,6 @@
 # lib/tryouts/test_executor.rb
+#
+# frozen_string_literal: true
 
 require_relative 'test_batch'
 

data/lib/tryouts/test_result_aggregator.rb

@@ -1,4 +1,6 @@
 # lib/tryouts/test_result_aggregator.rb
+#
+# frozen_string_literal: true
 
 require_relative 'failure_collector'
 require 'concurrent'

data/lib/tryouts/test_runner.rb

@@ -1,7 +1,8 @@
 # lib/tryouts/test_runner.rb
+#
+# frozen_string_literal: true
 
 require 'concurrent'
-require_relative 'parsers/legacy_parser'
 require_relative 'parsers/enhanced_parser'
 require_relative 'test_batch'
 require_relative 'translators/rspec_translator'

data/lib/tryouts/translators/minitest_translator.rb

@@ -1,4 +1,6 @@
 # lib/tryouts/translators/minitest_translator.rb
+#
+# frozen_string_literal: true
 
 class Tryouts
   module Translators
@@ -41,6 +43,15 @@ class Tryouts
     # Recommendation: Write tryouts tests that work in fresh context mode
     # if you plan to use Minitest translation.
     class MinitestTranslator
+      # Simple string parameterization for method names.
+      #
+      # Defined on the class because `translate` calls it from inside a
+      # `Class.new(Minitest::Test) do ... end` block, where `self` is the
+      # anonymous test class rather than the translator instance.
+      def self.parameterize(string)
+        string.downcase.gsub(/[^a-z0-9]+/, '_').gsub(/^_|_$/, '')
+      end
+
       def initialize
         require 'minitest/test'
       rescue LoadError
@@ -61,18 +72,29 @@ class Tryouts
 
           # Generate test methods
           testrun.test_cases.each_with_index do |test_case, index|
+            # Orphan blocks become plain statements in the class body, in source order
+            if test_case.is_a?(Tryouts::OrphanBlock)
+              unless test_case.empty?
+                class_eval(test_case.code, testrun.source_file, test_case.eval_start_line)
+              end
+              next
+            end
+
             next if test_case.empty? || !test_case.expectations?
 
-            method_name = "test_#{index.to_s.rjust(3, '0')}_#{parameterize(test_case.description)}"
+            method_name = "test_#{index.to_s.rjust(3, '0')}_#{MinitestTranslator.parameterize(test_case.description)}"
             define_method(method_name) do
               if test_case.exception_expectations?
-                # Handle exception expectations
-                assert_raises(StandardError) do
+                # Handle exception expectations. The raised exception is bound to
+                # a local named `error`, which is what #=!> expectations refer to,
+                # so the expectation is eval'd against this binding rather than
+                # instance_eval'd.
+                error = assert_raises(StandardError) do
                   instance_eval(test_case.code) unless test_case.code.strip.empty?
                 end
 
                 test_case.exception_expectations.each do |expectation|
-                  result = instance_eval(expectation.content)
+                  result = eval(expectation.content, binding) # rubocop:disable Security/Eval
                   assert result, "Exception expectation failed: #{expectation.content}"
                 end
               else
@@ -119,9 +141,18 @@ class Tryouts
         end
 
         testrun.test_cases.each_with_index do |test_case, index|
+          # Orphan blocks become plain statements in the class body, in source order
+          if test_case.is_a?(Tryouts::OrphanBlock)
+            unless test_case.empty?
+              test_case.code.lines.each { |line| lines << "  #{line.chomp}" }
+              lines << ''
+            end
+            next
+          end
+
           next if test_case.empty? || !test_case.expectations?
 
-          method_name = "test_#{index.to_s.rjust(3, '0')}_#{parameterize(test_case.description)}"
+          method_name = "test_#{index.to_s.rjust(3, '0')}_#{MinitestTranslator.parameterize(test_case.description)}"
           lines << "  def #{method_name}"
 
           if test_case.exception_expectations?
@@ -161,13 +192,6 @@ class Tryouts
         lines << 'end'
         lines.join("\n")
       end
-
-      private
-
-      # Simple string parameterization for method names
-      def parameterize(string)
-        string.downcase.gsub(/[^a-z0-9]+/, '_').gsub(/^_|_$/, '')
-      end
     end
   end
 end