knjrbfw 0.0.39 → 0.0.40

data/lib/knj/knjdb/libknjdb.rb

@@ -38,10 +38,6 @@ class Knj::Db
     @debug = @opts[:debug]
   end
   
-  def col_table
-    return "`"
-  end
-  
   def args
     return @opts
   end
@@ -118,6 +114,15 @@ class Knj::Db
     end
     
     thread_cur[:knjdb][tid] = @conns.get_and_lock if !thread_cur[:knjdb][tid]
+    
+    #If block given then be ensure to free thread after yielding.
+    if block_given?
+      begin
+        yield
+      ensure
+        self.free_thread
+      end
+    end
   end
   
   #Frees the current driver from the current thread.
@@ -154,7 +159,19 @@ class Knj::Db
   
   #Clones the current database-connection with possible extra arguments.
   def clone_conn(args = {})
-    return Knj::Db.new(@opts.clone.merge(args))
+    conn = Knj::Db.new(@opts.clone.merge(args))
+    
+    if block_given?
+      begin
+        yield(conn)
+      ensure
+        conn.close
+      end
+      
+      return nil
+    else
+      return conn
+    end
   end
   
   #Copies the content of the current database to another instance of Knj::Db.
@@ -213,6 +230,7 @@ class Knj::Db
   #===Examples
   # db.insert(:users, {:name => "John", :lastname => "Doe"})
   # id = db.insert(:users, {:name => "John", :lastname => "Doe"}, :return_id => true)
+  # sql = db.insert(:users, {:name => "John", :lastname => "Doe"}, :return_sql => true) #=> "INSERT INTO `users` (`name`, `lastname`) VALUES ('John', 'Doe')"
   def insert(tablename, arr_insert, args = nil)
     self.conn_exec do |driver|
       sql = "INSERT INTO #{driver.escape_table}#{tablename.to_s}#{driver.escape_table} ("
@@ -243,8 +261,10 @@ class Knj::Db
       
       sql << ")"
       
+      return sql if args and args[:return_sql]
       driver.query(sql)
       return driver.lastID if args and args[:return_id]
+      return nil
     end
   end
   
@@ -260,19 +280,19 @@ class Knj::Db
     
     self.conn_exec do |driver|
       if driver.respond_to?(:insert_multi)
-        return driver.insert_multi(tablename, arr_hashes, args)
+        return [driver.insert_multi(tablename, arr_hashes, args)]
       else
-        ids = [] if args and args[:return_id]
+        ret = [] if args and (args[:return_id] or args[:return_sql])
         arr_hashes.each do |hash|
-          if ids
-            ids << self.insert(tablename, hash, args)
+          if ret
+            ret << self.insert(tablename, hash, args)
           else
-            self.insert(tablename, hash)
+            self.insert(tablename, hash, args)
           end
         end
         
-        if ids
-          return ids
+        if ret
+          return ret
         else
           return nil
         end
@@ -316,10 +336,30 @@ class Knj::Db
   
   #Makes a select from the given arguments: table-name, where-terms and other arguments as limits and orders. Also takes a block to avoid raping of memory.
   def select(tablename, arr_terms = nil, args = nil, &block)
+    #Set up vars.
     sql = ""
+    args_q = nil
+    select_sql = "*"
+    
+    #Give 'cloned_ubuf' argument to 'q'-method.
+    if args and args[:cloned_ubuf]
+      args_q = {:cloned_ubuf => true}
+    end
+    
+    #Set up IDQuery-stuff if that is given in arguments.
+    if args and args[:idquery]
+      if args[:idquery] == true
+        select_sql = "`id`"
+        col = :id
+      else
+        select_sql = "`#{self.esc_col(args[:idquery])}`"
+        col = args[:idquery]
+      end
+    end
     
+    #Get the driver and generate SQL.
     self.conn_exec do |driver|
-      sql = "SELECT * FROM #{driver.escape_table}#{tablename.to_s}#{driver.escape_table}"
+      sql = "SELECT #{select_sql} FROM #{driver.escape_table}#{tablename.to_s}#{driver.escape_table}"
       
       if arr_terms != nil and !arr_terms.empty?
         sql << " WHERE #{self.makeWhere(arr_terms, driver)}"
@@ -327,24 +367,34 @@ class Knj::Db
       
       if args != nil
         if args["orderby"]
-          sql << " ORDER BY "
-          sql << args["orderby"]
+          sql << " ORDER BY #{args["orderby"]}"
         end
         
         if args["limit"]
-          sql << " LIMIT " + args["limit"].to_s
+          sql << " LIMIT #{args["limit"]}"
         end
         
         if args["limit_from"] and args["limit_to"]
           raise "'limit_from' was not numeric: '#{args["limit_from"]}'." if !Knj::Php.is_numeric(args["limit_from"])
           raise "'limit_to' was not numeric: '#{args["limit_to"]}'." if !Knj::Php.is_numeric(args["limit_to"])
-          
           sql << " LIMIT #{args["limit_from"]}, #{args["limit_to"]}"
         end
       end
     end
     
-    return self.q(sql, &block)
+    #Do IDQuery if given in arguments.
+    if args and args[:idquery]
+      res = Knj::Db::Idquery.new(:db => self, :table => tablename, :query => sql, :col => col, &block)
+    else
+      res = self.q(sql, args_q, &block)
+    end
+    
+    #Return result if a block wasnt given.
+    if block
+      return nil
+    else
+      return res
+    end
   end
   
   #Returns a single row from a database.
@@ -368,7 +418,7 @@ class Knj::Db
   #
   #===Examples
   # db.delete(:users, {:lastname => "Doe"})
-  def delete(tablename, arr_terms)
+  def delete(tablename, arr_terms, args = nil)
     self.conn_exec do |driver|
       sql = "DELETE FROM #{driver.escape_table}#{tablename}#{driver.escape_table}"
       
@@ -376,6 +426,7 @@ class Knj::Db
         sql << " WHERE #{self.makeWhere(arr_terms, driver)}"
       end
       
+      return sql if args and args[:return_sql]
       driver.query(sql)
     end
     
@@ -543,6 +594,11 @@ class Knj::Db
     return ret
   end
   
+  #Yields a query-buffer and flushes at the end of the block given.
+  def q_buffer(&block)
+    Knj::Db::Query_buffer.new(:db => self, &block)
+  end
+  
   #Returns the last inserted ID.
   #
   #===Examples
@@ -567,18 +623,21 @@ class Knj::Db
   
   alias :esc :escape
   
+  #Escapes the given string to be used as a column.
   def esc_col(str)
     self.conn_exec do |driver|
       return driver.esc_col(str)
     end
   end
   
+  #Escapes the given string to be used as a table.
   def esc_table(str)
     self.conn_exec do |driver|
       return driver.esc_table(str)
     end
   end
   
+  #Returns the sign for surrounding the string that should be used as a table.
   def enc_table
     if !@enc_table
       self.conn_exec do |driver|
@@ -589,6 +648,7 @@ class Knj::Db
     return @enc_table
   end
   
+  #Returns the sign for surrounding the string that should be used as a column.
   def enc_col
     if !@enc_col
       self.conn_exec do |driver|
@@ -663,6 +723,7 @@ class Knj::Db
     return @indexes
   end
   
+  #Returns the SQLSpec-module and spawns it if it isnt already spawned.
   def sqlspecs
     if !@sqlspecs
       require "#{File.dirname(__FILE__)}/drivers/#{@opts[:type]}/knjdb_#{@opts[:type]}_sqlspecs" if (!@opts.key?(:require) or @opts[:require])
@@ -674,6 +735,23 @@ class Knj::Db
     return @sqlspecs
   end
   
+  #Beings a transaction and commits when the block ends.
+  #
+  #===Examples
+  # db.transaction do |db|
+  #   db.insert(:users, {:name => "John"})
+  #   db.insert(:users, {:name => "Kasper"})
+  # end
+  def transaction(&block)
+    self.conn_exec do |driver|
+      driver.transaction(&block)
+    end
+  end
+  
+  def col_table
+    return "`"
+  end
+  
   #Proxies the method to the driver.
   #
   #===Examples
@@ -687,21 +765,4 @@ class Knj::Db
     
     raise "Method not found: #{method_name}"
   end
-  
-  #Beings a transaction and commits when the block ends.
-  #
-  #===Examples
-  # db.transaction do |db|
-  #   db.insert(:users, {:name => "John"})
-  #   db.insert(:users, {:name => "Kasper"})
-  # end
-  def transaction
-    self.query("START TRANSACTION")
-    
-    begin
-      yield(self)
-    ensure
-      self.query("COMMIT")
-    end
-  end
 end

data/lib/knj/knjdb/query_buffer.rb

@@ -0,0 +1,43 @@
+#This class buffers a lot of queries and flushes them out via transactions.
+class Knj::Db::Query_buffer
+  #Constructor. Takes arguments to be used and a block.
+  def initialize(args)
+    @args = args
+    @queries = []
+    @debug = @args[:debug]
+    
+    begin
+      yield(self)
+    ensure
+      self.flush if !@queries.empty?
+    end
+  end
+  
+  #Adds a query to the buffer.
+  def query(str)
+    STDOUT.print "Adding to buffer: #{str}\n" if @debug
+    @queries << str
+    self.flush if @queries.length > 1000
+    return nil
+  end
+  
+  #Delete as on a normal Knj::Db.
+  def delete(table, where)
+    self.query(@args[:db].delete(table, where, :return_sql => true))
+    return nil
+  end
+  
+  #Flushes all queries out in a transaction.
+  def flush
+    return nil if @queries.empty?
+    
+    @args[:db].transaction do
+      @queries.shift(1000).each do |str|
+        STDOUT.print "Executing via buffer: #{str}\n" if @debug
+        @args[:db].q(str)
+      end
+    end
+    
+    return nil
+  end
+end

data/lib/knj/locales.rb

@@ -20,19 +20,15 @@ module Knj::Locales
   def self.localeconv
     f = Knj::Locales.lang["first"]
     
-    dec = "."
-    thousand = ","
-    csv_delimiter = ","
-    
     case f
-      when "da", "es", "de", "sv"
+      when "da", "de", "es", "pl", "sv"
         dec = ","
         thousand = "."
         csv_delimiter = ";"
-      when "en"
-        #do nothing.
       else
-        raise "Cant figure out numbers for language: #{f}."
+        dec = "."
+        thousand = ","
+        csv_delimiter = ","
     end
     
     return {

data/lib/knj/objects/objects_sqlhelper.rb

@@ -220,8 +220,8 @@ class Knj::Objects
             )
             sql_where << " AND #{table}`#{db.esc_col(key)}` IN (#{escape_sql})"
           end
-        elsif val.is_a?(Hash) and val[:type] == "col"
-          raise "No table was given for join." if !val.key?(:table)
+        elsif val.is_a?(Hash) and val[:type] == :col
+          raise "No table was given for join: '#{val}', key: '#{key}' on table #{table}." if !val.key?(:table)
           
           do_joins[val[:table].to_sym] = true
           sql_where << " AND #{table}`#{db.esc_col(key)}` = `#{db.esc_table(val[:table])}`.`#{db.esc_col(val[:name])}`"

data/lib/knj/process.rb

@@ -1,6 +1,7 @@
 require "#{$knjpath}errors"
 require "#{$knjpath}thread"
 
+#This class is able to control communicate with another Ruby-process also running Knj::Process.
 class Knj::Process
   attr_reader :blocks, :blocks_send
   
@@ -56,10 +57,12 @@ class Knj::Process
     end
   end
   
+  #Kills the listen-thread.
   def kill_listen
     @listen_thread.kill if @listen_thread
   end
   
+  #Joins the listen-thread and the error-thread.
   def join
     @listen_thread.join if @listen_thread
     sleep 0.5
@@ -76,6 +79,7 @@ class Knj::Process
     end
   end
   
+  #This method is called by listen on every loop.
   def listen_loop
     $stderr.print "listen-loop called.\n" if @debug
     
@@ -421,6 +425,8 @@ class Knj::Process
       end
       
       err.set_backtrace(bt)
+      
+      $stderr.print Knj::Errors.error_str(err) if @debug
       raise err
     end
     

data/lib/knj/process_meta.rb

@@ -84,12 +84,14 @@ class Knj::Process_meta
     end
   end
   
+  #Finalizer for proxy-objects. Used for unsetting objects on the process-side.
   def proxy_finalizer(id)
     @finalize_mutex.synchronize do
       @finalize << id
     end
   end
   
+  #Flushes all finalized objects on the process-side.
   def check_finalizers
     return nil if @finalize.empty?
     
@@ -383,8 +385,8 @@ class Knj::Process_meta
         raise e if e.message.index("No such process") == nil
       end
       
-      $stderr.print "Try to kill again...\n"
-      retry
+      #$stderr.print "Try to kill again...\n"
+      #retry
     end
     
     @process = nil

data/lib/knj/threadpool.rb

@@ -1,3 +1,4 @@
+#A small threadpool framework.
 class Knj::Threadpool
   def self.worker_data
     raise "This thread is not running via the threadpool." if !Thread.current[:knj_threadpool]
@@ -6,6 +7,9 @@ class Knj::Threadpool
   
   attr_reader :workers, :blocks, :mutex, :args, :events
   
+  #Constructor.
+  #===Examples
+  # tp = Knj::Threadpool.new(:threads => 5)
   def initialize(args = {})
     @args = args
     @args[:sleep] = 0.2 if !@args.key?(:sleep)
@@ -21,6 +25,7 @@ class Knj::Threadpool
     self.start
   end
   
+  #Starts the threadpool. This is automatically called from the constructor.
   def start
     @mutex.synchronize do
       if !@running
@@ -33,6 +38,7 @@ class Knj::Threadpool
     end
   end
   
+  #Stops the threadpool.
   def stop
     if @running
       @workers.each do |worker|
@@ -46,6 +52,7 @@ class Knj::Threadpool
     end
   end
   
+  #Runs the given block, waits for the result and returns the result.
   def run(*args, &block)
     raise "No block given." if !block_given?
     blockdata = {:block => block, :result => nil, :running => false, :runned => false, :args => args}
@@ -70,16 +77,18 @@ class Knj::Threadpool
     end
   end
   
+  #Runs the given block in the threadpool asynced. Returns a 'Knj::Threadpool::Asynced'-object that can be used to get the result and more.
   def run_async(*args, &block)
     raise "No block given." if !block_given?
     
     @mutex.synchronize do
       blockdata = {:block => block, :running => false, :runned => false, :args => args}
       @blocks << blockdata
-      return blockdata
+      return Knj::Threadpool::Asynced.new(blockdata)
     end
   end
   
+  #Returns a new block to be runned if there is one. Otherwise false.
   def get_block
     return false if !@running
     
@@ -96,9 +105,11 @@ class Knj::Threadpool
   end
 end
 
+#This is the threadpool worker-object. No need to spawn this manually.
 class Knj::Threadpool::Worker
   attr_reader :running
   
+  #Constructor. Should not be called manually.
   def initialize(args)
     @args = args
     @tp = @args[:threadpool]
@@ -112,6 +123,8 @@ class Knj::Threadpool::Worker
   def spawn_thread
     @thread = Knj::Thread.new do
       loop do
+        break if !@sleep or !@tp
+        
         if !@blockdata
           sleep @sleep
           @blockdata = @tp.get_block if !@blockdata
@@ -128,47 +141,28 @@ class Knj::Threadpool::Worker
         }
         
         begin
-          if @blockdata.key?(:result)
-            begin
-              @running = true
-              res = @blockdata[:block].call(*@blockdata[:args])
-            rescue Exception => e
-              @mutex_tp.synchronize do
-                @blockdata[:error] = e
-              end
-            ensure
-              @running = false
-              
-              @mutex_tp.synchronize do
-                @blockdata[:result] = res
-                @blockdata[:runned] = true
-                @blockdata[:running] = false
-              end
-              
-              #Try to avoid slowdown of sleep by checking if there is a new block right away.
-              @blockdata = @tp.get_block
-            end
-          else
-            begin
-              @blockdata[:block].call(*@blockdata[:args])
-            rescue Exception => e
-              if @tp.events.connected?(:on_error)
-                @tp.events.call(:on_error, e)
-              else
-                STDOUT.print Knj::Errors.error_str(e)
-              end
-            ensure
-              @mutex_tp.synchronize do
-                @blockdata.clear if @blockdata
-                @tp.blocks.delete(@blockdata)
-              end
-              
-              #Try to avoid slowdown of sleep by checking if there is a new block right away.
-              @blockdata = @tp.get_block
-            end
+          @running = true
+          res = @blockdata[:block].call(*@blockdata[:args])
+        rescue => e
+          @mutex_tp.synchronize do
+            @blockdata[:error] = e
           end
         ensure
+          #Reset thread.
           Thread.current[:knj_threadpool] = nil
+          
+          #Set running-status on worker.
+          @running = false
+          
+          #Update block-data.
+          @mutex_tp.synchronize do
+            @blockdata[:result] = res if res
+            @blockdata[:runned] = true
+            @blockdata[:running] = false
+          end
+          
+          #Try to avoid slowdown of sleep by checking if there is a new block right away.
+          @blockdata = @tp.get_block
         end
       end
     end
@@ -196,7 +190,7 @@ class Knj::Threadpool::Worker
         begin
           sleep 0.1
           raise "The worker was stopped during execution of the block."
-        rescue Exception => e
+        rescue => e
           @blockdata[:error] = e
         end
       end
@@ -224,4 +218,54 @@ class Knj::Threadpool::Worker
       @thread.kill
     end
   end
+end
+
+#An object of this class will be returned when calling 'run_async'.
+class Knj::Threadpool::Asynced
+  #Constructor. Should not be called manually.
+  def initialize(args)
+    @args = args
+  end
+  
+  #Returns true if the asynced job is still running.
+  def running?
+    return true if @args[:running]
+    return false
+  end
+  
+  #Returns true if the asynced job is done running.
+  def done?
+    return true if @args[:runned] or @args.empty? or @args[:error]
+    return false
+  end
+  
+  #Returns true if the asynced job is still waiting to run.
+  def waiting?
+    return true if !@args.empty? and !@args[:running] and !@args[:runned]
+    return false
+  end
+  
+  #Raises error if one has happened in the asynced job.
+  def error!
+    raise @args[:error] if @args.key?(:error)
+  end
+  
+  #Sleeps until the asynced job is done. If an error occurred in the job, that error will be raised when calling the method.
+  def join
+    loop do
+      self.error!
+      break if self.done?
+      sleep 0.1
+    end
+    
+    self.error!
+  end
+  
+  #Returns the result of the job. If an error occurred in the job, that error will be raised when calling the method.
+  def result(args = nil)
+    self.join if args and args[:wait]
+    raise "Not done yet." unless self.done?
+    self.error!
+    return @args[:result]
+  end
 end

data/lib/knj/web.rb

@@ -1,7 +1,7 @@
 class Knj::Web
   #Parses URI and returns hash with data.
   def self.parse_uri(str)
-    uri_match = str.to_s.match(/^\/(.+?\..+?|)(\?(.+)|)$/)
+    uri_match = str.to_s.match(/^\/(.+?\..*?|)(\?(.*)|)$/)
     raise "Could not parse the URI: '#{str}'." if !uri_match
     
     return {