turkish_support 1.1.3 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ea4d5444e4bb6da4e3b833a0722f6d7f3540e4ce4271500f8807e84c91d72af
-  data.tar.gz: 63d120ac7d6794356019abb14f0cad1aad6d1af76277209581f821bbd3d56e66
+  metadata.gz: 661daa780f4a86533a3e5b3d7607b5d131549c928ab65db35598f93fbf89c103
+  data.tar.gz: 6006aa50c352658fbac41af13e40e77c49e09ea9887bb2ac605457f0734f14ad
 SHA512:
-  metadata.gz: a8f9d5c9c02da13a3bf45b59e09937702382422d7ae08c63a9e7aab7853052a1e73716c0ba5079fcdf5310b30dd2b4100f35c186ca943513e2a04345da1470c6
-  data.tar.gz: 2de927b3c9352ce60a2e650da231fe08c76b5ecc7fc04479bf06cf9fe61603988c798d5f675cbcfa302e09c1585cca6512469719781c7f58b311d74488e077da
+  metadata.gz: 2b06283e2a0626719a52e3e18e26bc3c4555ecedc2f2e7b05dd998a15953ef0ddf0cbf0b00ce88364941e3c8451467f9d24b6a3ee972f52422e6133e67ff1a30
+  data.tar.gz: e1cffa240cec788281aee54e8a1435255f90e4757b945e5768d100d48408168071a3137e1ba1597d1ce46d8383635e2c426b9fdb9371b02fde58edf38aeb5af0

data/.gitignore

@@ -16,3 +16,4 @@ test/tmp
 test/version_tmp
 tmp
 todo.txt
+.idea/*

data/.rubocop.yml

@@ -1,3 +1,5 @@
+AllCops:
+  TargetRubyVersion: 2.7
 StringLiterals:
   EnforcedStyle: single_quotes
 Documentation:

data/.travis.yml

@@ -1,3 +1,3 @@
 language: ruby
 rvm:
-  - 2.2.0
+  - 2.7.0

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2014-2017 Sıtkı Bağdat
+Copyright (c) 2014-2020 Sıtkı Bağdat
 
 MIT License
 

data/README.md

@@ -7,8 +7,8 @@ Turkish character support for core ruby methods. This gem provides support nearl
 
 ## Requirements
 
-* Ruby  >= 2.2.0
-* Rails >= 4.0.0
+* Ruby  >= 2.7.0
+* Rails >= 6.0.0
 
 __Notice:__ TurkishSupport uses __refinements__ instead of monkey patching.
 
@@ -20,7 +20,6 @@ __Notice:__ TurkishSupport uses __refinements__ instead of monkey patching.
 * [String Methods](#string-methods)
   * [#<=>](#-spaceship)
   * [#[] and #[]=](#-and-)
-  * [#=~](#-equal-tilda)
   * [capitalize](#capitalize-and-capitalize)
   * [casecmp](#casecmp)
   * [downcase](#downcase-and-downcase)
@@ -139,12 +138,6 @@ If you want to use original set of the core methods in the same scope, you can u
   'Çetin'[/[a-ğ]+/i]           # => "Çe"
 ```
 
-### =~ (equal-tilda)
-
-```ruby
-  'Bağlarbaşı Çarşı Kalabalık' =~ (/[s-ü]+/i) # => 8
-```
-
 ### capitalize and capitalize!
 
 ```ruby

data/lib/turkish_support/constants.rb

@@ -1,56 +1,38 @@
-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
 
+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
   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
-
-  # 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
+  ASCII_ALPHABET = ALPHABET.chars.map.with_index { |ch, i| [ch, i + 65] }.to_h
+  META_CHARS = { '\w' => '[\p{Latin}\d_]', '\W' => '[^\p{Latin}\d_]' }.freeze
 
-  RANGE_REGEXP = /\[[^\]]*?([#{ALPHABET}]-[#{ALPHABET}])[^\[]*?\]/
+  CASE_RELATED_METHS = %i[downcase
+                          downcase!
+                          upcase
+                          upcase!
+                          capitalize
+                          capitalize!].freeze
 
-  CONJUCTIONS = %w(ve ile veya).freeze
+  REGEX_REQUIRED_METHODS = %i[match scan].freeze
+  REGEX_OPTIONAL_METHODS = %i[[]
+                              []=
+                              index
+                              rindex
+                              partition
+                              rpartition
+                              slice
+                              slice!
+                              split
+                              sub
+                              sub!
+                              gsub
+                              gsub!].freeze
+  REGEX_METHS = REGEX_REQUIRED_METHODS + REGEX_OPTIONAL_METHODS
+  RANGE_REGEXP = /\[[^\]]*?([#{ALPHABET}]-[#{ALPHABET}])[^\[]*?\]/.freeze
 
-  SPECIAL_CHARS = %q{("'}.freeze
+  CONJUCTION = %w[ve ile veya].freeze
+  SPECIAL_CHARS = %q{("'}
 end

data/lib/turkish_support/helpers.rb

@@ -6,7 +6,7 @@ module TurkishSupportHelpers
 
     while re.match(RANGE_REGEXP)
       re.scan(RANGE_REGEXP).flatten.compact.each do |matching|
-        re.gsub! matching, translate_range(matching, pattern.casefold?)
+        re.gsub! matching, translate_range(matching, casefold: pattern.casefold?)
       end
     end
 
@@ -14,38 +14,28 @@ module TurkishSupportHelpers
     Regexp.new(re.force_encoding('UTF-8'), Regexp::FIXEDENCODING | options)
   end
 
-  def translate_range(range_as_string, casefold = false)
+  def translate_range(range_as_string, casefold: false)
     return '' unless range_as_string
 
-    range_as_string.gsub!(/\[\]/, '')
+    range_as_string = range_as_string.gsub(/\[\]/, '')
     first, last = range_as_string.split('-')
-
     expand_range(first, last, casefold)
   end
 
-  def prepare_for(meth, string)
-    valid_meths = %i[upcase downcase capitalize]
-    unless valid_meths.include?(meth) && string.is_a?(String)
-      raise ArgumentError, 'Invalid arguments for method `prepare_for`!'
-    end
-
-    method("prepare_for_#{meth}").call(string)
+  def tr_char?(char)
+    tr_lower?(char) || tr_upper?(char)
   end
 
-  def tr_char?(ch)
-    tr_lower?(ch) || tr_upper?(ch)
+  def tr_lower?(char)
+    ALPHA[:tr_lower].include? char
   end
 
-  def tr_lower?(ch)
-    ALPHA[:tr_lower].include? ch
-  end
-
-  def tr_upper?(ch)
-    ALPHA[:tr_upper].include? ch
+  def tr_upper?(char)
+    ALPHA[:tr_upper].include? char
   end
 
   def conjuction?(string)
-    CONJUCTIONS.include? string
+    CONJUCTION.include? string
   end
 
   def start_with_a_special_char?(string)
@@ -54,21 +44,6 @@ module TurkishSupportHelpers
 
   private
 
-  def prepare_for_upcase(string)
-    string.tr(ALPHA[:tr_lower], ALPHA[:tr_upper])
-  end
-
-  def prepare_for_downcase(string)
-    string.tr(ALPHA[:tr_upper], ALPHA[:tr_lower])
-  end
-
-  def prepare_for_capitalize(string)
-    [
-      prepare_for(:upcase, string.chr).upcase,
-      prepare_for(:downcase, self[1..-1]).downcase
-    ].join
-  end
-
   def expand_range(first, last, casefold)
     if lower.include?(first) && lower.include?(last)
       downcase_range(first, last, casefold)
@@ -91,6 +66,7 @@ module TurkishSupportHelpers
 
   def lower(first = nil, last = nil)
     return ALPHA[:lower] if first.nil? || last.nil?
+
     ALPHA[:lower][ALPHA[:lower].index(first)..ALPHA[:lower].index(last)]
   end
 
@@ -100,6 +76,7 @@ module TurkishSupportHelpers
 
   def upper(first = nil, last = nil)
     return ALPHA[:upper] if first.nil? || last.nil?
+
     ALPHA[:upper][ALPHA[:upper].index(first)..ALPHA[:upper].index(last)]
   end
 

data/lib/turkish_support/string_methods.rb

@@ -1,50 +1,46 @@
+# frozen_string_literal: true
+
 module TurkishSupport
   refine String do # rubocop:disable Metrics/BlockLength
-    (RE_RE_METHS + RE_OP_METHS).each do |meth|
+    REGEX_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
+        extend TurkishSupportHelpers
 
-        super(*args)
+        args[0] = translate_regexp(args[0]) if REGEX_REQUIRED_METHODS.include?(meth) || args[0].is_a?(Regexp)
+        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
+      define_method(meth) { super(:turkic) }
     end
 
-    def titleize(conjuctions = true) # rubocop:disable Metrics/AbcSize
-      split.map do |word|
-        word.downcase!
-        if conjuction?(word) && !conjuctions
+    def titleize(conjuction: true)
+      extend TurkishSupportHelpers
+
+      downcase.split.map do |word|
+        if !conjuction && conjuction?(word)
           word
         elsif start_with_a_special_char?(word)
-          word.size > 1 ? word[0] + word[1..-1].capitalize : word.chr
+          word.chr + (word.length > 1 ? word[1..].capitalize : '')
         else
           word.capitalize
         end
       end.join(' ')
     end
 
-    def titleize!(conjuctions = true)
-      replace(titleize(conjuctions))
+    def titleize!(conjuction: true)
+      replace(titleize(conjuction: conjuction))
     end
 
     def swapcase
-      extend(TurkishSupportHelpers)
-      chars.map do |ch|
-        if tr_char?(ch)
-          tr_lower?(ch) ? ch.upcase : ch.downcase
+      extend TurkishSupportHelpers
+
+      chars.map do |c|
+        if tr_char?(c)
+          tr_lower?(c) ? c.upcase : c.downcase
         else
-          ch.public_send(:swapcase)
+          c.instance_exec { super }
         end
       end.join
     end
@@ -53,26 +49,26 @@ module TurkishSupport
       replace(swapcase)
     end
 
-    def casecmp(other_string)
-      upcase.public_send(:casecmp, other_string.upcase)
+    def casecmp(other)
+      upcase.instance_exec { super(other.upcase) }
     end
 
-    def <=>(other_string)
-      return nil unless other_string.is_a? String
+    def <=>(other)
+      return nil unless other.is_a? String
 
       each_char.with_index do |ch, i|
         position1 = ASCII_ALPHABET[ch]
-        position2 = ASCII_ALPHABET[other_string[i]]
+        position2 = ASCII_ALPHABET[other[i]]
 
         return (position2.nil? ? 0 : -1) if position1.nil?
         return 1 if position2.nil?
         return (position1 < position2 ? -1 : 1) if position1 != position2
       end
 
-      return  0 if length == other_string.length
-      return -1 if length < other_string.length
-      return  1
-      
+      return 0 if length == other.length
+      return -1 if length < other.length
+
+      1
     end
   end
 end

data/lib/turkish_support/version.rb

@@ -1,3 +1,3 @@
 module TurkishSupport
-  VERSION = '1.1.3'.freeze
+  VERSION = '2.0.1'.freeze
 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