twiddler-utils 0.0.3

data/doc/coverage/print.css

@@ -0,0 +1,12 @@
+/* Hide controls */
+
+  body {
+    color: #000000;
+    background-color: #ffffff;
+  }
+
+/* Hide controls */
+
+  div.filters {
+    display: none;
+  }

data/doc/coverage/rcov.js

@@ -0,0 +1,42 @@
+function toggleCode( id ) {
+  if ( document.getElementById ) {
+    elem = document.getElementById( id );
+  } else if ( document.all ) {
+    elem = eval( "document.all." + id );
+  } else {
+    return false;
+  }
+  
+  elemStyle = elem.style;
+
+  if ( elemStyle.display != "block" ) {
+    elemStyle.display = "block";
+  } else {
+    elemStyle.display = "none";
+  }
+
+  return true;
+}
+
+function restripe() {
+  i = 0;
+  $('table#report_table tbody tr').each(function(){
+    if (this.style.display != "none") {
+      i += 1;
+      classes = this.className.split(" ");
+      if ($.inArray("even",classes) != -1) {
+        classes.splice($.inArray("even",classes),1);
+      } else if ($.inArray("odd",classes) != -1) {
+        classes.splice($.inArray("odd",classes),1);
+      }
+      if (i % 2 === 0) {
+        this.className = classes.join(" ") + " odd";
+      } else {
+        this.className = classes.join(" ") + " even";
+      }
+    }
+  });
+}
+
+// Fix IE's lack of support for indexOf (!)
+if (!Array.indexOf) { Array.prototype.indexOf = function(obj){ for(var i=0; i<this.length; i++){ if(this[i]==obj){return i;} } return -1; }}

data/doc/coverage/screen.css

@@ -0,0 +1,270 @@
+/* @group General */
+
+  body {
+    font-family: Verdana, Helvetica, Arial, Sans-Serif;
+    font-size: 12px;
+    color: #4C4C4C;
+    background-color: #F4F2ED;
+    padding: 1em;
+  }
+  
+  a:link {
+    color: #191919;
+  }
+  
+  a:visited {
+    color: #191919;
+  }
+
+  pre, code {
+    color: #000000;
+    font-family: "Bitstream Vera Sans Mono","Monaco","Courier New",monospace;
+    font-size: 95%;
+    line-height: 1.3em;
+    margin-top: 0;
+    margin-bottom: 0;
+    padding: 0;
+    word-wrap: break-word;
+  }
+
+  h1, h2, h3, h4, h5, h6 {
+    margin: 0em 0em 1em 0em;
+    color: #666666;
+  }
+  
+  h1 { 
+    display: block;
+    font-size: 2em;
+    letter-spacing: -1px;
+  }
+  
+  h2 {
+    margin-top: -1em;	
+  }
+  
+  fieldset {
+    display: inline;
+    border: 0px;
+    padding: 0px;
+    margin-right: 1em;
+  }
+  
+  div.filters {
+    margin-bottom: 1em;	
+  }
+  
+  .hidden {
+    display: none;
+  }
+  
+/* @end */
+
+/* @group Cross-References */
+
+  span.cross-ref-title {
+    font-size: 140%;
+  }
+  
+  span.cross-ref a {
+    text-decoration: none;
+  }
+  
+  span.cross-ref {
+    background-color:#f3f7fa;
+    border: 1px dashed #333;
+    margin: 1em;
+    padding: 0.5em;
+    overflow: hidden;
+  }
+  
+  a.crossref-toggle {
+    text-decoration: none;
+  }
+
+/* @end */
+
+/* @group Report Table */
+
+  div.report_table_wrapper {
+    min-width: 900px;
+  }
+
+  table.report {
+    border-collapse: collapse;
+    border: 1px solid #666666;
+    width: 100%;
+    margin-bottom: 1em;
+  }
+  
+  table.report tr {
+    line-height: 1.75em;
+  }
+  
+  table.report th {
+    background: #666666;
+    color: #ffffff;
+    text-align: right;
+    text-transform: uppercase;
+    font-size: .8em;
+    font-weight: bold;
+    padding: 0em .5em;
+    border: 1px solid #666666;
+  }
+
+  table.report tfoot tr {
+    background: #dddddd;
+    font-weight: bold;
+    padding: .5em;
+    border: 1px solid #666666;
+  }
+  
+  th.left_align, td.left_align {
+    text-align: left !important;
+  }
+  
+  th.right_align, td.right_align {
+    text-align: right;
+    padding-right: 2em !important;
+  }
+  
+  table.report th.header:hover {
+    cursor:	pointer;
+    text-decoration: underline; 
+  }
+
+  table.report th.headerSortUp:after{
+    content: "\25BC";
+    margin-left: 1em;
+  }
+
+  table.report th.headerSortDown:after {
+    content: "\25B2";
+    margin-left: 1em;
+  }
+
+  table.report tr.summary_row {
+    background: #cccccc;
+    border: 1px solid #cccccc;
+  }
+
+  table.report tr.summary_row td {
+    padding-left: .2em !important;
+    color: #333333;
+    font-weight: bold;
+  }
+  
+  table.report td {
+    padding: .2em .5em .2em .5em;
+  }
+
+  table.report td a {
+    text-decoration: none;
+  }
+  
+  table.report tbody tr:hover {
+    background: #cccccc !important;
+  }
+  
+  table.report tr.summary_row td {
+    border-bottom: 1px solid #aaaaaa;
+  }
+
+  table.report tr {
+    background-color: #eeeeee;
+  }
+
+  table.report tr.odd {
+    background-color: #dddddd;
+  }
+
+/* @end */
+
+/* @group Percentage Graphs */
+
+  div.percent_graph_legend {
+    width: 5.5em;
+    float: left;
+    margin: .5em 1em .5em 0em;
+    height: 1em;
+    line-height: 1em;
+  }
+  
+  div.percent_graph {
+    height: 1em;
+    border: #333333 1px solid;
+    empty-cells: show;
+    padding: 0px;
+    border-collapse: collapse;
+    width: 100px !important;
+    float: left;
+    margin: .5em 1em .5em 0em;
+  }
+
+  div.percent_graph div {
+  	float: left;
+    height: 1em;
+    padding: 0px !important;
+  }  
+
+  div.percent_graph div.covered {
+    background: #649632;
+  }
+  
+  div.percent_graph div.uncovered {
+    background: #a92730;
+  }
+  
+  div.percent_graph div.NA {
+    background: #eaeaea;
+  }
+  
+/* @end */
+
+/* @group Details page */
+
+  table.details {
+    margin-top: 1em;
+    border-collapse: collapse;
+    width: 100%;
+    border: 1px solid #666666;
+  }
+  
+  table.details tr {
+  	line-height: 1.75em;
+	}
+
+  table.details td {
+  	padding: .25em;
+	}
+
+  span.inferred, span.inferred1, span.marked, span.marked1, span.uncovered, span.uncovered1 {
+    display: block;
+    padding: .25em;
+  }
+  
+  tr.inferred td, span.inferred {
+    background-color: #e0dedb;
+  }
+  
+  tr.inferred1 td, span.inferred1 {
+    background-color: #e0dedb;
+  }
+  
+  tr.marked td, span.marked, span.marked1 {
+    background-color: #bed2be;
+  }
+  
+  tr.uncovered td, span.uncovered {
+    background-color: #ce8b8c;
+  }
+  
+  tr.uncovered1 td, span.uncovered1 {
+    background-color: #ce8b8c;
+  }
+
+  div.key {
+    border: 1px solid #666666;
+    margin: 1em 0em;
+  }
+
+/* @end */

data/lib/twiddler/config.rb

@@ -0,0 +1,414 @@
+module Twiddler
+  class Config
+    class KeyTable 
+      class KeyData
+        ModAliases = Hash.new{|h,k| k}.merge!(
+          "rsft" => "shift",
+          "lsft" => "shift",
+          "rctl" => "control",
+          "lctl" => "control",
+          "lalt" => "alt",
+          "ralt" => "alt",
+          "lgui" => "gui",
+          "rgui" => "gui"
+        )
+
+        def initialize(num, name)
+          @code = num
+          @data = { :unmod => name }
+          @tags = {}
+        end
+        attr_reader :code
+
+        def tag(name)
+          @tags[name.to_sym] = true
+        end
+
+        def tag?(name)
+          @tags.has_key?(name)
+        end
+
+        def modified(mod, value)
+          @data[normalized(mod)] = value
+        end
+
+        def string(mod=nil)
+          return @data[:unmod] if mod.nil? or mod.empty?
+          if data = @data[normalized(mod)]
+            return data
+          else
+            return "#{mod}-#{@data[:unmod]}"
+          end
+        end
+
+        def has_mod?(mod)
+          @data.has_key?(normalized(mod))
+        end
+
+        def ===(chord)
+          chord.single? and chord[0][0] == @code
+        end
+
+        def self.normalized(mod)
+          unless Array === mod
+            mod = mod.split("-")
+          end
+          return mod.map{|i| ModAliases[i.downcase]}.sort.join("-")
+        end
+
+        def normalized(mod)
+          self.class.normalized(mod)
+        end
+      end
+
+      def initialize
+        @data = Hash.new{|h,k| KeyData.new(k, "U/#{k.inspect}")}
+        @ordered = []
+        @current_tags = {}
+      end
+
+      def normalized(stroke)
+        mods = KeyData::normalized(stroke[1])
+        return [stroke[0], mods]
+      end
+
+      def unknowns(list)
+        return list.reject do |item|
+          @data.has_key?(item)
+        end
+      end
+
+      def start_tag(name)
+        @current_tags[name.to_sym] = true
+      end
+
+      def end_tag(name)
+        @current_tags.delete(name.to_sym)
+      end
+
+      def clear_tags
+        @current_tags.clear
+      end
+
+      def tagged(name)
+        @ordered.find_all do |key|
+          key.tag?(name)
+        end
+      end
+      
+      def is_tagged?(idx, tag)
+        @data[idx].tag?(tag)
+      end
+
+      def [](idx, mod=nil)
+        return @data[idx].string(mod)
+      end
+
+      def []=(idx, value)
+        if @data.has_key?(idx)
+          @ordered.delete(@data[idx])
+        end
+        data = KeyData.new(idx, value)
+        @current_tags.each_key do |name|
+          data.tag(name)
+        end
+        @data[idx] = data
+        @ordered << data
+      end
+
+      include Enumerable
+      def each(&block)
+        @ordered.each(&block)
+      end
+
+      def mod(idx, mod, value)
+        @data[idx].modified(mod, value)
+      end
+    end
+
+    def self.keytable
+      @table ||= 
+        begin
+          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
+          end
+          (("A".."Z").to_a).each_with_index do |ltr, idx|
+            table.mod(idx+4, "shift", ltr)
+          end
+          table.end_tag(:letters)
+          table.start_tag(:numbers)
+
+          (("1".."9").to_a + ["0"]).each_with_index do |num, idx|
+            table[idx+30] = num
+          end
+          %w[! @ # $ % ^ & * ( )].each_with_index do |shift_num, idx|
+            table.mod(idx+30, "shift", shift_num)
+          end
+          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
+          end
+          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
+    end
+
+    class Chord
+      def initialize
+        @rows = [:open, :open, :open, :open]
+        @mods = {:num => false, 
+          :shift => false, :ctrl => false, :alt => false}
+      end
+
+      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
+                     end
+        @mods[mod] = (bits[range.last] == ?1)
+
+      end
+
+      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)
+      end
+
+      def render_keys
+        mods = 
+          (@mods[:num] ?   "N" : "") +
+          (@mods[:alt] ?   "A" : "") +
+          (@mods[:ctrl] ?  "C" : "") +
+          (@mods[:shift] ? "S" : "")
+        if mods.empty?
+          mods = "O"
+        end
+
+        chord = rows.map do |row|
+          case row
+          when :open;   "O"
+          when :left;   "L"
+          when :right;  "R"
+          when :middle; "M"
+          else "wtf?"
+          end
+        end.join("")
+
+        return "#{mods} #{chord}"
+      end
+
+      def render_action
+        ""
+      end
+
+      def render
+        "#{render_keys} => #{render_action}"
+      end
+    end
+
+    class KeyChord < Chord
+      ModKeys = %w{RGui RAlt RSft RCtl LGui LAlt LSft LCtl}
+
+      def initialize
+        super
+        @keystrokes = []
+      end
+
+      attr_reader :keystrokes
+
+      def [](idx)
+        @keystrokes[idx]
+      end
+
+      def single?
+        @keystrokes.length == 1
+      end
+
+      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]
+      end
+
+      def keytable
+        Config.keytable
+      end
+
+      def render_action
+        output = []
+        (@keystrokes || []).each do |code, mods|
+          output << keytable[code, mods]
+        end
+
+        return output.join()
+      end
+    end
+
+    class MouseChord < Chord
+
+      def initialize
+        super
+        @mods = {
+          :ctrl => false,
+          :alt => false,
+          :shift => false,
+          :double => false,
+          :toggle => false
+        }
+        @buttons = {
+          :left => false,
+          :middle => false,
+          :right => false
+        }
+      end
+
+      attr_reader :mods, :buttons
+
+      def data=(bits)
+        if bits[0] == ?1
+          @mods[:ctrl] = true
+        end
+        if bits[1] == ?1 
+          @mods[:alt] = true
+        end
+        if bits[2] == ?1 
+          @mods[:shift] = true
+        end
+        if bits[3] == ?1 
+          @mods[:double] = true
+        end
+        if bits[4] == ?1 
+          @mods[:toggle] = true
+        end
+        if bits[5] == ?1 
+          @buttons[:middle] = true
+        end
+        if bits[6] == ?1 
+          @buttons[:right] = true
+        end
+        if bits[7] == ?1 
+          @buttons[:left] = true
+        end
+      end
+
+      def render_action
+        action = ""
+        if @mods[:ctrl]
+          action << "Ctl-"
+        end
+        if @mods[:alt]
+          action << "Alt-"
+        end
+        if @mods[:shift]
+          action << "Shf-"
+        end
+        if @mods[:double]
+          action << "Dbl-"
+        end
+        if @mods[:toggle]
+          action << "Tgl-"
+        end
+        if @buttons[:middle]
+          action << "M"
+        end
+        if @buttons[:right]
+          action << "R"
+        end
+        if @buttons[:left]
+          action << "L"
+        end
+        return action
+      end
+    end
+
+
+    def initialize()
+      @mouse = []
+      @keyboard = []
+      @configs = {}
+    end
+
+    def keytable
+      self.class.keytable
+    end
+
+    attr_reader :mouse, :keyboard, :configs
+
+    def inspect
+      "<Twiddler::Config: \n  " + 
+        "Config: #{@configs.inspect}\n  " + 
+      @keyboard.map do |chord|
+        chord.render
+      end.join("\n  ") + 
+        "\n  ---\n  " + 
+        @mouse.map do |chord|
+        chord.render
+        end.join("\n  ") + "\n" +
+          ">"
+    end
+  end
+end