lite-ruby 1.3.3 → 2.0.3

data/lib/lite/ruby/helpers/date_time_helper.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Lite
+  module Ruby
+    module DateTimeHelper
+
+      def format(string = nil)
+        string ||= self.class::DEFAULT_UNIT
+        delimiters = string.scan(/\W+/)
+        formatters = string.scan(/[a-z0-9_]+/i)
+        string = formatters.map { |key| "%#{self.class::UNITS[key.to_s]}#{delimiters.shift}" }
+        strftime(string.join)
+      end
+
+      def stamp(key = nil)
+        key = key.nil? ? self.class::DEFAULT_STAMP : key.to_s
+        strftime(self.class::STAMPS[key])
+      end
+
+      alias to_format stamp
+
+    end
+  end
+end

data/lib/lite/ruby/integer.rb

@@ -1,85 +1,84 @@
 # frozen_string_literal: true
 
-if Lite::Ruby.configuration.monkey_patches.include?('integer')
-  class Integer
-
-    ROMAN_NUMERALS = {
-      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
-    }.freeze
-
-    SQL_SMALLINT = 32_767
-    SQL_INTEGER = 2_147_483_647
-    SQL_BIGINT = 9_223_372_036_854_775_807
-
-    def bit(bit)
-      if bit.negative?
-        mask = (1 << ~bit)
-        self & ~mask
-      else
-        mask = (1 << bit)
-        self | mask
-      end
-    end
+require 'yaml' unless defined?(YAML)
 
-    def bit?(bit)
-      mask = (1 << bit)
-      (self & mask) != 0
-    end
+class Integer
 
-    def bit_clear(bit)
-      mask = (1 << bit)
-      self & ~mask
-    end
+  ROMAN_NUMERALS = YAML.load_file(
+    File.expand_path('formats/integer_roman_numerals.yml', File.dirname(__FILE__))
+  ).freeze
 
-    def bitmask(mask)
-      if mask.negative?
-        self & mask
-      else
-        self | mask
-      end
-    end
+  SQL_SMALLINT = 32_767
+  SQL_INTEGER = 2_147_483_647
+  SQL_BIGINT = 9_223_372_036_854_775_807
 
-    def bitmask?(mask)
-      (self & mask) != 0
+  def bit(bit)
+    if bit.negative?
+      mask = (1 << ~bit)
+      self & ~mask
+    else
+      mask = (1 << bit)
+      self | mask
     end
+  end
 
-    def combinatorial(num)
-      (0...num).inject(1) { |acc, i| (acc * (self - i)) / (i + 1) }
-    end
+  def bit?(bit)
+    mask = (1 << bit)
+    (self & mask) != 0
+  end
+
+  def bit_clear(bit)
+    mask = (1 << bit)
+    self & ~mask
+  end
 
-    def factorial
-      (1..self).inject { |acc, i| acc * i } || 0
+  def bitmask(mask)
+    if mask.negative?
+      self & mask
+    else
+      self | mask
     end
+  end
 
-    def factors
-      limit = Math.sqrt(self).floor
+  def bitmask?(mask)
+    (self & mask) != 0
+  end
 
-      (1..limit).each_with_object([]) do |i, array|
-        next unless (self % i).zero?
+  def combinatorial(num)
+    (0...num).inject(1) { |acc, i| (acc * (self - i)) / (i + 1) }
+  end
 
-        sq = (self / i)
-        array.push(i)
-        array.push(sq) if sq != i
-      end
-    end
+  def factorial
+    (1..self).inject { |acc, i| acc * i } || 0
+  end
 
-    def of(&block)
-      Array.new(self, &block)
-    end
+  def factors
+    limit = Math.sqrt(self).floor
 
-    def roman_numeral
-      return '' if zero?
-      return "-#{(-self).roman_numeral}" if negative?
+    (1..limit).each_with_object([]) do |i, array|
+      next unless (self % i).zero?
 
-      ROMAN_NUMERALS.each { |key, val| break "#{key}#{(self - val).roman_numeral}" if val <= self }
+      sq = (self / i)
+      array.push(i)
+      array.push(sq) if sq != i
     end
+  end
 
-    def to_time
-      Time.at(self)
-    end
+  def of(&block)
+    Array.new(self, &block)
+  end
+
+  def roman_numeral
+    return '' if zero?
+    return "-#{(-self).roman_numeral}" if negative?
 
-    alias to_t to_time unless defined?(to_t)
+    ROMAN_NUMERALS.each { |key, val| break "#{key}#{(self - val).roman_numeral}" if val <= self }
+  end
 
+  def to_time
+    Time.at(self)
   end
+
+  alias to_t to_time unless defined?(to_t)
+
 end

data/lib/lite/ruby/kernel.rb

@@ -1,31 +1,29 @@
 # frozen_string_literal: true
 
-if Lite::Ruby.configuration.monkey_patches.include?('kernel')
-  module Kernel
+module Kernel
 
-    # rubocop:disable Lint/RescueException, Security/Eval
-    def safe_eval
-      eval(self)
-    rescue Exception
-      self
-    end
-
-    def try_eval
-      val = /\[\d*,?\d*,?\d*\]/.match(to_s).to_s
-      return val if val.nil?
+  # rubocop:disable Lint/RescueException, Security/Eval
+  def safe_eval
+    eval(self)
+  rescue Exception
+    self
+  end
 
-      eval(val)
-    end
-    # rubocop:enable Lint/RescueException, Security/Eval
+  def try_eval
+    val = /\[\d*,?\d*,?\d*\]/.match(to_s).to_s
+    return val if val.nil?
 
-    private
+    eval(val)
+  end
+  # rubocop:enable Lint/RescueException, Security/Eval
 
-    def caller_name(depth = 0)
-      val = caller[depth][/`([^']*)'/, 1]
-      return val if depth.zero? || !val.include?('<top (required)>')
+  private
 
-      caller[depth - 1][/`([^']*)'/, 1]
-    end
+  def caller_name(depth = 0)
+    val = caller[depth][/`([^']*)'/, 1]
+    return val if depth.zero? || !val.include?('<top (required)>')
 
+    caller[depth - 1][/`([^']*)'/, 1]
   end
+
 end

data/lib/lite/ruby/monkey_patches.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'lite/ruby/array'
+require 'lite/ruby/boolean'
+require 'lite/ruby/date'
+require 'lite/ruby/enumerable'
+require 'lite/ruby/hash'
+require 'lite/ruby/integer'
+require 'lite/ruby/kernel'
+require 'lite/ruby/numeric'
+require 'lite/ruby/object'
+require 'lite/ruby/open_struct'
+require 'lite/ruby/range'
+require 'lite/ruby/string'
+require 'lite/ruby/struct'
+require 'lite/ruby/time'

data/lib/lite/ruby/numeric.rb

@@ -1,244 +1,259 @@
 # frozen_string_literal: true
 
-if Lite::Ruby.configuration.monkey_patches.include?('numeric')
-  class Numeric
+class Numeric
 
-    def add(num)
-      self + num
-    end
+  def add(num)
+    self + num
+  end
 
-    def at_least(lower)
-      self >= lower ? self : lower
-    end
+  def at_least(lower)
+    self >= lower ? self : lower
+  end
 
-    def at_most(upper)
-      self <= upper ? self : upper
-    end
+  def at_most(upper)
+    self <= upper ? self : upper
+  end
 
-    def close?(number, epsilon = 0.01)
-      return self == number if epsilon.zero?
+  def close?(number, epsilon = 0.01)
+    return self == number if epsilon.zero?
 
-      a = to_f
-      b = number.to_f
+    a = to_f
+    b = number.to_f
 
-      if a.zero? || b.zero?
-        (a - b).abs < epsilon
-      else
-        (a / b - 1).abs < epsilon
-      end
+    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 decrement(amount = 1.0)
+    self - amount
+  end
 
-    def delimit(options = {})
-      delimiter = options[:delimiter] || ','
-      separator = options[:separator] || '.'
+  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
+    digits, decimals = to_s.split('.')
+    digits = digits.reverse.chars.each_slice(3).map(&:join).join(delimiter).reverse
 
-      return digits unless decimals
+    return digits unless decimals
 
-      [digits, decimals].join(separator)
-    end
+    [digits, decimals].join(separator)
+  end
 
-    def delta(num)
-      (self - num).abs
-    end
+  def delta(num)
+    (self - num).abs
+  end
 
-    def distance(num)
-      self - num
-    end
+  def distance(num)
+    self - num
+  end
 
-    def divide(num)
-      return num if num.zero?
+  def divide(num)
+    return num if num.zero?
 
-      self / num
-    end
+    self / num
+  end
 
-    def equal_to?(num)
-      self == num
-    end
+  def equal_to?(num)
+    self == num
+  end
 
-    def fraction
-      (self - truncate).abs
-    end
+  def fraction
+    (self - truncate).abs
+  end
 
-    def fraction?
-      fraction.to_d != 0.0.to_d
-    end
+  def fraction?
+    fraction.to_d != 0.0.to_d
+  end
 
-    def greater_than?(num)
-      num < self
-    end
+  def greater_than?(num)
+    num < self
+  end
 
-    def greater_than_or_equal_to?(num)
-      num <= self
-    end
+  def greater_than_or_equal_to?(num)
+    num <= self
+  end
 
-    def increment(amount = 1.0)
-      self + amount
-    end
+  def increment(amount = 1.0)
+    self + amount
+  end
 
-    def inside?(start, finish)
-      (start < self) && (finish > self)
-    end
+  def inside?(start, finish)
+    (start < self) && (finish > self)
+  end
 
-    def less_than?(num)
-      num > self
-    end
+  def less_than?(num)
+    num > self
+  end
 
-    def less_than_or_equal_to?(num)
-      num >= self
-    end
+  def less_than_or_equal_to?(num)
+    num >= self
+  end
 
-    def markdown_percentage(percent)
-      to_f * ((100.0 - percent.to_f) / 100.0)
-    end
+  def many?
+    to_f > 1.0
+  end
 
-    def markup_percentage(percent)
-      to_f + (to_f * (percent.to_f / 100.0))
-    end
+  def markdown_percentage(percent)
+    to_f * ((100.0 - percent.to_f) / 100.0)
+  end
 
-    def multiply(num)
-      self * num
-    end
+  def markup_percentage(percent)
+    to_f + (to_f * (percent.to_f / 100.0))
+  end
 
-    def multiple_of?(number)
-      return zero? if number.zero?
+  def multiply(num)
+    self * num
+  end
 
-      modulo(number).zero?
-    end
+  def multiple_of?(number)
+    return zero? if number.zero?
 
-    def not_equal_to?(num)
-      self != num
-    end
+    modulo(number).zero?
+  end
 
-    def ordinal
-      return 'th' if (11..13).cover?(abs % 100)
+  def negate
+    -self
+  end
 
-      case abs % 10
-      when 1 then 'st'
-      when 2 then 'nd'
-      when 3 then 'rd'
-      else 'th'
-      end
-    end
+  def not_equal_to?(num)
+    self != num
+  end
 
-    def ordinalize
-      "#{self}#{ordinal}"
-    end
+  def one?
+    to_d == 1.0.to_d
+  end
 
-    def outside?(start, finish)
-      (start > self) || (finish < self)
+  def ordinal
+    return 'th' if (11..13).cover?(abs % 100)
+
+    case abs % 10
+    when 1 then 'st'
+    when 2 then 'nd'
+    when 3 then 'rd'
+    else 'th'
     end
+  end
 
-    def pad(options = {})
-      pad_number = options[:pad_number] || 0
-      precision = options[:precision] || 3
+  def ordinalize
+    "#{self}#{ordinal}"
+  end
 
-      to_s.rjust(precision, pad_number.to_s)
-    end
+  def outside?(start, finish)
+    (start > self) || (finish < self)
+  end
 
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-    def pad_precision(options = {})
-      pad_number = options[:pad_number] || 0
-      precision = options[:precision] || 2
-      separator = options[:separator] || '.'
-      string = to_s
-
-      string << separator unless string.include?(separator)
-      ljust_count = string.split(separator).first.length
-      ljust_count += (string.count(separator) + precision) if precision.positive?
-
-      if ljust_count >= string.length
-        string.ljust(ljust_count, pad_number.to_s)
-      else
-        string[0..(ljust_count - 1)]
-      end
-    end
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+  def pad(options = {})
+    pad_number = options[:pad_number] || 0
+    precision = options[:precision] || 3
 
-    def percentage_of(number)
-      return 0 if zero? || number.zero?
+    to_s.rjust(precision, pad_number.to_s)
+  end
 
-      (self / number.to_f) * 100.0
-    end
+  # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+  def pad_precision(options = {})
+    pad_number = options[:pad_number] || 0
+    precision = options[:precision] || 2
+    separator = options[:separator] || '.'
+    string = to_s
 
-    def power(num)
-      self**num
-    end
+    string << separator unless string.include?(separator)
+    ljust_count = string.split(separator).first.length
+    ljust_count += (string.count(separator) + precision) if precision.positive?
 
-    def range(value)
-      (self - value)..(self + value)
+    if ljust_count >= string.length
+      string.ljust(ljust_count, pad_number.to_s)
+    else
+      string[0..(ljust_count - 1)]
     end
+  end
+  # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
-    def root(num)
-      self**(1.0 / num)
-    end
+  def percentage_of(number)
+    return 0 if zero? || number.zero?
 
-    def round_down(num = 0)
-      int, dec = to_f.to_s.split('.')
+    (self / number.to_f) * 100.0
+  end
 
-      "#{int}.#{dec[0...num]}".to_f
-    end
+  def power(num)
+    self**num
+  end
 
-    def subtract(num)
-      self - num
-    end
+  def range(value)
+    (self - value)..(self + value)
+  end
 
-    def to_currency(options = {})
-      unit = options[:unit] || '$'
+  def root(num)
+    self**(1.0 / num)
+  end
 
-      "#{unit}#{pad_precision(options.only(:precision))}"
-    end
+  def round_down(num = 0)
+    int, dec = to_f.to_s.split('.')
 
-    def to_nearest_value(values = [])
-      return self if values.length.zero?
+    "#{int}.#{dec[0...num]}".to_f
+  end
 
-      value = values.first
-      difference = (self - value).abs
+  def subtract(num)
+    self - num
+  end
 
-      values.each do |val|
-        next unless (self - val).abs < difference
+  def to_currency(options = {})
+    unit = options[:unit] || '$'
 
-        difference = (self - val).abs
-        value = val
-      end
+    "#{unit}#{pad_precision(options.only(:precision))}"
+  end
 
-      value
-    end
+  def to_nearest_value(values = [])
+    return self if values.length.zero?
 
-    def to_percentage(options = {})
-      unit = options[:unit] || '%'
+    value = values.first
+    difference = (self - value).abs
 
-      "#{pad_precision(options.only(:precision))}#{unit}"
+    values.each do |val|
+      next unless (self - val).abs < difference
+
+      difference = (self - val).abs
+      value = val
     end
 
-    def within?(number, epsilon = 0.01)
-      return number == self if epsilon.zero?
+    value
+  end
 
-      alpha = to_f
-      beta = number.to_f
+  def to_percentage(options = {})
+    unit = options[:unit] || '%'
 
-      if alpha.zero? || beta.zero?
-        (alpha - beta).abs < epsilon
-      else
-        (alpha / beta - 1).abs < epsilon
-      end
-    end
+    "#{pad_precision(options.only(:precision))}#{unit}"
+  end
+
+  def to_range
+    negative? ? self..-self : -self..self
+  end
+
+  def within?(number, epsilon = 0.01)
+    return number == self if epsilon.zero?
 
-    alias eq? equal_to?
-    alias gt? greater_than?
-    alias gteq? greater_than_or_equal_to?
-    alias inequal_to? not_equal_to?
-    alias ineq? not_equal_to?
-    alias lt? less_than?
-    alias lteq? less_than_or_equal_to?
-    alias not_eq? not_equal_to?
-    alias plus_minus range
+    alpha = to_f
+    beta = number.to_f
 
+    if alpha.zero? || beta.zero?
+      (alpha - beta).abs < epsilon
+    else
+      (alpha / beta - 1).abs < epsilon
+    end
   end
+
+  alias eq? equal_to?
+  alias gt? greater_than?
+  alias gteq? greater_than_or_equal_to?
+  alias inequal_to? not_equal_to?
+  alias ineq? not_equal_to?
+  alias lt? less_than?
+  alias lteq? less_than_or_equal_to?
+  alias none? zero?
+  alias not_eq? not_equal_to?
+  alias plus_minus range
+
 end