flame 5.0.0.rc4 → 5.0.0.rc7

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

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]

data/lib/flame/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Flame
-	VERSION = '5.0.0.rc4'
+	VERSION = '5.0.0.rc7'
 end

data/lib/flame.rb

@@ -1,8 +1,15 @@
 # frozen_string_literal: true
 
-require 'addressable'
-require 'rack'
+require 'gorilla_patch/inflections'
 
-require_relative 'flame/application'
-require_relative 'flame/controller'
-require_relative 'flame/version'
+## Base module
+module Flame
+	using GorillaPatch::Inflections
+
+	%i[Config Application Controller VERSION]
+		.each do |constant_name|
+			autoload(
+				constant_name, "#{__dir__}/flame/#{constant_name.to_s.underscore}"
+			)
+		end
+end