flame 4.18.1 → 5.0.0.rc1

data/lib/flame/render.rb

@@ -13,14 +13,26 @@ require_relative 'errors/template_not_found_error'
 module Flame
 	## Helper for render functionality
 	class Render
+		## Create a new instance from controller, by path and with options
+		## @param controller [Flame::Controller]
+		##   controller for default scope, views directory and cache
+		## @param path [Symbol, String] path (full or the last part) for view search
+		## @param options [Hash] options for template
+		## @option options [Object] :scope (controller)
+		##   scope of visibility in rendering
+		## @option options [Symbol, String, false] :layout ('layout.*')
+		##   name of the layout file
+		## @option options [Hash] :tilt options for Tilt
+		## @option options [Hash] :locals ({}) local variables for rendering
 		def initialize(controller, path, options = {})
 			## Take options for rendering
 			@controller = controller
-			@scope = options.delete(:scope) || @controller
-			@layout = options.delete(:layout)
-			@layout = 'layout.*' if @layout.nil?
+			@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) || {})
+			@locals = options.merge(options.delete(:locals) { {} })
 			## Find filename
 			@filename = find_file(path)
 			unless @filename
@@ -29,15 +41,16 @@ module Flame
 			@layout = nil if File.basename(@filename)[0] == '_'
 		end
 
-		## Render template
+		## Render template with layout
 		## @param cache [Boolean] cache compiles or not
-		def render(cache: true)
+		## @return [String] compiled template
+		def render(cache: true, &block)
 			@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)
+			layout_render tilt.render(@scope, @locals, &block)
 		end
 
 		private
@@ -51,7 +64,7 @@ module Flame
 		def compile_file(filename = @filename)
 			cached = @controller.cached_tilts[filename]
 			return cached if @cache && cached
-			compiled = Tilt.new(filename)
+			compiled = Tilt.new(filename, nil, @tilt_options)
 			@controller.cached_tilts[filename] ||= compiled if @cache
 			compiled
 		end

data/lib/flame/router.rb

@@ -1,66 +1,58 @@
 # frozen_string_literal: true
 
+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'
 
 module Flame
 	## Router class for routing
 	class Router
-		attr_reader :app, :routes
+		attr_reader :app, :routes, :reverse_routes
 
+		## @param app [Flame::Application] host application
 		def initialize(app)
 			@app = app
-			@routes = []
-		end
-
-		## Add the controller with it's methods to routes
-		## @param ctrl [Flame::Controller] class of the controller which will be added
-		## @param path [String, nil] root path for controller's methods
-		## @yield block for routes refine
-		def add_controller(ctrl, path = nil, &block)
-			## @todo Add Regexp paths
-
-			## Add routes from controller to glob array
-			route_refine = RouteRefine.new(self, ctrl, path, block)
-			concat_routes(route_refine)
-		end
-
-		## Find route by any attributes
-		## @param attrs [Hash] attributes for comparing
-		## @return [Flame::Route, nil] return the found route, otherwise `nil`
-		def find_route(attrs)
-			route = routes.find { |r| r.compare_attributes(attrs) }
-			route.dup if route
+			@routes = Flame::Router::Routes.new
+			@reverse_routes = {}
 		end
 
 		## Find the nearest route by path
 		## @param path [Flame::Path] path for route finding
 		## @return [Flame::Route, nil] return the found nearest route or `nil`
 		def find_nearest_route(path)
-			path = Flame::Path.new(path) if path.is_a? String
 			path_parts = path.parts.dup
-			while path_parts.size >= 0
-				route = find_route path: Flame::Path.new(*path_parts)
-				break if route || path_parts.empty?
-				path_parts.pop
+			loop do
+				route = routes.navigate(*path_parts)&.values&.grep(Route)&.first
+				break route if route || path_parts.pop.nil?
 			end
-			route
 		end
 
-		private
-
-		## Add `RouteRefine` routes to the routes of `Flame::Router`
-		## @param route_refine [Flame::Router::RouteRefine] `RouteRefine` with routes
-		def concat_routes(route_refine)
-			routes.concat(route_refine.routes)
+		## Find the path of route
+		## @param route_or_controller [Flame::Router::Route, Flame::Controller]
+		##   route or controller
+		## @param action [Symbol, nil] action (or not for route)
+		## @return [Flame::Path] mounted path to action of controller
+		def path_of(route_or_controller, action = nil)
+			if route_or_controller.is_a?(Flame::Router::Route)
+				route = route_or_controller
+				controller = route.controller
+				action = route.action
+			else
+				controller = route_or_controller
+			end
+			reverse_routes.dig(controller.to_s, action)
 		end
 
 		## Helper class for controller routing refine
-		class RouteRefine
-			attr_accessor :rest_routes
-			attr_reader :ctrl, :routes
+		class RoutesRefine
+			attr_reader :routes, :reverse_routes
 
 			## Defaults REST routes (methods, pathes, controllers actions)
-			def rest_routes
+			def self.rest_routes
 				@rest_routes ||= [
 					{ method: :GET,     path: '/',  action: :index  },
 					{ method: :POST,    path: '/',  action: :create },
@@ -70,15 +62,33 @@ module Flame
 				]
 			end
 
-			def initialize(router, ctrl, path, block)
+			def initialize(router, namespace_name, controller_name, path, &block)
 				@router = router
-				@ctrl = ctrl
-				@path = path || @ctrl.default_path
-				@routes = []
+				@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
 
-			%i[GET POST PUT PATCH DELETE].each do |request_method|
+			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
+
+			%i[GET POST PUT PATCH DELETE].each do |http_method|
 				## Define refine methods for all HTTP methods
 				## @overload post(path, action)
 				##   Execute action on requested path and HTTP method
@@ -91,19 +101,24 @@ module Flame
 				##   @param action [Symbol] name of method for the request
 				##   @example Set method to :POST for action `goodbye`
 				##     post :goodbye
-				method = request_method.downcase
-				define_method(method) do |path, action = nil|
+				define_method(http_method.downcase) do |action_path, action = nil|
 					## Swap arguments if action in path variable
 					unless action
-						action = path.to_sym
-						path = nil
+						action = action_path.to_sym
+						action_path = nil
 					end
-					## Init new Route
-					route = Route.new(@ctrl, action, method, @path, path)
-					## Try to find route with the same action
-					index = find_route_index(action: action)
-					## Overwrite route if needed
-					index ? @routes[index] = route : @routes.push(route)
+					## 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
 
@@ -111,42 +126,73 @@ module Flame
 			##   to defaults pathes and HTTP methods
 			def defaults
 				rest
-				@ctrl.actions.each do |action|
-					next if find_route_index(action: action)
+				@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
-				rest_routes.each do |rest_route|
+				self.class.rest_routes.each do |rest_route|
 					action = rest_route[:action]
-					next if !@ctrl.actions.include?(action) ||
-					        find_route_index(action: 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 ctrl [Flame::Controller] class of mounting 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(ctrl, path = nil, &block)
-				path = Flame::Path.merge(@path, path || ctrl.default_path)
-				@router.add_controller(ctrl, path, &block)
+			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
+			# private
 
 			## Execute block of refinings end sorting routes
 			def execute(&block)
 				instance_exec(&block) if block
 				defaults
-				@routes.sort!
 			end
 
-			def find_route_index(attrs)
-				@routes.find_index { |route| route.compare_attributes(attrs) }
+			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

data/lib/flame/router/route.rb

@@ -7,74 +7,27 @@ module Flame
 	class Router
 		## Class for Route in Router.routes
 		class Route
-			attr_reader :method, :controller, :action, :path
+			attr_reader :controller, :action
 
-			def initialize(controller, action, method, ctrl_path, action_path)
+			## Create a new instance
+			## @param controller [Flame::Controller] controller
+			## @param action [Symbol] action
+			def initialize(controller, action)
 				@controller = controller
 				@action = action
-				@method = method.to_sym.upcase
-				## Make path by controller method with parameners
-				action_path = Flame::Path.new(action_path).adapt(controller, action)
-				## Merge action path with controller path
-				@path = Flame::Path.new(ctrl_path, action_path)
-				Validators::RouteArgumentsValidator.new(
-					@controller, action_path, @action
-				).valid?
-				freeze
-			end
-
-			def freeze
-				@path.freeze
-				super
-			end
-
-			## Compare attributes for `Router.find_route`
-			## @param attrs [Hash] Hash of attributes for comparing
-			def compare_attributes(attrs)
-				attrs.each do |name, value|
-					next true if compare_attribute(name, value)
-					break false
-				end
 			end
 
 			## Method for Routes comparison
+			## @param other [Flame::Router::Route] other route
+			## @return [true, false] equal or not
 			def ==(other)
-				%i[controller action method path].reduce(true) do |result, method|
+				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
-
-			## Compare by:
-			## 1. path parts count (more is matter);
-			## 2. args position (father is matter);
-			## 3. HTTP-method (default).
-			def <=>(other)
-				path_result = other.path <=> path
-				return path_result unless path_result.zero?
-				method <=> other.method
-			end
-
-			private
-
-			## Helpers for `compare_attributes`
-			def compare_attribute(name, value)
-				case name
-				when :method
-					compare_method(value)
-				when :path
-					path.match? value
-				else
-					send(name) == value
-				end
-			end
-
-			def compare_method(request_method)
-				request_method = request_method.upcase.to_sym
-				request_method = :GET if request_method == :HEAD
-				method.upcase.to_sym == request_method
-			end
 		end
 	end
 end

data/lib/flame/router/routes.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Flame
+	class Router
+		## Custom Hash for routes
+		class Routes < Hash
+			## @param path_parts [Array<String, Flame::Path, Flame::Path::Part>]
+			##   path parts for nested keys
+			## @example Initialize without keys
+			##   Flame::Router::Routes.new # => {}
+			## @example Initialize with nested keys
+			##   Flame::Router::Routes.new('/foo/bar/baz')
+			##   # => { 'foo' => { 'bar' => { 'baz' => {} } } }
+			def initialize(*path_parts)
+				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 }
+				self[path.parts.first] = nested_routes
+			end
+
+			## Move into Hash by equal key
+			## @param path_part [String, Flame::Path::Part, Symbol] requested key
+			## @return [Flame::Router::Routes, Flame::Router::Route, nil] found value
+			## @example Move by static path part
+			##   routes = Flame::Router::Routes.new('/foo/bar/baz')
+			##   routes['foo'] # => { 'bar' => { 'baz' => {} } }
+			## @example Move by HTTP-method
+			##   routes = Flame::Router::Routes.new('/foo/bar')
+			##   routes['foo']['bar'][:GET] = 42
+			##   routes['foo']['bar'][:GET] # => 42
+			def [](key)
+				if key.is_a? String
+					key = Flame::Path::Part.new(key)
+				elsif !key.is_a?(Flame::Path::Part) && !key.is_a?(Symbol)
+					return
+				end
+				super
+			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
+			## @return [Flame::Router::Routes, Flame::Router::Route, nil] found value
+			## @example Move by static path part and argument
+			##   routes = Flame::Router::Routes.new('/foo/:first/bar')
+			##   routes.navigate('foo', 'value') # => { 'bar' => {} }
+			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])
+			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
+			end
+
+			def allow
+				methods = keys.select { |key| key.is_a? Symbol }
+				return if methods.empty?
+				methods.push(:OPTIONS).join(', ')
+			end
+
+			private
+
+			def first_arg_key
+				keys.find do |key|
+					key.is_a?(Flame::Path::Part) && key.arg?
+				end
+			end
+
+			def first_opt_arg_key
+				keys.find do |key|
+					key.is_a?(Flame::Path::Part) && key.opt_arg?
+				end
+			end
+		end
+	end
+end