knjrbfw 0.0.3

data/lib/knj/autoload/tmail.rb

@@ -0,0 +1,6 @@
+begin
+	require "tmail"
+rescue LoadError
+	require "rubygems"
+	require "tmail"
+end

data/lib/knj/autoload/twitter.rb

@@ -0,0 +1,2 @@
+require "rubygems"
+require "twitter"

data/lib/knj/autoload/xmlsimple.rb

@@ -0,0 +1,6 @@
+begin
+	require "xmlsimple"
+rescue LoadError
+	require "rubygems"
+	require "xmlsimple"
+end

data/lib/knj/autoload/zip.rb

@@ -0,0 +1,6 @@
+begin
+	require "zip/zip"
+rescue LoadError
+	require "rubygems"
+	require "zip"
+end

data/lib/knj/autoload.rb

@@ -0,0 +1,136 @@
+$knjpath = File.dirname(__FILE__) + "/" if !$knjpath
+require "#{$knjpath}/knj.rb"
+
+module Knj
+	autoload :ArrayExt, $knjpath + "arrayext.rb"
+	autoload :Datestamp, $knjpath + "datestamp.rb"
+	autoload :Datet, $knjpath + "datet.rb"
+	autoload :Compiler, $knjpath + "compiler.rb"
+	autoload :Cpufreq, $knjpath + "cpufreq.rb"
+	autoload :Datarow, $knjpath + "datarow.rb"
+	autoload :Db, $knjpath + "knjdb/libknjdb.rb"
+	autoload :Db_row, $knjpath + "knjdb/libknjdb_row.rb"
+	autoload :Degulesider, $knjpath + "degulesider.rb"
+	autoload :Errors, $knjpath + "errors.rb"
+	autoload :Eruby, $knjpath + "eruby.rb"
+	autoload :Event_filemod, $knjpath + "event_filemod.rb"
+	autoload :Event_handler, $knjpath + "event_handler.rb"
+	autoload :Exchangerates, $knjpath + "exchangerates.rb"
+	autoload :Fs, $knjpath + "fs/fs.rb"
+	autoload :Filesystem, $knjpath + "filesystem.rb"
+	autoload :Gettext_threadded, $knjpath + "gettext_threadded.rb"
+	autoload :Hash_methods, $knjpath + "hash_methods.rb"
+	autoload :Ip2location, $knjpath + "ip2location.rb"
+	autoload :Jruby_compiler, $knjpath + "jruby_compiler.rb"
+	autoload :Locales, $knjpath + "locales.rb"
+	autoload :Objects, $knjpath + "objects.rb"
+	autoload :Opts, $knjpath + "opts.rb"
+	autoload :Mail, $knjpath + "mail.rb"
+	autoload :Mailobj, $knjpath + "mailobj.rb"
+	autoload :Mount, $knjpath + "mount.rb"
+	autoload :Mplayer, $knjpath + "mplayer.rb"
+	autoload :Notify, $knjpath + "notify.rb"
+	autoload :Nvidia_settings, $knjpath + "nvidia_settings.rb"
+	autoload :Web, $knjpath + "web.rb"
+	autoload :Google_sitemap, $knjpath + "google_sitemap.rb"
+	autoload :Http, $knjpath + "http.rb"
+	autoload :Sms, $knjpath + "sms.rb"
+	autoload :Os, $knjpath + "os.rb"
+	autoload :Gtk2, $knjpath + "gtk2.rb"
+	autoload :Php, $knjpath + "php.rb"
+	autoload :Php_parser, $knjpath + "php_parser/php_parser.rb"
+	autoload :Power_manager, $knjpath + "power_manager.rb"
+	autoload :Rand, $knjpath + "rand.rb"
+	autoload :Retry, $knjpath + "retry.rb"
+	autoload :RSVGBIN, $knjpath + "rsvgbin.rb"
+	autoload :Strings, $knjpath + "strings.rb"
+	autoload :SSHRobot, $knjpath + "sshrobot/sshrobot.rb"
+	autoload :Sysuser, $knjpath + "sysuser.rb"
+	autoload :Thread, $knjpath + "thread.rb"
+	autoload :Thread2, $knjpath + "thread2.rb"
+	autoload :Threadpool, $knjpath + "threadpool.rb"
+	autoload :Threadhandler, $knjpath + "threadhandler.rb"
+	autoload :Translations, $knjpath + "translations.rb"
+	autoload :X11VNC, $knjpath + "x11vnc.rb"
+	autoload :Unix_proc, $knjpath + "unix_proc.rb"
+	autoload :YouTube, $knjpath + "youtube.rb"
+	autoload :Win, $knjpath + "win.rb"
+end
+
+#ruby objects.
+autoload :Base64, "base64"
+autoload :CGI, "cgi"
+autoload :CSV, "csv"
+autoload :Date, "date"
+autoload :Digest, "digest"
+autoload :Erubis, $knjpath + "autoload/erubis"
+autoload :EM, "eventmachine"
+autoload :FCGI, "fcgi"
+autoload :FileUtils, "fileutils"
+autoload :IPAddr, "ipaddr"
+autoload :JSON, $knjpath + "autoload/json_autoload"
+autoload :GD2, $knjpath + "autoload/gd2"
+autoload :Magick, $knjpath + "autoload/magick"
+autoload :Mutex, "thread"
+autoload :Mysql, $knjpath + "autoload/mysql"
+autoload :Open3, "open3"
+autoload :OpenSSL, "openssl"
+autoload :OptionParser, "optparse"
+autoload :ParseDate, $knjpath + "autoload/backups/parsedate.rb"
+autoload :Pathname, "pathname"
+autoload :Ping, $knjpath + "autoload/ping"
+autoload :REXML, $knjpath + "autoload/rexml"
+autoload :StringIO, "stringio"
+autoload :SOAP, $knjpath + "autoload/soap"
+autoload :SQLite3, $knjpath + "autoload/sqlite3"
+autoload :Timeout, "timeout"
+autoload :TCPSocket, "socket"
+autoload :TCPServer, "socket"
+autoload :URI, "uri"
+autoload :Win32, "win32/registry"
+autoload :WIN32OLE, "win32ole"
+autoload :WEBrick, "webrick"
+autoload :XmlSimple, $knjpath + "autoload/xmlsimple"
+autoload :Zip, $knjpath + "autoload/zip.rb"
+autoload :Zlib, "zlib"
+
+if RUBY_PLATFORM == "java"
+	autoload :GetText, $knjpath + "autoload/gettext"
+	autoload :Gtk, "knj/jruby-gtk2/gtk2"
+	autoload :Gdk, "knj/jruby-gtk2/gtk2"
+	autoload :GladeXML, "knj/jruby-gtk2/gtk2"
+elsif RUBY_PLATFORM.index("mswin32") != nil
+	autoload :GetText, "knj/gettext_fallback"
+	autoload :Gtk, "knj/ironruby-gtk2/gtk2"
+	autoload :Gdk, "knj/ironruby-gtk2/gtk2"
+	autoload :GladeXML, "knj/ironruby-gtk2/gtk2"
+else
+	autoload :GetText, $knjpath + "autoload/gettext"
+	autoload :Gtk, $knjpath + "autoload/gtk2"
+	autoload :GladeXML, "libglade2"
+	
+	#this bugs?
+	#autoload :Gdk, $knjpath + "autoload/gtk2"
+end
+
+module Net
+	autoload :IMAP, "net/imap"
+	autoload :SMTP, "net/smtp"
+	autoload :HTTP, "net/http"
+	autoload :POP3, "net/pop"
+	autoload :POP, "net/pop"
+	autoload :SSH, "net/ssh"
+end
+
+module TMail
+	autoload :Mail, $knjpath + "autoload/tmail"
+end
+
+#facets
+autoload :Dictionary, $knjpath + "autoload/facets_dictionary"
+
+#gems
+autoload :Twitter, $knjpath + "autoload/twitter"
+autoload :Facebooker, $knjpath + "autoload/facebooker"
+autoload :Cinch, $knjpath + "autoload/cinch"
+autoload :ActiveSupport, $knjpath + "autoload/activesupport"

data/lib/knj/compiler.rb

@@ -0,0 +1,53 @@
+#This class can compile Ruby-files into Ruby-methods on a special class and then call these methods to run the code from the file. The theory is that this can be faster...
+class Knj::Compiler
+	def initialize(args = {})
+		@args = args
+		@mutex = Mutex.new
+		
+		if @args[:cache_hash]
+      @compiled = @args[:cache_hash]
+    else
+      @compiled = {}
+    end
+	end
+	
+	#Compiles file into cache as a method.
+	def compile_file(args)
+		raise "File does not exist." if !File.exist?(args[:filepath])
+		filepath = Knj::Php.realpath(args[:filepath])
+		defname = def_name_for_file_path(filepath)
+		
+		evalcont = "class Knj::Compiler::Container; def self.#{defname};"
+		evalcont += File.read(filepath)
+		evalcont += ";end;end"
+		
+		eval(evalcont, nil, args[:fileident])
+    @compiled[filepath] = Time.new
+	end
+	
+	#Returns the method name for a filepath.
+	def def_name_for_file_path(filepath)
+		return filepath.gsub("/", "_").gsub(".", "_")
+	end
+	
+	#Compile and evaluate a file - it will be cached.
+	def eval_file(args)
+    filepath = Knj::Php.realpath(args[:filepath])
+    
+		#Compile if it hasnt been compiled yet.
+		@mutex.synchronize do
+      compile_file(args) if !@compiled.has_key?(filepath)
+      
+      #Compile if modified time has been changed.
+      mtime = File.mtime(filepath)
+      compile_file(args) if @compiled[filepath] < mtime
+    end
+    
+		#Call the compiled function.
+		defname = def_name_for_file_path(filepath)
+		Knj::Compiler::Container.send(defname)
+	end
+	
+	#This class holds the compiled methods.
+	class Knj::Compiler::Container; end
+end

data/lib/knj/cpufreq.rb

@@ -0,0 +1,40 @@
+#This class can manipulate the CPU behavior through "cpufreq".
+class Knj::Cpufreq
+	attr_reader :data
+	
+	def initialize(data)
+		@data = data
+		@allowed_govs = ["performance", "ondemand", "powersafe", "conservative"]
+	end
+	
+	def self.list
+		ret = []
+		cont = File.read("/proc/cpuinfo")
+		
+		matches = cont.scan(/processor\s*:[\s\S]+?\n\n/)
+		raise "Could not detect CPUs" if !matches or matches.empty?
+		
+		matches.each do |cpucont|
+			cpu_features = {}
+			features = cpucont.scan(/(.+)\s*:\s*(.+)\s*/)
+			
+			features.each do |data|
+				cpu_features[data[0].strip] = data[1].strip
+			end
+			
+			ret << Knj::Cpufreq.new(cpu_features)
+		end
+		
+		return ret
+	end
+	
+	def governor=(newgov)
+		raise "Governor not found." if @allowed_govs.index(newgov) == nil
+		
+		cmd = "cpufreq-set --cpu #{@data["processor"]} --governor #{newgov}"
+		res = Knj::Os::shellcmd(cmd)
+		if res.index("Error setting new values") != nil
+			raise res.strip
+		end
+	end
+end

data/lib/knj/datarow.rb

@@ -0,0 +1,256 @@
+class Knj::Datarow
+	attr_reader :data, :ob
+	
+	def self.required_data
+    @required_data = [] if !@required_data
+    return @required_data
+  end
+  
+  def self.depending_data
+    @depending_data = [] if !@depending_data
+    return @depending_data
+  end
+	
+	def is_knj?; return true; end
+	
+	def self.is_nullstamp?(stamp)
+    return true if !stamp or stamp == "0000-00-00 00:00:00" or stamp == "0000-00-00"
+    return false
+	end
+	
+	def self.has_many(arr)
+    arr.each do |val|
+      if val.is_a?(Array)
+        classname, colname, methodname = *val
+      elsif val.is_a?(Hash)
+        classname = val[:class]
+        colname = val[:col]
+        methodname = val[:method]
+        
+        if val[:depends]
+          depending_data << {
+            :colname => colname,
+            :classname => classname
+          }
+        end
+      else
+        raise "Unknown argument: '#{val.class.name}'."
+      end
+      
+      if !methodname
+        methodname = "#{classname.to_s.downcase}s".to_sym
+      end
+      
+      define_method(methodname) do |*args|
+        merge_args = args[0] if args and args[0]
+        merge_args = {} if !merge_args
+        return ob.list(classname, {colname.to_s => self.id}.merge(merge_args))
+      end
+    end
+	end
+	
+	def self.has_one(arr)
+    arr.each do |val|
+      methodname = nil
+      colname = nil
+      classname = nil
+      
+      if val.is_a?(Symbol)
+        classname = val
+        methodname = val.to_s.downcase.to_sym
+        colname = "#{val.to_s.downcase}_id".to_sym
+      elsif val.is_a?(Array)
+        classname, colname, methodname = *val
+      elsif val.is_a?(Hash)
+        classname, colname, methodname = val[:class], val[:col], val[:method]
+        
+        if val[:required]
+          colname = "#{classname.to_s.downcase}_id".to_sym if !colname
+          required_data << {
+            :col => colname,
+            :class => classname
+          }
+        end
+      else
+        raise "Unknown argument-type: '#{arr.class.name}'."
+      end
+      
+      methodname = classname.to_s.downcase if !methodname
+      colname = "#{classname.to_s.downcase}_id".to_sym if !colname
+      
+      define_method(methodname) do
+        return ob.get_try(self, colname, classname)
+      end
+      
+      methodname_html = "#{methodname.to_s}_html".to_sym
+      define_method(methodname_html) do |*args|
+        obj = self.send(methodname)
+        return ob.events.call(:no_html, classname) if !obj
+        
+        raise "Class '#{classname}' does not have a 'html'-method." if !obj.respond_to?(:html)
+        return obj.html(*args)
+      end
+    end
+	end
+	
+	def self.table
+		return self.name.split("::").last
+	end
+	
+	def self.columns(d)
+		columns_load(d) if !@columns
+		return @columns
+	end
+	
+	def self.columns_load(d)
+		return nil if @columns
+		@columns = d.db.tables[table].columns
+	end
+	
+	def self.columns_sqlhelper_args
+		return @columns_sqlhelper_args
+	end
+	
+	def self.list_helper(d)
+		sleep 0.1 while @columns_sqlhelper_args_working
+		
+		if !@columns_sqlhelper_args
+			begin
+				@columns_sqlhelper_args_working = true
+				cols = self.columns(d)
+				
+				sqlhelper_args = {
+					:db => d.db,
+					:table => table,
+					:cols_bools => [],
+					:cols_date => [],
+					:cols_dbrows => [],
+					:cols_num => [],
+					:cols_str => []
+				}
+				cols.each do |col_name, col_obj|
+					col_type = col_obj.type
+					col_type = "int" if col_type == "bigint" or col_type == "tinyint" or col_type == "mediumint" or col_type == "smallint"
+					
+					if col_type == "enum" and col_obj.maxlength == "'0','1'"
+						sqlhelper_args[:cols_bools] << col_name
+					elsif col_type == "int" and col_name.slice(-3, 3) == "_id"
+						sqlhelper_args[:cols_dbrows] << col_name
+					elsif col_type == "int" or col_type == "bigint"
+						sqlhelper_args[:cols_num] << col_name
+					elsif col_type == "varchar" or col_type == "text" or col_type == "enum"
+						sqlhelper_args[:cols_str] << col_name
+					elsif col_type == "date" or col_type == "datetime"
+						sqlhelper_args[:cols_date] << col_name
+					end
+				end
+				
+				@columns_sqlhelper_args = sqlhelper_args
+			ensure
+				@columns_sqlhelper_args_working = false
+			end
+		end
+		
+		return d.ob.sqlhelper(d.args, @columns_sqlhelper_args)
+	end
+	
+	def table
+		return self.class.name.split("::").last
+	end
+	
+	def initialize(d)
+		@ob = d.ob
+		raise "No ob given." if !@ob
+		
+		if d.data.is_a?(Hash)
+			@data = d.data
+		elsif d.data
+			@data = {:id => d.data}
+			self.reload
+		else
+			raise Knj::Errors::InvalidData, "Could not figure out the data from '#{d.data.class.name}'."
+		end
+	end
+	
+	def db
+		return @ob.db
+	end
+	
+	def reload
+		data = self.db.single(self.table, {:id => @data[:id]})
+		if !data
+			raise Knj::Errors::NotFound, "Could not find any data for the object with ID: '#{@data[:id]}' in the table '#{self.table}'."
+		end
+		
+		@data = data
+	end
+	
+	def update(newdata)
+		self.db.update(self.table, newdata, {:id => @data[:id]})
+		self.reload
+		
+		if self.ob
+			self.ob.call("object" => self, "signal" => "update")
+		end
+	end
+	
+	def destroy
+		@ob = nil
+		@data = nil
+	end
+	
+	def has_key?(key)
+		return @data.has_key?(key.to_sym)
+	end
+	
+	def [](key)
+		raise "No valid key given." if !key.is_a?(Symbol)
+		raise "No data was loaded on the object? Maybe you are trying to call a deleted object?" if !@data
+		return @data[key] if @data.has_key?(key)
+		raise "No such key: #{key}."
+	end
+	
+	def []=(key, value)
+		self.update(key.to_sym => value)
+		self.reload
+	end
+	
+	def id
+    raise "No data on object." if !@data
+		return @data[:id]
+	end
+	
+	def name
+		if @data.has_key?(:title)
+			return @data[:title]
+		elsif @data.has_key?(:name)
+			return @data[:name]
+		end
+		
+		obj_methods = self.class.instance_methods(false)
+		[:name, :title].each do |method_name|
+			return self.method(method_name).call if obj_methods.index(method_name)
+		end
+		
+		raise "Couldnt figure out the title/name of the object on class #{self.class.name}."
+	end
+	
+	alias :title :name
+	
+	def each(&args)
+		return @data.each(&args)
+	end
+	
+	def method_missing(*args)
+		func_name = args[0].to_s
+		if match = func_name.match(/^(\S+)\?$/) and @data.has_key?(match[1].to_sym)
+			if @data[match[1].to_sym] == "1" or @data[match[1].to_sym] == "yes"
+				return true
+			elsif @data[match[1].to_sym] == "0" or @data[match[1].to_sym] == "no"
+				return false
+			end
+		end
+		
+		raise "No such method: '#{func_name}' on '#{self.class.name}'"
+	end
+end

data/lib/knj/datestamp.rb

@@ -0,0 +1,91 @@
+class Knj::Datestamp
+	def self.in(time = Time.new)
+		if Knj::Php.is_numeric(time)
+			time = Time.at(time.to_i)
+		elsif time.is_a?(String)
+			time = Time.local(*ParseDate.parsedate(time))
+		end
+		
+		return time
+	end
+	
+	def self.dbstr(time = nil)
+		if !time
+			time = Time.new
+		end
+		
+		if Knj::Php.is_numeric(time)
+			time = Time.at(time.to_i)
+		elsif time.is_a?(String)
+			begin
+				time = Time.local(*ParseDate.parsedate(time))
+			rescue => e
+				raise sprintf("Could not parse date: %s", time.to_s)
+			end
+		else
+			raise "Could not figure out given argument: #{time.class.name}"
+		end
+		
+		return "%04d" % time.year.to_s + "-" + "%02d" % time.month.to_s + "-" + "%02d" % time.day.to_s + " " + "%02d" % time.hour.to_s + ":" + "%02d" % time.min.to_s + ":" + "%02d" % time.sec.to_s
+	end
+	
+	def self.from_dbstr(date_string)
+		if Knj::Datestamp.is_nullstamp?(date_string)
+			return 0
+		end
+		
+		return Time.local(*ParseDate.parsedate(date_string))
+	end
+	
+	def self.out(time = nil, args = {})
+		Knj::ArrayExt.hash_sym(args)
+		
+		time = Time.new if !time
+		
+		if Knj::Php.is_numeric(time)
+			time = Time.at(time.to_i)
+		elsif time.is_a?(String)
+			time = Time.at(Knj::Php.strtotime(time))
+		end
+		
+		str = ""
+		
+		if !args.has_key?(:date) or args[:date] == true
+			str += "%02d" % time.day.to_s + "/" + "%02d" % time.month.to_s + " " + "%04d" % time.year.to_s
+		end
+			
+		if !args.has_key?(:time) or args[:time] == true
+			str += " " + "%02d" % time.hour.to_s + ":" + "%02d" % time.min.to_s
+		end
+		
+		return str
+	end
+	
+	def self.in(timestr)
+		if match = timestr.to_s.match(/^(\d+)\/(\d+) (\d+)/)
+			timestr = timestr.gsub(match[0], "")
+			date = match[1]
+			month = match[2]
+			year = match[3]
+		else
+			raise sprintf(_("Wrong format: %s"), timestr)
+		end
+		
+		if match = timestr.match(/\s*(\d+):(\d+)/)
+			timestr = timestr.gsub(match[0], "")
+			hour = match[1]
+			minute = match[2]
+		end
+		
+		datestr = ""
+		datestr = "#{year}-#{month}-#{date}" if date and month and year
+		datestr += " #{hour}:#{minute}" if hour and minute
+		
+		return Knj::Datestamp.from_dbstr(datestr)
+	end
+	
+	def self.is_nullstamp?(datestamp)
+		return true if datestamp.is_a?(String) and datestamp == "0000-00-00 00:00:00"
+		return false
+	end
+end