Module: C

Defined in:
lib/rub/c.rb,
lib/rub/r/i/runner.rb

Overview

Core Module

Defined Under Namespace

Classes: Tag, TargetTag

Class Method Summary collapse

Class Method Details

.add_dir(dir) ⇒ Object

Add a directory to the build.

This will run the “dir.rub” file in that directory synchronously. Any values that that directory defines will be available when this call returns.

This function only runs scripts once, if the script has already run this function will return success without running the script, and as the script has already been run the exported values should be available.



63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/rub/r/i/runner.rb', line 63

def self.add_dir(dir)
	dir = C.path(dir)
	
	if not dir.directory?
		raise "\"#{dir}\" is not a directory!"
	end
	
	dir += 'dir.rub'
	if not dir.exist?
		raise "\"#{dir}\" does not exist!"
	end
	dir = dir.realpath
	
	R::I::Runner.do_file(dir)
end

.chash(o) ⇒ Object

Get a consistant hash of an object.



62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/rub/c.rb', line 62

def self.chash(o)
	if o.is_a? Array
		return o.map{|i| chash i}.join
	end
	
	# Super hacky, strip out object-ids, because they change every
	# invocation, but use inspect.  It works alright.
	r = o.inspect.gsub(/(?<!:):0x[0-9a-f]*/, '')
	
	# Modules don't print themselfs meaningfully.
	if o.is_a? Module
		r << o.pretty_print_instance_variables.map{|k| [k, o.instance_variable_get(k)] }.inspect
	end

	r	
end

.find_command(cmd) ⇒ Pathname?

Find an executable on the system.

This searches the system for execrable in the appropriate locations (example $PATH on UNIX).

This function caches its result both in memory and between Rub runs. Feel free to call it often.

Examples:

C::find_command 'true'    #=> #<Pathname:/usr/bin/true>
C::find_command 'cc'      #=> #<Pathname:/home/kevincox/.local/bin/cc>
C::find_command 'sl'      #=> #<Pathname:/usr/bin/sl>
C::find_command 'python'  #=> #<Pathname:/usr/bin/python>
C::find_command 'explode' #=> nil

Parameters:

  • cmd (String) —

    The name of the command (basename only).

Returns:

  • (Pathname, nil) —

    Pathname, or nil if not found.



243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
 
# File 'lib/rub/c.rb', line 243

def self.find_command(cmd)
	pn = Pathname.new(cmd)
	if pn.absolute?
		#return pn.executable? ? pn : nil
		return pn
	end
	
	exe = R.spersistant["C.find_command.#{cmd}"]
	
	exe and exe.executable? and return exe
	
	exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
	names = exts.map{|e| cmd+e}
	ENV['PATH'].split(File::PATH_SEPARATOR)
	           .map{|d|Pathname.new(d)}
	           .each do |d|
		names.each do |n|
			e = d + n
			#p e
			
			if e.executable?
				exe = e
				break
			end
		end
		
		exe and break
	end
	
	R.spersistant["C.find_command.#{cmd}"] = exe
end

.generator(src, cmd, out, desc: nil) ⇒ Array<Pathname>

Add a generator to the build

This function provides a simple api for creating R::TargetGenerator targets. It creates a target that simply runs one or more commands to transform it’s inputs into outputs. This interface handles all build caching and parallelization.

Parameters:

  • src (Array<Pathname,String>, Pathname, String) —

    The source file or list of source files.

  • cmd (Array<Array<Pathname,String>>, Array<Pathname,String>) —

    The command or list of commands to run. Commands will run in order.

  • out (Array<Pathname,String>, Pathname, String) —

    The output files of the command.

  • desc (defaults to: nil) —

    The verb for this step in the process. (See R::TargetGenerator#action)

Returns:

  • (Array<Pathname>) —

    The output files. This will represent the same values passed in to the out parameter but it will be a new Array and all the values will be Pathnames.



208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
 
# File 'lib/rub/c.rb', line 208

def self.generator(src, cmd, out, desc: nil)
	t = R::TargetGenerator.new
	
	desc and t.action = desc
	
	src = R::Tool.make_set_paths(src)
	out = R::Tool.make_set_paths(out)
	cmd[0].is_a?(Array) or cmd = [cmd]
	
	t.input .merge(src)
	t.output.merge(out)
	t.add_cmds cmd
	
	t.register
	
	out
end

.glob(glob) ⇒ Set<Pathname>

Glob pathnames.

Parameters:

  • glob (String)

Returns:

  • (Set<Pathname>)

See Also:

  • Dir.glob


57
58
59
 
# File 'lib/rub/c.rb', line 57

def self.glob(glob)
	Set.new Dir.glob(glob).map{|e| C.path(e) }
end

.path(p) ⇒ Pathname

Expand a path.

Returns:

  • (Pathname) 


32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/rub/c.rb', line 32

def self.path(p)
	p.is_a? Symbol   and return p
	p.is_a? Pathname and return p.expand_path
	p = p.to_s
	
	#p = case p[0]
	#	when '!'
	#		Pathname.new(p[1..-1])
	#	when '>'
	#		R::Env.out_dir + p[1..-1]
	#	when '<'
	#		R::Env.src_dir + p[1..-1]
	#	else
	#		Pathname.new(p)
	#end
	
	Pathname.new(p).expand_path
end

.tag(t) ⇒ Tag

Get a tag.

If the tag already exists it returns the existing Tag object otherwise it creates and returns a new Tag instance.

Parameters:

  • t (Symbol) —

    The tag name.

Returns:

  • (Tag) —

    The tag object.



179
180
181
 
# File 'lib/rub/c.rb', line 179

def self.tag(t)
	R.find_target(t) || Tag.new(t)
end

.unique_path(base, seed) ⇒ Object

Return a probably unique file name.

This file can be used as a build target.

Parameters:

  • base (String) —

    The basename of the file.

  • seed (Object) —

    A value to use for the folder name, keeping this the same across invocations allows predictable names, preventing unnecessary rebuilds.



100
101
102
 
# File 'lib/rub/c.rb', line 100

def self.unique_path(base, seed)
	R::Env.out_dir + 'c/unique/' + unique_segment(seed) + base
end

.unique_segment(*seed) ⇒ Object

Create a probably unique path segment.

Creates a string in the form ‘$stuff/’ that will probably be unique.

Parameters:

  • seed (Object) —

    A value to use for the folder name, keeping this the same across invocations allows predictable names, preventing unnecessary rebuilds.



86
87
88
89
90
 
# File 'lib/rub/c.rb', line 86

def self.unique_segment(*seed)
	seed ||= caller_locations(1,1)
	
	return Digest::SHA1.hexdigest(chash(seed))
end