flame 4.14.1 → 4.15.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5bc0b79cf5230c68de69ef02ca56cbcb87129596
-  data.tar.gz: 704eeb2d13348ff0a2550f2bec091b3ce31f0107
+  metadata.gz: b3c14c31d4f80cb54a03a36060c74c668b624b4a
+  data.tar.gz: 13d93b6e48507a6ad1b5bb0263ab368e2ab973da
 SHA512:
-  metadata.gz: c7e1bab7ef3dea8e2b4ebd3c0a2794238363d2667b8231a693450c906dfb49013d5280893003e65484678be80ff130860b7e16fab477aa62484630026c0ac347
-  data.tar.gz: 22a49850f69e4ca3dfa5ac4a58bb9fcaf639be004b6f0c2ec9ce9d45e64a4784840ad90b4f7aaf5c6057d0bce35a1736dd965f0a7096d2eff8b110781443270c
+  metadata.gz: cdcdfca044347e8abe725cca2260987468519a1d4a875cae66656f064ed5e2cadab4818698d50d3cb5360e0302c43117ff3c875ad3c440ec92c751847404fb06
+  data.tar.gz: c73d1862a9e5e4f3fe1f30429b304518ab9c7d772fda324f09795067bf064510ff8048ae9c699b4153796a1fcce5228a8ac4a94e821ba13b5ffe46c26f631863

data/lib/flame/application.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative 'application/config'
 require_relative 'router'
 require_relative 'dispatcher'
 
@@ -8,117 +9,81 @@ module Flame
 	class Application
 		class << self
 			attr_accessor :config
-		end
 
-		## Framework configuration
-		def config
-			self.class.config
-		end
+			## Router for routing
+			def router
+				@router ||= Flame::Router.new(self)
+			end
 
-		## Generating application config when inherited
-		def self.inherited(app)
-			app.config = Config.new(
-				app,
-				default_config_dirs(
-					root_dir: File.dirname(caller[0].split(':')[0])
-				).merge(
-					environment: ENV['RACK_ENV'] || 'development'
+			def cached_tilts
+				@cached_tilts ||= {}
+			end
+
+			## Generating application config when inherited
+			def inherited(app)
+				app.config = Config.new(
+					app,
+					default_config_dirs(
+						root_dir: File.dirname(caller[0].split(':')[0])
+					).merge(
+						environment: ENV['RACK_ENV'] || 'development'
+					)
 				)
-			)
-		end
+			end
 
-		def initialize(app = nil)
-			@app = app
-		end
+			## Make available `run Application` without `.new` for `rackup`
+			def call(env)
+				@app ||= new
+				@app.call env
+			end
 
-		## Request recieving method
-		def call(env)
-			@app.call(env) if @app.respond_to? :call
-			Flame::Dispatcher.new(self, env).run!
-		end
+			private
 
-		## 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 mount(ctrl, path = nil, &block)
+				router.add_controller(ctrl, path, &block)
+			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)
+			## Initialize default for config directories
+			def default_config_dirs(root_dir:)
+				result = { root_dir: File.realpath(root_dir) }
+				%i[public views config tmp].each do |key|
+					result[:"#{key}_dir"] = proc { File.join(config[:root_dir], key.to_s) }
+				end
+				result
+			end
 		end
 
-		## Router for routing
-		def self.router
-			@router ||= Flame::Router.new(self)
+		## Framework configuration
+		def config
+			self.class.config
 		end
 
 		def router
 			self.class.router
 		end
 
-		## Initialize default for config directories
-		def self.default_config_dirs(root_dir:)
-			result = { root_dir: File.realpath(root_dir) }
-			%i[public views config tmp].each do |key|
-				result[:"#{key}_dir"] = proc { File.join(config[:root_dir], key.to_s) }
-			end
-			result
-		end
-
-		def self.cached_tilts
-			@cached_tilts ||= {}
+		def initialize(app = nil)
+			@app = app
 		end
 
-		## 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
-
-			## Method for loading YAML-files from config directory
-			## @param file [String, Symbol] file name (typecast to String with '.yml')
-			## @param key [Symbol, String, nil]
-			##   key for allocating YAML in config Hash (typecast to Symbol)
-			## @param set [Boolean] allocating YAML in Config Hash
-			## @example Load SMTP file from `config/smtp.yml' to config[]
-			##   config.load_yaml('smtp.yml')
-			## @example Load SMTP file without extension, by Symbol
-			##   config.load_yaml(:smtp)
-			## @example Load SMTP file with other key to config[:mail]
-			##   config.load_yaml('smtp.yml', :mail)
-			## @example Load SMTP file without allocating in config[]
-			##   config.load_yaml('smtp.yml', set: false)
-			def load_yaml(file, key: nil, set: true)
-				file = "#{file}.yml" if file.is_a? Symbol
-				file_path = File.join(self[:config_dir], file)
-				yaml = YAML.load_file(file_path)
-				key ||= File.basename(file, '.*')
-				self[key.to_sym] = yaml if set
-				yaml
-			end
+		## Request recieving method
+		def call(env)
+			@app.call(env) if @app.respond_to? :call
+			Flame::Dispatcher.new(self, env).run!
 		end
 	end
 end

data/lib/flame/application/config.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Flame
+	class Application
+		## 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
+
+			## Method for loading YAML-files from config directory
+			## @param file [String, Symbol] file name (typecast to String with '.yml')
+			## @param key [Symbol, String, nil]
+			##   key for allocating YAML in config Hash (typecast to Symbol)
+			## @param set [Boolean] allocating YAML in Config Hash
+			## @example Load SMTP file from `config/smtp.yml' to config[]
+			##   config.load_yaml('smtp.yml')
+			## @example Load SMTP file without extension, by Symbol
+			##   config.load_yaml(:smtp)
+			## @example Load SMTP file with other key to config[:mail]
+			##   config.load_yaml('smtp.yml', key: :mail)
+			## @example Load SMTP file without allocating in config[]
+			##   config.load_yaml('smtp.yml', set: false)
+			def load_yaml(file, key: nil, set: true)
+				file = "#{file}.yml" if file.is_a? Symbol
+				file_path = File.join(self[:config_dir], file)
+				yaml = YAML.load_file(file_path)
+				key ||= File.basename(file, '.*')
+				self[key.to_sym] = yaml if set
+				yaml
+			end
+		end
+	end
+end

data/lib/flame/controller.rb

@@ -34,7 +34,13 @@ module Flame
 
 		## Build a URI to the given controller and action, or path
 		def url_to(*args)
-			path = args.first.is_a?(String) ? args.first : path_to(*args)
+			first_arg = args.first
+			path =
+				if first_arg.is_a?(String) || first_arg.is_a?(Flame::Path)
+					first_arg
+				else
+					path_to(*args)
+				end
 			"#{request.scheme}://#{request.host_with_port}#{path}"
 		end
 
@@ -126,6 +132,20 @@ module Flame
 
 		private
 
+		## Execute any action from any controller
+		## @example Execute `new` action of `ArticlesController`
+		##   reroute ArticlesController, :new
+		## @example Execute `index` action of `ArticlesController`
+		##   reroute ArticlesController
+		## @example Execute `foo` action of current controller
+		##   reroute :foo
+		def reroute(*args)
+			add_controller_class(args)
+			ctrl, action = args[0..1]
+			ctrl_object = ctrl == self.class ? self : ctrl.new(@dispatcher)
+			ctrl_object.send :execute, action
+		end
+
 		def extract_params_for(action)
 			# p action, params, parameters
 			method(action).parameters.each_with_object({}) do |parameter, result|
@@ -145,10 +165,12 @@ module Flame
 
 			## Default root path of the controller for requests
 			def default_path
-				modules = name.underscore.split('/')
-				parts = modules[-1].split('_') - %w[index controller ctrl]
-				return modules[-2] if parts.empty?
-				parts.join('_')
+				modules = underscore.split('/')
+				parts = modules.pop.split('_')
+				parts.shift if parts.first == 'index'
+				parts.pop if %w[controller ctrl].include? parts.last
+				parts = [modules.last] if parts.empty?
+				Flame::Path.merge nil, parts.join('_')
 			end
 
 			## Re-define public instance method from parent

data/lib/flame/dispatcher.rb

@@ -2,10 +2,13 @@
 
 require 'gorilla-patch/symbolize'
 
-require_relative 'cookies'
-require_relative 'request'
-require_relative 'response'
-require_relative 'static'
+require_relative 'dispatcher/request'
+require_relative 'dispatcher/response'
+
+require_relative 'dispatcher/cookies'
+require_relative 'dispatcher/static'
+
+require_relative 'errors/route_not_found_error'
 
 module Flame
 	## Helpers for dispatch Flame::Application#call
@@ -22,8 +25,8 @@ module Flame
 		def initialize(app, env)
 			@app = app
 			@env = env
-			@request = Flame::Request.new(env)
-			@response = Flame::Response.new
+			@request = Flame::Dispatcher::Request.new(env)
+			@response = Flame::Dispatcher::Response.new
 		end
 
 		## Start of execution the request
@@ -96,7 +99,7 @@ module Flame
 			raise Errors::RouteNotFoundError.new(ctrl, action) unless route
 			query = Rack::Utils.build_nested_query args.delete(:params)
 			query = nil if query&.empty?
-			path = route.assign_arguments(args)
+			path = route.path.assign_arguments(args)
 			path = '/' if path.empty?
 			URI::Generic.build(path: path, query: query).to_s
 		end
@@ -150,7 +153,7 @@ module Flame
 		def try_route
 			route = @app.class.router.find_route(
 				method: request.http_method,
-				path_parts: request.path_parts
+				path: request.path
 			)
 			return nil unless route
 			status 200
@@ -160,7 +163,7 @@ module Flame
 		## Execute route
 		## @param route [Flame::Route] route that must be executed
 		def execute_route(route, action = route.action)
-			params.merge!(route.arguments(request.path_parts))
+			params.merge! route.path.extract_arguments(request.path)
 			# route.execute(self)
 			controller = route.controller.new(self)
 			controller.send(:execute, action)
@@ -178,7 +181,7 @@ module Flame
 			## 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_parts)
+			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

data/lib/flame/dispatcher/request.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Flame
+	class Dispatcher
+		## Class for requests
+		class Request < Rack::Request
+			## Initialize Flame::Path
+			def path
+				@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
+			end
+		end
+	end
+end

data/lib/flame/dispatcher/response.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Flame
+	class Dispatcher
+		## Class for responses
+		class Response < Rack::Response
+			## Set Content-Type header directly or by extension
+			## @param value [String] value for header or extension of file
+			## @return [String] setted value
+			## @example Set value directly
+			##   content_type = 'text/css'
+			## @example Set value by file extension
+			##   content_type = '.css'
+			def content_type=(value)
+				value = Rack::Mime.mime_type(value) if value.start_with? '.'
+				set_header Rack::CONTENT_TYPE, value
+			end
+		end
+	end
+end

data/lib/flame/errors/argument_not_assigned_error.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Flame
+	module Errors
+		## Error for Flame::Dispatcher.path_to
+		class ArgumentNotAssignedError < StandardError
+			def initialize(path, argument)
+				@path = path
+				@argument = argument
+			end
+
+			def message
+				"Argument '#{@argument}' for path '#{@path}' is not assigned"
+			end
+		end
+	end
+end

data/lib/flame/{errors.rb → errors/route_arguments_error.rb}

@@ -19,6 +19,7 @@ module Flame
 				case @extra[:place]
 				when :ctrl
 					## Error if path has no arguments, that controller's method has
+					## NOTE: It isn't using because `Flame::Path#adopt`
 					"Path '#{@path}' has no #{@extra[:type_name]}" \
 						" arguments #{@extra[:args].inspect}"
 				when :path
@@ -28,30 +29,5 @@ module Flame
 				end
 			end
 		end
-
-		## Error for Flame::Dispatcher.path_to
-		class RouteNotFoundError < StandardError
-			def initialize(ctrl, method)
-				@ctrl = ctrl
-				@method = method
-			end
-
-			def message
-				"Route with controller '#{@ctrl}' and method '#{@method}'" \
-					' not found in application routes'
-			end
-		end
-
-		## Error for Flame::Dispatcher.path_to
-		class ArgumentNotAssignedError < StandardError
-			def initialize(path, argument)
-				@path = path
-				@argument = argument
-			end
-
-			def message
-				"Argument '#{@argument}' for path '#{@path}' is not assigned"
-			end
-		end
 	end
 end

data/lib/flame/errors/route_not_found_error.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Flame
+	module Errors
+		## Error for Flame::Dispatcher.path_to
+		class RouteNotFoundError < StandardError
+			def initialize(ctrl, method)
+				@ctrl = ctrl
+				@method = method
+			end
+
+			def message
+				"Route with controller '#{@ctrl}' and method '#{@method}'" \
+					' not found in application routes'
+			end
+		end
+	end
+end

data/lib/flame/path.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require_relative 'errors/argument_not_assigned_error'
+
+module Flame
+	## Class for working with paths
+	class Path
+		def self.merge(*parts)
+			parts.join('/').gsub(%r{\/{2,}}, '/')
+		end
+
+		def initialize(*paths)
+			@path = self.class.merge(*paths)
+			freeze
+		end
+
+		def parts
+			@parts ||= @path.to_s.split('/').reject(&:empty?)
+				.map! { |part| PathPart.new(part) }
+		end
+
+		def freeze
+			@path.freeze
+			parts.each(&:freeze)
+			parts.freeze
+			super
+		end
+
+		## Compare by parts count and the first arg position
+		def <=>(other)
+			self_parts, other_parts = [self, other].map(&:parts)
+			parts_size = self_parts.size <=> other_parts.size
+			return parts_size unless parts_size.zero?
+			self_parts.zip(other_parts)
+				.reduce(0) do |result, (self_part, other_part)|
+					break -1 if self_part.arg? && !other_part.arg?
+					break 1 if other_part.arg? && !self_part.arg?
+					result
+				end
+		end
+
+		def ==(other)
+			other = self.class.new(other) if other.is_a? String
+			parts == other.parts
+		end
+
+		## Complete path for the action of controller
+		## @todo Add :arg:type support (:id:num, :name:str, etc.)
+		def adapt(ctrl, action)
+			parameters = ctrl.instance_method(action).parameters
+			parameters.map! do |parameter|
+				parameter_type, parameter_name = parameter
+				path_part = PathPart.new parameter_name, arg: parameter_type
+				path_part unless parts.include? path_part
+			end
+			self.class.new @path.empty? ? "/#{action}" : self, *parameters
+		end
+
+		## Can recieve other as String
+		def match?(other)
+			other = self.class.new(other) if other.is_a? String
+			return false unless other_contain_required_parts?(other)
+			result = [self, other].map { |path| path.parts.size }.max.times do |i|
+				break false unless compare_parts parts[i], other.parts[i]
+			end
+			result = true if result
+			result
+		end
+
+		## Extract arguments from other path with values at arguments
+		## @param other_path [Flame::Path] other path with values at arguments
+		def extract_arguments(other_path)
+			parts.each_with_index.with_object({}) do |(part, i), args|
+				other_part = other_path.parts[i].to_s
+				next args unless part.arg?
+				break args if part.opt_arg? && other_part.empty?
+				args[
+					part[(part.opt_arg? ? 2 : 1)..-1].to_sym
+				] = URI.decode(other_part)
+			end
+		end
+
+		## Assign arguments to path for `Controller.path_to`
+		## @param args [Hash] arguments for assigning
+		def assign_arguments(args = {})
+			result_parts = parts.map { |part| assign_argument(part, args) }.compact
+			self.class.merge result_parts.unshift(nil)
+		end
+
+		def to_s
+			@path
+		end
+		alias to_str to_s
+
+		private
+
+		def other_contain_required_parts?(other)
+			other_parts = other.parts
+			req_path_parts = parts.reject(&:opt_arg?)
+			fixed_path_parts = parts.reject(&:arg?)
+			(fixed_path_parts - other_parts).empty? &&
+				other_parts.count >= req_path_parts.count
+		end
+
+		def compare_parts(part, other_part)
+			return unless part
+			return if other_part.nil? && !part.opt_arg?
+			# p other_part, part
+			return true if part.arg?
+			return true if other_part == part
+		end
+
+		## Helpers for `assign_arguments`
+		def assign_argument(part, args = {})
+			## Not argument
+			return part unless part.arg?
+			## Not required argument
+			return args[part[2..-1].to_sym] if part.opt_arg?
+			## Required argument
+			param = args[part[1..-1].to_sym]
+			## Required argument is nil
+			error = Errors::ArgumentNotAssignedError.new(@path, part)
+			raise error if param.nil?
+			## All is ok
+			param
+		end
+
+		## Class for one part of Path
+		class PathPart
+			extend Forwardable
+
+			def_delegators :@part, :[], :hash
+
+			ARG_CHAR = ':'
+			ARG_CHAR_OPT = '?'
+
+			def initialize(part, arg: false)
+				@part = "#{ARG_CHAR if arg}#{ARG_CHAR_OPT if arg == :opt}#{part}"
+			end
+
+			def freeze
+				@part.freeze
+				super
+			end
+
+			def ==(other)
+				to_s == other.to_s
+			end
+
+			alias eql? ==
+
+			def to_s
+				@part
+			end
+
+			def arg?
+				@part.start_with? ARG_CHAR
+			end
+
+			def opt_arg?
+				@part[1] == ARG_CHAR_OPT
+			end
+
+			def clean
+				@part.delete ARG_CHAR + ARG_CHAR_OPT
+			end
+		end
+	end
+end

data/lib/flame/router.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'route'
+require_relative 'router/route'
 
 module Flame
 	## Router class for routing
@@ -32,12 +32,14 @@ module Flame
 			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)
+		## Find the nearest route by path
+		## @param path [Flame::Path] path for route finding
+		## @return [Flame::Route, nil] return the found nearest route or `nil`
+		def find_nearest_route(path)
+			path = Flame::Path.new(path) if path.is_a? String
+			path_parts = path.parts.dup
 			while path_parts.size >= 0
-				route = find_route(path_parts: path_parts)
+				route = find_route path: Flame::Path.new(*path_parts)
 				break if route || path_parts.empty?
 				path_parts.pop
 			end
@@ -90,14 +92,12 @@ module Flame
 				##   @example Set method to :POST for action `goodbye`
 				##     post :goodbye
 				method = request_method.downcase
-				define_method(method) do |path, action = nil, prefix: false|
+				define_method(method) do |path, action = nil|
 					## Swap arguments if action in path variable
 					unless action
 						action = path.to_sym
 						path = nil
 					end
-					## Make path by controller method with parameners
-					path = default_action_path(action, path) if prefix || path.nil?
 					## Init new Route
 					route = Route.new(@ctrl, action, method, @path, path)
 					## Try to find route with the same action
@@ -123,7 +123,7 @@ module Flame
 					action = rest_route[:action]
 					next if !@ctrl.actions.include?(action) ||
 					        find_route_index(action: action)
-					send(*rest_route.values.map(&:downcase), prefix: true)
+					send(*rest_route.values.map(&:downcase))
 				end
 			end
 
@@ -132,7 +132,7 @@ module Flame
 			## @param path [String, nil] root path for mounting controller
 			## @yield Block of code for routes refine
 			def mount(ctrl, path = nil, &block)
-				path = Route.path_merge(@path, path || ctrl.default_path)
+				path = Flame::Path.merge(@path, path || ctrl.default_path)
 				@router.add_controller(ctrl, path, &block)
 			end
 
@@ -148,21 +148,6 @@ module Flame
 			def find_route_index(attrs)
 				@routes.find_index { |route| route.compare_attributes(attrs) }
 			end
-
-			## Build path for the action of controller
-			## @todo Add :arg:type support (:id:num, :name:str, etc.)
-			def default_action_path(action, prefix)
-				unshifted = prefix ? prefix : action_prefix(action)
-				parameters = @ctrl.instance_method(action).parameters
-				parameters.map! do |par|
-					":#{par[0] == :req ? '' : ARG_CHAR_OPT}#{par[1]}"
-				end
-				Route.path_merge(parameters.unshift(unshifted))
-			end
-
-			def action_prefix(action)
-				action == :index ? '/' : action
-			end
 		end
 	end
 end

data/lib/flame/router/route.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative '../path'
+require_relative '../validators'
+
+module Flame
+	class Router
+		## Class for Route in Router.routes
+		class Route
+			attr_reader :method, :controller, :action, :path
+
+			def initialize(controller, action, method, ctrl_path, action_path)
+				@controller = controller
+				@action = action
+				@method = method.to_sym.upcase
+				## Make path by controller method with parameners
+				action_path = Flame::Path.new(action_path).adapt(controller, action)
+				## Merge action path with controller path
+				@path = Flame::Path.new(ctrl_path, action_path)
+				Validators::RouteArgumentsValidator.new(
+					@controller, action_path, @action
+				).valid?
+				freeze
+			end
+
+			def freeze
+				@path.freeze
+				super
+			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)
+					break false
+				end
+			end
+
+			## Method for Routes comparison
+			def ==(other)
+				%i[controller action method path].reduce(true) do |result, method|
+					result && (
+						public_send(method) == other.public_send(method)
+					)
+				end
+			end
+
+			## Compare by:
+			## 1. path parts count (more is matter);
+			## 2. args position (father is matter);
+			## 3. HTTP-method (default).
+			def <=>(other)
+				path_result = other.path <=> path
+				return path_result unless path_result.zero?
+				method <=> other.method
+			end
+
+			private
+
+			## Helpers for `compare_attributes`
+			def compare_attribute(name, value)
+				case name
+				when :method
+					compare_method(value)
+				when :path
+					path.match? value
+				else
+					send(name) == value
+				end
+			end
+
+			def compare_method(request_method)
+				request_method = request_method.upcase.to_sym
+				request_method = :GET if request_method == :HEAD
+				method.upcase.to_sym == request_method
+			end
+		end
+	end
+end

data/lib/flame/validators.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'errors'
+require_relative 'errors/route_arguments_error'
 
 module Flame
 	module Validators
@@ -8,7 +8,7 @@ module Flame
 		class RouteArgumentsValidator
 			def initialize(ctrl, path, action)
 				@ctrl = ctrl
-				@path = path
+				@path = Flame::Path.new(path)
 				@action = action
 			end
 
@@ -30,16 +30,12 @@ module Flame
 
 			## Split path to args array
 			def path_arguments
-				@path_arguments ||= @path.split('/')
+				@path_arguments ||= @path.parts
 					.each_with_object(req: [], opt: []) do |part, hash|
 						## Take only argument parts
-						next if part[0] != Router::ARG_CHAR
-						## Clean argument from special chars
-						clean_part = part.delete(
-							Router::ARG_CHAR + Router::ARG_CHAR_OPT
-						).to_sym
+						next unless part.arg?
 						## Memorize arguments
-						hash[part[1] != Router::ARG_CHAR_OPT ? :req : :opt] << clean_part
+						hash[part.opt_arg? ? :opt : :req] << part.clean.to_sym
 					end
 			end
 

data/lib/flame/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Flame
-	VERSION = '4.14.1'
+	VERSION = '4.15.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flame
 version: !ruby/object:Gem::Version
-  version: 4.14.1
+  version: 4.15.2
 platform: ruby
 authors:
 - Alexander Popov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-29 00:00:00.000000000 Z
+date: 2017-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -222,16 +222,20 @@ files:
 - bin/flame
 - lib/flame.rb
 - lib/flame/application.rb
+- lib/flame/application/config.rb
 - lib/flame/controller.rb
-- lib/flame/cookies.rb
 - lib/flame/dispatcher.rb
-- lib/flame/errors.rb
+- lib/flame/dispatcher/cookies.rb
+- lib/flame/dispatcher/request.rb
+- lib/flame/dispatcher/response.rb
+- lib/flame/dispatcher/static.rb
+- lib/flame/errors/argument_not_assigned_error.rb
+- lib/flame/errors/route_arguments_error.rb
+- lib/flame/errors/route_not_found_error.rb
+- lib/flame/path.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/router/route.rb
 - lib/flame/validators.rb
 - lib/flame/version.rb
 - public/favicon.ico

data/lib/flame/request.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-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
-			@http_method ||= (params['_method'] || request_method).upcase.to_sym
-		end
-	end
-end

data/lib/flame/response.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Flame
-	## Class for responses
-	class Response < Rack::Response
-		## Set Content-Type header directly or by extension
-		## @param value [String] value for header or extension of file
-		## @return [String] setted value
-		## @example Set value directly
-		##   content_type = 'text/css'
-		## @example Set value by file extension
-		##   content_type = '.css'
-		def content_type=(value)
-			value = Rack::Mime.mime_type(value) if value.start_with? '.'
-			set_header Rack::CONTENT_TYPE, value
-		end
-	end
-end

data/lib/flame/route.rb

@@ -1,154 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'validators'
-
-module Flame
-	class Router
-		ARG_CHAR = ':'
-		ARG_CHAR_OPT = '?'
-
-		## Class for Route in Router.routes
-		class Route
-			attr_reader :method, :controller, :action, :path, :path_parts
-
-			def initialize(controller, action, method, ctrl_path, action_path)
-				## Merge action path with controller path
-				path = self.class.path_merge(ctrl_path, action_path)
-				@controller = controller
-				@action = action
-				@method = method.to_sym.upcase
-				## MAKE PATH
-				@path = path
-				Validators::RouteArgumentsValidator.new(
-					@controller, action_path, @action
-				).valid?
-				@path_parts = @path.to_s.split('/').reject(&:empty?)
-				freeze
-			end
-
-			def freeze
-				@path.freeze
-				@path_parts.freeze
-				super
-			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)
-					break false
-				end
-			end
-
-			## Assign arguments to path for `Controller.path_to`
-			## @param args [Hash] arguments for assigning
-			def assign_arguments(args = {})
-				parts = @path_parts.map { |part| assign_argument(part, args) }.compact
-				self.class.path_merge(parts.unshift(nil))
-			end
-
-			## Extract arguments from request_parts for `execute`
-			## @param request_parts [Array] parts of the request (Array of String)
-			def arguments(request_parts)
-				@path_parts.each_with_index.with_object({}) do |(path_part, i), args|
-					request_part = request_parts[i].to_s
-					path_part_opt = path_part[1] == ARG_CHAR_OPT
-					next args unless path_part[0] == ARG_CHAR
-					break args if path_part_opt && request_part.empty?
-					args[
-						path_part[(path_part_opt ? 2 : 1)..-1].to_sym
-					] = URI.decode(request_part)
-				end
-			end
-
-			## Method for Routes comparison
-			def ==(other)
-				%i[controller action method path_parts].reduce(true) do |result, method|
-					result && (
-						public_send(method) == other.public_send(method)
-					)
-				end
-			end
-
-			## Compare by path parts count (more is matter)
-			def <=>(other)
-				self_parts, other_parts = [self, other].map(&:path_parts)
-				path_parts_size = other_parts.size <=> self_parts.size
-				return path_parts_size unless path_parts_size.zero?
-				other_parts.zip(self_parts)
-					.reduce(0) do |result, (other_part, self_part)|
-						break 1 if part_arg?(self_part) && !part_arg?(other_part)
-						break -1 if part_arg?(other_part) && !part_arg?(self_part)
-						result
-					end
-			end
-
-			def self.path_merge(*parts)
-				parts.join('/').gsub(%r{\/{2,}}, '/')
-			end
-
-			private
-
-			def part_arg?(part)
-				part.start_with? ARG_CHAR
-			end
-
-			## Helpers for `compare_attributes`
-			def compare_attribute(name, value)
-				case name
-				when :method
-					compare_method(value)
-				when :path_parts
-					compare_path_parts(value)
-				else
-					send(name) == value
-				end
-			end
-
-			def compare_method(request_method)
-				request_method = request_method.upcase.to_sym
-				request_method = :GET if request_method == :HEAD
-				method.upcase.to_sym == request_method
-			end
-
-			def compare_path_parts(request_parts)
-				return false unless request_contain_required_path_parts?(request_parts)
-				[request_parts.size, @path_parts.size].max.times do |i|
-					break false unless compare_parts request_parts[i], @path_parts[i]
-				end
-			end
-
-			def compare_parts(request_part, path_part)
-				# p request_part, path_part
-				return unless path_part
-				return if request_part.nil? && path_part[1] != ARG_CHAR_OPT
-				# p request_part, path_part
-				return true if path_part[0] == ARG_CHAR
-				return true if request_part == path_part
-			end
-
-			def request_contain_required_path_parts?(request_parts)
-				req_path_parts = @path_parts.reject { |part| part[1] == ARG_CHAR_OPT }
-				fixed_path_parts = @path_parts.reject { |part| part[0] == ARG_CHAR }
-				(fixed_path_parts - request_parts).empty? &&
-					request_parts.count >= req_path_parts.count
-			end
-
-			## Helpers for `assign_arguments`
-			def assign_argument(path_part, args = {})
-				## Not argument
-				return path_part unless path_part[0] == ARG_CHAR
-				## Not required argument
-				return args[path_part[2..-1].to_sym] if path_part[1] == ARG_CHAR_OPT
-				## Required argument
-				param = args[path_part[1..-1].to_sym]
-				## Required argument is nil
-				error = Errors::ArgumentNotAssignedError.new(path, path_part)
-				raise error if param.nil?
-				## All is ok
-				param
-			end
-		end
-	end
-end