flame 5.0.0.rc4 → 5.0.0.rc7

data/lib/flame/controller.rb

@@ -3,65 +3,48 @@
 require 'forwardable'
 require 'gorilla_patch/namespace'
 
+require_relative 'router'
+
+require_relative 'controller/actions'
+require_relative 'controller/cookies'
 require_relative 'controller/path_to'
-require_relative 'render'
 
+## Just because of `autoload`
 module Flame
+	autoload :Render, "#{__dir__}/render"
+
 	## Class initialize when Dispatcher found route with it
 	## For new request and response
 	class Controller
-		extend Forwardable
+		extend Actions
+		include Memery
 
-		## Shortcut for not-inherited public methods: actions
-		## @return [Array<Symbol>] array of actions (public instance methods)
-		def self.actions
-			public_instance_methods(false)
-		end
+		class << self
+			attr_accessor :path_arguments
+
+			def path
+				return self::PATH if const_defined?(:PATH)
 
-		## Re-define public instance methods (actions) from parent
-		## @param actions [Array<Symbol>] Actions for inheritance
-		## @param exclude [Array<Symbol>] Actions for excluding from inheritance
-		## @example Inherit all parent actions
-		##   class MyController < BaseController
-		##     inherit_actions
-		##   end
-		## @example Inherit certain parent actions
-		##   class MyController < BaseController
-		##     inherit_actions :index, :show
-		##   end
-		## @example Inherit all parent actions exclude certain
-		##   class MyController < BaseController
-		##     inherit_actions exclude: %i[edit update]
-		##   end
-		def self.inherit_actions(actions = superclass.actions, exclude: [])
-			(actions - exclude).each do |public_method|
-				um = superclass.public_instance_method(public_method)
-				define_method public_method, um
+				default_path
 			end
-		end
 
-		## Re-define public instance method from module
-		## @example Define actions from module in controller
-		##   class MyController < BaseController
-		##     include with_actions Module1
-		##     include with_actions Module2
-		##     ....
-		##   end
-		def self.with_actions(mod, exclude: [])
-			Module.new do
-				@mod = mod
-				@exclude = exclude
-
-				def self.included(ctrl)
-					ctrl.include @mod
-
-					(@mod.public_instance_methods - @exclude).each do |meth|
-						ctrl.send :define_method, meth, @mod.public_instance_method(meth)
-					end
-				end
+			private
+
+			using GorillaPatch::Inflections
+
+			## Default root path of the controller for requests
+			def default_path
+				modules = underscore.split('/')
+				parts = modules.pop.split('_')
+				parts.shift if parts.first == 'index'
+				parts.pop if %w[controller ctrl].include? parts.last
+				parts = [modules.last] if parts.empty?
+				Flame::Path.merge nil, parts.join('_')
 			end
 		end
 
+		extend Forwardable
+
 		def_delegators(
 			:@dispatcher,
 			:config, :request, :params, :halt, :session, :response, :status, :body,
@@ -74,6 +57,11 @@ module Flame
 			@dispatcher = dispatcher
 		end
 
+		## Cookies object as Hash
+		memoize def cookies
+			Cookies.new(request.cookies, response)
+		end
+
 		include Flame::Controller::PathTo
 
 		## Redirect for response
@@ -127,6 +115,7 @@ module Flame
 			content_dis = 'Content-Disposition'
 			response[content_dis] = disposition.to_s
 			return unless filename
+
 			response[content_dis] << "; filename=\"#{File.basename(filename)}\""
 			ext = File.extname(filename)
 			response.content_type = ext unless ext.empty?
@@ -157,13 +146,15 @@ module Flame
 		end
 
 		def not_found
-			body default_body
+			default_body
 		end
 
 		## Default method for Internal Server Error, can be inherited
 		## @param _exception [Exception] exception from code executing
 		## @return [String] content of exception page
-		def server_error(_exception)
+		def server_error(exception)
+			raise exception if Object.const_defined?(:BetterErrors)
+
 			body default_body
 		end
 
@@ -184,6 +175,12 @@ module Flame
 			body
 		end
 
+		using GorillaPatch::Slice
+
+		def controller_arguments
+			params.slice(*self.class.path_arguments)
+		end
+
 		def extract_params_for(action)
 			## Take parameters from action method
 			parameters = method(action).parameters
@@ -198,35 +195,5 @@ module Flame
 			## Concat values
 			req_values + opt_values
 		end
-
-		def add_controller_class(args)
-			args.unshift(self.class) if args[0].is_a?(Symbol)
-			args.insert(1, :index) if args[0].is_a?(Class) && !args[1].is_a?(Symbol)
-		end
-
-		class << self
-			using GorillaPatch::Inflections
-
-			## Default root path of the controller for requests
-			def default_path
-				modules = underscore.split('/')
-				parts = modules.pop.split('_')
-				parts.shift if parts.first == 'index'
-				parts.pop if %w[controller ctrl].include? parts.last
-				parts = [modules.last] if parts.empty?
-				Flame::Path.merge nil, parts.join('_')
-			end
-
-			def refined_http_methods
-				@refined_http_methods ||= []
-			end
-
-			Flame::Router::HTTP_METHODS.each do |http_method|
-				downcased_http_method = http_method.downcase
-				define_method(downcased_http_method) do |action_path, action = nil|
-					refined_http_methods << [downcased_http_method, action_path, action]
-				end
-			end
-		end
 	end
 end

data/lib/flame/dispatcher/request.rb

@@ -4,15 +4,15 @@ module Flame
 	class Dispatcher
 		## Class for requests
 		class Request < Rack::Request
+			include Memery
+
 			## Initialize Flame::Path
-			def path
-				@path ||= Flame::Path.new path_info
+			memoize def path
+				Flame::Path.new path_info
 			end
 
 			## Override HTTP-method of the request if the param '_method' found
-			def http_method
-				return @http_method if defined?(@http_method)
-
+			memoize def http_method
 				method_from_method =
 					begin
 						params['_method']
@@ -21,7 +21,23 @@ module Flame
 						raise unless e.message.include?('invalid %-encoding')
 					end
 
-				@http_method = (method_from_method || request_method).upcase.to_sym
+				(method_from_method || request_method).upcase.to_sym
+			end
+
+			using GorillaPatch::Inflections
+
+			HEADER_PREFIX = 'HTTP_'
+
+			## Helper method for comfortable Camel-Cased Hash of headers
+			memoize def headers
+				env.each_with_object({}) do |(key, value), result|
+					next unless key.start_with?(HEADER_PREFIX)
+
+					camelized_key =
+						key.delete_prefix(HEADER_PREFIX).downcase.tr('_', '/').camelize.gsub('::', '-')
+
+					result[camelized_key] = value
+				end
 			end
 		end
 	end

data/lib/flame/dispatcher/routes.rb

@@ -11,8 +11,10 @@ module Flame
 				http_method = request.http_method
 				http_method = :GET if http_method == :HEAD
 				return unless available_endpoint
+
 				route = available_endpoint[http_method]
 				return unless route || available_endpoint.allow
+
 				halt(405, nil, 'Allow' => available_endpoint.allow) unless route
 				status 200
 				execute_route route
@@ -26,32 +28,38 @@ module Flame
 					router.path_of(route).extract_arguments(request.path)
 				)
 				# route.execute(self)
-				controller = route.controller.new(self)
-				controller.send(:execute, action)
-			rescue StandardError => exception
+				@current_controller = route.controller.new(self)
+				@current_controller.send(:execute, action)
+			rescue StandardError, SyntaxError => e
 				# p 'rescue from dispatcher'
-				dump_error(exception)
+				dump_error(e)
 				status 500
-				controller&.send(:server_error, exception)
-				# p 're raise exception from dispatcher'
-				# raise exception
+				@current_controller&.send(:server_error, e)
+				# p 're raise error from dispatcher'
+				# raise e
 			end
 
 			## Generate a default body of nearest route
 			def default_body_of_nearest_route
 				## Return nil if must be no body for current HTTP status
 				return if Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include?(status)
+
 				## Find the nearest route by the parts of requested path
 				route = router.find_nearest_route(request.path)
 				## Return standard `default_body` if the route not found
 				return default_body unless route
-				controller = route.controller.new(self)
-				## Execute `not_found` method for the founded route
-				if response.not_found?
-					controller.send(:not_found)
-				else
-					body controller.send(:default_body)
-				end
+
+				return not_found_body(route) if response.not_found?
+
+				controller =
+					(@current_controller if defined?(@current_controller)) || route.controller.new(self)
+				controller.send :default_body
+			end
+
+			def not_found_body(route)
+				## Execute `not_found` method as action for the founded route
+				execute_route(route, :not_found)
+				body
 			end
 		end
 	end

data/lib/flame/dispatcher/static.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'cgi'
+
 module Flame
 	class Dispatcher
 		## Module for working with static files
@@ -16,9 +18,11 @@ module Flame
 			private
 
 			## Find static files and try return it
-			def try_static(*args)
-				file = find_static(*args)
+			def try_static(*args, **kwargs)
+				file = find_static(*args, **kwargs)
 				return nil unless file.exist?
+
+				halt 400 unless file.within_directory
 				return_static(file)
 			end
 
@@ -32,9 +36,14 @@ module Flame
 
 			## Class for static files with helpers methods
 			class StaticFile
+				attr_reader :extname, :within_directory
+
 				def initialize(filename, dir)
 					@filename = filename.to_s
-					@file_path = File.join dir, CGI.unescape(@filename)
+					@directory = File.expand_path dir
+					@file_path = File.expand_path File.join dir, CGI.unescape(@filename)
+					@extname = File.extname(@file_path)
+					@within_directory = @file_path.start_with? @directory
 				end
 
 				def exist?
@@ -45,10 +54,6 @@ module Flame
 					File.mtime(@file_path)
 				end
 
-				def extname
-					File.extname(@file_path)
-				end
-
 				def newer?(http_since)
 					!http_since || mtime.to_i > Time.httpdate(http_since).to_i
 				end
@@ -58,8 +63,7 @@ module Flame
 				end
 
 				def path(with_version: false)
-					path = @filename
-					with_version ? "#{path}?v=#{mtime.to_i}" : path
+					with_version ? "#{@filename}?v=#{mtime.to_i}" : @filename
 				end
 			end
 

data/lib/flame/dispatcher.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 require 'gorilla_patch/symbolize'
+require 'rack'
 
 require_relative 'dispatcher/request'
 require_relative 'dispatcher/response'
-require_relative 'dispatcher/cookies'
 
 require_relative 'dispatcher/static'
 require_relative 'dispatcher/routes'
@@ -14,6 +14,8 @@ require_relative 'errors/route_not_found_error'
 module Flame
 	## Helpers for dispatch Flame::Application#call
 	class Dispatcher
+		include Memery
+
 		GEM_STATIC_FILES = File.join(__dir__, '../../public').freeze
 
 		extend Forwardable
@@ -73,34 +75,27 @@ module Flame
 
 		## Parameters of the request
 		def params
-			@params ||=
-				begin
-					request.params.symbolize_keys(deep: true)
-				rescue ArgumentError => e
-					raise unless e.message.include?('invalid %-encoding')
-					{}
-				end
+			request.params.symbolize_keys(deep: true)
+		rescue ArgumentError => e
+			raise unless e.message.include?('invalid %-encoding')
+
+			{}
 		end
+		memoize :params
 
 		## Session object as Hash
 		def session
 			request.session
 		end
 
-		## Cookies object as Hash
-		def cookies
-			@cookies ||= Cookies.new(request.cookies, response)
-		end
-
 		## Application-config object as Hash
 		def config
 			@app_class.config
 		end
 
 		## Available routes endpoint
-		def available_endpoint
-			return @available_endpoint if defined? @available_endpoint
-			@available_endpoint = router.navigate(*request.path.parts)
+		memoize def available_endpoint
+			router.navigate(*request.path.parts)
 		end
 
 		## Interrupt the execution of route, and set new optional data
@@ -129,7 +124,7 @@ module Flame
 		def dump_error(error)
 			error_message = [
 				"#{Time.now.strftime('%Y-%m-%d %H:%M:%S')} - " \
-				"#{error.class} - #{error.message}:",
+					"#{error.class} - #{error.message}:",
 				*error.backtrace
 			].join("\n\t")
 			@env[Rack::RACK_ERRORS].puts(error_message)
@@ -138,7 +133,7 @@ module Flame
 		## Generate default body of error page
 		def default_body
 			# response.headers[Rack::CONTENT_TYPE] = 'text/html'
-			"<h1>#{Rack::Utils::HTTP_STATUS_CODES[status]}</h1>"
+			Rack::Utils::HTTP_STATUS_CODES[status]
 		end
 
 		## All cached tilts (views) for application by Flame::Render
@@ -153,12 +148,14 @@ module Flame
 			request.params
 		rescue ArgumentError => e
 			raise unless e.message.include?('invalid %-encoding')
+
 			halt 400
 		end
 
 		## Return response if HTTP-method is OPTIONS
 		def try_options
 			return unless request.http_method == :OPTIONS
+
 			allow = available_endpoint&.allow
 			halt 404 unless allow
 			response.headers['Allow'] = allow

data/lib/flame/errors/argument_not_assigned_error.rb

@@ -9,14 +9,9 @@ module Flame
 			## @param argument [Flame::Path::Part, String, Symbol]
 			##   not assigned argument
 			def initialize(path, argument)
-				@path = path
-				@argument = argument
-			end
-
-			## Calculated message of the error
-			## @return [String] message of the error
-			def message
-				"Argument '#{@argument}' for path '#{@path}' is not assigned"
+				super(
+					"Argument '#{argument}' for path '#{path}' is not assigned"
+				)
 			end
 		end
 	end

data/lib/flame/errors/config_file_not_found_error.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Flame
+	module Errors
+		## Error for not found config file in Config
+		class ConfigFileNotFoundError < StandardError
+			## Create a new instance of error
+			## @param file_name [String]
+			##   file name mask by which file was not found
+			## @param directory [String] directory in which file was not found
+			def initialize(file_name, directory)
+				directory = directory.sub(%r{^/+}, '').sub(%r{/+$}, '')
+				super "Config file '#{file_name}' not found in '#{directory}/'"
+			end
+		end
+	end
+end

data/lib/flame/errors/controller_not_found_error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Flame
+	module Errors
+		## Error for not found controller by name in namespace
+		class ControllerNotFoundError < StandardError
+			## Create a new instance of error
+			## @param controller_name [Symbol, String]
+			##   name of controller which not found
+			## @param namespace [Module]
+			##   namespace for which controller not found
+			def initialize(controller_name, namespace)
+				super(
+					"Controller '#{controller_name}' not found for '#{namespace}'"
+				)
+			end
+		end
+	end
+end

data/lib/flame/errors/route_arguments_order_error.rb

@@ -9,16 +9,9 @@ module Flame
 			## @param wrong_ordered_arguments [Array<Symbol>]
 			##   two wrong ordered arguments
 			def initialize(path, wrong_ordered_arguments)
-				@path = path
-				@wrong_ordered_arguments = wrong_ordered_arguments
-			end
-
-			## Calculated message of the error
-			## @return [String] message of the error
-			def message
-				"Path '#{@path}' should have" \
-					" '#{@wrong_ordered_arguments.first}' argument before" \
-					" '#{@wrong_ordered_arguments.last}'"
+				super(<<~MESSAGE.chomp)
+					Path '#{path}' should have '#{wrong_ordered_arguments.first}' argument before '#{wrong_ordered_arguments.last}'
+				MESSAGE
 			end
 		end
 	end

data/lib/flame/errors/route_extra_arguments_error.rb

@@ -13,30 +13,17 @@ module Flame
 			## @option extra [Symbol] :place extra arguments in controller or path
 			## @option extra [Array<Symbol>] :args extra arguments
 			def initialize(ctrl, action, path, extra)
-				@ctrl = ctrl
-				@action = action
-				@path = path
-				@extra = extra
-				@extra[:type_name] = {
-					req: 'required',
-					opt: 'optional'
-				}[@extra[:type]]
-			end
+				extra[:type_name] = { req: 'required', opt: 'optional' }[extra[:type]]
 
-			## Calculated message of the error
-			## @return [String] message of the error
-			def message
-				case @extra[:place]
-				when :ctrl
+				entity = {
 					## Error if path has no arguments, that controller's method has
 					## NOTE: It isn't using because `Flame::Path#adopt`
-					"Path '#{@path}' has no #{@extra[:type_name]}" \
-						" arguments #{@extra[:args].inspect}"
-				when :path
+					ctrl: "Path '#{path}'",
 					## Error if path has more arguments, than controller's method
-					"Action '#{@ctrl}##{@action}' has no #{@extra[:type_name]}" \
-						" arguments #{@extra[:args].inspect}"
-				end
+					path: "Action '#{ctrl}##{action}'"
+				}[extra[:place]]
+
+				super "#{entity} has no #{extra[:type_name]} arguments #{extra[:args].inspect}"
 			end
 		end
 	end

data/lib/flame/errors/route_not_found_error.rb

@@ -9,15 +9,10 @@ module Flame
 			##   controller with which route not found
 			## @param action [Symbol] action with which route not found
 			def initialize(controller, action)
-				@controller = controller
-				@action = action
-			end
-
-			## Calculated message of the error
-			## @return [String] message of the error
-			def message
-				"Route with controller '#{@controller}' and action '#{@action}'" \
-					' not found in application routes'
+				super(
+					"Route with controller '#{controller}' and action '#{action}' " \
+						'not found in application routes'
+				)
 			end
 		end
 	end

data/lib/flame/errors/template_not_found_error.rb

@@ -9,15 +9,9 @@ module Flame
 			##   controller from which template not found
 			## @param path [String, Symbol] path of not founded template
 			def initialize(controller, path)
-				@controller = controller
-				@controller = @controller.class unless @controller.is_a? Class
-				@path = path
-			end
+				controller = controller.class unless controller.is_a? Class
 
-			## Calculated message of the error
-			## @return [String] message of the error
-			def message
-				"Template '#{@path}' not found for '#{@controller}'"
+				super "Template '#{path}' not found for '#{controller}'"
 			end
 		end
 	end