strcmp 1.0.0

data/Gemfile

@@ -0,0 +1,8 @@
+source :rubygems
+
+gem 'ffi', '~> 1.1.5'
+
+group :test do
+  gem 'rspec', '2.13.0'
+  gem 'jeweler'
+end

data/Gemfile.lock

@@ -0,0 +1,29 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.2.1)
+    ffi (1.1.5)
+    git (1.2.5)
+    jeweler (1.8.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    rake (10.0.3)
+    rdoc (3.9.5)
+    rspec (2.13.0)
+      rspec-core (~> 2.13.0)
+      rspec-expectations (~> 2.13.0)
+      rspec-mocks (~> 2.13.0)
+    rspec-core (2.13.0)
+    rspec-expectations (2.13.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.13.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  ffi (~> 1.1.5)
+  jeweler
+  rspec (= 2.13.0)

data/README.md

@@ -0,0 +1,27 @@
+strcmp
+======
+
+Strcmp is a simple ruby gem that is used to compute how similar two strings are
+to one another. It includes a fast C implementation of the [jaro-winkler]
+(http://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance) distance algorithm
+and soon the levenshtein distance algorithm. More metrics on the way. I claim no
+ownership of the algorithm.
+
+Installing
+==========
+
+    gem install strcmp
+
+Usage
+=====
+
+Using the gem is simple. First add the require statement to the file you wish to
+use it in.
+
+    require 'strcmp'
+
+To use the gem call:
+
+    StrCmp.jaro_winkler("martha", "marhta") => 0.961111
+    StrCmp.jaro("martha", "marhta") => 0.944444
+

data/Rakefile

@@ -0,0 +1,18 @@
+begin
+    require 'jeweler'
+        Jeweler::Tasks.new do |gemspec|
+        gemspec.name = "strcmp"
+        gemspec.summary = "A gem to compare strings and compute a distance or other metric between two strings."
+        gemspec.description = "A simple ruby gem that is used to compute how similar two strings are to one another. It includes a fast C implementation of the jaro-winkler distance algorith and soon the levenshtein distance algorithm. More metrics on the way."
+        gemspec.email = "rostepher.dev@gmail.com"
+        gemspec.homepage = "http://github.com/Rostepher/strcmp"
+        gemspec.authors = ["Ross Bayer"]
+        gemspec.add_dependency "ffi"
+        gemspec.add_development_dependency "rspec"
+        gemspec.add_development_dependency "jeweler"
+    end
+
+    Jeweler::GemcutterTasks.new
+rescue LoadError
+    puts "Jeweler does not seem to be here... Try installing it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/ext/strcmp/.gitignore

@@ -0,0 +1,4 @@
+*.out
+*.bundle
+*.o
+Makefile

data/ext/strcmp/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+$CFLAGS = "-std=c11 " + $CFLAGS
+create_makefile "strcmp"

data/ext/strcmp/jaro_winkler.c

@@ -0,0 +1,99 @@
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#define TRUE    1
+#define FALSE   0
+
+#define max(a, b) ((a) > (b) ? (a) : (b))
+#define min(a, b) ((a) < (b) ? (a) : (b))
+#define equal(a, b) (tolower(a) == tolower(b))
+#define not_equal(a, b) (tolower(a) != tolower(b))
+
+double jaro_distance(char *foo, char *bar) {
+    // length of the strings, stops the repeated use of strlen
+    int foo_len = strlen(foo);
+    int bar_len = strlen(bar);
+
+    // if both strings are empty return 1
+    // if only one of the strings is empty return 0
+    if (foo_len == 0) return bar_len == 0 ? 1.0 : 0.0;
+
+    // max distance between two chars to be considered matching
+    // floor() is ommitted due to integer division rules
+    int match_distance = (int) max(foo_len, bar_len)/2 - 1;
+
+    // arrays of bools that signify if that char in the matcing string has a match
+    int *foo_matches = calloc(foo_len, sizeof(int));
+    int *bar_matches = calloc(bar_len, sizeof(int));
+
+    // number of matches and transpositions
+    double matches = 0.0;
+    double transpositions = 0.0;
+
+    // find the matches
+    for (int i = 0; i < foo_len; i++) {
+        // start and end take into account the match distance
+        int start = max(0, i - match_distance);
+        int end = min(i + match_distance + 1, bar_len);
+
+        // add comments...
+        for (int k = start; k < end; k++) {
+            // if bar already has a match continue
+            if (bar_matches[k]) continue;
+            // if foo and bar are not
+            if (not_equal(foo[i], bar[k])) continue;
+            // otherwise assume there is a match
+            foo_matches[i] = TRUE;
+            bar_matches[k] = TRUE;
+            matches++;
+            break;
+        }
+    }
+
+    // if there are no matches return 0
+    if (matches == 0) {
+        free(foo_matches);
+        free(bar_matches);
+        return 0.0;
+    }
+
+    // count transpositions
+    int k = 0;
+    for (int i = 0; i < foo_len; i++) {
+        // if there are no matches in foo continue
+        if (!foo_matches[i]) continue;
+        // while there is no match in bar increment k
+        while (!bar_matches[k]) k++;
+        // increment transpositions
+        if (not_equal(foo[i], bar[k])) transpositions++;
+        k++;
+    }
+
+    // divide the number of transpositions by two as per the algorithm specs
+    // this division is valid because the counted transpositions include both
+    // instances of the transposed characters.
+    transpositions /= 2.0;
+
+    // free dat allocated memory !VERY IMPORTANT!
+    free(foo_matches);
+    free(bar_matches);
+
+    // return the jaro distance
+    return ((matches / foo_len) +
+        (matches / bar_len) +
+        ((matches - transpositions) / matches)) / 3.0;
+}
+
+double jaro_winkler_distance(char *foo, char *bar) {
+    // compute the jaro distance
+    double jaro = jaro_distance(foo, bar);
+
+    // finds the number of common terms in the first 3 strings, max 3.
+    int prefix_length = 0;
+    if (strlen(foo) != 0 && strlen(bar) != 0)
+        while (prefix_length < 3 && equal(*foo++, *bar++)) prefix_length++;
+
+    // 0.1 is the default scaling factor
+    return jaro + prefix_length * 0.1 * (1 - jaro);
+}

data/ext/strcmp/jaro_winkler.h

@@ -0,0 +1,2 @@
+double jaro_distance(char *, char *);
+double jaro_winkler_distance(char *, char *);

data/ext/strcmp/test.c

@@ -0,0 +1,15 @@
+#include <stdio.h>
+#include "jaro_winkler.h"
+
+int main(int argc, char *argv[]) {
+    //char *str1 = argv[1];
+    //char *str2 = argv[2];
+    char *str1[] = { "", "foobar", "martha", "dwayne", "dixon" };
+    char *str2[] = { "", "", "marhta", "duane", "dicksonx" };
+    for (int i = 0; i < 5; i++) {
+        double dist_1 = jaro_distance(str1[i], str2[i]);
+        double dist_2 = jaro_distance(str2[i], str1[i]);
+        printf("jaro_distance(\"%s\", \"%s\") => %f\n", str1[i], str2[i], dist_1);
+        printf("jaro_distance(\"%s\", \"%s\") => %f\n", str2[i], str1[i], dist_2);
+    }
+}

data/lib/strcmp.rb

@@ -0,0 +1,36 @@
+require 'ffi'
+
+module StrCmp
+    class << self
+        extend FFI::Library
+
+        # Try loading in order.
+        library = File.dirname(__FILE__) + "/../ext/strcmp/strcmp"
+        candidates = ['.bundle', '.so', '.dylib', ''].map { |ext| library + ext }
+        ffi_lib(candidates)
+
+        def jaro(string1, string2)
+            validate(string1)
+            validate(string2)
+            ffi_jaro(string1, string2)
+        end
+
+        def jaro_winkler(string1, string2)
+            validate(string1)
+            validate(string2)
+            ffi_jaro_winkler(string1, string2)
+        end
+
+        private
+        # attach the c functions with ffi
+        attach_function :ffi_jaro, :jaro_distance, [:string, :string], :double
+        attach_function :ffi_jaro_winkler, :jaro_winkler_distance, [:string, :string], :double
+
+        # confirm that the given object is a string, if not raise type error
+        def validate(object)
+            unless object.kind_of?(String)
+                raise TypeError, "Wrong argument type #{object.class} (expected String)"
+            end
+        end
+    end
+end

data/spec/jaro_winkler_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe JaroWinkler do
+    test_cases = [
+        ["", "", 1.0],
+        ["foobar", "", 0.0],
+        ["martha", "marhta", 0.961],
+        ["dwayne", "duane", 0.84],
+        ["dixon", "dicksonx", 0.813]
+    ]
+
+    test_cases.each do |str1, str2, distance|
+        it "should calculate the distance #{distance} from #{str1} and #{str2}" do
+            JaroWinkler.distance(str1, str2).round(3) == distance
+            JaroWinkler.distance(str2, str1).round(3) == distance
+        end
+    end
+
+    it "should raise an error if either arguemnt is nil" do
+        expect { JaroWinkler.distance("", nil) }.to raise_error TypeError
+        expect { JaroWinkler.distance(nil, "") }.to raise_error TypeError
+    end
+
+    it "should raise an error if either argument is not a string" do
+        expect { JaroWinkler.distance("foo", /bar/) }.to raise_error TypeError
+        expect { JaroWinkler.distance("42", 42) }.to raise_error TypeError
+        expect { JaroWinkler.distance("Object", Object.new) }.to raise_error TypeError
+    end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + "/../lib/strcmp"

data/strcmp.gemspec

@@ -0,0 +1,62 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "strcmp"
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ross Bayer"]
+  s.date = "2013-03-05"
+  s.description = "A simple ruby gem that is used to compute how similar two strings are to one another. It includes a fast C implementation of the jaro-winkler distance algorith and soon the levenshtein distance algorithm. More metrics on the way."
+  s.email = "rostepher.dev@gmail.com"
+  s.extensions = ["ext/strcmp/extconf.rb"]
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "ext/strcmp/.gitignore",
+    "ext/strcmp/extconf.rb",
+    "ext/strcmp/jaro_winkler",
+    "ext/strcmp/jaro_winkler.c",
+    "ext/strcmp/jaro_winkler.h",
+    "ext/strcmp/test.c",
+    "lib/strcmp.rb",
+    "spec/jaro_winkler_spec.rb",
+    "spec/spec_helper.rb",
+    "strcmp.gemspec"
+  ]
+  s.homepage = "http://github.com/Rostepher/strcmp"
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.25"
+  s.summary = "A gem to compare strings and compute a distance or other metric between two strings."
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<ffi>, ["~> 1.1.5"])
+      s.add_runtime_dependency(%q<ffi>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+    else
+      s.add_dependency(%q<ffi>, ["~> 1.1.5"])
+      s.add_dependency(%q<ffi>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<ffi>, ["~> 1.1.5"])
+    s.add_dependency(%q<ffi>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+  end
+end
+

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: strcmp
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Ross Bayer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.5
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A simple ruby gem that is used to compute how similar two strings are
+  to one another. It includes a fast C implementation of the jaro-winkler distance
+  algorith and soon the levenshtein distance algorithm. More metrics on the way.
+email: rostepher.dev@gmail.com
+executables: []
+extensions:
+- ext/strcmp/extconf.rb
+extra_rdoc_files:
+- README.md
+files:
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- VERSION
+- ext/strcmp/.gitignore
+- ext/strcmp/extconf.rb
+- ext/strcmp/jaro_winkler
+- ext/strcmp/jaro_winkler.c
+- ext/strcmp/jaro_winkler.h
+- ext/strcmp/test.c
+- lib/strcmp.rb
+- spec/jaro_winkler_spec.rb
+- spec/spec_helper.rb
+- strcmp.gemspec
+homepage: http://github.com/Rostepher/strcmp
+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.25
+signing_key: 
+specification_version: 3
+summary: A gem to compare strings and compute a distance or other metric between two
+  strings.
+test_files: []