Class: Rmk

Inherits:
Object
  • Object
show all
Defined in:
lib/rmk/rmk.rb,
lib/rmk/vars.rb,
lib/rmk/version.rb,
lib/rmk/schedule.rb

Defined Under Namespace

Modules: Schedule Classes: Build, MultiVarWriter, Rule, Storage, VDir, VFile, VOutDir, Vars

Constant Summary collapse

VERSION = 
"0.3.0"

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(srcroot: '', outroot: '', variant: nil) ⇒ Rmk

create Rmk object

Parameters:

  • srcroot (String) (defaults to: '') —

    source root dir,can be absolute or relative to output root(start with ..)

  • outroot (String) (defaults to: '') —

    output root dir,can be absolute or relative to pwd,default pwd



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
 
# File 'lib/rmk/rmk.rb', line 39

def initialize(srcroot:'', outroot:'', variant:nil)
	@files_mutex = Thread::Mutex.new	# files operate mutex
	@stdoe_mutex = Thread::Mutex.new	# stdout and stderr mutex

	srcroot = Rmk.normalize_path srcroot
	@outroot = File.join Rmk.normalize_path(File.absolute_path outroot), ''
	@srcroot = File.join File.absolute_path(srcroot, @outroot), ''
	raise "source path '#{@srcroot}' not exist or not directory" unless ::Dir.exist?(@srcroot)
	warn 'in-source build' if @outroot == @srcroot
	@src_relative = srcroot.match?(/^\.\./) && File.join(srcroot, '')
	Dir.mkdir @outroot unless Dir.exist? @outroot
	Dir.chdir @outroot
	Dir.mkdir '.rmk' unless Dir.exist? '.rmk'
	@mid_storage = Rmk::Storage.new '.rmk/mid', {}
	@dep_storage = Rmk::Storage.new '.rmk/dep', {}
	@cml_storage = Rmk::Storage.new '.rmk/cml', {}	# command line text storage
	@srcfiles = {}
	@outfiles = {}
	@defaultfiles = []
	@vars = {'srcroot'=>@srcroot[0..-2], 'outroot'=>@outroot[0..-2], 'src_rto_root'=>(@src_relative || @srcroot)[0..-2]}
	@vars['variant'] = variant if variant
	@vars.freeze
	@log_prefix = variant ? "Rmk (#{variant}): " : 'Rmk: '
	@virtual_root = Rmk::VDir.new self, nil
end

Instance Attribute Details

#cml_storage ⇒ Object (readonly)

Returns the value of attribute cml_storage.



65
66
67
 
# File 'lib/rmk/rmk.rb', line 65

def cml_storage
  @cml_storage
end

#dep_storage ⇒ Object (readonly)

Returns the value of attribute dep_storage.



65
66
67
 
# File 'lib/rmk/rmk.rb', line 65

def dep_storage
  @dep_storage
end

#mid_storage ⇒ Object (readonly)

Returns the value of attribute mid_storage.



65
66
67
 
# File 'lib/rmk/rmk.rb', line 65

def mid_storage
  @mid_storage
end

#outfiles ⇒ Object (readonly)

Returns the value of attribute outfiles.



64
65
66
 
# File 'lib/rmk/rmk.rb', line 64

def outfiles
  @outfiles
end

#outroot ⇒ Object (readonly)

Returns the value of attribute outroot.



64
65
66
 
# File 'lib/rmk/rmk.rb', line 64

def outroot
  @outroot
end

#srcfiles ⇒ Object (readonly)

Returns the value of attribute srcfiles.



64
65
66
 
# File 'lib/rmk/rmk.rb', line 64

def srcfiles
  @srcfiles
end

#srcroot ⇒ Object (readonly)

Returns the value of attribute srcroot.



64
65
66
 
# File 'lib/rmk/rmk.rb', line 64

def srcroot
  @srcroot
end

#vars ⇒ Object (readonly)

Returns the value of attribute vars.



64
65
66
 
# File 'lib/rmk/rmk.rb', line 64

def vars
  @vars
end

#virtual_root ⇒ Object (readonly)

Returns the value of attribute virtual_root.



64
65
66
 
# File 'lib/rmk/rmk.rb', line 64

def virtual_root
  @virtual_root
end

Class Method Details

.normalize_path(path) ⇒ String

Returns:

  • (String) 


9
 
# File 'lib/rmk/rmk.rb', line 9

def self.normalize_path(path) path.gsub(?\\, ?/).sub(/^[a-z](?=:)/){|ch|ch.upcase} end

Instance Method Details

#add_default(*files) ⇒ Object

add default target



172
 
# File 'lib/rmk/rmk.rb', line 172

def add_default(*files) @files_mutex.synchronize{@defaultfiles.concat files} end

#add_out_file(path:, vpath: nil) ⇒ Rmk::VFile

register a out file

Parameters:

  • path (String)
  • vpath (String) (defaults to: nil)

Returns:



153
154
155
156
157
158
159
 
# File 'lib/rmk/rmk.rb', line 153

def add_out_file(path:, vpath:nil)
	@files_mutex.synchronize do
		raise "file '#{path}' has been defined" if @outfiles.include? path
		file = @srcfiles.delete(path).change_to_out! file if @srcfiles.include? path
		@outfiles[path] = VFile.new rmk:self, path:path, vpath:vpath
	end
end

#add_src_file(path:, vpath: nil) ⇒ Rmk::VFile

register a src file

Parameters:

  • path (String)
  • vpath (String) (defaults to: nil)

Returns:



165
166
167
168
169
 
# File 'lib/rmk/rmk.rb', line 165

def add_src_file(path:, vpath:nil)
	@files_mutex.synchronize do
		@outfiles[path] || (@srcfiles[path] ||= VFile.new(rmk:self, path:path, vpath:vpath, is_src:true))
	end
end

#build(*tgts) ⇒ Object 



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
 
# File 'lib/rmk/rmk.rb', line 186

def build(*tgts)
	std_puts 'build start'
	if tgts.empty?
		files = @defaultfiles
	else
		files = tgts.map do |name|
			file = Rmk.normalize_path name
			file = @outfiles[File.absolute_path file, @outroot] || @srcfiles[File.absolute_path file, @srcroot]
			raise "build target '#{name}' not found" unless file
			file = file.input_ref_builds[0].outfiles[0] if file.src? && file.input_ref_builds.size == 1
			file
		end
	end
	if files.empty?
		@srcfiles.each_value{|file| file.check_for_build}
	else
		checklist = []
		checkproc = proc do |fi|
			next checklist << fi if fi.src?
			fi.output_ref_build.infiles.each &checkproc
			fi.output_ref_build.depfiles.each &checkproc
			fi.output_ref_build.orderfiles.each &checkproc
		end
		files.each &checkproc
		exit std_puts('','found nothing to build') || 0 if checklist.empty?
		checklist.each {|file| file.check_for_build}
	end
	while Thread.list.size > 1
		thr = Thread.list[-1]
		thr.join unless thr == Thread.current
	end
	std_puts 'build end'
	@mid_storage.save
	@dep_storage.data!.each_key {|key| @dep_storage.data!.delete key unless @outfiles.include? key}
	@dep_storage.save
	@cml_storage.data!.each_key {|key| @cml_storage.data!.delete key unless @outfiles.include? key}
	@cml_storage.save
end

#err_puts(mark, *parms) ⇒ Object 



22
 
# File 'lib/rmk/rmk.rb', line 22

def err_puts(mark, *parms) @stdoe_mutex.synchronize{log $stderr, mark, *parms} end

#find_inputfiles(pattern, ffile: false) ⇒ Array<VFile, FFile>

find files which can be build’s imput file

Parameters:

  • pattern (String) —

    absolute path to find src and out files which can include ‘*’ to match any char at last no dir part

  • ffile (Boolean) (defaults to: false) —

    return FFile struct or not

Returns:

  • (Array<VFile, FFile>) —

    return array of FFile when ffile, otherwise array of VFile



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
 
# File 'lib/rmk/rmk.rb', line 88

def find_inputfiles(pattern, ffile:false)
	pattern = Rmk.normalize_path pattern
	path, regex, postpath = split_path_pattern pattern
	files = []
	if regex
		@files_mutex.synchronize do
			find_outfiles_imp files, path, regex, postpath, ffile:ffile
			range = postpath ? path.size..-1-postpath.size : path.size..-1
			Dir[pattern].each do |fn|
				next if @outfiles.include? fn
				next files << (ffile ? FFile.new(@srcfiles[fn], nil, fn[range][regex, 1]) : @srcfiles[fn]) if @srcfiles.include? fn
				file = (@srcfiles[fn] = VFile.new rmk:self, path:fn, is_src:true,
					vpath:fn.start_with?(@srcroot) && fn[@srcroot.size .. -1])
				files << (ffile ? FFile.new(file, nil, fn[range][regex, 1]) : file)
			end
		end
	else
		@files_mutex.synchronize do
			next files << (ffile ? FFile.new(@outfiles[path]) : @outfiles[path]) if @outfiles.include? path
			next files << (ffile ? FFile.new(@srcfiles[path]) : @srcfiles[path]) if @srcfiles.include? path
			next unless File.exist? path
			file = @srcfiles[path] = VFile.new rmk:self, path:path, is_src:true,
					vpath:path.start_with?(@srcroot) && path[@srcroot.size .. -1]
			files << (ffile ? FFile.new(file) : file)
		end
	end
	files
end

#find_outfiles(pattern) ⇒ Array<Hash>

find files which must be build’s output

Parameters:

  • pattern (String) —

    absolute path to find out files which can include ‘*’ to match any char at last no dir part

Returns:

  • (Array<Hash>) —

    return Array of file, and Regex when has ‘*’ pattern



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

def find_outfiles(pattern)
	path, regex, postpath = split_path_pattern Rmk.normalize_path pattern
	files = []
	@files_mutex.synchronize do
		next (files << @outfiles[path] if @outfiles.include? path) unless regex
		find_outfiles_imp files, path, regex, postpath
	end
	files
end

#join_abs_src_path(path) ⇒ Object 



67
 
# File 'lib/rmk/rmk.rb', line 67

def join_abs_src_path(path) File.join @srcroot, path end

#join_rto_src_path(path) ⇒ Object

join src file path relative to out root, or absolute src path when not relative src



70
 
# File 'lib/rmk/rmk.rb', line 70

def join_rto_src_path(path) ::File.join @src_relative ? @src_relative : @srcroot, path end

#log_cmd_out(mark, out, err) ⇒ Object 



29
30
31
32
33
34
 
# File 'lib/rmk/rmk.rb', line 29

def log_cmd_out(mark, out, err)
	@stdoe_mutex.synchronize do
		split_log $stdout, mark, out
		split_log $stderr, nil, err unless err.empty?
	end
end

#parse ⇒ self

parse project

Returns:

  • (self) 


176
177
178
179
180
181
182
183
184
 
# File 'lib/rmk/rmk.rb', line 176

def parse
	std_puts 'parse start'
	@mid_storage.wait_ready
	@dep_storage.wait_ready
	@cml_storage.wait_ready
	@virtual_root.parse
	std_puts 'parse done'
	self
end

#split_path_pattern(pattern) ⇒ Object

split path pattern to dir part and file match regex part when pattern include ‘*’, return [dir part, file(or dir) match regex, post dir part, post file part] ;otherwise return [origin pattern, nil, nil, nil]

Parameters:

  • pattern (String) —

    absolute path, can include ‘*’ to match any char at last no dir part



76
77
78
79
80
81
82
 
# File 'lib/rmk/rmk.rb', line 76

def split_path_pattern(pattern)
	match = /^([a-zA-Z]:\/(?:[^\/*]+\/)*+)([^\/*]*+)(?:\*([^\/*]*+))?(?(3)(\/(?:[^\/*]+\/)*+[^\/*]++)?)$/.match pattern
	raise "file syntax '#{pattern}' error" unless match
	dir, prefix, postfix, postpath = *match[1..5]
	regex = postfix && /#{Regexp.escape prefix}(.*)#{Regexp.escape postfix}$/
	[regex ? dir : pattern, regex, postpath]
end

#std_puts(mark, *parms) ⇒ Object 



20
 
# File 'lib/rmk/rmk.rb', line 20

def std_puts(mark, *parms) @stdoe_mutex.synchronize{log $stdout, mark, *parms} end