rubko 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 507cef7351098c01960413739e54b19d74ea872d
+  data.tar.gz: b6476fac467d2265b8777620e77b9557fc16e19f
+SHA512:
+  metadata.gz: 926e843d6848ceb3dccb87affd87b1c57998a8d38822517e2cbc02ef077cdde55fb2944d62741c7b67e04388cc2fcf6deea4b5fe59626fa47cf5ca33ce0ca19d
+  data.tar.gz: 35f3021ce7bae47895be95216f0358314dd93a5c47b972d94540aa0df94dfdfac662a1768f610c67a5ed37007fbf4f3342cc81650192dfa134be946c0905d032

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/bin/rubko-deploy

@@ -0,0 +1,40 @@
+#!/usr/bin/ruby
+
+	# settings
+
+	ssh = true
+	host = 'hetzner:54321'
+	user = 'root'
+	remote = '/srv/http/' + File.basename(Dir.getwd)
+
+	exclude = [
+		'log.txt',
+		#'config/db.rb',
+		'.deploy.rb',
+		'.dev/',
+		'.run/',
+		'.repo/',
+		'.gitignore',
+		'.git/'
+	]
+
+	# program
+
+	require 'io/console'
+	print 'Password: ';
+	pass = STDIN.noecho(&:gets).strip
+	puts
+
+	protocol = ssh ? 'sftp' : 'ftp'
+
+	commands = [
+		'set ftp:list-options -a',
+		"open #{protocol}://#{user}:#{pass}@#{host}",
+		'lcd ./',
+		"cd #{remote}",
+		'mirror -L --reverse --only-newer --verbose ' + exclude.map { |el|
+			'--exclude-glob ' + el
+		}.join(' ')
+	]
+
+	system 'lftp', '-c', commands.join(';')

data/bin/rubko-init

@@ -0,0 +1,6 @@
+#!/usr/bin/ruby
+
+	require 'fileutils'
+
+	stamp = File.expand_path '../stamp', __dir__
+	FileUtils.cp_r Dir["#{stamp}/*"], '.'

data/lib/rubko/app.rb

@@ -0,0 +1,79 @@
+require 'rubko/base'
+require 'rubko/asset/gzipStream'
+
+class Rubko::App
+	include Rubko::Base
+
+	def initialize(env, shared = nil)
+		@status = 200
+		@headers = {'Connection' => 'Keep-Alive', 'Date' => Time.now.httpdate}
+		@mime = 'text/html'
+		@body = ''
+
+		@shared = shared
+		@finalizers = []
+
+		@env = env
+		params = Rack::Utils.parse_nested_query @env['rack.input'].read
+		@params = Hash[ params.map { |k, v|
+			[ k.to_sym, v ]
+		} ]
+
+		super()
+	end
+
+	attr_accessor :status, :headers, :mime, :body
+	attr_reader :env, :params, :shared, :finalizers
+
+	def init(path)
+		url.path = path
+		request( *url.newPath )
+	end
+
+	def request(name = :welcome, action = nil, *path)
+		controller = loadController(name) || loadController(:error404)
+
+		calls = [ action ? "_#{action}" : 'index' ]
+		calls << calls.first + '_' + url.method
+
+		calls.map! { |call|
+			if controller.respond_to? call
+				@body = controller.__send__ call, *path
+				true
+			end
+		}
+		if calls.compact.empty?
+			@body = controller.other action, *path
+		end
+
+		# finalize request
+		finalizers.reverse_each(&:finalize)
+		@headers['Content-Type'] = "#{mime}; charset=utf-8" unless @status == 304
+
+		# make sure body responds to :each
+		@body = @body.to_s if Integer === @body
+		@body = [@body] if String === @body
+		@body = [] unless @body.respond_to? :each
+
+		# compress
+		if controller.compressible?
+			headers['Content-Encoding'] = 'gzip'
+			@body = Rubko::Asset::GzipStream.new @body
+		end
+
+		# add Content-Length header
+		if @body.respond_to? :bytesize
+			headers['Content-Length'] = @body.bytesize.to_s
+		elsif Array === @body
+			headers['Content-Length'] = @body.reduce(0) { |sum, x|
+				sum + x.bytesize
+			}.to_s
+		end
+
+		[@status, @headers, @body]
+	end
+
+	def production?
+		ENV['RACK_ENV'] == 'production'
+	end
+end

data/lib/rubko/asset/fileStream.rb

@@ -0,0 +1,18 @@
+class Rubko::Asset::FileStream
+	def initialize(path, chunk = 32)
+		@path = path
+		@chunk = 1024*chunk
+	end
+
+	def each
+		File.open(@path, 'rb') { |f|
+			while part = f.read(@chunk)
+				yield part
+			end
+		}
+	end
+
+	def bytesize
+		File.size @path
+	end
+end

data/lib/rubko/asset/gzipStream.rb

@@ -0,0 +1,26 @@
+require 'rubko/controller'
+require 'zlib'
+
+class Rubko::Asset < Rubko::Controller
+	class GzipStream
+		def initialize(body, mtime = Time.now)
+			@body = body
+			@gzip = Zlib::GzipWriter.new self
+			@gzip.mtime = mtime
+		end
+
+		def each(&block)
+			@writer = block
+			@body.each { |part|
+				@gzip.write part
+				@gzip.flush
+			}
+		ensure
+			@gzip.close
+		end
+
+		def write(data)
+			@writer.call data
+		end
+	end
+end

data/lib/rubko/asset.rb

@@ -0,0 +1,71 @@
+require 'rubko/controller'
+
+# in case we want to serve files and get notified on hits
+class Rubko::Asset < Rubko::Controller
+
+	def init
+		@dir = 'public'
+	end
+
+	attr_accessor :dir
+
+	def hit(*path)
+		puts "File #{path*'/'} hit." unless production?
+	end
+
+	def cache(*path)
+	end
+
+	def miss(*path)
+		puts "File #{path*'/'} not found (404)."
+		loadController(:error404).other( *path )
+	end
+
+	private :hit, :cache, :miss
+
+	def compressible?
+		super && @mime != 'application/octet-stream' &&
+		['application', 'text'].any? { |type|
+			@mime.start_with? type+'/'
+		}
+	end
+
+	attr_reader :mime, :modified
+
+	def index
+		other
+	end
+
+	def other(*path)
+		# protect private files
+		if path.include?('..') || path.include?('.private') && production?
+			return miss(*path)
+		end
+
+		path.shift if path[0] =~ /^\d*$/
+		path = "#{@dir}/#{path * '/'}"
+		@mime = Rack::Mime.mime_type File.extname(path)
+		if File.file? path
+			self.mime = @mime
+			headers['Cache-Control'] = 'public'
+			headers['Vary'] = 'Accept-Encoding'
+
+			@modified = File.mtime path
+			since = (Time.httpdate(env['HTTP_IF_MODIFIED_SINCE']).to_i rescue 0)
+			headers['Last-Modified'] = @modified.httpdate
+			headers['Expires'] = (DateTime.now >> 12).httpdate
+
+			if @modified.to_i <= since
+				cache( *path )
+				self.status = 304
+				''
+			else
+				hit( *path )
+				require 'rubko/asset/fileStream'
+				FileStream.new path
+			end
+		else
+			miss( *path )
+		end
+	end
+end

data/lib/rubko/base.rb

@@ -0,0 +1,123 @@
+require 'date'
+require 'json'
+
+class Rubko
+	module Base
+		def initialize(parent = nil)
+			@parent = parent
+			finalizers << self if @parent
+			@plugins = {}
+			puts "#{self.class} initialized." unless production?
+		end
+
+		def init(*) end
+		def finalize(*) end
+
+		attr_accessor :parent
+
+		def loadFile(name)
+			require(name) || true
+		rescue LoadError
+			false
+		end
+
+		def camelize(array)
+			array.map { |x|
+				x.to_s.downcase.capitalize
+			}.join
+		end
+		def uncamelize(str)
+			str.to_s.split(/(?=[A-Z])/).map(&:downcase)
+		end
+
+		def load(what, name, *args)
+			Kernel.const_get(camelize [*[*name].reverse, what]).
+				new(self).tap { |x| x.init(*args) }
+		end
+		private :load
+
+		def loadPlugin(name, *args)
+			require 'rubko/plugin'
+
+			process = -> search, range, proc=nil {
+				p = Dir[search].sort_by { |x|
+					x.split('/').size
+				}.first
+				if p
+					loadFile p
+					p[range].split '/'
+				else
+					proc.call if proc
+				end
+			}
+
+			path = uncamelize(name).reverse * '/'
+			name = process.call "./plugins/**/#{path}.rb", 10..-4, -> {
+				d = __dir__
+				process.call "#{d}/plugins/**/#{path}.rb", (d.size+9)..-4
+			}
+			return false unless name
+
+			loadFile "./config/#{name * '/'}.rb"
+			load :plugin, name, *args
+		end
+
+		def loadController(name, *args)
+			require 'rubko/controller'
+			return false unless loadFile "./controllers/#{name}.rb"
+			load :controller, name, *args
+		end
+
+		def loadModel(name, *args)
+			require 'rubko/model'
+			return false unless loadFile "./models/#{name}.rb"
+			load :model, name, *args
+		end
+
+		def loadView(*name)
+			if production?
+				template = memory[:views, name]
+			end
+			unless template
+				fileName = 'views/'+name.join('/')+'.erb'
+				if File.exists? fileName
+					require 'erb'
+					template = ERB.new File.read(fileName)
+				else
+					fileName = 'views/'+name.join('/')+'.haml'
+					return unless File.exists? fileName
+					require 'haml'
+					template = Haml::Engine.new File.read(fileName), ugly: true, remove_whitespace: true
+				end
+				memory[:views, name] = template if production?
+				puts "Template #{name * '/'} initialized."
+			end
+
+			case template.class.to_s
+			when 'ERB'
+				template.result binding
+			when 'Haml::Engine'
+				template.render binding
+			end
+		end
+
+		def method_missing(name, *args)
+			if @plugins && @plugins[name]
+				@plugins[name]
+			elsif parent
+				parent.__send__ name, *args
+			else
+				@plugins[name] = loadPlugin(name) || super
+			end
+		end
+
+		def httpGet(url)
+			require 'net/http'
+			Net::HTTP.get_response(URI.parse url).body
+		end
+
+		def jsonParse(resource)
+			JSON.parse resource, symbolize_names: true
+		end
+	end
+end

data/lib/rubko/controller.rb

@@ -0,0 +1,17 @@
+require 'rubko/base'
+
+class Rubko::Controller
+	include Rubko::Base
+
+	def index
+		'It works. Please create the index() method.'
+	end
+
+	def other(name, *args)
+		loadController('error404').other name, args
+	end
+
+	def compressible?
+		env['HTTP_ACCEPT_ENCODING'].to_s.split(',').map(&:strip).include? 'gzip'
+	end
+end

data/lib/rubko/model.rb

@@ -0,0 +1,5 @@
+require 'rubko/base'
+
+class Rubko::Model
+	include Rubko::Base
+end

data/lib/rubko/plugin.rb

@@ -0,0 +1,7 @@
+require 'rubko/base'
+
+class Rubko::Plugin
+	include Rubko::Base
+
+	def config; end
+end

data/lib/rubko/plugins/cookie.rb

@@ -0,0 +1,45 @@
+class CookiePlugin < Rubko::Plugin
+	def init
+		@domain = nil
+		@path = url.base
+		@httpOnly = true
+		@secure = false
+
+		@maxAge = 30*24*60*60
+		@expires = nil
+		config
+	end
+
+	attr_accessor :domain, :path, :httpOnly, :secure, :maxAge, :expires
+
+	def cookies
+		return @cookies if @cookies
+		return @cookies = {} unless env['HTTP_COOKIE']
+
+		@cookies = Rack::Utils.parse_query(env['HTTP_COOKIE'], ';,').
+		inject({}) { |h, (k,v)|
+			h.tap { |x|
+				x[k.to_sym] = (Array === v) ? v.first : v
+			}
+		}
+	end
+	private :cookies
+
+	def ip
+		Rack::Request.new(env).ip.encode 'UTF-8'
+	end
+
+	def [](key = nil)
+		key.nil? ? cookies : cookies[key]
+	end
+
+	def []=(key, val)
+		if val.nil?
+			Rack::Utils.delete_cookie_header! headers, key, domain: domain, path: path
+		else
+			Rack::Utils.set_cookie_header! headers, key, value: val, domain: domain, path: path,
+			httponly: httpOnly, secure: secure, max_age: maxAge.to_s, expires: expires
+		end
+		val
+	end
+end