rbindkeys 0.0.1

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+*.o
+*.so
+*.dll
+*~
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+Makefile
+_yardoc
+core
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rbindkeys.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Keiichiro Ui
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,52 @@
+# rbindkeys
+
+a key remapper, which is configurable in ruby, for Linux and X Window System
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+	gem 'rbindkeys'
+
+And then execute:
+
+	$ bundle
+
+Or install it yourself as:
+
+	$ gem install rbindkeys
+
+## Usage
+
+1. `rbindkeys -e > ~/.rbindkeys.rb`
+2. edit `~.rbindkeys.rb`
+3. select a keyboard device (see `sudo rbindkeys --evdev-list`)
+4. `sudo rbindkeys /dev/input/event2` if you selected "/dev/input/event2"
+   as a target keyboard
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## TODO
+
+* write documents and publish on rubygem.org
+* a daemonize script
+* remove @two_storoke and add PrefixBindResolver class
+* change BindResolver on input method system
+* simplify config file (e.g. `bind_key [:ctrl, :m], :enter`, `bind_key "ctrl+m", "enter"` )
+* integrate ibus controller (e.g. `bind_key "alt-grave", "toggle_ibus"` )
+* notification when active a prefix key, changing ibus status, etc..
+* the LED manipulation does not work for bluetooth devices
+* fix bug
+	* the enter key cannot be release when `rbindkey` is executed
+
+## Other Configurable Key Remappers For Linux
+
+* [x11keymacs](http://yashiromann.sakura.ne.jp/x11keymacs/index-en.html)
+* [xfumble](http://endoh-namazu.tierra.ne.jp/xfumble/)
+* [私家版 窓使いの憂鬱 Linux & Mac (Darwin) 対応版](http://www42.tok2.com/home/negidakude/)

data/Rakefile

@@ -0,0 +1,11 @@
+#!/usr/bin/env rake
+
+require "bundler/gem_tasks"
+require "rspec/core"
+require "rspec/core/rake_task"
+
+desc "Run all specs in spec/*_spec.rb"
+RSpec::Core::RakeTask.new :spec
+
+task :build => :spec
+task :default => :spec

data/bin/rbindkeys

@@ -0,0 +1,5 @@
+# -*- coding:utf-8; mode:ruby; -*-
+
+require "rbindkeys"
+
+Rbindkeys::CLI::main

data/lib/rbindkeys.rb

@@ -0,0 +1,38 @@
+# -*- coding:undecided-unix; mode:ruby; -*-
+
+require 'rubygems'
+require 'rbindkeys/version'
+require 'rbindkeys/log_utils'
+
+require 'rbindkeys/key_bind'
+require 'rbindkeys/bind_tree'
+require 'rbindkeys/observer'
+require 'rbindkeys/device'
+require 'rbindkeys/virtual_device'
+
+require 'rbindkeys/device_operator'
+require 'rbindkeys/key_event_handler'
+require 'rbindkeys/window_matcher'
+require 'rbindkeys/bind_resolver'
+require 'rbindkeys/fix_resolver'
+
+require 'rbindkeys/cli'
+
+module Rbindkeys
+
+  class BindTree; end
+  class Observer; end
+  class Devicie; end
+  class VirtualDevice; end
+
+  class DeviceOperator; end
+  class WindowMatcher; end
+  class KeyEventHandler; end
+  class BindResolver; end
+  class FixResolver; end
+
+  class CLI; end
+
+  class DuplicateNodeError < ArgumentError; end
+  class UnknownKeyValue < Exception; end
+end

data/lib/rbindkeys/bind_resolver.rb

@@ -0,0 +1,58 @@
+# -*- coding:utf-8; mode:ruby; -*-
+
+module Rbindkeys
+
+  class BindResolver
+
+    LOG = LogUtils.get_logger name
+    DEFAULT_VALUE = :through
+
+    attr_reader :tree
+
+    # delegate if cannot resolved
+    attr_reader :upper_resolver
+
+    # if this resolver is set by prefix key, then true
+    # else, false
+    attr_reader :two_stroke
+    alias :two_stroke? :two_stroke
+
+    def initialize upper_resolver=:through, two_stroke=false
+      @tree = {}
+      if upper_resolver.kind_of? Symbol
+        upper_resolver = FixResolver.instance upper_resolver
+      end
+      @upper_resolver = upper_resolver
+      @two_stroke = two_stroke
+    end
+
+    def bind input, output
+      @tree[input.last] ||= []
+      @tree[input.last].each do |b|
+        if b.input == input
+          raise DuplicateNodeError, "already this input(#{input.inspect}) was binded"
+        end
+      end
+
+      kb = KeyBind.new input, output
+      @tree[input.last] << kb # TODO implement a bubble insertion
+      @tree[input.last].sort!{|a,b| b.input.length <=> a.input.length}
+      kb
+    end
+
+    def resolve key_code, key_code_set
+      just_resolve(key_code, key_code_set) or
+        @upper_resolver.resolve(key_code, key_code_set)
+    end
+
+    def just_resolve key_code, key_code_set
+      arr = @tree[key_code]
+      arr.each do |kb|
+        sub = kb.input - key_code_set
+        sub.first == kb.input.last and
+          return kb
+      end if not arr.nil?
+      nil
+    end
+  end
+end

data/lib/rbindkeys/bind_set.rb

@@ -0,0 +1,10 @@
+# -*- coding:utf-8; mode:ruby; -*-
+
+module Rbindkeys
+
+  # BindSet is a implementation for replace with BindTree
+  # using Array#& (set intersection).
+  # because BindTree drop bind order infomation.
+  class BindSet
+  end
+end

data/lib/rbindkeys/bind_tree.rb

@@ -0,0 +1,148 @@
+# -*- coding:utf-8; mode:ruby; -*-
+
+module Rbindkeys
+  class BindTree
+
+    DEFAULT_DEFAULT_VALUE = :through
+    AVAIVABLE_DEFAULT_VALUE = [:through, :ignore]
+
+    # a tree structure which that nodes are Fixnum(keycode) and
+    # leaves are Leaf
+    attr_reader :tree
+
+    attr_reader :main_tree
+
+    # active KeyBind
+    # TODO create KeyEventHandler which exist between Observer and BindTree
+    # TODO move out @active_key_binds to KeyEventHandler
+    attr_reader :active_key_binds
+
+    # a value if no binds hit
+    attr_reader :default_value
+
+    def initialize default_value=DEFAULT_DEFAULT_VALUE
+      @tree = {}
+      @active_key_binds = []
+      if AVAIVABLE_DEFAULT_VALUE.include? default_value
+        @default_value = default_value
+      else
+        raise ArgumentError, "expect #{AVAIVABLE_DEFAULT_VALUE.join('/')}"
+      end
+    end
+
+    # register an input-output pair
+    # _input_: Array of (Array of) input keycodes
+    # _output_: Array of send keycodes or Proc
+    def bind input, output=nil
+      input = input.clone
+      new_input = []
+
+      if input.kind_of? Array and input[0].kind_of? Array
+        new_input = input
+        input = new_input.shift
+      end
+
+      tail_code = input.pop
+      input.sort!
+
+      subtree = @tree
+      input.each do |code|
+        if subtree.has_key? code and (not subtree[code].kind_of? Hash)
+          raise DuplicateNodeError, "already register an input:#{input}"
+        end
+        subtree[code] ||= {}
+        subtree = subtree[code]
+      end
+
+      if not new_input.empty?
+        if subtree.has_key?(tail_code) and
+            not (subtree[tail_code].kind_of?(Leaf) and
+                 subtree[tail_code].payload.kind_of?(BindTree))
+          raise DuplicateNodeError, "already register an input:#{input}"
+        end
+
+        if new_input.length == 1
+          new_input = new_input.first
+        end
+
+        subtree[tail_code] ||= Leaf.new BindTree.new :ignore
+        subtree[tail_code].payload.bind new_input, output
+
+      elsif subtree.has_key? tail_code
+        raise DuplicateNodeError, "already register an input:#{input}"
+
+      else
+        subtree[tail_code] = Leaf.new KeyBind.new input.push(tail_code), output
+      end
+    end
+
+    # called when event.value == 0
+    def resolve_for_released_event event, pressed_keys
+      release_binds = []
+      @active_key_binds.reject! do |key_bind|
+        if key_bind.input.include? event.code
+          release_binds << key_bind
+          true
+        else
+          false
+        end
+      end
+
+      if release_binds.empty?
+        :through
+      else
+        release_binds
+      end
+    end
+
+    # called when event.value == 1
+    def resolve_for_pressed_event event, pressed_keys
+      subtree = @tree
+      last_code = -1
+      pressed_keys.each do |code|
+        if last_code >= code
+          raise ArgumentError, "expect a sorted Array for 2nd arg (pressed_keys)"
+        end
+        last_code = code
+
+        if subtree.has_key? code
+          subtree = subtree[code]
+        end
+      end
+
+      subtree = (subtree.kind_of?(Hash) and subtree[event.code])
+
+      if not subtree or subtree.kind_of? Hash
+        return @default_value
+      elsif subtree.kind_of? Leaf
+        if subtree.payload.kind_of? KeyBind
+          @active_key_binds << subtree.payload
+          return subtree.payload
+        elsif subtree.payload.kind_of? BindTree
+          return subtree.payload
+        end
+      else
+        raise UnexpecedLeafError, "unexpeced Leaf: #{subtree.inspect}"
+      end
+    end
+
+    # called when event.value == 2
+    def resolve_for_pressing_event event, pressed_keys
+      if @active_key_binds.empty?
+        @default_value
+      else
+        @active_key_binds
+      end
+    end
+
+    class Leaf
+      attr_reader :payload
+
+      def initialize payload
+        @payload = payload
+      end
+    end
+
+    class UnexpecedLeafError < RuntimeError; end
+  end
+end

data/lib/rbindkeys/cli.rb

@@ -0,0 +1,103 @@
+# -*- coding:utf-8; mode:ruby; -*-
+
+module Rbindkeys
+
+  SUMMARY = 'key remapper for Linux which is configured in ruby'
+
+  # a class is executed by bin/rbindkeys
+  class CLI
+
+    EVDEVS = '/dev/input/event*'
+
+    class << self
+      require 'optparse'
+
+      # if @@cmd == :observe then CLI excecute to observe a given event device
+      # else if @@cmd == :ls then CLI list event devices
+      # (default: :observe)
+      @@cmd = :observe
+      def cmd; @@cmd end
+
+      # a location of a config file (default: "~/.rbindkeys.rb")
+      @@config = "#{ENV['HOME']}/.rbindkeys.rb"
+      def config; @@config end
+
+      @@usage = SUMMARY
+
+      def main
+        begin
+          parse_opt
+        rescue OptionParser::ParseError => e
+          puts "ERROR #{e.to_s}"
+          err
+        end
+
+        method(@@cmd).call
+      end
+
+      def err code=1
+        puts @@usage
+        exit code
+      end
+
+      def parse_opt
+        opt = OptionParser.new <<BANNER
+#{SUMMARY}
+Usage: sudo #{$0} [--config file] #{EVDEVS}
+   or: sudo #{$0} --evdev-list
+BANNER
+        opt.version = VERSION
+        opt.on '-l', '--evdev-list', 'a list of event devices' do
+          @@cmd = :ls
+        end
+        opt.on '-c VAL', '--config VAL', 'specifying your configure file' do |v|
+          @@config = v
+        end
+        opt.on '-e', '--print-example', 'print an example config' do |v|
+          @@cmd = :print_example
+        end
+
+        opt.parse! ARGV
+
+        @@usage = opt.help
+      end
+
+      def observe
+        if ARGV.length != 1
+          puts 'ERROR invalid arguments'
+          err
+        end
+        evdev = ARGV.first
+        Observer.new(@@config, evdev).start
+      end
+
+      def ls
+        require 'revdev'
+        Dir::glob(EVDEVS).sort do |a,b|
+          am = a.match(/[0-9]+$/)
+          bm = b.match(/[0-9]+$/)
+          ai = am[0] ? am[0].to_i : 0
+          bi = bm[0] ? bm[0].to_i : 0
+          ai <=> bi
+        end.each do |f|
+          begin
+            e = Revdev::EventDevice.new f
+            puts "#{f}:	#{e.device_name} (#{e.device_id.hr_bustype})"
+          rescue => ex
+            puts ex
+          end
+        end
+      end
+
+      def print_example
+        dir = File.dirname File.expand_path __FILE__
+        dir = File.expand_path File.join dir, '..', '..', 'sample'
+        file = File.join dir, 'emacs.rb'
+        IO.foreach file do |line|
+          puts "# #{line}"
+        end
+      end
+
+    end
+  end # of class Runner
+end