ruber 0.0.1.1

data/spec/gui_states_handler_spec.rb

@@ -0,0 +1,304 @@
+require 'spec/common'
+require 'ruber/gui_states_handler'
+
+describe Ruber::GuiStatesHandler do
+  
+  describe '.included' do
+    
+    class TestObject < Qt::Object
+    end
+    
+    it 'creates the "ui_state_changed(QString, bool)" signal if included in a class derived from Qt::Object' do
+      flexmock(TestObject).should_receive(:signals).with("ui_state_changed(QString, bool)").once
+      TestObject.send :include, Ruber::GuiStatesHandler
+    end
+    
+    it 'doesn\'t attempt to create the "ui_state_changed(QString, bool)" signal if included in a class not derived from Qt::Object' do
+      cls = Class.new
+      flexmock(cls).should_receive(:signals).never
+      cls.send :include, Ruber::GuiStatesHandler
+    end
+    
+    it 'doesn\'t attempt to create the "ui_state_changed(QString, bool)" signal if included in a modules' do
+      cls = Module.new
+      flexmock(cls).should_receive(:signals).never
+      cls.send :include, Ruber::GuiStatesHandler
+    end
+    
+  end
+  
+  describe '#initialize_states_handler' do
+    
+    it 'creates an empty hash of states and an empty hash of state handlers' do
+      o = Object.new
+      o.extend Ruber::GuiStatesHandler
+      o.send :initialize_states_handler
+      o.instance_variable_get(:@gui_state_handler_states).should == {}
+      o.instance_variable_get(:@gui_state_handler_handlers).should == {}
+    end
+    
+  end
+  
+  describe '#register_action_handler' do
+    
+    before do
+      @handler = Object.new
+      @handler.extend Ruber::GuiStatesHandler
+      @handler.send :initialize_states_handler
+    end
+    
+    it 'creates a new Data object for the action, passing it the action, the block and the extra_id entry of the optional hash as argument' do
+      flexmock(Ruber::GuiStatesHandler::Data).should_receive(:new).once.with(KDE::Action, Proc, nil).and_return Object.new
+      flexmock(Ruber::GuiStatesHandler::Data).should_receive(:new).once.with(KDE::Action, Proc, :a).and_return Object.new
+      @handler.register_action_handler(KDE::Action.new(nil), ['x']){}
+      @handler.register_action_handler(KDE::Action.new(nil), ['x'], :extra_id => :a){}
+    end
+    
+    it 'adds the Data object to the entries corresponding to the states in the second argument in the state handlers hash' do
+      a1 = KDE::Action.new(nil)
+      a2 = KDE::Action.new(nil)
+      blk1 = Proc.new{true}
+      blk2 = Proc.new{false}
+      @handler.register_action_handler a1, ['x'], &blk1
+      h = @handler.instance_variable_get(:@gui_state_handler_handlers)
+      data1 = Ruber::GuiStatesHandler::Data.new(a1, blk1, nil)
+      h['x'].should == [data1]
+      @handler.register_action_handler a2, ['x', 'y'], :extra_id => :a, &blk2
+      data2 = Ruber::GuiStatesHandler::Data.new(a2, blk2, :a)
+      h['x'].should == [data1, data2]
+      h['y'].should == [data2]
+    end
+    
+    it 'treats a single string passed as second argument as an array with only that string' do
+      a = KDE::Action.new(nil)
+      blk = Proc.new{true}
+      @handler.register_action_handler a, 'x', &blk
+      h = @handler.instance_variable_get(:@gui_state_handler_handlers)
+      h['x'].should == [Ruber::GuiStatesHandler::Data.new(a, blk, nil)]
+    end
+    
+    it 'convert any symbol in the second argument to a string' do
+      h = @handler.instance_variable_get(:@gui_state_handler_handlers)
+      @handler.register_action_handler(KDE::Action.new(nil), [:a, 'b']){}
+      h['a'].should_not be_empty
+      h[:a].should be_empty
+    end
+    
+    it 'raises ArgumentError if no block is given and the second argument is an array with more than one element' do
+      lambda{@handler.register_action_handler KDE::Action.new(nil), ['x', 'y']}.should raise_error(ArgumentError, "If more than one state is supplied, a block is needed")
+    end
+
+    
+    it 'creates a default handler which returns true or false according to the value of the state if no block is given and the second argument is a string or symbol or an array with a single element' do
+      h = @handler.instance_variable_get(:@gui_state_handler_handlers)
+      @handler.register_action_handler(KDE::Action.new(nil), 'a')
+      @handler.register_action_handler(KDE::Action.new(nil), :b)
+      h['a'][0].handler.call('a' => true).should be_true
+      h['a'][0].handler.call('a' => false).should be_false
+      h['b'][0].handler.call('b' => true).should be_true
+      h['b'][0].handler.call('b' => false).should be_false
+
+    end
+    
+    it 'creates a default handler which returns true or false according to the opposite of the value of the state if no block is given and the second argument is a string or symbol starting with !' do
+      h = @handler.instance_variable_get(:@gui_state_handler_handlers)
+      @handler.register_action_handler(KDE::Action.new(nil), '!a')
+      @handler.register_action_handler(KDE::Action.new(nil), :"!b")
+      h['a'][0].handler.call('a' => true).should be_false
+      h['a'][0].handler.call('a' => false).should be_true
+      h['b'][0].handler.call('b' => true).should be_false
+      h['b'][0].handler.call('b' => false).should be_true
+    end
+    
+    it 'calls the handler passing it the gui states and enables or disables the action according to the returned value if the :check option is given' do
+      a1 = KDE::Action.new(nil)
+      a2 = KDE::Action.new(nil)
+      @handler.change_state 'a', true
+      @handler.change_state 'b', false
+      flexmock(a1).should_receive(:enabled=).with(true).once 
+      flexmock(a2).should_receive(:enabled=).with(false).once
+      @handler.register_action_handler(a1, 'a', :check => true)
+      @handler.register_action_handler(a2, "b", :check => true)
+    end
+    
+    it 'doesn\'t call the handlerif the :check option is not given' do
+      a1 = KDE::Action.new(nil)
+      a2 = KDE::Action.new(nil)
+      @handler.change_state 'a', true
+      @handler.change_state 'b', false
+      flexmock(a1).should_receive(:enabled=).never
+      flexmock(a2).should_receive(:enabled=).never
+      @handler.register_action_handler(a1, 'a', :check => false)
+      @handler.register_action_handler(a2, "b", :check => false)
+    end
+    
+  end
+  
+  describe '#remove_action_handler_for' do
+    
+    before do
+      @handler = Object.new
+      @handler.extend Ruber::GuiStatesHandler
+      @handler.send :initialize_states_handler
+    end
+    
+    describe ', when the first argument is a KDE::Action' do
+      
+      it 'removes all the handlers corresponding to the action from the handler list' do
+        a = KDE::Action.new(nil){self.object_name = 'a'}
+        @handler.register_action_handler(KDE::Action.new(nil), %w[x y]){}
+        @handler.register_action_handler(a, %w[x z]){}
+        @handler.register_action_handler(KDE::Action.new(nil), %w[z w]){}
+        @handler.remove_action_handler_for a
+        @handler.instance_variable_get(:@gui_state_handler_handlers).each_value.any? do |v|
+          v.any?{|d| d.action.equal? a}
+        end.should be_false
+      end
+      
+    end
+    
+    describe ', when the first argument is a string' do
+      
+      it 'removes all the handlers corresponding to actions having the first argument as object name if the second argument is nil' do
+        a1 = KDE::Action.new(nil){self.object_name = 'a'}
+        a2= KDE::Action.new(nil){self.object_name = 'a'}
+        @handler.register_action_handler(a1, %w[x z]){}
+        @handler.register_action_handler(KDE::Action.new(nil), %w[x y]){}
+        @handler.register_action_handler(a2, %w[z w], :extra_id => 'x'){}
+        @handler.remove_action_handler_for 'a'
+        @handler.instance_variable_get(:@gui_state_handler_handlers).each_value.any? do |v|
+          v.any?{|d| d.action.object_name == 'a'}
+        end.should be_false
+      end
+      
+      it 'removes all the handlers corresponding to actions having the first argument as object name and the second as extra_id if the second argument is not nil' do
+        a1 = KDE::Action.new(nil){self.object_name = 'a'}
+        a2= KDE::Action.new(nil){self.object_name = 'a'}
+        @handler.register_action_handler(a1, %w[x z]){}
+        @handler.register_action_handler(KDE::Action.new(nil), %w[x y]){}
+        @handler.register_action_handler(a2, %w[z w], :extra_id => 'x'){}
+        @handler.remove_action_handler_for 'a', 'x'
+        @handler.instance_variable_get(:@gui_state_handler_handlers).each_value.any? do |v|
+          v.any?{|d| d.action.object_name == 'a' and d.extra_id == 'x'}
+        end.should be_false
+        @handler.instance_variable_get(:@gui_state_handler_handlers).each_value.any? do |v|
+          v.any?{|d| d.action.object_name == 'a' and d.extra_id != 'x'}
+        end.should be_true
+      end
+      
+      it 'removes all entries corresponding to empty arrays from the handlers hash' do
+        a1 = KDE::Action.new(nil){self.object_name = 'a'}
+        a2= KDE::Action.new(nil){self.object_name = 'a'}
+        @handler.register_action_handler(a1, %w[x z]){}
+        @handler.register_action_handler(KDE::Action.new(nil), %w[x y]){}
+        @handler.register_action_handler(a2, %w[z w], :extra_id => 'x'){}
+        @handler.remove_action_handler_for 'a'
+        hash = @handler.instance_variable_get(:@gui_state_handler_handlers)
+        hash.should_not have_key('z')
+        hash.any?{|k, v| v.empty? }.should_not be_true
+      end
+      
+    end
+    
+    describe '#change_state' do
+      
+      class TestObject < Qt::Object
+        include Ruber::GuiStatesHandler
+        def initialize
+          super
+          initialize_states_handler
+        end
+      end
+      
+      before do
+        @handler = TestObject.new
+      end
+      
+      it 'sets the state corresponding to the first argument to true or false depending on the second argument' do
+        @handler.change_state 'x', true
+        @handler.instance_variable_get(:@gui_state_handler_states)['x'].should be_true
+        @handler.change_state 'x', false
+        @handler.instance_variable_get(:@gui_state_handler_states)['x'].should be_false
+        @handler.change_state 'x', 3
+        @handler.instance_variable_get(:@gui_state_handler_states)['x'].should be_true
+        @handler.change_state 'x', nil
+        @handler.instance_variable_get(:@gui_state_handler_states)['x'].should be_false
+      end
+      
+      it 'converts the first argument to a string' do
+        @handler.change_state :x, true
+        @handler.instance_variable_get(:@gui_state_handler_states)['x'].should be_true
+        @handler.instance_variable_get(:@gui_state_handler_states)[:x].should be_nil
+      end
+      
+      it 'calls the handler of each action associated with the state passing it the states hash' do
+        @handler.instance_variable_get(:@gui_state_handler_states)['y'] = false
+        m1 = flexmock{|m| m.should_receive(:test).once.with({'x' => true, 'y' => false})}
+        m2 = flexmock{|m| m.should_receive(:test).once.with({'x' => true, 'y' => false})}
+        m3 = flexmock{|m| m.should_receive(:test).never}
+        @handler.register_action_handler(KDE::Action.new(nil), %w[x y], :check => false){|states| m1.test states}
+        @handler.register_action_handler(KDE::Action.new(nil), %w[x], :check => false){|states| m2.test states}
+        @handler.register_action_handler(KDE::Action.new(nil), %w[y], :check => false){|states| m3.test states}
+        @handler.change_state 'x', true
+      end
+      
+      it 'enables or disables the actions associated with the state according to the value returned by the handler' do
+        @handler.instance_variable_get(:@gui_state_handler_states)['y'] = false
+        actions = 3.times.map{KDE::Action.new nil}
+        m1 = flexmock{|m| m.should_receive(:test).once.with({'x' => true, 'y' => false}).and_return true}
+        m2 = flexmock{|m| m.should_receive(:test).once.with({'x' => true, 'y' => false}).and_return false}
+        m3 = flexmock{|m| m.should_receive(:test).never}
+        flexmock(actions[0]).should_receive(:enabled=).with(true).once
+        flexmock(actions[1]).should_receive(:enabled=).with(false).once
+        flexmock(actions[2]).should_receive(:enabled=).never
+        @handler.register_action_handler(actions[0], %w[x y], :check => false){|states| m1.test states}
+        @handler.register_action_handler(actions[1], %w[x], :check => false){|states| m2.test states}
+        @handler.register_action_handler(actions[2], %w[y], :check => false){|states| m3.test states}
+        @handler.change_state 'x', true
+      end
+      
+      it 'emits the "ui_state_changed(QString, bool)" signal passing the name of the state and the value if self is a Qt::Object' do
+        m = flexmock{|mk| mk.should_receive(:state_changed).once.with('x', true)}
+        @handler.connect(SIGNAL('ui_state_changed(QString, bool)')){|state, val| m.state_changed state, val}
+        @handler.change_state 'x', 3
+      end
+      
+      it 'should not attempt to emit the "ui_state_changed" signal if self is not a Qt::Object' do
+        cls = Class.new do
+          include Ruber::GuiStatesHandler
+          def initialize
+            initialize_states_handler
+          end
+        end
+        @handler = cls.new
+        flexmock(@handler).should_receive(:emit).never
+        @handler.change_state 'x', 3
+      end
+      
+    end
+    
+    describe '#state' do
+      
+      before do
+        @handler = Object.new
+        @handler.extend Ruber::GuiStatesHandler
+        @handler.send :initialize_states_handler
+      end
+      
+      it 'returns the value of the state, after converting the name to a string' do
+        @handler.instance_variable_get(:@gui_state_handler_states)['a'] = true
+        @handler.instance_variable_get(:@gui_state_handler_states)['b'] = false
+        @handler.state('a').should be_true
+        @handler.state(:b).should be_false
+      end
+      
+      it 'returns nil if the state is not known' do
+        @handler.state('a').should be_nil
+        @handler.state(:b).should be_nil
+      end
+      
+    end
+    
+  end
+  
+end

data/spec/kde_config_option_backend_spec.rb

@@ -0,0 +1,214 @@
+require 'spec/common'
+
+require 'tmpdir'
+
+require 'ruber/kde_config_option_backend'
+
+#We need to generate a different file for each test, since otherwise the config object generated for one spec will also be used for the others (since they're KDE::SharedConfig objects)
+def generate_random_file base = "ruber_kde_config_option_backend"
+  File.join Dir.tmpdir, "#{base}-#{5.times.map{rand 10}.join}"
+end
+
+
+describe 'Ruber::KDEConfigSettingsBackend when created' do
+    
+  it 'should use the global kde config object if the constructor is called with no arguments' do
+    cfg = KDE::Config.new File.join( Dir.tmpdir, 'ruber_kde_config_option_backend'), KDE::Config::SimpleConfig
+    flexmock(KDE::Global).should_receive(:config).once.and_return cfg
+    back = Ruber::KDEConfigSettingsBackend.new
+    back.instance_variable_get(:@config).should equal(cfg)
+  end
+  
+  it 'should use a new full KDE::SharedConfig object corresponding to the path given as argument if called with one argument' do
+    filename = generate_random_file
+    back = Ruber::KDEConfigSettingsBackend.new filename
+    back.instance_variable_get(:@config).name.should == filename
+  end
+  
+  it 'should use a new KDE::SharedConfig object corresponding to the path and the mode given as arguments if called with two arguments' do
+    filename = generate_random_file
+    cfg = KDE::SharedConfig.open_config filename, KDE::Config::SimpleConfig
+    flexmock(KDE::SharedConfig).should_receive(:open_config).once.with(filename, KDE::Config::SimpleConfig).and_return cfg
+    back = Ruber::KDEConfigSettingsBackend.new filename, KDE::Config::SimpleConfig
+    back.instance_variable_get(:@config).name.should == filename
+  end
+  
+  it 'should read the "Yaml options" entry of the "Ruber Internal" group and store the result in the @yaml_options instance variable, after having converted it' do
+    filename = generate_random_file
+    File.open(filename, 'w') do |f|
+      data = <<-EOS
+[Ruber Internal]
+Yaml options=g1/o1,g1/o2,g2/o3
+      EOS
+      f.write data
+    end
+    back = Ruber::KDEConfigSettingsBackend.new filename
+    FileUtils.rm_f filename
+    back.instance_variable_get(:@yaml_options).should == [[:g1, :o1], [:g1, :o2], [:g2, :o3]]
+  end
+  
+end
+
+describe 'Ruber::KDEConfigSettingsBackend#[]' do
+  
+  before(:all) do
+    @filename = generate_random_file
+    data = <<-EOS
+[Ruber Internal]
+Yaml options=group_two/option_two,group_two/option_three
+
+[Group One]
+Option 1=test string
+Option 2=1224
+
+[Group Two]
+Option One=ab,cd,ef
+Option Two={a: b, c: :d}
+Option Three=:xyz
+    EOS
+    File.open( @filename, 'w'){|f| f.write data}
+  end
+  
+  after :all do
+    FileUtils.rm_f @filename
+  end
+  
+  it 'should return the value of option corresponding to the automatically determined human-friendly versions of the group and name of the argument' do
+    back = Ruber::KDEConfigSettingsBackend.new @filename
+    opt = OS.new({:name => :option_1, :group => :group_one, :default => ''})
+    back[opt].should == 'test string'
+    opt = OS.new({:name => :option_2, :group => :group_one, :default => 12})
+    back[opt].should == 1224
+    opt = OS.new({:name => :option_one, :group => :group_two, :default => []})
+    back[opt].should == %w[ab cd ef]
+  end
+  
+  it 'should process the string using YAML if it is included in the Yaml options list' do
+    back = Ruber::KDEConfigSettingsBackend.new @filename
+    opt = OS.new({:name => :option_two, :group => :group_two, :default => {}})
+    back[opt].should == {'a' => 'b', 'c' => :d}
+    opt = OS.new({:name => :option_three, :group => :group_two, :default => :abc})
+    back[opt].should == :xyz
+  end
+  
+  it 'should process the string using YAML if the option\'s default value isn\'t manageable using KDE::Config' do
+    back = Ruber::KDEConfigSettingsBackend.new @filename
+    opt = OS.new({:name => :option_2, :group => :group_one, :default => nil})
+    flexmock(YAML).should_receive(:load).with('1224').once.and_return 1224
+    back[opt].should == 1224
+  end
+  
+  it 'should return a deep duplicate of the default value for the option if the option isn\'t in the file' do
+    back = Ruber::KDEConfigSettingsBackend.new @filename
+    opt = OS.new({:name => :option_6, :group => :group_one, :default => {:a => 2}})
+    back[opt].should == {:a => 2}
+    back[opt].should_not equal(opt.default)
+    opt = OS.new({:name => :option_2, :group => :group_three, :default => 'hello'})
+    back[opt].should == 'hello'
+    back[opt].should_not equal(opt.default)
+    opt = OS.new({:name => :option_6, :group => :group_one, :default => {:a => %w[a b]}})
+    back[opt].should == {:a => %w[a b]}
+    back[opt].should_not equal(opt.default)
+    back[opt][:a].should_not equal(opt.default[:a])
+    opt = OS.new({:name => :option_7, :group => :group_three, :default => 3})
+    back[opt].should == 3
+  end
+  
+end
+
+describe 'Ruber::KDEConfigSettingsBackend#[]' do
+  
+#   before(:all) do
+#   end
+  
+  before do
+    @filename = generate_random_file
+    data = <<-EOS
+    [Ruber Internal]
+    Yaml options=group_two/option_two,group_two/option_three
+    
+    [Group One]
+    Option 1=test string
+    Option 2=1224
+    
+    [Group Two]
+    Option One=ab,cd,ef
+    Option Two={a: b, c: :d}
+    Option Three=:xyz
+    EOS
+    File.open( @filename, 'w'){|f| f.write data}
+    @back = Ruber::KDEConfigSettingsBackend.new @filename
+  end
+  
+  it 'should write the options which the KDE configuration system can handle' do
+    opts = {
+      OS.new({:name => :option_1, :group => :group_one, :default => ''}) => 'hello',
+      OS.new({:name => :option_one, :group => :group_two, :default => []}) => %w[x y],
+      OS.new({:name => :o1, :group => :G3, :default => 0}) => 5
+    }
+    @back.write opts
+    cfg = KDE::Config.new @filename, KDE::Config::SimpleConfig
+    cfg.group('Group One').read_entry('Option 1', '').should == 'hello'
+    cfg.group('Group Two').read_entry('Option One', []).should == %w[x y]
+    cfg.group('G3').read_entry('O1', 1).should == 5
+  end
+  
+  it 'should write the options which the KDE configuration system can\'t handle converting them to YAML and store them in the "Yaml options option"' do
+    opts = {
+      OS.new({:name => :option_3, :group => :group_one, :default => (1..2)}) => (3..5),
+      OS.new({:name => :option_two, :group => :group_two, :default => {}}) => {1 => :x},
+    }
+    @back.write opts
+    cfg = KDE::Config.new @filename, KDE::Config::SimpleConfig
+    YAML.load(cfg.group('Group One').read_entry('Option 3', '')).should == (3..5)
+    YAML.load(cfg.group('Group Two').read_entry('Option Two', '')).should == {1 => :x}
+    cfg.group('Ruber Internal').read_entry('Yaml options', []).should =~ %w[group_two/option_two group_two/option_three group_one/option_3] 
+  end
+  
+  it 'should write the options which whose value is of a different class from the default value (except for true and false) converting them to YAML and store them in the "Yaml options option"' do
+    opts = {
+      OS.new({:name => :option_3, :group => :group_one, :default => 'abc'}) => %w[a b],
+      OS.new({:name => :option_two, :group => :group_two, :default => []}) => 3,
+      OS.new({:name => :option_four, :group => :group_three, :default => true}) => false,
+      OS.new({:name => :option_five, :group => :group_three, :default => false}) => true,
+    }
+    @back.write opts
+    cfg = KDE::Config.new @filename, KDE::Config::SimpleConfig
+    YAML.load(cfg.group('Group One').read_entry('Option 3', 'abc')).should == %w[a b]
+    YAML.load(cfg.group('Group Two').read_entry('Option Two', '')).should == 3
+    cfg.group('Group Three').read_entry('Option Four', true).should == false
+    cfg.group('Group Three').read_entry('Option Five', false).should == true
+    cfg.group('Ruber Internal').read_entry('Yaml options', []).should =~ %w[group_two/option_two group_two/option_three group_one/option_3] 
+  end
+  
+  it 'should keep the options which haven\'t been explicitly written' do
+    opts = {
+      OS.new({:name => :option_1, :group => :group_one, :default => ''}) => 'hello',
+      OS.new({:name => :o1, :group => :G3, :default => 0}) => 5,
+      OS.new({:name => :o2,  :group => :G3, :default => /ab/}) => /abc/
+    }
+    @back.write opts
+    cfg = KDE::Config.new @filename, KDE::Config::SimpleConfig
+    cfg.group('Group One').read_entry('Option 2', 0).should == 1224
+    cfg.group('Group Two').read_entry('Option One', []).should == %w[ab cd ef]
+    YAML.load(cfg.group('Group Two').read_entry('Option Two', '')).should == {'a' => 'b', 'c' => :d}
+    YAML.load(cfg.group('Group Two').read_entry('Option Three', '')).should == :xyz
+    cfg.group('Ruber Internal').read_entry('Yaml options', []).should =~ %w[group_two/option_two group_two/option_three G3/o2] 
+  end
+  
+  it 'should not write options whose value is equal to their default value' do
+    opts = { 
+      OS.new({:name => :option_2, :group => :group_one, :default => 5}) => 5,
+      OS.new({:name => :option_3, :group => :group_three, :default => 'ab'}) => 'ab',
+    }
+    @back.write opts
+    cfg = KDE::Config.new @filename, KDE::Config::SimpleConfig
+    cfg.group('Group One').has_key('Option 2').should be_false
+    cfg.group('Group Three').has_key('Option 3').should be_false
+  end
+  
+  after do
+    FileUtils.rm_f @filename
+  end
+  
+end