├── .rspec ├── lib ├── knj │ ├── .gitignore │ ├── autoload │ │ ├── wref.rb │ │ ├── cinch.rb │ │ ├── gd2.rb │ │ ├── tzinfo.rb │ │ ├── activesupport.rb │ │ ├── parsedate.rb │ │ ├── soap.rb │ │ ├── gtk2.rb │ │ ├── facebooker.rb │ │ ├── mysql.rb │ │ ├── tmail.rb │ │ ├── zip.rb │ │ ├── magick.rb │ │ ├── sqlite3.rb │ │ ├── xmlsimple.rb │ │ ├── erubis.rb │ │ ├── facets_dictionary.rb │ │ ├── gettext.rb │ │ ├── json.rb │ │ ├── rexml.rb │ │ ├── backups │ │ │ ├── parsedate.rb │ │ │ └── ping.rb │ │ └── ping.rb │ ├── erb │ │ ├── cache │ │ │ └── README │ │ ├── erb_fcgi_jruby.rb │ │ ├── apache_knjerb.conf │ │ ├── erb_1.9.rb │ │ ├── erb_cache_clean.rb │ │ ├── erb.rb │ │ ├── erb_jruby.rb │ │ ├── erb_fcgi.rb │ │ └── erb_fcgi_1.9.rb │ ├── php_parser │ │ ├── arguments.rb │ │ ├── tests │ │ │ ├── test_function.php │ │ │ ├── test.rb │ │ │ └── test_function_run.rb │ │ ├── php_parser.rb │ │ └── functions.rb │ ├── ironruby-gtk2 │ │ ├── iconsize.rb │ │ ├── gtk_menu.rb │ │ ├── gdk_event.rb │ │ ├── stock.rb │ │ ├── vbox.rb │ │ ├── gtk_cellrenderertext.rb │ │ ├── gtk_filechooserbutton.rb │ │ ├── gtk_menuitem.rb │ │ ├── entry.rb │ │ ├── gtk_statusicon.rb │ │ ├── gdk_eventbutton.rb │ │ ├── gdk_pixbuf.rb │ │ ├── glib.rb │ │ ├── gtk_treeselection.rb │ │ ├── image.rb │ │ ├── gtk_treeview.rb │ │ ├── gtk_combobox.rb │ │ ├── gtk_liststore.rb │ │ ├── tests │ │ │ ├── test_2.rb │ │ │ ├── test.glade │ │ │ └── test_ironruby_window.rb │ │ ├── button.rb │ │ ├── label.rb │ │ ├── window.rb │ │ ├── gtk_treeiter.rb │ │ ├── gtk_builder.rb │ │ ├── gtk_treeviewcolumn.rb │ │ ├── dialog.rb │ │ ├── gladexml.rb │ │ └── gtk2.rb │ ├── scripts │ │ ├── keepalive.rb │ │ ├── degulesider.rb │ │ ├── ip2location.rb │ │ ├── svn_merge.rb │ │ ├── upgrade_knjrbfw_checker.rb │ │ ├── filesearch.rb │ │ └── speed_test.rb │ ├── jruby-gtk2 │ │ ├── tests │ │ │ ├── test_trayicon.png │ │ │ ├── test_normal_window.rb │ │ │ ├── test_trayicon.rb │ │ │ └── test_glade_window.rb │ │ ├── checkbutton.rb │ │ ├── iconsize.rb │ │ ├── image.rb │ │ ├── cellrenderertext.rb │ │ ├── hbox.rb │ │ ├── stock.rb │ │ ├── statusicon.rb │ │ ├── window.rb │ │ ├── vbox.rb │ │ ├── progressbar.rb │ │ ├── builder │ │ │ ├── test_builder.rb │ │ │ ├── test_builder.ui │ │ │ └── test_builder.glade │ │ ├── eventbutton.rb │ │ ├── combobox.rb │ │ ├── builder.rb │ │ ├── menu.rb │ │ ├── dialog.rb │ │ ├── liststore.rb │ │ ├── treeview.rb │ │ └── gladexml.rb │ ├── win.rb │ ├── tests │ │ ├── test_degulesider.rb │ │ ├── compiler │ │ │ ├── compiler_test.rb │ │ │ └── compiler_test_file.rb │ │ ├── test_http2.rb │ │ ├── test_http2_proxy.rb │ │ └── test_mount.rb │ ├── rhodes │ │ ├── mutex.rb │ │ ├── rhodes.js │ │ ├── youtube_embed.erb │ │ └── youtube_open.erb │ ├── fs │ │ ├── drivers │ │ │ ├── filesystem.rb │ │ │ ├── ssh.rb │ │ │ └── ftp.rb │ │ └── fs.rb │ ├── filesystem.rb │ ├── libqt_window.rb │ ├── includes │ │ ├── require_info.rb │ │ └── appserver_cli.rb │ ├── jruby_compiler.rb │ ├── rand.rb │ ├── ip2location.rb │ ├── sysuser.rb │ ├── rsvgbin.rb │ ├── gettext_fallback.rb │ ├── knj_controller.rb │ ├── csv.rb │ ├── power_manager.rb │ ├── thread.rb │ ├── exchangerates.rb │ ├── youtube.rb │ ├── gtk2_msgbox.rb │ ├── nvidia_settings.rb │ ├── thread2.rb │ ├── notify.rb │ ├── x11vnc.rb │ ├── hash_methods.rb │ ├── mutexcl.rb │ ├── gtk2_window.rb │ ├── opts.rb │ ├── degulesider.rb │ ├── errors.rb │ ├── cpufreq.rb │ ├── gtk2_menu.rb │ ├── gtk2_statuswindow.rb │ ├── maemo │ │ └── fremantle-calendar │ │ │ └── fremantle-calendar.rb │ ├── event_filemod.rb │ ├── sms.rb │ ├── win_registry.rb │ ├── compiler.rb │ ├── iotop.rb │ ├── locale_strings.rb │ ├── mail.rb │ ├── libqt.rb │ ├── mailobj.rb │ ├── cmd_gen.rb │ ├── knj.rb │ ├── cmd_parser.rb │ ├── google_sitemap.rb │ ├── gettext_threadded.rb │ ├── autoload.rb │ ├── mount.rb │ ├── locales.rb │ ├── kvm.rb │ ├── event_handler.rb │ ├── facebook_connect.rb │ ├── win_tightvnc.rb │ ├── gtk2_cb.rb │ ├── amixer.rb │ ├── threadhandler.rb │ ├── unix_proc.rb │ └── webscripts │ │ └── image.rhtml └── knjrbfw.rb ├── Gemfile ├── .document ├── testfiles └── image.jpg ├── spec ├── autoload_spec.rb ├── locales_spec.rb ├── spec_helper.rb ├── amixer_spec.rb ├── cmd_parser_spec.rb ├── arrayext_spec.rb ├── strings_spec.rb ├── web_spec.rb └── knjrbfw_spec.rb ├── .github └── dependabot.yml ├── peak_flow.yml ├── README.rdoc ├── Rakefile ├── .gitignore ├── LICENSE.txt ├── knjrbfw.gemspec └── Gemfile.lock /.rspec: -------------------------------------------------------------------------------- 1 | --color 2 | -------------------------------------------------------------------------------- /lib/knj/.gitignore: -------------------------------------------------------------------------------- 1 | erb/cache/* 2 | -------------------------------------------------------------------------------- /Gemfile: -------------------------------------------------------------------------------- 1 | source "http://rubygems.org" 2 | gemspec 3 | -------------------------------------------------------------------------------- /lib/knj/autoload/wref.rb: -------------------------------------------------------------------------------- 1 | Knj.gem_require(:Wref, :wref) -------------------------------------------------------------------------------- /lib/knj/autoload/cinch.rb: -------------------------------------------------------------------------------- 1 | require "rubygems" 2 | require "cinch" -------------------------------------------------------------------------------- /lib/knj/autoload/gd2.rb: -------------------------------------------------------------------------------- 1 | require "rubygems" 2 | require "gd2" -------------------------------------------------------------------------------- /lib/knj/autoload/tzinfo.rb: -------------------------------------------------------------------------------- 1 | require "rubygems" 2 | require "tzinfo" -------------------------------------------------------------------------------- /lib/knj/autoload/activesupport.rb: -------------------------------------------------------------------------------- 1 | require "rubygems" 2 | require "active_support" -------------------------------------------------------------------------------- /lib/knj/autoload/parsedate.rb: -------------------------------------------------------------------------------- 1 | require "#{$knjpath}autoload/backups/parsedate.rb" -------------------------------------------------------------------------------- /.document: -------------------------------------------------------------------------------- 1 | lib/**/*.rb 2 | bin/* 3 | - 4 | features/**/*.feature 5 | LICENSE.txt 6 | -------------------------------------------------------------------------------- /lib/knj/erb/cache/README: -------------------------------------------------------------------------------- 1 | This is where cache-files are stored for fast execution. 2 | -------------------------------------------------------------------------------- /testfiles/image.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kaspernj/knjrbfw/HEAD/testfiles/image.jpg -------------------------------------------------------------------------------- /lib/knj/autoload/soap.rb: -------------------------------------------------------------------------------- 1 | module SOAP 2 | autoload :WSDLDriverFactory, "soap/wsdlDriver" 3 | end -------------------------------------------------------------------------------- /lib/knj/php_parser/arguments.rb: -------------------------------------------------------------------------------- 1 | class Knj::Php_parser 2 | def args 3 | 4 | end 5 | end -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/iconsize.rb: -------------------------------------------------------------------------------- 1 | class Gtk::IconSize 2 | DIALOG = RealGtk::IconSize.Dialog 3 | end -------------------------------------------------------------------------------- /lib/knj/autoload/gtk2.rb: -------------------------------------------------------------------------------- 1 | require "gtk2" 2 | 3 | module Gtk 4 | autoload :MozEmbed, "gtkmozembed" 5 | end -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/gtk_menu.rb: -------------------------------------------------------------------------------- 1 | class Gtk::Menu 2 | def popup(*paras) 3 | @ob.popup 4 | end 5 | end -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/gdk_event.rb: -------------------------------------------------------------------------------- 1 | class Gdk::Event 2 | BUTTON_PRESS = RealGdk::EventType.ButtonPress 3 | end -------------------------------------------------------------------------------- /lib/knj/scripts/keepalive.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | 3 | while true 4 | print "Keel-alive\n" 5 | sleep 1 6 | end -------------------------------------------------------------------------------- /lib/knj/autoload/facebooker.rb: -------------------------------------------------------------------------------- 1 | require "rubygems" 2 | require "#{File.dirname(__FILE__)}/json_autoload" 3 | require "facebooker" -------------------------------------------------------------------------------- /lib/knj/autoload/mysql.rb: -------------------------------------------------------------------------------- 1 | begin 2 | require "mysql" 3 | rescue LoadError 4 | require "rubygems" 5 | require "mysql" 6 | end -------------------------------------------------------------------------------- /lib/knj/autoload/tmail.rb: -------------------------------------------------------------------------------- 1 | begin 2 | require "tmail" 3 | rescue LoadError 4 | require "rubygems" 5 | require "tmail" 6 | end -------------------------------------------------------------------------------- /lib/knj/autoload/zip.rb: -------------------------------------------------------------------------------- 1 | begin 2 | require "zip/zip" 3 | rescue LoadError 4 | require "rubygems" 5 | require "zip" 6 | end -------------------------------------------------------------------------------- /lib/knj/autoload/magick.rb: -------------------------------------------------------------------------------- 1 | begin 2 | require "rmagick" 3 | rescue LoadError 4 | require "rubygems" 5 | require "rmagick" 6 | end -------------------------------------------------------------------------------- /lib/knj/autoload/sqlite3.rb: -------------------------------------------------------------------------------- 1 | begin 2 | require "sqlite3" 3 | rescue LoadError 4 | require "rubygems" 5 | require "sqlite3" 6 | end -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/stock.rb: -------------------------------------------------------------------------------- 1 | module Gtk::Stock 2 | OK = RealGtk::Stock.Ok 3 | DIALOG_WARNING = RealGtk::Stock.DialogWarning 4 | end -------------------------------------------------------------------------------- /lib/knj/jruby-gtk2/tests/test_trayicon.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kaspernj/knjrbfw/HEAD/lib/knj/jruby-gtk2/tests/test_trayicon.png -------------------------------------------------------------------------------- /lib/knj/autoload/xmlsimple.rb: -------------------------------------------------------------------------------- 1 | begin 2 | require "xmlsimple" 3 | rescue LoadError 4 | require "rubygems" 5 | require "xmlsimple" 6 | end -------------------------------------------------------------------------------- /lib/knjrbfw.rb: -------------------------------------------------------------------------------- 1 | module Knj 2 | end 3 | 4 | $knjpath = "knj/" if !$knjpath 5 | $: << File.dirname(__FILE__) 6 | 7 | require "#{$knjpath}knj" -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/vbox.rb: -------------------------------------------------------------------------------- 1 | class Gtk::VBox 2 | def pack_start(widget, arg1 = false, arg2 = false) 3 | @ob.PackStart(widget.ob) 4 | end 5 | end -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/gtk_cellrenderertext.rb: -------------------------------------------------------------------------------- 1 | class Gtk::CellRendererText 2 | def initialize(*paras) 3 | @ob = RealGtk::CellRendererText.new 4 | end 5 | end -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/gtk_filechooserbutton.rb: -------------------------------------------------------------------------------- 1 | class Gtk::FileChooserButton 2 | def filename=(newfilename) 3 | @ob.set_filename(newfilename) 4 | end 5 | end -------------------------------------------------------------------------------- /lib/knj/jruby-gtk2/checkbutton.rb: -------------------------------------------------------------------------------- 1 | class Gtk::CheckButton 2 | #nothing here yet... once there were something here... but that was a long long time ago... 3 | end -------------------------------------------------------------------------------- /lib/knj/win.rb: -------------------------------------------------------------------------------- 1 | module Knj::Win 2 | #Autoloader. 3 | def self.const_missing(name) 4 | require "#{$knjpath}knj/win_#{name.to_s.downcase}" 5 | end 6 | end -------------------------------------------------------------------------------- /lib/knj/autoload/erubis.rb: -------------------------------------------------------------------------------- 1 | module Erubis; end #bugfix 2 | 3 | begin 4 | require "erubis" 5 | rescue LoadError 6 | require "rubygems" 7 | require "erubis" 8 | end -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/gtk_menuitem.rb: -------------------------------------------------------------------------------- 1 | Gtk.events["Gtk"]["MenuItem"] = { 2 | "activate" => "activated" 3 | } 4 | 5 | class Gtk::MenuItem 6 | #nothing here yet. 7 | end -------------------------------------------------------------------------------- /lib/knj/erb/erb_fcgi_jruby.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/jruby 2 | 3 | require "fcgi" 4 | FCGI.each_cgi do |fcgi| 5 | print "Content-Type: text/html\n\n" 6 | print "Hello world." 7 | end 8 | -------------------------------------------------------------------------------- /lib/knj/php_parser/tests/test_function.php: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /lib/knj/jruby-gtk2/iconsize.rb: -------------------------------------------------------------------------------- 1 | class Gtk::IconSize 2 | DIALOG = org.gnome.gtk.IconSize::DIALOG 3 | BUTTON = org.gnome.gtk.IconSize::BUTTON 4 | MENU = org.gnome.gtk.IconSize::MENU 5 | end -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/entry.rb: -------------------------------------------------------------------------------- 1 | Gtk.events["Gtk"]["Entry"] = { 2 | "activate" => "activate" 3 | } 4 | 5 | class Gtk::Entry 6 | def set_text(newtext) 7 | @ob.text = newtext 8 | end 9 | end -------------------------------------------------------------------------------- /lib/knj/autoload/facets_dictionary.rb: -------------------------------------------------------------------------------- 1 | require "rubygems" 2 | 3 | begin 4 | require "facets/dictionary" 5 | rescue LoadError 6 | require File.dirname(__FILE__) + "/backups/facets_dictionary" 7 | end -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/gtk_statusicon.rb: -------------------------------------------------------------------------------- 1 | Gtk.events["Gtk"]["StatusIcon"] = { 2 | "activate" => "activate", 3 | "popup-menu" => "popup_menu" 4 | } 5 | 6 | class Gtk::StatusIcon 7 | #nothing here yet. 8 | end -------------------------------------------------------------------------------- /spec/autoload_spec.rb: -------------------------------------------------------------------------------- 1 | require File.expand_path(File.dirname(__FILE__) + '/spec_helper') 2 | 3 | describe "Autoload" do 4 | it "Wref" do 5 | require "#{File.dirname(__FILE__)}/../lib/knj/autoload/wref.rb" 6 | end 7 | end -------------------------------------------------------------------------------- /lib/knj/tests/test_degulesider.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | 3 | require "knj/autoload" 4 | 5 | dgs = Knj::Degulesider.new 6 | results = dgs.search( 7 | :where => "Engvej 3, 4970 Rødby" 8 | ) 9 | 10 | Php4r.print_r(results) -------------------------------------------------------------------------------- /lib/knj/rhodes/mutex.rb: -------------------------------------------------------------------------------- 1 | class Mutex 2 | def synchronize 3 | sleep 0.05 while @working 4 | @working = true 5 | 6 | begin 7 | yield 8 | ensure 9 | @working = false 10 | end 11 | end 12 | end -------------------------------------------------------------------------------- /lib/knj/erb/apache_knjerb.conf: -------------------------------------------------------------------------------- 1 | AddType text/html .rhtml 2 | 3 | ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/ 4 | 5 | 6 | AddType application/x-httpd-knj .rhtml 7 | Action application/x-httpd-knj "/cgi-bin/knjerb" 8 | -------------------------------------------------------------------------------- /.github/dependabot.yml: -------------------------------------------------------------------------------- 1 | version: 2 2 | updates: 3 | - package-ecosystem: bundler 4 | directory: "/" 5 | schedule: 6 | interval: daily 7 | time: "01:00" 8 | timezone: Europe/Copenhagen 9 | open-pull-requests-limit: 99 10 | -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/gdk_eventbutton.rb: -------------------------------------------------------------------------------- 1 | class Gdk::EventButton 2 | def initialize(*paras) 3 | #take no args. 4 | end 5 | 6 | def button 7 | #do nothing. 8 | end 9 | 10 | def time 11 | #do nothing. 12 | end 13 | end -------------------------------------------------------------------------------- /lib/knj/scripts/degulesider.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | 3 | require "knj/autoload" 4 | include Knj 5 | 6 | dgs = Degulesider.new 7 | res = dgs.search( 8 | :where => ARGV[0], 9 | :what => ARGV[1] 10 | ) 11 | 12 | print JSON.generate(res) -------------------------------------------------------------------------------- /lib/knj/jruby-gtk2/image.rb: -------------------------------------------------------------------------------- 1 | class Gtk::Image 2 | def initialize(arg1, arg2) 3 | if Gtk.takeob 4 | @ob = Gtk.takeob 5 | Gtk.takeob = nil 6 | else 7 | @ob = Gtk.evalob("org.gnome.gtk.Image").new(arg1, arg2) 8 | end 9 | end 10 | end -------------------------------------------------------------------------------- /lib/knj/scripts/ip2location.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | 3 | require "knj/autoload" 4 | ip2loc = Knj::Ip2location.new 5 | 6 | data = ip2loc.lookup(ARGV[0]) 7 | 8 | if ARGV[1] == "json" 9 | print Php4r.json_encode(data) 10 | else 11 | Php4r.print_r(data) 12 | end -------------------------------------------------------------------------------- /lib/knj/autoload/gettext.rb: -------------------------------------------------------------------------------- 1 | #In some version just requiring gettext givet an error because you have to define the constant first... weird... 2 | module GetText; end 3 | 4 | begin 5 | require "gettext" 6 | rescue LoadError 7 | require "rubygems" 8 | require "gettext" 9 | end -------------------------------------------------------------------------------- /lib/knj/fs/drivers/filesystem.rb: -------------------------------------------------------------------------------- 1 | class Knj::Fs::Filesystem 2 | def self.args 3 | return [ 4 | { 5 | "title" => "Path", 6 | "name" => "texpath" 7 | } 8 | ] 9 | end 10 | 11 | def initialize(args) 12 | @args = args 13 | end 14 | end -------------------------------------------------------------------------------- /lib/knj/filesystem.rb: -------------------------------------------------------------------------------- 1 | class Knj::Filesystem 2 | def self.copy(args) 3 | FileUtils.rm(args[:to]) if args[:replace] and File.exist?(args[:to]) 4 | FileUtils.cp(args[:from], args[:to]) 5 | mod = File.lstat(args[:from]).mode & 0777 6 | File.chmod(mod, args[:to]) 7 | end 8 | end -------------------------------------------------------------------------------- /lib/knj/jruby-gtk2/cellrenderertext.rb: -------------------------------------------------------------------------------- 1 | class Gtk::CellRendererText 2 | def initialize 3 | if Gtk.takeob 4 | @ob = Gtk.takeob 5 | Gtk.takeob = nil 6 | end 7 | end 8 | 9 | def init(tcol) 10 | @ob = org.gnome.gtk.CellRendererText.new(tcol.ob) 11 | end 12 | end -------------------------------------------------------------------------------- /lib/knj/jruby-gtk2/hbox.rb: -------------------------------------------------------------------------------- 1 | class Gtk::HBox 2 | def initialize(homogeneous = false, spacing = 0) 3 | if Gtk.takeob 4 | @ob = Gtk.takeob 5 | Gtk.takeob = nil 6 | else 7 | @ob = Gtk.evalob("org.gnome.gtk.HBox").new(homogeneous, spacing) 8 | end 9 | end 10 | end -------------------------------------------------------------------------------- /lib/knj/rhodes/rhodes.js: -------------------------------------------------------------------------------- 1 | function knj_rhodes_html_links(args){ 2 | $.ajax({type: "POST", data: {"url": args.url}, url: "/app/Knj/html_links"}) 3 | } 4 | 5 | function knj_rhodes_youtube_open_in_app(args){ 6 | $.ajax({type: "POST", data: {"youtube_id": args.youtube_id}, url: "/app/Knj/youtube_open_in_app"}) 7 | } -------------------------------------------------------------------------------- /lib/knj/libqt_window.rb: -------------------------------------------------------------------------------- 1 | class QtWindow 2 | def self.doCenter(tha_window) 3 | qdw = Qt::DesktopWidget.new 4 | 5 | move_left = (qdw.width / 2) - (tha_window.width / 2) 6 | move_top = (qdw.height / 2) - (tha_window.height / 2) 7 | 8 | tha_window.move(move_left, move_top) 9 | end 10 | end -------------------------------------------------------------------------------- /peak_flow.yml: -------------------------------------------------------------------------------- 1 | rvm: true 2 | builds: 3 | build_1: 4 | environment: 5 | RUBY_VERSION: 2.7.8 6 | name: Ruby 2.7.8 7 | script: 8 | - bundle exec rspec 9 | build_2: 10 | environment: 11 | RUBY_VERSION: 3.2.2 12 | name: Ruby 3.2.2 13 | script: 14 | - bundle exec rspec 15 | -------------------------------------------------------------------------------- /lib/knj/jruby-gtk2/stock.rb: -------------------------------------------------------------------------------- 1 | class Gtk::Stock 2 | OK = org.gnome.gtk.Stock::OK 3 | YES = org.gnome.gtk.Stock::YES 4 | NO = org.gnome.gtk.Stock::NO 5 | DIALOG_WARNING = org.gnome.gtk.Stock::DIALOG_WARNING 6 | DIALOG_QUESTION = org.gnome.gtk.Stock::DIALOG_QUESTION 7 | DIALOG_INFO = org.gnome.gtk.Stock::DIALOG_INFO 8 | end -------------------------------------------------------------------------------- /lib/knj/tests/compiler/compiler_test.rb: -------------------------------------------------------------------------------- 1 | require "knj/knj" 2 | require "#{$knjpath}compiler" 3 | 4 | compiler = Knj::Compiler.new 5 | 6 | time_start = Time.new.to_f 7 | 8 | #0.upto(10000) do 9 | compiler.eval_file("compiler_test_file.rb") 10 | #end 11 | 12 | time_spent = Time.new.to_f - time_start 13 | print "#{time_spent}\n" -------------------------------------------------------------------------------- /lib/knj/jruby-gtk2/statusicon.rb: -------------------------------------------------------------------------------- 1 | Gtk.events << ["StatusIcon", "activate", org.gnome.gtk.StatusIcon::Activate, :onActivate, nil] 2 | Gtk.events << ["StatusIcon", "popup-menu", org.gnome.gtk.StatusIcon::PopupMenu, :onPopupMenu, nil] 3 | 4 | class Gtk::StatusIcon 5 | def pixbuf=(newpixbuf) 6 | @ob.from_pixbuf = newpixbuf.ob 7 | end 8 | end -------------------------------------------------------------------------------- /lib/knj/jruby-gtk2/window.rb: -------------------------------------------------------------------------------- 1 | Gtk.events << ["Window", "destroy", org.gnome.gtk.Window::DeleteEvent, :onDeleteEvent, false] 2 | 3 | class Gtk::Window 4 | def destroy 5 | @ob.hide #destroy does not exist in the Java-version? - knj 6 | end 7 | 8 | def set_frame_dimensions(arg1, arg2, arg3, arg4) 9 | @ob.border_width = arg1 10 | end 11 | end -------------------------------------------------------------------------------- /lib/knj/includes/require_info.rb: -------------------------------------------------------------------------------- 1 | Knj::REQUIRE_INFO = {} 2 | 3 | class Object 4 | alias_method :require_knj, :require 5 | 6 | def require(path) 7 | stat = require_knj(path) 8 | 9 | if stat and !Knj::REQUIRE_INFO.key?(path) 10 | Knj::REQUIRE_INFO[path] = {:caller => caller} 11 | end 12 | 13 | return stat 14 | end 15 | end -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/gdk_pixbuf.rb: -------------------------------------------------------------------------------- 1 | class Gdk::Pixbuf 2 | def initialize(*args) 3 | if Gtk.takeob 4 | @ob = Gtk.takeob 5 | Gtk.takeob = nil 6 | else 7 | @ob = Kernel.const_get("RealGdk").const_get("Pixbuf").method(:new).overload(System::String).call(System::String.new(args[0])) 8 | #method.call("") 9 | end 10 | end 11 | end -------------------------------------------------------------------------------- /lib/knj/jruby-gtk2/vbox.rb: -------------------------------------------------------------------------------- 1 | class Gtk::VBox 2 | def initialize 3 | if Gtk.takeob 4 | @ob = Gtk.takeob 5 | Gtk.takeob = nil 6 | else 7 | splitted = self.class.to_s.split("::") 8 | javaname = "org.gnome." + splitted.first.downcase + "." + splitted.last 9 | @ob = Gtk.evalob(javaname).new(false, 0) 10 | end 11 | end 12 | end -------------------------------------------------------------------------------- /lib/knj/jruby_compiler.rb: -------------------------------------------------------------------------------- 1 | class Knj::Jruby_compiler 2 | def initialize(args = {}) 3 | @args = args 4 | 5 | factory = javax.script.ScriptEngineManager.new 6 | engine = factory.getEngineByName("jruby") 7 | code = File.read(args[:path]) 8 | @script = engine.compile(code) 9 | end 10 | 11 | def run 12 | @script.eval 13 | end 14 | end -------------------------------------------------------------------------------- /lib/knj/autoload/json.rb: -------------------------------------------------------------------------------- 1 | require "rubygems" 2 | 3 | begin 4 | if RUBY_ENGINE == "jruby" 5 | require "json/pure" #normal json has utf-8 encoding problems - knj. 6 | else 7 | require "json/pure" 8 | 9 | #deactivated because of problems with utf-8 encoding. 10 | #require "json/ext" 11 | end 12 | rescue LoadError 13 | require "json/pure" 14 | end -------------------------------------------------------------------------------- /lib/knj/erb/erb_1.9.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby1.9 2 | 3 | knjdir = File.dirname(File.realpath(__FILE__)) + "/../" 4 | 5 | require knjdir + "autoload" 6 | require knjdir + "/erb/include" 7 | 8 | $knj_eruby = KnjEruby 9 | 10 | filename = ENV["PATH_TRANSLATED"] if ENV and ENV["PATH_TRANSLATED"] 11 | filename = ARGV[0] if ARGV and ARGV[0] 12 | 13 | KnjEruby.load(filename) -------------------------------------------------------------------------------- /lib/knj/jruby-gtk2/progressbar.rb: -------------------------------------------------------------------------------- 1 | class Gtk::ProgressBar 2 | def initialize 3 | if Gtk.takeob 4 | @ob = Gtk.takeob 5 | Gtk.takeob = nil 6 | else 7 | splitted = self.class.to_s.split("::") 8 | javaname = "org.gnome." + splitted.first.downcase + "." + splitted.last 9 | @ob = Gtk.evalob(javaname).new 10 | end 11 | end 12 | end -------------------------------------------------------------------------------- /lib/knj/autoload/rexml.rb: -------------------------------------------------------------------------------- 1 | require "rexml/rexml" 2 | 3 | module REXML 4 | autoload :Document, "rexml/document" 5 | autoload :ParseException, "rexml/parseexception" 6 | end 7 | 8 | module REXML::Formatters 9 | autoload :Default, "rexml/formatters/default" 10 | autoload :Pretty, "rexml/formatters/pretty" 11 | autoload :Transitive, "rexml/formatters/transitive" 12 | end -------------------------------------------------------------------------------- /spec/locales_spec.rb: -------------------------------------------------------------------------------- 1 | require File.expand_path(File.dirname(__FILE__) + '/spec_helper') 2 | 3 | describe "Locales" do 4 | it "should do convertions of short formats" do 5 | Thread.current[:locale] = "en" 6 | res = Knj::Locales.lang 7 | raise "Result wasnt as expected: '#{res}'." if res["first"] != "en" or res["second"] != "GB" or res["full"] != "en_GB" 8 | end 9 | end -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/glib.rb: -------------------------------------------------------------------------------- 1 | module GLib 2 | class Timeout 3 | def self.add(time, &block) 4 | Thread.new(time, block) do |time, block| 5 | begin 6 | sleep(time / 1000) 7 | block.call 8 | rescue Exception => e 9 | puts e.inspect 10 | puts e.backtrace 11 | end 12 | end 13 | end 14 | end 15 | end -------------------------------------------------------------------------------- /lib/knj/jruby-gtk2/tests/test_normal_window.rb: -------------------------------------------------------------------------------- 1 | require "knj/autoload" 2 | 3 | button = Gtk::Button.new("Test") 4 | button.signal_connect("clicked") do 5 | print "Clicked!\n" 6 | end 7 | 8 | win = Gtk::Window.new("Trala") 9 | win.add(button) 10 | win.show_all 11 | 12 | win.signal_connect("destroy") do 13 | print "Destroy!\n" 14 | Gtk.main_quit 15 | end 16 | 17 | Gtk.main -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/gtk_treeselection.rb: -------------------------------------------------------------------------------- 1 | Gtk.events["Gtk"]["TreeSelection"] = { 2 | "changed" => "changed" 3 | } 4 | 5 | class Gtk::TreeSelection 6 | def selected_rows 7 | ret = [] 8 | sel_rows = @ob.GetSelectedRows 9 | sel_rows.each do |tpath| 10 | Gtk.takeob = tpath 11 | ret << Gtk::TreePath.new 12 | end 13 | 14 | return ret 15 | end 16 | end -------------------------------------------------------------------------------- /lib/knj/jruby-gtk2/tests/test_trayicon.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/jruby 2 | 3 | require "knj/autoload" 4 | 5 | pixbuf = Gdk::Pixbuf.new("test_trayicon.png") 6 | 7 | icon = Gtk::StatusIcon.new 8 | icon.pixbuf = pixbuf 9 | 10 | icon.signal_connect("activate") do 11 | print "Activate\n" 12 | end 13 | 14 | icon.signal_connect("popup-menu") do 15 | print "Popup-menu\n" 16 | end 17 | 18 | Gtk.main -------------------------------------------------------------------------------- /lib/knj/php_parser/tests/test.rb: -------------------------------------------------------------------------------- 1 | require "knj/autoload" 2 | require "php4r" if !Kernel.const_defined?(:Php4r) 3 | require "#{$knjpath}php_parser/php_parser" 4 | 5 | module Knj::Php_parser::Functions 6 | def self.my_function(phpvar_arg) 7 | Php4r.print("Hejsa.\n") 8 | Php4r.print(phpvar_arg + "\n") 9 | end 10 | end 11 | Knj::Php_parser::Functions.my_function("Helloworld.") 12 | 13 | -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/image.rb: -------------------------------------------------------------------------------- 1 | class Gtk::Image 2 | def initialize(*paras) 3 | if Gtk.takeob 4 | @ob = Gtk.takeob 5 | Gtk.takeob = nil 6 | else 7 | splitted = self.class.to_s.split("::") 8 | @ob = RealGtk.const_get(splitted.last).new(*paras) 9 | end 10 | 11 | if !@ob 12 | raise "Object was not spawned: #{self.class.to_s}" 13 | end 14 | end 15 | end -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/gtk_treeview.rb: -------------------------------------------------------------------------------- 1 | class Gtk::TreeView 2 | def selection 3 | if !@selection 4 | Gtk.takeob = @ob.selection 5 | @selection = Gtk::TreeSelection.new 6 | end 7 | 8 | return @selection 9 | end 10 | 11 | def model=(newmodel) 12 | @model = newmodel 13 | @ob.model = newmodel.ob 14 | end 15 | 16 | def model 17 | return @model 18 | end 19 | end -------------------------------------------------------------------------------- /lib/knj/jruby-gtk2/builder/test_builder.rb: -------------------------------------------------------------------------------- 1 | require "knj/autoload" 2 | 3 | class TestWindow 4 | def initialize 5 | @gui = Gtk::Builder.new 6 | @gui.add_from_file("test_builder.ui") 7 | @gui.connect_signals(){|h|method(h)} 8 | 9 | @gui["window1"].show_all 10 | end 11 | 12 | def on_window1_destroy 13 | Gtk.main_quit 14 | end 15 | end 16 | 17 | TestWindow.new 18 | 19 | Gtk.main -------------------------------------------------------------------------------- /lib/knj/rand.rb: -------------------------------------------------------------------------------- 1 | #This module is used to handel various random handeling. 2 | module Knj::Rand 3 | #Returns a random integer between the two integers given. 4 | def self.range(first, last) 5 | return first.to_i + rand(last.to_i - first.to_i) 6 | end 7 | 8 | #Returns a random element in the given array. 9 | def self.array(arr) 10 | key = rand(arr.length) 11 | return arr[key] 12 | end 13 | end -------------------------------------------------------------------------------- /lib/knj/php_parser/tests/test_function_run.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | 3 | require "knj/autoload" 4 | include Knj 5 | 6 | parser = Php_parser.new( 7 | "file" => File.dirname(__FILE__) + "/test_function.php" 8 | ) 9 | 10 | begin 11 | cont = parser.parse 12 | rescue RuntimeError => e 13 | print "Retcont:\n#{parser.retcont}\n\n" 14 | print "Cont:\n#{parser.cont}\n\n" 15 | 16 | raise e 17 | end 18 | 19 | print cont + "\n" -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/gtk_combobox.rb: -------------------------------------------------------------------------------- 1 | class Gtk::ComboBox 2 | def pack_start(widget, val) 3 | @ob.pack_start(widget.ob, val) 4 | @ob.add_attribute(widget.ob, "text", 0) 5 | end 6 | 7 | def add_attribute(*paras) 8 | #this should not do anything. 9 | end 10 | 11 | def model=(newmodel) 12 | @model = newmodel 13 | @ob.model = newmodel.ob 14 | end 15 | 16 | def model 17 | return @model 18 | end 19 | end -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/gtk_liststore.rb: -------------------------------------------------------------------------------- 1 | class Gtk::ListStore 2 | def initialize(*args) 3 | args_cons = [] 4 | args.each do |col_name| 5 | args_cons << System::String.to_clr_type 6 | end 7 | 8 | @ob = RealGtk::ListStore.new(*args_cons) 9 | end 10 | 11 | def append 12 | Gtk.takeob = @ob.append 13 | retob = Gtk::TreeIter.new 14 | retob.liststore = self 15 | 16 | return retob 17 | end 18 | end -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/tests/test_2.rb: -------------------------------------------------------------------------------- 1 | require "knj/autoload" 2 | 3 | class MainWindow 4 | def initialize 5 | button = Gtk::Button.new("Test") 6 | 7 | button.signal_connect("clicked") do 8 | Gtk.main_quit 9 | end 10 | 11 | win = Gtk::Window.new 12 | win.add button 13 | win.show_all 14 | end 15 | 16 | def on_button1_clicked(object, event) 17 | print "hmm\n" 18 | end 19 | end 20 | 21 | main_window = MainWindow.new 22 | Gtk.main -------------------------------------------------------------------------------- /spec/spec_helper.rb: -------------------------------------------------------------------------------- 1 | $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib')) 2 | $LOAD_PATH.unshift(File.dirname(__FILE__)) 3 | require 'rspec' 4 | require 'knjrbfw' 5 | 6 | # Requires supporting files with custom matchers and macros, etc, 7 | # in ./support/ and its subdirectories. 8 | Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f} 9 | 10 | RSpec.configure do |config| 11 | config.expect_with(:rspec) { |c| c.syntax = :should } 12 | end 13 | -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/button.rb: -------------------------------------------------------------------------------- 1 | Gtk.events["Gtk"]["Button"] = { 2 | "clicked" => "clicked" 3 | } 4 | 5 | class Gtk::Button 6 | def initialize(title = "") 7 | if Gtk.takeob 8 | @ob = Gtk.takeob 9 | Gtk.takeob = nil 10 | else 11 | splitted = self.class.to_s.split("::") 12 | @ob = RealGtk.const_get(splitted.last).new(title) 13 | end 14 | 15 | if !@ob 16 | raise "Object was not spawned: #{self.class.to_s}" 17 | end 18 | end 19 | end -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/label.rb: -------------------------------------------------------------------------------- 1 | class Gtk::Label 2 | def initialize(title = "") 3 | if Gtk.takeob 4 | @ob = Gtk.takeob 5 | Gtk.takeob = nil 6 | else 7 | splitted = self.class.to_s.split("::") 8 | @ob = RealGtk.const_get(splitted.last).new(title) 9 | end 10 | 11 | if !@ob 12 | raise "Object was not spawned: #{self.class.to_s}" 13 | end 14 | end 15 | 16 | def label=(newlabel) 17 | @ob.label_prop = newlabel 18 | end 19 | end -------------------------------------------------------------------------------- /lib/knj/erb/erb_cache_clean.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | 3 | require "knj/autoload" 4 | include Knj 5 | Os.chdir_file(__FILE__) 6 | 7 | curtime = Time.new.to_i 8 | 9 | Dir.new("cache").each do |filename| 10 | if filename != "." and filename != ".." and filename != "README" 11 | fn = "cache/#{filename}" 12 | file = File.new(fn) 13 | mtime = file.mtime.to_i 14 | diftime = curtime - mtime 15 | 16 | if diftime >= (3600 * 48) 17 | File.delete(fn) 18 | end 19 | end 20 | end -------------------------------------------------------------------------------- /lib/knj/rhodes/youtube_embed.erb: -------------------------------------------------------------------------------- 1 |
2 |
3 |

<%=_"YouTube embedded"%>

4 | 5 | <%=_("Back")%> 6 |
7 |
8 |
9 | 10 |
11 |
12 |
-------------------------------------------------------------------------------- /lib/knj/jruby-gtk2/eventbutton.rb: -------------------------------------------------------------------------------- 1 | class Gdk::EventButton 2 | def initialize(eventtype) 3 | if Gtk.takeob 4 | @ob = Gtk.takeob 5 | Gtk.takeob = nil 6 | else 7 | splitted = self.class.to_s.split("::") 8 | classname = splitted[splitted.length - 1] 9 | class_spawn = Gtk.evalob("org.gnome.gdk." + classname) 10 | #@ob = class_spawn.new 11 | end 12 | end 13 | 14 | def button 15 | return 2 16 | end 17 | 18 | def time 19 | return 0 20 | end 21 | end -------------------------------------------------------------------------------- /lib/knj/erb/erb.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | 3 | def File::realpath(path) 4 | if File.symlink?(path) 5 | return self.realpath(File.readlink(path)) 6 | end 7 | 8 | return path 9 | end 10 | 11 | knjdir = File.dirname(File.realpath(__FILE__)) + "/../" 12 | 13 | require knjdir + "autoload" 14 | require knjdir + "erb/include" 15 | 16 | $knj_eruby = KnjEruby 17 | 18 | filename = ENV["PATH_TRANSLATED"] if ENV and ENV["PATH_TRANSLATED"] 19 | filename = ARGV[0] if ARGV and ARGV[0] 20 | 21 | KnjEruby.load(filename) -------------------------------------------------------------------------------- /lib/knj/tests/test_http2.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby1.9.1 2 | 3 | Dir.chdir(File.dirname(__FILE__)) 4 | require "../../knjrbfw.rb" 5 | 6 | require "../autoload" 7 | 8 | http = Http2.new(:host => "www.partyworm.dk", :port => 80, :ssl => false) 9 | resp = http.get(:url => "/?show=frontpage") 10 | resp = http.get(:url => "/?show=login") 11 | 12 | #print "Wee!\n" 13 | #exit 14 | 15 | http = Http2.new(:host => "mexico.balance4u.com", :port => 443, :ssl => true) 16 | resp = http.get(:url => "/") 17 | 18 | Php4r.print_r(http.cookies) -------------------------------------------------------------------------------- /lib/knj/erb/erb_jruby.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/jruby 2 | 3 | def File::realpath(path) 4 | if File.symlink?(path) 5 | return self.realpath(File.readlink(path)) 6 | end 7 | 8 | return path 9 | end 10 | 11 | knjdir = File.dirname(File.realpath(__FILE__)) + "/../" 12 | 13 | require knjdir + "autoload" 14 | require "erubis" 15 | require knjdir + "/erb/include" 16 | 17 | $knj_eruby = KnjEruby 18 | 19 | filename = ENV["PATH_TRANSLATED"] if ENV and ENV["PATH_TRANSLATED"] 20 | filename = ARGV[0] if ARGV and ARGV[0] 21 | 22 | KnjEruby.load(filename) -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/window.rb: -------------------------------------------------------------------------------- 1 | Gtk.events["Gtk"]["Window"] = { 2 | "destroy" => "destroyed" 3 | } 4 | 5 | class Gtk::Window 6 | def initialize(title = "") 7 | if Gtk.takeob 8 | @ob = Gtk.takeob 9 | Gtk.takeob = nil 10 | else 11 | splitted = self.class.to_s.split("::") 12 | @ob = RealGtk.const_get(splitted.last).new(title) 13 | end 14 | 15 | if !@ob 16 | raise "Object was not spawned: #{self.class.to_s}" 17 | end 18 | end 19 | 20 | def add(widget) 21 | @ob.add(widget.ob) 22 | end 23 | end -------------------------------------------------------------------------------- /lib/knj/ip2location.rb: -------------------------------------------------------------------------------- 1 | class Knj::Ip2location 2 | def initialize(args = {}) 3 | @args = args 4 | @http = Knj::Http.new( 5 | "host" => "www.ip2location.com", 6 | "port" => 80 7 | ) 8 | end 9 | 10 | def lookup(ip) 11 | raise "Invalid IP: #{ip}." if !ip.to_s.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/) 12 | 13 | html = @http.get("/#{ip}")["data"] 14 | ret = {} 15 | 16 | html.scan(/(.+?)<\/span>/) do |match| 17 | ret[match[0]] = match[1] 18 | end 19 | 20 | return ret 21 | end 22 | end -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/tests/test.glade: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | button 9 | True 10 | True 11 | True 12 | 13 | 14 | 15 | 16 | -------------------------------------------------------------------------------- /lib/knj/fs/drivers/ssh.rb: -------------------------------------------------------------------------------- 1 | class Knj::Fs::Ssh 2 | def self.args 3 | return [ 4 | { 5 | "title" => "Hostname", 6 | "name" => "texhostname" 7 | }, 8 | { 9 | "title" => "Port", 10 | "name" => "texport" 11 | }, 12 | { 13 | "title" => "Username", 14 | "name" => "texusername" 15 | }, 16 | { 17 | "title" => "Password", 18 | "name" => "texpassword", 19 | "type" => "password" 20 | } 21 | ] 22 | end 23 | 24 | def initialize(args) 25 | @args = args 26 | raise "Stub!" 27 | end 28 | end -------------------------------------------------------------------------------- /lib/knj/sysuser.rb: -------------------------------------------------------------------------------- 1 | class Knj::Sysuser 2 | def initialize(data) 3 | @data = data 4 | end 5 | 6 | def self.list(paras = {}) 7 | cont = File.read("/etc/passwd") 8 | 9 | list = [] 10 | cont.split("\n").each do |line| 11 | linearr = line.split(":") 12 | 13 | list << Knj::Sysuser.new( 14 | "nick" => linearr[0], 15 | "home" => linearr[5], 16 | "shell" => linearr[6] 17 | ) 18 | end 19 | 20 | return list 21 | end 22 | 23 | def [](key) 24 | raise "No such key: " + key if !@data.key?(key) 25 | return @data[key] 26 | end 27 | end -------------------------------------------------------------------------------- /lib/knj/rsvgbin.rb: -------------------------------------------------------------------------------- 1 | class Knj::RSVGBIN 2 | def self.test_version 3 | test_version = %x[rsvg-convert -v] 4 | if !test_version.match(/^rsvg-convert version [0-9\.]+$/) 5 | raise "No valid version of rsvg-bin was found." 6 | end 7 | end 8 | 9 | def self.png_content_from_file(file_from) 10 | RSVGBIN.test_version 11 | return %x[rsvg-convert #{Strings.unixsafe(file_from)}] 12 | end 13 | 14 | def self.convert_file(file_from, file_to) 15 | RSVGBIN.test_version 16 | 17 | png_content = RSVGBIN.png_content_from_file(file_from) 18 | Php.file_put_contents(file_to, png_content) 19 | end 20 | end -------------------------------------------------------------------------------- /lib/knj/gettext_fallback.rb: -------------------------------------------------------------------------------- 1 | #A fallback GetText implementation that basically returns the given strings, but can be useful for using methods that uses GetText without using an actual GetText implementation. 2 | module GetText 3 | #Returns the given string. 4 | def self._(string) 5 | return string 6 | end 7 | 8 | #Returns the given string. 9 | def _(string) 10 | return string 11 | end 12 | 13 | #Returns the given string. 14 | def gettext(string) 15 | return string 16 | end 17 | 18 | #Doesnt do anything. 19 | def bindtextdomain(temp1 = nil, temp2 = nil, temp3 = nil) 20 | #nothing here. 21 | end 22 | end -------------------------------------------------------------------------------- /lib/knj/scripts/svn_merge.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/ruby 2 | 3 | require "knj/autoload" 4 | 5 | path_to = ARGV[0] 6 | 7 | Dir.glob(File.join("**", ".svn")).each do |dir| 8 | newdir = path_to + "/" + dir 9 | 10 | #print dir + "\n" 11 | #print newdir + "\n" 12 | 13 | if File.exist?(newdir) 14 | print "Remove: " + newdir.to_s + "\n" 15 | FileUtils.rm_r(newdir) 16 | end 17 | 18 | begin 19 | #print "Move: " + dir + "\n" 20 | #FileUtils.mv(dir, newdir) 21 | 22 | print "Copy: " + dir + "\n" 23 | FileUtils.cp_r(dir, newdir) 24 | rescue => e 25 | print "Failed: " + e.message + "\n" 26 | end 27 | 28 | #print "\n" 29 | end -------------------------------------------------------------------------------- /lib/knj/php_parser/php_parser.rb: -------------------------------------------------------------------------------- 1 | class Knj::Php_parser 2 | attr_reader :cont, :retcont 3 | 4 | def initialize(args) 5 | @args = args 6 | @cont = File.read(@args["file"]) 7 | 8 | if !args.key?("require_requirements") or args["require_requirements"] 9 | @retcont = "require \"knj/autoload\"\n" 10 | @retcont << "require \"php4r\"\n" 11 | @retcont << "require \"knj/php_parser/php_parser\"\n" 12 | @retcont << "\n" 13 | else 14 | @retcont = "" 15 | end 16 | end 17 | end 18 | 19 | require File.dirname(__FILE__) + "/functions.rb" 20 | 21 | module Knj::Php_parser::Functions 22 | #nothing here. 23 | end -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/gtk_treeiter.rb: -------------------------------------------------------------------------------- 1 | class Gtk::TreeIter 2 | def initialize(*paras) 3 | if Gtk.takeob 4 | print "TreeIter from takeob.\n" 5 | @ob = Gtk.takeob 6 | Gtk.takeob = nil 7 | else 8 | print "TreeIter from constructor.\n" 9 | @ob = RealGtk::TreeIter.new(*paras) 10 | end 11 | end 12 | 13 | def liststore=(newliststore) 14 | @liststore = newliststore 15 | end 16 | 17 | def []=(key, value) 18 | return @liststore.ob.method(:set_value).overload(RealGtk::TreeIter, Fixnum, System::String).call(@ob, key, value) 19 | end 20 | 21 | def [](key) 22 | return @liststore.ob.get_value(@ob, key) 23 | end 24 | end -------------------------------------------------------------------------------- /lib/knj/includes/appserver_cli.rb: -------------------------------------------------------------------------------- 1 | require "knj/autoload" 2 | require "#{$knjpath}web" 3 | 4 | class Appserver_cli 5 | def self.loadfile(filepath) 6 | require filepath 7 | end 8 | 9 | def self._(str) 10 | return str 11 | end 12 | 13 | def self.gettext 14 | return self 15 | end 16 | 17 | def self.lang_opts 18 | return [] 19 | end 20 | end 21 | 22 | def _kas 23 | return Appserver_cli 24 | end 25 | 26 | def _db 27 | return $db 28 | end 29 | 30 | def _ob 31 | return $ob 32 | end 33 | 34 | autoinc_cli_path = "../include/autoinclude_cli.rb" 35 | if File.exist?(autoinc_cli_path) 36 | require autoinc_cli_path 37 | else 38 | require "../include/autoinclude.rb" 39 | end -------------------------------------------------------------------------------- /lib/knj/knj_controller.rb: -------------------------------------------------------------------------------- 1 | #This files makes the framework able to receive calls from the Rhodes framework from RhoMobile. 2 | class KnjController < Rho::RhoController 3 | #GET /Server 4 | def index 5 | render 6 | end 7 | 8 | def html_links 9 | System.open_url(@params["url"]) 10 | end 11 | 12 | def callback 13 | block = $rhodes.callbacks(@params["callback_id"]) 14 | block.call(:params => @params) 15 | end 16 | 17 | def youtube_embed 18 | @iframe_height = System.get_property("screen_height").to_i - 40 19 | render :file => "Knj/rhodes/youtube_embed.erb" 20 | end 21 | 22 | def youtube_open 23 | render :file => "Knj/rhodes/youtube_open.erb" 24 | end 25 | end -------------------------------------------------------------------------------- /lib/knj/csv.rb: -------------------------------------------------------------------------------- 1 | #Contains various methods for handeling CSV-stuff. 2 | class Knj::Csv 3 | #Converts a given array to a CSV-string. 4 | #===Examples 5 | # str = Knj::Csv.arr_to_csv([1, 2, 3], ";", "'") #=> "'1';'2';'3'\n" 6 | def self.arr_to_csv(arr, del, encl) 7 | raise "No delimiter given." if !del 8 | raise "No enclosure given." if !encl 9 | 10 | str = "" 11 | first = true 12 | arr.each do |val| 13 | if first 14 | first = false 15 | else 16 | str << del 17 | end 18 | 19 | val = val.to_s.encode("utf-8").gsub(del, "").gsub(encl, "") 20 | str << "#{encl}#{val}#{encl}" 21 | end 22 | 23 | str << "\n" 24 | 25 | return str 26 | end 27 | end -------------------------------------------------------------------------------- /lib/knj/fs/drivers/ftp.rb: -------------------------------------------------------------------------------- 1 | class Knj::Fs::Ftp 2 | def self.args 3 | return [ 4 | { 5 | "title" => "Hostname", 6 | "name" => "texhost" 7 | }, 8 | { 9 | "title" => "Port", 10 | "name" => "texport" 11 | }, 12 | { 13 | "title" => "Username", 14 | "name" => "texusername" 15 | }, 16 | { 17 | "title" => "Password", 18 | "name" => "texpassword", 19 | "type" => "password" 20 | }, 21 | { 22 | "title" => "Passive?", 23 | "name" => "chepassive", 24 | "type" => "checkbox" 25 | } 26 | ] 27 | end 28 | 29 | def initialize(args) 30 | @args = args 31 | raise "Stub!" 32 | end 33 | end -------------------------------------------------------------------------------- /lib/knj/tests/test_http2_proxy.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby1.9.1 2 | 3 | require "#{File.dirname(__FILE__)}/../../knjrbfw.rb" 4 | require "knj/autoload" 5 | 6 | proxy_settings = Marshal.load(File.read("#{File.dirname(__FILE__)}/test_http2_proxy_settings.marshal")) 7 | 8 | http = Http2.new( 9 | :host => "www.partyworm.dk", 10 | :proxy => proxy_settings 11 | ) 12 | 13 | urls = [ 14 | "?show=users_search", 15 | "?show=users_online", 16 | "?show=drinksdb", 17 | "?show=forum&fid=9&tid=1917&page=0" 18 | ] 19 | urls = ["robots.txt"] 20 | 21 | 0.upto(105) do |count| 22 | url = urls[rand(urls.size)] 23 | print "Doing request #{count} of 200 (#{url}).\n" 24 | res = http.get(:url => url) 25 | raise "Body was empty." if res.body.to_s.length <= 0 26 | end -------------------------------------------------------------------------------- /lib/knj/jruby-gtk2/combobox.rb: -------------------------------------------------------------------------------- 1 | class Gtk::ComboBox 2 | def pack_start(widget, arg1, arg2 = false) 3 | #widget is useually a Gtk::CellRendererText which is started by this way in Java GTK. 4 | @renderer = widget 5 | widget.init(self) 6 | 7 | if self.model 8 | widget.text = self.model.dcol[0] 9 | @renderer_set = true 10 | end 11 | end 12 | 13 | def add_attribute(arg1, arg2, arg3) 14 | #do nothing - this method does not exist on Java GTK's ComboBox. 15 | end 16 | 17 | def model=(newmodel) 18 | @model = newmodel 19 | @ob.model = newmodel.ob 20 | 21 | if !@renderer_set 22 | @renderer.text = self.model.dcol[0] 23 | end 24 | end 25 | 26 | def model 27 | return @model 28 | end 29 | end -------------------------------------------------------------------------------- /lib/knj/tests/test_mount.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | 3 | Dir.chdir(File.dirname(__FILE__)) 4 | require "../autoload" 5 | 6 | print "Listing all mounts.\n" 7 | mounts = Knj::Mount.list 8 | mounts.each do |mount| 9 | Php4r.print_r(mount.data) 10 | print "Access: #{mount.access?}\n\n" 11 | end 12 | 13 | mounts = Knj::Mount.list("from_search" => "test_dir") 14 | mounts.each do |mount| 15 | print "Unmounting test_dir.\n" 16 | mount.umount 17 | end 18 | 19 | print "Mount binding test_dir to test_dir_to.\n" 20 | Knj::Mount.mount( 21 | "from" => "test_dir", 22 | "to" => "test_dir_to", 23 | "bind" => true 24 | ) 25 | 26 | mounts = Knj::Mount.list("from_search" => "test_dir") 27 | mounts.each do |mount| 28 | print "Unmounting test_dir.\n" 29 | mount.umount 30 | end -------------------------------------------------------------------------------- /lib/knj/power_manager.rb: -------------------------------------------------------------------------------- 1 | class Knj::Power_manager 2 | def initialize(args = {}) 3 | @args = args 4 | 5 | if !File.exist?("/proc/acpi/ac_adapter") 6 | raise "Could not find the proc-acpi folder." 7 | end 8 | 9 | Dir.new("/proc/acpi/ac_adapter").each do |file| 10 | next if file == "." or file == ".." 11 | fn = "/proc/acpi/ac_adapter/#{file}" 12 | 13 | if File.directory?(fn) 14 | @ac_folder = Php4r.realpath(fn) 15 | break 16 | end 17 | end 18 | 19 | raise "Could not register ac-folder." if !@ac_folder 20 | end 21 | 22 | def state 23 | cont = File.read("#{@ac_folder}/state") 24 | 25 | if match = cont.match(/state:\s*(.+)\s*/) 26 | return match[1] 27 | end 28 | 29 | raise "Could not figure out state." 30 | end 31 | end -------------------------------------------------------------------------------- /lib/knj/thread.rb: -------------------------------------------------------------------------------- 1 | #This class behaves like a normal thread - but it shows error-messages and tracebacks. Normal threads dont do that. 2 | class Knj::Thread < Thread 3 | attr_accessor :data 4 | 5 | #Initializes the thread and passes any given arguments to the thread-block. 6 | def initialize(*args) 7 | raise "No block was given." unless block_given? 8 | 9 | super(*args) do 10 | begin 11 | yield(*args) 12 | rescue SystemExit, Interrupt 13 | raise 14 | rescue Exception => e 15 | print "#{Knj::Errors.error_str(e)}\n\n" 16 | end 17 | end 18 | 19 | @data = {} 20 | end 21 | 22 | #Returns a key from the data-hash. 23 | def [](key) 24 | return @data[key] 25 | end 26 | 27 | #Sets a key on the data-hash. 28 | def []=(key, value) 29 | return @data[key] = value 30 | end 31 | end -------------------------------------------------------------------------------- /lib/knj/jruby-gtk2/builder.rb: -------------------------------------------------------------------------------- 1 | class Gtk::Builder 2 | def initialize 3 | 4 | end 5 | 6 | def add_from_file(filename) 7 | cont = File.read(filename).gsub("", "").gsub("", "") 8 | cont = cont.gsub("", "") 9 | cont = cont.gsub("", "") 10 | cont = cont.gsub("", "") 11 | cont = cont.gsub("", "") 12 | cont = cont.gsub("", "") 13 | 14 | @glade = GladeXML.new(cont) 15 | end 16 | 17 | def connect_signals(&block) 18 | @glade.block = block 19 | @glade.auto_connect(@glade.data) 20 | end 21 | 22 | def [](key) 23 | return @glade[key] 24 | end 25 | 26 | alias get_object [] 27 | end -------------------------------------------------------------------------------- /README.rdoc: -------------------------------------------------------------------------------- 1 | = knjrbfw 2 | 3 | Description goes here. 4 | 5 | == Contributing to knjrbfw 6 | 7 | * Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet 8 | * Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it 9 | * Fork the project 10 | * Start a feature/bugfix branch 11 | * Commit and push until you are happy with your contribution 12 | * Make sure to add tests for it. This is important so I don't break it in a future version unintentionally. 13 | * Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it. 14 | 15 | == Copyright 16 | 17 | Copyright (c) 2011 Kasper Johansen. See LICENSE.txt for 18 | further details. 19 | 20 | -------------------------------------------------------------------------------- /spec/amixer_spec.rb: -------------------------------------------------------------------------------- 1 | require File.expand_path(File.dirname(__FILE__) + '/spec_helper') 2 | 3 | describe "Amixer" do 4 | it "should load by using autoload" do 5 | if Knj::Os.os == "linux" 6 | require "knjrbfw" 7 | $amixer = Knj::Amixer.new 8 | end 9 | end 10 | 11 | it "should register various devices" do 12 | if Knj::Os.os == "linux" 13 | $devices = $amixer.devices 14 | end 15 | end 16 | 17 | it "should register various mixers and do various operations on them" do 18 | if Knj::Os.os == "linux" 19 | $devices.each do |name, device| 20 | mixers = device.mixers 21 | 22 | if device.active?(:stream => "PLAYBACK") 23 | mixers.each do |name, mixer| 24 | next if !mixer.volume? 25 | mixer.vol_add -5 26 | mixer.vol_add 3 27 | end 28 | end 29 | end 30 | end 31 | end 32 | end -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/gtk_builder.rb: -------------------------------------------------------------------------------- 1 | class Gtk::Builder 2 | def initialize 3 | 4 | end 5 | 6 | def add_from_file(filename) 7 | cont = File.read(filename).gsub("", "").gsub("", "") 8 | cont = cont.gsub("", "") 9 | cont = cont.gsub("", "") 10 | cont = cont.gsub("", "") 11 | cont = cont.gsub("", "") 12 | cont = cont.gsub("", "") 13 | 14 | @glade = GladeXML.new(cont) 15 | end 16 | 17 | def connect_signals(&block) 18 | @glade.block = block 19 | @glade.auto_connect(@glade.data) 20 | end 21 | 22 | def [](key) 23 | return @glade[key] 24 | end 25 | 26 | alias get_object [] 27 | 28 | def objects 29 | return [] 30 | end 31 | end -------------------------------------------------------------------------------- /Rakefile: -------------------------------------------------------------------------------- 1 | # encoding: utf-8 2 | 3 | require 'rubygems' 4 | require 'bundler' 5 | begin 6 | Bundler.setup(:default, :development) 7 | rescue Bundler::BundlerError => e 8 | $stderr.puts e.message 9 | $stderr.puts "Run `bundle install` to install missing gems" 10 | exit e.status_code 11 | end 12 | require 'rake' 13 | 14 | require 'rspec/core' 15 | require 'rspec/core/rake_task' 16 | RSpec::Core::RakeTask.new(:spec) do |spec| 17 | spec.pattern = FileList['spec/**/*_spec.rb'] 18 | end 19 | 20 | RSpec::Core::RakeTask.new(:rcov) do |spec| 21 | spec.pattern = 'spec/**/*_spec.rb' 22 | spec.rcov = true 23 | end 24 | 25 | task :default => :spec 26 | 27 | require 'rdoc/task' 28 | Rake::RDocTask.new do |rdoc| 29 | version = File.exist?('VERSION') ? File.read('VERSION') : "" 30 | 31 | rdoc.rdoc_dir = 'rdoc' 32 | rdoc.title = "knjrbfw #{version}" 33 | rdoc.rdoc_files.include('README*') 34 | rdoc.rdoc_files.include('lib/**/*.rb') 35 | end 36 | -------------------------------------------------------------------------------- /lib/knj/fs/fs.rb: -------------------------------------------------------------------------------- 1 | class Knj::Fs 2 | @drivers = [] 3 | drivers_path = Php4r.realpath("#{File.dirname(__FILE__)}/drivers") 4 | Dir.new(drivers_path).each do |file| 5 | fn = "#{drivers_path}/#{file}" 6 | next if file == "." or file == ".." or File.directory?(fn) 7 | 8 | class_name = Php4r.ucwords(file.slice(0..-4)).to_sym 9 | print "Classname: #{class_name}\n" 10 | autoload class_name, fn 11 | 12 | @drivers << { 13 | :name => file.slice(0..-4), 14 | :args => const_get(class_name).args 15 | } 16 | end 17 | 18 | def self.drivers 19 | return @drivers 20 | end 21 | 22 | def initialize(args = {}) 23 | @args = args 24 | end 25 | 26 | def spawn_driver 27 | class_name = Php4r.ucwords(@args[:driver]) 28 | @driver = self.class.const_get(class_name).new(:fs => self, :args => @args) 29 | end 30 | end 31 | 32 | class Knj::Fs::File 33 | def initialize 34 | 35 | end 36 | end -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/gtk_treeviewcolumn.rb: -------------------------------------------------------------------------------- 1 | class Gtk::TreeViewColumn 2 | def initialize(title, renderer, *paras) 3 | @title = title 4 | @renderer = renderer 5 | 6 | if Gtk.takeob 7 | @ob = Gtk.takeob 8 | if !@ob 9 | raise "Gtk.takeob was not set correctly: " + @ob.class.to_s 10 | end 11 | 12 | Gtk.takeob = nil 13 | else 14 | splitted = self.class.to_s.split("::") 15 | realclass = "Real#{splitted.first}" 16 | classob = Kernel.const_get(realclass).const_get(splitted.last) 17 | 18 | if !classob 19 | raise "Class does not exist: " + realclass + "::" + splitted.last 20 | end 21 | 22 | @ob = classob.new 23 | 24 | if !@ob 25 | raise "Object was not spawned: #{self.class.to_s}, #{@ob.class.to_s}, #{realclass}::#{splitted.last}" 26 | end 27 | 28 | @ob.pack_start(renderer.ob, true) 29 | #@ob.add_attribute(renderer.ob, "text", 0) 30 | end 31 | end 32 | end -------------------------------------------------------------------------------- /lib/knj/exchangerates.rb: -------------------------------------------------------------------------------- 1 | class Knj::Exchangerates 2 | attr_reader :rates 3 | 4 | def initialize(args = {}) 5 | @rates = {} 6 | end 7 | 8 | def base=(data) 9 | @base = data[:locale].to_s 10 | self.add_rate(data) 11 | end 12 | 13 | def add_rate(data) 14 | if !data[:locale] or data[:locale].to_s.length <= 0 15 | raise "Invalid locale given." 16 | end 17 | 18 | @rates[data[:locale].to_s] = data 19 | end 20 | 21 | def value(locale, floatval) 22 | floatval = floatval.to_f 23 | locale = locale.to_s 24 | 25 | raise "No such locale: '#{locale}' in '#{@rates.keys.join(",")}'." if !@rates.key?(locale) 26 | 27 | base_rate = @rates[@base][:rate].to_f 28 | cur_rate = @rates[locale][:rate].to_f 29 | 30 | if base_rate == cur_rate 31 | return floatval 32 | elsif cur_rate < base_rate 33 | diff = 1 + (base_rate - cur_rate) 34 | return floatval * diff 35 | else 36 | return floatval / cur_rate 37 | end 38 | end 39 | end -------------------------------------------------------------------------------- /lib/knj/jruby-gtk2/menu.rb: -------------------------------------------------------------------------------- 1 | class Gtk::Menu 2 | def initialize 3 | if Gtk.takeob 4 | @ob = Gtk.takeob 5 | Gtk.takeob = nil 6 | else 7 | splitted = self.class.to_s.split("::") 8 | classname = splitted[splitted.length - 1] 9 | class_spawn = Gtk.evalob("org.gnome.gtk." + classname) 10 | @ob = class_spawn.new 11 | end 12 | end 13 | 14 | def popup(arg1, arg2, event_button, event_time) 15 | @ob.popup 16 | end 17 | 18 | def prepend(object) 19 | @ob.prepend(object.ob) 20 | end 21 | end 22 | 23 | class Gtk::MenuItem 24 | def initialize(title) 25 | if Gtk.takeob 26 | @ob = Gtk.takeob 27 | Gtk.takeob = nil 28 | else 29 | splitted = self.class.to_s.split("::") 30 | classname = splitted[splitted.length - 1] 31 | class_spawn = Gtk.evalob("org.gnome.gtk." + classname) 32 | 33 | if title 34 | @ob = class_spawn.new(title) 35 | else 36 | @ob = class_spawn.new 37 | end 38 | end 39 | end 40 | end -------------------------------------------------------------------------------- /lib/knj/youtube.rb: -------------------------------------------------------------------------------- 1 | class Knj::YouTube 2 | def self.all_videos(data, params = {}, opts = {}) 3 | params[:per_page] = 50 4 | 5 | ret_arr = [] 6 | go_through_pages = true 7 | page = 1 8 | while go_through_pages 9 | #print "Getting page #{page.to_s}\n" 10 | 11 | newparams = Marshal.load(Marshal.dump(params)) 12 | newparams[:page] = page 13 | videos = data["youtube"].videos_by(newparams) 14 | 15 | videos.videos.each do |video| 16 | if data["check_stop"] and data["check_stop"].respond_to?("check_stop_parsing") 17 | if data["check_stop"].check_stop_parsing(video) 18 | go_through_pages = false 19 | break 20 | end 21 | end 22 | 23 | ret_arr << video 24 | end 25 | 26 | status = videos.next_page 27 | break if !status 28 | 29 | page += 1 30 | break if data["pages"] and page > data["pages"].to_i 31 | end 32 | 33 | return ret_arr 34 | end 35 | end -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # rcov generated 2 | coverage 3 | 4 | # rdoc generated 5 | rdoc 6 | 7 | # yard generated 8 | doc 9 | .yardoc 10 | 11 | # bundler 12 | .bundle 13 | 14 | *.gem 15 | 16 | # Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore: 17 | # 18 | # * Create a file at ~/.gitignore 19 | # * Include files you want ignored 20 | # * Run: git config --global core.excludesfile ~/.gitignore 21 | # 22 | # After doing this, these files will be ignored in all your git projects, 23 | # saving you from having to 'pollute' every project you touch with them 24 | # 25 | # Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line) 26 | # 27 | # For MacOS: 28 | # 29 | #.DS_Store 30 | 31 | # For TextMate 32 | #*.tmproj 33 | #tmtags 34 | 35 | # For emacs: 36 | #*~ 37 | #\#* 38 | #.\#* 39 | 40 | # For vim: 41 | #*.swp 42 | 43 | # For redcar: 44 | #.redcar 45 | 46 | # For rubinius: 47 | #*.rbc 48 | 49 | lib/knj/tests/test_http2_proxy_settings.marshal 50 | -------------------------------------------------------------------------------- /lib/knj/scripts/upgrade_knjrbfw_checker.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | 3 | require "knj/autoload" 4 | 5 | mode = ARGV[0] 6 | 7 | if mode.to_s.length <= 0 8 | print "No mode was given.\n" 9 | exit 10 | elsif mode != "dev" and mode != "original" 11 | print "Invalid mode: #{mode}\n" 12 | exit 13 | end 14 | 15 | checks = [ 16 | "/usr/share/php/knjphpframework", 17 | "/usr/lib/ruby/1.8/knjrbfw" 18 | ] 19 | 20 | checks.each do |dir| 21 | dev_name = dir + "_dev" 22 | original_name = dir + "_original" 23 | 24 | if mode == "dev" 25 | if File.exist?(dir) and File.symlink?(dir) 26 | #do nothing. 27 | elsif File.exist?(dir) and !File.exist?(original_name) 28 | File.rename(dir, original_name) 29 | File.rename(dev_name, dir) 30 | end 31 | elsif mode == "original" 32 | if File.exist?(dir) and File.exist?(original_name) and File.symlink?(dir) 33 | File.rename(dir, dev_name) 34 | File.rename(original_name, dir) 35 | else 36 | #do nothing. 37 | end 38 | else 39 | raise "No such mode: #{mode}" 40 | end 41 | end -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/tests/test_ironruby_window.rb: -------------------------------------------------------------------------------- 1 | require "gtk-sharp, Version=2.12.0.0, Culture=neutral, PublicKeyToken=35e10195dab3c99f" 2 | require "glade-sharp, Version=2.12.0.0, Culture=neutral, PublicKeyToken=35e10195dab3c99f" 3 | 4 | RealGtk = Gtk 5 | RealGtk::Application.init 6 | 7 | Gtk = Class.new do 8 | class Window 9 | def initialize(title = "") 10 | @ob = RealGtk::Window.new(title) 11 | end 12 | 13 | def add(widget) 14 | @ob.add(widget.ob) 15 | end 16 | 17 | def show_all 18 | @ob.show_all 19 | end 20 | end 21 | 22 | class Button 23 | def initialize(title = nil) 24 | @ob = RealGtk::Button.new(title) 25 | end 26 | 27 | def ob 28 | return @ob 29 | end 30 | 31 | def signal_connect(signal, &block) 32 | @ob.send(signal) do |sender, e| 33 | block.call 34 | end 35 | end 36 | end 37 | 38 | def self.main 39 | RealGtk::Application.run 40 | end 41 | 42 | def self.main_quit 43 | RealGtk::Application.quit 44 | end 45 | end 46 | 47 | require "test_2.rb" -------------------------------------------------------------------------------- /spec/cmd_parser_spec.rb: -------------------------------------------------------------------------------- 1 | require File.expand_path(File.dirname(__FILE__) + '/spec_helper') 2 | 3 | describe "Cmd_parser" do 4 | it "should be able to parse various strings" do 5 | require "knjrbfw" 6 | require "knj/cmd_parser" 7 | require "php4r" if !Kernel.const_defined?(:Php4r) 8 | 9 | strs = [ 10 | "-rw-r--r-- 1 admin administ 186.3M Aug 30 18:09 b4u_synoptik_2011_08_30_17_57_32.sql.gz\n", 11 | "-rw-r--r-- 1 admin administ 2 Nov 21 18:12 test\n", 12 | "-rw-r--r-- 1 kaspernj kaspernj 279943393 2011-07-27 09:28 dbdump_2011_07_27_03_07_36.sql\n", 13 | "-rw-rw-r-- 1 kaspernj kaspernj 58648 2011-10-28 18:33 2011-11-28 - Programmerings aften hos Anders - mad - 600 kr.pdf\n", 14 | "-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" 15 | ] 16 | 17 | strs.each do |str| 18 | res = Knj::Cmd_parser.lsl(str) 19 | 20 | res.each do |file| 21 | raise "Byte was not numeric in: '#{str}'." if !(Float(file[:size]) rescue false) 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/knj/gtk2_msgbox.rb: -------------------------------------------------------------------------------- 1 | #This class holds various methods for message-box-functionality and debugging. 2 | class Knj::Gtk2::Msgbox 3 | #This hash contains various data like the currently shown message-box. 4 | DATA = {} 5 | 6 | #Returns the label of the currently shown message-box. 7 | def self.cur_label 8 | raise "No message-box currentl shown." if !Knj::Gtk2::Msgbox::DATA[:current] 9 | return Knj::Gtk2::Msgbox::DATA[:current].children.first.children.first.children.last.label 10 | end 11 | 12 | #Send a response to the currently shown message-box. 13 | def self.cur_respond(response) 14 | raise "No message-box currentl shown." if !Knj::Gtk2::Msgbox::DATA[:current] 15 | id = Knj::Gtk2::Msgbox::DATA[:current].__id__ 16 | Knj::Gtk2::Msgbox::DATA[:current].response(response) 17 | Thread.pass while Knj::Gtk2::Msgbox::DATA[:current] and Knj::Gtk2::Msgbox::DATA[:current].__id__ == id 18 | nil 19 | end 20 | 21 | #Returns true if a message-box is currently shown. 22 | def self.shown? 23 | return true if Knj::Gtk2::Msgbox::DATA[:current] 24 | return false 25 | end 26 | end -------------------------------------------------------------------------------- /lib/knj/jruby-gtk2/tests/test_glade_window.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/jruby 2 | 3 | require "knj/autoload" 4 | require "#{$knjpath}gtk2_tv" 5 | 6 | class WinAppEdit 7 | def initialize 8 | print "Loading Glade.\n" 9 | @glade = GladeXML.new("test_glade_window.glade"){|h|method(h)} 10 | print "Done loading glade.\n" 11 | 12 | @glade["tvTest"].selection.signal_connect("changed") do 13 | print "test\n" 14 | end 15 | 16 | @glade["tvTest"].init(["ID", "Title"]) 17 | @glade["tvTest"].append(["Test1", "Test2"]) 18 | 19 | @glade["window"].show_all 20 | end 21 | 22 | def on_tvTest_row_activated 23 | #print "Test\n" 24 | end 25 | 26 | def on_btnSave_clicked(arg1) 27 | print arg1.to_s + "\n" 28 | print "Save clicked.\n" 29 | 30 | val = @glade["tvTest"].sel 31 | Php4r.print_r(val) 32 | end 33 | 34 | def on_btnCancel_clicked 35 | print "Cancel clicked.\n" 36 | end 37 | 38 | def on_window_destroy 39 | print "Destroyed!\n" 40 | Gtk.main_quit 41 | end 42 | end 43 | 44 | print "Starting app.\n" 45 | WinAppEdit.new 46 | 47 | Gtk.main -------------------------------------------------------------------------------- /LICENSE.txt: -------------------------------------------------------------------------------- 1 | Copyright (c) 2011 Kasper Johansen 2 | 3 | Permission is hereby granted, free of charge, to any person obtaining 4 | a copy of this software and associated documentation files (the 5 | "Software"), to deal in the Software without restriction, including 6 | without limitation the rights to use, copy, modify, merge, publish, 7 | distribute, sublicense, and/or sell copies of the Software, and to 8 | permit persons to whom the Software is furnished to do so, subject to 9 | the following conditions: 10 | 11 | The above copyright notice and this permission notice shall be 12 | included in all copies or substantial portions of the Software. 13 | 14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 15 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 16 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 17 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 18 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 19 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 20 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 21 | -------------------------------------------------------------------------------- /lib/knj/nvidia_settings.rb: -------------------------------------------------------------------------------- 1 | class Knj::Nvidia_settings 2 | attr_reader :data 3 | 4 | def initialize(data = {}) 5 | @data = data 6 | @power_mizer_modes = { 7 | "adaptive" => 0, 8 | "performance" => 1 9 | } 10 | end 11 | 12 | def self.list(args = {}) 13 | res = Knj::Os.shellcmd("nvidia-settings -q gpus") 14 | ret = [] 15 | 16 | res.scan(/\[gpu:(\d+)\]/) do |gpu| 17 | ret << Knj::Nvidia_settings.new(args.merge({ 18 | "gpu_no" => gpu[0] 19 | })) 20 | end 21 | 22 | return ret 23 | end 24 | 25 | def power_mizer_mode=(newval) 26 | raise "No such power-mizer-mode." if @power_mizer_modes[newval] == nil 27 | 28 | cmd = "nvidia-settings -a [gpu:#{@data["gpu_no"]}]/GPUPowerMizerMode=#{@power_mizer_modes[newval]}" 29 | res = Knj::Os.shellcmd(cmd) 30 | 31 | if res.index("assigned value") == nil 32 | raise res.strip 33 | end 34 | end 35 | 36 | def extra_args 37 | str = "" 38 | 39 | if @data["display"] 40 | str << " --display #{@data["display"]}" 41 | end 42 | 43 | return str 44 | end 45 | end -------------------------------------------------------------------------------- /lib/knj/thread2.rb: -------------------------------------------------------------------------------- 1 | class Knj::Thread2 2 | def initialize(args = {}, &block) 3 | @args = args 4 | @block = block if block_given? 5 | @callbacks = {} 6 | end 7 | 8 | def connect(signal, &block) 9 | @callbacks[signal] = [] if !@callbacks.key?(signal) 10 | @callbacks[signal] << block 11 | end 12 | 13 | def call(signal, *args) 14 | return false if !@callbacks.key?(signal) 15 | @callbacks[signal].each do |block| 16 | block.call(*args) 17 | end 18 | 19 | return {:count => count} 20 | end 21 | 22 | def run 23 | Thread.new do 24 | abort_on_exception = true 25 | call(:on_run) 26 | 27 | begin 28 | @block.call 29 | rescue SystemExit 30 | call(:on_exit) 31 | exit 32 | rescue => e 33 | call(:on_error, e) 34 | 35 | if !@args.key?(:print_error) or @args[:print_error] 36 | print "Error: " 37 | puts e.inspect 38 | print "\n" 39 | puts e.backtrace 40 | print "\n\n" 41 | end 42 | end 43 | 44 | call(:on_done) 45 | end 46 | end 47 | end -------------------------------------------------------------------------------- /lib/knj/notify.rb: -------------------------------------------------------------------------------- 1 | #This class can be used to send notify-messages through the notify-binary (notify-send or kdialog). 2 | class Knj::Notify 3 | #Call this method to show notifications. 4 | #===Examples 5 | # Knj::Notify.send("msg" => "Hello world!", "time" => 5) 6 | def self.send(args) 7 | begin 8 | toolkit = Knj::Os.toolkit 9 | rescue 10 | toolkit = "" 11 | end 12 | 13 | if toolkit == "kde" 14 | cmd = "kdialog --passivepopup #{Knj::Strings.unixsafe(args["msg"])}" 15 | 16 | if args["title"] 17 | cmd << " --title #{Knj::Strings.unixsafe(args["msg"])}" 18 | end 19 | 20 | if args["time"] 21 | cmd << " #{Knj::Strings.unixsafe(args["time"])}" 22 | end 23 | 24 | system(cmd) 25 | else 26 | cmd = "notify-send" 27 | 28 | if args["time"] 29 | raise "Time is not numeric." if !(Float(args["time"]) rescue false) 30 | cmd << " -t #{args["time"]}" 31 | end 32 | 33 | cmd << " #{Knj::Strings.unixsafe(args["title"])} #{Knj::Strings.unixsafe(args["msg"])}" 34 | system(cmd) 35 | end 36 | end 37 | end -------------------------------------------------------------------------------- /lib/knj/erb/erb_fcgi.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | 3 | def File::realpath(path) 4 | if File.symlink?(path) 5 | return self.realpath(File.readlink(path)) 6 | end 7 | 8 | return path 9 | end 10 | 11 | require File.dirname(File.realpath(__FILE__)) + "/../autoload" 12 | 13 | $_FCGI_COUNT = 0 14 | require File.dirname(File.realpath(__FILE__)) + "/include" 15 | $knj_eruby = KnjEruby 16 | FCGI.each_cgi do |fcgi| 17 | $_FCGI_COUNT += 1 18 | $_CGI = fcgi 19 | $_FCGI = fcgi 20 | 21 | loadfp = File.dirname(__FILE__) + "/" + File.basename(__FILE__).slice(0..-6) + ".rhtml" 22 | 23 | begin 24 | KnjEruby.fcgi = fcgi 25 | KnjEruby.load(loadfp) 26 | 27 | if KnjEruby.connects["exit"] 28 | KnjEruby.connects["exit"].each do |block| 29 | block.call 30 | end 31 | end 32 | 33 | if $_FCGI_EXIT 34 | #Kill self! Need to start a new thread because the app as to finish. Give it 0.1 second to do that before killing it. 35 | Thread.new do 36 | sleep 0.5 37 | Process.kill(9, Process.pid) 38 | end 39 | end 40 | rescue Exception => e 41 | puts e.inspect 42 | puts e.backtrace 43 | end 44 | end -------------------------------------------------------------------------------- /lib/knj/erb/erb_fcgi_1.9.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby1.9 2 | 3 | def File::realpath(path) 4 | if File.symlink?(path) 5 | return self.realpath(File.readlink(path)) 6 | end 7 | 8 | return path 9 | end 10 | 11 | require File.dirname(File.realpath(__FILE__)) + "/../autoload" 12 | 13 | $_FCGI_COUNT = 0 14 | require File.dirname(File.realpath(__FILE__)) + "/include" 15 | $knj_eruby = KnjEruby 16 | FCGI.each_cgi do |fcgi| 17 | $_FCGI_COUNT += 1 18 | $_CGI = fcgi 19 | $_FCGI = fcgi 20 | 21 | loadfp = File.dirname(__FILE__) + "/" + File.basename(__FILE__).slice(0..-6) + ".rhtml" 22 | 23 | begin 24 | KnjEruby.fcgi = fcgi 25 | KnjEruby.load(loadfp) 26 | 27 | if KnjEruby.connects["exit"] 28 | KnjEruby.connects["exit"].each do |block| 29 | block.call 30 | end 31 | end 32 | 33 | if $_FCGI_EXIT 34 | #Kill self! Need to start a new thread because the app as to finish. Give it 0.1 second to do that before killing it. 35 | Thread.new do 36 | sleep 0.5 37 | Process.kill(9, Process.pid) 38 | end 39 | end 40 | rescue Exception => e 41 | puts e.inspect 42 | puts e.backtrace 43 | end 44 | end -------------------------------------------------------------------------------- /lib/knj/x11vnc.rb: -------------------------------------------------------------------------------- 1 | class Knj::X11VNC 2 | def initialize(args = {}) 3 | @args = ArrayExt.hash_sym(args) 4 | @open = true 5 | 6 | cmd = "x11vnc -q" 7 | cmd << " -shared" if @args[:shared] or !@args.key?(:shared) 8 | cmd << " -forever" if @args[:forever] or !@args.key?(:forever) 9 | cmd << " -rfbport #{@args[:port]}" if @args[:port] 10 | cmd << " -nolookup" if @args[:nolookup] or !@args.key?(:nolookup) 11 | 12 | print cmd + "\n" 13 | 14 | @thread = Knj::Thread.new do 15 | IO.popen(cmd) do |process| 16 | @pid = process.pid 17 | process.sync 18 | 19 | while read = process.read 20 | break if read.length == 0 21 | #print read 22 | end 23 | 24 | @open = false 25 | @pid = nil 26 | @thread = nil 27 | end 28 | end 29 | 30 | Kernel.at_exit do 31 | self.close 32 | end 33 | end 34 | 35 | def open? 36 | return @open 37 | end 38 | 39 | def close 40 | return nil if !@thread 41 | 42 | Process.kill("HUP", @pid) if @pid 43 | @thread.exit if @thread 44 | @thread = nil 45 | @open = false 46 | @pid = nil 47 | end 48 | end -------------------------------------------------------------------------------- /lib/knj/hash_methods.rb: -------------------------------------------------------------------------------- 1 | #A normal hash that uses 'method_missing' to be able to call keys by using methods. It is heavily used by Knj::Objects and have some pre-defined methods because of it to optimize performance. 2 | #===Examples 3 | # hm = Knj::Hash_methods(:test => "Test") 4 | # print hm.test 5 | class Knj::Hash_methods < Hash 6 | #Spawns the object and takes a hash as argument. 7 | def initialize(hash = {}) 8 | self.update(hash) 9 | end 10 | 11 | #Returns the db-key. 12 | def db 13 | return self[:db] 14 | end 15 | 16 | #Returns the ob-key. 17 | def ob 18 | return self[:ob] 19 | end 20 | 21 | #Returns the args-key. 22 | def args 23 | return self[:args] 24 | end 25 | 26 | #Returns the data-key. 27 | def data 28 | return self[:data] 29 | end 30 | 31 | def to_hash 32 | h = {} 33 | self.each do |key, val| 34 | h[k] = val 35 | end 36 | 37 | return h 38 | end 39 | 40 | #Proxies methods into the hash as keys. 41 | def method_missing(method, *args) 42 | method = method.to_sym 43 | return self[method] if self.key?(method) 44 | 45 | raise "No such method '#{method}' on class '#{self.class.name}'" 46 | end 47 | end -------------------------------------------------------------------------------- /lib/knj/jruby-gtk2/dialog.rb: -------------------------------------------------------------------------------- 1 | Gtk.events << ["Dialog", "response", org.gnome.gtk.Dialog::Response, :onResponse, nil] 2 | 3 | class Gtk::Dialog 4 | RESPONSE_OK = org.gnome.gtk.ResponseType::OK 5 | RESPONSE_YES = org.gnome.gtk.ResponseType::YES 6 | RESPONSE_NO = org.gnome.gtk.ResponseType::NO 7 | RESPONSE_CANCEL = org.gnome.gtk.ResponseType::CANCEL 8 | RESPONSE_CLOSE = org.gnome.gtk.ResponseType::CLOSE 9 | RESPONSE_DELETE_EVENT = org.gnome.gtk.ResponseType::DELETE_EVENT 10 | MODAL = true 11 | 12 | def initialize(title = nil, win_parent = nil, modal = nil, *buttons) 13 | if Gtk.takeob 14 | @ob = Gtk.takeob 15 | Gtk.takeob = nil 16 | else 17 | @ob = Gtk.evalob("org.gnome.gtk.Dialog").new(title, win_parent, modal) 18 | 19 | buttons.each do |button| 20 | self.add_button(button[0], button[1]) 21 | end 22 | 23 | self.signal_connect("response") do 24 | self.destroy 25 | end 26 | end 27 | end 28 | 29 | def vbox 30 | return self 31 | end 32 | 33 | def has_separator=(newval) 34 | # FIXME: No way to do this in Java-GTK? 35 | end 36 | 37 | def destroy 38 | if @ob 39 | @ob.hide 40 | end 41 | 42 | @ob = nil 43 | end 44 | end -------------------------------------------------------------------------------- /lib/knj/mutexcl.rb: -------------------------------------------------------------------------------- 1 | class Knj::Mutexcl 2 | def initialize(args = {}) 3 | @args = args 4 | raise "No ':modes' given in arguments." if !@args.key?(:modes) 5 | @mutex = Mutex.new 6 | @blocked = {} 7 | @args[:modes].each do |mode, data| 8 | data[:blocks].each do |block| 9 | @blocked[block] = { 10 | :mutex => Mutex.new, 11 | :count => 0 12 | } 13 | end 14 | end 15 | end 16 | 17 | def self.rw 18 | return Knj::Mutexcl.new( 19 | :modes => { 20 | :reader => {:blocks => [:writer]}, 21 | :writer => {:blocks => [:writer, :reader]} 22 | } 23 | ) 24 | end 25 | 26 | def sync(mode) 27 | raise "No such mode: '#{mode}'." if !@args[:modes].key?(mode) 28 | 29 | while @blocked[mode][:count].to_i > 0 30 | STDOUT.print "Sleeping because blocked '#{mode}' (#{@blocked[mode][:count]}).\n" 31 | sleep 0.1 32 | end 33 | 34 | @mutex.synchronize do 35 | @args[:modes][mode][:blocks].each do |block| 36 | @blocked[block][:count] += 1 37 | end 38 | end 39 | 40 | begin 41 | yield 42 | ensure 43 | @args[:modes][mode][:blocks].each do |block| 44 | @blocked[block][:count] -= 1 45 | end 46 | end 47 | end 48 | end -------------------------------------------------------------------------------- /lib/knj/gtk2_window.rb: -------------------------------------------------------------------------------- 1 | Knj.gem_require(:wref) 2 | 3 | #Containing various helper methods for Gtk2-windows. 4 | class Knj::Gtk2::Window 5 | @@uniques = Wref::Map.new 6 | 7 | #Used to make a window-instance unique. If it already exists when unique! is called, then it will pass focus to the existing window instead of yielding the block, which should contain code to create the window. 8 | #===Examples 9 | #This should only create a single window. 10 | # Knj::Gtk2::Window.unique!("my_window") do 11 | # Gtk::Window.new 12 | # end 13 | # 14 | # Knj::Gtk2::Window.unique!("my_window") do 15 | # Gtk::Window.new 16 | # end 17 | def self.unique!(id) 18 | instance = @@uniques.get!(id) 19 | 20 | if instance and !instance.gui["window"].destroyed? 21 | instance.gui["window"].present 22 | else 23 | obj = yield 24 | @@uniques[id] = obj 25 | end 26 | end 27 | 28 | #Returns the object if it hasnt been destroyed. 29 | #===Examples 30 | # Knj::Gtk2::Window.get("my_window") #=> nil 31 | # Knj::Gtk2::Window.get("my_window") #=> Gtk::Builder-object 32 | def self.get(id) 33 | instance = @@uniques.get!(id) 34 | 35 | if instance and !instance.gui["window"].destroyed? 36 | return instance 37 | end 38 | 39 | return nil 40 | end 41 | end -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/dialog.rb: -------------------------------------------------------------------------------- 1 | class Gtk::Dialog 2 | RESPONSE_OK = RealGtk::ResponseType.Ok 3 | RESPONSE_YES = RealGtk::ResponseType.Yes 4 | RESPONSE_NO = RealGtk::ResponseType.No 5 | RESPONSE_CANCEL = RealGtk::ResponseType.Cancel 6 | RESPONSE_CLOSE = RealGtk::ResponseType.Close 7 | RESPONSE_DELETE_EVENT = RealGtk::ResponseType.DeleteEvent 8 | MODAL = 0 9 | 10 | def initialize(*paras) 11 | if Gtk.takeob 12 | @ob = Gtk.takeob 13 | Gtk.takeob = nil 14 | else 15 | splitted = self.class.to_s.split("::") 16 | @ob = RealGtk.const_get(splitted.last).new(*paras) 17 | end 18 | 19 | if paras.length > 3 20 | 3.upto(paras.length) do |count| 21 | data = paras[count] 22 | 23 | if data.is_a?(Array) 24 | @ob.method(:add_button).overload(System::String, RealGtk::ResponseType).call(data[0], data[1]) 25 | elsif data.is_a?(NilClass) 26 | #do nothing. 27 | else 28 | #raise "Unhandeled data: #{data.class.to_s}" 29 | end 30 | end 31 | end 32 | 33 | if !@ob 34 | raise "Object was not spawned: #{self.class.to_s}" 35 | end 36 | end 37 | 38 | def vbox 39 | Gtk.takeob = @ob.VBox 40 | conv_widget = Gtk::VBox.new 41 | 42 | return conv_widget 43 | end 44 | end -------------------------------------------------------------------------------- /knjrbfw.gemspec: -------------------------------------------------------------------------------- 1 | Gem::Specification.new do |s| 2 | s.name = "knjrbfw" 3 | s.version = "0.0.116" 4 | 5 | s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version= 6 | s.require_paths = ["lib"] 7 | s.authors = ["Kasper Stöckel"] 8 | s.description = "Including stuff for HTTP, SSH and much more." 9 | s.email = "k@spernj.org" 10 | s.extra_rdoc_files = [ 11 | "LICENSE.txt", 12 | "README.rdoc" 13 | ] 14 | s.files = Dir["{include,lib}/**/*"] + ["Rakefile"] 15 | s.homepage = "http://github.com/kaspernj/knjrbfw" 16 | s.licenses = ["MIT"] 17 | s.rubygems_version = "2.4.0" 18 | s.summary = "A framework with lots of stuff for Ruby." 19 | 20 | s.add_runtime_dependency("wref", ">= 0.0.8") 21 | s.add_runtime_dependency("tsafe", ">= 0") 22 | s.add_runtime_dependency("datet", ">= 0") 23 | s.add_runtime_dependency("http2", ">= 0") 24 | s.add_runtime_dependency("php4r", ">= 0") 25 | s.add_runtime_dependency("ruby_process", ">= 0") 26 | s.add_development_dependency("rspec", ">= 0") 27 | s.add_development_dependency("bundler", ">= 0") 28 | s.add_development_dependency("jeweler", ">= 0") 29 | s.add_development_dependency("sqlite3", ">= 0") 30 | s.add_development_dependency("rmagick", ">= 0") 31 | s.add_development_dependency("array_enumerator", ">= 0") 32 | end 33 | -------------------------------------------------------------------------------- /lib/knj/scripts/filesearch.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | 3 | require "knj/autoload" 4 | include Knj 5 | 6 | begin 7 | options = {} 8 | OptionParser.new do |opts| 9 | opts.banner = "Usage: example.rb [options]" 10 | 11 | opts.on("-f FINDTHIS", "--find", "Search for this string.") do |f| 12 | options[:find] = f 13 | end 14 | 15 | opts.on("-b BYTES", "--bytes BYTES", "Return this number of bytes and finding the string.") do |b| 16 | options[:bytes] = b.to_i 17 | end 18 | 19 | opts.on("--filepath FILEPATH", "The file that should be searched.") do |fp| 20 | options[:filepath] = fp 21 | end 22 | end.parse! 23 | rescue OptionParser::InvalidOption => e 24 | Php.die(e.message + "\n") 25 | end 26 | 27 | cont = "" 28 | readstr = "" 29 | retcont = "" 30 | File.open(options[:filepath], "r") do |fp| 31 | loop do 32 | break if fp.eof 33 | 34 | prevcont = String.new(readstr) 35 | readstr = fp.read(1024) 36 | cont = prevcont + readstr 37 | 38 | if ind = cont.index(options[:find]) 39 | read_size = options[:bytes] - (cont.length - ind) 40 | 41 | if read_size > 0 42 | cont += fp.read(read_size) 43 | end 44 | 45 | retcont = cont.slice(ind, options[:bytes]) 46 | break 47 | end 48 | end 49 | end 50 | 51 | print retcont + "\n" -------------------------------------------------------------------------------- /lib/knj/opts.rb: -------------------------------------------------------------------------------- 1 | module Knj::Opts 2 | CONFIG = { 3 | "table" => "options" 4 | } 5 | 6 | def self.init(arr_opts) 7 | arr_opts.each do |pair| 8 | if pair[0] == "knjdb" or pair[0] == "table" 9 | Knj::Opts::CONFIG[pair[0]] = pair[1] 10 | end 11 | end 12 | end 13 | 14 | def self.get(title) 15 | db = Knj::Opts::CONFIG["knjdb"] 16 | value = db.select(Knj::Opts::CONFIG["table"], {"title" => title}, {"limit" => 1}).fetch 17 | 18 | if !value 19 | return "" 20 | else 21 | return value["value"] if value.key?("value") 22 | return value[:value] if value.key?(:value) 23 | raise "Could not figure out of value." 24 | end 25 | end 26 | 27 | def self.set(title, value) 28 | db = Knj::Opts::CONFIG["knjdb"] 29 | result = db.select(Knj::Opts::CONFIG["table"], {"title" => title}, {"limit" => 1}).fetch 30 | 31 | if !result 32 | db.insert(Knj::Opts::CONFIG["table"], { 33 | "title" => title, 34 | "value" => value 35 | }) 36 | else 37 | id = nil 38 | id = result["id"] if result.key?("id") 39 | id = result[:id] if result.key?(:id) 40 | raise "Could not figure out of ID." if !id 41 | 42 | db.update(Knj::Opts::CONFIG["table"], {"value" => value}, {"id" => id}) 43 | end 44 | end 45 | end -------------------------------------------------------------------------------- /lib/knj/degulesider.rb: -------------------------------------------------------------------------------- 1 | class Knj::Degulesider 2 | def initialize(args = {}) 3 | @args = args 4 | @http = Knj::Http.new( 5 | "host" => "www.degulesider.dk" 6 | ) 7 | end 8 | 9 | def search(sargs) 10 | url = "/search/#{Php4r.urlencode(sargs[:where])}/-/1/" 11 | 12 | html = @http.get(url) 13 | ret = [] 14 | 15 | tbody_match = html["data"].match(//) do |match| 17 | res = {} 18 | 19 | if title_match = match[1].match(/

(.+)<\/a><\/h2>/) 20 | res[:name] = title_match[1] 21 | end 22 | 23 | if phone_match = match[1].match(/
  • (Mob.|)\s*([\d\s]+)<\/li><\/ul><\/div>/) 24 | if phone_match[1] == "Mob." 25 | res[:mobile] = phone_match[2].gsub(/\s+/, "") 26 | else 27 | raise "No such phone-mode: #{phone_match[1]}" 28 | end 29 | end 30 | 31 | if city_match = match[1].match(/'locality'>(.+)<\/span>/) 32 | res[:city] = city_match[1] 33 | end 34 | 35 | if category_match = match[1].match(/class='categoryLink'>(.+)<\/a>/) 36 | res[:category] = category_match[1] 37 | end 38 | 39 | ret << res 40 | end 41 | 42 | return ret 43 | end 44 | end -------------------------------------------------------------------------------- /lib/knj/jruby-gtk2/liststore.rb: -------------------------------------------------------------------------------- 1 | class Gtk::ListStore 2 | def dcol; return @dcol; end 3 | def dcol_arr; return @dcol_arr; end 4 | def tv; return @knj_tv; end 5 | 6 | def initialize(*args) 7 | if Gtk.takeob 8 | @ob = Gtk.takeob 9 | Gtk.takeob = nil 10 | else 11 | splitted = self.class.to_s.split("::") 12 | classname = splitted[splitted.length - 1] 13 | 14 | class_spawn = Gtk.evalob("org.gnome.gtk." + classname) 15 | if !class_spawn 16 | raise "Could not find class: " + classname 17 | end 18 | 19 | @dcol = org.gnome.gtk.DataColumn[args.length].new 20 | @dcol_arr = [] 21 | count = 0 22 | args.each do |col_name| 23 | colstring = org.gnome.gtk.DataColumnString.new 24 | @dcol[count] = colstring 25 | @dcol_arr[count] = colstring 26 | count += 1 27 | end 28 | 29 | @ob = class_spawn.new(@dcol) 30 | end 31 | 32 | $knj_jruby_gtk_last_liststore = self 33 | end 34 | 35 | def append 36 | Gtk.takeob = @ob.appendRow 37 | iter = Gtk::TreeIter.new 38 | iter.model = self 39 | 40 | return iter 41 | end 42 | 43 | def tv=(newtv) 44 | @knj_tv = newtv 45 | end 46 | 47 | def get_iter(selection) 48 | iter = @ob.get_iter(selection) 49 | 50 | Gtk.takeob = iter 51 | retob = Gtk::TreeIter.new 52 | retob.model = self 53 | 54 | return retob 55 | end 56 | end -------------------------------------------------------------------------------- /lib/knj/errors.rb: -------------------------------------------------------------------------------- 1 | #This module contains various extra errors used by the other Knj-code. 2 | module Knj::Errors 3 | #An error that is used when the error is just a notice. 4 | class Notice < StandardError; end 5 | 6 | #An error that specifies that the caller should retry the operation. 7 | class Retry < StandardError; end 8 | 9 | #An error that specifies that the current entry should be skipped. 10 | class Skip < StandardError; end 11 | 12 | #Returns a string describing the given error. Possible arguments can be given if you want the returned string formatted as HTML. 13 | # 14 | #===Examples 15 | # begin 16 | # raise 'test' 17 | # rescue => e 18 | # print Knj::Errors.error_str(e, :html => true) 19 | # end 20 | def self.error_str(err, args = {}) 21 | if !err.is_a?(Exception) and err.class.name != "Java::JavaLang::LinkageError" 22 | raise "Invalid object of class '#{err.class.name}' given." 23 | end 24 | 25 | str = "" 26 | 27 | if args[:html] 28 | str << "#{Knj::Web.html(err.class.name)}: #{Knj::Web.html(err.message)}
    \n
    \n" 29 | 30 | err.backtrace.each do |bt| 31 | str << "#{Knj::Web.html(bt)}
    \n" 32 | end 33 | 34 | str << "
    \n
    \n" 35 | else 36 | str << "#{err.class.name}: #{err.message}\n\n" 37 | str << err.backtrace.join("\n") 38 | str << "\n\n" 39 | end 40 | 41 | return str 42 | end 43 | end -------------------------------------------------------------------------------- /lib/knj/tests/compiler/compiler_test_file.rb: -------------------------------------------------------------------------------- 1 | # The Computer Language Benchmarks Game 2 | # http://shootout.alioth.debian.org/ 3 | # 4 | # contributed by Karl von Laudermann 5 | # modified by Jeremy Echols 6 | # modified by Detlef Reichl 7 | # modified by Joseph LaFata 8 | # modified by Peter Zotov 9 | 10 | size = ARGV.shift.to_i 11 | 12 | puts "P4\n#{size} #{size}" 13 | 14 | byte_acc = 0 15 | bit_num = 0 16 | 17 | y = 0 18 | while y < size 19 | ci = (2.0*y/size)-1.0 20 | 21 | x = 0 22 | while x < size 23 | zrzr = zr = 0.0 24 | zizi = zi = 0.0 25 | cr = (2.0*x/size)-1.5 26 | escape = 0b1 27 | 28 | z = 0 29 | while z < 50 30 | tr = zrzr - zizi + cr 31 | ti = 2.0*zr*zi + ci 32 | zr = tr 33 | zi = ti 34 | # preserve recalculation 35 | zrzr = zr*zr 36 | zizi = zi*zi 37 | if zrzr+zizi > 4.0 38 | escape = 0b0 39 | break 40 | end 41 | z += 1 42 | end 43 | 44 | byte_acc = (byte_acc << 1) | escape 45 | bit_num += 1 46 | 47 | # Code is very similar for these cases, but using separate blocks 48 | # ensures we skip the shifting when it's unnecessary, which is most cases. 49 | if (bit_num == 8) 50 | print byte_acc.chr 51 | byte_acc = 0 52 | bit_num = 0 53 | elsif (x == size - 1) 54 | byte_acc <<= (8 - bit_num) 55 | print byte_acc.chr 56 | byte_acc = 0 57 | bit_num = 0 58 | end 59 | x += 1 60 | end 61 | y += 1 62 | end -------------------------------------------------------------------------------- /lib/knj/scripts/speed_test.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | 3 | require "timeout" 4 | 5 | args = {} 6 | ARGV.each do |arg| 7 | if match = arg.match(/^tmpfile=(.+)$/) 8 | args["tmpfile"] = match[1] 9 | else 10 | raise "Unknown argument: '#{arg}'." 11 | end 12 | end 13 | 14 | raise "No 'tmpfile' given in arguments." if !args["tmpfile"] 15 | 16 | #8 kb string. 17 | str = ("0" * 1024) * 8 18 | strl = str.length 19 | 20 | count = 0 21 | time_begin = Time.now.to_f 22 | 23 | puts "Starting to write file." 24 | begin 25 | Timeout.timeout(4) do 26 | File.open(args["tmpfile"], "w") do |fp| 27 | fp.sync = true 28 | 29 | loop do 30 | fp.write(str) 31 | count += strl 32 | end 33 | end 34 | end 35 | rescue Timeout::Error 36 | #ignore 37 | end 38 | 39 | secs = Time.now.to_f - time_begin 40 | mb_sec = ((count / secs) / 1024) / 1024 41 | 42 | puts "#{mb_sec.round(2)} mb/s in #{secs.round(1)} seconds." 43 | 44 | 45 | puts "Starting to read the file again." 46 | count = 0 47 | time_begin = Time.now.to_f 48 | 49 | begin 50 | Timeout.timeout(4) do 51 | File.open(args["tmpfile"], "r") do |fp| 52 | loop do 53 | read = fp.read(4096) 54 | count += read.length 55 | end 56 | end 57 | end 58 | rescue Timeout::Error 59 | #ignore 60 | end 61 | 62 | secs = Time.now.to_f - time_begin 63 | mb_sec = ((count / secs) / 1024) / 1024 64 | 65 | puts "#{mb_sec.round(2)} mb/s in #{secs.round(1)} seconds." 66 | 67 | File.unlink(args["tmpfile"]) -------------------------------------------------------------------------------- /lib/knj/cpufreq.rb: -------------------------------------------------------------------------------- 1 | #This class can manipulate the CPU behavior through "cpufreq". 2 | class Knj::Cpufreq 3 | #Data that is used to identify the CPU controlled by this object. 4 | attr_reader :data 5 | 6 | #Useually called through "Knj::Cpufreq.list". 7 | def initialize(data) 8 | @data = data 9 | @allowed_govs = ["performance", "ondemand", "powersafe", "conservative"] 10 | end 11 | 12 | #Returns a list of CPUs. 13 | #===Examples 14 | # list = Knj::Cpufreq.list 15 | # list.each do |cpufreq| 16 | # cpufreq.governor = "performance" 17 | # end 18 | def self.list 19 | ret = [] 20 | cont = File.read("/proc/cpuinfo") 21 | 22 | matches = cont.scan(/processor\s*:[\s\S]+?\n\n/) 23 | raise "Could not detect CPUs" if !matches or matches.empty? 24 | 25 | matches.each do |cpucont| 26 | cpu_features = {} 27 | features = cpucont.scan(/(.+)\s*:\s*(.+)\s*/) 28 | 29 | features.each do |data| 30 | cpu_features[data[0].strip] = data[1].strip 31 | end 32 | 33 | ret << Knj::Cpufreq.new(cpu_features) 34 | end 35 | 36 | return ret 37 | end 38 | 39 | #Sets the governor. 40 | #===Examples 41 | # cpufreq.governor = "performance" 42 | def governor=(newgov) 43 | raise "Governor not found." if @allowed_govs.index(newgov) == nil 44 | 45 | cmd = "cpufreq-set --cpu #{@data["processor"]} --governor #{newgov}" 46 | res = Knj::Os::shellcmd(cmd) 47 | if res.index("Error setting new values") != nil 48 | raise res.strip 49 | end 50 | end 51 | end -------------------------------------------------------------------------------- /lib/knj/gtk2_menu.rb: -------------------------------------------------------------------------------- 1 | class Knj::Gtk2::Menu 2 | def initialize(paras) 3 | @paras = paras 4 | @items = [] 5 | @mainmenu = Gtk::Menu.new 6 | @signal = "" 7 | 8 | count = 0 9 | if @paras["items"].respond_to?("reverse") 10 | items = @paras["items"].reverse 11 | else 12 | items = @paras["items"] 13 | end 14 | 15 | if items.is_a?(Array) 16 | items = Knj::ArrayExt.dict(items) 17 | end 18 | 19 | items.each do |signal, menuitem| 20 | if menuitem.is_a?(Array) 21 | old_mi = menuitem 22 | menuitem = {"text" => menuitem[0], "connect" => menuitem[1]} 23 | end 24 | 25 | newitem = Gtk::MenuItem.new(menuitem["text"]) 26 | 27 | if menuitem["connect"] 28 | newitem.signal_connect("activate") do 29 | Php4r.call_user_func(menuitem["connect"]) 30 | end 31 | else 32 | newitem.signal_connect("activate") do 33 | on_menuitem_activate 34 | end 35 | end 36 | 37 | @items[count] = { 38 | "gtkmenuitem" => newitem, 39 | "signal" => signal 40 | } 41 | @mainmenu.prepend(newitem) 42 | 43 | count += 1 44 | end 45 | 46 | event = Gdk::EventButton.new(Gdk::Event::BUTTON_PRESS) 47 | 48 | @mainmenu.show_all 49 | @mainmenu.popup(nil, nil, event.button, event.time) 50 | end 51 | 52 | def on_menuitem_activate(signal) 53 | @signal = signal 54 | end 55 | 56 | def signal() return @signal end 57 | end -------------------------------------------------------------------------------- /lib/knj/gtk2_statuswindow.rb: -------------------------------------------------------------------------------- 1 | class Knj::Gtk2::StatusWindow 2 | def initialize(opts = {}) 3 | @opts = opts 4 | 5 | @window = Gtk::Window.new("Status") 6 | @window.modal = true 7 | @window.border_width = 8 8 | @window.set_frame_dimensions(3, 3, 3, 3) 9 | @window.window_position = Gtk::Window::POS_CENTER_ALWAYS 10 | @window.signal_connect("destroy") do 11 | destroy 12 | end 13 | 14 | if opts["transient_for"] 15 | @window.transient_for = @opts["transient_for"] 16 | end 17 | 18 | @label = Gtk::Label.new("Loading...") 19 | @pbar = Gtk::ProgressBar.new 20 | 21 | @vbox = Gtk::VBox.new 22 | @vbox.spacing = 4 23 | @vbox.pack_start(@label, false, true) 24 | @vbox.pack_start(@pbar, false, true) 25 | 26 | @window.add(@vbox) 27 | 28 | @window.show_all 29 | end 30 | 31 | def label=(newlabel) 32 | if @label 33 | @label.label = newlabel 34 | end 35 | end 36 | 37 | def setStatus(perc, newlabel, temp = nil) 38 | if !perc 39 | perc = 0 40 | end 41 | 42 | self.percent = perc 43 | self.label = newlabel.to_s 44 | end 45 | 46 | def percent=(newperc) 47 | if @pbar 48 | @pbar.fraction = newperc 49 | end 50 | end 51 | 52 | def destroy 53 | if @window 54 | @window.destroy 55 | end 56 | 57 | @window = nil 58 | @vbox = nil 59 | @pbar = nil 60 | @label = nil 61 | @opts = nil 62 | end 63 | 64 | alias closeWindow destroy 65 | end -------------------------------------------------------------------------------- /lib/knj/maemo/fremantle-calendar/fremantle-calendar.rb: -------------------------------------------------------------------------------- 1 | class Knj 2 | class Maemo 3 | class FremantleCalendar 4 | def initialize 5 | require "knjrbfw/libknjphpfuncs.rb" 6 | 7 | require "knjrbfw/knjdb/libknjdb.rb" 8 | @db = KnjDB.new({ 9 | "type" => "sqlite3", 10 | "path" => "/home/user/.calendar/calendardb" 11 | }) 12 | end 13 | 14 | def events 15 | ret = [] 16 | f_gevents = @db.query("SELECT * FROM Components ORDER BY DateStart") 17 | while(d_gevents = f_gevents.fetch) 18 | ret << Event.new({ 19 | "cal" => self, 20 | "data" => d_gevents, 21 | "db" => @db 22 | }) 23 | end 24 | 25 | return ret 26 | end 27 | 28 | class Event 29 | def data; return @data; end 30 | def db; return @db; end 31 | def cal; return @cal; end 32 | 33 | def initialize(paras) 34 | @db = paras["db"] 35 | @data = paras["data"] 36 | @cal = paras["cal"] 37 | end 38 | 39 | def [](key) 40 | if (!@data.key?(key)) 41 | raise "No such key: '" + key + "'" 42 | end 43 | 44 | return @data[key] 45 | end 46 | 47 | def []=(key, value) 48 | self[key] #raises error if key is invalid. 49 | 50 | @db.update("Components", {key => value}, {"Id" => @data["Id"]}) 51 | @data[key] = value 52 | end 53 | end 54 | end 55 | end 56 | end -------------------------------------------------------------------------------- /lib/knj/autoload/backups/parsedate.rb: -------------------------------------------------------------------------------- 1 | # 2 | # = parsedate.rb: Parses dates 3 | # 4 | # Author:: Tadayoshi Funaba 5 | # Documentation:: Konrad Meyer 6 | # 7 | # ParseDate munches on a date and turns it into an array of values. 8 | # 9 | 10 | # 11 | # ParseDate converts a date into an array of values. 12 | # For example: 13 | # 14 | # require 'parsedate' 15 | # 16 | # ParseDate.parsedate "Tuesday, July 6th, 2007, 18:35:20 UTC" 17 | # # => [2007, 7, 6, 18, 35, 20, "UTC", 2] 18 | # 19 | # The order is of the form [year, month, day of month, hour, minute, second, 20 | # timezone, day of the week]. 21 | 22 | require 'date/format' 23 | 24 | module ParseDate 25 | # 26 | # Parse a string representation of a date into values. 27 | # For example: 28 | # 29 | # require 'parsedate' 30 | # 31 | # ParseDate.parsedate "Tuesday, July 5th, 2007, 18:35:20 UTC" 32 | # # => [2007, 7, 5, 18, 35, 20, "UTC", 2] 33 | # 34 | # The order is of the form [year, month, day of month, hour, minute, 35 | # second, timezone, day of week]. 36 | # 37 | # ParseDate.parsedate can also take a second argument, +comp+, which 38 | # is a boolean telling the method to compensate for dates with years 39 | # expressed as two digits. Example: 40 | # 41 | # require 'parsedate' 42 | # 43 | # ParseDate.parsedate "Mon Dec 25 00 06:53:24 UTC", true 44 | # # => [2000, 12, 25, 6, 53, 24, "UTC", 1] 45 | # 46 | def parsedate(str, comp=false) 47 | Date._parse(str, comp). 48 | values_at(:year, :mon, :mday, :hour, :min, :sec, :zone, :wday) 49 | end 50 | 51 | module_function :parsedate 52 | 53 | end 54 | -------------------------------------------------------------------------------- /lib/knj/event_filemod.rb: -------------------------------------------------------------------------------- 1 | class Knj::Event_filemod 2 | attr_reader :args 3 | 4 | def initialize(args, &block) 5 | @args = args 6 | @run = true 7 | @mutex = Mutex.new 8 | 9 | @args[:wait] = 1 if !@args.key?(:wait) 10 | 11 | @mtimes = {} 12 | args[:paths].each do |path| 13 | @mtimes[path] = File.mtime(path) 14 | end 15 | 16 | Knj::Thread.new do 17 | while @run do 18 | break if !@args or !@args[:paths] or @args[:paths].empty? 19 | 20 | @mutex.synchronize do 21 | @args[:paths].each do |path| 22 | changed = false 23 | 24 | if @mtimes and !@mtimes.key?(path) and @mtimes.is_a?(Hash) 25 | @mtimes[path] = File.mtime(path) 26 | end 27 | 28 | begin 29 | newdate = File.mtime(path) 30 | rescue Errno::ENOENT 31 | #file does not exist. 32 | changed = true 33 | end 34 | 35 | if !changed and newdate and @mtimes and newdate > @mtimes[path] 36 | changed = true 37 | end 38 | 39 | if changed 40 | block.call(self, path) 41 | @args[:paths].delete(path) if @args and @args[:break_when_changed] 42 | end 43 | end 44 | 45 | sleep @args[:wait] if @args and @run 46 | end 47 | end 48 | end 49 | end 50 | 51 | def destroy 52 | @mtimes = {} 53 | @run = false 54 | @args = nil 55 | end 56 | 57 | def add_path(fpath) 58 | @args[:paths] << fpath 59 | end 60 | end -------------------------------------------------------------------------------- /lib/knj/jruby-gtk2/builder/test_builder.ui: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | True 10 | 11 | 12 | button 13 | True 14 | True 15 | True 16 | 17 | 18 | 0 19 | 20 | 21 | 22 | 23 | True 24 | label 25 | 26 | 27 | 1 28 | 29 | 30 | 31 | 32 | True 33 | True 34 | ● 35 | 36 | 37 | 2 38 | 39 | 40 | 41 | 42 | 43 | 44 | -------------------------------------------------------------------------------- /lib/knj/jruby-gtk2/builder/test_builder.glade: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | True 10 | 11 | 12 | button 13 | True 14 | True 15 | True 16 | 17 | 18 | 0 19 | 20 | 21 | 22 | 23 | True 24 | label 25 | 26 | 27 | 1 28 | 29 | 30 | 31 | 32 | True 33 | True 34 | ● 35 | 36 | 37 | 2 38 | 39 | 40 | 41 | 42 | 43 | 44 | -------------------------------------------------------------------------------- /spec/arrayext_spec.rb: -------------------------------------------------------------------------------- 1 | require File.expand_path(File.dirname(__FILE__) + '/spec_helper') 2 | 3 | describe "ArrayExt" do 4 | it "should be able to do powersets" do 5 | ps = Knj::ArrayExt.powerset(:arr => [1, 2, 3, 4]).to_a 6 | raise "Expected length of 16 but it wasnt: #{ps.length}" if ps.length != 16 7 | 8 | ite = 0 9 | Knj::ArrayExt.powerset(:arr => [1, 2, 3, 4]) do |arr| 10 | ite += 1 11 | end 12 | 13 | raise "Expected block to be executed 16 times but it wasnt: #{ite}" if ite != 16 14 | end 15 | 16 | it "should be able to divide arrays" do 17 | arr = [1, 2, 3, 4, 6, 7, 8, 9, 15, 16, 17, 18] 18 | res = Knj::ArrayExt.divide(:arr => arr) do |a, b| 19 | if (b - a) > 1 20 | false 21 | else 22 | true 23 | end 24 | end 25 | 26 | raise "Expected length of 3 but it wasnt: #{res.length}" if res.length != 3 27 | raise "Expected length of 4 but it wasnt: #{res[0].length}" if res[0].length != 4 28 | raise "Expected length of 3 but it wasnt: #{res[1].length}" if res[1].length != 3 29 | raise "Expected length of 3 but it wasnt: #{res[2].length}" if res[2].length != 3 30 | end 31 | 32 | it "should be able to make ago-strings" do 33 | arr = [1, 2] 34 | Knj::ArrayExt.force_no_cols(:arr => arr, :no => 1) 35 | raise "Expected length of 1 but got: #{arr.length}" if arr.length != 1 36 | raise "Expected element to be 1 but it wasnt: #{arr[0]}" if arr[0] != 1 37 | 38 | Knj::ArrayExt.force_no_cols(:arr => arr, :no => 3, :empty => "test") 39 | raise "Expected length of 3 but got: #{arr.lengtj}" if arr.length != 3 40 | raise "Expected element 2 to be 'test' but it wasnt: #{arr[2]}" if arr[2] != "test" 41 | end 42 | end -------------------------------------------------------------------------------- /lib/knj/autoload/ping.rb: -------------------------------------------------------------------------------- 1 | # 2 | # = ping.rb: Check a host for upness 3 | # 4 | # Author:: Yukihiro Matsumoto 5 | # Documentation:: Konrad Meyer 6 | # 7 | # Performs the function of the basic network testing tool, ping. 8 | # See: Ping. 9 | # 10 | 11 | require 'timeout' 12 | require "socket" 13 | 14 | # 15 | # Ping contains routines to test for the reachability of remote hosts. 16 | # Currently the only routine implemented is pingecho(). 17 | # 18 | # Ping.pingecho uses a TCP echo (not an ICMP echo) to determine if the 19 | # remote host is reachable. This is usually adequate to tell that a remote 20 | # host is available to telnet, ftp, or ssh to. 21 | # 22 | # Warning: Ping.pingecho may block for a long time if DNS resolution is 23 | # slow. Requiring 'resolv-replace' allows non-blocking name resolution. 24 | # 25 | # Usage: 26 | # 27 | # require 'ping' 28 | # 29 | # puts "'jimmy' is alive and kicking" if Ping.pingecho('jimmy', 10) 30 | # 31 | module Ping 32 | 33 | # 34 | # Return true if we can open a connection to the hostname or IP address 35 | # +host+ on port +service+ (which defaults to the "echo" port) waiting up 36 | # to +timeout+ seconds. 37 | # 38 | # Example: 39 | # 40 | # require 'ping' 41 | # 42 | # Ping.pingecho "google.com", 10, 80 43 | # 44 | def pingecho(host, timeout=5, service="echo") 45 | begin 46 | timeout(timeout) do 47 | s = TCPSocket.new(host, service) 48 | s.close 49 | end 50 | rescue Errno::ECONNREFUSED 51 | return true 52 | rescue Timeout::Error, StandardError 53 | return false 54 | end 55 | return true 56 | end 57 | module_function :pingecho 58 | end 59 | 60 | if $0 == __FILE__ 61 | host = ARGV[0] 62 | host ||= "localhost" 63 | printf("%s alive? - %s\n", host, Ping::pingecho(host, 5)) 64 | end 65 | -------------------------------------------------------------------------------- /lib/knj/autoload/backups/ping.rb: -------------------------------------------------------------------------------- 1 | # 2 | # = ping.rb: Check a host for upness 3 | # 4 | # Author:: Yukihiro Matsumoto 5 | # Documentation:: Konrad Meyer 6 | # 7 | # Performs the function of the basic network testing tool, ping. 8 | # See: Ping. 9 | # 10 | 11 | require 'timeout' 12 | require "socket" 13 | 14 | # 15 | # Ping contains routines to test for the reachability of remote hosts. 16 | # Currently the only routine implemented is pingecho(). 17 | # 18 | # Ping.pingecho uses a TCP echo (not an ICMP echo) to determine if the 19 | # remote host is reachable. This is usually adequate to tell that a remote 20 | # host is available to telnet, ftp, or ssh to. 21 | # 22 | # Warning: Ping.pingecho may block for a long time if DNS resolution is 23 | # slow. Requiring 'resolv-replace' allows non-blocking name resolution. 24 | # 25 | # Usage: 26 | # 27 | # require 'ping' 28 | # 29 | # puts "'jimmy' is alive and kicking" if Ping.pingecho('jimmy', 10) 30 | # 31 | module Ping 32 | 33 | # 34 | # Return true if we can open a connection to the hostname or IP address 35 | # +host+ on port +service+ (which defaults to the "echo" port) waiting up 36 | # to +timeout+ seconds. 37 | # 38 | # Example: 39 | # 40 | # require 'ping' 41 | # 42 | # Ping.pingecho "google.com", 10, 80 43 | # 44 | def pingecho(host, timeout=5, service="echo") 45 | begin 46 | timeout(timeout) do 47 | s = TCPSocket.new(host, service) 48 | s.close 49 | end 50 | rescue Errno::ECONNREFUSED 51 | return true 52 | rescue Timeout::Error, StandardError 53 | return false 54 | end 55 | return true 56 | end 57 | module_function :pingecho 58 | end 59 | 60 | if $0 == __FILE__ 61 | host = ARGV[0] 62 | host ||= "localhost" 63 | printf("%s alive? - %s\n", host, Ping::pingecho(host, 5)) 64 | end 65 | -------------------------------------------------------------------------------- /lib/knj/rhodes/youtube_open.erb: -------------------------------------------------------------------------------- 1 |
    2 |
    3 |

    <%=_"Open YouTube link"%>

    4 | 5 | <%=_("Back")%> 6 |
    7 |
    8 | 38 | 39 | <%if System::get_property("platform") == "APPLE"%> 40 | 43 | <%end%> 44 |
    45 |
    -------------------------------------------------------------------------------- /lib/knj/sms.rb: -------------------------------------------------------------------------------- 1 | class Knj::Sms 2 | def initialize(opts) 3 | @opts = Knj::ArrayExt.hash_sym(opts) 4 | 5 | @opts.each do |key, value| 6 | if key == :type 7 | if value == "bibob" or value == "cbb" or value == "smsd_db" 8 | @type = value 9 | 10 | if @type == "smsd_db" 11 | @db = Knj::Db.new(@opts[:knjdb_args]) 12 | Knj::Thread.new(@db) do |db| 13 | db.query("SELECT * FROM outbox WHERE id = 0") #ping! 14 | sleep 15 15 | end 16 | end 17 | else 18 | raise "Not supported: " + value.to_s 19 | end 20 | end 21 | end 22 | end 23 | 24 | def send_sms(number, msg) 25 | if @type == "bibob" 26 | if !@soap 27 | require "webrick/https" 28 | @soap = SOAP::WSDLDriverFactory.new("https://www.bibob.dk/SmsSender.asmx?WSDL").create_rpc_driver 29 | end 30 | 31 | result = @soap.SendMessage({ 32 | "cellphone" => @opts[:user], 33 | "password" => Php4r.md5(@opts[:pass]), 34 | "smsTo" => {"string" => number}, 35 | "smscontents" => msg, 36 | "sendDate" => Php4r.date("Y-m-d"), 37 | "deliveryReport" => "0", 38 | "fromNumber" => @opts[:user] 39 | }) 40 | 41 | if result.sendMessageResult.errorString.to_s != "Ingen fejl." 42 | raise "Could not send SMS: (" + result.sendMessageResult.errorCode.to_s + "): " + result.sendMessageResult.errorString.to_s 43 | end 44 | elsif @type == "smsd_db" 45 | @db.insert("outbox", { 46 | "number" => number, 47 | "text" => msg, 48 | "insertdate" => Php4r.date("Y-m-d H:i:s") 49 | }) 50 | else 51 | raise "Not supported: " + @type 52 | end 53 | end 54 | end -------------------------------------------------------------------------------- /lib/knj/win_registry.rb: -------------------------------------------------------------------------------- 1 | class Knj::Win::Registry 2 | def self.const(type) 3 | if type == :cur_user 4 | return Win32::Registry::HKEY_CURRENT_USER 5 | elsif type == :local_machine 6 | return Win32::Registry::HKEY_LOCAL_MACHINE 7 | else 8 | raise "Unknown type: " + type.to_s 9 | end 10 | end 11 | 12 | def self.type(in_type) 13 | return Win32::Registry::REG_SZ if in_type == :sz 14 | return Win32::Registry::REG_DWORD if in_type == :dword 15 | return Win32::Registry::REG_BINARY if in_type == :bin 16 | return nil if in_type == nil 17 | 18 | raise "Unknown type: #{in_type}" 19 | end 20 | 21 | def self.get(type, regpath, key, in_type = nil) 22 | hkey = self.const(type) 23 | hkey.open(regpath, Win32::Registry::KEY_ALL_ACCESS) do |reg| 24 | return reg[key, self.type(in_type)].to_s 25 | 26 | #reg.each_key do |k, v| 27 | # puts k, v 28 | #end 29 | #reg.each_value do |k, v| 30 | # puts k, v 31 | #end 32 | 33 | #reg_typ, reg_val = reg.read('') 34 | #return { 35 | # :type => reg_typ, 36 | # :value => reg_val 37 | #} 38 | end 39 | end 40 | 41 | def self.set(type, regpath, key, content = nil, in_type = nil) 42 | if key.is_a?(Array) 43 | key.each do |v| 44 | if v.is_a?(Array) 45 | self.set(type, regpath, v[0], v[1], v[2]) 46 | elsif v.is_a?(Hash) 47 | self.set(type, regpath, k, v[:val], v[:type]) 48 | else 49 | raise "Unknown type: #{v.class.to_s}" 50 | end 51 | end 52 | else 53 | hkey = self.const(type) 54 | hkey.create(regpath) 55 | hkey.open(regpath, Win32::Registry::KEY_ALL_ACCESS) do |reg| 56 | reg[key.to_s, self.type(in_type)] = content.to_s 57 | end 58 | end 59 | end 60 | end -------------------------------------------------------------------------------- /lib/knj/compiler.rb: -------------------------------------------------------------------------------- 1 | #This class can compile Ruby-files into Ruby-methods on a special class and then call these methods to run the code from the file. The theory is that this can be faster... 2 | class Knj::Compiler 3 | def initialize(args = {}) 4 | @args = args 5 | @mutex = Mutex.new 6 | 7 | if @args[:cache_hash] 8 | @compiled = @args[:cache_hash] 9 | else 10 | @compiled = {} 11 | end 12 | end 13 | 14 | #Compiles file into cache as a method. 15 | def compile_file(args) 16 | raise "File does not exist." if !File.exist?(args[:filepath]) 17 | defname = def_name_for_file_path(args[:filepath]) 18 | 19 | evalcont = "class Knj::Compiler::Container; def self.#{defname};" 20 | evalcont << File.read(args[:filepath]) 21 | evalcont << ";end;end" 22 | 23 | eval(evalcont, nil, args[:fileident]) 24 | @compiled[args[:filepath]] = Time.new 25 | end 26 | 27 | #Returns the method name for a filepath. 28 | def def_name_for_file_path(filepath) 29 | return filepath.gsub("/", "_").gsub(".", "_") 30 | end 31 | 32 | #Compile and evaluate a file - it will be cached. 33 | def eval_file(args) 34 | #Compile if it hasnt been compiled yet. 35 | if !@compiled.key?(args[:filepath]) 36 | @mutex.synchronize do 37 | compile_file(args) if !@compiled.key?(args[:filepath]) 38 | end 39 | end 40 | 41 | #Compile if modified time has been changed. 42 | mtime = File.mtime(args[:filepath]) 43 | if @compiled[args[:filepath]] < mtime 44 | @mutex.synchronize do 45 | compile_file(args) 46 | end 47 | end 48 | 49 | #Call the compiled function. 50 | defname = def_name_for_file_path(args[:filepath]) 51 | Knj::Compiler::Container.send(defname) 52 | end 53 | 54 | #This class holds the compiled methods. 55 | class Knj::Compiler::Container; end 56 | end -------------------------------------------------------------------------------- /lib/knj/iotop.rb: -------------------------------------------------------------------------------- 1 | #Currently broken - cannot get iotop to return values when running through script :-( 2 | class Knj::Iotop 3 | def initialize(args) 4 | @data = {} 5 | @mutex = Monitor.new 6 | 7 | cmd = "iotop -bPk" 8 | 9 | if args[:pids] 10 | args[:pids].each do |pid| 11 | cmd << " --pid=#{pid.to_i}" 12 | end 13 | end 14 | 15 | @stdout = IO.popen(cmd) 16 | 17 | @thread = Knj::Thread.new do 18 | @stdout.each_line do |line_str| 19 | if line_str.match(/^Total\s+disk\s+read:\s+([\d\.]+)\s+(K\/s)\s+\|\s+Total\s+disk\s+write:\s+([\d\.]+)\s+(K\/s)\s*$/i) 20 | #ignore. 21 | elsif line_str.match(/ PID PRIO USER DISK READ DISK WRITE SWAPIN IO COMMAND/) 22 | #ignore. 23 | elsif match = line_str.match(/^\s*(\d+)\s+(.+?)\s+(.+?)\s+([\d\.]+)\s+(K\/s)\s+([\d\.]+)\s+(K\/s)\s+([\d\.]+)\s+(%)\s+([\d\.]+)\s+(%)\s+(.+)\s*$/) 24 | @mutex.synchronize do 25 | pid = match[1].to_i 26 | 27 | if match[12].index("bestseller") != nil 28 | print line_str + "\n" 29 | Php4r.print_r(match) 30 | end 31 | 32 | @data[pid] = { 33 | :pid => pid, 34 | :prio => match[2], 35 | :user => match[3], 36 | :disk_read => (match[4].to_f * 1024).to_i, 37 | :disk_write => (match[6].to_f * 1024).to_i, 38 | :spawpin => match[8].to_f, 39 | :io => match[10].to_f, 40 | :cmd => match[12] 41 | } 42 | end 43 | else 44 | raise "Could not parse line: '#{line_str}'." 45 | end 46 | end 47 | end 48 | end 49 | 50 | #Returns information for the given PID. 51 | def [](pid) 52 | @mutex.synchronize do 53 | pid = pid.to_i 54 | raise "No such PID: '#{pid}'." if !@data.key?(pid) 55 | return @data[pid] 56 | end 57 | end 58 | end -------------------------------------------------------------------------------- /lib/knj/locale_strings.rb: -------------------------------------------------------------------------------- 1 | #This file can be symlinked and thereby easily translated by POEdit. Further more the static methods can be used for stuff. 2 | module Knj::Locales 3 | #Returns an array of translated day-names ('_'-method must exist!). 4 | #===Examples 5 | # Knj::Locales.days_arr #=> ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"] 6 | def self.days_arr 7 | return [_("Monday"), _("Tuesday"), _("Wednesday"), _("Thursday"), _("Friday"), _("Saturday"), _("Sunday")] 8 | end 9 | 10 | #Returns an array of short translated day-names. 11 | #===Examples 12 | # Knj::Locales.days_short_arr #=> ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"] 13 | def self.days_short_arr 14 | return [_("Mon"), _("Tue"), _("Wed"), _("Thu"), _("Fri"), _("Sat"), _("Sun")] 15 | end 16 | 17 | #Returns an array of translated month-names. 18 | #===Examples 19 | # Knj::Locales.months_arr #=> ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"] 20 | def self.months_arr 21 | return [_("January"), _("February"), _("March"), _("April"), _("May"), _("June"), _("July"), _("August"), _("September"), _("October"), _("November"), _("December")] 22 | end 23 | 24 | #Returns an array of translate 'ago'-strings. View the source to see which. 25 | def self.ago_strings 26 | return { 27 | :year_ago_str => _("%s year ago"), 28 | :years_ago_str => _("%s years ago"), 29 | :month_ago_str => _("%s month ago"), 30 | :months_ago_str => _("%s months ago"), 31 | :day_ago_str => _("%s day ago"), 32 | :days_ago_str => _("%s days ago"), 33 | :hour_ago_str => _("%s hour ago"), 34 | :hours_ago_str => _("%s hours ago"), 35 | :min_ago_str => _("%s minute ago"), 36 | :mins_ago_str => _("%s minutes ago"), 37 | :sec_ago_str => _("%s second ago"), 38 | :secs_ago_str => _("%s seconds ago"), 39 | :right_now_str => _("right now") 40 | } 41 | end 42 | end -------------------------------------------------------------------------------- /lib/knj/mail.rb: -------------------------------------------------------------------------------- 1 | class Knj::Mail 2 | def initialize(paras = {}) 3 | @paras = { 4 | "smtp_host" => "localhost", 5 | "smtp_port" => 25, 6 | "smtp_user" => nil, 7 | "smtp_passwd" => nil, 8 | "smtp_domain" => ENV["HOSTNAME"] 9 | } 10 | 11 | if paras.is_a?(Hash) 12 | paras.each do |key, value| 13 | @paras[key] = value 14 | end 15 | end 16 | 17 | self.send if @paras["send"] 18 | end 19 | 20 | def html=(value) 21 | @paras["html"] = value 22 | end 23 | 24 | def text=(value) 25 | @paras["text"] = value 26 | end 27 | 28 | def from=(value) 29 | @paras["from"] = value 30 | end 31 | 32 | def subject=(value) 33 | @paras["subject"] = value 34 | end 35 | 36 | def to=(value) 37 | @paras["to"] = value.untaint 38 | end 39 | 40 | def send 41 | raise "No email has been defined to send to." if !@paras["to"] 42 | raise "No subject has been defined." if !@paras["subject"] 43 | raise "No content has been defined." if !@paras["text"] and !@paras["html"] 44 | 45 | mail = TMail::Mail.new 46 | mail.to = @paras["to"] 47 | mail.subject = @paras["subject"] 48 | mail.date = Time.new 49 | 50 | mail.from = @paras["from"] if @paras["from"] 51 | 52 | if @paras["html"] 53 | mail.set_content_type("text", "html") 54 | mail.body = @paras["html"] 55 | elsif @paras["text"] 56 | mail.body = @paras["text"] 57 | end 58 | 59 | smtp_start = Net::SMTP.new(@paras["smtp_host"], @paras["smtp_port"]) 60 | smtp_start.enable_ssl if @paras["ssl"] 61 | smtp_start.enable_starttls if @paras["tls"] 62 | 63 | if !@paras["smtp_domain"] 64 | if @paras["smtp_host"] 65 | @paras["smtp_domain"] = @paras["smtp_host"] 66 | else 67 | raise "SMTP domain not given." 68 | end 69 | end 70 | 71 | smtp_start.start(@paras["smtp_domain"], @paras["smtp_user"], @paras["smtp_passwd"]) do |smtp| 72 | smtp.send_message(mail.to_s, @paras["from"], @paras["to"]) 73 | end 74 | end 75 | end -------------------------------------------------------------------------------- /lib/knj/libqt.rb: -------------------------------------------------------------------------------- 1 | require "Qt" 2 | require "qtuitools" 3 | require "knjrbfw/libqt_window.rb" 4 | 5 | class QtLoader 6 | def window 7 | return @window 8 | end 9 | 10 | def loader 11 | return @loader 12 | end 13 | 14 | def object_connect 15 | return @object_connect 16 | end 17 | 18 | def widget(name) 19 | return @widgets[name] 20 | end 21 | 22 | def initialize(paras) 23 | @widgets = {} 24 | 25 | if (paras.class.to_s == "Hash") 26 | file_path = paras["file"] 27 | @object_connect = paras["object_connect"] 28 | elsif(paras.class.to_s == "String") 29 | file_path = paras 30 | elsif(paras.class.to_s == "Array") 31 | file_path = paras[0] 32 | @object_connect = paras[1] 33 | else 34 | raise "Unknown parameter" 35 | end 36 | 37 | file = Qt::File.new(file_path) 38 | file.open(Qt::File::ReadOnly) 39 | @loader = Qt::UiLoader.new 40 | @window = @loader.load(file, nil) 41 | file.close 42 | 43 | 44 | @window.findChildren(Qt::Object).each do |widget| 45 | object_name = widget.object_name.to_s 46 | 47 | if (object_name.length > 0) 48 | @widgets[object_name] = widget 49 | 50 | if (@object_connect) 51 | meta = widget.meta_object 52 | signals = {} 53 | 0.upto(meta.methodCount - 1) do |count| 54 | method_info = meta.method(count) 55 | 56 | if (method_info.method_type == 1) 57 | method_name = method_info.signature.match(/^(.+)\(/) 58 | signals[method_name[1]] = method_info.signature 59 | end 60 | end 61 | end 62 | 63 | signals.each do |item| 64 | func_name = "on_" + object_name + "_" + item[0] 65 | if (@object_connect.respond_to?(func_name)) 66 | params = item[1].sub(/[a-z]+(\(.*$)/, '\1') 67 | widget.connect(SIGNAL item[1]) do 68 | @object_connect.send(func_name) 69 | end 70 | end 71 | end 72 | end 73 | end 74 | end 75 | end -------------------------------------------------------------------------------- /lib/knj/mailobj.rb: -------------------------------------------------------------------------------- 1 | class Knj::Mailobj 2 | def initialize(args = {}) 3 | @args = { 4 | "smtp_host" => "localhost", 5 | "smtp_port" => 25, 6 | "smtp_user" => nil, 7 | "smtp_passwd" => nil, 8 | "smtp_domain" => ENV["HOSTNAME"] 9 | } 10 | 11 | if args.is_a?(Hash) 12 | args.each do |key, value| 13 | @args[key] = value 14 | end 15 | end 16 | 17 | self.send if @args["send"] 18 | end 19 | 20 | def html=(value) 21 | @args["html"] = value 22 | end 23 | 24 | def text=(value) 25 | @args["text"] = value 26 | end 27 | 28 | def from=(value) 29 | @args["from"] = value 30 | end 31 | 32 | def subject=(value) 33 | @args["subject"] = value 34 | end 35 | 36 | def to=(value) 37 | @args["to"] = value.untaint 38 | end 39 | 40 | def send 41 | raise "No email has been defined to send to." if !@args["to"] 42 | raise "No subject has been defined." if !@args["subject"] 43 | raise "No content has been defined." if !@args["text"] and !@args["html"] 44 | 45 | require "mail" 46 | 47 | mail = Mail.new 48 | mail.to = @args["to"] 49 | mail.subject = @args["subject"] 50 | mail.date = Time.now 51 | mail.from = @args["from"] if @args["from"] 52 | 53 | if @args["html"] 54 | tha_html = @args["html"] 55 | mail.html_part do 56 | content_type "text/html; charset=UTF-8" 57 | body tha_html 58 | end 59 | end 60 | 61 | if @args["text"] 62 | tha_text = @args["text"] 63 | mail.text_part do 64 | body tha_text 65 | end 66 | end 67 | 68 | smtp_start = Net::SMTP.new(@args["smtp_host"], @args["smtp_port"]) 69 | smtp_start.enable_ssl if @args["ssl"] 70 | smtp_start.enable_starttls if @args["tls"] 71 | 72 | if !@args["smtp_domain"] 73 | if @args["smtp_host"] 74 | @args["smtp_domain"] = @args["smtp_host"] 75 | else 76 | raise "SMTP domain not given." 77 | end 78 | end 79 | 80 | smtp_start.start(@args["smtp_domain"], @args["smtp_user"], @args["smtp_passwd"]) do |smtp| 81 | smtp.send_message(mail.to_s, @args["from"], @args["to"]) 82 | end 83 | end 84 | end -------------------------------------------------------------------------------- /lib/knj/cmd_gen.rb: -------------------------------------------------------------------------------- 1 | #This class holds various methods to generate commands for command-line-purpose. 2 | class Knj::Cmd_gen 3 | #Generates rsync commands as strings. 4 | #===Examples 5 | # Knj::Cmd_gen.rsync( 6 | # :bin => "/usr/bin/rsync", 7 | # :verbose => 2, 8 | # :ssh => true, 9 | # :port => 10022, 10 | # :delete => true, 11 | # :exclude => "cache", 12 | # :user => "username", 13 | # :host => "mydomain.com", 14 | # :dir_host => "/home/username/sync_path", 15 | # :dir_local => "/home/otheruser/sync_path" 16 | # ) #=> 17 | def self.rsync(args) 18 | cmd = "" 19 | 20 | if args[:bin] 21 | cmd << args[:bin] 22 | else 23 | cmd << "rsync" 24 | end 25 | 26 | cmd << " -az" 27 | 28 | if args[:verbose] 29 | 1.upto(args[:verbose]) do 30 | cmd << "v" 31 | end 32 | end 33 | 34 | if args[:ssh] 35 | cmd << " -e ssh" 36 | 37 | if args[:port] 38 | cmd << " --rsh='ssh -p #{args[:port]}'" 39 | end 40 | end 41 | 42 | if args[:delete] 43 | cmd << " --delete" 44 | end 45 | 46 | if args[:exclude] 47 | args[:exclude].each do |dir| 48 | cmd << " --exclude \"#{dir}\"" 49 | end 50 | end 51 | 52 | cmd << " \"#{args[:user]}@#{args[:host]}:#{args[:dir_host]}\" \"#{args[:dir_local]}\"" 53 | 54 | return cmd 55 | end 56 | 57 | #Generates tar commands. 58 | #===Examples 59 | # Knj::Cmd_gen.tar( 60 | # :bin => "/usr/bin/tar", 61 | # :gzip => true, 62 | # :extract => false, 63 | # :file => true, 64 | # :create => true, 65 | # :verbose => 1, 66 | # :archive_path => "~/myarchive.tar.gz", 67 | # :paths => ["~/mylib1", "~/mylib2", "~/mylib3"] 68 | # ) #=> 69 | def self.tar(args) 70 | cmd = "" 71 | 72 | if args[:bin] 73 | cmd << args[:bin] 74 | else 75 | cmd << "tar" 76 | end 77 | 78 | cmd << " " 79 | cmd << "z"if args[:gzip] 80 | cmd << "x" if args[:extract] 81 | cmd << "f" if args[:file] 82 | cmd << "c" if args[:create] 83 | 84 | if args[:verbose] 85 | 1.upto(args[:verbose]) do 86 | cmd << "v" 87 | end 88 | end 89 | 90 | cmd << " \"#{args[:archive_path]}\"" 91 | 92 | args[:paths].each do |path| 93 | cmd << " \"#{path}\"" 94 | end 95 | 96 | return cmd 97 | end 98 | end -------------------------------------------------------------------------------- /spec/strings_spec.rb: -------------------------------------------------------------------------------- 1 | require File.expand_path(File.dirname(__FILE__) + '/spec_helper') 2 | 3 | require "knj/strings" 4 | require "knj/errors" 5 | 6 | describe "Strings" do 7 | it "regex" do 8 | regex = Knj::Strings.regex("/(\d+)/i") 9 | raise "Regex should be '(?i-mx:(d+))' but wasnt: '#{regex}'." if "#{regex}" != "(?i-mx:(d+))" 10 | 11 | regex = Knj::Strings.regex("/\d+/") 12 | raise "Regex should be '(?-mix:d+)' but wasnt: '#{regex}'." if "#{regex}" != "(?-mix:d+)" 13 | 14 | begin 15 | regex = Knj::Strings.regex("/\d+/U") 16 | raise "Ruby doesnt support the U-modifier - an exception should be thrown!" 17 | rescue ArgumentError 18 | #this should happen - Ruby doesnt support U-modifier... 19 | end 20 | 21 | regex = Knj::Strings.regex("/(\\d{6})$/") 22 | res = "FNR. 7213820".match(regex) 23 | raise "Not matched." if !res 24 | raise "Expected result 1 to be '213820' but it wasnt: '#{res[1]}'." if res[1] != "213820" 25 | 26 | res = Knj::Strings.is_regex?("Kasper") 27 | raise "Expected res to be false but it wasnt." if res 28 | 29 | res = Knj::Strings.is_regex?("/^Kasper$/") 30 | raise "Expected res to be true but it wasnt." if !res 31 | end 32 | 33 | it "secs_to_human_time_str" do 34 | res = Knj::Strings.secs_to_human_time_str(3695) 35 | raise "Expected '01:01:35' but got: '#{res}'." if res != "01:01:35" 36 | 37 | secs = Knj::Strings.human_time_str_to_secs("01:30:30") 38 | raise "Expected secs to be 5430 but it was #{secs}" if secs != 5430 39 | 40 | secs = Knj::Strings.human_time_str_to_secs("01:30") 41 | raise "Expected secs to be 5400 but it was #{secs}" if secs != 5400 42 | end 43 | 44 | it "secs_to_human_short_time" do 45 | res = Knj::Strings.secs_to_human_short_time(3700) 46 | raise "Expected '1.0t' but got '#{res}'." if res != "1.0t" 47 | 48 | res = Knj::Strings.secs_to_human_short_time(57) 49 | raise "Expected '57s' but got '#{res}'." if res != "57s" 50 | 51 | res = Knj::Strings.secs_to_human_short_time(185) 52 | raise "Expected '3m' but got '#{res}'." if res != "3m" 53 | 54 | res = Knj::Strings.secs_to_human_short_time(57, :secs => false) 55 | raise "Expected '0m' but got '#{res}'." if res != "0m" 56 | 57 | res = Knj::Strings.secs_to_human_short_time(120, :mins => false) 58 | raise "Expected '0.0t' but got '#{res}'." if res != "0.0t" 59 | end 60 | 61 | it "sanitize_filename" do 62 | res = Knj::Strings.sanitize_filename('1\2 3/4') 63 | res.should eql("1_2_3_4") 64 | end 65 | end -------------------------------------------------------------------------------- /lib/knj/knj.rb: -------------------------------------------------------------------------------- 1 | $knjpath = "knj/" if !$knjpath 2 | 3 | module Knj 4 | CONFIG = {} 5 | 6 | def self.const_missing(name) 7 | if name == :Db 8 | filepath = "#{$knjpath}knjdb/libknjdb" 9 | else 10 | filepath = "#{$knjpath}#{name.to_s.downcase}" 11 | end 12 | 13 | require filepath 14 | raise "Constant still not defined: '#{name}'." if !Knj.const_defined?(name) 15 | return Knj.const_get(name) 16 | end 17 | 18 | def self.appserver_cli(filename) 19 | Knj::Os.chdir_file(filename) 20 | require "#{$knjpath}/includes/appserver_cli.rb" 21 | end 22 | 23 | def self.dirname(filepath) 24 | raise "Filepath does not exist: #{filepath}" if !File.exist?(filepath) 25 | return File.realpath(File.dirname(filepath)) 26 | end 27 | 28 | #Returns the path of the knjrbfw-framework. 29 | def self.knjrbfw_path 30 | return File.realpath(File.dirname(__FILE__)) 31 | end 32 | 33 | #Shortcut to Php4r.print_r. 34 | def self.p(*args, &block) 35 | require "php4r" if !Kernel.const_defined?(:Php4r) 36 | return Php4r.print_r(*args, &block) 37 | end 38 | 39 | def self.handle_return(args) 40 | if args[:block] 41 | args[:enum].each(&args[:block]) 42 | return nil 43 | else 44 | return Array_enumerator.new(args[:enum]) 45 | end 46 | end 47 | 48 | #Loads a gem by a given name. First tries to load the gem from a custom parent directory to enable loading of development-gems. 49 | def self.gem_require(gem_const, gem_name = nil) 50 | #Support given an array for multiple gem-names in one call. 51 | if gem_const.is_a?(Array) and gem_name == nil 52 | gem_const.each do |gem_i| 53 | self.gem_require(gem_i) 54 | end 55 | 56 | return nil 57 | end 58 | 59 | #Set correct names. 60 | gem_name = gem_const.to_s.downcase.strip if !gem_name 61 | gem_const = "#{gem_const.to_s[0].upcase}#{gem_const.to_s[1, gem_name.length]}" 62 | 63 | #Return false if the constant is already loaded. 64 | return false if ::Kernel.const_defined?(gem_const) 65 | 66 | #Try to load gem from custom development-path. 67 | found_custom = false 68 | 69 | paths = [ 70 | "#{File.realpath("#{File.dirname(__FILE__)}/../../..")}/#{gem_name}/lib/#{gem_name}.rb" 71 | ] 72 | paths.each do |path| 73 | if File.exist?(path) 74 | require path 75 | found_custom = true 76 | break 77 | end 78 | end 79 | 80 | #Custom-path could not be loaded - load gem normally. 81 | if !found_custom 82 | require "rubygems" 83 | require gem_name.to_s 84 | end 85 | 86 | #Return true to enable detection of that something was loaded. 87 | return true 88 | end 89 | end -------------------------------------------------------------------------------- /lib/knj/cmd_parser.rb: -------------------------------------------------------------------------------- 1 | Knj.gem_require(:Datet, :datet) 2 | 3 | #This class can help you parse results from command-line commands. 4 | class Knj::Cmd_parser 5 | #Parses the results of "ls -l". 6 | #===Examples 7 | # str = %x[ls -l] 8 | # Knj::Cmd_parser.lsl(str) #=> holding a lot of info about the various listed files. 9 | def self.lsl(str, args = {}) 10 | ret = [] 11 | 12 | str.lines.each do |line| 13 | next if line.match(/^total([A-z]*)\s+([\d\.,]+)(M|k|G|)$/) 14 | match = line.match(/^(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)\s+(\d+)\s+(.+)\s+([^\W].+?)\s+([\d\.,]+)(M|k|G|K|)\s+((\d+)-(\d+)-(\d+)|(([A-z]{3})\s+(\d+)))\s+((\d+):(\d+)|(\d{4}))\s+(.+)$/) 15 | raise "Could not match: '#{line}'." if !match 16 | 17 | year = nil 18 | 19 | if match[17].to_i > 0 20 | year = match[17].to_i 21 | elsif match[26].to_i > 0 22 | year = match[26].to_i 23 | end 24 | 25 | hour = match[24].to_i 26 | min = match[25].to_i 27 | 28 | if match[17] and match[18] and match[19] 29 | month = match[18].to_i 30 | date = match[19].to_i 31 | elsif match[20] and match[21] and match[22] 32 | month = Datet.month_str_to_no(match[21]) 33 | date = match[22].to_i 34 | end 35 | 36 | if !year 37 | if month > Time.now.month 38 | year = Time.now.year - 1 39 | else 40 | year = Time.now.year 41 | end 42 | end 43 | 44 | time = Time.local(year, month, date, hour, min) 45 | bytes = match[14].gsub(",", ".").to_f 46 | 47 | size_match = match[15] 48 | if size_match == "" 49 | #bytes - dont touch 50 | elsif size_match.downcase == "k" 51 | bytes = bytes * 1024 52 | elsif size_match == "M" 53 | bytes = bytes * 1024 * 1024 54 | elsif size_match == "G" 55 | bytes = bytes * 1024 * 1024 * 1024 56 | else 57 | raise "Unknown size match: '#{size_match}'." 58 | end 59 | 60 | ret << { 61 | :mod => { 62 | :usr => { 63 | :read => match[2], 64 | :write => match[3], 65 | :exec => match[4] 66 | }, 67 | :grp => { 68 | :read => match[5], 69 | :write => match[6], 70 | :exec => match[7] 71 | }, 72 | :all => { 73 | :read => match[8], 74 | :write => match[9], 75 | :exec => match[10] 76 | } 77 | }, 78 | :usr => match[12], 79 | :grp => match[13], 80 | :size => bytes.to_i, 81 | :time => time, 82 | :file => match[27] 83 | } 84 | end 85 | 86 | return ret 87 | end 88 | end -------------------------------------------------------------------------------- /lib/knj/php_parser/functions.rb: -------------------------------------------------------------------------------- 1 | class Knj::Php_parser 2 | def func_args(func_name) 3 | func_arg_count = 0 4 | args = [] 5 | 6 | loop do 7 | if match = self.matchclear(/\A\$#{@regex_varname}\s*(,\s*|)/) 8 | args << { 9 | "varname" => match[1], 10 | "newname" => "phpvar_#{match[1]}" 11 | } 12 | elsif match = self.matchclear(/\A\)\s*\{/) 13 | break 14 | else 15 | raise "Could not match function arguments." 16 | end 17 | end 18 | 19 | @retcont << "#{self.tabs}module Knj::Php_parser::Functions\n" 20 | @tabs << 1 21 | @retcont << "#{self.tabs}def self.#{func_name}(" 22 | 23 | first = true 24 | args.each do |arg| 25 | @retcont << ", " if !first 26 | first = false if first 27 | @retcont << arg["newname"] 28 | end 29 | 30 | @retcont << ")\n" 31 | @tabs += 1 32 | @funcs_started += 1 33 | 34 | self.search_newstuff 35 | end 36 | 37 | def func_args_single_given 38 | arg_found = false 39 | 40 | loop do 41 | if !arg_found and match = self.matchclear(/\A\"/) 42 | @retcont << "\"" 43 | self.match_semi 44 | @retcont << ")" 45 | arg_found = true 46 | elsif !arg_found and match = self.matchclear(/\A\$(#{@regex_varname})/) 47 | @retcont << "phpvar_#{match[1]}" 48 | arg_found = true 49 | elsif arg_found and match = self.matchclear(/\A\.\s*/) 50 | @retcont << " + " 51 | arg_found = false 52 | elsif arg_found and match = self.matchclear(/\A;/) 53 | @retcont << "\n" 54 | break 55 | else 56 | raise "Could not figure out what to do." 57 | end 58 | end 59 | end 60 | 61 | def func_args_given 62 | arg_found = false 63 | 64 | loop do 65 | if !arg_found and match = self.matchclear(/\A\"/) 66 | @retcont << "\"" 67 | self.match_semi 68 | @retcont << ")" 69 | arg_found = true 70 | elsif !arg_found and match = self.matchclear(/\A\$(#{@regex_varname})/) 71 | @retcont << "phpvar_#{match[1]}" 72 | arg_found = true 73 | elsif arg_found and match = self.matchclear(/\A\.\s*/) 74 | @retcont << " + " 75 | arg_found = false 76 | elsif arg_found and match = self.matchclear(/\A\)\s*;/) 77 | @retcont << "\n" 78 | break 79 | else 80 | raise "Could not figure out what to do." 81 | end 82 | end 83 | end 84 | 85 | def match_semi 86 | loop do 87 | if match = self.matchclear(/\A[A-z\d_\.]+/) 88 | @retcont << match[0] 89 | elsif match = self.matchclear(/\A\"/) 90 | @retcont << "\"" 91 | break 92 | else 93 | raise "Could not figure out what to do." 94 | end 95 | end 96 | end 97 | end -------------------------------------------------------------------------------- /lib/knj/jruby-gtk2/treeview.rb: -------------------------------------------------------------------------------- 1 | Gtk.events << ["TreeView", "row_activated", org.gnome.gtk.TreeView::RowActivated, :onRowActivated, nil] 2 | Gtk.events << ["TreeSelection", "changed", org.gnome.gtk.TreeSelection::Changed, :onChanged, nil] 3 | 4 | class Gtk::TreeView 5 | def set_model(newmodel) 6 | @knj_model = newmodel 7 | @ob.model = newmodel.ob 8 | newmodel.tv = self 9 | 10 | $knj_jruby_gtk_last_treeview = self 11 | end 12 | 13 | alias :model= :set_model 14 | 15 | def append_column(column) 16 | #do nothing - the Java mode should already have done this. 17 | end 18 | 19 | def model 20 | return @knj_model 21 | end 22 | 23 | def columns 24 | return TreeViewColumns.new(self) 25 | end 26 | 27 | def selection 28 | if !@tsel 29 | Gtk.takeob = @ob.selection 30 | @tsel = Gtk::TreeSelection.new 31 | end 32 | 33 | return @tsel 34 | end 35 | end 36 | 37 | class TreeViewColumns < Array 38 | def initialize(treeview) 39 | @treeview = treeview 40 | @treeview.ob.columns.each do |column| 41 | Gtk.takeob = column 42 | self << Gtk::TreeViewColumn.new(nil, nil) 43 | end 44 | end 45 | end 46 | 47 | class Gtk::TreeSelection 48 | def initialize(val1 = nil) 49 | if Gtk.takeob 50 | @ob = Gtk.takeob 51 | Gtk.takeob = nil 52 | else 53 | @ob = @treeview.ob.append_column 54 | @ob.title = title 55 | renderer.init(self) 56 | colstring = @treeview.model.dcol[@treeview.columns.length - 1] 57 | renderer.text = colstring 58 | end 59 | end 60 | end 61 | 62 | class Gtk::TreeViewColumn 63 | def initialize(title, renderer, last_args = {}) 64 | @treeview = $knj_jruby_gtk_last_treeview 65 | 66 | if Gtk.takeob 67 | @ob = Gtk.takeob 68 | Gtk.takeob = nil 69 | else 70 | @ob = @treeview.ob.append_column 71 | @ob.title = title 72 | $knj_jruby_gtk_last_treeview_column = self 73 | renderer.init(self) 74 | colstring = @treeview.model.dcol[@treeview.columns.length - 1] 75 | renderer.text = colstring 76 | end 77 | end 78 | 79 | def set_visible(newval) 80 | @treeview.remove_column(@ob) 81 | end 82 | 83 | alias visible= set_visible 84 | end 85 | 86 | class Gtk::TreeIter 87 | def []=(key, value) 88 | dcol = @knj_model.dcol[key] 89 | @knj_model.ob.set_value(@ob, dcol, value) 90 | end 91 | 92 | def [](key) 93 | tv = @knj_model.tv 94 | selected = tv.ob.get_selection.get_selected_rows 95 | 96 | iter = @knj_model.ob.get_iter(selected[0]) 97 | dcol = @knj_model.dcol[key] 98 | 99 | return @knj_model.ob.get_value(iter, dcol) 100 | end 101 | 102 | def model=(newmodel) 103 | @knj_model = newmodel 104 | end 105 | end -------------------------------------------------------------------------------- /lib/knj/jruby-gtk2/gladexml.rb: -------------------------------------------------------------------------------- 1 | class GladeXML 2 | attr_accessor :block 3 | attr_reader :data 4 | 5 | def initialize(filename, &block) 6 | @obs = {} 7 | 8 | if filename.index("interface>") == nil 9 | cont = File.read(filename) 10 | @data = XmlSimple.xml_in(cont) 11 | window_name = self.find_window(data) 12 | @glade = org.gnome.glade.Glade::parse(filename, window_name) 13 | else 14 | cont = filename 15 | @data = XmlSimple.xml_in(cont) 16 | window_name = self.find_window(data) 17 | Php4r.file_put_contents("temp.glade", cont) 18 | @glade = org.gnome.glade.Glade::parse("temp.glade", window_name) 19 | FileUtils.rm("temp.glade") 20 | end 21 | 22 | if block_given? 23 | @block = block 24 | self.auto_connect(@data) 25 | end 26 | end 27 | 28 | def auto_connect(data) 29 | data.each do |item| 30 | if item[0] == "widget" 31 | if item[1][0]["signal"] 32 | tha_class = item[1][0]["class"] 33 | tha_id = item[1][0]["id"] 34 | func_name = item[1][0]["signal"][0]["handler"] 35 | name = item[1][0]["signal"][0]["name"] 36 | 37 | method = @block.call(func_name) 38 | 39 | object = self.get_widget(tha_id) 40 | object.signal_connect(name) do |*paras| 41 | #Convert arguments to fit the arity-count of the Proc-object (the block, the method or whatever you want to call it). 42 | newparas = [] 43 | 0.upto(method.arity - 1) do |number| 44 | if paras[number] 45 | newparas << paras[number] 46 | end 47 | end 48 | 49 | method.call(*newparas) 50 | end 51 | end 52 | end 53 | 54 | if item.is_a?(Array) or item.is_a?(Hash) 55 | self.auto_connect(item) 56 | end 57 | end 58 | end 59 | 60 | def find_window(data) 61 | data.each do |item| 62 | if item[0] == "widget" 63 | class_str = item[1][0]["class"] 64 | 65 | if class_str == "GtkWindow" 66 | ret = item[1][0]["id"] 67 | if ret.is_a?(String) 68 | return ret 69 | end 70 | end 71 | elsif item.is_a?(Array) or item.is_a?(Hash) 72 | ret = self.find_window(item) 73 | if ret.is_a?(String) 74 | return ret 75 | end 76 | end 77 | end 78 | end 79 | 80 | def get_widget(wname) 81 | if @obs[wname] 82 | return @obs[wname] 83 | end 84 | 85 | widget = @glade.get_widget(wname) 86 | 87 | Gtk.takeob = widget 88 | splitted = widget.class.to_s.split("::") 89 | conv_widget = Gtk.const_get(splitted.last).new 90 | 91 | @obs[wname] = conv_widget 92 | 93 | return conv_widget 94 | end 95 | 96 | def [](wname) 97 | return self.get_widget(wname) 98 | end 99 | end -------------------------------------------------------------------------------- /lib/knj/google_sitemap.rb: -------------------------------------------------------------------------------- 1 | class Knj::Google_sitemap 2 | attr_reader :doc 3 | 4 | def initialize(args = {}) 5 | raise "No block given." if !block_given? 6 | 7 | @args = args 8 | 9 | #used for Time.iso8601. 10 | require "time" 11 | 12 | #REXML is known to leak memory - use subprocess. 13 | Knj.gem_require(:Ruby_process) 14 | 15 | begin 16 | Ruby_process::Cproxy.run do |data| 17 | @subproc = data[:subproc] 18 | @subproc.static(:Object, :require, "rexml/rexml") 19 | @subproc.static(:Object, :require, "rexml/document") 20 | @subproc.static(:Object, :require, "rexml/element") 21 | 22 | @doc = @subproc.new("REXML::Document") 23 | 24 | xmldecl = @subproc.new("REXML::XMLDecl", "1.0", "UTF-8") 25 | @doc << xmldecl 26 | 27 | urlset = @doc.add_element("urlset") 28 | urlset.add_attributes("xmlns" => "http://www.sitemaps.org/schemas/sitemap/0.9") 29 | 30 | @root = @doc.root 31 | yield(self) 32 | end 33 | ensure 34 | @doc = nil 35 | @root = nil 36 | @subproc = nil 37 | end 38 | end 39 | 40 | #Adds a URL to the XML. 41 | def add_url(url_value, lastmod_value, cf_value = nil, priority_value = nil) 42 | if !lastmod_value or lastmod_value.to_i == 0 43 | raise sprintf("Invalid date: %1$s, url: %2$s", lastmod_value.to_s, url_value) 44 | end 45 | 46 | el = @subproc.new("REXML::Element", "url") 47 | 48 | loc = el.add_element("loc") 49 | loc.text = url_value 50 | 51 | lm = el.add_element("lastmod") 52 | if @args.key?(:date_min) and @args[:date_min] > lastmod_value 53 | lastmod_value = @args[:date_min] 54 | end 55 | 56 | lm.text = lastmod_value.iso8601 57 | 58 | if cf_value 59 | cf = el.add_element("changefreq") 60 | cf.text = cf_value 61 | end 62 | 63 | if priority_value 64 | priority = el.add_element("priority") 65 | priority.text = priority_value 66 | end 67 | 68 | @root << el 69 | end 70 | 71 | #This will return a non-human-readable XML-string. 72 | def to_xml 73 | return @doc.to_s 74 | end 75 | 76 | #This will return a non-human-readable XML-string. 77 | def to_s 78 | return @doc.to_s 79 | end 80 | 81 | #This will print the result. 82 | def write(io = $stdout) 83 | #Require and spawn StringIO in the subprocess. 84 | @subproc.static(:Object, :require, "stringio") 85 | string_io = @subproc.new("StringIO") 86 | 87 | #We want a human-readable print. 88 | writer = @subproc.new("REXML::Formatters::Pretty", 5) 89 | writer.write(@doc, string_io) 90 | 91 | #Prepare printing by rewinding StringIO to read from beginning. 92 | string_io.rewind 93 | 94 | #Print out the result in bits to avoid raping the memory (subprocess is already raped - no question there...). 95 | string_io.each(4096) do |str| 96 | io.print(str) 97 | end 98 | end 99 | end -------------------------------------------------------------------------------- /spec/web_spec.rb: -------------------------------------------------------------------------------- 1 | require File.expand_path(File.dirname(__FILE__) + '/spec_helper') 2 | 3 | describe "Web" do 4 | it "should be able to parse url and generate hashes" do 5 | require "php4r" if !Kernel.const_defined?(:Php4r) 6 | require "knj/web" 7 | 8 | url = "first=test&#{Knj::Web.urlenc("second[trala][]")}=1&#{Knj::Web.urlenc("second[trala][]")}=2&#{Knj::Web.urlenc("second[trala][]")}=3" 9 | res = Knj::Web.parse_urlquery(url) 10 | 11 | raise "Couldnt parse 'first'-element." if res["first"] != "test" 12 | raise "'second' wasnt a hash or contained invalid amounr of elements." if !res["second"].is_a?(Hash) or res["second"].length != 1 13 | raise "'trala' in 'second' wasnt a hash or contained invalid amount of elements." if !res["second"]["trala"].is_a?(Hash) or res["second"]["trala"].length != 3 14 | raise "'trala' in 'second' didnt contain the right elements." if res["second"]["trala"]["0"] != "1" or res["second"]["trala"]["1"] != "2" or res["second"]["trala"]["2"] != "3" 15 | end 16 | 17 | #Moved from "knjrbfw_spec.rb". 18 | it "should be able to use alert and back." do 19 | Knj::Web.alert("Trala") 20 | 21 | begin 22 | Knj::Web.back 23 | raise "It should have called exit which it didnt." 24 | rescue SystemExit 25 | #ignore. 26 | end 27 | 28 | begin 29 | Knj::Web.redirect("?show=test") 30 | raise "It should have called exit which it didnt." 31 | rescue SystemExit 32 | #ignore. 33 | end 34 | end 35 | 36 | it "should be able to properly parse 'Set-Cookie' headers." do 37 | data = Knj::Web.parse_set_cookies("TestCookie=TestValue+; Expires=Fri, 05 Aug 2011 10:58:17 GMT; Path=\n") 38 | 39 | raise "No data returned?" if !data or !data.respond_to?(:length) 40 | raise "Wrong number of cookies returned: '#{data.length}'." if data.length != 1 41 | 42 | raise "Unexpected name: '#{data[0]["name"]}'." if data[0]["name"] != "TestCookie" 43 | raise "Unexpected value: '#{data[0]["value"]}'." if data[0]["value"] != "TestValue " 44 | raise "Unexpected path: '#{data[0]["path"]}'." if data[0]["path"] != "" 45 | raise "Unexpected expire:' #{data[0]["expire"]}'." if data[0]["expires"] != "Fri, 05 Aug 2011 10:58:17 GMT" 46 | end 47 | 48 | it "should be able to execute various forms of Web.input methods." do 49 | html = Knj::Web.inputs([{ 50 | :title => "Test 1", 51 | :name => :textest1, 52 | :type => :text, 53 | :default => "hmm", 54 | :value => "trala" 55 | },{ 56 | :title => "Test 2", 57 | :name => :chetest2, 58 | :type => :checkbox, 59 | :default => true 60 | },{ 61 | :title => "Test 4", 62 | :name => :textest4, 63 | :type => :textarea, 64 | :height => 300, 65 | :default => "Hmm", 66 | :value => "Trala" 67 | },{ 68 | :title => "Test 5", 69 | :name => :filetest5, 70 | :type => :file 71 | },{ 72 | :title => "Test 6", 73 | :type => :info, 74 | :value => "Argh" 75 | }]) 76 | end 77 | end -------------------------------------------------------------------------------- /Gemfile.lock: -------------------------------------------------------------------------------- 1 | PATH 2 | remote: . 3 | specs: 4 | knjrbfw (0.0.116) 5 | datet 6 | http2 7 | php4r 8 | ruby_process 9 | tsafe 10 | wref (>= 0.0.8) 11 | 12 | GEM 13 | remote: http://rubygems.org/ 14 | specs: 15 | addressable (2.4.0) 16 | array_enumerator (0.0.10) 17 | builder (3.2.4) 18 | datet (0.0.25) 19 | descendants_tracker (0.0.4) 20 | thread_safe (~> 0.3, >= 0.3.1) 21 | diff-lcs (1.5.1) 22 | faraday (0.9.2) 23 | multipart-post (>= 1.2, < 3) 24 | git (1.11.0) 25 | rchardet (~> 1.8) 26 | github_api (0.16.0) 27 | addressable (~> 2.4.0) 28 | descendants_tracker (~> 0.0.4) 29 | faraday (~> 0.8, < 0.10) 30 | hashie (>= 3.4) 31 | mime-types (>= 1.16, < 3.0) 32 | oauth2 (~> 1.0) 33 | hashie (5.0.0) 34 | highline (2.0.3) 35 | http2 (0.0.36) 36 | string-cases (~> 0) 37 | jeweler (2.3.9) 38 | builder 39 | bundler 40 | git (>= 1.2.5) 41 | github_api (~> 0.16.0) 42 | highline (>= 1.6.15) 43 | nokogiri (>= 1.5.10) 44 | psych 45 | rake 46 | rdoc 47 | semver2 48 | jwt (2.3.0) 49 | mime-types (2.99.3) 50 | mini_portile2 (2.8.5) 51 | multi_json (1.15.0) 52 | multi_xml (0.6.0) 53 | multipart-post (2.1.1) 54 | nokogiri (1.14.3) 55 | mini_portile2 (~> 2.8.0) 56 | racc (~> 1.4) 57 | oauth2 (1.4.8) 58 | faraday (>= 0.8, < 3.0) 59 | jwt (>= 1.0, < 3.0) 60 | multi_json (~> 1.3) 61 | multi_xml (~> 0.5) 62 | rack (>= 1.2, < 3) 63 | observer (0.1.2) 64 | php4r (0.0.4) 65 | datet 66 | http2 67 | string-strtr 68 | pkg-config (1.5.6) 69 | psych (5.1.2) 70 | stringio 71 | racc (1.6.2) 72 | rack (2.2.8.1) 73 | rake (13.0.6) 74 | rchardet (1.8.0) 75 | rdoc (6.6.3.1) 76 | psych (>= 4.0.0) 77 | ref (2.0.0) 78 | rmagick (5.5.0) 79 | observer (~> 0.1) 80 | pkg-config (~> 1.4) 81 | rspec (3.13.0) 82 | rspec-core (~> 3.13.0) 83 | rspec-expectations (~> 3.13.0) 84 | rspec-mocks (~> 3.13.0) 85 | rspec-core (3.13.0) 86 | rspec-support (~> 3.13.0) 87 | rspec-expectations (3.13.0) 88 | diff-lcs (>= 1.2.0, < 2.0) 89 | rspec-support (~> 3.13.0) 90 | rspec-mocks (3.13.0) 91 | diff-lcs (>= 1.2.0, < 2.0) 92 | rspec-support (~> 3.13.0) 93 | rspec-support (3.13.0) 94 | ruby_process (0.0.13) 95 | string-cases 96 | tsafe 97 | wref 98 | semver2 (3.4.2) 99 | sqlite3 (1.6.8) 100 | mini_portile2 (~> 2.8.0) 101 | string-cases (0.0.4) 102 | string-strtr (0.0.3) 103 | stringio (3.1.0) 104 | thread_safe (0.3.6) 105 | tsafe (0.0.12) 106 | weakling (0.0.3) 107 | wref (0.0.9) 108 | ref 109 | weakling 110 | 111 | PLATFORMS 112 | ruby 113 | 114 | DEPENDENCIES 115 | array_enumerator 116 | bundler 117 | jeweler 118 | knjrbfw! 119 | rmagick 120 | rspec 121 | sqlite3 122 | 123 | BUNDLED WITH 124 | 2.3.8 125 | -------------------------------------------------------------------------------- /lib/knj/gettext_threadded.rb: -------------------------------------------------------------------------------- 1 | #This class reads .po-files generated by something like POEdit and can be used to run multi-language applications or websites. 2 | class Knj::Gettext_threadded 3 | #Hash that contains all translations loaded. 4 | attr_reader :langs 5 | 6 | #Config-hash that contains encoding and more. 7 | attr_reader :args 8 | 9 | #Initializes various data. 10 | def initialize(args = {}) 11 | @args = { 12 | :encoding => "utf-8" 13 | }.merge(args) 14 | @langs = {} 15 | @dirs = [] 16 | load_dir(@args["dir"]) if @args["dir"] 17 | end 18 | 19 | #Loads a 'locales'-directory with .mo- and .po-files and fills the '@langs'-hash. 20 | #===Examples 21 | # gtext.load_dir("#{File.dirname(__FILE__)}/../locales") 22 | def load_dir(dir) 23 | @dirs << dir 24 | check_folders = ["LC_MESSAGES", "LC_ALL"] 25 | 26 | Dir.foreach(dir) do |file| 27 | fn = "#{dir}/#{file}" 28 | if File.directory?(fn) and file.match(/^[a-z]{2}_[A-Z]{2}$/) 29 | @langs[file] = {} if !@langs[file] 30 | 31 | check_folders.each do |fname| 32 | fpath = "#{dir}/#{file}/#{fname}" 33 | 34 | if File.exist?(fpath) and File.directory?(fpath) 35 | Dir.foreach(fpath) do |pofile| 36 | if pofile.match(/\.po$/) 37 | pofn = "#{dir}/#{file}/#{fname}/#{pofile}" 38 | 39 | cont = nil 40 | File.open(pofn, "r", {:encoding => @args[:encoding]}) do |fp| 41 | cont = fp.read.encode("utf-8") 42 | end 43 | 44 | cont.scan(/msgid\s+\"(.+)\"(\r|)\nmsgstr\s+\"(.+)\"(\r|)\n(\r|)\n/) do |match| 45 | @langs[file][match[0]] = match[2].to_s.encode("utf-8") 46 | end 47 | end 48 | end 49 | end 50 | end 51 | end 52 | end 53 | end 54 | 55 | #Translates a given string to a given locale from the read .po-files. 56 | #===Examples 57 | # str = "Hello" #=> "Hello" 58 | # gtext.trans("da_DK", str) #=> "Hej" 59 | def trans(locale, str) 60 | locale = locale.to_s 61 | str = str.to_s 62 | 63 | if !@langs.key?(locale) 64 | raise "Locale was not found: '#{locale}' in '#{@langs.keys.join(", ")}'." 65 | end 66 | 67 | return str if !@langs[locale].key?(str) 68 | return @langs[locale][str] 69 | end 70 | 71 | #This function can be used to make your string be recognized by gettext tools. 72 | def gettext(str, locale) 73 | return trans(locale, str) 74 | end 75 | 76 | #Returns a hash with the language ID string as key and the language human-readable-title as value. 77 | def lang_opts 78 | langs = {} 79 | @langs.keys.sort.each do |lang| 80 | title = nil 81 | 82 | @dirs.each do |dir| 83 | title_file_path = "#{dir}/#{lang}/title.txt" 84 | if File.exist?(title_file_path) 85 | title = File.read(title_file_path, {:encoding => @args[:encoding]}).to_s.strip 86 | else 87 | title = lang.to_s.strip 88 | end 89 | 90 | break if title 91 | end 92 | 93 | langs[lang] = title 94 | end 95 | 96 | return langs 97 | end 98 | end -------------------------------------------------------------------------------- /spec/knjrbfw_spec.rb: -------------------------------------------------------------------------------- 1 | require File.expand_path(File.dirname(__FILE__) + '/spec_helper') 2 | 3 | describe "Knjrbfw" do 4 | it "should be able to join arrays with callbacks." do 5 | res = Knj::ArrayExt.join(:arr => [1, 2, 3], :sep => ",", :callback => proc{|value| "'#{value}'"}) 6 | raise "Unexpected result from ArrayExt." if res != "'1','2','3'" 7 | end 8 | 9 | it "should be able to draw rounded transparent corners on images." do 10 | require "rubygems" 11 | require "rmagick" 12 | 13 | pic = Magick::Image.read("#{File.dirname(__FILE__)}/../testfiles/image.jpg").first 14 | pic.format = "png" 15 | 16 | Knj::Image.rounded_corners( 17 | :img => pic, 18 | :radius => 10 19 | ) 20 | 21 | blob_cont = pic.to_blob 22 | end 23 | 24 | it "should be possible to use Strings.html_links-method." do 25 | teststr = "This is a test. http://www.google.com This is a test." 26 | 27 | #Test normal usage. 28 | test1 = Knj::Strings.html_links(teststr) 29 | raise "Unexpected string: '#{teststr}'" if test1 != "This is a test. http://www.google.com This is a test." 30 | 31 | 32 | #Test with a block. 33 | test2 = Knj::Strings.html_links(teststr) do |data| 34 | data[:str].gsub(data[:match][0], "TEST") 35 | end 36 | 37 | raise "Unexpected string: '#{test2}'." if test2 != "This is a test. TEST This is a test." 38 | end 39 | 40 | =begin 41 | it "should be able to use Knj::Mutexcl with advanced arguments." do 42 | mutex = Knj::Mutexcl.new( 43 | :modes => { 44 | :reader => { 45 | :blocks => [:writer] 46 | }, 47 | :writer => { 48 | :blocks => [:reader, :writer] 49 | } 50 | } 51 | ) 52 | 53 | $count = 0 54 | 55 | Knj::Thread.new do 56 | mutex.sync(:reader) do 57 | sleep 0.2 58 | $count += 1 59 | end 60 | end 61 | 62 | mutex.sync(:reader) do 63 | $count += 1 64 | end 65 | 66 | raise "Count should be 1 by now but it wasnt: '#{$count}'." if $count != 1 67 | sleep 0.3 68 | raise "Count should be 2 by now but it wasnt: '#{$count}'." if $count != 2 69 | 70 | 71 | $count = 0 72 | Knj::Thread.new do 73 | mutex.sync(:reader) do 74 | sleep 2 75 | $count += 1 76 | end 77 | end 78 | sleep 0.1 79 | 80 | Knj::Thread.new do 81 | mutex.sync(:writer) do 82 | $count += 1 83 | end 84 | end 85 | 86 | sleep 1 87 | raise "Count should be 0 but it wasnt: '#{$count}'." if $count != 0 88 | sleep 1.1 89 | raise "Count should be 2 but it wasnt: '#{$count}'." if $count != 2 90 | 91 | Knj::Thread.new do 92 | mutex.sync(:reader) do 93 | sleep 0.2 94 | $count += 1 95 | end 96 | end 97 | 98 | Knj::Thread.new do 99 | mutex.sync(:reader) do 100 | sleep 0.2 101 | $count += 1 102 | end 103 | end 104 | 105 | sleep 0.35 106 | raise "Count should be 4 but it wasnt: '#{$count}'." if $count != 4 107 | end 108 | =end 109 | end 110 | -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/gladexml.rb: -------------------------------------------------------------------------------- 1 | class GladeXML 2 | def block=(newblock); @block = newblock; end 3 | def data; return @data; end 4 | 5 | def initialize(filename, &block) 6 | @obs = {} 7 | 8 | if filename.index("interface>") == nil 9 | @cont = File.read(filename) 10 | @data = XmlSimple.xml_in(@cont) 11 | window_name = self.find_window(data) 12 | @glade = Glade::XML.new(filename, window_name, nil) 13 | else 14 | @cont = filename 15 | @data = XmlSimple.xml_in(@cont) 16 | window_name = self.find_window(data) 17 | Php4r.file_put_contents("temp.glade", @cont) 18 | @glade = Glade::XML.new("temp.glade", window_name, nil) 19 | FileUtils.rm("temp.glade") 20 | end 21 | 22 | if block_given? 23 | @block = block 24 | self.auto_connect(@data) 25 | end 26 | end 27 | 28 | def auto_connect(data) 29 | data.each do |item| 30 | if item[0] == "widget" 31 | if item[1][0]["signal"] 32 | tha_class = item[1][0]["class"] 33 | tha_id = item[1][0]["id"] 34 | func_name = item[1][0]["signal"][0]["handler"] 35 | name = item[1][0]["signal"][0]["name"] 36 | 37 | method = @block.call(func_name) 38 | 39 | object = self.get_widget(tha_id) 40 | object.signal_connect(name) do |*paras| 41 | #Convert arguments to fit the arity-count of the Proc-object (the block, the method or whatever you want to call it). 42 | newparas = [] 43 | 0.upto(method.arity - 1) do |number| 44 | if paras[number] 45 | newparas << paras[number] 46 | end 47 | end 48 | 49 | method.call(*newparas) 50 | end 51 | end 52 | end 53 | 54 | if item.is_a?(Array) or item.is_a?(Hash) 55 | self.auto_connect(item) 56 | end 57 | end 58 | end 59 | 60 | def find_window(data) 61 | match = @cont.match(/<(object|widget) class="GtkWindow" id="(.+?)">/) 62 | if match 63 | print "GladeXML: Window-name matched from content - dont do slow XML-go-through.\n" 64 | return match[2] 65 | end 66 | 67 | data.each do |item| 68 | if item[0] == "widget" 69 | class_str = item[1][0]["class"] 70 | 71 | if class_str == "GtkWindow" 72 | ret = item[1][0]["id"] 73 | if ret.is_a?(String) 74 | return ret 75 | end 76 | end 77 | elsif item.is_a?(Array) or item.is_a?(Hash) 78 | ret = self.find_window(item) 79 | if ret.is_a?(String) 80 | return ret 81 | end 82 | end 83 | end 84 | end 85 | 86 | def get_widget(wname) 87 | if @obs[wname] 88 | return @obs[wname] 89 | end 90 | 91 | widget = @glade[wname] 92 | Gtk.takeob = widget 93 | 94 | splitted = widget.class.to_s.split("::") 95 | conv_widget = Gtk.const_get(splitted.last).new 96 | @obs[wname] = conv_widget 97 | 98 | return conv_widget 99 | end 100 | 101 | def [](wname) 102 | return self.get_widget(wname) 103 | end 104 | end -------------------------------------------------------------------------------- /lib/knj/autoload.rb: -------------------------------------------------------------------------------- 1 | $knjpath = File.dirname(__FILE__) + "/" if !$knjpath 2 | require "#{$knjpath}/knj" 3 | 4 | module Knj 5 | autoload :Db_row, $knjpath + "knjdb/libknjdb_row" 6 | autoload :Fs, $knjpath + "fs/fs" 7 | autoload :Php_parser, $knjpath + "php_parser/php_parser" 8 | autoload :SSHRobot, $knjpath + "sshrobot/sshrobot" 9 | end 10 | 11 | #ruby objects. 12 | autoload :Base64, "base64" 13 | autoload :CGI, "cgi" 14 | autoload :CSV, "csv" 15 | autoload :Date, "date" 16 | autoload :Digest, "digest" 17 | autoload :Erubis, $knjpath + "autoload/erubis" 18 | autoload :EM, "eventmachine" 19 | autoload :FCGI, "fcgi" 20 | autoload :FileUtils, "fileutils" 21 | autoload :IPAddr, "ipaddr" 22 | autoload :JSON, $knjpath + "autoload/json" 23 | autoload :GD2, $knjpath + "autoload/gd2" 24 | autoload :Magick, $knjpath + "autoload/magick" 25 | autoload :Monitor, "monitor" 26 | autoload :Mutex, "thread" 27 | autoload :Mysql, $knjpath + "autoload/mysql" 28 | autoload :Open3, "open3" 29 | autoload :OpenSSL, "openssl" 30 | autoload :OptionParser, "optparse" 31 | autoload :ParseDate, $knjpath + "autoload/backups/parsedate" 32 | autoload :Pathname, "pathname" 33 | autoload :Php4r, "php4r" 34 | autoload :Ping, $knjpath + "autoload/ping" 35 | autoload :REXML, $knjpath + "autoload/rexml" 36 | autoload :StringIO, "stringio" 37 | autoload :SOAP, $knjpath + "autoload/soap" 38 | autoload :SQLite3, $knjpath + "autoload/sqlite3" 39 | autoload :Timeout, "timeout" 40 | autoload :TCPSocket, "socket" 41 | autoload :TCPServer, "socket" 42 | autoload :TZInfo, $knjpath + "autoload/tzinfo" 43 | autoload :URI, "uri" 44 | autoload :Win32, "win32/registry" 45 | autoload :WIN32OLE, "win32ole" 46 | autoload :WeakRef, "weakref" 47 | autoload :WEBrick, "webrick" 48 | autoload :XmlSimple, $knjpath + "autoload/xmlsimple" 49 | autoload :Zip, $knjpath + "autoload/zip" 50 | autoload :Zlib, "zlib" 51 | 52 | if RUBY_PLATFORM == "java" 53 | autoload :GetText, $knjpath + "autoload/gettext" 54 | autoload :Gtk, "knj/jruby-gtk2/gtk2" 55 | autoload :Gdk, "knj/jruby-gtk2/gtk2" 56 | autoload :GladeXML, "knj/jruby-gtk2/gtk2" 57 | elsif RUBY_PLATFORM.index("mswin32") != nil 58 | autoload :GetText, "knj/gettext_fallback" 59 | autoload :Gtk, "knj/ironruby-gtk2/gtk2" 60 | autoload :Gdk, "knj/ironruby-gtk2/gtk2" 61 | autoload :GladeXML, "knj/ironruby-gtk2/gtk2" 62 | else 63 | autoload :GetText, $knjpath + "autoload/gettext" 64 | autoload :Gtk, $knjpath + "autoload/gtk2" 65 | autoload :GladeXML, "libglade2" 66 | 67 | #this bugs? 68 | #autoload :Gdk, $knjpath + "autoload/gtk2" 69 | end 70 | 71 | module Net 72 | autoload :IMAP, "net/imap" 73 | autoload :SMTP, "net/smtp" 74 | autoload :HTTP, "net/http" 75 | autoload :POP3, "net/pop" 76 | autoload :POP, "net/pop" 77 | autoload :SSH, "net/ssh" 78 | end 79 | 80 | module TMail 81 | autoload :Mail, $knjpath + "autoload/tmail" 82 | end 83 | 84 | #facets 85 | autoload :Dictionary, $knjpath + "autoload/facets_dictionary" 86 | 87 | #gems 88 | autoload :ActiveSupport, $knjpath + "autoload/activesupport" 89 | autoload :Cinch, $knjpath + "autoload/cinch" 90 | autoload :Facebooker, $knjpath + "autoload/facebooker" 91 | autoload :Tsafe, "tsafe" 92 | autoload :Wref, $knjpath + "autoload/wref" 93 | -------------------------------------------------------------------------------- /lib/knj/mount.rb: -------------------------------------------------------------------------------- 1 | class Knj::Mount 2 | def self.list(args = {}) 3 | mount_output = Knj::Os.shellcmd("mount") 4 | ret = [] 5 | 6 | mount_output.scan(/^(.+?) on (.+?) type (.+) \((.+?)\)$/) do |match| 7 | type = match[2] 8 | folder_from = match[0] 9 | folder_to = match[1] 10 | opts = match[3].split(",") 11 | 12 | folder_from = nil if folder_from == "none" 13 | #raise "The folder doesnt exist?" if !File.exist?(folder_to) 14 | 15 | add = true 16 | add = false if args.key?("to") and args["to"] != folder_to 17 | add = false if args.key?("from") and args["from"] != folder_from 18 | 19 | if args["from_search"] 20 | Knj::Strings.searchstring(args["from_search"]).each do |str| 21 | add = false if !folder_from or folder_from.index(str) == nil 22 | end 23 | end 24 | 25 | if args["to_search"] 26 | Knj::Strings.searchstring(args["to_search"]).each do |str| 27 | add = false if !folder_to or folder_to.index(str) == nil 28 | end 29 | end 30 | 31 | if add 32 | ret << Knj::Mount.new( 33 | :type => type, 34 | :from => folder_from, 35 | :to => folder_to, 36 | :opts => opts 37 | ) 38 | end 39 | end 40 | 41 | return ret 42 | end 43 | 44 | def self.mount(args) 45 | cmd = "mount" 46 | cmd << " -t #{Knj::Strings.unixsafe(args["type"])}" if args.key?("type") 47 | cmd << " --bind" if args["bind"] 48 | cmd << " #{Knj::Strings.unixsafe(args["from"])} #{Knj::Strings.unixsafe(args["to"])}" 49 | 50 | if args.key?("opts") 51 | raise "opts argument must be an array." if !args["opts"].is_a?(Array) 52 | 53 | cmd << "-O " 54 | 55 | first = true 56 | args["opts"].each do |opt| 57 | cmd << "," if !first 58 | first = false if first 59 | 60 | if opt.is_a?(Array) 61 | raise "Array-opt must have a length of 2." if opt.length != 2 62 | cmd << "#{Knj::Strings.unixsafe(opt[0])}=#{Knj::Strings.unixsafe(opt[1])}" 63 | elsif arg.is_a?(String) 64 | cmd << "#{Knj::Strings.unixsafe(opt)}" 65 | else 66 | raise "Unknown class: #{opt.class.name}." 67 | end 68 | end 69 | end 70 | 71 | Knj::Os.shellcmd(cmd) 72 | end 73 | 74 | def self.ensure(args) 75 | list = Knj::Mount.list("to_search" => args["to"]) 76 | return false if !list.empty? 77 | Knj::Mount.mount(args) 78 | return true 79 | end 80 | 81 | attr_reader :data 82 | 83 | def initialize(data) 84 | @data = data 85 | end 86 | 87 | def [](key) 88 | raise "Invalid key: #{key}." if !@data.key?(key) 89 | return @data[key] 90 | end 91 | 92 | def unmount 93 | Knj::Os.shellcmd("umount #{Knj::Strings.unixsafe(@data[:to])}") 94 | end 95 | 96 | alias :umount :unmount 97 | 98 | def access?(args = {}) 99 | args["timeout"] = 2 if !args.key?("timeout") 100 | access = false 101 | 102 | begin 103 | Timeout.timeout(args["timeout"]) do 104 | Dir.new(@data[:to]).each do |file| 105 | access = true 106 | break 107 | end 108 | end 109 | rescue Timeout::Error => e 110 | return false 111 | end 112 | 113 | return access 114 | end 115 | end 116 | -------------------------------------------------------------------------------- /lib/knj/locales.rb: -------------------------------------------------------------------------------- 1 | #Fixes a bug in the 'locale'-gem when running under KDE and 'LANGUAGE'-ENV-variable is set but empty. 2 | ENV["LANGUAGE"] = "en_GB" if ENV["LANGUAGE"] == "" 3 | 4 | #This module can be used to handel various language-stuff. 5 | module Knj::Locales 6 | LANG_CONVERTIONS = { 7 | "en" => "en_GB" 8 | } 9 | 10 | #Returns the primary locale, secondary locale and the two put together. 11 | #===Examples 12 | # Knj::Locales.lang #=> {"first" => "en", "second" => "GB", "full" => "en_GB"} 13 | def self.lang 14 | locale_str = self.locale.to_s.strip 15 | locale_str = "en_GB" if locale_str.empty? 16 | 17 | #Sometimes language can be 'en'. Convert that to 'en_GB' if that is so. 18 | locale_str = Knj::Locales::LANG_CONVERTIONS[locale_str] if Knj::Locales::LANG_CONVERTIONS.key?(locale_str) 19 | 20 | match = locale_str.match(/^([a-z]{2})_([A-Z]{2})/) 21 | if !match 22 | match = locale_str.match(/^[a-z]{2}$/) 23 | raise "Could not understand language: '#{locale_str}'." unless match 24 | end 25 | 26 | return { 27 | "first" => match[1], 28 | "second" => match[2], 29 | "full" => "#{match[1]}_#{match[2]}" 30 | } 31 | end 32 | 33 | #Returns various localized information about the environment. 34 | #===Examples 35 | # Knj::Locales.localeconv #=> {"decimal_point" => ".", "thousands_sep" => ",", "csv_delimiter" => ","} 36 | def self.localeconv 37 | f = Knj::Locales.lang["first"] 38 | 39 | case f 40 | when "da", "de", "es", "pl", "sv" 41 | dec = "," 42 | thousand = "." 43 | csv_delimiter = ";" 44 | else 45 | dec = "." 46 | thousand = "," 47 | csv_delimiter = "," 48 | end 49 | 50 | return { 51 | "decimal_point" => dec, 52 | "thousands_sep" => thousand, 53 | "csv_delimiter" => csv_delimiter 54 | } 55 | end 56 | 57 | #Returns a float from the formatted string according to the current locale. 58 | #===Examples 59 | # Knj::Locales.number_in("123,456.68") #=> 123456.68 60 | def self.number_in(num_str) 61 | lc = Knj::Locales.localeconv 62 | return num_str.to_s.gsub(lc["thousands_sep"], "").gsub(lc["decimal_point"], ".").to_f 63 | end 64 | 65 | #Returns the given number as a formatted string according to the current locale. 66 | #===Examples 67 | # Knj::Locales.number_out(123456.68) #=> "123,456.68" 68 | def self.number_out(num_str, dec = 2) 69 | lc = Knj::Locales.localeconv 70 | 71 | require "php4r" if !Kernel.const_defined?(:Php4r) 72 | return Php4r.number_format(num_str, dec, lc["decimal_point"], lc["thousands_sep"]) 73 | end 74 | 75 | #Returns the current locale for the current environment (_session[:locale] or Thread.current[:locale]). 76 | #===Examples 77 | # Knj::Locales.locale #=> 'en_GB' 78 | # Knj::Locales.locale #=> 'da_DK' 79 | def self.locale 80 | begin 81 | return _session[:locale] if _session[:locale].to_s.strip.length > 0 82 | rescue NameError 83 | #ignore. 84 | end 85 | 86 | if Thread.current[:locale] 87 | return Thread.current[:locale] 88 | elsif ::Kernel.const_defined?(:I18n) && !I18n.locale.to_s.strip.empty? 89 | return I18n.locale 90 | elsif ENV["LANGUAGE"] 91 | return ENV["LANGUAGE"] 92 | elsif ENV["LANG"] 93 | return ENV["LANG"] 94 | end 95 | 96 | return "en_GB" 97 | end 98 | end -------------------------------------------------------------------------------- /lib/knj/kvm.rb: -------------------------------------------------------------------------------- 1 | #This class and subclasses holds various functionality to view status for Kvm-instances. 2 | class Knj::Kvm 3 | #Lists all running Kvm-instances on this machine. 4 | #===Examples 5 | # Knj::Kvm.list do |kvm| 6 | # print kvm.pid 7 | # end 8 | def self.list 9 | list = [] 10 | 11 | Knj::Unix_proc.list("grep" => "kvm") do |proc_obj| 12 | next if !proc_obj["cmd"].match(/^\/usr\/bin\/kvm\s+/) 13 | 14 | args = { 15 | :pid => proc_obj["pid"] 16 | } 17 | 18 | if mac_match = proc_obj["cmd"].match(/mac=(.+?)(,|\s+|$)/) 19 | args[:mac] = mac_match[1] 20 | end 21 | 22 | if name_match = proc_obj["cmd"].match(/\-name\s+(.+?)(,|\s+|$)/) 23 | args[:name] = name_match[1] 24 | end 25 | 26 | if args.length > 0 and args[:name].to_s.length > 0 27 | machine = Knj::Kvm::Machine.new(args) 28 | if block_given? 29 | yield(machine) 30 | else 31 | list << machine 32 | end 33 | end 34 | end 35 | 36 | if block_given? 37 | return nil 38 | else 39 | return list 40 | end 41 | end 42 | end 43 | 44 | #Describes each Kvm-instance. 45 | class Knj::Kvm::Machine 46 | #Sets the data called from Knj::Kvm.list. 47 | def initialize(args) 48 | @args = args 49 | end 50 | 51 | #Returns the PID of the Kvm-instance. 52 | def pid 53 | return @args[:pid] 54 | end 55 | 56 | #Returns the name from the Kvm-instance. 57 | def name 58 | return @args[:name] 59 | end 60 | 61 | #Returns the MAC from a network interfaces on the Kvm-instance. 62 | def mac 63 | raise "No MAC-address has been registered for this machine." if !@args.key?(:mac) 64 | return @args[:mac] 65 | end 66 | 67 | #Returns what virtual interface the Kvm is using. 68 | #===Examples 69 | # kvm.iface #=> "vnet12" 70 | def iface 71 | if !@iface 72 | res = Knj::Os.shellcmd("ifconfig | grep \"#{self.mac[3, self.mac.length]}\"") 73 | 74 | if net_match = res.match(/^vnet(\d+)/) 75 | @iface = net_match[0] 76 | else 77 | raise "Could not figure out iface from '#{res}' for '#{self.name}'." 78 | end 79 | end 80 | 81 | return @iface 82 | end 83 | 84 | #Returns various data about the networking (how much have been sent and recieved). 85 | #===Examples 86 | # kvm.net_status #=> {:tx => 1024, :rx => 2048} 87 | def net_status 88 | res = Knj::Os.shellcmd("ifconfig \"#{self.iface}\"") 89 | 90 | ret = {} 91 | 92 | if tx_bytes_match = res.match(/TX\s*bytes:\s*(\d+)/) 93 | ret[:tx] = tx_bytes_match[1].to_i 94 | end 95 | 96 | if rx_bytes_match = res.match(/RX\s*bytes:\s*(\d+)/) 97 | ret[:rx] = rx_bytes_match[1].to_i 98 | end 99 | 100 | return ret 101 | end 102 | 103 | #Returns various data about how much disk IO the Kvm-instance have been using. 104 | #===Examples 105 | # kvm.io_status #=> {:read_bytes => 1024, :write_bytes => 2048} 106 | def io_status 107 | io_status = File.read("/proc/#{self.pid}/io") 108 | 109 | if !matches = io_status.scan(/^(.+): (\d+)$/) 110 | raise "Could not match IO-status from: '#{io_status}'." 111 | end 112 | 113 | ret = {} 114 | matches.each do |match| 115 | ret[match[0].to_sym] = match[1].to_i 116 | end 117 | 118 | return ret 119 | end 120 | end -------------------------------------------------------------------------------- /lib/knj/event_handler.rb: -------------------------------------------------------------------------------- 1 | #This class is used for event handeling. 2 | #===Examples 3 | # events = Knj::Event_handler.new 4 | # events.add_event(:name => :test_event) 5 | # events.connect(:test_event) do |*args| 6 | # print "Test-event called!\n" 7 | # end 8 | # 9 | # events.call(:test_event) #=> prints "Test-event called!\n" 10 | class Knj::Event_handler 11 | #Sets various used variables. 12 | def initialize(args = {}) 13 | @args = args 14 | @events = {} 15 | end 16 | 17 | #Adds information about a new event. 18 | #===Examples 19 | # events.add_event(:name => :test_event) 20 | def add_event(event) 21 | raise "No name given." if !event[:name] 22 | 23 | @events[event[:name]] = [] if !@events.key?(event[:name]) 24 | @events[event[:name]] = { 25 | :event => event, 26 | :callbacks => {}, 27 | :callbacks_count => 0 28 | } 29 | end 30 | 31 | #Adds multiple events. 32 | #===Examples 33 | # events.add_events(:test_event, :another_event, :a_third_event) 34 | def add_events(*events) 35 | events.each do |event| 36 | self.add_event(:name => event) 37 | end 38 | end 39 | 40 | #Connects the given block to a given event. 41 | #===Examples 42 | # events.connect(:test_event){ |*args| print "Test event!\n"} 43 | def connect(name, &block) 44 | raise "No such event: '#{name}'." if !@events.key?(name) 45 | 46 | event = @events[name] 47 | 48 | if event[:event].key?(:connections_max) and event[:callbacks].length >= event[:event][:connections_max].to_i 49 | raise "The event '#{name}' has reached its maximum connections of '#{event[:event][:connections_max]}'" 50 | end 51 | 52 | event[:callbacks_count] += 1 53 | count = event[:callbacks_count] 54 | event[:callbacks][count] = { 55 | :block => block 56 | } 57 | 58 | return count 59 | end 60 | 61 | #Returns true if the given event is connected. 62 | #===Examples 63 | # print "Test-event is connected!" if events.connected?(:test_event) 64 | def connected?(name) 65 | raise "No such event." if !@events.key?(name) 66 | return !@events[name][:callbacks].empty? 67 | end 68 | 69 | #Disconnects an event. 70 | #===Examples 71 | # connection_id = events.connect(:test_event){print "test event!} 72 | # events.disconnect(:test_event, connection_id) 73 | # events.call(:test_event) #=> Doesnt print 'test event!'. 74 | def disconnect(name, callback_id) 75 | raise "No such event: '#{name}'." if !@events.key?(name) 76 | raise "No such connection: '#{name}' --> '#{callback_id}' (#{@events[name]})" if !@events[name][:callbacks].key?(callback_id) 77 | @events[name][:callbacks][callback_id].clear 78 | @events[name][:callbacks].delete(callback_id) 79 | end 80 | 81 | #Returns how many blocks have been connected to an event. 82 | #===Examples 83 | # print "More than five connections to test-event!" if events.count_events(:test_event) > 5 84 | def count_connects(name) 85 | raise "No such event." if !@events.key?(name) 86 | return @events[name][:callbacks].length 87 | end 88 | 89 | #Calls an added event. 90 | #===Examples 91 | # events.call(:test_event, {:data => 1}) 92 | def call(name, *args, **opts) 93 | raise "No such event: '#{name}'." if !@events.key?(name) 94 | event = @events[name] 95 | ret = nil 96 | event[:callbacks].clone.each do |callback_id, callback_hash| 97 | ret = callback_hash.fetch(:block).call(name, *args, **opts) 98 | end 99 | 100 | return ret 101 | end 102 | end -------------------------------------------------------------------------------- /lib/knj/facebook_connect.rb: -------------------------------------------------------------------------------- 1 | class Knj::Facebook_connect 2 | attr_reader :args 3 | 4 | def initialize(args) 5 | require "http2" 6 | 7 | @args = args 8 | 9 | raise "No app-ID given." if !@args[:app_id] 10 | raise "No app-secret given." if !@args[:app_secret] 11 | end 12 | 13 | def base64_urldecode(str) 14 | return Base64.decode64("#{str.tr("-_", "+/")}=") 15 | end 16 | 17 | def get(http, url) 18 | resp = http.get(:url => url) 19 | 20 | if resp.body.length > 0 21 | begin 22 | jdata = JSON.parse(resp.body) 23 | 24 | error_type = RuntimeError 25 | if jdata["error"] and jdata["error"]["message"] == "Code was invalid or expired. The session is invalid because the user logged out." 26 | error_type = ArgumentError 27 | end 28 | 29 | raise error_type, "#{jdata["error"]["type"]}: #{jdata["error"]["message"]}" if jdata["error"] 30 | rescue JSON::ParserError 31 | #ignore 32 | end 33 | end 34 | 35 | return {:json => jdata, :resp => resp, :headers => resp.headers, :body => resp.body} 36 | end 37 | 38 | def validate_cookie(cookie) 39 | data = cookie.split(".", 2) 40 | enc_sig, payload = data[0], data[1] 41 | 42 | sig = self.base64_urldecode(enc_sig).unpack("H*").first 43 | data = self.base64_urldecode(payload) 44 | data = JSON.parse(data) 45 | 46 | raise "Unknown algorithm: '#{data["algorithm"]}'." if data["algorithm"] != "HMAC-SHA256" 47 | exp_sig = OpenSSL::HMAC.hexdigest("sha256", @args[:app_secret], payload) 48 | 49 | raise "Bad signed JSON signature." if sig != exp_sig 50 | 51 | return data 52 | end 53 | 54 | def token_from_cookie(http, cookie = nil) 55 | if @token 56 | return @token 57 | end 58 | 59 | raise "No token set and no cookie given." if !@args[:cookie] 60 | 61 | data = self.validate_cookie(@args[:cookie]) 62 | resp = self.get(http, "oauth/access_token?client_id=#{Knj::Web.urlenc(@args[:app_id])}&client_secret=#{Knj::Web.urlenc(@args[:app_secret])}&redirect_uri=&code=#{Knj::Web.urlenc(data["code"])}") 63 | 64 | match = resp[:body].match(/access_token=(.+)&expires=(\d+)/) 65 | raise "No access token was given." if !match 66 | atoken = match[1] 67 | @token = atoken 68 | @expires = match[2] 69 | 70 | return atoken 71 | end 72 | 73 | def login(args = {}) 74 | http = Http2.new( 75 | :host => "graph.facebook.com", 76 | :ssl => true 77 | ) 78 | 79 | atoken = self.token_from_cookie(http, @args[:cookie]) 80 | 81 | url = "me?access_token=#{Knj::Web.urlenc(atoken)}" 82 | resp = self.get(http, url) 83 | data = {"user" => resp[:json]} 84 | 85 | if args[:profile_picture] 86 | pic_data = self.get(http, "#{data["user"]["id"]}/picture?type=large") 87 | pic_obj = Magick::Image.from_blob(pic_data[:body].to_s)[0] 88 | data["pic"] = pic_obj 89 | end 90 | 91 | return data 92 | end 93 | 94 | def wall_post(args) 95 | http = Http2.new( 96 | :host => "graph.facebook.com", 97 | :ssl => true 98 | ) 99 | 100 | atoken = self.token_from_cookie(http) 101 | post_data = {} 102 | 103 | args_keys = [:link, :object_attachment, :picture, :caption, :name, :description, :message, :media] 104 | args_keys.each do |key| 105 | if args.key?(key) and args[key] 106 | post_data[key] = args[key] 107 | end 108 | end 109 | 110 | res = http.post(:url => "/me/feed?access_token=#{atoken}", :post => post_data) 111 | raise res.body.to_s.strip if res.code.to_s != "200" 112 | end 113 | end -------------------------------------------------------------------------------- /lib/knj/win_tightvnc.rb: -------------------------------------------------------------------------------- 1 | class Knj::Win::TightVNC 2 | def initialize(args) 3 | @args = ArrayExt.hash_sym(args) 4 | 5 | @args[:port] = 5900 if !@args[:port] 6 | @args[:port_http] = 5800 if !@args[:http_port] 7 | 8 | raise "No path given." if !@args[:path] 9 | 10 | exefile = @args[:path] + "/WinVNC.exe" 11 | raise "#{exefile} was not found." if !File.exist?(exefile) 12 | 13 | @wmi = WIN32OLE.connect("winmgmts://") 14 | processes = @wmi.ExecQuery("SELECT * FROM win32_process") 15 | ended = false 16 | for process in processes do 17 | if process.Name == "WinVNC.exe" 18 | process.Terminate 19 | ended = true 20 | end 21 | end 22 | 23 | sleep 1 if ended 24 | 25 | #print Win::Registry.get(:cur_user, 'Software\ORL\WinVNC3', 'Password', :sz).unpack('H*')[0] + "\n" 26 | #print ["160e9d46f26586ca"].pack('H*').unpack('H*')[0] + "\n" 27 | #exit 28 | 29 | Win::Registry.set(:cur_user, 'Software\ORL\WinVNC3', [ 30 | ["AutoPortSelect", 1, :dword], 31 | ["BlankScreen", 0, :dword], 32 | ["DontSetHooks", 0, :dword], 33 | ["DontUseDriver", 0, :dword], 34 | ["DriverDirectAccess", 1, :dword], 35 | ["EnableFileTransfers", 1, :dword], 36 | ["HTTPPortNumber", @args[:port_http], :dword], 37 | ["IdleTimeout", 0, :dword], 38 | ["InputsEnabled", 1, :dword], 39 | ["LocalInputsDisabled", 0, :dword], 40 | ["LocalInputsPriority", 0, :dword], 41 | ["LocalInputsPriorityTime", 3, :dword], 42 | ["LockSetting", 0, :dword], 43 | ["OnlyPollConsole", 1, :dword], 44 | ["OnlyPollOnEvent", 0, :dword], 45 | ["PollForeground", 1, :dword], 46 | ["PollFullScreen", 0, :dword], 47 | ["PollingCycle", 300, :dword], 48 | ["PollUnderCursor", 0, :dword], 49 | ["PollUnderCursor", @args[:port], :dword], 50 | ["QueryAccept", 0, :dword], 51 | ["QueryAllowNoPass", 0, :dword], 52 | ["QuerySetting", 2, :dword], 53 | ["QueryTimeout", 30, :dword], 54 | ["RemoveWallpaper", 0, :dword], 55 | ["SocketConnect", 1, :dword], 56 | ["Password", ["160e9d46f26586ca"].pack('H*'), :bin], 57 | ["PasswordViewOnly", ["160e9d46f26586ca"].pack('H*'), :bin] 58 | ]) 59 | Win::Registry.set(:local_machine, 'Software\ORL\WinVNC3', [ 60 | ["AllowLoopback", 1, :dword], 61 | ["LoopbackOnly", 0, :dword] 62 | ]) 63 | #password is of this moment only 'kaspernj'. 64 | 65 | @wmi = WIN32OLE.connect("winmgmts://") 66 | processes = @wmi.ExecQuery("SELECT * FROM win32_process") 67 | ended = false 68 | for process in processes do 69 | if process.Name == "WinVNC.exe" 70 | process.Terminate 71 | ended = true 72 | end 73 | end 74 | 75 | sleep 1 if ended 76 | 77 | Knj::Thread.new do 78 | IO.popen(exefile) do |process| 79 | #nothing 80 | end 81 | end 82 | 83 | sleep 1 84 | 85 | @processes = @wmi.ExecQuery("SELECT * FROM win32_process") 86 | for process in @processes do 87 | if process.Name == "WinVNC.exe" 88 | @process = process 89 | break 90 | end 91 | end 92 | 93 | raise "Could not start WinVNC.exe." if !@process 94 | 95 | Kernel.at_exit do 96 | self.close 97 | end 98 | end 99 | 100 | def open? 101 | begin 102 | @process.GetOwner 103 | return true 104 | rescue => e 105 | return false 106 | end 107 | end 108 | 109 | def close 110 | return nil if !@process 111 | 112 | begin 113 | @process.Terminate 114 | rescue => e 115 | if e.class.to_s == "WIN32OLERuntimeError" and e.message.index("Terminate") != nil 116 | #do nothing. 117 | else 118 | raise e 119 | end 120 | end 121 | 122 | @process = nil 123 | @args = nil 124 | @wmi = nil 125 | @processes = nil 126 | end 127 | end -------------------------------------------------------------------------------- /lib/knj/gtk2_cb.rb: -------------------------------------------------------------------------------- 1 | module Knj::Gtk2::Cb 2 | #This method can be used to invoke autoloading of this file. 3 | def self.init(paras) 4 | return paras["cb"].init(paras["items"]) 5 | end 6 | 7 | #This method can be used to invoke autoloading of this file. 8 | def self.sel(cb) 9 | return cb.sel 10 | end 11 | end 12 | 13 | class Gtk::ComboBox 14 | #Shortcut to initialize a combobox with items (or models). 15 | def init(items) 16 | @knj = { 17 | :items => [] 18 | } 19 | 20 | @ls = Gtk::ListStore.new(String, String) 21 | cr = Gtk::CellRendererText.new 22 | self.pack_start(cr, false) 23 | self.add_attribute(cr, "text", 0) 24 | 25 | if items.is_a?(Array) 26 | items.each do |appendob| 27 | if appendob.is_a?(String) 28 | iter = @ls.append 29 | iter[0] = appendob 30 | elsif appendob.respond_to?(:is_knj?) 31 | self.append_model(:model => appendob) 32 | end 33 | end 34 | elsif items.is_a?(Hash) 35 | @knj[:type] = :hash 36 | 37 | items.each do |key, val| 38 | iter = @ls.append 39 | iter[0] = val 40 | 41 | @knj[:items] << { 42 | :iter => iter, 43 | :object => key 44 | } 45 | end 46 | else 47 | raise "Unsupported type: '#{items.class.name}'." 48 | end 49 | 50 | self.model = @ls 51 | self.active = 0 52 | end 53 | 54 | #Appens a model to the list-store. 55 | def append_model(args) 56 | iter = @ls.append 57 | appendob = args[:model] 58 | 59 | if appendob.respond_to?(:name) 60 | iter[0] = appendob.name 61 | elsif appendob.respond_to?(:title) 62 | iter[0] = appendob.title 63 | else 64 | raise "Could not figure out of the name of the object." 65 | end 66 | 67 | @knj[:items] << { 68 | :iter => iter, 69 | :object => appendob 70 | } 71 | 72 | return {} 73 | end 74 | 75 | #Returns the active item (or model) for the combobox. 76 | def sel 77 | iter = self.active_iter 78 | 79 | if @knj[:items].length > 0 80 | @knj[:items].each do |item| 81 | if item[:iter] == iter 82 | return item[:object] 83 | end 84 | end 85 | 86 | return false 87 | else 88 | return { 89 | "active" => self.active, 90 | "text" => iter[0] 91 | } 92 | end 93 | end 94 | 95 | #Sets the active element (or model) in the combobox. 96 | def sel=(actob) 97 | if actob.respond_to?(:is_knj?) 98 | @knj[:items].each do |item| 99 | if item[:object].id == actob.id 100 | self.active_iter = item[:iter] 101 | return nil 102 | end 103 | end 104 | elsif @knj[:type] == :hash 105 | @knj[:items].each do |item| 106 | if item[:object] == actob 107 | self.active_iter = item[:iter] 108 | return nil 109 | end 110 | end 111 | else 112 | self.model.each do |model, path, iter| 113 | text = self.model.get_value(iter, 0) 114 | 115 | if text == actob 116 | self.active_iter = iter 117 | return nil 118 | end 119 | end 120 | end 121 | 122 | raise "Could not find such a row: '#{actob}'." 123 | end 124 | 125 | #Resorts all items in the list-store. If an item doesnt have an ID, then that item will be put first (for 'Choose', 'All' and such options). 126 | def resort 127 | @ls.set_sort_column_id(0) 128 | @ls.set_sort_func(0, &lambda{|iter1, iter2| 129 | item_id_1 = iter1[1].to_i 130 | item_id_2 = iter2[1].to_i 131 | 132 | item_name_1 = iter1[0].to_s.downcase 133 | item_name_2 = iter2[0].to_s.downcase 134 | 135 | if item_id_1 == 0 136 | return -1 137 | elsif item_id_2 == 0 138 | return 1 139 | else 140 | return item_name_1 <=> item_name_2 141 | end 142 | }) 143 | end 144 | end -------------------------------------------------------------------------------- /lib/knj/amixer.rb: -------------------------------------------------------------------------------- 1 | #This class is a Ruby-interface to the amixer-binary. It can read and set the volume. 2 | class Knj::Amixer 3 | attr_reader :args 4 | 5 | def initialize(args = {}) 6 | @args = { 7 | :amixer_bin => "/usr/bin/amixer", 8 | :aplay_bin => "/usr/bin/aplay" 9 | }.merge(args) 10 | 11 | @devices = {} 12 | end 13 | 14 | #Returns a hash with devices. 15 | def devices 16 | ret = %x[#{@args[:aplay_bin]} -l] 17 | 18 | ret.scan(/card (\d+): (.+?) \[(.+?)\],/) do |match| 19 | id = match[0] 20 | 21 | if !@devices.key?(id) 22 | @devices[id] = Knj::Amixer::Device.new( 23 | :amixer => self, 24 | :id => id, 25 | :name => match[2], 26 | :code => match[1] 27 | ) 28 | end 29 | end 30 | 31 | return @devices 32 | end 33 | 34 | class Device 35 | def initialize(args) 36 | @args = args 37 | @mixers = {} 38 | end 39 | 40 | def id 41 | return @args[:id] 42 | end 43 | 44 | def name 45 | return @args[:name] 46 | end 47 | 48 | def code 49 | return @args[:code] 50 | end 51 | 52 | def amixer 53 | return @args[:amixer] 54 | end 55 | 56 | #Returns true if the device is active by looking in '/proc/asounc/card*/pcm*/sub*/status'. 57 | def active?(args = {}) 58 | proc_path = "/proc/asound/#{@args[:code]}" 59 | 60 | Dir.foreach(proc_path) do |file| 61 | next if file == "." or file == ".." or !file.match(/^pcm(\d+)[a-z]+$/) 62 | sub_path = "#{proc_path}/#{file}" 63 | info_path = "#{sub_path}/info" 64 | info_cont = File.read(info_path) 65 | 66 | if stream_match = info_cont.match(/stream: (.+?)\s+/) 67 | next if args.key?(:stream) and stream_match[1] != args[:stream] 68 | end 69 | 70 | Dir.foreach(sub_path) do |file_sub| 71 | next if file_sub == "." or file_sub == ".." or !file_sub.match(/^sub(\d+)$/) 72 | status_path = "#{sub_path}/#{file_sub}/status" 73 | cont = File.read(status_path) 74 | return true if cont.strip != "closed" 75 | end 76 | end 77 | 78 | return false 79 | end 80 | 81 | #Returns a hash of the various mixers. 82 | def mixers 83 | ret = %x[#{@args[:amixer].args[:amixer_bin]} -c #{@args[:id]} scontrols] 84 | 85 | ret.scan(/Simple mixer control '(.+)',0/) do |match| 86 | name = match[0] 87 | 88 | if !@mixers.key?(name) 89 | @mixers[name] = Knj::Amixer::Mixer.new( 90 | :amixer => @args[:amixer], 91 | :device => self, 92 | :name => name 93 | ) 94 | end 95 | end 96 | 97 | return @mixers 98 | end 99 | end 100 | 101 | #This class controls each mixer. 102 | class Mixer 103 | def initialize(args) 104 | @args = args 105 | end 106 | 107 | #Returns the name of the mixer (example: Master). 108 | def name 109 | return @args[:name] 110 | end 111 | 112 | #Returns a bool. If the mixer supports volume-operations (some mixers are just switches and doenst support volume). 113 | def volume? 114 | ret = %x[#{@args[:amixer].args[:amixer_bin]} -c #{@args[:device].id} sget "#{@args[:name]}"] 115 | raise "No content for mixer: '#{@args[:name]}'." if !ret 116 | 117 | match = ret.match(/(Capture|Playback) (\d+) \[(\d+%)\]/) 118 | return false if !match 119 | return true 120 | end 121 | 122 | #Returns the volume-value as an integer (or as the percent if {:percent => true} if given in arguments). 123 | def vol(args = {}) 124 | ret = %x[#{@args[:amixer].args[:amixer_bin]} -c #{@args[:device].id} sget "#{@args[:name]}"] 125 | raise "No content for mixer: '#{@args[:name]}'." if !ret 126 | 127 | match = ret.match(/(Capture|Playback) (\d+) \[(\d+%)\]/) 128 | raise "Couldnt figure out volume for '#{@args[:name]}' from:\n'#{ret}'\n" if !match 129 | 130 | return match[3].to_i if args[:percent] 131 | return match[2].to_i 132 | end 133 | 134 | #Sets a new value for the volume. 135 | def vol=(newvol) 136 | ret = %x[#{@args[:amixer].args[:amixer_bin]} -c #{@args[:device].id} sset "#{@args[:name]}" "#{newvol}"] 137 | #NOTE: Do some error handeling here? 138 | end 139 | 140 | #Adds a number to the volume. 141 | def vol_add(add_vol) 142 | vol = self.vol 143 | newvol = vol + add_vol.to_i 144 | newvol = 0 if newvol < 0 145 | self.vol=(newvol) 146 | end 147 | end 148 | end -------------------------------------------------------------------------------- /lib/knj/threadhandler.rb: -------------------------------------------------------------------------------- 1 | class Knj::Threadhandler 2 | attr_reader :inactive_blocks, :args, :activate_blocks, :mutex, :objects 3 | 4 | def initialize(args = {}) 5 | require "#{$knjpath}errors" 6 | require "tsafe" if !Kernel.const_defined?(:Tsafe) 7 | 8 | @args = args 9 | @objects = [] 10 | @args[:timeout] = 5 if !@args[:timeout] 11 | @args[:max] = 50 if !@args[:max] 12 | @inactive_blocks = [] 13 | @activate_blocks = [] 14 | @mutex = Mutex.new 15 | 16 | @thread_timeout = Thread.new do 17 | begin 18 | loop do 19 | sleep @args[:timeout] 20 | break if !@mutex 21 | check_inactive 22 | end 23 | rescue => e 24 | STDOUT.print Knj::Errors.error_str(e) 25 | end 26 | end 27 | end 28 | 29 | def on_spawn_new(&block) 30 | raise "Destroyed Knj::Threadhandler." if !@mutex 31 | @spawn_new_block = block 32 | end 33 | 34 | def on_inactive(&block) 35 | raise "Destroyed Knj::Threadhandler." if !@mutex 36 | @inactive_blocks << block 37 | end 38 | 39 | def on_activate(&block) 40 | raise "Destroyed Knj::Threadhandler." if !@mutex 41 | @activate_blocks << block 42 | end 43 | 44 | def destroy 45 | return false if !@mutex 46 | 47 | @thread_timeout.kill if @thread_timeout and @thread_timeout.alive? 48 | @thread_timeout = nil 49 | 50 | @mutex.synchronize do 51 | @objects.each do |data| 52 | @inactive_blocks.each do |block| 53 | data[:inactive] = true 54 | block.call(:obj => data[:object]) 55 | end 56 | end 57 | end 58 | 59 | @args = nil 60 | @objects = nil 61 | @inactive_blocks = nil 62 | @activate_blocks = nil 63 | @mutex = nil 64 | end 65 | 66 | def check_inactive 67 | raise "Destroyed Knj::Threadhandler." if !@mutex 68 | cur_time = Time.now.to_i - @args[:timeout] 69 | 70 | @mutex.synchronize do 71 | @objects.each do |data| 72 | if data[:free] and !data[:inactive] and data[:free] < cur_time 73 | @inactive_blocks.each do |block| 74 | data[:inactive] = true 75 | block.call(:obj => data[:object]) 76 | end 77 | end 78 | end 79 | end 80 | end 81 | 82 | def get_and_lock 83 | raise "Destroyed Knj::Threadhandler." if !@mutex 84 | newobj = nil 85 | 86 | begin 87 | retdata = nil 88 | 89 | @mutex.synchronize do 90 | @objects.each do |data| 91 | if data[:free] 92 | retdata = data 93 | break 94 | end 95 | end 96 | end 97 | 98 | if retdata 99 | #Test if object is still free - if not, try again - knj. 100 | return get_and_lock if !retdata[:free] 101 | retdata[:free] = false 102 | 103 | if retdata[:inactive] 104 | @activate_blocks.each do |block| 105 | block.call(:obj => retdata[:object]) 106 | end 107 | 108 | retdata.delete(:inactive) 109 | end 110 | 111 | return retdata[:object] 112 | end 113 | 114 | if @objects.length >= @args[:max] 115 | #The maximum amount of objects has already been spawned... Sleep 0.1 sec and try to lock an object again... 116 | raise Knj::Errors::Retry 117 | else 118 | #No free objects, but we can spawn a new one and use that... 119 | newobj = @spawn_new_block.call 120 | @mutex.synchronize do 121 | @objects << Tsafe::MonHash.new.merge( 122 | :free => false, 123 | :object => newobj 124 | ) 125 | end 126 | STDOUT.print "Spawned db and locked new.\n" if @args[:debug] 127 | end 128 | 129 | return newobj 130 | rescue Knj::Errors::Retry 131 | STDOUT.print "All objects was taken - sleeping 0.1 sec and tries again.\n" #if @args[:debug] 132 | sleep 0.1 133 | retry 134 | end 135 | end 136 | 137 | def free(obj) 138 | @mutex.synchronize do 139 | return false if !@mutex or !@objects #something is trying to free and object, but the handler is destroyed. Dont crash but return false. 140 | 141 | freedata = false 142 | @objects.each do |data| 143 | if data[:object] == obj 144 | freedata = data 145 | break 146 | end 147 | end 148 | 149 | raise "Could not find that object in list." if !freedata 150 | STDOUT.print "Freed one.\n" if @args[:debug] 151 | freedata[:free] = Time.now.to_i 152 | end 153 | end 154 | 155 | #Executes the given block with an element and then frees it. 156 | def use 157 | raise "No block was given." if !block_given? 158 | 159 | obj = self.get_and_lock 160 | 161 | begin 162 | yield(obj) 163 | ensure 164 | self.free(obj) 165 | end 166 | end 167 | end -------------------------------------------------------------------------------- /lib/knj/unix_proc.rb: -------------------------------------------------------------------------------- 1 | #Require the 'wref'-gem if it hasnt already been. 2 | require "wref" if !Kernel.const_defined?(:Wref) 3 | 4 | #This class handels various stuff regarding Unix-processes. 5 | class Knj::Unix_proc 6 | attr_reader :data 7 | 8 | PROCS = Wref::Map.new 9 | MUTEX = Mutex.new 10 | 11 | #Spawns a process if it doesnt already exist in the wrap-map. 12 | def self.spawn(data) 13 | pid = data["pid"].to_i 14 | 15 | begin 16 | proc_ele = PROCS.get!(pid) 17 | proc_ele.update_data(data) 18 | rescue Wref::Recycled 19 | proc_ele = Knj::Unix_proc.new(data) 20 | PROCS[pid] = proc_ele 21 | end 22 | 23 | return proc_ele 24 | end 25 | 26 | #Returns an array with (or yields if block given) Unix_proc. Hash-arguments as 'grep'. 27 | def self.list(args = {}) 28 | cmdstr = "ps aux" 29 | grepstr = "" 30 | 31 | if args["grep"] 32 | grepstr = "grep #{args["grep"]}" #used for ignoring the grep-process later. 33 | cmdstr << " | grep #{Knj::Strings.unixsafe(args["grep"])}" 34 | end 35 | 36 | MUTEX.synchronize do 37 | ret = [] unless block_given? 38 | 39 | if args["psaux_str"] 40 | res = args["psaux_str"] 41 | else 42 | res = Knj::Os.shellcmd(cmdstr) 43 | end 44 | 45 | res.scan(/^(\S+)\s+([0-9]+)\s+([0-9.]+)\s+([0-9.]+)\s+\S+\s+\S+\s+\S+\s+\S+\s+\S+\s+\S+ (.+)($|\n)/) do |match| 46 | pid = match[1] 47 | 48 | data = { 49 | "user" => match[0], 50 | "pid" => pid, 51 | "cpu_last" => match[2], 52 | "ram_last" => match[3], 53 | "cmd" => match[4], 54 | "app" => File.basename(match[4]) 55 | } 56 | 57 | next if (!args.key?("ignore_self") or args["ignore_self"]) and match[1].to_i == $$.to_i 58 | next if grepstr.length > 0 and match[4].index(grepstr) != nil #dont return current process. 59 | 60 | if args.key?("pids") 61 | found = false 62 | args["pids"].each do |pid_given| 63 | if pid_given.to_s == pid.to_s 64 | found = true 65 | break 66 | end 67 | end 68 | 69 | next if !found 70 | end 71 | 72 | if args["yield_data"] 73 | yield(data) 74 | else 75 | proc_obj = Knj::Unix_proc.spawn(data) 76 | 77 | if block_given? 78 | yield(proc_obj) 79 | else 80 | ret << proc_obj 81 | end 82 | end 83 | end 84 | 85 | PROCS.clean 86 | 87 | if block_given? 88 | return nil 89 | else 90 | return ret 91 | end 92 | end 93 | end 94 | 95 | #Returns the "Knj::Unix_proc" for the current process. 96 | def self.find_self 97 | procs = Knj::Unix_proc.list("ignore_self" => false) 98 | pid_find = Process.pid 99 | 100 | proc_find = false 101 | procs.each do |proc_ele| 102 | if proc_ele["pid"].to_i == pid_find.to_i 103 | proc_find = proc_ele 104 | break 105 | end 106 | end 107 | 108 | return proc_find 109 | end 110 | 111 | #Return true if the given PID is running. 112 | def self.pid_running?(pid) 113 | begin 114 | Process.getpgid(pid) 115 | return true 116 | rescue Errno::ESRCH 117 | return false 118 | end 119 | end 120 | 121 | #Initializes various data for a Unix_proc-object. This should not be called manually but through "Unix_proc.list". 122 | def initialize(data) 123 | @data = data 124 | end 125 | 126 | #Updates the data. This should not be called manually, but is exposed because of various code in "Unix_proc.list". 127 | def update_data(data) 128 | @data = data 129 | end 130 | 131 | #Returns the PID of the process. 132 | def pid 133 | return @data["pid"].to_i 134 | end 135 | 136 | #Returns a key from the data or raises an error. 137 | def [](key) 138 | raise "No such data: #{key}" if !@data.key?(key) 139 | return @data[key] 140 | end 141 | 142 | #Kills the process. 143 | def kill 144 | Process.kill("TERM", @data["pid"].to_i) 145 | end 146 | 147 | #Kills the process with 9. 148 | def kill! 149 | Process.kill(9, @data["pid"].to_i) 150 | end 151 | 152 | #Hash-compatible. 153 | def to_h 154 | return @data.clone 155 | end 156 | 157 | #Tries to kill the process gently, waits a couple of secs to check if the process is actually dead, then sends -9 kill signals. 158 | def kill_ensure(args = {}) 159 | begin 160 | self.kill 161 | sleep 0.1 162 | return nil if !self.alive? 163 | 164 | args[:sleep] = 2 if !args.key(:sleep) 165 | 166 | 0.upto(5) do 167 | sleep args[:sleep] 168 | self.kill! 169 | sleep 0.1 170 | return nil if !self.alive? 171 | end 172 | 173 | raise "Could not kill the process." 174 | rescue Errno::ESRCH 175 | return nil 176 | end 177 | end 178 | 179 | #Returns true if the process is still alive. 180 | def alive? 181 | return Knj::Unix_proc.pid_running?(@data["pid"].to_i) 182 | end 183 | end -------------------------------------------------------------------------------- /lib/knj/ironruby-gtk2/gtk2.rb: -------------------------------------------------------------------------------- 1 | require "gdk-sharp, Version=2.12.0.0, Culture=neutral, PublicKeyToken=35e10195dab3c99f" 2 | require "gtk-sharp, Version=2.12.0.0, Culture=neutral, PublicKeyToken=35e10195dab3c99f" 3 | require "glade-sharp, Version=2.12.0.0, Culture=neutral, PublicKeyToken=35e10195dab3c99f" 4 | 5 | 6 | #Hack Gtk 7 | RealGtk = Gtk 8 | RealGtk::Application.init 9 | 10 | Gtk = Module.new do 11 | @all = { 12 | "Gtk" => [ 13 | "Button", "CellRendererText", "ComboBox", "Dialog", "Entry", "Label", "ListStore", "Window", "ProgressBar", 14 | "VBox", "HBox", "Image", "IconSize", "StatusIcon", "Menu", "MenuItem", "Builder", "CheckButton", 15 | "FileChooserButton", "TreeView", "TreeViewColumn", "TreeSelection", "TreePath" 16 | ], 17 | "Gdk" => [ 18 | "Pixbuf", "Event", "EventButton" 19 | ] 20 | } 21 | @events = {"Gtk" => {}} 22 | 23 | def self.all; return @all; end; 24 | def self.events; return @events; end 25 | 26 | def self.main 27 | RealGtk::Application.run 28 | end 29 | 30 | def self.main_quit 31 | RealGtk::Application.quit 32 | end 33 | 34 | def self.takeob=(newob) 35 | @takeob = newob 36 | end 37 | 38 | def self.takeob 39 | return @takeob 40 | end 41 | end 42 | 43 | 44 | #Hack Gdk 45 | RealGdk = Module.const_get("Gdk") 46 | Gdk = Module.new 47 | module Gdk 48 | #nothing here yet. 49 | end 50 | 51 | 52 | 53 | Gtk.all.each do |parentclass, classes| 54 | classes.each do |classname| 55 | Kernel.const_get(parentclass).const_set(classname, Class.new do 56 | attr_reader :ob 57 | attr_writer :ob 58 | 59 | def initialize(*paras) 60 | if Gtk.takeob 61 | @ob = Gtk.takeob 62 | if !@ob 63 | raise "Gtk.takeob was not set correctly: " + @ob.class.to_s 64 | end 65 | 66 | print "Spawning '#{self.class.to_s}' from default takeob.\n" 67 | 68 | Gtk.takeob = nil 69 | else 70 | splitted = self.class.to_s.split("::") 71 | realclass = "Real#{splitted.first}" 72 | classob = Kernel.const_get(realclass).const_get(splitted.last) 73 | 74 | if !classob 75 | raise "Class does not exist: " + realclass + "::" + splitted.last 76 | end 77 | 78 | print "Spawning '#{self.class.to_s}' from default constructor.\n" 79 | 80 | @ob = classob.new(*paras) 81 | 82 | if !@ob 83 | raise "Object was not spawned: #{self.class.to_s}, #{@ob.class.to_s}, #{realclass}::#{splitted.last}" 84 | end 85 | end 86 | end 87 | 88 | def signal_connect(signal, &block) 89 | classname = self.class.to_s.split("::") 90 | 91 | if Gtk.events[classname[0]] and Gtk.events[classname[0]][classname[1]] and Gtk.events[classname[0]][classname[1]][signal] 92 | ironevent = Gtk.events[classname[0]][classname[1]][signal] 93 | end 94 | 95 | if !ironevent 96 | raise "No iron-event '#{signal}' for '#{self.class.to_s}'" 97 | end 98 | 99 | print "Connected signal '#{signal}' to '#{self.class.to_s}'\n" 100 | 101 | if !@ob.respond_to?(ironevent) 102 | #puts @ob.methods.sort 103 | raise "RealGtk::" + classname[1] + " does not respond to: #{ironevent}." 104 | end 105 | 106 | @ob.send(ironevent) do |*args| 107 | print "Called signal '#{signal}' on '#{self.class.to_s}'\n" 108 | block.call 109 | end 110 | end 111 | 112 | def method_missing(*paras) 113 | newparas = [] 114 | first = true 115 | paras.each do |para| 116 | if first 117 | first = false 118 | else 119 | splitted = para.class.to_s.split("::") 120 | 121 | if splitted.first == "Gtk" 122 | para = para.ob 123 | elsif splitted.first == "Gdk" 124 | para = para.ob 125 | end 126 | 127 | newparas << para 128 | end 129 | end 130 | 131 | #print "Respond to '#{@ob.class.to_s}' -> '#{paras[0].to_s}'\n" 132 | if @ob.respond_to?(paras[0].to_s) 133 | #print "Send '#{@ob.class.to_s}' -> '#{paras[0].to_s}'\n" 134 | return @ob.send(paras[0], *newparas) 135 | end 136 | 137 | #puts @ob.methods.sort 138 | raise "No such method on #{self.class.name}: #{paras[0]}" 139 | end 140 | end 141 | ) 142 | end 143 | end 144 | 145 | files = ["gladexml", "gtk_combobox", "gtk_cellrenderertext", "window", "vbox", "stock", "label", "image", "iconsize", "entry", "dialog", "button", "gtk_builder", "gdk_pixbuf", "gdk_event", "gdk_eventbutton", "gtk_filechooserbutton", "gtk_liststore", "gtk_statusicon", "gtk_menuitem", "gtk_menu", "gtk_treeiter", "gtk_treeview", "gtk_treeviewcolumn", "gtk_treeselection", "glib"] 146 | files.each do |file| 147 | require File.dirname(__FILE__) + "/" + file 148 | end -------------------------------------------------------------------------------- /lib/knj/webscripts/image.rhtml: -------------------------------------------------------------------------------- 1 | <% 2 | #Register appserver. 3 | begin 4 | appsrv = _hb 5 | rescue NameError 6 | appsrv = _kas 7 | end 8 | 9 | #Support for the PHP-version... Comes handy when converting PHP to Ruby... 10 | if !_get["path"] 11 | trans = { 12 | "picture" => "path" 13 | } 14 | 15 | if _get["edgesize"] 16 | _get["rounded_corners"] = (_get["edgesize"].to_f / 3.0).to_i 17 | end 18 | 19 | if _get["edgeborder"] 20 | if _get["edgeborder"].length == 6 21 | _get["border_color"] = "##{_get["edgeborder"]}" 22 | else 23 | _get["border_color"] = _get["edbeborder"] 24 | end 25 | end 26 | 27 | if _get["edgeborder"] 28 | _get["border"] = 1 29 | end 30 | 31 | trans.each do |key, val| 32 | _get[val] = _get[key] if _get[key] 33 | end 34 | end 35 | 36 | #Base64-encoding of path. 37 | if _get["path64"] 38 | require "base64" 39 | _get["path"] = Base64.decode64(_get["path64"]) 40 | end 41 | 42 | require "digest/md5" 43 | idstr = Digest::MD5.hexdigest("#{Process.euid}_#{_get["path"]}_#{_get["smartsize"].to_i}_#{_get["width"].to_i}_#{_get["height"].to_i}_#{_get["maxwidth"].to_i}_#{_get["maxheight"].to_i}_#{_get["rounded_corners"].to_i}_#{_get["border"].to_i}_#{_get["border_color"]}") 44 | 45 | if !_get["path"] or !File.exist?(_get["path"]) 46 | print "File does not exist: '#{_get["path"]}'.\n" 47 | exit 48 | end 49 | 50 | time_orig = File.mtime(_get["path"]) 51 | tmp_write = false 52 | if Knj::CONFIG["webscripts_image"] 53 | tmp_path = "#{Knj::CONFIG["webscripts_image"]["tmp_path"]}/#{idstr}" 54 | else 55 | tmp_path = "#{Knj::Os.tmpdir}/knjrbfw_image_#{idstr}" 56 | end 57 | 58 | tmp_exists = File.exist?(tmp_path) 59 | tmp_write = true unless tmp_exists 60 | 61 | if !tmp_write and tmp_exists 62 | time_cache = File.mtime(tmp_path) 63 | 64 | if time_orig > time_cache 65 | tmp_write = true 66 | end 67 | end 68 | 69 | if _get["force"] == "true" or _get["force"] == "1" 70 | force = true 71 | else 72 | force = false 73 | end 74 | 75 | notchanged = false 76 | 77 | if _httpsession.handler.modified_since and time_cache and _httpsession.handler.modified_since.utc.to_s == time_cache.utc.to_s 78 | notchanged = true 79 | elsif _httpsession.handler.modified_since and _httpsession.handler.modified_since.utc.to_s == time_orig.utc.to_s 80 | notchanged = true 81 | end 82 | 83 | if notchanged and !force 84 | _httpsession.resp.status = 304 85 | exit 86 | end 87 | 88 | if tmp_write or force 89 | blob_cont = nil 90 | 91 | raise "RMagick has not been loaded. If loaded through here bugs will occur. Load in beginning of script." unless ::Kernel.const_defined?(:Magick) 92 | pic = Magick::Image.read(_get["path"]).first 93 | 94 | if !pic 95 | print "Could not open image from '#{_get["path"]}'." 96 | exit 97 | end 98 | 99 | pic.format = "png" 100 | 101 | pic_columns = pic.columns 102 | pic_rows = pic.rows 103 | 104 | width = pic_columns 105 | height = pic_rows 106 | 107 | height = _get["height"].to_i if _get["height"] 108 | width = _get["width"].to_i if _get["width"] 109 | 110 | if _get["width"] && !_get["height"] 111 | height = (pic_rows.to_f / (pic_columns.to_f / width.to_f)).to_i 112 | elsif _get["height"] && !_get["width"] 113 | width = (pic_columns.to_f / (pic_rows.to_f / height.to_f)).to_i 114 | end 115 | 116 | if _get["smartsize"] 117 | if pic_columns > pic_rows 118 | width = _get["smartsize"].to_i 119 | height = (pic_rows.to_f / (pic_columns.to_f / width.to_f)).to_i 120 | else 121 | height = _get["smartsize"].to_i 122 | width = (pic_columns.to_f / (pic_rows.to_f / height.to_f)).to_i 123 | end 124 | end 125 | 126 | if _get["maxwidth"] 127 | maxwidth = _get["maxwidth"].to_i 128 | 129 | if width > maxwidth 130 | height = (pic_rows.to_f / (pic_columns.to_f / maxwidth.to_f)).to_i 131 | width = maxwidth 132 | end 133 | end 134 | 135 | if _get["maxheight"] 136 | maxheight = _get["maxheight"].to_i 137 | 138 | if height > maxheight 139 | width = (pic_columns.to_f / (pic_rows.to_f / maxheight.to_f)).to_i 140 | height = maxheight 141 | end 142 | end 143 | 144 | if _get["width"] and _get["height"] 145 | width = _get["width"].to_i 146 | height = _get["height"].to_i 147 | end 148 | 149 | if height != pic_rows or width != pic_columns 150 | pic = pic.resize_to_fill(width.to_i, height.to_i) 151 | end 152 | 153 | if _get["rounded_corners"] 154 | args = {:img => pic, :radius => _get["rounded_corners"].to_i} 155 | 156 | if _get["border"] and _get["border_color"] 157 | args[:border] = _get["border"].to_i 158 | args[:border_color] = _get["border_color"] 159 | end 160 | 161 | #Call rounded_corners with the proxy-hash. 162 | Knj::Image.rounded_corners(args) 163 | end 164 | 165 | pic.write(tmp_path) if tmp_write or force 166 | end 167 | 168 | raise "Picture was not written: '#{tmp_path}'." if !tmp_path || !File.exist?(tmp_path) 169 | 170 | appsrv.header("Last-Modified", "#{time_orig.httpdate} GMT") if time_orig 171 | appsrv.header("Content-Type", "image/png") 172 | _httpsession.force_fileread(tmp_path) 173 | %> --------------------------------------------------------------------------------