puppet-editor-services 2.0.4

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

@@ -0,0 +1,331 @@
+# frozen_string_literal: true
+
+module PuppetLanguageServer
+  module Manifest
+    module CompletionProvider
+      def self.complete(session_state, content, line_num, char_num, options = {})
+        options = {
+          tasks_mode: false,
+          context: nil # LSP::CompletionContext object
+        }.merge(options)
+        items = []
+        incomplete = false
+        is_trigger_char = !options[:context].nil? && options[:context].triggerKind == LSP::CompletionTriggerKind::TRIGGERCHARACTER
+
+        result = PuppetLanguageServer::PuppetParserHelper.object_under_cursor(content, line_num, char_num,
+                                                                              multiple_attempts: true,
+                                                                              disallowed_classes: [Puppet::Pops::Model::QualifiedName, Puppet::Pops::Model::BlockExpression],
+                                                                              tasks_mode: options[:tasks_mode],
+                                                                              remove_trigger_char: is_trigger_char)
+        if result.nil?
+          # We are in the root of the document.
+
+          # Add keywords
+          keywords(%w[class define node application site]) { |x| items << x }
+          keywords(%w[plan]) { |x| items << x } if options[:tasks_mode]
+
+          # Add resources
+          all_resources(session_state) { |x| items << x }
+
+          all_functions(session_state, options[:tasks_mode]) { |x| items << x }
+
+          response = LSP::CompletionList.new
+          response.items = items
+          response.isIncomplete = incomplete
+          return response
+        end
+
+        item = result[:model]
+
+        case item.class.to_s
+        when 'Puppet::Pops::Model::VariableExpression'
+          expr = item.expr.value
+
+          # Complete for `$facts[...`
+          all_facts(session_state) { |x| items << x } if expr == 'facts'
+
+        when 'Puppet::Pops::Model::HostClassDefinition', 'Puppet::Pops::Model::ResourceTypeDefinition'
+          # We are in the root of a `class` or `define` statement
+
+          # Add keywords
+          keywords(%w[require contain]) { |x| items << x }
+
+          # Add resources
+          all_resources(session_state) { |x| items << x }
+
+        when 'Puppet::Pops::Model::PlanDefinition'
+          # We are in the root of a `plan` statement
+
+          # Add resources
+          all_resources(session_state) { |x| items << x }
+
+          all_functions(session_state, options[:tasks_mode]) { |x| items << x }
+
+        when 'Puppet::Pops::Model::ResourceExpression'
+          # We are inside a resource definition.  Should display all available
+          # properities and parameters.
+
+          # Try Types first
+          # The `class` pseudo resource type is actually used to set properties/params for the puppet type
+          # specified in the resource title.
+          # Ref: https://puppet.com/docs/puppet/5.3/lang_classes.html#using-resource-like-declarations
+          item_value = item.type_name.value == 'class' && item.bodies.length == 1 ? item.bodies[0].title.value : item.type_name.value
+          item_object = PuppetLanguageServer::PuppetHelper.get_type(session_state, item_value)
+          unless item_object.nil?
+            # Add Parameters
+            item_object.attributes.select { |_name, data| data[:type] == :param }.each_key do |name|
+              items << LSP::CompletionItem.new(
+                'label' => name.to_s,
+                'kind' => LSP::CompletionItemKind::PROPERTY,
+                'detail' => 'Parameter',
+                'data' => {
+                  'type' => 'resource_parameter',
+                  'param' => name.to_s,
+                  'resource_type' => item_value
+                }
+              )
+            end
+            # Add Properties
+            item_object.attributes.select { |_name, data| data[:type] == :property }.each_key do |name|
+              items << LSP::CompletionItem.new(
+                'label' => name.to_s,
+                'kind' => LSP::CompletionItemKind::PROPERTY,
+                'detail' => 'Property',
+                'data' => {
+                  'type' => 'resource_property',
+                  'prop' => name.to_s,
+                  'resource_type' => item_value
+                }
+              )
+            end
+            # TODO: What about meta parameters?
+          end
+          if item_object.nil?
+            # Try Classes/Defined Types
+            item_object = PuppetLanguageServer::PuppetHelper.get_class(session_state, item_value)
+            unless item_object.nil?
+              # Add Parameters
+              item_object.parameters.each_key do |name|
+                items << LSP::CompletionItem.new(
+                  'label' => name.to_s,
+                  'kind' => LSP::CompletionItemKind::PROPERTY,
+                  'detail' => 'Parameter',
+                  'data' => {
+                    'type' => 'resource_class_parameter',
+                    'param' => name.to_s,
+                    'resource_type' => item_value
+                  }
+                )
+              end
+            end
+          end
+        end
+
+        response = LSP::CompletionList.new
+        response.items = items
+        response.isIncomplete = incomplete
+        response
+      end
+
+      # BEGIN CompletionItem Helpers
+      def self.keywords(keywords = [], &block)
+        keywords.each do |keyword|
+          item = LSP::CompletionItem.new(
+            'label' => keyword,
+            'kind' => LSP::CompletionItemKind::KEYWORD,
+            'detail' => 'Keyword',
+            'data' => {
+              'type' => 'keyword',
+              'name' => keyword
+            }
+          )
+          yield(item) if block
+        end
+      end
+
+      def self.all_facts(session_state, &block)
+        PuppetLanguageServer::FacterHelper.fact_names(session_state).each do |name|
+          item = LSP::CompletionItem.new(
+            'label' => name.to_s,
+            'insertText' => "'#{name}'",
+            'kind' => LSP::CompletionItemKind::VARIABLE,
+            'detail' => 'Fact',
+            'data' => {
+              'type' => 'variable_expr_fact',
+              'expr' => name
+            }
+          )
+          yield(item) if block
+        end
+      end
+
+      def self.all_resources(session_state, &block)
+        # Find Puppet Types
+        PuppetLanguageServer::PuppetHelper.type_names(session_state).each do |pup_type|
+          item = LSP::CompletionItem.new(
+            'label' => pup_type,
+            'kind' => LSP::CompletionItemKind::MODULE,
+            'detail' => 'Resource',
+            'data' => {
+              'type' => 'resource_type',
+              'name' => pup_type
+            }
+          )
+          yield(item) if block
+        end
+        # Find Puppet Classes/Defined Types
+        PuppetLanguageServer::PuppetHelper.class_names(session_state).each do |pup_class|
+          item = LSP::CompletionItem.new('label' => pup_class,
+                                         'kind' => LSP::CompletionItemKind::MODULE,
+                                         'detail' => 'Resource',
+                                         'data' => { 'type' => 'resource_class',
+                                                     'name' => pup_class })
+          yield(item) if block
+        end
+      end
+
+      def self.all_functions(session_state, tasks_mode, &block)
+        PuppetLanguageServer::PuppetHelper.function_names(session_state, tasks_mode).each do |name|
+          item = LSP::CompletionItem.new(
+            'label' => name.to_s,
+            'kind' => LSP::CompletionItemKind::FUNCTION,
+            'detail' => 'Function',
+            'data' => {
+              'type' => 'function',
+              'name' => name.to_s
+            }
+          )
+          yield(item) if block
+        end
+      end
+      # END Helpers
+
+      # completion_item is an instance of LSP::CompletionItem
+      def self.resolve(session_state, completion_item)
+        result = completion_item.clone
+        data = result.data
+        case data['type']
+        when 'variable_expr_fact'
+          value = PuppetLanguageServer::FacterHelper.fact_value(session_state, data['expr'])
+          # TODO: More things?
+          result.documentation = value.to_s
+
+        when 'keyword'
+          case data['name']
+          when 'class'
+            result.documentation = 'Classes are named blocks of Puppet code that are stored in modules for later use and ' \
+                                   'are not applied until they are invoked by name. They can be added to a node’s catalog ' \
+                                   'by either declaring them in your manifests or assigning them from an ENC.'
+            result.insertText = "# Class: $1\n#\n#\nclass ${1:name} {\n\t${2:# resources}\n}$0"
+            result.insertTextFormat = LSP::InsertTextFormat::SNIPPET
+          when 'define'
+            result.documentation = 'Defined resource types (also called defined types or defines) are blocks of Puppet code ' \
+                                   'that can be evaluated multiple times with different parameters. Once defined, they act ' \
+                                   'like a new resource type: you can cause the block to be evaluated by declaring a resource ' \
+                                   'of that new resource type.'
+            result.insertText = "define ${1:name} () {\n\t${2:# resources}\n}$0"
+            result.insertTextFormat = LSP::InsertTextFormat::SNIPPET
+          when 'application'
+            result.detail = 'Orchestrator'
+            result.documentation = 'Application definitions are a lot like a defined resource type except that instead of defining ' \
+                                   'a chunk of reusable configuration that applies to a single node, the application definition ' \
+                                   'operates at a higher level. The components you declare inside an application can be individually ' \
+                                   'assigned to separate nodes you manage with Puppet.'
+            result.insertText = "application ${1:name} () {\n\t${2:# resources}\n}$0"
+            result.insertTextFormat = LSP::InsertTextFormat::SNIPPET
+          when 'site'
+            result.detail = 'Orchestrator'
+            result.documentation = 'Within the site block, applications are declared like defined types. They can be declared any ' \
+                                   'number of times, but their type and title combination must be unique within an environment.'
+            result.insertText = "site ${1:name} () {\n\t${2:# applications}\n}$0"
+            result.insertTextFormat = LSP::InsertTextFormat::SNIPPET
+          end
+
+        when 'function'
+          # We don't know if this resolution is coming from a plan or not, so just assume it is
+          item_type = PuppetLanguageServer::PuppetHelper.function(session_state, data['name'], true)
+          return result if item_type.nil?
+
+          result.documentation = item_type.doc unless item_type.doc.nil?
+          unless item_type.nil? || item_type.signatures.count.zero?
+            result.detail = item_type.signatures.map(&:key).join("\n\n")
+            # The signature provider should handle suggestions after this, so just place the cursor ready for an opening bracket
+            result.insertText = data['name'].to_s
+            result.insertTextFormat = LSP::InsertTextFormat::PLAINTEXT
+          end
+
+        when 'resource_type'
+          item_type = PuppetLanguageServer::PuppetHelper.get_type(session_state, data['name'])
+          return result if item_type.nil?
+
+          attr_names = []
+          # Add required attributes.  Ignore namevars as they come from the resource title
+          item_type.attributes.each { |name, item| attr_names.push(name.to_s) if item[:required?] && item[:isnamevar?] != true }
+          # Remove the'ensure' param/property for now, and we'll re-add later
+          attr_names.reject! { |item| item == 'ensure' }
+          # The param/property list should initially sorted alphabetically
+          attr_names.sort!
+          # Add the 'ensure' param/property at the top if the resource supports it
+          attr_names.insert(0, 'ensure') unless item_type.attributes.keys.find_index(:ensure).nil?
+          # Get the longest string length for later hash-rocket padding
+          max_length = -1
+          attr_names.each { |name| max_length = name.length if name.length > max_length }
+
+          # Generate the text snippet
+          snippet = "#{data['name']} { '${1:title}':\n"
+          attr_names.each_index do |index|
+            name = attr_names[index]
+            value_text = (name == 'ensure') ? 'present' : 'value' # rubocop:disable Style/TernaryParentheses  In this case it's easier to read.
+            snippet += "\t#{name.ljust(max_length, ' ')} => '${#{index + 2}:#{value_text}}'\n"
+          end
+          snippet += '}'
+
+          result.documentation = item_type.doc unless item_type.doc.nil?
+          result.insertText = snippet
+          result.insertTextFormat = LSP::InsertTextFormat::SNIPPET
+        when 'resource_parameter'
+          item_type = PuppetLanguageServer::PuppetHelper.get_type(session_state, data['resource_type'])
+          return result if item_type.nil?
+
+          param_type = item_type.attributes[data['param'].intern]
+          unless param_type.nil?
+            # TODO: More things?
+            result.documentation = param_type[:doc] unless param_type[:doc].nil?
+            result.insertText = "#{data['param']} => ,"
+          end
+        when 'resource_property'
+          item_type = PuppetLanguageServer::PuppetHelper.get_type(session_state, data['resource_type'])
+          return result if item_type.nil?
+
+          prop_type = item_type.attributes[data['prop'].intern]
+          unless prop_type.nil?
+            # TODO: More things?
+            result.documentation = prop_type[:doc] unless prop_type[:doc].nil?
+            result.insertText = "#{data['prop']} => ,"
+          end
+
+        when 'resource_class'
+          item_class = PuppetLanguageServer::PuppetHelper.get_class(session_state, data['name'])
+          return result if item_class.nil?
+
+          result.insertText = "#{data['name']} { '${1:title}':\n\t$0\n}"
+          result.insertTextFormat = LSP::InsertTextFormat::SNIPPET
+        when 'resource_class_parameter'
+          item_class = PuppetLanguageServer::PuppetHelper.get_class(session_state, data['resource_type'])
+          return result if item_class.nil?
+
+          param_type = item_class.parameters[data['param']]
+          unless param_type.nil?
+            doc = ''
+            doc += param_type[:type] unless param_type[:type].nil?
+            doc += "---\n#{param_type[:doc]}" unless param_type[:doc].nil?
+            result.documentation = doc
+            result.insertText = "#{data['param']} => ,"
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module PuppetLanguageServer
+  module Manifest
+    module DefinitionProvider
+      def self.find_definition(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]
+
+        response = []
+        case item.class.to_s
+        when 'Puppet::Pops::Model::CallNamedFunctionExpression'
+          func_name = item.functor_expr.value
+          response << function_name(session_state, func_name)
+
+        when 'Puppet::Pops::Model::LiteralString'
+          # LiteralString could be anything.  Context is the key here
+          parent = path.last
+
+          # What if it's a resource name.  Then the Literal String must be the same as the Resource Title
+          # e.g.
+          # class { 'testclass':    <--- testclass would be the LiteralString inside a ResourceBody
+          # }
+          if !parent.nil? &&
+             parent.instance_of?(::Puppet::Pops::Model::ResourceBody) &&
+             parent.title.value == item.value
+            resource_name = item.value
+            response << type_or_class(session_state, resource_name)
+          end
+
+        when 'Puppet::Pops::Model::QualifiedName'
+          # Qualified names could be anything.  Context is the key here
+          parent = path.last
+
+          # What if it's a function name.  Then the Qualified name must be the same as the function name
+          if !parent.nil? &&
+             parent.instance_of?(::Puppet::Pops::Model::CallNamedFunctionExpression) &&
+             parent.functor_expr.value == item.value
+            func_name = item.value
+            response << function_name(session_state, func_name)
+          end
+          # What if it's an "include <class>" call
+          if !parent.nil? && parent.instance_of?(::Puppet::Pops::Model::CallNamedFunctionExpression) && parent.functor_expr.value == 'include'
+            resource_name = item.value
+            response << type_or_class(session_state, resource_name)
+          end
+          # What if it's the name of a resource type or class
+          if !parent.nil? && parent.instance_of?(::Puppet::Pops::Model::ResourceExpression)
+            resource_name = item.value
+            response << type_or_class(session_state, resource_name)
+          end
+
+        when 'Puppet::Pops::Model::ResourceExpression'
+          resource_name = item.type_name.value
+          response << type_or_class(session_state, resource_name)
+
+        else
+          raise "Unable to generate Defintion information for object of type #{item.class}"
+        end
+
+        response.compact
+      end
+
+      def self.type_or_class(session_state, resource_name)
+        # Strip the leading double-colons for root resource names
+        resource_name = resource_name.slice(2, resource_name.length - 2) if resource_name.start_with?('::')
+        item = PuppetLanguageServer::PuppetHelper.get_type(session_state, resource_name)
+        item = PuppetLanguageServer::PuppetHelper.get_class(session_state, resource_name) if item.nil?
+        unless item.nil?
+          return LSP::Location.new(
+            'uri' => PuppetLanguageServer::UriHelper.build_file_uri(item.source),
+            'range' => LSP.create_range(item.line, 0, item.line, 1024)
+          )
+        end
+        nil
+      end
+      private_class_method :type_or_class
+
+      def self.function_name(session_state, func_name)
+        item = PuppetLanguageServer::PuppetHelper.function(session_state, func_name)
+        return nil if item.nil? || item.source.nil? || item.line.nil?
+
+        LSP::Location.new(
+          'uri' => "file:///#{item.source}",
+          'range' => LSP.create_range(item.line, 0, item.line, 1024)
+        )
+      end
+      private_class_method :function_name
+    end
+  end
+end

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

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module PuppetLanguageServer
+  module Manifest
+    module DocumentSymbolProvider
+      def self.workspace_symbols(query, object_cache)
+        query = '' if query.nil?
+        result = []
+        object_cache.all_objects do |key, item|
+          key_string = key.to_s
+          next unless query.empty? || key_string.include?(query)
+
+          case item
+          when PuppetLanguageServer::Sidecar::Protocol::PuppetType
+            result << LSP::SymbolInformation.new(
+              'name' => key_string,
+              'kind' => LSP::SymbolKind::METHOD,
+              'location' => {
+                'uri' => PuppetLanguageServer::UriHelper.build_file_uri(item.source),
+                # Don't have char pos for types so just pick extreme values
+                'range' => LSP.create_range(item.line, 0, item.line, 1024)
+              }
+            )
+
+          when PuppetLanguageServer::Sidecar::Protocol::PuppetFunction
+            result << LSP::SymbolInformation.new(
+              'name' => key_string,
+              'kind' => LSP::SymbolKind::FUNCTION,
+              'location' => {
+                'uri' => PuppetLanguageServer::UriHelper.build_file_uri(item.source),
+                # Don't have char pos for functions so just pick extreme values
+                'range' => LSP.create_range(item.line, 0, item.line, 1024)
+              }
+            )
+
+          when PuppetLanguageServer::Sidecar::Protocol::PuppetClass
+            result << LSP::SymbolInformation.new(
+              'name' => key_string,
+              'kind' => LSP::SymbolKind::CLASS,
+              'location' => {
+                'uri' => PuppetLanguageServer::UriHelper.build_file_uri(item.source),
+                # Don't have char pos for classes so just pick extreme values
+                'range' => LSP.create_range(item.line, 0, item.line, 1024)
+              }
+            )
+
+          when PuppetLanguageServer::Sidecar::Protocol::PuppetDataType
+            result << LSP::SymbolInformation.new(
+              'name' => key_string,
+              'kind' => LSP::SymbolKind::NAMESPACE,
+              'location' => {
+                'uri' => PuppetLanguageServer::UriHelper.build_file_uri(item.source),
+                # Don't have char pos for data types so just pick extreme values
+                'range' => LSP.create_range(item.line, 0, item.line, 1024)
+              }
+            )
+
+          when PuppetLanguageServer::Sidecar::Protocol::Fact
+            # Do nothing
+
+          else
+            PuppetLanguageServer.log_message(:warn, "[Manifest::DocumentSymbolProvider] Unknown object type #{item.class}")
+          end
+        end
+        result
+      end
+
+      def self.extract_document_symbols(content, options = {})
+        options = {
+          tasks_mode: false
+        }.merge(options)
+        parser = Puppet::Pops::Parser::Parser.new
+        result = parser.singleton_parse_string(content, options[:tasks_mode], '')
+
+        if result.model.respond_to? :eAllContents
+          # We are unable to build a document symbol tree for Puppet 4 AST
+          return []
+        end
+
+        symbols = []
+        recurse_document_symbols(result.model, '', nil, symbols) # []
+
+        symbols
+      end
+
+      def self.create_range(offset, length, locator)
+        start_line = locator.line_for_offset(offset) - 1
+        start_char = locator.pos_on_line(offset) - 1
+        end_line = locator.line_for_offset(offset + length) - 1
+        end_char = locator.pos_on_line(offset + length) - 1
+
+        LSP.create_range(start_line, start_char, end_line, end_char)
+      end
+
+      def self.locator_text(offset, length, locator)
+        locator.string.slice(offset, length)
+      end
+
+      def self.recurse_document_symbols(object, path, parentsymbol, symbollist)
+        # POPS Object Model
+        # https://github.com/puppetlabs/puppet/blob/master/lib/puppet/pops/model/ast.pp
+
+        # Path is just an internal path for debugging
+        # path = path + '/' + object.class.to_s[object.class.to_s.rindex('::')..-1]
+
+        this_symbol = nil
+
+        case object.class.to_s
+        # Puppet Resources
+        when 'Puppet::Pops::Model::ResourceExpression'
+          this_symbol = LSP::DocumentSymbol.new(
+            'name' => object.type_name.value,
+            'kind' => LSP::SymbolKind::METHOD,
+            'detail' => object.type_name.value,
+            'range' => create_range(object.offset, object.length, object.locator),
+            'selectionRange' => create_range(object.offset, object.length, object.locator),
+            'children' => []
+          )
+
+        when 'Puppet::Pops::Model::ResourceBody'
+          # We modify the parent symbol with the resource information,
+          # mainly we care about the resource title.
+          parentsymbol.name = "#{parentsymbol.name}: #{locator_text(object.title.offset, object.title.length, object.title.locator)}"
+          parentsymbol.detail = parentsymbol.name
+          parentsymbol.selectionRange = create_range(object.title.offset, object.title.length, object.locator)
+
+        when 'Puppet::Pops::Model::AttributeOperation'
+          attr_name = object.attribute_name
+          this_symbol = LSP::DocumentSymbol.new(
+            'name' => attr_name,
+            'kind' => LSP::SymbolKind::VARIABLE,
+            'detail' => attr_name,
+            'range' => create_range(object.offset, object.length, object.locator),
+            'selectionRange' => create_range(object.offset, attr_name.length, object.locator),
+            'children' => []
+          )
+
+        # Puppet Class
+        when 'Puppet::Pops::Model::HostClassDefinition'
+          this_symbol = LSP::DocumentSymbol.new(
+            'name' => object.name,
+            'kind' => LSP::SymbolKind::CLASS,
+            'detail' => object.name,
+            'range' => create_range(object.offset, object.length, object.locator),
+            'selectionRange' => create_range(object.offset, object.length, object.locator),
+            'children' => []
+          )
+          # Load in the class parameters
+          object.parameters.each do |param|
+            param_symbol = LSP::DocumentSymbol.new(
+              'name' => "$#{param.name}",
+              'kind' => LSP::SymbolKind::PROPERTY,
+              'detail' => "$#{param.name}",
+              'range' => create_range(param.offset, param.length, param.locator),
+              'selectionRange' => create_range(param.offset, param.length, param.locator),
+              'children' => []
+            )
+            this_symbol.children.push(param_symbol)
+          end
+
+        # Puppet Defined Type
+        when 'Puppet::Pops::Model::ResourceTypeDefinition'
+          this_symbol = LSP::DocumentSymbol.new(
+            'name' => object.name,
+            'kind' => LSP::SymbolKind::CLASS,
+            'detail' => object.name,
+            'range' => create_range(object.offset, object.length, object.locator),
+            'selectionRange' => create_range(object.offset, object.length, object.locator),
+            'children' => []
+          )
+          # Load in the class parameters
+          object.parameters.each do |param|
+            param_symbol = LSP::DocumentSymbol.new(
+              'name' => "$#{param.name}",
+              'kind' => LSP::SymbolKind::FIELD,
+              'detail' => "$#{param.name}",
+              'range' => create_range(param.offset, param.length, param.locator),
+              'selectionRange' => create_range(param.offset, param.length, param.locator),
+              'children' => []
+            )
+            this_symbol.children.push(param_symbol)
+          end
+
+        when 'Puppet::Pops::Model::AssignmentExpression'
+          this_symbol = LSP::DocumentSymbol.new(
+            'name' => "$#{object.left_expr.expr.value}",
+            'kind' => LSP::SymbolKind::VARIABLE,
+            'detail' => "$#{object.left_expr.expr.value}",
+            'range' => create_range(object.left_expr.offset, object.left_expr.length, object.left_expr.locator),
+            'selectionRange' => create_range(object.left_expr.offset, object.left_expr.length, object.left_expr.locator),
+            'children' => []
+          )
+
+        # Puppet Plan
+        when 'Puppet::Pops::Model::PlanDefinition'
+          this_symbol = LSP::DocumentSymbol.new(
+            'name' => object.name,
+            'kind' => LSP::SymbolKind::CLASS,
+            'detail' => object.name,
+            'range' => create_range(object.offset, object.length, object.locator),
+            'selectionRange' => create_range(object.offset, object.length, object.locator),
+            'children' => []
+          )
+          # Load in the class parameters
+          object.parameters.each do |param|
+            param_symbol = LSP::DocumentSymbol.new(
+              'name' => "$#{param.name}",
+              'kind' => LSP::SymbolKind::CLASS,
+              'detail' => "$#{param.name}",
+              'range' => create_range(param.offset, param.length, param.locator),
+              'selectionRange' => create_range(param.offset, param.length, param.locator),
+              'children' => []
+            )
+            this_symbol.children.push(param_symbol)
+          end
+        end
+
+        object._pcore_contents do |item|
+          recurse_document_symbols(item, path, this_symbol.nil? ? parentsymbol : this_symbol, symbollist)
+        end
+
+        return if this_symbol.nil?
+
+        parentsymbol.nil? ? symbollist.push(this_symbol) : parentsymbol.children.push(this_symbol)
+      end
+    end
+  end
+end