Class: PuppetMetadata::Metadata

Inherits:
Object
  • Object
show all
Defined in:
lib/puppet_metadata/metadata.rb

Overview

An abstraction over Puppet metadata

Constant Summary collapse

SUPPORTED_REQUIREMENTS = 
['openvox', 'puppet'].freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(metadata, validate = true) ⇒ Metadata

Returns a new instance of Metadata.

Parameters:

  • metadata (Hash[String, Any]) —

    The metadata as a data structure

  • validate (Boolean) (defaults to: true) —

    Whether to validate the metadata using metadata-json-lint

Raises:

See Also:



36
37
38
39
40
41
42
43
44
 
# File 'lib/puppet_metadata/metadata.rb', line 36

def initialize(metadata, validate = true)
  if validate
    require 'metadata_json_lint'
    schema_errors = MetadataJsonLint::Schema.new.validate(metadata)
    raise InvalidMetadataException, schema_errors if schema_errors.any?
  end

  @metadata = metadata
end

Instance Attribute Details

#metadata ⇒ Object (readonly)

Returns the value of attribute metadata.



25
26
27
 
# File 'lib/puppet_metadata/metadata.rb', line 25

def metadata
  @metadata
end

Instance Method Details

#dependencies ⇒ Hash[String, SemanticPuppet::VersionRange]

A hash representation of the dependencies

Every element in the original array is converted. The name is used as a key while version_requirement is used as a value. No value indicates any version is accepted.

Examples:

metadata = Metadata.new(data)
metadata.dependencies.each do |os, releases|
  if releases
    releases.each do |release|
      puts "#{metadata.name} supports #{os} #{release}"
    end
  else
    puts "#{metadata.name} supports all #{os} releases"
  end
end

Returns:

  • (Hash[String, SemanticPuppet::VersionRange]) —

    The dependencies of the module

See Also:



186
187
188
 
# File 'lib/puppet_metadata/metadata.rb', line 186

def dependencies
  @dependencies ||= build_version_requirement_hash(metadata['dependencies'])
end

#eol_operatingsystems(at = nil) ⇒ Hash[String, Array[String]]

Parameters:

  • at (Date) (defaults to: nil) —

    The date to check the EOL time. Today is used when nil.

Returns:

  • (Hash[String, Array[String]]) 


99
100
101
102
103
104
105
106
107
108
109
110
 
# File 'lib/puppet_metadata/metadata.rb', line 99

def eol_operatingsystems(at = nil)
  at ||= Date.today

  unsupported = operatingsystems.map do |os, rels|
    next unless rels

    eol = rels.select { |rel| OperatingSystem.eol?(os, rel, at) }
    [os, eol] if eol.any?
  end

  unsupported.compact.to_h
end

#github_actions(options) ⇒ PuppetMetadata::GithubActions

Returns A GithubActions instance.

Parameters:

  • options (Hash) —

    A hash containing the command line options

Returns:



199
200
201
 
# File 'lib/puppet_metadata/metadata.rb', line 199

def github_actions(options)
  PuppetMetadata::GithubActions.new(self, options)
end

#license ⇒ String

The license

Returns:

  • (String) —

    The license



60
61
62
 
# File 'lib/puppet_metadata/metadata.rb', line 60

def license
  metadata['license']
end

#major_versions(requirement_name) ⇒ Array[Integer]

Returns Supported major Puppet versions.

Returns:

  • (Array[Integer]) —

    Supported major Puppet versions

See Also:



151
152
153
154
155
156
 
# File 'lib/puppet_metadata/metadata.rb', line 151

def major_versions(requirement_name)
  requirement = requirements[requirement_name]
  return [] unless requirement

  major_version_for_requirement(requirement)
end

#major_versions!(requirement_name) ⇒ Object

Raises:

  • (Exception) 


158
159
160
161
162
163
 
# File 'lib/puppet_metadata/metadata.rb', line 158

def major_versions!(requirement_name)
  requirement = requirements[requirement_name]
  raise Exception, "No '#{requirement_name}' requirement found'" unless requirement

  major_version_for_requirement(requirement)
end

#name ⇒ String

The name

Returns:

  • (String) —

    The name



48
49
50
 
# File 'lib/puppet_metadata/metadata.rb', line 48

def name
  metadata['name']
end

#operatingsystems ⇒ Hash[String, Array[String]]

Returns The supported operating system and its major releases.

Returns:

  • (Hash[String, Array[String]]) —

    The supported operating system and its major releases



66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/puppet_metadata/metadata.rb', line 66

def operatingsystems
  @operatingsystems ||= begin
    return {} if metadata['operatingsystem_support'].nil?

    supported = metadata['operatingsystem_support'].map do |os|
      next unless os['operatingsystem']

      [os['operatingsystem'], os['operatingsystemrelease']]
    end

    supported.compact.to_h
  end
end

#os_release_supported?(operatingsystem, release) ⇒ Boolean

Returns whether an operating system’s release is supported

Parameters:

  • operatingsystem (String) —

    The operating system

  • release (String) —

    The major release of the OS

Returns:

  • (Boolean) —

    Whether an operating system’s release is supported



85
86
87
88
89
90
91
92
93
94
95
 
# File 'lib/puppet_metadata/metadata.rb', line 85

def os_release_supported?(operatingsystem, release)
  # If no OS is present, everything is supported. An example of this is
  # modules with only functions.
  return true if operatingsystems.empty?

  # if the key present, nil indicates all releases are supported
  return false unless operatingsystems.key?(operatingsystem)

  releases = operatingsystems[operatingsystem]
  releases.nil? || releases.include?(release)
end

#requirements ⇒ Hash[String, SemanticPuppet::VersionRange]

A hash representation of the requirements

Every element in the original array is converted. The name is used as a key while version_requirement is used as a value. No value indicates any version is accepted.

Examples:

metadata = Metadata.new(data)
metadata.requirements.each do |requirement, version_requirement|
  if version_requirement
    puts "#{metadata.name} requires #{requirement} #{version_requirement}"
  else
    puts "#{metadata.name} requires any #{requirement}"
  end
end

Returns:

  • (Hash[String, SemanticPuppet::VersionRange]) —

    The requirements of the module

See Also:



131
132
133
 
# File 'lib/puppet_metadata/metadata.rb', line 131

def requirements
  @requirements ||= build_version_requirement_hash(metadata['requirements'])
end

#requirements_with_major_versions ⇒ Object 



142
143
144
145
146
147
 
# File 'lib/puppet_metadata/metadata.rb', line 142

def requirements_with_major_versions
  SUPPORTED_REQUIREMENTS.filter_map do |requirement|
    majors = major_versions(requirement)
    [requirement, majors] unless majors.empty?
  end.to_h
end

#satisfies_dependency?(name, version) ⇒ Boolean

Parameters:

  • name (String) —

    The name of the dependency

  • version (String) —

    The version of the dependency

Returns:

  • (Boolean)

See Also:



193
194
195
 
# File 'lib/puppet_metadata/metadata.rb', line 193

def satisfies_dependency?(name, version)
  matches?(dependencies[name], version)
end

#satisfies_requirement?(name, version) ⇒ Boolean

Parameters:

  • name (String) —

    The name of the requirement

  • version (String) —

    The version of the requirement

Returns:

  • (Boolean)

See Also:



138
139
140
 
# File 'lib/puppet_metadata/metadata.rb', line 138

def satisfies_requirement?(name, version)
  matches?(requirements[name], version)
end

#version ⇒ String

The version

Returns:

  • (String) 


54
55
56
 
# File 'lib/puppet_metadata/metadata.rb', line 54

def version
  metadata['version']
end