turkish_support 1.1.0 → 2.1.0

data/turkish_support.gemspec

@@ -1,4 +1,6 @@
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'turkish_support/version'
 
@@ -18,8 +20,13 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.required_ruby_version = '>= 2.0.0'
-  spec.add_development_dependency 'bundler', '~> 1.5'
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rspec'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.7.0')
+  spec.add_runtime_dependency 'turkish_ranges', '~> 0.1'
+  spec.add_runtime_dependency 'turkish_regexps', '~> 0.1'
+
+  spec.add_development_dependency 'bundler', '~> 2.1'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec', '~> 3.10'
+  spec.add_development_dependency 'turkish_ranges', '~> 0.1'
+  spec.add_development_dependency 'turkish_regexps', '~> 0.1'
 end

metadata

@@ -1,57 +1,113 @@
 --- !ruby/object:Gem::Specification
 name: turkish_support
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Sıtkı Bağdat
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-22 00:00:00.000000000 Z
+date: 2020-11-25 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: turkish_ranges
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: turkish_regexps
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '2.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: turkish_ranges
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: turkish_regexps
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.1'
 description: |-
   Turkish character support for core ruby methods
       like String#upcase, String#gsub, String#match, Array#sort, and etc...)
@@ -63,9 +119,12 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".hound.yml"
+- ".reek.yml"
 - ".rspec"
 - ".rubocop.yml"
 - ".travis.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -73,11 +132,11 @@ files:
 - lib/turkish_support.rb
 - lib/turkish_support/array_methods.rb
 - lib/turkish_support/constants.rb
-- lib/turkish_support/helpers.rb
 - lib/turkish_support/string_methods.rb
 - lib/turkish_support/version.rb
-- spec/helpers_spec.rb
+- spec/array_spec.rb
 - spec/spec_helper.rb
+- spec/string_spec.rb
 - spec/turkish_support_spec.rb
 - turkish_support.gemspec
 homepage: https://github.com/sbagdat/turkish_support
@@ -92,19 +151,19 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Turkish character support for core ruby methods.
 test_files:
-- spec/helpers_spec.rb
+- spec/array_spec.rb
 - spec/spec_helper.rb
+- spec/string_spec.rb
 - spec/turkish_support_spec.rb

data/lib/turkish_support/helpers.rb

@@ -1,113 +0,0 @@
-module TurkishSupportHelpers
-  def translate_regexp(pattern) # rubocop:disable Metrics/AbcSize
-    Regexp.new(pattern) unless pattern.is_a? Regexp
-    re = pattern.source
-    options = pattern.options
-
-    while re.match(RANGE_REGEXP)
-      re.scan(RANGE_REGEXP).flatten.compact.each do |matching|
-        re.gsub! matching, translate_range(matching, pattern.casefold?)
-      end
-    end
-
-    META_CHARS.each { |k, v| re.gsub!(k, v) }
-    Regexp.new(re.force_encoding('UTF-8'), Regexp::FIXEDENCODING | options)
-  end
-
-  def translate_range(range_as_string, casefold = false)
-    return '' unless 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)
-  end
-
-  def tr_char?(ch)
-    tr_lower?(ch) || tr_upper?(ch)
-  end
-
-  def tr_lower?(ch)
-    ALPHA[:tr_lower].include? ch
-  end
-
-  def tr_upper?(ch)
-    ALPHA[:tr_upper].include? ch
-  end
-
-  def conjuction?(string)
-    CONJUCTIONS.include? string
-  end
-
-  def start_with_a_special_char?(string)
-    string =~ /^[#{SPECIAL_CHARS}]/
-  end
-
-  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)
-    elsif upper.include?(first) && upper.include?(last)
-      upcase_range(first, last, casefold)
-    else
-      raise ArgumentError, 'Invalid regexp range arguments!'
-    end
-  end
-
-  def downcase_range(first, last, casefold)
-    lower(first, last) +
-      (lower_opposite(first, last) if casefold).to_s
-  end
-
-  def upcase_range(first, last, casefold)
-    upper(first, last) +
-      (upper_opposite(first, last) if casefold).to_s
-  end
-
-  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
-
-  def lower_opposite(first, last)
-    upper[lower.index(first)..lower.index(last)].delete("^#{ALPHA[:tr_upper]}")
-  end
-
-  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
-
-  def upper_opposite(first, last)
-    lower[upper.index(first)..upper.index(last)].delete("^#{ALPHA[:tr_lower]}")
-  end
-end
-
-module TurkishSupport
-  include TurkishSupportHelpers
-end

data/spec/helpers_spec.rb

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