obfs 0.0.2 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62ca2bff9fda087f834b3823adac6a193fd419c78e3dd72bdbf37b4b104c0e00
-  data.tar.gz: 07a819a4eb162a7bcbc43d3310f1a68ed4c6dd35b7cc1a333b69b57d536fc8bd
+  metadata.gz: 704cf6c36b527d888d2a755f3b41f56c94a9f121543e8337e7d9b8afb28f32b0
+  data.tar.gz: 4a9ed29dd0f313ca5ced039ef1d6900e02d9cede067e5d537596be532a23c57f
 SHA512:
-  metadata.gz: df53e0a7fed4b2f6e2b78fabe11ac0e40acc055128eff51119b9f615a25fe5bfe61becbac770043422c958d6ecc43fbb11b091fcfca68d91a5adf836d3320675
-  data.tar.gz: 45765a1f45e9b0969c8597003ca1f4b8e56fcc8bdba79bc5c6a326653b2cd2d682837d3e1d7e928226a40f2d32bef3426c2ccb7569bf2bfc3378907843c346af
+  metadata.gz: c2eddd3da38dc73e10715018286734ce0170b17ae73b6e459aa9faa9ca1ac94e27e4a3420423ff3b3a47fc84307d0f1f3caac2ad673bda405968cfe379f97f81
+  data.tar.gz: 3f2a4e93c277de2b09e449d3a2b05a5676e854ef511d5157cbbd908cec27308714e2ca5a685f9234aa21d648ccf31474396d15a063a780aed8039dded6df7644

data/lib/obfs.rb

@@ -1,119 +1,11 @@
-# dependencies
+# core
 require 'fileutils'
 require 'json'
-require 'text'
+require 'set'
 
-# main
-class OBFS
+# obfs
+require 'obfs/store'
 
-        def initialize(attributes = {}) # hash argument
-            @path = (attributes.keys.include? :path) ? attributes[:path] : (File.join(Dir.home, '.obfs'))
-        end
-
-        # regular methods
-
-        def method_missing(m, *args, &block)
-
-            # normalize
-            method_name = m.to_s
-            dataA = args[0]
-            dataB = args[1]
-
-            # setter call
-            if  method_name.end_with?('=')
-
-                # clean up name
-                method_name = method_name.gsub('=','')
-
-                # reassign if square bracket notation
-                if method_name == "[]"
-                    method_name = dataA
-                    data = dataB
-                else # make sure we load the proper method_name and data
-                    method_name = m.to_s.gsub('=','')
-                    data = args[0]
-                end
-                    
-                # write data
-                if data == nil
-                    FileUtils.rm_rf (File.join @path, method_name)
-                else
-                    FileUtils.rm_rf (File.join @path, method_name) if File.exist? (File.join @path, method_name)
-                    FileUtils.mkpath @path if !File.directory? @path
-                    write(@path, method_name, data)
-                end
-            
-            # bracket notation
-            elsif method_name == "[]"
-
-                method_name = dataA.to_s.gsub(/\["/,'').gsub(/"\]/,'')
-                if (!File.directory? File.join(@path, method_name)) && (File.exist? File.join(@path, method_name))
-                    read(@path, method_name)
-                else
-                    OBFS.new({ path: File.join(@path, method_name.to_s) })
-                end
-
-            # recurse or read
-            else
-
-                if (!File.directory? File.join(@path, method_name)) && (File.exist? File.join(@path, method_name))
-                    read(@path, method_name)
-                else
-                    OBFS.new({ path: File.join(@path, method_name.to_s) })
-                end
-
-            end
-            
-        end
-
-        # special methods
-
-        # returns current working path for obfs
-        def _path
-            @path
-        end
-
-        # returns directory contents in an array
-        def _index
-            Dir.entries(@path).reject { |k| k == '.' || k == '..' } rescue nil
-        end
-
-        # searches directory contents (1 level) and returns array sorted by relevance
-        def _find(term = '', records = 1000, tolerance = 10)
-            output = []
-            search_space = Dir.entries(@path).reject { |k| k == '.' || k == '..' } rescue []
-            search_space.each do |search_space_term|
-                if Text::Levenshtein.distance(search_space_term, term) <= tolerance && Text::WhiteSimilarity.similarity(search_space_term, term) > 0.0
-                    output << search_space_term
-                end
-            end
-            output.first(records)
-        end
-
-        # searches directory contents (1 level) and returns boolean if term exist
-        def _exist(term = '')
-            exist_space = Dir.entries(@path).reject { |k| k != term.to_s }
-            if exist_space.length > 0
-                true
-            else
-                false
-            end
-        end
-
-        private
-
-        # filesystem R/W
-
-        def write(path, filename, data)
-            Thread.new {
-                curr_path = File.join path, filename
-                File.write(curr_path, JSON.unparse(data))
-            }
-        end
-
-        def read(path, filename)
-            curr_path = File.join path, filename
-            JSON.parse(File.open(curr_path).read) rescue File.open(curr_path).read
-        end
-
-end
+# third party
+require 'text/levenshtein'
+require 'text/white_similarity'

data/lib/obfs/store.rb

@@ -0,0 +1,132 @@
+module OBFS
+
+    class Store
+
+            def initialize(attributes = {}) # hash argument
+                @path = (attributes.keys.include? :path) ? attributes[:path] : (File.join(Dir.home, '.obfs'))
+            end
+
+            # regular methods
+
+            def method_missing(m, *args, &block)
+
+                # normalize
+                method_name = m.to_s
+                dataA = args[0]
+                dataB = args[1]
+
+                # prevent traversing out of dir
+                raise "traversal through . and .. not allowed" if ['.', '..'].include? method_name
+
+                # setter call
+                if  method_name.end_with?('=')
+
+                    # clean up name
+                    method_name = method_name.gsub('=','')
+
+                    # reassign if square bracket notation
+                    if method_name == "[]"
+                        method_name = dataA
+                        data = dataB
+                    else # make sure we load the proper method_name and data
+                        method_name = m.to_s.gsub('=','')
+                        data = args[0]
+                    end
+
+                    # prevent traversing out of dir
+                    raise "traversal through . and .. not allowed" if ['.', '..'].include? method_name
+                        
+                    # write data
+                    if data == nil
+                        FileUtils.rm_rf (File.join @path, method_name)
+                    else
+                        FileUtils.rm_rf (File.join @path, method_name) if File.exist? (File.join @path, method_name)
+                        FileUtils.mkpath @path if !File.directory? @path
+                        write(@path, method_name, data)
+                    end
+                
+                # bracket notation
+                elsif method_name == "[]"
+
+                    method_name = dataA.to_s.gsub(/\["/,'').gsub(/"\]/,'')
+
+                    # prevent traversing out of dir
+                    raise "traversal through . and .. not allowed" if ['.', '..'].include? method_name
+                        
+                    if (!File.directory? File.join(@path, method_name)) && (File.exist? File.join(@path, method_name))
+                        read(@path, method_name)
+                    else
+                        OBFS::Store.new({ path: File.join(@path, method_name.to_s) })
+                    end
+
+                # recurse or read
+                else
+
+                    # prevent traversing out of dir
+                    raise "traversal through . and .. not allowed" if ['.', '..'].include? method_name
+
+                    if (!File.directory? File.join(@path, method_name)) && (File.exist? File.join(@path, method_name))
+                        read(@path, method_name)
+                    else
+                        OBFS::Store.new({ path: File.join(@path, method_name.to_s) })
+                    end
+
+                end
+                
+            end
+
+            # special methods
+
+            # returns current working path for obfs
+            def _path
+                @path
+            end
+
+            # returns directory contents in an array
+            def _index
+                Dir.entries(@path).reject { |k| k == '.' || k == '..' } rescue nil
+            end
+
+            # searches directory contents (1 level) and returns array sorted by relevance
+            def _find(term = '', records = 1000, tolerance = 50)
+                output = []
+                search_space = Dir.entries(@path).reject { |k| k == '.' || k == '..' } rescue []
+                search_space.each do |search_space_term|
+                    if OBFS::Levenshtein.distance(search_space_term, term) <= tolerance && OBFS::WhiteSimilarity.similarity(search_space_term, term) > 0.0
+                        output << search_space_term
+                    end
+                end
+                output.first(records)
+            end
+
+            # searches directory contents (1 level) and returns boolean if term exist
+            def _exist(term = '')
+                exist_space = Dir.entries(@path).reject { |k| k != term.to_s || k == '.' || k == '..' } rescue nil
+                if !exist_space.nil?
+                    if exist_space.length > 0
+                        true
+                    else
+                        false
+                    end
+                else
+                    false
+                end 
+            end
+
+            private
+
+            # filesystem R/W
+
+            def write(path, filename, data)
+                curr_path = File.join path, filename
+                File.write(curr_path, JSON.unparse(data))
+            end
+
+            def read(path, filename)
+                curr_path = File.join path, filename
+                JSON.parse(File.open(curr_path).read) rescue File.open(curr_path).read
+            end
+
+    end
+
+end

data/lib/text/levenshtein.rb

@@ -0,0 +1,166 @@
+#
+# 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

@@ -0,0 +1,66 @@
+#
+# 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: obfs
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.1
 platform: ruby
 authors:
 - Jensel Gatchalian
@@ -17,6 +17,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/obfs.rb
+- lib/obfs/store.rb
+- lib/text/levenshtein.rb
+- lib/text/white_similarity.rb
 homepage: https://github.com/jenselg/obfs-ruby
 licenses:
 - MIT