flame 3.4.0 → 3.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e91ac518b94afb516a97c8ed22a63c7e6381dc0e
-  data.tar.gz: 187942692b4872a65869011f43153275e6faff36
+  metadata.gz: edd8f37ca2180414b5428f5d5bbb5cf146daa356
+  data.tar.gz: 1f79bd46b74f82ac879c470dc2df4d59d2120adc
 SHA512:
-  metadata.gz: 21d8513b6c528d7b3b576f7cab5aedfe51ddd66c8b18cf451a0f6049ca7ef5b974c4668732c46c29e9c42c7a14c8b18943908c2f9493cfedb273071aa0ad5f61
-  data.tar.gz: b78b9c72ba68ad431d27877776814261c4b74fd9b1e5b5c14d75a055c5f96c02ce2652e317b5d4b9fc70df0f76ffd68d8223b6f2e63692c5381e97d3309918e5
+  metadata.gz: 907034532dbbd46fad3ecb8963579a4ec92f161b0aad1c798a663aea55b46e38efa1b6a4e549d6a1706b5cd42973fb130878ac7b56d96e491ff0e027ec742a87
+  data.tar.gz: 19b1337d223b707b2ed27b692d718746f895fc7d439ee3bf296742889dcc19525ffe49b1f5a46943b2cadeb6e5d285d82bb80ca7fb9cf703d46ec6a6e01d9340

data/lib/flame/application.rb

@@ -1,5 +1,4 @@
 require_relative 'router'
-require_relative 'request'
 require_relative 'dispatcher'
 
 module Flame
@@ -25,22 +24,32 @@ module Flame
 			)
 		end
 
-		def self.call(env)
-			@app ||= new
-			@app.call env
+		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
 		def call(env)
+			@app.call(env) if @app.respond_to? :call
 			Flame::Dispatcher.new(self, env).run!
 		end
 
+		def self.call(env)
+			@app ||= new
+			@app.call env
+		end
+
 		def self.mount(ctrl, path = nil, &block)
 			router.add_controller(ctrl, path, block)
 		end
 
 		def self.helpers(*modules)
-			modules.empty? ? (@helpers ||= []) : @helpers = modules
+			modules.empty? ? (@helpers ||= []) : helpers.concat(modules).uniq!
 		end
 
 		## Router for routing
@@ -48,6 +57,10 @@ module Flame
 			@router ||= Flame::Router.new(self)
 		end
 
+		def router
+			self.class.router
+		end
+
 		def self.default_config_dirs(root_dir:)
 			{
 				root_dir: File.realpath(root_dir),

data/lib/flame/controller.rb

@@ -29,7 +29,7 @@ module Flame
 			)
 			template.render(cache: config[:environment] == 'production')
 		end
-		alias_method :render, :view
+		alias render view
 
 		## Helpers from Flame::Dispatcher
 		def method_missing(m, *args, &block)
@@ -37,14 +37,14 @@ module Flame
 			@dispatcher.send(m, *args, &block)
 		end
 
-		private
+		class << self
+			using GorillaPatch::StringExt
 
-		using GorillaPatch::StringExt
-
-		def self.default_path(last = false)
-			(name.split('::').last.underscore.split('_') - %w(index controller ctrl))
-			  .join('/').split('/')
-			  .unshift(nil)[(last ? -1 : 0)..-1].join('/')
+			def default_path(last = false)
+				(name.split('::').last.underscore.split('_') - %w(index controller ctrl))
+				  .join('/').split('/')
+				  .unshift(nil)[(last ? -1 : 0)..-1].join('/')
+			end
 		end
 	end
 end

data/lib/flame/cookies.rb

@@ -0,0 +1,18 @@
+module Flame
+	## Helper class for cookies
+	class Cookies
+		def initialize(request_cookies, response)
+			@request_cookies = request_cookies
+			@response = response
+		end
+
+		def [](key)
+			@request_cookies[key.to_s]
+		end
+
+		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: '/')
+		end
+	end
+end

data/lib/flame/dispatcher.rb

@@ -1,5 +1,10 @@
 require 'gorilla-patch/hash'
 
+require_relative 'cookies'
+require_relative 'request'
+require_relative 'response'
+require_relative 'static'
+
 module Flame
 	## Helpers for dispatch Flame::Application#call
 	class Dispatcher
@@ -7,26 +12,28 @@ module Flame
 
 		using GorillaPatch::HashExt
 
+		include Flame::Dispatcher::Static
+
 		def initialize(app, env)
 			@app = app
+			@env = env
 			@request = Flame::Request.new(env)
-			@response = Rack::Response.new
+			@response = Flame::Response.new
 		end
 
 		def run!
-			body = catch :halt do
+			catch :halt do
 				try_route ||
-				try_static ||
-				try_static(File.join(__dir__, '..', '..', 'public')) ||
-				halt(404)
+				  try_static ||
+				  try_static(File.join(__dir__, '..', '..', 'public')) ||
+				  try_error(404)
 			end
-			# p body
-			response.write body
 			response.finish
 		end
 
 		def status(value = nil)
 			response.status ||= 200
+			response.headers['X-Cascade'] = 'pass' if value == 404
 			value ? response.status = value : response.status
 		end
 
@@ -53,26 +60,37 @@ module Flame
 			path.empty? ? '/' : path
 		end
 
-		def halt(new_status, body = nil, new_headers = {})
-			new_status.is_a?(String) ? (body = new_status) : (status new_status)
-			response.headers.merge!(new_headers)
-			# p response.body
-			if body.nil? &&
-			   !Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include?(status)
-				body = Rack::Utils::HTTP_STATUS_CODES[status]
+		def halt(new_status = nil, body = nil, new_headers = {})
+			case new_status
+			when String then body = new_status
+			when Integer then status new_status
 			end
-			throw :halt, body
+			# new_status.is_a?(String) ? () : (status new_status)
+			body = default_body if body.nil? && response.body.empty?
+			response.body = body if body
+			response.headers.merge!(new_headers)
+			throw :halt
 		end
 
 		private
 
+		## Generate default body of error page
+		def default_body
+			return if Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include?(status)
+			"<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(
 				method: request.http_method,
 				path_parts: request.path_parts
 			)
-			# p route
 			return nil unless route
 			status 200
 			params.merge!(route.arguments(request.path_parts))
@@ -81,67 +99,29 @@ module Flame
 		end
 
 		def execute_route(route)
-			ctrl = route[:controller].new(self)
-			route[:befores].each { |before| ctrl.send(before) }
-			result = ctrl.send(route[:action], *route.arranged_params(params))
-			route[:afters].each { |after| result = execute_after(ctrl, after, result) }
-			result
-		end
-
-		def execute_after(ctrl, after, result)
-			case after.class.to_s.to_sym
-			when :Symbol, :String
-				result = ctrl.send(after.to_sym, result)
-			when :Proc
-				ctrl.instance_exec(result, &after)
-			else
-				fail UnexpectedTypeOfAfterError.new(after, route)
-			end
-			result
-		end
-
-		## Find static files and try return it
-		def try_static(dir = config[:public_dir])
-			file = File.join(dir, request.path_info)
-			# p static_file
-			return nil unless File.exist?(file) && File.file?(file)
-			return_static(file)
-		end
-
-		def static_cached?(file_time)
-			since = request.env['HTTP_IF_MODIFIED_SINCE']
-			since && Time.httpdate(since).to_i >= file_time.to_i
-		end
-
-		def return_static(file)
-			file_time = File.mtime(file)
-			halt 304 if static_cached?(file_time)
-			mime_type = Rack::Mime.mime_type(File.extname(file))
-			response.headers.merge!(
-				'Content-Type' => mime_type,
-				'Last-Modified' => file_time.httpdate
-				# 'Content-Disposition' => 'attachment;' \
-				#	"filename=\"#{File.basename(static_file)}\"",
-				# 'Content-Length' => File.size?(static_file).to_s
-			)
-			halt 200, File.read(file)
-		end
-
-		## Helper class for cookies
-		class Cookies
-			def initialize(request_cookies, response)
-				@request_cookies = request_cookies
-				@response = response
-			end
-
-			def [](key)
-				@request_cookies[key.to_s]
-			end
-
-			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: '/')
-			end
+			exec_route = route.executable
+			response.body = exec_route.run!(self)
+		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)
+			exec_route = nearest_route_for_request.executable unless exec_route
+			status error_status if error_status
+			exec_route.execute_errors(status)
+			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)
 		end
 	end
 end

data/lib/flame/errors.rb

@@ -79,14 +79,14 @@ module Flame
 	end
 
 	## Error for Flame::Router.find_path
-	class UnexpectedTypeOfAfterError < StandardError
-		def initialize(after, route)
-			@after = after
+	class UnexpectedTypeOfHookError < StandardError
+		def initialize(hook, route)
+			@hook = hook
 			@route = route
 		end
 
 		def message
-			"Unexpected after-block class '#{@after.class}'" \
+			"Unexpected hook-block class '#{@hook.class}'" \
 			" in route '#{@route}'"
 		end
 	end

data/lib/flame/render.rb

@@ -16,6 +16,7 @@ module Flame
 			@locals = options.merge(options.delete(:locals) || {})
 			## Find filename
 			@filename = find_file(path)
+			@ctrl.instance_exec { halt 404 } unless @filename
 			@layout = nil if File.basename(@filename)[0] == '_'
 		end
 
@@ -26,7 +27,15 @@ module Flame
 			layout_render tilt.render(@scope, @locals), cache: cache
 		end
 
-	private
+		private
+
+		class << self
+			private
+
+			def tilts
+				@tilts ||= {}
+			end
+		end
 
 		using GorillaPatch::StringExt
 
@@ -34,19 +43,20 @@ module Flame
 			Tilt.new(filename)
 		end
 
-		def self.tilts
-			@tilts ||= {}
-		end
-
 		## 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(',')},}",
 				"#{path}.*"
-			)].find do |file|
+			)].uniq.find do |file|
 				Tilt[file]
 			end
 		end
@@ -68,11 +78,11 @@ module Flame
 			## Compile layout to hash
 			return result unless layout_file
 			layout =
-				if cache
-					self.class.tilts[layout_file] ||= compile(layout_file)
-				else
-					compile(layout_file)
-				end
+					if cache
+						self.class.tilts[layout_file] ||= compile(layout_file)
+					else
+						compile(layout_file)
+					end
 			return result unless layout
 			layout.render(@scope, @locals) { result }
 		end

data/lib/flame/response.rb

@@ -0,0 +1,11 @@
+module Flame
+	## Class for responses
+	class Response < Rack::Response
+		## Rewrite body assign (reset Content-Length and use #write)
+		def body=(value)
+			@length = 0
+			body.clear
+			write value
+		end
+	end
+end

data/lib/flame/route.rb

@@ -9,13 +9,17 @@ module Flame
 			)
 		end
 
-		def [](attribute)
-			@attributes[attribute]
+		def [](key)
+			@attributes[key]
 		end
 
-		def merge(attrs)
-			dup.attributes.merge!(attrs)
-			self
+		def []=(key, value)
+			@attributes[key] = value
+		end
+
+		## Create Executable object (route)
+		def executable
+			Executable.new(self)
 		end
 
 		## Compare attributes for `Router.find_route`
@@ -46,16 +50,6 @@ module Flame
 			end
 		end
 
-		## Arguments in order as parameters of method of controller
-		def arranged_params(params)
-			self[:controller].instance_method(self[:action]).parameters
-			  .each_with_object([]) do |par, arr|
-				  arr << params[par[1]] if par[0] == :req || params[par[1]]
-			  end
-		end
-
-		private
-
 		## Helpers for `compare_attributes`
 		def compare_attribute(name, value)
 			case name
@@ -99,5 +93,59 @@ module Flame
 			## All is ok
 			param
 		end
+
+		## Class for Route execution
+		class Executable
+			def initialize(route)
+				@route = route
+			end
+
+			## Execute route from Dispatcher
+			def run!(dispatcher)
+				@ctrl = @route[:controller].new(dispatcher)
+				execute_hooks(:before)
+				result = @ctrl.send(@route[:action], *arranged_params)
+				execute_hooks(:after)
+				result
+			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,12 +4,12 @@ require_relative 'validators'
 module Flame
 	## Router class for routing
 	class Router
-		attr_reader :app, :routes, :befores, :afters
+		attr_reader :app, :routes, :hooks
 
 		def initialize(app)
 			@app = app
 			@routes = []
-			@befores, @afters = Array.new(2) { {} }
+			@hooks = {}
 		end
 
 		def add_controller(ctrl, path, block = nil)
@@ -22,39 +22,48 @@ module Flame
 		end
 
 		## Find route by any attributes
-		def find_route(attrs, with_hooks = true)
+		def find_route(attrs)
 			route = routes.find { |r| r.compare_attributes(attrs) }
-			return route unless route && with_hooks
-			route.merge(
-				befores: find_befores(route),
-				afters: find_afters(route)
-			)
+			route.dup if route
 		end
 
-		## Find before hook by Route
-		def find_befores(route)
-			(befores[route[:controller]][:*] || []) +
-			  (befores[route[:controller]][route[:action]] || [])
+		## Find the nearest route by path parts
+		def find_nearest_route(path_parts)
+			while path_parts.size >= 0
+				route = find_route(path_parts: path_parts)
+				break if route || path_parts.empty?
+				path_parts.pop
+			end
+			route
 		end
 
-		## Find after hook by Route
-		def find_afters(route)
-			(afters[route[:controller]][:*] || []) +
-			  (afters[route[:controller]][route[:action]] || [])
+		## 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
 
 		def concat_routes(route_refine)
 			routes.concat(route_refine.routes)
-			befores[route_refine.ctrl] = route_refine.befores
-			afters[route_refine.ctrl] = route_refine.afters
+			hooks[route_refine.ctrl] = route_refine.hooks
 		end
 
 		## Helper module for routing refine
 		class RouteRefine
 			attr_accessor :rest_routes
-			attr_reader :ctrl, :routes, :befores, :afters
+			attr_reader :ctrl, :routes, :hooks
+
+			HOOK_TYPES = [:before, :after, :error].freeze
 
 			def self.http_methods
 				[:GET, :POST, :PUT, :DELETE]
@@ -75,7 +84,7 @@ module Flame
 				@ctrl = ctrl
 				@path = path || @ctrl.default_path
 				@routes = []
-				@befores, @afters = Array.new(2) { {} }
+				@hooks = HOOK_TYPES.each_with_object({}) { |type, hash| hash[type] = {} }
 				execute(&block)
 			end
 
@@ -90,14 +99,12 @@ module Flame
 				end
 			end
 
-			def before(actions = :*, action = nil, &block)
-				actions = [actions] unless actions.is_a?(Array)
-				actions.each { |a| (@befores[a] ||= []).push(action || block) }
-			end
-
-			def after(actions = :*, action = nil, &block)
-				actions = [actions] unless actions.is_a?(Array)
-				actions.each { |a| (@afters[a] ||= []).push(action || block) }
+			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
 
 			def defaults
@@ -141,10 +148,9 @@ module Flame
 				## TODO: Add :arg:type support (:id:num, :name:str, etc.)
 				unshifted = force_params ? path : action_path(action)
 				if path.nil? || force_params
-					path = @ctrl.instance_method(action).parameters
-					       .map { |par| ":#{par[0] == :req ? '' : '?'}#{par[1]}" }
-					       .unshift(unshifted)
-					       .join('/')
+					parameters = @ctrl.instance_method(action).parameters
+					parameters.map! { |par| ":#{par[0] == :req ? '' : '?'}#{par[1]}" }
+					path = parameters.unshift(unshifted).join('/')
 				end
 				path_merge(@path, path)
 			end

data/lib/flame/static.rb

@@ -0,0 +1,32 @@
+module Flame
+	class Dispatcher
+		## Module for working with static files
+		module Static
+			## Find static files and try return it
+			def try_static(dir = config[:public_dir])
+				file = File.join(dir, request.path_info)
+				return nil unless File.exist?(file) && File.file?(file)
+				return_static(file)
+			end
+
+			def static_cached?(file_time)
+				since = request.env['HTTP_IF_MODIFIED_SINCE']
+				since && Time.httpdate(since).to_i >= file_time.to_i
+			end
+
+			def return_static(file)
+				file_time = File.mtime(file)
+				halt 304 if static_cached?(file_time)
+				mime_type = Rack::Mime.mime_type(File.extname(file))
+				response.headers.merge!(
+					'Content-Type' => mime_type,
+					'Last-Modified' => file_time.httpdate
+					# 'Content-Disposition' => 'attachment;' \
+					#	"filename=\"#{File.basename(static_file)}\"",
+					# 'Content-Length' => File.size?(static_file).to_s
+				)
+				halt 200, File.read(file)
+			end
+		end
+	end
+end

data/lib/flame/validators.rb

@@ -58,28 +58,42 @@ module Flame
 	## Compare actions from routes and from controller
 	class ActionsValidator
 		def initialize(route_refine)
-			@routes = route_refine.routes
+			@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),
+				all: @ctrl.instance_methods + @ctrl.private_instance_methods
+			}
 		end
 
 		def valid?
-			@routes_actions = @routes.map { |route| route[:action] }
-			@ctrl_actions = @ctrl.public_instance_methods(false)
-			no_extra_routes_actions? && no_extra_controller_actions?
+			no_extra_routes_actions? &&
+			  no_extra_hooks_actions? &&
+			  no_extra_controller_actions?
 		end
 
 		private
 
 		def no_extra_routes_actions?
-			extra_routes_actions = @routes_actions - @ctrl_actions
+			extra_routes_actions = @routes_actions - @ctrl_actions[:public]
 			return true if extra_routes_actions.empty?
 			fail RouterError::ExtraRoutesActionsError.new(
 				@ctrl, extra_routes_actions
 			)
 		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 - @routes_actions
+			extra_ctrl_actions = @ctrl_actions[:public] - @routes_actions
 			return true if extra_ctrl_actions.empty?
 			fail RouterError::ExtraControllerActionsError.new(
 				@ctrl, extra_ctrl_actions

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flame
 version: !ruby/object:Gem::Version
-  version: 3.4.0
+  version: 3.5.0
 platform: ruby
 authors:
 - Alexander Popov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-11 00:00:00.000000000 Z
+date: 2016-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -75,12 +75,15 @@ files:
 - lib/flame.rb
 - lib/flame/application.rb
 - lib/flame/controller.rb
+- lib/flame/cookies.rb
 - lib/flame/dispatcher.rb
 - lib/flame/errors.rb
 - lib/flame/render.rb
 - lib/flame/request.rb
+- lib/flame/response.rb
 - lib/flame/route.rb
 - lib/flame/router.rb
+- lib/flame/static.rb
 - lib/flame/validators.rb
 - public/favicon.ico
 homepage: https://gitlab.com/AlexWayfer/flame