flame 5.0.0.rc5 → 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,8 +1,15 @@
 # frozen_string_literal: true
 
-require 'addressable'
-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,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['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

@@ -3,65 +3,48 @@
 require 'forwardable'
 require 'gorilla_patch/namespace'
 
+require_relative 'router'
+
+require_relative 'controller/actions'
+require_relative 'controller/cookies'
 require_relative 'controller/path_to'
-require_relative 'render'
 
+## 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
 
-		## Shortcut for not-inherited public methods: actions
-		## @return [Array<Symbol>] array of actions (public instance methods)
-		def self.actions
-			public_instance_methods(false)
-		end
+		class << self
+			attr_accessor :path_arguments
+
+			def path
+				return self::PATH if const_defined?(:PATH)
 
-		## Re-define public instance methods (actions) from parent
-		## @param actions [Array<Symbol>] Actions for inheritance
-		## @param exclude [Array<Symbol>] Actions for excluding from inheritance
-		## @example Inherit all parent actions
-		##   class MyController < BaseController
-		##     inherit_actions
-		##   end
-		## @example Inherit certain parent actions
-		##   class MyController < BaseController
-		##     inherit_actions :index, :show
-		##   end
-		## @example Inherit all parent actions exclude certain
-		##   class MyController < BaseController
-		##     inherit_actions exclude: %i[edit update]
-		##   end
-		def self.inherit_actions(actions = superclass.actions, exclude: [])
-			(actions - exclude).each do |public_method|
-				um = superclass.public_instance_method(public_method)
-				define_method public_method, um
+				default_path
 			end
-		end
 
-		## Re-define public instance method from module
-		## @example Define actions from module in controller
-		##   class MyController < BaseController
-		##     include with_actions Module1
-		##     include with_actions Module2
-		##     ....
-		##   end
-		def self.with_actions(mod, exclude: [])
-			Module.new do
-				@mod = mod
-				@exclude = exclude
-
-				def self.included(ctrl)
-					ctrl.include @mod
-
-					(@mod.public_instance_methods - @exclude).each do |meth|
-						ctrl.send :define_method, meth, @mod.public_instance_method(meth)
-					end
-				end
+			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,
@@ -74,6 +57,11 @@ module Flame
 			@dispatcher = dispatcher
 		end
 
+		## Cookies object as Hash
+		memoize def cookies
+			Cookies.new(request.cookies, response)
+		end
+
 		include Flame::Controller::PathTo
 
 		## Redirect for response
@@ -127,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?
@@ -157,13 +146,15 @@ module Flame
 		end
 
 		def not_found
-			body default_body
+			default_body
 		end
 
 		## Default method for Internal Server Error, can be inherited
 		## @param _exception [Exception] exception from code executing
 		## @return [String] content of exception page
-		def server_error(_exception)
+		def server_error(exception)
+			raise exception if Object.const_defined?(:BetterErrors)
+
 			body default_body
 		end
 
@@ -184,6 +175,12 @@ 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
 			parameters = method(action).parameters
@@ -198,35 +195,5 @@ module Flame
 			## 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
-
-			def refined_http_methods
-				@refined_http_methods ||= []
-			end
-
-			Flame::Router::HTTP_METHODS.each do |http_method|
-				downcased_http_method = http_method.downcase
-				define_method(downcased_http_method) do |action_path, action = nil|
-					refined_http_methods << [downcased_http_method, action_path, action]
-				end
-			end
-		end
 	end
 end