twiddler-utils 0.0.3

data/lib/twiddler/lint.rb

@@ -0,0 +1,59 @@
+require 'twiddler/config'
+
+module Twiddler
+  module Lint
+    def self.check(config)
+      report = []
+      Rule::registered.each do |rule|
+        report << rule.new(config).check
+      end
+      report
+    end
+
+    class Rule
+      class << self
+        def register
+          @@registered ||= []
+          @@registered << self
+        end
+
+        def registered
+          @@registered || []
+        end
+      end
+
+      def initialize(config)
+        @config = config
+      end
+
+      def check()
+        return ""
+      end
+    end
+
+    class MissingStrokes < Rule
+      register
+      def check()
+        all_strokes = []
+        @config.keytable.each do |key|
+          all_strokes << [key.code, ""]
+          all_strokes << [key.code, "shift"] if key.has_mod?("shift")
+        end
+
+        @config.keyboard.each do |chord|
+          next unless chord.single?
+          all_strokes.delete(@config.keytable.normalized(chord[0]))
+        end
+
+        if all_strokes.empty?
+          return "Missing: all normal keystrokes accounted for"
+        else
+          return "Config lacks strokes: #{all_strokes.map{|str| @config.keytable[*str]}.inspect}"
+        end
+      end
+      
+    end
+
+
+  end
+end

data/lib/twiddler/parser.rb

@@ -0,0 +1,97 @@
+require 'twiddler/config'
+
+module Twiddler
+  class Parser
+    def self.parse(data)
+      version = *data.unpack("c")
+      case version
+      when 4
+        V4Parser.new(data, 1).go.parsed
+      end
+    end
+
+    class V4Parser
+      def initialize(raw, skipped = 0)
+        @data = raw
+        @refs = Hash.new{|h,k| h[k] = [:missing_ref]}
+        bytes_hex
+        @index = 0
+        consume("x" * skipped)
+        bytes_hex
+        @config = Config.new()
+      end
+
+      def parsed
+        return @config
+      end
+
+      def consume(template)
+        old_len = @data.length
+        values = @data.unpack(template + "a*")
+        @data = values.pop
+        @index += old_len - @data.length
+        return values
+      end
+
+      def bytes_hex(count = 8)
+        "0x%04x:#{' %02x'*count}" % ([@index] + @data.unpack("c" * count))
+      end
+
+      def go()
+        total_size = @data.length + 1
+        @keyboard_chord_table, @mouse_chord_table, @multichar_table = *consume("vvv")
+
+        @config.configs[:raw] = *consume("a#{@keyboard_chord_table - @index}")
+
+        until @index >= @mouse_chord_table
+          key1234, mod_or_ff, keyindex = consume("B16B8c")
+          exit if @index > 685 
+          if keyindex == 0 and 
+            key1234 == "0000000000000000" and 
+            mod_or_ff == "00000000"
+            next
+          end
+
+          chord = Config::KeyChord.new
+          chord.keydata = key1234
+
+          if(mod_or_ff == "11111111")
+            @refs[keyindex] = chord
+          else
+            chord.add_keystroke(mod_or_ff, keyindex)
+          end
+
+          @config.keyboard << chord
+        end
+
+        while @index < @multichar_table
+          key1234, data = consume("B16B8")
+          if key1234 == "0000000000000000" and 
+            data == "00000000"
+            next
+          end
+
+          chord_record = Config::MouseChord.new
+          chord_record.keydata = key1234
+          chord_record.data = data
+          @config.mouse << chord_record
+        end
+
+        data_idx = 0
+        until @data.size == 0 do
+          data_size = *consume("v")
+
+          chord_data = []
+          ((data_size-1)/2).times do 
+            mod, idx = *consume("B8c")
+            next if idx == 0 #Not sure this is sufficient
+            @refs[data_idx].add_keystroke(mod, idx)
+          end
+          data_idx += 1
+        end
+
+        return self
+      end
+    end
+  end
+end

data/lib/twiddler/rendering.rb

@@ -0,0 +1,23 @@
+require 'erb'
+
+module Twiddler
+  class Rendering
+    def initialize(config)
+      @config = config
+    end
+
+    def embed(name)
+      path = template_path(name)
+      template = File::read(path)
+      erb = ERB.new(template, nil, "%>")
+      erb.filename = path
+      mod = erb.def_module("render")
+      @config.extend(mod)
+    end
+
+    def template_path(name)
+      path = File::expand_path("../../templates/#{name}.erb", 
+                               File::dirname(__FILE__))
+    end
+  end
+end

data/lib/twiddler/target_builder.rb

@@ -0,0 +1,120 @@
+require 'fileutils'
+
+module Twiddler
+  module TargetBuilder
+    def self.build(output_dir, dictionary, config)
+      FileUtils::mkdir_p(output_dir)
+      File::open(dictionary, "r") do |dict|
+        Builder::registered.each do |klass|
+          dict.rewind
+          klass.new(output_dir, dict, config).go
+        end
+      end
+    end
+
+    class Builder
+      class << self
+        def register
+          @@registered ||= []
+          @@registered << self
+        end
+
+        def registered
+          @@registered || []
+        end
+      end
+
+      def initialize(dir, dict, config)
+        @dir = dir
+        @dict = dict
+        @config = config
+      end
+
+      def output_to(name)
+        File::open(File::expand_path("#{name}.list", @dir), "w") do |file|
+          yield(file)
+        end
+      end
+
+      def go
+      end
+    end
+
+    class RegexpBuilder < Builder
+      def match_any_of(list)
+        return "(?:#{list.map{|it| Regexp::escape(it)}.join(")|(?:")})"
+      end
+      def go
+        output_to(filename) do |file|
+          @dict.grep(regexp) do |word|
+            file.puts(word)
+          end
+        end
+      end
+    end
+
+    class ShortWords < RegexpBuilder
+      register
+
+      def filename
+        "Short Words"
+      end
+
+      def regexp
+        /^.{1,5}$/
+      end
+    end
+
+    class Macros < RegexpBuilder
+      register
+
+      def filename
+        "Macros"
+      end
+
+      def regexp
+        macros = @config.keyboard.find_all do |chord|
+          chord.keystrokes.length > 1 and chord.keystrokes.all? do |stroke|
+            stroke[1].empty?
+          end
+        end
+        return %r{^.{0,1}(?:#{match_any_of(macros.map{|chord| chord.render_action})}).{0,1}$}
+      end
+    end
+
+    class Flow < RegexpBuilder
+      register
+
+      def filename
+        "Flow"
+      end
+
+      def regexp
+        flow = []
+        chords = @config.keyboard.find_all do |chord|
+          chord.single? and chord.keystrokes[0][1].empty? and Config.keytable.is_tagged?(chord.keystrokes[0][0], :letters)
+        end
+
+        chords.each do |first|
+          chords.each do |second|
+            next if first == second
+            pairs = first.rows.zip(second.rows).find_all{|one,two| one != two}
+            case pairs.length 
+            when 1
+              flow << first.render_action + second.render_action
+              next
+            when 2
+              next if pairs.find{|pair| !pair.include?(:open)}
+              if pairs[0][0] == pairs[1][1] and pairs[0][1] == pairs[1][0]
+                flow << first.render_action + second.render_action
+                next
+              end
+            end
+          end
+        end
+
+        return %r{^.{0,1}(?:#{match_any_of(flow)}).{0,1}$}
+      end
+    end
+  end
+end

data/spec_help/file-sandbox.rb

@@ -0,0 +1,164 @@
+require 'ftools'
+require 'fileutils'
+
+module FileSandbox
+  def self.included(spec)
+    return unless spec.respond_to? :before
+
+    spec.before do
+      setup_sandbox
+    end
+
+    spec.after do
+      teardown_sandbox
+    end
+  end
+
+  class HaveContents
+    def initialize(contents)
+      @contents = contents
+    end
+
+    def matches?(target)
+      case @contents
+      when Regexp
+	@contents =~ target.contents
+      when String
+	@contents == target.contents
+      end
+    end
+  end
+
+  def have_contents(expected)
+    HaveContents.new(expected)
+  end
+
+  attr_reader :sandbox
+  
+  def in_sandbox(&block)
+    raise "I expected to create a sandbox as you passed in a block to me" if !block_given?
+
+    setup_sandbox
+    original_error = nil
+
+    begin
+      yield @sandbox
+    rescue => e
+      original_error = e
+      raise
+    ensure
+      begin
+        teardown_sandbox
+      rescue
+        if original_error
+          STDERR.puts "ALERT: a test raised an error and failed to release some lock(s) in the sandbox directory"
+          raise(original_error)
+        else
+          raise
+        end
+      end
+    end
+  end
+
+  def setup_sandbox(path = '__sandbox')
+    unless @sandbox
+      @sandbox = Sandbox.new(path)
+      @__old_path_for_sandbox = Dir.pwd
+      Dir.chdir(@sandbox.root)
+    end
+  end
+
+  def teardown_sandbox
+    if @sandbox
+      Dir.chdir(@__old_path_for_sandbox)
+      @sandbox.clean_up
+      @sandbox = nil
+    end
+  end
+
+  class Sandbox
+    attr_reader :root
+
+    def initialize(path = '__sandbox')
+      @root = File.expand_path(path)
+      clean_up
+      FileUtils.mkdir_p @root
+    end
+    
+    def [](name)
+      SandboxFile.new(File.join(@root, name), name)
+    end
+
+    # usage new :file=>'my file.rb', :with_contents=>'some stuff'
+    def new(options)
+      if options.has_key? :directory
+        dir = self[options.delete(:directory)]
+        FileUtils.mkdir_p dir.path
+      else
+        file = self[options.delete(:file)]
+        if (binary_content = options.delete(:with_binary_content) || options.delete(:with_binary_contents))
+          file.binary_content = binary_content
+        else
+          file.content = (options.delete(:with_content) || options.delete(:with_contents) || '')
+        end
+      end
+      
+      raise "unexpected keys '#{options.keys.join(', ')}'" unless options.empty?
+      
+      dir || file
+    end
+    
+    def remove(options)
+      name = File.join(@root, options[:file])
+      FileUtils.remove_file name
+    end
+    
+    def clean_up
+      FileUtils.rm_rf @root
+      if File.exists? @root
+        raise "Could not remove directory #{@root.inspect}, something is probably still holding a lock on it"
+      end
+    end
+  end
+
+
+  class SandboxFile
+    attr_reader :path
+    
+    def initialize(path, sandbox_path)
+      @path = path
+      @sandbox_path = sandbox_path
+    end
+
+    def inspect
+      "SandboxFile: #@sandbox_path"
+    end
+
+    def exist?
+      File.exist? path
+    end
+
+    def content
+      File.read path
+    end
+    
+    def content=(content)
+      FileUtils.mkdir_p File.dirname(@path)
+      File.open(@path, "w") {|f| f << content}
+    end
+    
+    def binary_content=(content)
+      FileUtils.mkdir_p File.dirname(@path)
+      File.open(@path, "wb") {|f| f << content}
+    end
+
+    def create
+      self.content = ''
+    end
+
+    alias exists? exist?
+    alias contents content
+    alias contents= content=
+    alias binary_contents= binary_content=    
+  end
+end