flame 4.18.1 → 5.0.0.rc6

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/master/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/master"><img
+        src="https://api.cirrus-ci.com/github/AlexWayfer/flame.svg?branch=master"
+        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=master&style=flat-square"
+        alt="Docs"
+    /></a>
+    <a href="https://rubygems.org/gems/flame"><img
+        src="https://img.shields.io/gem/v/flame.svg?style=flat-square"
+        alt="Gem"
+    /></a>
+    <a href="https://github.com/AlexWayfer/flame/blob/master/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.rb

@@ -1,7 +1,15 @@
 # frozen_string_literal: true
 
-require 'rack'
+require 'gorilla_patch/inflections'
 
-require_relative 'flame/application'
-require_relative 'flame/controller'
-require_relative 'flame/version'
+## Base module
+module Flame
+	using GorillaPatch::Inflections
+
+	%i[Config Application Controller VERSION]
+		.each do |constant_name|
+			autoload(
+				constant_name, "#{__dir__}/flame/#{constant_name.to_s.underscore}"
+			)
+		end
+end

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,27 +9,37 @@ 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
 
-			## 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'
-					)
-				)
+			## Require project directories, exclude executable files
+			## @param dirs [Array<String>] Array of directories names
+			## @example Regular require of project
+			##   Flame::Application.require_dirs(
+			##     %w[config lib models helpers mailers services controllers]
+			##	 )
+			def require_dirs(dirs, ignore: [])
+				dirs.each do |dir|
+					require_dir File.join(root_dir, dir), ignore: ignore
+				end
 			end
 
 			## Make available `run Application` without `.new` for `rackup`
@@ -37,53 +48,95 @@ module Flame
 				@app.call env
 			end
 
+			using GorillaPatch::DeepDup
+
+			## Build a path to the given controller and action
+			##
+			## @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`
+			##   path_to ArticlesController, :show, id: 2 # => "/articles/show/2"
+			## @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
+
+				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
 
+			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 ctrl [Flame::Controller] the mounted controller 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 ArticlesController
+			##   mount :articles # ArticlesController
 			## @example Mount controller with specific path
-			##   mount HomeController, '/welcome'
+			##   mount :home, '/welcome' # HomeController
 			## @example Mount controller with specific path of methods
-			##   mount HomeController do
+			##   mount :home do # HomeController
 			##     get '/bye', :goodbye
 			##     post '/greetings', :new
 			##     defaults
 			##   end
-			def mount(ctrl, path = nil, &block)
-				router.add_controller(ctrl, path, &block)
+			## @example Mount controller with nested controllers
+			##   mount :cabinet do # Cabinet::IndexController
+			##     mount :articles # Cabinet::ArticlesController
+			##   end
+			def mount(controller, path = nil, nested: true, &block)
+				## Add routes from controller to glob array
+				router.add Router::RoutesRefine.new(
+					namespace_name, controller, path, nested: nested, &block
+				)
 			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) }
+			using GorillaPatch::Namespace
+
+			def namespace_name
+				namespace = self
+				while namespace.name.nil? && namespace.superclass != Flame::Application
+					namespace = superclass
 				end
-				result
+				namespace.deconstantize
 			end
 		end
 
-		## Framework configuration
-		def config
-			self.class.config
-		end
-
-		def router
-			self.class.router
-		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, env).run!
+			Flame::Dispatcher.new(self.class, env).run!
 		end
 	end
 end

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['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)
+			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.rb

@@ -1,21 +1,50 @@
 # frozen_string_literal: true
 
 require 'forwardable'
-require_relative 'render'
+require 'gorilla_patch/namespace'
 
+require_relative 'router'
+
+require_relative 'controller/actions'
+require_relative 'controller/cookies'
+require_relative 'controller/path_to'
+
+## Just because of `autoload`
 module Flame
+	autoload :Render, "#{__dir__}/render"
+
 	## Class initialize when Dispatcher found route with it
 	## For new request and response
 	class Controller
-		extend Forwardable
+		extend Actions
+		include Memery
 
-		FORBIDDEN_ACTIONS = [].freeze
+		class << self
+			attr_accessor :path_arguments
+
+			def path
+				return self::PATH if const_defined?(:PATH)
+
+				default_path
+			end
 
-		## Shortcut for not-inherited public methods: actions
-		def self.actions
-			public_instance_methods(false)
+			private
+
+			using GorillaPatch::Inflections
+
+			## Default root path of the controller for requests
+			def default_path
+				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
 		end
 
+		extend Forwardable
+
 		def_delegators(
 			:@dispatcher,
 			:config, :request, :params, :halt, :session, :response, :status, :body,
@@ -23,29 +52,17 @@ module Flame
 		)
 
 		## Initialize the controller for request execution
-		## @param dispatcher [Flame::Dispatcher] dispatcher object
+		## @param dispatcher [Flame::Dispatcher] host dispatcher
 		def initialize(dispatcher)
 			@dispatcher = dispatcher
 		end
 
-		## Helpers
-		def path_to(*args)
-			add_controller_class(args)
-			@dispatcher.path_to(*args)
+		## Cookies object as Hash
+		memoize def cookies
+			Cookies.new(request.cookies, response)
 		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)
-					static_file = find_static(first_arg)
-					static_file.path(with_version: options[:version])
-				else
-					path_to(*args, **options)
-				end
-			"#{request.scheme}://#{request.host_with_port}#{path}"
-		end
+		include Flame::Controller::PathTo
 
 		## Redirect for response
 		## @overload redirect(path, status)
@@ -98,6 +115,7 @@ module Flame
 			content_dis = 'Content-Disposition'
 			response[content_dis] = disposition.to_s
 			return unless filename
+
 			response[content_dis] << "; filename=\"#{File.basename(filename)}\""
 			ext = File.extname(filename)
 			response.content_type = ext unless ext.empty?
@@ -107,7 +125,7 @@ module Flame
 		## @param path [Symbol, nil] path to the template file
 		## @param options [Hash] options for the `Flame::Render` rendering
 		## @return [String] rendered template
-		def view(path = nil, options = {})
+		def view(path = nil, options = {}, &block)
 			cache = options.delete(:cache)
 			cache = config[:environment] == 'production' if cache.nil?
 			template = Flame::Render.new(
@@ -115,7 +133,7 @@ module Flame
 				(path || caller_locations(1, 1)[0].label.to_sym),
 				options
 			)
-			template.render(cache: cache)
+			template.render(cache: cache, &block)
 		end
 		alias render view
 
@@ -127,8 +145,16 @@ module Flame
 			body send(method, *extract_params_for(method))
 		end
 
+		def not_found
+			default_body
+		end
+
 		## Default method for Internal Server Error, can be inherited
-		def server_error(_exception)
+		## @param _exception [Exception] exception from code executing
+		## @return [String] content of exception page
+		def server_error(exception)
+			raise exception if Object.const_defined?(:BetterErrors)
+
 			body default_body
 		end
 
@@ -149,87 +175,25 @@ module Flame
 			body
 		end
 
+		using GorillaPatch::Slice
+
+		def controller_arguments
+			params.slice(*self.class.path_arguments)
+		end
+
 		def extract_params_for(action)
-			# Take parameters from action method
+			## Take parameters from action method
 			parameters = method(action).parameters
-			# Fill variables with values from params
+			## Fill variables with values from params
 			req_values, opt_values = %i[req opt].map! do |type|
 				params.values_at(
 					*parameters.select { |key, _value| key == type }.map!(&:last)
 				)
 			end
-			# Remove nils from the end of optional values
+			## Remove nils from the end of optional values
 			opt_values.pop while opt_values.last.nil? && !opt_values.empty?
-			# Concat values
+			## Concat values
 			req_values + opt_values
 		end
-
-		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
-
-		class << self
-			using GorillaPatch::Inflections
-
-			## Default root path of the controller for requests
-			def default_path
-				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
-			## @example Inherit controller with parent actions by method
-			##   class MyController < BaseController.with_actions
-			##   end
-			## @example Define actions from module in controller
-			##   class MyController < BaseController
-			##     include with_actions Module1
-			##     include with_actions Module2
-			##     ....
-			##   end
-			def with_actions(mod = nil)
-				return mod.extend(ModuleActions) if mod
-				@with_actions ||= Class.new(self) { extend ParentActions }
-			end
-		end
-
-		## Extension for modules whose public methods will be defined as actions
-		## via including
-		module ModuleActions
-			def included(ctrl)
-				public_instance_methods.each do |meth|
-					ctrl.send :define_method, meth, public_instance_method(meth)
-				end
-			end
-		end
-
-		## Module for public instance methods re-defining from superclass
-		## @example Inherit controller with parent actions without forbidden
-		## actions by `extend`
-		##   class MyController < BaseController
-		##     FORBIDDEN_ACTIONS = %[foo bar baz].freeze
-		##     extend Flame::Controller::ParentActions
-		##   end
-		module ParentActions
-			def inherited(ctrl)
-				ctrl.define_parent_actions
-			end
-
-			def self.extended(ctrl)
-				ctrl.define_parent_actions
-			end
-
-			def define_parent_actions
-				(superclass.actions - self::FORBIDDEN_ACTIONS).each do |public_method|
-					um = superclass.public_instance_method(public_method)
-					define_method public_method, um
-				end
-			end
-		end
 	end
 end