pragmatic_segmenter 0.3.3 → 0.3.4

data/lib/pragmatic_segmenter/languages/common/ellipsis.rb

@@ -0,0 +1,37 @@
+# -*- encoding : utf-8 -*-
+
+module PragmaticSegmenter
+  module Languages
+    module Common
+      # This class searches for ellipses within a string and
+      # replaces the periods.
+
+      # http://www.dailywritingtips.com/in-search-of-a-4-dot-ellipsis/
+      # http://www.thepunctuationguide.com/ellipses.html
+
+      module EllipsisRules
+        # Rubular: http://rubular.com/r/i60hCK81fz
+        ThreeConsecutiveRule = Rule.new(/\.\.\.(?=\s+[A-Z])/, '☏.')
+
+        # Rubular: http://rubular.com/r/Hdqpd90owl
+        FourConsecutiveRule = Rule.new(/(?<=\S)\.{3}(?=\.\s[A-Z])/, 'ƪ')
+
+        # Rubular: http://rubular.com/r/YBG1dIHTRu
+        ThreeSpaceRule = Rule.new(/(\s\.){3}\s/, '♟')
+
+        # Rubular: http://rubular.com/r/2VvZ8wRbd8
+        FourSpaceRule = Rule.new(/(?<=[a-z])(\.\s){3}\.(\z|$|\n)/, '♝')
+
+        OtherThreePeriodRule = Rule.new(/\.\.\./, 'ƪ')
+
+        All = [
+          ThreeSpaceRule,
+          FourSpaceRule,
+          FourConsecutiveRule,
+          ThreeConsecutiveRule,
+          OtherThreePeriodRule
+        ]
+      end
+    end
+  end
+end

data/lib/pragmatic_segmenter/languages/common/numbers.rb

@@ -0,0 +1,90 @@
+# -*- encoding : utf-8 -*-
+
+module PragmaticSegmenter
+  module Languages
+    module Common
+      module Numbers
+        # Rubular: http://rubular.com/r/oNyxBOqbyy
+        PeriodBeforeNumberRule = Rule.new(/\.(?=\d)/, '∯')
+
+        # Rubular: http://rubular.com/r/EMk5MpiUzt
+        NumberAfterPeriodBeforeLetterRule = Rule.new(/(?<=\d)\.(?=\S)/, '∯')
+
+        # Rubular: http://rubular.com/r/rf4l1HjtjG
+        NewLineNumberPeriodSpaceLetterRule = Rule.new(/(?<=\r\d)\.(?=(\s\S)|\))/, '∯')
+
+        # Rubular: http://rubular.com/r/HPa4sdc6b9
+        StartLineNumberPeriodRule = Rule.new(/(?<=^\d)\.(?=(\s\S)|\))/, '∯')
+
+        # Rubular: http://rubular.com/r/NuvWnKleFl
+        StartLineTwoDigitNumberPeriodRule = Rule.new(/(?<=^\d\d)\.(?=(\s\S)|\))/, '∯')
+
+        All = [
+          PeriodBeforeNumberRule,
+          NumberAfterPeriodBeforeLetterRule,
+          NewLineNumberPeriodSpaceLetterRule,
+          StartLineNumberPeriodRule,
+          StartLineTwoDigitNumberPeriodRule
+        ]
+      end
+
+
+      SENTENCE_BOUNDARY_REGEX = /\u{ff08}(?:[^\u{ff09}])*\u{ff09}(?=\s?[A-Z])|\u{300c}(?:[^\u{300d}])*\u{300d}(?=\s[A-Z])|\((?:[^\)]){2,}\)(?=\s[A-Z])|'(?:[^'])*[^,]'(?=\s[A-Z])|"(?:[^"])*[^,]"(?=\s[A-Z])|“(?:[^”])*[^,]”(?=\s[A-Z])|\S.*?[。．.！!?？ȸȹ☉☈☇☄]/
+
+      # Rubular: http://rubular.com/r/NqCqv372Ix
+      QUOTATION_AT_END_OF_SENTENCE_REGEX = /[!?\.-][\"\'\u{201d}\u{201c}]\s{1}[A-Z]/
+
+      # Rubular: http://rubular.com/r/6flGnUMEVl
+      PARENS_BETWEEN_DOUBLE_QUOTES_REGEX = /["”]\s\(.*\)\s["“]/
+
+      # Rubular: http://rubular.com/r/TYzr4qOW1Q
+      BETWEEN_DOUBLE_QUOTES_REGEX = /"(?:[^"])*[^,]"|“(?:[^”])*[^,]”/
+
+      # Rubular: http://rubular.com/r/JMjlZHAT4g
+      SPLIT_SPACE_QUOTATION_AT_END_OF_SENTENCE_REGEX = /(?<=[!?\.-][\"\'\u{201d}\u{201c}])\s{1}(?=[A-Z])/
+
+      # Rubular: http://rubular.com/r/mQ8Es9bxtk
+      CONTINUOUS_PUNCTUATION_REGEX = /(?<=\S)(!|\?){3,}(?=(\s|\z|$))/
+
+      # Rubular: http://rubular.com/r/yqa4Rit8EY
+      PossessiveAbbreviationRule = Rule.new(/\.(?='s\s)|\.(?='s$)|\.(?='s\z)/, '∯')
+
+      # Rubular: http://rubular.com/r/NEv265G2X2
+      KommanditgesellschaftRule = Rule.new(/(?<=Co)\.(?=\sKG)/, '∯')
+
+      # Rubular: http://rubular.com/r/xDkpFZ0EgH
+      MULTI_PERIOD_ABBREVIATION_REGEX = /\b[a-z](?:\.[a-z])+[.]/i
+
+      module AmPmRules
+        # Rubular: http://rubular.com/r/Vnx3m4Spc8
+        UpperCasePmRule = Rule.new(/(?<=P∯M)∯(?=\s[A-Z])/, '.')
+
+        # Rubular: http://rubular.com/r/AJMCotJVbW
+        UpperCaseAmRule = Rule.new(/(?<=A∯M)∯(?=\s[A-Z])/, '.')
+
+        # Rubular: http://rubular.com/r/13q7SnOhgA
+        LowerCasePmRule = Rule.new(/(?<=p∯m)∯(?=\s[A-Z])/, '.')
+
+        # Rubular: http://rubular.com/r/DgUDq4mLz5
+        LowerCaseAmRule = Rule.new(/(?<=a∯m)∯(?=\s[A-Z])/, '.')
+
+        All = [UpperCasePmRule, UpperCaseAmRule, LowerCasePmRule, LowerCaseAmRule]
+      end
+
+      # This class searches for periods within an abbreviation and
+      # replaces the periods.
+      module SingleLetterAbbreviationRules
+        # Rubular: http://rubular.com/r/e3H6kwnr6H
+        SingleUpperCaseLetterAtStartOfLineRule = Rule.new(/(?<=^[A-Z])\.(?=\s)/, '∯')
+
+        # Rubular: http://rubular.com/r/gitvf0YWH4
+        SingleUpperCaseLetterRule = Rule.new(/(?<=\s[A-Z])\.(?=\s)/, '∯')
+
+        All = [
+          SingleUpperCaseLetterAtStartOfLineRule,
+          SingleUpperCaseLetterRule
+        ]
+      end
+    end
+  end
+end

data/lib/pragmatic_segmenter/languages/deutsch.rb

@@ -18,11 +18,20 @@ module PragmaticSegmenter
       # Rubular: http://rubular.com/r/TkZomF9tTM
       BETWEEN_DOUBLE_QUOTES_DE_REGEX = /„(?>[^“\\]+|\\{2}|\\.)*“/
 
-      # Rubular: http://rubular.com/r/hZxoyQwKT1
-      NumberPeriodSpaceRule = Rule.new(/(?<=\s[0-9]|\s([1-9][0-9]))\.(?=\s)/, '∯')
 
-      # Rubular: http://rubular.com/r/ityNMwdghj
-      NegativeNumberPeriodSpaceRule = Rule.new(/(?<=-[0-9]|-([1-9][0-9]))\.(?=\s)/, '∯')
+      module Numbers
+        # Rubular: http://rubular.com/r/hZxoyQwKT1
+        NumberPeriodSpaceRule = Rule.new(/(?<=\s[0-9]|\s([1-9][0-9]))\.(?=\s)/, '∯')
+
+        # Rubular: http://rubular.com/r/ityNMwdghj
+        NegativeNumberPeriodSpaceRule = Rule.new(/(?<=-[0-9]|-([1-9][0-9]))\.(?=\s)/, '∯')
+
+        All = [
+          Common::Numbers::All,
+          NumberPeriodSpaceRule,
+          NegativeNumberPeriodSpaceRule
+        ]
+      end
 
       MONTHS = ['Januar', 'Februar', 'März', 'April', 'Mai', 'Juni', 'Juli', 'August', 'September', 'Oktober', 'November', 'Dezember']
 
@@ -32,59 +41,35 @@ module PragmaticSegmenter
       # Rubular: http://rubular.com/r/iUNSkCuso0
       SingleLowerCaseLetterAtStartOfLineRule = Rule.new(/(?<=^[a-z])\.(?=\s)/, '∯')
 
-
-      class Process < PragmaticSegmenter::Process
-        private
-
-        def between_punctuation(txt)
-          BetweenPunctuation.new(text: txt).replace
-        end
-
-        def replace_numbers(txt)
-          Number.new(text: txt).replace
-        end
-
-        def replace_abbreviations(txt)
-          AbbreviationReplacer.new(text: txt, language: Deutsch).replace
-        end
-      end
-
-      class Cleaner < PragmaticSegmenter::Cleaner
+      class Processor < PragmaticSegmenter::Processor
         private
 
-        def abbreviations
-          Abbreviation::ABBREVIATIONS
-        end
-      end
+        def replace_numbers
+          @text.apply Numbers::All
 
-      class Number < PragmaticSegmenter::Number
-        def replace
-          super
-          @text.apply(NumberPeriodSpaceRule, NegativeNumberPeriodSpaceRule)
-          replace_period_in_deutsch_dates(@text)
+          replace_period_in_deutsch_dates
         end
 
-        def replace_period_in_deutsch_dates(txt)
+        def replace_period_in_deutsch_dates
           MONTHS.each do |month|
             # Rubular: http://rubular.com/r/zlqgj7G5dA
-            txt.gsub!(/(?<=\d)\.(?=\s*#{Regexp.escape(month)})/, '∯')
+            @text.gsub!(/(?<=\d)\.(?=\s*#{Regexp.escape(month)})/, '∯')
           end
-          txt
         end
       end
 
       class AbbreviationReplacer  < AbbreviationReplacer
         def replace
-          @reformatted_text = text.apply(
+          @text = text.apply(
             @language::PossessiveAbbreviationRule,
             @language::SingleLetterAbbreviationRules::All,
             SingleLowerCaseLetterRule,
             SingleLowerCaseLetterAtStartOfLineRule)
 
-          @reformatted_text = search_for_abbreviations_in_string(@reformatted_text)
-          @reformatted_text = replace_multi_period_abbreviations(@reformatted_text)
-          @reformatted_text = @reformatted_text.apply(Languages::Common::AmPmRules::All)
-          replace_abbreviation_as_sentence_boundary(@reformatted_text)
+          @text = search_for_abbreviations_in_string(@text)
+          @text = replace_multi_period_abbreviations(@text)
+          @text.apply(Languages::Common::AmPmRules::All)
+          replace_abbreviation_as_sentence_boundary(@text)
         end
 
         private
@@ -97,15 +82,7 @@ module PragmaticSegmenter
       class BetweenPunctuation < PragmaticSegmenter::BetweenPunctuation
         private
 
-        def sub_punctuation_between_double_quotes(txt)
-          btwn_dbl_quote = sub_punctuation_between_double_quotes_de(txt)
-          PragmaticSegmenter::PunctuationReplacer.new(
-            matches_array: btwn_dbl_quote,
-            text: txt
-          ).replace
-        end
-
-        def sub_punctuation_between_double_quotes_de(txt)
+        def btwn_dbl_quote(txt)
           if txt.include?('„')
             btwn_dbl_quote = txt.scan(BETWEEN_DOUBLE_QUOTES_DE_REGEX)
             txt.scan(SPLIT_DOUBLE_QUOTES_DE_REGEX).each do |q|

data/lib/pragmatic_segmenter/languages/english.rb

@@ -6,13 +6,13 @@ module PragmaticSegmenter
       class Cleaner < Cleaner
         def clean
           super
-          clean_quotations(@clean_text)
+          clean_quotations
         end
 
         private
 
-        def clean_quotations(txt)
-          txt.gsub(/`/, "'")
+        def clean_quotations
+          @text.gsub(/`/, "'")
         end
 
         def abbreviations

data/lib/pragmatic_segmenter/languages/japanese.rb

@@ -3,27 +3,19 @@ module PragmaticSegmenter
     module Japanese
       include Languages::Common
 
-      class Process < Process
-        private
-
-        def between_punctuation(txt)
-          BetweenPunctuation.new(text: txt).replace
-        end
-      end
-
       class Cleaner < PragmaticSegmenter::Cleaner
         # Rubular: http://rubular.com/r/N4kPuJgle7
         NewLineInMiddleOfWordRule = Rule.new(/(?<=の)\n(?=\S)/, '')
 
         def clean
           super
-          @clean_text = remove_newline_in_middle_of_word(@clean_text)
+          remove_newline_in_middle_of_word
         end
 
         private
 
-        def remove_newline_in_middle_of_word(txt)
-          txt.apply(NewLineInMiddleOfWordRule)
+        def remove_newline_in_middle_of_word
+          @text.apply NewLineInMiddleOfWordRule
         end
       end
 
@@ -42,14 +34,14 @@ module PragmaticSegmenter
         end
 
         def sub_punctuation_between_quotes_ja(txt)
-          PragmaticSegmenter::PunctuationReplacer.new(
+          PunctuationReplacer.new(
             matches_array: txt.scan(BETWEEN_QUOTE_JA_REGEX),
             text: txt
           ).replace
         end
 
         def sub_punctuation_between_parens_ja(txt)
-          PragmaticSegmenter::PunctuationReplacer.new(
+          PunctuationReplacer.new(
             matches_array: txt.scan(BETWEEN_PARENS_JA_REGEX),
             text: txt
           ).replace

data/lib/pragmatic_segmenter/languages/persian.rb

@@ -9,20 +9,6 @@ module PragmaticSegmenter
       ReplaceColonBetweenNumbersRule = Rule.new(/(?<=\d):(?=\d)/, '♭')
       ReplaceNonSentenceBoundaryCommaRule = Rule.new(/،(?=\s\S+،)/, '♬')
 
-      class Process < Process
-        private
-
-        def sentence_boundary_punctuation(txt)
-          txt = txt.apply ReplaceColonBetweenNumbersRule,
-            ReplaceNonSentenceBoundaryCommaRule
-          txt.scan(SENTENCE_BOUNDARY_REGEX)
-        end
-
-        def replace_abbreviations(txt)
-          AbbreviationReplacer.new(text: txt).replace
-        end
-      end
-
       class AbbreviationReplacer  < AbbreviationReplacer
         private
 

data/lib/pragmatic_segmenter/languages/russian.rb

@@ -9,34 +9,9 @@ module PragmaticSegmenter
         NUMBER_ABBREVIATIONS = []
       end
 
-      class Process < Process
-        private
-
-        def replace_abbreviations(txt)
-          AbbreviationReplacer.new(text: txt, language: Russian).replace
-        end
-      end
-
       class AbbreviationReplacer  < AbbreviationReplacer
         private
 
-        def scan_for_replacements(txt, am, index, character_array)
-          character = character_array[index]
-          prepositive = @language::Abbreviation::PREPOSITIVE_ABBREVIATIONS
-          number_abbr = @language::Abbreviation::NUMBER_ABBREVIATIONS
-          upper = /[[:upper:]]/.match(character.to_s)
-          if upper.nil? || prepositive.include?(am.downcase.strip)
-            if prepositive.include?(am.downcase.strip)
-              txt = replace_prepositive_abbr(txt, am)
-            elsif number_abbr.include?(am.downcase.strip)
-              txt = replace_pre_number_abbr(txt, am)
-            else
-              txt = replace_period_of_abbr(txt, am)
-            end
-          end
-          txt
-        end
-
         def replace_period_of_abbr(txt, abbr)
           txt.gsub(/(?<=\s#{abbr.strip})\./, '∯')
             .gsub(/(?<=\A#{abbr.strip})\./, '∯')

data/lib/pragmatic_segmenter/languages/spanish.rb

@@ -8,15 +8,6 @@ module PragmaticSegmenter
         PREPOSITIVE_ABBREVIATIONS = ['a', 'aero', 'ambi', 'an', 'anfi', 'ante', 'anti', 'archi', 'arci', 'auto', 'bi', 'bien', 'bis', 'co', 'com', 'con', 'contra', 'crio', 'cuadri', 'cuasi', 'cuatri', 'de', 'deci', 'des', 'di', 'dis', 'dr', 'ecto', 'ee', 'en', 'endo', 'entre', 'epi', 'equi', 'ex', 'extra', 'geo', 'hemi', 'hetero', 'hiper', 'hipo', 'homo', 'i', 'im', 'in', 'infra', 'inter', 'intra', 'iso', 'lic', 'macro', 'mega', 'micro', 'mini', 'mono', 'mt', 'multi', 'neo', 'omni', 'para', 'pen', 'ph', 'ph.d', 'pluri', 'poli', 'pos', 'post', 'pre', 'pro', 'prof', 'pseudo', 're', 'retro', 'semi', 'seudo', 'sobre', 'sub', 'super', 'supra', 'sra', 'srta', 'trans', 'tras', 'tri', 'ulter', 'ultra', 'un', 'uni', 'vice', 'yuxta']
         NUMBER_ABBREVIATIONS = ['cra', 'ext', 'no', 'nos', 'p', 'pp', 'tel']
       end
-
-      class Cleaner < Cleaner
-        private
-
-        def abbreviations
-          Abbreviation::ABBREVIATIONS
-        end
-      end
-
     end
   end
 end

data/lib/pragmatic_segmenter/list.rb

@@ -5,6 +5,8 @@ module PragmaticSegmenter
   # newlines before each list item.
   class List
     ROMAN_NUMERALS = %w(i ii iii iv v vi vii viii ix x xi xii xiii xiv x xi xii xiii xv xvi xvii xviii xix xx)
+    LATIN_NUMERALS = ('a'..'z').to_a
+
     # Rubular: http://rubular.com/r/XcpaJKH0sz
     ALPHABETICAL_LIST_WITH_PERIODS =
       /(?<=^)[a-z](?=\.)|(?<=\A)[a-z](?=\.)|(?<=\s)[a-z](?=\.)/
@@ -45,10 +47,10 @@ module PragmaticSegmenter
     end
 
     def add_line_break
-      formatted_text = format_alphabetical_lists(text)
-      formatted_text = format_roman_numeral_lists(formatted_text)
-      formatted_text = format_numbered_list_with_periods(formatted_text)
-      format_numbered_list_with_parens(formatted_text)
+      format_alphabetical_lists
+      format_roman_numeral_lists
+      format_numbered_list_with_periods
+      format_numbered_list_with_parens
     end
 
     def replace_parens
@@ -63,64 +65,63 @@ module PragmaticSegmenter
 
     private
 
-    def format_numbered_list_with_parens(txt)
-      new_txt = replace_parens_in_numbered_list(txt)
-      new_txt = add_line_breaks_for_numbered_list_with_parens(new_txt)
-      new_txt.apply(ListMarkerRule)
+    def format_numbered_list_with_parens
+      replace_parens_in_numbered_list
+      add_line_breaks_for_numbered_list_with_parens
+      @text.apply(ListMarkerRule)
     end
 
-    def format_numbered_list_with_periods(txt)
-      new_txt = replace_periods_in_numbered_list(txt)
-      new_txt = add_line_breaks_for_numbered_list_with_periods(new_txt)
-      new_txt.apply(SubstituteListPeriodRule)
+    def format_numbered_list_with_periods
+      replace_periods_in_numbered_list
+      add_line_breaks_for_numbered_list_with_periods
+      @text.apply(SubstituteListPeriodRule)
     end
 
-    def format_alphabetical_lists(txt)
-      new_txt = add_line_breaks_for_alphabetical_list_with_periods(txt, false)
-      add_line_breaks_for_alphabetical_list_with_parens(new_txt, false)
+    def format_alphabetical_lists
+      add_line_breaks_for_alphabetical_list_with_periods(roman_numeral: false)
+      add_line_breaks_for_alphabetical_list_with_parens(roman_numeral: false)
     end
 
-    def format_roman_numeral_lists(txt)
-      new_txt = add_line_breaks_for_alphabetical_list_with_periods(txt, true)
-      add_line_breaks_for_alphabetical_list_with_parens(new_txt, true)
+    def format_roman_numeral_lists
+      add_line_breaks_for_alphabetical_list_with_periods(roman_numeral: true)
+      add_line_breaks_for_alphabetical_list_with_parens(roman_numeral: true)
     end
 
-    def replace_periods_in_numbered_list(txt)
-      scan_lists(NUMBERED_LIST_REGEX_1, NUMBERED_LIST_REGEX_2, '♨', true, txt)
+    def replace_periods_in_numbered_list
+      scan_lists(NUMBERED_LIST_REGEX_1, NUMBERED_LIST_REGEX_2, '♨', strip: true)
     end
 
-    def add_line_breaks_for_numbered_list_with_periods(txt)
-      return txt unless txt.include?('♨') &&
-                        txt !~ /♨.+\n.+♨|♨.+\r.+♨/ &&
-                        txt !~ /for\s\d{1,2}♨\s[a-z]/
-      txt.apply(SpaceBetweenListItemsFirstRule).
-          apply(SpaceBetweenListItemsSecondRule)
+    def add_line_breaks_for_numbered_list_with_periods
+      if @text.include?('♨') && @text !~ /♨.+\n.+♨|♨.+\r.+♨/ && @text !~ /for\s\d{1,2}♨\s[a-z]/
+        @text.apply(SpaceBetweenListItemsFirstRule, SpaceBetweenListItemsSecondRule)
+      end
     end
 
-    def replace_parens_in_numbered_list(txt)
+    def replace_parens_in_numbered_list
       scan_lists(
-        NUMBERED_LIST_PARENS_REGEX, NUMBERED_LIST_PARENS_REGEX, '☝', false, txt)
+        NUMBERED_LIST_PARENS_REGEX, NUMBERED_LIST_PARENS_REGEX, '☝')
+      scan_lists(NUMBERED_LIST_PARENS_REGEX, NUMBERED_LIST_PARENS_REGEX, '☝')
     end
 
-    def add_line_breaks_for_numbered_list_with_parens(txt)
-      return txt unless txt.include?('☝') && txt !~ /☝.+\n.+☝|☝.+\r.+☝/
-      txt.apply(SpaceBetweenListItemsThirdRule)
+    def add_line_breaks_for_numbered_list_with_parens
+      if @text.include?('☝') && @text !~ /☝.+\n.+☝|☝.+\r.+☝/
+        @text.apply(SpaceBetweenListItemsThirdRule)
+      end
     end
 
-    def scan_lists(regex1, regex2, replacement, strip, txt)
-      list_array = txt.scan(regex1).map(&:to_i)
+    def scan_lists(regex1, regex2, replacement, strip: false)
+      list_array = @text.scan(regex1).map(&:to_i)
       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))
-        substitute_found_list_items(txt, regex2, a, strip, replacement)
+        substitute_found_list_items(regex2, a, strip, replacement)
       end
-      txt
     end
 
-    def substitute_found_list_items(txt, regex, a, strip, replacement)
-      txt.gsub!(regex).with_index do |m|
+    def substitute_found_list_items(regex, a, strip, replacement)
+      @text.gsub!(regex).with_index do |m|
         if a.to_s.eql?(strip ? m.strip.chop : m)
           "#{Regexp.escape(a.to_s)}" + replacement
         else
@@ -129,22 +130,24 @@ module PragmaticSegmenter
       end
     end
 
-    def add_line_breaks_for_alphabetical_list_with_periods(txt, roman_numeral)
-      iterate_alphabet_array(ALPHABETICAL_LIST_WITH_PERIODS, false, txt, roman_numeral)
+    def add_line_breaks_for_alphabetical_list_with_periods(roman_numeral: false)
+      iterate_alphabet_array(ALPHABETICAL_LIST_WITH_PERIODS, roman_numeral: roman_numeral)
     end
 
-    def add_line_breaks_for_alphabetical_list_with_parens(txt, roman_numeral)
-      iterate_alphabet_array(ALPHABETICAL_LIST_WITH_PARENS, true, txt, roman_numeral)
+    def add_line_breaks_for_alphabetical_list_with_parens(roman_numeral: false)
+      iterate_alphabet_array(ALPHABETICAL_LIST_WITH_PARENS,
+        parens: true,
+        roman_numeral: roman_numeral)
     end
 
-    def replace_alphabet_list(a, txt)
-      txt.gsub!(ALPHABETICAL_LIST_LETTERS_AND_PERIODS_REGEX).with_index do |m|
+    def replace_alphabet_list(a)
+      @text.gsub!(ALPHABETICAL_LIST_LETTERS_AND_PERIODS_REGEX).with_index do |m|
         a.eql?(m.chomp('.')) ? "\r#{Regexp.escape(a.to_s)}∯" : "#{m}"
       end
     end
 
-    def replace_alphabet_list_parens(a, txt)
-      txt.gsub!(EXTRACT_ALPHABETICAL_LIST_LETTERS_REGEX).with_index do |m|
+    def replace_alphabet_list_parens(a)
+      @text.gsub!(EXTRACT_ALPHABETICAL_LIST_LETTERS_REGEX).with_index do |m|
         if m.include?('(')
           a.eql?(m.dup.downcase.gsub!(/\(/, '')) ? "\r&✂&#{Regexp.escape(m.gsub!(/\(/, ''))}" : "#{m}"
         else
@@ -153,48 +156,47 @@ module PragmaticSegmenter
       end
     end
 
-    def replace_correct_alphabet_list(a, txt, parens)
+    def replace_correct_alphabet_list(a, parens)
       if parens
-        replace_alphabet_list_parens(a, txt)
+        replace_alphabet_list_parens(a)
       else
-        replace_alphabet_list(a, txt)
+        replace_alphabet_list(a)
       end
     end
 
-    def last_array_item_replacement(a, i, alphabet, list_array, txt, parens)
+    def last_array_item_replacement(a, i, alphabet, list_array, parens)
       return if alphabet & list_array == [] ||
         !alphabet.include?(list_array[i - 1]) ||
         !alphabet.include?(a)
       return if (alphabet.index(list_array[i - 1]) - alphabet.index(a)).abs != 1
-      replace_correct_alphabet_list(a, txt, parens)
+      replace_correct_alphabet_list(a, parens)
     end
 
-    def other_items_replacement(a, i, alphabet, list_array, txt, parens)
+    def other_items_replacement(a, i, alphabet, list_array, parens)
       return if alphabet & list_array == [] ||
         !alphabet.include?(list_array[i - 1]) ||
         !alphabet.include?(a) ||
         !alphabet.include?(list_array[i + 1])
       return if alphabet.index(list_array[i + 1]) - alphabet.index(a) != 1 &&
                 (alphabet.index(list_array[i - 1]) - alphabet.index(a)).abs != 1
-      replace_correct_alphabet_list(a, txt, parens)
+      replace_correct_alphabet_list(a, parens)
     end
 
-    def iterate_alphabet_array(regex, parens, txt, roman_numeral)
-      list_array = txt.scan(regex).map(&:downcase)
+    def iterate_alphabet_array(regex, parens: false, roman_numeral: false)
+      list_array = @text.scan(regex).map(&:downcase)
       if roman_numeral
         alphabet = ROMAN_NUMERALS
       else
-        alphabet = ('a'..'z').to_a
+        alphabet = LATIN_NUMERALS
       end
       list_array.delete_if { |item| !alphabet.any? { |a| a.include?(item) } }
       list_array.each_with_index do |a, i|
         if i.eql?(list_array.length - 1)
-          last_array_item_replacement(a, i, alphabet, list_array, txt, parens)
+          last_array_item_replacement(a, i, alphabet, list_array, parens)
         else
-          other_items_replacement(a, i, alphabet, list_array, txt, parens)
+          other_items_replacement(a, i, alphabet, list_array, parens)
         end
       end
-      txt
     end
   end
 end