lite-ruby 1.0.1 → 1.0.2

data/lib/lite/ruby/hash.rb

@@ -2,6 +2,19 @@
 
 class Hash
 
+  class << self
+
+    def zip(keys, values)
+      keys.size.times.with_object({}) { |i, hash| hash[keys[i]] = values[i] }
+    end
+
+  end
+
+  def alias(new_key, old_key)
+    self[new_key] = self[old_key] if key?(old_key)
+    self
+  end
+
   def assert_valid_keys!(*valid_keys)
     each_key do |key|
       next if valid_keys.include?(key)
@@ -50,6 +63,31 @@ class Hash
   end
   # rubocop:enable Style/GuardClause
 
+  # rubocop:disable Metrics/MethodLength
+  def collate(*others)
+    hash = {}
+
+    each_key { |key| hash[key] = [] }
+
+    others.each do |other|
+      other.each_key { |key| hash[key] = [] }
+    end
+
+    each { |key, val| hash[key] << val }
+
+    others.each do |other|
+      other.each { |key, val| hash[key] << val }
+    end
+
+    hash.each_value(&:flatten!)
+    hash
+  end
+  # rubocop:enable Metrics/MethodLength
+
+  def collate!(other_hash)
+    replace(collate(other_hash))
+  end
+
   def collect_keys
     collect { |key, _| yield(key) }
   end
@@ -58,16 +96,41 @@ class Hash
     collect { |_, val| yield(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
+
+  def dearray_values!(idx = 0)
+    replace(dearray_values(idx))
+  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 dearray_singular_values!
+    replace(dearray_singular_values)
+  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]
+    other_hash.each_pair.with_object(self) do |(current_key, other_value), hash|
+      this_value = hash[current_key]
 
-      self[current_key] = if this_value.is_a?(Hash) && other_value.is_a?(Hash)
+      hash[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)
@@ -75,10 +138,20 @@ class Hash
                             other_value
                           end
     end
+  end
 
-    self
+  def delete_unless
+    delete_if { |key, val| !yield(key, val) }
+  end
+
+  def delete_values(*values)
+    each_key.with_object([]) do |key, array|
+      next unless values.include?(self[key])
+
+      array << key
+      delete(key)
+    end
   end
-  # rubocop:enable Metrics/MethodLength
 
   def demote(key)
     dup.demote!(key)
@@ -99,6 +172,12 @@ class Hash
     each { |key, val| self[key] = val.nil? ? value : val }
   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 except(*keys)
     dup.except!(*keys)
   end
@@ -119,6 +198,30 @@ class Hash
     inject(self) { |hash, (key, val)| hash.merge(yield(key, val)) }
   end
 
+  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 keys?(*check_keys)
+    unknown_keys = check_keys - keys
+    unknown_keys.empty?
+  end
+
+  alias has_keys? keys?
+
   def nillify
     dup.nillify!
   end
@@ -137,6 +240,13 @@ class Hash
     replace(only_fill(*keys, placeholder: placeholder))
   end
 
+  def only_keys?(*check_keys)
+    unknown_keys = keys - check_keys
+    unknown_keys.empty?
+  end
+
+  alias has_only_keys? only_keys?
+
   def pair?(key, value)
     self[key] == value
   end
@@ -277,6 +387,22 @@ class Hash
 
   alias to_o to_object
 
+  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 block_given?
+
+    replace(each_with_object({}) { |(key, val), hash| hash[yield(key)] = val })
+  end
+
+  def update_values
+    return to_enum(:update_values) unless block_given?
+
+    replace(each_with_object({}) { |(key, val), hash| hash[key] = yield(val) })
+  end
+
   def vacant?(key)
     self[key].blank?
   end

data/lib/lite/ruby/integer.rb

@@ -7,6 +7,38 @@ class Integer
     I: 1
   }.freeze
 
+  def bit(bit)
+    if bit.negative?
+      mask = (1 << ~bit)
+      self & ~mask
+    else
+      mask = (1 << bit)
+      self | mask
+    end
+  end
+
+  def bit?(bit)
+    mask = (1 << bit)
+    (self & mask) != 0
+  end
+
+  def bit_clear(bit)
+    mask = (1 << bit)
+    self & ~mask
+  end
+
+  def bitmask(mask)
+    if mask.negative?
+      self & mask
+    else
+      self | mask
+    end
+  end
+
+  def bitmask?(mask)
+    (self & mask) != 0
+  end
+
   def factorial
     return 1 if zero?
 

data/lib/lite/ruby/numeric.rb

@@ -6,6 +6,14 @@ class Numeric
     self + num
   end
 
+  def at_least(lower)
+    self >= lower ? self : lower
+  end
+
+  def at_most(upper)
+    self <= upper ? self : upper
+  end
+
   # rubocop:disable Metrics/MethodLength
   def clamp(minimum, maximum = nil)
     if minimum.is_a?(Range)
@@ -23,14 +31,43 @@ class Numeric
   end
   # rubocop:enable Metrics/MethodLength
 
+  def close?(number, epsilon = 0.01)
+    return self == number if epsilon.zero?
+
+    a = to_f
+    b = number.to_f
+
+    if a.zero? || b.zero?
+      (a - b).abs < epsilon
+    else
+      (a / b - 1).abs < epsilon
+    end
+  end
+
   def decrement(amount = 1.0)
     self - amount
   end
 
-  def distance(num)
+  def delimit(options = {})
+    delimiter = options[:delimiter] || ','
+    separator = options[:separator] || '.'
+
+    digits, decimals = to_s.split('.')
+    digits = digits.reverse.chars.each_slice(3).map(&:join).join(delimiter).reverse
+
+    return digits unless decimals
+
+    [digits, decimals].join(separator)
+  end
+
+  def delta(num)
     (self - num).abs
   end
 
+  def distance(num)
+    self - num
+  end
+
   def divide(num)
     return num if num.zero?
 
@@ -158,6 +195,12 @@ class Numeric
     self**num
   end
 
+  def range(value)
+    (self - value)..(self + value)
+  end
+
+  alias plus_minus range
+
   def root(num)
     self**(1.0 / num)
   end

data/lib/lite/ruby/open_struct.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: false
+
+require 'ostruct'
+
+class OpenStruct
+
+  def initialize(hash = nil, &block)
+    @table = if block && block.arity == 2
+               Hash.new(&block)
+             else
+               {}
+             end
+
+    if hash
+      hash.each do |key, val|
+        @table[key.to_sym] = val
+        new_ostruct_member(key)
+      end
+    end
+
+    yield self if block && block.arity == 1
+  end
+
+  def [](key)
+    key = key.to_sym unless key.is_a?(Symbol)
+    @table[key]
+  end
+
+  def []=(key, val)
+    raise TypeError, "can't modify frozen #{self.class}", caller(1) if frozen?
+
+    key = key.to_sym unless key.is_a?(Symbol)
+    @table[key] = val
+  end
+
+  def attributes
+    each_pair.with_object({}) { |(key, val), hash| hash[key] = val }
+  end
+
+  def replace(args)
+    args.each_pair { |key, val| send("#{key}=", val) }
+  end
+
+end

data/lib/lite/ruby/string.rb

@@ -33,28 +33,34 @@ class String
   }.freeze
 
   def acronym
-    gsub(/(([a-zA-Z0-9])([a-zA-Z0-9])*)./, '\\2')
+    dup.acronym!
   end
 
   def acronym!
-    replace(acronym)
+    gsub!(/(([a-zA-Z0-9])([a-zA-Z0-9])*)./, '\\2') || self
   end
 
   def any?(*keys)
     keys.any? { |key| include?(key) }
   end
 
+  def ascii_only(alt = '')
+    dup.ascii_only!(alt)
+  end
+
+  def ascii_only!(alt = '')
+    encode_only!('ASCII', alt)
+  end
+
   def at(position)
     self[position]
   end
 
   def camelize(first_letter = :upper)
-    if first_letter.to_sym != :lower
-      regex_last = Regexp.last_match(1).upcase
-      to_s.gsub(%r{\/(.?)}) { "::#{regex_last}" }.gsub(%r{^/(?:^|_)(.)}) { regex_last }
-    else
-      "#{to_s.first.chr.downcase}#{camelize(self)[1..-1]}"
-    end
+    case first_letter
+    when :upper, true then gsub(/(\A|\s)([a-z])/) { $1 + $2.upcase }
+    when :lower, false then gsub(/(\A|\s)([A-Z])/) { $1 + $2.downcase }
+    end || self
   end
 
   alias camelcase camelize
@@ -65,12 +71,17 @@ class String
 
   alias camelcase! camelize!
 
+  def capitalized?
+    capitalize == self
+  end
+
   def classify
-    to_s.sub(/.*\./, '').camelize
+    dup.classify!
   end
 
   def classify!
-    replace(classify)
+    sub!(/.*\./, '')
+    camelize!
   end
 
   def constantize
@@ -78,15 +89,15 @@ class String
   end
 
   def dasherize
-    tr(/_/, '-')
+    dup.dasherize!
   end
 
   def dasherize!
-    replace(dasherize)
+    tr!('_', '-')
   end
 
   def deconstantize
-    to_s[0, rindex('::') || 0]
+    [0, rindex('::') || 0]
   end
 
   def deconstantize!
@@ -94,7 +105,7 @@ class String
   end
 
   def demodulize
-    to_s.gsub(/^.*::/, '')
+    gsub(/^.*::/, '')
   end
 
   def demodulize!
@@ -111,6 +122,25 @@ class String
     downcase == self
   end
 
+  def each_word(&block)
+    words.each(&block)
+  end
+
+  def encode_only(encoding, alt = '')
+    dup.encode_only!(encoding, alt)
+  end
+
+  def encode_only!(encoding, alt = '')
+    encoding_options = {
+      invalid: :replace,
+      undef: :replace,
+      replace: alt,
+      UNIVERSAL_NEWLINE_DECORATOR: true
+    }
+
+    encode!(Encoding.find(encoding), encoding_options)
+  end
+
   def ellipsize(ellipsize_at, options = {})
     return self if length <= ellipsize_at
 
@@ -139,7 +169,7 @@ class String
   end
 
   def headerize
-    squish.split(' ').map(&:capitalize).join(' ')
+    squish.each_word(&:capitalize!).join(' ')
   end
 
   def headerize!
@@ -147,28 +177,28 @@ class String
   end
 
   def humanize(options = {})
-    capitalize = options[:capitalize] || true
-
-    underscore.gsub(/_id\z/, '')
-              .tr('_', ' ')
-              .squish
-              .gsub(/([a-z\d]*)/i, &:downcase)
-              .gsub(/\A\w/) { |str| capitalize ? str.upcase : str }
+    dup.humanize!(options)
   end
 
-  def humanize!(options = {})
-    replace(humanize(options))
+  def humanize!(capitalize: true)
+    underscore!
+    gsub!(/_id\z/, '')
+    tr!('_', ' ')
+    squish!
+    gsub!(/([a-z\d]*)/i, &:downcase)
+    gsub!(/\A\w/) { |str| capitalize ? str.upcase : str } || self
   end
 
-  def indent(amount, indent_string = nil, indent_empty_lines = false)
-    indent_string = indent_string || self[/^[ \t]/] || ' '
-    substitutes = indent_empty_lines ? /^/ : /^(?!$)/
-
-    gsub(substitutes, indent_string * amount)
+  def indent(amount, seperator = ' ')
+    dup.indent!(amount, seperator)
   end
 
-  def indent!(amount, indent_string = nil, indent_empty_lines = false)
-    replace(indent(amount, indent_string, indent_empty_lines))
+  def indent!(amount, seperator = ' ')
+    if amount >= 0
+      gsub!(/^/, seperator * amount)
+    else
+      gsub!(/^#{Regexp.escape(seperator)}{0,#{-amount}}/, '')
+    end
   end
 
   def index_all(pattern)
@@ -186,19 +216,18 @@ class String
   end
 
   def labelize(options = {})
-    capitalize = options[:capitalize] || true
-
-    underscore.tr('_', ' ')
-              .squish
-              .gsub(/([a-z\d]*)/i, &:downcase)
-              .gsub(/\A\w/) { |str| capitalize ? str.upcase : str }
-              .gsub(/ id\z/, ' ID')
+    dup.labelize!(options)
   end
 
   alias labelcase labelize
 
-  def labelize!(options = {})
-    replace(labelize(options))
+  def labelize!(capitalize: true)
+    underscore!
+    tr!('_', ' ')
+    squish!
+    gsub!(/([a-z\d]*)/i, &:downcase)
+    gsub!(/\A\w/) { |str| capitalize ? str.upcase : str }
+    gsub!(/ id\z/, ' ID') || self
   end
 
   alias labelcase! labelize!
@@ -213,6 +242,40 @@ class String
     end
   end
 
+  def lchomp(match)
+    dup.lchomp!(match)
+  end
+
+  def lchomp!(match)
+    return self unless index(match)
+
+    self[0...match.size] = ''
+    self
+  end
+
+  def methodize
+    dup.methodize!
+  end
+
+  def methodize!
+    gsub!(/([A-Z]+)([A-Z])/, '\1_\2')
+    gsub!(/([a-z])([A-Z])/, '\1_\2')
+    gsub!('/', '__')
+    gsub!('::', '__')
+    downcase! || self
+  end
+
+  def modulize
+    dup.modulize!
+  end
+
+  def modulize!
+    gsub!(/__(.?)/) { "::#{$1.upcase}" }
+    gsub!(%r{/(.?)}) { "::#{$1.upcase}" }
+    gsub!(/(?:_+|-+)([a-z])/) { $1.upcase }
+    gsub!(/(\A|\s)([a-z])/) { $1 + $2.upcase } || self
+  end
+
   def mixedcase?
     !upcase? && !downcase?
   end
@@ -226,15 +289,31 @@ class String
   end
 
   def parameterize(separator: '-')
-    underscore.gsub(/\s+/, separator).downcase
+    dup.parameterize!(separator: separator)
   end
 
   def parameterize!(separator: '-')
-    replace(parameterize(separator: separator))
+    underscore!
+    gsub!(/\s+/, separator)
+    downcase! || self
+  end
+
+  def pathize
+    dup.pathize!
+  end
+
+  def pathize!
+    gsub!(/([A-Z]+)([A-Z])/, '\1_\2')
+    gsub!(/([a-z])([A-Z])/, '\1_\2')
+    gsub!('__', '/')
+    gsub!('::', '/')
+    gsub!(/\s+/, '')
+    gsub!(/[?%*:|"<>.]+/, '')
+    downcase! || self
   end
 
   def pollute(delimiter = '^--^--^')
-    split('').map { |chr| "#{chr}#{delimiter}" }.join
+    chars.map { |chr| "#{chr}#{delimiter}" }.join
   end
 
   def pollute!(delimiter = '^--^--^')
@@ -249,22 +328,75 @@ class String
     replace(concat(string))
   end
 
-  def remove(*patterns)
-    patterns.each_with_object(dup) do |pat, str|
-      pat.is_a?(Range) ? str.slice!(pat) : str.gsub!(pat, '')
+  # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+  def quote(type = :double, amount = nil)
+    if type.is_a?(Integer)
+      tmp = amount
+      amount = type
+      type = tmp || :mixed
+    else
+      amount ||= 1
+    end
+
+    case type.to_s
+    when "'", 'single', 's', '1'
+      f = "'" * amount
+      b = f
+    when '"', 'double', 'd', '2'
+      f = '"' * amount
+      b = f
+    when '`', 'back', 'backtick', 'b', '-1'
+      f = '`' * amount
+      b = f
+    when "`'", 'bracket', 'sb'
+      f = '`' * amount
+      b = "'" * amount
+    when "'\"", 'mixed', 'm', 'Integer'
+      c = (amount.to_f / 2).to_i
+      f = '"' * c
+      b = f
+
+      if amount.odd?
+        f = "'" + f
+        b += "'"
+      end
+    else
+      raise ArgumentError, "Invalid quote type: #{type.inspect}"
     end
+
+    "#{f}#{self}#{b}"
+  end
+  # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+
+  def quote!(type = :double, amount = nil)
+    replace(quote(type, amount))
+  end
+
+  def remove(*patterns)
+    dup.remove!(*patterns)
   end
 
   def remove!(*patterns)
-    replace(remove(*patterns))
+    patterns.each_with_object(self) do |pat, str|
+      pat.is_a?(Range) ? str.slice!(pat) : str.gsub!(pat, '')
+    end
   end
 
   def remove_tags
-    gsub(%r{<\/?[^>]*>}, '')
+    dup.remove_tags!
   end
 
   def remove_tags!
-    replace(remove_tags)
+    gsub!(%r{<\/?[^>]*>}, '') || self
+  end
+
+  def rotate(amount = 1)
+    dup.rotate!(amount)
+  end
+
+  def rotate!(amount = 1)
+    amount += size if amount.negative?
+    slice!(amount, size - amount) + slice!(0, amount)
   end
 
   def sample(separator = ' ')
@@ -276,13 +408,13 @@ class String
   end
 
   def shift(*patterns)
-    return self[0] if patterns.empty?
-
-    patterns.each_with_object(dup) { |pat, str| str.sub!(pat, '') }
+    dup.shift!(*patterns)
   end
 
   def shift!(*patterns)
-    replace(shift(*patterns))
+    return self[0] if patterns.empty?
+
+    patterns.each_with_object(self) { |pat, str| str.sub!(pat, '') }
   end
 
   def shuffle(separator = '')
@@ -298,7 +430,7 @@ class String
            when String then keep.chars
            when Array then keep.map(&:to_s)
            when Range then keep.to_a.map(&:to_s)
-           else raise TypeError, "Invalid parameter #{keep.inspect}"
+           else raise TypeError, "Invalid parameter: #{keep.inspect}"
            end
 
     chars.keep_if { |chr| keep.include?(chr) }.join
@@ -309,23 +441,24 @@ class String
   end
 
   def slugify
-    to_s.gsub(/[^\x00-\x7F]+/, '')
-        .gsub(/[^\w_ \-]+/i, '')
-        .gsub(/[ \-]+/i, '-')
-        .gsub(/^\-|\-$/i, '')
-        .downcase
+    dup.slugify!
   end
 
   def slugify!
-    replace(slugify)
+    gsub!(/[^\x00-\x7F]+/, '')
+    gsub!(/[^\w_ \-]+/i, '')
+    gsub!(/[ \-]+/i, '-')
+    gsub!(/^\-|\-$/i, '')
+    downcase! || self
   end
 
   def squish
-    strip.gsub(/\s+/, ' ')
+    dup.squish!
   end
 
   def squish!
-    replace(squish)
+    strip!
+    gsub!(/\s+/, ' ') || self
   end
 
   def sort
@@ -337,13 +470,15 @@ class String
   end
 
   def titleize
-    underscore.humanize.gsub(/\b(?<!['’`])[a-z]/) { $&.capitalize }
+    dup.titleize!
   end
 
   alias titlecase titleize
 
   def titleize!
-    replace(titleize)
+    underscore!
+    humanize!
+    gsub!(/\b(?<!['’`])[a-z]/) { $&.capitalize } || self
   end
 
   alias titlecase! titleize!
@@ -385,23 +520,27 @@ class String
   end
 
   def underscore
-    to_s.gsub(/::/, '/')
-        .gsub(/([A-Z\d]+)([A-Z][a-z])/, "\1_\2")
-        .gsub(/([a-z\d])([A-Z])/, "\1_\2")
-        .tr('-', '_')
-        .downcase
+    dup.underscore!
   end
 
+  alias snakecase underscore
+
   def underscore!
-    replace(underscore)
+    gsub!(/::/, '/')
+    gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+    gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+    tr!('-', '_')
+    downcase! || self
   end
 
+  alias snakecase! underscore!
+
   def unpollute(delimiter = '^--^--^')
-    gsub(delimiter, '')
+    dup.unpollute!(delimiter)
   end
 
   def unpollute!(delimiter = '^--^--^')
-    replace(unpollute(delimiter))
+    gsub!(delimiter, '') || self
   end
 
   def upcase?
@@ -417,4 +556,42 @@ class String
     replace(unshift(*patterns))
   end
 
+  def unquote
+    dup.unquote!
+  end
+
+  def unquote!
+    [0, -1].each do |i|
+      case self[i, 1]
+      when "'", '"', '`' then self[i] = ''
+      end
+    end
+
+    self
+  end
+
+  def words
+    split(/\s+/)
+  end
+
+  def words_without_punctuation
+    str = dup
+    str.gsub!(%r{[.?¿¡…!,:：;—"。？！、‘“”„«»〈〉《》，/\[\]]}, ' ')
+    str.gsub!('- ', ' ')
+    str.squeeze!(' ')
+    str.strip!
+    str.words
+  end
+
+  def variablize
+    "@#{gsub(/\W/, '_')}"
+  end
+
+  def variablize!
+    replace(variablize)
+  end
+
+  alias ends_with? end_with?
+  alias starts_with? start_with?
+
 end