obfs 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 648385c40ccd4ea5cb5f608fc7164e1c86757f5ec6c2053711ebf71eab7fa752
-  data.tar.gz: f89b3c016e0949fab62abf7187970db6e16524e927dfa5a98747a6e3d6e7bc83
+  metadata.gz: 2a4b8b313bcfac3893da631ea24c90b5cf39f7337e4dd804e922edfa893d4d77
+  data.tar.gz: b7afaac2c2fa61e82e888223dd6473a14dbde609dea0eb67b06d2069bafb164a
 SHA512:
-  metadata.gz: d6617be8b4f8d2c57f9ad353eb5954cf66604c1bfcf03dac73465d0e2854257e52efe979225a55907e75c6be1e59834fbb55f1ba80983bb638c4639f05065569
-  data.tar.gz: 02f0c229b2cff282033822c0d3502b006714ec361411f284123b971bf04ee1f8f94bbb77409bd39a7b66205adf95d2fe8f464fe8d3a24779720148457256fab2
+  metadata.gz: b782fbfd5d5c740c3256a74b0fb66083d102cc71c59439c673c9a86bc516a438aa63f673d7a609d55d3376fb548421d846345142429b211eeb3e3b304b0edbc6
+  data.tar.gz: 3fdd856e0c0c4d65b593f47893c3a85d8d2a3514a03f28656eebbece06aa5ff22a746c58f9b022b14d761187b0cd5ef7336113912caf82c06c80de4a4881fdce

data/README.md

@@ -0,0 +1,602 @@
+# OBFS
+
+[![Gem Version](https://badge.fury.io/rb/obfs.svg)](https://badge.fury.io/rb/obfs)
+
+File-based, object-oriented data store for Ruby.
+
+OBFS maps recursive Ruby object access directly to the filesystem, allowing data to be addressed using dot notation, bracket notation, or a combination of both.
+
+```ruby
+datastore.users.cat.preferences.theme = "dark"
+
+datastore["users"]["cat"]["preferences"]["theme"]
+# => "dark"
+```
+
+The resulting filesystem structure is:
+
+```text
+users/
+└── cat/
+    └── preferences/
+        └── theme
+```
+
+OBFS also includes filesystem discovery helpers, including direct existence checks, recursive fuzzy directory search, timestamps, and directory indexing. It uses Ruby standard libraries and independent OBFS-owned text algorithms, with no external runtime gem dependencies.
+
+
+## Quickstart
+
+Add OBFS to your `Gemfile`:
+
+```ruby
+gem "obfs"
+```
+
+Require it:
+
+```ruby
+require "obfs"
+```
+
+Create a store:
+
+```ruby
+datastore = OBFS::Store.new
+```
+
+Write data:
+
+```ruby
+datastore.somefile = "some value"
+
+datastore["somefile"] = "some value"
+```
+
+Read data:
+
+```ruby
+datastore.somefile
+
+datastore["somefile"]
+```
+
+Delete data:
+
+```ruby
+datastore.somefile = nil
+
+datastore["somefile"] = nil
+```
+
+Supported values include:
+
+- String
+- Array
+- Hash
+- Integer
+- Float
+- Boolean
+
+
+## Usage
+
+By default, OBFS stores data inside:
+
+```text
+~/.obfs
+```
+
+A custom path can be specified:
+
+```ruby
+datastore = OBFS::Store.new({
+  path: "/some/other/folder"
+})
+```
+
+Paths are recursively created as needed.
+
+For example:
+
+```ruby
+datastore.some.long.path.to.create = "some string"
+```
+
+creates:
+
+```text
+some/
+└── long/
+    └── path/
+        └── to/
+            └── create
+```
+
+The file `create` contains the JSON-serialized value:
+
+```text
+"some string"
+```
+
+Bracket notation can also be used:
+
+```ruby
+datastore["some"]["long"]["path"]["to"]["create"] = "some string"
+```
+
+Dot and bracket notation may be mixed:
+
+```ruby
+datastore.some["long"].path["to"].create = "some string"
+```
+
+Hashes and arrays are serialized as JSON values into leaf files:
+
+```ruby
+datastore.settings = {
+  "theme" => "dark",
+  "notifications" => true
+}
+
+datastore.numbers = [1, 2, 3]
+```
+
+Reading those values returns the corresponding Ruby objects:
+
+```ruby
+datastore.settings
+# => {"theme"=>"dark", "notifications"=>true}
+
+datastore.numbers
+# => [1, 2, 3]
+```
+
+
+## Path Safety
+
+Each OBFS key represents exactly one filesystem node.
+
+Nested paths should therefore be expressed recursively:
+
+```ruby
+datastore["foo"]["bar"]
+```
+
+rather than by embedding filesystem separators:
+
+```ruby
+datastore["foo/bar"]
+```
+
+OBFS rejects keys containing filesystem path separators, null bytes, `.` or `..`.
+
+For example, the following are rejected:
+
+```ruby
+datastore[".."]
+datastore["../foo"]
+datastore["../../etc/passwd"]
+datastore["foo/bar"]
+datastore["..\\Windows"]
+```
+
+This prevents dynamic OBFS keys from traversing outside the intended datastore hierarchy.
+
+
+## Special Methods
+
+### `_path`
+
+Returns the current filesystem path.
+
+```ruby
+datastore.some.data._path
+```
+
+Example:
+
+```text
+/home/user/.obfs/some/data
+```
+
+
+### `_index`
+
+Returns the entries in the current directory.
+
+```ruby
+datastore.some.data._index
+```
+
+Example:
+
+```ruby
+[
+  "foo",
+  "bar",
+  "baz"
+]
+```
+
+
+### `_keys`
+
+Alias for `_index`.
+
+```ruby
+datastore.some.data._keys
+```
+
+
+### `_find`
+
+Performs a fuzzy search against entries in the current directory only.
+
+```ruby
+datastore.some.data._find("some term")
+```
+
+Full signature:
+
+```ruby
+datastore.some.data._find(term, records, tolerance)
+```
+
+Arguments:
+
+- `term` - search term
+- `records` - maximum number of records to return; defaults to `1000`
+- `tolerance` - maximum Levenshtein distance; defaults to `50`
+
+Results are returned as an array of entry names sorted by relevance. Entries must be within the Levenshtein tolerance and have a positive normalized bigram/Dice similarity score. The distance check is case-sensitive; similarity normalizes case, path separators, and whitespace.
+
+Example:
+
+```ruby
+datastore.services._find("nginx")
+```
+
+might return:
+
+```ruby
+[
+  "nginx",
+  "nginx_config",
+  "old_nginx"
+]
+```
+
+`_find` searches only the current directory level.
+
+
+### `_exist`
+
+Checks whether an immediate child with the specified name exists.
+
+```ruby
+datastore.some.data._exist("some term")
+```
+
+Returns:
+
+```ruby
+true
+```
+
+or:
+
+```ruby
+false
+```
+
+This method is retained for compatibility with earlier versions of OBFS.
+
+
+### `_exists`
+
+Checks whether the current OBFS node physically exists.
+
+```ruby
+datastore.some.data._exists
+```
+
+A question-mark alias is also available:
+
+```ruby
+datastore.some.data._exists?
+```
+
+Example:
+
+```ruby
+datastore.services.nginx._exists?
+# => true
+```
+
+
+### `_has`
+
+Checks whether an immediate child exists.
+
+```ruby
+datastore.services._has("nginx")
+```
+
+A question-mark alias is also available:
+
+```ruby
+datastore.services._has?("nginx")
+```
+
+Returns:
+
+```ruby
+true
+```
+
+or:
+
+```ruby
+false
+```
+
+Unlike `_exist`, `_has` performs a direct filesystem existence check rather than enumerating the current directory.
+
+
+### `_timestamp`
+
+Returns the modification time of the current filesystem node.
+
+```ruby
+datastore.services.nginx._timestamp
+```
+
+Returns a Ruby `Time` object when the node exists:
+
+```ruby
+2026-10-04 14:30:00 -0700
+```
+
+or:
+
+```ruby
+nil
+```
+
+if the node does not exist or cannot be read.
+
+
+### `_search`
+
+Performs a fuzzy search against directory names and relative directory paths.
+
+Unlike `_find`, `_search` can recursively search the entire directory hierarchy beneath the current OBFS node.
+
+Basic usage:
+
+```ruby
+datastore._search("nginx")
+```
+
+Example result:
+
+```ruby
+[
+  {
+    path: "systems/services/nginx",
+    score: 1.0
+  },
+  {
+    path: "systems/services/nginx/certificates",
+    score: 0.95
+  }
+]
+```
+
+Search may also be scoped to any recursive OBFS node:
+
+```ruby
+datastore.systems.services._search("nginx")
+```
+
+Options can be supplied using a hash:
+
+```ruby
+datastore._search(
+  "nginx certificate",
+  {
+    recursive: true,
+    min_score: 0.6,
+    limit: 10
+  }
+)
+```
+
+Available options:
+
+- `recursive` - recursively search child directories; defaults to `true`
+- `min_score` - minimum fuzzy relevance score from `0.0` to `1.0`; defaults to `0.5`
+- `limit` - maximum number of results; unlimited by default
+
+`minScore` is also accepted for compatibility with the JavaScript version:
+
+```ruby
+datastore._search(
+  "nginx",
+  {
+    minScore: 0.6
+  }
+)
+```
+
+Search results are sorted from highest to lowest relevance.
+
+`_search`:
+
+- searches directory names
+- searches relative directory paths
+- does not read stored file contents
+- does not follow symbolic links
+- ignores dot-prefixed entries
+- is scoped to the current OBFS node
+
+
+## `_find` vs `_search`
+
+`_find` is intended for lightweight one-level discovery:
+
+```ruby
+datastore.services._find("nginx")
+```
+
+and returns:
+
+```ruby
+[
+  "nginx",
+  "nginx_config"
+]
+```
+
+`_search` is intended for deeper discovery:
+
+```ruby
+datastore._search("nginx certificate")
+```
+
+and returns scored relative paths:
+
+```ruby
+[
+  {
+    path: "systems/services/nginx/certificates",
+    score: 0.95
+  }
+]
+```
+
+
+## Recursive Object Storage
+
+One of the primary goals of OBFS is to allow the filesystem to behave like an arbitrarily recursive Ruby object.
+
+For example:
+
+```ruby
+datastore.projects.example.servers.production.services.nginx.status = "running"
+```
+
+can later be accessed using the same structure:
+
+```ruby
+datastore.projects.example.servers.production.services.nginx.status
+# => "running"
+```
+
+The hierarchy itself is stored using physical directories and files, making the datastore directly inspectable using normal filesystem tools.
+
+
+## Notes
+
+- OBFS uses the filesystem directly as its persistence layer.
+- Intermediate paths are created automatically when writing data.
+- Setting a value to `nil` removes the corresponding file or directory recursively.
+- Existing values are replaced when reassigned.
+- JSON-compatible values are serialized using Ruby's JSON library.
+- Files containing valid JSON are deserialized when read.
+- Non-JSON files are returned as raw text.
+- Fuzzy search uses independent `OBFS::Levenshtein` and `OBFS::StringSimilarity` implementations.
+- No external runtime gem dependencies are required; the Text gem is not needed.
+- No database server is required.
+
+
+## Platform Support
+
+OBFS requires Ruby >= 2.0.0. The updated text algorithms use Ruby 2.0-compatible APIs. Syntax and basic behavior were validated on Ruby 4.0.7 on Linux; this update has not been tested on Ruby 2.0 itself.
+
+Windows and macOS have not been formally tested.
+
+
+## Links
+
+- [RubyGems](https://rubygems.org/gems/obfs)
+- [GitHub](https://github.com/jenselg/obfs-ruby)
+- [JavaScript / Node.js Version](https://github.com/jenselg/obfs)
+
+
+## Text Algorithms
+
+The algorithms are implemented locally in `lib/obfs/levenshtein.rb` and
+`lib/obfs/string_similarity.rb`. Requiring `obfs` loads both automatically.
+
+### `OBFS::Levenshtein.distance`
+
+Calculates unit-cost insertion, deletion, and substitution distance over Unicode
+codepoints. Inputs must support String encoding; Unicode normalization is not
+performed.
+
+```ruby
+OBFS::Levenshtein.distance("kitten", "sitting")
+# => 3
+
+OBFS::Levenshtein.distance("kitten", "sitting", 2)
+# => 2
+```
+
+The optional `max_distance` must be a nonnegative Integer or `nil`. When supplied,
+the result is capped at that maximum, preserving the existing API contract. A
+result equal to the maximum means the actual distance is at least that value.
+
+### `OBFS::StringSimilarity.similarity`
+
+Returns a normalized character-bigram Dice score between `0.0` and `1.0`. It
+normalizes case, path separators (`/`, `\`, `:`, `_`, and `-`), and whitespace.
+Bigrams span the normalized string, including spaces, and repeated bigrams count
+separately. Unicode codepoints are used without Unicode normalization.
+
+```ruby
+OBFS::StringSimilarity.similarity("France", "French")
+# => 0.4
+
+OBFS::StringSimilarity.similarity("nginx_config", "NGINX CONFIG")
+# => 1.0
+```
+
+Equal nonempty normalized strings score `1.0`, including one-character strings.
+Empty inputs score `0.0`; unequal one-character strings score `0.0`.
+
+Store relevance takes the highest score from exact, prefix, substring, token
+coverage, normalized Levenshtein, and Dice matching. `_find` and `_search` retain
+their signatures and result formats, but rankings can change with the new Dice
+scorer.
+
+When upgrading, replace `lib/obfs/white_similarity.rb` with
+`lib/obfs/string_similarity.rb` and update any direct `OBFS::WhiteSimilarity`
+references to `OBFS::StringSimilarity`. The copied Text implementations and
+`text/*` requires are no longer used.
+
+
+## License
+
+### MIT License
+
+Copyright (c) 2021 Jensel Gatchalian <jensel.gatchalian@gmail.com>
+
+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/lib/obfs/levenshtein.rb

@@ -0,0 +1,41 @@
+module OBFS
+  module Levenshtein
+    extend self
+
+    # Unit-cost edit distance over Unicode codepoints, without normalization.
+    # With a maximum, return the exact distance capped at that maximum.
+    def distance(str1, str2, max_distance = nil)
+      unless max_distance.nil? ||
+             (max_distance.is_a?(Integer) && max_distance >= 0)
+        raise ArgumentError, 'max_distance must be a nonnegative Integer or nil'
+      end
+      return 0 if max_distance == 0
+
+      left = str1.encode('UTF-8').each_codepoint.to_a
+      right = str2.encode('UTF-8').each_codepoint.to_a
+      return 0 if left == right
+
+      # The shorter input determines the width of the two working rows.
+      left, right = right, left if left.length < right.length
+      if max_distance && left.length - right.length >= max_distance
+        return max_distance
+      end
+      return left.length if right.empty?
+
+      previous = (0..right.length).to_a
+      left.each_with_index do |character, row|
+        current = [row + 1]
+        right.each_with_index do |other, column|
+          current << [current[column] + 1,
+                      previous[column + 1] + 1,
+                      previous[column] + (character == other ? 0 : 1)].min
+        end
+        # Every path to the final cell crosses this row; costs cannot decrease.
+        return max_distance if max_distance && current.min >= max_distance
+        previous = current
+      end
+
+      max_distance ? [previous.last, max_distance].min : previous.last
+    end
+  end
+end

data/lib/obfs/store.rb

@@ -249,7 +249,7 @@ module OBFS
 
 
         similarity =
-          OBFS::WhiteSimilarity.similarity(
+          OBFS::StringSimilarity.similarity(
             search_space_term,
             term
           )
@@ -753,8 +753,8 @@ module OBFS
     # - prefix matches
     # - substring matches
     # - token coverage
-    # - existing Levenshtein implementation
-    # - existing WhiteSimilarity implementation
+    # - OBFS Levenshtein distance
+    # - normalized bigram/Dice similarity
     #
     # No additional dependencies required.
     # ------------------------------------------------------------
@@ -859,42 +859,10 @@ module OBFS
 
 
       # ----------------------------------------------------------
-      # existing WhiteSimilarity
+      # normalized bigram/Dice similarity
       # ----------------------------------------------------------
 
-      begin
-
-        white_score =
-          OBFS::WhiteSimilarity.similarity(
-            query,
-            value
-          ).to_f
-
-
-        # support either:
-        #
-        #   0.0 - 1.0
-        #
-        # or:
-        #
-        #   0 - 100
-        #
-
-        white_score /= 100.0 if white_score > 1.0
-
-
-        white_score = 0.0 if white_score < 0.0
-        white_score = 1.0 if white_score > 1.0
-
-
-        scores << white_score
-
-
-      rescue
-
-        # Remaining scorers are sufficient.
-
-      end
+      scores << OBFS::StringSimilarity.similarity(query, value)
 
 
       scores.empty? ? 0.0 : scores.max

data/lib/obfs/string_similarity.rb

@@ -0,0 +1,41 @@
+module OBFS
+  module StringSimilarity
+    extend self
+
+    # Dice overlap of character-bigram multisets. Repeated pairs count separately.
+    # Case, path separators and whitespace are normalized before comparison.
+    # Empty text has no evidence of similarity; equal nonempty text scores 1.0.
+    def similarity(str1, str2)
+      left = normalize(str1)
+      right = normalize(str2)
+      return 0.0 if left.empty? || right.empty?
+      return 1.0 if left == right
+
+      left_pairs = bigrams(left)
+      right_pairs = bigrams(right)
+      total = left_pairs.values.inject(0, :+) + right_pairs.values.inject(0, :+)
+      return 0.0 if total == 0
+
+      overlap = left_pairs.inject(0) do |sum, entry|
+        pair, count = entry
+        sum + [count, right_pairs[pair]].min
+      end
+      2.0 * overlap / total
+    end
+
+    private
+
+    def normalize(value)
+      value.to_s.encode('UTF-8').downcase
+        .gsub(/[\\\/:_\-]+/, ' ')
+        .gsub(/\s+/, ' ').strip
+    end
+
+    def bigrams(value)
+      counts = Hash.new(0)
+      characters = value.each_codepoint.to_a
+      characters.each_cons(2) { |pair| counts[pair] += 1 }
+      counts
+    end
+  end
+end

data/lib/obfs.rb

@@ -4,8 +4,6 @@ require 'json'
 require 'set'
 
 # obfs
+require 'obfs/levenshtein'
+require 'obfs/string_similarity'
 require 'obfs/store'
-
-# third party
-require 'text/levenshtein'
-require 'text/white_similarity'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: obfs
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Jensel Gatchalian
@@ -9,16 +9,18 @@ bindir: bin
 cert_chain: []
 date: 2026-10-04 00:00:00.000000000 Z
 dependencies: []
-description: File-based, object-oriented data store for Ruby
+description: File-based, object-oriented data store for Ruby with recursive access,
+  fuzzy discovery, and no external runtime dependencies.
 email: jensel.gatchalian@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- README.md
 - lib/obfs.rb
+- lib/obfs/levenshtein.rb
 - lib/obfs/store.rb
-- lib/text/levenshtein.rb
-- lib/text/white_similarity.rb
+- lib/obfs/string_similarity.rb
 homepage: https://github.com/jenselg/obfs-ruby
 licenses:
 - MIT
@@ -39,5 +41,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.20
 specification_version: 4
-summary: OBFS
+summary: Filesystem-backed object store with fuzzy discovery
 test_files: []

data/lib/text/levenshtein.rb

@@ -1,166 +0,0 @@
-#
-# Credits to threedaymonk
-# https://github.com/threedaymonk/text/blob/master/lib/text/levenshtein.rb
-#
-# Levenshtein distance algorithm implementation for Ruby, with UTF-8 support.
-#
-# The Levenshtein distance is a measure of how similar two strings s and t are,
-# calculated as the number of deletions/insertions/substitutions needed to
-# transform s into t. The greater the distance, the more the strings differ.
-#
-# The Levenshtein distance is also sometimes referred to as the
-# easier-to-pronounce-and-spell 'edit distance'.
-#
-# Author: Paul Battley (pbattley@gmail.com)
-#
-
-module OBFS # :nodoc:
-
-    module Levenshtein
-    
-      # Calculate the Levenshtein distance between two strings +str1+ and +str2+.
-      #
-      # The optional argument max_distance can reduce the number of iterations by
-      # stopping if the Levenshtein distance exceeds this value. This increases
-      # performance where it is only necessary to compare the distance with a
-      # reference value instead of calculating the exact distance.
-      #
-      # The distance is calculated in terms of Unicode codepoints. Be aware that
-      # this algorithm does not perform normalisation: if there is a possibility
-      # of different normalised forms being used, normalisation should be performed
-      # beforehand.
-      #
-      def distance(str1, str2, max_distance = nil)
-        if max_distance
-          distance_with_maximum(str1, str2, max_distance)
-        else
-          distance_without_maximum(str1, str2)
-        end
-      end
-    
-    private
-
-      def distance_with_maximum(str1, str2, max_distance) # :nodoc:
-        s = str1.encode(Encoding::UTF_8).unpack("U*")
-        t = str2.encode(Encoding::UTF_8).unpack("U*")
-    
-        n = s.length
-        m = t.length
-        big_int = n * m
-    
-        # Swap if necessary so that s is always the shorter of the two strings
-        s, t, n, m = t, s, m, n if m < n
-    
-        # If the length difference is already greater than the max_distance, then
-        # there is nothing else to check
-        if (n - m).abs >= max_distance
-          return max_distance
-        end
-    
-        return 0 if s == t
-        return m if n.zero?
-        return n if m.zero?
-    
-        # The values necessary for our threshold are written; the ones after must
-        # be filled with large integers since the tailing member of the threshold
-        # window in the bottom array will run min across them
-        d = (m + 1).times.map { |i|
-          if i < m || i < max_distance + 1
-            i
-          else
-            big_int
-          end
-        }
-        x = nil
-        e = nil
-    
-        n.times do |i|
-          # Since we're reusing arrays, we need to be sure to wipe the value left
-          # of the starting index; we don't have to worry about the value above the
-          # ending index as the arrays were initially filled with large integers
-          # and we progress to the right
-          if e.nil?
-            e = i + 1
-          else
-            e = big_int
-          end
-    
-          diag_index = t.length - s.length + i
-    
-          # If max_distance was specified, we can reduce second loop. So we set
-          # up our threshold window.
-          # See:
-          # Gusfield, Dan (1997). Algorithms on strings, trees, and sequences:
-          # computer science and computational biology.
-          # Cambridge, UK: Cambridge University Press. ISBN 0-521-58519-8.
-          # pp. 263–264.
-          min = i - max_distance - 1
-          min = 0 if min < 0
-          max = i + max_distance
-          max = m - 1 if max > m - 1
-    
-          min.upto(max) do |j|
-            # If the diagonal value is already greater than the max_distance
-            # then we can safety return: the diagonal will never go lower again.
-            # See: http://www.levenshtein.net/
-            if j == diag_index && d[j] >= max_distance
-              return max_distance
-            end
-    
-            cost = s[i] == t[j] ? 0 : 1
-            insertion = d[j + 1] + 1
-            deletion = e + 1
-            substitution = d[j] + cost
-            x = insertion < deletion ? insertion : deletion
-            x = substitution if substitution < x
-    
-            d[j] = e
-            e = x
-          end
-          d[m] = x
-        end
-    
-        if x > max_distance
-          return max_distance
-        else
-          return x
-        end
-      end
-    
-      def distance_without_maximum(str1, str2) # :nodoc:
-        s = str1.encode(Encoding::UTF_8).unpack("U*")
-        t = str2.encode(Encoding::UTF_8).unpack("U*")
-    
-        n = s.length
-        m = t.length
-    
-        return m if n.zero?
-        return n if m.zero?
-    
-        d = (0..m).to_a
-        x = nil
-    
-        n.times do |i|
-          e = i + 1
-          m.times do |j|
-            cost = s[i] == t[j] ? 0 : 1
-            insertion = d[j + 1] + 1
-            deletion = e + 1
-            substitution = d[j] + cost
-            x = insertion < deletion ? insertion : deletion
-            x = substitution if substitution < x
-    
-            d[j] = e
-            e = x
-          end
-          d[m] = x
-        end
-    
-        return x
-      end
-    
-      extend self
-
-    end
-    
-end

data/lib/text/white_similarity.rb

@@ -1,66 +0,0 @@
-#
-# Credits to threedaymonk
-# https://github.com/threedaymonk/text/blob/master/lib/text/white_similarity.rb
-#
-# encoding: utf-8
-# Original author: Wilker Lúcio <wilkerlucio@gmail.com>
-
-module OBFS
-
-  # Ruby implementation of the string similarity described by Simon White
-  # at: http://www.catalysoft.com/articles/StrikeAMatch.html
-  #
-  #                        2 * |pairs(s1) INTERSECT pairs(s2)|
-  #   similarity(s1, s2) = -----------------------------------
-  #                            |pairs(s1)| + |pairs(s2)|
-  #
-  # e.g.
-  #                                             2 * |{FR, NC}|
-  #   similarity(FRANCE, FRENCH) = ---------------------------------------
-  #                                |{FR,RA,AN,NC,CE}| + |{FR,RE,EN,NC,CH}|
-  #
-  #                              = (2 * 2) / (5 + 5)
-  #
-  #                              = 0.4
-  #
-  #   WhiteSimilarity.new.similarity("FRANCE", "FRENCH")
-  #
-  class WhiteSimilarity
-
-    def self.similarity(str1, str2)
-      new.similarity(str1, str2)
-    end
-
-    def initialize
-      @word_letter_pairs = {}
-    end
-
-    def similarity(str1, str2)
-      pairs1 = word_letter_pairs(str1)
-      pairs2 = word_letter_pairs(str2).dup
-
-      union = pairs1.length + pairs2.length
-
-      intersection = 0
-      pairs1.each do |pair1|
-        if index = pairs2.index(pair1)
-          intersection += 1
-          pairs2.delete_at(index)
-        end
-      end
-
-      (2.0 * intersection) / union
-    end
-
-  private
-
-    def word_letter_pairs(str)
-      @word_letter_pairs[str] ||=
-        str.upcase.split(/\s+/).map{ |word|
-          (0 ... (word.length - 1)).map { |i| word[i, 2] }
-        }.flatten.freeze
-    end
-    
-  end
-  
-end