knjrbfw 0.0.110 → 0.0.114

data/lib/knj/sshrobot/sshrobot.rb

@@ -1,135 +0,0 @@
-class Knj::SSHRobot
-  def initialize(args)
-    require "net/ssh"
-    
-    @forwards = []
-    @args = Knj::ArrayExt.hash_sym(args)
-    @args[:port] = 22 if !@args.key?(:port)
-    
-    if block_given?
-      begin
-        yield(self)
-      ensure
-        self.close
-      end
-    end
-  end
-  
-  #Spawns a session if it hasnt already been spawned and returns it.
-  def session
-    @session = self.session_spawn if !@session
-    return @session
-  end
-  
-  #Spawns a new net-ssh-instance.
-  def session_spawn
-    return Net::SSH.start(@args[:host], @args[:user], :password => @args[:passwd], :port => @args[:port].to_i)
-  end
-  
-  #Returns the a shell-session.
-  def shell
-    return self.session.shell.sync
-  end
-  
-  def sftp
-    @sftp = Net::SFTP.start(@args[:host], @args[:user], @args[:passwd], :port => @args[:port].to_i)
-  end
-  
-  #Executes a command.
-  def exec(command, &block)
-    if block
-      return self.session.exec!(command) do |channel, stream, line|
-        block.call(:channel => channel, :stream => stream, :line => line)
-      end
-    else
-      return self.session.exec!(command)
-    end
-  end
-  
-  #Executes a command as "root" via "sudo". Accepts the "sudo"-password and a command.
-  def sudo_exec(sudo_passwd, command)
-    result = ""
-    
-    self.session.open_channel do |ch|
-      ch.request_pty
-      
-      ch.exec("sudo #{command}") do |ch, success|
-        ch.on_data do |ch, data|
-          if data =~ /^\[sudo\] password for (.+):\s*$/
-            ch.send_data("#{sudo_passwd}\n")
-          else
-            result << data
-          end
-        end
-      end
-    end
-    
-    self.session.loop
-    return result
-  end
-  
-  def fileExists(filepath)
-    result = self.exec("ls #{Strings.UnixSafe(filepath)}").strip
-    return true if result == filepath
-    return false
-  end
-  
-  def forward(args)
-    Knj::ArrayExt.hash_sym(args)
-    args[:type] = "local" if !args[:type]
-    args[:session] = self.session_spawn if !args[:session]
-    args[:host_local] = "0.0.0.0" if !args[:host_local]
-    return SSHRobot::Forward.new(args)
-  end
-  
-  alias getShell shell
-  alias getSFTP sftp
-  alias shellCMD exec
-  
-  def close
-    @session.close if @session
-    @session = nil
-  end
-end
-
-class Knj::SSHRobot::Forward
-  attr_reader :open
-  
-  def initialize(args)
-    @open = true
-    @args = args
-    @thread = Knj::Thread.new do
-      begin
-        #args[:session].logger.sev_threshold = Logger::Severity::DEBUG
-        if args[:type] == "local"
-          @args[:session].forward.local(@args[:host_local], @args[:port_local].to_i, @args[:host], @args[:port_remote].to_i)
-        elsif args[:type] == "remote"
-          @args[:session].forward.remote_to(@args[:port_local], @args[:host], @args[:port_remote], @args[:host_local])
-        else
-          raise "No valid type given."
-        end
-        
-        @args[:session].loop do
-          true
-        end
-      rescue => e
-        puts e.inspect
-        puts e.backtrace
-        
-        @open = false
-      end
-    end
-  end
-  
-  def close
-    if !@args
-      return nil
-    end
-    
-    @args[:session].close
-    @open = false
-    @thread.exit
-    @args = nil
-    @thread = nil
-  end
-end

data/lib/knj/sshrobot.rb

@@ -1 +0,0 @@
-require "#{$knjpath}sshrobot/sshrobot"

data/lib/knj/translations.rb

@@ -1,133 +0,0 @@
-class Knj::Translations
-  attr_accessor :args, :db, :ob, :cache
-  
-  def initialize(args)
-    @args = args
-    
-    raise "No DB given." if !@args[:db]
-    @db = @args[:db]
-    
-    @ob = Knj::Objects.new(
-      :db => @args[:db],
-      :extra_args => [self],
-      :class_path => File.dirname(__FILE__),
-      :module => Knj::Translations,
-      :require => false,
-      :datarow => true
-    )
-  end
-  
-  #Returns the translated value for an object by the given key.
-  def get(obj, key, args = {})
-    return "" if !obj
-    
-    if args[:locale]
-      locale = args[:locale].to_sym
-    else
-      locale = @args[:locale].to_sym
-    end
-    
-    #Force to symbol to save memory when caching.
-    key = key.to_sym
-    
-    #Set-get the cache-hash for the object.
-    if !obj.instance_variable_defined?("@knj_translations_cache")
-      obj.instance_variable_set("@knj_translations_cache", {})
-    end
-    
-    cache = obj.instance_variable_get("@knj_translations_cache")
-    
-    #Return from cache if set.
-    if cache.key?(key) and cache[key].key?(locale)
-      return cache[key][locale]
-    end
-    
-    trans = @ob.list(:Translation, {
-      "object_class" => obj.class.name,
-      "object_id" => obj.id,
-      "key" => key,
-      "locale" => locale
-    })
-    
-    if trans.empty?
-      print "Nothing found - returning empty string.\n" if @args[:debug] or args[:debug]
-      return ""
-    end
-    
-    trans.each do |tran|
-      if !cache[key]
-        cache[key] = {
-          locale => tran[:value]
-        }
-      elsif !cache[key][locale]
-        cache[key][locale] = tran[:value]
-      end
-    end
-    
-    return cache[key][locale]
-  end
-  
-  #Sets translations for an object by the given hash-keys and hash-values.
-  def set(obj, values, args = {})
-    #Reset cache to reflect the updates when read next time.
-    obj.instance_variable_set("@knj_translations_cache", {})
-    
-    if args[:locale]
-      locale = args[:locale]
-    else
-      locale = @args[:locale]
-    end
-    
-    values.each do |key, val|
-      trans = @ob.get_by(:Translation, {
-        "object_id" => obj.id,
-        "object_class" => obj.class.name,
-        "key" => key,
-        "locale" => locale
-      })
-      
-      if trans
-        trans.update(:value => val)
-      else
-        @ob.add(:Translation, {
-          :object => obj,
-          :key => key,
-          :locale => locale,
-          :value => val
-        })
-      end
-    end
-  end
-  
-  #Deletes all translations for a given object.
-  def delete(obj)
-    classn = obj.class.name
-    objid = obj.id.to_s
-    
-    if obj.instance_variable_defined?("@knj_translations_cache")
-      cache = obj.instance_variable_get("@knj_translations_cache")
-    end
-    
-    trans = @ob.list(:Translation, {
-      "object_id" => obj.id,
-      "object_class" => obj.class.name
-    })
-    trans.each do |tran|
-      #Delete the cache if defined on the object.
-      cache.delete(tran[:key].to_sym) if cache and cache.key?(tran[:key].to_sym)
-      
-      #Delete the translation object.
-      @ob.delete(tran)
-    end
-  end
-end
-
-class Knj::Translations::Translation < Knj::Datarow
-  def self.add(d)
-    if d.data[:object]
-      d.data[:object_class] = d.data[:object].class.name
-      d.data[:object_id] = d.data[:object].id
-      d.data.delete(:object)
-    end
-  end
-end

data/spec/amixer_spec.rb

@@ -1,32 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "Amixer" do
-  it "should load by using autoload" do
-    if Knj::Os.os == "linux"
-      require "knjrbfw"
-      $amixer = Knj::Amixer.new
-    end
-  end
-  
-  it "should register various devices" do
-    if Knj::Os.os == "linux"
-      $devices = $amixer.devices
-    end
-  end
-  
-  it "should register various mixers and do various operations on them" do
-    if Knj::Os.os == "linux"
-      $devices.each do |name, device|
-        mixers = device.mixers
-        
-        if device.active?(:stream => "PLAYBACK")
-          mixers.each do |name, mixer|
-            next if !mixer.volume?
-            mixer.vol_add -5
-            mixer.vol_add 3
-          end
-        end
-      end
-    end
-  end
-end

data/spec/arrayext_spec.rb

@@ -1,42 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "ArrayExt" do
-  it "should be able to do powersets" do
-    ps = Knj::ArrayExt.powerset(:arr => [1, 2, 3, 4]).to_a
-    raise "Expected length of 16 but it wasnt: #{ps.length}" if ps.length != 16
-    
-    ite = 0
-    Knj::ArrayExt.powerset(:arr => [1, 2, 3, 4]) do |arr|
-      ite += 1
-    end
-    
-    raise "Expected block to be executed 16 times but it wasnt: #{ite}" if ite != 16
-  end
-  
-  it "should be able to divide arrays" do
-    arr = [1, 2, 3, 4, 6, 7, 8, 9, 15, 16, 17, 18]
-    res = Knj::ArrayExt.divide(:arr => arr) do |a, b|
-      if (b - a) > 1
-        false
-      else
-        true
-      end
-    end
-    
-    raise "Expected length of 3 but it wasnt: #{res.length}" if res.length != 3
-    raise "Expected length of 4 but it wasnt: #{res[0].length}" if res[0].length != 4
-    raise "Expected length of 3 but it wasnt: #{res[1].length}" if res[1].length != 3
-    raise "Expected length of 3 but it wasnt: #{res[2].length}" if res[2].length != 3
-  end
-  
-  it "should be able to make ago-strings" do
-    arr = [1, 2]
-    Knj::ArrayExt.force_no_cols(:arr => arr, :no => 1)
-    raise "Expected length of 1 but got: #{arr.length}" if arr.length != 1
-    raise "Expected element to be 1 but it wasnt: #{arr[0]}" if arr[0] != 1
-    
-    Knj::ArrayExt.force_no_cols(:arr => arr, :no => 3, :empty => "test")
-    raise "Expected length of 3 but got: #{arr.lengtj}" if arr.length != 3
-    raise "Expected element 2 to be 'test' but it wasnt: #{arr[2]}" if arr[2] != "test"
-  end
-end

data/spec/autoload_spec.rb

@@ -1,7 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "Autoload" do
-  it "Wref" do
-    require "#{File.dirname(__FILE__)}/../lib/knj/autoload/wref.rb"
-  end
-end

data/spec/cmd_parser_spec.rb

@@ -1,25 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "Cmd_parser" do
-  it "should be able to parse various strings" do
-    require "knjrbfw"
-    require "knj/cmd_parser"
-    require "php4r" if !Kernel.const_defined?(:Php4r)
-    
-    strs = [
-      "-rw-r--r--    1 admin    administ   186.3M Aug 30 18:09 b4u_synoptik_2011_08_30_17_57_32.sql.gz\n",
-      "-rw-r--r--    1 admin    administ        2 Nov 21 18:12 test\n",
-      "-rw-r--r--  1 kaspernj kaspernj 279943393 2011-07-27 09:28 dbdump_2011_07_27_03_07_36.sql\n",
-      "-rw-rw-r--  1 kaspernj kaspernj     58648 2011-10-28 18:33 2011-11-28 - Programmerings aften hos Anders - mad - 600 kr.pdf\n",
-      "-rw-r--r-- 1 www-data www-data 4,0K 2011-05-16 23:21 dbbackup_2011_05_16-23:21:10.sql.gz\n"
-    ]
-    
-    strs.each do |str|
-      res = Knj::Cmd_parser.lsl(str)
-      
-      res.each do |file|
-        raise "Byte was not numeric in: '#{str}'." if !(Float(file[:size]) rescue false)
-      end
-    end
-  end
-end

data/spec/db_spec.rb

@@ -1,282 +0,0 @@
-#encoding: utf-8
-
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "Db" do
-  it "should be able to handle various encodings" do
-    #I never got this test to actually fail... :-(
-    
-    require "knj/db"
-    require "knj/os"
-    require "rubygems"
-    require "sqlite3" if !Kernel.const_defined?("SQLite3") and RUBY_ENGINE != "jruby"
-    
-    db_path = "#{Knj::Os.tmpdir}/knjrbfw_test_sqlite3.sqlite3"
-    File.unlink(db_path) if File.exists?(db_path)
-    
-    db = Knj::Db.new(
-      :type => "sqlite3",
-      :path => db_path,
-      :return_keys => "symbols",
-      :index_append_table_name => true
-    )
-    
-    db.tables.create("test", {
-      "columns" => [
-        {"name" => "id", "type" => "int", "autoincr" => true, "primarykey" => true},
-        {"name" => "text", "type" => "varchar"}
-      ]
-    })
-    
-    
-    
-    #Get a list of tables and check the list for errors.
-    list = db.tables.list
-    raise "Table not found: 'test'." if !list.key?("test")
-    raise "Table-name expected to be 'test' but wasnt: '#{list["test"].name}'." if list["test"].name != "test"
-    
-    
-    #Test revision to create tables, indexes and insert rows.
-    schema = {
-      "tables" => {
-        "test_table" => {
-          "columns" => [
-            {"name" => "id", "type" => "int", "autoincr" => true, "primarykey" => true},
-            {"name" => "name", "type" => "varchar"},
-            {"name" => "age", "type" => "int"},
-            {"name" => "nickname", "type" => "varchar"}
-          ],
-          "indexes" => [
-            "name"
-          ],
-          "rows" => [
-            {
-              "find_by" => {"id" => 1},
-              "data" => {"id" => 1, "name" => "trala"}
-            }
-          ]
-        }
-      }
-    }
-    
-    rev = Knj::Db::Revision.new
-    rev.init_db("schema" => schema, "db" => db)
-    
-    
-    #Test wrong encoding.
-    cont = File.read("#{File.dirname(__FILE__)}/db_spec_encoding_test_file.txt")
-    cont.force_encoding("ASCII-8BIT")
-    
-    db.insert("test", {
-      "text" => cont
-    })
-    
-    
-    #Throw out invalid encoding because it will make dumping fail.
-    db.tables[:test].truncate
-    
-    
-    
-    #Test IDQueries.
-    rows_count = 1250
-    db.transaction do
-      0.upto(rows_count) do |count|
-        db.insert(:test_table, {:name => "User #{count}"})
-      end
-    end
-    
-    block_ran = 0
-    idq = Knj::Db::Idquery.new(:db => db, :debug => false, :table => :test_table, :query => "SELECT id FROM test_table") do |data|
-      block_ran += 1
-    end
-    
-    raise "Block with should have ran too little: #{block_ran}." if block_ran < rows_count
-    
-    block_ran = 0
-    db.select(:test_table, {}, {:idquery => true}) do |data|
-      block_ran += 1
-    end
-    
-    raise "Block with should have ran too little: #{block_ran}." if block_ran < rows_count
-    
-    
-    #Test upserting.
-    data = {:name => "Kasper Johansen"}
-    sel = {:nickname => "kaspernj"}
-    
-    table = db.tables[:test_table]
-    table.reload
-    rows_count = table.rows_count
-    
-    db.upsert(:test_table, sel, data)
-    
-    table.reload
-    table.rows_count.should eql(rows_count + 1)
-    
-    db.upsert(:test_table, sel, data)
-    
-    table.reload
-    table.rows_count.should eql(rows_count + 1)
-    
-    
-    #Test dumping.
-    dump = Knj::Db::Dump.new(:db => db, :debug => false)
-    str_io = StringIO.new
-    dump.dump(str_io)
-    str_io.rewind
-    
-    
-    #Remember some numbers for validation.
-    tables_count = db.tables.list.length
-    
-    
-    #Remove everything in the db.
-    db.tables.list do |table|
-      table.drop unless table.native?
-    end
-    
-    
-    #Run the exported SQL.
-    db.transaction do
-      str_io.each_line do |sql|
-        db.q(sql)
-      end
-    end
-    
-    
-    #Vaildate import.
-    raise "Not same amount of tables: #{tables_count}, #{db.tables.list.length}" if tables_count != db.tables.list.length
-    
-    
-    
-    #Test revision table renaming.
-    Knj::Db::Revision.new.init_db("db" => db, "schema" => {
-      "tables" => {
-        "new_test_table" => {
-          "renames" => ["test_table"]
-        }
-      }
-    })
-    tables = db.tables.list
-    raise "Didnt expect table 'test_table' to exist but it did." if tables.key?("test_table")
-    raise "Expected 'new_test_table' to exist but it didnt." if !tables.key?("new_test_table")
-    
-    
-    #Test revision for column renaming.
-    Knj::Db::Revision.new.init_db("db" => db, "schema" => {
-      "tables" => {
-        "new_test_table" => {
-          "columns" => [
-            {"name" => "new_name", "type" => "varchar", "renames" => ["name"]}
-          ]
-        }
-      }
-    })
-    columns = db.tables["new_test_table"].columns
-    raise "Didnt expect 'name' to exist but it did." if columns.key?("name")
-    raise "Expected 'new_name'-column to exist but it didnt." if !columns.key?("new_name")
-    
-    
-    #Delete test-database if everything went well.
-    File.unlink(db_path) if File.exists?(db_path)
-  end
-  
-  it "should generate proper sql" do
-    require "knj/db"
-    require "knj/os"
-    require "rubygems"
-    require "sqlite3" if !Kernel.const_defined?("SQLite3") and RUBY_ENGINE != "jruby"
-    
-    db_path = "#{Knj::Os.tmpdir}/knjrbfw_test_sqlite3.sqlite3"
-    File.unlink(db_path) if File.exists?(db_path)
-    
-    db = Knj::Db.new(
-      :type => "sqlite3",
-      :path => db_path,
-      :return_keys => "symbols",
-      :index_append_table_name => true
-    )
-    
-    time = Time.new(1985, 6, 17, 10, 30)
-    db.insert(:test, {:date => time}, :return_sql => true).should eql("INSERT INTO `test` (`date`) VALUES ('1985-06-17 10:30:00')")
-    
-    date = Date.new(1985, 6, 17)
-    db.insert(:test, {:date => date}, :return_sql => true).should eql("INSERT INTO `test` (`date`) VALUES ('1985-06-17')")
-  end
-  
-  it "should copy database structure and data" do
-    require "knj/db"
-    require "knj/os"
-    require "rubygems"
-    require "sqlite3" if !Kernel.const_defined?("SQLite3") and RUBY_ENGINE != "jruby"
-    
-    db_path1 = "#{Knj::Os.tmpdir}/knjrbfw_test_sqlite3_db1.sqlite3"
-    File.unlink(db_path1) if File.exists?(db_path1)
-    
-    db_path2 = "#{Knj::Os.tmpdir}/knjrbfw_test_sqlite3_db2.sqlite3"
-    File.unlink(db_path2) if File.exists?(db_path2)
-    
-    db1 = Knj::Db.new(
-      :type => "sqlite3",
-      :path => db_path1,
-      :return_keys => "symbols",
-      :index_append_table_name => true
-    )
-    
-    db1.tables.create(:test_table, {
-      "columns" => [
-        {"name" => "id", "type" => "int", "autoincr" => true, "primarykey" => true},
-        {"name" => "testname", "type" => "varchar"}
-      ],
-      "indexes" => [
-        "testname"
-      ]
-    })
-    
-    table1 = db1.tables["test_table"]
-    cols1 = table1.columns
-    
-    100.times do |count|
-      table1.insert(:testname => "TestRow#{count}")
-    end
-    
-    db2 = Knj::Db.new(
-      :type => "sqlite3",
-      :path => db_path2,
-      :return_keys => "symbols",
-      :index_append_table_name => true
-    )
-    
-    begin
-      table2 = db2.tables["test_table"]
-      raise "Expected not-found exception."
-    rescue Errno::ENOENT
-      #expected
-    end
-    
-    db1.copy_to(db2)
-    
-    table2 = db2.tables["test_table"]
-    
-    cols2 = table2.columns
-    cols2.length.should eql(cols1.length)
-    
-    table2.rows_count.should eql(table1.rows_count)
-    
-    db1.select(:test_table) do |row1|
-      found = 0
-      db2.select(:test_table, row1) do |row2|
-        found += 1
-        
-        row1.each do |key, val|
-          row2[key].should eql(val)
-        end
-      end
-      
-      found.should eql(1)
-    end
-    
-    table1.indexes.length.should eql(1)
-    table2.indexes.length.should eql(table1.indexes.length)
-  end
-end

data/spec/db_spec_encoding_test_file.txt

@@ -1 +0,0 @@
-��pl��p���