Class: StTools::String

Inherits:
Object
  • Object
show all
Defined in:
lib/st_tools/string.rb

Class Method Summary collapse

Class Method Details

.caps(text) ⇒ String

Метод делает заглавной первую букву в словах, разделенных пробелами или дефисом.

Examples:

Примеры использования

StTools::String.caps("саНКТ-петеРБург")    #=> "Санкт-Петербург"

Parameters:

  • text (String) —

    исходная строка

Returns:

  • (String) —

    строка с первыми заглавными буквами



185
186
187
188
189
190
191
192
193
194
 
# File 'lib/st_tools/string.rb', line 185

def self.caps(text)
  return nil if text.nil?
  str = self.downcase(text)
  str.gsub!(/(^[а-яa-z]|[а-яa-z\s]-[а-яa-z]|[\.\s\_][а-яa-z])/) do |part|
    part.gsub(/.\b\z/) { |x| self.upcase(x) }
  end
  return str
rescue
  return text
end

.delat(text) ⇒ String

Метод заменяет в исходной строке английские символы, похожие на русские - на соответстующие русские символы. То есть это похоже на ситуацию, когда Google меняет слово, случайно написанное английскими буквами - на русское слово. Одновременно буква ‘ё’ меняется на ‘е’.

Parameters:

  • text (String) —

    текст со смесью английских и русских букв

Returns:

  • (String) —

    текст только с русскими буквами



64
65
66
67
 
# File 'lib/st_tools/string.rb', line 64

def self.delat(text)
  return nil if text.nil?
  text.tr('ёЁEeHCcTOoPpAHKXxBM', 'еЕЕеНСсТОоРрАНКХхВМ')
end

.downcase(text) ⇒ String

Метод преобразует строку в нижний регистр с одновременной заменой буквы ‘ё’ на ‘е’. Метод имеет примерно в два раза более высокую производительности по сравнению с традиционным .mb_chars.downcase.to_s, но имеет ограничение - работа только с русскими и английскими строками

Examples:

Примеры использования

StTools::String.downcase("Hello, Вася!")   #=> "hello, вася!"

Parameters:

  • text (String) —

    строка в произвольном регистре

Returns:

  • (String) —

    строка в нижнем регистре



31
32
33
34
35
36
37
 
# File 'lib/st_tools/string.rb', line 31

def self.downcase(text)
  if text
    return text.tr('QWERTYUIOPASDFGHJKLZXCVBNMАБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ',
                   'qwertyuiopasdfghjklzxcvbnmабвгдеежзийклмнопрстуфхцчшщъыьэюя')
  end
  ""
end

.hide(text) ⇒ String

Метод позволяет показывать клиенту строку в неполном объеме, с закрытием части символов в строке звездочкой. При этом число звездочек в строке определеяется ее длиной. Чем строка дилинее - тем больше в ней звездочек.

Examples:

Примеры использования

StTools::String.hide("мы")                          #=> "мы"
StTools::String.hide("москва")                      #=> "мо*ква"
StTools::String.hide("длиннаяфраза")                #=> "дли**аяфраза"
StTools::String.hide("просто произвольная фраза")   #=> "**осто пр*извол*н*я фраза"

Parameters:

  • text (String) —

    строка, которую необходимо закрыть звездочками

Returns:

  • (String) —

    строка, часть символов которой заменена звездочками



101
102
103
104
105
106
107
108
109
 
# File 'lib/st_tools/string.rb', line 101

def self.hide(text)
  return nil if text.nil?
  len = text.length - 3
  0.upto((len / 4).to_i) do
    pos          = rand(len)
    text[pos, 1] = '*'
  end
  return text
end

.normalize(text, delat: false) ⇒ String

Метод проводит нормализацию строки для последующей машиной обработки. При этом осуществляется:

  • убирается букву ‘ё’

  • перевод строку в нижний регистр

  • замена случайно введенных английских букв на русские

  • убираются лидирующие и завершающие пробелы

  • в строке удаляются повторные пробелы между словами

Examples:

Примеры использования

StTools::String.normalize("  Ёлки-     ПАЛКИ")   #=> "елки- палки"
StTools::String.normalize("Ee", delat: true)     #=> "ее" (русские буквы)
StTools::String.normalize("Ee")                  #=> "ee" (латинские буквы)

Parameters:

  • text (String) —

    строка, введенная пользователям

  • delat (Boolean) (defaults to: false) —

    флаг необходимости проводить де-латинизацию. По умолчанию - false

Returns:

  • (String) —

    строка без ‘ё’, в нижнем регистре, без английских букв



84
85
86
87
88
 
# File 'lib/st_tools/string.rb', line 84

def self.normalize(text, delat: false)
  return nil if text.nil? || text.empty?
  out = delat ? self.delat(text) : text.gsub('ё', 'е').gsub('Ё', 'Е')
  self.downcase(out).strip.gsub(/[\s\t\u00A0]{1,100}/, ' ')
end

.pretty_list(items, separator: ',', union: :and, pretag: '', afttag: '') ⇒ String

Метод преобразует список Array в строку перечисление вида “это, это и это”. Метод позволяет делать перечсиелние на разных языках, использовать частицы ‘и’ и ‘или’, а также оформлять список тегами HTML.

Examples:

Примеры использования

StTools.configure { |config| config.locale = :ru }
StTools::String.pretty_list([1,2])                      #=> "1 и 2"
StTools::String.pretty_list([1,2,4])                    #=> "1, 2 и 4"
StTools::String.pretty_list([1,2,3,4], union: :or)      #=> "1, 2, 3 или 4"

Parameters:

  • items (Array) —

    массив значений для оформления в виде списка

  • separator (String) (defaults to: ',') —

    знак разделитель, по умолчанию запятая (‘,’)

  • union (Sym) (defaults to: :and) —

    признак частицы, если указать :and, то будет использована частица ‘и’, либо ‘или’ в других случаях

  • pretag (String) (defaults to: '') —

    открывающий тег HTML для обрамления элементов списка

  • afttag (String) (defaults to: '') —

    закрывающий тег HTML для обрамления элементов списка

Returns:

  • (String) —

    конвертированная строка



242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
 
# File 'lib/st_tools/string.rb', line 242

def self.pretty_list(items, separator: ',', union: :and, pretag: '', afttag: '')
  return '' if items.nil? || items.empty?
  return "#{pretag}#{items.first}#{afttag}" if items.count == 1
  out  = Array.new
  last = items.last
  arr  = items[0, items.count - 1]
  arr.each do |one|
    out << "#{pretag}#{one}#{afttag}"
    out << separator + ' '
  end
  out.pop
  case union
    when :and
      out << " #{I18n.t('st_tools.pretty_list.and', locale: StTools.configuration.locale)} "
    else
      out << " #{I18n.t('st_tools.pretty_list.or', locale: StTools.configuration.locale)} "
  end
  out << "#{pretag}#{last}#{afttag}"
  out.join
end

.prune(text, length, words: false, endwith: '...') ⇒ String

Метод обрезает строку и добавляет в случае обрезания строки многоточие

Examples:

Примеры использования

StTools::String.prune("1234567890", 20)                   #=> "1234567890"
StTools::String.prune("1234567890", 8)                    #=> "12345..."
StTools::String.prune("1234567890", 8, endwidth: '---')   #=> "12345---"
StTools::String.prune("Привет мир!", 12)                  #=> "Привет ми..."
StTools::String.prune("Привет мир!", 12, words: true)     #=> "Привет..."

Parameters:

  • text (Object) —

    строка для обрезания

  • length (Object) —

    необходимая длина строки С УЧЕТОМ окончания (многоточия)

  • words (Object) (defaults to: false) —

    если true, то не будет слов “разрезанных” на части. По умолчанию false

  • endwith (Object) (defaults to: '...') —

    завершающее многоточие (по умолчанию ‘…’)

Returns:

  • (String) —

    сокращенная строка строка



277
278
279
280
281
282
283
284
285
 
# File 'lib/st_tools/string.rb', line 277

def self.prune(text, length, words: false, endwith: '...')
  return '' if text.nil? || text == ''
  return text if text.length <= length
  return text[0, length] if length <= endwith.length

  out = text.strip[0, length - endwith.length]
  out.gsub!(/\s[^\s]+?\z/, '') if words
  out.strip + endwith
end

.split(text, separator, opts = {}) ⇒ Array

Метод аналогичен обычной функции split, однако дополнительно может выполнять следующие действия:

  • strip каждого элемента

  • normalize соответсвующей функцией (#normalize)

  • сортировка в прямом порядке

  • удаление дубликотов

Examples:

Примеры использования

StTools::String.split("саша, Паша,   ТАНЯ, Алина", ',')                                                 #=> ["саша", "Паша", "ТАНЯ", "Алина"]
StTools::String.split("саша, Паша,   ТАНЯ, Алина", ',', normalize: true)                                #=> ["саша", "паша", "таня", "алина"]
StTools::String.split("саша, Паша,   ТАНЯ, Алина", ',', normalize: true, sort: true)                    #=> ["алина", "паша", "саша", "таня"]
StTools::String.split("саша, Паша,   ТАНЯ, Алина,  таня", ',', normalize: true, sort: true, uniq: true) #=> ["алина", "паша", "саша", "таня"]

Parameters:

  • text (String) —

    исходная строка

  • separator (String) —

    сепаратор (по умолчанию нет - необходимо явное указание)

  • opts (Hash) (defaults to: {}) —

    опции преобразования

Options Hash (opts):

  • :normalize (Boolean) —

    • применить к каждому элементу массива функцию #normalize

  • :sort (Boolean) —

    • сортировать выходной массив

  • :uniq (Boolean) —

    • удалить из массива дубликаты

Returns:

  • (Array) —

    массив элементов из строки



130
131
132
133
134
135
136
137
138
139
140
141
 
# File 'lib/st_tools/string.rb', line 130

def self.split(text, separator, opts = {})
  return [] if text.nil?
  out = text.split(separator)
  out.map! { |x| x.strip }
  out.map! { |x| self.normalize(x) } if opts[:normalize]
  out.uniq! if opts[:uniq]
  out.sort! if opts[:sort]

  return out
rescue
  return []
end

.to_bool(text, default = false) ⇒ Boolean

Метод конвертирует строку в тип boolean

Examples:

Примеры использования

StTools::String.to_bool("True")      #=> true
StTools::String.to_bool("trUE")      #=> true
StTools::String.to_bool("on")        #=> true
StTools::String.to_bool("1")         #=> true
StTools::String.to_bool("Да")        #=> true
StTools::String.to_bool("Yes")       #=> true
StTools::String.to_bool("false")     #=> false
StTools::String.to_bool("fALse")     #=> false
StTools::String.to_bool("oFF")       #=> false
StTools::String.to_bool("0")         #=> false
StTools::String.to_bool(nil, true)   #=> true
StTools::String.to_bool(nil, false)  #=> false

params = { opt1: true }
StTools::String.to_bool(params[:opt1], false)  #=> true
StTools::String.to_bool(params[:opt2], true)   #=> true

Parameters:

  • text (String) —

    исходная строка, содержащая ‘true/false’, ‘on/off’, ‘1/0’

  • default (Boolean) (defaults to: false) —

    значение по умолчанию для строк, имеющих значение nil

Returns:

  • (Boolean) —

    true или false



219
220
221
222
223
 
# File 'lib/st_tools/string.rb', line 219

def self.to_bool(text, default = false)
  return default if text.nil?
  return true if ['true', 'on', '1', 'да', 'yes'].include?(self.downcase(text.to_s))
  false
end

.to_float(text, round: 6, stop: true) ⇒ Float

Метод преобразует строковое выражение в число с плавающей запятой. При этом метод корректно преобразует числа вида “12.34” и “12,34”, то есть с точкой и запятой (но будет некорректный результат в случае американских чисел, где запятая - разделитель тысяч, а не дробная часть).

Examples:

Примеры использования

StTools::String.to_float('123.45678')                                 #=> 123.45678
StTools::String.to_float('123.474565', round: 2)                      #=> 123.47
StTools::String.to_float('123,474565', round: 2)                      #=> 123.47
StTools::String.to_float('   123,47456564', round: 2)                 #=> 123.47
StTools::String.to_float('   10 123,47456', round: 2)                 #=> 10123.47
StTools::String.to_float(' -  10 123,474565', round: 2)               #=> -10123.47
StTools::String.to_float(nil, round: 2) rescue 'fail')                #=> "fail"
StTools::String.to_float(nil, round: 2, stop: false) rescue 'fail')   #=> 0
StTools::String.to_float(145.5667, round: 2)                          #=> 145.57
StTools::String.to_float(23, round: 2)                                #=> 23

Parameters:

  • text (String, Float, Integer) —

    строка или число, которое нужно преобразовать в Float

  • round (Integer) (defaults to: 6) —

    число цифр после запятой при округлении. По умолчанию - 6

  • stop (Object) (defaults to: true) —

    если true, то при ошибке будет выброшен “Exception”, иначе при ошибках будет возвращаться “0”. По умолчанию - true.

Returns:

  • (Float) —

    число с плавающей запятой



307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
 
# File 'lib/st_tools/string.rb', line 307

def self.to_float(text, round: 6, stop: true)
  # http://stackoverflow.com/questions/1034418/determine-if-a-string-is-a-valid-float-value
  if text.nil?
    stop ? (raise TypeError, "can't convert nil into Float") : (return 0)
  end

  if text.is_a?(::Float) || text.is_a?(::Integer)
    return text.to_f.round(round)
  end

  if text.is_a?(::String)
    str = text.strip.gsub(/\,/, '.').gsub(/\s/, '')
    if str.match(/\A\s*[+-]?((\d+_?)*\d+(\.(\d+_?)*\d+)?|\.(\d+_?)*\d+)(\s*|([eE][+-]?(\d+_?)*\d+)\s*)\z/)
      begin
        return str.to_f.round(round)
      rescue Exception => e
        stop ? (raise ArgumentError, "invalid value for Float(): #{str.inspect}") : (return 0)
      end
    end
  end

  stop ? (raise ArgumentError, "invalid value for Float(): #{text.inspect}") : (return 0)
end

.to_range(text, opts = {}) ⇒ Array

Метод возвращает полный массив Array [1, 4, 5, 6, 7, 456] для строк вида ‘1, 4, 5-7, 456’. Дополнительно осуществляется:

  • сортировка в прямом порядке

  • удаление дубликотов

Examples:

Примеры использования

StTools::String.to_range("1, 4, 5-7, 456, 6")                           #=> [1, 4, 5, 6, 7, 456, 6]
StTools::String.to_range("1, 4, 5-7, 456, 6", sort: true)               #=> [1, 4, 5, 6, 6, 7, 456]
StTools::String.to_range("1, 4, 5-7, 456, 6", sort: true, uniq: true)   #=> [1, 4, 5, 6, 7, 456]

Parameters:

  • text (String) —

    исходная строка

  • opts (Hash) (defaults to: {})

Options Hash (opts):

  • :sort (Boolean) —

    • сортировать выходной массив

  • :uniq (Boolean) —

    • удалить из массива дубликаты

Returns:

  • (Array) —

    массив чисел



158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
 
# File 'lib/st_tools/string.rb', line 158

def self.to_range(text, opts = {})
  return [] if text.nil?
  out = Array.new

  tmp = self.split(text, ',')
  tmp.each do |one|
    if one.match(/\-/)
      d   = one.split(/\-/)
      out += Range.new(d.first.to_i, d.last.to_i).to_a
    else
      out << one.to_i
    end
  end

  out.uniq! if opts[:uniq]
  out.sort! if opts[:sort]

  return out
end

.translit(text) ⇒ String

Метод преобразует текст в транслит

Examples:

Примеры использования

StTools::String.translit("Жмеринка")   #=> "Zhmerinka"

Parameters:

  • text (String) —

    исходная строка с русскими буквами

Returns:

  • (String) —

    строка в транслите



10
11
12
13
14
15
16
17
18
19
20
 
# File 'lib/st_tools/string.rb', line 10

def self.translit(text)
  return nil if text.nil?
  translited = text.tr('абвгдеёзийклмнопрстуфхэыь', 'abvgdeezijklmnoprstufhey\'\'')
  translited = translited.tr('АБВГДЕЁЗИЙКЛМНОПРСТУФХЭЫЬ', 'ABVGDEEZIJKLMNOPRSTUFHEY\'\'')

  translited = translited.gsub(/[жцчшщъюяЖЦЧШЩЪЮЯ]/, 'ж' => 'zh', 'ц' => 'ts', 'ч' => 'ch', 'ш' => 'sh', 'щ' => 'sch',
                               'ъ'                       => '', 'ю' => 'ju', 'я' => 'ja',
                               'Ж'                       => 'Zh', 'Ц' => 'Ts', 'Ч' => 'Ch', 'Ш' => 'Sh', 'Щ' => 'Sch',
                               'Ъ'                       => '', 'Ю' => 'Ju', 'Я' => 'Ja')
  translited.gsub('\'', '')
end

.upcase(text) ⇒ String

Метод преобразует строку в верхний регистр с одновременной заменой буквы ‘Ё’ на ‘Е’. Метод имеет примерно в два раза более высокую производительности по сравнению с традиционным .mb_chars.downcase.to_s, но имеет ограничение - работа только с русскими и английскими строками

Examples:

Примеры использования

StTools::String.upcase("Hello, Вася!")   #=> "HELLO, ВАСЯ!"

Parameters:

  • text (String) —

    строка в произвольном регистре

Returns:

  • (String) —

    строка в верхнем регистре



48
49
50
51
52
53
54
 
# File 'lib/st_tools/string.rb', line 48

def self.upcase(text)
  if text
    return text.tr('qwertyuiopasdfghjklzxcvbnmабвгдеёжзийклмнопрстуфхцчшщъыьэюя',
                   'QWERTYUIOPASDFGHJKLZXCVBNMАБВГДЕЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ')
  end
  ""
end