flame 3.6.2 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d36bd7e8c5db7454423ff5a080c407aad30dd67e
-  data.tar.gz: 604cd066e8145524a01d323f4c3e021445413722
+  metadata.gz: 3b164f4b1817723648efb5412dc308265aaa30af
+  data.tar.gz: dc130470827a1bb8f1c22689c605381aa97ee78d
 SHA512:
-  metadata.gz: 4a6a22af1494cf9092ba01005e959579c93d900b6ce76d7bfb81dace1515649bf0f8b9d7bbd32b09f550120edbafeb789e71ec3a410b24aa7a9893d0692f5534
-  data.tar.gz: 941cc3b8d7891810c44b7998592c7263ce4cf3325d654b9041e335474b2bf094446589d5abf104d304e2a3b5b758c4838b36c53822ff5ba2518f9cd211c64976
+  metadata.gz: 2a482215bfd58d3ca783ac1c904f171d5e09f5a2cd42245b6324bf433ffb8611827602e551099076939969fe07b23ae0defb1be6a1c68d18708a270b4b97e3f4
+  data.tar.gz: 5afe0a7dcd19b8ee8eb9d674211f456ea0232932fd40bc0e24f86837dce011d81216c9ecaba9ab84bd4f5cc263a1c813efd1be6a28ceba7febb60dda3ce3341e

data/lib/flame/application.rb

@@ -13,6 +13,7 @@ module Flame
 			self.class.config
 		end
 
+		## Generating application config when inherited
 		def self.inherited(app)
 			app.config = Config.new(
 				app,
@@ -26,32 +27,38 @@ module Flame
 
 		def initialize(app = nil)
 			@app = app
-			router.routes.map! do |route|
-				route[:hooks] = router.find_hooks(route)
-				route.freeze
-			end
-			router.freeze
 		end
 
-		## Init function
+		## Request recieving method
 		def call(env)
 			@app.call(env) if @app.respond_to? :call
 			Flame::Dispatcher.new(self, env).run!
 		end
 
+		## Make available `run Application` without `.new` for `rackup`
 		def self.call(env)
 			@app ||= new
 			@app.call env
 		end
 
+		## Mount controller in application class
+		## @param ctrl [Flame::Controller] the mounted controller class
+		## @param path [String, nil] root path for the mounted controller
+		## @yield refine defaults pathes for a methods of the mounted controller
+		## @example Mount controller with defaults
+		##   mount ArticlesController
+		## @example Mount controller with specific path
+		##   mount HomeController, '/welcome'
+		## @example Mount controller with specific path of methods
+		##   mount HomeController do
+		##     get '/bye', :goodbye
+		##     post '/greetings', :new
+		##     defaults
+		##   end
 		def self.mount(ctrl, path = nil, &block)
 			router.add_controller(ctrl, path, block)
 		end
 
-		def self.helpers(*modules)
-			modules.empty? ? (@helpers ||= []) : helpers.concat(modules).uniq!
-		end
-
 		## Router for routing
 		def self.router
 			@router ||= Flame::Router.new(self)
@@ -61,6 +68,7 @@ module Flame
 			self.class.router
 		end
 
+		## Initialize default for config directories
 		def self.default_config_dirs(root_dir:)
 			{
 				root_dir: File.realpath(root_dir),

data/lib/flame/controller.rb

@@ -5,6 +5,8 @@ module Flame
 	## Class initialize when Dispatcher found route with it
 	## For new request and response
 	class Controller
+		## Initialize the controller for request execution
+		## @param dispatcher [Flame::Dispatcher] dispatcher object
 		def initialize(dispatcher)
 			@dispatcher = dispatcher
 		end
@@ -15,12 +17,27 @@ module Flame
 			@dispatcher.path_to(*args)
 		end
 
+		## Redirect for response
+		## @overload redirect(path)
+		##   Redirect to the string path
+		##   @param path [String] path
+		##   @example Redirect to '/hello'
+		##     redirect '/hello'
+		## @overload redirect(*args)
+		##   Redirect to the path of `path_to` method
+		##   @param args arguments for `path_to` method
+		##   @example Redirect to `show` method of `ArticlesController` with id = 2
+		##     redirect ArticlesController, :show, id: 2
 		def redirect(*params)
 			response.redirect(
 				params[0].is_a?(String) ? params[0] : path_to(*params)
 			)
 		end
 
+		## Render a template with `Flame::Render` (based on Tilt-engine)
+		## @param path [Symbol, nil] path to the template file
+		## @param options [Hash] options for the `Flame::Render` rendering
+		## @return [String] rendered template
 		def view(path = nil, options = {})
 			template = Flame::Render.new(
 				self,
@@ -31,7 +48,26 @@ module Flame
 		end
 		alias render view
 
-		## Helpers from Flame::Dispatcher
+		## Execute the method of the controller with hooks (may be overloaded)
+		## @param method [Symbol] name of the controller method
+		def execute(method)
+			# send method
+			body send(
+				method,
+				*params.values_at(
+					*self.class.instance_method(method).parameters.map { |par| par[1] }
+				)
+			)
+		rescue => exception
+			# p 'rescue from controller'
+			status 500
+			dump_error(exception)
+
+			## Re-raise exception for inherited controllers or `Flame::Dispatcher`
+			raise exception
+		end
+
+		## Call helpers methods from `Flame::Dispatcher`
 		def method_missing(m, *args, &block)
 			return super unless @dispatcher.respond_to?(m)
 			@dispatcher.send(m, *args, &block)
@@ -40,6 +76,7 @@ module Flame
 		class << self
 			using GorillaPatch::StringExt
 
+			## Default root path of the controller for requests
 			def default_path(last = false)
 				(name.split('::').last.underscore.split('_') - %w(index controller ctrl))
 				  .join('/').split('/')

data/lib/flame/cookies.rb

@@ -6,10 +6,19 @@ module Flame
 			@response = response
 		end
 
+		## Get request cookies
+		## @param key [String, Symbol] name of cookie
 		def [](key)
 			@request_cookies[key.to_s]
 		end
 
+		## Set (or delete) cookies for response
+		## @param key [String, Symbol] name of cookie
+		## @param new_value [Object, nil] value of cookie
+		## @example Set new value to `cat` cookie
+		##   cookies['cat'] = 'nice cat'
+		## @example Delete `cat` cookie
+		##   cookies['cat'] = nil
 		def []=(key, new_value)
 			return @response.delete_cookie(key.to_s, path: '/') if new_value.nil?
 			@response.set_cookie(key.to_s, value: new_value, path: '/')

data/lib/flame/dispatcher.rb

@@ -14,6 +14,9 @@ module Flame
 
 		include Flame::Dispatcher::Static
 
+		## Initialize Dispatcher from Application#call
+		## @param app [Flame::Application] application object
+		## @param env Rack-environment object
 		def initialize(app, env)
 			@app = app
 			@env = env
@@ -21,43 +24,66 @@ module Flame
 			@response = Flame::Response.new
 		end
 
+		## Start of execution the request
 		def run!
 			catch :halt do
 				try_route ||
 				  try_static ||
 				  try_static(File.join(__dir__, '..', '..', 'public')) ||
-				  try_error(404)
+				  not_found
 			end
 			response.write body
 			response.finish
 		end
 
+		## Acccess to the status of response
+		## @param value [Ineger, nil] integer value for new status
+		## @return [Integer] current status
+		## @example Set status value
+		##   status 200
 		def status(value = nil)
 			response.status ||= 200
 			response.headers['X-Cascade'] = 'pass' if value == 404
 			value ? response.status = value : response.status
 		end
 
+		## Acccess to the body of response
+		## @param value [String, nil] string value for new body
+		## @return [String] current body
+		## @example Set body value
+		##   body 'Hello World!'
 		def body(value = nil)
 			value ? @body = value : @body ||= ''
 		end
 
+		## Parameters of the request
 		def params
 			@params ||= request.params.merge(request.params.keys_to_sym)
 		end
 
+		## Session object as Hash
 		def session
 			request.session
 		end
 
+		## Cookies object as Hash
 		def cookies
 			@cookies ||= Cookies.new(request.cookies, response)
 		end
 
+		## Application-config object as Hash
 		def config
 			@app.config
 		end
 
+		## Get path for controller and action.
+		##
+		## @param ctrl [Flame::Controller] class of controller
+		## @param action [Symbol] method of controller
+		## @param args [Hash] parameters for method of controller
+		## @return [String] path for requested method, controller and parameters
+		## @example Path for `show(id)` method of `ArticlesController` with `id: 2`
+		##   path_to ArticlesController, :show, id: 2 # => "/articles/show/2"
 		def path_to(ctrl, action = :index, args = {})
 			route = @app.class.router.find_route(controller: ctrl, action: action)
 			fail RouteNotFoundError.new(ctrl, action) unless route
@@ -65,10 +91,22 @@ module Flame
 			path.empty? ? '/' : path
 		end
 
-		def halt(new_status = nil, new_body = nil, new_headers = {})
-			case new_status
-			when String then new_body = new_status
-			when Integer then status new_status
+		## Interrupt the execution of route, and set new optional data
+		##   (otherwise using existing)
+		## @param new_status_or_body [Integer, String]
+		##   set new HTTP status code or new body
+		## @param new_body [String] set new body
+		## @param new_headers [String] merge new headers
+		## @example Halt with 500, no change body
+		##   halt 500
+		## @example Halt with 404, render template
+		##   halt 404, render('errors/404')
+		## @example Halt with 200, set new headers
+		##   halt 200, 'Cats!', 'Content-Type' => 'animal/cat'
+		def halt(new_status_or_body = nil, new_body = nil, new_headers = {})
+			case new_status_or_body
+			when String then new_body = new_status_or_body
+			when Integer then status new_status_or_body
 			end
 			# new_status.is_a?(String) ? () : (status new_status)
 			new_body = default_body if new_body.nil? && body.empty?
@@ -77,20 +115,27 @@ module Flame
 			throw :halt
 		end
 
+		## Add error's backtrace to @env['rack.errors'] (terminal or file)
+		## @param error [Exception] exception for class, message and backtrace
+		def dump_error(error)
+			msg = [
+				"#{Time.now.strftime('%Y-%m-%d %H:%M:%S')} - " \
+				"#{error.class} - #{error.message}:",
+				*error.backtrace
+			].join("\n\t")
+			@env['rack.errors'].puts(msg)
+		end
+
 		private
 
 		## Generate default body of error page
 		def default_body
+			## Return nil if must be no body for current HTTP status
 			return if Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include?(status)
 			response.headers[Rack::CONTENT_TYPE] = 'text/html'
 			"<h1>#{Rack::Utils::HTTP_STATUS_CODES[status]}</h1>"
 		end
 
-		## Find nearest route
-		def nearest_route_for_request
-			@app.router.find_nearest_route(request.path_parts)
-		end
-
 		## Find route and try execute it
 		def try_route
 			route = @app.class.router.find_route(
@@ -98,39 +143,36 @@ module Flame
 				path_parts: request.path_parts
 			)
 			return nil unless route
-			status 200
-			params.merge!(route.arguments(request.path_parts))
-			# route.execute(self)
 			execute_route(route)
 		end
 
+		## Execute route
+		## @param route [Flame::Route] route that must be executed
 		def execute_route(route)
-			exec_route = route.executable(self)
-			exec_route.run!
-		rescue => exception
-			dump_error(exception)
-			# status 500
-			# exec_route.execute_errors(status)
-			try_error(500, exec_route)
-		end
-
-		def try_error(error_status = nil, exec_route = nil)
-			status error_status if error_status
-			unless exec_route
-				route = nearest_route_for_request unless exec_route
-				exec_route = route.executable(self) if route
-			end
-			exec_route.execute_errors(status) if exec_route
-			halt
-		end
-
-		def dump_error(error)
-			msg = [
-				"#{Time.now.strftime('%Y-%m-%d %H:%M:%S')} - " \
-				"#{error.class} - #{error.message}:",
-				*error.backtrace
-			].join("\n\t")
-			@env['rack.errors'].puts(msg)
+			status 200
+			params.merge!(route.arguments(request.path_parts))
+			# route.execute(self)
+			route[:controller].new(self).execute(route[:action])
+		rescue => _exception
+			# p 'rescue from dispatcher'
+			halt 500
+
+			# p 're raise exception from dispatcher'
+			# raise exception
+		end
+
+		## Generate a response if the route is not found
+		def not_found
+			# p 'not found from dispatcher'
+			## Change the status of response to 404
+			status 404
+			## Find the nearest route by the parts of requested path
+			route = @app.router.find_nearest_route(request.path_parts)
+			## Halt with default body if the route not found
+			##   or it's `not_found` method not defined
+			return halt unless route && route[:controller].method_defined?(:not_found)
+			## Execute `not_found` method for the founded route
+			route[:controller].new(self).execute(:not_found)
 		end
 	end
 end

data/lib/flame/render.rb

@@ -20,6 +20,8 @@ module Flame
 			@layout = nil if File.basename(@filename)[0] == '_'
 		end
 
+		## Render template
+		## @param cache [Boolean] cache compiles or not
 		def render(cache: true)
 			## Compile Tilt to instance hash
 			tilt = cache ? self.class.tilts[@filename] ||= compile : compile
@@ -39,19 +41,16 @@ module Flame
 
 		using GorillaPatch::StringExt
 
+		## Compile file with Tilt engine
+		## @param filename [String] filename
 		def compile(filename = @filename)
 			Tilt.new(filename)
 		end
 
-		## TODO: Add `views_dir` for Application and Controller
-		## TODO: Add `layout` method for Controller
+		## @todo Add `views_dir` for Application and Controller
+		## @todo Add `layout` method for Controller
 		def find_file(path)
 			## Get full filename
-			# p Dir[File.join(
-			# 	@ctrl.config[:views_dir],
-			# 	"{#{controller_dirs.join(',')},}",
-			# 	"#{path}.*"
-			# )].uniq
 			Dir[File.join(
 				@ctrl.config[:views_dir],
 				"{#{controller_dirs.join(',')},}",
@@ -61,18 +60,21 @@ module Flame
 			end
 		end
 
+		## Find possible directories for the controller
 		def controller_dirs
-			## Build controller_dirs
-			controller_dir = (
-				@ctrl.class.name.underscore.split('_') - %w(controller ctrl)
-			).join('_')
-			controller_dir_parts = controller_dir.split('/')
+			controller_dir_parts = @ctrl.class.name.underscore.split('/').map do |part|
+				(part.split('_') - %w(controller controllers ctrl)).join('_')
+			end
+			controller_dir = controller_dir_parts.join('/')
 			[controller_dir,
 			 controller_dir_parts[1..-1].join('/'),
 			 controller_dir_parts[1..-2].join('/'),
 			 controller_dir_parts.last]
 		end
 
+		## Render the layout with template
+		## @param result [String] result of template rendering
+		## @param cache [Boolean] cache compiles or not
 		def layout_render(result, cache: true)
 			layout_file = find_file(@layout)
 			## Compile layout to hash

data/lib/flame/request.rb

@@ -1,10 +1,12 @@
 module Flame
 	## Class for requests
 	class Request < Rack::Request
+		## Split path of the request to parts (Array of String)
 		def path_parts
 			@path_parts ||= path_info.to_s.split('/').reject(&:empty?)
 		end
 
+		## Override HTTP-method of the request if the param '_method' found
 		def http_method
 			params['_method'] || request_method
 		end

data/lib/flame/route.rb

@@ -5,24 +5,26 @@ module Flame
 
 		def initialize(attrs = {})
 			@attributes = attrs.merge(
-				path_parts: attrs[:path].to_s.split('/').reject(&:empty?)
+				## Split path to parts (Array of String)
+				path_parts: attrs[:path].to_s.split('/').reject(&:empty?).freeze
 			)
 		end
 
+		## Get the attribute of route
+		## @param key [Symbol] name of attribute
 		def [](key)
 			@attributes[key]
 		end
 
+		## Set the attribute of route
+		## @param key [Symbol] name of attribute
+		## @param value [Object] value of attribute
 		def []=(key, value)
 			@attributes[key] = value
 		end
 
-		## Create Executable object (route)
-		def executable(dispatcher)
-			Executable.new(self, dispatcher)
-		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)
@@ -31,6 +33,7 @@ module Flame
 		end
 
 		## Assign arguments to path for `Controller.path_to`
+		## @param args [Hash] arguments for assigning
 		def assign_arguments(args = {})
 			self[:path_parts]
 			  .map { |path_part| assign_argument(path_part, args) }
@@ -38,6 +41,7 @@ module Flame
 		end
 
 		## Extract arguments from request_parts for `execute`
+		## @param request_parts [Array] parts of the request (Array of String)
 		def arguments(request_parts)
 			self[:path_parts].each_with_index.with_object({}) do |(path_part, i), args|
 				request_part = request_parts[i]
@@ -93,59 +97,5 @@ module Flame
 			## All is ok
 			param
 		end
-
-		## Class for Route execution
-		class Executable
-			## Create executable route with dispatcher
-			def initialize(route, dispatcher)
-				@route = route
-				@ctrl = @route[:controller].new(dispatcher)
-			end
-
-			## Execute route
-			def run!
-				execute_hooks(:before)
-				@ctrl.body @ctrl.send(@route[:action], *arranged_params)
-				execute_hooks(:after)
-			end
-
-			def execute_errors(status = 500)
-				execute_hooks(:error, status)
-			end
-
-			private
-
-			## Arguments in order as parameters of method of controller
-			def arranged_params
-				# action_parameters.each_with_object([]) do |par, arr|
-				# 	arr << @ctrl.params[par[1]] if par[0] == :req || @ctrl.params[par[1]]
-				# end
-				@ctrl.params.values_at(*action_parameters.map { |par| par[1] })
-			end
-
-			## Method parameters of route controller#action
-			def action_parameters
-				@route[:controller].instance_method(@route[:action]).parameters
-			end
-
-			## Execute before, after or error hook of Symbol, String or Proc
-			def execute_hook(hook)
-				case hook
-				when Symbol, String
-					@ctrl.send(hook.to_sym)
-				when Proc
-					@ctrl.instance_exec(&hook)
-				else
-					fail UnexpectedTypeOfHookError.new(hook, @route)
-				end
-			end
-
-			## Execute before, after or error hooks
-			def execute_hooks(*keys)
-				hooks = @route[:hooks].dig(*keys)
-				# p hooks
-				hooks.each { |hook| execute_hook(hook) } if hooks
-			end
-		end
 	end
 end

data/lib/flame/router.rb

@@ -4,30 +4,36 @@ require_relative 'validators'
 module Flame
 	## Router class for routing
 	class Router
-		attr_reader :app, :routes, :hooks
+		attr_reader :app, :routes
 
 		def initialize(app)
 			@app = app
 			@routes = []
-			@hooks = {}
 		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] root path for controller's methods
+		## @param block [Proc, nil] block for routes refine
 		def add_controller(ctrl, path, block = nil)
-			## TODO: Add Regexp paths
+			## @todo Add Regexp paths
 
 			## Add routes from controller to glob array
-			ctrl.include(*@app.helpers)
 			route_refine = RouteRefine.new(self, ctrl, path, block)
 			concat_routes(route_refine) if ActionsValidator.new(route_refine).valid?
 		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
 		end
 
 		## Find the nearest route by path parts
+		## @param path_parts [Array] parts of path for route finding
+		## @return [Flame::Route, nil] return the found nearest route, otherwise `nil`
 		def find_nearest_route(path_parts)
 			while path_parts.size >= 0
 				route = find_route(path_parts: path_parts)
@@ -37,38 +43,24 @@ module Flame
 			route
 		end
 
-		## Find hooks by Route
-		def find_hooks(route)
-			result = {}
-			hooks[route[:controller]].each do |type, hash|
-				if type == :error
-					result[type] = hash
-				else
-					result[type] = (hash[route[:action]] || []) | (hash[:*] || [])
-				end
-			end
-			# p result
-			result
-		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)
-			hooks[route_refine.ctrl] = route_refine.hooks
 		end
 
-		## Helper module for routing refine
+		## Helper class for controller routing refine
 		class RouteRefine
 			attr_accessor :rest_routes
-			attr_reader :ctrl, :routes, :hooks
-
-			HOOK_TYPES = [:before, :after, :error].freeze
+			attr_reader :ctrl, :routes
 
 			def self.http_methods
 				[:GET, :POST, :PUT, :DELETE]
 			end
 
+			## Defaults REST routes (methods, pathes, controllers actions)
 			def rest_routes
 				@rest_routes ||= [
 					{ method: :GET,     path: '/',  action: :index  },
@@ -84,11 +76,22 @@ module Flame
 				@ctrl = ctrl
 				@path = path || @ctrl.default_path
 				@routes = []
-				@hooks = HOOK_TYPES.each_with_object({}) { |type, hash| hash[type] = {} }
 				execute(&block)
 			end
 
 			http_methods.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
 				define_method(request_method.downcase) do |path, action = nil|
 					if action.nil?
 						action = path.to_sym
@@ -99,14 +102,8 @@ module Flame
 				end
 			end
 
-			HOOK_TYPES.each do |type|
-				default_actions = (type == :error ? 500 : :*)
-				define_method(type) do |actions = default_actions, action = nil, &block|
-					actions = [actions] unless actions.is_a?(Array)
-					actions.each { |a| (@hooks[type][a] ||= []).push(action || block) }
-				end
-			end
-
+			## Assign remaining methods of the controller
+			##   to defaults pathes and HTTP methods
 			def defaults
 				rest
 				@ctrl.public_instance_methods(false).each do |action|
@@ -115,6 +112,7 @@ module Flame
 				end
 			end
 
+			## Assign methods of the controller to REST architecture
 			def rest
 				rest_routes.each do |rest_route|
 					action = rest_route[:action]
@@ -125,6 +123,10 @@ module Flame
 				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 = path_merge(
 					@path,
@@ -135,15 +137,18 @@ module Flame
 
 			private
 
+			## Execute block of refinings end sorting routes
 			def execute(&block)
 				block.nil? ? defaults : instance_exec(&block)
-				@router.app.helpers.each do |helper|
-					instance_exec(&helper.mount) if helper.respond_to?(:mount)
-				end
+				# instance_exec(&@ctrl.mounted) if @ctrl.respond_to? :mounted
+				# @router.app.helpers.each do |helper|
+				# 	instance_exec(&helper.mount) if helper.respond_to?(:mount)
+				# end
 				# p @routes
 				@routes.sort! { |a, b| b[:path] <=> a[:path] }
 			end
 
+			## Build path for the action of controller
 			def make_path(path, action = nil, force_params = false)
 				## TODO: Add :arg:type support (:id:num, :name:str, etc.)
 				unshifted = force_params ? path : action_path(action)

data/lib/flame/validators.rb

@@ -59,8 +59,6 @@ module Flame
 	class ActionsValidator
 		def initialize(route_refine)
 			@routes_actions = route_refine.routes.map { |route| route[:action] }
-			@hooks_actions = route_refine.hooks.values.map(&:values).flatten
-			@hooks_actions.select! { |action| action.is_a? Symbol }
 			@ctrl = route_refine.ctrl
 			@ctrl_actions = {
 				public: @ctrl.public_instance_methods(false),
@@ -69,9 +67,7 @@ module Flame
 		end
 
 		def valid?
-			no_extra_routes_actions? &&
-			  no_extra_hooks_actions? &&
-			  no_extra_controller_actions?
+			no_extra_routes_actions? && no_extra_controller_actions?
 		end
 
 		private
@@ -84,14 +80,6 @@ module Flame
 			)
 		end
 
-		def no_extra_hooks_actions?
-			extra_hooks_actions = @hooks_actions - @ctrl_actions[:all]
-			return true if extra_hooks_actions.empty?
-			fail RouterError::ExtraRoutesActionsError.new(
-				@ctrl, extra_hooks_actions
-			)
-		end
-
 		def no_extra_controller_actions?
 			extra_ctrl_actions = @ctrl_actions[:public] - @routes_actions
 			return true if extra_ctrl_actions.empty?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flame
 version: !ruby/object:Gem::Version
-  version: 3.6.2
+  version: 4.0.0
 platform: ruby
 authors:
 - Alexander Popov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-26 00:00:00.000000000 Z
+date: 2016-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack