keyboard_distance 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*~
+*.swp

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 snukky
+
+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,58 @@
+# KeyboardDistance
+
+Simple algorithm for measuring of distance-on-keyboard between two strings
+for various keyboard layouts.
+
+A diagonal distance between two keys equals the longer distance in a straight 
+line to the appropriate row/column, e.g.:
+
+    require 'keyboard_distance'
+    keyboard = KeyboardDistance.new
+
+    keyboard.character_distance('q', 'w') # => 1.0
+    keyboard.character_distance('q', 's') # => 1.0
+    keyboard.character_distance('q', 'd') # => 2.0
+
+The similarity of the two strings is:
+
+    1.0 - (D / (L * M))
+
+Where `D` is the distance between the two strings, L is the length of the
+longer string, and M is the maximum key distance for given layout.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'keyboard_distance'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install keyboard_distance
+
+## Usage
+
+Require the gem:
+
+    require 'keyboard_distance'
+
+Basic usage:
+
+    keyboard = KeyboardDistance.new
+    keyboard.distance("foo", "boo")   # => 1.0
+    keyboard.similarity("foo", "boo") # => 0.9770114942528736
+
+    keyboard.distance("foo", "Boo")   # => 2.0
+    keyboard.similarity("foo", "Boo") # => 0.9540229885057472
+
+Extra parameters:
+
+    keyboard = KeyboardDistance.new(:layout => :qwerty,
+                                    :national_keys => :polish,
+                                    :alt_distance => 0.5)
+
+    keyboard.distance("między", "miedzy") # => 0.5

data/Rakefile

@@ -0,0 +1,10 @@
+#!/usr/bin/env rake
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+desc "Run the specs under spec/"
+RSpec::Core::RakeTask.new :test do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rspec_opts = ['--color']
+end

data/keyboard_distance.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/keyboard_distance/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["snukky"]
+  gem.email         = ["snk987@gmail.com"]
+  gem.description   = %q{Simple algorithm for measuring of distance-on-keyboard 
+                      between two strings.}
+  gem.summary       = %q{Distance-on-keyboard algorithm.}
+  gem.homepage      = "https://github.com/snukky/keyboard_distance"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "keyboard_distance"
+  gem.require_paths = ["lib"]
+  gem.version       = KeyboardDistance::VERSION
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec', '>= 2.0.0'
+end

data/lib/keyboard_distance.rb

@@ -0,0 +1,119 @@
+# encoding: utf-8
+
+require "keyboard_distance/version"
+require "keyboard_distance/keyboard_layout"
+
+class KeyboardDistance
+
+  attr_reader :max_distance
+
+  SHIFT_DISTANCE = 1.0
+  ALT_DISTANCE = 0.5
+  SPACE_DISTANCE = 2.0
+  UNKNOWN_CHAR_DISTANCE = 3.0
+
+  def initialize(options={})
+    @layout = options[:layout] || :qwerty
+    raise "Unknown layout :#{@layout}" unless KeyboardLayout.layout_defined?(@layout)
+
+    @national_keys = options[:national_keys] || :polish 
+    raise "Unknown national keys #{@national_keys}" unless !@national_keys ||
+      KeyboardLayout.national_defined?(@national_keys)
+
+    @shift_distance = options[:shift_distance] || SHIFT_DISTANCE
+    @alt_distance = options[:alt_distance] || ALT_DISTANCE
+    @space_distance = options[:space_distance] || SPACE_DISTANCE
+    @unknown_char_distance = options[:unknown_char_distance] || UNKNOWN_CHAR_DISTANCE
+
+    @distances = calculate_distances
+    @max_distance = calculate_max_distance
+
+    @shift_map = KeyboardLayout.build_shifted_keys_map(@layout)
+    @alt_map = KeyboardLayout.build_alted_keys_map(@national_keys) if @national_keys
+  end
+
+  def similarity(word_1, word_2)
+    return nil unless word_1.size == word_2.size
+
+    max_word_length = [word_1.size, word_2.size].max
+    1.0 - distance(word_1, word_2) / (max_word_length * @max_distance)
+  end
+
+  def distance(word_1, word_2)
+    return nil unless word_1.size == word_2.size
+    return 0.0 if word_1 == word_2
+
+    dist = 0.0
+    word_1.each_char.with_index do |char_1, idx|
+      dist += character_distance(char_1, word_2[idx])
+    end
+
+    dist
+  end
+
+  def character_distance(char_1, char_2)
+    return 0.0 if char_1 == char_2
+    return @space_distance if char_1 == ' ' || char_2 == ' '
+    dist = 0.0
+
+    if @national_keys
+      key_1, key_2, difference = unalt_keys(char_1, char_2)
+      dist += @alt_distance if difference
+    end
+
+    key_1, key_2, difference = unshift_keys(key_1 || char_1, key_2 || char_2)
+    dist += @shift_distance if difference
+
+    return dist if key_1 == key_2
+
+    dist + (@distances[keys_signature(key_1, key_2)] || @unknown_char_distance)
+  end
+
+  private
+
+  def calculate_distances 
+    distances = {}
+
+    KeyboardLayout.foreach_unique_key_pair(@layout) do |key_1, key_2, indexes|
+      keys = keys_signature(key_1, key_2)
+      next if distances.include?(keys)
+
+      distances[keys] = key_distance(*indexes)
+    end
+
+    distances
+  end
+
+  def key_distance(idx_11, idx_12, idx_21, idx_22)
+    [(idx_11 - idx_21).abs, (idx_12 - idx_22).abs].max
+  end
+
+  def keys_signature(key_1, key_2)
+   [key_1, key_2].sort.join 
+  end
+
+  def unshift_keys(key_1, key_2)
+    unshifted_key_1 = @shift_map[key_1] || key_1
+    unshifted_key_2 = @shift_map[key_2] || key_2
+
+    difference = (unshifted_key_1 != key_1 && unshifted_key_2 == key_2) ||
+                 (unshifted_key_1 == key_1 && unshifted_key_2 != key_2)
+
+    return [unshifted_key_1, unshifted_key_2, difference]
+  end
+
+  def unalt_keys(key_1, key_2)
+    unalted_key_1 = @alt_map[key_1] || key_1
+    unalted_key_2 = @alt_map[key_2] || key_2
+
+    difference = (unalted_key_1 != key_1 && unalted_key_2 == key_2) ||
+                 (unalted_key_1 == key_1 && unalted_key_2 != key_2)
+
+    return [unalted_key_1, unalted_key_2, difference]
+  end
+
+  def calculate_max_distance
+    @distances.values.max + @alt_distance + @shift_distance
+  end
+
+end

data/lib/keyboard_distance/keyboard_layout.rb

@@ -0,0 +1,112 @@
+# encoding: utf-8
+
+class KeyboardLayout
+  
+  LAYOUTS = {
+    :qwerty => {
+      :normal => ['`1234567890-=', ' qwertyuiop[]\\', " asdfghjkl;'", ' zxcvbnm,./'],
+      :shift  => ['~!@#$%^&*()_+', ' QWERTYUIOP{}|',  ' ASDFGHJKL:"', ' ZXCVBNM<>?']
+    },
+    :qwertz => {
+      :normal => ['`1234567890-=', ' qwertzuiop[]\\', " asdfghjkl;'", ' yxcvbnm,./'],
+      :shift  => ['~!@#$%^&*()_+', ' QWERTZUIOP{}|',  ' ASDFGHJKL:"', ' YXCVBNM<>?']
+    }
+  }
+
+  NATIONAL_KEYS = {
+    :polish => ["ąćęłńóśżźĄĆĘŁŃÓŚŻŹ", "acelnoszzACELNOSZZ"]
+  }
+
+  EMPTY_KEY = ' '
+
+  class << self
+    def layout_defined?(layout)
+      LAYOUTS.keys.include?(layout)
+    end
+
+    def national_defined?(national)
+      NATIONAL_KEYS.keys.include?(national)
+    end
+
+    def build_shifted_keys_map(layout)
+      keys = layout_as_array(layout, :normal).flatten
+      shifted_keys = layout_as_array(layout, :shift).flatten
+
+      raise "Different number of shifted and unshifted keys for layout" \
+        " :#{layout}" unless keys.size == shifted_keys.size
+
+      shift_map = {}
+      shifted_keys.each_with_index do |shifted_key, idx|
+        shift_map[shifted_key] = keys[idx]
+      end
+
+      shift_map
+    end
+
+    def build_alted_keys_map(national)
+      national_keys = NATIONAL_KEYS[national]
+      raise "Undefined national keys #{}" if national_keys.nil?
+
+      raise "Different number of national and ASCII keys for " \
+        " :#{national}" unless national_keys[0].size == national_keys[1].size
+      
+      alt_map = {}
+      national_keys[0].split('').each_with_index do |char, idx|
+        alt_map[char] = national_keys[1][idx]
+      end
+
+      alt_map
+    end
+    
+    def foreach_unique_key_pair(layout, &block)
+      keyboard = layout_as_array(layout, :normal)
+
+      keyboard.each_with_index do |row_1, idx_11|
+        row_1.each_with_index do |key_1, idx_12|
+          keyboard.each_with_index do |row_2, idx_21|
+            row_2.each_with_index do |key_2, idx_22|
+              next if key_1 == key_2 || key_1 == EMPTY_KEY || key_2 == EMPTY_KEY
+              yield key_1, key_2, [idx_11, idx_12, idx_21, idx_22]
+            end
+          end
+        end
+      end
+    end
+
+    def print_layout(layout, type=:normal)
+      keyboard = layout_as_array(layout, type)
+      max_row_size = keyboard.map(&:size).max
+        
+      puts format_header(max_row_size), format_separator(max_row_size)
+      keyboard.each_with_index { |keys, idx| puts format_row(idx, keys) }
+      puts format_separator(max_row_size)
+    end
+
+    private
+
+    def layout_as_array(layout, type=:normal)
+      raise "Undefined layout :#{layout}" unless layout_defined?(layout)
+
+      LAYOUTS[layout][type].map{ |line| line.split('') }
+    end
+
+    def format_header(length)
+      header = "   |"
+      length.times{ |i| header << sprintf(" %-3d", i) }
+      header
+    end
+
+    def format_separator(length)
+      separator = " --+"
+      length.times{ |i| separator << "---+"}
+      separator
+    end
+
+    def format_row(idx, keys)
+      row = " #{idx} |"
+      keys.each{ |k| row << " #{k} |" }
+      row
+    end
+  end
+
+end

data/lib/keyboard_distance/version.rb

@@ -0,0 +1,3 @@
+class KeyboardDistance
+  VERSION = "0.0.1"
+end

data/spec/keyboard_distance_spec.rb

@@ -0,0 +1,118 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe KeyboardDistance do
+  before :all do
+    @keyboard = KeyboardDistance.new(:layout => :qwerty,
+                                     :national_keys => :polish,
+                                     :shift_distance => 1,
+                                     :alt_distance => 0.5,
+                                     :space_distance => 2,
+                                     :unknown_char_distance => 1)
+  end
+
+  describe "character_distance" do
+    it "should return zero for equal characters" do
+      @keyboard.character_distance('a', 'a').should eql 0.0
+      @keyboard.character_distance('A', 'A').should eql 0.0
+      @keyboard.character_distance('ą', 'ą').should eql 0.0
+    end
+
+    it "should measure distances in a straight line" do
+      @keyboard.character_distance('a', 's').should eql 1.0
+      @keyboard.character_distance('a', 'l').should eql 8.0
+      @keyboard.character_distance('a', 'z').should eql 1.0
+      @keyboard.character_distance('a', '1').should eql 2.0
+    end
+
+    it "should measure diagonally distances" do
+      @keyboard.character_distance('s', 'q').should eql 1.0
+      @keyboard.character_distance('s', 'e').should eql 1.0
+      @keyboard.character_distance('s', 'c').should eql 1.0
+      @keyboard.character_distance('s', 'z').should eql 1.0
+
+      @keyboard.character_distance('q', 'd').should eql 2.0
+      @keyboard.character_distance('q', '3').should eql 2.0
+
+      @keyboard.character_distance('q', 'p').should eql 9.0
+    end
+
+    it "should increase distance when shift is pressed" do
+      @keyboard.character_distance('a', 'z').should be <
+        @keyboard.character_distance('A', 'z')
+    end
+
+    it "should return the same distance when shift is pressed twice" do
+      @keyboard.character_distance('a', 'y').should eql \
+        @keyboard.character_distance('A', 'Y')
+    end
+
+    it "should increase distance when alt is pressed" do
+      @keyboard.character_distance('a', 'z').should be <
+        @keyboard.character_distance('ą', 'z')
+    end
+    
+    it "should return the same distance when alt is pressed twice" do
+      @keyboard.character_distance('a', 'z').should eql \
+        @keyboard.character_distance('ą', 'ż')
+    end
+
+    it "should work with a space character" do
+      expect{ @keyboard.character_distance('a', ' ') }.not_to raise_error
+    end
+
+    it "should work with unknown character" do
+      expect{ @keyboard.character_distance('a', '¶') }.not_to raise_error
+    end
+  end
+
+  describe "distance" do
+    it "should return zero for equals words" do
+      @keyboard.distance("foo", "foo").should eql 0.0
+      @keyboard.distance("FOO", "FOO").should eql 0.0
+    end
+
+    it "should measure distance as the sum of character distances" do
+      word_1 = "foo"
+      word_2 = "bar"
+
+      sum_of_char_distances = 0.0
+      word_1.each_char.with_index do |char, idx|
+        sum_of_char_distances += @keyboard.character_distance(char, word_2[idx])
+      end
+
+      @keyboard.distance(word_1, word_2).should eql sum_of_char_distances
+    end
+
+    it "should measure simple distances" do
+      @keyboard.distance("asd", "sdf").should eql 3.0
+      @keyboard.distance("1qaz", "2wsx").should eql 4.0
+      @keyboard.distance("qsc", "wdv").should eql 3.0
+
+      @keyboard.distance("foo", "Foo").should eql 1.0
+      @keyboard.distance("laka", "łąka").should eql 1.0
+    end
+
+    it "should work with different length strings" do
+      expect{ @keyboard.distance("foo", "bar baz") }.not_to raise_error
+    end
+  end
+
+  describe "similarity" do
+    it "should give 1 for the same strings" do
+      @keyboard.similarity("foo", "foo").should eql 1.0
+    end
+
+    it "should work for simple strings" do
+      expected_value = (1 - 1 / (3 * @keyboard.max_distance))
+      @keyboard.similarity("foo", "boo").should eql expected_value
+    end
+
+    it "should decrease similarity for longer string" do
+      @keyboard.similarity("foo", "boo").should be <
+        @keyboard.similarity("foooooo", "boooooo")
+    end
+  end
+
+end

data/spec/keyboard_layout_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe KeyboardLayout do
+  before :all do
+    @layout = KeyboardLayout::LAYOUTS.keys.first
+  end
+
+  describe "build_shifted_keys_map" do
+    it "should return a Hash object" do
+      KeyboardLayout.build_shifted_keys_map(@layout).should be_kind_of Hash
+    end
+
+    it "should have capital characters as keys" do
+      KeyboardLayout.build_shifted_keys_map(@layout).keys
+        .all?{ |big| big.upcase == big }.should be_true
+    end
+
+    it "should have small characters as keys" do
+      KeyboardLayout.build_shifted_keys_map(@layout).values
+        .all?{ |small| small.downcase == small }.should be_true
+    end
+  end
+
+  describe "layout_defined?" do
+    it "should raise error when access to undefined layout" do
+      expect{ KeyboardLayout.print_layout(:unexisted_layout) }.to raise_error
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'keyboard_distance'

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: keyboard_distance
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- snukky
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &69387850 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *69387850
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &69387230 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *69387230
+description: ! "Simple algorithm for measuring of distance-on-keyboard \n                      between
+  two strings."
+email:
+- snk987@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- keyboard_distance.gemspec
+- lib/keyboard_distance.rb
+- lib/keyboard_distance/keyboard_layout.rb
+- lib/keyboard_distance/version.rb
+- spec/keyboard_distance_spec.rb
+- spec/keyboard_layout_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/snukky/keyboard_distance
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Distance-on-keyboard algorithm.
+test_files:
+- spec/keyboard_distance_spec.rb
+- spec/keyboard_layout_spec.rb
+- spec/spec_helper.rb