flame 4.18.1 → 5.0.0.rc6

data/lib/flame/render.rb

@@ -6,38 +6,54 @@ require 'tilt'
 require 'tilt/plain'
 require 'tilt/erb'
 
-require 'gorilla-patch/inflections'
+require 'gorilla_patch/inflections'
 
 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
-				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
 
-		## 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 +67,8 @@ 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
@@ -76,7 +93,17 @@ module Flame
 
 		## Find template-file by path
 		def find_file(path)
-			find_files(path, controller_dirs).find { |file| Tilt[file] }
+			caller_path = caller_locations(4..4).first.path
+
+			caller_dir =
+				begin
+					File.dirname(caller_path).sub(views_dir, '') if Tilt[caller_path]
+				rescue LoadError
+					nil
+				end
+
+			find_files(path, controller_dirs | Array(caller_dir))
+				.find { |file| Tilt[file] }
 		end
 
 		## Find layout-files by path
@@ -88,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)$/, '')
@@ -128,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

@@ -1,153 +1,67 @@
 # frozen_string_literal: true
 
-require_relative 'router/route'
+require 'gorilla_patch/deep_merge'
+require 'gorilla_patch/inflections'
+require 'gorilla_patch/namespace'
+
+require_relative 'router/controller_finder'
+require_relative 'errors/controller_not_found_error'
 
 module Flame
 	## Router class for routing
 	class Router
-		attr_reader :app, :routes
+		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
+
+		attr_reader :app, :routes, :reverse_routes
 
+		## @param app [Flame::Application] host application
 		def initialize(app)
 			@app = app
-			@routes = []
+			@routes = Flame::Router::Routes.new
+			@reverse_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
+		using GorillaPatch::DeepMerge
 
-			## 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
+		## Add RoutesRefine to Router
+		## @param routes_refine [Flame::Router::RoutesRefine] refined routes
+		def add(routes_refine)
+			routes.deep_merge! routes_refine.routes
+			reverse_routes.merge! routes_refine.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)&.first_route
+				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)
-		end
-
-		## Helper class for controller routing refine
-		class RouteRefine
-			attr_accessor :rest_routes
-			attr_reader :ctrl, :routes
-
-			## Defaults REST routes (methods, pathes, controllers actions)
-			def 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, ctrl, path, block)
-				@router = router
-				@ctrl = ctrl
-				@path = path || @ctrl.default_path
-				@routes = []
-				execute(&block)
-			end
-
-			%i[GET POST PUT PATCH DELETE].each do |request_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
-				method = request_method.downcase
-				define_method(method) do |path, action = nil|
-					## Swap arguments if action in path variable
-					unless action
-						action = path.to_sym
-						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)
-				end
-			end
-
-			## Assign remaining methods of the controller
-			##   to defaults pathes and HTTP methods
-			def defaults
-				rest
-				@ctrl.actions.each do |action|
-					next if find_route_index(action: action)
-					send(:GET.downcase, action)
-				end
-			end
-
-			## Assign methods of the controller to REST architecture
-			def rest
-				rest_routes.each do |rest_route|
-					action = rest_route[:action]
-					next if !@ctrl.actions.include?(action) ||
-					        find_route_index(action: action)
-					send(*rest_route.values.map(&:downcase))
-				end
-			end
-
-			## Mount controller inside other (parent) controller
-			## @param ctrl [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)
-			end
-
-			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) }
+		## 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
 	end
 end

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,73 +7,35 @@ module Flame
 	class Router
 		## Class for Route in Router.routes
 		class Route
-			attr_reader :method, :controller, :action, :path
+			extend Forwardable
 
-			def initialize(controller, action, method, ctrl_path, action_path)
-				@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_delegators :to_s, :inspect
 
-			def freeze
-				@path.freeze
-				super
-			end
+			attr_reader :controller, :action
 
-			## 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
+			## Create a new instance
+			## @param controller [Flame::Controller] controller
+			## @param action [Symbol] action
+			def initialize(controller, action)
+				@controller = controller
+				@action = action
 			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
+			def to_s
+				"#{controller}##{action}"
 			end
 		end
 	end