turkish_support 0.3.0 → 1.0.0.pre.alpha

data/lib/turkish_support/string_methods.rb

@@ -1,20 +1,32 @@
 module TurkishSupport
   refine String do
-    %i{downcase downcase! upcase upcase! capitalize capitalize!}.each do |method_name|
-      non_destructive_method_name = method_name.to_s.chomp('!')
-      helper_method = instance_method("change_chars_for_#{non_destructive_method_name}")
-      define_method(method_name) do
-        str = helper_method.bind(self).call.public_send(non_destructive_method_name)
-        return method_name.to_s.end_with?('!') ? public_send(:replace, str) : str
+    (RE_RE_METHS + RE_OP_METHS).each do |meth|
+      define_method meth do |*args|
+        extend(TurkishSupportHelpers)
+
+        if RE_RE_METHS.include?(meth) || args[0].is_a?(Regexp)
+          args[0] = translate_regexp(args[0])
+        end
+
+        super(*args)
       end
     end
 
-    def titleize(conjuctions=true)
-      words.map do |word|
+    CASE_RELATED_METHS.each do |meth|
+      non_destructive = meth.to_s.chomp('!').to_sym
+      define_method(meth) do
+        extend(TurkishSupportHelpers)
+        str = prepare_for(non_destructive, self).public_send(non_destructive)
+        return meth.to_s.end_with?('!') ? public_send(:replace, str) : str
+      end
+    end
+
+    def titleize(conjuctions = true)
+      split.map do |word|
         word.downcase!
-        if word.conjuction? && !conjuctions
+        if conjuction?(word) && !conjuctions
           word
-        elsif word.start_with_a_special_char?
+        elsif start_with_a_special_char?(word)
           word.chr + word[1..-1].capitalize
         else
           word.capitalize
@@ -22,27 +34,27 @@ module TurkishSupport
       end.join(' ')
     end
 
+    def titleize!(conjuctions = true)
+      replace(titleize(conjuctions))
+    end
+
     def swapcase
+      extend(TurkishSupportHelpers)
       chars.map do |ch|
-        if ch.unsupported?
-          ch.unsupported_downcase? ? ch.upcase : ch.downcase
+        if tr_char?(ch)
+          tr_lower?(ch) ? ch.upcase : ch.downcase
         else
           ch.public_send(:swapcase)
         end
       end.join
     end
 
-    def casecmp(other_string)
-      upcase.public_send(:casecmp, other_string.upcase)
+    def swapcase!
+      replace(swapcase)
     end
 
-    %i[match scan =~].each do |method_name|
-      define_method(method_name) do |pattern|
-        Regexp.new(pattern) unless pattern.kind_of? Regexp
-        pattern, options = pattern.source, pattern.options
-        pattern = Regexp.new(pattern.transform_regex, Regexp::FIXEDENCODING | options)
-        public_send(method_name, pattern)
-      end
+    def casecmp(other_string)
+      upcase.public_send(:casecmp, other_string.upcase)
     end
   end
 end

data/lib/turkish_support/version.rb

@@ -1,3 +1,3 @@
 module TurkishSupport
-  VERSION = "0.3.0"
+  VERSION = '1.0.0-alpha'
 end

data/spec/helpers_spec.rb

@@ -0,0 +1,264 @@
+require 'spec_helper'
+require 'turkish_support/helpers'
+
+RSpec.configure do |config|
+  config.include TurkishSupportHelpers
+  using TurkishSupport
+end
+
+describe 'TurkishSupportHelpers' do
+  let(:downcased_alphabet) { 'abcçdefgğhıijklmnoöpqrsştuüvwxyz' }
+  let(:upcased_alphabet)   { 'ABCÇDEFGĞHIİJKLMNOÖPQRSŞTUÜVWXYZ' }
+  let(:alphabet)           { downcased_alphabet + upcased_alphabet }
+  let(:tr_specific_lower)  { 'çğıiöşü' }
+  let(:tr_specific_upper)  { 'ÇĞIİÖŞÜ' }
+  let(:tr_all)             { tr_specific_upper + tr_specific_lower }
+  let(:conjuctions)        { %w(ve ile veya) }
+  let(:turkish_words)      { %w(çamur ıhlamur insan ördek şahika ümraniye) }
+  let(:special_chars)      { %w{ ( " ' } }
+
+  describe '#prepare_for' do
+    context ':upcase' do
+      it "replaces unsupported lower case letters with their upper cases'" do
+        expect(prepare_for(:upcase, 'çğıiöşü'))
+          .to eq('ÇĞIİÖŞÜ')
+      end
+    end
+
+    context ':downcase' do
+      it "replaces unsupported upper case letters with their lower cases'" do
+        expect(prepare_for(:downcase, 'ÇĞIİÖŞÜ'))
+          .to eq('çğıiöşü')
+      end
+    end
+
+    context ':capitalize' do
+      it 'replaces unsupported upper case and lower case letters' do
+        dbl = double
+        allow(dbl)
+          .to receive(:prepare_for)
+          .with(:capitalize, 'çaĞLAyan')
+          .and_return('Çağlayan')
+
+        expect(dbl.prepare_for(:capitalize, 'çaĞLAyan'))
+          .to eq('Çağlayan')
+      end
+    end
+
+    context 'with invalid parameters' do
+      it 'raises an error if any parameter is not valid' do
+        expect { prepare_for(:not_valid, :not_valid) }
+          .to raise_error ArgumentError,
+                          'Invalid arguments for method `prepare_for`!'
+        expect { prepare_for(:swapcase, 'ÇĞ') }
+          .to raise_error ArgumentError,
+                          'Invalid arguments for method `prepare_for`!'
+        expect { prepare_for(:upcase, 123) }
+          .to raise_error ArgumentError,
+                          'Invalid arguments for method `prepare_for`!'
+      end
+    end
+  end
+
+  describe '#tr_lower?' do
+    it 'returns true for any Turkish specific lower case character' do
+      expect(tr_specific_lower
+        .chars
+        .all? { |ch| tr_lower?(ch) })
+        .to eq(true)
+    end
+
+    context 'returns false' do
+      it 'for non-Turkish specific lower case characters' do
+        expect(downcased_alphabet
+          .delete(tr_specific_lower)
+          .chars
+          .any? { |ch| tr_lower?(ch) }
+        ).to eq(false)
+      end
+
+      it 'for any upper case characters' do
+        expect(upcased_alphabet
+          .chars
+          .any? { |ch| tr_lower?(ch) }
+        ).to eq(false)
+      end
+
+      it 'for non-letter characters' do
+        expect("\"é1!2'3^+4.,-_"
+          .chars
+          .any? { |ch| tr_lower?(ch) }
+        ).to eq(false)
+      end
+    end
+  end
+
+  describe '#tr_upper?' do
+    it 'returns true for any Turkish specific upper case character' do
+      expect(tr_specific_upper
+        .chars
+        .all? { |ch| tr_upper?(ch) }
+      ).to eq(true)
+    end
+
+    context 'returns false' do
+      it 'for non-Turkish specific upper case characters' do
+        expect(upcased_alphabet
+          .delete(tr_specific_upper)
+          .chars
+          .any? { |ch| tr_upper?(ch) }
+        ).to eq(false)
+      end
+
+      it 'for any lower case characters' do
+        expect(downcased_alphabet
+          .chars
+          .any? { |ch| tr_upper?(ch) }
+        ).to eq(false)
+      end
+
+      it 'for non-letter characters' do
+        expect("\"é1!2'3^+4.,-_"
+          .chars
+          .any? { |ch| tr_upper?(ch) }
+        ).to eq(false)
+      end
+    end
+  end
+
+  describe '#tr_char?' do
+    it 'returns true for any Turkish specific character' do
+      expect(tr_all
+        .chars
+        .all? { |ch| tr_char?(ch) }
+      ).to eq(true)
+    end
+
+    context 'returns false' do
+      it 'for non-Turkish specific characters' do
+        expect(alphabet.delete(tr_all)
+          .chars
+          .any? { |ch| tr_char?(ch) }
+        ).to eq(false)
+      end
+
+      it 'for non-letter characters' do
+        expect("\"é1!2'3^+4.,-_"
+          .chars
+          .any? { |ch| tr_char?(ch) }
+        ).to eq(false)
+      end
+    end
+  end
+
+  describe '#conjuction?' do
+    it 'returns true for any conjuction' do
+      expect(conjuctions
+        .all? { |c| conjuction?(c) }
+      ).to eq(true)
+    end
+
+    it 'returns false for any word contains conjuction' do
+      expect(%w(veda aile veyahut)
+        .any? { |c| conjuction?(c) }
+      ).to eq(false)
+    end
+  end
+
+  describe '#start_with_a_special_char?' do
+    it 'returns true for all words starts with a special char' do
+      special_words = turkish_words.map { |w| special_chars.sample + w }
+      expect(special_words
+        .all? { |word| start_with_a_special_char?(word) }
+      ).to eq(true)
+    end
+
+    it 'returns false any words not starts with a special char' do
+      expect(turkish_words
+        .any? { |word| start_with_a_special_char?(word) }
+      ).to eq(false)
+    end
+  end
+
+  describe '#translate_range' do
+    it 'translates a complete lower-case range correctly' do
+      expect(translate_range('a-z'))
+        .to eq(downcased_alphabet)
+    end
+
+    it 'translates a complete upper-case range correctly' do
+      expect(translate_range('A-Z'))
+        .to eq(upcased_alphabet)
+    end
+
+    it 'raises an error if any arguments not a letter' do
+      invalid_arguments = %w(1-Z A-9 1-9 a-])
+      expect(invalid_arguments
+        .all? do |arg|
+          expect { translate_range(arg) }
+            .to raise_error ArgumentError,
+                            'Invalid regexp range arguments!'
+        end
+      ).to eq(true)
+    end
+
+    it 'raises an error if arguments are not in same case' do
+      expect { translate_range('a-Z') }
+        .to raise_error ArgumentError,
+                        'Invalid regexp range arguments!'
+    end
+
+    it 'translates a partial range correctly' do
+      expect(translate_range('d-t'))
+        .to eq('defgğhıijklmnoöpqrsşt')
+      expect(translate_range('Ç-Ü'))
+        .to eq('ÇDEFGĞHIİJKLMNOÖPQRSŞTUÜ')
+    end
+
+    it 'translates a range  correctly when casefold option is true' do
+      expect(translate_range('d-t', true))
+        .to eq('defgğhıijklmnoöpqrsştĞIİÖŞ')
+      expect(translate_range('C-U', true))
+        .to eq('CÇDEFGĞHIİJKLMNOÖPQRSŞTUçğıiöş')
+    end
+
+    it 'translates ranges created using Turkish characters' do
+      expect(translate_range('Ç-Ü', true))
+        .to eq('ÇDEFGĞHIİJKLMNOÖPQRSŞTUÜçğıiöşü')
+      expect(translate_range('ç-ü', true))
+        .to eq('çdefgğhıijklmnoöpqrsştuüÇĞIİÖŞÜ')
+    end
+  end
+
+  describe '#translate_regexp' do
+    it 'translates simple regexp to include Turkish characters' do
+      expect(translate_regexp(/\w+\s[a-h]/))
+        .to eq(/[\p{Latin}\d_]+\s[abcçdefgğh]/)
+    end
+
+    it 'translates simple regexp range created with Turkish characters' do
+      expect(translate_regexp(/[ç-ş]/))
+        .to eq(/[çdefgğhıijklmnoöpqrsş]/)
+    end
+
+    it 'preserves flags' do
+      expect(translate_regexp(/\w+/mixu))
+        .to eq(/[\p{Latin}\d_]+/mixu)
+    end
+
+    it 'translates many range inside a character class' do
+      expect(translate_regexp(/[a-ht-üy-z]/))
+        .to eq(/[abcçdefgğhtuüyz]/)
+    end
+
+    it 'translates many range inside different character class' do
+      expect(translate_regexp(/[a-ht-üy-z]\s[a-dr-z]/))
+        .to eq(/[abcçdefgğhtuüyz]\s[abcçdrsştuüvwxyz]/)
+    end
+
+    it 'does not translate ranges outside character class' do
+      expect(translate_regexp(/[a-h]+\se-h[ç-ş]afse-h+/))
+        .to eq(/[abcçdefgğh]+\se-h[çdefgğhıijklmnoöpqrsş]afse-h+/)
+    end
+  end
+end

data/spec/turkish_support_spec.rb

@@ -9,249 +9,609 @@ module TurkishSupport
   end
 
   describe String do
-    let(:downcased_turkish_alphabet) { "abcçdefgğhıijklmnoöprsştuüvyz" }
-    let(:upcased_turkish_alphabet)   { "ABCÇDEFGĞHIİJKLMNOÖPRSŞTUÜVYZ" }
+    let(:downcased_turkish_alphabet) { 'abcçdefgğhıijklmnoöprsştuüvyz' }
+    let(:upcased_turkish_alphabet)   { 'ABCÇDEFGĞHIİJKLMNOÖPRSŞTUÜVYZ' }
     let(:downcased_english_alphabet) { [*'a'..'z'].join }
     let(:upcased_english_alphabet)   { [*'A'..'Z'].join }
-    let(:turkish_words)              {  %w(çamur ıhlamur insan ördek şahika ümraniye) }
 
-    describe "#upcase" do
-      context "with non-destructive version" do
-        it "does not change the original value of the string" do
-          expect{ downcased_turkish_alphabet.upcase }.to_not change{ downcased_turkish_alphabet }
+    let(:turkish_words) do
+      %w(çamur ıhlamur insan ördek şahika ümraniye)
+    end
+
+    describe '#[]' do
+      context 'with non-destructive version' do
+        it 'does not change the original value of the string' do
+          word = turkish_words.sample
+
+          expect { word[/\w+/] }
+            .to_not change { word }
+        end
+
+        it 'is able to capture Turkish characters' do
+          expect(turkish_words
+            .all? { |w| w[/\w+/] == w }
+          ).to eq(true)
+
+          expect(turkish_words
+            .all? { |w| w[/[a-z]+/] == w }
+          ).to eq(true)
+
+          expect(
+            turkish_words
+            .map(&:upcase)
+            .all? { |w| w[/[a-z]+/i] == w }
+          ).to eq(true)
         end
+      end
+
+      context 'with destructive version' do
+        it 'changes the original value of the string' do
+          word = turkish_words.sample
+
+          expect { word[/\w+/] = 'new value' }
+            .to change { word }
+
+          expect(word)
+            .to eq('new value')
+        end
+      end
+    end
+
+    describe '#index' do
+      it 'does not change the original value of the string' do
+        word = turkish_words.sample
 
-        it "upcases all of Turkish characters" do
+        expect { word.index(/\w+/) }
+          .to_not change { word }
+      end
+
+      it 'is able to capture Turkish characters' do
+        expect(turkish_words
+          .all? { |w| w.index(/\w+/).zero? }
+        ).to eq(true)
+
+        expect(turkish_words
+          .all? { |w| w.index(/[a-z]+/).zero? }
+        ).to eq(true)
+
+        expect(turkish_words
+          .map(&:upcase)
+          .all? { |w| w.index(/[a-z]+/i).zero? }
+        ).to eq(true)
+      end
+
+      it 'begins to search from the right position' do
+        expect('şç-!+*/-ğüı'.index(/\w+/, 2))
+          .to eq(8)
+      end
+    end
+
+    describe '#rindex' do
+      it 'does not change the original value of the string' do
+        word = turkish_words.sample
+        expect { word.rindex(/\w+/) }
+          .to_not change { word }
+      end
+
+      it 'is able to capture Turkish characters' do
+        expect(turkish_words
+          .map(&:reverse)
+          .all? { |w| w.rindex(/\w+/) == w.size - 1 }
+        ).to eq(true)
+
+        expect(turkish_words
+          .map(&:reverse)
+          .all? { |w| w.rindex(/[a-z]+/) == w.size - 1 }
+        ).to eq(true)
+
+        expect(turkish_words
+          .map(&:upcase)
+          .map(&:reverse)
+          .all? { |w| w.rindex(/[a-z]+/i) == w.size - 1 }
+        ).to eq(true)
+      end
+
+      it 'finishes the searching to the right position' do
+        expect('şç-!+*/-ğüı'.rindex(/\w+/, 7))
+          .to eq(1)
+      end
+    end
+
+    describe '#partition' do
+      let(:word1)     { turkish_words.sample }
+      let(:word2)     { turkish_words.sample }
+      let(:two_words) { "#{word1} #{word2}" }
+
+      it 'does not change the original value of the string' do
+        expect { two_words.partition(/\W+/) }
+          .to_not change { two_words }
+      end
+
+      it 'is able to capture Turkish characters' do
+        expect(two_words.partition(/\W+/)
+        ).to eq([word1, ' ', word2])
+      end
+    end
+
+    describe '#rpartition' do
+      let(:word1)     { turkish_words.sample }
+      let(:word2)     { turkish_words.sample }
+      let(:word3)     { turkish_words.sample }
+      let(:three_words) { "#{word1} #{word2} #{word3}" }
+
+      it 'does not change the original value of the string' do
+        expect { three_words.rpartition(/\W+/) }
+          .to_not change { three_words }
+      end
+
+      it 'is able to capture Turkish characters' do
+        expect(three_words.rpartition(/\W+/))
+          .to eq(["#{word1} #{word2}", ' ', word3])
+      end
+    end
+
+    describe '#slice' do
+      context 'with non-destructive version' do
+        it 'does not change the original value of the string' do
+          sentence = turkish_words * ' '
+
+          expect { sentence.slice(/\w+/) }
+            .to_not change { sentence }
+        end
+
+        it 'is able to capture Turkish characters' do
+          expect(turkish_words
+            .all? { |w| w.slice(/\w+/) == w }
+          ).to eq(true)
+
+          expect(turkish_words
+            .all? { |w| w.slice(/[a-z]+/) == w }
+          ).to eq(true)
+
+          expect(turkish_words
+            .map(&:upcase)
+            .all? { |w| w.slice(/[a-z]+/i) == w }
+          ).to eq(true)
+        end
+      end
+
+      context 'with destructive version' do
+        it 'changes the original value of the string' do
+          sentence = turkish_words * ' '
+
+          expect { sentence.slice!(/\w+/) }
+            .to change { sentence }
+          expect(sentence)
+            .to eq(' ' + turkish_words[1..-1] * ' ')
+        end
+      end
+    end
+
+    describe '#split' do
+      it 'is able to capture Turkish characters' do
+        expect(turkish_words
+          .join(' ')
+          .split(/\w+/)
+          .join
+          .strip
+          .empty?
+        ).to eq(true)
+
+        expect(turkish_words
+          .join(' ')
+          .split(/[a-z]+/)
+          .join
+          .strip
+          .empty?
+        ).to eq(true)
+
+        expect(turkish_words
+          .join(' ')
+          .upcase
+          .split(/[a-z]+/i)
+          .join
+          .strip
+          .empty?
+        ).to eq(true)
+      end
+    end
+
+    describe '#upcase' do
+      context 'with non-destructive version' do
+        it 'does not change the original value of the string' do
+          expect { downcased_turkish_alphabet.upcase }
+            .to_not change { downcased_turkish_alphabet }
+        end
+
+        it 'upcases all of Turkish characters' do
           upcased_string = downcased_turkish_alphabet.upcase
-          expect(upcased_string).to eq( upcased_turkish_alphabet )
+
+          expect(upcased_string)
+            .to eq(upcased_turkish_alphabet)
         end
 
-        it "upcases English characters except i as I" do
+        it 'upcases English characters except i as I' do
           upcased_string = downcased_english_alphabet.upcase
-          expect(upcased_string).to eq( upcased_english_alphabet.tr('I', 'İ'))
+
+          expect(upcased_string)
+            .to eq(upcased_english_alphabet.tr('I', 'İ'))
         end
       end
 
-      context "with destructive version" do
-        it "changes the original value of the string with the upcased version" do
-          expect{ downcased_turkish_alphabet.upcase! }.to change{ downcased_turkish_alphabet }
-          expect( downcased_turkish_alphabet).to eq( upcased_turkish_alphabet )
+      context 'with destructive version' do
+        it 'changes the original value of the string' do
+          expect { downcased_turkish_alphabet.upcase! }
+            .to change { downcased_turkish_alphabet }
+
+          expect(downcased_turkish_alphabet)
+            .to eq(upcased_turkish_alphabet)
         end
       end
     end
 
-    describe "#downcase" do
-      context "with non-destructive version" do
-        it "does not change the original value of the string" do
-          expect{ upcased_turkish_alphabet.downcase }.to_not change{ upcased_turkish_alphabet }
+    describe '#downcase' do
+      context 'with non-destructive version' do
+        it 'does not change the original value of the string' do
+          expect { upcased_turkish_alphabet.downcase }
+            .to_not change { upcased_turkish_alphabet }
         end
 
-        it "downcases all of Turkish characters" do
+        it 'downcases all of Turkish characters' do
           downcased_string = upcased_turkish_alphabet.downcase
-          expect(downcased_string).to eq( downcased_turkish_alphabet )
+
+          expect(downcased_string)
+            .to eq(downcased_turkish_alphabet)
         end
 
-        it "downcases English characters except I as ı" do
+        it 'downcases English characters except I as ı' do
           downcased_string = upcased_english_alphabet.downcase
-          expect(downcased_string).to eq( downcased_english_alphabet.tr('i', 'ı'))
+          expect(downcased_string)
+            .to eq(downcased_english_alphabet.tr('i', 'ı'))
         end
       end
 
-      context "with destructive version" do
-        it "changes the original value of the string with the downcased version" do
-          expect{ upcased_turkish_alphabet.downcase! }.to change{ upcased_turkish_alphabet }
-          expect( upcased_turkish_alphabet).to eq(downcased_turkish_alphabet)
+      context 'with destructive version' do
+        it 'changes the original value of the string' do
+          expect { upcased_turkish_alphabet.downcase! }
+            .to change { upcased_turkish_alphabet }
+          expect(upcased_turkish_alphabet)
+            .to eq(downcased_turkish_alphabet)
         end
       end
     end
 
-    describe "#capitalize" do
-      context "with non-destructive version" do
-        it "does not change the original value of the string" do
+    describe '#capitalize' do
+      context 'with non-destructive version' do
+        it 'does not change the original value of the string' do
           turkish_word = turkish_words.sample
-          expect{ turkish_word.capitalize }.to_not change{ turkish_word }
+
+          expect { turkish_word.capitalize }
+            .to_not change { turkish_word }
         end
 
-        it "capitalizes the first character of a string that starts with an unsupported Turkish character" do
-          capitalized_words = turkish_words.map{ |w| w.capitalize }
-          expect(capitalized_words).to eq(%w[Çamur Ihlamur İnsan Ördek Şahika Ümraniye])
+        it 'capitalizes the leading first Turkish character' do
+          # rubocop:disable Style/SymbolProc
+          capitalized_words = turkish_words.map { |w| w.capitalize }
+
+          expect(capitalized_words)
+            .to eq(%w(Çamur Ihlamur İnsan Ördek Şahika Ümraniye))
         end
 
-        it "capitalizes the first character of a string and downcase others" do
-          capitalized_words = turkish_words.map{ |w| w.capitalize }
-          expect('türkÇE desteĞİ'.capitalize).to eq('Türkçe desteği')
+        it 'capitalizes the first character of a string and downcase others' do
+          expect('türkÇE desteĞİ'.capitalize)
+            .to eq('Türkçe desteği')
         end
 
-        it "capitalizes the first character of an English string" do
-          english_word = "spy"
+        it 'capitalizes the first character of an English string' do
+          english_word = 'spy'
           capitalized_string = english_word.capitalize
-          expect(capitalized_string).to eq("Spy")
+
+          expect(capitalized_string)
+            .to eq('Spy')
         end
       end
 
-      context "with destructive version" do
-        it "changes the original value of the string with the capitalized version" do
+      context 'with destructive version' do
+        it 'changes the original value of the string' do
           turkish_word = 'çamur'
-          expect{ turkish_word.capitalize! }.to change{ turkish_word }
-          expect(turkish_word).to eq('Çamur')
+
+          expect { turkish_word.capitalize! }
+            .to change { turkish_word }
+
+          expect(turkish_word)
+            .to eq('Çamur')
         end
       end
     end
 
-    describe "#casecmp" do
-      it "compares Turkish characters correctly" do
+    describe '#casecmp' do
+      it 'compares Turkish characters correctly' do
         result = downcased_turkish_alphabet.casecmp(upcased_turkish_alphabet)
-        expect(result).to be_zero
+
+        expect(result.zero?)
+          .to eq(true)
       end
 
-      it "compares Turkish characters correctly" do
-        result = downcased_turkish_alphabet.casecmp(upcased_turkish_alphabet)
-        expect('sıtkı'.casecmp('SıTKI')).to eq(0)
+      it 'compares Turkish characters correctly' do
+        expect('sıtkı'.casecmp('SıTKI').zero?)
+          .to eq(true)
       end
     end
 
-    describe "#titleize" do
-      context "with non-destructive version" do
-        it "does not change the original value of the string" do
-          word = "mERHABA çAMUR iSMETOĞULLARI"
-          expect{ word.titleize }.to_not change{ word }
+    describe '#titleize' do
+      context 'with non-destructive version' do
+        it 'does not change the original value of the string' do
+          word = 'mERHABA çAMUR iSMETOĞULLARI'
+
+          expect { word.titleize }
+            .to_not change { word }
         end
 
-        it "upcases first character of all words" do
-          titleized = "merhaba çamur ismet".titleize
-          expect(titleized).to eq("Merhaba Çamur İsmet")
+        it 'upcases first character of all words' do
+          titleized = 'merhaba çamur ismet'.titleize
+
+          expect(titleized)
+            .to eq('Merhaba Çamur İsmet')
         end
 
-        it "downcases characters other than first characters of all words" do
-          titleized = "mERHABA çAMUR iSMETOĞULLARI".titleize
-          expect(titleized).to eq("Merhaba Çamur İsmetoğulları")
+        it 'downcases characters other than first characters of all words' do
+          titleized = 'mERHABA çAMUR iSMETOĞULLARI'.titleize
+
+          expect(titleized)
+            .to eq('Merhaba Çamur İsmetoğulları')
         end
 
-        it "support strings that include paranthesis, quotes, etc." do
+        it 'support strings that include paranthesis, quotes, etc.' do
           titleized = "rUBY roCkS... (really! 'tRUSt' ME)".titleize
-          expect(titleized).to eq("Ruby Rocks... (Really! 'Trust' Me)")
+
+          expect(titleized)
+            .to eq("Ruby Rocks... (Really! 'Trust' Me)")
         end
 
-        it "doesn't capitalize conjuctions when false passed" do
-          titleized = "kerem VE aslı VeYa leyla İlE mecnun".titleize(false)
-          expect(titleized).to eq("Kerem ve Aslı veya Leyla ile Mecnun")
+        it 'does not capitalize conjuctions when false passed' do
+          titleized = 'kerem VE aslı VeYa leyla İlE mecnun'.titleize(false)
+
+          expect(titleized)
+            .to eq('Kerem ve Aslı veya Leyla ile Mecnun')
         end
       end
 
-      context "with destructive version" do
-          it "changes the original value of the string with the titleized version" do
-            word = "mERHABA çAMUR iSMETOĞULLARI"
-            expect{ word.titleize! }.to change{ word }
-            expect(word).to eq("Merhaba Çamur İsmetoğulları")
-          end
+      context 'with destructive version' do
+        it 'changes the original value of the string' do
+          word = 'mERHABA çAMUR iSMETOĞULLARI'
+
+          expect { word.titleize! }
+            .to change { word }
+
+          expect(word)
+            .to eq('Merhaba Çamur İsmetoğulları')
         end
+      end
     end
 
-    describe "#swapcase" do
-      context "with non-destructive version" do
-        it "does not change the original value of the string" do
-          word = "mErHaba çamur ismetoğullarI"
-          expect{ word.swapcase }.to_not change{ word }
+    describe '#swapcase' do
+      context 'with non-destructive version' do
+        it 'does not change the original value of the string' do
+          word = 'mErHaba çamur ismetoğullarI'
+
+          expect { word.swapcase }
+            .to_not change { word }
         end
 
-        it "swaps characters correctly" do
-          word = "mErHaba çamur ismetoğullarI".swapcase
-          expect(word).to eq("MeRhABA ÇAMUR İSMETOĞULLARı")
+        it 'swaps characters correctly' do
+          word = 'mErHaba çamur ismetoğullarI'.swapcase
+
+          expect(word)
+            .to eq('MeRhABA ÇAMUR İSMETOĞULLARı')
         end
       end
 
-      context "with destructive version" do
-        it "changes the original value of the string with the swapcased version" do
-          word = "mErHaba çamur ismetoğullarI"
-          expect{ word.swapcase! }.to change{ word }
-          expect(word).to eq('MeRhABA ÇAMUR İSMETOĞULLARı')
+      context 'with destructive version' do
+        it 'changes the original value of the string' do
+          word = 'mErHaba çamur ismetoğullarI'
+
+          expect { word.swapcase! }
+            .to change { word }
+          expect(word)
+            .to eq('MeRhABA ÇAMUR İSMETOĞULLARı')
         end
       end
     end
 
-    describe "#match" do
+    describe '#match' do
       it "matches Turkish characters when regex include '\\w'" do
-        expect('Aşağı'.match(/\w+/).to_s).to eq('Aşağı')
-        expect('Aşağı Ayrancı'.match(/^\w+\s\w+$/).to_s).to eq('Aşağı Ayrancı')
+        expect('Aşağı'.match(/\w+/).to_s)
+          .to eq('Aşağı')
+
+        expect('Aşağı Ayrancı'.match(/^\w+\s\w+$/).to_s)
+          .to eq('Aşağı Ayrancı')
       end
 
-      it "matches Turkish characters when regex include lowercase range" do
-        expect('aüvvağğ öövvaağ'.match(/^[a-z]+\s[a-z]+$/).to_s).to eq('aüvvağğ öövvaağ')
+      it 'matches Turkish characters when regex include lowercase range' do
+        expect('aüvvağğ öövvaağ'.match(/^[a-z]+\s[a-z]+$/).to_s)
+          .to eq('aüvvağğ öövvaağ')
       end
 
-      it "matches Turkish characters when regex include uppercase range" do
-        expect('BAĞCIlar'.match(/[A-Z]+/).to_s).to eq('BAĞCI')
+      it 'matches Turkish characters when regex include uppercase range' do
+        expect('BAĞCIlar'.match(/[A-Z]+/).to_s)
+          .to eq('BAĞCI')
       end
 
       it "doesn't match Turkish characters when regex include '\\W'" do
-        expect('Aşağı Ayrancı'.match(/\W+/).to_s).to eq(' ')
+        expect('Aşağı Ayrancı'
+          .match(/\W+/)
+          .to_s
+        ).to eq(' ')
       end
     end
 
-    describe "#scan" do
+    describe '#scan' do
       it "matches Turkish characters when regex include '\\w'" do
-        expect(turkish_words.join(' ').scan(/\w+/)).to eq(turkish_words)
+        expect(turkish_words
+          .join(' ')
+          .scan(/\w+/)
+        ).to eq(turkish_words)
       end
 
-      it "matches Turkish characters when regex include lowercase range" do
-        expect(turkish_words.join(' ').scan(/^[a-z\s]+$/)).to eq([turkish_words.join(' ')])
+      it 'matches Turkish characters when regex include lowercase range' do
+        expect(turkish_words
+          .join(' ')
+          .scan(/^[a-z\s]+$/)
+        ).to eq([turkish_words.join(' ')])
       end
 
-      it "matches Turkish characters when regex include uppercase range" do
-        expect(turkish_words.join(' ').upcase.scan(/^[A-Z\s]+$/)).to eq([turkish_words.join(' ').upcase])
+      it 'matches Turkish characters when regex include uppercase range' do
+        expect(turkish_words
+          .join(' ')
+          .upcase
+          .scan(/^[A-Z\s]+$/)
+        ).to eq([turkish_words.join(' ').upcase])
       end
 
       it "matches Turkish characters when regex include '\\w'" do
-        expect(turkish_words.join(' ').scan(/\W+/).map(&:strip).all?(&:empty?)).to eq(true)
+        expect(turkish_words
+          .join(' ')
+          .scan(/\W+/)
+          .map(&:strip)
+          .all?(&:empty?)
+        ).to eq(true)
       end
     end
 
-    describe "#=~" do
-      tr_chars = UNSUPPORTED_DOWNCASE_CHARS+UNSUPPORTED_UPCASE_CHARS
+    describe '#=~' do
+      tr_chars = ALPHA[:tr_lower] + ALPHA[:tr_upper]
 
       it "matches Turkish characters when regex include '\\w'" do
-        expect(tr_chars.split(//).all? {|ch| (ch =~ /\w/) == 0}).to eq(true)
+        expect(tr_chars
+          .split(//)
+          .all? { |ch| (ch =~ /\w/).zero? }
+        ).to eq(true)
       end
 
-      it "matches Turkish characters when regex include lowercase range" do
-        expect(UNSUPPORTED_DOWNCASE_CHARS.split(//).all? {|ch| (ch =~ /[a-z]/) == 0}).to eq(true)
+      it 'matches Turkish characters when regex include lowercase range' do
+        expect(ALPHA[:tr_lower]
+          .split(//)
+          .all? { |ch| (ch =~ /[a-z]/).zero? }
+        ).to eq(true)
       end
 
-      it "matches Turkish characters when regex include uppercase range" do
-        expect(UNSUPPORTED_UPCASE_CHARS.split(//).all? {|ch| (ch =~ /[A-Z]/) == 0}).to eq(true)
+      it 'matches Turkish characters when regex include uppercase range' do
+        expect(ALPHA[:tr_upper]
+          .split(//)
+          .all? { |ch| (ch =~ /[A-Z]/).zero? }
+        ).to eq(true)
       end
 
       it "doesn't match Turkish characters when regex include '\\W'" do
-        expect(tr_chars.split(//).all? {|ch| (ch =~ /\W/).nil?}).to eq(true)
+        expect(tr_chars
+          .split(//)
+          .all? { |ch| (ch =~ /\W/).nil? }
+        ).to eq(true)
+      end
+    end
+
+    describe '#sub' do
+      context 'non-destructive version' do
+        it 'does not affect the object' do
+          word = 'ağapaşa ağa'
+
+          expect { word.sub(/\w+/, 'bey') }
+            .to_not change { word }
+        end
+
+        it 'matches Turkish characters, and replaces them' do
+          expect('ağapaşa ağa'.sub(/\w+/, 'bey'))
+            .to eq('bey ağa')
+
+          expect('ağapaşa ağa şapka'.sub(/\W+/, 'bey'))
+            .to eq('ağapaşabeyağa şapka')
+
+          expect('ağapaşaağa'.sub(/[a-h]+/, 'bey'))
+            .to eq('beypaşaağa')
+        end
+      end
+
+      context 'destructive version' do
+        it 'affects the object' do
+          word = 'ağapaşa ağa'
+
+          expect { word.sub!(/\w+/, 'bey') }
+            .to change { word }
+            .from('ağapaşa ağa')
+            .to('bey ağa')
+        end
+      end
+    end
+
+    describe '#gsub' do
+      context 'non-destructive version' do
+        it 'does not affect the object' do
+          word = 'ağapaşa ağa'
+
+          expect { word.gsub(/\w+/, 'bey') }
+            .to_not change { word }
+        end
+
+        it 'matches Turkish characters, and replaces them' do
+          expect('ağapaşa ağa'.gsub(/\w+/, 'bey'))
+            .to eq('bey bey')
+
+          expect('ağapaşa ağa şapka'.gsub(/\W+/, 'bey'))
+            .to eq('ağapaşabeyağabeyşapka')
+
+          expect('ağapaşaağa'.gsub(/[a-h]+/, 'bey'))
+            .to eq('beypbeyşbey')
+        end
+      end
+
+      context 'destructive version' do
+        it 'affects the object' do
+          word = 'ağapaşa ağa'
+          expect { word.gsub!(/\w+/, 'bey') }
+            .to change { word }
+            .from('ağapaşa ağa')
+            .to('bey bey')
+        end
       end
     end
   end
 
   describe Array do
-    let(:unsorted_array1) { %w(bağcılar bahçelievler şimdi çüNKÜ olmalı üç\ kere düş ılık duy) }
-    let(:sorted_array1)   { %w(bağcılar bahçelievler çüNKÜ duy düş ılık olmalı şimdi üç\ kere) }
+    let(:unsorted_array1) do
+      %w(bağcılar bahçelievler şimdi çüNKÜ olmalı üç\ kere düş ılık duy)
+    end
+
+    let(:sorted_array1) do
+      %w(bağcılar bahçelievler çüNKÜ duy düş ılık olmalı şimdi üç\ kere)
+    end
+
     let(:unsorted_array2) { %w(iki Üç dört ılık İğne iyne Ul) }
     let(:sorted_array2)   { %w(İğne Ul Üç dört ılık iki iyne) }
 
-    describe "#sort" do
-      context "with non-destructive version" do
-        it "does not change the original value of the array" do
-          expect{ unsorted_array1.sort }.to_not change{ unsorted_array1 }
+    describe '#sort' do
+      context 'with non-destructive version' do
+        it 'does not change the original value of the array' do
+          expect { unsorted_array1.sort }
+            .to_not change { unsorted_array1 }
         end
 
-        it "sorts array in alphabetical order" do
-          expect(unsorted_array1.sort).to eq(sorted_array1)
+        it 'sorts array in alphabetical order' do
+          expect(unsorted_array1.sort)
+            .to eq(sorted_array1)
         end
 
-        it "sorts array in alphabetical order" do
-          expect(unsorted_array2.sort).to eq(sorted_array2)
+        it 'sorts array in alphabetical order' do
+          expect(unsorted_array2.sort)
+            .to eq(sorted_array2)
         end
       end
 
-      context "with destructive version" do
-        it "changes the original value of the array" do
-          expect{ unsorted_array1.sort! }.to change{ unsorted_array1 }
-          expect(unsorted_array1).to eq(sorted_array1)
+      context 'with destructive version' do
+        it 'changes the original value of the array' do
+          expect { unsorted_array1.sort! }
+            .to change { unsorted_array1 }
+          expect(unsorted_array1)
+            .to eq(sorted_array1)
         end
       end
     end