puppet-editor-services 2.0.4

data/lib/puppet-languageserver/session_state/document_store.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+module PuppetLanguageServer
+  module SessionState
+    # Represents a Document in the Document Store.
+    # Can be subclassed to add additional methods and helpers
+    class Document
+      attr_reader :uri, :content, :version, :tokens
+
+      # @param uri String The content of the document
+      # @param content String The content of the document
+      # @param version Integer The version the document
+      def initialize(uri, content, version)
+        @uri = uri
+        @content = content
+        @version = version
+        @tokens = nil
+      end
+
+      # Update a document with new content and version
+      # @param content String The new content for the document
+      # @param version Integer The version of the new document
+      def update(content, version)
+        @content = content
+        @version = version
+        @tokens = nil
+      end
+
+      # Subclass this!
+      def calculate_tokens!
+        []
+      end
+    end
+
+    class EppDocument < Document; end
+
+    class ManifestDocument < Document
+      def calculate_tokens!
+        lexer = Puppet::Pops::Parser::Lexer2WithComments.new
+        lexer.lex_string(content)
+        @tokens = lexer.fullscan
+      end
+    end
+
+    class PuppetfileDocument < Document; end
+
+    class DocumentStore
+      # @param options :workspace Path to the workspace
+      def initialize(_options = {})
+        @documents = {}
+        @doc_mutex = Mutex.new
+
+        initialize_store
+      end
+
+      def set_document(uri, content, doc_version)
+        @doc_mutex.synchronize do
+          if @documents[uri].nil?
+            @documents[uri] = create_document(uri, content, doc_version)
+          else
+            @documents[uri].update(content, doc_version)
+          end
+        end
+      end
+
+      def remove_document(uri)
+        @doc_mutex.synchronize { @documents.delete(uri) }
+        nil
+      end
+
+      def clear
+        @doc_mutex.synchronize { @documents.clear }
+      end
+
+      def document(uri, doc_version = nil)
+        @doc_mutex.synchronize do
+          return nil if @documents[uri].nil?
+          return nil unless doc_version.nil? || @documents[uri].version == doc_version
+
+          @documents[uri]
+        end
+      end
+
+      def document_content(uri, doc_version = nil)
+        doc = document(uri, doc_version)
+        doc.nil? ? nil : doc.content.clone
+      end
+
+      def get_document(uri)
+        doc = @documents[uri]
+        doc.nil? ? nil : doc.content.clone
+      end
+
+      def document_tokens(uri, doc_version = nil)
+        @doc_mutex.synchronize do
+          return nil if @documents[uri].nil?
+          return nil unless doc_version.nil? || @documents[uri].version == doc_version
+          return @documents[uri].tokens unless @documents[uri].tokens.nil?
+
+          return @documents[uri].calculate_tokens!
+        end
+      end
+
+      def document_version(uri)
+        doc = document(uri)
+        doc.nil? ? nil : doc.version
+      end
+
+      def document_uris
+        @doc_mutex.synchronize { @documents.keys.dup }
+      end
+
+      def document_type(uri)
+        case uri
+        when %r{/Puppetfile$}i
+          :puppetfile
+        when /\.pp$/i
+          :manifest
+        when /\.epp$/i
+          :epp
+        else
+          :unknown
+        end
+      end
+
+      # Plan files https://puppet.com/docs/bolt/1.x/writing_plans.html#concept-4485 can exist in many places
+      # The current best detection method is as follows:
+      # "Given the full path to the .pp file, if it contains a directory called plans, AND that plans is not a sub-directory of manifests, then it is a plan file"
+      #
+      # See https://github.com/lingua-pupuli/puppet-editor-services/issues/129 for the full discussion
+      def plan_file?(uri)
+        uri_path = PuppetLanguageServer::UriHelper.uri_path(uri)
+        return false if uri_path.nil?
+
+        # For the text searching below we need a leading slash. That way
+        # we don't need to use regexes which is slower
+        uri_path = "/#{uri_path}" unless uri_path.start_with?('/')
+        if windows?
+          plans_index = uri_path.upcase.index('/PLANS/')
+          manifests_index = uri_path.upcase.index('/MANIFESTS/')
+        else
+          plans_index = uri_path.index('/plans/')
+          manifests_index = uri_path.index('/manifests/')
+        end
+        return false if plans_index.nil?
+        return true if manifests_index.nil?
+
+        plans_index < manifests_index
+      end
+
+      # Workspace management
+      WORKSPACE_CACHE_TTL_SECONDS ||= 60
+      def initialize_store(options = {})
+        @workspace_path = options[:workspace]
+        @workspace_info_cache = {
+          expires: Time.new - 120
+        }
+      end
+
+      def expire_store_information
+        @doc_mutex.synchronize do
+          @workspace_info_cache[:expires] = Time.new - 120
+        end
+      end
+
+      def store_root_path
+        store_details[:root_path]
+      end
+
+      def store_has_module_metadata?
+        store_details[:has_metadatajson]
+      end
+
+      def store_has_environmentconf?
+        store_details[:has_environmentconf]
+      end
+
+      private
+
+      # Given a path, locate a metadata.json or environment.conf file to determine where the
+      # root of the module/control repo actually is
+      def find_root_path(path)
+        return nil if path.nil?
+
+        filepath = File.expand_path(path)
+
+        if dir_exist?(filepath)
+          directory = filepath
+        elsif file_exist?(filepath)
+          directory = File.dirname(filepath)
+        else
+          return nil
+        end
+
+        until directory.nil?
+          break if file_exist?(File.join(directory, 'metadata.json')) || file_exist?(File.join(directory, 'environment.conf'))
+
+          parent = File.dirname(directory)
+          # If the parent is the same as the original, then we've reached the end of the path chain
+          directory = if parent == directory
+                        nil
+                      else
+                        parent
+                      end
+        end
+
+        directory
+      end
+
+      def store_details
+        return @workspace_info_cache unless @workspace_info_cache[:never_expires] || @workspace_info_cache[:expires] < Time.new
+
+        # TTL has expired, time to calculate the document store details
+
+        new_cache = {
+          root_path: nil,
+          has_environmentconf: false,
+          has_metadatajson: false
+        }
+        if @workspace_path.nil?
+          # If we have never been given a local workspace path on the command line then there is really no
+          # way to know where the module file system path is.  Therefore the root_path is nil and assume that
+          # environment.conf and metadata.json does not exist. And don't bother trying to re-evaluate
+          new_cache[:never_expires] = true
+        else
+          root_path = find_root_path(@workspace_path)
+          if root_path.nil?
+            new_cache[:root_path] = @workspace_path
+          else
+            new_cache[:root_path] = root_path
+            new_cache[:has_metadatajson] = file_exist?(File.join(root_path, 'metadata.json'))
+            new_cache[:has_environmentconf] = file_exist?(File.join(root_path, 'environment.conf'))
+          end
+        end
+        new_cache[:expires] = Time.new + WORKSPACE_CACHE_TTL_SECONDS
+
+        @doc_mutex.synchronize do
+          @workspace_info_cache = new_cache
+        end
+        @workspace_info_cache
+      end
+
+      def file_exist?(path)
+        File.exist?(path) && !File.directory?(path)
+      end
+
+      def dir_exist?(path)
+        Dir.exist?(path)
+      end
+
+      def windows?
+        # Ruby only sets File::ALT_SEPARATOR on Windows and the Ruby standard
+        # library uses that to test what platform it's on.
+        !!File::ALT_SEPARATOR
+      end
+
+      # Creates a document object based on the Uri
+      def create_document(uri, content, doc_version)
+        case document_type(uri)
+        when :puppetfile
+          PuppetfileDocument.new(uri, content, doc_version)
+        when :manifest
+          ManifestDocument.new(uri, content, doc_version)
+        when :epp
+          EppDocument.new(uri, content, doc_version)
+        else
+          Document.new(uri, content, doc_version)
+        end
+      end
+    end
+  end
+end

data/lib/puppet-languageserver/session_state/language_client.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+module PuppetLanguageServer
+  module SessionState
+    class LanguageClient
+      attr_reader :message_handler, :format_on_type_filesize_limit, :folding_range, :folding_range_show_last_line, :use_puppetfile_resolver
+
+      # Client settings
+      attr_reader :format_on_type
+
+      DEFAULT_FORMAT_ON_TYPE_ENABLE = false
+      DEFAULT_FORMAT_ON_TYPE_FILESIZE_LIMIT = 4096
+      DEFAULT_FOLDING_RANGE_ENABLE = true         # Default is true as per VS Code
+      DEFAULT_FOLDING_RANGE_SHOW_LAST_LINE = true # Default is true as per VS Code
+      DEFAULT_VALIDATE_RESOLVE_PUPPETFILES = true
+
+      def initialize(message_handler)
+        @message_handler = message_handler
+        @client_capabilites = {}
+
+        # Internal registry of dynamic registrations and their current state
+        # @registrations[ <[String] method_name>] = [
+        #  {
+        #    :id         => [String] Request ID. Used for de-registration
+        #    :registered => [Boolean] true | false
+        #    :state      => [Enum] :pending | :complete
+        #   }
+        # ]
+        @registrations = {}
+
+        # Initial state. Not always the same as defaults
+        @folding_range = false
+        @folding_range_show_last_line = DEFAULT_FOLDING_RANGE_SHOW_LAST_LINE
+        @format_on_type = false
+        @format_on_type_filesize_limit = DEFAULT_FORMAT_ON_TYPE_FILESIZE_LIMIT
+        @use_puppetfile_resolver = DEFAULT_VALIDATE_RESOLVE_PUPPETFILES
+      end
+
+      def client_capability(*names)
+        safe_hash_traverse(@client_capabilites, *names)
+      end
+
+      def send_configuration_request
+        params = LSP::ConfigurationParams.new.from_h!('items' => [])
+        params.items << LSP::ConfigurationItem.new.from_h!('section' => 'puppet')
+
+        message_handler.protocol.send_client_request('workspace/configuration', params)
+        true
+      end
+
+      def parse_lsp_initialize!(initialize_params = {})
+        @client_capabilites = initialize_params['capabilities']
+      end
+
+      def parse_lsp_configuration_settings!(settings = {})
+        # format on type enabled
+        value = to_boolean(safe_hash_traverse(settings, 'puppet', 'editorService', 'formatOnType', 'enable'), DEFAULT_FORMAT_ON_TYPE_ENABLE)
+        unless value == @format_on_type # Ummm no.
+          # Is dynamic registration available?
+          if client_capability('textDocument', 'onTypeFormatting', 'dynamicRegistration') == true
+            if value
+              register_capability('textDocument/onTypeFormatting', PuppetLanguageServer::ServerCapabilites.document_on_type_formatting_options)
+            else
+              unregister_capability('textDocument/onTypeFormatting')
+            end
+          end
+          @format_on_type = value
+        end
+        # format on type file size
+        @format_on_type_filesize_limit = to_integer(safe_hash_traverse(settings, 'puppet', 'editorService', 'formatOnType', 'maxFileSize'), DEFAULT_FORMAT_ON_TYPE_FILESIZE_LIMIT, 0)
+
+        # use puppetfile resolver
+        @use_puppetfile_resolver = to_boolean(safe_hash_traverse(settings, 'puppet', 'validate', 'resolvePuppetfiles'), DEFAULT_VALIDATE_RESOLVE_PUPPETFILES)
+
+        # folding range enabled
+        value = to_boolean(safe_hash_traverse(settings, 'puppet', 'editorService', 'foldingRange', 'enable'), DEFAULT_FOLDING_RANGE_ENABLE) && PuppetLanguageServer::ServerCapabilites.folding_provider_supported?
+        unless value == @folding_range # Ummm no.
+          # Is dynamic registration available?
+          if client_capability('textDocument', 'foldingRange', 'dynamicRegistration') == true
+            if value
+              register_capability('textDocument/foldingRange', PuppetLanguageServer::ServerCapabilites.document_on_type_formatting_options)
+            else
+              unregister_capability('textDocument/foldingRange')
+            end
+          end
+          @folding_range = value
+        end
+        # folding range last line display
+        @folding_range_show_last_line = to_boolean(safe_hash_traverse(settings, 'puppet', 'editorService', 'foldingRange', 'showLastLine'), DEFAULT_FOLDING_RANGE_SHOW_LAST_LINE)
+      end
+
+      def capability_registrations(method)
+        return [{ registered: false, state: :complete }] if @registrations[method].nil? || @registrations[method].empty?
+
+        @registrations[method].dup
+      end
+
+      def register_capability(method, options = {})
+        id = new_request_id
+
+        PuppetLanguageServer.log_message(:info, "Attempting to dynamically register the #{method} method with id #{id}")
+
+        if @registrations[method] && @registrations[method].select { |i| i[:state] == :pending }.count > 0
+          # The protocol doesn't specify whether this is allowed and is probably per client specific. For the moment we will allow
+          # the registration to be sent but log a message that something may be wrong.
+          PuppetLanguageServer.log_message(:warn, "A dynamic registration/deregistration for the #{method} method is already in progress")
+        end
+
+        params = LSP::RegistrationParams.new.from_h!('registrations' => [])
+        params.registrations << LSP::Registration.new.from_h!('id' => id, 'method' => method, 'registerOptions' => options)
+        # Note - Don't put more than one method per request even though you can.  It makes decoding errors much harder!
+
+        @registrations[method] = [] if @registrations[method].nil?
+        @registrations[method] << { registered: false, state: :pending, id: id }
+
+        message_handler.protocol.send_client_request('client/registerCapability', params)
+        true
+      end
+
+      def unregister_capability(method)
+        if @registrations[method].nil?
+          PuppetLanguageServer.log_message(:debug, "No registrations to deregister for the #{method}")
+          return true
+        end
+
+        params = LSP::UnregistrationParams.new.from_h!('unregisterations' => [])
+        @registrations[method].each do |reg|
+          next if reg[:id].nil?
+
+          PuppetLanguageServer.log_message(:warn, "A dynamic registration/deregistration for the #{method} method, with id #{reg[:id]} is already in progress") if reg[:state] == :pending
+          # Ignore registrations that don't need to be unregistered
+          next if reg[:state] == :complete && !reg[:registered]
+
+          params.unregisterations << LSP::Unregistration.new.from_h!('id' => reg[:id], 'method' => method)
+          reg[:state] = :pending
+        end
+
+        if params.unregisterations.count.zero?
+          PuppetLanguageServer.log_message(:debug, "Nothing to deregister for the #{method} method")
+          return true
+        end
+
+        message_handler.protocol.send_client_request('client/unregisterCapability', params)
+        true
+      end
+
+      def parse_register_capability_response!(response, original_request)
+        raise 'Response is not from client/registerCapability request' unless original_request.rpc_method == 'client/registerCapability'
+
+        unless response.is_successful
+          original_request.params.registrations.each do |reg|
+            # Mark the registration as completed and failed
+            @registrations[reg.method__lsp] = [] if @registrations[reg.method__lsp].nil?
+            @registrations[reg.method__lsp].select { |i| i[:id] == reg.id }.each { |i| i[:registered] = false; i[:state] = :complete } # rubocop:disable Style/Semicolon This is fine
+          end
+          return true
+        end
+
+        original_request.params.registrations.each do |reg|
+          PuppetLanguageServer.log_message(:info, "Succesfully dynamically registered the #{reg.method__lsp} method")
+
+          # Mark the registration as completed and succesful
+          @registrations[reg.method__lsp] = [] if @registrations[reg.method__lsp].nil?
+          @registrations[reg.method__lsp].select { |i| i[:id] == reg.id }.each { |i| i[:registered] = true; i[:state] = :complete } # rubocop:disable Style/Semicolon This is fine
+
+          # If we just registered the workspace/didChangeConfiguration method then
+          # also trigger a configuration request to get the initial state
+          send_configuration_request if reg.method__lsp == 'workspace/didChangeConfiguration'
+        end
+
+        true
+      end
+
+      def parse_unregister_capability_response!(response, original_request)
+        raise 'Response is not from client/unregisterCapability request' unless original_request.rpc_method == 'client/unregisterCapability'
+
+        unless response.is_successful
+          original_request.params.unregisterations.each do |reg|
+            # Mark the registration as completed and failed
+            @registrations[reg.method__lsp] = [] if @registrations[reg.method__lsp].nil?
+            @registrations[reg.method__lsp].select { |i| i[:id] == reg.id && i[:registered] }.each { |i| i[:state] = :complete }
+            @registrations[reg.method__lsp].delete_if { |i| i[:id] == reg.id && !i[:registered] }
+          end
+          return true
+        end
+
+        original_request.params.unregisterations.each do |reg|
+          PuppetLanguageServer.log_message(:info, "Succesfully dynamically unregistered the #{reg.method__lsp} method")
+
+          # Remove registrations
+          @registrations[reg.method__lsp] = [] if @registrations[reg.method__lsp].nil?
+          @registrations[reg.method__lsp].delete_if { |i| i[:id] == reg.id }
+        end
+
+        true
+      end
+
+      private
+
+      def to_boolean(value, default = false)
+        return default if value.nil?
+        return value if value == true || value == false # rubocop:disable Style/MultipleComparison
+
+        value.to_s =~ %r{^(true|t|yes|y|1)$/i}
+      end
+
+      def to_integer(value, default = nil, min = nil, max = nil)
+        return default if value.nil?
+
+        begin
+          intv = Integer(value)
+          return default if !min.nil? && intv < min
+          return default if !max.nil? && intv > max
+
+          intv
+        rescue ArgumentError
+          default
+        end
+      end
+
+      def new_request_id
+        SecureRandom.uuid
+      end
+
+      def safe_hash_traverse(hash, *names)
+        return nil if names.empty? || hash.nil? || hash.empty?
+
+        item = nil
+        loop do
+          name = names.shift
+          item = item.nil? ? hash[name] : item[name]
+          return nil if item.nil?
+          return item if names.empty?
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/puppet-languageserver/session_state/object_cache.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module PuppetLanguageServer
+  module SessionState
+    class ObjectCache
+      SECTIONS = %i[class type function datatype fact].freeze
+      ORIGINS = %i[default workspace bolt].freeze
+
+      def initialize(_options = {})
+        @cache_lock = Mutex.new
+        @inmemory_cache = {}
+        # The cache consists of hash of hashes
+        # @inmemory_cache[<origin>][<section>] = [ Array of SidecarProtocol Objects ]
+      end
+
+      def import_sidecar_list!(list, section, origin)
+        return if origin.nil?
+        return if section.nil?
+
+        list = [] if list.nil?
+
+        @cache_lock.synchronize do
+          # Remove the existing items
+          remove_section_impl(section, origin)
+          # Set the list
+          @inmemory_cache[origin] = {} if @inmemory_cache[origin].nil?
+          @inmemory_cache[origin][section] = list.dup
+        end
+        nil
+      end
+
+      def remove_section!(section, origin = nil)
+        @cache_lock.synchronize do
+          remove_section_impl(section, origin)
+        end
+        nil
+      end
+
+      def remove_origin!(origin)
+        @cache_lock.synchronize do
+          @inmemory_cache[origin] = nil
+        end
+        nil
+      end
+
+      def origin_exist?(origin)
+        @cache_lock.synchronize do
+          return @inmemory_cache.key?(origin)
+        end
+      end
+
+      def section_in_origin_exist?(section, origin)
+        @cache_lock.synchronize do
+          return false if @inmemory_cache[origin].nil? || @inmemory_cache[origin].empty?
+
+          @inmemory_cache[origin].key?(section)
+        end
+      end
+
+      # section => <Type of object in the file :function, :type, :class, :datatype>
+      def object_by_name(section, name, options = {})
+        # options[:exclude_origins]
+        # options[:fuzzy_match]
+        options = {
+          exclude_origins: [],
+          fuzzy_match: false
+        }.merge(options)
+
+        name = name.intern if name.is_a?(String)
+        return nil if section.nil?
+
+        @cache_lock.synchronize do
+          @inmemory_cache.each do |origin, sections|
+            next if sections.nil? || sections[section].nil? || sections[section].empty?
+            next if options[:exclude_origins].include?(origin)
+
+            sections[section].each do |item|
+              match = options[:fuzzy_match] ? fuzzy_match?(item.key, name) : item.key == name
+              return item if match
+            end
+          end
+        end
+        nil
+      end
+
+      # Performs fuzzy text matching of Puppet Language Type names
+      #  e.g 'TargetSpec' in 'Boltlib::TargetSpec'
+      # @api private
+      def fuzzy_match?(obj, test_obj)
+        value = obj.is_a?(String) ? obj.dup : obj.to_s
+        test_string = test_obj.is_a?(String) ? test_obj.dup : test_obj.to_s
+
+        # Test for equality
+        return true if value == test_string
+
+        # Test for a shortname
+        if !test_string.start_with?('::') && value.end_with?("::#{test_string}")
+          # e.g 'TargetSpec' in 'Boltlib::TargetSpec'
+          return true
+        end
+
+        false
+      end
+
+      # section => <Type of object in the file :function, :type, :class, :datatype>
+      # options[:exclude_origins]
+      def object_names_by_section(section, options = {})
+        options = {
+          exclude_origins: []
+        }.merge(options)
+        result = []
+        return result if section.nil?
+
+        @cache_lock.synchronize do
+          @inmemory_cache.each do |origin, sections|
+            next if sections.nil? || sections[section].nil? || sections[section].empty?
+            next if options[:exclude_origins].include?(origin)
+
+            result.concat(sections[section].map { |i| i.key })
+          end
+        end
+        result.uniq!
+        result.compact
+      end
+
+      # section => <Type of object in the file :function, :type, :class, :datatype>
+      def objects_by_section(section, &_block)
+        return if section.nil?
+
+        @cache_lock.synchronize do
+          @inmemory_cache.each_value do |sections|
+            next if sections.nil? || sections[section].nil? || sections[section].empty?
+
+            sections[section].each { |i| yield i.key, i }
+          end
+        end
+      end
+
+      def all_objects(&_block)
+        @cache_lock.synchronize do
+          @inmemory_cache.each_value do |sections|
+            next if sections.nil?
+
+            sections.each_value do |list|
+              list.each { |i| yield i.key, i }
+            end
+          end
+        end
+      end
+
+      private
+
+      def remove_section_impl(section, origin = nil)
+        @inmemory_cache.each do |list_origin, sections|
+          next unless origin.nil? || list_origin == origin
+
+          sections[section].clear unless sections.nil? || sections[section].nil?
+        end
+      end
+    end
+  end
+end