class Puppet::Module

# File lib/puppet/module.rb, line 157
def all_manifests
  return [] unless Puppet::FileSystem.exist?(manifests)

  Dir.glob(File.join(manifests, '**', '*.{rb,pp}'))
end

# File lib/puppet/module.rb, line 198
def dependencies_as_modules
  dependent_modules = []
  dependencies and dependencies.each do |dep|
    author, dep_name = dep["name"].split('/')
    found_module = environment.module(dep_name)
    dependent_modules << found_module if found_module
  end

  dependent_modules
end

# File lib/puppet/module.rb, line 183
def has_external_facts?
  File.directory?(plugin_fact_directory)
end

# File lib/puppet/module.rb, line 213
def has_local_changes?
  Puppet.deprecation_warning("This method is being removed.")
  require 'puppet/module_tool/applications'
  changes = Puppet::ModuleTool::Applications::Checksummer.run(path)
  !changes.empty?
end

# File lib/puppet/module.rb, line 56
def has_metadata?
  return false unless metadata_file

  return false unless Puppet::FileSystem.exist?(metadata_file)

  begin
    metadata =  JSON.parse(File.read(metadata_file))
  rescue JSON::JSONError => e
    Puppet.debug("#{name} has an invalid and unparsable metadata.json file.  The parse error: #{e.message}")
    return false
  end

  return metadata.is_a?(Hash) && !metadata.keys.empty?
end

# File lib/puppet/module.rb, line 109
def license_file
  return @license_file if defined?(@license_file)

  return @license_file = nil unless path
  @license_file = File.join(path, "License")
end

# File lib/puppet/module.rb, line 116
def load_metadata
  @metadata = data = JSON.parse(File.read(metadata_file))
  @forge_name = data['name'].gsub('-', '/') if data['name']

  [:source, :author, :version, :license, :puppetversion, :dependencies].each do |attr|
    unless value = data[attr.to_s]
      unless attr == :puppetversion
        raise MissingMetadata, "No #{attr} module metadata provided for #{self.name}"
      end
    end

    # NOTICE: The fallback to `versionRequirement` is something we'd like to
    # not have to support, but we have a reasonable number of releases that
    # don't use `version_requirement`. When we can deprecate this, we should.
    if attr == :dependencies
      value.tap do |dependencies|
        dependencies.each do |dep|
          dep['version_requirement'] ||= dep['versionRequirement'] || '>= 0.0.0'
        end
      end
    end

    send(attr.to_s + "=", value)
  end
end

# File lib/puppet/module.rb, line 220
def local_changes
  Puppet.deprecation_warning("This method is being removed.")
  require 'puppet/module_tool/applications'
  Puppet::ModuleTool::Applications::Checksummer.run(path)
end

# File lib/puppet/module.rb, line 144
def match_manifests(rest)
  if rest
    wanted_manifests = wanted_manifests_from(rest)
    searched_manifests = wanted_manifests.glob.reject { |f| FileTest.directory?(f) }
  else
    searched_manifests = []
  end

  # (#4220) Always ensure init.pp in case class is defined there.
  init_manifests = [manifest("init.pp"), manifest("init.rb")].compact
  init_manifests + searched_manifests
end

# File lib/puppet/module.rb, line 163
def metadata_file
  return @metadata_file if defined?(@metadata_file)

  return @metadata_file = nil unless path
  @metadata_file = File.join(path, "metadata.json")
end

# File lib/puppet/module.rb, line 170
def modulepath
  File.dirname(path) if path
end

# File lib/puppet/module.rb, line 175
def plugin_directory
  subpath("lib")
end

# File lib/puppet/module.rb, line 179
def plugin_fact_directory
  subpath("facts.d")
end

# File lib/puppet/module.rb, line 209
def required_by
  environment.module_requirements[self.forge_name] || {}
end

# File lib/puppet/module.rb, line 187
def supports(name, version = nil)
  @supports ||= []
  @supports << [name, version]
end

# File lib/puppet/module.rb, line 192
def to_s
  result = "Module #{name}"
  result += "(#{path})" if path
  result
end

# File lib/puppet/module.rb, line 252
def unmet_dependencies
  unmet_dependencies = []
  return unmet_dependencies unless dependencies

  dependencies.each do |dependency|
    forge_name = dependency['name']
    version_string = dependency['version_requirement'] || '>= 0.0.0'

    dep_mod = begin
      environment.module_by_forge_name(forge_name)
    rescue
      nil
    end

    error_details = {
      :name => forge_name,
      :version_constraint => version_string.gsub(/^(?=\d)/, "v"),
      :parent => {
        :name => self.forge_name,
        :version => self.version.gsub(/^(?=\d)/, "v")
      },
      :mod_details => {
        :installed_version => dep_mod.nil? ? nil : dep_mod.version
      }
    }

    unless dep_mod
      error_details[:reason] = :missing
      unmet_dependencies << error_details
      next
    end

    if version_string
      begin
        required_version_semver_range = SemVer[version_string]
        actual_version_semver = SemVer.new(dep_mod.version)
      rescue ArgumentError
        error_details[:reason] = :non_semantic_version
        unmet_dependencies << error_details
        next
      end

      unless required_version_semver_range.include? actual_version_semver
        error_details[:reason] = :version_mismatch
        unmet_dependencies << error_details
        next
      end
    end
  end

  unmet_dependencies
end

# File lib/puppet/module.rb, line 305
def validate_puppet_version
  return unless puppetversion and puppetversion != Puppet.version
  raise IncompatibleModule, "Module #{self.name} is only compatible with Puppet version #{puppetversion}, not #{Puppet.version}"
end

# File lib/puppet/module.rb, line 29
def self.find(modname, environment = nil)
  return nil unless modname
  # Unless a specific environment is given, use the current environment
  env = environment ? Puppet.lookup(:environments).get!(environment) : Puppet.lookup(:current_environment)
  env.module(modname)
end

# File lib/puppet/module.rb, line 42
def initialize(name, path, environment)
  @name = name
  @path = path
  @environment = environment

  assert_validity

  load_metadata if has_metadata?

  validate_puppet_version

  @absolute_path_to_manifests = Puppet::FileSystem::PathPattern.absolute(manifests)
end