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
|
require 'digest'
require 'erb'
require 'fileutils'
require_relative 'resource'
require_relative '../chained'
module RCM
# Backup the file on change
module FileBackup
def backup!(file_path, checksum = Digest::SHA256.file(file_path).hexdigest)
return if @without_backup
backup_dir = "#{::File.dirname(file_path)}/.rcm"
Dir.mkdir(backup_dir) unless ::File.directory?(backup_dir)
backup_path = "#{backup_dir}/#{::File.basename(file_path)}.#{checksum}"
return if ::File.exist?(backup_path)
info("Backing up #{file_path} -> #{backup_path}")
::File.rename(file_path, backup_path)
end
end
# Base for File and Symlink
class BaseFile < Resource
include Chained
def initialize(file_path)
super(file_path)
@file_path = file_path
@is = :present
end
class UnsupportedOperation < StandardError; end
def is(what) = @is = validate(__method__, what.to_sym, :present, :absent)
def manage(what) = @manage_directory = validate(__method__, what.to_sym, :directory) == :directory
def from(what) = @from = validate(__method__, what.to_sym, :sourcefile, :template)
def path(file_path = nil) = file_path.nil? ? @file_path : @file_path = file_path
def content(text = nil)
if text.nil?
text = @from == :sourcefile ? ::File.read(@content) : @content
return @from == :template ? ERB.new(text).result : text
end
@content = text.instance_of?(Array) ? text.join("\n") : text
end
protected
# Validate whether we can use this up in this context or not
def validate(method, what, *valids)
return what if valids.include?(what)
raise UnsupportedOperation,
"Unsupported '#{method}' operation #{what} (#{what.class})"
end
def create_parent_directory!
dirname = ::File.dirname(@file_path)
return if ::File.directory?(dirname)
dry? "Creating parent directory #{dirname}" do
FileUtils.mkdir_p(dirname)
end
end
def evaluate_absent!
if ::File.exist?(@file_path)
dry? "Deleting #{@file_path}" do
backup!(@file_path)
::File.delete(@file_path) if ::File.file?(@file_path)
end
end
cleanup_directory! if @manage_directory
end
def cleanup_directory!
parent_dir = ::File.dirname(@file_path)
while Dir.empty?(parent_dir)
dry? "Deleting empty parent directory #{parent_dir}" do
Dir.rmdir(parent_dir)
end
parent_dir = ::File.dirname(parent_dir)
end
end
end
# Managing files
class File < BaseFile
include FileBackup
def line(line) = @ensure_line = line
def without(what) = @without_backup = validate(__method__, what.to_sym, :backup) == :backup
def evaluate!
return unless super
return evaluate_ensure_line! unless @ensure_line.nil?
return evaluate_absent! if @is == :absent
create_parent_directory! if @manage_directory
write!(content)
end
private
def evaluate_ensure_line!
return evaluate_ensure_line_absent! if %i[absent].include?(@is)
return write!(@ensure_line) unless ::File.file?(@file_path)
return if ::File.readlines(@file_path, chomp: true).include?(@ensure_line)
dry? "Appending line #{@ensure_line} to #{@file_path}" do
::File.open(@file_path, 'a') do |fd|
fd.puts(@ensure_line)
end
end
end
def evaluate_ensure_line_absent!
return unless ::File.file?(@file_path)
dry? "Removing line #{@ensure_line} from #{@file_path}" do
write!(::File.readlines(@file_path, chomp: true).reject do |line|
line == @ensure_line
end.join("\n"))
end
end
def write!(text)
tmp_path = "#{@file_path}.rcmtmp"
dry? "Writing file #{@file_path}" do
::File.write(tmp_path, text)
end
if ::File.file?(@file_path)
checksum = Digest::SHA256.file(@file_path).hexdigest
tmp_checksum = Digest::SHA256.file(tmp_path).hexdigest
if tmp_checksum == checksum
::File.delete(tmp_path) # File has not changed, not doing anything
return
end
# File changed, backup!
backup!(@file_path, checksum) unless option :dry
end
::File.rename(tmp_path, @file_path) unless option :dry
end
end
# Manage symlinks
class Symlink < BaseFile
def evaluate!
return unless super
return evaluate_absent! if @is == :absent
create_parent_directory! if @manage_directory
dry? "Creating symlink #{@file_path}" do
FileUtils.ln_sf(content, @file_path)
end
end
end
# Add file keyword to the DSL
class DSL
def file(file_path, &block)
return unless @conds_met
f = File.new(file_path)
f.content(f.instance_eval(&block))
self << f
f
end
def symlink(file_path, &block)
return unless @conds_met
s = Symlink.new(file_path)
s.content(s.instance_eval(&block))
self << s
s
end
end
end
|
