flame 4.18.1 → 5.0.0.rc1

data/lib/flame/validators.rb

@@ -7,12 +7,18 @@ module Flame
 	module Validators
 		## Compare arguments from path and from controller's action
 		class RouteArgumentsValidator
+			## Create a new instance of validator
+			## @param ctrl [Flame::Controller] controller of route
+			## @param path [Flame::Path, String] path of route
+			## @param action [Symbol, String] action of route
 			def initialize(ctrl, path, action)
 				@ctrl = ctrl
 				@path = Flame::Path.new(path)
 				@action = action
 			end
 
+			## Validate
+			## @return [true, false] valid or not
 			def valid?
 				extra_valid? && order_valid?
 			end
@@ -81,7 +87,7 @@ module Flame
 			def first_wrong_ordered_arguments
 				opt_arguments = action_arguments[:opt].zip(path_arguments[:opt])
 				opt_arguments.map! do |args|
-					args.map { |arg| Flame::Path::PathPart.new(arg, arg: :opt) }
+					args.map { |arg| Flame::Path::Part.new(arg, arg: :opt) }
 				end
 				opt_arguments.find do |action_argument, path_argument|
 					action_argument != path_argument

data/lib/flame/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Flame
-	VERSION = '4.18.1'
+	VERSION = '5.0.0.rc1'
 end

data/template/.editorconfig

@@ -0,0 +1,15 @@
+root = true
+
+[*]
+indent_style = tab
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.yml]
+indent_style = space
+
+[*.md]
+indent_style = space

data/template/.gitignore

@@ -1,11 +1,28 @@
 # configuration
-config/*.yml
-!config/*example.yml
+config/**/*
+!config/**/*.example*
+!config/**/*.rb
+!config/**/*.erb
+!config/nginx
+!config/nginx/snippets
+!config/nginx/snippets/*.example*
+!config/nginx/snippets/ssl-params.conf
+!config/nginx/sites
+!config/nginx/sites/*.example*
 
 # temp
+.sass-cache/
 log/
 tmp/
 *.bak
+*~
+
+# uploaded files
+#public/files
 
 # dumps
 *.sql
+
+# seo files
+#views/site/sitemap.html
+#public/robots.txt

data/template/.rubocop.yml

@@ -0,0 +1,14 @@
+Layout/Tab:
+  Enabled: false
+Layout/IndentationWidth:
+  Width: 1
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: indented
+
+AllCops:
+  TargetRubyVersion: 2.3
+
+Metrics/BlockLength:
+  Exclude:
+    - Rakefile
+    - db/migrations/*

data/template/Gemfile

@@ -2,14 +2,54 @@
 
 source 'https://rubygems.org'
 
-## Framework
-gem 'flame'
-# gem 'flame-flash'
-# gem 'flame-r18n'
+## https://github.com/bundler/bundler/issues/4978
+git_source(:github) { |name| "https://github.com/#{name}.git" }
 
-## Server
-gem 'thin'
+## system
+# gem 'gorilla-patch'
 
-## DataBase
-gem 'sequel'
+## server
+gem 'flame', github: 'AlexWayfer/flame'
+# gem 'flame-flash', github: 'AlexWayfer/flame-flash'
+gem 'puma'
+# gem 'rack-slashenforce'
+gem 'rack-utf8_sanitizer'
+# gem 'rack_csrf', require: 'rack/csrf'
+
+group :development do
+	gem 'filewatcher'
+	gem 'pry-byebug'
+end
+
+group :linter do
+	# gem 'rubocop'
+end
+
+## database
 # gem 'pg'
+# gem 'sequel'
+# gem 'sequel_pg', require: 'sequel'
+
+## translations
+# gem 'flame-r18n', github: 'AlexWayfer/flame-r18n'
+## for named_variables filter
+# gem 'r18n-rails-api'
+
+## views
+gem 'erubi', require: 'tilt/erubi'
+
+## assets
+# gem 'sass'
+
+## others
+# gem 'faker'
+# gem 'google_currency'
+# gem 'kramdown'
+# gem 'mail'
+# gem 'money'
+# gem 'sentry-raven'
+
+## tools
+gem 'pry'
+gem 'rack-console'
+gem 'rake'

data/template/Rakefile

@@ -0,0 +1,824 @@
+# 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')
+
+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 File.join('~', '.pgpass')
+
+		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 = File.join('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