Twiddler Utils C0 Coverage Information - RCov

 module Twiddler

   class Config

     class KeyTable 

       class KeyData

         ModAliases = Hash.new{|h,k| k}.merge!(

         def initialize(num, name)

           @code = num

           @data = { :unmod => name }

           @tags = {}

         attr_reader :code

         def tag(name)

           @tags[name.to_sym] = true

         def tag?(name)

           @tags.has_key?(name)

         def modified(mod, value)

           @data[normalized(mod)] = value

         def string(mod=nil)

           return @data[:unmod] if mod.nil? or mod.empty?

           if data = @data[normalized(mod)]

             return data

         def has_mod?(mod)

           @data.has_key?(normalized(mod))

         def ===(chord)

           chord.single? and chord[0][0] == @code

         def self.normalized(mod)

           unless Array === mod

             mod = mod.split("-")

           return mod.map{|i| ModAliases[i.downcase]}.sort.join("-")

         def normalized(mod)

           self.class.normalized(mod)

       def initialize

         @data = Hash.new{|h,k| KeyData.new(k, "U/#{k.inspect}")}

         @ordered = []

         @current_tags = {}

       def normalized(stroke)

         mods = KeyData::normalized(stroke[1])

         return [stroke[0], mods]

       def unknowns(list)

       def start_tag(name)

         @current_tags[name.to_sym] = true

       def end_tag(name)

         @current_tags.delete(name.to_sym)

       def clear_tags

         @current_tags.clear

       def tagged(name)

         @ordered.find_all do |key|

           key.tag?(name)

       def is_tagged?(idx, tag)

         @data[idx].tag?(tag)

       def [](idx, mod=nil)

         return @data[idx].string(mod)

       def []=(idx, value)

         if @data.has_key?(idx)

         data = KeyData.new(idx, value)

         @current_tags.each_key do |name|

           data.tag(name)

         @data[idx] = data

         @ordered << data

       include Enumerable

       def each(&block)

         @ordered.each(&block)

       def mod(idx, mod, value)

         @data[idx].modified(mod, value)

     def self.keytable

           table = KeyTable.new

           table.start_tag(:normal)

           table.start_tag(:letters)

           (("a".."z").to_a).each_with_index do |ltr, idx|

             table[idx+4] = ltr

           (("A".."Z").to_a).each_with_index do |ltr, idx|

             table.mod(idx+4, "shift", ltr)

           table.end_tag(:letters)

           table.start_tag(:numbers)

           (("1".."9").to_a + ["0"]).each_with_index do |num, idx|

             table[idx+30] = num

           %w[! @ # $ % ^ & * ( )].each_with_index do |shift_num, idx|

             table.mod(idx+30, "shift", shift_num)

           table.end_tag(:numbers)

           table.start_tag(:punctuation)

           table[45] = "-"

           table.mod(45, "shift", "_")

           table[46] = "="

           table.mod(46, "shift", "+")

           table[47] = "["

           table.mod(47, "shift", "{")

           table[48] = "]"

           table.mod(48, "shift", "}")

           table[49] = "\\"

           table.mod(49, "shift", "|")

           table[56] = "/"

           table.mod(56, "shift", "?")

           table[51] = ";"

           table.mod(51, "shift", ":")

           table[52] = "'"

           table.mod(52, "shift", "\"")

           table[53] = "`"

           table.mod(53, "shift", "~")

           table[54] = ","

           table.mod(54, "shift", "<")

           table[55] = "."

           table.mod(55, "shift", ">")

           table[73] = "~"

           table.clear_tags

           table.start_tag(:special)

           table[40] = "<Rtrn>"

           table[41] = "<Esc>"

           table[42] = "<Bksp>"

           table[43] = "<Tab>"

           table[44] = "<Spc>"

           table[57] = "<Cplk>"

           table[71] = "<Scrlk>"

           table[74] = "<Home>"

           table[75] = "<PgUp>"

           table[76] = "<Delete>"

           table[77] = "<End>"

           table[78] = "<PgDn>"

           table[79] = "<Right>"

           table[80] = "<Left>"

           table[81] = "<Down>"

           table[82] = "<Up>"

           table[83] = "<Nmlk>"

           table.start_tag(:fkeys)

           ("1".."12").to_a.each_with_index do |fkey, idx|

             table[idx+58] = "F" + fkey

           table.end_tag(:fkeys)

           table.start_tag(:hardware_control)

           table[-2] = "<<Mass Storage Mode>>"

           table[-3] = "<<Upgrade Mode>>"

           table[-4] = "<<Disable Mouse Mode>>"

           table[-5] = "<<Enable Mouse Mode>>"

           table.clear_tags

           table

         end

     class Chord

       def initialize

         @rows = [:open, :open, :open, :open]

         @mods = {:num => false, 

           :shift => false, :ctrl => false, :alt => false}

       attr_reader :rows, :mods

       def extract_key(bits, idx, mod, range)

         @rows[idx] = case bits[range]

                      when /1.../; :left

                      when /.1../; :middle

                      when /..1./; :right

                      else :open

         @mods[mod] = (bits[range.last] == ?1)

       def keydata=(bits)

         extract_key(bits, 0, :num,    4..7)

         extract_key(bits, 1, :alt,    0..3)

         extract_key(bits, 2, :ctrl,  12..15)

         extract_key(bits, 3, :shift,  8..11)

       def render_keys

         mods = 

           (@mods[:num] ?   "N" : "") +

           (@mods[:alt] ?   "A" : "") +

           (@mods[:ctrl] ?  "C" : "") +

           (@mods[:shift] ? "S" : "")

         if mods.empty?

           mods = "O"

         chord = rows.map do |row|

           case row

           when :open;   "O"

           when :left;   "L"

           when :right;  "R"

           when :middle; "M"

         return "#{mods} #{chord}"

       def render_action

       def render

         "#{render_keys} => #{render_action}"

     class KeyChord < Chord

       ModKeys = %w{RGui RAlt RSft RCtl LGui LAlt LSft LCtl}

       def initialize

         super

         @keystrokes = []

       attr_reader :keystrokes

       def [](idx)

         @keystrokes[idx]

       def single?

         @keystrokes.length == 1

       def add_keystroke(mod_bits, idx)

         mods = ModKeys.zip(mod_bits.split('')).delete_if{|mod,bit| bit != "1"}.map{|mod,bit| mod}

         @keystrokes << [idx, mods]

       def keytable

         Config.keytable

       def render_action

         output = []

         (@keystrokes || []).each do |code, mods|

           output << keytable[code, mods]

         return output.join()

     class MouseChord < Chord

       def initialize

         super

         @mods = {

         @buttons = {

           :right => false

       attr_reader :mods, :buttons

       def data=(bits)

         if bits[0] == ?1

           @mods[:ctrl] = true

         if bits[1] == ?1 

           @mods[:alt] = true

         if bits[2] == ?1 

           @mods[:shift] = true

         if bits[3] == ?1 

           @mods[:double] = true

         if bits[4] == ?1 

           @mods[:toggle] = true

         if bits[5] == ?1 

           @buttons[:middle] = true

         if bits[6] == ?1 

           @buttons[:right] = true

         if bits[7] == ?1 

           @buttons[:left] = true

       def render_action

         action = ""

         if @mods[:ctrl]

           action << "Ctl-"

         if @mods[:alt]

           action << "Alt-"

         if @mods[:shift]

           action << "Shf-"

         if @mods[:double]

           action << "Dbl-"

         if @mods[:toggle]

           action << "Tgl-"

         if @buttons[:middle]

           action << "M"

         if @buttons[:right]

           action << "R"

         if @buttons[:left]

           action << "L"

         return action

     def initialize()

       @mouse = []

       @keyboard = []

       @configs = {}

     def keytable

       self.class.keytable

     attr_reader :mouse, :keyboard, :configs

     def inspect