docscribe 1.5.0 → 1.5.1

data/lib/docscribe/cli/run.rb

@@ -4,7 +4,6 @@ require 'pathname'
 
 require 'docscribe/cli/config_builder'
 require 'docscribe/cli/formatters'
-require 'docscribe/inline_rewriter'
 
 module Docscribe
   module CLI
@@ -35,6 +34,14 @@ module Docscribe
           total: 0,
           processed: 0
         }.freeze
+
+        CLI_OVERRIDE_KEYS = %i[
+          keep_descriptions no_boilerplate
+          include exclude include_file exclude_file
+          rbs rbs_collection sig_dirs
+          sorbet rbi_dirs
+        ].freeze
+
         # Run Docscribe for files or STDIN using the selected mode and strategy.
         #
         # Modes:
@@ -50,6 +57,9 @@ module Docscribe
         # @param [Array<String>] argv remaining path arguments
         # @return [Integer] process exit code
         def run(options:, argv:)
+          return run_via_server(options: options, argv: argv) if options[:server]
+
+          require 'docscribe/inline_rewriter'
           conf = build_config(options)
 
           return run_stdin(options: options, conf: conf) if options[:mode] == :stdin
@@ -60,10 +70,45 @@ module Docscribe
           run_files(options: options, conf: conf, paths: paths)
         end
 
-        # Load and build the effective config from CLI options.
+        # @param [Docscribe::CLI::Formatters::opts] options
+        # @param [Array<String>] argv
+        # @raise [RuntimeError]
+        # @return [Integer]
+        # @return [Integer] if RuntimeError
+        def run_via_server(options:, argv:)
+          require 'docscribe/server'
+          conf = build_light_config(options)
+          ensure_server_running!(config_path: conf.config_path)
+          client = Docscribe::Server::Client.new(config_path: conf.config_path)
+          paths = filtered_paths(argv, conf)
+          return no_files_found unless paths.any?
+
+          run_files_via_server(client, paths, options)
+        rescue RuntimeError => e
+          warn e.message
+          1
+        end
+
+        # Run files through the server client with progress tracking.
         #
-        # @param [Docscribe::CLI::Formatters::opts] options parsed CLI options
-        # @return [Docscribe::Config] effective config with plugins loaded
+        # @param [Docscribe::Server::Client] client server client
+        # @param [Array<String>] paths file paths to process
+        # @param [Docscribe::CLI::Formatters::opts] options CLI options
+        # @return [Integer] exit code
+        def run_files_via_server(client, paths, options)
+          $stdout.sync = true
+          state = initial_run_state
+          state[:total] = paths.size
+          pwd = Pathname.pwd
+          paths.each do |path|
+            process_one_file_via_server(client, path, options: options, pwd: pwd, state: state)
+          end
+          finalize_run(options, state)
+          run_exit_code(options, state)
+        end
+
+        # @param [Docscribe::CLI::Formatters::opts] options
+        # @return [Docscribe::Config]
         def build_config(options)
           conf = Docscribe::Config.load(options[:config])
           conf = Docscribe::CLI::ConfigBuilder.build(conf, options)
@@ -71,13 +116,20 @@ module Docscribe
           conf
         end
 
+        # @param [Docscribe::CLI::Formatters::opts] options
+        # @return [Docscribe::Config]
+        def build_light_config(options)
+          conf = Docscribe::Config.load(options[:config])
+          Docscribe::CLI::ConfigBuilder.build(conf, options)
+        end
+
         # Rewrite code from STDIN using the selected strategy and print the
         # result.
         #
         # @param [Docscribe::CLI::Formatters::opts] options parsed CLI options
         # @param [Docscribe::Config] conf effective config
         # @raise [StandardError]
-        # @return [Integer] if StandardError
+        # @return [Integer]
         # @return [Integer] if StandardError
         def run_stdin(options:, conf:)
           puts stdin_rewrite_result(options, conf)[:output]
@@ -127,6 +179,161 @@ module Docscribe
           2
         end
 
+        # Ensure the server daemon is running, auto-starting if necessary.
+        #
+        # @param [String?] config_path
+        # @return [void]
+        def ensure_server_running!(config_path: nil)
+          Docscribe::Server.ensure_running!(config_path: config_path)
+        end
+
+        # Process a single file via the server client.
+        #
+        # @param [Docscribe::Server::Client] client server client
+        # @param [String] path file path
+        # @param [Docscribe::CLI::Formatters::opts] options CLI options
+        # @param [Pathname] pwd current working directory
+        # @param [Docscribe::CLI::Formatters::state] state shared processing state
+        # @return [void]
+        def process_one_file_via_server(client, path, options:, pwd:, state:)
+          display_path = display_path_for(path, pwd: pwd)
+          report_progress(state, options, display_path)
+          response = send_server_request(client, path, options)
+          return server_error(path, state, 'Server unreachable') unless response
+          return server_error(path, state, response['error']['message']) if response['error']
+
+          result = response['result']
+          file_changes = (result['changes'] || []).map { |c| symbolize_change(c) }
+          dispatch_server_result(result, file_changes, path,
+                                 display_path: display_path, options: options, state: state)
+        end
+
+        # @param [Docscribe::Server::Client] client
+        # @param [String] path
+        # @param [Docscribe::CLI::Formatters::opts] options
+        # @return [Hash<String, Object>, nil]
+        def send_server_request(client, path, options)
+          method_name = options[:mode] == :write ? :fix : :check
+          strategy = options[:strategy].to_s
+          cli_overrides = extract_cli_overrides(options)
+          if cli_overrides.empty?
+            client.send(method_name, file: path, strategy: strategy)
+          else
+            client.send(method_name, file: path, strategy: strategy, cli_overrides: cli_overrides)
+          end
+        end
+
+        # Record a server error in the shared state and print an indicator.
+        #
+        # @param [String] path file path
+        # @param [Docscribe::CLI::Formatters::state] state shared processing state
+        # @param [String] message error message
+        # @return [void]
+        def server_error(path, state, message)
+          state[:had_errors] = true
+          state[:error_paths] << path
+          state[:error_messages][path] = message
+          $stderr.print('E')
+        end
+
+        # Dispatch the server result to check or write handler.
+        #
+        # @param [Hash<String, Object>] result server result with :changed and :changes keys
+        # @param [Array<Docscribe::CLI::Formatters::change>] file_changes change records
+        # @param [String] path file path
+        # @param [Object] ctx context hash with :display_path, :options, :state keys
+        # @return [void]
+        def dispatch_server_result(result, file_changes, path, **ctx)
+          if ctx[:options][:mode] == :check
+            handle_via_server_check(path, file_changes: file_changes,
+                                          display_path: ctx[:display_path],
+                                          options: ctx[:options], state: ctx[:state])
+          else
+            write_server_result(result, file_changes, display_path: ctx[:display_path],
+                                                      options: ctx[:options], state: ctx[:state])
+          end
+        end
+
+        # Handle a server write-mode result.
+        #
+        # @param [Hash<String, Object>] result server result with :changed key
+        # @param [Array<Docscribe::CLI::Formatters::change>] file_changes change records
+        # @param [String] display_path path shown in CLI output
+        # @param [Docscribe::CLI::Formatters::opts] options CLI options
+        # @param [Docscribe::CLI::Formatters::state] state shared processing state
+        # @return [void]
+        def write_server_result(result, file_changes, display_path:, options:, state:)
+          if result['changed']
+            state[:corrected] += 1
+            state[:corrected_paths] << display_path
+            state[:corrected_changes][display_path] = file_changes
+            log_check_verdict('CHANGED', display_path, options)
+          else
+            log_check_verdict('OK', display_path, options)
+          end
+        end
+
+        # Handle a check result from the server.
+        #
+        # @param [String] path file path
+        # @param [Array<Docscribe::CLI::Formatters::change>] file_changes change records from server
+        # @param [String] display_path path shown in CLI output
+        # @param [Docscribe::CLI::Formatters::opts] options CLI options
+        # @param [Docscribe::CLI::Formatters::state] state shared processing state
+        # @return [void]
+        def handle_via_server_check(path, file_changes:, display_path:, options:, state:)
+          if file_changes.empty?
+            state[:checked_ok] += 1
+            return log_check_verdict('OK', display_path, options)
+          end
+
+          report_check_failure(display_path, file_changes, options)
+          update_check_failure_state(path, file_changes, state)
+        end
+
+        # Report a check failure with verbose or compact output.
+        #
+        # @param [String] display_path path shown in CLI output
+        # @param [Array<Docscribe::CLI::Formatters::change>] file_changes change records from server
+        # @param [Docscribe::CLI::Formatters::opts] options CLI options
+        # @return [void]
+        def report_check_failure(display_path, file_changes, options)
+          if options[:verbose]
+            warn("FAIL #{display_path}")
+            print_check_explanations(file_changes)
+          else
+            $stderr.print('F')
+          end
+        end
+
+        # Update shared state after a check failure.
+        #
+        # @param [String] path file path
+        # @param [Array<Docscribe::CLI::Formatters::change>] file_changes change records from server
+        # @param [Docscribe::CLI::Formatters::state] state shared processing state
+        # @return [void]
+        def update_check_failure_state(path, file_changes, state)
+          state[:checked_fail] += 1
+          state[:changed] = true
+          state[:fail_paths] << path
+          state[:fail_changes][path] = file_changes
+        end
+
+        # Convert server response change (string keys) to formatter-compatible
+        # change (symbol keys).
+        #
+        # @param [Hash<String, Object>] change change record from server
+        # @return [Docscribe::CLI::Formatters::change]
+        def symbolize_change(change)
+          {
+            type: change['type'].to_sym,
+            file: change['file'],
+            line: change['line'],
+            method: change['method'],
+            message: change['message']
+          }
+        end
+
         # Expand CLI path arguments into a sorted list of Ruby files.
         #
         # Directories are expanded recursively to `**/*.rb`.
@@ -190,6 +397,20 @@ module Docscribe
           run_exit_code(options, state)
         end
 
+        # @param [Docscribe::CLI::Formatters::opts] options
+        # @return [Hash<String, Object>]
+        def extract_cli_overrides(options)
+          overrides = options.slice(*CLI_OVERRIDE_KEYS)
+          acc = {} #: Hash[String, untyped]
+          overrides.each do |k, v|
+            next if v.nil? || v == false
+            next if v.is_a?(Array) && v.empty?
+
+            acc[k.to_s] = v
+          end
+          acc
+        end
+
         private
 
         # Print the check or write summary at the end of a run.
@@ -293,7 +514,7 @@ module Docscribe
         # @param [String] path file path to display
         # @param [Pathname] pwd current working directory
         # @raise [StandardError]
-        # @return [String] if StandardError
+        # @return [String]
         # @return [Object] if StandardError
         def display_path_for(path, pwd:)
           abs = Pathname.new(path).expand_path
@@ -315,7 +536,7 @@ module Docscribe
         # @param [Docscribe::CLI::Formatters::opts] options CLI options
         # @param [Docscribe::CLI::Formatters::state] state shared processing state
         # @raise [StandardError]
-        # @return [String, nil] if StandardError
+        # @return [String, nil]
         # @return [nil] if StandardError
         def read_source_for_path(path, display_path:, options:, state:)
           File.read(path)
@@ -334,7 +555,7 @@ module Docscribe
         # @param [String] src source code
         # @param [Hash<Symbol, Object>] ctx context hash with :conf, :display_path, :options, :state keys
         # @raise [StandardError]
-        # @return [Hash<Symbol, Object>, nil] if StandardError
+        # @return [Hash<Symbol, Object>, nil]
         # @return [nil] if StandardError
         def rewrite_result_for_path(path, src:, ctx:)
           conf = ctx[:conf]
@@ -456,7 +677,7 @@ module Docscribe
         # @param [Array<Docscribe::CLI::Formatters::change>] file_changes structured change records
         # @param [Object] ctx context hash with :display_path, :options, :state keys
         # @raise [StandardError]
-        # @return [void] if StandardError
+        # @return [void]
         # @return [Object] if StandardError
         def handle_write_result(path, src:, out:, file_changes:, **ctx)
           return log_check_verdict('OK', ctx[:display_path], ctx[:options]) if out == src

data/lib/docscribe/cli/server.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Docscribe
+  module CLI
+    # Handle the `docscribe server` subcommand.
+    module ServerCmd
+      BANNER = <<~TEXT
+        Usage: docscribe server <command> [options]
+
+        Commands:
+          start    Start the background daemon
+          stop     Stop the background daemon
+          status   Show daemon status
+
+        Options:
+          -C, --config <path>    Config file path (default: auto-detect)
+
+        Once the server is running, use `--server` with other commands:
+          docscribe --server check lib/
+          docscribe --server --autocorrect lib/
+      TEXT
+
+      class << self
+        # Run the server subcommand.
+        #
+        # @param [Array<String>] argv subcommand arguments
+        # @return [Integer] exit code
+        def run(argv)
+          config_path, cmd = parse_args(argv)
+          return warn(BANNER) || 1 unless cmd
+
+          case cmd
+          when 'start' then start_server(config_path)
+          when 'stop' then stop_server(config_path)
+          when 'status' then show_status(config_path)
+          else warn(usage) || 1
+          end
+        end
+
+        private
+
+        # @private
+        # @param [Array<String>] argv
+        # @return [(String?, String?)]
+        def parse_args(argv)
+          config_path = nil
+          rest = OptionParser.new do |opts|
+            opts.on('-C', '--config <path>', 'Config file path') { |v| config_path = v }
+          end.parse!(argv.dup)
+          [config_path, rest.first]
+        end
+
+        # Start the background daemon process.
+        #
+        # @private
+        # @param [String?] config_path optional config file path
+        # @return [Integer] exit code
+        def start_server(config_path = nil)
+          require 'docscribe/server'
+          return already_running(config_path) if Docscribe::Server.running?(config_path)
+
+          Docscribe::Server.ensure_running!(daemonize: true, config_path: config_path)
+          pid = Docscribe::Server.read_pid(config_path)
+          warn "Docscribe server started (pid #{pid})"
+          0
+        end
+
+        # @private
+        # @param [String?] config_path optional config file path
+        # @return [Integer]
+        def already_running(config_path = nil)
+          pid = Docscribe::Server.read_pid(config_path)
+          warn "Docscribe server already running (pid #{pid})"
+          0
+        end
+
+        # Stop the background daemon.
+        #
+        # @private
+        # @param [String?] config_path optional config file path
+        # @return [Integer] exit code
+        def stop_server(config_path = nil)
+          require 'docscribe/server'
+          alive = Docscribe::Server::Client.new(config_path: config_path).shutdown
+          warn(alive ? 'Docscribe server stopped' : 'Docscribe server is not running')
+          0
+        end
+
+        # Show the server status.
+        #
+        # @private
+        # @param [String?] config_path optional config file path
+        # @return [Integer] exit code
+        def show_status(config_path = nil)
+          require 'docscribe/server'
+          return warn('Docscribe server is not running') || 0 unless Docscribe::Server.running?(config_path)
+
+          info = Docscribe::Server::Client.new(config_path: config_path).ping
+          info ? show_status_from_ping(info) : show_status_fallback(config_path)
+          0
+        end
+
+        # @private
+        # @param [Hash<String, Object>] info ping response hash
+        # @return [void]
+        def show_status_from_ping(info)
+          pid = info.dig('result', 'pid')
+          version = info.dig('result', 'version')
+          uptime = info.dig('result', 'uptime')
+          sock = info.dig('result', 'socket_path')
+          warn "Docscribe server v#{version} is running (pid #{pid}, socket #{sock}, uptime #{uptime}s)"
+        end
+
+        # @private
+        # @param [String?] config_path
+        # @return [void]
+        def show_status_fallback(config_path)
+          pid = Docscribe::Server.read_pid(config_path)
+          sock = Docscribe::Server.socket_path(config_path)
+          warn "Docscribe server is running (pid #{pid}, socket #{sock})"
+        end
+
+        # Print usage information for the server subcommand.
+        #
+        # @private
+        # @return [String]
+        def usage
+          BANNER
+        end
+      end
+    end
+  end
+end

data/lib/docscribe/cli/sigs.rb

@@ -160,9 +160,9 @@ module Docscribe
         # @param [Array<Docscribe::CLI::Sigs::MethodDef>] methods
         # @raise [Parser::SyntaxError]
         # @raise [StandardError]
-        # @return [void] if StandardError
-        # @return [Object] if Parser::SyntaxError
-        # @return [Object] if StandardError
+        # @return [void]
+        # @return [nil] if Parser::SyntaxError
+        # @return [nil] if StandardError
         def extract_methods_from_file(path, methods)
           src = File.read(path)
           ast = Docscribe::Parsing.parse(src, file: path)
@@ -281,7 +281,7 @@ module Docscribe
         # @param [Hash<Symbol, Object>] options
         # @raise [LoadError]
         # @raise [StandardError]
-        # @return [Docscribe::Types::RBS::Provider?] if StandardError
+        # @return [Docscribe::Types::RBS::Provider?]
         # @return [nil] if LoadError
         # @return [nil] if StandardError
         def build_provider(options)
@@ -298,7 +298,7 @@ module Docscribe
 
         # @private
         # @raise [StandardError]
-        # @return [Array<String>] if StandardError
+        # @return [Array<String>]
         # @return [Array] if StandardError
         def load_collection_dirs
           dir = Docscribe::Types::RBS::CollectionLoader.resolve

data/lib/docscribe/cli.rb

@@ -1,27 +1,14 @@
 # frozen_string_literal: true
 
-require 'docscribe/cli/init'
-require 'docscribe/cli/generate'
 require 'docscribe/cli/options'
 require 'docscribe/cli/run'
-require 'docscribe/cli/sigs'
-require 'docscribe/cli/rbs_gen'
-require 'docscribe/cli/update_types'
-require 'docscribe/cli/check_for_comments'
 
 module Docscribe
   # CLI entry point and command dispatch.
   module CLI
     class << self
-      # Main CLI entry point.
-      #
-      # Dispatches:
-      # - `docscribe init ...`     to the config-template generator
-      # - `docscribe generate ...` to the plugin skeleton generator
-      # - all other commands to the main option parser and runner
-      #
-      # @param [Array<String>] argv raw command-line arguments
-      # @return [Integer] process exit code
+      # @param [Array<String>] argv
+      # @return [Integer]
       def run(argv)
         argv = argv.dup
         return dispatch_subcommand(argv) if subcommand?(argv.first)
@@ -30,33 +17,35 @@ module Docscribe
         Docscribe::CLI::Run.run(options: options, argv: argv)
       end
 
+      COMMANDS = {
+        'init' => :Init,
+        'generate' => :Generate,
+        'sigs' => :Sigs,
+        'rbs' => :RbsGen,
+        'update_types' => :UpdateTypes,
+        'check_for_comments' => :CheckForComments,
+        'server' => :ServerCmd
+      }.freeze
+
       private
 
-      # Subcommand
-      #
       # @private
-      # @param [String?] cmd potential subcommand name
+      # @param [String?] cmd
       # @return [Boolean]
       def subcommand?(cmd)
-        %w[init generate sigs rbs update_types check_for_comments].include?(cmd)
+        COMMANDS.key?(cmd)
       end
 
-      # Dispatch subcommand
-      #
       # @private
-      # @param [Array<String>] argv raw command-line arguments
+      # @param [Array<String>] argv
       # @return [Integer]
       def dispatch_subcommand(argv)
         cmd = argv.shift
-        case cmd
-        when 'init' then Docscribe::CLI::Init.run(argv)
-        when 'generate' then Docscribe::CLI::Generate.run(argv)
-        when 'sigs' then Docscribe::CLI::Sigs.run(argv)
-        when 'rbs' then Docscribe::CLI::RbsGen.run(argv)
-        when 'update_types' then Docscribe::CLI::UpdateTypes.run(argv)
-        when 'check_for_comments' then Docscribe::CLI::CheckForComments.run(argv)
-        else 0
-        end
+        const_name = COMMANDS[cmd]
+        return 0 unless const_name
+
+        require "docscribe/cli/#{cmd == 'rbs' ? 'rbs_gen' : cmd}"
+        Docscribe::CLI.const_get(const_name).run(argv)
       end
     end
   end

data/lib/docscribe/config/defaults.rb

@@ -70,7 +70,8 @@ module Docscribe
       'sorbet' => {
         'enabled' => false,
         'rbi_dirs' => ['sorbet/rbi', 'rbi'],
-        'collapse_generics' => false
+        'collapse_generics' => false,
+        'collapse_object_generics' => false
       },
       'keep_descriptions' => false,
       'skip_anonymous_block_params' => false,

data/lib/docscribe/config/filtering.rb

@@ -32,8 +32,8 @@ module Docscribe
     #
     # @param [String] path file path to test
     # @raise [StandardError]
+    # @return [String]
     # @return [String] if StandardError
-    # @return [Object] if StandardError
     def relative_path(path)
       Pathname.new(path).expand_path.relative_path_from(Pathname.pwd).cleanpath.to_s
     rescue StandardError

data/lib/docscribe/config/loader.rb

@@ -14,12 +14,10 @@ module Docscribe
     # @return [Docscribe::Config]
     def self.load(path = nil)
       raw = {} #: Hash[String, untyped]
-      if path && File.file?(path)
-        raw = safe_load_file_compat(path)
-      elsif File.file?('docscribe.yml')
-        raw = safe_load_file_compat('docscribe.yml')
-      end
-      new(raw)
+      resolved = path if path && File.file?(path)
+      resolved ||= 'docscribe.yml' if File.file?('docscribe.yml')
+      raw = safe_load_file_compat(resolved) if resolved
+      new(config_path: resolved, **raw) # steep:ignore
     end
 
     # Safely load YAML from a file across Ruby/Psych versions.
@@ -47,7 +45,7 @@ module Docscribe
     # @param [String] yaml YAML document
     # @param [String?] filename optional filename for diagnostics
     # @raise [ArgumentError]
-    # @return [Hash<String, Object>] if ArgumentError
+    # @return [Hash<String, Object>]
     # @return [Object] if ArgumentError
     def self.safe_load_compat(yaml, filename: nil)
       pclasses = [] #: Array[String]

data/lib/docscribe/config/rbs.rb

@@ -62,7 +62,7 @@ module Docscribe
     #
     # @private
     # @raise [LoadError]
-    # @return [Docscribe::Types::RBS::Provider, nil] if LoadError
+    # @return [Docscribe::Types::RBS::Provider, nil]
     # @return [nil] if LoadError
     def build_rbs_provider
       require 'docscribe/types/rbs/provider'
@@ -81,7 +81,7 @@ module Docscribe
     #
     # @private
     # @raise [LoadError]
-    # @return [Docscribe::Types::RBS::Provider, nil] if LoadError
+    # @return [Docscribe::Types::RBS::Provider, nil]
     # @return [nil] if LoadError
     def build_core_rbs_provider
       require 'docscribe/types/rbs/provider'

data/lib/docscribe/config/sorbet.rb

@@ -40,14 +40,15 @@ module Docscribe
     # @param [String] source Ruby source being rewritten
     # @param [String] file source name for diagnostics
     # @raise [LoadError]
-    # @return [Docscribe::Types::Sorbet::SourceProvider, nil] if LoadError
+    # @return [Docscribe::Types::Sorbet::SourceProvider, nil]
     # @return [nil] if LoadError
     def sorbet_source_provider(source, file)
       require 'docscribe/types/sorbet/source_provider'
       Docscribe::Types::Sorbet::SourceProvider.new(
         source: source,
         file: file,
-        collapse_generics: sorbet_collapse_generics?
+        collapse_generics: sorbet_collapse_generics?,
+        collapse_object_generics: sorbet_collapse_object_generics?
       )
     rescue LoadError
       nil
@@ -74,10 +75,9 @@ module Docscribe
 
       @sorbet_rbi_provider ||= begin
         require 'docscribe/types/sorbet/rbi_provider'
-        Docscribe::Types::Sorbet::RBIProvider.new(
-          rbi_dirs: sorbet_rbi_dirs,
-          collapse_generics: sorbet_collapse_generics?
-        )
+        Docscribe::Types::Sorbet::RBIProvider.new(rbi_dirs: sorbet_rbi_dirs,
+                                                  collapse_generics: sorbet_collapse_generics?,
+                                                  collapse_object_generics: sorbet_collapse_object_generics?)
       rescue LoadError
         nil
       end
@@ -106,5 +106,14 @@ module Docscribe
     def sorbet_collapse_generics?
       fetch_bool(%w[sorbet collapse_generics], rbs_collapse_generics?)
     end
+
+    # Whether to collapse Object-typed generics in Sorbet types.
+    #
+    # Falls back to the RBS setting when Sorbet-specific config is not present.
+    #
+    # @return [Boolean]
+    def sorbet_collapse_object_generics?
+      fetch_bool(%w[sorbet collapse_object_generics], rbs_collapse_object_generics?)
+    end
   end
 end