flame 4.18.1 → 5.0.0.rc6

data/lib/flame/dispatcher/routes.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Flame
+	class Dispatcher
+		## Module for working with routes
+		module Routes
+			private
+
+			## Find route and try execute it
+			def try_route
+				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
+				true
+			end
+
+			## Execute route
+			## @param route [Flame::Route] route that must be executed
+			def execute_route(route, action = route.action)
+				params.merge!(
+					router.path_of(route).extract_arguments(request.path)
+				)
+				# route.execute(self)
+				@current_controller = route.controller.new(self)
+				@current_controller.send(:execute, action)
+			rescue StandardError, SyntaxError => e
+				# p 'rescue from dispatcher'
+				dump_error(e)
+				status 500
+				@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
+
+				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
+end

data/lib/flame/dispatcher/static.rb

@@ -1,9 +1,16 @@
 # frozen_string_literal: true
 
+require 'cgi'
+
 module Flame
 	class Dispatcher
 		## Module for working with static files
 		module Static
+			## Find static file by path
+			## @param filename [String] relative path to the static file
+			## @param dir [String]
+			##   absolute local path of the directory with static files
+			## @return [Flame::Dispatcher::Static::StaticFile] instance of static file
 			def find_static(filename = request.path_info, dir: config[:public_dir])
 				StaticFile.new(filename, dir)
 			end
@@ -11,52 +18,56 @@ 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
 
 			def return_static(file)
-				halt 304 if file.newer? request.env['HTTP_IF_MODIFIED_SINCE']
+				response[Rack::CACHE_CONTROL] = 'public, max-age=31536000' # one year
+				halt 304 unless file.newer? request.env['HTTP_IF_MODIFIED_SINCE']
 				response.content_type = file.extname
-				response[Rack::CACHE_CONTROL] = 'no-cache'
 				response['Last-Modified'] = file.mtime.httpdate
 				body file.content
 			end
 
 			## Class for static files with helpers methods
 			class StaticFile
+				attr_reader :extname, :within_directory
+
 				def initialize(filename, dir)
 					@filename = filename.to_s
-					@path = File.join dir, URI.decode(@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?
-					File.exist?(@path) && File.file?(@path)
+					File.exist?(@file_path) && File.file?(@file_path)
 				end
 
 				def mtime
-					File.mtime(@path)
-				end
-
-				def extname
-					File.extname(@path)
+					File.mtime(@file_path)
 				end
 
 				def newer?(http_since)
-					http_since && Time.httpdate(http_since).to_i >= mtime.to_i
+					!http_since || mtime.to_i > Time.httpdate(http_since).to_i
 				end
 
 				def content
-					File.read(@path)
+					File.read(@file_path)
 				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
+
+			private_constant :StaticFile
 		end
 	end
 end

data/lib/flame/errors/argument_not_assigned_error.rb

@@ -4,13 +4,14 @@ module Flame
 	module Errors
 		## Error for Flame::Dispatcher.path_to
 		class ArgumentNotAssignedError < StandardError
+			## Create a new instance of error
+			## @param path [Flame::Path, String] path without argument
+			## @param argument [Flame::Path::Part, String, Symbol]
+			##   not assigned argument
 			def initialize(path, argument)
-				@path = path
-				@argument = argument
-			end
-
-			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

@@ -4,15 +4,16 @@ module Flame
 	module Errors
 		## Error for Route initialization
 		class RouteArgumentsOrderError < StandardError
+			## Create a new instance of error
+			## @param path [Flame::Path, String] path with wrong arguments order
+			## @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
-
-			def message
-				"Path '#{@path}' should have" \
-					" '#{@wrong_ordered_arguments.first}' argument before" \
-					" '#{@wrong_ordered_arguments.last}'"
+				super(
+					"Path '#{path}' should have" \
+						" '#{wrong_ordered_arguments.first}' argument before" \
+						" '#{wrong_ordered_arguments.last}'"
+				)
 			end
 		end
 	end

data/lib/flame/errors/route_extra_arguments_error.rb

@@ -4,29 +4,29 @@ module Flame
 	module Errors
 		## Error for Route initialization
 		class RouteExtraArgumentsError < StandardError
+			## Create a new instance of error
+			## @param ctrl [Flame::Controller] controller
+			## @param action [Symbol] action
+			## @param path [Flame::Path, String] path
+			## @param extra [Hash] extra arguments
+			## @option extra [Symbol] :type required or optional
+			## @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]]
 
-			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

@@ -4,14 +4,15 @@ module Flame
 	module Errors
 		## Error for Flame::Dispatcher.path_to
 		class RouteNotFoundError < StandardError
-			def initialize(ctrl, method)
-				@ctrl = ctrl
-				@method = method
-			end
-
-			def message
-				"Route with controller '#{@ctrl}' and method '#{@method}'" \
+			## Create a new instance of error
+			## @param controller [Flame::Controller]
+			##   controller with which route not found
+			## @param action [Symbol] action with which route not found
+			def initialize(controller, action)
+				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

@@ -4,14 +4,14 @@ module Flame
 	module Errors
 		## Error for not found template file in Render
 		class TemplateNotFoundError < StandardError
+			## Create a new instance of error
+			## @param controller [Flame::Controller]
+			##   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
 
-			def message
-				"Template '#{@path}' not found for '#{@controller}'"
+				super "Template '#{path}' not found for '#{controller}'"
 			end
 		end
 	end

data/lib/flame/path.rb

@@ -1,26 +1,41 @@
 # frozen_string_literal: true
 
 require 'forwardable'
+require 'memery'
 
 require_relative 'errors/argument_not_assigned_error'
 
 module Flame
 	## Class for working with paths
 	class Path
+		include Memery
+
+		extend Forwardable
+		def_delegators :to_s, :include?
+
+		## Merge parts of path to one path
+		## @param parts [Array<String, Flame::Path>] parts of expected path
+		## @return [Flame::Path] path from parts
 		def self.merge(*parts)
-			parts.join('/').gsub(%r{\/{2,}}, '/')
+			parts.join('/').gsub(%r|/{2,}|, '/')
 		end
 
+		## Create a new instance
+		## @param paths [String, Flame::Path, Array<String, Flame::Path>]
+		##   paths as parts for new path
 		def initialize(*paths)
 			@path = self.class.merge(*paths)
 			freeze
 		end
 
-		def parts
-			@parts ||= @path.to_s.split('/').reject(&:empty?)
-				.map! { |part| PathPart.new(part) }
+		## Return parts of path, splitted by slash (`/`)
+		## @return [Array<Flame::Path::Part>] array of path parts
+		memoize def parts
+			@path.to_s.split('/').reject(&:empty?)
+				.map! { |part| self.class::Part.new(part) }
 		end
 
+		## Freeze all strings in object
 		def freeze
 			@path.freeze
 			parts.each(&:freeze)
@@ -28,143 +43,214 @@ module Flame
 			super
 		end
 
+		## Create new instance from self and other by concatinating
+		## @param other [Flame::Path, String] other path which will be concatinated
+		## @return [Flame::Path] result of concatinating
+		def +(other)
+			self.class.new(self, other)
+		end
+
 		## Compare by parts count and the first arg position
+		## @param other [Flame::Path] other path
+		## @return [-1, 0, 1] result of comparing
 		def <=>(other)
 			self_parts, other_parts = [self, other].map(&:parts)
-			parts_size = self_parts.size <=> other_parts.size
-			return parts_size unless parts_size.zero?
-			self_parts.zip(other_parts)
-				.reduce(0) do |result, (self_part, other_part)|
-					break -1 if self_part.arg? && !other_part.arg?
-					break 1 if other_part.arg? && !self_part.arg?
-					result
-				end
+			by_parts_size = self_parts.size <=> other_parts.size
+			return by_parts_size unless by_parts_size.zero?
+
+			compare_by_args_in_parts self_parts.zip(other_parts)
 		end
 
+		## Compare with other path by parts
+		## @param other [Flame::Path, String] other path
+		## @return [true, false] equal or not
 		def ==(other)
 			other = self.class.new(other) if other.is_a? String
 			parts == other.parts
 		end
 
 		## Complete path for the action of controller
+		## @param ctrl [Flame::Controller] to which controller adapt
+		## @param action [Symbol] to which action of controller adapt
+		## @return [Flame::Path] adapted path
 		## @todo Add :arg:type support (:id:num, :name:str, etc.)
 		def adapt(ctrl, action)
 			parameters = ctrl.instance_method(action).parameters
 			parameters.map! do |parameter|
 				parameter_type, parameter_name = parameter
-				path_part = PathPart.new parameter_name, arg: parameter_type
+				path_part = self.class::Part.new parameter_name, arg: parameter_type
 				path_part unless parts.include? path_part
 			end
 			self.class.new @path.empty? ? "/#{action}" : self, *parameters.compact
 		end
 
-		## Can recieve other as String
-		def match?(other)
-			other = self.class.new(other) if other.is_a? String
-			return false unless other_contain_required_parts?(other)
-			result = [self, other].map { |path| path.parts.size }.max.times do |i|
-				break false unless compare_parts parts[i], other.parts[i]
-			end
-			result = true if result
-			result
-		end
-
 		## Extract arguments from other path with values at arguments
 		## @param other_path [Flame::Path] other path with values at arguments
+		## @return [Hash{Symbol => String}] hash of arguments from two paths
 		def extract_arguments(other_path)
-			parts.each_with_index.with_object({}) do |(part, i), args|
-				other_part = other_path.parts[i].to_s
-				next args unless part.arg?
-				break args if part.opt_arg? && other_part.empty?
-				args[
-					part[(part.opt_arg? ? 2 : 1)..-1].to_sym
-				] = URI.decode(other_part)
-			end
+			Extractor.new(parts, other_path.parts).run
 		end
 
-		## Assign arguments to path for `Controller.path_to`
+		## Assign arguments to path for `Controller#path_to`
 		## @param args [Hash] arguments for assigning
 		def assign_arguments(args = {})
 			result_parts = parts.map { |part| assign_argument(part, args) }.compact
 			self.class.merge result_parts.unshift(nil)
 		end
 
+		## @return [String] path as String
 		def to_s
 			@path
 		end
 		alias to_str to_s
 
-		private
-
-		def other_contain_required_parts?(other)
-			other_parts = other.parts
-			req_path_parts = parts.reject(&:opt_arg?)
-			fixed_path_parts = parts.reject(&:arg?)
-			(fixed_path_parts - other_parts).empty? &&
-				other_parts.count >= req_path_parts.count
+		## Path parts as keys of nested Hashes
+		## @return [Array(Flame::Router::Routes, Flame::Router::Routes)]
+		##   whole Routes (parent) and the endpoint (most nested Routes)
+		def to_routes_with_endpoint
+			endpoint =
+				parts.reduce(result = Flame::Router::Routes.new) do |hash, part|
+					hash[part] ||= Flame::Router::Routes.new
+				end
+			[result, endpoint]
 		end
 
-		def compare_parts(part, other_part)
-			return unless part
-			return if other_part.nil? && !part.opt_arg?
-			# p other_part, part
-			return true if part.arg?
-			return true if other_part == part
-		end
+		private
 
 		## Helpers for `assign_arguments`
 		def assign_argument(part, args = {})
 			## Not argument
 			return part unless part.arg?
 			## Not required argument
-			return args[part[2..-1].to_sym] if part.opt_arg?
+			return args.delete(part[2..-1].to_sym) if part.opt_arg?
+
 			## Required argument
-			param = args[part[1..-1].to_sym]
+			param = args.delete(part[1..-1].to_sym)
 			## Required argument is nil
 			error = Errors::ArgumentNotAssignedError.new(@path, part)
 			raise error if param.nil?
+
 			## All is ok
 			param
 		end
 
+		def compare_by_args_in_parts(self_and_other_parts)
+			result = 0
+
+			self_and_other_parts.each do |self_part, other_part|
+				if self_part.arg?
+					break result = -1 unless other_part.arg?
+				elsif other_part.arg?
+					break result = 1
+				end
+			end
+
+			result
+		end
+
+		## Class for extracting arguments from other path
+		class Extractor
+			def initialize(parts, other_parts)
+				@parts = parts
+				@other_parts = other_parts
+
+				@index = 0
+				@other_index = 0
+
+				@args = {}
+			end
+
+			def run
+				@parts.each do |part|
+					next static_part_found unless part.arg?
+
+					break if part.opt_arg? && @other_parts.count <= @other_index
+
+					@args[part.to_sym] = extract
+					@index += 1
+				end
+
+				@args
+			end
+
+			private
+
+			def static_part_found
+				@index += 1
+				@other_index += 1
+			end
+
+			def extract
+				other_part = @other_parts[@other_index]
+
+				return if @parts[@index.next] == other_part
+
+				@other_index += 1
+				URI.decode_www_form_component(other_part)
+			end
+		end
+
+		private_constant :Extractor
+
 		## Class for one part of Path
-		class PathPart
+		class Part
 			extend Forwardable
 
-			def_delegators :@part, :[], :hash
+			def_delegators :to_s, :[], :hash, :size, :empty?, :b, :inspect
 
 			ARG_CHAR = ':'
 			ARG_CHAR_OPT = '?'
 
+			## Create new instance from String
+			## @param part [String] path part as String
+			## @param arg [Boolean] is this part an argument
 			def initialize(part, arg: false)
 				@part = "#{ARG_CHAR if arg}#{ARG_CHAR_OPT if arg == :opt}#{part}"
+				freeze
 			end
 
+			## Freeze object
 			def freeze
 				@part.freeze
 				super
 			end
 
+			## Compare with another
+			## @param other [Flame::Path::Part] other path part
+			## @return [true, false] equal or not
 			def ==(other)
 				to_s == other.to_s
 			end
 
 			alias eql? ==
 
+			## Convert path part to String
+			## @return [String] path part as String
 			def to_s
 				@part
 			end
+			alias to_str to_s
 
+			## Is the path part an argument
+			## @return [true, false] an argument or not
 			def arg?
 				@part.start_with? ARG_CHAR
 			end
 
+			## Is the path part an optional argument
+			## @return [true, false] an optional argument or not
 			def opt_arg?
-				@part[1] == ARG_CHAR_OPT
+				arg? && @part[1] == ARG_CHAR_OPT
 			end
 
-			def clean
-				@part.delete ARG_CHAR + ARG_CHAR_OPT
+			# def req_arg?
+			# 	arg? && !opt_arg?
+			# end
+
+			## Path part as a Symbol without arguments characters
+			## @return [Symbol] clean Symbol
+			def to_sym
+				@part.delete(ARG_CHAR + ARG_CHAR_OPT).to_sym
 			end
 		end
 	end