st_tools 0.3.18 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1b75103e477ed3bfa3fe90d783b6d3322e5f6cab
-  data.tar.gz: 72d7f8f22f2ca4e4d8f47a76364ec7a38d9dbb4d
+  metadata.gz: 9a7fcb770812f74e220c7964ea4f065807e643d6
+  data.tar.gz: 692c8ba12cd6a0bc6d55f01e78e3b22653bc5978
 SHA512:
-  metadata.gz: d6bcfb61c19bcc4bd889b60de26a646e077385e3c3ce218a1de6892e7d094212a14cbccb054dfb41820a16db5efe75e8146c18ebb3bea4c25c2b2bf51669bcf1
-  data.tar.gz: 69ffea0a6edf61a2de3f5f798ac82dce656f1eba7b3a755725708c47a3987b5e29f84be8e9010335ed7ff46a10769a45d35d35dd67ca02cf50e96084d82e0eec
+  metadata.gz: 9b3ccdc959bbaa8072d2753949442ec04cd56a1035ba0ad96106dac7edf8d3c1209d3b79658811715e9412fcfc068bb66a13cf7a328a40dab4240586af180a8e
+  data.tar.gz: d5c7bbe1d071cc8d3b60581041f64e902d2e11749844115f61ea4ac03126b221a541cc92ee7457472fca679af07b3da16fe8fc5fd1130ed7b2239e0b4b3b9f61

data/README.md

@@ -23,20 +23,32 @@ gem 'st_tools'
 
 # Зависимости
 
-Для работы гема требуется Ruby не младше версии 2.0.0. StTools не привязана к Rails и может использоваться в CLI-приложениях.
+Для работы гема требуется Ruby не младше версии 2.2.0. StTools не привязана к Rails и может использоваться в CLI-приложениях.
  Класс StTools::ProgressBar является надстройкой над гемом 'progressbar-ruby'.
 
 ## Использование
 
 Часть методов библиотеки поддерживают русскую и английскую локализацию.
 Поскольку все методы StTools могут вызываться без создания экземпляра класса - вызов конструктура класса отсутствует.
-Поэтому перед работой библиотеки рекомендуется вызвать StTools::Setup.setup(:ru или :en) для загрузки файлов локализации.
+Ряд методов библиотеки требуют настройки локализации. Для этого, в приложении Ruby CLI нужно использовать:
+
+```ruby
+StTools.configure { |config| config.locale = :ru }
+```
+
+В приложении Rails необходимо создать файл `/initializers/st_tools.rb`, и включить в него:
+```ruby
+StTools.configure do |config|
+  config.locale = :ru
+end
+```
 
 ### StTools::Human
 
 Вы вызываете в любой момент StTools::Human.memory и узнаете текущий размер памяти, занимаемый приложением (процессом)
 
 ```ruby
+StTools.configure { |config| config.locale = :ru }
 StTools::Human.memory               # => 14 кбайт
 StTools::Human.memory               # => 45,3 Мбайт
 StTools::Human.memory               # => 2,6 Гбайт
@@ -45,6 +57,7 @@ StTools::Human.memory               # => 2,6 Гбайт
 Вы вызываете StTools::Human.bytes и перевести любое значение в человеко-удобный вид. Метод можно использовать для показа размера файла
 
 ```ruby
+StTools.configure { |config| config.locale = :ru }
 StTools::Human.bytes(345)           # => 345 байт
 StTools::Human.bytes(14653)         # => 14,5 кбайт
 StTools::Human.bytes(23653763)      # => 23,4 Мбайт
@@ -54,6 +67,7 @@ StTools::Human.bytes(23653763)      # => 23,4 Мбайт
 Метод можно использовать для показа, например, суммы денег
 
 ```ruby
+StTools.configure { |config| config.locale = :ru }
 StTools::Human.number(345)           # => 345
 StTools::Human.number(14653)         # => 14,6 тыс.
 StTools::Human.number(23653763)      # => 23,7 млн.
@@ -63,6 +77,7 @@ StTools::Human.number(23653763)      # => 23,7 млн.
 число цифр после запятой, и автоматически конвертировать точку в звпятую
 
 ```ruby
+StTools.configure { |config| config.locale = :ru }
 StTools::Human.pretty_number(345)                       # => 345
 StTools::Human.pretty_number(345, round: 2)             # => 345,00
 StTools::Human.pretty_number(75345, round: 1)           # => 75 345,0
@@ -73,14 +88,14 @@ StTools::Human.pretty_number('1675345.763', round: 1)   # => 1 675 345,7
 Вы имеете возможность узнать разницу между текущим временем и временем какого-либо события.
 
 ```ruby
-StTools::Setup.setup(:ru)
+StTools.configure { |config| config.locale = :ru }
 StTools::Human.human_ago(DateTime.new(2014,12,31), true)        # => 4 месяца 21 день назад
 StTools::Human.human_ago(DateTime.new(2013,08,01), false)       # => 1 год 8 месяца
 StTools::Human.human_ago(Time.now - 15, true)                   # => 15 секунд назад
 ```
 
 ```ruby
-StTools::Setup.setup(:en)
+StTools.configure { |config| config.locale = :en }
 StTools::Human.human_ago(DateTime.new(2014,12,31), true)        # => 4 months 21 days ago
 StTools::Human.human_ago(DateTime.new(2013,08,01), false)       # => 1 year 8 months
 StTools::Human.human_ago(Time.now - 15, true)                   # => 15 seconds ago
@@ -96,17 +111,17 @@ StTools::Human.human_ago(Time.now - 15, true)                   # => 15 seconds
 не временная метка, а просто количество секунд между двумя событиями.
 
 ```ruby
-StTools::Setup.setup(:ru)
+StTools.configure { |config| config.locale = :ru }
 StTools::Human.seconds_ago(DateTime.new(2014,12,31), true)        # => 4 months 21 days ago
 StTools::Human.seconds_ago(DateTime.new(2013,08,01), false)       # => 1 year 8 months
 StTools::Human.seconds_ago(Time.now - 15, true)                   # => 15 seconds ago
 ```
 
 
-Вы имеете форматировать дату и время в соответствии с правилами русского и английского языка.
+Вы можете форматировать дату и время в соответствии с правилами русского и английского языка.
 
 ```ruby
-StTools::Setup.setup(:ru)
+StTools.configure { |config| config.locale = :ru }
 StTools::Human.format_time(Time.now, :full, :full)              # => 28 апреля 2015 г. 10:45:23
 StTools::Human.format_time(Time.now, :date, :full)              # => 28 апреля 2015 г.
 StTools::Human.format_time(Time.now, :time, :full)              # => 10:45:23
@@ -116,7 +131,7 @@ StTools::Human.format_time(Time.now, :time, :short)             # => 10:45
 ```
 
 ```ruby
-StTools::Setup.setup(:en)
+StTools.configure { |config| config.locale = :en }
 StTools::Human.format_time(Time.now, :full, :full)              # => April 28, 2015 09:45:23 am
 StTools::Human.format_time(Time.now, :date, :full)              # => April 28, 2015
 StTools::Human.format_time(Time.now, :time, :full)              # => 09:45:23 am
@@ -125,6 +140,20 @@ StTools::Human.format_time(Time.now, :date, :short)             # => 04/28/2015
 StTools::Human.format_time(Time.now, :time, :short)             # => 09:45 am
 ```
 
+Новая версия данной функции имеет более прстой и понятный синтаксис. Первый параметр - формат даты, второй - времени.
+
+```ruby
+StTools.configure { |config| config.locale = :ru }
+StTools::Human.format_time2(Time.now, :human, :full)               #=> "30 апреля 2015 г. 08:54:34"
+StTools::Human.format_time2(Time.now, :human, :full, god: false)   #=> "30 апреля 2015 08:54:34"
+StTools::Human.format_time2(Time.now, :human, :short)              #=> "30 апреля 2015 г. 8:54"
+StTools::Human.format_time2(Time.now, :human, :none)               #=> "30 апреля 2015 г."
+StTools::Human.format_time2(Time.now, :full, :full)                #=> "30/04/2015 08:54:34"
+StTools::Human.format_time2(Time.now, :short, :short)              #=> "30/04/15 8:54"
+StTools::Human.format_time2(Time.now, :none, :full)                #=> "08:54:34"
+StTools::Human.format_time2(Time.now, :none, :short)               #=> "8:54"
+````
+
 Вы можете подмешать модуль `StTools::Module` в классы String, Integer, Time.
 
 ```ruby

data/lib/i18n/en.yml

@@ -33,6 +33,13 @@ en:
       date_short: "%m/%d/%Y"
       full_short: "%m/%d/%Y %I:%M:%S %P"
       time_short: "%I:%M %P"
+
+      # Values for format_time2
+      tfull: "%I:%M:%S %P"
+      tshort: "%I:%M %P"
+      dhuman: "%B %-d, %Y"
+      dfull: "%m/%d/%Y"
+      dshort: "%-m/%-d/%Y"
   date:
     <<: *defaults
   time:
@@ -71,7 +78,11 @@ en:
         two: seconds
         other: seconds
 
-  string:
+  st_tools:
+    bytes: "b,kb,Mb,Gb,Tb,Pb"
+    numbers: ",k,m,b,t"
+    numbers_separator: ""
     pretty_list:
       and: and
       or: or
+

data/lib/i18n/ru.yml

@@ -12,6 +12,13 @@ ru:
        date_short: "%d/%m/%Y"
        full_short: "%d/%m/%Y %H:%M"
        time_short: "%H:%M"
+
+       # Значения для format_time2
+       tfull: "%H:%M:%S"
+       tshort: "%H:%M"
+       dhuman: "%-d %B %Y"
+       dfull: "%d/%m/%Y"
+       dshort: "%-d/%-m/%Y"
   date:
     <<: *defaults
   time:
@@ -48,7 +55,10 @@ ru:
         two: секунды
         other: секунд
 
-  string:
+  st_tools:
+    bytes: "байт,кбайт,Мбайт,Гбайт,Тбайт,Пбайт"
+    numbers: ",тыс.,млн.,млрд.,трлн."
+    numbers_separator: " "
     pretty_list:
       and: и
       or: или

data/lib/st_tools.rb

@@ -4,6 +4,7 @@ require "st_tools/version"
 
 require 'ruby-progressbar'
 require 'yaml'
+require 'i18n'
 
 module StTools
   require "st_tools/common"
@@ -19,8 +20,65 @@ module StTools
   require 'modules/time'
   require 'modules/fias'
 
-  class Setup
+  # Use tutorial https://robots.thoughtbot.com/mygem-configure-block
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration)
+  end
+
+  class Configuration
+    attr_reader :locale
+    attr_accessor :bytes_array
+    attr_accessor :numbers_array
 
+    def initialize
+      locale = :ru
+    end
+
+    def locale=(val)
+      ::I18n.load_path += Dir[File.join(File.dirname(__dir__), '/lib/i18n/*.yml')]
+      ::I18n.backend.load_translations
+      case val.to_sym
+        when :ru, :en
+          @locale = val.to_sym
+        else
+          @locale = :ru
+      end
+      rebuild_bytes_array
+      rebuild_numbers_array
+    end
+
+    def rebuild_bytes_array
+      keys = I18n.t('st_tools.bytes', locale: @locale).split(",")
+      keys.map! { |x| x.strip }
+      raise "Must be 6 elements in array #{keys.inspect}" if keys.count != 6
+      @bytes_array = Hash.new
+      inc_value = 1024
+      keys.each do |key|
+        @bytes_array[key] = inc_value
+        inc_value *= 1024
+      end
+    end
+
+    def rebuild_numbers_array
+      keys = I18n.t('st_tools.numbers', locale: @locale).split(",")
+      keys.map! { |x| x.strip }
+      raise "Must be 5 elements in array #{keys.inspect}" if keys.count != 5
+      @numbers_array = Hash.new
+      inc_value = 1000
+      keys.each do |key|
+        @numbers_array[key] = inc_value
+        inc_value *= 1000
+      end
+    end
+
+  end
+
+  class Setup
     # Метод загрузки файлов локализации для методов форматирования времени. Принимает значения [:en, :ru]
     #
     # @param [Object] locale - язык локализации, поддерживается :ru, :en. Если передена неизвестная локализация
@@ -29,6 +87,7 @@ module StTools
     def self.setup(locale)
       locale = :ru unless [:ru, :en].include?(locale)
       self.setup_locale(locale)
+      warn "[DEPRECATION] setup is will deprecated."
     end
 
     private

data/lib/st_tools/human.rb

@@ -3,47 +3,42 @@ module StTools
 
 
     # Метод форматирует число, добавляя суффиксы 'тыс.', 'млн.' и пр.
+    # Предварительно необходимо вызвать StTools.configure { |config| config.locale = :ru }.
     #
     # @param [Integer] val исходное числовое значение
     # @return [String] строка вида "512,4 тыс."
     # @example Примеры использования
+    #   StTools.configure { |config| config.locale = :ru }
     #   StTools::Human.number(123)           #=> "123"
     #   StTools::Human.number(14563)         #=> "14 тыс."
     #   StTools::Human.number(763552638)     #=> "763.6 млн."
     def self.number(val)
-      # todo: локлаизовать через i18N
-      # noinspection RubyStringKeysInHashInspection
-      arr = {'' => 1000, 'тыс.' => 1000 * 1000, 'млн.' => 1000 * 1000 * 1000,
-             'млрд.' => 1000 * 1000 * 1000 * 1000, 'трлн.' => 1000 * 1000 * 1000 * 1000 * 1000}
-
-      arr.each_pair do |e, s|
+      StTools.configuration.numbers_array.each_pair do |e, s|
         if val < s
-          if ['', ' тыс.'].include?(e)
-            return "#{(val.to_f / (s / 1000)).round(0)} #{e}"
+          if s <= 1000*1000
+            return "#{(val.to_f / (s / 1000)).round(0)}#{I18n.t('st_tools.numbers_separator', locale: StTools.configuration.locale)}#{e}"
           else
-            return "#{(val.to_f / (s / 1000)).round(1)} #{e}"
+            return "#{(val.to_f / (s / 1000)).round(1)}#{I18n.t('st_tools.numbers_separator', locale: StTools.configuration.locale)}#{e}"
           end
         end
       end
     end
 
     # Метод форматирует число, добавляя суффиксы 'кбайт', 'Мбайт' и др.
+    # Предварительно необходимо вызвать StTools.configure { |config| config.locale = :ru }.
     #
     # @param [Integer] val исходное числовое значение в байтах
     # @return [String] строка вида "512,4 Мбайт"
     # @example Примеры использования
+    #   StTools.configure { |config| config.locale = :ru }
     #   StTools::Human.bytes(123)           #=> "123 байта"
     #   StTools::Human.bytes(14563)         #=> "14 кбайт"
     #   StTools::Human.bytes(763552638)     #=> "728.2 Мбайт"
     def self.bytes(val)
-      # todo: локлаизовать через i18N
       # noinspection RubyStringKeysInHashInspection
-      arr = {'байт' => 1024, 'кбайт' => 1024 * 1024, 'Мбайт' => 1024 * 1024 * 1024,
-             'Гбайт' => 1024 * 1024 * 1024 * 1024, 'Тбайт' => 1024 * 1024 * 1024 * 1024 * 1024}
-
-      arr.each_pair do |e, s|
+      StTools.configuration.bytes_array.each_pair do |e, s|
         if val < s
-          if %w(байт кбайт).include?(e)
+          if s <= 1024*1024
             return "#{(val.to_f / (s / 1024)).round(0)} #{e}"
           else
             return "#{(val.to_f / (s / 1024)).round(1)} #{e}"
@@ -61,13 +56,13 @@ module StTools
     end
 
     # Метод переводит DateTime в строку на русском или иных языках вида "4 дня 23 часа назад".
-    # Предварительно необходимо вызвать StTools.setup(:ru или :en).
+    # Предварительно необходимо вызвать StTools.configure { |config| config.locale = :ru }.
     #
     # @param [DateTime] time время и дата
     # @param [Boolean] ago true, если надо добавить слово "назад" в конец строки
     # @return [String] строка вида "3 дня 12 часов" или "3 дня 12 часов назад"
     # @example Примеры использования
-    #   StTools::Setup.setup(:ru)
+    #   StTools.configure { |config| config.locale = :ru }
     #   StTools::Human.human_ago(Time.now - 23, true)       #=> "23 секунды назад"
     #   StTools::Human.human_ago(Time.now - 24553, false)   #=> 6 часов 49 минут"
     #   StTools::Human.human_ago(Time.now)                  #=> "сейчас"
@@ -75,37 +70,39 @@ module StTools
       now = self.to_time(Time.now.strftime('%Y-%m-%d %H:%M:%S UTC'))
       slf = self.to_time(time.strftime('%Y-%m-%d %H:%M:%S UTC'))
       secs = (now - slf).to_i
-      return I18n.t('common.ago.very_long') if time.year < 1800
-      return I18n.t('common.ago.just_now') if secs > -1 && secs < 1
+      return I18n.t('common.ago.very_long', locale: StTools.configuration.locale) if time.year < 1800
+      return I18n.t('common.ago.just_now', locale: StTools.configuration.locale) if secs > -1 && secs < 1
       return '' if secs <= -1
       pair = self.ago_in_words_pair(secs)
-      pair << I18n.t("common.ago.ago_word") if ago == true
+      pair << I18n.t("common.ago.ago_word", locale: StTools.configuration.locale) if ago == true
       pair.join(' ')
     end
 
     # Метод принимает параметр - количество секунд между двумя любыми событиями в секундах,
     # и переводит их в строку на русском или иных языках вида "4 дня 23 часа назад".
-    # Предварительно необходимо вызвать StTools.setup(:ru или :en).
+    # Предварительно необходимо вызвать StTools.configure { |config| config.locale = :ru (или :en) }.
     #
     # @param [DateTime] sesc количество секунд
     # @param [Boolean] ago true, если надо добавить слово "назад" в конец строки
     # @return [String] строка вида "3 дня 12 часов" или "3 дня 12 часов назад"
     # @example Примеры использования
-    #   StTools::Setup.setup(:ru)
+    #   StTools.configure { |config| config.locale = :ru }
     #   StTools::Human.seconds_ago(23, true)       #=> "23 секунды назад"
     #   StTools::Human.seconds_ago(24553, false)   #=> 6 часов 49 минут"
     #   StTools::Human.seconds_ago(0)              #=> "сейчас"
     def self.seconds_ago(secs, ago = true)
       secs_i = secs.to_i
-      return I18n.t('common.ago.just_now') if secs_i > -1 && secs_i < 1
+      return I18n.t('common.ago.just_now', locale: StTools.configuration.locale) if secs_i > -1 && secs_i < 1
       return '' if secs_i <= -1
       pair = self.ago_in_words_pair(secs_i)
-      pair << I18n.t("common.ago.ago_word") if ago == true
+      pair << I18n.t("common.ago.ago_word", locale: StTools.configuration.locale) if ago == true
       pair.join(' ')
     end
 
     # Метод переводит DateTime в строку на русском или иных языках. Предварительно необходимо вызвать
-    # StTools.setup(:ru или :en).
+    # StTools.configure { |config| config.locale = :ru (или :en) }.
+    #
+    # DEPRECATED
     #
     # @param [DateTime] time исходные время и дата
     # @param [Sym] what формат возвращаемого результата, принимает одно из следующих значений
@@ -117,7 +114,7 @@ module StTools
     # @option :short короткая форма
     # @return [String] строка с форматированными датой и временем
     # @example Примеры использования
-    #   StTools::Setup.setup(:ru)
+    #   StTools.configure { |config| config.locale = :ru }
     #   StTools::Human.format_time(Time.now, :full, :full)       #=> "30 апреля 2015 г. 08:54:34"
     #   StTools::Human.format_time(Time.now, :date, :full)       #=> "30 апреля 2015 г."
     #   StTools::Human.format_time(Time.now, :time, :full)       #=> "08:54:34"
@@ -129,9 +126,57 @@ module StTools
         warn "WARNING: what ':#{what.to_s}' must be in [:full, :date, :time]. Use ':full' now (at line #{__LINE__} of StTools::#{File.basename(__FILE__)})"
         what = :full
       end
-      return I18n.l(time, :format => "#{what.to_s}_#{type.to_s}".to_sym)
+      return I18n.l(time, :format => "#{what.to_s}_#{type.to_s}".to_sym, locale: StTools.configuration.locale)
     end
 
+    # Метод переводит DateTime в строку на русском или иных языках. Предварительно необходимо вызвать
+    # StTools.configure { |config| config.locale = :ru (или :en) }.
+    #
+    # @param [DateTime] timestamp исходные время и дата
+    # @param [Sym] date формат возвращаемого результата, принимает одно из следующих значений
+    # @option :human форматирует дату и время в формате "21 марта 2011"
+    # @option :full форматирует дату и время в формате "21.03.2016"
+    # @option :short форматирует только дату в формате "21.3.16"
+    # @option :none игнорирует значение даты
+    # @param [Sym] time форма в которой возращать результат
+    # @option :full длинна форма в формате "08:23:03"
+    # @option :short короткая форма в формате "8:23", "22:34", "8:23 am"
+    # @option :none игнорирует значение времени
+    # @param [Sym] god при русской локализации и методе :human добавляет "г." после даты
+    # @return [String] строка с форматированными датой и временем
+    # @example Примеры использования
+    #   StTools.configure { |config| config.locale = :ru }
+    #   StTools::Human.format_time2(Time.now, :human, :full)               #=> "30 апреля 2015 г. 08:54:34"
+    #   StTools::Human.format_time2(Time.now, :human, :full, god: false)   #=> "30 апреля 2015 08:54:34"
+    #   StTools::Human.format_time2(Time.now, :human, :short)              #=> "30 апреля 2015 г. 8:54"
+    #   StTools::Human.format_time2(Time.now, :human, :none)               #=> "30 апреля 2015 г."
+    #   StTools::Human.format_time2(Time.now, :full, :full)                #=> "30/04/2015 08:54:34"
+    #   StTools::Human.format_time2(Time.now, :short, :short)              #=> "30/04/15 8:54"
+    #   StTools::Human.format_time2(Time.now, :none, :full)                #=> "08:54:34"
+    #   StTools::Human.format_time2(Time.now, :none, :short)               #=> "8:54"
+    def self.format_time2(timestamp, date, time, god: true)
+      unless [:human, :full, :short, :none].include?(date)
+        warn "WARNING: date ':#{date.to_s}' must be in [:human, :full, :short, :none]. Use ':human' now (at line #{__LINE__} of StTools::#{File.basename(__FILE__)})"
+        date = :human
+      end
+      unless [:full, :short, :none].include?(time)
+        warn "WARNING: time ':#{time.to_s}' must be in [:full, :short, :none]. Use ':full' now (at line #{__LINE__} of StTools::#{File.basename(__FILE__)})"
+        time = :full
+      end
+
+      case
+        when date == :none && time == :none
+          ""
+        when date != :none && time == :none
+          StTools::Human.format_time2_date(timestamp, date, god)
+        when date != :none && time != :none
+          "#{StTools::Human.format_time2_date(timestamp, date, god)} #{StTools::Human.format_time2_time(timestamp, time)}"
+        when date == :none && time != :none
+          StTools::Human.format_time2_time(timestamp, time)
+        else
+          ""
+      end
+    end
 
     # Метод оформляет число красивым способом, в виде "1 456 742,34".
     #
@@ -193,10 +238,10 @@ module StTools
     def self.ago_in_words_one_value(val, tag)
       num100 = val % 100
       num10 = val % 10
-      return val.to_s + " " + I18n.t("common.ago.#{tag}.other") if (num100 >=5 && num100 <= 20)
-      return val.to_s + " " + I18n.t("common.ago.#{tag}.one") if (num10 == 1)
-      return val.to_s + " " + I18n.t("common.ago.#{tag}.two") if ([2, 3, 4].include?(num10))
-      return val.to_s + " " + I18n.t("common.ago.#{tag}.other")
+      return val.to_s + " " + I18n.t("common.ago.#{tag}.other", locale: StTools.configuration.locale) if (num100 >=5 && num100 <= 20)
+      return val.to_s + " " + I18n.t("common.ago.#{tag}.one", locale: StTools.configuration.locale) if (num10 == 1)
+      return val.to_s + " " + I18n.t("common.ago.#{tag}.two", locale: StTools.configuration.locale) if ([2, 3, 4].include?(num10))
+      return val.to_s + " " + I18n.t("common.ago.#{tag}.other", locale: StTools.configuration.locale)
     end
 
     def self.to_time(time, form = :local)
@@ -217,5 +262,15 @@ module StTools
       form == :utc ? time.utc : time.getlocal
     end
 
+    def self.format_time2_time(timestamp, format)
+      I18n.l(timestamp, :format => "t#{format.to_s}".to_sym, locale: StTools.configuration.locale)
+    end
+
+    def self.format_time2_date(timestamp, format, god)
+      res = I18n.l(timestamp, :format => "d#{format.to_s}".to_sym, locale: StTools.configuration.locale)
+      res += " г." if god && StTools.configuration.locale == :ru
+      res
+    end
+
   end
 end

data/lib/st_tools/string.rb

@@ -16,8 +16,7 @@ module StTools
                                    'ъ' => '', 'ю' => 'ju', 'я' => 'ja',
                                    'Ж' => 'Zh', 'Ц' => 'Ts', 'Ч' => 'Ch', 'Ш' => 'Sh', 'Щ' => 'Sch',
                                    'Ъ' => '', 'Ю' => 'Ju', 'Я' => 'Ja')
-      translited.gsub!('\'', '')
-      return translited
+      translited.gsub('\'', '')
     end
 
     # Метод преобразует строку в нижний регистр с одновременной заменой буквы 'ё' на 'е'.
@@ -29,9 +28,15 @@ module StTools
     # @example Примеры использования
     #   StTools::String.downcase("Hello, Вася!")   #=> "hello, вася!"
     def self.downcase(text)
-      return nil if text.nil?
-      return text.tr('QWERTYUIOPASDFGHJKLZXCVBNMАБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ',
-                     'qwertyuiopasdfghjklzxcvbnmабвгдеёжзийклмнопрстуфхцчшщъыьэюя').gsub('ё', 'е')
+      if text
+        if RUBY_VERSION < "2.4"
+          return text.tr('QWERTYUIOPASDFGHJKLZXCVBNMАБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ',
+                         'qwertyuiopasdfghjklzxcvbnmабвгдеежзийклмнопрстуфхцчшщъыьэюя')
+        else
+          return text.downcase
+        end
+      end
+      ""
     end
 
     # Метод преобразует строку в верхний регистр с одновременной заменой буквы 'Ё' на 'Е'.
@@ -43,9 +48,15 @@ module StTools
     # @example Примеры использования
     #   StTools::String.upcase("Hello, Вася!")   #=> "HELLO, ВАСЯ!"
     def self.upcase(text)
-      return nil if text.nil?
-      return text.tr('qwertyuiopasdfghjklzxcvbnmабвгдеёжзийклмнопрстуфхцчшщъыьэюя',
-                     'QWERTYUIOPASDFGHJKLZXCVBNMАБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ').gsub('Ё', 'Е')
+      if text
+        if RUBY_VERSION < "2.4"
+          return text.tr('qwertyuiopasdfghjklzxcvbnmабвгдеёжзийклмнопрстуфхцчшщъыьэюя',
+                         'QWERTYUIOPASDFGHJKLZXCVBNMАБВГДЕЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ')
+        else
+          return text.upcase
+        end
+      end
+      ""
     end
 
     # Метод заменяет в исходной строке английские символы, похожие
@@ -57,7 +68,7 @@ module StTools
     # @return [String] текст только с русскими буквами
     def self.delat(text)
       return nil if text.nil?
-      return text.tr('ёЁEeHCcTOoPpAHKXxBM', 'еЕЕеНСсТОоРрАНКХхВМ')
+      text.tr('ёЁEeHCcTOoPpAHKXxBM', 'еЕЕеНСсТОоРрАНКХхВМ')
     end
 
     # Метод проводит нормализацию строки для последующей машиной обработки. При этом осуществляется:
@@ -68,12 +79,16 @@ module StTools
     # - в строке удаляются повторные пробелы между словами
     #
     # @param [String] text строка, введенная пользователям
+    # @param [Boolean] delat флаг необходимости проводить де-латинизацию. По умолчанию - false
     # @return [String] строка без 'ё', в нижнем регистре, без английских букв
     # @example Примеры использования
     #   StTools::String.normalize("  Ёлки-     ПАЛКИ")   #=> "елки- палки"
-    def self.normalize(text)
-      return nil if text.nil?
-      return self.downcase(self.delat(text)).strip.gsub(/[\s\t\u00A0]{1,100}/, ' ')
+    #   StTools::String.normalize("Ee", delat: true)     #=> "ее" (русские буквы)
+    #   StTools::String.normalize("Ee")                  #=> "ee" (латинские буквы)
+    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
 
     # Метод позволяет показывать клиенту строку в неполном объеме, с закрытием части символов в строке звездочкой.
@@ -91,7 +106,7 @@ module StTools
       len = text.length - 3
       0.upto((len/4).to_i) do
         pos = rand(len)
-        text[pos,1] = '*'
+        text[pos, 1] = '*'
       end
       return text
     end
@@ -218,7 +233,7 @@ module StTools
     #
     # @return [String] конвертированная строка
     # @example Примеры использования
-    #   StTools::Setup.setup(:ru)
+    #   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"
@@ -227,7 +242,7 @@ module StTools
       return "#{pretag}#{items.first}#{afttag}" if items.count == 1
       out = Array.new
       last = items.last
-      arr = items[0,items.count-1]
+      arr = items[0, items.count-1]
       arr.each do |one|
         out << "#{pretag}#{one}#{afttag}"
         out << separator + ' '
@@ -235,9 +250,9 @@ module StTools
       out.pop
       case union
         when :and
-          out << " #{I18n.t('string.pretty_list.and')} "
+          out << " #{I18n.t('st_tools.pretty_list.and', locale: StTools.configuration.locale)} "
         else
-          out << " #{I18n.t('string.pretty_list.or')} "
+          out << " #{I18n.t('st_tools.pretty_list.or', locale: StTools.configuration.locale)} "
       end
       out << "#{pretag}#{last}#{afttag}"
       out.join
@@ -261,7 +276,7 @@ module StTools
       return text if text.length <= length
       return text[0, length] if length <= endwith.length
 
-      out = text.strip[0,length - endwith.length]
+      out = text.strip[0, length - endwith.length]
       out.gsub!(/\s[^\s]+?\z/, '') if words
       out.strip + endwith
     end

data/lib/st_tools/version.rb

@@ -1,3 +1,3 @@
 module StTools
-  VERSION = '0.3.18'
+  VERSION = '0.4.0'
 end

data/test/bench/strings/downcase.rb

@@ -0,0 +1,30 @@
+require "st_tools"
+
+input = "Слово о полку ИГОРЕВЕ (Slovo O POLKU IGOREVE)"
+count = 50_000
+total = 5
+
+def test_st_tools(str, count)
+  started_at = Time.now.to_f
+  count.times do
+    StTools::String.downcase(str)
+  end
+  executed_at = Time.now.to_f - started_at
+  speed = count.to_f / executed_at
+  puts "Executed at: #{executed_at.round(3)} sec (speed = #{speed.round(1)} ops/sec)"
+  speed
+end
+
+puts "RUBY_VERSION: #{RUBY_VERSION}"
+
+avg = 0
+puts "StTools::Strings.downcase"
+total.times do
+  avg += test_st_tools(input, count)
+end
+puts "------------------------------------------------------"
+puts "Average speed = #{(avg.to_f / total).round(1)} ops/sec"
+puts
+
+
+

data/test/human_lib_format_time2_spec.rb

@@ -0,0 +1,58 @@
+require 'rspec'
+require 'st_tools'
+
+describe 'Проверка методов StTools::Human.format_time2 (:ru)' do
+    it '.format_time2 (:human, :full)' do
+      StTools.configure { |config| config.locale = :ru }
+      test = ::StTools::Human.format_time2(Time.now, :human, :full)
+      expect(test).to match(/[а-я]{3,10}/)
+      expect(test).to match(/г\./)
+      expect(test).to match(/\d{2}\:\d{2}\:\d{2}/)
+    end
+
+    it '.format_time2 (:human, :full, god:false)' do
+      StTools.configure { |config| config.locale = :ru }
+      test = ::StTools::Human.format_time2(Time.now, :human, :full, god: false)
+      expect(test).to match(/[а-я]{3,10}/)
+      expect(test).to_not match(/г\./)
+      expect(test).to match(/\d{2}\:\d{2}\:\d{2}/)
+    end
+
+    it '.format_time2 (:full, :full)' do
+      StTools.configure { |config| config.locale = :ru }
+      test = ::StTools::Human.format_time2(Time.now, :full, :full)
+      expect(test).to match(/\d{2}\/\d{2}\/\d{4}/)
+      expect(test).to match(/\d{2}\:\d{2}\:\d{2}/)
+    end
+
+    it '.format_time2 (:full, :short)' do
+      StTools.configure { |config| config.locale = :ru }
+      test = ::StTools::Human.format_time2(Time.now, :full, :short)
+      expect(test).to match(/\d{2}\/\d{2}\/\d{4}/)
+      expect(test).to_not match(/\d{2}\:\d{2}\:\d{2}/)
+    end
+end
+
+describe 'Проверка методов StTools::Human.format_time2 (:en)' do
+  it '.format_time2 (:human, :full)' do
+    StTools.configure { |config| config.locale = :en }
+    test = ::StTools::Human.format_time2(Time.now, :human, :full)
+    expect(test).to match(/[a-zA-Z]{3,10}/)
+    expect(test).to match(/\d{2}\:\d{2}\:\d{2}/)
+  end
+
+  it '.format_time2 (:full, :full)' do
+    StTools.configure { |config| config.locale = :en }
+    test = ::StTools::Human.format_time2(Time.now, :full, :full)
+    expect(test).to match(/\d{2}\/\d{2}\/\d{4}/)
+    expect(test).to match(/\d{2}\:\d{2}\:\d{2}/)
+  end
+
+  it '.format_time2 (:full, :short)' do
+    StTools.configure { |config| config.locale = :en }
+    test = ::StTools::Human.format_time2(Time.now, :full, :short)
+    expect(test).to match(/\d{2}\/\d{2}\/\d{4}/)
+    expect(test).to_not match(/\d{2}\:\d{2}\:\d{2}/)
+  end
+end
+

data/test/human_lib_spec.rb

@@ -4,63 +4,94 @@ require 'st_tools'
 
 describe 'Проверка методов StTools::Human.*' do
   it '.bytes(234)' do
+    StTools.configure { |config| config.locale = :ru }
     test = ::StTools::Human.bytes(234)
     expect(test).to include('234')
     expect(test).to include('байт')
   end
 
   it '.bytes(14234)' do
+    StTools.configure { |config| config.locale = :ru }
     test = ::StTools::Human.bytes(14234)
     expect(test).to include('14')
     expect(test).to include('кбайт')
   end
 
+  it '.bytes(:en, 234)' do
+    StTools.configure { |config| config.locale = :en }
+    test = ::StTools::Human.bytes(234)
+    expect(test).to include('234')
+    expect(test).to include('b')
+  end
+
+  it '.bytes(:en, 14234)' do
+    StTools.configure { |config| config.locale = :en }
+    test = ::StTools::Human.bytes(14234)
+    expect(test).to include('14')
+    expect(test).to include('kb')
+  end
+
   it '.number(234)' do
+    StTools.configure { |config| config.locale = :ru }
     test = ::StTools::Human.number(234)
     expect(test).to include('234')
   end
 
   it '.number(14234)' do
+    StTools.configure { |config| config.locale = :ru }
     test = ::StTools::Human.number(14234)
     expect(test).to include('14')
-    expect(test).to include('тыс.')
+    expect(test).to include(' тыс.')
+  end
+
+  it '.number(:en, 234)' do
+    StTools.configure { |config| config.locale = :en }
+    test = ::StTools::Human.number(234)
+    expect(test).to include('234')
+  end
+
+  it '.number(:en, 14234)' do
+    StTools.configure { |config| config.locale = :en }
+    test = ::StTools::Human.number(14234)
+    expect(test).to include('14k')
   end
 
   it '.memory' do
+    StTools.configure { |config| config.locale = :ru }
     test = ::StTools::Human.memory
     expect(test).to include('байт')
   end
 
   it '.human_ago (:ru)' do
-    ::StTools::Setup.setup(:ru)
+    StTools.configure { |config| config.locale = :ru }
     test = ::StTools::Human.human_ago(DateTime.new(2001,2,3,4,5,6,'+7'), true)
     expect(test).to include('назад')
     expect(test).to include('лет')
   end
 
   it '.human_ago (:en)' do
-    ::StTools::Setup.setup(:en)
+    StTools.configure { |config| config.locale = :en }
     test = ::StTools::Human.human_ago(DateTime.new(2001,2,3,4,5,6,'+7'), true)
     expect(test).to include('ago')
     expect(test).to include('years')
   end
 
   it '.seconds_ago (:ru)' do
-    ::StTools::Setup.setup(:ru)
+    StTools.configure { |config| config.locale = :ru }
     test = ::StTools::Human.seconds_ago(67, true)
     expect(test).to include('назад')
     expect(test).to include('1 минута')
   end
 
   it '.seconds_ago (:en)' do
-    ::StTools::Setup.setup(:en)
+    StTools.configure { |config| config.locale = :en }
     test = ::StTools::Human.seconds_ago(67, true)
     expect(test).to include('ago')
     expect(test).to include('1 minute')
   end
 
   it '.format_time (:ru)' do
-    ::StTools::Setup.setup(:ru)
+    StTools.configure { |config| config.locale = :ru }
     test = ::StTools::Human.format_time(Time.now, :full, :full)
     expect(test).to match(/[а-я]{1,3}/)
     test = ::StTools::Human.format_time(Time.now, :full, :short)
@@ -68,7 +99,7 @@ describe 'Проверка методов StTools::Human.*' do
   end
 
   it '.format_time (:en)' do
-    ::StTools::Setup.setup(:en)
+    StTools.configure { |config| config.locale = :en }
     test = ::StTools::Human.format_time(Time.now, :full, :full)
     expect(test).to match(/[a-z]{1,3}/i)
     test = ::StTools::Human.format_time(Time.now, :full, :short)
@@ -95,5 +126,5 @@ describe 'Проверка методов StTools::Human.*' do
     expect(test).to match('0')
   end
 
+end
 
-end

data/test/string_lib_spec.rb

@@ -14,10 +14,20 @@ describe 'Проверка методов StTools::String.*' do
   end
 
   it '.normalize' do
-    test = ::StTools::String.normalize('Ярослав    Му(y)дрёный')
+    test = ::StTools::String.normalize('Ярослав    Му(y)дрёный', delat: true)
     expect(test).to include('ярослав му(y)дреный')
   end
 
+  it '.normalize без delat' do
+    test = ::StTools::String.normalize('Ee') # Английские буквы
+    expect(test).to include('ee') # Английские буквы
+  end
+
+  it '.normalize с delat' do
+    test = ::StTools::String.normalize('Ee', delat: true) # Английкие буквы
+    expect(test).to include('ее') # Русские буквы
+  end
+
   it '.downcase("EngLish")' do
     test = ::StTools::String.downcase('EngLish')
     expect(test).to include('english')
@@ -112,7 +122,7 @@ describe 'Проверка методов StTools::String.*' do
   end
 
   it 'pretty_list - ru' do
-    ::StTools::Setup.setup(:ru)
+    StTools.configure { |config| config.locale = :ru }
     test = ::StTools::String.pretty_list(['Паша'])
     expect(test).to eq('Паша')
     test = ::StTools::String.pretty_list(['Паша', 'Маша'])
@@ -126,7 +136,7 @@ describe 'Проверка методов StTools::String.*' do
   end
 
   it 'pretty_list - en' do
-    ::StTools::Setup.setup(:en)
+    StTools.configure { |config| config.locale = :en }
     test = ::StTools::String.pretty_list(['Паша'])
     expect(test).to eq('Паша')
     test = ::StTools::String.pretty_list(['Паша', 'Маша'])

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: st_tools
 version: !ruby/object:Gem::Version
-  version: 0.3.18
+  version: 0.4.0
 platform: ruby
 authors:
 - Stan Zhuravlev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-05-12 00:00:00.000000000 Z
+date: 2016-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -98,8 +98,10 @@ files:
 - lib/st_tools/system.rb
 - lib/st_tools/tokenizer.rb
 - lib/st_tools/version.rb
+- test/bench/strings/downcase.rb
 - test/countries_lib_spec.rb
 - test/fias_lib_spec.rb
+- test/human_lib_format_time2_spec.rb
 - test/human_lib_spec.rb
 - test/progress_bar_lib_spec.rb
 - test/string_caps_lib_spec.rb