flame 4.18.1 → 5.0.0.rc1

data/template/{app.rb.erb → application.rb.erb}

@@ -2,6 +2,9 @@
 
 module <%= @module_name %>
 	## Class for application (mounting controllers)
-	class Application
+	class Application < Flame::Application
+		include <%= @short_module_name %>::Config
+
+		mount :site, '/'
 	end
 end

data/template/config.ru.erb

@@ -1,20 +1,72 @@
 # frozen_string_literal: true
 
+environment = ENV['RACK_ENV'].to_sym
+
+is_development = environment == :development
+
 ## Require gems
 require 'bundler'
-Bundler.require
+Bundler.require :default, environment
+
+## Require libs
+# require 'money/bank/google_currency'
 
-## Require project
-Dir[File.join(
-	__dir__, '{config,models,helpers,controllers}', '{,**}', '{_,}*.rb'
-)].each { |file| require file }
+## Require dirs
+Flame::Application.require_dirs(
+	%w[config lib models helpers exports mailers services controllers]
+)
 
 ## Require application
-require_relative './app'
+require './application'
+
+## Use session middleware
+if <%= @short_module_name %>::Application.config[:session]
+	use Rack::Session::Cookie, <%= @short_module_name %>::Application.config[:session][:cookie]
+end
+
+## Logger
+require 'logger'
+logs_dir = File.join(
+	__dir__,
+	<%= @short_module_name %>::Application.config[:server][environment.to_s][:logs_dir]
+)
+
+<%= @short_module_name %>::Application.config[:logger] = Logger.new(
+	is_development ? $stdout : File.join(logs_dir, 'stdout'),
+	'weekly'
+)
+
+## Access Logger
+unless is_development
+	use Rack::CommonLogger, Logger.new(
+		File.join(logs_dir, 'access'),
+		'weekly'
+	)
+end
+
+if <%= @short_module_name %>.const_defined?(:DB)
+	## SQL Logger
+	if is_development
+		<%= @short_module_name %>::DB.loggers <<
+			if ENV['RACK_CONSOLE_INTRO']
+				Logger.new($stdout)
+			else
+				<%= @short_module_name %>.logger
+			end
+	end
+
+	## Freeze DB (not for `rake console`)
+	<%= @short_module_name %>::DB.freeze unless ENV['RACK_CONSOLE_INTRO']
+end
+
+## Remove invalid UTF-8 characters from requests
+use Rack::UTF8Sanitizer
+
+## Remove trailing slashes from request path (and redirect)
+# use Rack::RemoveTrailingSlashes
 
-## Use middlewares
-use Rack::Session::Cookie, key: 'rack.session', secret: 'dummy_secret'
-use Rack::CommonLogger
+## CSRF
+# use Rack::Csrf, raise: is_development
 
 ## Run application
-run <%= @module_name %>::Application
+run <%= @short_module_name %>::Application

data/template/config/config.rb.erb

@@ -1,14 +1,56 @@
 # frozen_string_literal: true
 
+## Module for Application configuration
 module <%= @module_name %>
 	## Constants
-	SITE_NAME = '<%= @module_name %>'.freeze
+	SITE_NAME = '<%= @module_name %>'
+	ORGANIZATION_NAME = '<%= @module_name %> LLC'
+	::<%= @short_module_name %> = ::<%= @module_name %>
+
+	## Helpers
+	def self.logger
+		<%= @short_module_name %>::Application.config[:logger]
+	end
 
 	## Configuration for application
 	module Config
 		def self.included(app)
 			## Translations
-			# Flame::R18n.config(app)
+			# app.include Flame::R18n::Configuration
+
+			## Mail
+			# app.include Config::Mail
+
+			## Sentry
+			# app.include Config::Sentry
+
+			## Threads (for mails)
+			Thread.abort_on_exception = true
+
+			## Currencies rates
+			# Money.default_bank = Money::Bank::GoogleCurrency.new
+			### https://github.com/RubyMoney/money#troubleshooting
+			# I18n.enforce_available_locales = false
+
+			## Required configs
+			load_configs(app, :server, require: true)
+
+			## Not-required configs
+			# load_configs(app, :google_maps_api)
+
+			## Mails directory
+			# app.config[:mails_dir] = proc { File.join config[:views_dir], 'mail' }
+		end
+
+		def self.load_configs(app, *keys, require: false)
+			keys.each do |key|
+				begin
+					app.config.load_yaml key
+				rescue => exception
+					next unless require
+					raise exception
+				end
+			end
 		end
 	end
 end

data/template/config/database.example.yml

@@ -2,4 +2,4 @@
 :host: 'localhost'
 :database: 'database'
 :user: 'user'
-:password: 'password'
+# :password: 'password'

data/template/config/deploy.example.yml

@@ -0,0 +1,2 @@
+- :ssh: 'server alias from ~/.ssh/config (or user@host)'
+  :path: '/path/to/root/of/project'

data/template/config/puma.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env puma
+# frozen_string_literal: true
+
+require 'yaml'
+config = YAML.load_file(File.join(__dir__, 'server.yml'))
+
+environment = ENV['RACK_ENV'] || config[:environment]
+env_config = config[environment]
+
+root_dir = File.join(__dir__, '..')
+directory root_dir
+
+prune_bundler
+
+rackup 'config.ru'
+
+require 'fileutils'
+
+raise 'Unknown directory for pid files!' unless env_config[:pids_dir]
+pids_dir = File.join root_dir, env_config[:pids_dir]
+FileUtils.mkdir_p pids_dir
+
+pidfile File.join pids_dir, env_config[:pid_file]
+state_path File.join pids_dir, 'puma.state'
+
+raise 'Unknown directory for log files!' unless env_config[:logs_dir]
+log_dir = File.join root_dir, env_config[:logs_dir]
+FileUtils.mkdir_p log_dir
+
+if env_config[:daemonize]
+	stdout_redirect(
+		File.join(log_dir, 'stdout'),
+		File.join(log_dir, 'stderr'),
+		true # append to file
+	)
+end
+
+environment environment
+
+# preload_app! if config['environment'] != 'production'
+
+cores = Etc.nprocessors
+workers_count = env_config[:workers_count] || (cores < 2 ? 1 : 2)
+
+workers workers_count
+worker_timeout env_config[:daemonize] ? 15 : 1_000_000
+threads 0, env_config[:threads_count] || 4
+daemonize env_config[:daemonize]
+
+# bind 'unix://' + File.join(%w[tmp sockets puma.sock])
+env_config[:binds].each do |type, value|
+	value = "#{value[:host]}:#{value[:port]}" if type == :tcp
+	FileUtils.mkdir_p File.join(root_dir, File.dirname(value)) if type == :unix
+	bind "#{type}://#{value}"
+end
+# activate_control_app 'tcp://0.0.0.0:3000'

data/template/config/sequel.rb.erb

@@ -4,12 +4,19 @@ require 'yaml'
 
 ## Database initialize for Sequel
 module <%= @module_name %>
-	# Sequel::Model.plugin :timestamps
-	# Sequel::Model.raise_on_save_failure = false
+	database_config_file = File.join(__dir__, 'database.yml')
+	if File.exist?(database_config_file)
+		Sequel::Model.plugin :timestamps
+		Sequel::Model.plugin :json_serializer
+		Sequel::Model.raise_on_save_failure = false
 
-	DB = Sequel.connect(
-		YAML.load_file(File.join(__dir__, 'database.yml'))
-	)
+		database_config = YAML.load_file(database_config_file)
+		env_db_name = ENV['DB_NAME']
+		database_config[:database] = env_db_name if env_db_name
+		DB = Sequel.connect database_config
 
-	# DB.extension :pg_enum
+
+		# DB.extension :pg_enum
+		DB.extension :error_sql
+	end
 end

data/template/config/server.example.yml

@@ -0,0 +1,32 @@
+:environment: development
+# :environment: production
+
+:default: &default
+  :binds:
+    :tcp:
+      :host: '0.0.0.0'
+      :port: 3000
+    # :unix: 'tmp/sockets/puma.sock'
+  :daemonize: false
+  :pids_dir: tmp/pids
+  :logs_dir: log
+  :pid_file: puma.pid
+  # :workers_count: 1
+  # :threads_count: 4
+
+development: &development
+  <<: *default
+  :workers_count: 1
+  :threads_count: 4
+
+test: &test
+  <<: *default
+  :daemonize: false
+
+production: &production
+  <<: *default
+  :binds:
+    # :tcp:
+    #   :host: '0.0.0.0'
+    #   :port: 3000
+    :unix: 'tmp/sockets/puma.sock'

data/template/config/session.example.yml

@@ -0,0 +1,7 @@
+:cookie:
+  :key: 'rack.session'
+  #:domain: 'foo.com'
+  #:path: '/'
+  :expire_after: 2592000 # 30 days
+  :secret: 'change_me'
+  #:old_secret: 'also_change_me'

data/template/controllers/{_base_controller.rb.erb → _controller.rb.erb}

@@ -3,11 +3,12 @@
 module <%= @module_name %>
 	## Base controller for any others controllers
 	class Controller < Flame::Controller
-		# include Flame::R18n
+		# include Flame::R18n::Initialization
 
-		def execute(method)
-			# session[:locale] = params[:locale] || 'ru'
-			super
+		private
+
+		def logger
+			<%= @short_module_name %>.logger
 		end
 	end
 end

data/template/controllers/site/_controller.rb.erb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module <%= @module_name %>
+	module Site
+		## Base controller for site-section
+		class Controller < <%= @short_module_name %>::Controller
+			# include Flame::Flash
+			# include Flame::R18n::LocaleInPath
+
+			protected
+
+			def execute(method)
+				response.headers[Rack::CONTENT_TYPE] = 'text/html; charset=utf-8'
+				super
+			end
+		end
+	end
+end

data/template/controllers/site/index_controller.rb.erb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module <%= @module_name %>
+	module Site
+		## Index controller for example
+		class IndexController < <%= @short_module_name %>::Site::Controller
+			def index
+				view
+			end
+		end
+	end
+end

data/template/filewatchers.yml

@@ -0,0 +1,12 @@
+- :pattern: '**/{Gemfile,*.{rb,ru,yml}}'
+  :exclude: '**/{spec/**/*,config/**/*.example*}'
+  :command: bundle exec pumactl restart -F config/puma.rb
+
+# - :pattern: 'assets/styles/**/*'
+#   :command: rake assets:build:styles
+#
+# - :pattern: '{assets/scripts/**/*,{.babelrc,webpack.config.js}}'
+#   :command: rake assets:build:scripts
+#
+# - :pattern: 'package.json'
+#   :command: yarn install && rake assets:build:scripts

data/template/server

@@ -1,49 +1,200 @@
 #!/usr/bin/env ruby
+
 # frozen_string_literal: true
 
+require 'shellwords'
+require 'yaml'
+
 ## Functons
 def show_usage
-	puts 'Usage: ./server COMMAND'
-	puts 'COMMAND is one of:'
-	puts '    start - Start server'
-	puts '     stop - Stop server'
-	puts '  restart - Stop/Start server'
-	puts '  monitor - Show log'
-	puts '    devel - Restart/Monitor server'
+	puts <<~USAGE
+		Usage: ./server COMMAND
+
+		  COMMAND is one of:
+		      start - Start server
+		       stop - Stop server
+		       kill - Kill server (and filewatcher)
+		    restart - Restart server
+		    monitor - Show log
+		      devel - Restart and monitor server
+		         ps - Show processes of server
+	USAGE
+end
+
+def bash(command, print: true)
+	puts command if print
+	system bash_command(command)
+end
+
+def bash_command(command)
+	escaped_command = Shellwords.escape(command)
+	"bash -c #{escaped_command}"
+end
+
+def bash_spawn(command)
+	puts "spawn #{command}"
+	spawn bash_command command
+end
+
+def server(command)
+	if %i[start restart].include?(command) &&
+	   !(dependencies_check && assets_build)
+		exit
+	end
+	if %i[stop restart].include?(command)
+		kill_each read_filewatcher_pids
+		delete_filewatcher_pids_file
+	end
+	web_server(command)
+end
+
+def web_server(command)
+	pumactl_command = "bundle exec pumactl #{command} -F #{puma_config_file}"
+	if environment == 'production' || command != :restart
+		waiting_mailing_lock if %i[stop restart].include?(command)
+		return bash pumactl_command
+	end
+	development_restart pumactl_command
+end
+
+def development_restart(pumactl_command)
+	filewatcher_pids =
+		development_filewatchers.map { |command| bash_spawn command }
+	dump_filewatcher_pids filewatcher_pids
+	# web_server :stop if File.exist? puma_pid_file
+	# web_server :start
+	File.exist?(puma_pid_file) ? bash(pumactl_command) : web_server(:start)
+rescue SystemExit, Interrupt
+	kill_each filewatcher_pids
+	delete_filewatcher_pids_file
+end
+
+def kill_each(pids)
+	Array(pids).each do |pid|
+		bash "kill #{pid}"
+	end
+end
+
+def filewatcher_command(pattern, execute, exclude: nil)
+	<<-CMD.split.join(' ')
+		bundle exec "
+			filewatcher
+				'#{pattern}'
+				#{"--exclude '#{exclude}'" unless exclude.nil?}
+				'#{execute}'
+		"
+	CMD
+end
+
+def development_filewatchers
+	YAML.load_file(File.join(__dir__, 'filewatchers.yml')).map do |args|
+		filewatcher_command args[:pattern], args[:command], exclude: args[:exclude]
+	end
+end
+
+def dump_filewatcher_pids(filewatcher_pids)
+	FileUtils.mkdir_p server_config_pids_dir
+	File.write(
+		filewatcher_pids_file,
+		filewatcher_pids.join($RS)
+	)
+end
+
+def read_filewatcher_pids
+	return unless File.exist?(filewatcher_pids_file)
+	File.read(filewatcher_pids_file).split($RS)
+end
+
+def delete_filewatcher_pids_file
+	return unless File.exist?(filewatcher_pids_file)
+	File.delete filewatcher_pids_file
+end
+
+def server_config
+	@server_config ||= YAML.load_file(File.join(__dir__, 'config', 'server.yml'))
+end
+
+def puma_config_file
+	@puma_config_file ||= File.join(__dir__, 'config', 'puma.rb')
+end
+
+def puma_pid_file
+	File.join(
+		__dir__, *server_config[environment].values_at(:pids_dir, :pid_file)
+	)
 end
 
-def start_server
-	system 'rm log/*'
-	system 'thin -C config/thin.yml start'
+def server_config_pids_dir
+	server_config[environment][:pids_dir]
 end
 
-def stop_server
-	system 'thin -C config/thin.yml stop'
+def filewatcher_pids_file
+	File.join server_config_pids_dir, 'filewatcher.pids'
 end
 
-def restart_server
-	stop_server
-	start_server
+def environment
+	ENV['RACK_ENV'] || server_config[:environment]
+end
+
+def log_files
+	File.join(__dir__, %w[log {stdout,stderr}])
+end
+
+def waiting_mailing_lock
+	while Dir[File.join(__dir__, 'tmp', 'mailing_*')].any?
+		puts "\e[31m\e[1mMails sending in progress!\e[22m\e[0m\nWaiting..."
+		sleep 1
+	end
 end
 
 def monitor_server
-	system 'tail -f log/thin.*.log'
+	bash "tail -f #{log_files}"
+end
+
+def dependencies_check
+	bash('bundle check || bundle install') # && bash('yarn install')
+end
+
+def assets_build
+	bash 'rake assets:build', print: false
+end
+
+def ps_with_grep(pattern)
+	bash "ps aux | grep #{pattern} --color", print: false
 end
 
 ## Runtime
 case ARGV[0]
 when 'start'
-	start_server
+	server :start
 when 'stop'
-	stop_server
+	server :stop
 when 'restart'
-	restart_server
+	server :restart
+when 'kill'
+	server :stop
+	bash 'pkill -f filewatcher'
+	bash 'pkill -f puma'
 when 'monitor'
 	monitor_server
 when 'devel'
-	restart_server
-	monitor_server
+	server :restart
+	if environment == 'production'
+		puts 'Waiting for logs...'
+		sleep 1.5
+		monitor_server
+	end
+when 'ps'
+	puts
+	puts 'Filewatcher:'
+	puts
+	ps_with_grep '[f]ilewatcher'
+	puts
+	puts 'Puma:'
+	puts
+	ps_with_grep '[p]uma[\ :]'
 else
 	puts "Unknown command #{ARGV[0]}"
+	puts
 	show_usage
 end