puppet-strings 2.8.0 → 3.0.0

data/lib/puppet-strings/yard/handlers/ruby/function_handler.rb

@@ -8,18 +8,18 @@ require 'puppet-strings/yard/util'
 # Implements the handler for Puppet functions written in Ruby.
 class PuppetStrings::Yard::Handlers::Ruby::FunctionHandler < PuppetStrings::Yard::Handlers::Ruby::Base
   # Represents the list of Puppet 4.x function API methods to support.
-  DISPATCH_METHOD_NAMES = %w(
-    param
-    required_param
-    optional_param
-    repeated_param
-    optional_repeated_param
-    required_repeated_param
-    block_param
-    required_block_param
-    optional_block_param
-    return_type
-  ).freeze
+  DISPATCH_METHOD_NAMES = [
+    'param',
+    'required_param',
+    'optional_param',
+    'repeated_param',
+    'optional_repeated_param',
+    'required_repeated_param',
+    'block_param',
+    'required_block_param',
+    'optional_block_param',
+    'return_type',
+  ].freeze
 
   namespace_only
   handles method_call(:create_function)
@@ -33,13 +33,13 @@ class PuppetStrings::Yard::Handlers::Ruby::FunctionHandler < PuppetStrings::Yard
     return unless statement.count > 1
 
     module_name = statement[0].source
-    return unless module_name == 'Puppet::Functions' || module_name == 'Puppet::Parser::Functions' || module_name == 'newfunction'
+    return unless ['Puppet::Functions', 'Puppet::Parser::Functions', 'newfunction'].include?(module_name)
 
     # Create and register the function object
-    is_3x = module_name == 'Puppet::Parser::Functions' || module_name == 'newfunction'
+    is_3x = ['Puppet::Parser::Functions', 'newfunction'].include?(module_name)
     object = PuppetStrings::Yard::CodeObjects::Function.new(
       get_name(statement, 'Puppet::Functions.create_function'),
-      is_3x ? PuppetStrings::Yard::CodeObjects::Function::RUBY_3X : PuppetStrings::Yard::CodeObjects::Function::RUBY_4X
+      is_3x ? PuppetStrings::Yard::CodeObjects::Function::RUBY_3X : PuppetStrings::Yard::CodeObjects::Function::RUBY_4X,
     )
     object.source = statement
     register object
@@ -56,7 +56,7 @@ class PuppetStrings::Yard::Handlers::Ruby::FunctionHandler < PuppetStrings::Yard
       end
 
       # Populate the parameters and the return tag
-      object.parameters = object.tags(:param).map{ |p| [p.name, nil] }
+      object.parameters = object.tags(:param).map { |p| [p.name, nil] }
       add_return_tag(object, statement.file, statement.line)
     else
       # For 4x, auto generate tags based on dispatch docstrings
@@ -71,11 +71,27 @@ class PuppetStrings::Yard::Handlers::Ruby::FunctionHandler < PuppetStrings::Yard
   end
 
   private
+
   def add_tags(object)
     log.warn "Missing documentation for Puppet function '#{object.name}' at #{statement.file}:#{statement.line}." if object.docstring.empty? && object.tags.empty?
-    log.warn "The docstring for Puppet 4.x function '#{object.name}' contains @param tags near #{object.file}:#{object.line}: parameter documentation should be made on the dispatch call." unless object.tags(:param).empty?
-    log.warn "The docstring for Puppet 4.x function '#{object.name}' contains @return tags near #{object.file}:#{object.line}: return value documentation should be made on the dispatch call." unless object.tags(:return).empty?
-    log.warn "The docstring for Puppet 4.x function '#{object.name}' contains @overload tags near #{object.file}:#{object.line}: overload tags are automatically generated from the dispatch calls." unless object.tags(:overload).empty?
+
+    unless object.tags(:param).empty?
+      log.warn "The docstring for Puppet 4.x function '#{object.name}' "\
+        "contains @param tags near #{object.file}:#{object.line}: parameter "\
+        'documentation should be made on the dispatch call.'
+    end
+
+    unless object.tags(:return).empty?
+      log.warn "The docstring for Puppet 4.x function '#{object.name}' "\
+      "contains @return tags near #{object.file}:#{object.line}: return "\
+      'value documentation should be made on the dispatch call.'
+    end
+
+    unless object.tags(:overload).empty?
+      log.warn "The docstring for Puppet 4.x function '#{object.name}' "\
+      "contains @overload tags near #{object.file}:#{object.line}: overload "\
+      'tags are automatically generated from the dispatch calls.'
+    end
 
     # Delete any existing param/return/overload tags
     object.docstring.delete_tags(:param)
@@ -106,12 +122,11 @@ class PuppetStrings::Yard::Handlers::Ruby::FunctionHandler < PuppetStrings::Yard
     end
 
     # If there's only one overload, move the tags to the object itself
-    if overloads.count == 1
-      overload = overloads.first
-      object.parameters = overload.parameters
-      object.add_tag(*overload.tags)
-      object.docstring.delete_tags(:overload)
-    end
+    return unless overloads.length == 1
+    overload = overloads.first
+    object.parameters = overload.parameters
+    object.add_tag(*overload.tags)
+    object.docstring.delete_tags(:overload)
   end
 
   def add_overload_tag(object, node)
@@ -169,7 +184,7 @@ class PuppetStrings::Yard::Handlers::Ruby::FunctionHandler < PuppetStrings::Yard
         node_as_string(parameters[0]),
         nil, # TODO: determine default from corresponding Ruby method signature?
         method_name.include?('optional'),
-        method_name.include?('repeated')
+        method_name.include?('repeated'),
       )
     end
 
@@ -200,7 +215,7 @@ class PuppetStrings::Yard::Handlers::Ruby::FunctionHandler < PuppetStrings::Yard
           nil, # TODO: determine default from corresponding Ruby method signature?
           block.method_name.source.include?('optional'),
           false, # Not repeated
-          true   # Is block
+          true, # Is block
         )
       end
     end
@@ -223,29 +238,29 @@ class PuppetStrings::Yard::Handlers::Ruby::FunctionHandler < PuppetStrings::Yard
     # Populate the required parameters
     params = parameters.unnamed_required_params
     params&.each do |parameter|
-        add_param_tag(
-          overload_tag,
-          param_tags,
-          parameter.source,
-          parameter.file,
-          parameter.line
-        )
-      end
+      add_param_tag(
+        overload_tag,
+        param_tags,
+        parameter.source,
+        parameter.file,
+        parameter.line,
+      )
+    end
 
     # Populate the optional parameters
     params = parameters.unnamed_optional_params
     params&.each do |parameter|
-        add_param_tag(
-          overload_tag,
-          param_tags,
-          parameter[0].source,
-          parameter.file,
-          parameter.line,
-          nil,
-          parameter[1].source,
-          true
-        )
-      end
+      add_param_tag(
+        overload_tag,
+        param_tags,
+        parameter[0].source,
+        parameter.file,
+        parameter.line,
+        nil,
+        parameter[1].source,
+        true,
+      )
+    end
 
     # Populate the splat parameter
     param = parameters.splat_param
@@ -259,7 +274,7 @@ class PuppetStrings::Yard::Handlers::Ruby::FunctionHandler < PuppetStrings::Yard
         nil,
         nil,
         false,
-        true
+        true,
       )
     end
 
@@ -276,7 +291,7 @@ class PuppetStrings::Yard::Handlers::Ruby::FunctionHandler < PuppetStrings::Yard
         nil,
         false,
         false,
-        true
+        true,
       )
     end
 
@@ -290,9 +305,14 @@ class PuppetStrings::Yard::Handlers::Ruby::FunctionHandler < PuppetStrings::Yard
   end
 
   def add_param_tag(object, tags, name, file, line, type = nil, default = nil, optional = false, repeated = false, block = false)
-    tag = tags.find { |tag| tag.name == name } if tags
+    tag = tags.find { |t| t.name == name } if tags
     log.warn "Missing @param tag for parameter '#{name}' near #{file}:#{line}." unless tag || object.docstring.all.empty?
-    log.warn "The @param tag for parameter '#{name}' should not contain a type specification near #{file}:#{line}: ignoring in favor of dispatch type information." if type && tag && tag.types && !tag.types.empty?
+
+    if type && tag && tag.types && !tag.types.empty?
+      log.warn "The @param tag for parameter '#{name}' should not contain a "\
+        "type specification near #{file}:#{line}: ignoring in favor of "\
+        'dispatch type information.'
+    end
 
     if repeated
       name = '*' + name

data/lib/puppet-strings/yard/handlers/ruby/provider_handler.rb

@@ -44,6 +44,7 @@ class PuppetStrings::Yard::Handlers::Ruby::ProviderHandler < PuppetStrings::Yard
   end
 
   private
+
   def register_provider_docstring(object)
     # Walk the tree searching for assignments or calls to desc/doc=
     statement.traverse do |child|
@@ -93,7 +94,7 @@ class PuppetStrings::Yard::Handlers::Ruby::ProviderHandler < PuppetStrings::Yard
 
           object.add_confine(node_as_string(kvp[0]) || kvp[0].source, node_as_string(kvp[1]) || kvp[1].source)
         end
-      elsif method_name == 'has_feature' || method_name == 'has_features'
+      elsif ['has_feature', 'has_features'].include?(method_name)
         # Add the features to the object
         parameters.each do |parameter|
           object.add_feature(node_as_string(parameter) || parameter.source)

data/lib/puppet-strings/yard/handlers/ruby/rsapi_handler.rb

@@ -52,11 +52,15 @@ class PuppetStrings::Yard::Handlers::Ruby::RsapiHandler < PuppetStrings::Yard::H
 
   # check that the params of the register_type call are key/value pairs.
   def kv_arg_list?(params)
-    params.type == :list && params.children.count > 0 && params.children.first.type == :list && params.children.first.children.count > 0 && statement.parameters.children.first.children.first.type == :assoc
+    params.type == :list &&
+      params.children.count > 0 &&
+      params.children.first.type == :list &&
+      params.children.first.children.count > 0 &&
+      statement.parameters.children.first.children.first.type == :assoc
   end
 
   def extract_schema
-    raise_parse_error("Expected list of key/value pairs as argument") unless kv_arg_list?(statement.parameters)
+    raise_parse_error('Expected list of key/value pairs as argument') unless kv_arg_list?(statement.parameters)
     hash_from_node(statement.parameters.children.first)
   end
 
@@ -84,7 +88,7 @@ class PuppetStrings::Yard::Handlers::Ruby::RsapiHandler < PuppetStrings::Yard::H
   def array_from_node(node)
     return nil unless node
 
-    arr = node.children.collect do |assoc|
+    node.children.map do |assoc|
       value_from_node(assoc.children[0])
     end
   end
@@ -94,7 +98,7 @@ class PuppetStrings::Yard::Handlers::Ruby::RsapiHandler < PuppetStrings::Yard::H
 
     # puts "hash from #{node.inspect}"
 
-    kv_pairs = node.children.collect do |assoc|
+    kv_pairs = node.children.map do |assoc|
       [value_from_node(assoc.children[0]), value_from_node(assoc.children[1])]
     end
     Hash[kv_pairs]
@@ -107,20 +111,19 @@ class PuppetStrings::Yard::Handlers::Ruby::RsapiHandler < PuppetStrings::Yard::H
 
     if node.children.first.type == :kw
       case node.children.first.source
-      when "false"
+      when 'false'
         return false
-      when "true"
+      when 'true'
         return true
-      when "nil"
+      when 'nil'
         return nil
       else
         raise_parse_error("unexpected keyword '#{node.children.first.source}'")
       end
     end
-    raise_parse_error("unexpected variable")
+    raise_parse_error('unexpected variable')
   end
 
-
   def populate_type_data(object, schema)
     return if schema['attributes'].nil?
 

data/lib/puppet-strings/yard/handlers/ruby/type_base.rb

@@ -2,17 +2,19 @@
 
 require 'puppet-strings/yard/handlers/ruby/base'
 
+# Base class for all Puppet resource type handlers.
 class PuppetStrings::Yard::Handlers::Ruby::TypeBase < PuppetStrings::Yard::Handlers::Ruby::Base
   protected
+
   def get_type_yard_object(name)
-    #Have to guess the path - if we create the object to get the true path from the code,
-    #it also shows up in the .at call - self registering?
+    # Have to guess the path - if we create the object to get the true path from the code,
+    # it also shows up in the .at call - self registering?
     guess_path = "puppet_types::#{name}"
     object = YARD::Registry.at(guess_path)
 
     return object unless object.nil?
 
-    #Didn't find, create instead
+    # Didn't find, create instead
     object = PuppetStrings::Yard::CodeObjects::Type.new(name)
     register object
     object
@@ -32,8 +34,8 @@ class PuppetStrings::Yard::Handlers::Ruby::TypeBase < PuppetStrings::Yard::Handl
       elsif child.is_a?(YARD::Parser::Ruby::MethodCallNode)
         # Look for a call to a dispatch method with a block
         next unless child.method_name &&
-                (child.method_name.source == 'desc' || child.method_name.source == 'doc=') &&
-                child.parameters(false).count == 1
+                    (child.method_name.source == 'desc' || child.method_name.source == 'doc=') &&
+                    child.parameters(false).count == 1
 
         docstring = node_as_string(child.parameters[0])
         log.error "Failed to parse docstring for #{kind} near #{child.file}:#{child.line}." and return nil unless docstring
@@ -100,27 +102,25 @@ class PuppetStrings::Yard::Handlers::Ruby::TypeBase < PuppetStrings::Yard::Handl
     parameters = node.parameters(false)
 
     if parameters.count >= 2
-      kvps = parameters[1].find_all { |kvp| kvp.count == 2 }
+      kvps = parameters[1].select { |kvp| kvp.count == 2 }
       required_features_kvp = kvps.find { |kvp| node_as_string(kvp[0]) == 'required_features' }
       object.required_features = node_as_string(required_features_kvp[1]) unless required_features_kvp.nil?
     end
 
-    if object.is_a? PuppetStrings::Yard::CodeObjects::Type::Parameter
-      # Process the options for parameter base types
-      if parameters.count >= 2
-        parameters[1].each do |kvp|
-          next unless kvp.count == 2
-          next unless node_as_string(kvp[0]) == 'parent'
-
-          if kvp[1].source == 'Puppet::Parameter::Boolean'
-            object.add('true') unless object.values.include? 'true' # rubocop:disable Performance/InefficientHashSearch Not supported on Ruby 2.1
-            object.add('false') unless object.values.include? 'false' # rubocop:disable Performance/InefficientHashSearch Not supported on Ruby 2.1
-            object.add('yes') unless object.values.include? 'yes' # rubocop:disable Performance/InefficientHashSearch Not supported on Ruby 2.1
-            object.add('no') unless object.values.include? 'no' # rubocop:disable Performance/InefficientHashSearch Not supported on Ruby 2.1
-          end
-          break
-        end
+    return unless object.is_a? PuppetStrings::Yard::CodeObjects::Type::Parameter
+    # Process the options for parameter base types
+    return unless parameters.count >= 2
+    parameters[1].each do |kvp|
+      next unless kvp.count == 2
+      next unless node_as_string(kvp[0]) == 'parent'
+
+      if kvp[1].source == 'Puppet::Parameter::Boolean'
+        object.add('true') unless object.values.include? 'true'
+        object.add('false') unless object.values.include? 'false'
+        object.add('yes') unless object.values.include? 'yes'
+        object.add('no') unless object.values.include? 'no'
       end
+      break
     end
   end
 
@@ -129,15 +129,15 @@ class PuppetStrings::Yard::Handlers::Ruby::TypeBase < PuppetStrings::Yard::Handl
 
     default = nil
     object.properties&.each do |property|
-        return nil if property.isnamevar
+      return nil if property.isnamevar
 
-        default = property if property.name == 'name'
-      end
+      default = property if property.name == 'name'
+    end
     object.parameters&.each do |parameter|
-        return nil if parameter.isnamevar
+      return nil if parameter.isnamevar
 
-        default ||= parameter if parameter.name == 'name'
-      end
+      default ||= parameter if parameter.name == 'name'
+    end
     default.isnamevar = true if default
   end
 end

data/lib/puppet-strings/yard/handlers/ruby/type_extras_handler.rb

@@ -16,7 +16,6 @@ class PuppetStrings::Yard::Handlers::Ruby::TypeExtrasHandler < PuppetStrings::Ya
   handles method_call(:ensurable)
 
   process do
-
     # Our entry point is a type newproperty/newparam compound statement like this:
     #  "Puppet::Type.type(:file).newparam(:content) do"
     # We want to
@@ -36,7 +35,7 @@ class PuppetStrings::Yard::Handlers::Ruby::TypeExtrasHandler < PuppetStrings::Ya
     return unless (statement.count > 1) && (statement[0].children.count > 2)
 
     module_name = statement[0].children[0].source
-    method1_name = statement[0].children.drop(1).find{ |c| c.type == :ident }.source
+    method1_name = statement[0].children.drop(1).find { |c| c.type == :ident }.source
     return unless ['Type', 'Puppet::Type'].include?(module_name) && method1_name == 'type'
 
     # ensurable is syntatic sugar for newproperty
@@ -52,7 +51,7 @@ class PuppetStrings::Yard::Handlers::Ruby::TypeExtrasHandler < PuppetStrings::Ya
     typeobject = get_type_yard_object(typename)
 
     # node - what should it be here?
-    node = statement #?? not sure... test...
+    node = statement # ?? not sure... test...
 
     if method2_name == 'newproperty'
       typeobject.add_property(create_property(propertyname, node))

data/lib/puppet-strings/yard/handlers/ruby/type_handler.rb

@@ -18,7 +18,7 @@ class PuppetStrings::Yard::Handlers::Ruby::TypeHandler < PuppetStrings::Yard::Ha
     return unless statement.count > 1
 
     module_name = statement[0].source
-    return unless module_name == 'Puppet::Type' || module_name == 'Type'
+    return unless ['Puppet::Type', 'Type'].include?(module_name)
 
     object = get_type_yard_object(get_name(statement, 'Puppet::Type.newtype'))
 
@@ -39,6 +39,7 @@ class PuppetStrings::Yard::Handlers::Ruby::TypeHandler < PuppetStrings::Yard::Ha
   end
 
   private
+
   def populate_type_data(object)
     # Traverse the block looking for properties/parameters/features
     block = statement.block

data/lib/puppet-strings/yard/parsers/json/parser.rb

@@ -2,6 +2,7 @@
 
 require 'puppet-strings/yard/parsers/json/task_statement'
 
+# Implementas a JSON parser.
 class PuppetStrings::Yard::Parsers::JSON::Parser < YARD::Parser::Base
   attr_reader :file, :source
 
@@ -9,7 +10,7 @@ class PuppetStrings::Yard::Parsers::JSON::Parser < YARD::Parser::Base
   # @param [String] source The source being parsed.
   # @param [String] filename The file name of the file being parsed.
   # @return [void]
-  def initialize(source, filename)
+  def initialize(source, filename) # rubocop:disable Lint/MissingSuper
     @file = filename
     @source = source
     @statements = []
@@ -27,7 +28,7 @@ class PuppetStrings::Yard::Parsers::JSON::Parser < YARD::Parser::Base
       # TODO: this should compare json to a Task metadata json-schema or perform some other hueristics
       # to determine what type of statement it represents
       @statements.push(PuppetStrings::Yard::Parsers::JSON::TaskStatement.new(json, @source, @file)) unless json.empty?
-    rescue  # rubocop:disable Style/RescueStandardError  Just catch everything
+    rescue
       log.error "Failed to parse #{@file}: "
       @statements = []
     end

data/lib/puppet-strings/yard/parsers/json/task_statement.rb

@@ -3,7 +3,7 @@
 module PuppetStrings::Yard::Parsers::JSON
   # Represents the Puppet Task statement.
   class TaskStatement
-    attr_reader :line, :comments, :comments_range, :json, :file, :source, :docstring
+    attr_reader :line, :comments_range, :json, :file, :source, :docstring
 
     def initialize(json, source, file)
       @file = file
@@ -23,7 +23,7 @@ module PuppetStrings::Yard::Parsers::JSON
     end
 
     def show
-      ""
+      ''
     end
 
     def comments
@@ -31,7 +31,7 @@ module PuppetStrings::Yard::Parsers::JSON
     end
 
     def name
-      File.basename(@file).gsub('.json','') || ""
+      File.basename(@file).gsub('.json', '') || ''
     end
   end
 end

data/lib/puppet-strings/yard/parsers/puppet/parser.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# rubocop:disable Naming/MethodName
+
 require 'puppet'
 require 'puppet/pops'
 require 'puppet-strings/yard/parsers/puppet/statement'
@@ -12,7 +14,7 @@ class PuppetStrings::Yard::Parsers::Puppet::Parser < YARD::Parser::Base
   # @param [String] source The source being parsed.
   # @param [String] filename The file name of the file being parsed.
   # @return [void]
-  def initialize(source, filename)
+  def initialize(source, filename) # rubocop:disable Lint/MissingSuper
     @source = source
     @file = filename
     @visitor = ::Puppet::Pops::Visitor.new(self, 'transform')
@@ -22,13 +24,11 @@ class PuppetStrings::Yard::Parsers::Puppet::Parser < YARD::Parser::Base
   # @return [void]
   def parse
     begin
-      if @file.to_s.match(/^plans|\/plans\//)
-        if Puppet::Util::Package.versioncmp(Puppet.version, "5.0.0") < 0
-          log.warn "Skipping #{@file}: Puppet Plans require Puppet 5 or greater."
-          return
-        end
-        Puppet[:tasks] = true if Puppet.settings.include?(:tasks)
+      if @file.to_s.match?(%r{^plans|/plans/}) && Puppet::Util::Package.versioncmp(Puppet.version, '5.0.0') < 0
+        log.warn "Skipping #{@file}: Puppet Plans require Puppet 5 or greater."
+        return
       end
+      Puppet[:tasks] = true if Puppet.settings.include?(:tasks)
       @statements ||= (@visitor.visit(::Puppet::Pops::Parser::Parser.new.parse_string(source)) || []).compact
     rescue ::Puppet::ParseError => e
       log.error "Failed to parse #{@file}: #{e.message}"

data/lib/puppet-strings/yard/parsers/puppet/statement.rb

@@ -7,7 +7,7 @@ module PuppetStrings::Yard::Parsers::Puppet
   # Represents the base Puppet language statement.
   class Statement
     # The pattern for parsing docstring comments.
-    COMMENT_REGEX = /^\s*#+\s?/
+    COMMENT_REGEX = %r{^\s*#+\s?}.freeze
 
     attr_reader :source
     attr_reader :file
@@ -21,9 +21,8 @@ module PuppetStrings::Yard::Parsers::Puppet
     def initialize(object, file)
       @file = file
 
-      adapter = ::Puppet::Pops::Adapters::SourcePosAdapter.adapt(object)
-      @source = adapter.extract_text
-      @line = adapter.line
+      @source = PuppetStrings::Yard::Util.ast_to_text(object)
+      @line = object.line
       @comments_range = nil
     end
 
@@ -32,7 +31,7 @@ module PuppetStrings::Yard::Parsers::Puppet
     # @return [void]
     def extract_docstring(lines)
       comment = []
-      (0..@line-2).reverse_each do |index|
+      (0..@line - 2).reverse_each do |index|
         break unless index <= lines.count
 
         line = lines[index].strip
@@ -66,8 +65,9 @@ module PuppetStrings::Yard::Parsers::Puppet
     end
 
     private
+
     def first_line
-      @source.split(/\r?\n/).first.strip
+      @source.split(%r{\r?\n}).first.strip
     end
   end
 
@@ -85,14 +85,11 @@ module PuppetStrings::Yard::Parsers::Puppet
         @name = parameter.name
         # Take the exact text for the type expression
         if parameter.type_expr
-          adapter = ::Puppet::Pops::Adapters::SourcePosAdapter.adapt(parameter.type_expr)
-          @type = adapter.extract_text
+          @type = PuppetStrings::Yard::Util.ast_to_text(parameter.type_expr)
         end
         # Take the exact text for the default value expression
-        if parameter.value
-          adapter = ::Puppet::Pops::Adapters::SourcePosAdapter.adapt(parameter.value)
-          @value = adapter.extract_text
-        end
+        return unless parameter.value
+        @value = PuppetStrings::Yard::Util.ast_to_text(parameter.value)
       end
     end
 
@@ -146,13 +143,10 @@ module PuppetStrings::Yard::Parsers::Puppet
     def initialize(object, file)
       super(object, file)
       @name = object.name
-      if object.respond_to? :return_type
-        type = object.return_type
-        if type
-          adapter = ::Puppet::Pops::Adapters::SourcePosAdapter.adapt(type)
-          @type = adapter.extract_text.gsub('>> ', '')
-        end
-      end
+      return unless object.respond_to? :return_type
+      type = object.return_type
+      return unless type
+      @type = PuppetStrings::Yard::Util.ast_to_text(type).gsub('>> ', '')
     end
   end
 
@@ -184,12 +178,11 @@ module PuppetStrings::Yard::Parsers::Puppet
       case type_expr
       when Puppet::Pops::Model::AccessExpression
         # TODO: I don't like rebuilding the source from the AST, but AccessExpressions don't expose the original source
-        @alias_of = ::Puppet::Pops::Adapters::SourcePosAdapter.adapt(type_expr.left_expr).extract_text + '['
-        @alias_of << type_expr.keys.map { |key| ::Puppet::Pops::Adapters::SourcePosAdapter.adapt(key).extract_text }.join(', ')
+        @alias_of = PuppetStrings::Yard::Util.ast_to_text(type_expr.left_expr) + '['
+        @alias_of << type_expr.keys.map { |key| PuppetStrings::Yard::Util.ast_to_text(key) }.join(', ')
         @alias_of << ']'
       else
-        adapter = ::Puppet::Pops::Adapters::SourcePosAdapter.adapt(type_expr)
-        @alias_of = adapter.extract_text
+        @alias_of = PuppetStrings::Yard::Util.ast_to_text(type_expr)
       end
       @name = object.name
     end

data/lib/puppet-strings/yard/parsers.rb

@@ -6,6 +6,7 @@ module PuppetStrings::Yard::Parsers
   module JSON
     require 'puppet-strings/yard/parsers/json/parser'
   end
+
   # The module for custom YARD parsers for the Puppet language.
   module Puppet
     require 'puppet-strings/yard/parsers/puppet/parser'

data/lib/puppet-strings/yard/tags/enum_tag.rb

@@ -3,12 +3,11 @@
 require 'yard/tags/option_tag'
 
 # Implements an enum tag for describing enumerated value data types
-
 class PuppetStrings::Yard::Tags::EnumTag < YARD::Tags::OptionTag
   # Registers the tag with YARD.
   # @return [void]
   def self.register!
-    YARD::Tags::Library.define_tag("puppet.enum", :enum, :with_enums)
+    YARD::Tags::Library.define_tag('puppet.enum', :enum, :with_enums)
     YARD::Tags::Library.visible_tags.place(:enum).after(:option)
   end
 end

data/lib/puppet-strings/yard/tags/factory.rb

@@ -3,8 +3,8 @@
 require 'yard/tags/default_factory'
 require 'puppet-strings/yard/tags/enum_tag'
 
+# Factory for creating tags.
 class PuppetStrings::Yard::Tags::Factory < YARD::Tags::DefaultFactory
-
   # Parses tag text and creates a new enum tag type. Modeled after
   # the parse_tag_with_options method in YARD::Tags::DefaultFactory.
   #