flame 5.0.0.rc5 → 5.0.0.rc6

data/lib/flame/controller/actions.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'gorilla_patch/slice'
+
+module Flame
+	class Controller
+		## Module for work with actions
+		module Actions
+			include Memery
+			using GorillaPatch::Slice
+
+			## Shortcut for not-inherited public methods: actions
+			## @return [Array<Symbol>] array of actions (public instance methods)
+			def actions
+				public_instance_methods(false)
+			end
+
+			## Re-define public instance methods (actions) from parent
+			## @param actions [Array<Symbol>] Actions for inheritance
+			## @param exclude [Array<Symbol>] Actions for excluding from inheritance
+			## @param from [Module]
+			##   Module (or Class) from which actions will be inherited
+			## @example Inherit all parent actions
+			##   class MyController < BaseController
+			##     inherit_actions
+			##   end
+			## @example Inherit certain parent actions
+			##   class MyController < BaseController
+			##     inherit_actions %i[index show]
+			##   end
+			## @example Inherit all parent actions exclude certain
+			##   class MyController < BaseController
+			##     inherit_actions exclude: %i[edit update]
+			##   end
+			## @example Inherit certain actions from specific module
+			##   class MyController < BaseController
+			##     inherit_actions %i[index show], from: ModuleWithActions
+			##   end
+			def inherit_actions(actions = nil, exclude: [], from: superclass)
+				actions = from.actions if actions.nil?
+				actions -= exclude
+
+				actions.each do |action|
+					define_method action, from.public_instance_method(action)
+				end
+
+				return unless from.respond_to?(:refined_http_methods)
+
+				refined_http_methods.merge!(
+					from.refined_http_methods.slice(*actions)
+				)
+			end
+
+			## Re-define public instance method from module
+			## @param mod [Module] Module for including to controller
+			## @param exclude [Array<Symbol>] Actions for excluding
+			##   from module public instance methods
+			## @param only [Array<Symbol>] Actions for re-defining
+			##   from module public instance methods
+			## @example Define actions from module in controller
+			##   class MyController < BaseController
+			##     include with_actions Module1
+			##     include with_actions Module2
+			##     ....
+			##   end
+			## @example Define actions from module exclude some actions in controller
+			##   class MyController < BaseController
+			##     include with_actions Module1, exclude: %i[action1 action2 ...]
+			##     include with_actions Module2, exclude: %i[action1 action2 ...]
+			##     ....
+			##   end
+			## @example Define actions from module according list in controller
+			##   class MyController < BaseController
+			##     include with_actions Module1, only: %i[action1 action2 ...]
+			##     include with_actions Module2, only: %i[action1 action2 ...]
+			##     ....
+			##   end
+			def with_actions(mod, exclude: [], only: nil)
+				Module.new do
+					@mod = mod
+					@actions = only || (@mod.public_instance_methods(false) - exclude)
+
+					extend ModuleWithActions
+				end
+			end
+
+			memoize def refined_http_methods
+				{}
+			end
+
+			private
+
+			Flame::Router::HTTP_METHODS.each do |http_method|
+				downcased_http_method = http_method.downcase
+				define_method(
+					downcased_http_method
+				) do |action_or_action_path, action = nil|
+					action, action_path =
+						if action
+							[action, action_or_action_path]
+						else
+							[action_or_action_path, nil]
+						end
+					refined_http_methods[action] = [downcased_http_method, action_path]
+				end
+			end
+
+			## Base module for module `with_actions`
+			module ModuleWithActions
+				using GorillaPatch::Slice
+
+				def included(ctrl)
+					ctrl.include @mod
+
+					ctrl.inherit_actions @actions, from: @mod
+				end
+			end
+
+			private_constant :ModuleWithActions
+		end
+	end
+end

data/lib/flame/{dispatcher → controller}/cookies.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Flame
-	class Dispatcher
+	class Controller
 		## Helper class for cookies
 		class Cookies
 			## Create an instance of Cookies
@@ -22,14 +22,19 @@ module Flame
 
 			## Set (or delete) cookies for response
 			## @param key [String, Symbol] name of cookie
-			## @param new_value [Object, nil] value of cookie
+			## @param new_value [Object, Hash, nil] value of cookie or Hash with `:value` and options
 			## @example Set new value to `cat` cookie
 			##   cookies['cat'] = 'nice cat'
+			## @example Set new value to `cat` cookie with `Max-Age` 60 seconds
+			##   cookies['cat'] = { value: 'nice cat', max_age: 60 }
 			## @example Delete `cat` cookie
 			##   cookies['cat'] = nil
 			def []=(key, new_value)
-				if new_value.nil?
+				case new_value
+				when NilClass
 					@response.delete_cookie(key.to_s, path: '/')
+				when Hash
+					@response.set_cookie(key.to_s, new_value)
 				else
 					@response.set_cookie(key.to_s, value: new_value, path: '/')
 				end

data/lib/flame/controller/path_to.rb

@@ -4,24 +4,19 @@ module Flame
 	class Controller
 		## Module with methods for path or URL building
 		module PathTo
+			include Memery
+
 			## Look documentation at {Flame::Dispatcher#path_to}
 			def path_to(*args)
 				add_controller_class(args)
+				add_controller_arguments(args)
 				@dispatcher.path_to(*args)
 			end
 
 			## Build a URI to the given controller and action, or path
 			def url_to(*args, **options)
-				first_arg = args.first
-				path =
-					if first_arg.is_a?(String) || first_arg.is_a?(Flame::Path)
-						find_static(first_arg).path(with_version: options[:version])
-					else
-						path_to(*args, **options)
-					end
-				Addressable::URI.new(
-					scheme: request.scheme, host: request.host_with_port, path: path
-				).to_s
+				path = build_path_for_url(*args, **options)
+				Addressable::URI.join(request.base_url, path).to_s
 			end
 
 			using GorillaPatch::Namespace
@@ -31,9 +26,38 @@ module Flame
 			def path_to_back
 				back_path = request.referer
 				return back_path if back_path && back_path != request.url
+
 				return path_to :index if self.class.actions.include?(:index)
+
 				'/'
 			end
+
+			private
+
+			def add_controller_class(args)
+				args.unshift(self.class) if args[0].is_a?(Symbol)
+				args.insert(1, :index) if args[0].is_a?(Class) && !args[1].is_a?(Symbol)
+			end
+
+			def add_controller_arguments(args)
+				if args[-1].is_a?(Hash)
+					args[-1] = controller_arguments.merge args[-1]
+				else
+					args.push(controller_arguments)
+				end
+			end
+
+			def build_path_for_url(*args, **options)
+				first_arg = args.first
+				if first_arg.is_a?(String) || first_arg.is_a?(Flame::Path)
+					find_static(first_arg).path(with_version: options[:version])
+				else
+					path_to(*args, **options)
+				end
+			end
+
+			memoize :build_path_for_url,
+				condition: -> { config[:environment] == 'production' }
 		end
 	end
 end

data/lib/flame/dispatcher.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 require 'gorilla_patch/symbolize'
+require 'rack'
 
 require_relative 'dispatcher/request'
 require_relative 'dispatcher/response'
-require_relative 'dispatcher/cookies'
 
 require_relative 'dispatcher/static'
 require_relative 'dispatcher/routes'
@@ -14,6 +14,8 @@ require_relative 'errors/route_not_found_error'
 module Flame
 	## Helpers for dispatch Flame::Application#call
 	class Dispatcher
+		include Memery
+
 		GEM_STATIC_FILES = File.join(__dir__, '../../public').freeze
 
 		extend Forwardable
@@ -73,34 +75,27 @@ module Flame
 
 		## Parameters of the request
 		def params
-			@params ||=
-				begin
-					request.params.symbolize_keys(deep: true)
-				rescue ArgumentError => e
-					raise unless e.message.include?('invalid %-encoding')
-					{}
-				end
+			request.params.symbolize_keys(deep: true)
+		rescue ArgumentError => e
+			raise unless e.message.include?('invalid %-encoding')
+
+			{}
 		end
+		memoize :params
 
 		## 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_class.config
 		end
 
 		## Available routes endpoint
-		def available_endpoint
-			return @available_endpoint if defined? @available_endpoint
-			@available_endpoint = router.navigate(*request.path.parts)
+		memoize def available_endpoint
+			router.navigate(*request.path.parts)
 		end
 
 		## Interrupt the execution of route, and set new optional data
@@ -138,7 +133,7 @@ module Flame
 		## Generate default body of error page
 		def default_body
 			# response.headers[Rack::CONTENT_TYPE] = 'text/html'
-			"<h1>#{Rack::Utils::HTTP_STATUS_CODES[status]}</h1>"
+			Rack::Utils::HTTP_STATUS_CODES[status]
 		end
 
 		## All cached tilts (views) for application by Flame::Render
@@ -153,12 +148,14 @@ module Flame
 			request.params
 		rescue ArgumentError => e
 			raise unless e.message.include?('invalid %-encoding')
+
 			halt 400
 		end
 
 		## Return response if HTTP-method is OPTIONS
 		def try_options
 			return unless request.http_method == :OPTIONS
+
 			allow = available_endpoint&.allow
 			halt 404 unless allow
 			response.headers['Allow'] = allow

data/lib/flame/dispatcher/request.rb

@@ -4,15 +4,15 @@ module Flame
 	class Dispatcher
 		## Class for requests
 		class Request < Rack::Request
+			include Memery
+
 			## Initialize Flame::Path
-			def path
-				@path ||= Flame::Path.new path_info
+			memoize def path
+				Flame::Path.new path_info
 			end
 
 			## Override HTTP-method of the request if the param '_method' found
-			def http_method
-				return @http_method if defined?(@http_method)
-
+			memoize def http_method
 				method_from_method =
 					begin
 						params['_method']
@@ -21,7 +21,26 @@ module Flame
 						raise unless e.message.include?('invalid %-encoding')
 					end
 
-				@http_method = (method_from_method || request_method).upcase.to_sym
+				(method_from_method || request_method).upcase.to_sym
+			end
+
+			using GorillaPatch::Inflections
+
+			HEADER_PREFIX = 'HTTP_'
+
+			## Helper method for comfortable Camel-Cased Hash of headers
+			memoize def headers
+				env.each_with_object({}) do |(key, value), result|
+					next unless key.start_with?(HEADER_PREFIX)
+
+					## TODO: Replace `String#[]` with `#delete_prefix`
+					## after Ruby < 2.5 dropping
+					camelized_key =
+						key[HEADER_PREFIX.size..-1].downcase.tr('_', '/')
+							.camelize.gsub('::', '-')
+
+					result[camelized_key] = value
+				end
 			end
 		end
 	end

data/lib/flame/dispatcher/routes.rb

@@ -11,8 +11,10 @@ module Flame
 				http_method = request.http_method
 				http_method = :GET if http_method == :HEAD
 				return unless available_endpoint
+
 				route = available_endpoint[http_method]
 				return unless route || available_endpoint.allow
+
 				halt(405, nil, 'Allow' => available_endpoint.allow) unless route
 				status 200
 				execute_route route
@@ -26,32 +28,38 @@ module Flame
 					router.path_of(route).extract_arguments(request.path)
 				)
 				# route.execute(self)
-				controller = route.controller.new(self)
-				controller.send(:execute, action)
-			rescue StandardError => exception
+				@current_controller = route.controller.new(self)
+				@current_controller.send(:execute, action)
+			rescue StandardError, SyntaxError => e
 				# p 'rescue from dispatcher'
-				dump_error(exception)
+				dump_error(e)
 				status 500
-				controller&.send(:server_error, exception)
-				# p 're raise exception from dispatcher'
-				# raise exception
+				@current_controller&.send(:server_error, e)
+				# p 're raise error from dispatcher'
+				# raise e
 			end
 
 			## Generate a default body of nearest route
 			def default_body_of_nearest_route
 				## Return nil if must be no body for current HTTP status
 				return if Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include?(status)
+
 				## Find the nearest route by the parts of requested path
 				route = router.find_nearest_route(request.path)
 				## Return standard `default_body` if the route not found
 				return default_body unless route
-				controller = route.controller.new(self)
-				## Execute `not_found` method for the founded route
-				if response.not_found?
-					controller.send(:not_found)
-				else
-					body controller.send(:default_body)
-				end
+
+				return not_found_body(route) if response.not_found?
+
+				controller =
+					(@current_controller if defined?(@current_controller)) || route.controller.new(self)
+				controller.send :default_body
+			end
+
+			def not_found_body(route)
+				## Execute `not_found` method as action for the founded route
+				execute_route(route, :not_found)
+				body
 			end
 		end
 	end

data/lib/flame/dispatcher/static.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'cgi'
+
 module Flame
 	class Dispatcher
 		## Module for working with static files
@@ -16,9 +18,11 @@ module Flame
 			private
 
 			## Find static files and try return it
-			def try_static(*args)
-				file = find_static(*args)
+			def try_static(*args, **kwargs)
+				file = find_static(*args, **kwargs)
 				return nil unless file.exist?
+
+				halt 400 unless file.within_directory
 				return_static(file)
 			end
 
@@ -32,9 +36,14 @@ module Flame
 
 			## Class for static files with helpers methods
 			class StaticFile
+				attr_reader :extname, :within_directory
+
 				def initialize(filename, dir)
 					@filename = filename.to_s
-					@file_path = File.join dir, CGI.unescape(@filename)
+					@directory = File.expand_path dir
+					@file_path = File.expand_path File.join dir, CGI.unescape(@filename)
+					@extname = File.extname(@file_path)
+					@within_directory = @file_path.start_with? @directory
 				end
 
 				def exist?
@@ -45,10 +54,6 @@ module Flame
 					File.mtime(@file_path)
 				end
 
-				def extname
-					File.extname(@file_path)
-				end
-
 				def newer?(http_since)
 					!http_since || mtime.to_i > Time.httpdate(http_since).to_i
 				end
@@ -58,8 +63,7 @@ module Flame
 				end
 
 				def path(with_version: false)
-					path = @filename
-					with_version ? "#{path}?v=#{mtime.to_i}" : path
+					with_version ? "#{@filename}?v=#{mtime.to_i}" : @filename
 				end
 			end