karules 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 276d1cb288bdf01c66130cebd08d2ffb2723f7e2b8fce6cbe6ffa97a0aa430d5
+  data.tar.gz: 5dd19e077072c671737e8fef8093e1f05b97a871a38c850bb24cfb0859e80935
+SHA512:
+  metadata.gz: 9933c4488162a5fd9e792c3dce4e220982d3a1709d6c9c511e123d8d0a798ba9a7c10c9925750fca3c4a1a5def0568c1a646b535d79f6f312a4530b02b76acfc
+  data.tar.gz: 2fc49300015041c4ea3dd9ade8b6dbbb0823669316013a7af98f14ffeefbeef0d733ea41ea3eb896ab4afcff103940076dddb259a046e4f8d2616c0e6ce4495e

data/CHANGELOG.md

@@ -0,0 +1,31 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2025-01-23
+
+### Added
+- Initial release of KaRules gem
+- Ruby DSL for configuring Karabiner-Elements
+- Support for keyboard mappings with modifiers
+- Support for mouse button mappings
+- Application-specific rules with bundle identifiers
+- Modal keyboard modes with state management
+- Custom Karabiner config path via `karabiner_path` DSL
+- XDG Base Directory specification support
+- Command-line executable for loading user configs
+- Example configuration file
+- Comprehensive test suite
+
+### Features
+- Simple mapping syntax: `m("from", "to")`
+- Modifier support: `+mandatory` and `-optional`
+- Shell command execution: `!command`
+- Complex conditions and parameters
+- Group organization with descriptions
+- Deep hash sorting for consistent JSON output
+
+[0.1.0]: https://github.com/avsej/karules/releases/tag/v0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Sergey Tarasov
+
+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,303 @@
+# karules
+
+Configure Karabiner-Elements with Ruby DSL - cleaner, more maintainable keyboard customization for macOS.
+
+## What is this?
+
+If you're like me and have a complex Karabiner-Elements configuration, you probably know the pain of editing that giant JSON file manually. I got tired of it and wrote a Ruby DSL to generate the config instead.
+
+**Features:**
+- Clean, readable Ruby syntax instead of JSON
+- Group related mappings together
+- Reusable helper methods
+- Application-specific rules
+- Modal keyboard modes
+- No need to remember Karabiner's JSON structure
+
+## Why?
+
+Karabiner-Elements is powerful but its configuration format is...verbose. Here's a simple caps lock → control mapping:
+
+**JSON (what Karabiner wants):**
+```json
+{
+  "description": "Caps Lock to Control",
+  "manipulators": [{
+    "type": "basic",
+    "from": {
+      "key_code": "caps_lock",
+      "modifiers": { "optional": ["any"] }
+    },
+    "to": [{ "key_code": "left_control" }]
+  }]
+}
+```
+
+**Ruby (what you write):**
+```ruby
+group("Caps Lock") do
+  m("caps_lock -any", "left_control")
+end
+```
+
+Much better.
+
+## Installation
+
+### Via Homebrew (soon)
+
+```bash
+brew tap dzirtusss/tap
+brew install karules
+```
+
+### Via RubyGems
+
+```bash
+gem install karules
+```
+
+### Manual
+
+```bash
+git clone https://github.com/dzirtusss/karules.git
+cd karules
+gem build karules.gemspec
+gem install karules-0.1.0.gem
+```
+
+## Configuration
+
+Create your config file at `~/.config/karules/config.rb`:
+
+```ruby
+require "karules"
+
+class MyConfig < KaRules
+  def config
+    # Define your apps
+    apps(
+      slack: "^com\\.tinyspeck\\.slackmacgap$",
+      terminal: "^com\\.apple\\.Terminal$"
+    )
+
+    # Simple mapping
+    group("Caps Lock") do
+      m("caps_lock -any", "left_control")
+    end
+
+    # App-specific rules
+    group("Slack shortcuts") do
+      app_if(:slack) do
+        m("h +right_option", "left_arrow")
+        m("l +right_option", "right_arrow")
+      end
+    end
+
+    # Launch apps
+    group("App launcher") do
+      m("t +right_command", "!open -a 'Terminal'")
+      m("s +right_command", "!open -a 'Safari'")
+    end
+
+    # Modal modes (vim-style)
+    group("Tab mode") do
+      m("tab", "right_option lazy", to_if_alone: "tab")
+      m("j +right_option", "down_arrow")
+      m("k +right_option", "up_arrow")
+      m("h +right_option", "left_arrow")
+      m("l +right_option", "right_arrow")
+    end
+  end
+end
+
+MyConfig.new.call
+```
+
+Then run:
+
+```bash
+karules
+```
+
+It will update your `~/.config/karabiner/karabiner.json` automatically.
+
+## Usage
+
+### Basic Mapping
+
+```ruby
+m("from_key", "to_key")
+```
+
+### Modifiers
+
+**Mandatory modifiers** (must be pressed):
+```ruby
+m("a +command", "b")  # Command+A → B
+```
+
+**Optional modifiers** (can be pressed):
+```ruby
+m("a -any", "b")  # A (with any modifiers) → B
+```
+
+### Shell Commands
+
+```ruby
+m("t +command", "!open -a 'Terminal'")
+```
+
+### Application-Specific Rules
+
+```ruby
+apps(slack: "^com\\.tinyspeck\\.slackmacgap$")
+
+app_if(:slack) do
+  m("j +control", "down_arrow")
+end
+```
+
+### Complex Mappings
+
+```ruby
+m("a +control",
+  to: "b",
+  to_if_alone: "escape",
+  conditions: some_condition)
+```
+
+### Modal Modes
+
+Create vim-like modal keyboards:
+
+```ruby
+group("Vi Mode") do
+  default_mode("vi-mode")
+
+  # Enter mode
+  m("escape", mode_on)
+
+  # Exit on any non-vi key
+  m("escape", mode_off)
+
+  # Mappings only active in mode
+  mode_if do
+    m("h", "left_arrow")
+    m("j", "down_arrow")
+    m("k", "up_arrow")
+    m("l", "right_arrow")
+  end
+end
+```
+
+### Custom Karabiner Path
+
+```ruby
+def config
+  karabiner_path "~/custom/karabiner.json"
+  # ... rest of config
+end
+```
+
+## Tips
+
+**Use groups** to organize your config:
+```ruby
+group("Navigation") do
+  # related mappings
+end
+
+group("App Launcher") do
+  # related mappings
+end
+```
+
+**Extract common patterns** into methods:
+```ruby
+def vim_nav(prefix)
+  m("h #{prefix}", "left_arrow")
+  m("j #{prefix}", "down_arrow")
+  m("k #{prefix}", "up_arrow")
+  m("l #{prefix}", "right_arrow")
+end
+
+group("Vim nav") do
+  vim_nav("+option")
+end
+```
+
+**Check the example** config for more ideas:
+- See the [example config](examples/config.rb)
+- Or run: `gem contents karules | grep examples`
+
+## How It Works
+
+1. You write Ruby DSL in `~/.config/karules/config.rb`
+2. Run `karules` command
+3. It generates the JSON rules
+4. Updates your Karabiner config
+5. Karabiner picks up the changes automatically
+
+The DSL is just Ruby, so you can:
+- Use variables and loops
+- Write helper methods
+- Split config into multiple files (with `load`)
+- Generate mappings programmatically
+
+## Troubleshooting
+
+**Config not loading?**
+
+Make sure your config file is at:
+- `~/.config/karules/config.rb` (default)
+- Or specify: `karules /path/to/config.rb`
+
+**Changes not applying?**
+
+Karabiner should detect changes automatically. If not:
+- Check Karabiner-EventViewer for errors
+- Verify your JSON at `~/.config/karabiner/karabiner.json`
+- Restart Karabiner-Elements
+
+**Syntax errors?**
+
+Your config is Ruby code. Check for:
+- Missing `do`/`end` blocks
+- Unmatched quotes
+- Typos in method names
+
+## Comparison with Alternatives
+
+**JSON (built-in):** Maximum control but verbose and error-prone
+
+**Goku/KarabinerDSL:** Great alternatives! This is just my take with Ruby instead of Clojure/other DSLs. Use whatever works for you.
+
+**Why Ruby?** Because I write Ruby daily and wanted something that feels natural to me. If you prefer other languages, check out the alternatives.
+
+## Known Limitations
+
+- This is an early version, expect some rough edges
+- Not all Karabiner features are wrapped (but you can use raw hashes for anything)
+- No validation yet (invalid configs will fail at Karabiner level)
+- Examples use my personal workflow - adapt to yours
+
+## Future Ideas
+
+- [ ] Config validation before writing
+- [ ] Interactive config generator
+- [ ] More helper methods for common patterns
+- [ ] Better error messages
+- [ ] Support for multiple profiles
+
+PRs welcome!
+
+## License
+
+MIT - see [LICENSE](LICENSE)
+
+## Credits
+
+Built with frustration and coffee by [@dzirtusss](https://github.com/dzirtusss)
+
+Inspired by everyone who's ever looked at a Karabiner JSON file and thought "there must be a better way."

data/examples/config.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+# Example Karabiner configuration
+# Copy this file to ~/.config/karules/config.rb and customize it
+
+require "karules"
+
+class MyKaRules < KaRules
+  def key_mode(key, mode)
+    m(
+      key,
+      to_if_alone: { key_code: key, halt: true },
+      to_after_key_up: mode_off(mode),
+      to_delayed_action: { to_if_canceled: { key_code: key }, to_if_invoked: mode_on(mode) },
+      parameters: {
+        "basic.to_if_held_down_threshold_milliseconds": 300,
+        "basic.to_delayed_action_delay_milliseconds": 300
+      }
+    )
+  end
+
+  def config
+    # Optional: specify custom Karabiner config path
+    # Default: $XDG_CONFIG_HOME/karabiner/karabiner.json or ~/.config/karabiner/karabiner.json
+    # karabiner_path "~/custom/path/karabiner.json"
+
+    apps(slack: "^com\\.tinyspeck\\.slackmacgap$", ghostty: "^com\\.mitchellh\\.ghostty$")
+
+    group("Caps Lock") do
+      # m("caps_lock -any", "left_control", to_if_alone: "escape")
+      m("caps_lock -any", "left_control")
+    end
+
+    group("Mouse buttons") do
+      m("pointing_button:button5 -any", "f3") # mission control
+      # m("pointing_button:button5 -any", "tab +right_command")
+    end
+
+    group("Tmux") do
+      app_unless(:ghostty) do
+        # Example: Focus terminal app, wait, then send Ctrl+A
+        # Replace with your own terminal focus script
+        m(
+          "a +control",
+          [
+            "!open -a 'Terminal'",
+            { key_code: "vk_none", hold_down_milliseconds: 100 },
+            "a +control"
+          ]
+        )
+      end
+    end
+
+    group("Tab mode") do
+      m("tab", "right_option lazy", to_if_alone: "tab")
+
+      m("j +right_option", "down_arrow")
+      m("k +right_option", "up_arrow")
+
+      app_if(:slack) do
+        m("h +right_option", "f6 +shift")
+        m("l +right_option", "f6")
+        m("semicolon +right_option", "right_arrow")
+      end
+
+      m("h +right_option", "left_arrow")
+      m("l +right_option", "right_arrow")
+
+      m("w +right_option", "right_arrow +right_option")
+      m("b +right_option", "left_arrow +right_option")
+      m("u +right_option", "page_up")
+      m("d +right_option", "page_down")
+    end
+
+    group("Mouse mode", enabled: false) do
+      default_mode("mouse-mode")
+      scroll = "mouse-scroll"
+
+      step = 1000
+      mult1 = 0.5
+      mult2 = 2
+      wheel = 50
+
+      # m("fn -any", mode_on, to_if_alone: "fn", to_after_key_up: mode_off)
+
+      key_mode("d", "mouse-mode")
+      mode_if do
+        m("left_shift +right_shift", mode_off)
+        m("right_shift +left_shift", mode_off)
+      end
+      m("left_shift +right_shift", mode_on)
+      m("right_shift +left_shift", mode_on)
+
+      mode_if do
+        mode_if(scroll) do
+          m("j -any", { mouse_key: { vertical_wheel: wheel } })
+          m("k -any", { mouse_key: { vertical_wheel: -wheel } })
+          m("h -any", { mouse_key: { horizontal_wheel: wheel } })
+          m("l -any", { mouse_key: { horizontal_wheel: -wheel } })
+        end
+
+        # normal movement
+        m("j -any", { mouse_key: { y: step } })
+        m("k -any", { mouse_key: { y: -step } })
+        m("h -any", { mouse_key: { x: -step } })
+        m("l -any", { mouse_key: { x: step } })
+
+        # mode modifiers
+        m("s -any", mode_on(scroll), to_after_key_up: mode_off(scroll))
+        m("c -any", { mouse_key: { speed_multiplier: mult1 } })
+        m("f -any", { mouse_key: { speed_multiplier: mult2 } })
+
+        # buttons
+        m("b -any", { pointing_button: "button1" })
+        m("spacebar -any", { pointing_button: "button1" })
+        m("n -any", { pointing_button: "button2" })
+
+        # position
+        m("u -any", { software_function: { set_mouse_cursor_position: { x: "20%", y: "20%" } } })
+        m("i -any", { software_function: { set_mouse_cursor_position: { x: "80%", y: "20%" } } })
+        m("o -any", { software_function: { set_mouse_cursor_position: { x: "20%", y: "80%" } } })
+        m("p -any", { software_function: { set_mouse_cursor_position: { x: "80%", y: "80%" } } })
+        m("m -any", { software_function: { set_mouse_cursor_position: { x: "50%", y: "50%" } } })
+      end
+    end
+
+    group("MacOS double CmdQ") do
+      default_mode("macos-q-command")
+      m("q +command", "q +command", conditions: mode_if)
+      m("q +command", mode_on, to_delayed_action: { to_if_canceled: mode_off, to_if_invoked: mode_off })
+    end
+
+    # Example: Switch between terminal windows/tabs
+    # Replace with your own terminal switching script
+    max = 9
+    group("terminal 1-#{max}") do
+      app_if(:ghostty) do
+        (1..max).each { |i| m("#{i} +left_command", "#{i} +command") }
+      end
+
+      (1..max).each { |i| m("#{i} +left_option", "#{i} +command") }
+    end
+
+    # Example: Application launcher shortcuts
+    group("Apps") do
+      m("j +right_command", "!open -a 'Terminal'")
+      m("k +right_command", "!open -a 'Safari'")
+      m("semicolon +right_command", "!open -a 'Mail'")
+
+      m("f +right_command", "!open -a 'Finder'")
+      m("s +right_command", "!open -a 'Slack'")
+      m("c +right_command", "!open -a 'Google Chrome'")
+      m("n +right_command", "!open -a 'Notes'")
+
+      # You can also map to other key combinations
+      m("t +right_command", "t +control +command +option")
+    end
+  end
+end
+
+MyKaRules.new.call

data/exe/karules

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "karules"
+
+# Determine config file path
+config_file = ARGV.first
+
+unless config_file
+  # Use XDG_CONFIG_HOME or default to ~/.config
+  config_home = ENV.fetch("XDG_CONFIG_HOME", File.expand_path("~/.config"))
+  config_file = File.join(config_home, "karules", "config.rb")
+end
+
+# Check if config file exists
+unless File.exist?(config_file)
+  warn "Config file not found: #{config_file}"
+  warn ""
+  warn "Usage: karules [CONFIG_FILE]"
+  warn ""
+  warn "Create a config file at #{config_file}"
+  warn "or specify a custom path as an argument."
+  warn ""
+  warn "See the example config at:"
+  warn "  #{File.expand_path('../../examples/config.rb', __dir__)}"
+  exit 1
+end
+
+# Load and execute the config file
+load config_file

data/lib/karules/dsl.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+# rubocop:disable Metrics/PerceivedComplexity,Metrics/CyclomaticComplexity
+
+require "json"
+
+module KaRulesDSL # rubocop:disable Metrics/ModuleLength
+  APPLE_KEYS = %w[spotlight].freeze
+
+  def m(
+    from, to = nil, conditions: nil, to_if_alone: nil, to_delayed_action: nil,
+    to_if_held_down: nil, parameters: nil, to_after_key_up: nil
+  )
+    res = {}
+    conditions = @default_conditions || conditions
+    parameters = @default_parameters || parameters
+    res[:conditions] = wrap(conditions) if conditions
+    res[:parameters] = parameters if parameters
+
+    res[:from] = from(from)
+
+    res[:to] = to(to) if to
+    res[:to_if_alone] = to(to_if_alone) if to_if_alone
+    res[:to_if_held_down] = to(to_if_held_down) if to_if_held_down
+    res[:to_delayed_action] = to_delayed_action if to_delayed_action
+    res[:to_after_key_up] = to(to_after_key_up) if to_after_key_up
+
+    res[:type] = "basic"
+    @manipulators << res
+  end
+
+  def from(from)
+    return from unless from.is_a?(String)
+
+    args = from.split
+    result =
+      if args.first.match?(":")
+        k, v = args.first.split(":")
+        { k.to_sym => v }
+      else
+        { key_code: args.first }
+      end
+    args[1..].each do |mod|
+      result[:modifiers] ||= {}
+      if mod.start_with?("+")
+        result[:modifiers][:mandatory] ||= []
+        result[:modifiers][:mandatory] << mod[1..]
+      elsif mod.start_with?("-")
+        result[:modifiers][:optional] ||= []
+        result[:modifiers][:optional] << mod[1..]
+      else
+        raise("Unknown modifier: #{mod}")
+      end
+    end
+    result
+  end
+
+  def to(to)
+    return to.map { |t| to(t) } if to.is_a?(Array)
+    return to unless to.is_a?(String)
+    return { shell_command: to[1..] } if to.start_with?("!")
+
+    args = to.split
+    result = { key_code: args.first }
+    args[1..].each do |mod|
+      if mod == "lazy"
+        result[:lazy] = true
+      elsif mod.start_with?("+")
+        result[:modifiers] ||= []
+        result[:modifiers] << mod[1..]
+      # elsif mod.start_with?("!")
+      #   result[:shell_command] = mod[1..] + args.split(mod).last
+      #   break
+      else
+        raise("Unknown modifier: #{mod}")
+      end
+    end
+    result
+  end
+
+  def v(name, value)
+    { set_variable: { name:, value: } }
+  end
+
+  def v_if(name, value, &)
+    block_given? ? conditions(v_if(name, value), &) : { name:, type: "variable_if", value: }
+  end
+
+  def v_unless(name, value, &)
+    block_given? ? conditions(v_unless(name, value), &) : { name:, type: "variable_unless", value: }
+  end
+
+  def mode_on(name = @default_mode) = v(name, true)
+  def mode_off(name = @default_mode)= v(name, false)
+  def mode_if(name = @default_mode, &) = v_if(name, true, &)
+  def mode_unless(name = @default_mode, &) = v_unless(name, true, &)
+
+  def apps(**apps)
+    @apps = apps
+  end
+
+  def app_if(name, &)
+    if block_given?
+      conditions(app_if(name), &)
+    else
+      app = @apps[name] || raise("Unknown app: #{name}")
+      { bundle_identifiers: wrap(app), type: "frontmost_application_if" }
+    end
+  end
+
+  def app_unless(name, &)
+    if block_given?
+      conditions(app_unless(name), &)
+    else
+      app = @apps[name] || raise("Unknown app: #{name}")
+      { bundle_identifiers: wrap(app), type: "frontmost_application_unless" }
+    end
+  end
+
+  def desc(description)
+    @description = description
+  end
+
+  def wrap(obj_or_arr)
+    obj_or_arr.is_a?(Array) ? obj_or_arr : [obj_or_arr]
+  end
+
+  def default_mode(name)
+    @default_mode = name
+  end
+
+  def conditions(*conditions)
+    original_conditions = @default_conditions
+    @default_conditions = (@default_conditions || []) + conditions
+    yield
+    @default_conditions = original_conditions
+  end
+
+  def parameters(**parameters)
+    original_parameters = @default_parameters
+    @default_parameters = (@default_parameters || {}).merge(parameters)
+    yield
+    @default_parameters = original_parameters
+  end
+
+  def group(description = "", skip: false, enabled: true)
+    return if skip
+
+    @description = description
+    @manipulators = []
+    @default_mode = nil
+    @default_conditions = nil
+    @default_parameters = nil
+    yield
+    @result << { description: @description, manipulators: @manipulators }
+    @result.last[:enabled] = false unless enabled
+  end
+
+  def karabiner_path(path = nil)
+    return @karabiner_path if path.nil?
+
+    @karabiner_path = File.expand_path(path)
+  end
+
+  def generate
+    @result = []
+    config
+    @result = deep_sort(@result)
+  end
+
+  def call
+    file = karabiner_path || default_karabiner_path
+    json = JSON.parse(File.read(file), symbolize_names: true)
+
+    json[:profiles][0][:complex_modifications][:rules].replace(generate)
+
+    File.write(file, json.to_json)
+    `karabiner_cli --format-json #{file}`
+  end
+
+  private
+
+  def default_karabiner_path
+    config_home = ENV.fetch("XDG_CONFIG_HOME", File.expand_path("~/.config"))
+    File.join(config_home, "karabiner", "karabiner.json")
+  end
+
+  def deep_sort(obj)
+    case obj
+    when Array
+      obj.map { |el| deep_sort(el) }
+    when Hash
+      obj.sort_by { |k, _| k }.to_h.transform_values { |v| deep_sort(v) }
+    else
+      obj
+    end
+  end
+end
+
+# rubocop:enable Metrics/MethodLength,Metrics/AbcSize
+# rubocop:enable Metrics/PerceivedComplexity,Metrics/CyclomaticComplexity

data/lib/karules/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Karules
+  VERSION = "0.1.0"
+end

data/lib/karules.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "karules/dsl"
+require_relative "karules/version"
+
+# Base class for Karabiner configuration
+# Users should subclass this and override the config method
+class KaRules
+  include KaRulesDSL
+
+  def config
+    # Override this method in your configuration file
+    # See examples/config.rb for a complete example
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: karules
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sergey Tarasov
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-11-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.69'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.69'
+description: A Ruby DSL for configuring Karabiner-Elements - cleaner, more maintainable
+  keyboard customization for macOS
+email:
+- dzirtusss@gmail.com
+executables:
+- karules
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- examples/config.rb
+- exe/karules
+- lib/karules.rb
+- lib/karules/dsl.rb
+- lib/karules/version.rb
+homepage: https://github.com/dzirtusss/karules
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/dzirtusss/karules
+  source_code_uri: https://github.com/dzirtusss/karules
+  bug_tracker_uri: https://github.com/dzirtusss/karules/issues
+  changelog_uri: https://github.com/dzirtusss/karules/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key:
+specification_version: 4
+summary: Configure Karabiner-Elements with Ruby DSL
+test_files: []