turkish_support 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9448e0e7b47a86bd29759babace95bf4a5cabd57
-  data.tar.gz: 34fcb378e3fcd1a0a6e6b9dfacb82c73950f0e9b
+  metadata.gz: f32fd6d6257f27898afd35c8d22ce950311a02fa
+  data.tar.gz: a01d88e348deaf13f0a195c9ae96a3354dc803da
 SHA512:
-  metadata.gz: 040f7aa4a46f01837517ac03ceaa0321eb4157ff6a8f8f97f02e1c9dc32b6edf5979b8e6b3478aa25de27e8cf0f760b237aa269794bbcf614e1980df0e3f0dfa
-  data.tar.gz: af8204a64ca2bbf161520ddbeda179b144cd10d3233d53f565f66ba7c72e990d57ea86066d73b148d3468a33df9004e2bec154c884ed112dac911a76449e5b7d
+  metadata.gz: a1c2449108b61d8d3ba128bec8c1ebc87ca117325f39ad5b4745b746990567bc0f41d975deea1a3879b6b102f350664a0ffe8f89540b3e67c42cd44947101fb3
+  data.tar.gz: 4c37ee949de4244d45d0d10fa041691c5e3fee00a7f2936068acb2d34f976e28ba6fae4e291631ca0bedaeb63ec524295240987c27923c1611adca6feca78063

data/LICENSE.txt

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

data/lib/turkish_support/constants.rb

@@ -4,20 +4,17 @@ module TurkishSupportHelpers
     upper:    'ABCÇDEFGĞHIİJKLMNOÖPQRSŞTUÜVWXYZ',
     tr_lower: 'çğıiöşü',
     tr_upper: 'ÇĞIİÖŞÜ'
-  }
+  }.freeze
 
   ALPHABET = ALPHA[:upper] + ALPHA[:lower]
 
   META_CHARS = {
     '\w' => '[\p{Latin}\d_]',
     '\W' => '[^\p{Latin}\d_]'
-  }
+  }.freeze
 
   # Regexp required methods
-  RE_RE_METHS = %i(
-    match
-    scan
-  )
+  RE_RE_METHS = %i(match scan).freeze
 
   # Regexp optional methods
   RE_OP_METHS = %i(
@@ -35,7 +32,7 @@ module TurkishSupportHelpers
     sub!
     gsub
     gsub!
-  )
+  ).freeze
 
   CASE_RELATED_METHS = %i(
     downcase
@@ -44,11 +41,11 @@ module TurkishSupportHelpers
     upcase!
     capitalize
     capitalize!
-  )
+  ).freeze
 
   RANGE_REGEXP = /\[[^\]]*?([#{ALPHABET}]-[#{ALPHABET}])[^\[]*?\]/
 
-  CONJUCTIONS = %w(ve ile veya)
+  CONJUCTIONS = %w(ve ile veya).freeze
 
-  SPECIAL_CHARS = %q{("'}
+  SPECIAL_CHARS = %q{("'}.freeze
 end

data/lib/turkish_support/helpers.rb

@@ -1,7 +1,8 @@
 module TurkishSupportHelpers
   def translate_regexp(pattern) # rubocop:disable Metrics/AbcSize
     Regexp.new(pattern) unless pattern.is_a? Regexp
-    re, options = pattern.source, pattern.options
+    re = pattern.source
+    options = pattern.options
 
     while re.match(RANGE_REGEXP)
       re.scan(RANGE_REGEXP).flatten.compact.each do |matching|
@@ -25,7 +26,7 @@ module TurkishSupportHelpers
   def prepare_for(meth, string)
     valid_meths = %i(upcase downcase capitalize)
     unless valid_meths.include?(meth) && string.is_a?(String)
-      fail ArgumentError, 'Invalid arguments for method `prepare_for`!'
+      raise ArgumentError, 'Invalid arguments for method `prepare_for`!'
     end
 
     method("prepare_for_#{meth}").call(string)
@@ -74,7 +75,7 @@ module TurkishSupportHelpers
     elsif upper.include?(first) && upper.include?(last)
       upcase_range(first, last, casefold)
     else
-      fail ArgumentError, 'Invalid regexp range arguments!'
+      raise ArgumentError, 'Invalid regexp range arguments!'
     end
   end
 

data/lib/turkish_support/string_methods.rb

@@ -21,13 +21,13 @@ module TurkishSupport
       end
     end
 
-    def titleize(conjuctions = true)
+    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.chr + word[1..-1].capitalize : word.chr
+          word.size > 1 ? word[0] + word[1..-1].capitalize : word.chr
         else
           word.capitalize
         end

data/lib/turkish_support/version.rb

@@ -1,3 +1,3 @@
 module TurkishSupport
-  VERSION = '1.0.2'
+  VERSION = '1.0.3'.freeze
 end

data/spec/helpers_spec.rb

@@ -71,24 +71,24 @@ describe 'TurkishSupportHelpers' do
     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)
+                .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)
+                .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)
+                .chars
+                .any? { |ch| tr_lower?(ch) }
+              ).to eq(false)
       end
     end
   end
@@ -96,32 +96,32 @@ describe 'TurkishSupportHelpers' do
   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)
+              .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)
+                .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)
+                .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)
+                .chars
+                .any? { |ch| tr_upper?(ch) }
+              ).to eq(false)
       end
     end
   end
@@ -129,24 +129,24 @@ describe 'TurkishSupportHelpers' do
   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)
+              .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)
+                .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)
+                .chars
+                .any? { |ch| tr_char?(ch) }
+              ).to eq(false)
       end
     end
   end
@@ -154,14 +154,14 @@ describe 'TurkishSupportHelpers' do
   describe '#conjuction?' do
     it 'returns true for any conjuction' do
       expect(conjuctions
-        .all? { |c| conjuction?(c) }
-      ).to eq(true)
+              .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)
+              .any? { |c| conjuction?(c) }
+            ).to eq(false)
     end
   end
 
@@ -169,37 +169,35 @@ describe 'TurkishSupportHelpers' 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)
+              .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)
+              .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
-      expect(translate_range('A-Z'))
-        .to eq(upcased_alphabet)
+      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)
+              .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

data/spec/turkish_support_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 using TurkishSupport
 
-module TurkishSupport
+module TurkishSupport # rubocop:disable Metrics/ModuleLength
   describe VERSION do
     it 'should have a version number' do
       expect(TurkishSupport::VERSION).to_not eq(nil)
@@ -29,18 +29,17 @@ module TurkishSupport
 
         it 'is able to capture Turkish characters' do
           expect(turkish_words
-            .all? { |w| w[/\w+/] == w }
-          ).to eq(true)
+                  .all? { |w| w[/\w+/] == w }
+                ).to eq(true)
 
           expect(turkish_words
-            .all? { |w| w[/[a-z]+/] == w }
-          ).to eq(true)
+                  .all? { |w| w[/[a-z]+/] == w }
+                ).to eq(true)
 
-          expect(
-            turkish_words
-            .map(&:upcase)
-            .all? { |w| w[/[a-z]+/i] == w }
-          ).to eq(true)
+          expect(turkish_words
+                  .map(&:upcase)
+                  .all? { |w| w[/[a-z]+/i] == w }
+                ).to eq(true)
         end
       end
 
@@ -67,53 +66,50 @@ module TurkishSupport
 
       it 'is able to capture Turkish characters' do
         expect(turkish_words
-          .all? { |w| w.index(/\w+/).zero? }
-        ).to eq(true)
+                .all? { |w| w.index(/\w+/).zero? }
+              ).to eq(true)
 
         expect(turkish_words
-          .all? { |w| w.index(/[a-z]+/).zero? }
-        ).to eq(true)
+                .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)
+                .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)
+        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 }
+        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)
+                .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)
+                .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)
+                .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)
+        expect('şç-!+*/-ğüı'.rindex(/\w+/, 7)).to eq(1)
       end
     end
 
@@ -123,13 +119,11 @@ module TurkishSupport
       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 }
+        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])
+        expect(two_words.partition(/\W+/)).to eq([word1, ' ', word2])
       end
     end
 
@@ -140,8 +134,7 @@ module TurkishSupport
       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 }
+        expect { three_words.rpartition(/\W+/) }.to_not change { three_words }
       end
 
       it 'is able to capture Turkish characters' do
@@ -154,24 +147,22 @@ module TurkishSupport
       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 }
+          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)
+                  .all? { |w| w.slice(/\w+/) == w }
+                ).to eq(true)
 
           expect(turkish_words
-            .all? { |w| w.slice(/[a-z]+/) == w }
-          ).to eq(true)
+                  .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)
+                  .map(&:upcase)
+                  .all? { |w| w.slice(/[a-z]+/i) == w }
+                ).to eq(true)
         end
       end
 
@@ -179,10 +170,8 @@ module TurkishSupport
         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] * ' ')
+          expect { sentence.slice!(/\w+/) }.to change { sentence }
+          expect(sentence).to eq(' ' + turkish_words[1..-1] * ' ')
         end
       end
     end
@@ -190,29 +179,29 @@ module TurkishSupport
     describe '#split' do
       it 'is able to capture Turkish characters' do
         expect(turkish_words
-          .join(' ')
-          .split(/\w+/)
-          .join
-          .strip
-          .empty?
-        ).to eq(true)
+                .join(' ')
+                .split(/\w+/)
+                .join
+                .strip
+                .empty?
+              ).to eq(true)
 
         expect(turkish_words
-          .join(' ')
-          .split(/[a-z]+/)
-          .join
-          .strip
-          .empty?
-        ).to eq(true)
+                .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)
+                .join(' ')
+                .upcase
+                .split(/[a-z]+/i)
+                .join
+                .strip
+                .empty?
+              ).to eq(true)
       end
     end
 
@@ -226,15 +215,13 @@ module TurkishSupport
         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
           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
 
@@ -243,8 +230,7 @@ module TurkishSupport
           expect { downcased_turkish_alphabet.upcase! }
             .to change { downcased_turkish_alphabet }
 
-          expect(downcased_turkish_alphabet)
-            .to eq(upcased_turkish_alphabet)
+          expect(downcased_turkish_alphabet).to eq(upcased_turkish_alphabet)
         end
       end
     end
@@ -285,8 +271,7 @@ module TurkishSupport
         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 leading first Turkish character' do
@@ -445,43 +430,37 @@ module TurkishSupport
       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
       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(' ')])
+                .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])
+                .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)
+                .join(' ')
+                .scan(/\W+/)
+                .map(&:strip)
+                .all?(&:empty?)
+              ).to eq(true)
       end
     end
 
@@ -490,30 +469,30 @@ module TurkishSupport
 
       it "matches Turkish characters when regex include '\\w'" do
         expect(tr_chars
-          .split(//)
-          .all? { |ch| (ch =~ /\w/).zero? }
-        ).to eq(true)
+                .split(//)
+                .all? { |ch| (ch =~ /\w/).zero? }
+              ).to eq(true)
       end
 
       it 'matches Turkish characters when regex include lowercase range' do
         expect(ALPHA[:tr_lower]
-          .split(//)
-          .all? { |ch| (ch =~ /[a-z]/).zero? }
-        ).to eq(true)
+                .split(//)
+                .all? { |ch| (ch =~ /[a-z]/).zero? }
+              ).to eq(true)
       end
 
       it 'matches Turkish characters when regex include uppercase range' do
         expect(ALPHA[:tr_upper]
-          .split(//)
-          .all? { |ch| (ch =~ /[A-Z]/).zero? }
-        ).to eq(true)
+                .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)
+                .split(//)
+                .all? { |ch| (ch =~ /\W/).nil? }
+              ).to eq(true)
       end
     end
 
@@ -522,19 +501,16 @@ module TurkishSupport
         it 'does not affect the object' do
           word = 'ağapaşa ağa'
 
-          expect { word.sub(/\w+/, 'bey') }
-            .to_not change { word }
+          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'.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')
+          expect('ağapaşaağa'.sub(/[a-h]+/, 'bey')).to eq('beypaşaağa')
         end
       end
 
@@ -555,19 +531,16 @@ module TurkishSupport
         it 'does not affect the object' do
           word = 'ağapaşa ağa'
 
-          expect { word.gsub(/\w+/, 'bey') }
-            .to_not change { word }
+          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'.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')
+          expect('ağapaşaağa'.gsub(/[a-h]+/, 'bey')).to eq('beypbeyşbey')
         end
       end
 
@@ -598,27 +571,22 @@ module TurkishSupport
     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 }
+          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)
+          expect(unsorted_array1.sort).to eq(sorted_array1)
         end
 
         it 'sorts array in alphabetical order' do
-          expect(unsorted_array2.sort)
-            .to eq(sorted_array2)
+          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)
+          expect { unsorted_array1.sort! }.to change { unsorted_array1 }
+          expect(unsorted_array1).to eq(sorted_array1)
         end
       end
     end

data/turkish_support.gemspec

@@ -1,4 +1,3 @@
-# coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'turkish_support/version'
@@ -15,8 +14,8 @@ Gem::Specification.new do |spec|
   spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(/^(test|spec|features)\//)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
   spec.required_ruby_version = '>= 2.0.0'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: turkish_support
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Sıtkı Bağdat
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-13 00:00:00.000000000 Z
+date: 2016-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -100,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Turkish character support for core ruby methods.