turkish_support 1.0.4 → 2.0.1

data/lib/turkish_support/version.rb

@@ -1,3 +1,3 @@
 module TurkishSupport
-  VERSION = '1.0.4'.freeze
+  VERSION = '2.0.1'.freeze
 end

data/spec/array_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+using TurkishSupport
+
+module TurkishSupport  
+  describe Array do
+    describe '#sort' do
+    
+      let(:samples) { 
+        [
+          { 
+            mixed: %w[ bağcılar bahçelievler şimdi çüNKÜ olmalı üç\ kere düş ılık duy ],
+            sorted: %w[ bağcılar bahçelievler çüNKÜ duy düş ılık olmalı şimdi üç\ kere ] 
+          },
+          { 
+            mixed: %w[ iki Üç dört ılık İğne iyne Ul ],
+            sorted: %w[ İğne Ul Üç dört ılık iki iyne ]
+          },
+          { 
+            mixed: %w[ Sıtkı1\ Bağdat Sıtkı\ Bağdat a 3s 2\ b ab\ ],
+            sorted: %w[ 2\ b 3s Sıtkı\ Bağdat Sıtkı1\ Bağdat a ab\ ] 
+          }
+        ] 
+      }
+
+      let(:block_samples) {
+        [
+          {
+            mixed: %w[ ağa aça aşa aöa aüa aua afa aba ],
+            sorted: {
+              "a[1]<=>b[1]": %w[ aba aça afa ağa aöa aşa aua aüa ],
+              "b[1]<=>a[1]": %w[ aüa aua aşa aöa ağa afa aça aba ]
+            }
+          },
+          {
+            mixed: %w[ iki Üç dört ılık İğne iyne Ul ],
+            sorted: {
+              "a.length<=>b.length": %w[ Üç Ul iki dört ılık İğne iyne ],
+              "b.length<=>a.length": %w[dört ılık İğne iyne iki Üç Ul ]
+            }
+          },
+          {
+            mixed: [["Şakir", 2], ["İsmet", 0], ["Zeliha", 1]],
+            sorted: {
+              "a[1]<=>b[1]": [["İsmet", 0], ["Zeliha", 1], ["Şakir", 2]],
+              "b[0]<=>a[0]": [["Zeliha", 1], ["Şakir", 2], ["İsmet", 0]]
+            }
+          }
+        ]
+      }
+
+      context 'nondestructive version' do
+        context 'no block given' do
+          it 'does not change the original value of the array' do
+            samples.each do |sample|
+              expect { sample[:mixed].sort }.to_not change { sample[:mixed] }
+            end
+          end
+
+          it 'sorts array in alphabetical order' do
+            samples.each do |sample|
+              expect(sample[:mixed].sort).to eq(sample[:sorted])
+            end
+          end
+        end
+
+        context 'block given' do
+          it 'sorts array for random conditions' do
+            sample = block_samples.first
+            expect(sample[:mixed].sort {|a, b| a[1] <=> b[1]})
+              .to eq(sample[:sorted][:"a[1]<=>b[1]"])
+
+            expect(sample[:mixed].sort {|a, b| b[1] <=> a[1]})
+              .to eq(sample[:sorted][:"b[1]<=>a[1]"])
+
+            sample = block_samples[1]
+            expect(sample[:mixed].sort {|a, b| a.length <=> b.length})
+              .to eq(sample[:sorted][:"a.length<=>b.length"])
+
+            expect(sample[:mixed].sort {|a, b| b.length <=> a.length})
+              .to eq(sample[:sorted][:"b.length<=>a.length"])
+          end
+
+          it 'sorts nested arrays' do
+            sample = block_samples[2]
+            expect(sample[:mixed].sort {|a, b| a[1] <=> b[1]})
+              .to eq(sample[:sorted][:"a[1]<=>b[1]"])
+            expect(sample[:mixed].sort {|a, b| b[0] <=> a[0]})
+              .to eq(sample[:sorted][:"b[0]<=>a[0]"])
+          end
+        end
+      end
+
+      context 'with destructive version' do
+        it 'changes the original value of the array' do
+          samples.each do |sample|
+              expect { sample[:mixed].sort! }.to change { sample[:mixed] }
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/helpers_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'turkish_support/helpers'
 
@@ -13,176 +15,90 @@ describe 'TurkishSupportHelpers' do
   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
+  let(:conjuctions)        { %w[ve ile veya] }
+  let(:turkish_words)      { %w[çamur ıhlamur insan ördek şahika ümraniye] }
+  let(:special_chars)      { %w[( " '] }
 
   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)
+      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)
+        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)
+        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)
+        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)
+      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)
+        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)
+        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)
+        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)
+      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)
+        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)
+        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)
+      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)
+      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)
+      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)
+      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)
+      expect(translate_range('a-z')).to(eq(downcased_alphabet))
     end
 
     it 'translates a complete upper-case range correctly' do
@@ -193,65 +109,52 @@ describe 'TurkishSupportHelpers' 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)
+               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!'
+        .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Ü')
+      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öş')
+      expect(translate_range('d-t', casefold: true)).to(eq('defgğhıijklmnoöpqrsştĞIİÖŞ'))
+      expect(translate_range('C-U', casefold: 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İÖŞÜ')
+      expect(translate_range('Ç-Ü', casefold: true)).to(eq('ÇDEFGĞHIİJKLMNOÖPQRSŞTUÜçğıiöşü'))
+      expect(translate_range('ç-ü', casefold: 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]/)
+      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ş]/)
+      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)
+      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]/)
+      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]/)
+      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

data/spec/string_spec.rb

@@ -0,0 +1,415 @@
+require 'spec_helper'
+using TurkishSupport
+
+module TurkishSupport # rubocop:disable Metrics/ModuleLength
+  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_english_alphabet) { ('a'..'z').to_a.join }
+    let(:upcased_english_alphabet)   { ('A'..'Z').to_a.join }
+    let(:turkish_words) { %w[çamur ıhlamur insan ördek şahika ümraniye] }
+
+    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
+        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 { |w| w.upcase.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..] * ' '}")
+        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))
+        end
+
+        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', 'İ')))
+        end
+      end
+
+      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 })
+        end
+
+        it 'downcases all of Turkish characters' do
+          downcased_string = upcased_turkish_alphabet.downcase
+          expect(downcased_string).to(eq(downcased_turkish_alphabet))
+        end
+
+        it 'downcases English characters except I as ı' do
+          downcased_string = upcased_english_alphabet.downcase
+          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' 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
+          turkish_word = turkish_words.sample
+          expect { turkish_word.capitalize }.to_not(change { turkish_word })
+        end
+
+        it 'capitalizes the leading first Turkish character' do
+          capitalized_words = turkish_words.map(&: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
+          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'
+          expect(english_word.capitalize).to(eq('Spy'))
+        end
+      end
+
+      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')
+        end
+      end
+    end
+
+    describe '#casecmp' do
+      it 'compares Turkish characters correctly' do
+        result = downcased_turkish_alphabet.casecmp(upcased_turkish_alphabet)
+
+        expect(result.zero?).to(eq(true))
+      end
+
+      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 })
+        end
+
+        it 'upcases first character of all words' do
+          titleized = 'merhaba çamur ismet'.titleize
+          expect(titleized).to(eq('Merhaba Çamur İsmet'))
+        end
+
+        it 'no problem with words that consist of special chars only' 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ı'))
+        end
+
+        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)"))
+        end
+
+        it 'does not capitalize conjuctions when false passed' do
+          titleized = 'kerem VE aslı VeYa leyla İlE mecnun'.titleize(conjuction: 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' 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 })
+        end
+
+        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' 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
+      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ı'))
+      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ğ'))
+      end
+
+      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(' '))
+      end
+    end
+
+    describe '#scan' do
+      it "matches Turkish characters when regex include '\\w'" do
+        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(' ')]))
+      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]))
+      end
+
+      it "matches Turkish characters when regex include '\\w'" do
+        expect(turkish_words.join(' ').scan(/\W+/).map(&:strip).all?(&:empty?)).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
+
+    describe '#<=>' do
+      let(:sorted_equal_length_strings) { %w[Cahit Çağla Ömer Sıtkı Şakir] }
+      let(:sorted_different_length_strings) { %w[c ca falan om saki sıt] }
+      context 'with equal length strings' do
+        it 'works for smaller test' do
+          0.upto(sorted_equal_length_strings.length - 2) do |i|
+            expect(sorted_equal_length_strings[i] <=> sorted_equal_length_strings[i + 1]).to(eq(-1))
+          end
+        end
+
+        it 'works for bigger test' do
+          (sorted_equal_length_strings.length - 1).downto(1) do |i|
+            expect(sorted_equal_length_strings[i] <=> sorted_equal_length_strings[i - 1]).to(eq(1))
+          end
+        end
+
+        it 'works for equals test' do
+          sorted_equal_length_strings.each do |str|
+            expect(str <=> str).to eq(0)  # rubocop:disable Lint/BinaryOperatorWithIdenticalOperands
+          end
+        end
+      end
+
+      context 'with different length strings' do
+        it 'works for smaller test' do
+          0.upto(sorted_different_length_strings.length - 2) do |i|
+            expect(sorted_different_length_strings[i] <=> sorted_different_length_strings[i + 1]).to eq(-1)
+          end
+        end
+
+        it 'works for bigger test' do
+          (sorted_different_length_strings.length - 1).downto(1) do |i|
+            expect(sorted_different_length_strings[i] <=> sorted_different_length_strings[i - 1]).to eq(1)
+          end
+        end
+      end
+
+      context 'invalid comparisons' do
+        it 'returns nil' do
+          expect('a' <=> 3.5).to eq(nil)
+          expect('a' <=> true).to eq(nil)
+          expect('a' <=> Object.new).to eq(nil)
+          expect('a' <=> 1).to eq(nil)
+        end
+      end
+    end
+  end
+end