puppet-strings 2.3.0 → 2.7.0

data/lib/puppet-strings/yard/code_objects/function.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'puppet-strings/yard/code_objects/group'
 
 # Implements the group for Puppet functions.
@@ -61,11 +63,12 @@ class PuppetStrings::Yard::CodeObjects::Function < PuppetStrings::Yard::CodeObje
   # @return [String] Returns the Puppet signature of the function.
   def signature
     return '' if self.has_tag? :overload
+
     tags = self.tags(:param)
     args = @parameters.map do |parameter|
       name, default = parameter
       tag = tags.find { |t| t.name == name } if tags
-      type = tag && tag.types ? "#{tag.type} " : 'Any '
+      type = tag&.types ? "#{tag.type} " : 'Any '
       prefix = "#{name[0]}" if name.start_with?('*', '&')
       name = name[1..-1] if prefix
       default = " = #{default}" if default
@@ -88,16 +91,16 @@ class PuppetStrings::Yard::CodeObjects::Function < PuppetStrings::Yard::CodeObje
     if self.has_tag? :overload
       # loop over overloads and append onto the signatures array
       self.tags(:overload).each do |o|
-        hash[:signatures] << { :signature => o.signature, :docstring => PuppetStrings::Yard::Util.docstring_to_hash(o.docstring, %i[param option return example]) }
+        hash[:signatures] << { :signature => o.signature, :docstring => PuppetStrings::Yard::Util.docstring_to_hash(o.docstring, %i[param option enum return example]) }
       end
     else
-      hash[:signatures] << { :signature => self.signature, :docstring =>  PuppetStrings::Yard::Util.docstring_to_hash(docstring, %i[param option return example]) }
+      hash[:signatures] << { :signature => self.signature, :docstring =>  PuppetStrings::Yard::Util.docstring_to_hash(docstring, %i[param option enum return example]) }
     end
 
     hash[:docstring] = PuppetStrings::Yard::Util.docstring_to_hash(docstring)
     defaults = Hash[*parameters.reject{ |p| p[1].nil? }.flatten]
-    hash[:defaults] = defaults unless defaults.empty?
-    hash[:source] = source unless source && source.empty?
+    hash[:defaults] = defaults unless defaults.nil? || defaults.empty?
+    hash[:source] = source unless source.nil? || source.empty?
     hash
   end
 end

data/lib/puppet-strings/yard/code_objects/group.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'puppet-strings/yard/code_objects/base'
 
 # Implements the base class for "groups".
@@ -10,6 +12,7 @@ class PuppetStrings::Yard::CodeObjects::Group < PuppetStrings::Yard::CodeObjects
   def self.instance(key)
     instance = P(:root, key)
     return instance unless instance.is_a?(YARD::CodeObjects::Proxy)
+
     instance = self.new(:root, key)
     instance.visibility = :hidden
     P(:root).children << instance

data/lib/puppet-strings/yard/code_objects/plan.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'puppet-strings/yard/code_objects/group'
 
 class PuppetStrings::Yard::CodeObjects::Plans < PuppetStrings::Yard::CodeObjects::Group
@@ -49,8 +51,8 @@ class PuppetStrings::Yard::CodeObjects::Plan < PuppetStrings::Yard::CodeObjects:
     hash[:line] = line
     hash[:docstring] = PuppetStrings::Yard::Util.docstring_to_hash(docstring)
     defaults = Hash[*parameters.reject{ |p| p[1].nil? }.flatten]
-    hash[:defaults] = defaults unless defaults.empty?
-    hash[:source] = source unless source && source.empty?
+    hash[:defaults] = defaults unless defaults.nil? || defaults.empty?
+    hash[:source] = source unless source.nil? || source.empty?
     hash
   end
 end

data/lib/puppet-strings/yard/code_objects/provider.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'puppet-strings/yard/code_objects/group'
 
 # Implements the group for Puppet providers.
@@ -42,6 +44,7 @@ class PuppetStrings::Yard::CodeObjects::Provider < PuppetStrings::Yard::CodeObje
   # @return [void]
   def add_confine(key, value)
     return unless key && value
+
     @confines ||= {}
     @confines[key] = value
   end
@@ -51,6 +54,7 @@ class PuppetStrings::Yard::CodeObjects::Provider < PuppetStrings::Yard::CodeObje
   # @return [void]
   def add_feature(feature)
     return unless feature
+
     @features ||= []
     @features << feature
   end
@@ -60,6 +64,7 @@ class PuppetStrings::Yard::CodeObjects::Provider < PuppetStrings::Yard::CodeObje
   # @return [void]
   def add_default(constraints)
     return unless constraints
+
     @defaults ||= []
     @defaults << constraints
   end
@@ -70,6 +75,7 @@ class PuppetStrings::Yard::CodeObjects::Provider < PuppetStrings::Yard::CodeObje
   # @return [void]
   def add_command(key, value)
     return unless key && value
+
     @commands ||= {}
     @commands[key] = value
   end

data/lib/puppet-strings/yard/code_objects/task.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'puppet-strings/yard/code_objects/group'
 
 # Implements the group for Puppet tasks.
@@ -43,7 +45,7 @@ class PuppetStrings::Yard::CodeObjects::Task < PuppetStrings::Yard::CodeObjects:
 
   def parameters
     parameters = []
-    statement.json['parameters'].each do |name,props|
+    statement.parameters.each do |name,props|
       parameters.push({ name: name.to_s,
                         tag_name: 'param',
                         text: props['description'] || "",

data/lib/puppet-strings/yard/code_objects/type.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'puppet-strings/yard/code_objects/group'
 require 'puppet-strings/yard/util'
 
@@ -73,6 +75,9 @@ class PuppetStrings::Yard::CodeObjects::Type < PuppetStrings::Yard::CodeObjects:
   class Property < Parameter
   end
 
+  class Check < Parameter
+  end
+
   # Represents a resource type feature.
   class Feature
     attr_reader :name, :docstring
@@ -95,7 +100,7 @@ class PuppetStrings::Yard::CodeObjects::Type < PuppetStrings::Yard::CodeObjects:
     end
   end
 
-  attr_reader :properties, :parameters, :features
+  attr_reader :properties, :features, :checks
 
   # Initializes a new resource type.
   # @param [String] name The resource type name.
@@ -134,17 +139,56 @@ class PuppetStrings::Yard::CodeObjects::Type < PuppetStrings::Yard::CodeObjects:
     @features << feature
   end
 
+  # Adds a check to the resource type.
+  # @param [PuppetStrings::Yard::CodeObjects::Type::Check] check The check to add.
+  # @return [void]
+  def add_check(check)
+    @checks ||= []
+    @checks << check
+  end
+
+  def parameters
+    # just return params if there are no providers
+    return @parameters if providers.empty?
+
+    # return existing params if we have already added provider
+    return @parameters if @parameters.any? { |p| p.name == 'provider' }
+
+    provider_param = Parameter.new(
+      'provider',
+      "The specific backend to use for this `#{self.name.to_s}` resource. You will seldom need " + \
+      "to specify this --- Puppet will usually discover the appropriate provider for your platform."
+    )
+
+    @parameters << provider_param
+  end
+
+  # Not sure if this is where this belongs or if providers should only be resolved at
+  # render-time. For now, this should re-resolve on every call.
+  # may be able to memoize this
+  def providers
+    providers = YARD::Registry.all("puppet_providers_#{name}".intern)
+    return providers if providers.empty?
+
+    providers.first.children
+  end
+
   # Converts the code object to a hash representation.
   # @return [Hash] Returns a hash representation of the code object.
   def to_hash
     hash = {}
+
     hash[:name] = name
     hash[:file] = file
     hash[:line] = line
-    hash[:docstring] = PuppetStrings::Yard::Util.docstring_to_hash(docstring)
-    hash[:properties] = properties.map(&:to_hash) if properties && !properties.empty?
-    hash[:parameters] = parameters.map(&:to_hash) if parameters && !parameters.empty?
-    hash[:features] = features.map(&:to_hash) if features && !features.empty?
+
+    hash[:docstring]  = PuppetStrings::Yard::Util.docstring_to_hash(docstring)
+    hash[:properties] = properties.sort_by { |p| p.name }.map(&:to_hash) if properties && !properties.empty?
+    hash[:parameters] = parameters.sort_by { |p| p.name }.map(&:to_hash) if parameters && !parameters.empty?
+    hash[:checks]     = checks.sort_by { |c| c.name }.map(&:to_hash) if checks && !checks.empty?
+    hash[:features]   = features.sort_by { |f| f.name }.map(&:to_hash) if features && !features.empty?
+    hash[:providers]  = providers.sort_by { |p| p.name }.map(&:to_hash) if providers && !providers.empty?
+
     hash
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # The module for custom YARD handlers.
 module PuppetStrings::Yard::Handlers
   # The module for custom Ruby YARD handlers.

data/lib/puppet-strings/yard/handlers/helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PuppetStrings::Yard::Handlers::Helpers
   # Logs a warning if a summary tag has more than 140 characters
   def self.validate_summary_tag(object)

data/lib/puppet-strings/yard/handlers/json/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class PuppetStrings::Yard::Handlers::JSON::Base < YARD::Handlers::Base
   def self.handles?(statement)
     handlers.any? {|handler| statement.is_a?(handler)}

data/lib/puppet-strings/yard/handlers/json/task_handler.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'puppet-strings/yard/handlers/json/base'
 require 'puppet-strings/yard/parsers'
 require 'puppet-strings/yard/parsers/json/parser'

data/lib/puppet-strings/yard/handlers/puppet/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Implements the base handler for Puppet language handlers.
 class PuppetStrings::Yard::Handlers::Puppet::Base < YARD::Handlers::Base
   # Determine sif the handler handles the given statement.
@@ -17,6 +19,7 @@ class PuppetStrings::Yard::Handlers::Puppet::Base < YARD::Handlers::Base
     tags = object.tags(:param)
     tags.each do |tag|
       next if statement.parameters.find { |p| tag.name == p.name }
+
       log.warn "The @param tag for parameter '#{tag.name}' has no matching parameter at #{statement.file}:#{statement.line}." unless tag.name == 'name' || tag.name == 'title'
     end
 

data/lib/puppet-strings/yard/handlers/puppet/class_handler.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'puppet-strings/yard/handlers/helpers'
 require 'puppet-strings/yard/handlers/puppet/base'
 require 'puppet-strings/yard/parsers'

data/lib/puppet-strings/yard/handlers/puppet/data_type_alias_handler.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'puppet-strings/yard/handlers/helpers'
 require 'puppet-strings/yard/handlers/puppet/base'
 require 'puppet-strings/yard/parsers'

data/lib/puppet-strings/yard/handlers/puppet/defined_type_handler.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'puppet-strings/yard/handlers/helpers'
 require 'puppet-strings/yard/handlers/puppet/base'
 require 'puppet-strings/yard/parsers'

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'puppet-strings/yard/handlers/helpers'
 require 'puppet-strings/yard/handlers/puppet/base'
 require 'puppet-strings/yard/parsers'
@@ -37,7 +39,7 @@ class PuppetStrings::Yard::Handlers::Puppet::FunctionHandler < PuppetStrings::Ya
   def add_return_tag(object, type=nil)
     tag = object.tag(:return)
     if tag
-      if (type && tag.types.first) && (type != tag.types.first)
+      if (type && tag.types && tag.types.first) && (type != tag.types.first)
         log.warn "Documented return type does not match return type in function definition near #{statement.file}:#{statement.line}."
       end
 

data/lib/puppet-strings/yard/handlers/puppet/plan_handler.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'puppet-strings/yard/handlers/helpers'
 require 'puppet-strings/yard/handlers/puppet/base'
 require 'puppet-strings/yard/parsers'

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'ripper'
 
 # Implements the base handler for Ruby language handlers.
@@ -12,6 +14,7 @@ class PuppetStrings::Yard::Handlers::Ruby::Base < YARD::Handlers::Ruby::Base
   # @return [String] Returns a string representation of the node or nil if a string representation was not possible.
   def node_as_string(node)
     return nil unless node
+
     case node.type
     when :symbol, :symbol_literal
       node.source[1..-1]
@@ -42,8 +45,10 @@ class PuppetStrings::Yard::Handlers::Ruby::Base < YARD::Handlers::Ruby::Base
   def get_name(statementobject, statementtype)
     parameters = statementobject.parameters(false)
     raise YARD::Parser::UndocumentableError, "Expected at least one parameter to #{statementtype} at #{statementobject.file}:#{statementobject.line}." if parameters.empty?
+
     name = node_as_string(parameters.first)
     raise YARD::Parser::UndocumentableError, "Expected a symbol or string literal for first parameter but found '#{parameters.first.type}' at #{statement.file}:#{statement.line}." unless name
+
     name
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'puppet-strings/yard/handlers/helpers'
 require 'puppet-strings/yard/handlers/ruby/base'
 require 'puppet-strings/yard/code_objects'
@@ -10,16 +12,21 @@ class PuppetStrings::Yard::Handlers::Ruby::DataTypeHandler < PuppetStrings::Yard
 
   process do
     return unless statement.count > 1
+
     ruby_module_name = statement[0].source
     return unless ruby_module_name == 'Puppet::DataTypes' || ruby_module_name == 'DataTypes' # rubocop:disable Style/MultipleComparison This reads better
-    object = get_datatype_yard_object(get_name(statement, 'Puppet::DataTypes.create_type'))
 
-    actual_params = extract_params_for_data_type # populate_data_type_data(object)
+    object = get_datatype_yard_object(get_name(statement, 'Puppet::DataTypes.create_type'))
+    # Extract the interface definition
+    type_interface = extract_data_type_interface
+    actual_params = extract_params(type_interface)
+    actual_funcs = extract_functions(object, type_interface)
 
     # Mark the data type as public if it doesn't already have an api tag
     object.add_tag YARD::Tags::Tag.new(:api, 'public') unless object.has_tag? :api
 
-    validate_tags!(object, actual_params)
+    validate_param_tags!(object, actual_params)
+    validate_methods!(object, actual_funcs)
 
     # Set the default values for all parameters
     actual_params.each { |name, data| object.set_parameter_default(name, data[:default]) }
@@ -49,38 +56,64 @@ class PuppetStrings::Yard::Handlers::Ruby::DataTypeHandler < PuppetStrings::Yard
     object
   end
 
-  def extract_params_for_data_type
-    params = {}
-    # Traverse the block looking for interface
+  # @return [Hash{Object => Object}] The Puppet DataType interface definition as a ruby Hash
+  def extract_data_type_interface
     block = statement.block
-    return unless block && block.count >= 2
-    block[1].children.each do |node|
-      next unless node.is_a?(YARD::Parser::Ruby::MethodCallNode) &&
-                  node.method_name
+    return {} unless block
+
+    # Declare the parsed interface outside of the closure
+    parsed_interface = nil
+
+    # Recursively traverse the block looking for the first valid 'interface' call
+    interface_node = find_ruby_ast_node(block, true) do |node|
+      next false unless node.is_a?(YARD::Parser::Ruby::MethodCallNode) &&
+                        node.method_name &&
+                        node.method_name.source == 'interface'
 
-      method_name = node.method_name.source
       parameters = node.parameters(false)
-      if method_name == 'interface'
-        next unless parameters.count >= 1
-        interface_string = node_as_string(parameters[0])
-        next unless interface_string
+      next false unless parameters.count >= 1
+
+      interface_string = node_as_string(parameters[0])
+      next false unless interface_string
+
+      begin
         # Ref - https://github.com/puppetlabs/puppet/blob/ba4d1a1aba0095d3c70b98fea5c67434a4876a61/lib/puppet/datatypes.rb#L159
         parsed_interface = Puppet::Pops::Parser::EvaluatingParser.new.parse_string("{ #{interface_string} }").body
-        next unless parsed_interface
-
-        # Now that we parsed the Puppet code (as a string) into a LiteralHash PCore type (Puppet AST),
-        #
-        # We need to convert the LiteralHash into a conventional ruby hash of strings. The
-        # LazyLiteralEvaluator does this by traversing the AST tree can converting objects to strings
-        # where possible and ignoring object types which cannot (thus the 'Lazy' name)
-        #
-        # Once we have it as a standard ruby hash we can then look at the keys and populate the YARD
-        # Code object with the correct attributes etc.
-        literal_eval = LazyLiteralEvaluator.new
-        populate_data_type_params_from_literal_hash!(literal_eval.literal(parsed_interface), params)
+      rescue Puppet::Error => e
+        log.warn "Invalid datatype definition at #{statement.file}:#{statement.line}: #{e.basic_message}"
+        next false
       end
+      !parsed_interface.nil?
     end
-    params
+
+    # Now that we parsed the Puppet code (as a string) into a LiteralHash PCore type (Puppet AST),
+    # We need to convert the LiteralHash into a conventional ruby hash of strings. The
+    # LazyLiteralEvaluator does this by traversing the AST tree can converting objects to strings
+    # where possible and ignoring object types which cannot (thus the 'Lazy' name)
+    literal_eval = LazyLiteralEvaluator.new
+    literal_eval.literal(parsed_interface)
+  end
+
+  # Find the first Ruby AST node within an AST Tree, optionally recursively. Returns nil of none could be found
+  #
+  # @param [YARD::Parser::Ruby::AstNode] ast_node The root AST node object to inspect
+  # @param [Boolean] recurse Whether to search the tree recursively.  Defaults to false
+  # @yieldparam [YARD::Parser::Ruby::AstNode] ast_node The AST Node that should be checked
+  # @yieldreturn [Boolean] Whether the node was what was searched for
+  # @return [YARD::Parser::Ruby::AstNode, nil]
+  def find_ruby_ast_node(ast_node, recurse = false, &block)
+    raise ArgumentError, 'find_ruby_ast_node requires a block' unless block_given?
+
+    is_found = yield ast_node
+    return ast_node if is_found
+
+    if ast_node.respond_to?(:children)
+      ast_node.children.each do |child_node|
+        child_found = find_ruby_ast_node(child_node, recurse, &block)
+        return child_found unless child_found.nil?
+      end
+    end
+    nil
   end
 
   # Lazily evaluates a Pops object, ignoring any objects that cannot
@@ -103,7 +136,7 @@ class PuppetStrings::Yard::Handlers::Ruby::DataTypeHandler < PuppetStrings::Yard
   # Anything else is ignored
   class LazyLiteralEvaluator
     def initialize
-      @literal_visitor ||= ::Puppet::Pops::Visitor.new(self, "literal", 0, 0)
+      @literal_visitor = ::Puppet::Pops::Visitor.new(self, "literal", 0, 0)
     end
 
     def literal(ast)
@@ -111,68 +144,72 @@ class PuppetStrings::Yard::Handlers::Ruby::DataTypeHandler < PuppetStrings::Yard
     end
 
     # ----- The following methods are different/additions from the original Literal_evaluator
-    def literal_Object(o) # rubocop:disable Naming/UncommunicativeMethodParamName
+    def literal_Object(o)
       # Ignore any other object types
     end
 
-    def literal_AccessExpression(o) # rubocop:disable Naming/UncommunicativeMethodParamName
+    def literal_AccessExpression(o)
       # Extract the raw text of the Access Expression
       ::Puppet::Pops::Adapters::SourcePosAdapter.adapt(o).extract_text
     end
 
-    def literal_QualifiedReference(o) # rubocop:disable Naming/UncommunicativeMethodParamName
+    def literal_QualifiedReference(o)
       # Extract the raw text of the Qualified Reference
       ::Puppet::Pops::Adapters::SourcePosAdapter.adapt(o).extract_text
     end
 
     # ----- The following methods are the same as the original Literal_evaluator
-    def literal_Factory(o) # rubocop:disable Naming/UncommunicativeMethodParamName
+    def literal_Factory(o)
       literal(o.model)
     end
 
-    def literal_Program(o) # rubocop:disable Naming/UncommunicativeMethodParamName
+    def literal_Program(o)
       literal(o.body)
     end
 
-    def literal_LiteralString(o) # rubocop:disable Naming/UncommunicativeMethodParamName
+    def literal_LiteralString(o)
       o.value
     end
 
-    def literal_QualifiedName(o) # rubocop:disable Naming/UncommunicativeMethodParamName
+    def literal_QualifiedName(o)
       o.value
     end
 
-    def literal_LiteralNumber(o) # rubocop:disable Naming/UncommunicativeMethodParamName
+    def literal_LiteralNumber(o)
       o.value
     end
 
-    def literal_LiteralBoolean(o) # rubocop:disable Naming/UncommunicativeMethodParamName
+    def literal_UnaryMinusExpression(o)
+      -1 * literal(o.expr)
+    end
+
+    def literal_LiteralBoolean(o)
       o.value
     end
 
-    def literal_LiteralUndef(o) # rubocop:disable Naming/UncommunicativeMethodParamName
+    def literal_LiteralUndef(o)
       nil
     end
 
-    def literal_LiteralDefault(o) # rubocop:disable Naming/UncommunicativeMethodParamName
+    def literal_LiteralDefault(o)
       :default
     end
 
-    def literal_LiteralRegularExpression(o) # rubocop:disable Naming/UncommunicativeMethodParamName
+    def literal_LiteralRegularExpression(o)
       o.value
     end
 
-    def literal_ConcatenatedString(o) # rubocop:disable Naming/UncommunicativeMethodParamName
+    def literal_ConcatenatedString(o)
       # use double quoted string value if there is no interpolation
       throw :not_literal unless o.segments.size == 1 && o.segments[0].is_a?(Model::LiteralString)
       o.segments[0].value
     end
 
-    def literal_LiteralList(o) # rubocop:disable Naming/UncommunicativeMethodParamName
-      o.values.map {|v| literal(v) }
+    def literal_LiteralList(o)
+      o.values.map { |v| literal(v) }
     end
 
-    def literal_LiteralHash(o) # rubocop:disable Naming/UncommunicativeMethodParamName
+    def literal_LiteralHash(o)
       o.entries.reduce({}) do |result, entry|
         result[literal(entry.key)] = literal(entry.value)
         result
@@ -180,27 +217,58 @@ class PuppetStrings::Yard::Handlers::Ruby::DataTypeHandler < PuppetStrings::Yard
     end
   end
 
-  def populate_data_type_params_from_literal_hash!(hash, params_hash)
-    return if hash.nil?
+  # Extracts the datatype attributes from a Puppet Data Type interface hash.
+  # Returns a Hash with a :types key (Array of data types for the parameter) and :default key (The default value of the parameter)
+  # @return Hash[Symbol => Hash] The Datatype Attributes as a hash
+  def extract_params(hash)
+    params_hash = {}
     # Exit early if there are no entries in the hash
-    return if hash['attributes'].nil? || hash['attributes'].count.zero?
+    return params_hash if hash.nil? || hash['attributes'].nil? || hash['attributes'].empty?
 
     hash['attributes'].each do |key, value|
       data_type = nil
       default = nil
-      case value
-      when String
+      if value.is_a?(String)
         data_type = value
-      when Hash
+      elsif value.is_a?(Hash)
         data_type = value['type'] unless value['type'].nil?
         default   = value['value'] unless value['value'].nil?
       end
       data_type = [data_type] unless data_type.nil? || data_type.is_a?(Array)
       params_hash[key] = { :types => data_type, :default => default }
     end
+
+    params_hash
+  end
+
+  # Extracts the datatype functions from a Puppet Data Type interface hash.
+  # Returns a Hash with a :param_types key (Array of types for each parameter) and :return_type key (The return type of the function)
+  # @return Hash[Symbol => Hash] The Datatype Attributes as a hash
+  def extract_functions(object, hash)
+    funcs_hash = {}
+    # Exit early if there are no entries in the hash
+    return funcs_hash if hash.nil? || hash['functions'].nil? || hash['functions'].empty?
+
+    hash['functions'].each do |key, func_type|
+      func_hash = { :param_types => [], :return_type => nil }
+      begin
+        callable_type = Puppet::Pops::Types::TypeParser.singleton.parse(func_type)
+        if callable_type.is_a?(Puppet::Pops::Types::PCallableType)
+          func_hash[:param_types] = callable_type.param_types.map { |pt| pt.to_s }
+          func_hash[:return_type] = callable_type.return_type.to_s
+        else
+          log.warn "The function definition for '#{key}' near #{object.file}:#{object.line} is not a Callable type"
+        end
+      rescue Puppet::ParseError => e
+        log.warn "Unable to parse the function definition for '#{key}' near #{object.file}:#{object.line}. #{e}"
+      end
+      funcs_hash[key] = func_hash
+    end
+    funcs_hash
   end
 
-  def validate_tags!(object, actual_params_hash)
+  # Validates and automatically fixes yard @param tags for the data type
+  def validate_param_tags!(object, actual_params_hash)
     actual_param_names = actual_params_hash.keys
     tagged_param_names = object.tags(:param).map(&:name)
     # Log any errors
@@ -215,8 +283,10 @@ class PuppetStrings::Yard::Handlers::Ruby::DataTypeHandler < PuppetStrings::Yard
     # Find param tags with a type that is different from the actual definition
     object.tags(:param).reject { |tag| tag.types.nil? }.each do |tag|
       next if actual_params_hash[tag.name].nil?
+
       actual_data_type = actual_params_hash[tag.name][:types]
       next if actual_data_type.nil?
+
       log.warn "The @param tag for '#{tag.name}' has a different type definition than the actual attribute near #{object.file}:#{object.line}." if tag.types != actual_data_type
     end
 
@@ -230,7 +300,110 @@ class PuppetStrings::Yard::Handlers::Ruby::DataTypeHandler < PuppetStrings::Yard
     # Set the type in the param tag
     object.tags(:param).each do |tag|
       next if actual_params_hash[tag.name].nil?
+
       tag.types = actual_params_hash[tag.name][:types]
     end
   end
+
+  # Validates and automatically fixes yard @method! tags for the data type
+  def validate_methods!(object, actual_functions_hash)
+    actual_func_names = actual_functions_hash.keys
+    tagged_func_names = object.meths.map { |meth| meth.name.to_s }
+
+    # Log any errors
+    # Find functions which are not documented
+    (actual_func_names - tagged_func_names).each do |item|
+      log.warn "Missing @!method tag for function '#{item}' near #{object.file}:#{object.line}."
+    end
+    # Find functions which are not defined
+    (tagged_func_names - actual_func_names).each do |item|
+      log.warn "The @!method tag for '#{item}' has no matching function definition near #{object.file}:#{object.line}."
+    end
+    # Functions with the wrong return type
+    object.meths.each do |meth|
+      next unless actual_func_names.include?(meth.name.to_s)
+
+      return_tag = meth.docstring.tag(:return)
+      next if return_tag.nil?
+
+      actual_return_types = [actual_functions_hash[meth.name.to_s][:return_type]]
+      next if return_tag.types == actual_return_types
+
+      log.warn "The @return tag for '#{meth.name}' has a different type definition than the actual function near #{object.file}:#{object.line}. Expected #{actual_return_types}"
+      return_tag.types = actual_return_types
+    end
+
+    # Automatically fix missing methods
+    (actual_func_names - tagged_func_names).each do |name|
+      object.add_function(name, actual_functions_hash[name][:return_type], actual_functions_hash[name][:param_types])
+    end
+    # Remove extra methods. Can't use `meths` as that's a derived property
+    object.children.reject! { |child| child.is_a?(YARD::CodeObjects::MethodObject) && !actual_func_names.include?(child.name.to_s) }
+
+    # Add the return type for the methods if missing
+    object.meths.each do |meth|
+      next unless meth.docstring.tag(:return).nil?
+
+      meth.docstring.add_tag(YARD::Tags::Tag.new(:return, '', actual_functions_hash[meth.name.to_s][:return_type]))
+    end
+
+    # Sync the method properties and add the return type for the methods if missing
+    object.meths.each do |meth|
+      validate_function_method!(object, meth, actual_functions_hash[meth.name.to_s])
+      next unless meth.docstring.tag(:return).nil?
+
+      meth.docstring.add_tag(YARD::Tags::Tag.new(:return, '', actual_functions_hash[meth.name.to_s][:return_type]))
+    end
+
+    # The default meth.signature assumes ruby invocation (e.g. def meth(...)) but this doesn't make sense for a
+    # Puppet Data Type function invocation. So instead we derive a signature from the method definition.
+    object.meths.each do |meth|
+      params = ''
+      unless meth.docstring.tags(:param).empty?
+        params += '(' + meth.docstring.tags(:param).map { |t| t.name }.join(', ') + ')'
+      end
+      meth.signature = "#{object.name}.#{meth.name}" + params
+    end
+
+    nil
+  end
+
+  # Validates and automatically fixes a single yard @method!
+  # Used by the validate_methods! method.
+  def validate_function_method!(object, meth, actual_function)
+    # Remove extra params
+    if meth.docstring.tags(:param).count > actual_function[:param_types].count
+      index = 0
+      meth.docstring.delete_tag_if do |tag|
+        if tag.tag_name == 'param'
+          index += 1
+          if index > actual_function[:param_types].count
+            log.warn "The @param tag for '#{tag.name}' should not exist for function '#{meth.name}' that is defined near #{object.file}:#{object.line}. Expected only #{actual_function[:param_types].count} parameter/s"
+            true
+          else
+            false
+          end
+        else
+          false
+        end
+      end
+    end
+
+    # Add missing params
+    if meth.docstring.tags(:param).count < actual_function[:param_types].count
+      start = meth.docstring.tags(:param).count + 1
+      (start..actual_function[:param_types].count).each do |index| # Using 1-based index here instead of usual zero
+        meth.add_tag(YARD::Tags::Tag.new(:param, '', actual_function[:param_types][index - 1], "param#{index}"))
+      end
+    end
+
+    # Ensure the parameter types are correct
+    meth.docstring.tags(:param).each_with_index do |tag, index|
+      actual_types = [actual_function[:param_types][index]]
+      if tag.types != actual_types
+        log.warn "The @param tag for '#{tag.name}' for function '#{meth.name}' has a different type definition than the actual function near #{object.file}:#{object.line}. Expected #{actual_types}"
+        tag.types = actual_types
+      end
+    end
+  end
 end