karabiner 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 54eca927143367b5272357cf58664363593c5b9b
+  data.tar.gz: 0bdcaaaee69fa945cab5e71d29d1b53b890c783f
+SHA512:
+  metadata.gz: 6d6370cb2fdead72745f722f9948bd5a9014e226cb12959d8aba50ba7f37f302008475f101dcfa1d6a76622d92a66daef78b364ec8a6f3849e772371d2edb59c
+  data.tar.gz: 0004cc00131dec168743bd19b4dd297960d9230fab516f9575e474692050c69af437c53520704fc2ad84f35ddf5bf1ac8523fed260f008ac9b1a6138efadd16c

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1 @@
+-c

data/.travis.yml

@@ -0,0 +1,7 @@
+rvm:
+- 2.1.2
+branches:
+  only:
+    - master
+script:
+  - 'bundle exec rspec .'

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Takashi Kokubun
+
+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,122 @@
+# Karabiner DSL [![Build Status](https://travis-ci.org/k0kubun/karabiner-dsl.png?branch=master)](https://travis-ci.org/k0kubun/karabiner-dsl)
+
+Lightweight keyremap configuration DSL for [Karabiner](https://pqrs.org/osx/karabiner/index.html.en)
+
+## Why Karabiner DSL?
+
+Original [Karabiner's configuration](https://pqrs.org/osx/karabiner/xml.html.ja) is very hard to write.  
+Karabiner DSL is its wrapper, which is easy-to-write and readable.  
+  
+If you write Karabiner's config with Karabiner DSL, you can update your keyremap configuration quickly.
+
+## Installation
+
+First of all, you have to install [Karabiner](https://pqrs.org/osx/karabiner/index.html.en).
+Karabiner is a keyboard remap utility for Mac OSX.  
+  
+Then execute:
+
+```bash
+$ gem install karabiner
+```
+
+Then `karabiner` executable will be installed.
+This gem provides only `karabiner dsl` subcommand and other subcommands are delegated to original CLI for Karabiner.app.
+
+## Usage
+### 1. Create ~/.karabiner
+
+```rb
+item "Command+G to open Google Chrome" do
+  remap "Cmd-g", to: invoke("Google Chrome")
+end
+```
+
+### 2. Execute karabiner dsl command
+
+```bash
+$ karabiner dsl
+```
+
+Then `karabiner dsl` will update Karabiner's config as you expected.
+
+![](https://raw.githubusercontent.com/k0kubun/karabiner-dsl/master/img/disabled.png)
+
+### 3. Enable your favorite configurations
+
+![](https://raw.githubusercontent.com/k0kubun/karabiner-dsl/master/img/enabled.png)
+
+Enjoy!
+
+## How to write ~/.karabiner
+### Basics
+
+karabiner-dsl's DSL is a superset of Ruby.  
+So you can use any Ruby methods in ~/.karabiner.
+
+#### item
+
+```rb
+item "configuration unit" do
+  ...
+end
+```
+
+In karabiner-dsl, any Karabiner's configuration unit is expressed in `item` and its `do ~ end` block.  
+You can group some remap configurations in one item and enable them in one click.
+
+#### remap
+
+```rb
+item "remap example" do
+  remap "Cmd-a", to: "C-a"
+end
+```
+
+If you want to add remap configuration, you have to call `remap` method.  
+In this example, Command+A will be remapped to Control+A.  
+  
+You have to write "key expression" to specify keys to remap.
+
+#### key expression
+
+- `a`, `A`, `1`, `;`, `tab`, `Tab`, `space`, `up`, `down`
+  - any string without `-` will be regarded as single key
+  - ignore upcase or downcase
+- `C-a`, `Ctrl-a`
+  - regarded as Control + A
+  - `C-` is a short expression of `Ctrl-`
+- `M-a`, `Opt-a`
+  - regarded as Option + A
+- `Shift-a`
+  - regarded as large A
+  - if you write just `A`, it will be regarded as small a
+- `Cmd-a`
+  - regarded as Command + A
+- `Cmd-Shift-a`
+  - regarded as Command + Shift + A
+  - you can use any combination of Ctrl, Opt, Shift, Cmd
+
+#### available single keys
+
+```
+a b c ... x y z
+0 1 2 ... 7 8 9
+F1 F2 ... F11 F12
+\ [ ] ; ' , . / - =
+Up Down Right Left
+space tab delete forward_delete capslock
+
+Ctrl_R  Ctrl_L
+Opt_R   Opt_L
+Cmd_R   Cmd_L
+Shift_R Shift_L
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/k0kubun/karabiner-dsl/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+
+task :spec do
+  system("bundle exec rspec")
+end
+
+task default: :spec

data/bin/karabiner

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+
+if [ $@ == "dsl" ]; then
+  bin_dir=$(cd $(dirname $0); pwd)
+  ${bin_dir}/karabiner-dsl
+else
+  /Applications/Karabiner.app/Contents/Library/bin/karabiner $@
+fi

data/bin/karabiner-dsl

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+lib = File.dirname(__FILE__) + "/../lib"
+$:.unshift lib unless $:.include? lib
+
+require "karabiner"
+
+DOTFILE_PATH = File.expand_path("~/.karabiner")
+
+karabiner = Karabiner.new(DOTFILE_PATH)
+karabiner.apply_configuration

data/dotremap.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'karabiner/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "karabiner"
+  spec.version       = Karabiner::VERSION
+  spec.authors       = ["Takashi Kokubun"]
+  spec.email         = ["takashikkbn@gmail.com"]
+  spec.summary       = %q{Lightweight keyremap configuration DSL}
+  spec.description   = %q{Lightweight keyremap configuration DSL for Karabiner}
+  spec.homepage      = "https://github.com/k0kubun/karabiner-dsl"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake", "~> 10.3.2"
+  spec.add_development_dependency "rspec", "~> 3.0.0"
+  spec.add_development_dependency "pry"
+  spec.add_dependency 'unindent', '~> 1.0'
+end

data/lib/karabiner/appdef.rb

@@ -0,0 +1,23 @@
+require "karabiner/xml_tree"
+
+class Karabiner::Appdef
+  include Karabiner::XmlTree
+
+  AVAILABLE_OPTIONS = %i(
+    equal
+    prefix
+    suffix
+  ).freeze
+
+  def initialize(appname, options)
+    property = Karabiner::Property.new("appname", appname)
+    add_child(property)
+
+    options.each do |option, value|
+      raise "Unavailable option: #{property}" unless AVAILABLE_OPTIONS.include?(option)
+
+      property = Karabiner::Property.new(option, value)
+      add_child(property)
+    end
+  end
+end

data/lib/karabiner/cli.rb

@@ -0,0 +1,25 @@
+require "karabiner/namespace"
+
+module Karabiner::CLI
+  CLI_PATH = "/Applications/Karabiner.app/Contents/Library/bin/karabiner"
+
+  def self.reload_xml
+    system("#{CLI_PATH} reloadxml")
+  end
+
+  def self.current_config
+    changed = `#{CLI_PATH} changed`
+    config_by_changed(changed)
+  end
+
+  private
+
+  def self.config_by_changed(changed)
+    config = {}
+    changed.each_line do |line|
+      property, value = line.strip.split("=")
+      config[property] = value
+    end
+    config
+  end
+end

data/lib/karabiner/config.rb

@@ -0,0 +1,15 @@
+require "forwardable"
+require "karabiner/namespace"
+
+class Karabiner::Config
+  extend Forwardable
+
+  def_delegator :@parent, :item
+  def_delegator :@parent, :group
+
+  def initialize(name)
+    @name = name
+  end
+
+  attr_writer :parent
+end

data/lib/karabiner/dsl/group.rb

@@ -0,0 +1,10 @@
+require "karabiner/namespace"
+require "karabiner/item"
+
+module Karabiner::DSL::Group
+  def item(name = nil, options = {}, &block)
+    item = Karabiner::Item.new(name, options)
+    item.instance_exec(&block)
+    add_child(item)
+  end
+end

data/lib/karabiner/dsl/item.rb

@@ -0,0 +1,38 @@
+require "karabiner/namespace"
+require "karabiner/property"
+require "karabiner/remap"
+require "karabiner/invoke_history"
+
+module Karabiner::DSL::Item
+  AVAILABLE_PROPERTIES = %i(
+    name
+    identifier
+    autogen
+  ).freeze
+
+  def remap(target, options = {})
+    remap = Karabiner::Remap.new(target, options[:to])
+    add_child(remap)
+  end
+
+  def show_message(message)
+    property = Karabiner::Property.new("autogen", "__ShowStatusMessage__ #{message}")
+    add_child(property)
+  end
+
+  def invoke(application)
+    Karabiner::InvokeHistory.register(application)
+    "VK_OPEN_URL_APP_#{application.gsub(/ /, '_')}"
+  end
+
+  private
+
+  def method_missing(property, value = '', options = {})
+    if AVAILABLE_PROPERTIES.include?(property)
+      property = Karabiner::Property.new(property, value, options)
+      add_child(property)
+    else
+      super
+    end
+  end
+end

data/lib/karabiner/dsl/root.rb

@@ -0,0 +1,28 @@
+require "karabiner/namespace"
+require "karabiner/appdef"
+require "karabiner/config"
+require "karabiner/item"
+require "karabiner/group"
+require "karabiner/dsl/group"
+
+module Karabiner::DSL::Root
+  include Karabiner::DSL::Group
+
+  def group(name, &block)
+    group = Karabiner::Group.new(name)
+    group.instance_exec(&block)
+    add_child(group)
+  end
+
+  def config(name, &block)
+    config = Karabiner::Config.new(name)
+    config.parent = self
+    config.instance_exec(&block)
+    add_config(config)
+  end
+
+  def appdef(appname = '', options = {})
+    appdef = Karabiner::Appdef.new(appname, options)
+    add_child(appdef)
+  end
+end

data/lib/karabiner/group.rb

@@ -0,0 +1,16 @@
+require "forwardable"
+require "karabiner/namespace"
+require "karabiner/dsl/group"
+
+class Karabiner::Group
+  extend Forwardable
+  include Karabiner::XmlTree
+  include Karabiner::DSL::Group
+
+  def_delegator :@item, :to_xml
+  def_delegator :@item, :add_child
+
+  def initialize(name)
+    @item = Karabiner::Item.new(name, skip_identifier: true)
+  end
+end

data/lib/karabiner/invoke_history.rb

@@ -0,0 +1,16 @@
+require "set"
+require "karabiner/vkopenurldef"
+
+module Karabiner::InvokeHistory
+  def self.clear_histroy
+    @@registered_applications = Set.new
+  end
+
+  def self.register(application)
+    registered_applications.add(application)
+  end
+
+  def self.registered_applications
+    @@registered_applications ||= Set.new
+  end
+end

data/lib/karabiner/item.rb

@@ -0,0 +1,54 @@
+require "karabiner/dsl/item"
+require "karabiner/xml_tree"
+
+class Karabiner::Item
+  include Karabiner::XmlTree
+  include Karabiner::DSL::Item
+
+  AVAILABLE_OPTIONS = %i(
+    not
+    only
+    config_not
+    config_only
+  ).freeze
+
+  def initialize(name, options = {})
+    @skip_identifier = options.delete(:skip_identifier)
+
+    if name
+      property = Karabiner::Property.new("name", name)
+      add_child(property)
+    end
+
+    options.each do |option, value|
+      raise "Unavailable option: #{option}" unless AVAILABLE_OPTIONS.include?(option)
+
+      property = Karabiner::Property.new(option, value)
+      add_child(property)
+    end
+  end
+
+  def to_xml
+    validate_name_existence
+    generate_identifier unless @skip_identifier
+
+    super
+  end
+
+  private
+
+  def validate_name_existence
+    properties = search_childs(Karabiner::Property)
+    raise "Name property does not exist" unless properties.map(&:attr).include?("name")
+  end
+
+  def generate_identifier
+    properties = search_childs(Karabiner::Property)
+    return if properties.map(&:attr).include?("identifier")
+
+    name = properties.find { |p| p.attr == "name" }
+    generated_identifier = name.value.gsub(/[^a-zA-Z]/, "_").downcase
+    identifier = Karabiner::Property.new("identifier", "remap.#{generated_identifier}")
+    childs[1, 0] = identifier
+  end
+end

data/lib/karabiner/key.rb

@@ -0,0 +1,85 @@
+class Karabiner::Key
+  KEYCODE_MAP = {
+    "0"      => "KEY_0",
+    "1"      => "KEY_1",
+    "2"      => "KEY_2",
+    "3"      => "KEY_3",
+    "4"      => "KEY_4",
+    "5"      => "KEY_5",
+    "6"      => "KEY_6",
+    "7"      => "KEY_7",
+    "8"      => "KEY_8",
+    "9"      => "KEY_9",
+    "Up"     => "CURSOR_UP",
+    "Down"   => "CURSOR_DOWN",
+    "Right"  => "CURSOR_RIGHT",
+    "Left"   => "CURSOR_LEFT",
+    "]"      => "BRACKET_RIGHT",
+    "["      => "BRACKET_LEFT",
+    ";"      => "SEMICOLON",
+    "-"      => "MINUS",
+    ","      => "COMMA",
+    "."      => "DOT",
+    "\\"     => "BACKSLASH",
+    "/"      => "SLASH",
+    "="      => "EQUAL",
+    "'"      => "QUOTE",
+    "Ctrl_R" => "CONTROL_R",
+    "Ctrl_L" => "CONTROL_L",
+    "Opt_R"  => "OPTION_R",
+    "Opt_L"  => "OPTION_L",
+    "Cmd_R"  => "COMMAND_R",
+    "Cmd_L"  => "COMMAND_L",
+  }.freeze
+  PREFIX_MAP = {
+    "C"     => "VK_CONTROL",
+    "Ctrl"  => "VK_CONTROL",
+    "Cmd"   => "VK_COMMAND",
+    "Shift" => "VK_SHIFT",
+    "M"     => "VK_OPTION",
+    "Opt"   => "VK_OPTION",
+  }.freeze
+  PREFIX_EXPRESSION = "(#{PREFIX_MAP.keys.map { |k| k + '-' }.join('|')})"
+
+  def initialize(expression)
+    @expression = expression
+  end
+
+  def to_s
+    key_combination(@expression)
+  end
+
+  private
+
+  def key_combination(raw_combination)
+    raw_prefixes, raw_key = split_key_combination(raw_combination)
+    return key_expression(raw_key) if raw_prefixes.empty?
+
+    prefixes = raw_prefixes.map { |raw_prefix| PREFIX_MAP[raw_prefix] }
+    "#{key_expression(raw_key)}, #{prefixes.join(' | ')}"
+  end
+
+  def key_expression(raw_key)
+    case raw_key
+    when /^(#{KEYCODE_MAP.keys.map { |k| Regexp.escape(k) }.join('|')})$/
+      "KeyCode::#{KEYCODE_MAP[raw_key]}"
+    else
+      raw_key = raw_key.upcase unless raw_key.match(/^VK_/)
+      "KeyCode::#{raw_key}"
+    end
+  end
+
+  def split_key_combination(raw_combination)
+    prefixes = []
+    key = raw_combination.dup
+
+    while key.match(/^#{PREFIX_EXPRESSION}/)
+      key.gsub!(/^#{PREFIX_EXPRESSION}/) do
+        prefixes << $1.gsub(/-$/, "")
+        ""
+      end
+    end
+
+    [prefixes, key]
+  end
+end

data/lib/karabiner/namespace.rb

@@ -0,0 +1,5 @@
+# Files which require this file can avoid deep nesting for class declaration
+class Karabiner
+  module DSL
+  end
+end

data/lib/karabiner/property.rb

@@ -0,0 +1,15 @@
+class Karabiner::Property
+  include Karabiner::XmlTree
+
+  def initialize(attr, value, options = {})
+    @attr = attr.to_s
+    @value = value
+    @options = options
+  end
+  attr_accessor :attr, :value
+
+  def to_xml
+    open_tag = @options.map { |a, v| "#{a}=\"#{v}\"" }.unshift(attr).join(" ")
+    "<#{open_tag}>#{value}</#{attr}>"
+  end
+end

data/lib/karabiner/remap.rb

@@ -0,0 +1,16 @@
+require "karabiner/key"
+require "karabiner/property"
+
+class Karabiner::Remap < Karabiner::Property
+  def initialize(from, to)
+    tos = [to].flatten
+
+    super(
+      "autogen",
+      [
+        "__KeyToKey__ #{Karabiner::Key.new(from)}",
+        *tos.map { |to| Karabiner::Key.new(to) },
+      ].join(", "),
+    )
+  end
+end

data/lib/karabiner/root.rb

@@ -0,0 +1,30 @@
+require "karabiner/invoke_history"
+require "karabiner/vkopenurldef"
+require "karabiner/dsl/root"
+
+class Karabiner::Root
+  include Karabiner::XmlTree
+  include Karabiner::DSL::Root
+
+  def initialize
+    @configs = []
+  end
+
+  def to_xml
+    Karabiner::InvokeHistory.registered_applications.each do |application|
+      vkopenurldef = Karabiner::Vkopenurldef.new(application)
+      add_child(vkopenurldef)
+    end
+
+    [
+      "<?xml version=\"1.0\"?>",
+      super(1),
+    ].join("\n")
+  end
+
+  private
+
+  def add_config(config)
+    @configs << config
+  end
+end

data/lib/karabiner/version.rb

@@ -0,0 +1,3 @@
+class Karabiner
+  VERSION = "0.1.0"
+end

data/lib/karabiner/vkopenurldef.rb

@@ -0,0 +1,11 @@
+require "karabiner/xml_tree"
+
+class Karabiner::Vkopenurldef
+  include Karabiner::XmlTree
+
+  def initialize(application)
+    name = Karabiner::Property.new("name", "KeyCode::VK_OPEN_URL_APP_#{application.gsub(/ /, "_")}")
+    url  = Karabiner::Property.new("url", "/Applications/#{application}.app", type: "file")
+    add_child(name, url)
+  end
+end