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
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
|
require File.expand_path('../external_iterator', __FILE__)
require File.expand_path('../ini_file/section', __FILE__)
module Puppet
module Util
class IniFile
SECTION_REGEX = /^\s*\[([\w\d\.\\\/\-\:]+)\]\s*$/
SETTING_REGEX = /^(\s*)([\w\d\.\\\/\-]+)(\s*=\s*)([\S\s]*\S)\s*$/
def initialize(path, key_val_separator = ' = ')
@path = path
@key_val_separator = key_val_separator
@section_names = []
@sections_hash = {}
if File.file?(@path)
parse_file
end
end
def section_names
@section_names
end
def get_value(section_name, setting)
if (@sections_hash.has_key?(section_name))
@sections_hash[section_name].get_value(setting)
end
end
def set_value(section_name, setting, value)
unless (@sections_hash.has_key?(section_name))
add_section(Section.new(section_name, nil, nil, nil, nil))
end
section = @sections_hash[section_name]
if (section.has_existing_setting?(setting))
update_line(section, setting, value)
section.update_existing_setting(setting, value)
else
section.set_additional_setting(setting, value)
end
end
def remove_setting(section_name, setting)
section = @sections_hash[section_name]
if (section.has_existing_setting?(setting))
# If the setting is found, we have some work to do.
# First, we remove the line from our array of lines:
remove_line(section, setting)
# Then, we need to tell the setting object to remove
# the setting from its state:
section.remove_existing_setting(setting)
# Finally, we need to update all of the start/end line
# numbers for all of the sections *after* the one that
# was modified.
section_index = @section_names.index(section_name)
decrement_section_line_numbers(section_index + 1)
end
end
def save
File.open(@path, 'w') do |fh|
@section_names.each_index do |index|
name = @section_names[index]
section = @sections_hash[name]
# We need a buffer to cache lines that are only whitespace
whitespace_buffer = []
if section.start_line.nil?
fh.puts("\n[#{section.name}]")
elsif ! section.end_line.nil?
(section.start_line..section.end_line).each do |line_num|
line = lines[line_num]
# We buffer any lines that are only whitespace so that
# if they are at the end of a section, we can insert
# any new settings *before* the final chunk of whitespace
# lines.
if (line =~ /^\s*$/)
whitespace_buffer << line
else
# If we get here, we've found a non-whitespace line.
# We'll flush any cached whitespace lines before we
# write it.
flush_buffer_to_file(whitespace_buffer, fh)
fh.puts(line)
end
end
end
section.additional_settings.each_pair do |key, value|
fh.puts("#{' ' * (section.indentation || 0)}#{key}#{@key_val_separator}#{value}")
end
if (whitespace_buffer.length > 0)
flush_buffer_to_file(whitespace_buffer, fh)
else
# We get here if there were no blank lines at the end of the
# section.
#
# If we are adding a new section with a new setting,
# and if there are more sections that come after this one,
# we'll write one blank line just so that there is a little
# whitespace between the sections.
if (section.end_line.nil? &&
(section.additional_settings.length > 0) &&
(index < @section_names.length - 1))
fh.puts("")
end
end
end
end
end
private
def add_section(section)
@sections_hash[section.name] = section
@section_names << section.name
end
def parse_file
line_iter = create_line_iter
# We always create a "global" section at the beginning of the file, for
# anything that appears before the first named section.
section = read_section('', 0, line_iter)
add_section(section)
line, line_num = line_iter.next
while line
if (match = SECTION_REGEX.match(line))
section = read_section(match[1], line_num, line_iter)
add_section(section)
end
line, line_num = line_iter.next
end
end
def read_section(name, start_line, line_iter)
settings = {}
end_line_num = nil
min_indentation = nil
while true
line, line_num = line_iter.peek
if (line_num.nil? or match = SECTION_REGEX.match(line))
return Section.new(name, start_line, end_line_num, settings, min_indentation)
elsif (match = SETTING_REGEX.match(line))
settings[match[2]] = match[4]
indentation = match[1].length
min_indentation = [indentation, min_indentation || indentation].min
end
end_line_num = line_num
line_iter.next
end
end
def update_line(section, setting, value)
(section.start_line..section.end_line).each do |line_num|
if (match = SETTING_REGEX.match(lines[line_num]))
if (match[2] == setting)
lines[line_num] = "#{match[1]}#{match[2]}#{match[3]}#{value}"
end
end
end
end
def remove_line(section, setting)
(section.start_line..section.end_line).each do |line_num|
if (match = SETTING_REGEX.match(lines[line_num]))
if (match[2] == setting)
lines.delete_at(line_num)
end
end
end
end
def create_line_iter
ExternalIterator.new(lines)
end
def lines
@lines ||= IniFile.readlines(@path)
end
# This is mostly here because it makes testing easier--we don't have
# to try to stub any methods on File.
def self.readlines(path)
# If this type is ever used with very large files, we should
# write this in a different way, using a temp
# file; for now assuming that this type is only used on
# small-ish config files that can fit into memory without
# too much trouble.
File.readlines(path)
end
# Utility method; given a section index (index into the @section_names
# array), decrement the start/end line numbers for that section and all
# all of the other sections that appear *after* the specified section.
def decrement_section_line_numbers(section_index)
@section_names[section_index..(@section_names.length - 1)].each do |name|
section = @sections_hash[name]
section.decrement_line_nums
end
end
def flush_buffer_to_file(buffer, fh)
if buffer.length > 0
buffer.each { |l| fh.puts(l) }
buffer.clear
end
end
end
end
end
|
