Class: Build

Inherits:
Path show all
Defined in:
lib/mako/build.rb

Instance Attribute Summary

Attributes inherited from Path

#args, #default, #settings

Instance Method Summary collapse

Methods inherited from Path

#aboslute_paths, #absolute_path, #initalize, #prepare_output_path, #prioritize

Constructor Details

#initialize(settings, default, args) ⇒ Build

Returns a new instance of Build.



34
35
36
37
38
 
# File 'lib/mako/build.rb', line 34

def initialize settings, default, args
	@settings = settings
	@default = default
	@args = args
end

Instance Method Details

#build_staging_area(source, output_dir) ⇒ Object 



292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
 
# File 'lib/mako/build.rb', line 292

def build_staging_area source, output_dir
	FileUtils.rm_r output_dir, :force=>true

	Dir::mkdir output_dir
	Dir::mkdir output_dir+'/swf'
	Dir::mkdir output_dir+'/img'
	Dir::mkdir output_dir+'/img/screen-shots'
	Dir::mkdir output_dir+'/_score-modules'
	Dir::mkdir output_dir+'/_assets'

	# copy everything to where it needs to be
	FileUtils.cp_r Dir[source+'swf/*'], output_dir+'/swf'
	FileUtils.cp_r Dir[source+'img/*'], output_dir+'/img'
	FileUtils.cp_r Dir[source+'_icons/*'], output_dir+'/img'
	FileUtils.cp_r Dir[source+'_screen-shots/*'], output_dir+'/img/screen-shots'
	FileUtils.cp_r Dir[source+'_assets/*'], output_dir+'/_assets'
	FileUtils.cp   source+'install.yaml', output_dir+'/install.yaml'
	FileUtils.cp   source+'demo.yaml', output_dir+'/demo.yaml'

	if File::exists? source+'_score/score_module.php'
		FileUtils.cp source+'_score/score_module.php', output_dir+'/_score-modules/score_module.php'
		FileUtils.cp source+'_score/test_score_module.php', output_dir+'/_score-modules/test_score_module.php'
	end

	output_dir
end

#compile(configs, current_path = Dir.pwd, output = nil) ⇒ Object

process_configs output, prioritize(:configs, args, default), default, settings, args



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
 
# File 'lib/mako/build.rb', line 41

def compile configs, current_path=Dir.pwd, output = nil
	output = output.nil? ? prepare_output_path(@args, @default) : output
	configs.each do |config|
		source = File.dirname absolute_path(config, current_path)
		cfg = load_symbolized_yaml absolute_path(config, current_path)

		if cfg == false
			abort
		end

		# build.yaml describes a single creator or engine that needs to be compiled?
		if cfg.compiles_widget?
			if cfg[:type] == 'compile_swf'
				compile_swc output, source, cfg
			end
			if cfg[:type] == 'compile_html'
				compile_html output, source, cfg
			end

		# build.yaml describes a single creator or engine that doesnt need compiling
		elsif cfg.is_copy_type?
			copy_to_output output, source, cfg

		# build.yaml describes a list of configs to run compile on
		elsif cfg.contains_configs?
			# for configs that only contain other configs but arent packages
			compile output, cfg[:configs], source

		# build.yaml describes a widget package (creator and engine)
		elsif cfg.is_package?
			if @args[:skip_package]
				compile_package source, output, cfg
			else
				staging_area = Dir.mktmpdir '-mako'
				compile_package source, staging_area, cfg
				zip_package staging_area, output, cfg
				FileUtils.rm_r staging_area, :force => true
			end
		else
			puts "#{config} unknown config type".red
		end
	end
end

#compile_html(output_dir, base_dir, config) ⇒ Object

copy and compile any html, js, coffeescript, saas, css, or images given the settings



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
 
# File 'lib/mako/build.rb', line 159

def compile_html output_dir, base_dir, config

	copy_to_output output_dir, base_dir, config

	coffee = Dir[output_dir+'/**/*.coffee']
	if coffee.any?
		require 'coffee-script'
		coffee.each do |source|
			process_coffee source, output_dir, output_dir, !@args[:skip_optimize]
			File.delete source
		end
	end

	less = Dir[output_dir+'/**/*.{less}']
	if less.any?
		require 'less'
		less.each do |source|
			process_less source, output_dir, output_dir, !@args[:skip_optimize]
			File.delete source
		end
	end

	sass = Dir[output_dir+'/**/*.{scss,sass}']
	if sass.any?
		require 'sass'
		sass.each do |source|
			process_sass source, output_dir, output_dir, !@args[:skip_optimize]
			File.delete source
		end
	end

	remove_html_dev_helpers output_dir
end

#compile_package(source, output_dir, cfg) ⇒ Object 



319
320
321
322
323
324
325
326
 
# File 'lib/mako/build.rb', line 319

def compile_package source, output_dir, cfg
	source << '/' unless source.end_with? '/'

	stage = build_staging_area source, output_dir

	compile [cfg[:engine], cfg[:creator]], Dir.pwd, stage
	optimize_staged_files(output_dir) unless @args[:skip_optimize]
end

#compile_swc(output_dir, base_dir, config) ⇒ Object

execute the mxmlc compiler on the given settings



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
 
# File 'lib/mako/build.rb', line 110

def compile_swc output_dir, base_dir, config

	# combine and prioritize the options
	run = {}
	run[:dev_kit]      = prioritize :dev_kit, @args, @settings, @default
	run[:sdk]          = prioritize :sdk, @args, @settings, @default
	run[:target]       = prioritize :target, @args, config, @default
	run[:app_class]    = absolute_path(prioritize(:app_class, config, @default), base_dir)
	run[:stop_on_fail] = prioritize :stop_on_fail, @args, @settings, @default
	run[:libs]         = aboslute_paths config[:libs], base_dir
	run[:sources]      = aboslute_paths config[:sources], base_dir

	# Make sure the SDK exists
	if run[:sdk].empty?
		puts "Mako can't find your Flex SDK".red
		puts "Please set MAKO_FLEX_SDK environment variable or the --sdk option"
		abort
	end

	# Check for the DevKit
	if prioritize(:dev_kit, @args, @settings, @default).empty?
		puts "Mako can't find your Materia Dev Kit".red
		puts "Please set MAKO_DEV_KIT environment variable or the --dev-kit option"
		abort
	end

	# Add in Materia and Flex Resources
	run[:sources].push run[:sdk]+'frameworks/' # flex sdk framework directory
	run[:sources].push run[:dev_kit]+'flash_widget_dev_core/src/' # Materia widget dev kit source
	run[:libs].push run[:sdk]+'frameworks/libs/' # Flex framework libs
	run[:libs].push run[:sdk]+'frameworks/locale/en_US/' # Flex local files

	# Setup the strings for the command
	mxmlc      = run[:sdk] + 'bin/mxmlc'
	sources    = ' -source-path '+run[:sources].join(' ')
	output_dir = ' -output '+output_dir+'/'+run[:target]
	extras     = ' -load-config '+run[:sdk]+'frameworks/flex-config.xml'+' -target-player 10.2.0 -debug=' +@args[:skip_optimize].to_s
	libs       = ' -library-path '+run[:libs].join(' ')

	# Execute
	puts "[Compiling] #{run[:target]}".white
	unless system(mxmlc+" "+run[:app_class]+sources+output_dir+libs+extras)
		puts "[Compile Failed]".red
		puts mxmlc+" "+run[:app_class]+sources+output_dir+libs+extras
		abort unless run[:stop_on_fail]
	end
end

#copy_to_output(output, base_dir, config) ⇒ Object 



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
 
# File 'lib/mako/build.rb', line 193

def copy_to_output output, base_dir, config

	base_dir << '/' unless base_dir.end_with? '/'
	output_dir = output.dup
	output_dir << '/' unless output_dir.end_with? '/'

	# FileUtils.rm_r output_dir, :force=>true
	Dir::mkdir output_dir unless File::exists? output_dir

	# copy any included directories
	if config[:include]
		config[:include].each do |item|
			item << '/' unless item.end_with? '/'
			Dir::mkdir output_dir+item unless File::exists? output_dir+item
			FileUtils.cp_r Dir[base_dir+item+'*'], output_dir+item
		end
	end

	#copy the target file incase its not in the included directories
	if config[:target]
		dir = File::dirname(output_dir+config[:target])
		FileUtils.mkpath dir unless File::exists? dir
		FileUtils.cp_r base_dir+config[:target], output_dir+config[:target]
	end
end

#load_symbolized_yaml(yaml) ⇒ Object 



92
93
94
95
96
97
98
99
 
# File 'lib/mako/build.rb', line 92

def load_symbolized_yaml yaml
	contents = load_yaml yaml
	if contents
		return string_keys_to_symbols contents
	end
	puts "Yaml file not valid #{yaml}".red
	false
end

#load_yaml(yaml) ⇒ Object 



85
86
87
88
89
90
 
# File 'lib/mako/build.rb', line 85

def load_yaml yaml
	if File::exists?(yaml) and contents = YAML::load_file(yaml)
		return contents
	end
	false
end

#optimize_staged_files(path) ⇒ Object 



349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
 
# File 'lib/mako/build.rb', line 349

def optimize_staged_files path
	css = Dir[path+'/**/*.css']
	if css.any?
		require "yui/compressor"
		css.each do |source|
			process_css source
		end
	end

	js = Dir[path+'/**/*.js']
	if js.any?
		require "yui/compressor"
		js.each do |source|
			process_js source
		end
	end
end

#process_coffee(file, output_dir, base_dir, optimize) ⇒ Object 



246
247
248
249
250
251
252
253
254
255
256
 
# File 'lib/mako/build.rb', line 246

def process_coffee file, output_dir, base_dir, optimize
	puts "Compiling CoffeeScript:".green + "#{file}".white
	# output to a css file of the same name, in the same reletive structure in the output directory
	output_file = (file.chomp(File.extname(file)) + '.js').sub(base_dir, output_dir)
	output_dir = File.dirname(output_file)
	# makes the directory structure if it doesnt exist
	FileUtils.mkdir_p output_dir unless File.directory? output_dir
	# process sass file and write output
	output = CoffeeScript.compile File.read(file)
	File.open(output_file, 'w') { |file_out| file_out.write(output) }
end

#process_css(file) ⇒ Object 



265
266
267
268
269
270
 
# File 'lib/mako/build.rb', line 265

def process_css file
	puts "Compressing CSS:".blue + "#{file}".white
	compressor = YUI::CssCompressor.new
	compressed = compressor.compress File.read(file)
	File.open(file, 'w') { |file_out| file_out.write(compressed) }
end

#process_js(file) ⇒ Object 



258
259
260
261
262
263
 
# File 'lib/mako/build.rb', line 258

def process_js file
	puts "Compressing JavaScript:".blue + "#{file}".white
	compressor = YUI::JavaScriptCompressor.new :munge => true
	compressed = compressor.compress File.read(file)
	File.open(file, 'w') { |file_out| file_out.write(compressed) }
end

#process_less(file, output_dir, base_dir, optimize) ⇒ Object

requires gem therubyracer



233
234
235
236
237
238
239
240
241
242
243
244
 
# File 'lib/mako/build.rb', line 233

def process_less file, output_dir, base_dir, optimize
	puts "Compiling LESS:".green + "#{file}".white

	output_file = (file.chomp(File.extname(file)) + '.css').sub(base_dir, output_dir)
	output_dir = File.dirname(output_file)
	# makes the directory structure if it doesnt exist
	FileUtils.mkdir_p output_dir unless File.directory? output_dir
	# process sass file and write output
	tree = Less::Parser.new().parse File.read(file)
	output = tree.to_css()
	File.open(output_file, 'w') { |file_out| file_out.write(output) }
end

#process_sass(file, output_dir, base_dir, optimize) ⇒ Object 



219
220
221
222
223
224
225
226
227
228
229
230
 
# File 'lib/mako/build.rb', line 219

def process_sass file, output_dir, base_dir, optimize
	puts "Compiling SASS:".green + "#{file}".white
	# output to a css file of the same name, in the same reletive structure in the output directory
	output_file = (file.chomp(File.extname(file)) + '.css').sub(base_dir, output_dir)
	output_dir = File.dirname(output_file)
	# makes the directory structure if it doesnt exist
	FileUtils.mkdir_p output_dir unless File.directory? output_dir
	# process sass file and write output
	sass_engine = Sass::Engine.for_file(file, {:style => :nested})
	output = sass_engine.render
	File.open(output_file, 'w') { |file_out| file_out.write(output) }
end

#remove_html_dev_helpers(output_path) ⇒ Object 



272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
 
# File 'lib/mako/build.rb', line 272

def remove_html_dev_helpers output_path
	# For development, html widgets support loading coffeescript via require.js
	# to do so, authors will add 'cs!' before the coffeescript file they are loading
	# dev: [ ...scripts..., 'cs!js/widget'] will load js/widget.coffee
	# packaged: [ ...scripts..., 'js/widget'] will load js/widget.js
	# Now we will pull out cs! because we pre-compile coffeescript
	# ALSO if LESS is used, we will be including  'less' in the require - we'll get rid of this too
	Dir[output_path+'/**/*.{html,htm}'].each do |file|
		text = File.read(file)
		# remove coffeescript helpers
		text = text.gsub(/['"]cs!/, "'")
		# remove less in require
		text = text.gsub(/(require\(\[[^\]]+?)['"]less['"]\s?,/, '\1')
		# remove less in includes
		text = text.gsub(/rel="stylesheet\/less"/, 'rel="stylesheet"')
		text = text.gsub(/href="(.+?)\.less"/, 'href="\1.css"')
		File.open(file, 'w') { |fpath| fpath.puts(text) }
	end
end

#string_keys_to_symbols(hash) ⇒ Object

Convert an array that uses string keys to symbol keys… cuz they look cooler



102
103
104
105
106
107
 
# File 'lib/mako/build.rb', line 102

def string_keys_to_symbols hash
	hash.keys.each do |key|
		hash[(key.to_sym rescue key) || key] = hash.delete(key)
	end
	hash
end

#zip_package(source, output_dir, cfg) ⇒ Object 



329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
 
# File 'lib/mako/build.rb', line 329

def zip_package source, output_dir, cfg
	# setup all the directories
	output_dir = output_dir.dup # output_dir is frozen typically and I don't know ruby enough to understand why
	output_dir << '/' unless output_dir.end_with? '/'
	source << '/' unless source.end_with? '/'
	name = load_yaml(source+'install.yaml')['general']['name'].pretty

	# zip it
	zip_file = "#{output_dir}#{name}.wigt"
	FileUtils.rm zip_file, :force=>true
	Zip::ZipFile.open(zip_file, Zip::ZipFile::CREATE) do |zip|
		Dir[source+'**/**'].each do |file|
			zip.add file.sub(source, ''), file
		end
	end

	# done, cleanup
	puts "[Package Finished] #{name} #{zip_file}".green
end