Class: Fig::Package

Inherits:
Object
  • Object
show all
Includes:
Comparable
Defined in:
lib/fig/package.rb

Overview

The parsed representation of a configuration file. Contains the statement objects.

Constant Summary collapse

UNPUBLISHED = 
'<unpublished>'
DEFAULT_CONFIG = 
'default'

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(package_name, version_name, directory, statements) ⇒ Package

Returns a new instance of Package.



21
22
23
24
25
26
27
28
 
# File 'lib/fig/package.rb', line 21

def initialize(package_name, version_name, directory, statements)
  @package_name = package_name
  @version_name = version_name
  @directory = directory
  @statements = statements
  @applied_config_names = []
  @backtrace = nil
end

Instance Attribute Details

#backtrace ⇒ Object

Returns the value of attribute backtrace.



19
20
21
 
# File 'lib/fig/package.rb', line 19

def backtrace
  @backtrace
end

#directory ⇒ Object (readonly)

Returns the value of attribute directory.



18
19
20
 
# File 'lib/fig/package.rb', line 18

def directory
  @directory
end

#package_name ⇒ Object (readonly)

Returns the value of attribute package_name.



18
19
20
 
# File 'lib/fig/package.rb', line 18

def package_name
  @package_name
end

#statements ⇒ Object (readonly)

Returns the value of attribute statements.



18
19
20
 
# File 'lib/fig/package.rb', line 18

def statements
  @statements
end

#version_name ⇒ Object (readonly)

Returns the value of attribute version_name.



18
19
20
 
# File 'lib/fig/package.rb', line 18

def version_name
  @version_name
end

Instance Method Details

#<=>(other) ⇒ Object 



46
47
48
49
50
51
 
# File 'lib/fig/package.rb', line 46

def <=>(other)
  compared = compare_components(package_name, other.package_name)
  return compared if compared != 0

  return compare_components(version_name, other.version_name)
end

#==(other) ⇒ Object 



134
135
136
137
138
139
140
 
# File 'lib/fig/package.rb', line 134

def ==(other)
  return false if other.nil?

  return @package_name == other.package_name &&
         @version_name == other.version_name &&
         @statements.to_yaml == other.statements.to_yaml
end

#[](config_name) ⇒ Object

Raises:



30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
# File 'lib/fig/package.rb', line 30

def [](config_name)
  @statements.each do |stmt|
    return stmt if stmt.is_a?(Fig::Statement::Configuration) && stmt.name == config_name
  end

  message =
    'Configuration not found: ' +
    (@package_name || '<empty>')  +
    '/'                         +
    (@version_name || '<empty>')  +
    ':'                         +
    (config_name || '<empty>')

  raise Fig::PackageError.new(message)
end

#add_applied_config_name(name) ⇒ Object 



85
86
87
 
# File 'lib/fig/package.rb', line 85

def add_applied_config_name(name)
  @applied_config_names << name
end

#applied_config_names ⇒ Object 



81
82
83
 
# File 'lib/fig/package.rb', line 81

def applied_config_names()
  return @applied_config_names.clone
end

#archive_urls ⇒ Object 



73
74
75
 
# File 'lib/fig/package.rb', line 73

def archive_urls
  return @statements.select{|s| s.is_a?(Fig::Statement::Archive)}.map{|s| s.url}
end

#config_names ⇒ Object 



57
58
59
 
# File 'lib/fig/package.rb', line 57

def config_names
  return configs.collect { |statement| statement.name }
end

#configs ⇒ Object 



53
54
55
 
# File 'lib/fig/package.rb', line 53

def configs
  return @statements.select { |statement| statement.is_a?(Fig::Statement::Configuration) }
end

#package_dependencies(config_name) ⇒ Object

Returns an array of PackageDescriptors



94
95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/fig/package.rb', line 94

def package_dependencies(config_name)
  descriptors = []

  self[config_name || DEFAULT_CONFIG].walk_statements do
    |statement|

    if statement.is_a?(Fig::Statement::Include)
      descriptors << statement.resolved_dependency_descriptor(self)
    end
  end

  return descriptors
end

#primary_config_name ⇒ Object 



89
90
91
 
# File 'lib/fig/package.rb', line 89

def primary_config_name()
  return @applied_config_names.first
end

#resource_urls ⇒ Object 



77
78
79
 
# File 'lib/fig/package.rb', line 77

def resource_urls
  return @statements.select{|s| s.is_a?(Fig::Statement::Resource)}.map{|s|s.url}
end

#retrieves ⇒ Object 



61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/fig/package.rb', line 61

def retrieves
  retrieves = {}

  statements.each do
    |statement|

    retrieves[statement.var] = statement.path if statement.is_a?(Fig::Statement::Retrieve)
  end

  return retrieves
end

#to_s ⇒ Object 



142
143
144
145
146
 
# File 'lib/fig/package.rb', line 142

def to_s
  package_name = @package_name || '<empty>'
  version_name = @version_name || '<empty>'
  return package_name + '/' + version_name
end

#to_s_with_config(config_name) ⇒ Object 



148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
 
# File 'lib/fig/package.rb', line 148

def to_s_with_config(config_name)
  string = nil

  if package_name.nil?
    string = UNPUBLISHED
  else
    string = to_s
  end

  if not config_name.nil? and config_name != DEFAULT_CONFIG
    string += ":#{config_name}"
  end

  return string
end

#to_s_with_primary_config ⇒ Object 



164
165
166
 
# File 'lib/fig/package.rb', line 164

def to_s_with_primary_config()
  return to_s_with_config(primary_config_name)
end

#unparse ⇒ Object 



130
131
132
 
# File 'lib/fig/package.rb', line 130

def unparse
  return @statements.map { |statement| statement.unparse('') }.join("\n")
end

#walk_statements(&block) ⇒ Object

Block will receive a Statement.



109
110
111
112
113
114
115
116
 
# File 'lib/fig/package.rb', line 109

def walk_statements(&block)
  @statements.each do |statement|
    yield statement
    statement.walk_statements &block
  end

  return
end

#walk_statements_following_package_dependencies(repository, &block) ⇒ Object

Block will receive a Package and a Statement.



119
120
121
122
123
124
125
126
127
128
 
# File 'lib/fig/package.rb', line 119

def walk_statements_following_package_dependencies(repository, &block)
  @statements.each do |statement|
    yield self, statement
    statement.walk_statements_following_package_dependencies(
      repository, self, &block
    )
  end

  return
end