knjrbfw 0.0.110 → 0.0.114

data/spec/knjrbfw_spec.rb

@@ -1,109 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "Knjrbfw" do
-  it "should be able to join arrays with callbacks." do
-    res = Knj::ArrayExt.join(:arr => [1, 2, 3], :sep => ",", :callback => proc{|value| "'#{value}'"})
-    raise "Unexpected result from ArrayExt." if res != "'1','2','3'"
-  end
-  
-  it "should be able to draw rounded transparent corners on images." do
-    require "rubygems"
-    require "RMagick"
-    
-    pic = Magick::Image.read("#{File.dirname(__FILE__)}/../testfiles/image.jpg").first
-    pic.format = "png"
-    
-    Knj::Image.rounded_corners(
-      :img => pic,
-      :radius => 10
-    )
-    
-    blob_cont = pic.to_blob
-  end
-  
-  it "should be possible to use Strings.html_links-method." do
-    teststr = "This is a test. http://www.google.com This is a test."
-    
-    #Test normal usage.
-    test1 = Knj::Strings.html_links(teststr)
-    raise "Unexpected string: '#{teststr}'" if test1 != "This is a test. <a href=\"http://www.google.com\">http://www.google.com</a> This is a test."
-    
-    
-    #Test with a block.
-    test2 = Knj::Strings.html_links(teststr) do |data|
-      data[:str].gsub(data[:match][0], "TEST")
-    end
-    
-    raise "Unexpected string: '#{test2}'." if test2 != "This is a test. TEST This is a test."
-  end
-  
-=begin
-  it "should be able to use Knj::Mutexcl with advanced arguments." do
-    mutex = Knj::Mutexcl.new(
-      :modes => {
-        :reader => {
-          :blocks => [:writer]
-        },
-        :writer => {
-          :blocks => [:reader, :writer]
-        }
-      }
-    )
-    
-    $count = 0
-    
-    Knj::Thread.new do
-      mutex.sync(:reader) do
-        sleep 0.2
-        $count += 1
-      end
-    end
-    
-    mutex.sync(:reader) do
-      $count += 1
-    end
-    
-    raise "Count should be 1 by now but it wasnt: '#{$count}'." if $count != 1
-    sleep 0.3
-    raise "Count should be 2 by now but it wasnt: '#{$count}'." if $count != 2
-    
-    
-    $count = 0
-    Knj::Thread.new do
-      mutex.sync(:reader) do
-        sleep 2
-        $count += 1
-      end
-    end
-    sleep 0.1
-    
-    Knj::Thread.new do
-      mutex.sync(:writer) do
-        $count += 1
-      end
-    end
-    
-    sleep 1
-    raise "Count should be 0 but it wasnt: '#{$count}'." if $count != 0
-    sleep 1.1
-    raise "Count should be 2 but it wasnt: '#{$count}'." if $count != 2
-    
-    Knj::Thread.new do
-      mutex.sync(:reader) do
-        sleep 0.2
-        $count += 1
-      end
-    end
-    
-    Knj::Thread.new do
-      mutex.sync(:reader) do
-        sleep 0.2
-        $count += 1
-      end
-    end
-    
-    sleep 0.35
-    raise "Count should be 4 but it wasnt: '#{$count}'." if $count != 4
-  end
-=end
-end

data/spec/locales_spec.rb

@@ -1,9 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "Locales" do
-  it "should do convertions of short formats" do
-    Thread.current[:locale] = "en"
-    res = Knj::Locales.lang
-    raise "Result wasnt as expected: '#{res}'." if res["first"] != "en" or res["second"] != "GB" or res["full"] != "en_GB"
-  end
-end

data/spec/objects_spec.rb

@@ -1,394 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "Objects" do
-  it "should be able to cache rows" do
-    begin
-      require "#{File.dirname(__FILE__)}/../../array_enumerator/lib/array_enumerator"
-    rescue LoadError
-      require "array_enumerator"
-    end
-    
-    require "sqlite3" if RUBY_ENGINE != "jruby"
-    
-    $db_path = "#{Knj::Os.tmpdir}/knjrbfw_objects_cache_test.sqlite3"
-    File.unlink($db_path) if File.exists?($db_path)
-    $db = Knj::Db.new(:type => :sqlite3, :path => $db_path, :return_keys => "symbols", :debug => false)
-    
-    schema = {
-      "tables" => {
-        "Group" => {
-          "columns" => [
-            {"name" => "id", "type" => "int", "autoincr" => true, "primarykey" => true},
-            {"name" => "groupname", "type" => "varchar"}
-          ]
-        },
-        "User" => {
-          "columns" => [
-            {"name" => "id", "type" => "int", "autoincr" => true, "primarykey" => true},
-            {"name" => "username", "type" => "varchar"}
-          ]
-        }
-      }
-    }
-    Knj::Db::Revision.new.init_db("schema" => schema, "db" => $db)
-    
-    class User < Knj::Datarow; end
-    
-    $ob = Knj::Objects.new(
-      :db => $db,
-      :datarow => true,
-      :require => false,
-      :array_enum => true,
-      :models => {
-        :User => {
-          :cache_ids => true
-        }
-      }
-    )
-    
-    $ob.adds(:User, [
-      {:username => "User 1"},
-      {:username => "User 2"},
-      {:username => "User 3"},
-      {:username => "User 4"},
-      {:username => "User 5"}
-    ])
-    
-    raise "Expected user-ID-cache to be 5 but it wasnt: #{$ob.ids_cache[:User].length}" if $ob.ids_cache[:User].length != 5
-    
-    user = $ob.get(:User, 4)
-    raise "No user returned." if !user
-    $ob.delete(user)
-    raise "Expected user-ID-cache to be 4 but it wasnt: #{$ob.ids_cache[:User].length} #{$ob.ids_cache}" if $ob.ids_cache[:User].length != 4
-    
-    $ob.deletes([$ob.get(:User, 1), $ob.get(:User, 2)])
-    raise "Expected user-ID-cache to be 2 but it wasnt: #{$ob.ids_cache[:User].length} #{$ob.ids_cache}" if $ob.ids_cache[:User].length != 2
-  end
-  
-  it "should be able to do 'select_col_as_array'" do
-    res = $ob.list(:User, {"select_col_as_array" => "id"}).to_a
-    raise "Expected length of 2 but got: #{res.length}" if res.length != 2
-  end
-  
-  it "should work even though stressed by threads (thread-safe)." do
-    userd = []
-    10.upto(25) do |i|
-      userd << {:username => "User #{i}"}
-    end
-    
-    $ob.adds(:User, userd)
-    users = $ob.list(:User).to_a
-    
-    #Stress it to test threadsafety...
-    threads = []
-    0.upto(5) do |tc|
-      threads << Knj::Thread.new do
-        0.upto(5) do |ic|
-          user = $ob.add(:User, {:username => "User #{tc}-#{ic}"})
-          raise "No user returned." if !user
-          $ob.delete(user)
-          
-          user1 = $ob.add(:User, {:username => "User #{tc}-#{ic}-1"})
-          user2 = $ob.add(:User, {:username => "User #{tc}-#{ic}-2"})
-          user3 = $ob.add(:User, {:username => "User #{tc}-#{ic}-3"})
-          
-          raise "Missing user?" if !user1 or !user2 or !user3 or user1.deleted? or user2.deleted? or user3.deleted?
-          $ob.deletes([user1, user2, user3])
-          
-          count = 0
-          users.each do |user|
-            count += 1
-            user[:username] = "#{user[:username]}." if !user.deleted?
-          end
-          
-          raise "Expected at least 15 users but got #{count}." if count != 18
-        end
-      end
-    end
-    
-    threads.each do |thread|
-      thread.join
-    end
-  end
-  
-  it "should be able to skip queries when adding" do
-    class Group < Knj::Datarow; end
-    
-    $ob2 = Knj::Objects.new(
-      :db => $db,
-      :datarow => true,
-      :require => false
-    )
-    
-    threads = []
-    0.upto(5) do
-      threads << Knj::Thread.new do
-        0.upto(5) do
-          ret = $ob2.add(:Group, {:groupname => "User 1"}, {:skip_ret => true})
-          raise "Expected empty return but got something: #{ret}" if ret
-        end
-      end
-    end
-    
-    threads.each do |thread|
-      thread.join
-    end
-  end
-  
-  it "should delete the temporary database." do
-    File.unlink($db_path) if File.exists?($db_path)
-  end
-  
-  #Moved from "knjrbfw_spec.rb"
-  it "should be able to generate a sample SQLite database and add a sample table, with sample columns and with a sample index to it" do
-    $db_path = "#{Knj::Os.tmpdir}/knjrbfw_test_sqlite3.sqlite3"
-    $db = Knj::Db.new(
-      :type => "sqlite3",
-      :path => $db_path,
-      :return_keys => "symbols",
-      :index_append_table_name => true
-    )
-    
-    $db.tables.create("Project", {
-      "columns" => [
-        {"name" => "id", "type" => "int", "autoincr" => true, "primarykey" => true},
-        {"name" => "category_id", "type" => "int"},
-        {"name" => "name", "type" => "varchar"}
-      ],
-      "indexes" => [
-        {"name" => "category_id", "columns" => ["category_id"]}
-      ]
-    })
-    
-    $db.tables.create("Task", {
-      "columns" => [
-        {"name" => "id", "type" => "int", "autoincr" => true, "primarykey" => true},
-        {"name" => "project_id", "type" => "int"},
-        {"name" => "person_id", "type" => "int"},
-        {"name" => "name", "type" => "varchar"}
-      ],
-      "indexes" => [
-        {"name" => "project_id", "columns" => ["project_id"]}
-      ]
-    })
-    
-    $db.tables.create("Person", {
-      "columns" => [
-        {"name" => "id", "type" => "int", "autoincr" => true, "primarykey" => true},
-        {"name" => "name", "type" => "varchar"}
-      ]
-    })
-    
-    $db.tables.create("Timelog", {
-      "columns" => [
-        {"name" => "id", "type" => "int", "autoincr" => true, "primarykey" => true},
-        {"name" => "person_id", "type" => "int"}
-      ],
-      "indexes" => [
-        "person_id"
-      ]
-    })
-    
-    table = $db.tables["Project"]
-    
-    indexes = table.indexes
-    raise "Could not find the sample-index 'category_id' that should have been created." if !indexes["Project__category_id"]
-    
-    
-    #If we insert a row the ID should increase and the name should be the same as inserted (or something is very very wrong)...
-    $db.insert("Project", {
-      "name" => "Test project"
-    })
-    
-    count = 0
-    $db.q("SELECT * FROM Project") do |d|
-      raise "Somehow name was not 'Test project'" if d[:name] != "Test project"
-      raise "ID was not set?" if d[:id].to_i <= 0
-      count += 1
-    end
-    
-    raise "Expected count of 1 but it wasnt: #{count}" if count != 1
-  end
-  
-  it "should be able to automatic generate methods on datarow-classes (has_many, has_one)." do
-    class Project < Knj::Datarow
-      has_many [
-        {:class => :Task, :col => :project_id, :depends => true}
-      ]
-    end
-    
-    class Task < Knj::Datarow
-      has_one [
-        {:class => :Person, :required => true},
-        :Project
-      ]
-    end
-    
-    class Person < Knj::Datarow
-      has_one [:Project]
-      
-      has_many [
-        {:class => :Timelog, :autozero => true}
-      ]
-      
-      def html
-        return self[:name]
-      end
-    end
-    
-    class Timelog < Knj::Datarow
-      
-    end
-    
-    $ob = Knj::Objects.new(:db => $db, :datarow => true, :require => false)
-    
-    $ob.add(:Person, {
-      :name => "Kasper"
-    })
-    $ob.add(:Task, {
-      :name => "Test task",
-      :person_id => 1,
-      :project_id => 1
-    })
-    
-    begin
-      $obb.add(:Task, {:name => "Test task"})
-      raise "Method should fail but didnt."
-    rescue
-      #ignore.
-    end
-    
-    
-    #Test 'list_invalid_required'.
-    $db.insert(:Task, :name => "Invalid require")
-    id = $db.last_id
-    found = false
-    
-    $ob.list_invalid_required(:class => :Task) do |d|
-      raise "Expected object ID to be #{id} but it wasnt: #{d[:obj].id}" if d[:obj].id.to_i != id.to_i
-      $ob.delete(d[:obj])
-      found = true
-    end
-    
-    raise "Expected to find a task but didnt." if !found
-    
-    
-    ret_proc = []
-    $ob.list(:Task) do |task|
-      ret_proc << task
-    end
-    
-    raise "list with proc should return one task but didnt." if ret_proc.length != 1
-    
-    
-    project = $ob.get(:Project, 1)
-    
-    tasks = project.tasks
-    raise "No tasks were found on project?" if tasks.empty?
-    
-    
-    ret_proc = []
-    ret_test = project.tasks do |task|
-      ret_proc << task
-    end
-    
-    raise "When given a block the return should be nil so it doesnt hold weak-ref-objects in memory but it didnt return nil." if ret_test != nil
-    raise "list for project with proc should return one task but didnt (#{ret_proc.length})." if ret_proc.length != 1
-    
-    person = tasks.first.person
-    project_second = tasks.first.project
-    
-    raise "Returned object was not a person on task." if !person.is_a?(Person)
-    raise "Returned object was not a project on task." if !project_second.is_a?(Project)
-    
-    
-    #Check that has_many-depending is actually working.
-    begin
-      $ob.delete(project)
-      raise "It was possible to delete project 1 even though task 1 depended on it!"
-    rescue
-      #this should happen - it should not possible to delete project 1 because task 1 depends on it."
-    end
-  end
-  
-  it "should be able to generate lists for inputs" do
-    Knj::Web.inputs([{
-      :title => "Test 3",
-      :name => :seltest3,
-      :type => :select,
-      :default => 1,
-      :opts => $ob.list_optshash(:Task)
-    }])
-  end
-  
-  it "should be able to connect to objects 'no-html' callback and test it." do
-    task = $ob.get(:Task, 1)
-    $ob.events.connect(:no_html) do |event, classname|
-      "[no #{classname.to_s.downcase}]"
-    end
-    
-    raise "Unexpected person_html from task (should have been 'Kasper'): '#{task.person_html}'." if task.person_html != "Kasper"
-    task.update(:person_id => 0)
-    raise "Unexpected person_html from task (should have been '[no person]')." if task.person_html != "[no person]"
-  end
-  
-  it "should be able to to multiple additions and delete objects through a buffer" do
-    objs = []
-    0.upto(500) do
-      objs << {:name => :Kasper}
-    end
-    
-    $ob.adds(:Person, objs)
-    pers_length = $ob.list(:Person, "count" => true)
-    
-    count = 0
-    $db.q_buffer do |buffer|
-      $ob.list(:Person) do |person|
-        count += 1
-        $ob.delete(person, :db_buffer => buffer)
-      end
-      
-      buffer.flush
-    end
-    
-    raise "Expected count to be #{pers_length} but it wasnt: #{count}" if count != pers_length
-    
-    persons = $ob.list(:Person).to_a
-    raise "Expected persons count to be 0 but it wasnt: #{persons.map{|e| e.data} }" if persons.length > 0
-  end
-  
-  it "should do autozero when deleting objects" do
-    person1 = $ob.add(:Person, {
-      :name => "Kasper"
-    })
-    person2 = $ob.add(:Person, {
-      :name => "Charlotte"
-    })
-    
-    timelog1 = $ob.add(:Timelog, {
-      :person_id => person1.id
-    })
-    timelog2 = $ob.add(:Timelog, {
-      :person_id => person2.id
-    })
-    
-    $ob.delete(person1)
-    
-    raise "Expected timelog1's person-ID to be zero but it wasnt: '#{timelog1[:person_id]}'." if timelog1[:person_id].to_i != 0
-    raise "Expected timelog2's person-ID to be #{person2.id} but it wasnt: '#{timelog2[:person_id]}'." if timelog2[:person_id].to_i != person2.id.to_i
-  end
-  
-  it "should be able to do multiple deletes from ids" do
-    ids = []
-    1.upto(10) do |count|
-      ids << $ob.add(:Person).id
-    end
-    
-    $ob.delete_ids(:class => :Person, :ids => ids)
-  end
-  
-  it "should delete the temp database again." do
-    db_path = "#{Knj::Os.tmpdir}/knjrbfw_test_sqlite3.sqlite3"
-    File.unlink(db_path) if File.exists?(db_path)
-  end
-end

data/spec/process_meta_spec.rb

@@ -1,172 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "Process_meta" do
-  it "should be able to start a server and a client" do
-    require "knj/process_meta"
-    require "timeout"
-    
-    #Start the activity.
-    $process_meta = Knj::Process_meta.new("debug" => true, "debug_err" => true, "id" => "process_meta_spec")
-  end
-  
-  it "should be able to do simple blocks" do
-    block_ran = false
-    fpath = "#{Knj::Os.tmpdir}/process_meta_file_open"
-    
-    Timeout.timeout(4) do
-      $process_meta.static(:File, :open, fpath, "w") do |fp|
-        block_ran = true
-        fp.write("Test!")
-      end
-    end
-    
-    raise "Block didnt run!" if !block_ran
-    raise "Unexpected file-content." if File.read(fpath) != "Test!"
-    File.unlink(fpath) if File.exists?(fpath)
-  end
-  
-  it "should be able to do various operations" do
-    #Test that breaking a block wont continue to run in the process.
-    $process_meta.str_eval("
-      class Testclass
-        attr_reader :last_num
-        
-        def initialize
-          @num = 0
-        end
-        
-        def test_block
-          @num.upto(10) do |i|
-            @last_num = i
-            yield(i)
-          end
-        end
-      end
-    ")
-    
-    proxy_obj = $process_meta.new(:Testclass)
-    proxy_obj2 = $process_meta.new(:Testclass)
-    proxy_obj3 = $process_meta.new(:Testclass)
-    
-    $ids = []
-    $ids << proxy_obj.__id__
-    $ids << proxy_obj2.__id__
-    $ids << proxy_obj3.__id__
-    
-    proxy_obj.test_block do |i|
-      break if i == 5
-    end
-    
-    last_num = proxy_obj.last_num
-    raise "Expected last num to be 5 but it wasnt: '#{last_num}'." if last_num != 5
-    
-    #Somehow define_finalizer is always one behind, so we have to do another funny one here.
-    ObjectSpace.define_finalizer(self, $process_meta.method(:proxy_finalizer))
-  end
-  
-  it "should be able to do more" do
-    GC.start
-    
-    #Its difficult to test this on JRuby.
-    if RUBY_ENGINE != "jruby"
-      count = 0
-      $ids.each do |id|
-        count += 1
-        raise "The object should no longer exist but it does: #{count}." if $process_meta.proxy_has?(id)
-      end
-    end
-    
-    
-    #Spawn a test-object - a string - with a variable-name.
-    proxy_obj = $process_meta.spawn_object(:String, "my_test_var", "Kasper")
-    raise "to_s should return 'Kasper' but didnt: '#{proxy_obj.to_s}'." if proxy_obj.to_s != "Kasper"
-    
-    #Stress it a little by doing 500 calls.
-    0.upto(500) do
-      res = proxy_obj.slice(0, 3)
-      raise "Expected output was: 'Kas' but wasnt: '#{res}'." if res != "Kas"
-    end
-    
-    #Do a lot of calls at the same time to test thread-safety.
-    threads = []
-    0.upto(10) do |thread_i|
-      should_return = "Kasper".slice(0, thread_i)
-      thread = Knj::Thread.new do
-        0.upto(500) do |num_i|
-          res = proxy_obj.slice(0, thread_i)
-          raise "Should return: '#{should_return}' but didnt: '#{res}'." if res != should_return
-        end
-      end
-      
-      threads << thread
-    end
-    
-    threads.each do |thread|
-      thread.join
-    end
-    
-    
-    
-    #Try to define an integer and run upto with a block.
-    proxy_int = $process_meta.spawn_object(:Integer, nil, 5)
-    expect = 5
-    proxy_int.upto(1000) do |i|
-      raise "Expected '#{expect}' but got: '#{i}'." if i != expect
-      expect += 1
-    end
-    
-    #Ensure the expected has actually been increased by running the block.
-    raise "Expected end-result of 1001 but got: '#{expect}'." if expect != 1001
-    
-    
-    proxy_int = $process_meta.spawn_object(:Integer, nil, 5)
-    proxy_int._process_meta_block_buffer_use = true
-    expect = 5
-    
-    #If this takes more than 10 secs - something is wrong (JRuby can take a long time)...
-    Timeout.timeout(10) do
-      proxy_int.upto(10000) do |i|
-        raise "Expected '#{expect}' but got: '#{i}'." if i != expect
-        expect += 1
-      end
-    end
-    
-    
-    #Ensure the expected has actually been increased by running the block.
-    raise "Expected end-result of 10001 but got: '#{expect}'." if expect != 10001
-    
-    #Try to unset an object.
-    proxy_obj._process_meta_unset
-    proxy_int._process_meta_unset
-  end
-  
-  it "should be able to do slow block-results in JRuby." do
-    $process_meta.str_eval("
-      class Kaspertest
-        def self.kaspertest
-          8.upto(12) do |i|
-            yield(i)
-            sleep 0.5
-          end
-        end
-      end
-      
-      nil
-    ")
-    
-    Timeout.timeout(10) do
-      expect = 8
-      $process_meta.static("Kaspertest", "kaspertest") do |count|
-        raise "Expected '#{expect}' but got: '#{count}'." if expect != count
-        expect += 1
-      end
-      
-      raise "Expected '13' but got: '#{expect}'." if expect != 13
-    end
-  end
-  
-  it "should be able to be destroyed." do
-    #Destroy the process-meta which should stop the process.
-    $process_meta.destroy
-  end
-end