flame 4.18.1 → 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/controller/cookies.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Flame
+	class Controller
+		## Helper class for cookies
+		class Cookies
+			## Create an instance of Cookies
+			## @param request_cookies [Hash{String=>Object}] cookies from request
+			## @param response [Flame::Dispatcher::Response, Rack::Response]
+			##   response object for cookies setting
+			def initialize(request_cookies, response)
+				@request_cookies = request_cookies
+				@response = response
+			end
+
+			## Get request cookies
+			## @param key [String, Symbol] name of cookie
+			## @return [Object] value 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, 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)
+				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
+			end
+		end
+	end
+end

data/lib/flame/controller/path_to.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+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)
+				path = build_path_for_url(*args, **options)
+				Addressable::URI.join(request.base_url, path).to_s
+			end
+
+			using GorillaPatch::Namespace
+
+			## Path to previous page, or to index action, or to Index controller
+			## @return [String] path to previous page or to index
+			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,29 +1,36 @@
 # frozen_string_literal: true
 
-require 'gorilla-patch/symbolize'
+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'
 
 require_relative 'errors/route_not_found_error'
 
 module Flame
 	## Helpers for dispatch Flame::Application#call
 	class Dispatcher
-		GEM_STATIC_FILES = File.join __dir__, '..', '..', 'public'
+		include Memery
+
+		GEM_STATIC_FILES = File.join(__dir__, '../../public').freeze
+
+		extend Forwardable
+		def_delegators :@app_class, :router, :path_to
 
 		attr_reader :request, :response
 
 		include Flame::Dispatcher::Static
+		include Flame::Dispatcher::Routes
 
 		## Initialize Dispatcher from Application#call
-		## @param app [Flame::Application] application object
+		## @param app_class [Class] application class
 		## @param env Rack-environment object
-		def initialize(app, env)
-			@app = app
+		def initialize(app_class, env)
+			@app_class = app_class
 			@env = env
 			@request = Flame::Dispatcher::Request.new(env)
 			@response = Flame::Dispatcher::Response.new
@@ -32,12 +39,15 @@ module Flame
 		## Start of execution the request
 		def run!
 			catch :halt do
-				try_static ||
+				validate_request
+
+				try_options ||
+					try_static ||
 					try_static(dir: GEM_STATIC_FILES) ||
 					try_route ||
 					halt(404)
 			end
-			response.write body unless request.http_method == :HEAD
+			response.write body unless request.head?
 			response.finish
 		end
 
@@ -65,43 +75,27 @@ module Flame
 
 		## Parameters of the request
 		def params
-			@params ||= request.params.symbolize_keys(deep: true)
+			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.config
+			@app_class.config
 		end
 
-		## Build a path to the given controller and action, with any expected params
-		##
-		## @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"
-		## @example Path for `new` method of `ArticlesController` with params
-		##   path_to ArticlesController, :new, params: { author_id: 1 }
-		##   # => "/articles/new?author_id=1"
-		def path_to(ctrl, action = :index, args = {})
-			route = @app.class.router.find_route(controller: ctrl, action: action)
-			raise Errors::RouteNotFoundError.new(ctrl, action) unless route
-			query = Rack::Utils.build_nested_query args.delete(:params)
-			query = nil if query&.empty?
-			path = route.path.assign_arguments(args)
-			path = '/' if path.empty?
-			URI::Generic.build(path: path, query: query).to_s
+		## Available routes endpoint
+		memoize def available_endpoint
+			router.navigate(*request.path.parts)
 		end
 
 		## Interrupt the execution of route, and set new optional data
@@ -117,7 +111,7 @@ module Flame
 		## @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'
+		##   halt 200, 'Cats!', 'Content-Type' # => 'animal/cat'
 		def halt(new_status = nil, new_body = nil, new_headers = {})
 			status new_status if new_status
 			body new_body || (default_body_of_nearest_route if body.empty?)
@@ -139,55 +133,32 @@ 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
 		def cached_tilts
-			@app.class.cached_tilts
+			@app_class.cached_tilts
 		end
 
 		private
 
-		## Find route and try execute it
-		def try_route
-			route = @app.class.router.find_route(
-				method: request.http_method,
-				path: request.path
-			)
-			return nil unless route
-			status 200
-			execute_route(route)
-		end
+		def validate_request
+			## https://github.com/rack/rack/issues/337#issuecomment-48555831
+			request.params
+		rescue ArgumentError => e
+			raise unless e.message.include?('invalid %-encoding')
 
-		## Execute route
-		## @param route [Flame::Route] route that must be executed
-		def execute_route(route, action = route.action)
-			params.merge! route.path.extract_arguments(request.path)
-			# route.execute(self)
-			controller = route.controller.new(self)
-			controller.send(:execute, action)
-		rescue => exception
-			# p 'rescue from dispatcher'
-			dump_error(exception)
-			status 500
-			controller&.send(:server_error, exception)
-			# p 're raise exception from dispatcher'
-			# raise exception
+			halt 400
 		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 = @app.router.find_nearest_route(request.path)
-			## Return nil if the route not found
-			##   or it's `default_body` method not defined
-			return default_body unless route
-			## Execute `default_body` method for the founded route
-			execute_route(route, :default_body)
-			default_body if body.empty?
+		## 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
 		end
 	end
 end

data/lib/flame/dispatcher/request.rb

@@ -4,14 +4,43 @@ 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
-				@http_method ||= (params['_method'] || request_method).upcase.to_sym
+			memoize def http_method
+				method_from_method =
+					begin
+						params['_method']
+					rescue ArgumentError => e
+						## https://github.com/rack/rack/issues/337#issuecomment-48555831
+						raise unless e.message.include?('invalid %-encoding')
+					end
+
+				(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