Class: Gem::Specification [RDoc Documentation]

The Specification class contains the metadata for a Gem. Typically defined in a .gemspec file or a Rakefile, and looks like this:

  spec = Gem::Specification.new do |s|
    s.name = 'rfoo'
    s.version = '1.0'
    s.summary = 'Example gem specification'
    ...
  end

For a great way to package gems, use Hoe.

Required gemspec attributes
Optional gemspec attributes
Aliased gemspec attributes

Methods

_dump _load add_bindir add_dependency add_development_dependency add_runtime_dependency array_attribute array_attributes assign_defaults attribute attribute_alias_singular attribute_defaults attribute_names attributes author authors autorequire bindir cert_chain date default_executable default_value dependencies dependent_gems description development_dependencies email executable executables extensions extra_rdoc_files file_name files from_yaml full_gem_path full_name has_rdoc has_rdoc has_rdoc? has_unit_tests? homepage initialize_copy installation_path lib_files license licenses load mark_version name new normalize normalize_yaml_input overwrite_accessor platform post_install_message rdoc_options read_only require_path require_paths required_attribute required_attribute? required_attributes required_ruby_version required_rubygems_version requirements rubyforge_project rubygems_version runtime_dependencies satisfies_requirement? signing_key sort_obj specification_version summary test_file test_files to_ruby validate version

Constants

NONEXISTENT_SPECIFICATION_VERSION	=	-1	The the version number of a specification that does not specify one (i.e. RubyGems 0.7 or earlier).
CURRENT_SPECIFICATION_VERSION	=	3	The specification version applied to any new Specification instances created. This should be bumped whenever something in the spec format changes.
SPECIFICATION_VERSION_HISTORY	=	{ -1 => ['(RubyGems versions up to and including 0.7 did not have versioned specifications)'], 1 => [ 'Deprecated "test_suite_file" in favor of the new, but equivalent, "test_files"', '"test_file=x" is a shortcut for "test_files=[x]"' ], 2 => [ 'Added "required_rubygems_version"', 'Now forward-compatible with future versions', ], 3 => [ 'Added Fixnum validation to the specification_version' ] }	An informal list of changes to the specification. The highest-valued key should be equal to the CURRENT_SPECIFICATION_VERSION.

External Aliases

loaded	->	loaded?
	True if this gem was loaded from disk
==	->	eql?

Attributes

loaded	[RW]	true when this gemspec has been loaded from a specifications directory. This attribute is not persisted.
loaded_from	[RW]	Path this gemspec was loaded from. This attribute is not persisted.

Public Class methods

_load(str)

Load custom marshal format, re-initializing defaults as needed

array_attribute(name)

Same as :attribute, but ensures that values assigned to the attribute are array values by applying :to_a to the value.

array_attributes()

Specification attributes that are arrays (appendable and so-forth)

attribute(name, default=nil)

Specifies the name and default for a specification attribute, and creates a reader and writer method like Module#attr_accessor.

The reader method returns the default if the value hasn’t been set.

attribute_alias_singular(singular, plural)

Defines a singular version of an existing plural attribute (i.e. one whose value is expected to be an array). This means just creating a helper method that takes a single value and appends it to the array. These are created for convenience, so that in a spec, one can write

  s.require_path = 'mylib'

instead of:

  s.require_paths = ['mylib']

That above convenience is available courtesy of:

  attribute_alias_singular :require_path, :require_paths

attribute_defaults()

Default values for specification attributes

attribute_names()

Names of all specification attributes

attributes(*args)

Shortcut for creating several attributes at once (each with a default value of nil).

default_value(name)

The default value for specification attribute name

from_yaml(input)

Special loader for YAML files. When a Specification object is loaded from a YAML file, it bypasses the normal Ruby object initialization routine (initialize). This method makes up for that and deals with gems of different ages.

‘input’ can be anything that YAML.load() accepts: String or IO.

load(filename)

Loads ruby format gemspec from filename

new() {|self if block_given?| ...}

Specification constructor. Assigns the default values to the attributes and yields itself for further initialization.

normalize_yaml_input(input)

Make sure the YAML specification is properly formatted with dashes

overwrite_accessor(name, &block)

Some attributes require special behaviour when they are accessed. This allows for that.

read_only(*names)

Sometimes we don’t want the world to use a setter method for a particular attribute.

read_only makes it private so we can still use it internally.

required_attribute(*args)

Same as attribute above, but also records this attribute as mandatory.

required_attribute?(name)

Is name a required attribute?

required_attributes()

Required specification attributes

Public Instance methods

_dump(limit)

Dump only crucial instance variables.

add_bindir(executables)

Returns an array with bindir attached to each executable in the executables list

add_dependency(gem, *requirements)

Alias for add_runtime_dependency

add_development_dependency(gem, *requirements)

Adds a development dependency named gem with requirements to this Gem. For example:

  spec.add_development_dependency 'jabber4r', '> 0.1', '<= 0.5'

Development dependencies aren’t installed by default and aren’t activated when a gem is required.

add_runtime_dependency(gem, *requirements)

Adds a runtime dependency named gem with requirements to this Gem. For example:

  spec.add_runtime_dependency 'jabber4r', '> 0.1', '<= 0.5'

assign_defaults()

Each attribute has a default value (possibly nil). Here, we initialize all attributes to their default value. This is done through the accessor methods, so special behaviours will be honored. Furthermore, we take a copy of the default so each specification instance has its own empty arrays, etc.

dependent_gems()

Return a list of all gems that have a dependency on this gemspec. The list is structured with entries that conform to:

  [depending_gem, dependency, [list_of_gems_that_satisfy_dependency]]

development_dependencies()

List of dependencies that are used for development

file_name()

The default (generated) file name of the gem.

full_gem_path()

The full path to the gem (install path + full name).

full_name()

Returns the full name (name-version) of this Gem. Platform information is included (name-version-platform) if it is specified and not the default Ruby platform.

has_unit_tests?()

True if this gem has files in test_files

initialize_copy(other_spec)

Duplicates array_attributes from other_spec so state isn’t shared.

installation_path()

The directory that this gem was installed into.

lib_files()

Files in the Gem under one of the require_paths

mark_version()

Sets the rubygems_version to the current RubyGems version

normalize()

Normalize the list of files so that:

All file lists have redundancies removed.
Files referenced in the extra_rdoc_files are included in the package file list.

runtime_dependencies()

List of depedencies that will automatically be activated at runtime.

satisfies_requirement?(dependency)

Checks if this specification meets the requirement of dependency.

sort_obj()

Returns an object you can use to sort specifications in sort_by.

to_ruby()

Returns a Ruby code representation of this specification, such that it can be eval’ed and reconstruct the same specification later. Attributes that still have their default values are omitted.

validate()

Checks that the specification contains all required fields, and does a very basic sanity check.

Raises InvalidSpecificationException if the spec does not pass the checks..