(GH-94) Use bolt metadata when inside plans

Previously the language server had no concept of Bolt Plan specific metadata,
e.g. Functions and DataTypes.  This commit updates the providers to optionally
query for Bolt specific (taskmode => true) metadata when gathering results.

Author: glennsarti

lib/puppet-languageserver/manifest/completion_provider.rb

@@ -24,7 +24,7 @@ def self.complete(content, line_num, char_num, options = {})
           # Add resources
           all_resources { |x| items << x }
 
-          all_functions { |x| items << x }
+          all_functions(options[:tasks_mode]) { |x| items << x }
 
           response = LSP::CompletionList.new
           response.items = items
@@ -50,6 +50,14 @@ def self.complete(content, line_num, char_num, options = {})
           # Add resources
           all_resources { |x| items << x }
 
+        when 'Puppet::Pops::Model::PlanDefinition'
+          # We are in the root of a `plan` statement
+
+          # Add resources
+          all_resources { |x| items << x }
+
+          all_functions(options[:tasks_mode]) { |x| items << x }
+
         when 'Puppet::Pops::Model::ResourceExpression'
           # We are inside a resource definition.  Should display all available
           # properities and parameters.
@@ -173,8 +181,8 @@ def self.all_resources(&block)
         end
       end
 
-      def self.all_functions(&block)
-        PuppetLanguageServer::PuppetHelper.function_names.each do |name|
+      def self.all_functions(tasks_mode, &block)
+        PuppetLanguageServer::PuppetHelper.function_names(tasks_mode).each do |name|
           item = LSP::CompletionItem.new(
             'label'  => name.to_s,
             'kind'   => LSP::CompletionItemKind::FUNCTION,
@@ -231,7 +239,8 @@ def self.resolve(completion_item)
           end
 
         when 'function'
-          item_type = PuppetLanguageServer::PuppetHelper.function(data['name'])
+          # We don't know if this resolution is coming from a plan or not, so just assume it is
+          item_type = PuppetLanguageServer::PuppetHelper.function(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?

lib/puppet-languageserver/manifest/hover_provider.rb

@@ -33,7 +33,7 @@ def self.resolve(content, line_num, char_num, options = {})
 
           content = get_hover_content_for_access_expression(path, expr)
         when 'Puppet::Pops::Model::CallNamedFunctionExpression'
-          content = get_call_named_function_expression_content(item)
+          content = get_call_named_function_expression_content(item, options[:tasks_mode])
         when 'Puppet::Pops::Model::AttributeOperation'
           # Get the parent resource class
           distance_up_ast = -1
@@ -66,7 +66,7 @@ def self.resolve(content, line_num, char_num, options = {})
           # https://github.com/puppetlabs/puppet-specifications/blob/master/language/names.md#names
           # Datatypes have to start with uppercase and can be fully qualified
           if item.cased_value =~ /^[A-Z][a-zA-Z:0-9]*$/ # rubocop:disable Style/GuardClause
-            content = get_puppet_datatype_content(item)
+            content = get_puppet_datatype_content(item, options[:tasks_mode])
           else
             raise "#{item.cased_value} is an unknown QualifiedReference"
           end
@@ -143,10 +143,10 @@ def self.get_attribute_class_parameter_content(item_class, param)
         content
       end
 
-      def self.get_call_named_function_expression_content(item)
+      def self.get_call_named_function_expression_content(item, tasks_mode)
         func_name = item.functor_expr.value
 
-        func_info = PuppetLanguageServer::PuppetHelper.function(func_name)
+        func_info = PuppetLanguageServer::PuppetHelper.function(func_name, tasks_mode)
         raise "Function #{func_name} does not exist" if func_info.nil?
 
         content = "**#{func_name}** Function"
@@ -189,8 +189,8 @@ def self.get_puppet_class_content(item_class)
       end
       private_class_method :get_puppet_class_content
 
-      def self.get_puppet_datatype_content(item)
-        dt_info = PuppetLanguageServer::PuppetHelper.datatype(item.cased_value)
+      def self.get_puppet_datatype_content(item, tasks_mode)
+        dt_info = PuppetLanguageServer::PuppetHelper.datatype(item.cased_value, tasks_mode)
         raise "DataType #{item.cased_value} does not exist" if dt_info.nil?
 
         content = "**#{item.cased_value}** Data Type"

lib/puppet-languageserver/puppet_helper.rb

@@ -160,18 +160,25 @@ def self.filtered_function_names(&block)
       result
     end
 
-    def self.function(name)
+    def self.function(name, tasks_mode = false)
       return nil if @default_functions_loaded == false
       raise('Puppet Helper Cache has not been configured') if @inmemory_cache.nil?
       load_default_functions unless @default_functions_loaded
-      @inmemory_cache.object_by_name(:function, name)
+      exclude_origins = tasks_mode ? [] : [:bolt]
+      @inmemory_cache.object_by_name(
+        :function,
+        name,
+        :fuzzy_match     => true,
+        :exclude_origins => exclude_origins
+      )
     end
 
-    def self.function_names
+    def self.function_names(tasks_mode = false)
       return [] if @default_functions_loaded == false
       raise('Puppet Helper Cache has not been configured') if @inmemory_cache.nil?
       load_default_functions if @default_functions_loaded.nil?
-      @inmemory_cache.object_names_by_section(:function).map(&:to_s)
+      exclude_origins = tasks_mode ? [] : [:bolt]
+      @inmemory_cache.object_names_by_section(:function, :exclude_origins => exclude_origins).map(&:to_s)
     end
 
     # Classes and Defined Types
@@ -229,11 +236,18 @@ def self.load_default_datatypes_async
       sidecar_queue.enqueue('default_datatypes', [])
     end
 
-    def self.datatype(name)
+    def self.datatype(name, tasks_mode = false)
       return nil if @default_datatypes_loaded == false
       raise('Puppet Helper Cache has not been configured') if @inmemory_cache.nil?
       load_default_datatypes unless @default_datatypes_loaded
-      @inmemory_cache.object_by_name(:datatype, name)
+      load_static_data if tasks_mode && !static_data_loaded?
+      exclude_origins = tasks_mode ? [] : [:bolt]
+      @inmemory_cache.object_by_name(
+        :datatype,
+        name,
+        :fuzzy_match     => true,
+        :exclude_origins => exclude_origins
+      )
     end
 
     def self.cache

lib/puppet-languageserver/puppet_helper/cache.rb

@@ -36,27 +36,60 @@ def remove_section!(section, origin = nil)
       end
 
       # section => <Type of object in the file :function, :type, :class, :datatype>
-      def object_by_name(section, name)
+      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 |_, sections|
+          @inmemory_cache.each do |origin, sections|
             next if sections[section].nil? || sections[section].empty?
+            next if options[:exclude_origins].include?(origin)
             sections[section].each do |item|
-              return item if item.key == name
+              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
+        unless test_string.start_with?('::')
+          # e.g 'TargetSpec' in 'Boltlib::TargetSpec'
+          return true if value.end_with?('::' + test_string)
+        end
+
+        false
+      end
+
       # section => <Type of object in the file :function, :type, :class, :datatype>
-      def object_names_by_section(section)
+      # 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 |_, sections|
+          @inmemory_cache.each do |origin, sections|
             next if sections[section].nil? || sections[section].empty?
+            next if options[:exclude_origins].include?(origin)
             result.concat(sections[section].map { |i| i.key })
           end
         end

spec/languageserver/integration/puppet-languageserver/manifest/completion_provider_spec.rb

@@ -4,6 +4,10 @@ def number_of_completion_item_with_type(completion_list, typename)
   (completion_list.items.select { |item| item.data['type'] == typename}).length
 end
 
+def completion_item_with_type_and_name(completion_list, typename, name)
+  completion_list.items.find { |item| item.data['type'] == typename && item.data['name'] == name }
+end
+
 def retrieve_completion_response(label, kind)
   value = @completion_response.items.find do |item|
     item.label == label && item.kind == kind
@@ -106,12 +110,20 @@ def create_ensurable_property
       let(:content) { <<-EOT
         plan mymodule::my_plan(
         ) {
+          # Needed
         }
         EOT
       }
+
       it "should not raise an error" do
         result = subject.complete(content, 0, 1, { :tasks_mode => true})
       end
+
+      it 'should suggest Bolt functions' do
+        result = subject.complete(content, 2, 1, { :tasks_mode => true})
+
+        expect(completion_item_with_type_and_name(result, 'function', 'run_task')).to_not be_nil
+      end
     end
 
     context "Given a simple valid manifest" do
@@ -147,7 +159,7 @@ class Alice {
             end
 
             expected_types.each do |typename|
-              expect(number_of_completion_item_with_type(result,typename)).to be > 0
+              expect(number_of_completion_item_with_type(result, typename)).to be > 0
             end
           end
         end
@@ -464,6 +476,21 @@ class Alice {
           expect(result.insertTextFormat).to eq(LSP::InsertTextFormat::PLAINTEXT)
         end
       end
+
+      context 'for a Bolt function (run_task)' do
+        it 'should return the documentation' do
+          @resolve_request.data['name'] = 'run_task'
+          result = subject.resolve(@resolve_request)
+          expect(result.documentation).to match(/.+/)
+        end
+
+        it 'should return plain text' do
+          @resolve_request.data['name'] = 'run_task'
+          result = subject.resolve(@resolve_request)
+          expect(result.insertText).to match(/.+/)
+          expect(result.insertTextFormat).to eq(LSP::InsertTextFormat::PLAINTEXT)
+        end
+      end
     end
 
     context 'when resolving a resource_type request' do

spec/languageserver/integration/puppet-languageserver/manifest/hover_provider_spec.rb

@@ -75,13 +75,45 @@
     context 'Given a Puppet Plan', :if => Puppet.tasks_supported? do
       let(:content) { <<-EOT
         plan mymodule::my_plan(
+          TargetSpec $webservers,
         ) {
+          $webserver_names = get_targets($webservers).map |$n| { $n.name }
         }
         EOT
       }
+
       it "should not raise an error" do
         result = subject.resolve(content, 0, 1, { :tasks_mode => true})
       end
+
+      it 'should find bolt specific data types' do
+        result = subject.resolve(content, 1, 15, { :tasks_mode => true})
+        expect(result.contents).to start_with("**TargetSpec** Data Type Alias\n")
+      end
+
+      it 'should find bolt specific functions' do
+        result = subject.resolve(content, 3, 36, { :tasks_mode => true})
+        expect(result.contents).to start_with("**get_targets** Function\n")
+      end
+    end
+
+    context 'When using Bolt specific information in a normal manifest' do
+      let(:content) { <<-EOT
+        class mymodule::my_plan(
+          TargetSpec $webservers,
+        ) {
+          $webserver_names = get_targets($webservers).map |$n| { $n.name }
+        }
+        EOT
+      }
+
+      it "should raise an error for Bolt datatypes" do
+        expect{subject.resolve(content, 1, 15, { :tasks_mode => false})}.to raise_error(RuntimeError)
+      end
+
+      it "should raise an error for Bolt functions" do
+        expect{subject.resolve(content, 3, 36, { :tasks_mode => false})}.to raise_error(RuntimeError)
+      end
     end
 
     describe 'when cursor is in the root of the document' do