knjrbfw 0.0.7 → 0.0.8

data/lib/knj/autoload/erubis.rb

@@ -1,3 +1,5 @@
+module Erubis; end #bugfix
+
 begin
 	require "erubis"
 rescue LoadError

data/lib/knj/cmd_gen.rb

@@ -0,0 +1,71 @@
+class Knj::Cmd_gen
+  def self.rsync(args)
+    cmd = ""
+    
+    if args[:bin]
+      cmd += args[:bin]
+    else
+      cmd += "rsync"
+    end
+    
+    cmd += " -az"
+    
+    if args[:verbose]
+      1.upto(args[:verbose]) do
+        cmd += "v"
+      end
+    end
+    
+    if args[:ssh]
+      cmd += " -e ssh"
+      
+      if args[:port]
+        cmd += " --rsh='ssh -p #{args[:port]}'"
+      end
+    end
+    
+    if args[:delete]
+      cmd += " --delete"
+    end
+    
+    if args[:exclude]
+      args[:exclude].each do |dir|
+        cmd += " --exclude \"#{dir}\""
+      end
+    end
+    
+    cmd += " \"#{args[:user]}@#{args[:host]}:#{args[:dir_host]}\" \"#{args[:dir_local]}\""
+    
+    return cmd
+  end
+  
+  def self.tar(args)
+    cmd = ""
+    
+    if args[:bin]
+      cmd += args[:bin]
+    else
+      cmd += "tar"
+    end
+    
+    cmd += " "
+    cmd += "z"if args[:gzip]
+    cmd += "x" if args[:extract]
+    cmd += "f" if args[:file]
+    cmd += "c" if args[:create]
+    
+    if args[:verbose]
+      1.upto(args[:verbose]) do
+        cmd += "v"
+      end
+    end
+    
+    cmd += " \"#{args[:archive_path]}\""
+    
+    args[:paths].each do |path|
+      cmd += " \"#{path}\""
+    end
+    
+    return cmd
+  end
+end

data/lib/knj/compiler.rb

@@ -32,9 +32,9 @@ class Knj::Compiler
 	#Compile and evaluate a file - it will be cached.
 	def eval_file(args)
 		#Compile if it hasnt been compiled yet.
-    if !@compiled.has_key?(args[:filepath])
+    if !@compiled.key?(args[:filepath])
       @mutex.synchronize do
-        compile_file(args) if !@compiled.has_key?(args[:filepath])
+        compile_file(args) if !@compiled.key?(args[:filepath])
       end
     end
     

data/lib/knj/datarow.rb

@@ -1,5 +1,5 @@
 class Knj::Datarow
-	attr_reader :data, :ob
+	attr_reader :data, :ob, :db
 	
 	def self.required_data
     @required_data = [] if !@required_data
@@ -10,7 +10,7 @@ class Knj::Datarow
     @depending_data = [] if !@depending_data
     return @depending_data
   end
-	
+  
 	def is_knj?; return true; end
 	
 	def self.is_nullstamp?(stamp)
@@ -37,18 +37,41 @@ class Knj::Datarow
         raise "Unknown argument: '#{val.class.name}'."
       end
       
+      if val.is_a?(Hash) and val.key?(:where)
+        where_args = val[:where]
+      else
+        where_args = {}
+      end
+      
+      raise "No classname given." if !classname
       methodname = "#{classname.to_s.downcase}s".to_sym if !methodname
       
-      define_method(methodname) do |*args|
+      define_method(methodname) do |*args, &block|
         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))
+        
+        all_args = []
+        all_args << block if block
+        
+        if block
+          @ob.list(classname, merge_args.merge(colname.to_s => self.id)) do |obj|
+            block.call(obj)
+          end
+        else
+          return @ob.list(classname, merge_args.merge(colname.to_s => self.id))
+        end
       end
       
       define_method("#{methodname}_count".to_sym) do |*args|
         merge_args = args[0] if args and args[0]
         merge_args = {} if !merge_args
-        return ob.list(classname, {"count" => true, colname.to_s => self.id}.merge(merge_args))
+        
+        return @ob.list(classname, merge_args.merge(colname.to_s => self.id, "count" => true))
+      end
+      
+      define_method("#{methodname}_last".to_sym) do |args|
+        args = {} if !args
+        return @ob.list(classname, {"orderby" => [["id", "desc"]], "limit" => 1}.merge(args))
       end
     end
 	end
@@ -83,13 +106,13 @@ class Knj::Datarow
       colname = "#{classname.to_s.downcase}_id".to_sym if !colname
       
       define_method(methodname) do
-        return ob.get_try(self, colname, classname)
+        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
+        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)
@@ -97,6 +120,10 @@ class Knj::Datarow
     end
 	end
 	
+	def self.joined_tables(hash)
+    @columns_joined_tables = hash
+	end
+	
 	def self.table
 		return self.name.split("::").last
 	end
@@ -108,6 +135,7 @@ class Knj::Datarow
 	
 	def self.columns_load(d)
 		return nil if @columns
+		@ob = d.ob
 		@columns = d.db.tables[table].columns
 	end
 	
@@ -116,39 +144,60 @@ class Knj::Datarow
 	end
 	
 	def self.list(d)
+    ec_col = d.db.enc_col
+    ec_table = d.db.enc_table
+    
+    table_str = "#{ec_table}#{d.db.esc_table(self.table)}#{ec_table}"
+    
     if d.args["count"]
       count = true
       d.args.delete("count")
-      sql = "SELECT COUNT(*) AS count"
+      sql = "SELECT COUNT(#{table_str}.#{ec_col}id#{ec_col}) AS count"
     else
-      sql = "SELECT *"
+      sql = "SELECT #{table_str}.*"
     end
     
-    sql += " FROM #{d.db.enc_table}#{table}#{d.db.enc_table} WHERE 1=1"
+    ret = self.list_helper(d)
+    
+    sql += " FROM #{table_str}"
+    sql += ret[:sql_joins]
+    sql += " WHERE 1=1"
     
-    ret = list_helper(d)
     d.args.each do |key, val|
-      raise "Invalid key: '#{key}'."
+      case key
+        when "return_sql"
+          #ignore
+        else
+          raise "Invalid key: '#{key}'."
+      end
     end
     
     sql += ret[:sql_where]
+    
+    #The count will bug if there is a group-by-statement.
+    if !count
+      sql += " GROUP BY #{table_str}.#{ec_col}id#{ec_col}"
+    end
+    
     sql += ret[:sql_order]
     sql += ret[:sql_limit]
     
-    return d.db.query(sql).fetch[:count].to_i if count
-    return d.ob.list_bysql(table, sql)
+    return sql.to_s if d.args["return_sql"]
+    
+    if count
+      ret = d.db.query(sql).fetch
+      return ret[:count].to_i if ret
+      return 0
+    end
+    
+    return d.ob.list_bysql(self.table, sql)
 	end
 	
 	def self.load_columns(d)
-    if @columns_sqlhelper_args_working
-      sleep 0.1 while @columns_sqlhelper_args_working
-      return false
-    end
+    @mutex = Mutex.new if !@mutex
     
-    begin
-      @columns_sqlhelper_args_working = true
+    @mutex.synchronize do
       cols = self.columns(d)
-      
       inst_methods = instance_methods(false)
       
       sqlhelper_args = {
@@ -158,11 +207,13 @@ class Knj::Datarow
         :cols_date => [],
         :cols_dbrows => [],
         :cols_num => [],
-        :cols_str => []
+        :cols_str => [],
+        :cols => {}
       }
       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"
+        sqlhelper_args[:cols][col_name] = true
         
         if col_type == "enum" and col_obj.maxlength == "'0','1'"
           sqlhelper_args[:cols_bools] << col_name
@@ -187,23 +238,70 @@ class Knj::Datarow
           if !inst_methods.index(method_name)
             define_method(method_name) do |*args|
               if Knj::Datet.is_nullstamp?(self[col_name.to_sym])
-                return ob.events.call(:no_date, self.class.name)
+                return @ob.events.call(:no_date, self.class.name)
               end
               
               return Knj::Datet.in(self[col_name.to_sym]).out(*args)
             end
           end
+          
+          method_name = "#{col_name}".to_sym
+          if !inst_methods.index(method_name)
+            define_method(method_name) do |*args|
+              return false if Knj::Datet.is_nullstamp?(self[col_name.to_sym])
+              return Knj::Datet.in(self[col_name.to_sym])
+            end
+          end
+        end
+        
+        if col_type == "int" or col_type == "decimal"
+          method_name = "#{col_name}_format"
+          if inst_methods.index(method_name) == nil
+            define_method(method_name) do |*args|
+              return Knj::Locales.number_out(self[col_name.to_sym], *args)
+            end
+          end
         end
+        
+        if col_type == "int" or col_type == "varchar"
+          method_name = "by_#{col_name}".to_sym
+          if !inst_methods.index(method_name) and RUBY_VERSION.to_s.slice(0, 3) != "1.8"
+            define_singleton_method(method_name) do |arg|
+              return d.ob.get_by(self.table, {col_name.to_s => arg})
+            end
+          end
+        end
+        
+        if col_type == "time"
+          method_name = "#{col_name}_dbt"
+          if !inst_methods.index(method_name)
+            define_method(method_name) do
+              return Knj::Db::Dbtime.new(self[col_name.to_sym])
+            end
+          end
+        end
+      end
+      
+      if @columns_joined_tables
+        @columns_joined_tables.each do |table_name, table_data|
+          table_data[:where].each do |key, val|
+            val[:table] = self.table.to_sym if val.is_a?(Hash) and !val.key?(:table) and val[:type] == "col"
+          end
+          
+          table_data[:datarow] = @ob.args[:module].const_get(table_name.to_sym) if !table_data.key?(:datarow)
+        end
+        
+        sqlhelper_args[:joined_tables] = @columns_joined_tables
       end
       
       @columns_sqlhelper_args = sqlhelper_args
-    ensure
-      @columns_sqlhelper_args_working = false
     end
+    
+    self.init_class(d) if self.respond_to?(:init_class)
 	end
 	
 	def self.list_helper(d)
-		load_columns(d) if !@columns_sqlhelper_args
+		self.load_columns(d) if !@columns_sqlhelper_args
 		return d.ob.sqlhelper(d.args, @columns_sqlhelper_args)
 	end
 	
@@ -213,6 +311,7 @@ class Knj::Datarow
 	
 	def initialize(d)
 		@ob = d.ob
+		@db = d.ob.db
 		raise "No ob given." if !@ob
 		
 		if d.data.is_a?(Hash)
@@ -225,12 +324,8 @@ class Knj::Datarow
 		end
 	end
 	
-	def db
-		return @ob.db
-	end
-	
 	def reload
-		data = self.db.single(self.table, {:id => @data[:id]})
+		data = @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
@@ -239,27 +334,32 @@ class Knj::Datarow
 	end
 	
 	def update(newdata)
-		self.db.update(self.table, newdata, {:id => @data[:id]})
+		@db.update(self.table, newdata, {:id => @data[:id]})
 		self.reload
 		
-		if self.ob
-			self.ob.call("object" => self, "signal" => "update")
+		if @ob
+			@ob.call("object" => self, "signal" => "update")
 		end
 	end
 	
 	def destroy
 		@ob = nil
+		@db = nil
 		@data = nil
 	end
 	
 	def has_key?(key)
-		return @data.has_key?(key.to_sym)
+		return @data.key?(key.to_sym)
+	end
+	
+	def key?(key)
+    return @data.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)
+		return @data[key] if @data.key?(key)
 		raise "No such key: #{key}."
 	end
 	
@@ -274,9 +374,9 @@ class Knj::Datarow
 	end
 	
 	def name
-		if @data.has_key?(:title)
+		if @data.key?(:title)
 			return @data[:title]
-		elsif @data.has_key?(:name)
+		elsif @data.key?(:name)
 			return @data[:name]
 		end
 		

data/lib/knj/datestamp.rb

@@ -50,11 +50,11 @@ class Knj::Datestamp
 		
 		str = ""
 		
-		if !args.has_key?(:date) or args[:date] == true
+		if !args.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
+		if !args.key?(:time) or args[:time] == true
 			str += " " + "%02d" % time.hour.to_s + ":" + "%02d" % time.min.to_s
 		end
 		

data/lib/knj/datet.rb

@@ -1,3 +1,5 @@
+require "time"
+
 class Knj::Datet
 	attr_accessor :time
 	
@@ -126,6 +128,8 @@ class Knj::Datet
 	
 	#Returns the number of days in the current month.
 	def days_in_month
+    return 29 if month == 2 and Date.gregorian_leap?(self.year)
+    
 		#Thanks to ActiveSupport: http://rubydoc.info/docs/rails/2.3.8/ActiveSupport/CoreExtensions/Time/Calculations
 		days_in_months = [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
 		return days_in_months[@time.month]
@@ -245,9 +249,9 @@ class Knj::Datet
 		secs = arg_to_time(timeobj).to_i
 		
 		if secs > @time.to_i
-			return 1
-		elsif secs < @time.to_i
 			return -1
+		elsif secs < @time.to_i
+			return 1
 		else
 			return 0
 		end
@@ -299,17 +303,23 @@ class Knj::Datet
 			vars[key.to_sym] = value.to_i if key != :datet
 		end
 		
-		time = Time.gm(vars[:year], vars[:month], vars[:day], vars[:hour], vars[:min], vars[:sec])
+		time = Time.local(vars[:year], vars[:month], vars[:day], vars[:hour], vars[:min], vars[:sec])
 		
-		if !args.has_key?(:datet) or args[:datet]
+		if !args.key?(:datet) or args[:datet]
 			return Knj::Datet.new(time)
 		end
 		
 		return time
 	end
 	
-	def dbstr
-		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
+	def dbstr(args = {})
+    str = "%04d" % @time.year.to_s + "-" + "%02d" % @time.month.to_s + "-" + "%02d" % @time.day.to_s
+    
+    if !args.key?(:time) or args[:time]
+      str += " " + "%02d" % @time.hour.to_s + ":" + "%02d" % @time.min.to_s + ":" + "%02d" % @time.sec.to_s
+    end
+    
+    return str
 	end
 	
 	def self.from_dbstr(date_string)
@@ -337,16 +347,16 @@ class Knj::Datet
 		date_shown = false
 		time_shown = false
 		
-		if !args.has_key?(:date) or args[:date]
+		if !args.key?(:date) or args[:date]
 			date_shown = true
 			str += "%02d" % @time.day.to_s + "/" + "%02d" % @time.month.to_s
 			
-			if !args.has_key?(:year) or args[:year]
+			if !args.key?(:year) or args[:year]
 				str += " " + "%04d" % @time.year.to_s
 			end
 		end
 		
-		if !args.has_key?(:time) or args[:time]
+		if !args.key?(:time) or args[:time]
 			time_shown = true
 			str += " - " if date_shown
 			str += "%02d" % @time.hour.to_s + ":" + "%02d" % @time.min.to_s
@@ -380,24 +390,31 @@ class Knj::Datet
 				minute = match[2]
 			end
 			
-			return Knj::Datet.new(Time.gm(year, month, date, hour, minute))
+			return Knj::Datet.new(Time.local(year, month, date, hour, minute))
     elsif match = timestr.to_s.match(/^(\d{1,2})\/(\d{1,2})\/(\d{4})$/)
-      return Knj::Datet.new(Time.gm(match[3], match[2], match[1]))
-		elsif match = timestr.to_s.match(/^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})(\d{5})$/)
+      return Knj::Datet.new(Time.local(match[3], match[2], match[1]))
+		elsif match = timestr.to_s.match(/^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})(\d{5,6})$/)
 			#Datet.code format
-			return Knj::Datet.new(Time.gm(match[1], match[2], match[3], match[4], match[5], match[6], match[7]))
+			return Knj::Datet.new(Time.local(match[1], match[2], match[3], match[4], match[5], match[6], match[7]))
 		elsif match = timestr.to_s.match(/^\s*(\d{4})-(\d{1,2})-(\d{1,2})(|\s+(\d{2}):(\d{2}):(\d{2})(|\.\d+)\s*)(|\s+(UTC))(|\s+(\+|\-)(\d{2})(\d{2}))$/)
 			#Database date format (with possibility of .0 in the end - miliseconds? -knj.
 			
-			if match[11]
-        utc_str = "+#{match[13]}:#{match[14]}"
+			if match[11] and match[13] and match[14]
+        if match[12] == "+" or match[12] == "-"
+          sign = match[12]
+        else
+          sign = "+"
+        end
+        
+        utc_str = "#{sign}#{match[13]}:#{match[14]}"
       elsif match[8]
         utc_str = match[8].to_i
       else
         utc_str = nil
       end
-			
-			return Knj::Datet.new(Time.gm(match[1].to_i, match[2].to_i, match[3].to_i, match[5].to_i, match[6].to_i, match[7].to_i,utc_str))
+      
+			time = Time.local(match[1].to_i, match[2].to_i, match[3].to_i, match[5].to_i, match[6].to_i, match[7].to_i, utc_str)
+			return Knj::Datet.new(time)
 		end
 		
 		raise Knj::Errors::InvalidData.new("Wrong format: '#{timestr}', class: '#{timestr.class.name}'")
@@ -457,4 +474,42 @@ class Knj::Datet
 	end
 	
 	alias :to_i :unixt
+	
+	def httpdate
+    require "time"
+    return @time.httpdate
+	end
+	
+	def offset_info
+    offset_secs = @time.gmt_offset
+    
+    offset_hours = (offset_secs.to_f / 3600.0).floor
+    offset_secs -= offset_hours * 3600
+    
+    offset_minutes = (offset_secs.to_f / 60.0).floor
+    offset_secs -= offset_minutes * 60
+    
+    if offset_hours > 0
+      sign = "+"
+    else
+      sign = ""
+    end
+    
+    return {
+      :sign => sign,
+      :hours => offset_hours,
+      :mins => offset_minutes,
+      :secs => offset_secs
+    }
+	end
+	
+	def offset_str
+    offset_info_data = self.offset_info
+    return "#{offset_info_data[:sign]}#{"%02d" % offset_info_data[:hours]}#{"%02d" % offset_info_data[:mins]}"
+	end
+	
+	#Returns 'localtime' as of 1.9 - even in 1.8 which does it different.
+	def localtime_str
+    return "#{"%04d" % @time.year}-#{"%02d" % @time.month}-#{"%02d" % @time.day} #{"%02d" % @time.hour}:#{"%02d" % @time.min}:#{"%02d" % @time.sec} #{self.offset_str}"
+	end
 end