knjrbfw 0.0.29 → 0.0.30

data/lib/knj/knjdb/revision.rb

@@ -1,43 +1,32 @@
+#This class takes a database-schema from a hash and runs it against the database. It then checks that the database matches the given schema.
+#
+#===Examples
+# db = Knj::Db.new(:type => "sqlite3", :path => "test_db.sqlite3")
+# schema = {
+#   "tables" => {
+#     "columns" => [
+#       {"name" => "id", "type" => "int", "autoincr" => true, "primarykey" => true},
+#       {"name" => "name", "type" => "varchar"},
+#       {"name" => "lastname", "type" => "varchar"}
+#     ],
+#     "indexes" => [
+#       "name",
+#       {"name" => "lastname", "columns" => ["lastname"]}
+#     ]
+#   }
+# }
+# 
+# rev = Knj::Db::Revision.new
+# rev.init_db("db" => db, "schema" => schema)
 class Knj::Db::Revision
   def initialize(args = {})
     @args = args
   end
   
-  #This method checks if certain rows are present in a table based on a hash.
-  def rows_init(args)
-    db = args["db"]
-    table = args["table"]
-    
-    raise "No db given." if !db
-    raise "No table given." if !table
-    
-    args["rows"].each do |row_data|
-      if row_data["find_by"]
-        find_by = row_data["find_by"]
-      elsif row_data["data"]
-        find_by = row_data["data"]
-      else
-        raise "Could not figure out the find-by."
-      end
-      
-      rows_found = 0
-      args["db"].select(table.name, find_by) do |d_rows|
-        rows_found += 1
-        
-        if Knj::ArrayExt.hash_diff?(Knj::ArrayExt.hash_sym(row_data["data"]), Knj::ArrayExt.hash_sym(d_rows), {"h2_to_h1" => false})
-          print "Data was not right - updating row: #{JSON.generate(row_data["data"])}\n" if args["debug"]
-          args["db"].update(table.name, row_data["data"], d_rows)
-        end
-      end
-      
-      if rows_found == 0
-        print "Inserting row: #{JSON.generate(row_data["data"])}\n" if args["debug"]
-        table.insert(row_data["data"])
-      end
-    end
-  end
-  
   #This initializes a database-structure and content based on a schema-hash.
+  #===Examples
+  # dbrev = Knj::Db::Revision.new
+  # dbrev.init_db("db" => db_obj, "schema" => schema_hash)
   def init_db(args)
     schema = args["schema"]
     db = args["db"]
@@ -283,4 +272,40 @@ class Knj::Db::Revision
     tables.clear
     tables = nil
   end
+  
+  private
+  
+  #This method checks if certain rows are present in a table based on a hash.
+  def rows_init(args)
+    db = args["db"]
+    table = args["table"]
+    
+    raise "No db given." if !db
+    raise "No table given." if !table
+    
+    args["rows"].each do |row_data|
+      if row_data["find_by"]
+        find_by = row_data["find_by"]
+      elsif row_data["data"]
+        find_by = row_data["data"]
+      else
+        raise "Could not figure out the find-by."
+      end
+      
+      rows_found = 0
+      args["db"].select(table.name, find_by) do |d_rows|
+        rows_found += 1
+        
+        if Knj::ArrayExt.hash_diff?(Knj::ArrayExt.hash_sym(row_data["data"]), Knj::ArrayExt.hash_sym(d_rows), {"h2_to_h1" => false})
+          print "Data was not right - updating row: #{JSON.generate(row_data["data"])}\n" if args["debug"]
+          args["db"].update(table.name, row_data["data"], d_rows)
+        end
+      end
+      
+      if rows_found == 0
+        print "Inserting row: #{JSON.generate(row_data["data"])}\n" if args["debug"]
+        table.insert(row_data["data"])
+      end
+    end
+  end
 end

data/lib/knj/memory_analyzer.rb

@@ -1,8 +1,14 @@
+#This class contains methods to debug memory-leaks. It prints its collected information as HTML.
+#===Examples
+# ma = Knj::Memory_analyzer.new
+# ma.write
 class Knj::Memory_analyzer
+  #Initialized various objects.
   def initialize
     @printed = {}
   end
   
+  #Writes all available memory-analyzer-information to the given IO.
   def write(to = $stdout)
     to.print "<div style=\"width: 600px;\">\n"
     
@@ -24,6 +30,7 @@ class Knj::Memory_analyzer
     to.print "</div>\n"
   end
   
+  #Writes information about the garbage-collector to the given IO as HTML.
   def garbage_collector(to = $stdout)
     to.print "<h1>Garbage collector</h1>\n"
     
@@ -36,6 +43,7 @@ class Knj::Memory_analyzer
     GC.start
   end
   
+  #Collects and writes out a lot of information about the spawned hashes as HTML to the given IO.
   def hashes(to = $stdout)
     hashes = {}
     
@@ -94,6 +102,7 @@ class Knj::Memory_analyzer
     to.write "</table>\n"
   end
   
+  #Collects and writes a lot of information about the spawned arrays as HTML to the given IO.
   def arrays(to = $stdout)
     arrays = {}
     
@@ -152,6 +161,7 @@ class Knj::Memory_analyzer
     to.write "</table>\n"
   end
   
+  #Collects a lot of information and writes a lot of info about the spawned global variables as HTML to the given IO.
   def global_vars(to = $stdout)
     to.print "<h1>Global variables</h1>\n"
     to.print "<table class=\"global_variables list\">\n"
@@ -195,6 +205,7 @@ class Knj::Memory_analyzer
     to.print "</table>\n"
   end
   
+  #Collects information about the spawned classes and writes it as HTML to the given IO.
   def constants(to = $stdout)
     to.print "<h1>Constants</h1>\n"
     to.print "<table class=\"memory_analyzer list\">\n"
@@ -219,6 +230,7 @@ class Knj::Memory_analyzer
     to.print "</table>\n"
   end
   
+  #Writes information about the given mod and submod to the given IO as HTML.
   def write_constant(to, mod, submod)
     submod_s = submod.to_s
     
@@ -278,6 +290,7 @@ class Knj::Memory_analyzer
   end
 end
 
+#This class is used to calculate a guessed amount of memory the given object requires.
 class Knj::Memory_analyzer::Object_size_counter
   def initialize(obj)
     @checked = {}

data/lib/knj/os.rb

@@ -1,4 +1,7 @@
 module Knj::Os
+  #Returns the path of the home-dir as a string.
+  #===Examples
+  # print "Looks like the current user uses Mozilla software?" if File.exists?("#{Knj::Os.homedir}/.mozilla")
   def self.homedir
     if ENV["USERPROFILE"]
       homedir = ENV["USERPROFILE"]
@@ -14,6 +17,8 @@ module Knj::Os
   end
   
   #This method was created to make up for the fact that Dir.tmpdir sometimes returns empty strings??
+  #===Examples
+  # tmp_db_path = "#{Knj::Os.tmpdir}/temp_db.sqlite3"
   def self.tmpdir
     require "tmpdir"
     tmpdir = Dir.tmpdir.to_s.strip
@@ -26,6 +31,9 @@ module Knj::Os
     raise "Could not figure out temp-dir."
   end
   
+  #This method returns the username of the current user.
+  #===Examples
+  # print "I can do what I want, I am root!" if Knj::Os.whoami == "root"
   def self.whoami
     if ENV["USERNAME"]
       whoami = ENV["USERNAME"]
@@ -40,6 +48,10 @@ module Knj::Os
     return whoami
   end
   
+  #Returns the operating system a string.
+  #===Examples
+  # print "Can I please move to another machine?" if Knj::Os.os == "windows"
+  # print "I like it better now." if Knj::Os.os == "linux"
   def self.os
     if ENV["OS"]
       teststring = ENV["OS"].to_s

data/lib/knj/process.rb

@@ -182,21 +182,15 @@ class Knj::Process
           self.answer(id, "ok")
         when "send_block_buffer"
           Knj::Thread.new do
-            mutex = Mutex.new #Protecting 'buffer_answers'-variable. Crashing JRuby...
             result_obj = Knj::Process::Resultobject.new(:process => self, :id => id, :obj => obj)
             block_res = nil
             buffer_done = false
             
             begin
-              buffer_answers = []
-              
+              buffer_answers = Knj::Threadsafe.std_array #JRuby needs the threadsafety.
               buffer_thread = Knj::Thread.new do
-                dobreak = false
                 loop do
-                  arr = nil
-                  mutex.synchronize do
-                    arr = buffer_answers.shift(200)
-                  end
+                  arr = buffer_answers.shift(200)
                   
                   if !arr.empty?
                     $stderr.print "Sending: #{arr.length} results.\n" if @debug
@@ -206,14 +200,7 @@ class Knj::Process
                     sleep 0.05
                   end
                   
-                  if buffer_done
-                    mutex.synchronize do
-                      $stderr.print "Buffer-answers: #{buffer_answers.length}, #{buffer_answers.empty?}\n" if @debug
-                      dobreak = true if buffer_answers.empty? #since a break will not affect the real loop in Mutex#synchronize set this variable.
-                    end
-                    
-                    break if dobreak
-                  end
+                  break if buffer_done and buffer_answers.empty?
                 end
               end
               
@@ -222,12 +209,7 @@ class Knj::Process
                   count = 0
                   block_res = @on_rec.call(result_obj) do |answer_block|
                     loop do
-                      len = nil
-                      mutex.synchronize do
-                        len = buffer_answers.length
-                      end
-                      
-                      if len > 1000
+                      if buffer_answers.length > 1000
                         $stderr.print "Buffer is more than 1000 - sleeping and tries again in 0.05 sec.\n" if @debug
                         sleep 0.05
                       else
@@ -236,9 +218,7 @@ class Knj::Process
                     end
                     
                     count += 1
-                    mutex.synchronize do
-                      buffer_answers << answer_block
-                    end
+                    buffer_answers << answer_block
                     
                     if count >= 100
                       count = 0

data/lib/knj/process_meta.rb

@@ -1,9 +1,22 @@
 require "#{$knjpath}process"
 require "#{$knjpath}os"
 
+#This class can spawn another Ruby-process and manipulate it to create objects, evaluate code, create proxy-objects and other stuff in that process.
+#===Examples
+# This will create another Ruby-process, spawn an integer with the value of 5, run upto(10) and return each block to the current block. In the end the subprocess is terminated.
+# Knj::Process_meta.new do |subproc|
+#   proxy_int = subproc.new(:Integer, 5)
+#   proxy_int.upto(10) do |i|
+#     print "Number: #{i}\n"
+#   end
+# end
 class Knj::Process_meta
   attr_reader :process, :pid
   
+  #===Examples
+  #Knj::Process_meta.new("id" => "my_subproc") #Will make this ID be shown in the command, so you can recocknize it from "ps aux".
+  #Knj::Process_meta.new("exec_path" => "ruby1.9.1") #If you want a certain Ruby-command to be used when starting the subprocess, instead of detecting the current one.
+  #Knj::Process_meta.new("debug" => true, "debug_err" => true) #Enables various debug-messages to be printed.
   def initialize(args = {})
     @args = args
     @objects = {}

data/lib/knj/threadsafe.rb

@@ -1,33 +1,120 @@
-#Copied from Headius: https://github.com/headius/thread_safe. Not just bundeled because I would like to make changes later...
-#Minor modifications from Headius's original lib like submoduled, lower-case-safe and more...
+require "monitor"
 
-if defined?(JRUBY_VERSION)
-  require "jruby/synchronized"
+#This module contains various tools to handle thread-safety easily and pretty.
+module Knj::Threadsafe
+  #JRuby can corrupt an array in a threadded env. Use this method to only get a synchronized array when running JRuby and not having to write "if RUBY_ENGINE"-stuff.
+  def self.std_array
+    return Synced_array.new if RUBY_ENGINE == "jruby"
+    return []
+  end
   
-  module Knj::Threadsafe
-    # A thread-safe subclass of Array. This version locks
-    # against the object itself for every method call,
-    # ensuring only one thread can be reading or writing
-    # at a time. This includes iteration methods like
-    # #each.
-    class Array < ::Array
-      include JRuby::Synchronized
+  #Instances of this class proxies calls to a given-object by using a mutex or monitor.
+  #
+  #==== Examples
+  # threadsafe_array = Knj::Threadsafe::Proxy.new(:obj => [])
+  # threadsafe_array << 5
+  # ret = threadsafe_array[0]
+  #
+  # threadsafe_array = Knj::Threadsafe::Proxy.new(:obj => [], :monitor => true)
+  class Proxy
+    #Spawn needed vars.
+    def initialize(args)
+      if args[:monitor]
+        @mutex = Monitor.new
+      elsif args[:mutex]
+        @mutex = args[:mutex]
+      else
+        @mutex = Mutex.new
+      end
+      
+      @obj = args[:obj]
     end
     
-    # A thread-safe subclass of Hash. This version locks
-    # against the object itself for every method call,
-    # ensuring only one thread can be reading or writing
-    # at a time. This includes iteration methods like
-    # #each.
-    class Hash < ::Hash
-      include JRuby::Synchronized
+    #Proxies all calls to this object through the mutex.
+    def method_missing(method_name, *args, &block)
+      @mutex.synchronize do
+        @obj.__send__(method_name, *args, &block)
+      end
+    end
+  end
+  
+  #This module can be included on a class to make all method-calls synchronized (by using monitor). Examples with array and hash are below.
+  #
+  #===Examples
+  # class MySyncedClass < SomeOtherClassThatNeedsToBeSynchronized
+  #   include Knj::Threadsafe::Monitored
+  # end
+  module Monitored
+    def self.included(base)
+      Knj::Strings.const_get_full(base.to_s).class_eval do
+        self.instance_methods.each do |method_name|
+          #These two methods create warnings under JRuby.
+          if RUBY_ENGINE == "jruby"
+            next if method_name == :instance_exec or method_name == :instance_eval
+          end
+          
+          new_method_name = "_ts_#{method_name}"
+          alias_method(new_method_name, method_name)
+          
+          define_method method_name do |*args, &block|
+            #Need to use monitor, since the internal calls might have to run not-synchronized, and we have just overwritten the internal methods.
+            @_ts_mutex = Monitor.new if !@_ts_mutex
+            @_ts_mutex.synchronize do
+              return self._ts___send__(new_method_name, *args, &block)
+            end
+          end
+        end
+      end
+    end
+  end
+  
+  #This module can be included on a class to make all method-calls synchronized (by using mutex). Examples with array and hash are below.
+  #
+  #===Examples
+  # class MySyncedClass < SomeOtherClassThatNeedsToBeSynchronized
+  #   include Knj::Threadsafe::Mutexed
+  # end
+  module Mutexed
+    def self.included(base)
+      Knj::Strings.const_get_full(base.to_s).class_eval do
+        self.instance_methods.each do |method_name|
+          #These two methods create warnings under JRuby.
+          if RUBY_ENGINE == "jruby"
+            next if method_name == :instance_exec or method_name == :instance_eval
+          end
+          
+          new_method_name = "_ts_#{method_name}"
+          alias_method(new_method_name, method_name)
+          
+          define_method method_name do |*args, &block|
+            #Need to use monitor, since the internal calls might have to run not-synchronized, and we have just overwritten the internal methods.
+            @_ts_mutex = Mutex.new if !@_ts_mutex
+            @_ts_mutex.synchronize do
+              return self._ts___send__(new_method_name, *args, &block)
+            end
+          end
+        end
+      end
     end
   end
-else
-  # Because MRI never runs code in parallel, the existing
-  # non-thread-safe structures should usually work fine.
-  module Knj::ThreadSafe
-    Array = ::Array
-    Hash = ::Hash
+  
+  #Predefined synchronized array.
+  #
+  #===Examples
+  # arr = Knj::Threadsafe::Synced_array.new
+  # arr << 5
+  # ret = arr[0]
+  class Synced_array < ::Array
+    include Mutexed
+  end
+  
+  #Predefined synchronized hash.
+  #
+  #===Examples
+  # h = Knj::Threadsafe::Synced_hash.new
+  # h['test'] = 'trala'
+  # ret = h['test']
+  class Synced_hash < ::Hash
+    include Mutexed
   end
 end

data/spec/threadsafe_spec.rb

@@ -0,0 +1,57 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Threadsafe" do
+  it "should be able to spawn threadsafe proxy-objects" do
+    require "knjrbfw"
+    
+    arr = Knj::Threadsafe::Proxy.new(:obj => {})
+    
+    0.upto(5) do |i|
+      arr[i] = i
+    end
+    
+    Knj::Thread.new do
+      arr.each do |key, val|
+        res = key + val
+        sleep 0.1
+      end
+    end
+    
+    5.upto(10) do |i|
+      arr[i] = i
+      sleep 0.1
+    end
+  end
+  
+  it "should be able to spawn special classes" do
+    require "knjrbfw"
+    
+    #Create new synchronized hash.
+    arr = Knj::Threadsafe::Synced_hash.new
+    
+    #Make sure we get the right results.
+    arr[1] = 2
+    
+    res = arr[1]
+    raise "Expected 2 but got '#{res}'." if res != 2
+    
+    #Set some values to test with.
+    0.upto(5) do |i|
+      arr[i] = i
+    end
+    
+    #Try to call through each through a thread and then also try to set new values, which normally would crash the hash.
+    Knj::Thread.new do
+      arr.each do |key, val|
+        res = key + val
+        sleep 0.1
+      end
+    end
+    
+    #This should not crash it, since they should wait for each other.
+    5.upto(10) do |i|
+      arr[i] = i
+      sleep 0.1
+    end
+  end
+end