Merge pull request #90 from austb/puppet5_ast

Support the Puppet 5 AST on the Language Server

Author: austb

appveyor.yml

@@ -18,6 +18,7 @@ environment:
   - PUPPET_GEM_VERSION: "~> 5.0"
     RUBY_VER: 24-x64
     RAKE_TASK: test
+
   # Ruby style
   - PUPPET_GEM_VERSION: "~> 4.0"
     RUBY_VER: 23-x64
@@ -36,10 +37,6 @@ matrix:
     - PUPPET_GEM_VERSION: "~> 4.0"
       RUBY_VER: 23-x64
       RAKE_TASK: rubocop
-    # Latest Puppet
-    - PUPPET_GEM_VERSION: "~> 5.0"
-      RUBY_VER: 24-x64
-      RAKE_TASK: test
 
 install:
 - ps: |

server/lib/puppet-languageserver/completion_provider.rb

@@ -4,9 +4,9 @@ def self.complete(content, line_num, char_num)
       items = []
       incomplete = false
 
-      item = PuppetLanguageServer::PuppetParserHelper.object_under_cursor(content, line_num, char_num, true, [Puppet::Pops::Model::QualifiedName])
+      result = PuppetLanguageServer::PuppetParserHelper.object_under_cursor(content, line_num, char_num, true, [Puppet::Pops::Model::QualifiedName])
 
-      if item.nil?
+      if result.nil?
         # We are in the root of the document.
 
         # Add keywords
@@ -22,6 +22,8 @@ def self.complete(content, line_num, char_num)
                                                      'items' => items)
       end
 
+      item = result[:model]
+
       case item.class.to_s
       when 'Puppet::Pops::Model::VariableExpression'
         expr = item.expr.value

server/lib/puppet-languageserver/hover_provider.rb

@@ -1,44 +1,44 @@
 module PuppetLanguageServer
   module HoverProvider
     def self.resolve(content, line_num, char_num)
-      item = PuppetLanguageServer::PuppetParserHelper.object_under_cursor(content, line_num, char_num, false)
-      return LanguageServer::Hover.create_nil_response if item.nil?
+      result = PuppetLanguageServer::PuppetParserHelper.object_under_cursor(content, line_num, char_num, false, [Puppet::Pops::Model::QualifiedName])
+      return LanguageServer::Hover.create_nil_response if result.nil?
+
+      path = result[:path]
+      item = result[:model]
 
       content = nil
       case item.class.to_s
       when 'Puppet::Pops::Model::ResourceExpression'
         content = get_resource_expression_content(item)
       when 'Puppet::Pops::Model::LiteralString'
-        if item.eContainer.class == Puppet::Pops::Model::AccessExpression
-          expr = item.eContainer.left_expr.expr.value
+        if path[-1].class == Puppet::Pops::Model::AccessExpression
+          expr = path[-1].left_expr.expr.value
 
-          content = get_hover_content_for_access_expression(item, expr)
-        elsif item.eContainer.class == Puppet::Pops::Model::ResourceBody
+          content = get_hover_content_for_access_expression(path, expr)
+        elsif path[-1].class == Puppet::Pops::Model::ResourceBody
           # We are hovering over the resource name
-          content = get_resource_expression_content(item.eContainer.eContainer)
+          content = get_resource_expression_content(path[-2])
         end
       when 'Puppet::Pops::Model::VariableExpression'
         expr = item.expr.value
 
-        content = get_hover_content_for_access_expression(item, expr)
-      when 'Puppet::Pops::Model::QualifiedName'
-        if !item.eContainer.nil? && item.eContainer.class.to_s == 'Puppet::Pops::Model::ResourceExpression'
-          content = get_resource_expression_content(item.eContainer)
-        elsif !item.eContainer.nil? && item.eContainer.class.to_s == 'Puppet::Pops::Model::CallNamedFunctionExpression'
-          content = get_call_named_function_expression_content(item.eContainer)
-        end
-
+        content = get_hover_content_for_access_expression(path, expr)
+      when 'Puppet::Pops::Model::CallNamedFunctionExpression'
+        content = get_call_named_function_expression_content(item)
       when 'Puppet::Pops::Model::AttributeOperation'
         # Get the parent resource class
-        parent_klass = item.eContainer
+        distance_up_ast = -1
+        parent_klass = path[distance_up_ast]
         while !parent_klass.nil? && parent_klass.class.to_s != 'Puppet::Pops::Model::ResourceBody'
-          parent_klass = parent_klass.eContainer
+          distance_up_ast -= 1
+          parent_klass = path[distance_up_ast]
         end
         raise "Unable to find suitable parent object for object of type #{item.class}" if parent_klass.nil?
 
         # Get an instance of the type
-        item_type = PuppetLanguageServer::PuppetHelper.get_type(parent_klass.eContainer.type_name.value)
-        raise "#{parent_klass.eContainer.type_name.value} is not a valid puppet type" if item_type.nil?
+        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)
         if attribute != false
@@ -58,12 +58,20 @@ def self.resolve(content, line_num, char_num)
       end
     end
 
-    def self.get_hover_content_for_access_expression(item, expr)
+    def self.get_hover_content_for_access_expression(path, expr)
       if expr == 'facts'
         # We are dealing with the facts variable
         # Just get the first part of the array and display that
-        if item.eContainer.eContents.length > 1
-          factname = item.eContainer.eContents[1].value
+        fact_array = path[-1]
+        if fact_array.respond_to? :eContents
+          fact_array_content = fact_array.eContents
+        else
+          fact_array_content = []
+          fact_array._pcore_contents { |item| fact_array_content.push item }
+        end
+
+        if fact_array_content.length > 1
+          factname = fact_array_content[1].value
           content = get_fact_content(factname)
         end
       elsif expr.start_with?('::') && expr.rindex(':') == 1

server/lib/puppet-languageserver/puppet_parser_helper.rb

@@ -120,28 +120,64 @@ def self.object_under_cursor(content, line_num, char_num, multiple_attempts = fa
       #     [0, 14, 34, 36]  means line number 2 starts at absolute offset 34
       #   Once we know the line offset, we can simply add on the char_num to get the absolute offset
       #   If during paring we modified the source we may need to change the cursor location
-      abs_offset = result.line_offsets[line_num] + char_num + move_offset
+      begin
+        line_offset = result.line_offsets[line_num]
+      rescue
+        line_offset = result['locator'].line_index[line_num]
+      end
       # Typically we're completing after something was typed, so go back one char
-      abs_offset -= 1
+      abs_offset = line_offset + char_num + move_offset - 1
 
       # Enumerate the AST looking for items that span the line/char we want.
       # Once we have all valid items, sort them by the smallest span.  Typically the smallest span
       # is the most specific object in the AST
       #
       # TODO: Should probably walk the AST and only look for the deepest child, but integer sorting
       #       is so much easier and faster.
-      valid_models = result.model.eAllContents.select do |item|
-        !item.offset.nil? && !item.length.nil? && abs_offset >= item.offset && abs_offset <= item.offset + item.length && !disallowed_classes.include?(item.class)
-      end
-      valid_models.sort! { |a, b| a.length - b.length }
+      model_path_struct = Struct.new(:model, :path)
+      valid_models = []
+      if result.model.respond_to? :eAllContents
+        valid_models = result.model.eAllContents.select do |item|
+          check_for_valid_item(item, abs_offset, disallowed_classes)
+        end
+
+        valid_models.sort! { |a, b| a.length - b.length }
+      else
+        path = []
+        result.model._pcore_all_contents(path) do |item|
+          if check_for_valid_item(item, abs_offset, disallowed_classes)
+            valid_models.push(model_path_struct.new(item, path.dup))
+          end
+        end
 
+        valid_models.sort! { |a, b| a[:model].length - b[:model].length }
+      end
       # nil means the root of the document
       return nil if valid_models.empty?
       item = valid_models[0]
 
+      if item.respond_to? :eAllContents
+        item = model_path_struct.new(item, construct_path(item))
+      end
+
       item
     end
 
+    def self.construct_path(item)
+      path = []
+      item = item.eContainer
+      while item.class != Puppet::Pops::Model::Program
+        path.unshift item
+        item = item.eContainer
+      end
+
+      path
+    end
+
+    def self.check_for_valid_item(item, abs_offset, disallowed_classes)
+      item.respond_to?(:offset) && !item.offset.nil? && !item.length.nil? && abs_offset >= item.offset && abs_offset <= item.offset + item.length && !disallowed_classes.include?(item.class)
+    end
+
     # Reference - https://github.com/puppetlabs/puppet/blob/master/spec/lib/puppet_spec/compiler.rb
     def self.compile_to_catalog(string, node = Puppet::Node.new('test'))
       Puppet[:code] = string