lite-ruby 1.3.3 → 2.0.3

data/lib/lite/ruby/formats/date_stamps.yml

@@ -0,0 +1,34 @@
+weekday: '%d'
+weekday_blank: '%_d'
+weekday_padded: '%d'
+weekday_unpadded: '%-d'
+weekday_name: '%A'
+weekday_name_abbr: '%a'
+month: '%m'
+month_blank: '%_m'
+month_padded: '%m'
+month_unpadded: '%-m'
+month_name: '%B'
+month_name_abbr: '%b'
+week_iso: '%V'
+week_monday: '%W'
+week_sunday: '%U'
+year: '%Y'
+yr: '%y'
+year_abbr: '%y'
+day: '%B %-d'
+day_abbr: '%b %-d'
+day_iso: '%m-%d'
+month_year: '%m %Y'
+month_blank_year: '%_m %Y'
+month_padded_year: '%m %Y'
+month_unpadded_year: '%-m %Y'
+month_name_year: '%B %Y'
+month_name_abbr_year: '%b %Y'
+week_year_iso: '%V-%G'
+year_day: '%Y-%m-%d'
+year_month: '%Y-%m'
+year_week: '%G-%V'
+date: '%B %-d %Y'
+date_abbr: '%b %-d %Y'
+date_iso: '%Y-%m-%d'

data/lib/lite/ruby/formats/date_units.yml

@@ -0,0 +1,42 @@
+w: 'u'
+weekday: 'u'
+ww: 'w'
+weekday_offset: 'w'
+www: 'A'
+weekday_name: 'A'
+wwww: 'a'
+weekday_name_abbr: 'a'
+d: 'd'
+day: 'd'
+day_padded: 'd'
+dd: '-d'
+Day: '-d'
+day_unpadded: '-d'
+ddd: '_d'
+DAY: '_d'
+day_blank: '_d'
+dddd: 'j'
+day_of_the_year: 'j'
+m: 'm'
+month: 'm'
+month_padded: 'm'
+mm: '-m'
+Month: '-m'
+month_unpadded: '-m'
+mmm: '_m'
+MONTH: '_m'
+month_blank: '_m'
+mmmm: 'B'
+month_name: 'B'
+mmmmm: 'b'
+month_name_abbr: 'b'
+swe: 'U'
+sunday_week: 'U'
+mwe: 'W'
+monday_week: 'W'
+we: 'V'
+week: 'V'
+yy: 'y'
+yr: 'y'
+year: 'Y'
+yyyy: 'Y'

data/lib/lite/ruby/formats/integer_roman_numerals.yml

@@ -0,0 +1,13 @@
+M: 1000
+CM: 900
+D: 500
+CD: 400
+C: 100
+XC: 90
+L: 50,
+XL: 40
+X: 10
+IX: 9
+V: 5
+IV: 4
+I: 1

data/lib/lite/ruby/formats/string_transliterations.yml

@@ -0,0 +1,189 @@
+'À': 'A'
+'Á': 'A'
+'Â': 'A'
+'Ã': 'A'
+'Ä': 'A'
+'Å': 'A'
+'Æ': 'Ae'
+'Ç': 'C'
+'È': 'E'
+'É': 'E'
+'Ê': 'E'
+'Ë': 'E'
+'Ì': 'I'
+'Í': 'I'
+'Î': 'I'
+'Ï': 'I'
+'Ð': 'D'
+'Ñ': 'N'
+'Ò': 'O'
+'Ó': 'O'
+'Ô': 'O'
+'Õ': 'O'
+'Ö': 'O'
+'Ø': 'O'
+'Ù': 'U'
+'Ú': 'U'
+'Û': 'U'
+'Ü': 'U'
+'Ý': 'Y'
+'Þ': 'Th'
+'ß': 'ss'
+'à': 'a'
+'á': 'a'
+'â': 'a'
+'ã': 'a'
+'ä': 'a'
+'å': 'a'
+'æ': 'ae'
+'ç': 'c'
+'è': 'e'
+'é': 'e'
+'ê': 'e'
+'ë': 'e'
+'ì': 'i'
+'í': 'i'
+'î': 'i'
+'ï': 'i'
+'ð': 'd'
+'ñ': 'n'
+'ò': 'o'
+'ó': 'o'
+'ô': 'o'
+'õ': 'o'
+'ö': 'o'
+'ø': 'o'
+'ù': 'u'
+'ú': 'u'
+'û': 'u'
+'ü': 'u'
+'ý': 'y'
+'þ': 'th'
+'ÿ': 'y'
+'Ā': 'A'
+'ā': 'a'
+'Ă': 'A'
+'ă': 'a'
+'Ą': 'A'
+'ą': 'a'
+'Ć': 'C'
+'ć': 'c'
+'Ĉ': 'C'
+'ĉ': 'c'
+'Ċ': 'C'
+'ċ': 'c'
+'Č': 'C'
+'č': 'c'
+'Ď': 'D'
+'ď': 'd'
+'Đ': 'D'
+'đ': 'd'
+'Ē': 'E'
+'ē': 'e'
+'Ĕ': 'E'
+'ĕ': 'e'
+'Ė': 'E'
+'ė': 'e'
+'Ę': 'E'
+'ę': 'e'
+'Ě': 'E'
+'ě': 'e'
+'Ĝ': 'G'
+'ĝ': 'g'
+'Ğ': 'G'
+'ğ': 'g'
+'Ġ': 'G'
+'ġ': 'g'
+'Ģ': 'G'
+'ģ': 'g'
+'Ĥ': 'H'
+'ĥ': 'h'
+'Ħ': 'H'
+'ħ': 'h'
+'Ĩ': 'I'
+'ĩ': 'i'
+'Ī': 'I'
+'ī': 'i'
+'Ĭ': 'I'
+'ĭ': 'i'
+'Į': 'I'
+'į': 'i'
+'İ': 'I'
+'ı': 'i'
+'IJ': 'Ij'
+'ij': 'ij'
+'Ĵ': 'J'
+'ĵ': 'j'
+'Ķ': 'K'
+'ķ': 'k'
+'ĸ': 'k'
+'Ĺ': 'L'
+'ĺ': 'l'
+'Ļ': 'L'
+'ļ': 'l'
+'Ľ': 'L'
+'ľ': 'l'
+'Ŀ': 'L'
+'ŀ': 'l'
+'Ł': 'L'
+'ł': 'l'
+'Ń': 'N'
+'ń': 'n'
+'Ņ': 'N'
+'ņ': 'n'
+'Ň': 'N'
+'ň': 'n'
+'ʼn': 'n'
+'Ŋ': 'Ng'
+'ŋ': 'ng'
+'Ō': 'O'
+'ō': 'o'
+'Ŏ': 'O'
+'ŏ': 'o'
+'Ő': 'O'
+'ő': 'o'
+'Œ': 'OE'
+'œ': 'oe'
+'Ŕ': 'R'
+'ŕ': 'r'
+'Ŗ': 'R'
+'ŗ': 'r'
+'Ř': 'R'
+'ř': 'r'
+'Ś': 'S'
+'ś': 's'
+'Ŝ': 'S'
+'ŝ': 's'
+'Ş': 'S'
+'ş': 's'
+'Š': 'S'
+'š': 's'
+'Ţ': 'T'
+'ţ': 't'
+'Ť': 'T'
+'ť': 't'
+'Ŧ': 'T'
+'ŧ': 't'
+'Ũ': 'U'
+'ũ': 'u'
+'Ū': 'U'
+'ū': 'u'
+'Ŭ': 'U'
+'ŭ': 'u'
+'Ů': 'U'
+'ů': 'u'
+'Ű': 'U'
+'ű': 'u'
+'Ų': 'U'
+'ų': 'u'
+'Ŵ': 'W'
+'ŵ': 'w'
+'Ŷ': 'Y'
+'ŷ': 'y'
+'Ÿ': 'Y'
+'Ź': 'Z'
+'ź': 'z'
+'Ż': 'Z'
+'ż': 'z'
+'Ž': 'Z'
+'ž': 'z'

data/lib/lite/ruby/formats/time_stamps.yml

@@ -0,0 +1,42 @@
+hour: '%H'
+hour_blank: '%k'
+hour_padded: '%H'
+hour12: '%I'
+hour12_padded: '%I'
+hour12_blank: '%l'
+minute: '%M'
+second: '%S'
+ampm: '%P'
+meridian: '%p'
+time_zone: '%z'
+time_zone_offset: '%:z'
+time_zone_offset_full: '%::z'
+time_zone_name: '%Z'
+time: '%H:%M'
+time_blank: '%k:%M'
+time_padded: '%H:%M'
+time_tz: '%H:%M %z'
+time_tzn: '%H:%M %Z'
+time12: '%I:%M %P'
+time12_padded: '%I:%M %P'
+time12_blank: '%l:%M %P'
+time12_tz: '%I:%M %P %z'
+time12_tzn: '%I:%M %P %Z'
+daytime: '%B %-d %H:%M'
+daytime_abbr: '%b %-d %H:%M'
+daytime_iso: '%m-%d %H:%M'
+daytime12: '%B %-d %I:%M %P'
+daytime12_abbr: '%b %-d %I:%M %P'
+daytime12_iso: '%m-%d %I:%M %P'
+datetime: '%B %-d %Y %H:%M'
+datetime_abbr: '%b %-d %Y %H:%M'
+datetime_iso: '%Y-%m-%d %H:%M'
+datetime12: '%B %-d %Y %I:%M %P'
+datetime12_abbr: '%b %-d %Y %I:%M %P'
+datetime12_iso: '%Y-%m-%d %I:%M %P'
+datetime_tzn: '%B %-d %Y %H:%M %Z'
+datetime_abbr_tzn: '%b %-d %Y %H:%M %Z'
+datetime_iso_tzn: '%Y-%m-%d %H:%M %z'
+datetime12_tzn: '%B %-d %Y %I:%M %P %Z'
+datetime12_abbr_tzn: '%b %-d %Y %I:%M %P %Z'
+datetime12_iso_tzn: '%Y-%m-%d %I:%M %P %z'

data/lib/lite/ruby/formats/time_units.yml

@@ -0,0 +1,28 @@
+h: 'H'
+hour: 'H'
+hour_padded: 'H'
+hh: 'k'
+HOUR: 'k'
+hour_blank: 'k'
+hhh: 'I'
+hour12: 'I'
+hour12_padded: 'I'
+hhhh: 'l'
+HOUR12: 'l'
+hour12_blank: 'l'
+n: 'M'
+minute: 'M'
+s: 'S'
+second: 'S'
+ampm: 'P'
+meridian: 'P'
+AMPM: 'p'
+MERIDIAN: 'p'
+z: 'z'
+time_zone: 'z'
+zz: ':z'
+time_zone_offset: ':z'
+zzz: '::z'
+time_zone_offset_full: '::z'
+zzzz: 'Z'
+time_zone_name: 'Z'

data/lib/lite/ruby/hash.rb

@@ -1,408 +1,420 @@
 # frozen_string_literal: true
 
-if Lite::Ruby.configuration.monkey_patches.include?('hash')
-  class Hash
+class Hash
 
-    class << self
-
-      def zip(keys, values)
-        keys.size.times.with_object({}) { |i, hash| hash[keys[i]] = values[i] }
-      end
+  class << self
 
+    def zip(keys, values)
+      keys.size.times.with_object({}) { |i, hash| hash[keys[i]] = values[i] }
     end
 
-    def aka(new_key, old_key)
-      self[new_key] = self[old_key] if key?(old_key)
-      self
-    end
-
-    def assert_min_keys!(*valid_keys)
-      return self if empty?
-
-      valid_keys.each do |key|
-        next if key?(key)
-
-        raise ArgumentError,
-              "Missing key: #{key.inspect}. " \
-              "Minimum keys are: #{valid_keys.map(&:inspect).join(', ')}"
-      end
+  end
 
-      self
-    end
+  def aka(new_key, old_key)
+    self[new_key] = self[old_key] if key?(old_key)
+    self
+  end
 
-    def assert_all_min_keys!(*valid_keys)
-      return assert_min_keys!(*valid_keys) unless empty?
+  def assert_min_keys!(*valid_keys)
+    return self if empty?
 
-      raise ArgumentError, 'An empty hash is not allowed'
-    end
+    valid_keys.each do |key|
+      next if key?(key)
 
-    def assert_pair_presence!(*valid_keys)
-      each do |key, value|
-        if !valid_keys.include?(key)
-          raise ArgumentError,
-                "Invalid key: #{key.inspect}. " \
-                "Allowed keys are: #{valid_keys.map(&:inspect).join(', ')}"
-        elsif value.respond_to?(:blank?) ? value.blank? : !value
-          raise ArgumentError, "A #{value.inspect} value for #{key.inspect} is not allowed"
-        end
-      end
+      raise ArgumentError,
+            "Missing key: #{key.inspect}. " \
+            "Minimum keys are: #{valid_keys.map(&:inspect).join(', ')}"
     end
 
-    def assert_all_pair_presence!(*valid_keys)
-      return assert_pair_presence!(*valid_keys) unless empty?
+    self
+  end
 
-      raise ArgumentError, 'An empty hash is not allowed'
-    end
+  def assert_all_min_keys!(*valid_keys)
+    return assert_min_keys!(*valid_keys) unless empty?
 
-    def assert_valid_keys!(*valid_keys)
-      each_key do |key|
-        next if valid_keys.include?(key)
+    raise ArgumentError, 'An empty hash is not allowed'
+  end
 
+  def assert_pair_presence!(*valid_keys)
+    each do |key, value|
+      if !valid_keys.include?(key)
         raise ArgumentError,
               "Invalid key: #{key.inspect}. " \
               "Allowed keys are: #{valid_keys.map(&:inspect).join(', ')}"
+      elsif value.respond_to?(:blank?) ? value.blank? : !value
+        raise ArgumentError, "A #{value.inspect} value for #{key.inspect} is not allowed"
       end
     end
+  end
 
-    def assert_all_valid_keys!(*valid_keys)
-      return assert_valid_keys!(*valid_keys) unless empty?
+  def assert_all_pair_presence!(*valid_keys)
+    return assert_pair_presence!(*valid_keys) unless empty?
 
-      raise ArgumentError, 'An empty hash is not allowed'
-    end
+    raise ArgumentError, 'An empty hash is not allowed'
+  end
 
-    def assert_valid_values!(*valid_values)
-      each_value do |value|
-        next if valid_values.include?(value)
+  def assert_valid_keys!(*valid_keys)
+    each_key do |key|
+      next if valid_keys.include?(key)
 
-        raise ArgumentError,
-              "Invalid value: #{value.inspect}. " \
-              "Allowed values are: #{valid_values.map(&:inspect).join(', ')}"
-      end
+      raise ArgumentError,
+            "Invalid key: #{key.inspect}. " \
+            "Allowed keys are: #{valid_keys.map(&:inspect).join(', ')}"
     end
+  end
 
-    def assert_all_valid_values!(*valid_values)
-      return assert_valid_values!(*valid_values) unless empty?
+  def assert_all_valid_keys!(*valid_keys)
+    return assert_valid_keys!(*valid_keys) unless empty?
 
-      raise ArgumentError, 'An empty hash is not allowed'
-    end
+    raise ArgumentError, 'An empty hash is not allowed'
+  end
 
-    # rubocop:disable Style/GuardClause
-    def bury(*args)
-      if args.count < 2
-        raise ArgumentError, '2 or more arguments required'
-      elsif args.count == 2
-        self[args[0]] = args[1]
-      else
-        arg = args.shift
-        self[arg] = {} unless self[arg]
-        self[arg].bury(*args) unless args.empty?
-      end
+  def assert_valid_values!(*valid_values)
+    each_value do |value|
+      next if valid_values.include?(value)
 
-      self
+      raise ArgumentError,
+            "Invalid value: #{value.inspect}. " \
+            "Allowed values are: #{valid_values.map(&:inspect).join(', ')}"
     end
-    # rubocop:enable Style/GuardClause
+  end
 
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
-    def collate(*others)
-      hash = {}
+  def assert_all_valid_values!(*valid_values)
+    return assert_valid_values!(*valid_values) unless empty?
 
-      each_key { |key| hash[key] = [] }
+    raise ArgumentError, 'An empty hash is not allowed'
+  end
 
-      others.each do |other|
-        other.each_key { |key| hash[key] = [] }
-      end
+  # rubocop:disable Style/GuardClause
+  def bury(*args)
+    if args.count < 2
+      raise ArgumentError, '2 or more arguments required'
+    elsif args.count == 2
+      self[args[0]] = args[1]
+    else
+      arg = args.shift
+      self[arg] = {} unless self[arg]
+      self[arg].bury(*args) unless args.empty?
+    end
 
-      each { |key, val| hash[key] << val }
+    self
+  end
+  # rubocop:enable Style/GuardClause
 
-      others.each do |other|
-        other.each { |key, val| hash[key] << val }
-      end
+  # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+  def collate(*others)
+    hash = {}
 
-      hash.each_value(&:flatten!)
-      hash
-    end
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+    each_key { |key| hash[key] = [] }
 
-    def collate!(other_hash)
-      replace(collate(other_hash))
+    others.each do |other|
+      other.each_key { |key| hash[key] = [] }
     end
 
-    def collect_keys(&block)
-      keys.map(&block)
-    end
+    each { |key, val| hash[key] << val }
 
-    def collect_values(&block)
-      values.map(&block)
+    others.each do |other|
+      other.each { |key, val| hash[key] << val }
     end
 
-    def dearray_values(idx = 0)
-      each_with_object({}) do |(key, val), hash|
-        hash[key] = case val
-                    when Array then val[idx] || val[-1]
-                    else val
-                    end
-      end
-    end
+    hash.each_value(&:flatten!)
+    hash
+  end
+  # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
 
-    def dearray_values!(idx = 0)
-      replace(dearray_values(idx))
-    end
+  def collate!(other_hash)
+    replace(collate(other_hash))
+  end
 
-    def dearray_singular_values
-      each_with_object({}) do |(key, val), hash|
-        hash[key] = case val
-                    when Array then val.size < 2 ? val[0] : val
-                    else val
-                    end
-      end
-    end
+  def collect_keys(&block)
+    keys.map(&block)
+  end
 
-    def dearray_singular_values!
-      replace(dearray_singular_values)
-    end
+  def collect_values(&block)
+    values.map(&block)
+  end
 
-    def delete_unless
-      delete_if { |key, val| !yield(key, val) }
+  def dearray_values(idx = 0)
+    each_with_object({}) do |(key, val), hash|
+      hash[key] = case val
+                  when Array then val[idx] || val[-1]
+                  else val
+                  end
     end
+  end
 
-    def delete_values(*values)
-      each_key.with_object([]) do |key, array|
-        next unless values.include?(self[key])
+  def dearray_values!(idx = 0)
+    replace(dearray_values(idx))
+  end
 
-        array << key
-        delete(key)
-      end
+  def dearray_singular_values
+    each_with_object({}) do |(key, val), hash|
+      hash[key] = case val
+                  when Array then val.size < 2 ? val[0] : val
+                  else val
+                  end
     end
+  end
 
-    def demote(key)
-      dup.demote!(key)
-    end
+  def dearray_singular_values!
+    replace(dearray_singular_values)
+  end
 
-    def demote!(key)
-      return self unless key?(key)
+  def deep_key?(*keys)
+    last_hash = self
+    found_key = false
 
-      self[key] = delete(key)
-      self
-    end
+    keys.each do |key|
+      break found_key = false unless last_hash.key?(key)
 
-    def denillify(identity = 0)
-      dup.denillify!(identity)
+      last_hash = last_hash[key]
+      found_key = true
     end
 
-    def denillify!(identity = 0)
-      each { |key, val| self[key] = val || identity }
-    end
+    found_key
+  end
 
-    def diff(hash)
-      h1 = dup.delete_if { |k, v| hash[k] == v }
-      h2 = hash.dup.delete_if { |k, _| key?(k) }
-      h1.merge(h2)
-    end
+  def delete_unless
+    delete_if { |key, val| !yield(key, val) }
+  end
 
-    def hmap(&block)
-      dup.hmap!(&block)
-    end
+  def delete_values(*values)
+    each_key.with_object([]) do |key, array|
+      next unless values.include?(self[key])
 
-    def hmap!
-      inject(self) { |hash, (key, val)| hash.merge(yield(key, val)) }
+      array << key
+      delete(key)
     end
+  end
 
-    def insert(name, value)
-      return false if key?(name)
+  def demote(key)
+    dup.demote!(key)
+  end
 
-      store(name, value)
-      true
-    end
+  def demote!(key)
+    return self unless key?(key)
 
-    def invert
-      each_pair.with_object({}) do |(key, val), hash|
-        if val.is_a?(Array)
-          val.each { |x| hash[x] = (hash.key?(x) ? [key, hash[x]].flatten : key) }
-        else
-          hash[val] = (hash.key?(val) ? [key, hash[val]].flatten : key)
-        end
-      end
-    end
+    self[key] = delete(key)
+    self
+  end
 
-    def keys?(*check_keys)
-      unknown_keys = check_keys - keys
-      unknown_keys.empty?
-    end
+  def denillify(identity = 0)
+    dup.denillify!(identity)
+  end
 
-    def nillify
-      dup.nillify!
-    end
+  def denillify!(identity = 0)
+    each { |key, val| self[key] = val || identity }
+  end
 
-    def nillify!
-      each do |key, val|
-        next if val.nil?
+  def diff(hash)
+    h1 = dup.delete_if { |k, v| hash[k] == v }
+    h2 = hash.dup.delete_if { |k, _| key?(k) }
+    h1.merge(h2)
+  end
+
+  def hmap(&block)
+    dup.hmap!(&block)
+  end
+
+  def hmap!
+    inject(self) { |hash, (key, val)| hash.merge(yield(key, val)) }
+  end
 
-        self[key] = nil if respond_to?(:blank?) ? val.blank? : !val
+  def insert(name, value)
+    return false if key?(name)
+
+    store(name, value)
+    true
+  end
+
+  def invert
+    each_pair.with_object({}) do |(key, val), hash|
+      if val.is_a?(Array)
+        val.each { |x| hash[x] = (hash.key?(x) ? [key, hash[x]].flatten : key) }
+      else
+        hash[val] = (hash.key?(val) ? [key, hash[val]].flatten : key)
       end
     end
+  end
 
-    def only_fill(*keys, placeholder: nil)
-      keys.each_with_object({}) { |key, hash| hash[key] = key?(key) ? self[key] : placeholder }
-    end
+  def keys?(*check_keys)
+    unknown_keys = check_keys - keys
+    unknown_keys.empty?
+  end
 
-    def only_fill!(*keys, placeholder: nil)
-      replace(only_fill(*keys, placeholder: placeholder))
-    end
+  def nillify
+    dup.nillify!
+  end
 
-    def only_keys?(*check_keys)
-      unknown_keys = keys - check_keys
-      unknown_keys.empty?
-    end
+  def nillify!
+    each do |key, val|
+      next if val.nil?
 
-    def pair?(key, value)
-      self[key] == value
+      self[key] = nil if respond_to?(:blank?) ? val.blank? : !val
     end
+  end
 
-    def promote(key)
-      dup.promote!(key)
-    end
+  def only_fill(*keys, placeholder: nil)
+    keys.each_with_object({}) { |key, hash| hash[key] = key?(key) ? self[key] : placeholder }
+  end
 
-    def promote!(key)
-      return self unless key?(key)
+  def only_fill!(*keys, placeholder: nil)
+    replace(only_fill(*keys, placeholder: placeholder))
+  end
 
-      { key => delete(key) }.merge(self)
-    end
+  def only_keys?(*check_keys)
+    unknown_keys = keys - check_keys
+    unknown_keys.empty?
+  end
 
-    def rename_keys(*keys)
-      dup.rename_keys!(*keys)
-    end
+  def pair?(key, value)
+    self[key] == value
+  end
 
-    def rename_keys!(*keys)
-      keys = Hash[*keys]
-      keys.each_with_object(self) { |(key, val), hash| hash[val] = delete(key) if hash[key] }
-    end
+  def promote(key)
+    dup.promote!(key)
+  end
 
-    def sample
-      key = sample_key
-      [key, fetch(key)]
-    end
+  def promote!(key)
+    return self unless key?(key)
 
-    def sample!
-      key, value = sample
-      delete(key)
-      [key, value]
-    end
+    { key => delete(key) }.merge(self)
+  end
 
-    def sample_key
-      hash_keys = keys
-      hash_keys.at(Random.rand(hash_keys.size - 1))
-    end
+  def rename_keys(*keys)
+    dup.rename_keys!(*keys)
+  end
 
-    def sample_key!
-      key, _val = sample
-      delete(key)
-      key
-    end
+  def rename_keys!(*keys)
+    keys = Hash[*keys]
+    keys.each_with_object(self) { |(key, val), hash| hash[val] = delete(key) if hash[key] }
+  end
 
-    def sample_value
-      fetch(sample_key)
-    end
+  def sample
+    key = sample_key
+    [key, fetch(key)]
+  end
 
-    def sample_value!
-      key, value = sample
-      delete(key)
-      value
-    end
+  def sample!
+    key, value = sample
+    delete(key)
+    [key, value]
+  end
 
-    def shuffle
-      to_a.sample(size).to_h
-    end
+  def sample_key
+    hash_keys = keys
+    hash_keys.at(Random.rand(hash_keys.size - 1))
+  end
 
-    def shuffle!
-      replace(shuffle)
-    end
+  def sample_key!
+    key, _val = sample
+    delete(key)
+    key
+  end
 
-    def slice!(*keys)
-      omit = slice(*self.keys - keys)
-      hash = slice(*keys)
-      hash.default = default
-      hash.default_proc = default_proc if default_proc
-      replace(hash)
-      omit
-    end
+  def sample_value
+    fetch(sample_key)
+  end
 
-    def strip
-      reject { |_, val| respond_to?(:blank?) ? val.blank? : !val }
-    end
+  def sample_value!
+    key, value = sample
+    delete(key)
+    value
+  end
 
-    def strip!
-      reject! { |_, val| respond_to?(:blank?) ? val.blank? : !val }
-    end
+  def shuffle
+    to_a.sample(size).to_h
+  end
 
-    # rubocop:disable Metrics/MethodLength
-    def symbolize_and_underscore_keys
-      each_with_object({}) do |(key, val), hash|
-        new_key = begin
-          str = key.dup.to_s
-          str.gsub!(/::/, '/') || str
-          str.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2') || str
-          str.gsub!(/([a-z\d])([A-Z])/, '\1_\2') || str
-          str.tr!(' -', '_') || str
-          str.downcase!
-          str.to_sym
-        rescue StandardError
-          key
-        end
-
-        hash[new_key] = val
-      end
-    end
-    # rubocop:enable Metrics/MethodLength
+  def shuffle!
+    replace(shuffle)
+  end
 
-    def symbolize_and_underscore_keys!
-      replace(symbolize_and_underscore_keys)
-    end
+  def slice!(*keys)
+    omit = slice(*self.keys - keys)
+    hash = slice(*keys)
+    hash.default = default
+    hash.default_proc = default_proc if default_proc
+    replace(hash)
+    omit
+  end
 
-    def to_object
-      JSON.parse(to_json, object_class: OpenStruct)
-    end
+  def strip
+    reject { |_, val| respond_to?(:blank?) ? val.blank? : !val }
+  end
 
-    def to_open_struct(lazy: true)
-      struct = OpenStruct.new(self)
-      struct.methods(lazy)
-      struct
-    end
+  def strip!
+    reject! { |_, val| respond_to?(:blank?) ? val.blank? : !val }
+  end
 
-    def to_struct
-      struct = Struct.new(*keys)
-      struct.new(*values)
-    end
+  # rubocop:disable Metrics/MethodLength
+  def symbolize_and_underscore_keys
+    each_with_object({}) do |(key, val), hash|
+      new_key = begin
+        str = key.dup.to_s
+        str.gsub!(/::/, '/') || str
+        str.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2') || str
+        str.gsub!(/([a-z\d])([A-Z])/, '\1_\2') || str
+        str.tr!(' -', '_') || str
+        str.downcase!
+        str.to_sym
+      rescue StandardError
+        key
+      end
 
-    def update_each
-      replace(each_with_object({}) { |(key, val), hash| hash.update(yield(key, val)) })
+      hash[new_key] = val
     end
+  end
+  # rubocop:enable Metrics/MethodLength
 
-    def update_keys
-      return to_enum(:update_keys) unless defined?(yield)
+  def symbolize_and_underscore_keys!
+    replace(symbolize_and_underscore_keys)
+  end
 
-      replace(each_with_object({}) { |(key, val), hash| hash[yield(key)] = val })
-    end
+  def to_object
+    JSON.parse(to_json, object_class: OpenStruct)
+  end
 
-    def update_values
-      return to_enum(:update_values) unless defined?(yield)
+  def to_open_struct(lazy: true)
+    struct = OpenStruct.new(self)
+    struct.methods(lazy)
+    struct
+  end
 
-      replace(each_with_object({}) { |(key, val), hash| hash[key] = yield(val) })
-    end
+  def to_struct
+    struct = Struct.new(*keys)
+    struct.new(*values)
+  end
 
-    def vacant?(key)
-      value = self[key]
-      respond_to?(:blank?) ? value.blank? : !value
-    end
+  def update_each
+    replace(each_with_object({}) { |(key, val), hash| hash.update(yield(key, val)) })
+  end
+
+  def update_keys
+    return to_enum(:update_keys) unless defined?(yield)
+
+    replace(each_with_object({}) { |(key, val), hash| hash[yield(key)] = val })
+  end
 
-    alias has_keys? keys?
-    alias has_only_keys? only_keys?
-    alias map_keys collect_keys
-    alias map_values collect_values
-    alias only slice
-    alias only! slice!
-    alias to_o to_object
+  def update_values
+    return to_enum(:update_values) unless defined?(yield)
 
+    replace(each_with_object({}) { |(key, val), hash| hash[key] = yield(val) })
   end
 
-  require 'lite/ruby/safe/hash' unless defined?(ActiveSupport)
+  def vacant?(key)
+    value = self[key]
+    respond_to?(:blank?) ? value.blank? : !value
+  end
+
+  alias has_keys? keys?
+  alias has_only_keys? only_keys?
+  alias map_keys collect_keys
+  alias map_values collect_values
+  alias only slice
+  alias only! slice!
+  alias to_o to_object
+
 end
+
+require 'lite/ruby/safe/hash' unless defined?(ActiveSupport)