flame 5.0.0.rc5 → 5.0.0.rc6

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,11 @@ 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(
+					"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

@@ -13,30 +13,20 @@ 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}'" \
+				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

data/lib/flame/path.rb

@@ -1,12 +1,18 @@
 # 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
@@ -24,8 +30,8 @@ module Flame
 
 		## 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?)
+		memoize def parts
+			@path.to_s.split('/').reject(&:empty?)
 				.map! { |part| self.class::Part.new(part) }
 		end
 
@@ -49,14 +55,10 @@ module Flame
 		## @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
@@ -120,16 +122,32 @@ module Flame
 			## 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)
@@ -148,7 +166,7 @@ module Flame
 
 					break if part.opt_arg? && @other_parts.count <= @other_index
 
-					@args[part.clean.to_sym] = extract
+					@args[part.to_sym] = extract
 					@index += 1
 				end
 
@@ -178,7 +196,7 @@ module Flame
 		class Part
 			extend Forwardable
 
-			def_delegators :@part, :[], :hash, :empty?, :b
+			def_delegators :to_s, :[], :hash, :size, :empty?, :b, :inspect
 
 			ARG_CHAR = ':'
 			ARG_CHAR_OPT = '?'
@@ -229,10 +247,10 @@ module Flame
 			# 	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
+			## 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

data/lib/flame/render.rb

@@ -29,15 +29,17 @@ module Flame
 			@controller = controller
 			@scope = options.delete(:scope) { @controller }
 			@layout = options.delete(:layout) { 'layout.*' }
+
 			## Options for Tilt Template
 			@tilt_options = options.delete(:tilt)
+
 			## And get the rest variables to locals
 			@locals = options.merge(options.delete(:locals) { {} })
+
 			## Find filename
 			@filename = find_file(path)
-			unless @filename
-				raise Flame::Errors::TemplateNotFoundError.new(controller, path)
-			end
+			raise Flame::Errors::TemplateNotFoundError.new(controller, path) unless @filename
+
 			@layout = nil if File.basename(@filename)[0] == '_'
 		end
 
@@ -48,6 +50,7 @@ module Flame
 			@cache = cache
 			## Compile Tilt to instance hash
 			return unless @filename
+
 			tilt = compile_file
 			## Render Tilt from instance hash with new options
 			layout_render tilt.render(@scope, @locals, &block)
@@ -64,6 +67,7 @@ module Flame
 		def compile_file(filename = @filename)
 			cached = @controller.cached_tilts[filename]
 			return cached if @cache && cached
+
 			compiled = Tilt.new(filename, nil, @tilt_options)
 			@controller.cached_tilts[filename] ||= compiled if @cache
 			compiled
@@ -111,11 +115,13 @@ module Flame
 
 		using GorillaPatch::Inflections
 
+		CONTROLLER_SUFFIXES = %w[_controller _ctrl].freeze
+		private_constant :CONTROLLER_SUFFIXES
+
 		## Find possible directories for the controller
 		def controller_dirs
 			parts = @controller.class.underscore.split('/').map do |part|
-				%w[_controller _ctrl]
-					.find { |suffix| part.chomp! suffix }
+				CONTROLLER_SUFFIXES.find { |suffix| part.chomp! suffix }
 				part
 				## Alternative, but slower by ~50%:
 				# part.sub(/_(controller|ctrl)$/, '')
@@ -151,8 +157,10 @@ module Flame
 		## @param result [String] result of template rendering
 		def layout_render(content)
 			return content unless @layout
+
 			layout_files = find_layouts(@layout)
 			return content if layout_files.empty?
+
 			layout_files.each_with_object(content.dup) do |layout_file, result|
 				layout = compile_file(layout_file)
 				result.replace layout.render(@scope, @locals) { result }

data/lib/flame/router.rb

@@ -3,16 +3,19 @@
 require 'gorilla_patch/deep_merge'
 require 'gorilla_patch/inflections'
 require 'gorilla_patch/namespace'
-require 'gorilla_patch/transform'
 
-require_relative 'router/routes'
-require_relative 'router/route'
+require_relative 'router/controller_finder'
+require_relative 'errors/controller_not_found_error'
 
 module Flame
 	## Router class for routing
 	class Router
 		HTTP_METHODS = %i[GET POST PUT PATCH DELETE].freeze
 
+		require_relative 'router/route'
+		require_relative 'router/routes'
+		require_relative 'router/routes_refine'
+
 		extend Forwardable
 		def_delegators :routes, :navigate
 
@@ -40,7 +43,7 @@ module Flame
 		def find_nearest_route(path)
 			path_parts = path.parts.dup
 			loop do
-				route = routes.navigate(*path_parts)&.values&.grep(Route)&.first
+				route = routes.navigate(*path_parts)&.first_route
 				break route if route || path_parts.pop.nil?
 			end
 		end
@@ -60,158 +63,5 @@ module Flame
 			end
 			reverse_routes.dig(controller.to_s, action)
 		end
-
-		## Helper class for controller routing refine
-		class RoutesRefine
-			attr_reader :routes, :reverse_routes
-
-			## Defaults REST routes (methods, pathes, controllers actions)
-			def self.rest_routes
-				@rest_routes ||= [
-					{ method: :GET,     path: '/',  action: :index  },
-					{ method: :POST,    path: '/',  action: :create },
-					{ method: :GET,     path: '/',  action: :show   },
-					{ method: :PUT,     path: '/',  action: :update },
-					{ method: :DELETE,  path: '/',  action: :delete }
-				]
-			end
-
-			def initialize(router, namespace_name, controller_name, path, &block)
-				@router = router
-				@controller = constantize_controller namespace_name, controller_name
-				@path = Flame::Path.new(path || @controller.default_path)
-				@routes, @endpoint = @path.to_routes_with_endpoint
-				@reverse_routes = {}
-				execute(&block)
-			end
-
-			private
-
-			using GorillaPatch::Inflections
-
-			def constantize_controller(namespace_name, controller_name)
-				controller_name = controller_name.to_s.camelize
-				namespace =
-					namespace_name.empty? ? Object : Object.const_get(namespace_name)
-				if namespace.const_defined?(controller_name)
-					controller = namespace.const_get(controller_name)
-					return controller if controller < Flame::Controller
-					controller::IndexController
-				else
-					namespace.const_get("#{controller_name}Controller")
-				end
-			end
-
-			HTTP_METHODS.each do |http_method|
-				## Define refine methods for all HTTP methods
-				## @overload post(path, action)
-				##   Execute action on requested path and HTTP method
-				##   @param path [String] path of method for the request
-				##   @param action [Symbol] name of method for the request
-				##   @example Set path to '/bye' and method to :POST for action `goodbye`
-				##     post '/bye', :goodbye
-				## @overload post(action)
-				##   Execute action on requested HTTP method
-				##   @param action [Symbol] name of method for the request
-				##   @example Set method to :POST for action `goodbye`
-				##     post :goodbye
-				define_method(http_method.downcase) do |action_path, action = nil|
-					## Swap arguments if action in path variable
-					unless action
-						action = action_path.to_sym
-						action_path = nil
-					end
-					## Initialize new route
-					route = Route.new(@controller, action)
-					## Make path by controller method with parameners
-					action_path = Flame::Path.new(action_path).adapt(@controller, action)
-					## Validate action path
-					validate_action_path(action, action_path)
-					## Merge action path with controller path
-					path = Flame::Path.new(@path, action_path)
-					## Remove the same route if needed
-					remove_old_routes(action, route)
-					## Add new route
-					add_new_route(route, action, path, http_method)
-				end
-			end
-
-			## Assign remaining methods of the controller
-			##   to defaults pathes and HTTP methods
-			def defaults
-				rest
-				@controller.actions.each do |action|
-					next if find_reverse_route(action)
-					send(:GET.downcase, action)
-				end
-			end
-
-			## Assign methods of the controller to REST architecture
-			def rest
-				self.class.rest_routes.each do |rest_route|
-					action = rest_route[:action]
-					next if !@controller.actions.include?(action) ||
-					        find_reverse_route(action)
-					send(*rest_route.values.map(&:downcase))
-				end
-			end
-
-			using GorillaPatch::Namespace
-			using GorillaPatch::Transform
-			using GorillaPatch::DeepMerge
-
-			## Mount controller inside other (parent) controller
-			## @param controller [Flame::Controller] class of mounting controller
-			## @param path [String, nil] root path for mounting controller
-			## @yield Block of code for routes refine
-			def mount(controller_name, path = nil, &block)
-				routes_refine = self.class.new(
-					@router, @controller.deconstantize, controller_name, path, &block
-				)
-
-				@endpoint.deep_merge! routes_refine.routes
-
-				@reverse_routes.merge!(
-					routes_refine.reverse_routes.transform_values do |hash|
-						hash.transform_values { |action_path| @path + action_path }
-					end
-				)
-			end
-
-			# private
-
-			## Execute block of refinings end sorting routes
-			def execute(&block)
-				@controller.refined_http_methods
-					.each do |http_method, action_path, action|
-						send(http_method, action_path, action)
-					end
-				instance_exec(&block) if block
-				defaults
-			end
-
-			def find_reverse_route(action)
-				@reverse_routes.dig(@controller.to_s, action)
-			end
-
-			def validate_action_path(action, action_path)
-				Validators::RouteArgumentsValidator.new(
-					@controller, action_path, action
-				).valid?
-			end
-
-			def remove_old_routes(action, new_route)
-				return unless (old_path = @reverse_routes[@controller.to_s]&.delete(action))
-				@routes.dig(*old_path.parts)
-					.delete_if { |_method, old_route| old_route == new_route }
-			end
-
-			def add_new_route(route, action, path, http_method)
-				path_routes, endpoint = path.to_routes_with_endpoint
-				endpoint[http_method] = route
-				@routes.deep_merge!(path_routes)
-				(@reverse_routes[@controller.to_s] ||= {})[action] = path
-			end
-		end
 	end
 end