flame 1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c69eaa9cc9a97a1ad4962f3e54011450dc1e1f11
+  data.tar.gz: 91d5016a225a54dbd43b36b8ef12b07f9b174051
+SHA512:
+  metadata.gz: 669fed7b35fc590a1c895292f704fe2d20a112189c34e14ee87fbf95ae70441f425a45648d070d1cf20809077234cbfc716809394290141d74f062dc978772b5
+  data.tar.gz: 7ec7a41b6c8ba4b58c83ad613df1f54280504d3cbbb0f22bc27cb7f4827f16e1fb8bdb269b821fe75abb6be69c9c1e0998bd5323bae54d74b1fd8be62e0bb920

data/lib/flame.rb

@@ -0,0 +1,4 @@
+require 'gorilla-patch/string'
+
+require_relative './flame/application'
+require_relative './flame/controller'

data/lib/flame/application.rb

@@ -0,0 +1,43 @@
+require_relative './router'
+require_relative './dispatcher'
+
+module Flame
+	## Core class, like Framework::Application
+	class Application
+		## Framework configuration
+		def self.config
+			@config ||= {}
+		end
+
+		def config
+			self.class.config
+		end
+
+		def self.inherited(app)
+			root_dir = File.dirname(caller[0].split(':')[0])
+			app.config.merge!(
+				root_dir: root_dir,
+				public_dir: File.join(root_dir, 'public'),
+				views_dir: File.join(root_dir, 'views')
+			)
+		end
+
+		## Init function
+		def call(env)
+			Dispatcher.new(self, env).run!
+		end
+
+		def self.mount(ctrl, path = nil, &block)
+			router.add_controller(ctrl, path, block)
+		end
+
+		## Router for routing
+		def self.router
+			@router ||= Flame::Router.new
+		end
+
+		def router
+			self.class.router
+		end
+	end
+end

data/lib/flame/controller.rb

@@ -0,0 +1,26 @@
+require_relative './render'
+
+module Flame
+	## Class for controllers helpers, like Framework::Controller
+	class Controller
+		include Flame::Render
+
+		def initialize(dispatcher)
+			@dispatcher = dispatcher
+		end
+
+		def config
+			@dispatcher.config
+		end
+
+		def params
+			@dispatcher.params
+		end
+
+		def path_to(*params)
+			@dispatcher.path_to(*params)
+		end
+
+		## TODO: Add more helpers
+	end
+end

data/lib/flame/dispatcher.rb

@@ -0,0 +1,102 @@
+require 'rack'
+
+module Flame
+	## Class initialize when Application.call(env) invoked
+	## For new request and response
+	class Dispatcher
+		def initialize(app, env)
+			@app = app
+			@env = env
+		end
+
+		def run!
+			body = catch :halt do
+				try_route ||
+				try_static ||
+				try_static(File.join(__dir__, '..', '..', 'public')) ||
+				halt(404)
+			end
+			response.write body
+			response.finish
+		end
+
+		## Helpers
+		def config
+			@app.config
+		end
+
+		def request
+			@request ||= Rack::Request.new(@env)
+		end
+
+		def params
+			request.params
+		end
+
+		def response
+			@response ||= Rack::Response.new
+		end
+
+		def status(value = nil)
+			response.status ||= 200
+			value ? response.status = value : response.status
+		end
+
+		def halt(new_status, body = '', new_headers = {})
+			status new_status
+			response.headers.merge!(new_headers)
+			# p response.body
+			if body.empty? &&
+			   !Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include?(status)
+				body = Rack::Utils::HTTP_STATUS_CODES[status]
+			end
+			throw :halt, body
+		end
+
+		def path_to(ctrl, action, args = {})
+			route = @app.router.find_route(controller: ctrl, action: action)
+			fail RouteNotFoundError.new(ctrl, action) unless route
+			route.assign_arguments(args)
+		end
+
+		private
+
+		def try_route
+			method = params['_method'] || request.request_method
+			path = request.path_info
+			route = @app.router.find_route(
+				method: method,
+				path: path
+			)
+			# p route
+			return nil unless route
+			status 200
+			route.execute(self)
+		end
+
+		def try_static(dir = config[:public_dir])
+			static_file = File.join(dir, request.path_info)
+			# p static_file
+			return nil unless File.exist?(static_file) && File.file?(static_file)
+			return_static(static_file)
+		end
+
+		def return_static(file)
+			since = @env['HTTP_IF_MODIFIED_SINCE']
+			file_time = File.mtime(file)
+			halt 304 if since && Time.httpdate(since).to_i >= file_time.to_i
+			response.headers.merge!(
+				'Content-Type' => file_mime_type(file),
+				'Last-Modified' => file_time.httpdate
+				# 'Content-Disposition' => 'attachment;' \
+				#	"filename=\"#{File.basename(static_file)}\"",
+				# 'Content-Length' => File.size?(static_file).to_s
+			)
+			halt 200, File.read(file)
+		end
+
+		def file_mime_type(file)
+			Rack::Mime.mime_type(File.extname(file))
+		end
+	end
+end

data/lib/flame/errors.rb

@@ -0,0 +1,80 @@
+module Flame
+	module RouterError
+		## Error for Flame::Router.compare_actions
+		class ActionsError < StandardError
+			def initialize(ctrl, extra_actions)
+				@ctrl = ctrl
+				@extra_actions = extra_actions
+			end
+		end
+
+		## Error if routes have more actions, than controller
+		class ExtraRoutesActionsError < ActionsError
+			def message
+				"Controller '#{@ctrl}' has no methods" \
+				" '#{@extra_actions.join(', ')}' from routes"
+			end
+		end
+
+		## Error if controller has not assigned in routes actions
+		class ExtraControllerActionsError < ActionsError
+			def message
+				"Routes for '#{@ctrl}' has no methods" \
+				" '#{@extra_actions.join(', ')}'"
+			end
+		end
+
+		## Error for Flame::Router::RouteRefine.arguments_valid?
+		class ArgumentsError < StandardError
+			def initialize(ctrl, action, path, extra_args)
+				@ctrl = ctrl
+				@action = action
+				@path = path
+				@extra_args = extra_args
+			end
+		end
+
+		## Error if path has more arguments, than controller's method
+		class ExtraPathArgumentsError < ArgumentsError
+			def message
+				"Method '#{@action}' from controller '#{@ctrl}'" \
+				" does not know arguments '#{@extra_args.join(', ')}'" \
+				" from path '#{@path}'"
+			end
+		end
+
+		## Error if path has no arguments, that controller's method required
+		class ExtraActionArgumentsError < ArgumentsError
+			def message
+				"Path '#{@path}' does not contain required arguments" \
+				" '#{@extra_args.join(', ')}' of method '#{@action}'" \
+				" from controller '#{@ctrl}'"
+			end
+		end
+	end
+
+	## Error for Flame::Router.find_path
+	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::Controller.path_to
+	class ArgumentNotAssigned < StandardError
+		def initialize(path, path_part)
+			@path = path
+			@path_part = path_part
+		end
+
+		def message
+			"Argument '#{@path_part}' for '#{@path}' is not assigned"
+		end
+	end
+end

data/lib/flame/render.rb

@@ -0,0 +1,49 @@
+require 'tilt'
+
+module Flame
+	## Helper for render functionality
+	module Render
+		def view(path, options = {})
+			## Take options for rendering
+			scope = options.delete(:scope) || self
+			layout = options.delete(:layout) || 'layout.*'
+			## And get the rest variables to locals
+			locals = options.merge(options.delete(:locals) || {})
+			## Find filename
+			filename = find_file(path)
+			## Compile Tilt to instance hash
+			@tilts ||= {}
+			@tilts[filename] ||= Tilt.new(filename)
+			## Render Tilt from instance hash with new options
+			layout_render layout, @tilts[filename].render(scope, locals)
+		end
+
+		alias_method :render, :view
+
+	private
+
+		## TODO: Add `views_dir` for Application and Controller
+		## TODO: Add `layout` method for Controller
+		def find_file(path)
+			## Build controller_dir
+			controller_dir = (
+				self.class.name.split(/(?=[A-Z])/) - ['Controller']
+			).join('_').downcase
+			## Get full filename
+			Dir[File.join(
+				config[:views_dir],
+				"{#{controller_dir},}",
+				"#{path}.*"
+			)].find do |file|
+				Tilt[file]
+			end
+		end
+
+		def layout_render(layout, result)
+			layout_filename = find_file(layout)
+			## Compile layout to hash
+			@tilts[layout_filename] ||= Tilt.new(layout_filename)
+			@tilts[layout_filename] ? @tilts[layout_filename].render { result } : result
+		end
+	end
+end

data/lib/flame/route.rb

@@ -0,0 +1,114 @@
+module Flame
+	## Class for Route in Router.routes
+	class Route
+		attr_reader :attributes
+
+		def initialize(attrs = {})
+			@attributes = attrs
+		end
+
+		def [](attribute)
+			@attributes[attribute]
+		end
+
+		## Arguments in order as parameters of method of controller
+		def arrange_arguments(args = {})
+			self[:controller].instance_method(self[:action]).parameters
+			  .each_with_object([]) do |par, arr|
+				  arr << args[par[1]] if par[0] == :req || args[par[1]]
+			  end
+		end
+
+		## Compare attributes for `Router.find_route`
+		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`
+		def assign_arguments(args = {})
+			extract_path_parts
+			  .map { |path_part| assign_argument(path_part, args) }
+			  .unshift('').join('/').gsub(%r{\/{2,}}, '/')
+		end
+
+		## Execute by Application.call
+		def execute(app)
+			ctrl = self[:controller].new(app)
+			args = extract_arguments(app.request.path_info)
+			app.params.merge!(args)
+			ctrl.send(self[:action], *arrange_arguments(args))
+		end
+
+		private
+
+		## Helpers for attributes accessors
+		def extract_path_parts(other_path = self[:path])
+			other_path.to_s.split('/').reject(&:empty?)
+		end
+
+		## Extract arguments from request_path for `execute`
+		def extract_arguments(request_path)
+			args = {}
+			request_parts = extract_path_parts(request_path)
+			extract_path_parts.each_with_index do |path_part, i|
+				next unless path_part[0] == ':'
+				args[
+				  path_part[(path_part[1] == '?' ? 2 : 1)..-1].to_sym
+				] = URI.decode(request_parts[i])
+			end
+			args
+		end
+
+		## Helpers for `compare_attributes`
+		def compare_attribute(name, value)
+			case name
+			when :method
+				compare_method(value)
+			when :path
+				compare_path(value)
+			else
+				self[name] == value
+			end
+		end
+
+		def compare_method(request_method)
+			self[:method].upcase.to_sym == request_method.upcase.to_sym
+		end
+
+		def compare_path(request_path)
+			path_parts = extract_path_parts
+			request_parts = extract_path_parts(request_path)
+			# p route_path
+			req_path_parts = path_parts.select { |part| part[1] != '?' }
+			return false if request_parts.count < req_path_parts.count
+			compare_parts(request_parts, path_parts)
+		end
+
+		def compare_parts(request_parts, path_parts)
+			request_parts.each_with_index do |request_part, i|
+				path_part = path_parts[i]
+				# p request_part, path_part
+				break false unless path_part
+				next if path_part[0] == ':'
+				break false unless request_part == path_part
+			end
+		end
+
+		## Helpers for `assign_arguments`
+		def assign_argument(path_part, args = {})
+			## Not argument
+			return path_part unless path_part[0] == ':'
+			## Not required argument
+			return args[path_part[2..-1].to_sym] if path_part[1] == '?'
+			## Required argument
+			param = args[path_part[1..-1].to_sym]
+			## Required argument is nil
+			fail ArgumentNotAssigned.new(self[:path], path_part) if param.nil?
+			## All is ok
+			param
+		end
+	end
+end

data/lib/flame/router.rb

@@ -0,0 +1,126 @@
+require_relative './route.rb'
+require_relative './validators.rb'
+
+module Flame
+	## Router class for routing
+	class Router
+		attr_accessor :routes
+
+		def initialize
+			@routes = []
+		end
+
+		def add_controller(ctrl, path, block = nil)
+			## TODO: Add Regexp paths
+			## TODO: Add `before` and `after` methods
+
+			## Add routes from controller to glob array
+			ctrl_routes = RouteRefine.new(ctrl, path, block).routes
+			ActionsValidator.new(ctrl_routes, ctrl).valid?
+			routes.concat(ctrl_routes)
+		end
+
+		## Find route by any attributes
+		def find_route(attrs)
+			routes.find { |route| route.compare_attributes(attrs) }
+		end
+
+		private
+
+		## Helper module for routing refine
+		class RouteRefine
+			attr_accessor :rest_routes
+			attr_reader :routes
+
+			def self.http_methods
+				[:GET, :POST, :PUT, :DELETE]
+			end
+
+			def rest_routes
+				@rest_routes ||= [
+					{ method: :GET,     path: '/',  action: :index  },
+					{ method: :POST,    path: '/',  action: :create },
+					{ method: :GET,     path: '/',  action: :show   },
+					{ method: :PUT,     path: '/',  action: :update },
+					{ method: :DELETE,  path: '/',  action: :delete }
+				]
+			end
+
+			def initialize(ctrl, path, block)
+				@ctrl = ctrl
+				@path = path || default_controller_path
+				@routes = []
+				block.nil? ? defaults : instance_exec(&block)
+				# p @routes
+				@routes.sort! { |a, b| b[:path] <=> a[:path] }
+			end
+
+			http_methods.each do |request_method|
+				define_method(request_method.downcase) do |path, action|
+					ArgumentsValidator.new(@ctrl, path, action).valid?
+					add_route(request_method, path, action)
+				end
+			end
+
+			def defaults
+				@ctrl.public_instance_methods(false).each do |action|
+					next if find_route_index(action: action)
+					add_route(:GET, nil, action)
+				end
+			end
+
+			def rest
+				rest_routes.each do |rest_route|
+					action = rest_route[:action]
+					if @ctrl.public_instance_methods.include?(action) &&
+					   find_route_index(action: action).nil?
+						add_route(*rest_route.values, true)
+					end
+				end
+			end
+
+			private
+
+			using GorillaPatch::StringExt
+
+			def default_controller_path
+				@ctrl.name.underscore
+				  .split('_')
+				  .take_while { |part| part != 'controller' }
+				  .unshift(nil)
+				  .join('/')
+			end
+
+			def make_path(path, action = nil, force_params = false)
+				## TODO: Add :arg:type support (:id:num, :name:str, etc.)
+				unshifted = force_params ? path : action_path(action)
+				if path.nil? || force_params
+					path = @ctrl.instance_method(action).parameters
+					       .map { |par| ":#{par[0] == :req ? '' : '?'}#{par[1]}" }
+					       .unshift(unshifted)
+					       .join('/')
+				end
+				"#{@path}/#{path}".gsub(%r{\/{2,}}, '/')
+			end
+
+			def action_path(action)
+				action == :index ? '/' : action
+			end
+
+			def add_route(method, path, action, force_params = false)
+				route = Route.new(
+					method: method,
+					path: make_path(path, action, force_params),
+					controller: @ctrl,
+					action: action
+				)
+				index = find_route_index(action: action)
+				index ? @routes[index] = route : @routes.push(route)
+			end
+
+			def find_route_index(attrs)
+				@routes.find_index { |route| route.compare_attributes(attrs) }
+			end
+		end
+	end
+end

data/lib/flame/validators.rb

@@ -0,0 +1,89 @@
+require_relative './errors.rb'
+
+module Flame
+	## Compare arguments from path and from controller's action
+	class ArgumentsValidator
+		def initialize(ctrl, path, action)
+			@ctrl = ctrl
+			@path = path
+			@action = action
+		end
+
+		def valid?
+			## Break path for ':arg' arguments
+			@path_args = path_arguments(@path)
+			## Take all and required arguments from Controller#action
+			@action_args = action_arguments(@action)
+			## Compare arguments from path and arguments from method
+			no_extra_path_arguments? && no_extra_action_arguments?
+		end
+
+		private
+
+		## Split path to args array
+		def path_arguments(path)
+			args = path.split('/').select { |part| part[0] == ':' }
+			args.map { |arg| arg[1..-1].to_sym }
+		end
+
+		## Take args from controller's action
+		def action_arguments(action)
+			parameters = @ctrl.instance_method(action).parameters
+			req_parameters = parameters.select { |par| par[0] == :req }
+			{
+				all: parameters.map { |par| par[1] },
+				req: req_parameters.map { |par| par[1] }
+			}
+		end
+
+		def no_extra_path_arguments?
+			## Subtraction action args from path args
+			extra_path_args = @path_args - @action_args[:all]
+			return true if extra_path_args.empty?
+			fail RouterError::ExtraPathArgumentsError.new(
+				@ctrl, @action, @path, extra_path_args
+			)
+		end
+
+		def no_extra_action_arguments?
+			## Subtraction path args from action required args
+			extra_action_args = @action_args[:req] - @path_args
+			return true if extra_action_args.empty?
+			fail RouterError::ExtraActionArgumentsError.new(
+				@ctrl, @action, @path, extra_action_args
+			)
+		end
+	end
+
+	## Compare actions from routes and from controller
+	class ActionsValidator
+		def initialize(routes, ctrl)
+			@routes = routes
+			@ctrl = ctrl
+		end
+
+		def valid?
+			@routes_actions = @routes.map { |route| route[:action] }
+			@ctrl_actions = @ctrl.public_instance_methods(false)
+			no_extra_routes_actions? && no_extra_controller_actions?
+		end
+
+		private
+
+		def no_extra_routes_actions?
+			extra_routes_actions = @routes_actions - @ctrl_actions
+			return true if extra_routes_actions.empty?
+			fail RouterError::ExtraRoutesActionsError.new(
+				@ctrl, extra_routes_actions
+			)
+		end
+
+		def no_extra_controller_actions?
+			extra_ctrl_actions = @ctrl_actions - @routes_actions
+			return true if extra_ctrl_actions.empty?
+			fail RouterError::ExtraControllerActionsError.new(
+				@ctrl, extra_ctrl_actions
+			)
+		end
+	end
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: flame
+version: !ruby/object:Gem::Version
+  version: '1.0'
+platform: ruby
+authors:
+- Alexander Popov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+- !ruby/object:Gem::Dependency
+  name: gorilla-patch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.5.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.5.3
+description: Use controller's classes with instance methods as routing actions, mounting
+  its in application class.
+email:
+- alex.wayfer@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/flame.rb
+- lib/flame/application.rb
+- lib/flame/controller.rb
+- lib/flame/dispatcher.rb
+- lib/flame/errors.rb
+- lib/flame/render.rb
+- lib/flame/route.rb
+- lib/flame/router.rb
+- lib/flame/validators.rb
+- public/favicon.ico
+homepage: https://gitlab.com/AlexWayfer/flame
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Web-framework, based on MVC-pattern
+test_files: []