openvox-editor-services 4.0.0 → 4.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bdea88fc71917e7a0813d0ede0cd6baa82770a416a998a68ee5a6e6e781fe88d
-  data.tar.gz: 6de1fb9e00fdfe2dc9824d13d40283c605ef2c79e62452df2b0a7614b4cba634
+  metadata.gz: 2482da72d66357f9710a3705a119f913b8b1f589cd8c1308fdf4267380516c14
+  data.tar.gz: 9166657dc9d5c62fd15ce34b97a89ab81db74cce077789c9d4801da61cfb7514
 SHA512:
-  metadata.gz: cc271d47fb8bfbda55e0948dc08b3786818d14b5141b3fa85fe51fa76a55949ba4e964961296faee32c1276e8a97727765da76eb5888af5eda8faab9c8ae07b6
-  data.tar.gz: ceff85dbada907b81d0ee9f527e5af58cff47373048c8d8c6de16233968255b02bf74f90d1bb75339497f280d53e89fe65aeadefe5488aa2fa6dd7bde1592a21
+  metadata.gz: 07a236de9536aa66d4311bb1632f0686a79bca0e0a2ab167c61ddeee1f0beafab2de63efc3d710b7023c45322f74bfea39b99bd1b1def1b9f15b34e1f9f3dee2
+  data.tar.gz: 1c3138263fc890e6c0aacce1c7806a538c73ab3fbd4d488d80ed07f8d21c6ddcd780cd01da4c12049698d502def58660df19be9fa66cbce148a70e288663edce

data/CHANGELOG.md

@@ -1,8 +1,16 @@
 # Changelog
 
-## [4.0.0](https://github.com/voxpupuli/openvox-editor-services/tree/4.0.0) (2026-11-06)
+## [4.0.1](https://github.com/voxpupuli/openvox-editor-services/tree/4.0.1) (2026-11-09)
 
-[Full Changelog](https://github.com/voxpupuli/openvox-editor-services/compare/v3.1.2...4.0.0)
+[Full Changelog](https://github.com/voxpupuli/openvox-editor-services/compare/v4.0.0...4.0.1)
+
+**Fixed bugs:**
+
+- fix: repair/extend attributes completion [\#88](https://github.com/voxpupuli/openvox-editor-services/pull/88) ([jay7x](https://github.com/jay7x))
+
+## [v4.0.0](https://github.com/voxpupuli/openvox-editor-services/tree/v4.0.0) (2026-11-06)
+
+[Full Changelog](https://github.com/voxpupuli/openvox-editor-services/compare/v3.1.2...v4.0.0)
 
 **Breaking changes:**
 

data/README.md

@@ -11,6 +11,7 @@ The internal `Puppet` Ruby namespace and `puppet/*` protocol methods are retaine
     - [How to run the Language Server for Development](#how-to-run-the-language-server-for-development)
     - [How to run the Language Server in Production](#how-to-run-the-language-server-in-production)
     - [Command line arguments](#command-line-arguments)
+    - [Resource attribute completion](#resource-attribute-completion)
   - [Language Server Sidecar](#language-server-sidecar)
     - [How to run the Language Server Sidecar for Development](#how-to-run-the-language-server-sidecar-for-development)
     - [Example usage](#example-usage)
@@ -146,6 +147,13 @@ For the complete option list, run:
 bundle exec ruby ./openvox-languageserver --help
 ```
 
+### Resource attribute completion
+
+Resource attribute completion aligns hashrockets to the longest attribute name in the resource.
+The alignment padding is capped at 999 characters (`MAX_ATTRIBUTE_PADDING`) because OpenVox/Puppet does not limit identifier length.
+This bounds memory and CPU use for pathological manifests and for client-supplied completion data.
+Attributes longer than the cap are inserted without extra alignment padding.
+
 ## Language Server Sidecar
 
 ### How to run the Language Server Sidecar for Development

data/lib/puppet-languageserver/global_queues/sidecar_queue.rb

@@ -3,6 +3,7 @@
 require 'puppet-languageserver/global_queues/single_instance_queue'
 require 'puppet_editor_services/server'
 require 'open3'
+require 'rbconfig'
 
 module PuppetLanguageServer
   module GlobalQueues
@@ -37,7 +38,10 @@ module PuppetLanguageServer
 
         sidecar_path = File.expand_path(File.join(__dir__, '..', '..', '..', 'openvox-languageserver-sidecar'))
         args = ['--action', job_object.action].concat(job_object.additional_args).concat(sidecar_args_from_connection(connection))
-        cmd = ['ruby', sidecar_path].concat(args)
+        # Use the same Ruby interpreter as the language server. Relying on a bare
+        # 'ruby' from PATH can pick up a different runtime which cannot see the
+        # Puppet agent's gems and types.
+        cmd = [RbConfig.ruby, sidecar_path].concat(args)
         PuppetLanguageServer.log_message(:debug, "SidecarQueue Thread: Running sidecar #{cmd}")
         stdout, stderr, status = run_sidecar(cmd)
         PuppetLanguageServer.log_message(:warning, "SidecarQueue Thread: Calling sidecar with #{args.join(' ')} returned exitcode #{status.exitstatus}, #{stderr}")
@@ -162,8 +166,25 @@ module PuppetLanguageServer
         handler.respond_to?(:session_state) ? handler.session_state : nil
       end
 
+      # The language server removes GEM_HOME/GEM_PATH from its own environment
+      # while activating the OpenVox agent runtime. The sidecar is a child
+      # process and still needs the bundled extension gems (openvox-strings,
+      # yard, etc.), so restore them for the sidecar invocation.
+      def sidecar_gem_environment
+        gem_home = File.expand_path(File.join(__dir__, '..', '..', '..', 'gems'))
+        return {} unless Dir.exist?(gem_home)
+
+        # Preserve any GEM_PATH entries inherited from the environment (for
+        # example a user's own gems) instead of replacing them. Keep the
+        # bundled gems first so they win when the same gem is available twice.
+        existing_paths = ENV['GEM_PATH'].to_s.split(File::PATH_SEPARATOR).reject(&:empty?)
+        gem_path = ([gem_home] + existing_paths).uniq.join(File::PATH_SEPARATOR)
+
+        { 'GEM_HOME' => gem_home, 'GEM_PATH' => gem_path }
+      end
+
       def run_sidecar(cmd)
-        Open3.capture3(*cmd)
+        Open3.capture3(sidecar_gem_environment, *cmd)
 
         # The following code should ONLY be uncommented when debugging acceptance tests failures.
         # It caches the sidecar responses so tests sidecar calls will be (VERY) quick, which speeds
@@ -182,7 +203,7 @@ module PuppetLanguageServer
         #   ]
         # end
         # # Rubocop failure is here on purpose
-        # stdout,stderr,status = Open3.capture3(*cmd)
+        # stdout,stderr,status = Open3.capture3(sidecar_gem_environment, *cmd)
         # File.write(cache_file, stdout, mode: 'wb', encoding: 'utf-8')
         # [stdout, stderr, status]
       end

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

@@ -1,12 +1,17 @@
 # frozen_string_literal: true
 
+require 'puppet-languageserver/manifest/completion_provider_attributes'
+
 module PuppetLanguageServer
   module Manifest
     module CompletionProvider
+      extend CompletionProviderAttributes
+
       def self.complete(session_state, content, line_num, char_num, options = {})
         options = {
           tasks_mode: false,
-          context: nil # LSP::CompletionContext object
+          context: nil, # LSP::CompletionContext object
+          file_uri: nil
         }.merge(options)
         items = []
         incomplete = false
@@ -62,14 +67,33 @@ module PuppetLanguageServer
           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
+          # We are inside a resource definition. Should display all available
           # properities and parameters.
 
+          # The attribute list is computed for the current prefix, and the
+          # client must ask again as the user keeps typing. Otherwise it reuses
+          # completion items whose document version and replacement range have
+          # gone stale.
+          incomplete = true
+
           # 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
+
+          # Align hashrockets with the longest existing attribute name. A zero
+          # padding means there are no existing attributes. A value above the
+          # cap is pathological and disables alignment entirely.
+          operations = item.bodies.flat_map { |body| body.operations || [] }
+          file_uri = options[:file_uri]
+          document_version = file_uri.nil? ? nil : session_state.documents.document_version(file_uri)
+          resource_data = attribute_resource_data(
+            content, line_num, char_num,
+            { file_uri: file_uri, document_version: document_version, tasks_mode: options[:tasks_mode] },
+            item_value, operations
+          )
+
           item_object = PuppetLanguageServer::PuppetHelper.get_type(session_state, item_value)
           unless item_object.nil?
             # Add Parameters
@@ -78,11 +102,7 @@ module PuppetLanguageServer
                 'label' => name.to_s,
                 'kind' => LSP::CompletionItemKind::PROPERTY,
                 'detail' => 'Parameter',
-                'data' => {
-                  'type' => 'resource_parameter',
-                  'param' => name.to_s,
-                  'resource_type' => item_value
-                }
+                'data' => attribute_data(resource_data, 'resource_parameter', 'param', name)
               )
             end
             # Add Properties
@@ -91,15 +111,12 @@ module PuppetLanguageServer
                 'label' => name.to_s,
                 'kind' => LSP::CompletionItemKind::PROPERTY,
                 'detail' => 'Property',
-                'data' => {
-                  'type' => 'resource_property',
-                  'prop' => name.to_s,
-                  'resource_type' => item_value
-                }
+                'data' => attribute_data(resource_data, 'resource_property', 'prop', name)
               )
             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)
@@ -110,11 +127,7 @@ module PuppetLanguageServer
                   'label' => name.to_s,
                   'kind' => LSP::CompletionItemKind::PROPERTY,
                   'detail' => 'Parameter',
-                  'data' => {
-                    'type' => 'resource_class_parameter',
-                    'param' => name.to_s,
-                    'resource_type' => item_value
-                  }
+                  'data' => attribute_data(resource_data, 'resource_class_parameter', 'param', name)
                 )
               end
             end
@@ -128,6 +141,7 @@ module PuppetLanguageServer
       end
 
       # BEGIN CompletionItem Helpers
+
       def self.keywords(keywords = [], &block)
         keywords.each do |keyword|
           item = LSP::CompletionItem.new(
@@ -247,7 +261,7 @@ module PuppetLanguageServer
           return result if item_type.nil?
 
           result.documentation = item_type.doc unless item_type.doc.nil?
-          unless item_type.nil? || item_type.signatures.none?
+          unless item_type.signatures.none?
             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
@@ -282,48 +296,47 @@ module PuppetLanguageServer
 
           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
+          return result if param_type.nil?
+
+          # TODO: More things?
+          result.documentation = param_type[:doc] unless param_type[:doc].nil?
+          attribute_insert_text(session_state, result, data, data['param'])
         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
+          return result if prop_type.nil?
+
+          # TODO: More things?
+          result.documentation = prop_type[:doc] unless prop_type[:doc].nil?
+          attribute_insert_text(session_state, result, data, data['prop'])
 
         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
+          return result if 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
+          attribute_insert_text(session_state, result, data, data['param'])
         end
 
+        result.insertTextFormat = LSP::InsertTextFormat::SNIPPET if data['type'].to_s.start_with?('resource_')
         result
       end
     end

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

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module PuppetLanguageServer
+  module Manifest
+    # Helpers for completing resource attributes.
+    module CompletionProviderAttributes
+      # OpenVox/Puppet does not limit attribute name length. The longest
+      # built-in attribute is 23 characters (selinux_ignore_defaults), and the
+      # style guide recommends lines no longer than 140 characters. This cap is
+      # purely defensive: it bounds alignment padding for pathological manifests
+      # and for client-supplied completion data.
+      MAX_ATTRIBUTE_PADDING = 999
+
+      def attribute_data(resource_data, type, name_key, name)
+        name_length = name.to_s.length
+        padding = [resource_data['padding'].to_i, name_length].max
+        alignment = resource_data['alignment'] == true && padding.positive? && padding <= MAX_ATTRIBUTE_PADDING
+        padding = name_length if padding > MAX_ATTRIBUTE_PADDING
+
+        resource_data.merge(
+          'type' => type,
+          name_key => name.to_s,
+          'padding' => padding,
+          'alignment' => alignment
+        )
+      end
+
+      # Build the shared data payload for every completion item generated from
+      # one resource expression.
+      def attribute_resource_data(content, line_num, char_num, options, resource_type, operations)
+        slice = content.split("\n", -1)[line_num].to_s[0, char_num].to_s
+        indent = slice[/\A[ \t]*/] || ''
+        # An unanchored search can retry at every offset, so use rindex instead
+        # of a trailing-anchored regex on long runs of attribute-name characters.
+        boundary = slice.rindex(/[^\w-]/)
+        prefix = boundary.nil? ? slice : slice[(boundary + 1)..].to_s
+
+        padding = operations.map { |operation| operation.attribute_name.to_s.length }.max || 0
+        alignment = padding.positive? && padding <= MAX_ATTRIBUTE_PADDING
+
+        {
+          'resource_type' => resource_type,
+          'padding' => alignment ? padding : 0,
+          'alignment' => alignment,
+          'replace_range' => LSP.create_range(line_num, char_num - prefix.length, line_num, char_num),
+          'uri' => options[:file_uri],
+          'document_version' => options[:document_version],
+          'cursor_line' => line_num,
+          'cursor_char' => char_num,
+          'indent_width' => indent.length,
+          'tasks_mode' => options[:tasks_mode] == true
+        }
+      end
+
+      # Build hashrocket alignment edits for resource attributes.
+      #
+      # operations   - Array of Puppet::Pops::Model::AttributeOperation
+      # cursor_line  - 0-based line number of the completion, which is skipped
+      # indent_width - number of leading spaces on the completion line
+      # width        - desired attribute-name column width
+      #
+      # Returns an Array of LSP::TextEdit. Returns an empty Array when
+      # alignment is not possible or not safe.
+      def alignment_edits_from_operations(operations, cursor_line, indent_width, width)
+        return [] if width.nil? || width <= 0 || width > MAX_ATTRIBUTE_PADDING
+        return [] if operations.nil? || operations.empty?
+
+        infos = []
+        operations.each do |operation|
+          name = operation.attribute_name.to_s
+          next if name.empty?
+          return [] if name.length > MAX_ATTRIBUTE_PADDING
+
+          locator = operation.respond_to?(:locator) ? operation.locator : nil
+          next if locator.nil?
+
+          source = locator.string
+          next if source.nil?
+
+          name_start = operation.offset
+          name_end = name_start + name.length
+          value_expr = operation.value_expr
+          next if value_expr.nil? || !value_expr.respond_to?(:offset)
+
+          gap = source[name_end...value_expr.offset]
+          next if gap.nil?
+
+          arrow_offset = gap.index('=>')
+          next if arrow_offset.nil?
+
+          arrow_start = name_end + arrow_offset
+
+          infos << {
+            line: locator.line_for_offset(name_start) - 1,
+            name_end_col: locator.pos_on_line(name_start) - 1 + name.length,
+            arrow_col: locator.pos_on_line(arrow_start) - 1
+          }
+        end
+
+        return [] if infos.empty?
+
+        # Match format-on-type: if two hashrockets share a line we cannot
+        # align the body safely.
+        lines = infos.map { |info| info[:line] }
+        return [] if lines.uniq.length != lines.length
+
+        target_col = infos.map { |info| info[:name_end_col] }.max + 1
+        target_col = [target_col, indent_width.to_i + width + 1].max
+
+        infos.each_with_object([]) do |info, edits|
+          # The completion snippet handles the line being completed.
+          next if info[:line] == cursor_line
+
+          whitespace = target_col - info[:name_end_col]
+          next if info[:arrow_col] - info[:name_end_col] == whitespace
+
+          edits << LSP::TextEdit.new.from_h!(
+            'newText' => ' ' * whitespace,
+            'range' => LSP.create_range(info[:line], info[:name_end_col], info[:line], info[:arrow_col])
+          )
+        end
+      end
+
+      def attribute_insert_text(session_state, item, data, name)
+        raw_padding = data['padding'].to_i
+        padding = if raw_padding.positive? && raw_padding <= MAX_ATTRIBUTE_PADDING
+                    [raw_padding, name.to_s.length].max
+                  else
+                    name.to_s.length
+                  end
+
+        content, char_num, replace_range = attribute_current_context(session_state, data)
+        item.insertText = "#{name.to_s.ljust(padding)} => ${1},$0"
+        item.textEdit = LSP::TextEdit.new.from_h!('newText' => item.insertText, 'range' => replace_range)
+        item.additionalTextEdits = nil
+
+        return if content.nil?
+
+        edits = attribute_alignment_edits(content, data, char_num, padding)
+        item.additionalTextEdits = edits unless edits.empty?
+      end
+
+      private
+
+      # Completion lists are reused while the user keeps typing, so the
+      # document version stored in the item data can lag behind the open
+      # document. When that happens, fall back to the current document and
+      # parse at the end of the completion line.
+      #
+      # Returns [content, cursor_char, replace_range].
+      def attribute_current_context(session_state, data)
+        uri = data['uri']
+        return [nil, nil, data['replace_range']] if uri.nil?
+
+        line_num = data['cursor_line'].to_i
+        content = session_state.documents.document_content(uri, data['document_version'])
+        return [content, data['cursor_char'].to_i, data['replace_range']] unless content.nil?
+
+        content = session_state.documents.document_content(uri)
+        return [nil, nil, data['replace_range']] if content.nil?
+
+        line_text = content.split("\n", -1)[line_num].to_s.rstrip
+        prefix = line_text[/[A-Za-z0-9_-]+\z/]
+        replace_range = if prefix.nil?
+                          data['replace_range']
+                        else
+                          LSP.create_range(line_num, line_text.length - prefix.length, line_num, line_text.length)
+                        end
+        [content, line_text.length, replace_range]
+      end
+
+      def attribute_alignment_edits(content, data, char_num, padding)
+        return [] unless data['alignment'] == true
+
+        raw_padding = data['padding'].to_i
+        return [] unless raw_padding.positive? && raw_padding <= MAX_ATTRIBUTE_PADDING
+
+        operations = attribute_operations(
+          content,
+          data['cursor_line'].to_i,
+          char_num.to_i,
+          data['tasks_mode'] == true
+        )
+        alignment_edits_from_operations(
+          operations,
+          data['cursor_line'].to_i,
+          data['indent_width'].to_i,
+          padding
+        )
+      rescue StandardError
+        []
+      end
+
+      def attribute_operations(content, line_num, char_num, tasks_mode)
+        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: tasks_mode,
+          remove_trigger_char: false
+        )
+        return [] if result.nil?
+
+        model = result[:model]
+        return [] unless model.instance_of?(::Puppet::Pops::Model::ResourceExpression)
+
+        model.bodies.flat_map { |body| body.operations || [] }
+      end
+    end
+  end
+end

data/lib/puppet-languageserver/message_handler.rb

@@ -163,7 +163,7 @@ module PuppetLanguageServer
 
       case documents.document_type(file_uri)
       when :manifest
-        PuppetLanguageServer::Manifest::CompletionProvider.complete(session_state, content, line_num, char_num, context:, tasks_mode: documents.plan_file?(file_uri))
+        PuppetLanguageServer::Manifest::CompletionProvider.complete(session_state, content, line_num, char_num, context: context, tasks_mode: documents.plan_file?(file_uri), file_uri: file_uri)
       else
         raise "Unable to provide completion on #{file_uri}"
       end

data/lib/puppet-languageserver-sidecar/puppet_helper.rb

@@ -262,16 +262,20 @@ module PuppetLanguageServerSidecar
             { relative_dir: 'manifests', glob: '/**/*.pp' } # Pretty much everything in most modules
           ],
           datatype: [
-            { relative_dir: 'lib/puppet/datatypes',        glob: '/**/*.rb' }, # Custom Data Types
-            { relative_dir: 'types',                       glob: '/**/*.pp' }  # Data Type aliases
+            { relative_dir: 'lib/puppet/datatypes',         glob: '/**/*.rb' }, # Custom Data Types
+            { relative_dir: 'vendor_ruby/puppet/datatypes', glob: '/**/*.rb' }, # As above, in a Puppet agent layout
+            { relative_dir: 'types',                        glob: '/**/*.pp' }  # Data Type aliases
           ],
           function: [
-            { relative_dir: 'functions',                   glob: '/**/*.pp' }, # Contains custom functions written in the Puppet language.
-            { relative_dir: 'lib/puppet/functions',        glob: '/**/*.rb' }, # Contains functions written in Ruby for the modern Puppet::Functions API
-            { relative_dir: 'lib/puppet/parser/functions', glob: '/**/*.rb' }  # Contains functions written in Ruby for the legacy Puppet::Parser::Functions API
+            { relative_dir: 'functions',                           glob: '/**/*.pp' }, # Contains custom functions written in the Puppet language.
+            { relative_dir: 'lib/puppet/functions',                glob: '/**/*.rb' }, # Contains functions written in Ruby for the modern Puppet::Functions API
+            { relative_dir: 'vendor_ruby/puppet/functions',        glob: '/**/*.rb' }, # As above, in a Puppet agent layout
+            { relative_dir: 'lib/puppet/parser/functions',         glob: '/**/*.rb' }, # Contains functions written in Ruby for the legacy Puppet::Parser::Functions API
+            { relative_dir: 'vendor_ruby/puppet/parser/functions', glob: '/**/*.rb' }  # As above, in a Puppet agent layout
           ],
           type: [
-            { relative_dir: 'lib/puppet/type', glob: '/{,file/}*.rb' } # Contains Puppet resource types. Resource types like `file` can live in subdirs, hence the glob
+            { relative_dir: 'lib/puppet/type',         glob: '/{,file/}*.rb' }, # Contains Puppet resource types. Resource types like `file` can live in subdirs, hence the glob
+            { relative_dir: 'vendor_ruby/puppet/type', glob: '/{,file/}*.rb' }  # As above, in a Puppet agent layout
           ]
         }
       end

data/lib/puppet-languageserver-sidecar/puppet_strings_helper.rb

@@ -294,6 +294,16 @@ module PuppetLanguageServerSidecar
             }
           end
         end
+        # Checks are parameters too. Types such as exec use `newcheck` for
+        # attributes like `creates`, `unless`, `onlyif` and `refreshonly`.
+        unless item[:checks].nil?
+          item[:checks].each do |check|
+            obj.attributes[check[:name]] = {
+              type: :param,
+              doc: check[:description]
+            }
+          end
+        end
 
         if obj.key == 'file'
           # Special case for file type

data/lib/puppet-languageserver-sidecar/puppet_strings_monkey_patches.rb

@@ -2,7 +2,7 @@
 
 require 'yard/logging'
 module YARD
-  class Logger < ::Logger
+  class Logger
     # Suppress ANY output
     def self.instance(_pipe = $stdout)
       @logger ||= new(nil)

data/lib/puppet_editor_services/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module PuppetEditorServices
-  PUPPETEDITORSERVICESVERSION = '4.0.0' unless defined? PUPPETEDITORSERVICESVERSION
+  PUPPETEDITORSERVICESVERSION = '4.0.1' unless defined? PUPPETEDITORSERVICESVERSION
 
   # @api public
   #

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openvox-editor-services
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 4.0.1
 platform: ruby
 authors:
 - OpenVox Project contributors
@@ -192,6 +192,7 @@ files:
 - lib/puppet-languageserver/global_queues/single_instance_queue.rb
 - lib/puppet-languageserver/global_queues/validation_queue.rb
 - lib/puppet-languageserver/manifest/completion_provider.rb
+- lib/puppet-languageserver/manifest/completion_provider_attributes.rb
 - lib/puppet-languageserver/manifest/definition_provider.rb
 - lib/puppet-languageserver/manifest/document_formatting_provider.rb
 - lib/puppet-languageserver/manifest/document_symbol_provider.rb