obfs 0.1.2 → 0.3.0

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,24 +1,26 @@
 --- !ruby/object:Gem::Specification
 name: obfs
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Jensel Gatchalian
 bindir: bin
 cert_chain: []
-date: 2021-01-16 00:00:00.000000000 Z
+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
@@ -37,7 +39,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.18
+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