dumon 0.1.7 → 0.2.0

data/README.md

@@ -25,7 +25,7 @@ Dual monitor manager for Linux with GTK2 based user interface represented by sys
 * gem published on http://rubygems.org/gems/dumon
 
 ### START
- > ruby -r dumon -e 'Dumon::run'
+ > ruby -r dumon -e 'Dumon::App.instance.run'
 
 * or add GEM PATH (see 'gem environment') into your PATH and then
 
@@ -33,10 +33,18 @@ Dual monitor manager for Linux with GTK2 based user interface represented by sys
 
 * or as daemon process
 
- > ruby -r dumon -e 'Dumon::run true'
+ > ruby -r dumon -e 'Dumon::App.instance.run true'
 
  > dumon --daemon
 
+* start with given profile
+
+ > ruby -r dumon -e 'Dumon::App.instance.run' -s 'profile:Profile name'
+
+* or
+
+ > dumon 'profile:Profile name'
+
 ### UPGRADE NOTICES
 
 * see lib/dumon/version.rb

data/bin/dumon

@@ -2,4 +2,4 @@
 
 require 'dumon'
 
-Dumon::run(ARGV[0] == '--daemon')
+Dumon::App.instance.run(ARGV.include? '--daemon')

data/lib/dumon/omanager.rb

@@ -4,73 +4,136 @@ module Dumon
   # This class represents a base class defining how concrete sub-classes manage
   # output devices available on your system.
   class OutDeviceManager
+    include Rrutils::Options
 
     ###
     # System tool to be used for output devices management.
-    attr_accessor :stool
+    attr_reader :stool
 
     ###
     # Cached information about current output devices.
+    # Value will be updated by each invocation of #read.
+    #
     # Format: {output_name=>{:default=>"AxB",:current=>"CxD",:resolutions=>[...], ...}
     # Sample: {
     #   "LVDS1"=>{:resolutions=>["1600x900", "1024x768"], :default=>"1600x900"},
     #   "VGA1" =>{:resolutions=>["1920x1080", "720x400"], :default=>"1920x1080", :current=>"1920x1080"}
     #         }
-    attr_accessor :outputs
+    attr_reader :outputs
 
     ###
-    # Reads info about current accessible output devices and their settings.
-    def read
-      raise NotImplementedError, 'this should be overridden by concrete sub-class'
-    end
+    # Switches output according to given mode and corresponding parameters.
+    #
+    # Possible options:
+    #
+    # Single output:
+    # {:mode=>:single, :out=>'VGA1', :resolution=>'1600x900'}
+    # Mirrored outputs:
+    # {:mode=>:mirror, :resolution=>'1600x900'}
+    # Sequence of outputs:
+    # {:mode=>:sequence, :outs=>['VGA1', 'LVDS1'], :resolutions=>['1920x1080', '1600x900'], :primary=>:none}
+    def switch(options)
+      # pre-conditions
+      verify_options(options, {
+        :mode => [:single, :mirror, :sequence],
+        :out => :optional, :outs => :optional,
+        :resolution => :optional, :resolutions => :optional,
+        :primary => :optional
+      })
+
+      mode = options[:mode].to_sym
+
+      case mode
+      when :single
+        verify_options(options, {:mode => [:single], :out => outputs.keys, :resolution => :optional})
+        out_name = options[:out]
+        # given resolution exists for given output
+        unless options[:resolution].nil?
+          assert(outputs[out_name][:resolutions].include?(options[:resolution]),
+              "unknown resolution: #{options[:resolution]}, output: #{out_name}")
+        end
+        single(out_name, options[:resolution])
+      when :mirror
+        verify_options(options, {:mode => [:mirror], :resolution => :mandatory})
+        # given resolution exist for all outputs
+        outputs.each do |k,v|
+          assert(v[:resolutions].include?(options[:resolution]), "unknown resolution: #{options[:resolution]}, output: #{k}")
+        end
+        mirror(options[:resolution])
+      when :sequence
+        verify_options(options, {:mode => [:sequence], :outs => :mandatory, :resolutions => :mandatory, :primary => :optional})
+        assert(options[:outs].is_a?(Array), 'parameter :outs has to be Array')
+        assert(options[:resolutions].is_a?(Array), 'parameter :resolutions has to be Array')
+        assert(options[:outs].size == options[:resolutions].size, 'size of :outs and :resolutions does not match')
+        assert(options[:outs].size > 1, 'sequence mode expects at least 2 outputs')
+        assert(outputs.keys.include?(options[:primary]), "unknown primary output: #{options[:primary]}") unless options[:primary].nil?
+        sequence(options[:outs], options[:resolutions], options[:primary])
+      end
 
-    ###
-    # Switch to given single output device with given resolution.
-    def single(output, resolution, type=nil)
-      raise NotImplementedError, 'this should be overridden by concrete sub-class'
+      Dumon::App.instance.current_profile = options
     end
 
     ###
-    # Mirrors output on all devices with given resolution.
-    def mirror(resolution)
-      raise NotImplementedError, 'this should be overridden by concrete sub-class'
-    end
-
-    ###
-    # Distributes output to given devices with given order and resolution.
-    # *param* outputs in form [["LVDS1", "1600x900"], [VGA1", "1920x1080"]]
-    # *param* primary name of primary output
-    def sequence(outputs, primary)
+    # Reads info about current accessible output devices and their settings.
+    # Readed infos will be stored and accessible via reader 'outputs'.
+    def read
       raise NotImplementedError, 'this should be overridden by concrete sub-class'
     end
 
     ###
     # Gets default resolution of given output device.
     def default_resolution(output)
-      raise 'no outputs' if self.outputs.nil? or self.outputs.empty?
-      raise "unknown output: #{output}" unless self.outputs.keys.include?(output)
-      raise "no default resolution, output: #{output}" unless self.outputs[output].keys.include?(:default)
+      assert(!outputs.nil?, 'no outputs found')
+      assert(outputs.keys.include?(output), "unknown output: #{output}")
+      assert(outputs[output].keys.include?(:default), "no default resolution, output: #{output}")
 
-      self.outputs[output][:default]
+      outputs[output][:default]
     end
 
     ###
     # Gets list of common resolutions of all output devices.
     def common_resolutions
-      raise 'no outputs' if self.outputs.nil? or self.outputs.empty?
+      assert(!outputs.nil?, 'no outputs found')
 
       rslt = []
-      o1 = self.outputs.keys.first
-      self.outputs[o1][:resolutions].each do |res|
-        self.outputs.keys.each do |o|
+      o1 = outputs.keys.first
+      outputs[o1][:resolutions].each do |res|
+        outputs.keys.each do |o|
           next if o === o1
-          rslt << res if self.outputs[o][:resolutions].include?(res)
+          rslt << res if outputs[o][:resolutions].include?(res)
         end
       end
 
       rslt
     end
 
+
+    protected
+
+
+    ###
+    # Switch to given single output device with given resolution.
+    # *param* output
+    # *resolution* nil for default resolution
+    def single(output, resolution=nil)
+      raise NotImplementedError, 'this should be overridden by concrete sub-class'
+    end
+
+    ###
+    # Mirrors output on all devices with given resolution.
+    def mirror(resolution)
+      raise NotImplementedError, 'this should be overridden by concrete sub-class'
+    end
+
+    ###
+    # Distributes output to given devices with given order and resolution.
+    # *param* outs in form ['VGA1', 'LVDS1']
+    # *resolutions* in form ['1920x1080', '1600x900']
+    # *param* primary name of primary output
+    def sequence(outs, resolutions, primary=:none)
+      raise NotImplementedError, 'this should be overridden by concrete sub-class'
+    end
+
   end
 
 
@@ -82,11 +145,11 @@ module Dumon
     # Constructor.
     # Checks whether the 'xrandr' system tool is there.
     def initialize
-      paths = ['xrandr', '/usr/bin/xrandr']
+      paths = ['/usr/bin/xrandr', 'xrandr']
       paths.each do |path|
         begin
           `#{path}`
-          self.stool = path
+          @stool = path
           Dumon.logger.info "System tool found: #{path}"
           break
         rescue  => e
@@ -96,11 +159,14 @@ module Dumon
 
       raise "no system tool found, checked for #{paths}" if self.stool.nil?
 
+      # just to check if it works
       self.read
     end
 
     def read #:nodoc:
+      @outputs = nil # clear previous info
       rslt = {}
+
       output = nil
       xrandr_out = `#{self.stool} -q`
       xrandr_out.each_line do |line|
@@ -115,15 +181,27 @@ module Dumon
           rslt[output][:resolutions] << resolution
         end
       end
-
       Dumon::logger.debug "Outputs found: #{rslt}"
-      self.outputs = rslt
+
+      # verify structure of readed infos
+      assert(!rslt.empty?, 'no outputs found')
+      rslt.keys.each do |k|
+        out_meta = rslt[k]
+        verify_options(out_meta, {:resolutions=>:mandatory, :default=>:mandatory, :current=>:optional})
+        assert(out_meta[:resolutions].size > 1, "no resolution found, output=#{k}")
+      end
+
+      @outputs = rslt
       rslt
     end
 
-    def single(output, resolution, type=nil) #:nodoc:
-      self.read if self.outputs.nil? or self.outputs.empty?
-      raise "uknown output: #{output}" unless self.outputs.keys.include?(output)
+
+    protected
+
+
+    def single(output, resolution=nil) #:nodoc:
+      assert(!outputs.nil?, 'no outputs found')
+      assert(outputs.keys.include?(output), "unknown output: #{output}")
 
       resolution = self.default_resolution(output) if resolution.nil?
 
@@ -137,7 +215,7 @@ module Dumon
     end
 
     def mirror(resolution) #:nodoc:
-      self.read if self.outputs.nil? or self.outputs.empty?
+      assert(!outputs.nil?, 'no outputs found')
 
       cmd = "#{self.stool}"
       self.outputs.keys.each { |o| cmd << " --output #{o} --mode #{resolution}" }
@@ -146,18 +224,15 @@ module Dumon
       `#{cmd}`
     end
 
-    def sequence(outputs, primary=:none) #:nodoc:
-      raise 'not an array' unless outputs.kind_of?(Array)
-      outputs.each { |pair| raise 'item not a pair' if !pair.kind_of?(Array) and pair.size != 2 }
-
+    def sequence(outs, resolutions, primary=:none) #:nodoc:
       cmd = "#{self.stool}"
-      for i in 0..outputs.size - 1
-        output = outputs[i][0]
-        resolution = outputs[i][1]
+      for i in 0..outs.size - 1
+        output = outs[i]
+        resolution = resolutions[i]
         resolution = self.default_resolution(output) if resolution.nil?
         cmd << " --output #{output} --mode #{resolution}"
         cmd << ' --primary' if primary.to_s == output
-        cmd << " --right-of #{outputs[i - 1][0]}" if i > 0
+        cmd << " --right-of #{outs[i - 1]}" if i > 0
       end
 
       Dumon::logger.debug "Command: #{cmd}"

data/lib/dumon/ui.rb

@@ -6,7 +6,27 @@ module Dumon
 
     ###
     # Output manager used to manipulate the output.
-    attr_accessor :omanager
+    attr_reader :omanager
+
+    ###
+    # Constructor.
+    def initialize
+      @omanager = new_omanager
+      Dumon::logger.debug "Used output manager: #{omanager.class.name}"
+    end
+
+    ###
+    # Factory method to create a new object of output manager.<p/>
+    # Can be used as Dependency Injection (DI) entry point:
+    # you can reopen Dumon:Ui and redefine 'new_omanager' if you implement a new output manager.
+    # <pre>
+    # class Dumon::Ui
+    #   def new_omanager; Dumon::XyManager.new; end
+    # end
+    # </pre>
+    def new_omanager(with=Dumon::XrandrManager)
+      with.new
+    end
 
     ###
     # Renders the UI.
@@ -18,7 +38,7 @@ module Dumon
     ###
     # Quits the application.
     def quit
-      Dumon::logger.info "Terminted..."
+      raise NotImplementedError, 'this should be overridden by concrete sub-class'
     end
 
     ###
@@ -47,7 +67,6 @@ module Dumon
     end
 
     def quit #:nodoc:
-      super
       Gtk.main_quit
     end
 
@@ -68,7 +87,7 @@ module Dumon
 
   ###
   # This class represents a user interface represented by system tray icon and its context menu.
-  class Tray < GtkUi
+  class GtkTrayUi < GtkUi
 
     def initialize #:nodoc:
       super
@@ -77,8 +96,8 @@ module Dumon
       # {"LVDS1" => "1600x900", "VGA1" => "800x600"}
       @selected_resolution = {}
 
-      # primary output
-      @primary = :none
+      # initial primary output
+      @primary_output = :none
 
       @tray = Gtk::StatusIcon.new
       @tray.visible = true
@@ -128,11 +147,11 @@ module Dumon
       item = Gtk::SeparatorMenuItem.new
       rslt.append(item)
 
-      # outputs
+      # single outputs
       outputs.keys.each do |o|
         item = Gtk::MenuItem.new("only #{o}")
         item.signal_connect('activate') do
-          self.omanager.single(o, @selected_resolution[o])
+          self.omanager.switch({:mode=>:single, :out=>o, :resolution=>@selected_resolution[o]})
           # clear preferred resolution, by next rendering will be read from real state
           @selected_resolution.clear
         end
@@ -150,7 +169,7 @@ module Dumon
 
       self.omanager.common_resolutions.each do |res|
         si = Gtk::MenuItem.new(res)
-        si.signal_connect('activate') { self.omanager.mirror(res) }
+        si.signal_connect('activate') { self.omanager.switch({:mode=>:mirror, :resolution=>res}) }
         submenu.append(si)
       end
       rslt.append(item)
@@ -160,7 +179,7 @@ module Dumon
       rslt.append(item)
 
       # primary output
-      item = Gtk::MenuItem.new('primary output')
+      item = Gtk::MenuItem.new('Primary output')
       submenu = Gtk::Menu.new
       item.set_submenu(submenu)
       item.sensitive = (outputs.keys.size >= 2)
@@ -169,27 +188,27 @@ module Dumon
       prims = outputs.keys.clone << :none
       prims.each do |o|
         si = Gtk::RadioMenuItem.new(radios, o.to_s)
-        si.active = (@primary.to_s == o.to_s)
+        si.active = (@primary_output.to_s == o.to_s)
         radios << si
-        si.signal_connect('activate') { @primary = o.to_s if si.active? }
+        si.signal_connect('activate') { @primary_output = o.to_s if si.active? }
         submenu.append(si)
       end
       rslt.append(item)
 
-      # sequence (currently supporting only 2 output devices)
+      # sequence
       if outputs.keys.size >= 2
         o0 = outputs.keys[0]
         o1 = outputs.keys[1]
         item = Gtk::MenuItem.new("#{o0} left of #{o1}")
         item.signal_connect('activate') do
-          self.omanager.sequence([[o0, @selected_resolution[o0]], [o1, @selected_resolution[o1]]], @primary)
+          omanager.switch({:mode=>:sequence, :outs=>[o0, o1], :resolutions=>[@selected_resolution[o0], @selected_resolution[o1]], :primary=>@primary_output})
           # clear preferred resolution, by next rendering will be read from real state
           @selected_resolution.clear
         end
         rslt.append(item)
         item = Gtk::MenuItem.new("#{o1} left of #{o0}")
         item.signal_connect('activate') do
-          self.omanager.sequence([[o1, @selected_resolution[o1]], [o0, @selected_resolution[o0]]], @primary)
+          omanager.switch({:mode=>:sequence, :outs=>[o1, o0], :resolutions=>[@selected_resolution[o1], @selected_resolution[o0]], :primary=>@primary_output})
           # clear preferred resolution, by next rendering will be read from real state
           @selected_resolution.clear
         end
@@ -197,20 +216,124 @@ module Dumon
       end
 
       # separator
-      item = Gtk::SeparatorMenuItem.new
+      rslt.append(Gtk::SeparatorMenuItem.new)
+
+      # Profiles
+      item = Gtk::MenuItem.new('Profiles...')
+      item.signal_connect('activate') { self.profile_management_dialog }
       rslt.append(item)
+
       # About
       item = Gtk::ImageMenuItem.new(Gtk::Stock::ABOUT)
       item.signal_connect('activate') { self.about }
       rslt.append(item)
       # Quit
       item = Gtk::ImageMenuItem.new(Gtk::Stock::QUIT)
-      item.signal_connect('activate') { self.quit }
+      item.signal_connect('activate') { Dumon::App.instance.quit }
       rslt.append(item)
 
       rslt
     end
 
+    ###
+    # Applies a profile from configuration according selection in tree view.
+    def apply_profile(conf, prof_name)
+      profile = conf[:profiles][prof_name.to_sym]
+      profile[:mode] = profile[:mode].to_sym
+      omanager.switch profile
+      Dumon::logger.debug "Profile applied, name=#{prof_name}"
+    end
+
+    ###
+    # Function to open a dialog box for profile management.
+    def profile_management_dialog
+      conf = Dumon::App.instance.read_config
+
+      # create the dialog
+      dialog = Gtk::Dialog.new('Profile management', nil, Gtk::Dialog::MODAL, [Gtk::Stock::CANCEL, Gtk::Dialog::RESPONSE_REJECT])
+      t = Gtk::Table.new(2, 2)
+      t.row_spacings = 5
+      t.column_spacings = 5
+
+      # save new profile
+      entry_store = Gtk::Entry.new
+      btn_save = Gtk::Button.new(Gtk::Stock::SAVE)
+      btn_save.signal_connect('clicked') do
+        if entry_store.text.size > 0
+          conf[:profiles][entry_store.text] = Dumon::App.instance.current_profile
+          Dumon::App.instance.write_config(conf)
+          Dumon::logger.debug "Stored profile, name=#{entry_store.text}"
+          dialog.destroy
+        end
+      end
+      # disable entry/button if no mode set (probably after start of Dumon)
+      if Dumon::App.instance.current_profile.nil?
+        entry_store.text = '<make a choice first>'
+        entry_store.set_sensitive false
+        btn_save.set_sensitive false
+      end
+
+      t.attach(Gtk::HBox.new(false, 5).pack_start(Gtk::Label.new('Profile name:'), false, false).add(entry_store), 0, 1, 0, 1)
+      t.attach(btn_save, 1, 2, 0, 1)
+
+      # select/delete existing profile
+      model = Gtk::ListStore.new(String)
+      treeview = Gtk::TreeView.new(model)
+      treeview.headers_visible = false
+      renderer = Gtk::CellRendererText.new
+      column = Gtk::TreeViewColumn.new('', renderer, :text => 0)
+      treeview.append_column(column)
+
+      conf[:profiles].keys.each do |k|
+        iter = model.append
+        iter.set_value 0, k.to_s
+      end
+
+      # apply
+      btn_apply = Gtk::Button.new(Gtk::Stock::APPLY)
+      btn_apply.signal_connect('clicked') do
+        selection = treeview.selection
+        if iter = selection.selected
+          apply_profile(conf, iter[0])
+          dialog.destroy
+        end
+      end
+      # double-click on treeview
+      treeview.signal_connect("row-activated") do |view, path|
+        if iter = view.model.get_iter(path)
+          apply_profile(conf, iter[0])
+          dialog.destroy
+        end
+      end
+      # delete
+      btn_delete = Gtk::Button.new(Gtk::Stock::DELETE)
+      btn_delete.signal_connect('clicked') do
+        selection = treeview.selection
+        if iter = selection.selected
+          prof_name = iter[0]
+          conf[:profiles].delete prof_name.to_sym
+          Dumon::App.instance.write_config(conf)
+          Dumon::logger.debug "Deleted profile, name=#{prof_name}"
+          dialog.destroy
+        end
+      end
+
+      t.attach(treeview, 0, 1, 1, 2)
+      t.attach(Gtk::VBox.new(false, 5).pack_start(btn_apply, false, false).pack_start(btn_delete, false, false), 1, 2, 1, 2)
+
+      dialog.vbox.add t
+
+      # ensure that the dialog box is destroyed when the user responds
+      dialog.signal_connect('response') do |w, code|
+        if Gtk::Dialog::RESPONSE_OK.eql?(code) and entry.text.size > 0
+          Dumon::App.instance.write(entry.text => Dumon::App.instance.current_profile)
+        end
+
+        dialog.destroy
+      end
+      dialog.show_all
+    end
+
   end
 
 end

data/lib/dumon/version.rb

@@ -2,6 +2,7 @@ module Dumon
 
   # Version history.
   VERSION_HISTORY = [
+    ['0.2.0',   '2013-03-12', 'Enh #5: Profiles; File based configuration'],
     ['0.1.7',   '2013-02-13', 'Enh #4: About dialog'],
     ['0.1.6',   '2013-02-11', 'BF #3: Crash by rendering popup menu if only one output is there'],
     ['0.1.5',   '2013-02-08', 'Enh #2: Support for primary output'],

data/lib/dumon.rb

@@ -1,17 +1,19 @@
 #!/usr/bin/ruby
 
+require 'singleton'
 require 'logger'
 require 'gtk2'
+require 'fileutils'
+require 'rrutils'
 require 'dumon/version'
+require 'dumon/omanager'
+require 'dumon/ui'
 
 
 ###
-# This module represents the entry point of Dumon tool.
+# This module represents namespace of Dumon tool.
 module Dumon
 
-  autoload :XrandrManager,   'dumon/omanager'
-  autoload :Tray,            'dumon/ui'
-
   class << self
 
     ###
@@ -22,37 +24,134 @@ module Dumon
 
 
   ###
-  # Runs the application.
-  def self.run(daemon=false)
-    if daemon
-      if RUBY_VERSION < '1.9'
-        Dumon::logger.warn 'Daemon mode supported only in Ruby >= 1.9'
-      else
-        # Daemonize the process
-        # - stay in the current directory
-        # - don't redirect standard input, standard output and standard error to /dev/null
-        Dumon::logger.info 'Running as daemon...'
-        Process.daemon(true, true)
+  # This class represents an entry point
+  class App
+    include ::Singleton
+    include Rrutils::Confdb
+    include Rrutils::Options
+
+    ###
+    # User interface of Dumon tool.
+    attr_reader :ui
+
+    ###
+    # Currently used profile.
+    attr_accessor :current_profile
+
+    ###
+    # Constructor.
+    def initialize
+      @ui = new_ui
+      Dumon::logger.debug "Used UI: #{ui.class.name}"
+
+      # storage of preferred resolution for next rendering (will be cleared by output changing)
+      # {"LVDS1" => "1600x900", "VGA1" => "800x600"}
+      @selected_resolution = {}
+    end
+
+    ###
+    # Factory method to create a new object of UI.<p/>
+    # Can be used as Dependency Injection (DI) entry point:
+    # you can reopen Dumon:App and redefine 'new_ui' if you implement a new UI class.
+    # <pre>
+    # class Dumon::App
+    #   def new_ui; Dumon::XyUi.new; end
+    # end
+    # </pre>
+    def new_ui(with=Dumon::GtkTrayUi)
+      with.new
+    end
+
+    ###
+    # Gets default config file.
+    def config_file(mode='r')
+      filename = "#{Dir.home}#{File::SEPARATOR}.config#{File::SEPARATOR}dumon.conf"
+
+      # check and create directory structure
+      dirname = File.dirname filename
+      ::FileUtils.mkdir_p(dirname) unless Dir.exist?(dirname)
+
+      # create file if does not exist
+      File.open(filename, 'w').close unless File.exist? filename
+
+      File.open(filename, mode)
+    end
+
+    ###
+    # Reads Dumon's configuration.
+    def read_config
+      conf = read config_file
+      conf = keys_to_sym conf
+
+      # there can be a hook if config version is old
+
+      conf
+    end
+
+    ###
+    # Writes Dumon's configuration.
+    def write_config(conf)
+      conf[:version] = VERSION
+      write(conf, config_file('w'))
+    end
+
+    ###
+    # Runs the application.
+    def run(daemon=false)
+      # profile
+      prof_arg = ARGV.select {|i| i.start_with? 'profile:'}.first
+      unless prof_arg.nil?
+        prof_name = prof_arg.split(':')[1]
+        conf = read_config
+        raise "unknown profile, name=#{prof_name}" unless conf[:profiles][prof_name.to_sym]
+        Dumon::logger.info "Started with profile '#{prof_name}'"
+        ui.apply_profile(conf, prof_name)
       end
+
+      # daemon mode
+      if daemon
+        if RUBY_VERSION < '1.9'
+          Dumon::logger.warn 'Daemon mode supported only in Ruby >= 1.9'
+        else
+          # Daemonize the process
+          # - stay in the current directory
+          # - don't redirect standard input, standard output and standard error to /dev/null
+          Dumon::logger.info 'Running as daemon...'
+          Process.daemon(true, true)
+        end
+      end
+
+      ui.render
     end
 
-    ui = Dumon::Tray.new
-    ui.omanager = Dumon::XrandrManager.new
-    ui.render
+    ###
+    # Quits cleanly the application.
+    def quit
+      ui.quit
+      Dumon::logger.info 'Terminted...'
+    end
 
-  end
+  end # App
 
 end
 
 
-# Configuration of logging.
+# Default configuration of logging.
 Dumon::logger = Logger.new(STDOUT)
 Dumon::logger.level = Logger::INFO
 
 Dumon::logger.info \
     "Dumon #{Dumon::VERSION}, running on Ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}]"
 
+# Capturing Ctrl+C to cleanly quit
+trap('INT') do
+  Dumon::logger.debug 'Ctrl+C captured'
+  Dumon::App.instance.quit
+end
+
 
-# development
-#Dumon::logger.level = Logger::DEBUG
-#Dumon::run(ARGV[0] == '--daemon')
+# development mode
+if __FILE__ == $0
+  Dumon::logger.level = Logger::DEBUG
+  Dumon::App.instance.run(ARGV.include? '--daemon')
+end

data/lib/rrutils/confdb.rb

@@ -0,0 +1,45 @@
+require 'json'
+
+module Rrutils
+
+  ###
+  # This modul represents a mixin for configuration
+  # that can be 'loaded from' or 'stored into' a persistent repository.
+  module Confdb
+
+    ###
+    # Loads and returns a configuration from a file.
+    def read(input_stream=STDIN)
+      rslt = {}
+      unless input_stream.nil?
+        begin
+          rslt = JSON.load(input_stream)
+          Dumon::logger.debug "Configuration readed, keys=#{rslt.keys}"
+        rescue => e
+          Dumon::logger.warn "failed to read configuration: #{e.message}"
+        ensure
+          input_stream.close unless input_stream === STDIN
+        end
+      end
+
+      rslt
+    end
+
+    ###
+    # Writes out the configuration to a given output stream.
+    def write(conf, output_stream=STDOUT)
+      raise ArgumentError, 'configuration not a hash' unless conf.is_a? Hash
+
+      begin
+        output_stream.write(JSON.pretty_generate(conf))
+        Dumon::logger.debug "Configuration written, keys=#{conf.keys}"
+      rescue => e
+        Dumon::logger.error "failed to write configuration: #{e.message}"
+      ensure
+        output_stream.close unless output_stream === STDOUT
+      end
+    end
+
+  end
+
+end

data/lib/rrutils/options.rb

@@ -0,0 +1,91 @@
+module Rrutils
+
+  ###
+  # This modul represents a mixin for a set of convenience methods
+  # that work with options representing method's parameters.
+  module Options
+
+    ###
+    # Fails unless +test+ is a true value.
+    #
+    # +msg+ may be a String or a Proc.
+    # If no +msg+ is given, a default message will be used.
+    def assert(test, msg=nil)
+      msg ||= 'failed assertion'
+      unless test
+        msg = msg.call if Proc === msg
+        raise ArgumentError, msg
+      end
+    end
+
+    ###
+    # Verifies given options against a pattern that defines checks applied on each option.
+    # The pattern is a Hash where property is an expected option's property and value can be:
+    # * :optional - corresponding option may or may not be presented
+    # * :mandatory - corresponding option has to be presented
+    # * Array - corresponding option has to be presented and value has to be in the given list
+    #
+    # Usage:
+    # verify_options(options_to_be_verified, {:foo=>:mandatory, :bar=>[true, false], :baz=>:optional})
+    #
+    def verify_options(options, pattern)
+      raise ArgumentError, 'options cannot be nil' if options.nil?
+      raise ArgumentError, 'options is not Hash' unless options.is_a? Hash
+
+      raise ArgumentError, 'pattern cannot be nil' if pattern.nil?
+      raise ArgumentError, 'pattern cannot be empty' if pattern.empty?
+      raise ArgumentError, 'pattern is not Hash' unless pattern.is_a? Hash
+
+      # unknown key?
+      options.keys.each do |k|
+        raise ArgumentError, "unknow option: #{k}" unless pattern.keys.include? k
+      end
+      # missing mandatory option?
+      pattern.each do |k,v|
+        # :mandatory
+        if v == :mandatory
+          raise ArgumentError, "missing mandatory option: #{k}" if !options.keys.include?(k) or options[k].nil?
+        elsif v.is_a? Array
+          raise ArgumentError, "value '#{options[k]}' not in #{v.inspect}, key=#{k}" unless v.include?(options[k])
+        end
+      end
+
+      options
+    end
+
+    ###
+    # The same as <code>verify_options</code> with opportunity to define default values
+    # of paramaters that will be set if missing in options.
+    #
+    # Usage:
+    # verify_and_sanitize_options(options_to_be_verified, {:foo=>'defaultValue', :bar=>100})
+    #
+    def verify_and_sanitize_options(options, pattern, cloned=true)
+      opts = cloned ? options.clone : options
+
+      verify_options(opts, pattern)
+
+      # set default values if missing in options
+      pattern.select { |k,v| !v.nil? and v != :optional }.each do |k,v|
+        opts[k] = v if !opts.keys.include? k
+      end
+      opts
+    end
+
+    ###
+    # Goes recursively through given Hash and converst all key into Symbol.
+    def keys_to_sym(options)
+      raise ArgumentError, 'not a hash' unless options.is_a? Hash
+      opts = options.clone
+
+      options.each do |k,v|
+        opts[k.to_sym] = opts.delete k unless k.is_a? Symbol
+        opts[k.to_sym] = keys_to_sym(v) if v.is_a? Hash
+      end
+
+      opts
+    end
+
+  end
+
+end

data/lib/rrutils.rb

@@ -0,0 +1,9 @@
+###
+# This module represents namespace of Rrutils meaning 'Reasonable Ruby Utilities'
+# - yet another general purpose utilities package.
+module Rrutils
+
+  autoload :Confdb,    'rrutils/confdb'
+  autoload :Options,   'rrutils/options'
+
+end

data/test/test_rrutils_options.rb

@@ -0,0 +1,51 @@
+require 'test/unit'
+require 'rrutils'
+
+###
+# This class tests Rrutils::Options module.
+class TestRrutilsOptions < Test::Unit::TestCase
+  include Rrutils::Options
+
+  def test_verify_options_preconditions
+    assert_raise ArgumentError do verify_options(nil, {:a => 'A'}); end
+    assert_raise ArgumentError do verify_options('a string', {:a => 'A'}); end
+    assert_raise ArgumentError do verify_options({:b => 'B'}, nil); end
+    assert_raise ArgumentError do verify_options({:b => 'B'}, {}); end
+    assert_raise ArgumentError do verify_options({:b => 'B'}, 'a string'); end
+  end
+
+  def test_verify_options
+    opt_pattern = {:a => :mandatory, :b => :optional, :c => 'predefined', :d => [1, false]}
+    assert_nothing_thrown do verify_options({:a => 'A', :b => 'B', :c => 'C', :d => 1}, opt_pattern); end
+    assert_nothing_thrown do verify_options({:a => 'A', :d => 1}, opt_pattern); end
+
+    # missing mandatory
+    assert_raise ArgumentError do verify_options({}, opt_pattern); end
+    assert_raise ArgumentError do verify_options({:a => 'A'}, opt_pattern); end
+    assert_raise ArgumentError do verify_options({:d => 1}, opt_pattern); end
+    assert_raise ArgumentError do verify_options({:a => nil, :d => 1}, opt_pattern); end
+    assert_raise ArgumentError do verify_options({:a => 'A', :d => nil}, opt_pattern); end
+    # unknown key
+    assert_raise ArgumentError do verify_options({:a => 'A', :z => 2}, opt_pattern); end
+    # value not in predefined set
+    assert_raise ArgumentError do verify_options({:a => 'A', :d => 3}, opt_pattern); end
+  end
+
+  def test_verify_and_sanitize_options
+    opt_pattern = {:a => 'A', :b => 'B'}
+    options = {:a => 'X'}
+    opts = verify_and_sanitize_options(options, opt_pattern)
+    assert_equal 2, opts.size
+    assert_equal 'X', opts[:a]
+    assert_equal 'B', opts[:b]
+
+    # :optional cannot be set as default value
+    opt_pattern = {:a => :optional, :b => 'B'}
+    options = {}
+    opts = verify_and_sanitize_options(options, opt_pattern)
+    assert_equal 1, opts.size
+    assert !opts.include?(:a)
+    assert_equal 'B', opts[:b]
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dumon
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-13 00:00:00.000000000 Z
+date: 2013-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gtk2
@@ -49,6 +49,10 @@ files:
 - lib/dumon/version.rb
 - lib/monitor24.png
 - lib/monitor48.png
+- lib/rrutils.rb
+- lib/rrutils/confdb.rb
+- lib/rrutils/options.rb
+- test/test_rrutils_options.rb
 homepage: http://github.com/veny/dumon
 licenses: []
 post_install_message: 
@@ -74,4 +78,5 @@ rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Dual monitor manager for Linux.
-test_files: []
+test_files:
+- test/test_rrutils_options.rb