confidential_info_redactor_lite 0.0.34 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 05d26fbe6fe84f3a1f695b05a47ff9ae555cbb06
-  data.tar.gz: 9be6e91bf1e96e8f237820ac53de547ce534c9d6
+  metadata.gz: 9cc0f357a427f4cc05da05abd1d0c89544f18e34
+  data.tar.gz: f76b54f78599ac06388f649a95a48f3bafe9e248
 SHA512:
-  metadata.gz: 528f42365aadf05514ec5d56d088e838392473c3cb80a8210302fc8a256bcbb9ed98817c2fd6d3034f99f0aef4b47f4ed67a393c654cdaecb84bc034f0eddd3d
-  data.tar.gz: d1c900aefe94e6a45a1c7c28d8dd61ac23b39f46f6f0ea1076e126312148254aa84349527b0183221e3c4519997a6d865993ddb573e94ee3dfd37e45506042d4
+  metadata.gz: e79cdf4659e79523dccba90d68b64e6b963511eded9621c7db79f15864292f1508b2034354511199d5e140da71e3421ea3d1bbc5e617d67a0873aa4bb3ae6504
+  data.tar.gz: e2f843ce61d278521a4ebd75e3d71979947f9cd53d0fe4e825ca49d305fb86d53088d96c6bd43238e594ae77369ce4143fe61a2b19f5d704817d47d529c29f74

data/lib/confidential_info_redactor_lite/date.rb

@@ -16,103 +16,33 @@ module ConfidentialInfoRedactorLite
 
     JA_DATE_REGEX_SHORT = /[０１２３４５６７８９]+月[０１２３４５６７８９]+日/
 
-    attr_reader :string, :dow, :dow_abbr, :months, :months_abbr
-    def initialize(string:, dow:, dow_abbr:, months:, months_abbr:)
-      @string = string
+    attr_reader :dow, :dow_abbr, :months, :months_abbr
+    def initialize(dow:, dow_abbr:, months:, months_abbr:)
       @dow = dow
       @dow_abbr = dow_abbr
       @months = months
       @months_abbr = months_abbr
     end
 
-    def includes_date?
-      long_date || number_only_date
+    def includes_date?(text)
+      includes_long_date?(text) || includes_number_only_date?(text)
     end
 
-    def replace
-      return string unless dow.kind_of?(Array) && dow_abbr.kind_of?(Array) && months.kind_of?(Array) && months_abbr.kind_of?(Array)
-      new_string = string.dup
+    def replace(text)
+      return text unless is_an_array?
       counter = 0
-      dow_abbr.each do |day|
-        counter +=1 if string.include?('day')
-      end
-      new_string = new_string.gsub(JA_DATE_REGEX_LONG, '<redacted date>')
-      new_string = new_string.gsub(JA_DATE_REGEX_SHORT, '<redacted date>')
-      if counter > 0
-        dow_abbr.each do |day|
-          months.each do |month|
-            new_string = new_string.gsub(/#{Regexp.escape(day)}(\.)*(,)*\s#{Regexp.escape(month)}\s\d+(rd|th|st)*(,)*\s\d{4}/i, ' <redacted date> ')
-          end
-          months_abbr.each do |month|
-            new_string = new_string.gsub(/#{Regexp.escape(day)}(\.)*(,)*\s#{Regexp.escape(month)}(\.)*\s\d+(rd|th|st)*(,)*\s\d{4}/i, ' <redacted date> ')
-          end
-        end
-        dow.each do |day|
-          months.each do |month|
-            new_string = new_string.gsub(/#{Regexp.escape(day)}(,)*\s#{Regexp.escape(month)}(\.)*\s\d+(rd|th|st)*(,)*\s\d{4}/i, ' <redacted date> ')
-                                   .gsub(/\d+\s+de\s+#{Regexp.escape(month)}\s\d{4}/i, ' <redacted date> ')
-                                   .gsub(/\d{2}(\.|-|\/)*\s?#{Regexp.escape(month)}(\.|-|\/)*\s?(\d{4}|\d{2})/i, ' <redacted date> ')
-                                   .gsub(/#{Regexp.escape(month)}(\.)*\s\d+(rd|th|st)*(,)*\s\d{4}/i, ' <redacted date> ')
-                                   .gsub(/\d{4}\.*\s#{Regexp.escape(month)}\s\d+(rd|th|st)*/i, ' <redacted date> ')
-                                   .gsub(/\d{4}(\.|-|\/)*#{Regexp.escape(month)}(\.|-|\/)*\d+/i, ' <redacted date> ')
-                                   .gsub(/#{Regexp.escape(month)}(\.)*\s\d+(rd|th|st)*/i, ' <redacted date> ')
-                                   .gsub(/#{Regexp.escape(month)}\sde\s\d+(rd|th|st)*/i, ' <redacted date> ')
-          end
-          months_abbr.each do |month|
-            new_string = new_string.gsub(/#{Regexp.escape(day)}(,)*\s#{Regexp.escape(month)}(\.)*\s\d+(rd|th|st)*(,)*\s\d{4}/i, ' <redacted date> ')
-                                   .gsub(/\d+\s+de\s+#{Regexp.escape(month)}\s\d{4}/i, ' <redacted date> ')
-                                   .gsub(/\d{2}(\.|-|\/)*\s?#{Regexp.escape(month)}(\.|-|\/)*\s?(\d{4}|\d{2})/i, ' <redacted date> ')
-                                   .gsub(/#{Regexp.escape(month)}(\.)*\s\d+(rd|th|st)*(,)*\s\d{4}/i, ' <redacted date> ')
-                                   .gsub(/\d{4}\.*\s#{Regexp.escape(month)}\s\d+(rd|th|st)*/i, ' <redacted date> ')
-                                   .gsub(/\d{4}(\.|-|\/)*#{Regexp.escape(month)}(\.|-|\/)*\d+/i, ' <redacted date> ')
-                                   .gsub(/#{Regexp.escape(month)}(\.)*\s\d+(rd|th|st)*/i, ' <redacted date> ')
-                                   .gsub(/#{Regexp.escape(month)}\sde\s\d+(rd|th|st)*/i, ' <redacted date> ')
-          end
-        end
-      else
-        dow.each do |day|
-          months.each do |month|
-            new_string = new_string.gsub(/#{Regexp.escape(day)}(,)*\s#{Regexp.escape(month)}(\.)*\s\d+(rd|th|st)*(,)*\s\d{4}/i, ' <redacted date> ')
-                                   .gsub(/\d+\s+de\s+#{Regexp.escape(month)}\s\d{4}/i, ' <redacted date> ')
-                                   .gsub(/\d{2}(\.|-|\/)*\s?#{Regexp.escape(month)}(\.|-|\/)*\s?(\d{4}|\d{2})/i, ' <redacted date> ')
-                                   .gsub(/#{Regexp.escape(month)}(\.)*\s\d+(rd|th|st)*(,)*\s\d{4}/i, ' <redacted date> ')
-                                   .gsub(/\d{4}\.*\s#{Regexp.escape(month)}\s\d+(rd|th|st)*/i, ' <redacted date> ')
-                                   .gsub(/\d{4}(\.|-|\/)*#{Regexp.escape(month)}(\.|-|\/)*\d+/i, ' <redacted date> ')
-                                   .gsub(/#{Regexp.escape(month)}(\.)*\s\d+(rd|th|st)*/i, ' <redacted date> ')
-                                   .gsub(/#{Regexp.escape(month)}\sde\s\d+(rd|th|st)*/i, ' <redacted date> ')
-          end
-          months_abbr.each do |month|
-            new_string = new_string.gsub(/#{Regexp.escape(day)}(,)*\s#{Regexp.escape(month)}(\.)*\s\d+(rd|th|st)*(,)*\s\d{4}/i, ' <redacted date> ')
-                                   .gsub(/\d+\s+de\s+#{Regexp.escape(month)}\s\d{4}/i, ' <redacted date> ')
-                                   .gsub(/\d{2}(\.|-|\/)*\s?#{Regexp.escape(month)}(\.|-|\/)*\s?(\d{4}|\d{2})/i, ' <redacted date> ')
-                                   .gsub(/#{Regexp.escape(month)}(\.)*\s\d+(rd|th|st)*(,)*\s\d{4}/i, ' <redacted date> ')
-                                   .gsub(/\d{4}\.*\s#{Regexp.escape(month)}\s\d+(rd|th|st)*/i, ' <redacted date> ')
-                                   .gsub(/\d{4}(\.|-|\/)*#{Regexp.escape(month)}(\.|-|\/)*\d+/i, ' <redacted date> ')
-                                   .gsub(/#{Regexp.escape(month)}(\.)*\s\d+(rd|th|st)*/i, ' <redacted date> ')
-                                   .gsub(/#{Regexp.escape(month)}\sde\s\d+(rd|th|st)*/i, ' <redacted date> ')
-          end
-        end
-        dow_abbr.each do |day|
-          months.each do |month|
-            new_string = new_string.gsub(/#{Regexp.escape(day)}(\.)*(,)*\s#{Regexp.escape(month)}\s\d+(rd|th|st)*(,)*\s\d{4}/i, ' <redacted date> ')
-          end
-          months_abbr.each do |month|
-            new_string = new_string.gsub(/#{Regexp.escape(day)}(\.)*(,)*\s#{Regexp.escape(month)}(\.)*\s\d+(rd|th|st)*(,)*\s\d{4}/i, ' <redacted date> ')
-          end
-        end
-      end
-      new_string = new_string.gsub(DMY_MDY_REGEX, ' <redacted date> ')
-                     .gsub(YMD_YDM_REGEX, ' <redacted date> ')
-                     .gsub(DIGIT_ONLY_YEAR_FIRST_REGEX, ' <redacted date> ')
-                     .gsub(DIGIT_ONLY_YEAR_LAST_REGEX, ' <redacted date> ')
+      dow_abbr.map { |day| counter +=1 if text.include?('day') }
+      text = text.gsub(JA_DATE_REGEX_LONG, '<redacted date>').gsub(JA_DATE_REGEX_SHORT, '<redacted date>')
+      text = redact_dates(counter, text)
+      redact_regex(text)
     end
 
-    def occurences
-      replace.scan(/<redacted date>/).size
+    def occurences(text)
+      replace(text).scan(/<redacted date>/).size
     end
 
-    def replace_number_only_date
-      string.gsub(DMY_MDY_REGEX, ' <redacted date> ')
+    def replace_number_only_date(text)
+      text.gsub(DMY_MDY_REGEX, ' <redacted date> ')
             .gsub(YMD_YDM_REGEX, ' <redacted date> ')
             .gsub(DIGIT_ONLY_YEAR_FIRST_REGEX, ' <redacted date> ')
             .gsub(DIGIT_ONLY_YEAR_LAST_REGEX, ' <redacted date> ')
@@ -120,45 +50,89 @@ module ConfidentialInfoRedactorLite
 
     private
 
-    def long_date
-      match_found = false
+    def is_an_array?
+      dow.kind_of?(Array) && dow_abbr.kind_of?(Array) && months.kind_of?(Array) && months_abbr.kind_of?(Array)
+    end
+
+    def redact_dates(counter, text)
+      if counter > 0
+        text = redact_dow_abbr(text)
+        text = redact_dow(text)
+      else
+        text = redact_dow(text)
+        text = redact_dow_abbr(text)
+      end
+      text
+    end
+
+    def redact_regex(text)
+      text.gsub(DMY_MDY_REGEX, ' <redacted date> ')
+          .gsub(YMD_YDM_REGEX, ' <redacted date> ')
+          .gsub(DIGIT_ONLY_YEAR_FIRST_REGEX, ' <redacted date> ')
+          .gsub(DIGIT_ONLY_YEAR_LAST_REGEX, ' <redacted date> ')
+    end
+
+    def redact_dow(text)
       dow.each do |day|
-        months.each do |month|
-          break if match_found
-          match_found = check_for_matches(day, month)
-        end
-        months_abbr.each do |month|
-          break if match_found
-          match_found = check_for_matches(day, month)
-        end
+        months.map { |month| text = redact_date(text, day, month) }
+        months_abbr.map { |month| text = redact_date(text, day, month) }
       end
+      text
+    end
+
+    def redact_dow_abbr(text)
+      dow_abbr.each do |day|
+        months.map { |month| text = text.gsub(/#{Regexp.escape(day)}(\.)*(,)*\s#{Regexp.escape(month)}\s\d+(rd|th|st)*(,)*\s\d{4}/i, ' <redacted date> ') }
+        months_abbr.map { |month| text = text.gsub(/#{Regexp.escape(day)}(\.)*(,)*\s#{Regexp.escape(month)}(\.)*\s\d+(rd|th|st)*(,)*\s\d{4}/i, ' <redacted date> ') }
+      end
+      text
+    end
+
+    def redact_date(text, day, month)
+      text.gsub(/#{Regexp.escape(day)}(,)*\s#{Regexp.escape(month)}(\.)*\s\d+(rd|th|st)*(,)*\s\d{4}/i, ' <redacted date> ')
+                       .gsub(/\d+\s+de\s+#{Regexp.escape(month)}\s\d{4}/i, ' <redacted date> ')
+                       .gsub(/\d{2}(\.|-|\/)*\s?#{Regexp.escape(month)}(\.|-|\/)*\s?(\d{4}|\d{2})/i, ' <redacted date> ')
+                       .gsub(/#{Regexp.escape(month)}(\.)*\s\d+(rd|th|st)*(,)*\s\d{4}/i, ' <redacted date> ')
+                       .gsub(/\d{4}\.*\s#{Regexp.escape(month)}\s\d+(rd|th|st)*/i, ' <redacted date> ')
+                       .gsub(/\d{4}(\.|-|\/)*#{Regexp.escape(month)}(\.|-|\/)*\d+/i, ' <redacted date> ')
+                       .gsub(/#{Regexp.escape(month)}(\.)*\s\d+(rd|th|st)*/i, ' <redacted date> ')
+                       .gsub(/#{Regexp.escape(month)}\sde\s\d+(rd|th|st)*/i, ' <redacted date> ')
+    end
+
+    def includes_long_date?(text)
+      includes_long_date_1?(text) || includes_long_date_2?(text)
+    end
+
+    def includes_long_date_1?(text)
+      dow.each do |day|
+        months.map { |month| return true if check_for_matches(day, month, text) }
+        months_abbr.map { |month| return true if check_for_matches(day, month, text) }
+      end
+      false
+    end
+
+    def includes_long_date_2?(text)
       dow_abbr.each do |day|
-        months.each do |month|
-          break if match_found
-          match_found = !(string !~ /#{Regexp.escape(day)}(\.)*(,)*\s#{Regexp.escape(month)}\s\d+(rd|th|st)*(,)*\s\d{4}/i)
-        end
-        months_abbr.each do |month|
-          break if match_found
-          match_found = !(string !~ /#{Regexp.escape(day)}(\.)*(,)*\s#{Regexp.escape(month)}(\.)*\s\d+(rd|th|st)*(,)*\s\d{4}/i)
-        end
+        months.map { |month| return true if !(text !~ /#{Regexp.escape(day)}(\.)*(,)*\s#{Regexp.escape(month)}\s\d+(rd|th|st)*(,)*\s\d{4}/i) }
+        months_abbr.map { |month| return true if !(text !~ /#{Regexp.escape(day)}(\.)*(,)*\s#{Regexp.escape(month)}(\.)*\s\d+(rd|th|st)*(,)*\s\d{4}/i) }
       end
-      match_found
+      false
     end
 
-    def number_only_date
-      !(string !~ DMY_MDY_REGEX) ||
-      !(string !~ YMD_YDM_REGEX) ||
-      !(string !~ DIGIT_ONLY_YEAR_FIRST_REGEX) ||
-      !(string !~ DIGIT_ONLY_YEAR_LAST_REGEX)
+    def includes_number_only_date?(text)
+      !(text !~ DMY_MDY_REGEX) ||
+      !(text !~ YMD_YDM_REGEX) ||
+      !(text !~ DIGIT_ONLY_YEAR_FIRST_REGEX) ||
+      !(text !~ DIGIT_ONLY_YEAR_LAST_REGEX)
     end
 
-    def check_for_matches(day, month)
-      !(string !~ /#{Regexp.escape(day)}(,)*\s#{Regexp.escape(month)}(\.)*\s\d+(rd|th|st)*(,)*\s\d{4}/i) ||
-      !(string !~ /#{Regexp.escape(month)}(\.)*\s\d+(rd|th|st)*(,)*\s\d{4}/i) ||
-      !(string !~ /\d{4}\.*\s#{Regexp.escape(month)}\s\d+(rd|th|st)*/i) ||
-      !(string !~ /\d{4}(\.|-|\/)*#{Regexp.escape(month)}(\.|-|\/)*\d+/i) ||
-      !(string !~ /#{Regexp.escape(month)}(\.)*\s\d+(rd|th|st)*/i) ||
-      !(string !~ /\d{2}(\.|-|\/)*#{Regexp.escape(month)}(\.|-|\/)*(\d{4}|\d{2})/i)
+    def check_for_matches(day, month, text)
+      !(text !~ /#{Regexp.escape(day)}(,)*\s#{Regexp.escape(month)}(\.)*\s\d+(rd|th|st)*(,)*\s\d{4}/i) ||
+      !(text !~ /#{Regexp.escape(month)}(\.)*\s\d+(rd|th|st)*(,)*\s\d{4}/i) ||
+      !(text !~ /\d{4}\.*\s#{Regexp.escape(month)}\s\d+(rd|th|st)*/i) ||
+      !(text !~ /\d{4}(\.|-|\/)*#{Regexp.escape(month)}(\.|-|\/)*\d+/i) ||
+      !(text !~ /#{Regexp.escape(month)}(\.)*\s\d+(rd|th|st)*/i) ||
+      !(text !~ /\d{2}(\.|-|\/)*#{Regexp.escape(month)}(\.|-|\/)*(\d{4}|\d{2})/i)
     end
   end
 end

data/lib/confidential_info_redactor_lite/extractor.rb

@@ -5,18 +5,17 @@ module ConfidentialInfoRedactorLite
     EXTRACT_REGEX = /(?<=\s|^|\s\"|\s\“|\s\«|\s\‹|\s\”|\s\»|\s\›)([A-Z]\S*\s)*[A-Z]\S*(?=(\s|\.|\z))|(?<=\s|^|\s\"|\s\”|\s\»|\s\›|\s\“|\s\«|\s\‹)[i][A-Z][a-z]+/
 
     PUNCTUATION_REGEX = /[\?\)\(\!\\\/\"\:\;\,\”\“\«\»\‹\›]/
-    attr_reader :text, :language, :corpus
-    def initialize(text:, corpus:, **args)
-      @text = text.gsub(/[’‘]/, "'").freeze
+    attr_reader :language, :corpus
+    def initialize(corpus:, **args)
       @corpus = Set.new(corpus).freeze
       @language = args[:language] || 'en'
     end
 
-    def extract
+    def extract(text)
       extracted_terms = []
-      PragmaticSegmenter::Segmenter.new(text: text, language: language).segment.each do |segment|
+      PragmaticSegmenter::Segmenter.new(text: text.gsub(/[’‘]/, "'"), language: language).segment.each do |segment|
         initial_extracted_terms = extract_preliminary_terms(segment)
-        next if initial_extracted_terms.length.eql?(segment.split(' ').length) && search_for_ngrams(initial_extracted_terms)
+        next if initial_extracted_terms.length.eql?(segment.split(' ').length) && !in_corpus?(initial_extracted_terms)
         search_ngrams(initial_extracted_terms, extracted_terms)
       end
       extracted_terms.uniq.reject(&:empty?)
@@ -28,36 +27,54 @@ module ConfidentialInfoRedactorLite
       segment.gsub(EXTRACT_REGEX).map { |match| match unless corpus.include?(match.downcase.gsub(PUNCTUATION_REGEX, '').gsub(/\'$/, '')) }.compact
     end
 
-    def search_for_ngrams(tokens)
-      in_corpus = true
-      tokens.each do |ngram|
-        ngram.split(PUNCTUATION_REGEX).each do |t|
-          unless corpus.include?(t.downcase.gsub(PUNCTUATION_REGEX, '').gsub(/\'$/, '').gsub(/\.\z/, '').strip)
-            in_corpus = false
-          end
-        end
+    def in_corpus?(tokens)
+      tokens.map { |token| token.split(PUNCTUATION_REGEX).map { |t| return true if corpus.include?(clean_token(t.downcase)) } }
+    end
+
+    def clean_token(token)
+      token.gsub(PUNCTUATION_REGEX, '').gsub(/\'$/, '').gsub(/\.\z/, '').strip
+    end
+
+    def non_confidential_token?(token, includes_confidential)
+      corpus.include?(token) || !includes_confidential || singular_in_corpus?(token)
+    end
+
+    def singular_in_corpus?(token)
+      corpus.include?(token[0...-1]) &&
+        token[-1].eql?('s')
+    end
+
+    def includes_confidential?(token)
+      token.split(' ').map { |t| return false if corpus.include?(t.downcase) } unless token.split(' ').length.eql?(2) && token.split(' ')[1].downcase.eql?('bank')
+      true
+    end
+
+    def matching_first_token?(tokens)
+      corpus.include?(tokens[0]) &&
+        tokens[0] != 'the' &&
+        tokens[0] != 'deutsche' &&
+        tokens.length.eql?(2)
+    end
+
+    def find_extracted_terms(string, extracted_terms)
+      cleaned_token_downcased = clean_token(string.downcase)
+      cleaned_token = clean_token(string)
+      tokens = cleaned_token_downcased.split(' ')
+      if matching_first_token?(tokens)
+        extracted_terms << cleaned_token.split(' ')[1] unless corpus.include?(tokens[1])
+      else
+        extracted_terms << cleaned_token unless non_confidential_token?(cleaned_token_downcased, includes_confidential?(cleaned_token))
       end
-      in_corpus
+      extracted_terms
     end
 
     def search_ngrams(tokens, extracted_terms)
       tokens.each do |ngram|
         ngram.split(PUNCTUATION_REGEX).each do |t|
           next if !(t !~ /.*\d+.*/)
-          if corpus.include?(t.downcase.gsub(PUNCTUATION_REGEX, '').gsub(/\'$/, '').gsub(/\.\z/, '').strip.split(' ')[0]) && t.downcase.gsub(PUNCTUATION_REGEX, '').gsub(/\'$/, '').gsub(/\.\z/, '').strip.split(' ')[0] != 'the' && t.downcase.gsub(PUNCTUATION_REGEX, '').gsub(/\'$/, '').gsub(/\.\z/, '').strip.split(' ')[0] != 'deutsche' && t.downcase.gsub(PUNCTUATION_REGEX, '').gsub(/\'$/, '').gsub(/\.\z/, '').strip.split(' ').length.eql?(2)
-            extracted_terms << t.gsub(PUNCTUATION_REGEX, '').gsub(/\'$/, '').gsub(/\.\z/, '').strip.split(' ')[1] unless corpus.include?(t.downcase.gsub(PUNCTUATION_REGEX, '').gsub(/\'$/, '').strip.split(' ')[1])
-          else
-            tracker = true
-            unless t.gsub(PUNCTUATION_REGEX, '').gsub(/\'$/, '').gsub(/\.\z/, '').strip.split(' ').length.eql?(2) && t.gsub(PUNCTUATION_REGEX, '').gsub(/\'$/, '').gsub(/\.\z/, '').strip.split(' ')[1].downcase.eql?('bank')
-              t.gsub(PUNCTUATION_REGEX, '').gsub(/\'$/, '').gsub(/\.\z/, '').strip.split(' ').each do |token|
-                tracker = false if corpus.include?(token.downcase)
-              end
-            end
-            extracted_terms << t.gsub(PUNCTUATION_REGEX, '').gsub(/\'$/, '').gsub(/\.\z/, '').strip unless corpus.include?(t.downcase.gsub(PUNCTUATION_REGEX, '').gsub(/\'$/, '').strip) || !tracker || (corpus.include?(t.downcase.gsub(PUNCTUATION_REGEX, '').gsub(/\'$/, '').strip[0...-2]) && t.downcase.gsub(PUNCTUATION_REGEX, '').gsub(/\'$/, '').strip[-2..-1].eql?('en')) || (corpus.include?(t.downcase.gsub(PUNCTUATION_REGEX, '').gsub(/\'$/, '').strip[0...-2]) && t.downcase.gsub(PUNCTUATION_REGEX, '').gsub(/\'$/, '').strip[-2..-1].eql?('es')) || (corpus.include?(t.downcase.gsub(PUNCTUATION_REGEX, '').gsub(/\'$/, '').strip[0...-2]) && t.downcase.gsub(PUNCTUATION_REGEX, '').gsub(/\'$/, '').strip[-2..-1].eql?('er')) || (corpus.include?(t.downcase.gsub(PUNCTUATION_REGEX, '').gsub(/\'$/, '').strip[0...-1]) && t.downcase.gsub(PUNCTUATION_REGEX, '').gsub(/\'$/, '').strip[-1].eql?('s')) || (corpus.include?(t.downcase.gsub(PUNCTUATION_REGEX, '').gsub(/\'$/, '').strip[0...-1]) && t.downcase.gsub(PUNCTUATION_REGEX, '').gsub(/\'$/, '').strip[-1].eql?('n'))
-          end
+          extracted_terms = find_extracted_terms(t, extracted_terms)
         end
       end
-      extracted_terms
     end
   end
 end

data/lib/confidential_info_redactor_lite/hyperlink.rb

@@ -4,17 +4,9 @@ module ConfidentialInfoRedactorLite
     # Rubular: http://rubular.com/r/fXa4lp0gfS
     HYPERLINK_REGEX = /(http|https|www)(\.|:)/
 
-    attr_reader :string
-    def initialize(string:)
-      @string = string
-    end
-
-    def replace
-      new_string = string.dup
-      string.split(/\s+/).each do |token|
-        new_string = new_string.gsub(/#{Regexp.escape(token.gsub(/\.\z/, ''))}/, ' <redacted hyperlink> ') if !(token !~ HYPERLINK_REGEX)
-      end
-      new_string
+    def replace(text)
+      text.split(/\s+/).map { |token| text = text.gsub(/#{Regexp.escape(token.gsub(/\.\z/, ''))}/, ' <redacted hyperlink> ') if !(token !~ HYPERLINK_REGEX) }
+      text
     end
   end
 end

data/lib/confidential_info_redactor_lite/redactor.rb

@@ -9,9 +9,8 @@ module ConfidentialInfoRedactorLite
     # Rubular: http://rubular.com/r/mxcj2G0Jfa
     EMAIL_REGEX = /(?<=\A|\s|\()[\w+\-.]+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+(?=\z|\s|\.|\))/i
 
-    attr_reader :text, :language, :email_text, :hyperlink_text, :number_text, :date_text, :token_text, :tokens, :ignore_emails, :ignore_dates, :ignore_numbers, :ignore_hyperlinks, :dow, :dow_abbr, :months, :months_abbr
-    def initialize(text:, dow:, dow_abbr:, months:, months_abbr:, **args)
-      @text = text
+    attr_reader :language, :email_text, :hyperlink_text, :number_text, :date_text, :token_text, :tokens, :ignore_emails, :ignore_dates, :ignore_numbers, :ignore_hyperlinks, :dow, :dow_abbr, :months, :months_abbr
+    def initialize(dow:, dow_abbr:, months:, months_abbr:, **args)
       @language = args[:language] || 'en'
       @tokens = args[:tokens]
       @number_text = args[:number_text] || '<redacted number>'
@@ -29,52 +28,52 @@ module ConfidentialInfoRedactorLite
       @months_abbr = months_abbr
     end
 
-    def dates
+    def dates(text)
       return '' if text.nil?
       redact_dates(text)
     end
 
-    def dates_html
+    def dates_html(text)
       return [] if text.nil?
       redact_dates_html(text)
     end
 
-    def numbers
+    def numbers(text)
       return '' if text.nil?
       redact_numbers(text)
     end
 
-    def numbers_html
+    def numbers_html(text)
       return [] if text.nil?
       redact_numbers_html(text)
     end
 
-    def emails
+    def emails(text)
       return '' if text.nil?
       redact_emails(text)
     end
 
-    def emails_html
+    def emails_html(text)
       return [] if text.nil?
       redact_emails_html(text)
     end
 
-    def hyperlinks
+    def hyperlinks(text)
       return '' if text.nil?
       redact_hyperlinks(text)
     end
 
-    def hyperlinks_html
+    def hyperlinks_html(text)
       return [] if text.nil?
       redact_hyperlinks_html(text)
     end
 
-    def proper_nouns
+    def proper_nouns(text)
       return '' if text.nil?
       redact_tokens(text)
     end
 
-    def redact
+    def redact(text)
       return '' if text.nil?
       if ignore_emails
         redacted_text = text
@@ -87,7 +86,7 @@ module ConfidentialInfoRedactorLite
       redact_tokens(redacted_text)
     end
 
-    def redact_html
+    def redact_html(text)
       return [] if text.nil?
       redacted_text = redact_dates_html(text)[0]
       redacted_text = redact_emails_html(redacted_text)[0]
@@ -183,11 +182,11 @@ module ConfidentialInfoRedactorLite
     end
 
     def redact_hyperlinks(txt)
-      ConfidentialInfoRedactorLite::Hyperlink.new(string: txt).replace.gsub(/<redacted hyperlink>/, "#{hyperlink_text}").gsub(/\s*#{Regexp.escape(hyperlink_text)}\s*/, " #{hyperlink_text} ").gsub(/#{Regexp.escape(hyperlink_text)}\s{1}\.{1}/, "#{hyperlink_text}.").gsub(/#{Regexp.escape(hyperlink_text)}\s{1}\,{1}/, "#{hyperlink_text},")
+      ConfidentialInfoRedactorLite::Hyperlink.new.replace(txt).gsub(/<redacted hyperlink>/, "#{hyperlink_text}").gsub(/\s*#{Regexp.escape(hyperlink_text)}\s*/, " #{hyperlink_text} ").gsub(/#{Regexp.escape(hyperlink_text)}\s{1}\.{1}/, "#{hyperlink_text}.").gsub(/#{Regexp.escape(hyperlink_text)}\s{1}\,{1}/, "#{hyperlink_text},")
     end
 
     def redact_dates(txt)
-      ConfidentialInfoRedactorLite::Date.new(string: txt, dow: dow, dow_abbr: dow_abbr, months: months, months_abbr: months_abbr).replace.gsub(/<redacted date>/, "#{date_text}").gsub(/\s*#{Regexp.escape(date_text)}\s*/, " #{date_text} ").gsub(/\A\s*#{Regexp.escape(date_text)}\s*/, "#{date_text} ").gsub(/#{Regexp.escape(date_text)}\s{1}\.{1}/, "#{date_text}.")
+      ConfidentialInfoRedactorLite::Date.new(dow: dow, dow_abbr: dow_abbr, months: months, months_abbr: months_abbr).replace(txt).gsub(/<redacted date>/, "#{date_text}").gsub(/\s*#{Regexp.escape(date_text)}\s*/, " #{date_text} ").gsub(/\A\s*#{Regexp.escape(date_text)}\s*/, "#{date_text} ").gsub(/#{Regexp.escape(date_text)}\s{1}\.{1}/, "#{date_text}.")
     end
 
     def redact_numbers(txt)