string_score 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

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

data/README.mdown

@@ -0,0 +1,5 @@
+String Score (Ruby)
+===
+
+Port of https://github.com/joshaven/string_score from js to ruby.
+

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec
+

data/lib/string_score/version.rb

@@ -0,0 +1,3 @@
+module StringScore
+  VERSION = "0.0.1"
+end

data/lib/string_score.rb

@@ -0,0 +1,150 @@
+module StringScore
+
+  class InternalError < RuntimeError; end
+  class ArgumentError < RuntimeError; end
+
+  NON_STRING_MSG = "Supply a string or an object with can be coerced to a string."
+  NON_STRING_ERROR_MESSAGE = /undefined method `to_s'/
+
+  def score(target_string, fuzziness = 0.0)
+    if @string_scorer && @string_scorer.base_string != self
+      @string_scorer = nil
+    end
+    @string_scorer ||= StringScore.new(self, fuzziness)
+    @string_scorer.score(target_string)
+  end
+
+  # proxy to Scorer to simplify calling API
+  def self.new(base_string, fuzziness=0.0)
+    StringScore::Scorer.new(base_string.to_s, fuzziness)
+  end
+
+  class Scorer
+
+    attr_accessor :base_string, :default_fuziness
+
+    def initialize(string, fuzziness=0.0)
+      with_error_handling do
+        @default_fuziness = fuzziness
+        @base_string = string.to_s
+      end
+    end
+
+    def score(target_string, fuzziness=nil)
+      with_error_handling do
+        return 1 if (base_string == target_string.to_s)
+        partial_score(target_string, (fuzziness || default_fuziness))
+      end
+    end
+
+    def partial_score(target, fuzziness)
+
+      string = base_string.dup # clean copy for chomping
+      over_all_index = 0
+
+      cumulative_score = 0.0
+
+      target_length = target.length.to_f
+      string_length = string.length.to_f
+
+      start_of_string_bonus = false
+
+      abbreviation_score = 0
+      fuzzies = 1.0
+      final_score = 0.0
+
+      target_index = 0
+
+      target.each_char do |c|
+        over_all_index = (base_string.length - string.length)
+
+        character_score = 0.0
+
+        index_c_lowercase = string.index(c.downcase)
+        index_c_uppercase = string.index(c.upcase)
+
+        current_index = [index_c_lowercase, index_c_uppercase].compact.min
+        over_all_index += current_index.to_i
+
+        if ! current_index
+
+          if fuzziness > 0.0
+            fuzzies += (1 - fuzziness)
+            target_index += 1
+            next
+          else
+            return 0 # abort on any mismatch
+          end
+
+        end
+
+        if string[current_index] == c
+          character_score = 0.2 # exact case match
+        else
+          character_score = 0.1 # character but not case match
+        end
+
+        # consecutive bonus
+        if current_index == 0
+          character_score += 0.6
+          if target_index == 0
+            start_of_string_bonus = true
+          end
+        end
+
+        # acronym bonus
+        if base_string[over_all_index - 1] == ' '
+          character_score += 0.8
+        end
+
+        cumulative_score += character_score
+        target_index += 1
+        string = string[(current_index + 1), (string.length - 1)]
+      end
+
+      matched_score = cumulative_score.to_f / string_length.to_f
+
+      with_long_string_bonus = (((matched_score * (target_length.to_f / string_length.to_f)) + matched_score) / 2)
+
+      final_score = with_long_string_bonus / fuzzies
+
+      if start_of_string_bonus
+        if final_score + 0.15 < 1.0
+          final_score += 0.15
+        elsif final_score + 0.15 >= 1.0
+          final_score = 1.0
+        end
+      end
+
+      if final_score > 1.0 || final_score < 0.0
+        raise StringScore::InternalError, "Out of range score: '#{final_score}'"
+      end
+
+      final_score
+    end
+
+    def with_error_handling
+
+      yield
+
+    rescue StringScore::InternalError, StringScore::ArgumentError
+
+      raise # allow nesting of #with_error_handling
+
+    rescue NoMethodError => e
+
+      if e.message =~ NON_STRING_MSG
+        raise StringScore::ArgumentError, NON_STRING_MSG
+      else
+        raise StringScore::InternalError, "#{e.class}: #{e.message}"
+      end
+
+    rescue => e
+
+      raise StringScore::InternalError, "#{e.class}: #{e.message}"
+
+    end
+
+  end
+
+end

data/spec/string_score_spec.rb

@@ -0,0 +1,119 @@
+require 'string_score'
+
+String.send(:include, StringScore)
+
+RSpec::Matchers.define :be_greater_than do |expected|
+  match do |actual|
+    expected < actual
+  end
+end
+
+RSpec::Matchers.define :be_less_than do |expected|
+  match do |actual|
+    expected > actual
+  end
+end
+
+RSpec::Matchers.define :be_about do |expected|
+  match do |actual|
+    expected.to_f.round(5) == actual.to_f.round(5) # to 3 decimal points
+  end
+end
+
+describe StringScore do
+
+  subject { StringScore.new('Hello World') }
+
+  it "provides a method directly on a string instance" do
+    "foobar".score('foo').should == StringScore.new("foobar").score('foo')
+  end
+
+  it "scores at 1 for exact match" do
+    subject.score('Hello World').should == 1
+  end
+
+  # probably rare but need to handle just in case
+  it "allows updates of string to match against" do
+    string_to_match = "Hello World"
+    string_to_match.score('Hello World').should == 1
+    string_to_match.gsub!(/\w/, 'X')
+    string_to_match.score('Hello World').should_not == 1
+  end
+
+  it "scores 0 for non-matches (character not in string)" do
+    subject.score("hellx").should == 0
+    subject.score("hello_world").should == 0
+  end
+
+  it "matches sequentially" do
+    subject.score('WH').should == 0
+  end
+
+  it "prefers same-case matches" do
+    subject.score('hello').should be_less_than(subject.score('Hello'))
+  end
+
+  it "scores higher on closers matchs" do
+    subject.score('H').should be_less_than(subject.score('He'))
+  end
+
+  it "will match despite wrong case" do
+    subject.score("hello").should be_greater_than(0)
+  end
+
+  it "scores progressively higher weighting on more matches" do
+    subject.score("e").should be_less_than(subject.score("h"))
+    subject.score("h").should be_less_than(subject.score("he"))
+    subject.score("hel").should be_less_than(subject.score("hell"))
+    subject.score("hell").should be_less_than(subject.score("hello"))
+    subject.score("hello").should be_less_than(subject.score("helloworld"))
+    subject.score("helloworl").should be_less_than(subject.score("hello worl"))
+    subject.score("hello worl").should be_less_than(subject.score("hello world"))
+  end
+
+  it "provides a consecutive letter bonus" do
+    subject.score('Hel').should be_greater_than(subject.score('Hld'))
+  end
+
+  it "gives an acronym bonus" do
+    subject.score('HW').should be_greater_than(subject.score('Ho'))
+    'yet another Hello World'.score('yaHW').should be_greater_than('Hello World'.score('yet another'))
+    "Hillsdale Michigan".score("HiMi").should be_greater_than("Hillsdale Michigan".score("Hill"))
+
+    # I think these pass in error in the js version, will check
+    # "Hillsdale Michigan".score("HiMi").should be_greater_than("Hillsdale Michigan".score("hills"))
+    # "Hillsdale Michigan".score("HiMi").should be_greater_than("Hillsdale Michigan".score("hillsd"))
+    # "Hillsdale Michigan".score("HiMi").should be_greater_than("Hillsdale Michigan".score("illsda"))
+  end
+
+  it "gives a bonus for matching the start of the string" do
+    "Hillsdale".score("hi").should be_greater_than("Chippewa".score("hi"))
+    "hello world".score("h").should be_greater_than("hello world".score("w"))
+  end
+
+  it "gives proper string weights" do
+    "Research Resources North".score('res').should be_greater_than("Mary Conces".score('res'))
+    "Research Resources North".score('res').should be_greater_than("Bonnie Strathern - Southwest Michigan Title Search".score('res'))
+  end
+
+  it "gives start of string bonuses" do
+    "Mary Large".score('mar').should be_greater_than("Large Mary".score('mar'))
+    "Silly Mary Large".score('mar').should be_about("Silly Large Mary".score('mar'))
+  end
+
+
+  it "can fuzzily match strings" do
+    subject.score('Hz').should == 0
+    subject.score('Hz', 0.5).should be_less_than(subject.score('H', 0.5))
+  end
+
+  it "should be tuned well" do
+    "hello world".score("hello worl", 0.5).should be_greater_than("hello world".score("hello wor1", 0.5))
+    'Hello World'.score('jello',0.5).should be_greater_than(0)
+  end
+
+  it "should have varying degrees of fuziness" do
+    subject.score('Hz', 0.9).should be_greater_than(subject.score('Hz', 0.5))
+  end
+
+end

data/string_score.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "string_score/version"
+
+Gem::Specification.new do |s|
+  s.name        = "string_score"
+  s.version     = StringScore::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Jim Lindley"]
+  s.email       = ["jim@jimlindley.com"]
+  s.homepage    = ""
+  s.summary     = %q{Score how close a string is to another string.}
+  s.description = %q{Port of https://github.com/joshaven/string_score from js to ruby.}
+
+  s.rubyforge_project = "string_score"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+
+  s.add_development_dependency "rspec", '~>2.5.0'
+
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: string_score
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jim Lindley
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-15 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.5.0
+  type: :development
+  version_requirements: *id001
+description: Port of https://github.com/joshaven/string_score from js to ruby.
+email: 
+- jim@jimlindley.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.mdown
+- Rakefile
+- lib/string_score.rb
+- lib/string_score/version.rb
+- spec/string_score_spec.rb
+- string_score.gemspec
+has_rdoc: true
+homepage: ""
+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: string_score
+rubygems_version: 1.6.0
+signing_key: 
+specification_version: 3
+summary: Score how close a string is to another string.
+test_files: 
+- spec/string_score_spec.rb