rbindkeys 0.0.1

data/spec/bind_tree_bind_spec.rb

@@ -0,0 +1,48 @@
+# -*- coding:utf-8; mode:ruby; -*-
+
+require 'rbindkeys'
+
+include Rbindkeys
+
+describe BindTree do
+  context "normal" do
+    describe 'BindTree#bind' do
+      before do
+        @bt = BindTree.new
+      end
+
+      context 'with valid input/output' do
+        it "should construct expected tree" do
+          input = [1,2]
+          @bt.bind input, [2,3]
+          input.should == [1,2] # should not destroyable
+          @bt.bind [1,0], [2,3]
+          @bt.bind [2], [2,4]
+          @bt.tree[1][2].payload.output.should == [2,3]
+          @bt.tree[1][0].payload.output.should == [2,3]
+          @bt.tree[2].payload.output.should == [2,4]
+        end
+      end
+      context 'with duplicate node input' do
+        it "should raise DuplicateNodeError" do
+          @bt.bind [1,2], [2,3]
+          begin
+            @bt.bind [1,2], [2,4]
+            violated "should raise"
+          rescue => e
+            e.class.should == BindTree::DuplicateNodeError
+          end
+        end
+        it "should raise DuplicateNodeError" do
+          @bt.bind [1,2], [2,3]
+          begin
+            @bt.bind [1,2,6], [2,4]
+            violated "should raise"
+          rescue => e
+            e.class.should == BindTree::DuplicateNodeError
+          end
+        end
+      end
+    end # describe
+  end # context
+end # describe

data/spec/bind_tree_resolve_for_pressed_event_spec.rb

@@ -0,0 +1,74 @@
+# -*- coding:utf-8; mode:ruby; -*-
+
+require 'rbindkeys'
+
+include Rbindkeys
+
+describe BindTree do
+  context "BindTree constracted" do
+    before do
+      @bt = BindTree.new
+      @bt.bind [1,2,3], [4,5,6]
+      @bt.bind [1,2,0], [6]
+      @bt.bind [1,3], [5,6]
+      @bt.bind [1,10,0], [55]
+      @bt.bind [2], [2]
+      @bt.bind [[4],[5]], [6]
+    end
+
+    describe "BindTree#resolve_for_pressed_event" do
+      before do
+        @ev = Revdev::InputEvent.new nil, Revdev::EV_KEY, 0, 1
+      end
+      context "with unsorted pressed keys" do
+        it "should rase" do
+          begin
+            @bt.resolve_for_pressed_event(@ev, [2, 1])
+            violated "should raise"
+          rescue => e
+          end
+        end
+      end
+      context "with binded pressed keys" do
+        it "should return Arrays and pressing_binds added" do
+          @ev.code = 0
+          @bt.resolve_for_pressed_event(@ev, [1,2]).output.should == [6]
+          expected_pressing_binds = [1, 2, @ev.code]
+          @bt.active_key_binds[0].input.should == expected_pressing_binds
+
+          @ev.code = 2
+          @bt.resolve_for_pressed_event(@ev, []).output.should == [2]
+          expected_pressing_binds = [@ev.code]
+          @bt.active_key_binds[1].input.should == expected_pressing_binds
+        end
+      end
+      context "with no binded pressed keys" do
+        it "should return nil" do
+          @ev.code = 5
+          @bt.resolve_for_pressed_event(@ev, []).should == @bt.default_value
+          @bt.resolve_for_pressed_event(@ev, [1]).should == @bt.default_value
+          @ev.code = 1
+          @bt.resolve_for_pressed_event(@ev, []).should == @bt.default_value
+        end
+      end
+      context "with pressed keys as super set of binded keys" do
+        it "should return Arrays" do
+          @ev.code = 0
+          @bt.resolve_for_pressed_event(@ev, [1,2,4,5]).output.should == [6]
+          @bt.resolve_for_pressed_event(@ev, [1,4,5,10]).output.should == [55]
+        end
+      end
+      context "with 2 stroke keybind" do
+        it "should return Arrays" do
+          @ev.code = 4
+          tree = @bt.resolve_for_pressed_event(@ev, [])
+          tree.class.should == BindTree
+          p tree.tree
+
+          @ev.code = 5
+          tree.resolve_for_pressed_event(@ev, []).output.should == [6]
+        end
+      end
+    end
+  end # context
+end # describe

data/spec/bind_tree_resolve_for_released_event_spec.rb

@@ -0,0 +1,63 @@
+# -*- coding:utf-8; mode:ruby; -*-
+
+require 'rbindkeys'
+
+include Rbindkeys
+
+describe BindTree do
+  describe '#resolve_for_released_event' do
+    before do
+      @bt = BindTree.new
+      @kb = []
+      @kb << KeyBind.new([1,2,3], [4,5,6])
+      @kb << KeyBind.new([1,2,0], [6])
+      @kb.each do |kb|
+        @bt.bind kb.input, kb.output
+      end
+    end
+    context "no pressed binds" do
+      before do
+        @ev = Revdev::InputEvent.new nil, Revdev::EV_KEY, 0, 0
+      end
+      it "'s pressed_binds should have empty" do
+        @bt.active_key_binds.should be_empty
+        @bt.resolve_for_pressed_event(@ev, []).should == @bt.default_value
+        @bt.active_key_binds.should be_empty
+      end
+    end
+    context "a pressed bind" do
+      before do
+        ev = Revdev::InputEvent.new nil, Revdev::EV_KEY, 0, 1
+        @bt.resolve_for_pressed_event ev, [1,2,4]
+        @ev = Revdev::InputEvent.new nil, Revdev::EV_KEY, 0, 0
+      end
+      it "'s pressed_binds should empty" do
+        @bt.active_key_binds.size.should == 1
+        @bt.resolve_for_released_event(@ev, [])[0].output.should == [6]
+        @bt.active_key_binds.should be_empty
+      end
+    end
+    context "two pressed binds" do
+      before do
+        ev = Revdev::InputEvent.new nil, Revdev::EV_KEY, 0, 1
+        @bt.resolve_for_pressed_event ev, [1,2,4]
+        ev = Revdev::InputEvent.new nil, Revdev::EV_KEY, 3, 1
+        @bt.resolve_for_pressed_event ev, [1,2,4]
+        @ev = Revdev::InputEvent.new nil, Revdev::EV_KEY, 0, 0
+      end
+      it "'s pressed_binds should decrease" do
+        @bt.active_key_binds.length.should == 2
+        @bt.resolve_for_released_event(@ev, [])
+        @bt.active_key_binds.length.should == 1
+        @ev.code = 3
+        @bt.resolve_for_released_event(@ev, [])
+        @bt.active_key_binds.should be_empty
+      end
+      it "'s pressed_binds should empty" do
+        @ev.code = 1
+        @bt.resolve_for_released_event(@ev, []).length.should == 2
+        @bt.active_key_binds.should be_empty
+      end
+    end
+  end
+end

data/spec/cli_spec.rb

@@ -0,0 +1,81 @@
+# -*- coding:utf-8; mode:ruby; -*-
+
+require 'rbindkeys'
+require 'revdev'
+
+include Rbindkeys
+
+describe CLI do
+  describe '#.main' do
+    context ', when ARGV is empty,' do
+      before do
+        @stdout = StringIO.new
+        # stub(STDOUT){@stdout}
+        ARGV = []
+      end
+      it 'shoud exit with code 1' do
+        expect { CLI::main }.to raise_error do |e|
+          e.should be_a SystemExit
+          e.status.should == 1
+        end
+      end
+    end
+    context ', when ARGV have an argument,' do
+      before do
+        ARGV = ['foo']
+        @observer = mock Observer
+        Observer.should_receive(:new){@observer}
+        @observer.should_receive(:start){nil}
+      end
+      it 'should call Observer#new#start' do
+        config = CLI::config
+        CLI::main
+        CLI::config.should == config
+      end
+    end
+    context ', when ARGV have an invalid option (--config),' do
+      before do
+        ARGV = ['--config']
+      end
+      it 'should exit with code 1' do
+        expect { CLI::main }.to raise_error do |e|
+          e.should be_a SystemExit
+          e.status.should == 1
+        end
+      end
+    end
+    context ', when ARGV have an option (--config) and an event device,' do
+      before do
+        @config = 'a_config_file'
+        ARGV = ['--config', @config,'foodev']
+        @observer = mock Observer
+        Observer.should_receive(:new){@observer}
+        @observer.should_receive(:start){nil}
+      end
+      it 'should call Observer#new#start ' do
+        CLI::main
+        CLI::config.should == @config
+      end
+    end
+    context ', when ARGV have an option (--evdev-list),' do
+      before do
+        ARGV = ['--evdev-list']
+        @evdev = mock Revdev::EventDevice
+        @id = mock Object
+        @evdev.stub(:device_name){"foo"}
+        @evdev.stub(:device_id){@id}
+        @id.stub(:hr_bustype){'bar'}
+        Revdev::EventDevice.stub(:new){@evdev}
+        Dir.should_receive(:glob).with(CLI::EVDEVS).
+          and_return(['/dev/input/event4','/dev/input/event2',
+                      '/dev/input/event13'])
+        # @stdout = StringIO.new
+        # $stdout = @stdout
+      end
+      it 'should pring device info' do
+        CLI::main
+        # @stdout.string.should match(%r!^/dev/input/event2!)
+      end
+    end
+  end
+end

data/spec/device_operator_spec.rb

@@ -0,0 +1,57 @@
+# -*- coding:utf-8; mode:ruby; -*-
+
+require 'rbindkeys'
+require 'revdev'
+
+include Rbindkeys
+
+describe DeviceOperator do
+  before do
+    @dev = mock Device
+    @vdev = mock VirtualDevice
+    @operator = DeviceOperator.new @dev, @vdev
+  end
+
+  describe "#send_key" do
+    context "with a code and a press value" do
+      before do
+        @code = 10
+        @value = 1
+      end
+      it "should call #send_event" do
+        @operator.should_receive(:send_event).with(Revdev::EV_KEY,@code,@value)
+        @operator.send_key @code, @value
+      end
+    end
+  end
+
+  context "#send_event" do
+    context "with normal values" do
+      before do
+        @type = Revdev::EV_KEY
+        @code = 10
+        @value = 1
+      end
+      it "should send a #write_input_event to @vdev" do
+        @vdev.should_receive(:write_input_event) do |ie|
+          ie.code.should == @code
+          10
+        end
+        @operator.send_event @type, @code, @value
+      end
+    end
+    context "with an input event" do
+      before do
+        @ie = Revdev::InputEvent.new nil, Revdev::EV_KEY, 10, 1
+      end
+      it "should send a #write_input_event to @vdev" do
+        @vdev.should_receive(:write_input_event) do |ie|
+          ie.should == @ie
+          10
+        end
+        @operator.send_event @ie
+      end
+    end
+  end
+
+end

data/spec/fix_resolver_spec.rb

@@ -0,0 +1,57 @@
+# -*- coding:utf-8; mode:ruby; -*-
+
+require 'rbindkeys'
+
+include Rbindkeys
+
+describe FixResolver do
+
+  describe ".instance" do
+    context "with different value" do
+      it "should return different instances" do
+        f = FixResolver.instance :foo
+        g = FixResolver.instance :bar
+        f.equal?(g).should be_false
+      end
+      it "should return different instances" do
+        f = FixResolver.instance :foo
+        g = FixResolver.instance :foo
+        f.equal?(g).should be_true
+      end
+    end
+  end
+
+  describe '.new' do
+    context 'with any arg' do
+      it 'should raise an exception' do
+        lambda{FixResolver.new}.should raise_error
+        lambda{FixResolver.new :foo}.should raise_error
+      end
+    end
+  end
+
+  describe '#bind' do
+    before do
+      @resolver = FixResolver.instance :foo
+    end
+    context 'with any args' do
+      it 'should raise an exception' do
+        lambda{@resolver.bind 1, 2}.should raise_error
+        lambda{@resolver.bind [], []}.should raise_error
+      end
+    end
+  end
+
+  describe '#resolve' do
+    before do
+      @resolver = FixResolver.instance :foo
+    end
+    context 'with any args' do
+      it 'should return :foo' do
+        @resolver.resolve(1, []).should == :foo
+        @resolver.resolve(3, [1,2]).should == :foo
+      end
+    end
+  end
+
+end

data/spec/key_event_handler/configurer_spec.rb

@@ -0,0 +1,201 @@
+# -*- coding:utf-8; mode:ruby; -*-
+
+require 'rbindkeys'
+require 'fileutils'
+require 'revdev'
+
+include Rbindkeys
+
+$tmp_dir = 'tmp'
+
+describe KeyEventHandler do
+  before :all do
+    FileUtils.mkdir $tmp_dir
+  end
+
+  after :all do
+    FileUtils.rm_r $tmp_dir
+  end
+
+  before do
+    @ope = mock DeviceOperator
+  end
+
+  describe "bind keys methods" do
+
+    before do
+      @defval = :hoge
+      @bind_set = []
+      @res = mock Rbindkeys::BindResolver
+
+      # define stubs
+      @res.stub(:bind) do |i, o|
+        @bind_set << [i, o]
+      end
+      @res.stub(:resolve) do |input, pressed_key_set|
+        if input == 10
+          BindResolver.new
+        else
+          @defval
+        end
+      end
+      @res.stub(:just_resolve) do |input, pressed_key_set|
+        if input == 10
+          BindResolver.new
+        else
+          nil
+        end
+      end
+      @res.stub(:kind_of?) do |klass|
+        klass == Rbindkeys::BindResolver
+      end
+      Rbindkeys::BindResolver.stub!(:new).and_return(@res)
+
+      @handler = KeyEventHandler.new @ope
+    end
+
+    describe KeyEventHandler, "#pre_bind_key" do
+      context "with a bind" do
+        it "map the bind to @pre_bind_resolver" do
+          @handler.pre_bind_key 1, 0
+          @handler.pre_bind_resolver[1].should == 0
+        end
+      end
+      context "with duplicated binds" do
+        it "should raise a DuplicatedNodeError" do
+          @handler.pre_bind_key 1, 0
+          lambda{ @handler.pre_bind_key(1, 2) }.should raise_error(DuplicateNodeError)
+        end
+      end
+    end
+
+    describe KeyEventHandler, "#bind_key" do
+      context "with two Fixnum" do
+        it "construct @bind_set" do
+          @handler.bind_key 0, 1
+          @bind_set.should == [[[0],[1]]]
+        end
+      end
+      context "with two Arrays" do
+        it "construct @bind_set" do
+          @handler.bind_key [0, 1], [2, 3]
+          @bind_set.should == [[[0, 1], [2, 3]]]
+        end
+      end
+      context "with an Array and a KeyResolver" do
+        it "construct @bind_set" do
+          @handler.bind_key [0,1], @res
+          @bind_set.should == [[[0,1], @res]]
+        end
+      end
+      context "with an Array and a block" do
+        it "construct @bind_set" do
+          @handler.bind_key [0,1] do
+            p 'foo'
+          end
+          @bind_set.first[1].class.should == Proc
+        end
+      end
+      context "with mix classes" do
+        it "construct @bind_set" do
+          @handler.bind_key 1, [2, 3]
+          @handler.bind_key [2, 3], 4
+          @bind_set.should == [[[1], [2, 3]], [[2, 3], [4]]]
+        end
+      end
+      context "with invalid args" do
+        it "raise some error" do
+          lambda{@handler.bind_key [1], [[[2]]]}.should raise_error
+        end
+      end
+    end
+
+    describe KeyEventHandler, "#bind_prefix_key" do
+      context "with a new prefix key" do
+        it "construct @bind_set" do
+          @handler.bind_prefix_key [0,1] do
+            @handler.bind_key 2, 3
+          end
+          @bind_set.length.should == 2
+          @bind_set.include?([[2],[3]]).should be_true
+        end
+      end
+      context "with a existing prefix key" do
+        it "should construct @bind_set" do
+          @handler.bind_prefix_key [0,10] do
+            @handler.bind_key 2, 3
+          end
+          @bind_set.length.should == 1
+          @bind_set.include?([[2],[3]]).should be_true
+        end
+      end
+    end
+
+    describe KeyEventHandler, "#window" do
+      context 'with invalid arg' do
+        it 'should raise ArgumentError' do
+          lambda { @handler.window(nil, "foo") }.should raise_error
+          lambda { @handler.window(nil, :class => "bar") }.should raise_error
+        end
+      end
+      context 'with nil and a regex' do
+        it 'should return the BindResolver and added it to @window_bind_resolver_map' do
+          size = @handler.window_bind_resolver_map.size
+          res = @handler.window(nil, /foo/)
+          res.should be_a BindResolver
+          (@handler.window_bind_resolver_map.size - size).should == 1
+          p '--------------'
+          Hash[*@handler.window_bind_resolver_map.flatten].value?(res).should be_true
+        end
+      end
+      context 'with nil and a Hash having :class key' do
+        it 'should return the BindResolver and added it to @window_bind_resolver_map' do
+          size = @handler.window_bind_resolver_map.size
+          res = @handler.window(nil, :class => /foo/)
+          res.should be_a BindResolver
+          (@handler.window_bind_resolver_map.size - size).should == 1
+          Hash[*@handler.window_bind_resolver_map.flatten].value?(res).should be_true
+        end
+      end
+      context 'with a BindResolver and a regex' do
+        before do
+          @arg_resolver = mock BindResolver
+          @arg_resolver.stub(:kind_of?).and_return(false)
+          @arg_resolver.stub(:kind_of?).with(BindResolver).and_return(true)
+        end
+        it 'should return the BindResolver and added it to @window_bind_resolver_map' do
+          size = @handler.window_bind_resolver_map.size
+          res = @handler.window(@arg_resolver, /foo/)
+          res.should be_a BindResolver
+          (@handler.window_bind_resolver_map.size - size).should == 1
+          Hash[*@handler.window_bind_resolver_map.flatten].value?(res).should be_true
+        end
+      end
+    end
+
+    describe "KeyEventHandler#load_config" do
+      before :all do
+        @config = File.join $tmp_dir, 'config'
+        open @config, 'w' do |f|
+          f.write <<-EOF
+pre_bind_key KEY_CAPSLOCK, KEY_LEFTCTRL
+bind_key [KEY_LEFTCTRL,KEY_F], KEY_RIGHT
+bind_key [KEY_LEFTCTRL,KEY_W], [KEY_LEFTCTRL,KEY_X]
+bind_prefix_key [KEY_LEFTCTRL,KEY_X] do
+  bind_key KEY_K, [KEY_LEFTCTRL, KEY_W]
+end
+EOF
+        end
+      end
+      it "construct @pre_bind_key_set and @bind_key_set" do
+        @handler.load_config @config
+        @handler.pre_bind_resolver.size.should == 1
+        @bind_set.length.should == 4
+        @bind_set[0][1].should == [Revdev::KEY_RIGHT]
+        @bind_set[1][1].should == [Revdev::KEY_LEFTCTRL, Revdev::KEY_X]
+        @bind_set[2][1].should == @res
+        @bind_set[3][1].should == [Revdev::KEY_LEFTCTRL, Revdev::KEY_W]
+      end
+    end
+  end
+end