turkish_support 0.3.0 → 1.0.0.pre.alpha

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f3b1088be5dda40f1dc4e4eb6fbb7d38db262f00
-  data.tar.gz: 9c43ab7aae842e4afb6dc9e816a62d856b0741e6
+  metadata.gz: fca374a0e22cae4752a98bc96a26b64d99e57612
+  data.tar.gz: 5ff3bac0eb61748ec55b9de97f6fed195f15222a
 SHA512:
-  metadata.gz: 2163bef027f543a1e6b19ffd321f6be0f1b6a758191503672e454ab149451a6270fb1a7fc74974b76090ac7f055699aa7681a14b52f7498193bce811168b1589
-  data.tar.gz: 28bbd4b4e070ccc06359d3e6aa6eacfef69cd4c7b808ecf8221f0f33667f3bda4e3cbd4f2e97a35457988cb85274192417c8eba87791d25e04023a4cade80345
+  metadata.gz: 1682d709edeeb141dc55ff93b9243298ae32892d8fe8e5beeabcc4a9b6d9c4800686a9f2a7d8899e52409e557843fd7dc9c37b89d4a072704314c388372809e7
+  data.tar.gz: a90302ff8136ee2ad490f6746cf1043c1fe61a58e750944fe8c5a21c333a4c8b0cab194f8fc6c637b10cfa3710ce9ea338aac4500ce2491bfdcb6d47ff40d16f

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+todo.txt

data/.hound.yml

@@ -0,0 +1,3 @@
+ruby:
+  enabled: true
+  config_file: .rubocop.yml

data/.rubocop.yml

@@ -0,0 +1,7 @@
+StringLiterals:
+  EnforcedStyle: single_quotes
+Documentation:
+  Enabled: false
+DotPosition:
+  EnforcedStyle: leading
+  Enabled: true

data/README.md

@@ -4,16 +4,41 @@
 [![Build Status](https://travis-ci.org/sbagdat/turkish_support.svg?branch=master)](https://travis-ci.org/sbagdat/turkish_support)
 [![Gitter chat](https://badges.gitter.im/sbagdat/turkish_support.png)](https://gitter.im/sbagdat/turkish_support)
 
-Turkish character support for some core ruby methods. This gem provide support for those methods: `String#upcase`,
-`String#downcase`, `String#capitalize`, `String#swapcase`, `String#casecmp`, `String#match`, `Array#sort`, and their destructive versions like `Array#sort!` or `String#capitalize!`. It also gives you some bonus methods like `String#titleize`.
+Turkish character support for core ruby methods. This gem provides support nearly all `String` methods, such as `String#upcase`, `String#downcase`, `String#match`, `String#gsub`. It also provides support for `Array#sort`and some bonus methods like `String#titleize`.
 
 ## Requirements
 
 * Ruby  >= 2.0.0
 * Rails >= 4.0.0
 
-__Notice:__ TurkishSupport uses refinements instead of monkey patching. Refinements come with Ruby 2.0.0 as a new feature
-and also, it is an experimental feature for now. If you want to more information about refinements, you can see the doc at [http://www.ruby-doc.org/core-2.0.0/doc/syntax/refinements_rdoc.html](http://www.ruby-doc.org/core-2.0.0/doc/syntax/refinements_rdoc.html)
+__Notice:__ TurkishSupport uses refinements instead of monkey patching. ~~Refinements come with Ruby 2.0.0 as a new feature and also, it is an experimental feature for now. If you want to more information about refinements, you can see the doc at [http://www.ruby-doc.org/core-2.0.0/doc/syntax/refinements_rdoc.html](http://www.ruby-doc.org/core-2.0.0/doc/syntax/refinements_rdoc.html)~~ *Refinements are not an experimental feature, it is a core feature now.*
+
+* [Installation](#installation)
+* [Usage](#usage)
+  * [Using with ruby](#using-with-ruby)
+  * [Using with ruby on rails](#using-with-ruby-on-rails)
+  * [Using Core Methods](#using-core-methods)
+* [String Methods](#string-methods)
+  * [#[] and #[]=](-and-)
+  * [#=~](#-equal-tilda)
+  * [capitalize](#capitalize-and-capitalize)
+  * [casecmp](#casecmp)
+  * [downcase](#downcase-and-downcase)
+  * [gsub](#gsub-and-gsub)
+  * [index](#index)
+  * [match](#match)
+  * [partition](#partition)
+  * [rpartition](#rpartition)
+  * [rindex](#rpartition)
+  * [scan](#scan)
+  * [slice](#slice-and-slice)
+  * [split](#split)
+  * [sub](#sub-and-sub)
+  * [swapcase](#swapcase-and-swapcase)
+  * [titleize](#titleize-and-titleize)
+  * [upcase](#upcase-and-upcase)
+* [Array Methods](#array-methods)
+  * [sort](sort-and-sort)
 
 ## Installation
 
@@ -29,7 +54,7 @@ Or install it yourself as:
 
     $ gem install turkish_support
 
-## Usage Instructions
+## Usage
 
 After the installation of the gem, you should follow these steps.
 
@@ -59,99 +84,206 @@ class Test
   end
 end
 
-Test.new.up_me('içel')  #=> "İÇEL"
+Test.new.up_me('içel')  # => "İÇEL"
 ```
 
 ### Using with rails
 
 __Note:__ You don't need to require, because it is already required by the rails.
 
-* In rails you must add `using TurkishSupport` line to the top of the scope, __not inside of any class or module__.
+* You must add `using TurkishSupport` line to the top of the scope.
 
 ```ruby
   using TurkishSupport
 
-  class SampleModel
+  class SampleModel < ActiveRecord::Base
     ...
   end
 ```
 
-## Examples
+* If you want to use TurkishSupport with a custom class or a module that is not inherited from any rails tie, you must add `using TurkishSupport` line to the class or module.
 
-Within the file that you added `using TurkishSupport` line; you can use the core methods like below:
+```ruby
+  class CustomClass
+    using TurkishSupport
+
+    ...
+  end
+```
 
-__String#upcase__ and __String#upcase!__
+### Using Core Methods
+
+If you want to use original set of the core methods in the same scope, you can use `Object#public_send`:
 
 ```ruby
   str = 'Bağcılar'
+  str.public_send(:upcase)  # => "BAğCıLAR"
+```
 
-  str.upcase    #=> "BAĞCILAR"
-  str           #=> "Bağcılar"
+## String Methods
 
-  str.upcase!   #=> "BAĞCILAR"
-  str           #=> "BAĞCILAR"
+### [] and []=
+
+```ruby
+  'Türkiye Cumhuriyeti'[/\w+/] # => "Türkiye"
+  'Çetin'[/[a-ğ]+/i]           # => "Çe"
 ```
 
-__String#downcase__ and __String#downcase!__
+### =~ (equal-tilda)
 
 ```ruby
-  str = 'İSMAİL'
-  str.downcase    #=> "ismail"
+  'Bağlarbaşı Çarşı Kalabalık' =~ (/[s-ü]+/i) # => 8
 ```
 
-__String#capitalize__ and __String#capitalize!__
+### capitalize and capitalize!
 
 ```ruby
   str = 'türkÇE desteĞİ'
-  str.capitalize    #=> "Türkçe desteği"
+
+  str.capitalize    # => "Türkçe desteği"
+  str.capitalize!   # => "Türkçe desteği"
 ```
 
-__String#swapcase__ and __String#swapcase!__
+### casecmp
+
 ```ruby
-  'TuğÇE'.swapcase    #=> "tUĞçe"
+  'sıtKI'.casecmp('SITkı')     # => 0
 ```
 
-__String#casecmp__
+### downcase and downcase!
+
 ```ruby
-  'sıtKI'.casecmp('SITkı')     #=> 0
+  str = 'İSMAİL'
+
+  str.downcase    # => "ismail"
+  str.downcase!   # => "ismail"
 ```
 
-__String#match__
+### gsub and gsub!
 
 ```ruby
-  'Aşağı'.match(/\w+/)                         #=> #<MatchData "Aşağı">
-  'Aşağı Ayrancı'.match(/^\w+\s\w+$/)          #=> #<MatchData "Aşağı Ayrancı">
-  'aüvvağğ öövvaağ'.match(/^[a-z]+\s[a-z]+$/)  #=> #<MatchData "aüvvağğ öövvaağ">
-  'BAĞCIlar'.match(/[A-Z]+/)                   #=> #<MatchData "BAĞCI">
-  'Aşağı Ayrancı'.match(/\W+/)                 #=> #<MatchData "">
+ 'ağapaşaağa'.gsub(/[a-h]+/, 'bey')
 ```
 
-__Array#sort__ and __Array#sort!__
+### index
 
 ```ruby
-  %w(iki üç dört ılık iğne iyne).sort
-  #=> ["dört", "ılık", "iğne", "iki", "iyne", "üç"]
+  '?ç-!+*/-ğüı'.index(/\w+/)        # => 1
+  '?ç-!+*/-ğüı'.index(/[a-z]+/, 2)  # => 8
+```
+
+### match
+
+```ruby
+  'Aşağı'.match(/\w+/)
+  # => #<MatchData "Aşağı">
+
+  'Aşağı Ayrancı'.match(/^\w+\s\w+$/)
+  # => #<MatchData "Aşağı Ayrancı">
+
+  'aüvvağğ öövvaağ'.match(/^[a-z]+\s[a-z]+$/)
+  # => #<MatchData "aüvvağğ öövvaağ">
+
+  'BAĞCIlar'.match(/[A-Z]+/)
+  # => #<MatchData "BAĞCI">
+
+  'Aşağı Ayrancı'.match(/\W+/)
+  # => #<MatchData "">
+```
+
+### partition
+
+```ruby
+  'Bağlarbaşı Çarşı'.partition(/\W+/) # => ["Bağlarbaşı", " ", "Çarşı"]
+```
+
+### rpartition
+
+```ruby
+  'Bağlarbaşı Çarşı Kalabalık'.rpartition(/\W+/)
+  # => ["Bağlarbaşı Çarşı", " ", "Kalabalık"]
+```
+
+### rindex
+
+```ruby
+  'şç-!+*/-ğüı'.rindex(/\w+/, 7)  # => 1
 ```
 
-__String#titleize__ and __String#titleize!__
+### scan
 
-These methods are not core methods of ruby, but they are accepted as useful in most situations.
+```ruby
+  'Bağlarbaşı Çarşı Kalabalık'.scan(/[a-z]+/i)
+  # => ["Bağlarbaşı", "Çarşı", "Kalabalık"]
+```
+
+
+### slice and slice!
 
 ```ruby
-  'türkÇE desteĞİ'.titleize           #=> "Türkçe Desteği"
+  'Duayen'.slice(/[^h-ö]+/) # => "Duaye"
+```
+
+### split
+
+```ruby
+  'Bağlarbaşı Çarşı Kalabalık'.split(/\W+/)
+  # => ["Bağlarbaşı", "Çarşı", "Kalabalık"]
+
+  'Bağlarbaşı Çarşı Kalabalık'.split(/[ç-ş]+/)
+  # => ["Ba", "a", "ba", " Ça", " Ka", "aba"]
+```
+
+### sub and sub!
+
+```ruby
+  'ağapaşaağa'.sub(/[a-h]+/, 'bey')  # => "beypaşaağa"
+```
+
+### swapcase and swapcase!
+
+```ruby
+  'TuğÇE'.swapcase    # => "tUĞçe"
+  'TuğÇE'.swapcase!   # => "tUĞçe"
+```
+
+### titleize and titleize!
+
+*These methods are not core methods of ruby, but they are accepted as useful in most situations.*
+
+```ruby
+  'türkÇE desteĞİ'.titleize           # => "Türkçe Desteği"
+  'türkÇE desteĞİ'.titleize!          # => "Türkçe Desteği"
 
   # Parenthesis, quotes, etc. support
-  "rUBY roCkS... (really! 'tRUSt' ME)".titleize          #=> "Ruby Rocks... (Really! 'Trust' Me)"
+  "rUBY roCkS... (really! 'tRUSt' ME)".titleize
+  # => "Ruby Rocks... (Really! 'Trust' Me)"
 
-  # If you don't want to capitalize conjuctions, simply pass a false value as a parameter
-  "kerem VE aslı VeYa leyla İlE mecnun".titleize(false)  #=> "Kerem ve Aslı veya Leyla ile Mecnun"
+  # If you don't want to capitalize conjuctions,
+  # simply pass a false value as parameter
+  "kerem VE aslı VeYa leyla İlE mecnun".titleize(false)
+  # => "Kerem ve Aslı veya Leyla ile Mecnun"
 ```
 
-__Important Note:__ If you also want to use original set of the core methods in the same scope, you can use `send` method like this:
+### upcase and upcase!
 
 ```ruby
   str = 'Bağcılar'
-  str.send(:upcase)  #=> "BAğCıLAR"
+
+  str.upcase    # => "BAĞCILAR"
+  str           # => "Bağcılar"
+
+  str.upcase!   # => "BAĞCILAR"
+  str           # => "BAĞCILAR"
+```
+
+## Array Methods
+
+### sort and sort!
+
+```ruby
+  %w(iki üç dört ılık iğne iyne).sort
+  # => ["dört", "ılık", "iğne", "iki", "iyne", "üç"]
 ```
 
 ## Contributing

data/Rakefile

@@ -1,6 +1,6 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task default: :spec

data/lib/turkish_support.rb

@@ -1,9 +1,9 @@
-require "turkish_support/version"
-require "turkish_support/constants"
-require "turkish_support/string_helpers"
-require "turkish_support/string_methods"
-require "turkish_support/array_methods"
-require "turkish_support/destructives"
+require 'turkish_support/version'
+require 'turkish_support/constants'
+require 'turkish_support/helpers'
+
+require 'turkish_support/string_methods'
+require 'turkish_support/array_methods'
 
 module TurkishSupport
 end

data/lib/turkish_support/array_methods.rb

@@ -3,11 +3,15 @@ module TurkishSupport
     def sort
       sort_by do |item|
         if item.is_a?(String)
-          item.chars.map { |ch| ORDERED_CHARS.index(ch) }
+          item.chars.map { |ch| ALPHABET.index(ch) }
         else
           super
         end
       end
     end
+
+    def sort!
+      replace(sort)
+    end
   end
 end

data/lib/turkish_support/constants.rb

@@ -1,21 +1,54 @@
-module TurkishSupport
-  DOWNCASED_ALPHABET = 'abcçdefgğhıijklmnoöpqrsştuüvwxyz'
-  UPCASED_ALPHABET   = 'ABCÇDEFGĞHIİJKLMNOÖPQRSŞTUÜVWXYZ'
-
-  UNSUPPORTED_DOWNCASE_CHARS  = 'çğıiöşü'
-  UNSUPPORTED_UPCASE_CHARS    = 'ÇĞIİÖŞÜ'
-  ORDERED_CHARS               = UPCASED_ALPHABET + DOWNCASED_ALPHABET
+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İÖŞÜ'
+  }
 
-  DESTRUCTIVE_STRING_METHODS  = %i(swapcase titleize)
-  DESTRUCTIVE_ARRAY_METHODS   = %i(sort)
+  ALPHABET = ALPHA[:upper] + ALPHA[:lower]
 
-  MATCH_TRANSFORMATIONS = {
+  META_CHARS = {
     '\w' => '[\p{Latin}\d_]',
-    '\W' => '[^\p{Latin}\d_]',
-    'a-z' => DOWNCASED_ALPHABET,
-    'A-Z' => UPCASED_ALPHABET
+    '\W' => '[^\p{Latin}\d_]'
   }
 
+  # Regexp required methods
+  RE_RE_METHS = %i(
+    match
+    scan
+  )
+
+  # Regexp optional methods
+  RE_OP_METHS = %i(
+    []
+    []=
+    =~
+    index
+    rindex
+    partition
+    rpartition
+    slice
+    slice!
+    split
+    sub
+    sub!
+    gsub
+    gsub!
+  )
+
+  CASE_RELATED_METHS = %i(
+    downcase
+    downcase!
+    upcase
+    upcase!
+    capitalize
+    capitalize!
+  )
+
+  RANGE_REGEXP = /\[[^\]]*?([#{ALPHABET}]-[#{ALPHABET}])[^\[]*?\]/
+
   CONJUCTIONS = %w(ve ile veya)
-  SPECIAL_CHARS = %(\("')
+
+  SPECIAL_CHARS = %q{("'}
 end

data/lib/turkish_support/helpers.rb

@@ -0,0 +1,112 @@
+module TurkishSupportHelpers
+  def translate_regexp(pattern) # rubocop:disable Metrics/AbcSize
+    Regexp.new(pattern) unless pattern.is_a? Regexp
+    re, options = pattern.source, 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)
+      fail 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
+      fail 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