ruby-lsp 0.3.6 → 0.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59e3f670a003f565c001d00333a727d8cf4080eb274d4ebdf248bc0ad76b9c16
-  data.tar.gz: 5010473614d96f47ba10a267844448d6b5985b469cdfec752489be268ba95510
+  metadata.gz: 5f1ed447e51909ada66f6bebceca82d807686a4889468838a797e2ed8afff50e
+  data.tar.gz: 7b429773bbdebc171debbe446adb868136bd15b5f493542898df0a9c82f3514e
 SHA512:
-  metadata.gz: '0853a29d497f7befc9bcbbd0387c3e456293728788b0067b91026f4c61c5013240284adc913471b5c015184b19752ecac5e958ab021f301e41c24ce55ed876e2'
-  data.tar.gz: c2ee016b997013590cad9c575b1461d50f833d3fc06a7b22aa953aa73d6163feb5d821fe443c4ba20b0ac25cf686f32ed26c34348016408f6118f45261cce8a9
+  metadata.gz: 62e8a6ee36c43dec6ec0af16fd19830b6369446455a5fc16871c368c8bb4ccdb47c0d9c5678990a43604bf03c622c2ef13bb82c6a6e9f26fdcde72b3b18ec99e
+  data.tar.gz: e441a670c22bcdbfdc3afe99743fe6e1c4aa5f28edaedcf09f47255372322c52ead68988bc6d7ce09170e368e4059c94dac73b395a640c86f20b2969ae8e8095

data/README.md

@@ -2,7 +2,7 @@
 
 # Ruby LSP
 
-This gem is an implementation of the language server protocol specification for Ruby, used to improve editor features.
+This gem is an implementation of the [language server protocol specification](https://microsoft.github.io/language-server-protocol/) for Ruby, used to improve editor features.
 
 ## Usage
 
@@ -14,7 +14,7 @@ group :development do
 end
 ```
 
-If using VS Code, install the [Ruby LSP plugin](https://github.com/Shopify/vscode-ruby-lsp) to get the extra features in
+If using VS Code, install the [Ruby LSP extension](https://github.com/Shopify/vscode-ruby-lsp) to get the extra features in
 the editor.
 
 See the [documentation](https://shopify.github.io/ruby-lsp) for
@@ -28,10 +28,25 @@ are expected to adhere to the
 [Contributor Covenant](https://github.com/Shopify/ruby-lsp/blob/main/CODE_OF_CONDUCT.md)
 code of conduct.
 
+### Running the test suite
+
+Run the test suite with `bin/test`.
+
+For more visibility into which tests are running, use the `SpecReporter`:
+
+`SPEC_REPORTER=1 bin/test`
+
+By default the tests run with warnings disabled to reduce noise. To enable warnings, pass `VERBOSE=1`.
+Warnings are always shown when running in CI.
+
 ### Expectation testing
 
 To simplify the way we run tests over different pieces of Ruby code, we use a custom expectations test framework against a set of Ruby fixtures.
 
+We define expectations as `.exp` files, of which there are two variants:
+* `.exp.rb`, to indicate the resulting code after an operation.
+* `.exp.json`, consisting of a `result`, and an optional set of input `params`.
+
 To add a new fixture to the expectations test suite:
 
 1. Add a new fixture `my_fixture.rb` file under `test/fixtures`
@@ -78,6 +93,18 @@ Possible values are:
 * `messages`: display requests and responses notifications
 * `verbose`: display each request and response as JSON
 
+### Debugging using VS Code
+
+The `launch.json` contains a 'Minitest - current file' configuration for the debugger.
+
+1. Add a breakpoint using the VS Code UI.
+1. Open the relevant test file.
+1. Open the **Run and Debug** panel on the sidebar.
+1. Ensure `Minitest - current file` is selected in the top dropdown.
+1. Press `F5` OR click the green triangle next to the top dropdown. VS Code will then run the test file with debugger activated.
+1. When the breakpoint is triggered, the process will pause and VS Code will connect to the debugger and activate the debugger UI.
+1. Open the Debug Console view to use the debugger's REPL.
+
 ## License
 
 The gem is available as open source under the terms of the

data/VERSION

@@ -1 +1 @@
-0.3.6
+0.3.8

data/lib/ruby_lsp/document.rb

@@ -15,15 +15,11 @@ module RubyLsp
     sig { returns(String) }
     attr_reader :source
 
-    sig { returns(T::Array[EditShape]) }
-    attr_reader :syntax_error_edits
-
-    sig { params(source: String).void }
-    def initialize(source)
+    sig { params(source: String, encoding: String).void }
+    def initialize(source, encoding = "utf-8")
       @cache = T.let({}, T::Hash[Symbol, T.untyped])
-      @syntax_error_edits = T.let([], T::Array[EditShape])
+      @encoding = T.let(encoding, String)
       @source = T.let(source, String)
-      @parsable_source = T.let(source.dup, String)
       @unparsed_edits = T.let([], T::Array[EditShape])
       @tree = T.let(SyntaxTree.parse(@source), T.nilable(SyntaxTree::Node))
     rescue SyntaxTree::Parser::ParseError
@@ -53,8 +49,15 @@ module RubyLsp
 
     sig { params(edits: T::Array[EditShape]).void }
     def push_edits(edits)
-      # Apply the edits on the real source
-      edits.each { |edit| apply_edit(@source, edit[:range], edit[:text]) }
+      edits.each do |edit|
+        range = edit[:range]
+        scanner = create_scanner
+
+        start_position = scanner.find_char_position(range[:start])
+        end_position = scanner.find_char_position(range[:end])
+
+        @source[start_position...end_position] = edit[:text]
+      end
 
       @unparsed_edits.concat(edits)
       @cache.clear
@@ -65,17 +68,14 @@ module RubyLsp
       return if @unparsed_edits.empty?
 
       @tree = SyntaxTree.parse(@source)
-      @syntax_error_edits.clear
       @unparsed_edits.clear
-      @parsable_source = @source.dup
     rescue SyntaxTree::Parser::ParseError
-      @syntax_error_edits = @unparsed_edits
-      update_parsable_source(@unparsed_edits)
+      # Do nothing if we fail parse
     end
 
     sig { returns(T::Boolean) }
-    def syntax_errors?
-      @syntax_error_edits.any?
+    def syntax_error?
+      @unparsed_edits.any?
     end
 
     sig { returns(T::Boolean) }
@@ -83,52 +83,57 @@ module RubyLsp
       !@tree.nil?
     end
 
-    private
-
-    sig { params(edits: T::Array[EditShape]).void }
-    def update_parsable_source(edits)
-      # If the new edits caused a syntax error, make all edits blank spaces and line breaks to adjust the line and
-      # column numbers. This is attempt to make the document parsable while partial edits are being applied
-      edits.each do |edit|
-        next if edit[:text].empty? # skip deletions, since they may have caused the syntax error
-
-        apply_edit(@parsable_source, edit[:range], edit[:text].gsub(/[^\r\n]/, " "))
-      end
-
-      @tree = SyntaxTree.parse(@parsable_source)
-    rescue StandardError
-      # Trying to maintain a parsable source when there are syntax errors is a best effort. If we fail to apply edits or
-      # parse, just ignore it
-    end
-
-    sig { params(source: String, range: RangeShape, text: String).void }
-    def apply_edit(source, range, text)
-      scanner = Scanner.new(source)
-      start_position = scanner.find_position(range[:start])
-      end_position = scanner.find_position(range[:end])
-
-      source[start_position...end_position] = text
+    sig { returns(Scanner) }
+    def create_scanner
+      Scanner.new(@source, @encoding)
     end
 
     class Scanner
       extend T::Sig
 
-      sig { params(source: String).void }
-      def initialize(source)
+      LINE_BREAK = T.let(0x0A, Integer)
+      # After character 0xFFFF, UTF-16 considers characters to have length 2 and we have to account for that
+      SURROGATE_PAIR_START = T.let(0xFFFF, Integer)
+
+      sig { params(source: String, encoding: String).void }
+      def initialize(source, encoding)
         @current_line = T.let(0, Integer)
         @pos = T.let(0, Integer)
-        @source = source
+        @source = T.let(source.codepoints, T::Array[Integer])
+        @encoding = encoding
       end
 
+      # Finds the character index inside the source string for a given line and column
       sig { params(position: PositionShape).returns(Integer) }
-      def find_position(position)
+      def find_char_position(position)
+        # Find the character index for the beginning of the requested line
         until @current_line == position[:line]
-          @pos += 1 until /\R/.match?(@source[@pos])
+          @pos += 1 until LINE_BREAK == @source[@pos]
           @pos += 1
           @current_line += 1
         end
 
-        @pos + position[:character]
+        # The final position is the beginning of the line plus the requested column. If the encoding is UTF-16, we also
+        # need to adjust for surrogate pairs
+        requested_position = @pos + position[:character]
+        requested_position -= utf_16_character_position_correction(@pos, requested_position) if @encoding == "utf-16"
+        requested_position
+      end
+
+      # Subtract 1 for each character after 0xFFFF in the current line from the column position, so that we hit the
+      # right character in the UTF-8 representation
+      sig { params(current_position: Integer, requested_position: Integer).returns(Integer) }
+      def utf_16_character_position_correction(current_position, requested_position)
+        utf16_unicode_correction = 0
+
+        until current_position == requested_position
+          codepoint = @source[current_position]
+          utf16_unicode_correction += 1 if codepoint && codepoint > SURROGATE_PAIR_START
+
+          current_position += 1
+        end
+
+        utf16_unicode_correction
       end
     end
   end

data/lib/ruby_lsp/handler.rb

@@ -59,7 +59,7 @@ module RubyLsp
 
     sig { void }
     def start
-      $stderr.puts "Starting Ruby LSP..."
+      warn("Starting Ruby LSP...")
 
       @reader.read do |request|
         handler = @handlers[request[:method]]
@@ -94,7 +94,7 @@ module RubyLsp
 
     sig { void }
     def shutdown
-      $stderr.puts "Shutting down Ruby LSP..."
+      warn("Shutting down Ruby LSP...")
       @queue.shutdown
       store.clear
     end

data/lib/ruby_lsp/requests/base_request.rb

@@ -29,13 +29,17 @@ module RubyLsp
         loc = node.location
 
         LanguageServer::Protocol::Interface::Range.new(
-          start: LanguageServer::Protocol::Interface::Position.new(line: loc.start_line - 1,
-            character: loc.start_column),
+          start: LanguageServer::Protocol::Interface::Position.new(
+            line: loc.start_line - 1,
+            character: loc.start_column,
+          ),
           end: LanguageServer::Protocol::Interface::Position.new(line: loc.end_line - 1, character: loc.end_column),
         )
       end
 
-      sig { params(node: SyntaxTree::ConstPathRef).returns(String) }
+      sig do
+        params(node: T.any(SyntaxTree::ConstPathRef, SyntaxTree::ConstRef, SyntaxTree::TopConstRef)).returns(String)
+      end
       def full_constant_name(node)
         name = +node.constant.value
         constant = T.let(node, SyntaxTree::Node)
@@ -56,28 +60,48 @@ module RubyLsp
 
       sig do
         params(
-          parent: SyntaxTree::Node,
-          target_nodes: T::Array[T.class_of(SyntaxTree::Node)],
+          node: SyntaxTree::Node,
           position: Integer,
-        ).returns(T::Array[SyntaxTree::Node])
+        ).returns([T.nilable(SyntaxTree::Node), T.nilable(SyntaxTree::Node)])
       end
-      def locate_node_and_parent(parent, target_nodes, position)
-        matched = parent.child_nodes.compact.bsearch do |child|
-          if (child.location.start_char...child.location.end_char).cover?(position)
-            0
-          else
-            position <=> child.location.start_char
+      def locate(node, position)
+        queue = T.let(node.child_nodes.compact, T::Array[T.nilable(SyntaxTree::Node)])
+        closest = node
+
+        until queue.empty?
+          candidate = queue.shift
+
+          # Skip nil child nodes
+          next if candidate.nil?
+
+          # Add the next child_nodes to the queue to be processed
+          queue.concat(candidate.child_nodes)
+
+          # Skip if the current node doesn't cover the desired position
+          loc = candidate.location
+          next unless (loc.start_char...loc.end_char).cover?(position)
+
+          # If the node's start character is already past the position, then we should've found the closest node already
+          break if position < loc.start_char
+
+          # If the current node is narrower than or equal to the previous closest node, then it is more precise
+          closest_loc = closest.location
+          if loc.end_char - loc.start_char <= closest_loc.end_char - closest_loc.start_char
+            parent = T.let(closest, SyntaxTree::Node)
+            closest = candidate
           end
         end
 
-        case matched
-        when *target_nodes
-          [matched, parent]
-        when SyntaxTree::Node
-          locate_node_and_parent(matched, target_nodes, position)
-        else
-          []
-        end
+        [closest, parent]
+      end
+
+      sig { params(node: T.nilable(SyntaxTree::Node), range: T.nilable(T::Range[Integer])).returns(T::Boolean) }
+      def visible?(node, range)
+        return true if range.nil?
+        return false if node.nil?
+
+        loc = node.location
+        range.cover?(loc.start_line - 1) && range.cover?(loc.end_line - 1)
       end
     end
   end

data/lib/ruby_lsp/requests/code_actions.rb

@@ -6,7 +6,7 @@ module RubyLsp
     # ![Code actions demo](../../misc/code_actions.gif)
     #
     # The [code actions](https://microsoft.github.io/language-server-protocol/specification#textDocument_codeAction)
-    # request informs the editor of RuboCop quick fixes that can be applied. These are accesible by hovering over a
+    # request informs the editor of RuboCop quick fixes that can be applied. These are accessible by hovering over a
     # specific diagnostic.
     #
     # # Example
@@ -35,7 +35,7 @@ module RubyLsp
 
       sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::CodeAction], Object)) }
       def run
-        diagnostics = Diagnostics.new(@uri, @document).run
+        diagnostics = @document.cache_fetch(:diagnostics) { Diagnostics.new(@uri, @document).run }
         corrections = diagnostics.select do |diagnostic|
           diagnostic.correctable? && T.cast(diagnostic, Support::RuboCopDiagnostic).in_range?(@range)
         end

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -37,18 +37,11 @@ module RubyLsp
         )
       end
       def run
-        return syntax_error_diagnostics if @document.syntax_errors?
+        return [] if @document.syntax_error?
         return [] unless defined?(Support::RuboCopDiagnosticsRunner)
 
         Support::RuboCopDiagnosticsRunner.instance.run(@uri, @document)
       end
-
-      private
-
-      sig { returns(T::Array[Support::SyntaxErrorDiagnostic]) }
-      def syntax_error_diagnostics
-        @document.syntax_error_edits.map { |e| Support::SyntaxErrorDiagnostic.new(e) }
-      end
     end
   end
 end

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -7,7 +7,7 @@ module RubyLsp
     #
     # The [document highlight](https://microsoft.github.io/language-server-protocol/specification#textDocument_documentHighlight)
     # informs the editor all relevant elements of the currently pointed item for highlighting. For example, when
-    # the cursor is on the `F` of the constant `FOO`, the editor should identify other occurences of `FOO`
+    # the cursor is on the `F` of the constant `FOO`, the editor should identify other occurrences of `FOO`
     # and highlight them.
     #
     # For writable elements like constants or variables, their read/write occurrences should be highlighted differently.
@@ -30,10 +30,9 @@ module RubyLsp
         super(document)
 
         @highlights = T.let([], T::Array[LanguageServer::Protocol::Interface::DocumentHighlight])
-        position = Document::Scanner.new(document.source).find_position(position)
-
         return unless document.parsed?
 
+        position = document.create_scanner.find_char_position(position)
         @target = T.let(find(T.must(document.tree), position), T.nilable(Support::HighlightTarget))
       end
 
@@ -56,13 +55,16 @@ module RubyLsp
 
       private
 
-      DIRECT_HIGHLIGHTS = T.let([
-        SyntaxTree::GVar,
-        SyntaxTree::IVar,
-        SyntaxTree::Const,
-        SyntaxTree::CVar,
-        SyntaxTree::VarField,
-      ], T::Array[T.class_of(SyntaxTree::Node)])
+      DIRECT_HIGHLIGHTS = T.let(
+        [
+          SyntaxTree::GVar,
+          SyntaxTree::IVar,
+          SyntaxTree::Const,
+          SyntaxTree::CVar,
+          SyntaxTree::VarField,
+        ],
+        T::Array[T.class_of(SyntaxTree::Node)],
+      )
 
       sig do
         params(
@@ -71,9 +73,10 @@ module RubyLsp
         ).returns(T.nilable(Support::HighlightTarget))
       end
       def find(node, position)
-        matched, parent = locate_node_and_parent(node, DIRECT_HIGHLIGHTS + [SyntaxTree::Ident], position)
+        matched, parent = locate(node, position)
 
         return unless matched && parent
+        return unless matched.is_a?(SyntaxTree::Ident) || DIRECT_HIGHLIGHTS.include?(matched.class)
 
         case matched
         when *DIRECT_HIGHLIGHTS

data/lib/ruby_lsp/requests/document_link.rb

@@ -33,35 +33,39 @@ module RubyLsp
 
         sig { returns(T::Hash[String, T::Hash[String, T::Hash[String, String]]]) }
         def gem_paths
-          @gem_paths ||= T.let(begin
-            lookup = {}
-
-            Gem::Specification.stubs.each do |stub|
-              spec = stub.to_spec
-              lookup[spec.name] = {}
-              lookup[spec.name][spec.version.to_s] = {}
-
-              Dir.glob("**/*.rb", base: "#{spec.full_gem_path}/").each do |path|
-                lookup[spec.name][spec.version.to_s][path] = "#{spec.full_gem_path}/#{path}"
+          @gem_paths ||= T.let(
+            begin
+              lookup = {}
+
+              Gem::Specification.stubs.each do |stub|
+                spec = stub.to_spec
+                lookup[spec.name] = {}
+                lookup[spec.name][spec.version.to_s] = {}
+
+                Dir.glob("**/*.rb", base: "#{spec.full_gem_path}/").each do |path|
+                  lookup[spec.name][spec.version.to_s][path] = "#{spec.full_gem_path}/#{path}"
+                end
               end
-            end
-
-            Gem::Specification.default_stubs.each do |stub|
-              spec = stub.to_spec
-              lookup[spec.name] = {}
-              lookup[spec.name][spec.version.to_s] = {}
-              prefix_matchers = [//]
-              prefix_matchers.concat(spec.require_paths.map { |rp| Regexp.new("^#{rp}/") })
-              prefix_matcher = Regexp.union(prefix_matchers)
-
-              spec.files.each do |file|
-                path = file.sub(prefix_matcher, "")
-                lookup[spec.name][spec.version.to_s][path] = "#{RbConfig::CONFIG["rubylibdir"]}/#{path}"
+
+              Gem::Specification.default_stubs.each do |stub|
+                spec = stub.to_spec
+                lookup[spec.name] = {}
+                lookup[spec.name][spec.version.to_s] = {}
+                prefix_matchers = Regexp.union(spec.require_paths.map do |rp|
+                                                 Regexp.new("^#{rp}/")
+                                               end)
+                prefix_matcher = Regexp.union(prefix_matchers, //)
+
+                spec.files.each do |file|
+                  path = file.sub(prefix_matcher, "")
+                  lookup[spec.name][spec.version.to_s][path] = "#{RbConfig::CONFIG["rubylibdir"]}/#{path}"
+                end
               end
-            end
 
-            lookup
-          end, T.nilable(T::Hash[String, T::Hash[String, T::Hash[String, String]]]))
+              lookup
+            end,
+            T.nilable(T::Hash[String, T::Hash[String, T::Hash[String, String]]]),
+          )
         end
       end
 

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -10,7 +10,7 @@ module RubyLsp
     # informs the editor of all the important symbols, such as classes, variables, and methods, defined in a file. With
     # this information, the editor can populate breadcrumbs, file outline and allow for fuzzy symbol searches.
     #
-    # In VS Code, fuzzy symbol search can be accessed by opened the command palette and inserting an `@` symbol.
+    # In VS Code, fuzzy symbol search can be accessed by opening the command palette and inserting an `@` symbol.
     #
     # # Example
     #
@@ -29,34 +29,37 @@ module RubyLsp
     class DocumentSymbol < BaseRequest
       extend T::Sig
 
-      SYMBOL_KIND = T.let({
-        file: 1,
-        module: 2,
-        namespace: 3,
-        package: 4,
-        class: 5,
-        method: 6,
-        property: 7,
-        field: 8,
-        constructor: 9,
-        enum: 10,
-        interface: 11,
-        function: 12,
-        variable: 13,
-        constant: 14,
-        string: 15,
-        number: 16,
-        boolean: 17,
-        array: 18,
-        object: 19,
-        key: 20,
-        null: 21,
-        enummember: 22,
-        struct: 23,
-        event: 24,
-        operator: 25,
-        typeparameter: 26,
-      }.freeze, T::Hash[Symbol, Integer])
+      SYMBOL_KIND = T.let(
+        {
+          file: 1,
+          module: 2,
+          namespace: 3,
+          package: 4,
+          class: 5,
+          method: 6,
+          property: 7,
+          field: 8,
+          constructor: 9,
+          enum: 10,
+          interface: 11,
+          function: 12,
+          variable: 13,
+          constant: 14,
+          string: 15,
+          number: 16,
+          boolean: 17,
+          array: 18,
+          object: 19,
+          key: 20,
+          null: 21,
+          enummember: 22,
+          struct: 23,
+          event: 24,
+          operator: 25,
+          typeparameter: 26,
+        }.freeze,
+        T::Hash[Symbol, Integer],
+      )
 
       ATTR_ACCESSORS = T.let(["attr_reader", "attr_writer", "attr_accessor"].freeze, T::Array[String])
 
@@ -92,7 +95,7 @@ module RubyLsp
       sig { override.params(node: SyntaxTree::ClassDeclaration).void }
       def visit_class(node)
         symbol = create_document_symbol(
-          name: fully_qualified_name(node),
+          name: full_constant_name(node.constant),
           kind: :class,
           range_node: node,
           selection_range_node: node.constant,
@@ -129,43 +132,19 @@ module RubyLsp
         )
       end
 
-      sig { override.params(node: SyntaxTree::Def).void }
+      sig { override.params(node: SyntaxTree::DefNode).void }
       def visit_def(node)
-        name = node.name.value
-
-        symbol = create_document_symbol(
-          name: name,
-          kind: name == "initialize" ? :constructor : :method,
-          range_node: node,
-          selection_range_node: node.name,
-        )
-
-        @stack << symbol
-        visit(node.bodystmt)
-        @stack.pop
-      end
-
-      sig { override.params(node: SyntaxTree::DefEndless).void }
-      def visit_def_endless(node)
-        name = node.name.value
+        if node.target&.value&.value == "self"
+          name = "self.#{node.name.value}"
+          kind = :method
+        else
+          name = node.name.value
+          kind = name == "initialize" ? :constructor : :method
+        end
 
         symbol = create_document_symbol(
           name: name,
-          kind: name == "initialize" ? :constructor : :method,
-          range_node: node,
-          selection_range_node: node.name,
-        )
-
-        @stack << symbol
-        visit(node.statement)
-        @stack.pop
-      end
-
-      sig { override.params(node: SyntaxTree::Defs).void }
-      def visit_defs(node)
-        symbol = create_document_symbol(
-          name: "self.#{node.name.value}",
-          kind: :method,
+          kind: kind,
           range_node: node,
           selection_range_node: node.name,
         )
@@ -178,7 +157,7 @@ module RubyLsp
       sig { override.params(node: SyntaxTree::ModuleDeclaration).void }
       def visit_module(node)
         symbol = create_document_symbol(
-          name: fully_qualified_name(node),
+          name: full_constant_name(node.constant),
           kind: :module,
           range_node: node,
           selection_range_node: node.constant,
@@ -241,25 +220,6 @@ module RubyLsp
 
         symbol
       end
-
-      sig { params(node: T.any(SyntaxTree::ClassDeclaration, SyntaxTree::ModuleDeclaration)).returns(String) }
-      def fully_qualified_name(node)
-        constant = T.let(node.constant, SyntaxTree::Node)
-        name = +node.constant.constant.value
-
-        while constant.is_a?(SyntaxTree::ConstPathRef)
-          constant = constant.parent
-
-          case constant
-          when SyntaxTree::ConstPathRef
-            name.prepend("#{constant.constant.value}::")
-          when SyntaxTree::VarRef
-            name.prepend("#{constant.value.value}::")
-          end
-        end
-
-        name
-      end
     end
   end
 end