puppet-strings 2.2.0 → 2.3.0

data/lib/puppet-strings/markdown/function.rb

@@ -30,11 +30,11 @@ module PuppetStrings::Markdown
       end
     end
 
-    def error_type(r)
+    def error_type(r) # rubocop:disable Naming/UncommunicativeMethodParamName
       "`#{r.split(' ')[0]}`"
     end
 
-    def error_text(r)
+    def error_text(r) # rubocop:disable Naming/UncommunicativeMethodParamName
       "#{r.split(' ').drop(1).join(' ')}"
     end
   end

data/lib/puppet-strings/markdown/table_of_contents.rb

@@ -7,6 +7,7 @@ module PuppetStrings::Markdown
       PuppetStrings::Markdown::DefinedTypes,
       PuppetStrings::Markdown::ResourceTypes,
       PuppetStrings::Markdown::Functions,
+      PuppetStrings::Markdown::DataTypes,
       PuppetStrings::Markdown::PuppetTasks,
       PuppetStrings::Markdown::PuppetPlans].each do |r|
         toc = r.toc_info

data/lib/puppet-strings/markdown/templates/data_type.erb

@@ -0,0 +1,78 @@
+### <%= name %>
+
+<% if text -%>
+<%= text %>
+<% elsif summary -%>
+<%= summary %>
+<% else -%>
+<%= "The #{name} data type." %>
+<% end -%>
+
+<% if todo -%>
+* **TODO** <%= todo %>
+
+<% end -%>
+<% if note -%>
+* **Note** <%= note %>
+
+<% end -%>
+<% if since -%>
+* **Since** <%= since %>
+
+<% end -%>
+<% if see -%>
+* **See also**
+<% see.each do |sa| -%>
+<% if sa[:name] -%>
+<%= sa[:name] %>
+<% end -%>
+<% if sa[:text] -%>
+<%= sa[:text] %>
+<% end -%>
+<% end -%>
+
+<% end -%>
+<% if examples -%>
+#### Examples
+
+<% examples.each do |eg| -%>
+##### <%= eg[:name] %>
+
+```puppet
+<%= eg[:text] %>
+```
+
+<% end -%>
+<% end -%>
+<% if alias_of -%>
+Alias of `<%= alias_of %>`
+
+<% end -%>
+<% if params -%>
+#### Parameters
+
+The following parameters are available in the `<%= name %>` <%= @type %>.
+
+<% params.each do |param| -%>
+##### `<%= param[:name] %>`
+
+<% if param[:types] -%>
+Data type: `<%= param[:types].join(', ') -%>`
+
+<% end -%>
+<%= param[:text] %>
+
+<% if options_for_param(param[:name]) -%>
+Options:
+
+<% options_for_param(param[:name]).each do |o| -%>
+* **<%= o[:opt_name] %>** `<%= o[:opt_types][0] %>`: <%= o[:opt_text] %>
+<% end -%>
+
+<% end -%>
+<% if defaults && defaults[param[:name]] -%>
+Default value: <%= value_string(defaults[param[:name]]) %>
+
+<% end -%>
+<% end -%>
+<% end -%>

data/lib/puppet-strings/tasks/generate.rb

@@ -33,11 +33,12 @@ namespace :strings do
         end
       end
     end
+    # rubocop:enable Style/PreferredHashMethods
 
-    [:json,:markdown].each { |format| parse_format_option(args, options, format) }
+    %i[json markdown].each { |format| parse_format_option(args, options, format) }
 
     warn('yard_args behavior is a little dodgy, use at your own risk') if args[:yard_args]
-    options[:yard_args] = args[:yard_args].split if args.has_key? :yard_args
+    options[:yard_args] = args[:yard_args].split if args.key? :yard_args
 
     PuppetStrings.generate(patterns, options)
   end

data/lib/puppet-strings/version.rb

@@ -1,3 +1,3 @@
 module PuppetStrings
-  VERSION = '2.2.0'.freeze
+  VERSION = '2.3.0'.freeze
 end

data/lib/puppet-strings/yard.rb

@@ -46,6 +46,8 @@ class YARD::CLI::Yardoc
       :module,
       :class,
       :puppet_class,
+      :puppet_data_type,
+      :puppet_data_type_alias,
       :puppet_defined_type,
       :puppet_type,
       :puppet_provider,
@@ -64,6 +66,14 @@ class YARD::CLI::Stats
     output 'Puppet Classes', *type_statistics_all(:puppet_class)
   end
 
+  def stats_for_puppet_data_types
+    output 'Puppet Data Types', *type_statistics_all(:puppet_data_type)
+  end
+
+  def stats_for_puppet_data_type_aliases
+    output 'Puppet Data Type Aliases', *type_statistics_all(:puppet_data_type_alias)
+  end
+
   def stats_for_puppet_defined_types
     output 'Puppet Defined Types', *type_statistics_all(:puppet_defined_type)
   end

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

@@ -1,6 +1,8 @@
 # The module for custom YARD code objects.
 module PuppetStrings::Yard::CodeObjects
   require 'puppet-strings/yard/code_objects/class'
+  require 'puppet-strings/yard/code_objects/data_type'
+  require 'puppet-strings/yard/code_objects/data_type_alias'
   require 'puppet-strings/yard/code_objects/defined_type'
   require 'puppet-strings/yard/code_objects/type'
   require 'puppet-strings/yard/code_objects/provider'

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

@@ -51,7 +51,7 @@ class PuppetStrings::Yard::CodeObjects::Class < PuppetStrings::Yard::CodeObjects
     hash[:line] = line
     hash[:inherits] = statement.parent_class if statement.parent_class
     hash[:docstring] = PuppetStrings::Yard::Util.docstring_to_hash(docstring)
-    defaults = Hash[*parameters.select{ |p| !p[1].nil? }.flatten]
+    defaults = Hash[*parameters.reject{ |p| p[1].nil? }.flatten]
     hash[:defaults] = defaults unless defaults.empty?
     hash[:source] = source unless source && source.empty?
     hash

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

@@ -0,0 +1,80 @@
+require 'puppet-strings/yard/code_objects/group'
+require 'puppet-strings/yard/util'
+
+# Implements the group for Puppet DataTypes.
+class PuppetStrings::Yard::CodeObjects::DataTypes < PuppetStrings::Yard::CodeObjects::Group
+  # Gets the singleton instance of the group.
+  # @return Returns the singleton instance of the group.
+  def self.instance
+    super(:puppet_data_types)
+  end
+
+  # Gets the display name of the group.
+  # @param [Boolean] prefix whether to show a prefix. Ignored for Puppet group namespaces.
+  # @return [String] Returns the display name of the group.
+  def name(prefix = false)
+    'Puppet Data Types'
+  end
+end
+
+# Implements the Puppet DataType code object.
+class PuppetStrings::Yard::CodeObjects::DataType < PuppetStrings::Yard::CodeObjects::Base
+  # Initializes a Puppet class code object.
+  # @param [String] The name of the Data Type
+  # @return [void]
+  def initialize(name)
+    super(PuppetStrings::Yard::CodeObjects::DataTypes.instance, name)
+    @parameters = []
+    @defaults = {}
+  end
+
+  # Gets the type of the code object.
+  # @return Returns the type of the code object.
+  def type
+    :puppet_data_type
+  end
+
+  # Gets the source of the code object.
+  # @return Returns the source of the code object.
+  def source
+    # Not implemented, but would be nice!
+    nil
+  end
+
+  def parameter_exist?(name)
+    !docstring.tags(:param).find { |item| item.name == name }.nil?
+  end
+
+  def add_parameter(name, type, default)
+    tag = docstring.tags(:param).find { |item| item.name == name }
+    if tag.nil?
+      tag = YARD::Tags::Tag.new(:param, '', nil, name)
+      docstring.add_tag(tag)
+    end
+    type = [type] unless type.is_a?(Array)
+    tag.types = type if tag.types.nil?
+    set_parameter_default(name, default)
+  end
+
+  def set_parameter_default(param_name, default)
+    defaults.delete(param_name)
+    defaults[param_name] = default unless default.nil?
+  end
+
+  def parameters
+    docstring.tags(:param).map { |tag| [tag.name, defaults[tag.name]] }
+  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[:defaults] = defaults unless defaults.empty?
+    hash[:source] = source unless source && source.empty?
+    hash
+  end
+end

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

@@ -0,0 +1,58 @@
+require 'puppet-strings/yard/code_objects/group'
+require 'puppet-strings/yard/util'
+
+# Implements the group for Puppet DataTypeAliases.
+class PuppetStrings::Yard::CodeObjects::DataTypeAliases < PuppetStrings::Yard::CodeObjects::Group
+  # Gets the singleton instance of the group.
+  # @return Returns the singleton instance of the group.
+  def self.instance
+    super(:puppet_data_type_aliases)
+  end
+
+  # Gets the display name of the group.
+  # @param [Boolean] prefix whether to show a prefix. Ignored for Puppet group namespaces.
+  # @return [String] Returns the display name of the group.
+  def name(prefix = false)
+    'Puppet Data Type Aliases'
+  end
+end
+
+# Implements the Puppet DataTypeAlias code object.
+class PuppetStrings::Yard::CodeObjects::DataTypeAlias < PuppetStrings::Yard::CodeObjects::Base
+  attr_reader :statement
+  attr_accessor :alias_of
+
+  # Initializes a Puppet data type alias code object.
+  # @param [PuppetStrings::Parsers::DataTypeAliasStatement] statement The data type alias statement that was parsed.
+  # @return [void]
+  def initialize(statement)
+    @statement = statement
+    @alias_of = statement.alias_of
+    super(PuppetStrings::Yard::CodeObjects::DataTypeAliases.instance, statement.name)
+  end
+
+  # Gets the type of the code object.
+  # @return Returns the type of the code object.
+  def type
+    :puppet_data_type_alias
+  end
+
+  # Gets the source of the code object.
+  # @return Returns the source of the code object.
+  def source
+    # Not implemented, but would be nice!
+    nil
+  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[:alias_of] = alias_of
+    hash
+  end
+end

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

@@ -50,7 +50,7 @@ class PuppetStrings::Yard::CodeObjects::DefinedType < PuppetStrings::Yard::CodeO
     hash[:file] = file
     hash[:line] = line
     hash[:docstring] = PuppetStrings::Yard::Util.docstring_to_hash(docstring)
-    defaults = Hash[*parameters.select{ |p| !p[1].nil? }.flatten]
+    defaults = Hash[*parameters.reject{ |p| p[1].nil? }.flatten]
     hash[:defaults] = defaults unless defaults.empty?
     hash[:source] = source unless source && source.empty?
     hash

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

@@ -88,14 +88,14 @@ 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, [:param, :option, :return, :example]) }
+        hash[:signatures] << { :signature => o.signature, :docstring => PuppetStrings::Yard::Util.docstring_to_hash(o.docstring, %i[param option return example]) }
       end
     else
-      hash[:signatures] << { :signature => self.signature, :docstring =>  PuppetStrings::Yard::Util.docstring_to_hash(docstring, [:param, :option, :return, :example]) }
+      hash[:signatures] << { :signature => self.signature, :docstring =>  PuppetStrings::Yard::Util.docstring_to_hash(docstring, %i[param option return example]) }
     end
 
     hash[:docstring] = PuppetStrings::Yard::Util.docstring_to_hash(docstring)
-    defaults = Hash[*parameters.select{ |p| !p[1].nil? }.flatten]
+    defaults = Hash[*parameters.reject{ |p| p[1].nil? }.flatten]
     hash[:defaults] = defaults unless defaults.empty?
     hash[:source] = source unless source && source.empty?
     hash

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

@@ -48,7 +48,7 @@ class PuppetStrings::Yard::CodeObjects::Plan < PuppetStrings::Yard::CodeObjects:
     hash[:file] = file
     hash[:line] = line
     hash[:docstring] = PuppetStrings::Yard::Util.docstring_to_hash(docstring)
-    defaults = Hash[*parameters.select{ |p| !p[1].nil? }.flatten]
+    defaults = Hash[*parameters.reject{ |p| p[1].nil? }.flatten]
     hash[:defaults] = defaults unless defaults.empty?
     hash[:source] = source unless source && source.empty?
     hash

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

@@ -2,6 +2,7 @@
 module PuppetStrings::Yard::Handlers
   # The module for custom Ruby YARD handlers.
   module Ruby
+    require 'puppet-strings/yard/handlers/ruby/data_type_handler'
     require 'puppet-strings/yard/handlers/ruby/type_handler'
     require 'puppet-strings/yard/handlers/ruby/type_extras_handler'
     require 'puppet-strings/yard/handlers/ruby/rsapi_handler'
@@ -17,6 +18,7 @@ module PuppetStrings::Yard::Handlers
   # The module for custom Puppet YARD handlers.
   module Puppet
     require 'puppet-strings/yard/handlers/puppet/class_handler'
+    require 'puppet-strings/yard/handlers/puppet/data_type_alias_handler'
     require 'puppet-strings/yard/handlers/puppet/defined_type_handler'
     require 'puppet-strings/yard/handlers/puppet/function_handler'
     require 'puppet-strings/yard/handlers/puppet/plan_handler'

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

@@ -0,0 +1,24 @@
+require 'puppet-strings/yard/handlers/helpers'
+require 'puppet-strings/yard/handlers/puppet/base'
+require 'puppet-strings/yard/parsers'
+require 'puppet-strings/yard/code_objects'
+
+# Implements the handler for Puppet Data Type Alias.
+class PuppetStrings::Yard::Handlers::Puppet::DataTypeAliasHandler < PuppetStrings::Yard::Handlers::Puppet::Base
+  handles PuppetStrings::Yard::Parsers::Puppet::DataTypeAliasStatement
+
+  process do
+    # Register the object
+    object = PuppetStrings::Yard::CodeObjects::DataTypeAlias.new(statement)
+    register object
+
+    # Log a warning if missing documentation
+    log.warn "Missing documentation for Puppet type alias '#{object.name}' at #{statement.file}:#{statement.line}." if object.docstring.empty? && object.tags.empty?
+
+    # Mark the class 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
+
+    # Warn if a summary longer than 140 characters was provided
+    PuppetStrings::Yard::Handlers::Helpers.validate_summary_tag(object) if object.has_tag? :summary
+  end
+end

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

@@ -18,7 +18,8 @@ class PuppetStrings::Yard::Handlers::Ruby::Base < YARD::Handlers::Ruby::Base
     when :label
       node.source[0..-2]
     when :dyna_symbol
-      node.source
+      content = node.jump(:tstring_content)
+      content.nil? ? node.source : content.source
     when :string_literal
       content = node.jump(:tstring_content)
       return content.source if content != node
@@ -45,5 +46,4 @@ class PuppetStrings::Yard::Handlers::Ruby::Base < YARD::Handlers::Ruby::Base
     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

@@ -0,0 +1,236 @@
+require 'puppet-strings/yard/handlers/helpers'
+require 'puppet-strings/yard/handlers/ruby/base'
+require 'puppet-strings/yard/code_objects'
+require 'puppet-strings/yard/util'
+
+# Implements the handler for Puppet Data Types written in Ruby.
+class PuppetStrings::Yard::Handlers::Ruby::DataTypeHandler < PuppetStrings::Yard::Handlers::Ruby::Base
+  namespace_only
+  handles method_call(:create_type)
+
+  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)
+
+    # 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)
+
+    # Set the default values for all parameters
+    actual_params.each { |name, data| object.set_parameter_default(name, data[:default]) }
+
+    # Default any typeless param tag to 'Any'
+    object.tags(:param).each do |tag|
+      tag.types = ['Any'] unless tag.types && !tag.types.empty?
+    end
+
+    # Warn if a summary longer than 140 characters was provided
+    PuppetStrings::Yard::Handlers::Helpers.validate_summary_tag(object) if object.has_tag? :summary
+  end
+
+  private
+
+  def get_datatype_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?
+    guess_path = "puppet_data_types::#{name}"
+    object = YARD::Registry.at(guess_path)
+
+    return object unless object.nil?
+
+    # Didn't find, create instead
+    object = PuppetStrings::Yard::CodeObjects::DataType.new(name)
+    register object
+    object
+  end
+
+  def extract_params_for_data_type
+    params = {}
+    # Traverse the block looking for 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
+
+      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
+        # 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)
+      end
+    end
+    params
+  end
+
+  # Lazily evaluates a Pops object, ignoring any objects that cannot
+  # be converted to a literal value. Based on the Puppet Literal Evaluator
+  # Ref - https://github.com/puppetlabs/puppet/blob/ba4d1a1aba0095d3c70b98fea5c67434a4876a61/lib/puppet/pops/evaluator/literal_evaluator.rb
+  #
+  # Literal values for:
+  # String (not containing interpolation)
+  # Numbers
+  # Booleans
+  # Undef (produces nil)
+  # Array
+  # Hash
+  # QualifiedName
+  # Default (produced :default)
+  # Regular Expression (produces ruby regular expression)
+  # QualifiedReference  e.g. File, FooBar
+  # AccessExpression
+  #
+  # Anything else is ignored
+  class LazyLiteralEvaluator
+    def initialize
+      @literal_visitor ||= ::Puppet::Pops::Visitor.new(self, "literal", 0, 0)
+    end
+
+    def literal(ast)
+      @literal_visitor.visit_this_0(self, ast)
+    end
+
+    # ----- The following methods are different/additions from the original Literal_evaluator
+    def literal_Object(o) # rubocop:disable Naming/UncommunicativeMethodParamName
+      # Ignore any other object types
+    end
+
+    def literal_AccessExpression(o) # rubocop:disable Naming/UncommunicativeMethodParamName
+      # 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
+      # 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
+      literal(o.model)
+    end
+
+    def literal_Program(o) # rubocop:disable Naming/UncommunicativeMethodParamName
+      literal(o.body)
+    end
+
+    def literal_LiteralString(o) # rubocop:disable Naming/UncommunicativeMethodParamName
+      o.value
+    end
+
+    def literal_QualifiedName(o) # rubocop:disable Naming/UncommunicativeMethodParamName
+      o.value
+    end
+
+    def literal_LiteralNumber(o) # rubocop:disable Naming/UncommunicativeMethodParamName
+      o.value
+    end
+
+    def literal_LiteralBoolean(o) # rubocop:disable Naming/UncommunicativeMethodParamName
+      o.value
+    end
+
+    def literal_LiteralUndef(o) # rubocop:disable Naming/UncommunicativeMethodParamName
+      nil
+    end
+
+    def literal_LiteralDefault(o) # rubocop:disable Naming/UncommunicativeMethodParamName
+      :default
+    end
+
+    def literal_LiteralRegularExpression(o) # rubocop:disable Naming/UncommunicativeMethodParamName
+      o.value
+    end
+
+    def literal_ConcatenatedString(o) # rubocop:disable Naming/UncommunicativeMethodParamName
+      # 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) }
+    end
+
+    def literal_LiteralHash(o) # rubocop:disable Naming/UncommunicativeMethodParamName
+      o.entries.reduce({}) do |result, entry|
+        result[literal(entry.key)] = literal(entry.value)
+        result
+      end
+    end
+  end
+
+  def populate_data_type_params_from_literal_hash!(hash, params_hash)
+    return if hash.nil?
+    # Exit early if there are no entries in the hash
+    return if hash['attributes'].nil? || hash['attributes'].count.zero?
+
+    hash['attributes'].each do |key, value|
+      data_type = nil
+      default = nil
+      case value
+      when String
+        data_type = value
+      when 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
+  end
+
+  def validate_tags!(object, actual_params_hash)
+    actual_param_names = actual_params_hash.keys
+    tagged_param_names = object.tags(:param).map(&:name)
+    # Log any errors
+    # Find attributes which are not documented
+    (actual_param_names - tagged_param_names).each do |item|
+      log.warn "Missing @param tag for attribute '#{item}' near #{object.file}:#{object.line}."
+    end
+    # Find param tags with no matching attribute
+    (tagged_param_names - actual_param_names).each do |item|
+      log.warn "The @param tag for '#{item}' has no matching attribute near #{object.file}:#{object.line}."
+    end
+    # 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
+
+    # Automatically fix missing @param tags
+    (actual_param_names - tagged_param_names).each do |name|
+      object.add_parameter(name, actual_params_hash[name][:types], actual_params_hash[name][:default])
+    end
+    # Remove extra param tags
+    object.docstring.delete_tag_if { |item| item.tag_name == 'param' && !actual_param_names.include?(item.name) }
+
+    # 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
+end