word_count_analyzer 0.0.1

data/lib/word_count_analyzer/date.rb

@@ -0,0 +1,149 @@
+module WordCountAnalyzer
+  class Date
+    DOW = %w(monday tuesday wednesday thursday friday saturday sunday)
+    DOW_ABBR = %w(mon tu tue tues wed th thu thur thurs fri sat sun)
+    MONTHS = %w(january february march april may june july august september october november december)
+    MONTH_ABBR = %w(jan feb mar apr jun jul aug sep sept oct nov dec)
+    # Rubular: http://rubular.com/r/73CZ2HU0q6
+    DMY_MDY_REGEX = /(\d{1,2}(\/|\.|-)){2}\d{4}\.?/
+
+    # Rubular: http://rubular.com/r/GWbuWXw4t0
+    YMD_YDM_REGEX = /\d{4}(\/|\.|-)(\d{1,2}(\/|\.|-)){2}\.?/
+
+    # Rubular: http://rubular.com/r/SRZ27XNlvR
+    DIGIT_ONLY_YEAR_FIRST_REGEX = /[12]\d{7}\D\.?/
+
+    # Rubular: http://rubular.com/r/mpVSeaKwdY
+    DIGIT_ONLY_YEAR_LAST_REGEX = /\d{4}[12]\d{3}\D\.?/
+
+    attr_reader :string
+    def initialize(string:)
+      @string = string
+    end
+
+    def includes_date?
+      long_date || number_only_date
+    end
+
+    def replace
+      new_string = string.dup
+      counter = 0
+      DOW_ABBR.each do |day|
+        counter +=1 if string.include?('day')
+      end
+      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)*(,)*\s\d{4}\.?/i, ' wsdateword ')
+          end
+          MONTH_ABBR.each do |month|
+            new_string = new_string.gsub(/#{Regexp.escape(day)}(\.)*(,)*\s#{Regexp.escape(month)}(\.)*\s\d+(rd|th)*(,)*\s\d{4}\.?/i, ' wsdateword ')
+          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)*(,)*\s\d{4}\.?/i, ' wsdateword ')
+                                   .gsub(/#{Regexp.escape(month)}(\.)*\s\d+(rd|th)*(,)*\s\d{4}\.?/i, ' wsdateword ')
+                                   .gsub(/\d{4}\.*\s#{Regexp.escape(month)}\s\d+(rd|th)*\.?/i, ' wsdateword ')
+                                   .gsub(/\d{4}(\.|-|\/)*#{Regexp.escape(month)}(\.|-|\/)*\d+\.?/i, ' wsdateword ')
+                                   .gsub(/#{Regexp.escape(month)}(\.)*\s\d+(rd|th)*\.?/i, ' wsdateword ')
+                                   .gsub(/\d{2}(\.|-|\/)*#{Regexp.escape(month)}(\.|-|\/)*(\d{4}|\d{2})\.?/i, ' wsdateword ')
+          end
+          MONTH_ABBR.each do |month|
+            new_string = new_string.gsub(/#{Regexp.escape(day)}(,)*\s#{Regexp.escape(month)}(\.)*\s\d+(rd|th)*(,)*\s\d{4}\.?/i, ' wsdateword ')
+                           .gsub(/#{Regexp.escape(month)}(\.)*\s\d+(rd|th)*(,)*\s\d{4}\.?/i, ' wsdateword ')
+                           .gsub(/\d{4}\.*\s#{Regexp.escape(month)}\s\d+(rd|th)*\.?/i, ' wsdateword ')
+                           .gsub(/\d{4}(\.|-|\/)*#{Regexp.escape(month)}(\.|-|\/)*\d+\.?/i, ' wsdateword ')
+                           .gsub(/#{Regexp.escape(month)}(\.)*\s\d+(rd|th)*\.?/i, ' wsdateword ')
+                           .gsub(/\d{2}(\.|-|\/)*#{Regexp.escape(month)}(\.|-|\/)*(\d{4}|\d{2})\.?/i, ' wsdateword ')
+          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)*(,)*\s\d{4}\.?/i, ' wsdateword ')
+                                   .gsub(/#{Regexp.escape(month)}(\.)*\s\d+(rd|th)*(,)*\s\d{4}\.?/i, ' wsdateword ')
+                                   .gsub(/\d{4}\.*\s#{Regexp.escape(month)}\s\d+(rd|th)*\.?/i, ' wsdateword ')
+                                   .gsub(/\d{4}(\.|-|\/)*#{Regexp.escape(month)}(\.|-|\/)*\d+\.?/i, ' wsdateword ')
+                                   .gsub(/#{Regexp.escape(month)}(\.)*\s\d+(rd|th)*\.?/i, ' wsdateword ')
+                                   .gsub(/\d{2}(\.|-|\/)*#{Regexp.escape(month)}(\.|-|\/)*(\d{4}|\d{2})\.?/i, ' wsdateword ')
+          end
+          MONTH_ABBR.each do |month|
+            new_string = new_string.gsub(/#{Regexp.escape(day)}(,)*\s#{Regexp.escape(month)}(\.)*\s\d+(rd|th)*(,)*\s\d{4}\.?/i, ' wsdateword ')
+                           .gsub(/#{Regexp.escape(month)}(\.)*\s\d+(rd|th)*(,)*\s\d{4}\.?/i, ' wsdateword ')
+                           .gsub(/\d{4}\.*\s#{Regexp.escape(month)}\s\d+(rd|th)*\.?/i, ' wsdateword ')
+                           .gsub(/\d{4}(\.|-|\/)*#{Regexp.escape(month)}(\.|-|\/)*\d+\.?/i, ' wsdateword ')
+                           .gsub(/#{Regexp.escape(month)}(\.)*\s\d+(rd|th)*\.?/i, ' wsdateword ')
+                           .gsub(/\d{2}(\.|-|\/)*#{Regexp.escape(month)}(\.|-|\/)*(\d{4}|\d{2})\.?/i, ' wsdateword ')
+          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)*(,)*\s\d{4}\.?/i, ' wsdateword ')
+          end
+          MONTH_ABBR.each do |month|
+            new_string = new_string.gsub(/#{Regexp.escape(day)}(\.)*(,)*\s#{Regexp.escape(month)}(\.)*\s\d+(rd|th)*(,)*\s\d{4}\.?/i, ' wsdateword ')
+          end
+        end
+      end
+      new_string = new_string.gsub(DMY_MDY_REGEX, ' wsdateword ')
+                     .gsub(YMD_YDM_REGEX, ' wsdateword ')
+                     .gsub(DIGIT_ONLY_YEAR_FIRST_REGEX, ' wsdateword ')
+                     .gsub(DIGIT_ONLY_YEAR_LAST_REGEX, ' wsdateword ')
+    end
+
+    def occurences
+      replace.scan(/wsdateword/).size
+    end
+
+    def replace_number_only_date
+      string.gsub(DMY_MDY_REGEX, ' wsdateword ')
+            .gsub(YMD_YDM_REGEX, ' wsdateword ')
+            .gsub(DIGIT_ONLY_YEAR_FIRST_REGEX, ' wsdateword ')
+            .gsub(DIGIT_ONLY_YEAR_LAST_REGEX, ' wsdateword ')
+    end
+
+    private
+
+    def long_date
+      match_found = false
+      DOW.each do |day|
+        MONTHS.each do |month|
+          break if match_found
+          match_found = check_for_matches(day, month)
+        end
+        MONTH_ABBR.each do |month|
+          break if match_found
+          match_found = check_for_matches(day, month)
+        end
+      end
+      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)*(,)*\s\d{4}/i)
+        end
+        MONTH_ABBR.each do |month|
+          break if match_found
+          match_found = !(string !~ /#{Regexp.escape(day)}(\.)*(,)*\s#{Regexp.escape(month)}(\.)*\s\d+(rd|th)*(,)*\s\d{4}/i)
+        end
+      end
+      match_found
+    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)
+    end
+
+    def check_for_matches(day, month)
+      !(string !~ /#{Regexp.escape(day)}(,)*\s#{Regexp.escape(month)}(\.)*\s\d+(rd|th)*(,)*\s\d{4}/i) ||
+      !(string !~ /#{Regexp.escape(month)}(\.)*\s\d+(rd|th)*(,)*\s\d{4}/i) ||
+      !(string !~ /\d{4}\.*\s#{Regexp.escape(month)}\s\d+(rd|th)*/i) ||
+      !(string !~ /\d{4}(\.|-|\/)*#{Regexp.escape(month)}(\.|-|\/)*\d+/i) ||
+      !(string !~ /#{Regexp.escape(month)}(\.)*\s\d+(rd|th)*/i) ||
+      !(string !~ /\d{2}(\.|-|\/)*#{Regexp.escape(month)}(\.|-|\/)*(\d{4}|\d{2})/i)
+    end
+  end
+end

data/lib/word_count_analyzer/ellipsis.rb

@@ -0,0 +1,48 @@
+module WordCountAnalyzer
+  class Ellipsis
+    # Rubular: http://rubular.com/r/i60hCK81fz
+    THREE_CONSECUTIVE_REGEX = /\.{3}(?=\s+[A-Z])/
+
+    # Rubular: http://rubular.com/r/mfdtSeuIf2
+    FOUR_CONSECUTIVE_REGEX = /(?<=[^\.])\.{3}\.(?=[^\.])/
+
+    # Rubular: http://rubular.com/r/YBG1dIHTRu
+    THREE_SPACE_REGEX = /(\s\.){3}\s/
+
+    # Rubular: http://rubular.com/r/2VvZ8wRbd8
+    FOUR_SPACE_REGEX = /(?<=[a-z])(\.\s){3}\.(\z|$|\n)/
+
+    OTHER_THREE_PERIOD_REGEX = /[^\.]\.{3}[^\.]/
+
+    UNICODE_ELLIPSIS = /(?<=[^…])…{1}(?=[^…])/
+
+    attr_reader :string
+    def initialize(string:)
+      @string = string
+    end
+
+    def includes_ellipsis?
+      !(string !~ THREE_CONSECUTIVE_REGEX) ||
+      !(string !~ FOUR_CONSECUTIVE_REGEX) ||
+      !(string !~ THREE_SPACE_REGEX) ||
+      !(string !~ FOUR_SPACE_REGEX) ||
+      !(string !~ OTHER_THREE_PERIOD_REGEX) ||
+      !(string !~ UNICODE_ELLIPSIS)
+    end
+
+    def replace
+      string.gsub(THREE_CONSECUTIVE_REGEX, ' wseword ')
+            .gsub(FOUR_CONSECUTIVE_REGEX, ' wseword ')
+            .gsub(THREE_SPACE_REGEX, ' wseword ')
+            .gsub(FOUR_SPACE_REGEX, ' wseword ')
+            .gsub(OTHER_THREE_PERIOD_REGEX, ' wseword ')
+            .gsub(UNICODE_ELLIPSIS, ' wseword ')
+    end
+
+    def occurences
+      count = 0
+      replace.split(' ').map { |token| count += 1 if token.strip.eql?('wseword') }
+      count
+    end
+  end
+end

data/lib/word_count_analyzer/hyperlink.rb

@@ -0,0 +1,53 @@
+module WordCountAnalyzer
+  class Hyperlink
+    NON_HYPERLINK_REGEX = /\A\w+:$/
+
+    # Rubular: http://rubular.com/r/fXa4lp0gfS
+    HYPERLINK_REGEX = /(http|https|www)(\.|:)/
+
+    attr_reader :string
+    def initialize(string:)
+      @string = string
+    end
+
+    def hyperlink?
+      !(string !~ URI.regexp) && string !~ NON_HYPERLINK_REGEX && !(string !~ HYPERLINK_REGEX)
+    end
+
+    def occurences
+      counter = 0
+      string.scan(URI.regexp).each do |link|
+        counter += 1 if link.compact.size > 1
+      end
+      counter
+    end
+
+    def replace
+      new_string = string.dup
+      string.split(/\s+/).each do |token|
+        if !(token !~ URI.regexp) && token !~ NON_HYPERLINK_REGEX && !(token !~ HYPERLINK_REGEX) && token.include?('">')
+          new_string = new_string.gsub(/#{Regexp.escape(token.split('">')[0])}/, ' wslinkword ')
+        elsif !(token !~ URI.regexp) && token !~ NON_HYPERLINK_REGEX && !(token !~ HYPERLINK_REGEX)
+          new_string = new_string.gsub(/#{Regexp.escape(token)}/, ' wslinkword ')
+        end
+      end
+      new_string
+    end
+
+    def replace_split_at_period
+      new_string = string.dup
+      string.split(/\s+/).each do |token|
+        if !(token !~ URI.regexp) && token !~ NON_HYPERLINK_REGEX && !(token !~ HYPERLINK_REGEX) && token.include?('">')
+          new_string.gsub!(/#{Regexp.escape(token.split('">')[0])}/) do |match|
+            match.split('.').join(' ')
+          end
+        elsif !(token !~ URI.regexp) && token !~ NON_HYPERLINK_REGEX && !(token !~ HYPERLINK_REGEX)
+          new_string.gsub!(/#{Regexp.escape(token)}/) do |match|
+            match.split('.').join(' ')
+          end
+        end
+      end
+      new_string
+    end
+  end
+end

data/lib/word_count_analyzer/hyphenated_word.rb

@@ -0,0 +1,23 @@
+module WordCountAnalyzer
+  class HyphenatedWord
+    # Rubular: http://rubular.com/r/RjZ7qi0uFf
+    DASHED_LINE_REGEX = /\s-{2,}(\s|$)|\A-{2,}(\s|$)/
+
+    attr_reader :token
+    def initialize(token:)
+      @token = token.gsub(DASHED_LINE_REGEX, '')
+    end
+
+    def hyphenated_word?
+      (token.include?('-') || token.include?('﹘')) && !WordCountAnalyzer::Hyperlink.new(string: token).hyperlink?
+    end
+
+    def count_as_multiple
+      token.split(/[﹘,-]/).length
+    end
+
+    def replace
+      token.split(/[﹘,-]/).join(' ')
+    end
+  end
+end

data/lib/word_count_analyzer/number.rb

@@ -0,0 +1,23 @@
+module WordCountAnalyzer
+  class Number
+    # Rubular: http://rubular.com/r/OGj82uEu8d
+    NUMBER_REGEX = /(?<=\A)\D?\d+((,|\.)*\d)*(\D?\s|\s|\.?\s|\.$)|(?<=\s)\D?\d+((,|\.)*\d)*(\D?\s|\s|\.?\s|\.$)/
+
+    attr_reader :string
+    def initialize(string:)
+      @string = WordCountAnalyzer::NumberedList.new(string: WordCountAnalyzer::Date.new(string: string).replace).replace
+    end
+
+    def includes_number?
+      !(string !~ NUMBER_REGEX)
+    end
+
+    def replace
+      string.gsub(NUMBER_REGEX, ' wsnumword ')
+    end
+
+    def occurences
+      replace.scan(/wsnumword/).size
+    end
+  end
+end

data/lib/word_count_analyzer/numbered_list.rb

@@ -0,0 +1,61 @@
+module WordCountAnalyzer
+  class NumberedList
+    # Rubular: http://rubular.com/r/RKmRH9Y4oO
+    NUMBERED_LIST_REGEX = /(?<=\s)\d{1,2}\.(?=\s)|^\d{1,2}\.(?=\s)|(?<=\s)\d{1,2}\.\)|^\d{1,2}\.\)/
+
+    attr_reader :string
+    def initialize(string:)
+      @string = string
+    end
+
+    def includes_numbered_list?
+      !(string !~ NUMBERED_LIST_REGEX) && has_at_least_two_items?
+    end
+
+    def replace
+      new_string = string.dup
+      list_array = string.scan(NUMBERED_LIST_REGEX).map(&:to_i)
+      skips = 0
+      list_array.each_with_index do |a, i|
+        if (a + 1).eql?(list_array[i + 1]) ||
+                    (a - 1).eql?(list_array[i - 1]) ||
+                    (a.eql?(0) && list_array[i - 1].eql?(9)) ||
+                    (a.eql?(9) && list_array[i + 1].eql?(0))
+          new_string.gsub!(NUMBERED_LIST_REGEX).with_index do |match, index|
+            if i.eql?(index + (i - skips)) && match.chomp('.').eql?(a.to_s)
+              ''
+            else
+              match
+            end
+          end
+        else
+          skips +=1
+        end
+      end
+      new_string
+    end
+
+    def occurences
+      count_list_items_in_array
+    end
+
+    private
+
+    def has_at_least_two_items?
+      count_list_items_in_array >= 2
+    end
+
+    def count_list_items_in_array
+      list_array = string.scan(NUMBERED_LIST_REGEX).map(&:to_i)
+      counter = 0
+      list_array.each_with_index do |a, i|
+        next unless (a + 1).eql?(list_array[i + 1]) ||
+                    (a - 1).eql?(list_array[i - 1]) ||
+                    (a.eql?(0) && list_array[i - 1].eql?(9)) ||
+                    (a.eql?(9) && list_array[i + 1].eql?(0))
+        counter += 1
+      end
+      counter
+    end
+  end
+end

data/lib/word_count_analyzer/punctuation.rb

@@ -0,0 +1,52 @@
+module WordCountAnalyzer
+  class Punctuation
+    # Rubular: http://rubular.com/r/ZVBsZVkiqC
+    DOTTED_LINE_REGEX = /…{2,}|\.{5,}/
+
+    # Rubular: http://rubular.com/r/RjZ7qi0uFf
+    DASHED_LINE_REGEX = /(?<=\s)-{2,}(\s|$)|\A-{2,}(?=(\s|$))/
+
+    # Rubular: http://rubular.com/r/hNofimZwdh
+    UNDERSCORE_REGEX = /(?<=\s)_{2,}(\s|$)|\A_{2,}(?=(\s|$))/
+
+    # Rubular: http://rubular.com/r/FexKxGUuIe
+    STRAY_PUNCTUATION_REGEX = /(?<=\s)[[:punct:]](?=(\s|$))|(?<=\s)\|(?=(\s|$))/
+
+    attr_reader :string
+    def initialize(string:)
+      @string = string
+    end
+
+    def dotted_line_ocurrances
+      string.scan(DOTTED_LINE_REGEX).size
+    end
+
+    def dashed_line_ocurrances
+      string.scan(DASHED_LINE_REGEX).size
+    end
+
+    def underscore_ocurrances
+      string.scan(UNDERSCORE_REGEX).size
+    end
+
+    def stray_punctuation_occurences
+      string.scan(STRAY_PUNCTUATION_REGEX).size
+    end
+
+    def replace_dotted_line
+      string.gsub(DOTTED_LINE_REGEX, '')
+    end
+
+    def replace_dashed_line
+      string.gsub(DASHED_LINE_REGEX, '')
+    end
+
+    def replace_underscore
+      string.gsub(UNDERSCORE_REGEX, '')
+    end
+
+    def replace_stray_punctuation
+      string.gsub(STRAY_PUNCTUATION_REGEX, '')
+    end
+  end
+end

data/lib/word_count_analyzer/slash.rb

@@ -0,0 +1,84 @@
+module WordCountAnalyzer
+  class Slash
+    # Rubular: http://rubular.com/r/AqvcH29sgg
+    FORWARD_SLASH_REGEX = /(?<=\s)(\S+\/)+\S+|(?<=\A)(\S+\/)+\S+/
+
+    # Rubular: http://rubular.com/r/tuFWtdMs4G
+    BACKSLASH_REGEX = /\S+\\\S+/
+
+    attr_reader :string, :processed_string, :date, :xhtml, :hyperlink
+    def initialize(string:, **args)
+      @string = string
+      @date = args[:date] || nil
+      @xhtml = args[:xhtml] || nil
+      @hyperlink = args[:hyperlink] || nil
+      if date.eql?('no_special_treatment')
+        if xhtml.eql?('keep')
+          if hyperlink.eql?('no_special_treatment') || hyperlink.eql?('split_at_period')
+            @processed_string = string
+          else
+            @processed_string = WordCountAnalyzer::Hyperlink.new(string: string).replace
+          end
+        else
+          if hyperlink.eql?('no_special_treatment') || hyperlink.eql?('split_at_period')
+            @processed_string = WordCountAnalyzer::Xhtml.new(string: string).replace
+          else
+            @processed_string = WordCountAnalyzer::Xhtml.new(string: WordCountAnalyzer::Hyperlink.new(string: string).replace).replace
+          end
+        end
+      else
+        if xhtml.eql?('keep')
+          if hyperlink.eql?('no_special_treatment') || hyperlink.eql?('split_at_period')
+            @processed_string = WordCountAnalyzer::Date.new(string: string).replace
+          else
+            @processed_string = WordCountAnalyzer::Date.new(string: WordCountAnalyzer::Hyperlink.new(string: string).replace).replace
+          end
+        else
+          if hyperlink.eql?('no_special_treatment') || hyperlink.eql?('split_at_period')
+            @processed_string = WordCountAnalyzer::Date.new(string: WordCountAnalyzer::Xhtml.new(string: string).replace).replace
+          else
+            @processed_string = WordCountAnalyzer::Date.new(string: WordCountAnalyzer::Xhtml.new(string: WordCountAnalyzer::Hyperlink.new(string: string).replace).replace).replace
+          end
+        end
+      end
+    end
+
+    def includes_forward_slash?
+      !(processed_string !~ FORWARD_SLASH_REGEX)
+    end
+
+    def includes_backslash?
+      !(processed_string !~ BACKSLASH_REGEX)
+    end
+
+    def forward_slash_occurences
+      processed_string.scan(FORWARD_SLASH_REGEX).size
+    end
+
+    def replace_forward_slashes
+      return processed_string if processed_string !~ FORWARD_SLASH_REGEX
+      processed_string.gsub!(FORWARD_SLASH_REGEX).each do |match|
+        match.split(/\/+/).join(' ')
+      end
+    end
+
+    def replace_forward_slashes_except_dates
+      return processed_string if processed_string !~ FORWARD_SLASH_REGEX
+      except_date_string = WordCountAnalyzer::Date.new(string: processed_string).replace_number_only_date
+      except_date_string.gsub!(FORWARD_SLASH_REGEX).each do |match|
+        match.split(/\/+/).join(' ')
+      end
+    end
+
+    def backslash_occurences
+      processed_string.scan(BACKSLASH_REGEX).size
+    end
+
+    def replace_backslashes
+      return processed_string if processed_string !~ BACKSLASH_REGEX
+      processed_string.gsub!(BACKSLASH_REGEX).each do |match|
+        ' word ' * match.split(/\\+/).length
+      end
+    end
+  end
+end