knjrbfw 0.0.3

data/lib/knj/erb/include.rb

@@ -0,0 +1,248 @@
+class ERuby
+	def self.load_settings
+		@settings_loaded = true
+		@inseq_cache = false
+		@inseq_rbc = false
+		@java_compile = false
+		
+		if RUBY_PLATFORM == "java"
+			@java_compile = true
+			@java_factory = javax.script.ScriptEngineManager.new
+			@java_engine = @java_factory.getEngineByName("jruby")
+			@eruby_java_cache = {}
+		elsif RUBY_VERSION.slice(0..2) == "1.9" and RubyVM::InstructionSequence.respond_to?(:compile_file)
+			@eruby_rbyte = {}
+			@inseq_cache = true
+			
+			if RubyVM::InstructionSequence.respond_to?(:load)
+				@inseq_rbc = true
+			end
+		end
+		
+		@inseq_rbc = false #this is not possible yet in Ruby... maybe in 1.9.3?
+	end
+	
+	def self.import(filename)
+		ERuby.load_settings if !@settings_loaded
+		
+		filename = File.expand_path(filename)
+		pwd = Dir.pwd
+		Dir.chdir(File.dirname(filename))
+		
+		fpath = "#{KnjEruby.filepath}/cache/#{filename.gsub("/", "_").gsub(".", "_")}"
+		pi = Knj::Php.pathinfo(filename)
+		cachename = fpath + ".cache"
+		
+		filetime = File.mtime(filename)
+		cacheexists = File.exists?(cachename)
+		cachetime = File.mtime(cachename) if File.exists?(cachename)
+		
+		if !cacheexists or filetime > cachetime
+			KnjEruby.load_file(File.basename(filename), {:cachename => cachename})
+			cachetime = File.mtime(cachename)
+			reload_cache = true
+		end
+		
+		if @java_compile
+			if !@eruby_java_cache[cachename] or reload_cache
+				#@eruby_java_cache[cachename] = @java_engine.compile(File.read(cachename))
+				@eruby_java_cache[cachename] = File.read(cachename)
+			end
+			
+			#@eruby_java_cache[cachename].eval
+			eval(@eruby_java_cache[cachename])
+		elsif @inseq_cache
+			if @inseq_rbc
+				bytepath = pi["dirname"] + "/" + pi["basename"] + ".rbc"
+				byteexists = File.exists?(bytepath)
+				bytetime = File.mtime(bytepath) if File.exists?(bytepath)
+				
+				if !File.exists?(bytepath) or cachetime > bytetime
+					res = RubyVM::InstructionSequence.compile_file(filename)
+					data = Marshal.dump(res.to_a)
+					File.open(bytepath, "w+") do |fp|
+						fp.write(data)
+					end
+				end
+			end
+			
+			if @inseq_rbc
+				res = Marshal.load(File.read(bytepath))
+				RubyVM::InstructionSequence.load(res).eval
+			else
+				if !@eruby_rbyte[cachename] or reload_cache
+					@eruby_rbyte[cachename] = RubyVM::InstructionSequence.new(File.read(cachename))
+					#@eruby_rbyte[cachename] = RubyVM::InstructionSequence.compile_file(cachename)
+					@eruby_rbyte[cachename].eval
+				else
+					_buf = ""
+					@eruby_rbyte[cachename].eval
+					if _buf
+						print _buf
+					end
+				end
+			end
+		else
+			eruby = KnjEruby.load_file(File.basename(filename), {:cachename => cachename})
+			print eruby.evaluate
+		end
+		
+		Dir.chdir(pwd)
+	end
+end
+
+class KnjEruby < Erubis::Eruby
+	include Erubis::StdoutEnhancer
+	
+	@headers = [
+		["Content-Type", "text/html; charset=utf-8"]
+	]
+	@filepath = File.dirname(Knj::Os::realpath(__FILE__))
+	@connects = {}
+	
+	def self.fcgi=(newvalue); @fcgi = newvalue; end
+	def self.fcgi; return @fcgi; end
+	def self.connects; return @connects; end
+	def self.headers; return @headers; end
+	
+	def self.print_headers(args = {})
+		header_str = ""
+		
+		@headers.each do |header|
+			header_str += "#{header[0]}: #{header[1]}\n"
+		end
+		
+		header_str += "\n"
+		self.reset_headers if @fcgi
+		return header_str
+	end
+	
+	def self.has_status_header?
+		@headers.each do |header|
+			if header[0] == "Status"
+				return true
+			end
+		end
+		
+		return false
+	end
+	
+	def self.reset_connects
+		@connects = {}
+	end
+	
+	def self.reset_headers
+		@headers = [
+			["Content-Type", "text/html; charset=utf-8"]
+		]
+	end
+	
+	def self.header(key, value)
+		@headers << [key, value]
+	end
+	
+	def self.filepath
+		return @filepath
+	end
+	
+	def self.connect(signal, &block)
+		@connects[signal] = [] if !@connects[signal]
+		@connects[signal] << block
+	end
+	
+	def self.printcont(tmp_out, args = {})
+		if @fcgi
+			@fcgi.print self.print_headers
+			tmp_out.rewind
+			@fcgi.print tmp_out.read.to_s
+		else
+			if args[:io] and !args[:custom_io]
+				old_out = $stdout
+				$stdout = args[:io]
+			elsif !args[:custom_io]
+				$stdout = STDOUT
+			end
+			
+			if !args[:custom_io]
+				print self.print_headers if !args.has_key?(:with_headers) or args[:with_headers]
+				tmp_out.rewind
+				print tmp_out.read
+			end
+		end
+	end
+	
+	def self.load_return(filename, args = {})
+		if !args[:io]
+			retio = StringIO.new
+			args[:io] = retio
+		end
+		
+		@args = args
+		KnjEruby.load(filename, args)
+		
+		if !args[:custom_io]
+			retio.rewind
+			return retio.read
+		end
+	end
+	
+	def self.load(filename, args = {})
+		begin
+			if !args[:custom_io]
+				tmp_out = StringIO.new
+				$stdout = tmp_out
+			end
+			
+			ERuby.import(filename)
+			
+			if KnjEruby.connects["exit"]
+				KnjEruby.connects["exit"].each do |block|
+					block.call
+				end
+			end
+			
+			KnjEruby.printcont(tmp_out, args)
+		rescue SystemExit => e
+			KnjEruby.printcont(tmp_out, args)
+		rescue Exception => e
+			begin
+				if KnjEruby.connects["error"]
+					KnjEruby.connects["error"].each do |block|
+						block.call(e)
+					end
+				end
+			rescue SystemExit => e
+				exit
+			rescue Exception => e
+				#An error occurred while trying to run the on-error-block - show this as an normal error.
+				print "\n\n<pre>\n\n"
+				print "<b>#{CGI.escapeHTML(e.class.name)}: #{CGI.escapeHTML(e.message)}</b>\n\n"
+				
+				#Lets hide all the stuff in what is not the users files to make it easier to debug.
+				bt = e.backtrace
+				#to = bt.length - 9
+				#bt = bt[0..to]
+				
+				bt.each do |line|
+					print CGI.escapeHTML(line) + "\n"
+				end
+				
+				print "</pre>"
+			end
+			
+			print "\n\n<pre>\n\n"
+			print "<b>#{CGI.escapeHTML(e.class.name)}: #{CGI.escapeHTML(e.message)}</b>\n\n"
+			
+			#Lets hide all the stuff in what is not the users files to make it easier to debug.
+			bt = e.backtrace
+			to = bt.length - 9
+			bt = bt[0..to]
+			
+			bt.each do |line|
+				print CGI.escapeHTML(line) + "\n"
+			end
+			
+			KnjEruby.printcont(tmp_out, args)
+		end
+	end
+end

data/lib/knj/errors.rb

@@ -0,0 +1,19 @@
+module Knj::Errors
+	class Notice < StandardError; end
+	class NotFound < StandardError; end
+	class InvalidData < StandardError; end
+	class Retry < StandardError; end
+	class NoAccess < StandardError; end
+	
+	def self.error_str(err, args = {})
+		if args[:html]
+			str += "<b>#{err.class.name}</b>: #{err.message}<br />\n<br />\n"
+			str += err.backtrace.join("<br />\n")
+		else
+			str = "#{err.class.name}: #{err.message}\n\n"
+			str += err.backtrace.join("\n")
+		end
+		
+		return str
+	end
+end

data/lib/knj/eruby.rb

@@ -0,0 +1,224 @@
+class Knj::Eruby
+  attr_reader :fcgi
+  attr_reader :connects, :headers
+  
+  def initialize(args = {})
+    @args = args
+    
+    require "tmpdir"
+    @tmpdir = "#{Dir.tmpdir}/knj_erb"
+    Dir.mkdir(@tmpdir) if !File.exists?(@tmpdir)
+    
+    
+    #This argument can be used if a shared cache should be used to speed up performance.
+    if @args[:cache_hash]
+      @cache = @args[:cache_hash]
+    else
+      @cache = {}
+    end
+    
+    if RUBY_PLATFORM == "java"
+      #@cache_mode = :code_eval
+      @cache_mode = :compile_knj
+    elsif RUBY_VERSION.slice(0..2) == "1.9" and RubyVM::InstructionSequence.respond_to?(:compile_file)
+      @cache_mode = :inseq
+      #@cache_mode = :compile_knj
+    end
+    
+    if @cache_mode == :compile_knj
+      @compiler = Knj::Compiler.new(:cache_hash => @cache)
+    end
+    
+    self.reset_headers
+    self.reset_connects
+  end
+  
+  def import(filename)
+    Dir.mkdir(@tmpdir) if !File.exists?(@tmpdir)
+    filename = File.expand_path(filename)
+    raise "File does not exist: #{filename}" if !File.exists?(filename)
+    filetime = File.mtime(filename)
+    cachename = "#{@tmpdir}/#{filename.gsub("/", "_").gsub(".", "_")}.cache"
+    cachetime = File.mtime(cachename) if File.exists?(cachename)
+    
+    begin
+      if !File.exists?(cachename) or filetime > cachetime
+        Knj::Eruby::Handler.load_file(filename, {:cachename => cachename})
+        cachetime = File.mtime(cachename)
+        reload_cache = true
+      elsif !@cache.has_key?(cachename)
+        reload_cache = true
+      end
+      
+      case @cache_mode
+        when :compile_knj
+          @compiler.eval_file(:filepath => cachename, :fileident => filename)
+        when :code_eval
+          @cache[cachename] = File.read(cachename) if reload_cache
+          eval(@cache[cachename], nil, filename)
+        when :inseq
+          if reload_cache or @cache[cachename][:time] < cachetime
+            @cache[cachename] = {
+              :inseq => RubyVM::InstructionSequence.compile(File.read(cachename), filename, nil, 1),
+              :time => Time.new
+            }
+          end
+          
+          @cache[cachename][:inseq].eval
+        else
+          loaded_content = Knj::Eruby::Handler.load_file(filename, {:cachename => cachename})
+          print loaded_content.evaluate
+      end
+    rescue SystemExit
+      #do nothing.
+    rescue Exception => e
+      self.handle_error(e)
+    end
+  end
+  
+  def destroy
+    @connects.clear if @connects.is_a?(Hash)
+    @headers.clear if @headers.is_a?(Array)
+    
+    @cache.clear if @cache.is_a?(Hash) and @args and !@args.has_key?(:cache_hash)
+    @args.clear if @args.is_a?(Hash)
+    @args = nil
+    @cache = nil
+    @connects = nil
+    @headers = nil
+  end
+  
+  def print_headers(args = {})
+    header_str = ""
+    
+    @headers.each do |header|
+      header_str += "#{header[0]}: #{header[1]}\n"
+    end
+    
+    header_str += "\n"
+    self.reset_headers if @fcgi
+    return header_str
+  end
+  
+  def has_status_header?
+    @headers.each do |header|
+      return true if header[0] == "Status"
+    end
+    
+    return false
+  end
+  
+  def reset_connects
+    @connects = {}
+  end
+  
+  def reset_headers
+    @headers = []
+  end
+  
+  def header(key, value)
+    @headers << [key, value]
+  end
+  
+  def connect(signal, &block)
+    @connects[signal] = [] if !@connects.has_key?(signal)
+    @connects[signal] << block
+  end
+  
+  def printcont(tmp_out, args = {})
+    if @fcgi
+      @fcgi.print self.print_headers
+      tmp_out.rewind
+      @fcgi.print tmp_out.read.to_s
+    else
+      if args[:io] and !args[:custom_io]
+        old_out = $stdout
+        $stdout = args[:io]
+      elsif !args[:custom_io]
+        $stdout = STDOUT
+      end
+      
+      if !args[:custom_io]
+        print self.print_headers if !args.has_key?(:with_headers) or args[:with_headers]
+        tmp_out.rewind
+        print tmp_out.read
+      end
+    end
+  end
+  
+  def load_return(filename, args = {})
+    if !args[:io]
+      retio = StringIO.new
+      args[:io] = retio
+    end
+    
+    self.load_filename(filename, args)
+    
+    if !args[:custom_io]
+      retio.rewind
+      return retio.read
+    end
+  end
+  
+  def load_filename(filename, args = {})
+    begin
+      if !args[:custom_io]
+        tmp_out = StringIO.new
+        $stdout = tmp_out
+      end
+      
+      self.import(filename)
+      
+      if @connects["exit"]
+        @connects["exit"].each do |block|
+          block.call
+        end
+      end
+      
+      self.printcont(tmp_out, args)
+    rescue SystemExit => e
+      self.printcont(tmp_out, args)
+    rescue Exception => e
+      self.handle_error(e)
+      self.printcont(tmp_out, args)
+    end
+  end
+  
+  def handle_error(e)
+    begin
+      if @connects and @connects.has_key?("error")
+        @connects["error"].each do |block|
+          block.call(e)
+        end
+      end
+    rescue SystemExit => e
+      exit
+    rescue Exception => e
+      #An error occurred while trying to run the on-error-block - show this as an normal error.
+      print "\n\n<pre>\n\n"
+      print "<b>#{CGI.escapeHTML(e.class.name)}: #{CGI.escapeHTML(e.message)}</b>\n\n"
+      
+      #Lets hide all the stuff in what is not the users files to make it easier to debug.
+      bt = e.backtrace
+      #to = bt.length - 9
+      #bt = bt[0..to]
+      
+      bt.each do |line|
+        print CGI.escapeHTML(line) + "\n"
+      end
+      
+      print "</pre>"
+    end
+    
+    print "\n\n<pre>\n\n"
+    print "<b>#{CGI.escapeHTML(e.class.name)}: #{CGI.escapeHTML(e.message)}</b>\n\n"
+    
+    e.backtrace.each do |line|
+      print CGI.escapeHTML(line) + "\n"
+    end
+  end
+end
+
+class Knj::Eruby::Handler < Erubis::Eruby
+  include Erubis::StdoutEnhancer
+end

data/lib/knj/event_filemod.rb

@@ -0,0 +1,53 @@
+class Knj::Event_filemod
+	attr_reader :args
+	
+	def initialize(args, &block)
+		@args = args
+		@run = true
+		
+		@args[:wait] = 1 if !@args.has_key?(:wait)
+		
+		@mtimes = {}
+		args[:paths].each do |path|
+			@mtimes[path] = File.mtime(path)
+		end
+		
+		Knj::Thread.new do
+			while @run do
+				break if !@args or !@args[:paths] or @args[:paths].empty?
+				
+				@args[:paths].clone.each do |path|
+					changed = false
+					
+					if @mtimes and !@mtimes.has_key?(path) and @mtimes.is_a?(Hash)
+						@mtimes[path] = File.mtime(path)
+					end
+					
+					begin
+						newdate = File.mtime(path)
+					rescue Errno::ENOENT
+						#file does not exist.
+						changed = true
+					end
+					
+					if !changed and newdate and @mtimes and newdate > @mtimes[path]
+						changed = true
+					end
+					
+					if changed
+						block.call(self, path)
+						@args[:paths].delete(path) if @args and @args[:break_when_changed]
+					end
+				end
+				
+				sleep @args[:wait] if @args and @run
+			end
+		end
+	end
+	
+	def destroy
+		@mtimes = {}
+		@run = false
+		@args = nil
+	end
+end

data/lib/knj/event_handler.rb

@@ -0,0 +1,69 @@
+class Knj::Event_handler
+	def initialize(args = {})
+		@args = args
+		@events = {}
+	end
+	
+	def add_event(event)
+		raise "No name given." if !event[:name]
+		
+		@events[event[:name]] = [] if !@events.has_key?(event[:name])
+		@events[event[:name]] = {
+			:event => event,
+			:callbacks => {},
+			:callbacks_count => 0
+		}
+	end
+	
+	def add_events(*events)
+		events.each do |event|
+			self.add_event(:name => event)
+		end
+	end
+	
+	def connect(name, &block)
+		raise "No such event." if !@events.has_key?(name)
+		
+		event = @events[name]
+		
+		if event[:event].has_key?(:connections_max) and event[:callbacks].length >= event[:event][:connections_max].to_i
+			raise "The event '#{name}' has reached its maximum connections of '#{event[:event][:connections_max]}'"
+		end
+		
+		event[:callbacks_count] += 1
+		count = event[:callbacks_count]
+		event[:callbacks][count] = {
+			:block => block
+		}
+		
+		return count
+	end
+	
+	def disconnect(name, callback_id)
+		raise "No such event: '#{name}'." if !@events.has_key?(name)
+		raise "No such connection: '#{name}' --> '#{callback_id}'" if !@events[name].has_key?(callback_id)
+		@events[name][callback_id].clear
+		@events[name].delete(callback_id)
+	end
+	
+	def count_connects(name)
+		raise "No such event." if !@events.has_key?(name)
+		return @events[name][:callbacks].length
+	end
+	
+	def connected?(name)
+		raise "No such event." if !@events.has_key?(name)
+		return !@events[name][:callbacks].empty?
+	end
+	
+	def call(name, *args)
+		raise "No such event: '#{name}'." if !@events.has_key?(name)
+		event = @events[name]
+		ret = nil
+		event[:callbacks].clone.each do |callback_id, callback_hash|
+			ret = callback_hash[:block].call(name, *args)
+		end
+		
+		return ret
+	end
+end

data/lib/knj/exchangerates.rb

@@ -0,0 +1,39 @@
+class Knj::Exchangerates
+	attr_reader :rates
+	
+	def initialize(args = {})
+		@rates = {}
+	end
+	
+	def base=(data)
+		@base = data[:locale].to_s
+		self.add_rate(data)
+	end
+	
+	def add_rate(data)
+		if !data[:locale] or data[:locale].to_s.length <= 0
+			raise "Invalid locale given."
+		end
+		
+		@rates[data[:locale].to_s] = data
+	end
+	
+	def value(locale, floatval)
+		floatval = floatval.to_f
+		locale = locale.to_s
+		
+		raise "No such locale: '#{locale}' in '#{@rates.keys.join(",")}'." if !@rates.has_key?(locale)
+		
+		base_rate = @rates[@base][:rate].to_f
+		cur_rate = @rates[locale][:rate].to_f
+		
+		if base_rate == cur_rate
+			return floatval 
+		elsif cur_rate < base_rate
+			diff = 1 + (base_rate - cur_rate)
+			return floatval * diff
+		else
+			return floatval / cur_rate
+		end
+	end
+end

data/lib/knj/ext/webrick.rb

@@ -0,0 +1,31 @@
+class WEBrick::HTTPRequest
+	#Function to clean up memory - knj.
+	def destroy
+		arr_hash = [@cookies, @accept, @accept_charset, @accept_encoding, @accept_language, @attributes]
+		arr_hash.each do |val|
+			if val and (val.is_a?(Array) or val.is_a?(Hash))
+				val.clear
+			end
+		end
+		
+		@config = nil
+		@cookies = nil
+		@accept = nil
+	end
+end
+
+class WEBrick::HTTPResponse
+	#Function to clean up memory - knj.
+	def destroy
+		arr_hash = [@cookies, @header]
+		arr_hash.each do |val|
+			if val and (val.is_a?(Array) or val.is_a?(Hash))
+				val.clear
+			end
+		end
+		
+		@config = nil
+		@header = nil
+		@cookies = nil
+	end
+end

data/lib/knj/filesystem.rb

@@ -0,0 +1,8 @@
+class Knj::Filesystem
+	def self.copy(args)
+		FileUtils.rm(args[:to]) if args[:replace] and File.exists?(args[:to])
+		FileUtils.cp(args[:from], args[:to])
+		mod = File.lstat(args[:from]).mode & 0777
+		File.chmod(mod, args[:to])
+	end
+end

data/lib/knj/fs/drivers/filesystem.rb

@@ -0,0 +1,14 @@
+class Knj::Fs::Filesystem
+	def self.args
+		return [
+			{
+				"title" => "Path",
+				"name" => "texpath"
+			}
+		]
+	end
+	
+	def initialize(args)
+		@args = args
+	end
+end