useful_utilities 5.4.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e5e4bbec43984ce6756ade1190a5f21e4dfbaf5e
+  data.tar.gz: 236d91abef2bedcfaaab5e49c7c78cc998a5eedd
+SHA512:
+  metadata.gz: 79972ec7576ea4d937a16a113cdf10082c7bad7a0b415b46a6adf56ead972caf76c3edc17286e6640c84b726fc48884726ba276c9647f20358b97b04a4cc94d7
+  data.tar.gz: 35b254e47c6638587ae79491a8eb013cbc39ea5fd5503a668f7847588eee3a8d2af74d32538e7fd52a0bb9f21236b0daf5048f73d4480ac74a4fdc1c92a58cb2

data/README.md

@@ -0,0 +1,14 @@
+## UsefulUtilities
+
+A collection of useful utilities
+
+This package include next tools with new namespaces:
+
+Api Utilities => UsefulUtilities::Api
+AR Utilities => UsefulUtilities::AR
+Hash Utilities => UsefulUtilities::Hash
+Size Utilities => UsefulUtilities::Size
+Numeric Utilities => UsefulUtilities::Numeric
+Time Utilities => UsefulUtilities::Time
+YAML Utilities => UsefulUtilities::YAML
+I18n Utilities => UsefulUtilities::I18n

data/Rakefile

@@ -0,0 +1,21 @@
+#!/usr/bin/env rake
+
+begin
+  require 'bundler/setup'
+  require 'rubygems'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+APP_RAKEFILE = File.expand_path('../spec/dummy/Rakefile', __FILE__)
+load 'rails/tasks/engine.rake'
+
+Bundler::GemHelper.install_tasks

data/lib/useful_utilities/api.rb

@@ -0,0 +1,26 @@
+require 'socket'
+require 'timeout'
+
+module UsefulUtilities
+  module Api
+    extend self
+
+    RESCUE_PORT_OPEN_EXCEPTIONS = [Errno::ENETUNREACH, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, SocketError, Timeout::Error].freeze
+
+    def convert_limit(value)
+      value == Float::INFINITY ? false : value
+    end
+
+    # checks if a port is open or not on a remote host
+    def port_open?(ip, port, sleep_time: 1, max_attempts: 3)
+      try_to(max_attempts: max_attempts, sleep_time: sleep_time, rescue_what: RESCUE_PORT_OPEN_EXCEPTIONS) do
+        Timeout::timeout(sleep_time) do
+          TCPSocket.new(ip, port).close
+          true
+        end
+      end
+    rescue *RESCUE_PORT_OPEN_EXCEPTIONS
+      false
+    end
+  end
+end

data/lib/useful_utilities/ar.rb

@@ -0,0 +1,147 @@
+require 'active_record'
+require 'active_support/all'
+
+module UsefulUtilities
+  module AR
+    module Methods
+      def foreign_key(association_class)
+        reflections.values.find do |reflection|
+          reflection.class_name == association_class.name
+        end.foreign_key
+      end
+    end
+
+    extend self
+
+    NESTED_ASSOCIATIONS = %i( has_one has_many )
+    BASE_ERROR_KEY = :base
+    TYPE_SUFFIX = '%s_type'
+    ID_SUFFIX = '%s_id'
+
+    def value_to_integer(value)
+      return 0 if value.nil?
+      return 0 if value == false
+      return 1 if value == true
+
+      ActiveRecord::Type::Integer.new.type_cast_from_database(value)
+    end
+
+    def value_to_decimal(value)
+      return BigDecimal.new(0) if value.nil?
+
+      ActiveRecord::Type::Decimal.new.type_cast_from_database(value)
+    end
+
+    def value_to_boolean(value)
+      return false if value.nil?
+
+      ActiveRecord::Type::Boolean.new.type_cast_from_database(value)
+    end
+
+    def boolean_to_float(value)
+      value ? 1.0 : 0.0
+    end
+
+    def deep_validation(record)
+      record.valid?
+      nested_associations_validation(record)
+    end
+
+    def nested_associations_validation(record, nested = false)
+      record.class.reflections.each do |name, reflection|
+        next unless NESTED_ASSOCIATIONS.include?(reflection.macro)
+
+        association_records = Array(record.public_send(name))
+        error_key = nested ? BASE_ERROR_KEY : name
+        record.errors.delete(name)
+
+        association_records.each do |nested_record|
+          next unless nested_record.changed?
+          nested_associations_validation(nested_record, :nested)
+          nested_record.errors.full_messages.each { |message| record.errors[error_key] << message }
+        end
+      end
+    end
+
+    def by_polymorphic(scope, key, value)
+      type = to_polymorphic_type(value)
+      type_column, id_column = TYPE_SUFFIX % key, ID_SUFFIX % key
+      scope.where(type_column => type, id_column => value)
+    end
+
+    def to_polymorphic_type(value)
+      klass =
+        if value.is_a?(Class) || value.nil? then value
+        elsif value.respond_to?(:klass) then value.klass
+        else value.class
+        end
+
+      klass.respond_to?(:base_class) ? klass.base_class : klass
+    end
+
+    def [](klass, *columns)
+      columns.map { |column| "#{ klass.table_name }.#{ column }" }.join(', ')
+    end
+
+    def asc(klass, column)
+      "#{ self[klass, column] } ASC"
+    end
+
+    def desc(klass, column)
+      "#{ self[klass, column] } DESC"
+    end
+
+    def older_than(scope, _value)
+      value = _value.is_a?(ActiveRecord::Base) ? _value.id : _value
+      value.present? ? scope.where("#{ self[scope, :id] } < ?", value) : scope
+    end
+
+    def null_to_zero(*args)
+      sql_column =
+        case args.size
+        when 1 then args.first
+        when 2 then self[args[0], args[1]]
+        else
+          raise ArgumentError, "wrong number of arguments (#{ args.size } for 1..2)"
+        end
+
+      "COALESCE(#{ sql_column }, 0)"
+    end
+
+    def ceil(value)
+      "CEILING(#{value})"
+    end
+
+    def sql_sum(*args, result)
+      "SUM(#{ null_to_zero(*args) }) AS #{ result }"
+    end
+
+    # Can be used for not NULL columns only
+    # sum_by_columns(Virtual, :column_1, :column2, column3: :column3_alias...)
+    def sum_by_columns(scope, *all_columns)
+      columns = all_columns.flatten
+      columns_with_aliases = columns.extract_options!
+
+      sql_query =
+        columns.reduce(columns_with_aliases) { |res, column| res.merge!(column => column) }.
+                map { |column, column_alias| "SUM(#{ column }) AS #{ column_alias }" }.join(', ')
+
+      scope.select(sql_query).first
+    end
+
+    def count(table, column, result)
+      "COUNT(#{ self[table, column] }) AS #{ result }"
+    end
+
+    def delete_dependents(owner, self_class, dependent_class)
+      dependent_fk = dependent_class.foreign_key(self_class)
+      self_fk = self_class.foreign_key(owner.class)
+
+         "DELETE #{dependent_class.table_name}
+            FROM #{dependent_class.table_name}
+      INNER JOIN #{self_class.table_name}
+              ON #{self[dependent_class, dependent_fk]} = #{self[self_class, :id]}
+           WHERE #{self[self_class, self_fk]} = #{owner.id}"
+    end
+  end
+end

data/lib/useful_utilities/centos_version.rb

@@ -0,0 +1,49 @@
+module UsefulUtilities
+  class CentOSVersion
+    attr_reader :version
+
+    def initialize(version)
+      @version = version.to_i
+    end
+
+    class << self
+      def centos5?(*args)
+        new(*args).centos5?
+      end
+      alias_method :five?, :centos5?
+
+      def centos6?(*args)
+        new(*args).centos6?
+      end
+      alias_method :six?, :centos6?
+
+      def centos7?(*args)
+        new(*args).centos7?
+      end
+      alias_method :seven?, :centos7?
+
+      def not_centos5?(*args)
+        new(*args).not_centos5?
+      end
+    end
+
+    def centos5?
+      version == 5
+    end
+    alias_method :five?, :centos5?
+
+    def centos6?
+      version == 6
+    end
+    alias_method :six?, :centos6?
+
+    def centos7?
+      version == 7
+    end
+    alias_method :seven?, :centos7?
+
+    def not_centos5?
+      !centos5?
+    end
+  end
+end

data/lib/useful_utilities/hash.rb

@@ -0,0 +1,29 @@
+module UsefulUtilities
+  module Hash
+    extend self
+
+    def sum_values(*list)
+      collect_keys(*list).inject({}) do |result, key|
+        result[key] = 0
+        list.each { |item| result[key] += item[key] if item.has_key?(key) }
+
+        result
+      end
+    end
+
+    def group_by_keys(*list)
+      collect_keys(*list).inject({}) do |result, key|
+        result[key] = []
+        list.each { |item| result[key] << item[key] if item.has_key?(key) }
+
+        result
+      end
+    end
+
+    private
+
+    def collect_keys(*list)
+      list.inject([]) { |result, item| result |= item.keys }
+    end
+  end
+end

data/lib/useful_utilities/i18n.rb

@@ -0,0 +1,16 @@
+module UsefulUtilities
+  module I18n
+    extend self
+
+    def humanize_type(object)
+      klass = case object
+              when Class then object
+              when object.respond_to?(:klass) then object.klass
+              else
+                object.class
+              end
+
+      klass.respond_to?(:model_name) ? klass.model_name.human : klass.to_s.underscore.humanize
+    end
+  end
+end

data/lib/useful_utilities/numeric.rb

@@ -0,0 +1,52 @@
+module UsefulUtilities
+  module Numeric
+    extend self
+
+    ZERO = 0
+    THOUSAND = 1_000
+    MILLION = 1_000_000
+    BILLION = 1_000_000_000
+
+    def positive_or_zero(value)
+      (value > ZERO) ? value : ZERO
+    end
+
+    def float_or_integer(value)
+      value == value.to_i ? value.to_i : value
+    end
+
+    def to_decimal(value, scale: nil)
+      result = value.to_f.to_d
+
+      scale ? result.round(scale) : result
+    end
+
+    # @note: used SI metric prefixes http://en.wikipedia.org/wiki/SI_prefix
+    def to_kilo(value, unit)
+      if    unit == :M then value * THOUSAND
+      elsif unit == :G then value * MILLION
+      else  unsupported_unit!(unit)
+      end
+    end
+
+    def to_giga(value, unit)
+      if    unit == :k then value.fdiv(MILLION)
+      elsif unit == :M then value.fdiv(THOUSAND)
+      else  unsupported_unit!(unit)
+      end
+    end
+
+    def to_number(value, unit)
+      if    unit == :M then value * MILLION
+      elsif unit == :G then value * BILLION
+      else  unsupported_unit!(unit)
+      end
+    end
+
+    private
+
+    def unsupported_unit!(unit)
+      raise ArgumentError.new("Unsupported unit - #{ unit }")
+    end
+  end
+end

data/lib/useful_utilities/redhat_release.rb

@@ -0,0 +1,72 @@
+module UsefulUtilities
+  class RedhatRelease
+    LEGACY_DISTRO_TEMPLATE = 'centos%{major_version}'.freeze
+
+    VERSION_SEPARATOR = '.'.freeze # this may change to "dot" and "hyphen" if we allow not only final releases(beta, custom git builds, etc)
+    VERSION_SEPARATOR_REGEXP = Regexp.escape(VERSION_SEPARATOR).freeze # regexp to match single "dot" character
+
+    VERSION_REGEXP = %r{              # /etc/redhat-release samples: "CentOS Linux release 7.1.1503 (Core)", "Red Hat Enterprise Linux Server release 7.2 (Maipo)"
+      (?<=[[:space:]])                # positive lookbehind assertion: ensures that the preceding character matches single "space" character, but doesn't include this character in the matched text
+      (?<major_version>[[:digit:]])   # :major_version named capture group; it matches single digits
+      #{VERSION_SEPARATOR_REGEXP}     # regexp for separator of version parts
+      (?<minor_version>[[:digit:]]+)  # :minor_version named capture group; it matches one or more sequential digits
+      (?:                             # grouping without capturing; "monthstamp" version part don't exist for versions of Centos older then 7
+        #{VERSION_SEPARATOR_REGEXP}   # regexp for separator of version parts
+        (?<monthstamp>[[:digit:]]{4}) # :monthstamp named capture group; it matches 4 sequential digits
+      )?                              # zero or one times quantifier(repetition metacharacter)
+      (?=[[:space:]])                 # positive lookahead assertion: ensures that the following character matches single "space" character, but doesn't include this character in the matched text
+    }x.freeze
+
+    DEFAULT_VERSION_ARR = [6, 0].freeze
+
+    attr_reader :release_string
+
+    def initialize(release_string)
+      @release_string = release_string.to_s
+    end
+
+    def self.major_version(*args)
+      new(*args).major_version
+    end
+
+    def self.legacy_distro(ver)
+      LEGACY_DISTRO_TEMPLATE % { major_version: ver }
+    end
+
+    def major_version
+      version_arr[0]
+    end
+
+    def minor_version
+      version_arr[1]
+    end
+
+    def monthstamp
+      version_arr[2]
+    end
+
+    def version_string
+      version_arr.join(VERSION_SEPARATOR)
+    end
+
+    private
+
+    def version_arr
+      @version_arr ||= version_match.present? ? match_version_arr : DEFAULT_VERSION_ARR
+    end
+
+    def match_version_arr
+      @match_version_arr ||= [
+        version_match[:major_version],
+        version_match[:minor_version],
+        version_match[:monthstamp]
+      ].compact.map(&:to_i)
+    end
+
+    def version_match
+      return @version_match if defined?(@version_match)
+
+      @version_match = VERSION_REGEXP.match(release_string)
+    end
+  end
+end

data/lib/useful_utilities/size/bit.rb

@@ -0,0 +1,92 @@
+require_relative 'standard/decimal'
+
+module UsefulUtilities
+  module Size
+    module Bit
+      # @note: used SI standard http://en.wikipedia.org/wiki/Binary_prefix
+      #   Decimal
+      #   1 K = 1000
+      include UsefulUtilities::Size::Standard::Decimal
+
+      def to_terabits(size, unit)
+        to_tera(size, bit_prefix(unit))
+      end
+
+      def to_gigabits(size, unit)
+        to_giga(size, bit_prefix(unit))
+      end
+
+      def to_megabits(size, unit)
+        to_mega(size, bit_prefix(unit))
+      end
+
+      def to_kilobits(size, unit)
+        to_kilo(size, bit_prefix(unit))
+      end
+
+      def to_bits(size, unit)
+        to_decimal_bi(size, bit_prefix(unit))
+      end
+
+      # Convert bits to manually defined format
+      #   by using parameter 'unit'
+      #   ATTENTION: by default round is eq to 3 digits
+      def bits_to_human_size(size, unit, rounder = 3)
+        case unit
+        when :bit  then size.round(rounder)
+        when :kbit then to_kilobits(size, :bit).round(rounder)
+        when :Mbit then to_megabits(size, :bit).round(rounder)
+        when :Gbit then to_gigabits(size, :bit).round(rounder)
+        when :Tbit then to_terabits(size, :bit).round(rounder)
+        else  unsupported_unit!(unit)
+        end
+      end
+
+      # Ignore any fractional part of the number
+      #   Bit can be only integer !!!
+      def suitable_unit_for_bits(value)
+        return not_integer!(value)          unless value.is_a?(Integer)
+        return not_positive_integer!(value) unless value > -1
+
+        if value.to_s.length    <= 3  then :bit
+        elsif value.to_s.length <= 6  then :kbit
+        elsif value.to_s.length <= 9  then :Mbit
+        elsif value.to_s.length <= 12 then :Gbit
+        else :Tbit
+        end
+      end
+
+      def bits_per_sec_to_human_readable(value_in_bits)
+        unit  = suitable_unit_for_bits(value_in_bits)
+        value = bits_to_human_size(value_in_bits, unit.to_sym)
+
+        "#{value} #{unit}/s"
+      end
+
+      private
+
+      def bit_prefix(unit)
+        case unit
+        when :bit  then :B
+        when :kbit then :KB
+        when :Mbit then :MB
+        when :Gbit then :GB
+        when :Tbit then :TB
+        else unsupported_unit!(unit)
+        end
+      end
+
+      def unsupported_unit!(unit)
+        raise ArgumentError.new("Unsupported unit - #{ unit }")
+      end
+
+      def not_integer!(value)
+        raise ArgumentError.new("#{value } is not integer")
+      end
+
+      def not_positive_integer!(value)
+        raise ArgumentError.new("#{value } is not positive integer")
+      end
+    end
+  end
+end

data/lib/useful_utilities/size/byte.rb

@@ -0,0 +1,69 @@
+require_relative 'standard/binary'
+
+module UsefulUtilities
+  module Size
+    module Byte
+      # @note: used ISO standard http://en.wikipedia.org/wiki/Binary_prefix
+      #   Binary
+      #   1 K = 1024
+      include UsefulUtilities::Size::Standard::Binary
+
+      HALF_OF_SECTOR = 0.5
+
+      def to_terabytes(size, unit)
+        to_tebi(size, byte_prefix(unit))
+      end
+
+      def to_gigabytes(size, unit)
+        to_gibi(size, byte_prefix(unit))
+      end
+
+      def to_megabytes(size, unit)
+        to_mebi(size, byte_prefix(unit))
+      end
+
+      def to_kilobytes(size, unit)
+        if unit == :sector
+          return (size * HALF_OF_SECTOR).round # http://en.wikipedia.org/wiki/Disk_sector
+        end
+
+        to_kibi(size, byte_prefix(unit))
+      end
+
+      def to_bytes(size, unit)
+        to_binary_bi(size, byte_prefix(unit))
+      end
+
+      # Convert bytes to manually defined format
+      #   by using parameter 'unit'
+      #   ATTENTION: by default round is eq to 3 digits
+      def bytes_to_human_size(size, unit, rounder = 3)
+        case unit
+        when :B  then size.round(rounder)
+        when :KB then to_kilobytes(size, :B).round(rounder)
+        when :MB then to_megabytes(size, :B).round(rounder)
+        when :GB then to_gigabytes(size, :B).round(rounder)
+        when :TB then to_terabytes(size, :B).round(rounder)
+        else  unsupported_unit!(unit)
+        end
+      end
+
+      private
+
+      def byte_prefix(unit)
+        case unit
+        when :B  then :B
+        when :KB then :KiB
+        when :MB then :MiB
+        when :GB then :GiB
+        when :TB then :TiB
+        else unsupported_unit!(unit)
+        end
+      end
+
+      def unsupported_unit!(unit)
+        raise ArgumentError.new("Unsupported unit - #{ unit }")
+      end
+    end
+  end
+end

data/lib/useful_utilities/size/cdn_speed.rb

@@ -0,0 +1,33 @@
+require_relative 'standard/decimal'
+
+module UsefulUtilities
+  module Size
+    module CdnSpeed
+      # @note: used SI standard http://en.wikipedia.org/wiki/Binary_prefix
+      #   Decimal
+      #   1 K = 1000
+      include UsefulUtilities::Size::Standard::Decimal
+
+      def to_cdn_gbps(speed, unit)
+        to_giga(speed, bit_prefix(unit))/8
+      end
+
+      private
+
+      def bit_prefix(unit)
+        case unit
+        when :bit  then :B
+        when :kbit then :KB
+        when :Mbit then :MB
+        when :Gbit then :GB
+        when :Tbit then :TB
+        else unsupported_unit!(unit)
+        end
+      end
+
+      def unsupported_unit!(unit)
+        raise ArgumentError.new("Unsupported unit - #{ unit }")
+      end
+    end
+  end
+end

data/lib/useful_utilities/size/frequency.rb

@@ -0,0 +1,37 @@
+require_relative 'standard/decimal'
+
+module UsefulUtilities
+  module Size
+    module Frequency
+      # @note: used SI standard http://en.wikipedia.org/wiki/Binary_prefix
+      #   Decimal
+      #   1 K = 1000
+      include UsefulUtilities::Size::Standard::Decimal
+
+      def to_megahertz(size, unit)
+        to_mega(size, frequency_prefix(unit))
+      end
+
+      def to_gigahertz(size, unit)
+        to_giga(size, frequency_prefix(unit))
+      end
+
+      private
+
+      def frequency_prefix(unit)
+        case unit
+        when :Hz  then :B
+        when :KHz then :KB
+        when :MHz then :MB
+        when :GHz then :GB
+        when :THz then :TB
+        else unsupported_unit!(unit)
+        end
+      end
+
+      def unsupported_unit!(unit)
+        raise ArgumentError.new("Unsupported unit - #{ unit }")
+      end
+    end
+  end
+end

data/lib/useful_utilities/size/percentage.rb

@@ -0,0 +1,15 @@
+module UsefulUtilities
+  module Size
+    module Percentage
+      HUNDRED = 100
+
+      def fraction_to_percentage(fraction)
+        fraction * HUNDRED
+      end
+
+      def percentage_to_fraction(percentage)
+        percentage.fdiv(HUNDRED)
+      end
+    end
+  end
+end

data/lib/useful_utilities/size/standard/binary.rb

@@ -0,0 +1,69 @@
+module UsefulUtilities
+  module Size
+    module Standard
+      module Binary
+        # @note: used ISO standard http://en.wikipedia.org/wiki/Binary_prefix
+
+        KIBI = 1024      # KiB
+        MEBI = KIBI ** 2 # MiB
+        GIBI = KIBI ** 3 # GiB
+        TEBI = KIBI ** 4 # TiB
+
+        def to_tebi(val, prefix)
+          case prefix
+          when :B   then val.fdiv(TEBI)
+          when :KiB then val.fdiv(GIBI)
+          when :MiB then val.fdiv(MEBI)
+          when :GiB then val.fdiv(KIBI)
+          when :TiB then val
+          else unsupported_unit!(prefix)
+          end
+        end
+
+        def to_gibi(val, prefix)
+          case prefix
+          when :B   then val.fdiv(GIBI)
+          when :KiB then val.fdiv(MEBI)
+          when :MiB then val.fdiv(KIBI)
+          when :GiB then val
+          when :TiB then val * KIBI
+          else unsupported_unit!(prefix)
+          end
+        end
+
+        def to_mebi(val, prefix)
+          case prefix
+          when :B   then val.fdiv(MEBI)
+          when :KiB then val.fdiv(KIBI)
+          when :MiB then val
+          when :GiB then val * KIBI
+          when :TiB then val * MEBI
+          else unsupported_unit!(prefix)
+          end
+        end
+
+        def to_kibi(val, prefix)
+          case prefix
+          when :B   then val.fdiv(KIBI)
+          when :KiB then val
+          when :MiB then val * KIBI
+          when :GiB then val * MEBI
+          when :TiB then val * GIBI
+          else unsupported_unit!(prefix)
+          end
+        end
+
+        def to_binary_bi(val, prefix)
+          case prefix
+          when :B   then val
+          when :KiB then val * KIBI
+          when :MiB then val * MEBI
+          when :GiB then val * GIBI
+          when :TiB then val * TEBI
+          else unsupported_unit!(prefix)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/useful_utilities/size/standard/decimal.rb

@@ -0,0 +1,69 @@
+module UsefulUtilities
+  module Size
+    module Standard
+      module Decimal
+        # @note: used SI standard http://en.wikipedia.org/wiki/Binary_prefix
+
+        KILO = 1000      # KB
+        MEGA = KILO ** 2 # MB
+        GIGA = KILO ** 3 # GB
+        TERA = KILO ** 4 # TB
+
+        def to_tera(val, prefix)
+          case prefix
+          when :B  then val.fdiv(TERA)
+          when :KB then val.fdiv(GIGA)
+          when :MB then val.fdiv(MEGA)
+          when :GB then val.fdiv(KILO)
+          when :TB then val
+          else unsupported_unit!(prefix)
+          end
+        end
+
+        def to_giga(val, prefix)
+          case prefix
+          when :B  then val.fdiv(GIGA)
+          when :KB then val.fdiv(MEGA)
+          when :MB then val.fdiv(KILO)
+          when :GB then val
+          when :TB then val * KILO
+          else unsupported_unit!(prefix)
+          end
+        end
+
+        def to_mega(val, prefix)
+          case prefix
+          when :B  then val.fdiv(MEGA)
+          when :KB then val.fdiv(KILO)
+          when :MB then val
+          when :GB then val * KILO
+          when :TB then val * MEGA
+          else unsupported_unit!(prefix)
+          end
+        end
+
+        def to_kilo(val, prefix)
+          case prefix
+          when :B  then val.fdiv(KILO)
+          when :KB then val
+          when :MB then val * KILO
+          when :GB then val * MEGA
+          when :TB then val * GIGA
+          else unsupported_unit!(prefix)
+          end
+        end
+
+        def to_decimal_bi(val, prefix)
+          case prefix
+          when :B  then val
+          when :KB then val * KILO
+          when :MB then val * MEGA
+          when :GB then val * GIGA
+          when :TB then val * TERA
+          else unsupported_unit!(prefix)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/useful_utilities/size.rb

@@ -0,0 +1,18 @@
+require 'active_support/core_ext/numeric/bytes'
+require_relative 'size/bit'
+require_relative 'size/cdn_speed'
+require_relative 'size/frequency'
+require_relative 'size/byte'
+require_relative 'size/percentage'
+
+module UsefulUtilities
+  module Size
+    include UsefulUtilities::Size::Bit
+    include UsefulUtilities::Size::CdnSpeed
+    include UsefulUtilities::Size::Frequency
+    include UsefulUtilities::Size::Byte
+    include UsefulUtilities::Size::Percentage
+
+    extend self
+  end
+end

data/lib/useful_utilities/time.rb

@@ -0,0 +1,97 @@
+require 'active_support/all'
+
+module UsefulUtilities
+  module Time
+    extend self
+
+    SECONDS_IN_HOUR = 3_600
+    MILLISECONDS_IN_SECOND = 1_000
+
+    # Whatever time is passed it will return it without any GMT offset and the passed time will be in UTC
+    # t = Time.now              #=> 2013-12-19 14:01:22 +0200
+    # UsefulUtilities::Time.assume_utc(t) #=> 2013-12-19 14:01:22 UTC
+    def assume_utc(time)
+      time.to_datetime.change(offset: 0)
+    end
+
+    # Examples of usage:
+    # 2014-01-04 14:29:59 #=> 2014-01-04 14:00:00
+    # 2014-01-04 14:30:00 #=> 2014-01-04 15:00:00
+    def round_to_hours(time)
+      (time.min < 30) ? time.beginning_of_hour : time.end_of_hour
+    end
+
+    def beginning_of_next_hour(time)
+      time.beginning_of_hour.in(1.hour)
+    end
+
+    def beginning_of_next_day(time)
+      time.beginning_of_day.in(1.day)
+    end
+
+    def beginning_of_next_month(time)
+      time.beginning_of_month.in(1.month)
+    end
+
+    # yields local time of the beginning of each hour
+    # between start time & current time
+    def each_hour_from(from, till = ::Time.now)
+      cursor = from.dup.utc.beginning_of_hour
+      end_time = till.dup.utc.beginning_of_hour
+
+      while cursor < end_time
+        yield cursor, next_hour = beginning_of_next_hour(cursor)
+
+        cursor = next_hour
+      end
+    end
+
+    def each_day_from(from, till = ::Time.now)
+      cursor = from.beginning_of_day
+      end_time = till.beginning_of_day
+
+      while cursor < end_time
+        yield cursor, next_day = beginning_of_next_day(cursor)
+
+        cursor = next_day
+      end
+    end
+
+    # Parse and convert Time to the given time zone. If time zone is
+    # not given, Time is assumed to be given in UTC. Returns result in
+    # UTC
+    def to_utc(time_string, time_zone)
+      time = ::DateTime.parse(time_string) # Wed, 22 Aug 2012 13:34:18 +0000
+    rescue
+      nil
+    else
+      if time_zone.present?
+        current_user_offset = ::Time.now.in_time_zone(::Time.find_zone(time_zone)).strftime("%z") # "+0300"
+        time = time.change(:offset => current_user_offset) # Wed, 22 Aug 2012 13:34:18 +0300
+        time.utc # Wed, 22 Aug 2012 10:34:18 +0000
+      else
+        time
+      end
+    end
+
+    def to_milliseconds(time)
+      time.to_time.to_i * MILLISECONDS_IN_SECOND
+    end
+
+    # takes two objects: Time
+    def diff_in_hours(end_time, start_time)
+      ((end_time.to_i - start_time.to_i) / SECONDS_IN_HOUR).abs
+    end
+
+    def valid_date?(date)
+      return true if date.acts_like?(:date)
+      return false if date.blank?
+
+      # http://stackoverflow.com/a/35502357/717336
+      date_hash = Date._parse(date.to_s)
+      Date.valid_date?(date_hash[:year].to_i,
+                       date_hash[:mon].to_i,
+                       date_hash[:mday].to_i)
+    end
+  end
+end

data/lib/useful_utilities/version.rb

@@ -0,0 +1,3 @@
+module UsefulUtilities
+  VERSION = '5.4.5'.freeze
+end

data/lib/useful_utilities/yaml.rb

@@ -0,0 +1,17 @@
+# It was used in outdated rake task, but we decided to leave for the future
+module UsefulUtilities
+  module YAML
+    extend self
+
+    def rename_keys(file_path, key_map)
+      yaml_hash = ::YAML.load_file(file_path)
+      keys_to_rename = yaml_hash.keys & key_map.keys
+
+      return if keys_to_rename.empty?
+
+      keys_to_rename.each { |old_key| yaml_hash[key_map.fetch(old_key)] = yaml_hash.delete(old_key) }
+
+      File.open(file_path, 'w') { |file| ::YAML.dump(yaml_hash, file) }
+    end
+  end
+end

data/lib/useful_utilities.rb

@@ -0,0 +1,15 @@
+require 'active_support'
+
+module UsefulUtilities
+  require_relative 'useful_utilities/version'
+  require_relative 'useful_utilities/ar' if defined?(ActiveRecord)
+  require_relative 'useful_utilities/numeric'
+  require_relative 'useful_utilities/time'
+  require_relative 'useful_utilities/size'
+  require_relative 'useful_utilities/api'
+  require_relative 'useful_utilities/i18n'
+  require_relative 'useful_utilities/hash'
+  require_relative 'useful_utilities/yaml'
+  require_relative 'useful_utilities/redhat_release'
+  require_relative 'useful_utilities/centos_version'
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: useful_utilities
+version: !ruby/object:Gem::Version
+  version: 5.4.5
+platform: ruby
+authors:
+- OnApp Ltd.
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-02-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: factory_girl_rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |2
+      A bunch of useful modules to work with time/size constants/hashes
+email: onapp@onapp.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/useful_utilities.rb
+- lib/useful_utilities/api.rb
+- lib/useful_utilities/ar.rb
+- lib/useful_utilities/centos_version.rb
+- lib/useful_utilities/hash.rb
+- lib/useful_utilities/i18n.rb
+- lib/useful_utilities/numeric.rb
+- lib/useful_utilities/redhat_release.rb
+- lib/useful_utilities/size.rb
+- lib/useful_utilities/size/bit.rb
+- lib/useful_utilities/size/byte.rb
+- lib/useful_utilities/size/cdn_speed.rb
+- lib/useful_utilities/size/frequency.rb
+- lib/useful_utilities/size/percentage.rb
+- lib/useful_utilities/size/standard/binary.rb
+- lib/useful_utilities/size/standard/decimal.rb
+- lib/useful_utilities/time.rb
+- lib/useful_utilities/version.rb
+- lib/useful_utilities/yaml.rb
+homepage: https://github.com/OnApp/useful_utilities
+licenses:
+- Apache 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 4
+summary: Helpful methods for time, sizes, hashes etc.
+test_files: []