lite-ruby 1.0.0

data/lib/lite/ruby/date.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'date'
+
+class Date
+
+  include Lite::Ruby::DateHelper
+
+  private
+
+  def default_format
+    'year-month-day'
+  end
+
+  def default_stamp
+    :date_iso
+  end
+
+  def format_for(key)
+    DATE_UNITS[key]
+  end
+
+  def stamp_for(key)
+    DATE_STAMPS[key]
+  end
+
+end

data/lib/lite/ruby/enumerable.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Enumerable
+
+  def cluster
+    each_with_object([]) do |ele, results|
+      last_res = results.last
+
+      if last_res && (yield(ele) == yield(last_res.last))
+        last_res << ele
+      else
+        results << [ele]
+      end
+    end
+  end
+
+  def deduce(identity = 0, &block)
+    if block_given?
+      map(&block).deduce(identity)
+    else
+      inject { |key, val| key - val } || identity
+    end
+  end
+
+  def divisible(identity = 0, &block)
+    if block_given?
+      map(&block).divisible(identity)
+    else
+      inject { |key, val| key / val } || identity
+    end
+  end
+
+  def drop_last(num)
+    collection_size = to_a.size
+    return self if num > collection_size
+
+    self[0...(collection_size - num)]
+  end
+
+  def drop_last_if
+    dropping = true
+    reverse_each.with_object([]) do |val, arr|
+      next if dropping &&= yield(val)
+
+      arr.unshift(val)
+    end
+  end
+
+  def exactly?(num)
+    found_count = 0
+
+    if block_given?
+      each { |*opt| found_count += 1 if yield(*opt) }
+    else
+      each { |opt| found_count += 1 if opt }
+    end
+
+    found_count > num ? false : num == found_count
+  end
+
+  # rubocop:disable Style/CaseEquality
+  def excase?(object)
+    none? { |val| object === val }
+  end
+  # rubocop:enable Style/CaseEquality
+
+  def exclude?(object)
+    !include?(object)
+  end
+
+  def expand
+    map { |val| val.is_a?(Enumerable) ? val.expand : val }
+  end
+
+  def exponential(identity = 0, &block)
+    if block_given?
+      map(&block).exponential(identity)
+    else
+      inject { |key, val| key**val } || identity
+    end
+  end
+
+  # rubocop:disable Style/CaseEquality
+  def incase?(object)
+    any? { |val| object === val }
+  end
+  # rubocop:enable Style/CaseEquality
+
+  # rubocop:disable Metrics/MethodLength
+  def interpose(sep, &block)
+    enum = Enumerator.new do |val|
+      items = each
+
+      loop do
+        begin
+          val << items.next
+        rescue StopIteration
+          break
+        end
+
+        begin
+          items.peek
+        rescue StopIteration
+          break
+        else
+          val << sep
+        end
+      end
+    end
+
+    block ? enum.each(&block) : enum
+  end
+  # rubocop:enable Metrics/MethodLength
+
+  def many?
+    found_count = 0
+
+    if block_given?
+      any? do |val|
+        found_count += 1 if yield(val)
+        found_count > 1
+      end
+    else
+      any? { (found_count += 1) > 1 }
+    end
+  end
+
+  def multiple(identity = 0, &block)
+    if block_given?
+      map(&block).multiple(identity)
+    else
+      inject { |key, val| key * val } || identity
+    end
+  end
+
+  def occurrences
+    each_with_object(Hash.new(0)) { |key, hsh| hsh[key] += 1 }
+  end
+
+  def several?
+    found_count = 0
+
+    if block_given?
+      each { |*opt| found_count += 1 if yield(*opt) }
+    else
+      each { |opt| found_count += 1 if opt }
+    end
+
+    found_count > 1
+  end
+
+  def take_last(num)
+    collection_size = to_a.size
+    return self if num > collection_size
+
+    self[(collection_size - num)..-1]
+  end
+
+  def take_last_if
+    reverse_each.with_object([]) do |val, arr|
+      break arr unless yield(val)
+
+      arr.unshift(val)
+    end
+  end
+
+end

data/lib/lite/ruby/hash.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+class Hash
+
+  def assert_valid_keys!(*valid_keys)
+    each_key do |key|
+      next if valid_keys.include?(key)
+
+      raise ArgumentError,
+            "Invalid key: #{key.inspect}." \
+            "Allowed keys are: #{valid_keys.map(&:inspect).join(', ')}"
+    end
+  end
+
+  def assert_all_valid_keys!(*valid_keys)
+    return assert_valid_keys!(*valid_keys) unless empty?
+
+    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)
+
+      raise ArgumentError,
+            "Invalid value: #{value.inspect}." \
+            "Allowed values are: #{valid_values.map(&:inspect).join(', ')}"
+    end
+  end
+
+  def assert_all_valid_values!(*valid_values)
+    return assert_valid_values!(*valid_values) unless empty?
+
+    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
+
+    self
+  end
+  # rubocop:enable Style/GuardClause
+
+  def collect_keys
+    collect { |key, _| yield(key) }
+  end
+
+  def collect_values
+    collect { |_, val| yield(val) }
+  end
+
+  def deep_merge(other_hash, &block)
+    dup.deep_merge!(other_hash, &block)
+  end
+
+  # rubocop:disable Metrics/MethodLength
+  def deep_merge!(other_hash, &block)
+    other_hash.each_pair do |current_key, other_value|
+      this_value = self[current_key]
+
+      self[current_key] = if this_value.is_a?(Hash) && other_value.is_a?(Hash)
+                            this_value.deep_merge(other_value, yield(block))
+                          elsif block_given? && key?(current_key)
+                            yield(current_key, this_value, other_value)
+                          else
+                            other_value
+                          end
+    end
+
+    self
+  end
+  # rubocop:enable Metrics/MethodLength
+
+  def demote(key)
+    dup.demote!(key)
+  end
+
+  def demote!(key)
+    return self unless key?(key)
+
+    self[key] = delete(key)
+    self
+  end
+
+  def denillify(value = 0)
+    dup.denillify!(value)
+  end
+
+  def denillify!(value = 0)
+    each { |key, val| self[key] = val.nil? ? value : val }
+  end
+
+  def except(*keys)
+    dup.except!(*keys)
+  end
+
+  def except!(*keys)
+    keys.each_with_object(self) { |key, _| delete(key) }
+  end
+
+  def extract!(*keys)
+    keys.each_with_object(self) { |key, hash| hash[key] = delete(key) if key?(key) }
+  end
+
+  def hmap(&block)
+    dup.hmap!(&block)
+  end
+
+  def hmap!
+    inject(self) { |hash, (key, val)| hash.merge(yield(key, val)) }
+  end
+
+  def nillify
+    dup.nillify!
+  end
+
+  def nillify!
+    each do |key, val|
+      self[key] = nil if !val.nil? && (val.try(:blank?) || val.try(:to_s).blank?)
+    end
+  end
+
+  def only_fill(*keys, placeholder: nil)
+    keys.each_with_object({}) { |key, hash| hash[key] = key?(key) ? self[key] : placeholder }
+  end
+
+  def only_fill!(*keys, placeholder: nil)
+    replace(only_fill(*keys, placeholder: placeholder))
+  end
+
+  def pair?(key, value)
+    self[key] == value
+  end
+
+  def promote(key)
+    dup.promote!(key)
+  end
+
+  def promote!(key)
+    return self unless key?(key)
+
+    { key => delete(key) }.merge(self)
+  end
+
+  def rename_keys(*keys)
+    dup.rename_keys!(*keys)
+  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 reverse_merge(other_hash)
+    other_hash.merge(self)
+  end
+
+  def reverse_merge!(other_hash)
+    other_hash.merge!(self)
+  end
+
+  def sample
+    key = sample_key
+    [key, fetch(key)]
+  end
+
+  def sample!
+    key, value = sample
+    delete(key)
+    [key, value]
+  end
+
+  def sample_key
+    hash_keys = keys
+    hash_keys.at(Random.rand(hash_keys.size - 1))
+  end
+
+  def sample_key!
+    key, = sample
+    delete(key)
+    key
+  end
+
+  def sample_value
+    fetch(sample_key)
+  end
+
+  def sample_value!
+    key, value = sample
+    delete(key)
+    value
+  end
+
+  def shuffle
+    Hash[to_a.sample(size)]
+  end
+
+  def shuffle!
+    replace(shuffle)
+  end
+
+  def slice!(*keys)
+    replace(slice(*keys))
+  end
+
+  alias only slice
+  alias only! slice!
+
+  def stringify_keys
+    each_with_object({}) { |(key, val), hash| hash[key.to_s] = val }
+  end
+
+  def stringify_keys!
+    replace(stringify_keys)
+  end
+
+  def strip
+    select { |_, val| !val.blank? }
+  end
+
+  def strip!
+    reject! { |_, val| val.blank? }
+  end
+
+  def symbolize_keys
+    each_with_object({}) do |(key, val), hash|
+      new_key = begin
+                  key.to_s.to_sym
+                rescue StandardError
+                  key
+                end
+
+      hash[new_key] = val
+    end
+  end
+
+  def symbolize_keys!
+    replace(symbolize_keys)
+  end
+
+  # rubocop:disable Metrics/MethodLength
+  def symbolize_and_underscore_keys
+    each_with_object({}) do |(key, val), hash|
+      new_key = begin
+                  key.to_s
+                     .gsub(/::/, '/')
+                     .gsub(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+                     .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                     .tr(' -', '_')
+                     .downcase
+                     .to_sym
+                rescue StandardError
+                  key
+                end
+
+      hash[new_key] = val
+    end
+  end
+  # rubocop:enable Metrics/MethodLength
+
+  def symbolize_and_underscore_keys!
+    replace(symbolize_and_underscore_keys)
+  end
+
+  def to_object
+    JSON.parse(to_json, object_class: OpenStruct)
+  end
+
+  alias to_o to_object
+
+  def vacant?(key)
+    self[key].blank?
+  end
+
+end