puppet-editor-services 2.0.4

data/lib/puppet-languageserver/puppet_parser_helper.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module PuppetLanguageServer
+  module PuppetParserHelper
+    def self.remove_chars_starting_at(content, line_offsets, line_num, char_num, num_chars_to_remove)
+      line_offset = line_offsets[line_num]
+      raise if line_offset.nil?
+
+      # Remove the offending character
+      content.slice(0, line_offset + char_num - num_chars_to_remove) + content.slice(line_offset + char_num, content.length - num_chars_to_remove)
+    end
+
+    def self.remove_char_at(content, line_offsets, line_num, char_num)
+      remove_chars_starting_at(content, line_offsets, line_num, char_num, 1)
+    end
+
+    def self.get_char_at(content, line_offsets, line_num, char_num)
+      line_offset = line_offsets[line_num]
+      raise if line_offset.nil?
+
+      absolute_offset = line_offset + (char_num - 1)
+
+      content[absolute_offset]
+    end
+
+    def self.insert_text_at(content, line_offsets, line_num, char_num, text)
+      # Insert text after where the cursor is
+      # This helps due to syntax errors like `$facts[]` or `ensure =>`
+      line_offset = line_offsets[line_num]
+      raise if line_offset.nil?
+
+      # Insert the text
+      content.slice(0, line_offset + char_num) + text + content.slice(line_offset + char_num, content.length - 1)
+    end
+
+    def self.line_offsets(content)
+      # Calculate all of the offsets of \n in the file
+      line_offsets = [0]
+      line_offset = -1
+      loop do
+        line_offset = content.index("\n", line_offset + 1)
+        break if line_offset.nil?
+
+        line_offsets << (line_offset + 1)
+      end
+      line_offsets
+    end
+
+    def self.get_line_at(content, line_offsets, line_num)
+      # Get the text of the designated line
+      start_index = line_offsets[line_num]
+      if line_offsets[line_num + 1].nil?
+        content.slice(start_index, content.length - start_index)
+      else
+        content.slice(start_index, line_offsets[line_num + 1] - start_index - 1)
+      end
+    end
+
+    def self.object_under_cursor(content, line_num, char_num, options)
+      options = {
+        multiple_attempts: false,
+        disallowed_classes: [],
+        tasks_mode: false,
+        remove_trigger_char: true
+      }.merge(options)
+
+      # Use Puppet to generate the AST
+      parser = Puppet::Pops::Parser::Parser.new
+
+      # Calculating the line offsets can be expensive and is only required
+      # if we're doing mulitple passes of parsing
+      line_offsets = line_offsets(content) if options[:multiple_attempts]
+
+      result = nil
+      move_offset = 0
+      %i[noop remove_word try_quotes try_quotes_and_comma remove_char].each do |method|
+        new_content = nil
+        case method
+        when :noop
+          new_content = content
+        when :remove_char
+          next if line_num.zero? && char_num.zero?
+
+          new_content = remove_char_at(content, line_offsets, line_num, char_num)
+          move_offset = -1
+        when :remove_word
+          next if line_num.zero? && char_num.zero?
+
+          next_char = get_char_at(content, line_offsets, line_num, char_num)
+
+          while /[[:word:]]/ =~ next_char
+            move_offset -= 1
+            next_char = get_char_at(content, line_offsets, line_num, char_num + move_offset)
+
+            break if char_num + move_offset < 0
+          end
+
+          new_content = remove_chars_starting_at(content, line_offsets, line_num, char_num, -move_offset)
+        when :try_quotes
+          # Perhaps try inserting double quotes.  Useful in empty arrays or during variable assignment
+          # Grab the line up to the cursor character + 1
+          line = get_line_at(content, line_offsets, line_num).slice!(0, char_num + 1)
+          if line.strip.end_with?('=') || line.end_with?('[]') # rubocop:disable Style/IfUnlessModifier  Nicer to read like this
+            new_content = insert_text_at(content, line_offsets, line_num, char_num, "''")
+          end
+        when :try_quotes_and_comma
+          # Perhaps try inserting double quotes with a comma.  Useful resource properties and parameter assignments
+          # Grab the line up to the cursor character + 1
+          line = get_line_at(content, line_offsets, line_num).slice!(0, char_num + 1)
+          if line.strip.end_with?('=>') # rubocop:disable Style/IfUnlessModifier  Nicer to read like this
+            new_content = insert_text_at(content, line_offsets, line_num, char_num, "'',")
+          end
+        else
+          raise("Unknown parsing method #{method}")
+        end
+        # if we have no content to parse, try the next method.
+        next if new_content.nil?
+
+        begin
+          result = parser.singleton_parse_string(new_content, options[:tasks_mode], '')
+          break
+        rescue Puppet::ParseErrorWithIssue
+          next if options[:multiple_attempts]
+
+          raise
+        end
+      end
+      raise('Unable to parse content') if result.nil?
+
+      # Convert line and char nums (base 0) to an absolute offset
+      #   result.line_offsets contains an array of the offsets on a per line basis e.g.
+      #     [0, 14, 34, 36]  means line number 2 starts at absolute offset 34
+      #   Once we know the line offset, we can simply add on the char_num to get the absolute offset
+      #   If during paring we modified the source we may need to change the cursor location
+      line_offset = if result.respond_to?(:line_offsets)
+                      result.line_offsets[line_num]
+                    else
+                      result['locator'].line_index[line_num]
+                    end
+      abs_offset = line_offset + char_num + move_offset
+      # Typically we're completing after something was typed, so go back one char by default
+      abs_offset -= 1 if options[:remove_trigger_char]
+
+      # Enumerate the AST looking for items that span the line/char we want.
+      # Once we have all valid items, sort them by the smallest span.  Typically the smallest span
+      # is the most specific object in the AST
+      #
+      # TODO: Should probably walk the AST and only look for the deepest child, but integer sorting
+      #       is so much easier and faster.
+      model_path_locator_struct = Struct.new(:model, :path, :locator)
+
+      valid_models = []
+      if result.model.respond_to? :eAllContents
+        valid_models = result.model.eAllContents.select do |item|
+          check_for_valid_item(item, abs_offset, options[:disallowed_classes])
+        end
+
+        valid_models.sort! { |a, b| a.length - b.length }
+      else
+        path = []
+        result.model._pcore_all_contents(path) do |item|
+          if check_for_valid_item(item, abs_offset, options[:disallowed_classes]) # rubocop:disable Style/IfUnlessModifier  Nicer to read like this
+            valid_models.push(model_path_locator_struct.new(item, path.dup))
+          end
+        end
+
+        valid_models.sort! { |a, b| a[:model].length - b[:model].length }
+      end
+      # nil means the root of the document
+      return nil if valid_models.empty?
+
+      response = valid_models[0]
+
+      if response.respond_to? :eAllContents # rubocop:disable Style/IfUnlessModifier  Nicer to read like this
+        response = model_path_locator_struct.new(response, construct_path(response))
+      end
+
+      response.locator = result.model.locator
+      response
+    end
+
+    def self.construct_path(item)
+      path = []
+      item = item.eContainer
+      while item.class != Puppet::Pops::Model::Program
+        path.unshift item
+        item = item.eContainer
+      end
+
+      path
+    end
+
+    def self.check_for_valid_item(item, abs_offset, disallowed_classes)
+      item.respond_to?(:offset) && !item.offset.nil? && !item.length.nil? && abs_offset >= item.offset && abs_offset <= item.offset + item.length && !disallowed_classes.include?(item.class)
+    end
+
+    # This method is only required during development or debugging.  Visualising the AST tree can be difficult
+    # so this method just prints it to the console.
+    # def self.recurse_showast(item, abs_offset, disallowed_classes, depth = 0)
+    #   output = "  " * depth
+    #   output += check_for_valid_item(item, abs_offset, disallowed_classes) ? 'X ' : '  '
+    #   output += "#{item.class.to_s} (#{item.object_id})"
+    #   if item.respond_to?(:offset)
+    #     output += " (Off-#{item.offset}:#{item.offset + item.length} Pos-#{item.line}:#{item.pos} Len-#{item.length}) ~#{item.locator.extract_text(item.offset, item.length)}~"
+    #   end
+    #   puts output
+    #   item._pcore_contents do |child|
+    #     recurse_showast(child, abs_offset, disallowed_classes, depth + 1)
+    #   end
+    # end
+  end
+end

data/lib/puppet-languageserver/puppetfile/validation_provider.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require 'lsp/lsp'
+
+module PuppetLanguageServer
+  module Puppetfile
+    module ValidationProvider
+      def self.max_line_length
+        # TODO: ... need to figure out the actual line length
+        1000
+      end
+
+      def self.validate(content, options = {})
+        options = {
+          max_problems: 100,
+          resolve_puppetfile: true,
+          module_path: [],
+          document_uri: '???'
+        }.merge(options)
+
+        result = []
+        # TODO: Need to implement max_problems
+        _problems = 0
+
+        require 'puppetfile-resolver'
+        require 'puppetfile-resolver/puppetfile/parser/r10k_eval'
+        parser = PuppetfileResolver::Puppetfile::Parser::R10KEval
+
+        # Attempt to parse the file
+        puppetfile = nil
+        begin
+          puppetfile = parser.parse(content)
+        rescue PuppetfileResolver::Puppetfile::Parser::ParserError => e
+          result << LSP::Diagnostic.new(
+            'severity' => LSP::DiagnosticSeverity::ERROR,
+            'range' => document_location_to_lsp_range(e.location),
+            'source' => 'Puppet',
+            'message' => e.to_s
+          )
+          puppetfile = nil
+        end
+        return result if puppetfile.nil?
+
+        puppetfile.validation_errors.each do |validation_error|
+          related_information = nil
+
+          if validation_error.is_a?(PuppetfileResolver::Puppetfile::DocumentDuplicateModuleError)
+            related_information = validation_error.duplicates.map do |dup_mod|
+              {
+                'location' => {
+                  'uri' => options[:document_uri],
+                  'range' => document_location_to_lsp_range(dup_mod.location)
+                },
+                'message' => validation_error.message
+              }
+            end
+          end
+
+          result << LSP::Diagnostic.new(
+            'severity' => LSP::DiagnosticSeverity::ERROR,
+            'range' => document_location_to_lsp_range(validation_error.puppet_module.location),
+            'source' => 'Puppet',
+            'message' => validation_error.message,
+            'relatedInformation' => related_information
+          )
+        end
+
+        return result unless options[:resolve_puppetfile] && puppetfile.valid?
+
+        result + validate_resolution(puppetfile, options[:document_uri], resolver_cache, options[:module_path], options[:puppet_version])
+      end
+
+      def self.validate_resolution(puppetfile_document, document_uri, cache, module_path, puppet_version)
+        ui = nil
+        resolver = PuppetfileResolver::Resolver.new(puppetfile_document, puppet_version)
+        opts = { cache: cache, ui: ui, module_paths: module_path, allow_missing_modules: true }
+        begin
+          resolution = resolver.resolve(opts)
+        rescue PuppetfileResolver::Puppetfile::DocumentVersionConflictError,
+               PuppetfileResolver::Puppetfile::DocumentCircularDependencyError => e
+          return [document_error_to_diagnostic(document_uri, e)]
+        rescue PuppetfileResolver::Puppetfile::DocumentResolveError => e
+          return [LSP::Diagnostic.new(
+            'severity' => LSP::DiagnosticSeverity::ERROR,
+            'range' => LSP.create_range(0, 0, 0, max_line_length),
+            'source' => 'Puppet',
+            'message' => e.message
+          )]
+        end
+
+        resolution.validation_errors.map do |error|
+          severity = case error
+                     when PuppetfileResolver::Puppetfile::DocumentLatestVersionError
+                       LSP::DiagnosticSeverity::INFORMATION
+                     when PuppetfileResolver::Puppetfile::DocumentMissingModuleError
+                       LSP::DiagnosticSeverity::HINT
+                     else
+                       LSP::DiagnosticSeverity::ERROR
+                     end
+          LSP::Diagnostic.new(
+            'severity' => severity,
+            'range' => document_location_to_lsp_range(error.puppet_module.location),
+            'source' => 'Puppet',
+            'message' => error.message
+          )
+        end
+      end
+
+      def self.find_dependencies(content)
+        require 'puppetfile-resolver'
+        require 'puppetfile-resolver/puppetfile/parser/r10k_eval'
+        parser = PuppetfileResolver::Puppetfile::Parser::R10KEval
+
+        result = []
+        puppetfile = parser.parse(content)
+
+        return result if puppetfile.nil?
+
+        raise 'Puppetfile is not valid' unless puppetfile.valid?
+
+        puppetfile.modules.select { |d| d.module_type == :forge }.each do |dep|
+          result << {
+            name: dep.name,
+            title: dep.title,
+            owner: dep.owner,
+            version: dep.version.to_s,
+            start_line: dep.location.start_line,
+            end_line: dep.location.end_line
+          }
+        end
+
+        result
+      end
+
+      def self.resolver_cache
+        return @resolver_cache unless @resolver_cache.nil?
+
+        require 'puppetfile-resolver/cache/base'
+        # TODO: The cache should probably not cache local module information though
+        # Share a cache between resolution calls to speed-up lookups
+        @resolver_cache = PuppetfileResolver::Cache::Base.new(nil)
+      end
+      private_class_method :resolver_cache
+
+      def self.document_error_to_diagnostic(document_uri, error)
+        if error.puppetfile_modules.count.zero?
+          return LSP::Diagnostic.new(
+            'severity' => LSP::DiagnosticSeverity::ERROR,
+            'range' => LSP.create_range(0, 0, 0, max_line_length),
+            'source' => 'Puppet',
+            'message' => error.message
+          )
+        end
+
+        related_information = error.puppetfile_modules.slice(1..-1).map do |dup_mod|
+          {
+            'location' => {
+              'uri' => document_uri,
+              'range' => document_location_to_lsp_range(dup_mod.location)
+            },
+            'message' => "Module definition for #{dup_mod.name}"
+          }
+        end
+
+        LSP::Diagnostic.new(
+          'severity' => LSP::DiagnosticSeverity::ERROR,
+          'range' => document_location_to_lsp_range(error.puppetfile_modules[0].location),
+          'source' => 'Puppet',
+          'message' => error.message,
+          'relatedInformation' => related_information.empty? ? nil : related_information
+        )
+      end
+      private_class_method :document_error_to_diagnostic
+
+      def self.document_location_to_lsp_range(location)
+        start_line = location.start_line
+        start_char = location.start_char.nil? ? 0 : location.start_char
+        end_line = location.end_line
+        end_char = location.end_char.nil? ? max_line_length : location.end_char
+        LSP.create_range(start_line, start_char, end_line, end_char)
+      end
+      private_class_method :document_location_to_lsp_range
+    end
+  end
+end

data/lib/puppet-languageserver/server_capabilities.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'lsp/lsp'
+
+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
+
+      value = {
+        'textDocumentSync' => LSP::TextDocumentSyncKind::FULL,
+        'hoverProvider' => true,
+        'completionProvider' => {
+          'resolveProvider' => true,
+          'triggerCharacters' => ['>', '$', '[', '=']
+        },
+        'definitionProvider' => true,
+        'documentSymbolProvider' => true,
+        'workspaceSymbolProvider' => true,
+        'signatureHelpProvider' => {
+          'triggerCharacters' => ['(', ',']
+        }
+      }
+      value['documentOnTypeFormattingProvider'] = document_on_type_formatting_options if options[:documentOnTypeFormattingProvider]
+      value['foldingRangeProvider'] = folding_range_provider_options if options[:foldingRangeProvider]
+      value
+    end
+
+    def self.document_on_type_formatting_options
+      {
+        'firstTriggerCharacter' => '>'
+      }
+    end
+
+    def self.folding_range_provider_options
+      true
+    end
+
+    def self.no_capabilities
+      # Any empty hash denotes no capabilities at all
+      {}
+    end
+  end
+end