(GH-236) Implement a fake object layer for Puppet assets

Previously the Language Server would query Puppet directly for lists of objects
such as types or functions.  However this meant for simple query operations the
entire object had to be parsed and loaded.  his commit introduces an object
system that can be populated from Puppet and then be consumed by the Language
Server (faux_objects.rb).

Author: glennsarti

server/lib/puppet-languageserver/completion_provider.rb

@@ -44,29 +44,26 @@ def self.complete(content, line_num, char_num)
         # We are inside a resource definition.  Should display all available
         # properities and parameters.
 
-        # TODO: Should really cache all of the resources and params/props for quick
-        # searching and then only actually instatiate when needed.  For the moment,
-        # instantiate all the things!
-
-        item_type = Puppet::Type.type(item.type_name.value)
+        item_type = PuppetLanguageServer::PuppetHelper.get_type(item.type_name.value)
         # Add Parameters
-        item_type.parameters.each do |param|
-          items << LanguageServer::CompletionItem.create('label'  => param.to_s,
+        item_type.parameters.each_key do |name|
+          items << LanguageServer::CompletionItem.create('label'  => name.to_s,
                                                          'kind'   => LanguageServer::COMPLETIONITEMKIND_PROPERTY,
                                                          'detail' => 'Parameter',
                                                          'data'   => { 'type' => 'resource_parameter',
-                                                                       'param' => param.to_s,
+                                                                       'param' => name.to_s,
                                                                        'resource_type' => item.type_name.value })
         end
         # Add Properties
-        item_type.properties.each do |prop|
-          items << LanguageServer::CompletionItem.create('label'  => prop.name.to_s,
+        item_type.properties.each_key do |name|
+          items << LanguageServer::CompletionItem.create('label'  => name.to_s,
                                                          'kind'   => LanguageServer::COMPLETIONITEMKIND_PROPERTY,
                                                          'detail' => 'Property',
                                                          'data'   => { 'type' => 'resource_property',
-                                                                       'prop' => prop.name.to_s,
+                                                                       'prop' => name.to_s,
                                                                        'resource_type' => item.type_name.value })
         end
+        # TODO: What about meta parameters?
       end
 
       LanguageServer::CompletionList.create('isIncomplete' => incomplete,
@@ -110,12 +107,12 @@ def self.all_resources(&block)
 
     def self.all_statement_functions(&block)
       # Find functions which don't return values i.e. statements
-      PuppetLanguageServer::PuppetHelper.functions.select { |_key, obj| obj[:type] == :statement }.each_key do |key|
-        item = LanguageServer::CompletionItem.create('label' => key.to_s,
+      PuppetLanguageServer::PuppetHelper.filtered_function_names { |_name, data| data.type == :statement }.each do |name|
+        item = LanguageServer::CompletionItem.create('label' => name.to_s,
                                                      'kind'   => LanguageServer::COMPLETIONITEMKIND_FUNCTION,
                                                      'detail' => 'Function',
                                                      'data'   => { 'type' => 'function',
-                                                                   'name' => key.to_s })
+                                                                   'name' => name.to_s })
         block.call(item) if block
       end
     end
@@ -162,32 +159,36 @@ def self.resolve(completion_item)
 
       when 'function'
         item_type = PuppetLanguageServer::PuppetHelper.function(data['name'])
-        completion_item['documentation'] = item_type[:doc] unless item_type[:doc].nil?
+        completion_item['documentation'] = item_type.doc unless item_type.doc.nil?
         completion_item['insertText'] = "#{data['name']}(${1:value}"
-        (2..item_type[:arity]).each do |index|
+        (2..item_type.arity).each do |index|
           completion_item['insertText'] += ", ${#{index}:value}"
         end
         completion_item['insertText'] += ')'
         completion_item['insertTextFormat'] = LanguageServer::INSERTTEXTFORMAT_SNIPPET
 
       when 'resource_type'
-        item_type = Puppet::Type.type(data['name'])
+        item_type = PuppetLanguageServer::PuppetHelper.get_type(data['name'])
         # TODO: More things?
         completion_item['documentation'] = item_type.doc unless item_type.doc.nil?
         completion_item['insertText'] = "#{data['name']} { '${1:title}':\n\tensure => '${2:present}'\n}"
         completion_item['insertTextFormat'] = LanguageServer::INSERTTEXTFORMAT_SNIPPET
       when 'resource_parameter'
-        item_type = Puppet::Type.type(data['resource_type'])
-        param_type = item_type.attrclass(data['param'].intern)
-        # TODO: More things?
-        completion_item['documentation'] = param_type.doc unless param_type.doc.nil?
-        completion_item['insertText'] = "#{data['param']} => "
+        item_type = PuppetLanguageServer::PuppetHelper.get_type(data['resource_type'])
+        param_type = item_type.parameters[data['param'].intern]
+        unless param_type.nil?
+          # TODO: More things?
+          completion_item['documentation'] = param_type[:doc] unless param_type[:doc].nil?
+          completion_item['insertText'] = "#{data['param']} => "
+        end
       when 'resource_property'
-        item_type = Puppet::Type.type(data['resource_type'])
-        prop_type = item_type.attrclass(data['prop'].intern)
-        # TODO: More things?
-        completion_item['documentation'] = prop_type.doc unless prop_type.doc.nil?
-        completion_item['insertText'] = "#{data['prop']} => "
+        item_type = PuppetLanguageServer::PuppetHelper.get_type(data['resource_type'])
+        prop_type = item_type.properties[data['prop'].intern]
+        unless prop_type.nil?
+          # TODO: More things?
+          completion_item['documentation'] = prop_type[:doc] unless prop_type[:doc].nil?
+          completion_item['insertText'] = "#{data['prop']} => "
+        end
       end
 
       LanguageServer::CompletionItem.create(completion_item)

server/lib/puppet-languageserver/definition_provider.rb

@@ -65,14 +65,14 @@ def self.find_definition(content, line_num, char_num)
     def self.type_or_class(resource_name)
       # Strip the leading double-colons for root resource names
       resource_name = resource_name.slice(2, resource_name.length - 2) if resource_name.start_with?('::')
-      location = PuppetLanguageServer::PuppetHelper.type_load_info(resource_name)
-      location = PuppetLanguageServer::PuppetHelper.class_load_info(resource_name) if location.nil?
-      unless location.nil?
+      item = PuppetLanguageServer::PuppetHelper.get_type(resource_name)
+      item = PuppetLanguageServer::PuppetHelper.get_class(resource_name) if item.nil?
+      unless item.nil?
         return LanguageServer::Location.create(
-          'uri' => 'file:///' + location['source'],
-          'fromline' => location['line'],
+          'uri' => 'file:///' + item.source,
+          'fromline' => item.line,
           'fromchar' => 0,
-          'toline' => location['line'],
+          'toline' => item.line,
           'tochar' => 1024
         )
       end
@@ -81,17 +81,15 @@ def self.type_or_class(resource_name)
     private_class_method :type_or_class
 
     def self.function_name(func_name)
-      location = PuppetLanguageServer::PuppetHelper.function_load_info(func_name)
-      unless location.nil?
-        return LanguageServer::Location.create(
-          'uri' => 'file:///' + location['source'],
-          'fromline' => location['line'],
-          'fromchar' => 0,
-          'toline' => location['line'],
-          'tochar' => 1024
-        )
-      end
-      nil
+      item = PuppetLanguageServer::PuppetHelper.function(func_name)
+      return nil if item.nil? || item.source.nil? || item.line.nil?
+      LanguageServer::Location.create(
+        'uri' => 'file:///' + item.source,
+        'fromline' => item.line,
+        'fromchar' => 0,
+        'toline' => item.line,
+        'tochar' => 1024
+      )
     end
     private_class_method :function_name
   end

server/lib/puppet-languageserver/hover_provider.rb

@@ -40,10 +40,10 @@ def self.resolve(content, line_num, char_num)
         item_type = PuppetLanguageServer::PuppetHelper.get_type(path[distance_up_ast - 1].type_name.value)
         raise "#{path[distance_up_ast - 1].type_name.value} is not a valid puppet type" if item_type.nil?
         # Check if it's a property
-        attribute = item_type.validproperty?(item.attribute_name)
+        attribute = item_type.properties.keys.include?(item.attribute_name.intern)
         if attribute != false
           content = get_attribute_property_content(item_type, item.attribute_name.intern)
-        elsif item_type.validparameter?(item.attribute_name.intern)
+        elsif item_type.parameters.keys.include?(item.attribute_name.intern)
           content = get_attribute_parameter_content(item_type, item.attribute_name.intern)
         end
 
@@ -102,17 +102,17 @@ def self.get_fact_content(factname)
     end
 
     def self.get_attribute_parameter_content(item_type, param)
-      param_type = item_type.attrclass(param)
+      param_type = item_type.parameters[param]
       content = "**#{param}** Parameter"
-      content += "\n\n#{param_type.doc}" unless param_type.doc.nil?
+      content += "\n\n#{param_type[:doc]}" unless param_type[:doc].nil?
       content
     end
 
     def self.get_attribute_property_content(item_type, property)
-      prop_type = item_type.attrclass(property)
+      prop_type = item_type.properties[property]
       content = "**#{property}** Property"
-      content += "\n\n(_required_)" if prop_type.required?
-      content += "\n\n#{prop_type.doc}" unless prop_type.doc.nil?
+      content += "\n\n(_required_)" if prop_type[:required?]
+      content += "\n\n#{prop_type[:doc]}" unless prop_type[:doc].nil?
       content
     end
 
@@ -124,7 +124,7 @@ def self.get_call_named_function_expression_content(item)
 
       # TODO: what about rvalue?
       content = "**#{func_name}** Function\n\n" # TODO: Do I add in the params from the arity number?
-      content += func_info[:doc]
+      content += func_info.doc
 
       content
     end