flame 4.18.1 → 5.0.0.rc1

data/lib/flame/dispatcher.rb

@@ -4,9 +4,10 @@ require 'gorilla-patch/symbolize'
 
 require_relative 'dispatcher/request'
 require_relative 'dispatcher/response'
-
 require_relative 'dispatcher/cookies'
+
 require_relative 'dispatcher/static'
+require_relative 'dispatcher/routes'
 
 require_relative 'errors/route_not_found_error'
 
@@ -15,15 +16,19 @@ module Flame
 	class Dispatcher
 		GEM_STATIC_FILES = File.join __dir__, '..', '..', 'public'
 
+		extend Forwardable
+		def_delegators :@app_class, :path_to
+
 		attr_reader :request, :response
 
 		include Flame::Dispatcher::Static
+		include Flame::Dispatcher::Routes
 
 		## Initialize Dispatcher from Application#call
-		## @param app [Flame::Application] application object
+		## @param app_class [Class] application class
 		## @param env Rack-environment object
-		def initialize(app, env)
-			@app = app
+		def initialize(app_class, env)
+			@app_class = app_class
 			@env = env
 			@request = Flame::Dispatcher::Request.new(env)
 			@response = Flame::Dispatcher::Response.new
@@ -32,7 +37,8 @@ module Flame
 		## Start of execution the request
 		def run!
 			catch :halt do
-				try_static ||
+				try_options ||
+					try_static ||
 					try_static(dir: GEM_STATIC_FILES) ||
 					try_route ||
 					halt(404)
@@ -80,28 +86,14 @@ module Flame
 
 		## Application-config object as Hash
 		def config
-			@app.config
+			@app_class.config
 		end
 
-		## Build a path to the given controller and action, with any expected params
-		##
-		## @param ctrl [Flame::Controller] class of controller
-		## @param action [Symbol] method of controller
-		## @param args [Hash] parameters for method of controller
-		## @return [String] path for requested method, controller and parameters
-		## @example Path for `show(id)` method of `ArticlesController` with `id: 2`
-		##   path_to ArticlesController, :show, id: 2 # => "/articles/show/2"
-		## @example Path for `new` method of `ArticlesController` with params
-		##   path_to ArticlesController, :new, params: { author_id: 1 }
-		##   # => "/articles/new?author_id=1"
-		def path_to(ctrl, action = :index, args = {})
-			route = @app.class.router.find_route(controller: ctrl, action: action)
-			raise Errors::RouteNotFoundError.new(ctrl, action) unless route
-			query = Rack::Utils.build_nested_query args.delete(:params)
-			query = nil if query&.empty?
-			path = route.path.assign_arguments(args)
-			path = '/' if path.empty?
-			URI::Generic.build(path: path, query: query).to_s
+		## Available routes endpoint
+		def available_endpoint
+			return @available_endpoint if defined? @available_endpoint
+			@available_endpoint =
+				@app_class.router.routes.navigate(*request.path.parts)
 		end
 
 		## Interrupt the execution of route, and set new optional data
@@ -117,7 +109,7 @@ module Flame
 		## @example Halt with 404, render template
 		##   halt 404, render('errors/404')
 		## @example Halt with 200, set new headers
-		##   halt 200, 'Cats!', 'Content-Type' => 'animal/cat'
+		##   halt 200, 'Cats!', 'Content-Type' # => 'animal/cat'
 		def halt(new_status = nil, new_body = nil, new_headers = {})
 			status new_status if new_status
 			body new_body || (default_body_of_nearest_route if body.empty?)
@@ -144,50 +136,17 @@ module Flame
 
 		## All cached tilts (views) for application by Flame::Render
 		def cached_tilts
-			@app.class.cached_tilts
+			@app_class.cached_tilts
 		end
 
 		private
 
-		## Find route and try execute it
-		def try_route
-			route = @app.class.router.find_route(
-				method: request.http_method,
-				path: request.path
-			)
-			return nil unless route
-			status 200
-			execute_route(route)
-		end
-
-		## Execute route
-		## @param route [Flame::Route] route that must be executed
-		def execute_route(route, action = route.action)
-			params.merge! route.path.extract_arguments(request.path)
-			# route.execute(self)
-			controller = route.controller.new(self)
-			controller.send(:execute, action)
-		rescue => exception
-			# p 'rescue from dispatcher'
-			dump_error(exception)
-			status 500
-			controller&.send(:server_error, exception)
-			# p 're raise exception from dispatcher'
-			# raise exception
-		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 = @app.router.find_nearest_route(request.path)
-			## Return nil if the route not found
-			##   or it's `default_body` method not defined
-			return default_body unless route
-			## Execute `default_body` method for the founded route
-			execute_route(route, :default_body)
-			default_body if body.empty?
+		## 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
 		end
 	end
 end

data/lib/flame/dispatcher/cookies.rb

@@ -4,6 +4,10 @@ module Flame
 	class Dispatcher
 		## Helper class for cookies
 		class Cookies
+			## Create an instance of Cookies
+			## @param request_cookies [Hash{String=>Object}] cookies from request
+			## @param response [Flame::Dispatcher::Response, Rack::Response]
+			##   response object for cookies setting
 			def initialize(request_cookies, response)
 				@request_cookies = request_cookies
 				@response = response
@@ -11,6 +15,7 @@ module Flame
 
 			## Get request cookies
 			## @param key [String, Symbol] name of cookie
+			## @return [Object] value of cookie
 			def [](key)
 				@request_cookies[key.to_s]
 			end
@@ -23,8 +28,11 @@ module Flame
 			## @example Delete `cat` cookie
 			##   cookies['cat'] = nil
 			def []=(key, new_value)
-				return @response.delete_cookie(key.to_s, path: '/') if new_value.nil?
-				@response.set_cookie(key.to_s, value: new_value, path: '/')
+				if new_value.nil?
+					@response.delete_cookie(key.to_s, path: '/')
+				else
+					@response.set_cookie(key.to_s, value: new_value, path: '/')
+				end
 			end
 		end
 	end

data/lib/flame/dispatcher/routes.rb

@@ -0,0 +1,53 @@
+# 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!(
+					@app_class.router.path_of(route).extract_arguments(request.path)
+				)
+				# route.execute(self)
+				controller = route.controller.new(self)
+				controller.send(:execute, action)
+			rescue StandardError => exception
+				# p 'rescue from dispatcher'
+				dump_error(exception)
+				status 500
+				controller&.send(:server_error, exception)
+				# p 're raise exception from dispatcher'
+				# raise exception
+			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 = @app_class.router.find_nearest_route(request.path)
+				## Return standard `default_body` if the route not found
+				return default_body unless route
+				## Execute `default_body` method for the founded route
+				body route.controller.new(self).send(:default_body)
+			end
+		end
+	end
+end

data/lib/flame/dispatcher/static.rb

@@ -4,6 +4,11 @@ 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
@@ -18,9 +23,9 @@ module Flame
 			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
@@ -29,27 +34,27 @@ module Flame
 			class StaticFile
 				def initialize(filename, dir)
 					@filename = filename.to_s
-					@path = File.join dir, URI.decode(@filename)
+					@file_path = File.join dir, URI.decode_www_form_component(@filename)
 				end
 
 				def exist?
-					File.exist?(@path) && File.file?(@path)
+					File.exist?(@file_path) && File.file?(@file_path)
 				end
 
 				def mtime
-					File.mtime(@path)
+					File.mtime(@file_path)
 				end
 
 				def extname
-					File.extname(@path)
+					File.extname(@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)
@@ -57,6 +62,8 @@ module Flame
 					with_version ? "#{path}?v=#{mtime.to_i}" : path
 				end
 			end
+
+			private_constant :StaticFile
 		end
 	end
 end

data/lib/flame/errors/argument_not_assigned_error.rb

@@ -4,11 +4,17 @@ 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
 
+			## Calculated message of the error
+			## @return [String] message of the error
 			def message
 				"Argument '#{@argument}' for path '#{@path}' is not assigned"
 			end

data/lib/flame/errors/route_arguments_order_error.rb

@@ -4,11 +4,17 @@ 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
 
+			## Calculated message of the error
+			## @return [String] message of the error
 			def message
 				"Path '#{@path}' should have" \
 					" '#{@wrong_ordered_arguments.first}' argument before" \

data/lib/flame/errors/route_extra_arguments_error.rb

@@ -4,6 +4,14 @@ 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
@@ -15,6 +23,8 @@ module Flame
 				}[@extra[:type]]
 			end
 
+			## Calculated message of the error
+			## @return [String] message of the error
 			def message
 				case @extra[:place]
 				when :ctrl

data/lib/flame/errors/route_not_found_error.rb

@@ -4,13 +4,19 @@ module Flame
 	module Errors
 		## Error for Flame::Dispatcher.path_to
 		class RouteNotFoundError < StandardError
-			def initialize(ctrl, method)
-				@ctrl = ctrl
-				@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)
+				@controller = controller
+				@action = action
 			end
 
+			## Calculated message of the error
+			## @return [String] message of the error
 			def message
-				"Route with controller '#{@ctrl}' and method '#{@method}'" \
+				"Route with controller '#{@controller}' and action '#{@action}'" \
 					' not found in application routes'
 			end
 		end

data/lib/flame/errors/template_not_found_error.rb

@@ -4,12 +4,18 @@ 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
 
+			## Calculated message of the error
+			## @return [String] message of the error
 			def message
 				"Template '#{@path}' not found for '#{@controller}'"
 			end

data/lib/flame/path.rb

@@ -7,20 +7,29 @@ require_relative 'errors/argument_not_assigned_error'
 module Flame
 	## Class for working with paths
 	class Path
+		## 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
 
+		## Return parts of path, splitted by slash (`/`)
+		## @return [Array<Flame::Path::Part>] array of path parts
 		def parts
 			@parts ||= @path.to_s.split('/').reject(&:empty?)
-				.map! { |part| PathPart.new(part) }
+				.map! { |part| self.class::Part.new(part) }
 		end
 
+		## Freeze all strings in object
 		def freeze
 			@path.freeze
 			parts.each(&:freeze)
@@ -28,7 +37,16 @@ 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
@@ -41,36 +59,32 @@ module Flame
 				end
 		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
@@ -78,39 +92,35 @@ module Flame
 				break args if part.opt_arg? && other_part.empty?
 				args[
 					part[(part.opt_arg? ? 2 : 1)..-1].to_sym
-				] = URI.decode(other_part)
+				] = URI.decode_www_form_component(other_part)
 			end
 		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 = {})
@@ -128,7 +138,7 @@ module Flame
 		end
 
 		## Class for one part of Path
-		class PathPart
+		class Part
 			extend Forwardable
 
 			def_delegators :@part, :[], :hash
@@ -136,33 +146,53 @@ module Flame
 			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
 
+			## 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 req_arg?
+			# 	arg? && !opt_arg?
+			# end
+
+			## Path part as a String without arguments characters
+			## @return [String] clean String
 			def clean
 				@part.delete ARG_CHAR + ARG_CHAR_OPT
 			end