flame 5.0.0.rc4 → 5.0.0.rc7

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..].to_sym) if part.opt_arg?
+
 			## Required argument
-			param = args[part[1..-1].to_sym]
+			param = args.delete(part[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/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 }
+
+				nested_routes = self.class.new Flame::Path.new(*path.parts[1..])
+				# 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,67 @@ 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..]) ||
+					find_among_arg_keys(path_parts[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|
+					[
+						key.is_a?(Symbol) ? Router::HTTP_METHODS.index(key) : Float::INFINITY,
+						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/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/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