flame 5.0.0.rc5 → 5.0.0.rc6

data/lib/flame/router/controller_finder.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Flame
+	## Comment due to `private_constant`
+	class Router
+		## Class for controller constant finding in namespace by names
+		class ControllerFinder
+			attr_reader :controller
+
+			def initialize(namespace_name, controller_or_name)
+				@namespace =
+					namespace_name.empty? ? Object : Object.const_get(namespace_name)
+
+				if controller_or_name.is_a?(Class)
+					@controller = controller_or_name
+					@controller_name = controller_or_name.name
+				else
+					@controller_name = controller_or_name
+					@controller = find
+				end
+			end
+
+			private
+
+			def find
+				found_controller_name = controller_name_variations.find do |variation|
+					@namespace.const_defined?(variation) unless variation.empty?
+				end
+
+				raise_controller_not_found_error unless found_controller_name
+
+				controller = @namespace.const_get(found_controller_name)
+				return controller if controller < Flame::Controller
+
+				controller::IndexController
+			end
+
+			using GorillaPatch::Inflections
+
+			TRASNFORMATION_METHODS = %i[camelize upcase].freeze
+
+			def controller_name_variations
+				TRASNFORMATION_METHODS.each_with_object([]) do |method, result|
+					transformed = @controller_name.to_s.send(method)
+					result.push transformed, "#{transformed}Controller"
+				end
+			end
+
+			def raise_controller_not_found_error
+				raise Errors::ControllerNotFoundError.new(@controller_name, @namespace)
+			end
+		end
+
+		private_constant :ControllerFinder
+	end
+end

data/lib/flame/router/route.rb

@@ -7,6 +7,10 @@ module Flame
 	class Router
 		## Class for Route in Router.routes
 		class Route
+			extend Forwardable
+
+			def_delegators :to_s, :inspect
+
 			attr_reader :controller, :action
 
 			## Create a new instance
@@ -22,12 +26,17 @@ module Flame
 			## @return [true, false] equal or not
 			def ==(other)
 				return false unless other.is_a? self.class
+
 				%i[controller action].reduce(true) do |result, method|
 					result && (
 						public_send(method) == other.public_send(method)
 					)
 				end
 			end
+
+			def to_s
+				"#{controller}##{action}"
+			end
 		end
 	end
 end

data/lib/flame/router/routes.rb

@@ -12,10 +12,15 @@ module Flame
 			##   Flame::Router::Routes.new('/foo/bar/baz')
 			##   # => { 'foo' => { 'bar' => { 'baz' => {} } } }
 			def initialize(*path_parts)
+				super()
+
 				path = Flame::Path.new(*path_parts)
 				return if path.parts.empty?
+
 				nested_routes = self.class.new Flame::Path.new(*path.parts[1..-1])
-				# path.parts.reduce(result) { |hash, part| hash[part] ||= self.class.new }
+				# path.parts.reduce(result) do |hash, part|
+				# 	hash[part] ||= self.class.new
+				# end
 				self[path.parts.first] = nested_routes
 			end
 
@@ -38,6 +43,12 @@ module Flame
 				super
 			end
 
+			## Return the first available route (at the first level).
+			## @return [Flame::Router::Route] the first route
+			def first_route
+				values.find { |value| value.is_a?(Route) }
+			end
+
 			## Navigate to Routes or Route through static parts or arguments
 			## @param path_parts [Array<String, Flame::Path, Flame::Path::Part>]
 			##   path or path parts as keys for navigating
@@ -48,31 +59,70 @@ module Flame
 			def navigate(*path_parts)
 				path_parts = Flame::Path.new(*path_parts).parts
 				return dig_through_opt_args if path_parts.empty?
+
 				endpoint =
-					self[path_parts.first] ||
-					dig(first_opt_arg_key, path_parts.first) ||
-					self[first_arg_key]
-				endpoint&.navigate(*path_parts[1..-1])
+					self[path_parts.first] || dig(first_opt_arg_key, path_parts.first)
+
+				endpoint&.navigate(*path_parts[1..-1]) ||
+					find_among_arg_keys(path_parts[1..-1])
 			end
 
 			## Dig through optional arguments as keys
 			## @return [Flame::Router::Routes] return most nested end-point
 			##   without optional arguments
 			def dig_through_opt_args
-				self[first_opt_arg_key]&.dig_through_opt_args || self
+				[
+					self[first_opt_arg_key]&.dig_through_opt_args,
+					self
+				]
+					.compact.find(&:first_route)
 			end
 
 			def allow
 				methods = keys.select { |key| key.is_a? Symbol }
 				return if methods.empty?
+
 				methods.push(:OPTIONS).join(', ')
 			end
 
+			PADDING_SIZE = Router::HTTP_METHODS.map(&:size).max
+			PADDING_FORMAT = "%#{PADDING_SIZE}.#{PADDING_SIZE}s"
+
+			## Output routes in human readable format
+			def to_s(prefix = '/')
+				sort.map do |key, value|
+					if key.is_a?(Symbol)
+						<<~OUTPUT
+							\e[1m#{format PADDING_FORMAT, key} #{prefix}\e[22m
+							#{' ' * PADDING_SIZE} \e[3m\e[36m#{value}\e[0m\e[23m
+						OUTPUT
+					else
+						value.to_s(Flame::Path.new(prefix, key))
+					end
+				end.join
+			end
+
+			## Sort routes for human readability
+			def sort
+				sort_by do |key, _value|
+					[
+						if key.is_a?(Symbol)
+						then Router::HTTP_METHODS.index(key)
+						else Float::INFINITY
+						end,
+						key.to_s
+					]
+				end
+			end
+
 			private
 
-			def first_arg_key
+			def find_among_arg_keys(path_parts)
 				keys.find do |key|
-					key.is_a?(Flame::Path::Part) && key.arg?
+					next unless key.is_a?(Flame::Path::Part) && key.arg?
+
+					result = self[key].navigate(*path_parts)
+					break result if result
 				end
 			end
 

data/lib/flame/router/routes_refine.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require_relative 'routes_refine/mounting'
+
+module Flame
+	class Router
+		## Helper class for controller routing refine
+		class RoutesRefine
+			attr_reader :routes, :reverse_routes
+
+			class << self
+				include Memery
+
+				## Defaults REST routes (methods, pathes, controllers actions)
+				def 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
+			end
+
+			using GorillaPatch::Namespace
+
+			def initialize(
+				namespace_name, controller_or_name, path, nested: true, &block
+			)
+				@controller =
+					ControllerFinder.new(namespace_name, controller_or_name).controller
+				@namespace_name = @controller.deconstantize
+				@path = Flame::Path.new(path || @controller.path)
+				@controller.path_arguments = @path.parts.select(&:arg?).map(&:to_sym)
+				@routes, @endpoint = @path.to_routes_with_endpoint
+				@reverse_routes = {}
+				@mount_nested = nested
+				execute(&block)
+			end
+
+			private
+
+			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|
+					get action unless find_reverse_route(action)
+				end
+
+				mount_nested_controllers if @mount_nested && (
+					@controller.demodulize == 'IndexController' &&
+					!@namespace_name.empty?
+				)
+			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
+
+			include Mounting
+
+			## Execute block of refinings end sorting routes
+			def execute(&block)
+				@controller.refined_http_methods
+					.each do |action, (http_method, action_path)|
+						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)
+				old_path = @reverse_routes[@controller.to_s]&.delete(action)
+				return unless old_path
+
+				@routes.dig(*old_path.parts)
+					.delete_if { |_method, old_route| old_route == new_route }
+			end
+
+			using GorillaPatch::DeepMerge
+
+			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

data/lib/flame/router/routes_refine/mounting.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Flame
+	class Router
+		class RoutesRefine
+			## Module for mounting in RoutesRefine
+			module Mounting
+				private
+
+				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(
+						@namespace_name, 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
+
+				using GorillaPatch::Namespace
+
+				def mount_nested_controllers
+					namespace = Object.const_get(@namespace_name)
+
+					namespace.constants.each do |constant_name|
+						constant = namespace.const_get(constant_name)
+						if constant < Flame::Controller || constant.instance_of?(Module)
+							mount_nested_controller constant
+						end
+					end
+				end
+
+				def mount_nested_controller(nested_controller)
+					mount nested_controller if should_be_mounted? nested_controller
+				end
+
+				def should_be_mounted?(controller)
+					if controller.instance_of?(Module)
+						controller.const_defined?(:IndexController, false)
+					else
+						controller.actions.any? && !@reverse_routes.key?(controller.to_s)
+					end
+				end
+			end
+		end
+	end
+end

data/lib/flame/validators.rb

@@ -7,6 +7,8 @@ module Flame
 	module Validators
 		## Compare arguments from path and from controller's action
 		class RouteArgumentsValidator
+			include Memery
+
 			## Create a new instance of validator
 			## @param ctrl [Flame::Controller] controller of route
 			## @param path [Flame::Path, String] path of route
@@ -29,6 +31,7 @@ module Flame
 				extra_arguments = first_extra_arguments
 				## Raise error if extra arguments
 				return true unless extra_arguments
+
 				raise Errors::RouteExtraArgumentsError.new(
 					@ctrl, @action, @path, extra_arguments
 				)
@@ -37,27 +40,28 @@ module Flame
 			def order_valid?
 				wrong_ordered_arguments = first_wrong_ordered_arguments
 				return true unless wrong_ordered_arguments
+
 				raise Errors::RouteArgumentsOrderError.new(
 					@path, wrong_ordered_arguments
 				)
 			end
 
 			## Split path to args array
-			def path_arguments
-				@path_arguments ||= @path.parts
-					.each_with_object(req: [], opt: []) do |part, hash|
-						## Take only argument parts
-						next unless part.arg?
-						## Memorize arguments
-						hash[part.opt_arg? ? :opt : :req] << part.clean.to_sym
-					end
+			memoize def path_arguments
+				@path.parts.each_with_object(req: [], opt: []) do |part, hash|
+					## Take only argument parts
+					next unless part.arg?
+
+					## Memorize arguments
+					hash[part.opt_arg? ? :opt : :req] << part.to_sym
+				end
 			end
 
 			## Take args from controller's action
-			def action_arguments
+			memoize def action_arguments
 				## Get all parameters (arguments) from method
 				## Than collect and sort parameters into hash
-				@action_arguments ||= @ctrl.instance_method(@action).parameters
+				@ctrl.instance_method(@action).parameters
 					.each_with_object(req: [], opt: []) do |param, hash|
 						## Only required parameters must be in `:req`
 						hash[param[0]] << param[1]