(GH-306) Add Puppet Manifest Folding provider to Server

Now that there is a Puppet Manifest Folding provider available, the server
capabilities need to be updated so that clients know to use it. This commit:

* Creates a method on ServerCapabilities to determine if folding is supported
  by the server
* Updates the Service Capabilities to advertise the 'foldingRangeProvider'
  capavility if it is supported but not dynamic registrations
* Updates the Client Settings to send dynamic registrations
  'textDocument/foldingRange' if supported
* Adds a two new settings for Folding: Enabled and Show Last Line
* Refactors the Language Client settings to make it easier to set defaults
* Updated Server to respond to 'textDocument/foldingRange' requests

Adds many tests for the message handler and language client for the new provider

Author: glennsarti

lib/puppet-languageserver/message_handler.rb

@@ -29,9 +29,12 @@ def request_initialize(_, json_rpc_message)
       PuppetLanguageServer.log_message(:debug, 'Received initialize method')
 
       language_client.parse_lsp_initialize!(json_rpc_message.params)
+      static_folding_provider = !language_client.client_capability('textDocument', 'foldingRange', 'dynamicRegistration') &&
+                                PuppetLanguageServer::ServerCapabilites.folding_provider_supported?
       # Setup static registrations if dynamic registration is not available
       info = {
-        :documentOnTypeFormattingProvider => !language_client.client_capability('textDocument', 'onTypeFormatting', 'dynamicRegistration')
+        :documentOnTypeFormattingProvider => !language_client.client_capability('textDocument', 'onTypeFormatting', 'dynamicRegistration'),
+        :foldingRangeProvider             => static_folding_provider
       }
 
       # Configure the document store
@@ -162,6 +165,20 @@ def request_textdocument_completion(_, json_rpc_message)
       LSP::CompletionList.new('isIncomplete' => false, 'items' => [])
     end
 
+    def request_textdocument_foldingrange(_, json_rpc_message)
+      return nil unless language_client.folding_range
+      file_uri = json_rpc_message.params['textDocument']['uri']
+      case documents.document_type(file_uri)
+      when :manifest
+        PuppetLanguageServer::Manifest::FoldingProvider.instance.folding_ranges(documents.document_tokens(file_uri))
+      else
+        raise "Unable to provide folding ranages on #{file_uri}"
+      end
+    rescue StandardError => e
+      PuppetLanguageServer.log_message(:error, "(textDocument/foldingRange) #{e}")
+      nil
+    end
+
     def request_completionitem_resolve(_, json_rpc_message)
       PuppetLanguageServer::Manifest::CompletionProvider.resolve(session_state, LSP::CompletionItem.new(json_rpc_message.params))
     rescue StandardError => e
@@ -285,6 +302,7 @@ def notification_initialized(_, _json_rpc_message)
           "Unable to use Puppet version '#{server_options[:puppet_version]}' as it is not available. Using version '#{Puppet.version}' instead."
         )
       end
+
       # Register for workspace setting changes if it's supported
       if language_client.client_capability('workspace', 'didChangeConfiguration', 'dynamicRegistration') == true
         language_client.register_capability('workspace/didChangeConfiguration')

lib/puppet-languageserver/server_capabilities.rb

@@ -4,6 +4,10 @@
 
 module PuppetLanguageServer
   module ServerCapabilites
+    def self.folding_provider_supported?
+      @folding_provider ||= PuppetLanguageServer::Manifest::FoldingProvider.supported?
+    end
+
     def self.capabilities(options = {})
       # https://github.com/Microsoft/language-server-protocol/blob/master/protocol.md#initialize-request
 
@@ -22,6 +26,7 @@ def self.capabilities(options = {})
         }
       }
       value['documentOnTypeFormattingProvider'] = document_on_type_formatting_options if options[:documentOnTypeFormattingProvider]
+      value['foldingRangeProvider'] = folding_range_provider_options if options[:foldingRangeProvider]
       value
     end
 
@@ -31,6 +36,10 @@ def self.document_on_type_formatting_options
       }
     end
 
+    def self.folding_range_provider_options
+      true
+    end
+
     def self.no_capabilities
       # Any empty hash denotes no capabilities at all
       {

lib/puppet-languageserver/session_state/language_client.rb

@@ -8,8 +8,16 @@ class LanguageClient
       # Client settings
       attr_reader :format_on_type
       attr_reader :format_on_type_filesize_limit
+      attr_reader :folding_range
+      attr_reader :folding_range_show_last_line
       attr_reader :use_puppetfile_resolver
 
+      DEFAULT_FORMAT_ON_TYPE_ENABLE = false
+      DEFAULT_FORMAT_ON_TYPE_FILESIZE_LIMIT = 4096
+      DEFAULT_FOLDING_RANGE_ENABLE = true         # Default is true as per VS Code
+      DEFAULT_FOLDING_RANGE_SHOW_LAST_LINE = true # Default is true as per VS Code
+      DEFAULT_VALIDATE_RESOLVE_PUPPETFILES = true
+
       def initialize(message_handler)
         @message_handler = message_handler
         @client_capabilites = {}
@@ -24,10 +32,12 @@ def initialize(message_handler)
         # ]
         @registrations = {}
 
-        # Default settings
+        # Initial state. Not always the same as defaults
+        @folding_range = false
+        @folding_range_show_last_line = DEFAULT_FOLDING_RANGE_SHOW_LAST_LINE
         @format_on_type = false
-        @format_on_type_filesize_limit = 4096
-        @use_puppetfile_resolver = true
+        @format_on_type_filesize_limit = DEFAULT_FORMAT_ON_TYPE_FILESIZE_LIMIT
+        @use_puppetfile_resolver = DEFAULT_VALIDATE_RESOLVE_PUPPETFILES
       end
 
       def client_capability(*names)
@@ -47,9 +57,9 @@ def parse_lsp_initialize!(initialize_params = {})
       end
 
       def parse_lsp_configuration_settings!(settings = {})
-        # format on type
-        value = safe_hash_traverse(settings, 'puppet', 'editorService', 'formatOnType', 'enable')
-        unless value.nil? || to_boolean(value) == @format_on_type # rubocop:disable Style/GuardClause  Ummm no.
+        # format on type enabled
+        value = to_boolean(safe_hash_traverse(settings, 'puppet', 'editorService', 'formatOnType', 'enable'), DEFAULT_FORMAT_ON_TYPE_ENABLE)
+        unless value == @format_on_type # rubocop:disable Style/GuardClause  Ummm no.
           # Is dynamic registration available?
           if client_capability('textDocument', 'onTypeFormatting', 'dynamicRegistration') == true
             if value
@@ -61,11 +71,26 @@ def parse_lsp_configuration_settings!(settings = {})
           @format_on_type = value
         end
         # format on type file size
-        value = safe_hash_traverse(settings, 'puppet', 'editorService', 'formatOnType', 'maxFileSize')
-        @format_on_type_filesize_limit = to_integer(value, 4096, 0)
+        @format_on_type_filesize_limit = to_integer(safe_hash_traverse(settings, 'puppet', 'editorService', 'formatOnType', 'maxFileSize'), DEFAULT_FORMAT_ON_TYPE_FILESIZE_LIMIT, 0)
+
         # use puppetfile resolver
-        value = safe_hash_traverse(settings, 'puppet', 'validate', 'resolvePuppetfiles')
-        @use_puppetfile_resolver = to_boolean(value)
+        @use_puppetfile_resolver = to_boolean(safe_hash_traverse(settings, 'puppet', 'validate', 'resolvePuppetfiles'), DEFAULT_VALIDATE_RESOLVE_PUPPETFILES)
+
+        # folding range enabled
+        value = to_boolean(safe_hash_traverse(settings, 'puppet', 'editorService', 'foldingRange', 'enable'), DEFAULT_FOLDING_RANGE_ENABLE) && PuppetLanguageServer::ServerCapabilites.folding_provider_supported?
+        unless value == @folding_range # rubocop:disable Style/GuardClause  Ummm no.
+          # Is dynamic registration available?
+          if client_capability('textDocument', 'foldingRange', 'dynamicRegistration') == true
+            if value
+              register_capability('textDocument/foldingRange', PuppetLanguageServer::ServerCapabilites.document_on_type_formatting_options)
+            else
+              unregister_capability('textDocument/foldingRange')
+            end
+          end
+          @folding_range = value
+        end
+        # folding range last line display
+        @folding_range_show_last_line = to_boolean(safe_hash_traverse(settings, 'puppet', 'editorService', 'foldingRange', 'showLastLine'), DEFAULT_FOLDING_RANGE_SHOW_LAST_LINE)
       end
 
       def capability_registrations(method)
@@ -173,9 +198,9 @@ def parse_unregister_capability_response!(response, original_request)
 
       private
 
-      def to_boolean(value)
-        return false if value.nil? || value == false
-        return true if value == true
+      def to_boolean(value, default = false)
+        return default if value.nil?
+        return value if value == true || value == false # rubocop:disable Style/MultipleComparison
         value.to_s =~ %r{^(true|t|yes|y|1)$/i}
       end
 

spec/languageserver/unit/puppet-languageserver/message_handler_spec.rb

@@ -54,10 +54,77 @@
 
     # initialize - https://github.com/Microsoft/language-server-protocol/blob/master/protocol.md#initialize
     describe '.request_initialize' do
-      #context 'given an initialize request' do
       let(:request_rpc_method) { 'initialize' }
       let(:request_params) { { 'capabilities' => { 'cap1' => 'value1' } } }
 
+      RSpec.shared_examples 'dynamically registered provider' do |short_client_cap, client_cap, server_cap_name|
+        def client_cap_hash(client_cap_string, dynamic_reg)
+          client_cap_string.split('/').reverse.reduce(dynamic_reg) { |memo, obj| { obj => memo } }
+        end
+
+        context "when #{short_client_cap} does support dynamic registration" do
+          let(:request_params) do
+            { 'capabilities' => client_cap_hash(client_cap, true) }
+          end
+
+          it "should not statically register a #{server_cap_name}" do
+            expect(subject.request_initialize(connection_id, request_message)).to_not server_capability(server_cap_name)
+          end
+        end
+
+        context "when #{short_client_cap} does not support dynamic registration" do
+          let(:request_params) do
+            { 'capabilities' => client_cap_hash(client_cap, false) }
+          end
+
+          it "should statically register a #{server_cap_name}" do
+            expect(subject.request_initialize(connection_id, request_message)).to server_capability(server_cap_name)
+          end
+        end
+
+        context "when #{short_client_cap} does not specify dynamic registration" do
+          let(:request_params) { {} }
+
+          it "should statically register a #{server_cap_name}" do
+            expect(subject.request_initialize(connection_id, request_message)).to server_capability(server_cap_name)
+          end
+        end
+      end
+
+      RSpec.shared_examples 'never registered provider' do |short_client_cap, client_cap, server_cap_name|
+        def client_cap_hash(client_cap_string, dynamic_reg)
+          client_cap_string.split('/').reverse.reduce(dynamic_reg) { |memo, obj| { obj => memo } }
+        end
+
+        context "when #{short_client_cap} does support dynamic registration" do
+          let(:request_params) do
+            { 'capabilities' => client_cap_hash(client_cap, true) }
+          end
+
+          it "should not statically register a #{server_cap_name}" do
+            expect(subject.request_initialize(connection_id, request_message)).to_not server_capability(server_cap_name)
+          end
+        end
+
+        context "when #{short_client_cap} does not support dynamic registration" do
+          let(:request_params) do
+            { 'capabilities' => client_cap_hash(client_cap, false) }
+          end
+
+          it "should not statically register a #{server_cap_name}" do
+            expect(subject.request_initialize(connection_id, request_message)).to_not server_capability(server_cap_name)
+          end
+        end
+
+        context "when #{short_client_cap} does not specify dynamic registration" do
+          let(:request_params) { {} }
+
+          it "should not statically register a #{server_cap_name}" do
+            expect(subject.request_initialize(connection_id, request_message)).to_not server_capability(server_cap_name)
+          end
+        end
+      end
+
       it 'should reply with capabilites' do
         expect(subject.request_initialize(connection_id, request_message)['capabilities']).to_not be_nil
       end
@@ -67,46 +134,22 @@
         subject.request_initialize(connection_id, request_message)
       end
 
-      context 'when onTypeFormatting does support dynamic registration' do
-        let(:request_params) do
-          { 'capabilities' => {
-              'textDocument' => {
-                'onTypeFormatting' => {
-                  'dynamicRegistration' => true
-                }
-              }
-            }
-          }
-        end
-
-        it 'should not statically register a documentOnTypeFormattingProvider' do
-          expect(subject.request_initialize(connection_id, request_message)).to_not server_capability('documentOnTypeFormattingProvider')
-        end
-      end
+      include_examples 'dynamically registered provider', 'onTypeFormatting', 'textDocument/onTypeFormatting/dynamicRegistration', 'documentOnTypeFormattingProvider'
 
-      context 'when onTypeFormatting does not support dynamic registration' do
-        let(:request_params) do
-          { 'capabilities' => {
-              'textDocument' => {
-                'onTypeFormatting' => {
-                  'dynamicRegistration' => false
-                }
-              }
-            }
-          }
+      context 'When folding is supported' do
+        before(:each) do
+          allow(PuppetLanguageServer::ServerCapabilites).to receive(:folding_provider_supported?).and_return(true)
         end
 
-        it 'should statically register a documentOnTypeFormattingProvider' do
-          expect(subject.request_initialize(connection_id, request_message)).to server_capability('documentOnTypeFormattingProvider')
-        end
+        include_examples 'dynamically registered provider', 'foldingRange', 'textDocument/foldingRange/dynamicRegistration', 'foldingRangeProvider'
       end
 
-      context 'when onTypeFormatting does not specify dynamic registration' do
-        let(:request_params) { {} }
-
-        it 'should statically register a documentOnTypeFormattingProvider' do
-          expect(subject.request_initialize(connection_id, request_message)).to server_capability('documentOnTypeFormattingProvider')
+      context 'When folding is not supported' do
+        before(:each) do
+          allow(PuppetLanguageServer::ServerCapabilites).to receive(:folding_provider_supported?).and_return(false)
         end
+
+        include_examples 'never registered provider', 'foldingRange', 'textDocument/foldingRange/dynamicRegistration', 'foldingRangeProvider'
       end
     end