turkish_support 1.1.0 → 2.1.0

data/lib/turkish_support/array_methods.rb

@@ -1,15 +1,12 @@
+# frozen_string_literal: true
+
 module TurkishSupport
+  # :nodoc:
   refine Array do
     def sort
-      sort_by do |item|
-        item.chars.map do |ch|
-          if ALPHABET.include?(ch)
-            ASCII_ALPHABET[ch]
-          else
-            ch.ord
-          end
-        end
-      end
+      return super if block_given?
+
+      sort_by { _1.chars.map { |ch| TurkishRanges::TrText.new(ch).code } }
     end
 
     def sort!

data/lib/turkish_support/constants.rb

@@ -1,56 +1,30 @@
-module TurkishSupportHelpers
-  ALPHA = {
-    lower:    'abcçdefgğhıijklmnoöpqrsştuüvwxyz',
-    upper:    'ABCÇDEFGĞHIİJKLMNOÖPQRSŞTUÜVWXYZ',
-    tr_lower: 'çğıiöşü',
-    tr_upper: 'ÇĞIİÖŞÜ'
-  }.freeze
+# frozen_string_literal: true
 
-  ALPHABET = ALPHA[:upper] + ALPHA[:lower]
-  
-  ASCII_ALPHABET = ALPHABET.chars.map.with_index do |ch, i|
-    # Add 65 to put special chars and numbers in correct order
-    [ch, i + 65]
-  end.to_h
-  
-  META_CHARS = {
-    '\w' => '[\p{Latin}\d_]',
-    '\W' => '[^\p{Latin}\d_]'
-  }.freeze
+module TurkishSupport
+  CASE_METHODS = %i[downcase
+                    downcase!
+                    upcase
+                    upcase!
+                    capitalize
+                    capitalize!
+                    swapcase
+                    swapcase!].freeze
 
-  # Regexp required methods
-  RE_RE_METHS = %i(match scan).freeze
-
-  # Regexp optional methods
-  RE_OP_METHS = %i(
-    []
-    []=
-    =~
-    index
-    rindex
-    partition
-    rpartition
-    slice
-    slice!
-    split
-    sub
-    sub!
-    gsub
-    gsub!
-  ).freeze
-
-  CASE_RELATED_METHS = %i(
-    downcase
-    downcase!
-    upcase
-    upcase!
-    capitalize
-    capitalize!
-  ).freeze
-
-  RANGE_REGEXP = /\[[^\]]*?([#{ALPHABET}]-[#{ALPHABET}])[^\[]*?\]/
-
-  CONJUCTIONS = %w(ve ile veya).freeze
-
-  SPECIAL_CHARS = %q{("'}.freeze
+  REGEX_METHODS = %i[[]
+                     []=
+                     index
+                     gsub
+                     gsub!
+                     match
+                     rindex
+                     partition
+                     rpartition
+                     scan
+                     slice
+                     slice!
+                     split
+                     sub
+                     sub!
+                     gsub
+                     gsub!].freeze
 end

data/lib/turkish_support/string_methods.rb

@@ -1,78 +1,56 @@
+# frozen_string_literal: false
+
 module TurkishSupport
   refine String do # rubocop:disable Metrics/BlockLength
-    (RE_RE_METHS + RE_OP_METHS).each do |meth|
+    REGEX_METHODS.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])
+        if args[0].is_a?(Regexp) || %i[match scan].include?(meth)
+          args[0] = TurkishRegexps::TrRegexp.new(args[0]).translate
         end
 
-        super(*args)
+        instance_exec { super(*args) }
       end
     end
 
-    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
+    CASE_METHODS.each { define_method(_1) { super(:turkic) } }
 
-    def titleize(conjuctions = true) # rubocop:disable Metrics/AbcSize
-      split.map do |word|
-        word.downcase!
-        if conjuction?(word) && !conjuctions
-          word
-        elsif start_with_a_special_char?(word)
-          word.size > 1 ? word[0] + word[1..-1].capitalize : word.chr
-        else
-          word.capitalize
-        end
-      end.join(' ')
+    # capitalize all words and returns a copy of the string
+    #
+    # @return [String]
+    def titleize
+      downcase.gsub(/\b\S/u).each { _1.upcase }
     end
 
-    def titleize!(conjuctions = true)
-      replace(titleize(conjuctions))
+    # capitalize all words in place
+    # @return [String]
+    def titleize!
+      replace(titleize)
     end
 
-    def swapcase
-      extend(TurkishSupportHelpers)
-      chars.map do |ch|
-        if tr_char?(ch)
-          tr_lower?(ch) ? ch.upcase : ch.downcase
-        else
-          ch.public_send(:swapcase)
-        end
-      end.join
+    def casecmp(other) # :nodoc:
+      upcase.instance_exec { super(other.upcase) }
     end
 
-    def swapcase!
-      replace(swapcase)
-    end
+    def <=>(other) # :nodoc:
+      return nil unless other.is_a? String
 
-    def casecmp(other_string)
-      upcase.public_send(:casecmp, other_string.upcase)
+      TurkishRanges::TrText.new(to_s) <=> TurkishRanges::TrText.new(other)
     end
 
-    def <=>(other_string)
-      return nil unless other_string.is_a? String
+    def >(other) # :nodoc:
+      (self <=> other) == 1
+    end
 
-      each_char.with_index do |ch, i|
-        position1 = ASCII_ALPHABET[ch]
-        position2 = ASCII_ALPHABET[other_string[i]]
+    def <(other) # :nodoc:
+      (self <=> other) == -1
+    end
 
-        return (position2.nil? ? 0 : -1) if position1.nil?
-        return 1 if position2.nil?
-        return (position1 < position2 ? -1 : 1) if position1 != position2
-      end
+    def >=(other)  # :nodoc:
+      (self <=> other) != -1
+    end
 
-      return  0 if length == other_string.length
-      return -1 if length < other_string.length
-      return  1
-      
+    def <=(other)  # :nodoc:
+      (self <=> other) != 1
     end
   end
 end

data/lib/turkish_support/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module TurkishSupport
-  VERSION = '1.1.0'.freeze
+  VERSION = '2.1.0'
 end

data/spec/array_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: false
+
+using TurkishSupport
+
+describe 'Array' do
+  describe '#sort' do
+    let(:samples) do
+      [{ 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\ ] }]
+    end
+    let(:block_samples) do
+      [{ 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]] } }]
+    end
+
+    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

data/spec/spec_helper.rb

@@ -1,2 +1,4 @@
-$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
 require 'turkish_support'

data/spec/string_spec.rb

@@ -0,0 +1,467 @@
+# frozen_string_literal: false
+
+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    be true
+          expect(turkish_words.all? { |w| w[/[a-z]+/] == w }).to be true
+          expect(turkish_words.map(&:upcase).all? { |w| w[/[a-z]+/i] == w }).to be 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    be true
+        expect(turkish_words.all? { |w| w.index(/[a-z]+/).zero? }).to be true
+        expect(turkish_words.map(&:upcase).all? { |w| w.index(/[a-z]+/i).zero? }).to be true
+      end
+
+      it 'begins to search from the right position' do
+        expect('şç-!+*/-ğüı'.index(/\w+/, 2)).to be 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    be true
+        expect(turkish_words.map(&:reverse).all? { |w| w.rindex(/[a-z]+/) == w.size - 1 }).to be true
+        expect(turkish_words.map { |w| w.upcase.reverse }.all? { |w| w.rindex(/[a-z]+/i) == w.size - 1 }).to be true
+      end
+
+      it 'finishes the searching to the right position' do
+        expect('şç-!+*/-ğüı'.rindex(/\w+/, 7)).to be 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    be true
+          expect(turkish_words.all? { |w| w.slice(/[a-z]+/) == w }).to be true
+          expect(turkish_words.map(&:upcase).all? { |w| w.slice(/[a-z]+/i) == w }).to be 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    be true
+        expect(turkish_words.join(' ').split(/[a-z]+/).join.strip.empty?).to be true
+        expect(turkish_words.join(' ').upcase.split(/[a-z]+/i).join.strip.empty?).to be 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 be true
+      end
+
+      it 'compares Turkish characters correctly' do
+        expect('sıtkı'.casecmp('SıTKI')&.zero?).to be 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
+      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 be 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
+      it 'should compares turkish cars correctly' do
+        expect('d'   > 'ç').to   be true
+        expect('ağa' > 'aga').to be true
+        expect('ğ'   > 'h').to   be false
+      end
+    end
+
+    describe '#>=' do
+      it 'should compares turkish cars correctly' do
+        expect('d'   >= 'ç').to   be true
+        expect('aha' >= 'ağa').to be true
+        expect('ğ.'  >= 'ğ').to   be true
+      end
+    end
+
+    describe '#<' do
+      it 'should compares turkish cars correctly' do
+        expect('d'   < 'ç').to   be false
+        expect('ağa' < 'aga').to be false
+        expect('ğ'   < 'h').to   be true
+      end
+    end
+
+    describe '#<=' do
+      it 'should compares turkish cars correctly' do
+        expect('d'   <= 'ç').to   be false
+        expect('aha' <= 'ağa').to be false
+        expect('ğ.'  <= 'ğ').to   be false
+      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        be nil
+          expect('a' <=> true).to       be nil
+          expect('a' <=> Object.new).to be nil
+          expect('a' <=> 1).to          be nil
+        end
+      end
+    end
+  end
+end