flame 5.0.0.rc4 → 5.0.0.rc7

data/template/Rakefile

@@ -1,824 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-
-require 'pry-byebug' ## for `binding.pry` debugging
-
-def alias_task(name, old_name)
-	t = Rake::Task[old_name]
-	desc t.full_comment if t.full_comment
-	task name, *t.arg_names do |_, args|
-		# values_at is broken on Rake::TaskArguments
-		args = t.arg_names.map { |a| args[a] }
-		t.invoke(*args)
-	end
-end
-
-def edit_file(filename)
-	sh "eval $EDITOR #{filename}"
-end
-
-def show_diff(filename, other_filename)
-	sh "diff -u --color=always #{filename} #{other_filename} || true"
-	puts
-end
-
-def env_true?(key)
-	%(true yes 1 y).include?(ENV[key.to_s].to_s.downcase)
-end
-
-## Class for questions
-class Question
-	def initialize(text, possible_answers)
-		@text = text
-		@possible_answers = Set.new(possible_answers) << 'quit' << 'help'
-	end
-
-	def answer
-		while @answer.nil?
-			ask
-			@answer = @possible_answers.find do |possible_answer|
-				possible_answer.start_with? @real_answer
-			end
-			print_help if @answer.nil?
-		end
-		@answer
-	end
-
-	private
-
-	def print_question
-		print "#{@text} [#{@possible_answers.map(&:chr).join(',')}] : "
-	end
-
-	def print_help
-		@possible_answers.each do |possible_answer|
-			puts "#{possible_answer.chr} - #{possible_answer}"
-		end
-	end
-
-	def ask
-		print_question
-		@real_answer = STDIN.gets.chomp.downcase
-		case @real_answer
-		when 'h'
-			print_help
-			return ask
-		when 'q'
-			exit
-		end
-	end
-end
-
-DB_CONFIG_FILE = File.join(__dir__, 'config/database.yml').freeze
-
-if File.exist? DB_CONFIG_FILE
-	namespace :db do
-		## Require libs and config
-		require 'logger'
-		require 'sequel'
-
-		## Constants for DB directories
-
-		DB_DIR = File.join(__dir__, 'db')
-		DB_MIGRATIONS_DIR = File.join(DB_DIR, 'migrations')
-		DB_DUMPS_DIR = File.join(DB_DIR, 'dumps')
-
-		DB_CONFIG = YAML.load_file DB_CONFIG_FILE
-
-		env_db_name = ENV['DB_NAME']
-		DB_CONFIG[:database] = env_db_name if env_db_name
-
-		def db_connection
-			@db_connection ||= Sequel.connect DB_CONFIG
-		end
-
-		DB_ACCESS = "-U #{DB_CONFIG[:user]} -h #{DB_CONFIG[:host]}"
-
-		DB_EXTENSIONS = %w[citext pgcrypto].freeze
-
-		PGPASS_FILE = File.expand_path('~/.pgpass').freeze
-
-		PGPASS_LINE =
-			DB_CONFIG
-				.fetch_values(:host, :port, :database, :user, :password) { |_key| '*' }
-				.join(':')
-
-		def update_pgpass
-			pgpass_lines =
-				File.exist?(PGPASS_FILE) ? File.read(PGPASS_FILE).split($RS) : []
-			return if pgpass_lines&.include? PGPASS_LINE
-			File.write PGPASS_FILE, pgpass_lines.push(PGPASS_LINE, nil).join($RS)
-			File.chmod(0o600, PGPASS_FILE)
-		end
-
-		# db_connection.loggers << Logger.new($stdout)
-
-		namespace :migrations do
-			## Migration file
-			class MigrationFile
-				MIGRATION_CONTENT =
-					<<~STR
-						# frozen_string_literal: true
-
-						Sequel.migration do
-							change do
-							end
-						end
-					STR
-
-				DISABLING_EXT = '.bak'
-
-				def self.find(query, only_one: true, enabled: true, disabled: true)
-					filenames = Dir[File.join(DB_MIGRATIONS_DIR, "*#{query}*")]
-					filenames.select! { |filename| File.file? filename }
-					files = filenames.map { |filename| new filename: filename }.sort!
-					files.reject!(&:disabled) unless disabled
-					files.select!(&:disabled) unless enabled
-					return files unless only_one
-					return files.first if files.size < 2
-					raise 'More than one file mathes the query'
-				end
-
-				attr_accessor :version, :name, :disabled
-
-				def initialize(filename: nil, name: nil)
-					self.filename = filename
-					self.name = name if name
-				end
-
-				## Accessors
-
-				def basename
-					File.basename(@filename)
-				end
-
-				def filename=(value)
-					parse_filename value if value.is_a? String
-					@filename = value
-				end
-
-				def name=(value)
-					@name = value.tr(' ', '_').downcase
-				end
-
-				def disabled=(value)
-					@disabled =
-						case value
-						when String
-							[DISABLING_EXT, DISABLING_EXT[1..-1]].include? value
-						else
-							value
-						end
-				end
-
-				def <=>(other)
-					version <=> other.version
-				end
-
-				## Behavior
-
-				def print
-					datetime = Time.parse(version).strftime('%F %R')
-					fullname = name.tr('_', ' ').capitalize
-					fullname = "#{fullname} (disabled)" if disabled
-					version_color, name_color =
-						disabled ? ["\e[37m", "\e[37m- "] : ["\e[36m", '']
-					puts "\e[37m[#{version}]\e[0m #{version_color}#{datetime}\e[0m" \
-						" #{name_color}#{fullname}\e[0m"
-				end
-
-				def generate
-					self.version = new_version
-					FileUtils.mkdir_p File.dirname new_filename
-					File.write new_filename, MIGRATION_CONTENT
-				end
-
-				def reversion
-					rename version: new_version
-				end
-
-				def disable
-					abort 'Migration already disabled' if disabled
-
-					rename disabled: true
-				end
-
-				def enable
-					abort 'Migration already enabled' unless disabled
-
-					rename disabled: false
-				end
-
-				private
-
-				def parse_filename(value = @filename)
-					basename = File.basename value
-					self.version, parts = basename.split('_', 2)
-					self.name, _ext, self.disabled = parts.split('.')
-				end
-
-				def new_version
-					Time.now.strftime('%Y%m%d%H%M')
-				end
-
-				def rename(vars = {})
-					vars.each { |key, value| send :"#{key}=", value }
-					return unless @filename.is_a? String
-					File.rename @filename, new_filename
-					self.filename = new_filename
-				end
-
-				def new_filename
-					new_basename = "#{version}_#{name}.rb#{DISABLING_EXT if disabled}"
-					File.join DB_MIGRATIONS_DIR, new_basename
-				end
-			end
-
-			desc 'Run migrations'
-			task :run, %i[target current] do |_t, args|
-				Rake::Task['db:dump'].invoke
-
-				Sequel.extension :migration
-				Sequel.extension :inflector
-				# db_connection.extension :pg_enum
-
-				options = {
-					allow_missing_migration_files: env_true?(:ignore)
-				}
-				if (target = args[:target])
-					if target == '0'
-						puts 'Migrating all the way down'
-					else
-						file = MigrationFile.find target, disabled: false
-
-						abort 'Migration with this version not found' if file.nil?
-
-						current = args[:current] || 'current'
-						puts "Migrating from #{current} to #{file.basename}"
-						target = file.version
-					end
-					options[:current] = args[:current].to_i
-					options[:target] = target.to_i
-				else
-					puts 'Migrating to latest'
-				end
-
-				db_connection.loggers << Logger.new($stdout)
-
-				Sequel::Migrator.run(
-					db_connection,
-					DB_MIGRATIONS_DIR,
-					options
-				)
-			end
-
-			desc 'Rollback the database N steps'
-			task :rollback, :step do |_task, args|
-				Rake::Task['db:dump'].invoke
-
-				step = args[:step] ? Integer(args[:step]).abs : 1
-
-				file = MigrationFile.find('*', only_one: false)[-1 - step]
-
-				Rake::Task['db:migrations:run'].invoke(file.version)
-
-				puts "Rolled back to #{file.basename}"
-			end
-
-			desc 'Create migration'
-			task :new, :name do |_t, args|
-				abort 'You must specify a migration name' if args[:name].nil?
-
-				file = MigrationFile.new name: args[:name]
-				file.generate
-			end
-
-			desc 'Change version of migration to latest'
-			task :reversion, :filename do |_t, args|
-				# rubocop:disable Style/IfUnlessModifier
-				if args[:filename].nil?
-					abort 'You must specify a migration name or version'
-				end
-
-				file = MigrationFile.find args[:filename]
-				file.reversion
-			end
-
-			desc 'Disable migration'
-			task :disable, :filename do |_t, args|
-				if args[:filename].nil?
-					abort 'You must specify a migration name or version'
-				end
-
-				file = MigrationFile.find args[:filename]
-				file.disable
-			end
-
-			desc 'Enable migration'
-			task :enable, :filename do |_t, args|
-				if args[:filename].nil?
-					abort 'You must specify a migration name or version'
-				end
-
-				file = MigrationFile.find args[:filename]
-				file.enable
-			end
-
-			desc 'Show all migrations'
-			task :list do |_t, _args|
-				files = MigrationFile.find '*', only_one: false
-				files.each(&:print)
-			end
-
-			desc 'Check applied migrations'
-			task :check do
-				applied_names = db_connection[:schema_migrations].select_map(:filename)
-				applied = applied_names.map { |one| MigrationFile.new filename: one }
-				existing = MigrationFile.find '*', only_one: false, disabled: false
-				existing_names = existing.map(&:basename)
-				a_not_e = applied.reject { |one| existing_names.include? one.basename }
-				e_not_a = existing.reject { |one| applied_names.include? one.basename }
-				if a_not_e.any?
-					puts 'Applied, but not existing'
-					a_not_e.each(&:print)
-					puts "\n" if e_not_a.any?
-				end
-				if e_not_a.any?
-					puts 'Existing, but not applied'
-					e_not_a.each(&:print)
-				end
-			end
-		end
-
-		alias_task :migrate, 'migrations:run'
-
-		desc 'Run seeds'
-		task :seed do
-			require 'sequel/extensions/seed'
-			seeds_dir = File.join(DB_DIR, 'seeds')
-
-			## Doesn't support version yet
-			puts 'Seeding latest'
-			Sequel::Seeder.apply(db_connection, seeds_dir)
-		end
-
-		namespace :dumps do
-			## Class for single DB dump file
-			class DumpFile
-				DB_DUMP_TIMESTAMP = '%Y-%m-%d_%H-%M'
-
-				DB_DUMP_TIMESTAMP_REGEXP_MAP = {
-					'Y' => '\d{4}',
-					'm' => '\d{2}',
-					'd' => '\d{2}',
-					'H' => '\d{2}',
-					'M' => '\d{2}'
-				}.freeze
-
-				missing_keys =
-					DB_DUMP_TIMESTAMP.scan(/%(\w)/).flatten -
-					DB_DUMP_TIMESTAMP_REGEXP_MAP.keys
-
-				if missing_keys.any?
-					raise "`DB_DUMP_TIMESTAMP_REGEXP_MAP` doesn't contain keys" \
-						" #{missing_keys} for `DB_DUMP_TIMESTAMP`"
-				end
-
-				DB_DUMP_TIMESTAMP_REGEXP =
-					DB_DUMP_TIMESTAMP_REGEXP_MAP
-						.each_with_object(DB_DUMP_TIMESTAMP.dup) do |(key, value), result|
-							result.gsub! "%#{key}", value
-						end
-
-				DB_DUMP_FORMATS = %w[custom plain].freeze
-
-				DB_DUMP_EXTENSIONS = {
-					'plain'  => '.sql',
-					'custom' => '.dump'
-				}.freeze
-
-				missing_formats = DB_DUMP_FORMATS.reject do |db_dump_format|
-					DB_DUMP_EXTENSIONS[db_dump_format]
-				end
-
-				if missing_formats.any?
-					raise "`DB_DUMP_EXTENSIONS` has no keys for #{missing_formats}" \
-						' from `DB_DUMP_FORMATS`'
-				end
-
-				regexp_escaped_db_dump_extensions =
-					DB_DUMP_EXTENSIONS.values.map do |db_dump_extension|
-						Regexp.escape(db_dump_extension)
-					end
-
-				DB_DUMP_REGEXP = /^
-					#{DB_DUMPS_DIR}#{Regexp.escape(File::SEPARATOR)}
-					#{DB_CONFIG[:database]}_#{DB_DUMP_TIMESTAMP_REGEXP}
-					(#{regexp_escaped_db_dump_extensions.join('|')})
-				$/xo
-
-				def self.all
-					Dir[File.join(DB_DUMPS_DIR, '*')]
-						.select { |file| file.match?(DB_DUMP_REGEXP) }
-						.map! { |file| new filename: file }
-						.sort!
-				end
-
-				attr_reader :version, :timestamp, :format
-
-				def initialize(filename: nil, format: 'custom')
-					if filename
-						@extension = File.extname(filename)
-						@format = DB_DUMP_EXTENSIONS.key(@extension)
-						self.version = filename[/#{DB_DUMP_TIMESTAMP_REGEXP}/o]
-					else
-						@format = format
-						@extension = DB_DUMP_EXTENSIONS[@format]
-						self.timestamp = Time.now
-					end
-				end
-
-				def <=>(other)
-					timestamp <=> other.timestamp
-				end
-
-				def to_s
-					"#{readable_timestamp} #{format}"
-				end
-
-				def print
-					puts to_s
-				end
-
-				def path
-					File.join(
-						DB_DUMPS_DIR, "#{DB_CONFIG[:database]}_#{version}#{@extension}"
-					)
-				end
-
-				private
-
-				def version=(value)
-					@version = value
-					@timestamp = Time.strptime(version, DB_DUMP_TIMESTAMP)
-				end
-
-				def timestamp=(value)
-					@timestamp = value
-					@version = timestamp.strftime(DB_DUMP_TIMESTAMP)
-				end
-
-				def readable_timestamp
-					datetime = timestamp.strftime('%F %R')
-					"\e[36m#{datetime}\e[0m"
-				end
-			end
-
-			desc 'Make DB dump'
-			task :create, :format do |_task, args|
-				dump_format =
-					if args[:format]
-						DumpFile::DB_DUMP_FORMATS.find do |db_dump_format|
-							db_dump_format.start_with? args[:format]
-						end
-					else
-						DumpFile::DB_DUMP_FORMATS.first
-					end
-
-				update_pgpass
-
-				filename = DumpFile.new(format: dump_format).path
-				sh "mkdir -p #{DB_DUMPS_DIR}"
-				sh "pg_dump #{DB_ACCESS} -F#{dump_format.chr}" \
-				   " #{DB_CONFIG[:database]} > #{filename}"
-			end
-
-			desc 'Restore DB dump'
-			task :restore, :step do |_task, args|
-				step = args[:step] ? Integer(args[:step]) : -1
-
-				update_pgpass
-
-				dump_file = DumpFile.all[step]
-
-				abort 'Dump file not found' unless dump_file
-
-				if Question.new("Restore #{dump_file} ?", %w[yes no]).answer == 'no'
-					abort 'Okay'
-				end
-
-				Rake::Task['db:dump'].invoke
-
-				case dump_file.format
-				when 'custom'
-					sh "pg_restore #{DB_ACCESS} -n public -d #{DB_CONFIG[:database]}" \
-					   " #{dump_file.path} --jobs=4 --clean --if-exists"
-				when 'plain'
-					Rake::Task['db:drop'].invoke
-					Rake::Task['db:create'].invoke
-					sh "psql #{DB_ACCESS} #{DB_CONFIG[:database]} < #{dump_file.path}"
-				else
-					raise 'Unknown DB dump file format'
-				end
-			end
-
-			desc 'List DB dumps'
-			task :list do
-				DumpFile.all.each(&:print)
-			end
-		end
-
-		alias_task :dumps, 'dumps:list'
-		alias_task :dump, 'dumps:create'
-		alias_task :restore, 'dumps:restore'
-
-		desc 'Create empty DB'
-		task :create do
-			sh "createdb -U postgres #{DB_CONFIG[:database]} -O #{DB_CONFIG[:user]}"
-			DB_EXTENSIONS.each do |db_extension|
-				sh "psql -U postgres -c 'CREATE EXTENSION #{db_extension}'" \
-					 " #{DB_CONFIG[:database]}"
-			end
-		end
-
-		desc 'Drop DB'
-		task :drop, :force do |_task, args|
-			case Question.new("Drop #{DB_CONFIG[:database]} ?", %w[yes no]).answer
-			when 'no'
-				abort 'OK'
-			end
-
-			Rake::Task['db:dump'].invoke unless args[:force]
-			sh "dropdb #{DB_ACCESS} #{DB_CONFIG[:database]}"
-		end
-	end
-end
-
-namespace :locales do
-	CROWDIN_CONFIG_FILE = 'config/crowdin.yml'
-
-	desc 'Upload files for translation'
-	task :upload do
-		sh "crowdin --config #{CROWDIN_CONFIG_FILE} upload sources"
-	end
-
-	desc 'Download translated files'
-	task :download do
-		sh "crowdin --config #{CROWDIN_CONFIG_FILE} download translations"
-	end
-
-	desc 'Check locales'
-	task :check do
-		require 'yaml'
-		require 'json'
-
-		## Class for Locale file
-		class Locale
-			attr_reader :code, :hash
-
-			EXT = '.yml'
-
-			def self.load(locales_dir = 'locales')
-				Dir[File.join(__dir__, locales_dir, "*#{EXT}")].map do |file|
-					new File.basename(file, EXT), YAML.load_file(file)
-				end
-			end
-
-			def initialize(code, hash)
-				@code = code
-				@hash = hash
-			end
-
-			class HashCompare
-				def initialize(hash, other_hash)
-					@hash = hash
-					@other_hash = other_hash
-					@diff = {}
-				end
-
-				def different_keys
-					@hash.each_pair do |key, value|
-						other_value = @other_hash[key]
-						if value.is_a?(Hash) && other_value.is_a?(Hash)
-							add_differences_in_hash(value, other_value, key)
-						elsif value.is_a?(Array) && other_value.is_a?(Array)
-							add_differences_in_array(value, other_value, key)
-						elsif other_value.nil? || value.class != other_value.class
-							add_difference(value, key)
-						end
-					end
-					@diff
-				end
-
-				private
-
-				def add_difference(difference, key)
-					@diff[key] = difference unless difference.empty?
-				end
-
-				def add_differences_in_hash(hash, other_hash, key)
-					difference = self.class.new(hash, other_hash).different_keys
-					add_difference(difference, key)
-				end
-
-				def add_differences_in_array(array, other_array, key)
-					difference =
-						if array.size != other_array.size
-							array
-						else
-							differences_in_array(array, other_array)
-						end
-					add_difference(difference, key)
-				end
-
-				def differences_in_array(array, other_array)
-					array.each_with_object([]).with_index do |(object, diff), i|
-						other_object = other_array[i]
-						if object.is_a?(Hash) && other_object.is_a?(Hash)
-							difference = self.class.new(object, other_object).different_keys
-							diff << difference unless difference.empty?
-						end
-					end.compact
-				end
-			end
-
-			def diff(other)
-				HashCompare.new(hash, other.hash).different_keys
-			end
-		end
-
-		locales = Locale.load
-
-		def compare_locales(locale, other_locale)
-			puts "#{locale.code.upcase} -> #{other_locale.code.upcase}:\n\n"
-			puts locale.diff(other_locale).to_yaml
-		end
-
-		locales.each_with_index do |locale, ind|
-			locales[ind..-1].each do |other_locale|
-				next if locale == other_locale
-				compare_locales(locale, other_locale)
-				compare_locales(other_locale, locale)
-			end
-		end
-	end
-end
-
-namespace :static do
-	desc 'Check static files'
-	task :check do
-		Dir[File.join(__dir__, 'public/**/*')].each do |file|
-			basename = File.basename(file)
-			grep_options = '--exclude-dir={\.git,log} --color=always'
-			found = `grep -ir '#{basename}' ./ #{grep_options}`
-			next unless found.empty? && File.dirname(file) != @skipping_dir
-			filename = file.sub(__dir__, '')
-			case Question.new("Delete #{filename} ?", %w[yes no skip]).answer
-			when 'yes'
-				`git rm #{file.gsub(' ', '\ ')}`
-			when 'skip'
-				@skipping_dir = File.dirname(file)
-			end
-		end
-	end
-end
-
-namespace :config do
-	desc 'Check config files'
-	task :check do
-		example_suffix = '.example'
-		Dir[
-			File.join(__dir__, "config/**/*#{example_suffix}*")
-		].each do |example_filename|
-			regular_filename = example_filename.sub(example_suffix, '')
-			if File.exist? regular_filename
-				if File.mtime(example_filename) > File.mtime(regular_filename)
-					example_basename = File.basename example_filename
-					regular_basename = File.basename regular_filename
-
-					ask_what_to_do = proc do
-						case answer = Question.new(
-							"\e[32m\e[1m#{example_basename}\e[22m\e[0m was modified after" \
-								" \e[31m\e[1m#{regular_basename}\e[22m\e[0m." \
-								" Do you want to edit \e[31m\e[1m#{regular_basename}\e[22m\e[0m ?",
-							%w[yes no show quit]
-						).answer
-						when 'yes'
-							edit_file regular_filename
-						when 'show'
-							show_diff regular_filename, example_filename
-							answer = ask_what_to_do.call
-						end
-
-						answer
-					end
-
-					break if ask_what_to_do.call == 'quit'
-				end
-			else
-				FileUtils.cp example_filename, regular_filename
-				edit_file regular_filename
-			end
-		end
-	end
-end
-
-desc 'Start interactive console'
-task :console, :environment do |_t, args|
-	require 'rack/console'
-
-	args = args.to_hash
-	args[:environment] ||= 'development'
-	ARGV.clear
-	Rack::Console.new(args).start
-end
-
-desc 'Start psql'
-task :psql do
-	update_pgpass
-	sh "psql #{DB_ACCESS} #{DB_CONFIG[:database]}"
-end
-
-## Command for update server
-desc 'Update from git'
-task :update, :branch, :without_restart do |_t, args|
-	args = args.to_hash
-	args[:branch] ||= :master
-	server = './server'
-	sh "git checkout #{args[:branch]}"
-	sh "git pull origin #{args[:branch]}"
-	next if args[:without_restart]
-	sh 'bundle check || bundle install'
-	sh "#{server} stop"
-	sh 'rake config:check'
-	sh 'rake db:migrate'
-	sh "#{server} start"
-end
-
-## Command before creating new branch
-desc 'Fetch origin and rebase branch from master'
-task :rebase do
-	sh 'git fetch origin'
-	sh 'git rebase origin/master'
-end
-
-## Command for deploy code from git to server
-## @example rake deploy
-##  Update from git with migrations and restart (for .rb and .erb files update)
-## @example rake deploy[true]
-##  Update from git without migrations and restart (for static files update)
-desc 'Deploy to production server'
-task :deploy, :without_restart do |_t, args|
-	servers = YAML.load_file File.join(__dir__, 'config/deploy.yml')
-	rake_command = "rake update[master#{',true' if args.without_restart}]"
-	servers.each do |server|
-		update_command = "cd #{server[:path]} && #{rake_command}"
-		sh "ssh -t #{server[:ssh]} 'bash --login -c \"#{update_command}\"'"
-	end
-end
-
-namespace :assets do
-	assets_dir = File.join __dir__, 'assets'
-	public_dir = File.join __dir__, 'public'
-
-	styles_input_dir = File.join assets_dir, 'styles'
-	styles_input_file = File.join styles_input_dir, 'main.scss'
-	styles_output_dir = File.join public_dir, 'styles'
-	styles_output_file = File.join styles_output_dir, 'main.css'
-
-	scripts_input_dir = File.join assets_dir, 'scripts'
-	scripts_input_file = File.join scripts_input_dir, 'app.js'
-	scripts_output_dir = File.join public_dir, 'scripts', 'app', 'compiled'
-	scripts_output_file = 'app.js'
-
-	namespace :build do
-		desc 'Build all assets'
-		task all: %w[assets:build:styles assets:build:scripts]
-
-		desc 'Build styles assets'
-		task :styles do
-			next unless File.exist? styles_input_file
-			FileUtils.mkdir_p styles_output_dir
-			sh "sass #{styles_input_file} #{styles_output_file} -t compact"
-		end
-
-		desc 'Build scripts assets'
-		task :scripts do
-			next unless File.exist? scripts_input_file
-			sh 'yarn run webpack' \
-			   " --entry #{scripts_input_file}" \
-			   " --output-path #{scripts_output_dir}" \
-			   " --output-filename #{scripts_output_file}"
-		end
-	end
-
-	alias_task :build, 'build:all'
-
-	namespace :watch do
-		desc 'Watch for styles assets'
-		task :styles do
-			sh "sass --watch #{styles_input_dir}:#{styles_output_dir} -t compact"
-		end
-	end
-end