flame 5.0.0.rc4 → 5.0.0.rc7

data/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2015-2017 Alexander Popov (AlexWayfer)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom
+the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,135 @@
+<p align="center">
+    <img
+        src="https://raw.githubusercontent.com/AlexWayfer/flame/main/public/favicon.ico"
+        height="150"
+        alt="Flame Logo"
+        title="Logo from open-source Elusive-Iconfont (https://github.com/reduxframework/elusive-iconfont)"
+    />
+</p>
+
+<h1 align="center">Flame</h1>
+
+<p align="center">
+    <a href="https://cirrus-ci.com/github/AlexWayfer/flame/main"><img
+        src="https://api.cirrus-ci.com/github/AlexWayfer/flame.svg?branch=main"
+        alt="Cirrus CI"
+    /></a>
+    <a href="https://codecov.io/gh/AlexWayfer/flame"><img
+        src="https://img.shields.io/codecov/c/github/AlexWayfer/flame.svg?style=flat-square"
+        alt="Codecov"
+    /></a>
+    <a href="https://codeclimate.com/github/AlexWayfer/flame"><img
+        src="https://img.shields.io/codeclimate/maintainability/AlexWayfer/flame.svg?style=flat-square"
+        alt="Code Climate"
+    /></a>
+    <a href="https://depfu.com/repos/AlexWayfer/flame"><img
+        src="https://img.shields.io/depfu/AlexWayfer/flame.svg?style=flat-square"
+        alt="Depfu"
+    /></a>
+    <a href="http://inch-ci.org/github/AlexWayfer/flame"><img
+        src="http://inch-ci.org/github/AlexWayfer/flame.svg?branch=main&style=flat-square"
+        alt="Docs"
+    /></a>
+    <a href="https://rubygems.org/gems/flame"><img
+        src="https://img.shields.io/gem/v/flame.svg?include_prereleases&style=flat-square"
+        alt="Gem (including prereleases)"
+    /></a>
+    <a href="https://github.com/AlexWayfer/flame/blob/main/LICENSE.txt"><img
+        src="https://img.shields.io/github/license/AlexWayfer/flame.svg?style=flat-square"
+        alt="MIT license"
+    /></a>
+</p>
+
+Flame is a small Ruby web framework, built on [Rack](https://github.com/rack/rack),
+inspired by [Gin](https://github.com/0jcasts/gin) (which follows class-controllers style),
+designed as a replacement [Sinatra](https://github.com/sinatra/sinatra)
+or maybe even [Rails](https://github.com/rails/rails).
+
+## Why?
+
+I didn't like class methods, especially for controller's hooks — OOP is prettier without it.
+And I found a way to implement controller's hooks without using class methods,
+but with the inheritance (including the including of modules).
+Moreover, with class methods an insufficiently obvious order of hooks (especially with inheritance)
+and complicated implementation of conditions are obtained.
+In this framework everything is Ruby-native as it can be.
+
+## Installation
+
+Using the built-in `gem`:
+
+```bash
+$ gem install flame
+```
+
+or with [Bundler](http://bundler.io/):
+
+```ruby
+# Gemfile
+gem 'flame'
+```
+
+## Usage
+
+The simplest example:
+
+```ruby
+# index_controller.rb
+
+class IndexController < Flame::Controller
+  def index
+    view :index # or just `view`, Symbol as method-name by default
+  end
+
+  def hello_world
+    "Hello World!"
+  end
+
+  def goodbye
+    "Goodbye World!"
+  end
+end
+
+# app.rb
+
+class App < Flame::Application
+  mount IndexController do
+    # all methods will be mounted automatically, it's just an example of refinement
+    get '/hello', :hello_world
+  end
+end
+
+# config.ru
+
+require_relative './index_controller'
+
+require_relative './app'
+
+run App.new # or `run App`
+```
+
+More at [Wiki](https://github.com/AlexWayfer/flame/wiki).
+
+## Benchmark
+
+The last benchmark can be viewed [here](https://github.com/luislavena/bench-micro).
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies.
+
+Then, run `toys rspec` to run the tests.
+
+To install this gem onto your local machine, run `toys gem install`.
+
+To release a new version, run `toys gem release %version%`.
+See how it works [here](https://github.com/AlexWayfer/gem_toys#release).
+
+## Contributing
+
+Bug reports and pull requests are welcome on [GitHub](https://github.com/AlexWayfer/flame).
+
+## License
+
+The gem is available as open source under the terms of the
+[MIT License](https://opensource.org/licenses/MIT).

data/lib/flame/application.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'application/config'
+require 'addressable'
+
 require_relative 'router'
 require_relative 'dispatcher'
 
@@ -8,15 +9,25 @@ module Flame
 	## Core class, like Framework::Application
 	class Application
 		class << self
-			attr_accessor :config
+			include Memery
+
+			## Remember root directory when inherited
+			def inherited(app)
+				super
+				app.root_dir = File.dirname caller(2..2).first.split(':')[0]
+			end
+
+			memoize def config
+				Flame::Config.new root_dir
+			end
 
 			## Router for routing
-			def router
-				@router ||= Flame::Router.new(self)
+			memoize def router
+				Flame::Router.new(self)
 			end
 
-			def cached_tilts
-				@cached_tilts ||= {}
+			memoize def cached_tilts
+				{}
 			end
 
 			## Require project directories, exclude executable files
@@ -25,34 +36,20 @@ module Flame
 			##   Flame::Application.require_dirs(
 			##     %w[config lib models helpers mailers services controllers]
 			##	 )
-			def require_dirs(dirs)
-				caller_dir = File.dirname caller_file
+			def require_dirs(dirs, ignore: [])
 				dirs.each do |dir|
-					Dir[File.join(caller_dir, dir, '**/*.rb')]
-						.reject { |file| File.executable?(file) }
-						.sort_by { |s| [File.basename(s)[0], s] }
-						.each { |file| require File.expand_path(file) }
+					require_dir File.join(root_dir, dir), ignore: ignore
 				end
 			end
 
-			## Generating application config when inherited
-			def inherited(app)
-				app.config = Config.new(
-					app,
-					default_config_dirs(
-						root_dir: File.dirname(caller_file)
-					).merge(
-						environment: ENV['RACK_ENV'] || 'development'
-					)
-				)
-			end
-
 			## Make available `run Application` without `.new` for `rackup`
 			def call(env)
 				@app ||= new
 				@app.call env
 			end
 
+			using GorillaPatch::DeepDup
+
 			## Build a path to the given controller and action
 			##
 			## @param ctrl [Flame::Controller] class of controller
@@ -61,32 +58,45 @@ module Flame
 			## @return [String] path for requested method, controller and parameters
 			## @example Path for `show(id)` method of `ArticlesController`
 			##   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 }
+			## @example Path for `new` method of `ArticlesController` with query
+			##   path_to ArticlesController, :new, author_id: 1
 			##   # => "/articles/new?author_id=1"
 			def path_to(ctrl, action = :index, args = {})
 				path = router.path_of(ctrl, action)
+
 				raise Errors::RouteNotFoundError.new(ctrl, action) unless path
-				query = Rack::Utils.build_nested_query args.delete(:params)
-				query = nil if query&.empty?
+
+				args = args.deep_dup
 				path = path.assign_arguments(args)
 				path = '/' if path.empty?
+				query = Rack::Utils.build_nested_query args unless args.empty?
 				Addressable::URI.new(path: path, query: query).to_s
 			end
 
+			protected
+
+			attr_accessor :root_dir
+
 			private
 
-			## Get filename from caller of method
-			## @return [String] filename of caller
-			def caller_file
-				caller(2..2).first.split(':')[0]
+			def require_dir(dir, ignore: [])
+				files =
+					Dir[File.join(dir, '**/*.rb')]
+						.reject do |file|
+							File.executable?(file) ||
+								ignore.any? { |regexp| regexp.match?(file) }
+						end
+				files.sort_by! do |file|
+					[File.basename(file).start_with?('_') ? 1 : 2, file]
+				end
+				files.each { |file| require File.expand_path(file) }
 			end
 
 			## Mount controller in application class
 			## @param controller [Symbol] the snake-cased name of mounted controller
 			##   (without `Controller` or `::IndexController` for namespaces)
 			## @param path [String, nil] root path for the mounted controller
-			## @yield refine defaults pathes for a methods of the mounted controller
+			## @yield refine defaults paths for a methods of the mounted controller
 			## @example Mount controller with defaults
 			##   mount :articles # ArticlesController
 			## @example Mount controller with specific path
@@ -101,38 +111,29 @@ module Flame
 			##   mount :cabinet do # Cabinet::IndexController
 			##     mount :articles # Cabinet::ArticlesController
 			##   end
-			def mount(controller_name, path = nil, &block)
+			def mount(controller, path = nil, nested: true, &block)
 				## Add routes from controller to glob array
 				router.add Router::RoutesRefine.new(
-					router, namespace, controller_name, path, &block
+					namespace_name, controller, path, nested: nested, &block
 				)
 			end
 
 			using GorillaPatch::Namespace
 
-			def namespace
+			def namespace_name
 				namespace = self
 				while namespace.name.nil? && namespace.superclass != Flame::Application
 					namespace = superclass
 				end
 				namespace.deconstantize
 			end
-
-			## 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
 
 		def initialize(app = nil)
 			@app = app
 		end
 
-		## Request recieving method
+		## Request receiving method
 		def call(env)
 			@app.call(env) if @app.respond_to? :call
 			Flame::Dispatcher.new(self.class, env).run!

data/lib/flame/config.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative 'errors/config_file_not_found_error'
+
+module Flame
+	## Class for application configuration
+	class Config < Hash
+		DEFAULT_DIRS =
+			%i[config log public tmp views].each_with_object({}) do |key, result|
+				result[:"#{key}_dir"] = proc { File.join(self[:root_dir], key.to_s) }
+			end.freeze
+
+		## Create an instance of application config
+		## @param app [Flame::Application] application
+		## @param hash [Hash] config content
+		def initialize(root_dir)
+			super()
+			replace DEFAULT_DIRS.merge(
+				root_dir: File.realpath(root_dir),
+				environment: ENV.fetch('RACK_ENV', 'development')
+			)
+		end
+
+		## Get config value by key
+		## @param key [Symbol] config key
+		## @return [Object] config value
+		def [](key)
+			result = super(key)
+			result = instance_exec(&result) if result.class <= Proc && result.parameters.empty?
+			result
+		end
+
+		## Method for loading YAML-files from config directory
+		## @param file [String, Symbol]
+		##   file name (typecast to String with '.yaml')
+		## @param key [Symbol, String, nil]
+		##   key for allocating YAML in config Hash (typecast to Symbol)
+		## @param set [Boolean] allocating YAML in Config Hash
+		## @param require [Boolean] don't raise an error if file not found and not required
+		## @example Load SMTP file from `config/smtp.yaml' to config[]
+		##   config.load_yaml('smtp.yaml')
+		## @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.yaml', key: :mail)
+		## @example Load SMTP file without allocating in config[]
+		##   config.load_yaml('smtp.yaml', set: false)
+		## @example Try to load nonexistent SMTP file without raising an error
+		##   config.load_yaml('smtp.yaml', require: false)
+		def load_yaml(file, key: nil, set: true, required: true)
+			file = "#{file}.y{a,}ml" if file.is_a? Symbol
+
+			file_path = find_config_file file, required: required
+			return unless file_path
+
+			yaml = YAML.load_file(file_path, aliases: true)
+			key ||= File.basename(file, '.*')
+			self[key.to_sym] = yaml if set
+			yaml
+		end
+
+		private
+
+		def find_config_file(filename, required:)
+			file_path = Dir[File.join(self[:config_dir], filename)].first
+			return file_path if file_path || !required
+
+			raise Errors::ConfigFileNotFoundError.new(
+				filename, self[:config_dir].sub(self[:root_dir], '')
+			)
+		end
+	end
+end

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