puppet-editor-services 2.0.4

data/lib/puppet-languageserver/manifest/folding_provider.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require 'puppet-languageserver/puppet_lexer_helper'
+require 'lsp/lsp'
+
+module PuppetLanguageServer
+  module Manifest
+    class FoldingProvider
+      class << self
+        def instance
+          @instance ||= new
+        end
+
+        def supported?
+          # Folding is only supported on Puppet 6.3.0 and above
+          # Requires - https://github.com/puppetlabs/puppet/commit/6d375ab4d735779031d49ab8631bd9d161a9c3e3
+          @supported ||= Gem::Version.new(Puppet.version) >= Gem::Version.new('6.3.0')
+        end
+      end
+
+      REGION_NONE = nil
+      REGION_COMMENT = 'comment'
+      REGION_REGION = 'region'
+
+      def start_region?(text)
+        !(text =~ /^#\s*region\b/).nil?
+      end
+
+      def end_region?(text)
+        !(text =~ /^#\s*endregion\b/).nil?
+      end
+
+      def folding_ranges(tokens, show_last_line = false)
+        return nil unless self.class.supported?
+
+        ranges = {}
+
+        brace_stack = []
+        brack_stack = []
+        comment_stack = []
+
+        index = 0
+        until index > tokens.length - 1
+          case tokens[index][0]
+          # Find comments
+          when :TOKEN_COMMENT
+            if block_comment?(index, tokens)
+              comment = tokens[index][1].locator.extract_text(tokens[index][1].offset, tokens[index][1].length)
+              if start_region?(comment) # rubocop:disable Metrics/BlockNesting
+                comment_stack.push(tokens[index][1])
+              elsif end_region?(comment) && !comment_stack.empty? # rubocop:disable Metrics/BlockNesting
+                add_range!(create_range_span_tokens(comment_stack.pop, tokens[index][1], REGION_REGION), ranges)
+              else
+                index = process_block_comment!(index, tokens, ranges)
+              end
+            end
+
+          # Find old style comments /* -> */
+          when :TOKEN_MLCOMMENT
+            add_range!(create_range_whole_token(tokens[index][1], REGION_COMMENT), ranges)
+
+          # Find matching braces { -> } and select brace ?{ -> }
+          when :LBRACE, :SELBRACE
+            brace_stack.push(tokens[index][1])
+          when :RBRACE
+            add_range!(create_range_span_tokens(brace_stack.pop, tokens[index][1], REGION_NONE), ranges) unless brace_stack.empty?
+
+          # Find matching braces [ -> ], list and index
+          when :LISTSTART, :LBRACK
+            brack_stack.push(tokens[index][1])
+          when :RBRACK
+            add_range!(create_range_span_tokens(brack_stack.pop, tokens[index][1], REGION_NONE), ranges) unless brack_stack.empty?
+
+          # Find matching Heredoc and heredoc sublocations
+          when :HEREDOC
+            # Need to check if the next token is :SUBLOCATE
+            if index < tokens.length - 2 && tokens[index + 1][0] == :SUBLOCATE # rubocop:disable Style/IfUnlessModifier
+              add_range!(create_range_heredoc(tokens[index][1], tokens[index + 1][1], REGION_NONE), ranges)
+            end
+          end
+
+          index += 1
+        end
+
+        # If we are showing the last line then decrement the EndLine by one, if possible
+        if show_last_line
+          ranges.values.each do |range|
+            range.endLine = [range.startLine, range.endLine - 1].max
+            range.endCharacter = 0 # We don't know where the previous line actually ends so set it to zero
+          end
+        end
+
+        ranges.values
+      end
+
+      private
+
+      # region Internal Helper methods to call locator methods on Locators or SubLocators
+      def line_for_offset(token, offset = nil)
+        locator_method_with_offset(token, :line_for_offset, offset || token.offset)
+      end
+
+      def pos_on_line(token, offset = nil)
+        locator_method_with_offset(token, :pos_on_line, offset || token.offset)
+      end
+
+      def locator_method_with_offset(token, method_name, offset)
+        if token.locator.is_a?(Puppet::Pops::Parser::Locator::SubLocator)
+          global_offset, = token.locator.to_global(offset, token.length)
+          token.locator.locator.send(method_name, global_offset)
+        else
+          token.locator.send(method_name, offset)
+        end
+      end
+
+      def extract_text(token)
+        if token.locator.is_a?(Puppet::Pops::Parser::Locator::SubLocator)
+          global_offset, global_length = token.locator.to_global(token.offset, token.length)
+          token.locator.locator.extract_text(global_offset, global_length)
+        else
+          token.locator.extract_text(token.offset, token.length)
+        end
+      end
+      # endregion
+
+      # Return nil if not valid range
+      def create_range_span_tokens(start_token, end_token, kind)
+        start_line = line_for_offset(start_token) - 1
+        end_line = line_for_offset(end_token) - 1
+        return nil if start_line == end_line
+
+        LSP::FoldingRange.new({
+                                'startLine' => start_line,
+                                'startCharacter' => pos_on_line(start_token) - 1,
+                                'endLine' => end_line,
+                                'endCharacter' => pos_on_line(end_token, end_token.offset + end_token.length) - 1,
+                                'kind' => kind
+                              })
+      end
+
+      # Return nil if not valid range
+      def create_range_whole_token(token, kind)
+        start_line = line_for_offset(token) - 1
+        end_line = line_for_offset(token, token.offset + token.length) - 1
+        return nil if start_line == end_line
+
+        LSP::FoldingRange.new({
+                                'startLine' => start_line,
+                                'startCharacter' => pos_on_line(token) - 1,
+                                'endLine' => end_line,
+                                'endCharacter' => pos_on_line(token, token.offset + token.length) - 1,
+                                'kind' => kind
+                              })
+      end
+
+      # Return nil if not valid range
+      def create_range_heredoc(heredoc_token, subloc_token, kind)
+        start_line = line_for_offset(heredoc_token) - 1
+        # The lexer does not output the end heredoc_token. Instead we
+        # use the heredoc sublocator endline and add one
+        end_line = line_for_offset(heredoc_token, heredoc_token.offset + heredoc_token.length + subloc_token.length)
+        return nil if start_line == end_line
+
+        LSP::FoldingRange.new({
+                                'startLine' => start_line,
+                                'startCharacter' => pos_on_line(heredoc_token) - 1,
+                                'endLine' => end_line,
+                                # We don't know where the end token for the Heredoc is, so just assume it's at the start of the line
+                                'endCharacter' => 0,
+                                'kind' => kind
+                              })
+      end
+
+      # Adds a FoldingReference to the list and enforces ordering rules e.g. Only one fold per start line
+      def add_range!(range, ranges)
+        # Make sure the arguments are correct
+        return nil if range.nil? || ranges.nil?
+
+        # Ignore the range if there is an existing one which is bigger
+        return nil unless ranges[range.startLine].nil? || ranges[range.startLine].endLine < range.endLine
+
+        ranges[range.startLine] = range
+        nil
+      end
+
+      # Returns new index position
+      def process_block_comment!(index, tokens, ranges)
+        start_index = index
+        line_num = line_for_offset(tokens[index][1])
+        while index < tokens.length - 2
+          break unless tokens[index + 1][0] == :TOKEN_COMMENT
+
+          next_line = line_for_offset(tokens[index + 1][1])
+          # Tokens must be on contiguous lines
+          break unless next_line == line_num + 1
+
+          # Must not be a region comment
+          comment = extract_text(tokens[index + 1][1])
+          break if start_region?(comment) || end_region?(comment)
+
+          # It's a block comment
+          line_num = next_line
+          index += 1
+        end
+
+        return index if start_index == index
+
+        add_range!(create_range_span_tokens(tokens[start_index][1], tokens[index][1], REGION_COMMENT), ranges)
+        index
+      end
+
+      def block_comment?(index, tokens)
+        # Has to be a comment token
+        return false unless tokens[index][0] == :TOKEN_COMMENT
+        # If it's the first token then it has to be at the start of a line
+        return true if index.zero?
+
+        # It has to be the first token on this line
+        this_token_line = line_for_offset(tokens[index][1])
+        prev_token_line = line_for_offset(tokens[index - 1][1])
+
+        this_token_line != prev_token_line
+      end
+    end
+  end
+end

data/lib/puppet-languageserver/manifest/format_on_type_provider.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'puppet-lint'
+
+module PuppetLanguageServer
+  module Manifest
+    class FormatOnTypeProvider
+      class << self
+        def instance
+          @instance ||= new
+        end
+      end
+
+      def format(content, line, char, trigger_character, formatting_options, max_filesize = 4096)
+        result = []
+        # Abort if the user has pressed something other than `>`
+        return result unless trigger_character == '>'
+        # Abort if the formatting is tab based. Can't do that yet
+        return result unless formatting_options['insertSpaces'] == true
+        # Abort if content is too big
+        return result if !max_filesize.zero? && (content.length > max_filesize)
+
+        lexer = PuppetLint::Lexer.new
+        tokens = lexer.tokenise(content)
+
+        # Find where in the manifest the cursor is
+        cursor_token = find_token_by_location(tokens, line, char)
+        return result if cursor_token.nil?
+        # The cursor should be at the end of a hashrocket, otherwise exit
+        return result unless cursor_token.type == :FARROW
+
+        # Find the start of the hash (or semicolon for multi-resource definitions) with respect to the cursor
+        start_brace = cursor_token.prev_token_of(%i[LBRACE SEMIC], skip_blocks: true)
+        # Find the end of the hash (or semicolon for multi-resource definitions) with respect to the cursor
+        end_brace = cursor_token.next_token_of(%i[RBRACE SEMIC], skip_blocks: true)
+
+        # The line count between the start and end brace needs to be at least 2 lines. Otherwise there's nothing to align to
+        return result if end_brace.nil? || start_brace.nil? || end_brace.line - start_brace.line <= 2
+
+        # Find all hashrockets '=>' between the hash braces, ignoring nested hashes
+        farrows = []
+        farrow_token = start_brace
+        lines = []
+        loop do
+          farrow_token = farrow_token.next_token_of(:FARROW, skip_blocks: true)
+          # if there are no more hashrockets, or we've gone past the end_brace, we can exit the loop
+          break if farrow_token.nil? || farrow_token.line > end_brace.line
+          # if there's a hashrocket AFTER the closing brace (why?) then we can also exit the loop
+          break if farrow_token.line == end_brace.line && farrow_token.character > end_brace.character
+          # Check for multiple hashrockets on the same line. If we find some, then we can't do any automated indentation
+          return result if lines.include?(farrow_token.line)
+
+          lines << farrow_token.line
+          farrows << { token: farrow_token }
+        end
+
+        # Now we have a list of farrows, time for figure out the indentation marks
+        farrows.each do |item|
+          item.merge!(calculate_indentation_info(item[:token]))
+        end
+
+        # Now we have the list of indentations we can find the biggest
+        max_indent = -1
+        farrows.each do |info|
+          max_indent = info[:indent] if info[:indent] > max_indent
+        end
+        # No valid indentations found
+        return result if max_indent == -1
+
+        # Now we have the indent size, generate all of the required TextEdits
+        farrows.each do |info|
+          # Ignore invalid hashrockets
+          next if info[:indent] == -1
+
+          end_name_token = info[:name_token].column + info[:name_token].to_manifest.length
+          begin_farrow_token = info[:token].column
+          new_whitespace = max_indent - end_name_token
+          # If the whitespace is already what we want, then ignore it.
+          next if begin_farrow_token - end_name_token == new_whitespace
+
+          # Create the TextEdit
+          result << LSP::TextEdit.new.from_h!(
+            'newText' => ' ' * new_whitespace,
+            'range' => LSP.create_range(info[:token].line - 1, end_name_token - 1, info[:token].line - 1, begin_farrow_token - 1)
+          )
+        end
+        result
+      end
+
+      private
+
+      VALID_TOKEN_TYPES = %i[NAME STRING SSTRING].freeze
+
+      def find_token_by_location(tokens, line, character)
+        return nil if tokens.empty?
+
+        # Puppet Lint uses base 1, but LSP is base 0, so adjust accordingly
+        cursor_line = line + 1
+        cursor_column = character + 1
+        idx = -1
+        while idx < tokens.count
+          idx += 1
+          # if the token is on previous lines keep looking...
+          next if tokens[idx].line < cursor_line
+          # return nil if we skipped over the line we need
+          return nil if tokens[idx].line > cursor_line
+          # return nil if we skipped over the character position we need
+          return nil if tokens[idx].column > cursor_column
+          # return the token if it starts on the cursor column we are interested in
+          return tokens[idx] if tokens[idx].column == cursor_column
+
+          end_column = tokens[idx].column + tokens[idx].to_manifest.length
+          # return the token it the cursor column is within the token string
+          return tokens[idx] if cursor_column <= end_column
+          # otherwise, keep on searching
+        end
+        nil
+      end
+
+      def calculate_indentation_info(farrow_token)
+        result = { indent: -1 }
+        # This is not a valid hashrocket if there's no previous tokens
+        return result if farrow_token.prev_token.nil?
+
+        if VALID_TOKEN_TYPES.include?(farrow_token.prev_token.type)
+          # Someone forgot the whitespace! e.g. ensure=>
+          result[:indent] = farrow_token.column + 1
+          result[:name_token] = farrow_token.prev_token
+          return result
+        end
+        if farrow_token.prev_token.type == :WHITESPACE
+          # If the whitespace has no previous token (which shouldn't happen) or the thing before the whitespace is not a property name this it not a valid hashrocket
+          return result if farrow_token.prev_token.prev_token.nil?
+          return result unless VALID_TOKEN_TYPES.include?(farrow_token.prev_token.prev_token.type)
+
+          result[:name_token] = farrow_token.prev_token.prev_token
+          result[:indent] = farrow_token.prev_token.column + 1 # The indent is the whitespace column + 1
+        end
+        result
+      end
+    end
+  end
+end

data/lib/puppet-languageserver/manifest/hover_provider.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module PuppetLanguageServer
+  module Manifest
+    module HoverProvider
+      def self.resolve(session_state, content, line_num, char_num, options = {})
+        options = {
+          tasks_mode: false
+        }.merge(options)
+        result = PuppetLanguageServer::PuppetParserHelper.object_under_cursor(content, line_num, char_num,
+                                                                              disallowed_classes: [Puppet::Pops::Model::BlockExpression],
+                                                                              tasks_mode: options[:tasks_mode])
+        return nil if result.nil?
+
+        path = result[:path]
+        item = result[:model]
+
+        # Munge the item
+        # We're not really interested in the Name of thing yet, we want the "thing" it's a name of
+        item = path.pop if item.instance_of?(Puppet::Pops::Model::QualifiedName) && !path.empty?
+
+        content = nil
+        case item.class.to_s
+        when 'Puppet::Pops::Model::ResourceExpression'
+          content = get_resource_expression_content(session_state, item)
+        when 'Puppet::Pops::Model::LiteralString'
+          if path[-1].instance_of?(Puppet::Pops::Model::AccessExpression)
+            expr = path[-1].left_expr.expr.value
+
+            content = get_hover_content_for_access_expression(session_state, path, expr)
+          elsif path[-1].instance_of?(Puppet::Pops::Model::ResourceBody)
+            # We are hovering over the resource name
+            content = get_resource_expression_content(session_state, path[-2])
+          end
+        when 'Puppet::Pops::Model::VariableExpression'
+          expr = item.expr.value
+
+          content = get_hover_content_for_access_expression(session_state, path, expr)
+        when 'Puppet::Pops::Model::CallNamedFunctionExpression'
+          content = get_call_named_function_expression_content(session_state, item, options[:tasks_mode])
+        when 'Puppet::Pops::Model::AttributeOperation'
+          # Get the parent resource class
+          distance_up_ast = -1
+          parent_klass = path[distance_up_ast]
+          while !parent_klass.nil? && parent_klass.class.to_s != 'Puppet::Pops::Model::ResourceBody'
+            distance_up_ast -= 1
+            parent_klass = path[distance_up_ast]
+          end
+          raise "Unable to find suitable parent object for object of type #{item.class}" if parent_klass.nil?
+
+          resource_type_name = path[distance_up_ast - 1].type_name.value
+          # Check if it's a Puppet Type
+          resource_object = PuppetLanguageServer::PuppetHelper.get_type(session_state, resource_type_name)
+          unless resource_object.nil?
+            # Check if it's a property
+            attribute = resource_object.attributes[item.attribute_name.intern]
+            case attribute[:type]
+            when :property
+              content = get_attribute_type_property_content(resource_object, item.attribute_name.intern)
+            when :param
+              content = get_attribute_type_parameter_content(resource_object, item.attribute_name.intern)
+            end
+          end
+          # Check if it's a Puppet Class / Defined Type
+          if resource_object.nil?
+            resource_object = PuppetLanguageServer::PuppetHelper.get_class(session_state, resource_type_name)
+            content = get_attribute_class_parameter_content(resource_object, item.attribute_name) unless resource_object.nil?
+          end
+          raise "#{resource_type_name} is not a valid puppet type, class or defined type" if resource_object.nil?
+        when 'Puppet::Pops::Model::QualifiedReference'
+          # https://github.com/puppetlabs/puppet-specifications/blob/master/language/names.md#names
+          # Datatypes have to start with uppercase and can be fully qualified
+          if /^[A-Z][a-zA-Z:0-9]*$/.match?(item.cased_value) # rubocop:disable Style/GuardClause
+            content = get_puppet_datatype_content(session_state, item, options[:tasks_mode])
+          else
+            raise "#{item.cased_value} is an unknown QualifiedReference"
+          end
+        else
+          raise "Unable to generate Hover information for object of type #{item.class}"
+        end
+
+        return nil if content.nil?
+
+        LSP::Hover.new('contents' => content)
+      end
+
+      def self.get_hover_content_for_access_expression(session_state, path, expr)
+        if expr == 'facts'
+          # We are dealing with the facts variable
+          # Just get the first part of the array and display that
+          fact_array = path[-1]
+          if fact_array.respond_to? :eContents
+            fact_array_content = fact_array.eContents
+          else
+            fact_array_content = []
+            fact_array._pcore_contents { |item| fact_array_content.push item }
+          end
+
+          if fact_array_content.length > 1
+            factname = fact_array_content[1].value
+            content = get_fact_content(session_state, factname)
+          end
+        elsif expr.start_with?('::') && expr.rindex(':') == 1
+          # We are dealing with a top local scope variable - Possible fact name
+          factname = expr.slice(2, expr.length - 2)
+          content = get_fact_content(session_state, factname)
+        else
+          # Could be a flatout fact name.  May not *shrugs*.  That method of access is deprecated
+          content = get_fact_content(session_state, expr)
+        end
+
+        content
+      end
+
+      # Content generation functions
+      def self.get_fact_content(session_state, factname)
+        fact = PuppetLanguageServer::FacterHelper.fact(session_state, factname)
+        return nil if fact.nil?
+
+        value = fact.value
+        content = "**#{factname}** Fact\n\n"
+
+        if value.is_a?(Hash)
+          content = "#{content}```\n#{JSON.pretty_generate(value)}\n```"
+        else
+          content += value.to_s
+        end
+
+        content
+      end
+
+      def self.get_attribute_type_parameter_content(item_type, param)
+        param_type = item_type.attributes[param]
+        content = "**#{param}** Parameter"
+        content += "\n\n#{param_type[:doc]}" unless param_type[:doc].nil?
+        content
+      end
+
+      def self.get_attribute_type_property_content(item_type, property)
+        prop_type = item_type.attributes[property]
+        content = "**#{property}** Property"
+        content += "\n\n(_required_)" if prop_type[:required?]
+        content += "\n\n#{prop_type[:doc]}" unless prop_type[:doc].nil?
+        content
+      end
+
+      def self.get_attribute_class_parameter_content(item_class, param)
+        param_type = item_class.parameters[param]
+        return nil if param_type.nil?
+
+        content = "**#{param}** Parameter"
+        content += "\n\n#{param_type[:doc]}" unless param_type[:doc].nil?
+        content
+      end
+
+      def self.get_call_named_function_expression_content(session_state, item, tasks_mode)
+        func_name = item.functor_expr.value
+
+        func_info = PuppetLanguageServer::PuppetHelper.function(session_state, func_name, tasks_mode)
+        raise "Function #{func_name} does not exist" if func_info.nil?
+
+        content = "**#{func_name}** Function"
+        content += "\n\n#{func_info.doc}" unless func_info.doc.nil?
+
+        content
+      end
+
+      def self.get_resource_expression_content(session_state, item)
+        name = item.type_name.value
+        # Strip top scope colons if found
+        name = name[2..-1] if name.start_with?('::')
+        # Get an instance of the type
+        item_object = PuppetLanguageServer::PuppetHelper.get_type(session_state, name)
+        return get_puppet_type_content(item_object) unless item_object.nil?
+
+        item_object = PuppetLanguageServer::PuppetHelper.get_class(session_state, name)
+        return get_puppet_class_content(item_object) unless item_object.nil?
+
+        raise "#{name} is not a valid puppet type"
+      end
+
+      def self.get_puppet_type_content(item_type)
+        content = "**#{item_type.key}** Resource\n\n"
+        content += "\n\n#{item_type.doc}" unless item_type.doc.nil?
+        content += "\n\n---\n"
+        item_type.attributes.keys.sort.each do |attr|
+          content += "* #{attr}\n"
+        end
+
+        content
+      end
+      private_class_method :get_puppet_type_content
+
+      def self.get_puppet_class_content(item_class)
+        content = "**#{item_class.key}** Resource"
+        content += "\n\n#{item_class.doc}" unless item_class.doc.nil?
+        unless item_class.parameters.count.zero?
+          content += "\n\n---\n"
+          item_class.parameters.sort.each do |name, _param|
+            content += "* #{name}\n"
+          end
+        end
+        content.strip
+      end
+      private_class_method :get_puppet_class_content
+
+      def self.get_puppet_datatype_content(session_state, item, tasks_mode)
+        dt_info = PuppetLanguageServer::PuppetHelper.datatype(session_state, item.cased_value, tasks_mode)
+        raise "DataType #{item.cased_value} does not exist" if dt_info.nil?
+
+        content = "**#{item.cased_value}** Data Type"
+        content += ' Alias' if dt_info.is_type_alias
+        content += "\n\n#{dt_info.doc}" unless dt_info.doc.nil?
+
+        content += "\n\nAlias of `#{dt_info.alias_of}`" if dt_info.is_type_alias
+        content
+      end
+      private_class_method :get_puppet_datatype_content
+    end
+  end
+end