1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
|
# Module Puppet::IniConfig
# A generic way to parse .ini style files and manipulate them in memory
# One 'file' can be made up of several physical files. Changes to sections
# on the file are tracked so that only the physical files in which
# something has changed are written back to disk
# Great care is taken to preserve comments and blank lines from the original
# files
#
# The parsing tries to stay close to python's ConfigParser
require 'puppet/util/filetype'
module Puppet::Util::IniConfig
# A section in a .ini file
class Section
attr_reader :name, :file
def initialize(name, file)
@name = name
@file = file
@dirty = false
@entries = []
end
# Has this section been modified since it's been read in
# or written back to disk
def dirty?
@dirty
end
# Should only be used internally
def mark_clean
@dirty = false
end
# Add a line of text (e.g., a comment) Such lines
# will be written back out in exactly the same
# place they were read in
def add_line(line)
@entries << line
end
# Set the entry 'key=value'. If no entry with the
# given key exists, one is appended to teh end of the section
def []=(key, value)
entry = find_entry(key)
@dirty = true
if entry.nil?
@entries << [key, value]
else
entry[1] = value
end
end
# Return the value associated with KEY. If no such entry
# exists, return nil
def [](key)
entry = find_entry(key)
return(entry.nil? ? nil : entry[1])
end
# Format the section as text in the way it should be
# written to file
def format
text = "[#{name}]\n"
@entries.each do |entry|
if entry.is_a?(Array)
key, value = entry
text << "#{key}=#{value}\n" unless value.nil?
else
text << entry
end
end
text
end
private
def find_entry(key)
@entries.each do |entry|
return entry if entry.is_a?(Array) && entry[0] == key
end
nil
end
end
# A logical .ini-file that can be spread across several physical
# files. For each physical file, call #read with the filename
class File
def initialize
@files = {}
end
# Add the contents of the file with name FILE to the
# already existing sections
def read(file)
text = Puppet::Util::FileType.filetype(:flat).new(file).read
raise "Could not find #{file}" if text.nil?
section = nil # The name of the current section
optname = nil # The name of the last option in section
line = 0
@files[file] = []
text.each_line do |l|
line += 1
if l.strip.empty? || "#;".include?(l[0,1]) ||
(l.split(nil, 2)[0].downcase == "rem" && l[0,1].downcase == "r")
# Whitespace or comment
if section.nil?
@files[file] << l
else
section.add_line(l)
end
elsif " \t\r\n\f".include?(l[0,1]) && section && optname
# continuation line
section[optname] += "\n#{l.chomp}"
elsif l =~ /^\[([^\]]+)\]/
# section heading
section.mark_clean unless section.nil?
section = add_section($1, file)
optname = nil
elsif l =~ /^\s*([^\s=]+)\s*\=(.*)$/
# We allow space around the keys, but not the values
# For the values, we don't know if space is significant
if section.nil?
raise "#{file}:#{line}:Key/value pair outside of a section for key #{$1}"
else
section[$1] = $2
optname = $1
end
else
raise "#{file}:#{line}: Can't parse '#{l.chomp}'"
end
end
section.mark_clean unless section.nil?
end
# Store all modifications made to sections in this file back
# to the physical files. If no modifications were made to
# a physical file, nothing is written
def store
@files.each do |file, lines|
text = ""
dirty = false
lines.each do |l|
if l.is_a?(Section)
dirty ||= l.dirty?
text << l.format
l.mark_clean
else
text << l
end
end
if dirty
Puppet::Util::FileType.filetype(:flat).new(file).write(text)
return file
end
end
end
# Execute BLOCK, passing each section in this file
# as an argument
def each_section(&block)
@files.each do |file, list|
list.each do |entry|
yield(entry) if entry.is_a?(Section)
end
end
end
# Execute BLOCK, passing each file constituting this inifile
# as an argument
def each_file(&block)
@files.keys.each do |file|
yield(file)
end
end
# Return the Section with the given name or nil
def [](name)
name = name.to_s
each_section do |section|
return section if section.name == name
end
nil
end
# Return true if the file contains a section with name NAME
def include?(name)
! self[name].nil?
end
# Add a section to be stored in FILE when store is called
def add_section(name, file)
raise "A section with name #{name} already exists" if include?(name)
result = Section.new(name, file)
@files[file] ||= []
@files[file] << result
result
end
end
end
|
