puppet-editor-services 2.0.4

data/lib/puppet-languageserver-sidecar/cache/filesystem.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module PuppetLanguageServerSidecar
+  module Cache
+    class FileSystem < Base
+      attr_reader :cache_dir
+
+      def initialize(_options = {})
+        super
+        require 'digest'
+        require 'json'
+        require 'tmpdir'
+
+        @cache_dir = File.join(Dir.tmpdir, 'puppet-vscode-cache')
+        begin
+          Dir.mkdir(@cache_dir) unless Dir.exist?(@cache_dir)
+        rescue Errno::ENOENT => e
+          PuppetLanguageServerSidecar.log_message(:error, "[PuppetLanguageServerSidecar::Cache::FileSystem] An error occured while creating file cache.  Disabling cache: #{e}")
+          @cache_dir = nil
+        end
+      end
+
+      def active?
+        !@cache_dir.nil?
+      end
+
+      def load(absolute_path, section)
+        return nil unless active?
+
+        file_key = file_key(absolute_path, section)
+        cache_file = File.join(cache_dir, cache_filename(file_key))
+
+        content = read_file(cache_file)
+        return nil if content.nil?
+
+        json_obj = JSON.parse(content)
+        return nil if json_obj.nil?
+
+        # Check that this is from the same language server version
+        unless json_obj['sidecar_version'] == PuppetLanguageServerSidecar.version
+          PuppetLanguageServerSidecar.log_message(:debug, "[PuppetLanguageServerSidecar::Cache::FileSystem.load] Error loading #{absolute_path}: Expected sidecar_version version #{PuppetLanguageServerSidecar.version} but found #{json_obj['sidecar_version']}")
+          return nil
+        end
+        # Check that the source file hash matches
+        content_hash = calculate_hash(absolute_path)
+        if json_obj['file_hash'] != content_hash
+          PuppetLanguageServerSidecar.log_message(:debug, "[PuppetLanguageServerSidecar::Cache::FileSystem.load] Error loading #{absolute_path}: Expected file_hash of #{content_hash} but found #{json_obj['file_hash']}")
+          return nil
+        end
+        PuppetLanguageServerSidecar.log_message(:debug, "[PuppetLanguageServerSidecar::Cache::FileSystem.load] Loading #{absolute_path} from cache")
+
+        json_obj['data']
+      rescue RuntimeError => e
+        PuppetLanguageServerSidecar.log_message(:debug, "[PuppetLanguageServerSidecar::Cache::FileSystem.load] Error loading #{absolute_path}: #{e}")
+        raise
+      end
+
+      def save(absolute_path, section, content_string)
+        return false unless active?
+
+        file_key = file_key(absolute_path, section)
+        cache_file = File.join(cache_dir, cache_filename(file_key))
+
+        content = { 'data' => content_string }
+        # Inject metadata
+        content['sidecar_version'] = PuppetLanguageServerSidecar.version
+        content['file_hash'] = calculate_hash(absolute_path)
+        content['created'] = Time.now.utc.strftime('%FT%T')
+        content['path'] = absolute_path
+        content['section'] = section
+
+        PuppetLanguageServerSidecar.log_message(:debug, "[PuppetLanguageServerSidecar::Cache::FileSystem.save] Saving #{absolute_path} to cache")
+        save_file(cache_file, content.to_json)
+      end
+
+      def clear!
+        return unless active?
+
+        PuppetLanguageServerSidecar.log_message(:warn, '[PuppetLanguageServerSidecar::Cache::FileSystem.clear] Filesystem based cache is being cleared')
+        FileUtils.rm(Dir.glob(File.join(cache_dir, '*')), force: true)
+      end
+
+      private
+
+      def file_key(filepath, section)
+        # Strictly speaking some file systems are case sensitive but ruby/puppet throws a fit
+        # with naming if you do
+        filepath.downcase + File::SEPARATOR + section
+      end
+
+      def read_file(filepath)
+        return nil unless File.exist?(filepath)
+
+        File.binread(filepath)
+      end
+
+      def save_file(filepath, content)
+        File.binwrite(filepath, content)
+        true
+      end
+
+      def cache_filename(file_key)
+        "#{Digest::SHA256.hexdigest(file_key)}.txt"
+      end
+
+      def calculate_hash(filepath)
+        Digest::SHA256.hexdigest(read_file(filepath))
+      end
+    end
+  end
+end

data/lib/puppet-languageserver-sidecar/cache/null.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module PuppetLanguageServerSidecar
+  module Cache
+    class Null < Base
+      def initialize(options = {})
+        super
+      end
+
+      def active?
+        false
+      end
+
+      def load(*)
+        nil
+      end
+
+      def save(*)
+        true
+      end
+
+      def clear!
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module PuppetLanguageServerSidecar
+  module FacterHelper
+    def self.current_environment
+      begin
+        env = Puppet.lookup(:environments).get!(Puppet.settings[:environment])
+        return env unless env.nil?
+      rescue Puppet::Environments::EnvironmentNotFound
+        PuppetLanguageServerSidecar.log_message(:warning, "[FacterHelper::current_environment] Unable to load environment #{Puppet.settings[:environment]}")
+      rescue StandardError => e
+        PuppetLanguageServerSidecar.log_message(:warning, "[FacterHelper::current_environment] Error loading environment #{Puppet.settings[:environment]}: #{e}")
+      end
+      Puppet.lookup(:current_environment)
+    end
+
+    def self.retrieve_facts(_cache, _options = {})
+      require 'puppet/indirector/facts/facter'
+
+      PuppetLanguageServerSidecar.log_message(:debug, '[FacterHelper::retrieve_facts] Starting')
+      facts = PuppetLanguageServer::Sidecar::Protocol::FactList.new
+      begin
+        req = Puppet::Indirector::Request.new(:facts, :find, 'language_server', nil, environment: current_environment)
+        result = Puppet::Node::Facts::Facter.new.find(req)
+        result.values.each do |key, value|
+          # TODO: This isn't strictly correct e.g. fully qualified facts will look a bit odd.
+          # Consider a fact called foo.bar.baz = 'Hello'.  Even though the fact name is `foo.bar.baz`
+          # it will appear in the facts object as `facts['foo'] = { 'bar' => { 'baz' => 'Hello' }}`
+          facts << PuppetLanguageServer::Sidecar::Protocol::Fact.new.from_h!('key' => key, 'value' => value)
+        end
+      rescue StandardError => e
+        PuppetLanguageServerSidecar.log_message(:error, "[FacterHelper::_load_facts] Error loading facts #{e.message} #{e.backtrace}")
+      rescue LoadError => e
+        PuppetLanguageServerSidecar.log_message(:error, "[FacterHelper::_load_facts] Error loading facts (LoadError) #{e.message} #{e.backtrace}")
+      end
+
+      PuppetLanguageServerSidecar.log_message(:debug, "[FacterHelper::retrieve_facts] Finished loading #{facts.count} facts")
+      facts
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Puppet::Environments
+  class Directories
+    # Monkey patch the environment loader.  When it attempts to load the special sidecar
+    # environment, create a new Puppet::Node::Environment object for the workspace
+    alias original_get get
+    def get(name)
+      if name.intern == PuppetLanguageServerSidecar::PuppetHelper::SIDECAR_PUPPET_ENVIRONMENT.intern
+        env_symbol = name.intern
+        setting_values = Puppet.settings.values(env_symbol, Puppet.settings.preferred_run_mode)
+        env = Puppet::Node::Environment.create(
+          env_symbol,
+          Puppet::Node::Environment.split_path(setting_values.interpolate(:modulepath)),
+          setting_values.interpolate(:manifest),
+          setting_values.interpolate(:config_version)
+        )
+        return env
+      end
+
+      original_get(name)
+    end
+
+    # Monkey patch the environment loader.  When it attempts to load the special sidecar
+    # environment.conf file, create a new Puppet::Settings::EnvironmentConf object
+    # from the workspace.
+    alias original_get_conf get_conf
+    def get_conf(name)
+      if name.intern == PuppetLanguageServerSidecar::PuppetHelper::SIDECAR_PUPPET_ENVIRONMENT.intern
+        conf = Puppet::Settings::EnvironmentConf.load_from(PuppetLanguageServerSidecar::Workspace.root_path, @global_module_path)
+        # Unfortunately the environment.conf expects OS style delimiters which means
+        # it fails if written for windows and read on Unix and vice versa. So we just
+        # inline munge the modulepath
+        modpath = conf.get_raw_setting(:modulepath).value
+        modpath.gsub!(':', File::PATH_SEPARATOR) if File::PATH_SEPARATOR != ':'
+        modpath.gsub!(';', File::PATH_SEPARATOR) if File::PATH_SEPARATOR != ';'
+        return conf
+      end
+
+      original_get_conf(name)
+    end
+  end
+end
+
+# Monkey patch the environment.  Normally it's not possible to modify environment settings.
+# Add a method to get the underlying environment settings which can be used to modify
+# settings on the fly.
+class Puppet::Settings::EnvironmentConf
+  def get_raw_setting(setting_name)
+    section.setting(setting_name) if section
+  end
+end

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

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+require 'puppet/indirector/face'
+
+module PuppetLanguageServerSidecar
+  module PuppetHelper
+    SIDECAR_PUPPET_ENVIRONMENT = 'sidecarenvironment'
+
+    # Ignore certain data types. For more information see https://tickets.puppetlabs.com/browse/DOCUMENT-1020
+    # TypeReference - Internal to the Puppet Data Type system
+    # TypeAlias - Internal to the Puppet Data Type system
+    # Object - While useful, typically only needed when extended the type system as opposed to general use
+    # TypeSet - While useful, typically only needed when extended the type system as opposed to general use
+    IGNORE_DATATYPE_NAMES = %w[TypeReference TypeAlias Object TypeSet ObjectTypeExten Iterable AbstractTimeData TypeWithContained].freeze
+
+    # Resource Face
+    def self.get_puppet_resource(typename, title = nil)
+      result = PuppetLanguageServer::Sidecar::Protocol::PuppetClassList.new
+      resources = if title.nil?
+                    Puppet::Face[:resource, '0.0.1'].search(typename)
+                  else
+                    Puppet::Face[:resource, '0.0.1'].find("#{typename}/#{title}")
+                  end
+      return result if resources.nil?
+
+      resources = [resources] unless resources.is_a?(Array)
+      prune_resource_parameters(resources).each do |item|
+        obj = PuppetLanguageServer::Sidecar::Protocol::Resource.new
+        obj.manifest = item.to_manifest
+        result << obj
+      end
+      result
+    end
+
+    # Puppet Strings loading
+    def self.available_documentation_types
+      %I[class datatype function type]
+    end
+
+    def self.retrieve_default_data_types
+      default_types = PuppetLanguageServer::Sidecar::Protocol::PuppetDataTypeList.new
+      # There's no actual record of all available types, but we can use the Puppet::Pops::Types to implicitly get their names
+      name_list = []
+
+      Puppet::Pops::Types.constants.each do |const|
+        thing = Puppet::Pops::Types.const_get(const)
+        # Not that this is a reference to a type, not an INSTANCE of that type.
+        # So we can't do .is_a? checks. But instead look for methods on the thing
+        # that would indicate it's a Puppet Type
+        #   _pcore_type : is present on all Pops type objects
+        #   simple_name : comes from PAnyType
+        next unless thing.respond_to?(:_pcore_type) && thing.respond_to?(:simple_name)
+        # Ignore certain data types
+        next if IGNORE_DATATYPE_NAMES.include?(thing.simple_name)
+        # Don't need duplicates
+        next if name_list.include?(thing.simple_name)
+
+        name_list << thing.simple_name
+
+        obj                = PuppetLanguageServer::Sidecar::Protocol::PuppetDataType.new
+        obj.key            = thing.simple_name
+        obj.source         = nil
+        obj.calling_source = nil
+        obj.line           = nil
+        obj.doc            = "The #{thing.simple_name} core data type"
+        obj.is_type_alias  = false
+        obj.alias_of       = nil
+        # So far, no core data types have attributes
+        obj.attributes     = []
+        default_types << obj
+      end
+
+      default_types
+    end
+    private_class_method :retrieve_default_data_types
+
+    # Retrieve objects via the Puppet 4 API loaders
+    def self.retrieve_via_puppet_strings(cache, options = {})
+      PuppetLanguageServerSidecar.log_message(:debug, '[PuppetHelper::retrieve_via_puppet_strings] Starting')
+
+      object_types = options[:object_types].nil? ? available_documentation_types : options[:object_types]
+      object_types.select! { |i| available_documentation_types.include?(i) }
+
+      result = PuppetLanguageServer::Sidecar::Protocol::AggregateMetadata.new
+      return result if object_types.empty?
+
+      current_env = current_environment
+      for_agent = options[:for_agent].nil? ? true : options[:for_agent]
+      Puppet::Pops::Loaders.new(current_env, for_agent)
+
+      finder = PuppetPathFinder.new(current_env, object_types)
+      paths = finder.find(options[:root_path])
+
+      paths.each do |path|
+        file_doc = PuppetLanguageServerSidecar::PuppetStringsHelper.file_documentation(path, finder.puppet_path, cache)
+        next if file_doc.nil?
+
+        if object_types.include?(:class) # rubocop:disable Style/IfUnlessModifier   This reads better
+          file_doc.classes.each { |item| result.append!(item) }
+        end
+        if object_types.include?(:datatype) # rubocop:disable Style/IfUnlessModifier   This reads better
+          file_doc.datatypes.each { |item| result.append!(item) }
+        end
+        if object_types.include?(:function) # rubocop:disable Style/IfUnlessModifier   This reads better
+          file_doc.functions.each { |item| result.append!(item) }
+        end
+        next unless object_types.include?(:type)
+
+        file_doc.types.each do |item|
+          result.append!(item) unless name == 'whit' || name == 'component'
+          finder.temp_file.unlink if item.key == 'file' && File.exist?(finder.temp_file.path) # Remove the temp_file.rb if it exists
+        end
+      end
+
+      # Remove Puppet3 functions which have a Puppet4 function already loaded
+      if object_types.include?(:function) && !result.functions.nil?
+        pup4_functions = result.functions.select { |i| i.function_version == 4 }.map { |i| i.key }
+        result.functions.reject! { |i| i.function_version == 3 && pup4_functions.include?(i.key) }
+      end
+
+      # Add the inbuilt data types if there's no root path
+      result.concat!(retrieve_default_data_types) if object_types.include?(:datatype) && options[:root_path].nil?
+
+      result.each_list { |key, item| PuppetLanguageServerSidecar.log_message(:debug, "[PuppetHelper::retrieve_via_puppet_strings] Finished loading #{item.count} #{key}") }
+      result
+    end
+
+    # Private functions
+
+    def self.prune_resource_parameters(resources)
+      # From https://github.com/puppetlabs/puppet/blob/488661d84e54904124514ab9e4500e81b10f84d1/lib/puppet/application/resource.rb#L146-L148
+      if resources.is_a?(Array)
+        resources.map(&:prune_parameters)
+      else
+        resources.prune_parameters
+      end
+    end
+    private_class_method :prune_resource_parameters
+
+    def self.current_environment
+      begin
+        env = Puppet.lookup(:environments).get!(Puppet.settings[:environment])
+        return env unless env.nil?
+      rescue Puppet::Environments::EnvironmentNotFound
+        PuppetLanguageServerSidecar.log_message(:warning, "[PuppetHelper::current_environment] Unable to load environment #{Puppet.settings[:environment]}")
+      rescue StandardError => e
+        PuppetLanguageServerSidecar.log_message(:warning, "[PuppetHelper::current_environment] Error loading environment #{Puppet.settings[:environment]}: #{e}")
+      end
+      Puppet.lookup(:current_environment)
+    end
+    private_class_method :current_environment
+
+    # A helper class to find the paths for different kinds of things related to Puppet, for example
+    # DataType ruby files or manifests.
+    class PuppetPathFinder
+      attr_reader :object_types, :puppet_path, :temp_file
+
+      # @param puppet_env [Puppet::Node::Environment] The environment to search within
+      # @param object_types [Symbol] The types of objects that will be searched for. See available_documentation_types for the complete list
+      def initialize(puppet_env, object_types)
+        # Path to every module
+        @module_paths = puppet_env.modules.map(&:path)
+        # Path to the environment
+        @env_path = puppet_env.configuration.path_to_env
+        # Path to the puppet installation
+        @puppet_path = if puppet_env.loaders.nil? # No loaders have been created yet
+                         nil
+                       elsif puppet_env.loaders.puppet_system_loader.nil?
+                         nil
+                       elsif puppet_env.loaders.puppet_system_loader.lib_root?
+                         File.join(puppet_env.loaders.puppet_system_loader.path, '..')
+                       else
+                         puppet_env.loaders.puppet_system_loader.path
+                       end
+        # Path to the cached puppet files e.g. pluginsync
+        @vardir_path = Puppet.settings[:vardir]
+
+        @object_types = object_types
+      end
+
+      # Find all puppet related files, optionally from within a root path
+      # @param from_root_path [String] The path which files can be found within.  If nil, only the default Puppet locations are searched e.g. vardir
+      # @return [Array[String]] A list of all files that are found. This is the absolute path to the file.
+      def find(from_root_path = nil)
+        require 'tempfile'
+        paths = []
+        search_paths = @module_paths.nil? ? [] : @module_paths
+        search_paths << @env_path unless @env_path.nil?
+        search_paths << @vardir_path unless @vardir_path.nil?
+        search_paths << @puppet_path unless @puppet_path.nil?
+
+        searched_globs = []
+        search_paths.each do |search_root|
+          PuppetLanguageServerSidecar.log_message(:debug, "[PuppetPathFinder] Potential search root '#{search_root}'")
+          next if search_root.nil?
+
+          # We need absolute paths from here on in.
+          search_root = File.expand_path(search_root)
+          next unless path_in_root?(from_root_path, search_root) && Dir.exist?(search_root)
+
+          PuppetLanguageServerSidecar.log_message(:debug, "[PuppetPathFinder] Using '#{search_root}' as a directory to search")
+          # name of temp file to store the file type definitions (if any)
+          @temp_file = Tempfile.new('file.rb')
+          all_object_info.each do |object_type, paths_to_search|
+            next unless object_types.include?(object_type)
+
+            # TODO: next unless object_type is included
+            paths_to_search.each do |path_info|
+              path = File.join(search_root, path_info[:relative_dir])
+              glob = path + path_info[:glob]
+              next if searched_globs.include?(glob) # No point searching twice
+              next unless Dir.exist?(path)
+
+              searched_globs << glob
+              PuppetLanguageServerSidecar.log_message(:debug, "[PuppetPathFinder] Searching glob '#{glob}''")
+
+              Dir.glob(glob) do |filename|
+                # if filename matches file.rb or /file/<any>.rb then we need to loop through each file type definition
+                if filename.match?(%r{/type/file/.*.rb|/type/file.rb})
+                  PuppetLanguageServerSidecar.log_message(:debug, "[PuppetPathFinder] Found file type definition at '#{filename}'.")
+                  # Read each file type definition and write it to the temp file
+                  @temp_file.write(File.read(filename))
+                else
+                  paths << filename
+                end
+              end
+            end
+          end
+        end
+        #  Add the temp_file.rb to the paths array for searching (if exists)
+        if @temp_file && File.exist?(@temp_file.path)
+          paths << @temp_file.path
+          @temp_file.close
+        end
+        paths
+      end
+
+      private
+
+      # Simple text based path checking
+      # Is [path] in the [root]
+      # @param root [String] The Root path
+      # @param path [String] The path to check if it's within the root
+      # @return [Boolean]
+      def path_in_root?(root, path)
+        # Doesn't matter what the root is, if the path is nil, it's false
+        return false if path.nil?
+        # Doesn't matter what the path is, if the root is nil it's true.
+        return true if root.nil?
+        # If the path is less than root, then it has to be false
+        return false if root.length > path.length
+
+        # Is the beginning of the path, the same as the root
+        value = path.slice(0, root.length)
+        value.casecmp(root).zero?
+      end
+
+      # The metadata for all object types and where they can be found on the filesystem
+      # @return [Hash[Symbol => Hash[Symbol => String]]]
+      def all_object_info
+        {
+          class: [
+            { 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
+          ],
+          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
+          ],
+          type: [
+            { relative_dir: 'lib/puppet/type',             glob: '/{,file/}*.rb' } # Contains Puppet resource types. Resource types like `file` can live in subdirs, hence the glob
+          ]
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+# Inject the workspace libdir on the fly
+require 'puppet/util/autoload'
+module Puppet
+  module Util
+    class Autoload
+      class << self
+        alias original_module_directories module_directories
+        def module_directories(env)
+          result = original_module_directories(env)
+          return result unless PuppetLanguageServerSidecar::Workspace.has_module_metadata?
+
+          workspace_lib = File.join(PuppetLanguageServerSidecar::Workspace.root_path, 'lib')
+          return result unless FileTest.directory?(workspace_lib)
+
+          result << workspace_lib
+
+          result
+        end
+      end
+    end
+  end
+end
+
+# Monkey patch the module loader and inject a workspace module
+# into the modules memoization variable
+require 'puppet/node/environment'
+class Puppet::Node::Environment
+  alias original_modules modules
+  alias original_modules_by_path modules_by_path
+
+  # The Puppet::Util::Json class doesn't exist in all puppet version.  Instead
+  # just vendor the code here as it's a simple JSON loader only for metadata.json.
+  # https://github.com/puppetlabs/puppet/blob/5.5.0/lib/puppet/util/json.rb#L32-L49
+  def workspace_load_json(string, options = {})
+    if defined? MultiJson
+      begin
+        MultiJson.load(string, options)
+      rescue MultiJson::ParseError => e
+        raise Puppet::Util::Json::ParseError.build(e, string)
+      end
+    else
+      begin
+        string = string.read if string.respond_to?(:read)
+
+        options[:symbolize_names] = true if options.delete(:symbolize_keys)
+        ::JSON.parse(string, options)
+      rescue JSON::ParserError => e
+        raise Puppet::Util::Json::ParseError.build(e, string)
+      end
+    end
+  end
+
+  def create_workspace_module_object(path)
+    # Read the metadata to find the actual module name
+    md_file = File.join(PuppetLanguageServerSidecar::Workspace.root_path, 'metadata.json')
+    begin
+      metadata = workspace_load_json(File.read(md_file, encoding: 'utf-8'))
+      return nil if metadata['name'].nil?
+
+      # Extract the actual module name
+      if Puppet::Module.is_module_directory_name?(metadata['name'])
+        module_name = metadata['name']
+      elsif Puppet::Module.is_module_namespaced_name?(metadata['name'])
+        # Based on regex at https://github.com/puppetlabs/puppet/blob/f5ca8c05174c944f783cfd0b18582e2160b77d0e/lib/puppet/module.rb#L54
+        result = /^[a-zA-Z0-9]+-([a-z][a-z0-9_]*)$/.match(metadata['name'])
+        module_name = result[1]
+      else
+        # TODO: This is an invalid puppet module name in the metadata.json.  Should we log an error/warning?
+        return nil
+      end
+
+      # The Puppet::Module initializer was changed in
+      # https://github.com/puppetlabs/puppet/commit/935c0311dbaf1df03937822525c36b26de5390ef
+      # We need to switch the creation based on whether the modules_strict_semver? method is available
+      return Puppet::Module.new(module_name, path, self, modules_strict_semver?) if respond_to?(:modules_strict_semver?)
+
+      Puppet::Module.new(module_name, path, self)
+    rescue StandardError
+      nil
+    end
+  end
+
+  def modules
+    if @modules.nil?
+      original_modules
+      if PuppetLanguageServerSidecar::Workspace.has_module_metadata?
+        workspace_module = create_workspace_module_object(PuppetLanguageServerSidecar::Workspace.root_path)
+        @modules << workspace_module unless workspace_module.nil?
+      end
+
+      @modules
+    else
+      original_modules
+    end
+  end
+
+  def modules_by_path
+    result = original_modules_by_path
+
+    result.keys.each do |key|
+      if key == PuppetLanguageServerSidecar::Workspace.root_path && PuppetLanguageServerSidecar::Workspace.has_module_metadata?
+        workspace_module = create_workspace_module_object(key)
+        result[key] = workspace_module.nil? ? [] : [workspace_module]
+      end
+    end
+
+    result
+  end
+end
+
+# Inject the workspace as a module in all modulepaths
+require 'puppet/settings/environment_conf'
+class Puppet::Settings::EnvironmentConf
+  alias original_modulepath modulepath
+
+  def modulepath
+    result = original_modulepath
+
+    if PuppetLanguageServerSidecar::Workspace.has_module_metadata? # rubocop:disable Style/IfUnlessModifier  Nicer to read like this
+      result = result + File::PATH_SEPARATOR + PuppetLanguageServerSidecar::Workspace.root_path
+    end
+
+    result
+  end
+end
+
+# Inject the workspace into the facter search paths
+require 'puppet/indirector/facts/facter'
+class Puppet::Node::Facts::Facter
+  class << self
+    alias original_setup_search_paths setup_search_paths
+    def setup_search_paths(request)
+      result = original_setup_search_paths(request)
+      return result unless PuppetLanguageServerSidecar::Workspace.has_module_metadata?
+
+      additional_dirs = %w[lib plugins].map { |path| File.join(PuppetLanguageServerSidecar::Workspace.root_path, path, 'facter') }
+                                       .select { |path| FileTest.directory?(path) }
+
+      return result if additional_dirs.empty?
+
+      Facter.search(*additional_dirs)
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# MUST BE LAST!!!!!!
+# Suppress any warning messages to STDOUT.  It can pollute stdout when running in STDIO mode
+Puppet::Util::Log.newdesttype :null_logger do
+  def handle(msg)
+    PuppetLanguageServerSidecar.log_message(:debug, "[PUPPET LOG] [#{msg.level}] #{msg.message}")
+  end
+end