flame 2.2.0 → 3.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 132a976db3536271fcd021dea1158925d8d61db6
-  data.tar.gz: 413e4476ce2a9d76b52894d03088945a389eb299
+  metadata.gz: c72f15f6e82b2b169b8e8db77fe10d1d3674e217
+  data.tar.gz: 319e24d36eacdbda8cd2454270cf6dea293d9d55
 SHA512:
-  metadata.gz: e71747e2c149f2e06a8e3760e8dcef947e4c34ca4a26105a572fcaf2bd9651229264f08d05a5d7dfc2d4b813a2d69cf049fa56706d495ee5a03f33b1a2c6806f
-  data.tar.gz: ebeac2eb2732bcac1530a3b8c0d6994060696de7d82679c4073a23611460f047688c7f2146711a0b1b10082ee84468e01059f3da0609fdd9c2e0b5093a29c3fc
+  metadata.gz: 414b88f416bc9ba7d7723d5df9d419c36865f3c08ce55f7f800e52f4b0371f8243d19800ccc37ef9194080be88296e0d832f0a95e3a4e4d76ddfcc6842b1b581
+  data.tar.gz: 96c70734f79a4a12040a3895445d18d97cad4a858b093a858d9f46399ebcf9aeb028526840238e5b9e860f4491263c2ace2368d36460fef9858fe8dc48916e61

data/lib/flame/application.rb

@@ -1,32 +1,35 @@
 require_relative 'router'
+require_relative 'request'
 require_relative 'dispatcher'
 
 module Flame
 	## Core class, like Framework::Application
 	class Application
-		## Framework configuration
-		def self.config
-			@config ||= {}
+		class << self
+			attr_accessor :config
 		end
 
+		## Framework configuration
 		def config
 			self.class.config
 		end
 
 		def self.inherited(app)
-			root_dir = File.dirname(caller[0].split(':')[0])
-			app.config.merge!(
-				root_dir: root_dir,
-				public_dir: File.join(root_dir, 'public'),
-				views_dir: File.join(root_dir, 'views')
+			app.config = Config.new(
+				app,
+				default_config_dirs(
+					root_dir: File.dirname(caller[0].split(':')[0])
+				)
 			)
-			app.use Rack::Session::Pool
+			# app.use Rack::Session::Pool
 		end
 
 		def initialize
 			app = self
 			@builder = Rack::Builder.new do
-				app.class.middlewares.each { |m| use m[:class], *m[:args], &m[:block] }
+				app.class.middlewares.each do |m|
+					use m[:class], *m[:args], &m[:block]
+				end
 				run app
 			end
 		end
@@ -34,7 +37,7 @@ module Flame
 		## Init function
 		def call(env)
 			if env[:FLAME_CALL]
-				Dispatcher.new(self, env).run!
+				Flame::Dispatcher.new(self, env).run!
 			else
 				env[:FLAME_CALL] = true
 				@builder.call env
@@ -45,21 +48,46 @@ module Flame
 			router.add_controller(ctrl, path, block)
 		end
 
+		def self.middlewares
+			@middlewares ||= []
+		end
+
 		def self.use(middleware, *args, &block)
 			middlewares << { class: middleware, args: args, block: block }
 		end
 
-		def self.middlewares
-			@middlewares ||= []
+		def self.helpers(*modules)
+			modules.empty? ? (@helpers ||= []) : @helpers = modules
 		end
 
 		## Router for routing
 		def self.router
-			@router ||= Flame::Router.new
+			@router ||= Flame::Router.new(self)
+		end
+
+		def self.default_config_dirs(root_dir:)
+			{
+				root_dir: File.realpath(root_dir),
+				public_dir: proc { File.join(config[:root_dir], 'public') },
+				views_dir: proc { File.join(config[:root_dir], 'views') },
+				config_dir: proc { File.join(config[:root_dir], 'config') }
+			}
 		end
 
-		def router
-			self.class.router
+		## Class for Flame::Application.config
+		class Config < Hash
+			def initialize(app, hash = {})
+				@app = app
+				replace(hash)
+			end
+
+			def [](key)
+				result = super(key)
+				if result.class <= Proc && result.parameters.empty?
+					result = @app.class_exec(&result)
+				end
+				result
+			end
 		end
 	end
 end

data/lib/flame/controller.rb

@@ -0,0 +1,49 @@
+require 'rack'
+require_relative 'render'
+
+module Flame
+	## Class initialize when Dispatcher found route with it
+	## For new request and response
+	class Controller
+		def initialize(dispatcher)
+			@dispatcher = dispatcher
+		end
+
+		## Helpers
+		def path_to(*args)
+			args.unshift self.class if args[0].is_a? Symbol
+			@dispatcher.path_to(*args)
+		end
+
+		def redirect(*params)
+			response.redirect(
+				params[0].is_a?(String) ? params[0] : path_to(*params)
+			)
+		end
+
+		def view(path = nil, options = {})
+			Flame::Render.new(
+				self,
+				(path || caller_locations(1, 1)[0].label.to_sym),
+				options
+			).render
+		end
+		alias_method :render, :view
+
+		## Helpers from Flame::Dispatcher
+		def method_missing(m, *args, &block)
+			return super unless @dispatcher.respond_to?(m)
+			@dispatcher.send(m, *args, &block)
+		end
+
+		private
+
+		using GorillaPatch::StringExt
+
+		def self.default_path(last = false)
+			(name.split('::').last.underscore.split('_') - %w(controller ctrl))
+			  .join('/').split('/')
+			  .unshift(nil)[(last ? -1 : 0)..-1].join('/')
+		end
+	end
+end

data/lib/flame/dispatcher.rb

@@ -1,14 +1,12 @@
-require 'rack'
-require_relative 'request'
-require_relative 'render'
-
 module Flame
-	## Class initialize when Application.call(env) invoked
-	## For new request and response
+	## Helpers for dispatch Flame::Application#call
 	class Dispatcher
+		attr_reader :request, :response
+
 		def initialize(app, env)
 			@app = app
-			@env = env
+			@request = Flame::Request.new(env)
+			@response = Rack::Response.new
 		end
 
 		def run!
@@ -18,38 +16,41 @@ module Flame
 				try_static(File.join(__dir__, '..', '..', 'public')) ||
 				halt(404)
 			end
+			# p body
 			response.write body
 			response.finish
 		end
 
-		## Helpers
-		def config
-			@app.config
+		def status(value = nil)
+			response.status ||= 200
+			value ? response.status = value : response.status
 		end
 
-		def router
-			@app.router
+		def params
+			request.params
 		end
 
-		def request
-			@request ||= Flame::Request.new(@env)
+		def session
+			request.session
 		end
 
-		def params
-			request.params
+		def cookies
+			@cookies ||= Cookies.new(request.cookies, response)
 		end
 
-		def response
-			@response ||= Rack::Response.new
+		def config
+			@app.config
 		end
 
-		def status(value = nil)
-			response.status ||= 200
-			value ? response.status = value : response.status
+		def path_to(ctrl, action, args = {})
+			route = @app.class.router.find_route(controller: ctrl, action: action)
+			fail RouteNotFoundError.new(ctrl, action) unless route
+			path = route.assign_arguments(args)
+			path.empty? ? '/' : path
 		end
 
 		def halt(new_status, body = '', new_headers = {})
-			status new_status
+			new_status.is_a?(String) ? (body = new_status) : (status new_status)
 			response.headers.merge!(new_headers)
 			# p response.body
 			if body.empty? &&
@@ -59,36 +60,11 @@ module Flame
 			throw :halt, body
 		end
 
-		def path_to(ctrl, action, args = {})
-			route = router.find_route(controller: ctrl, action: action)
-			fail RouteNotFoundError.new(ctrl, action) unless route
-			path = route.assign_arguments(args)
-			path.empty? ? '/' : path
-		end
-
-		def redirect(*params)
-			throw :halt, response.redirect(
-				params[0].is_a?(String) ? params[0] : path_to(*params)
-			)
-		end
-
-		def session
-			request.session
-		end
-
-		def cookies
-			@cookies ||= Cookies.new(request.cookies, response)
-		end
-
-		def view(path, options = {})
-			Flame::Render.new(self, path, options).render
-		end
-		alias_method :render, :view
-
 		private
 
+		## Find route and try execute it
 		def try_route
-			route = router.find_route(
+			route = @app.class.router.find_route(
 				method: request.http_method,
 				path_parts: request.path_parts
 			)
@@ -101,28 +77,44 @@ module Flame
 		end
 
 		def execute_route(route)
-			singleton_class.include route[:controller]
-			router.find_befores(route).each { |before| send(before) }
-			result = send(route[:action], *route.arranged_params(params))
-			router.find_afters(route).each do |after|
-				result = send(after, result)
+			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])
-			static_file = File.join(dir, request.path_info)
+			file = File.join(dir, request.path_info)
 			# p static_file
-			return nil unless File.exist?(static_file) && File.file?(static_file)
-			return_static(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)
-			since = @env['HTTP_IF_MODIFIED_SINCE']
 			file_time = File.mtime(file)
-			halt 304 if since && Time.httpdate(since).to_i >= file_time.to_i
+			halt 304 if static_cached?(file_time)
+			mime_type = Rack::Mime.mime_type(File.extname(file))
 			response.headers.merge!(
-				'Content-Type' => file_mime_type(file),
+				'Content-Type' => mime_type,
 				'Last-Modified' => file_time.httpdate
 				# 'Content-Disposition' => 'attachment;' \
 				#	"filename=\"#{File.basename(static_file)}\"",
@@ -131,10 +123,6 @@ module Flame
 			halt 200, File.read(file)
 		end
 
-		def file_mime_type(file)
-			Rack::Mime.mime_type(File.extname(file))
-		end
-
 		## Helper class for cookies
 		class Cookies
 			def initialize(request_cookies, response)

data/lib/flame/errors.rb

@@ -67,14 +67,27 @@ module Flame
 	end
 
 	## Error for Flame::Controller.path_to
-	class ArgumentNotAssigned < StandardError
+	class ArgumentNotAssignedError < StandardError
 		def initialize(path, path_part)
 			@path = path
 			@path_part = path_part
 		end
 
 		def message
-			"Argument '#{@path_part}' for '#{@path}' is not assigned"
+			"Argument '#{@path_part}' for path '#{@path}' is not assigned"
+		end
+	end
+
+	## Error for Flame::Router.find_path
+	class UnexpectedTypeOfAfterError < StandardError
+		def initialize(after, route)
+			@after = after
+			@route = route
+		end
+
+		def message
+			"Unexpected after-block class '#{@after.class}'" \
+			" in route '#{@route}'"
 		end
 	end
 end

data/lib/flame/render.rb

@@ -52,9 +52,13 @@ module Flame
 		def controller_dirs
 			## Build controller_dirs
 			controller_dir = (
-				@ctrl.controller.name.underscore.split('_') - %w(controller ctrl)
+				@ctrl.class.name.underscore.split('_') - %w(controller ctrl)
 			).join('_')
-			[controller_dir, controller_dir.split('/').last]
+			controller_dir_parts = controller_dir.split('/')
+			[controller_dir,
+			 controller_dir_parts[1..-1].join('/'),
+			 controller_dir_parts[1..-2].join('/'),
+			 controller_dir_parts.last]
 		end
 
 		def layout_render(result)

data/lib/flame/route.rb

@@ -13,6 +13,11 @@ module Flame
 			@attributes[attribute]
 		end
 
+		def merge(attrs)
+			dup.attributes.merge!(attrs)
+			self
+		end
+
 		## Compare attributes for `Router.find_route`
 		def compare_attributes(attrs)
 			attrs.each do |name, value|
@@ -90,7 +95,7 @@ module Flame
 			## Required argument
 			param = args[path_part[1..-1].to_sym]
 			## Required argument is nil
-			fail ArgumentNotAssigned.new(self[:path], path_part) if param.nil?
+			fail ArgumentNotAssignedError.new(self[:path], path_part) if param.nil?
 			## All is ok
 			param
 		end

data/lib/flame/router.rb

@@ -4,28 +4,31 @@ require_relative 'validators'
 module Flame
 	## Router class for routing
 	class Router
-		attr_accessor :routes, :befores, :afters
+		attr_reader :app, :routes, :befores, :afters
 
-		def initialize
+		def initialize(app)
+			@app = app
 			@routes = []
 			@befores, @afters = Array.new(2) { {} }
 		end
 
 		def add_controller(ctrl, path, block = nil)
 			## TODO: Add Regexp paths
-			## TODO: Add `before` and `after` methods
 
 			## Add routes from controller to glob array
-			ctrl_routes = RouteRefine.new(ctrl, path, block)
-			ActionsValidator.new(ctrl_routes.routes, ctrl).valid?
-			routes.concat(ctrl_routes.routes)
-			befores[ctrl] = ctrl_routes.befores
-			afters[ctrl] = ctrl_routes.afters
+			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
-		def find_route(attrs)
-			routes.find { |route| route.compare_attributes(attrs) }
+		def find_route(attrs, with_hooks = true)
+			route = routes.find { |r| r.compare_attributes(attrs) }
+			return route unless route && with_hooks
+			route.merge(
+				befores: find_befores(route),
+				afters: find_afters(route)
+			)
 		end
 
 		## Find before hook by Route
@@ -42,10 +45,16 @@ module Flame
 
 		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
+		end
+
 		## Helper module for routing refine
 		class RouteRefine
 			attr_accessor :rest_routes
-			attr_reader :routes, :befores, :afters
+			attr_reader :ctrl, :routes, :befores, :afters
 
 			def self.http_methods
 				[:GET, :POST, :PUT, :DELETE]
@@ -61,31 +70,34 @@ module Flame
 				]
 			end
 
-			def initialize(ctrl, path, block)
+			def initialize(router, ctrl, path, block)
+				@router = router
 				@ctrl = ctrl
-				@path = path || default_controller_path
+				@path = path || @ctrl.default_path
 				@routes = []
 				@befores, @afters = Array.new(2) { {} }
-				block.nil? ? defaults : instance_exec(&block)
-				# p @routes
-				@routes.sort! { |a, b| b[:path] <=> a[:path] }
+				execute(&block)
 			end
 
 			http_methods.each do |request_method|
-				define_method(request_method.downcase) do |path, action|
+				define_method(request_method.downcase) do |path, action = nil|
+					if action.nil?
+						action = path.to_sym
+						path = "/#{path}"
+					end
 					ArgumentsValidator.new(@ctrl, path, action).valid?
 					add_route(request_method, path, action)
 				end
 			end
 
-			def before(actions, action)
+			def before(actions, action = nil, &block)
 				actions = [actions] unless actions.is_a?(Array)
-				actions.each { |a| (@befores[a] ||= []).push(action) }
+				actions.each { |a| (@befores[a] ||= []).push(action || block) }
 			end
 
-			def after(actions, action)
+			def after(actions, action = nil, &block)
 				actions = [actions] unless actions.is_a?(Array)
-				actions.each { |a| (@afters[a] ||= []).push(action) }
+				actions.each { |a| (@afters[a] ||= []).push(action || block) }
 			end
 
 			def defaults
@@ -106,13 +118,23 @@ module Flame
 				end
 			end
 
-			private
+			def mount(ctrl, path = nil, &block)
+				path = path_merge(
+					@path,
+					(path || ctrl.default_path(true))
+				)
+				@router.add_controller(ctrl, path, block)
+			end
 
-			using GorillaPatch::StringExt
+			private
 
-			def default_controller_path
-				(@ctrl.name.underscore.split('_') - %w(controller ctrl))
-				  .unshift(nil).join('/')
+			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
+				# p @routes
+				@routes.sort! { |a, b| b[:path] <=> a[:path] }
 			end
 
 			def make_path(path, action = nil, force_params = false)
@@ -124,13 +146,17 @@ module Flame
 					       .unshift(unshifted)
 					       .join('/')
 				end
-				"#{@path}/#{path}".gsub(%r{\/{2,}}, '/')
+				path_merge(@path, path)
 			end
 
 			def action_path(action)
 				action == :index ? '/' : action
 			end
 
+			def path_merge(*parts)
+				parts.join('/').gsub(%r{\/{2,}}, '/')
+			end
+
 			def add_route(method, path, action, force_params = false)
 				route = Route.new(
 					method: method,

data/lib/flame/validators.rb

@@ -57,9 +57,9 @@ module Flame
 
 	## Compare actions from routes and from controller
 	class ActionsValidator
-		def initialize(routes, ctrl)
-			@routes = routes
-			@ctrl = ctrl
+		def initialize(route_refine)
+			@routes = route_refine.routes
+			@ctrl = route_refine.ctrl
 		end
 
 		def valid?

data/lib/flame.rb

@@ -1,3 +1,4 @@
 require 'gorilla-patch/string'
 
 require_relative 'flame/application'
+require_relative 'flame/controller'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flame
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 3.2.1
 platform: ruby
 authors:
 - Alexander Popov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-06 00:00:00.000000000 Z
+date: 2015-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -74,6 +74,7 @@ extra_rdoc_files: []
 files:
 - lib/flame.rb
 - lib/flame/application.rb
+- lib/flame/controller.rb
 - lib/flame/dispatcher.rb
 - lib/flame/errors.rb
 - lib/flame/render.rb