lite-ruby 1.0.0

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Lite
+  module Ruby
+    module DateHelper
+
+      DATE_STAMPS ||= {
+        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'
+      }.freeze
+      DATE_UNITS ||= {
+        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'
+      }.freeze
+
+      def format(string = nil)
+        string ||= default_format
+        delimiters = string.scan(/\W+/)
+        formatters = string.scan(/[a-z0-9_]+/i)
+        string = formatters.map { |key| "%#{format_for(key.to_sym)}#{delimiters.shift}" }
+        strftime(string.join)
+      end
+
+      def stamp(key = nil)
+        key = stamp_for(key&.to_sym || default_stamp)
+        strftime(key)
+      end
+
+      alias to_format stamp
+
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Lite
+  module Ruby
+    module TimeHelper
+
+      TIME_STAMPS ||= {
+        hour: '%H',
+        hour_blank: '%k',
+        hour_padded: '%H',
+        hour_12: '%I',
+        hour_12_padded: '%I',
+        hour_12_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',
+        time_12: '%I:%M %P',
+        time_12_padded: '%I:%M %P',
+        time_12_blank: '%l:%M %P',
+        time_12_tz: '%I:%M %P %z',
+        time_12_tzn: '%I:%M %P %Z',
+        daytime: '%B %-d %H:%M',
+        daytime_abbr: '%b %-d %H:%M',
+        daytime_iso: '%m-%d %H:%M',
+        daytime_12: '%B %-d %I:%M %P',
+        daytime_12_abbr: '%b %-d %I:%M %P',
+        daytime_12_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',
+        datetime_12: '%B %-d, %Y %I:%M %P',
+        datetime_12_abbr: '%b %-d, %Y %I:%M %P',
+        datetime_12_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',
+        datetime_12_tzn: '%B %-d, %Y %I:%M %P %Z',
+        datetime_12_abbr_tzn: '%b %-d, %Y %I:%M %P %Z',
+        datetime_12_iso_tzn: '%Y-%m-%d %I:%M %P %z'
+      }.freeze
+      TIME_UNITS = {
+        h: 'H',
+        hour: 'H',
+        hour_padded: 'H',
+        hh: 'k',
+        HOUR: 'k',
+        hour_blank: 'k',
+        hhh: 'I',
+        hour_12: 'I',
+        hour_12_padded: 'I',
+        hhhh: 'l',
+        HOUR_12: 'l',
+        hour_12_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'
+      }.freeze
+
+    end
+  end
+end

data/lib/lite/ruby/integer.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+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
+
+  def factorial
+    return 1 if zero?
+
+    2.upto(self).inject(1) { |acc, i| acc * i }
+  end
+
+  def factors
+    limit = Math.sqrt(self).floor
+
+    (1..limit).each_with_object([]) do |i, array|
+      next unless (self % i).zero?
+
+      sq = (self / i)
+      array.push(i)
+      array.push(sq) if sq != i
+    end
+  end
+
+  def of(&block)
+    Array.new(self, &block)
+  end
+
+  def roman_numeral
+    return '' if zero?
+    return "-#{(-self).roman_numeral}" if negative?
+
+    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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+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?
+
+    eval(val)
+  end
+  # rubocop:enable Lint/RescueException, Security/Eval
+
+  private
+
+  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/numeric.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+class Numeric
+
+  def add(num)
+    self + num
+  end
+
+  # rubocop:disable Metrics/MethodLength
+  def clamp(minimum, maximum = nil)
+    if minimum.is_a?(Range)
+      maximum = minimum.max
+      minimum = minimum.min
+    end
+
+    if minimum > self
+      minimum
+    elsif maximum < self
+      maximum
+    else
+      self
+    end
+  end
+  # rubocop:enable Metrics/MethodLength
+
+  def decrement(amount = 1.0)
+    self - amount
+  end
+
+  def distance(num)
+    (self - num).abs
+  end
+
+  def divide(num)
+    return num if num.zero?
+
+    self / num
+  end
+
+  def equal_to?(num)
+    self == num
+  end
+
+  alias eq? equal_to?
+
+  def fraction
+    (self - truncate).abs
+  end
+
+  def fraction?
+    fraction != 0.0
+  end
+
+  def greater_than?(num)
+    num < self
+  end
+
+  alias gt? greater_than?
+
+  def greater_than_or_equal_to?(num)
+    num <= self
+  end
+
+  alias gteq? greater_than_or_equal_to?
+
+  def increment(amount = 1.0)
+    self + amount
+  end
+
+  def inside?(start, finish)
+    (start < self) && (finish > self)
+  end
+
+  def less_than?(num)
+    num > self
+  end
+
+  alias lt? less_than?
+
+  def less_than_or_equal_to?(num)
+    num >= self
+  end
+
+  alias lteq? less_than_or_equal_to?
+
+  def multiply(num)
+    self * num
+  end
+
+  def multiple_of?(number)
+    return zero? if number.zero?
+
+    modulo(number).zero?
+  end
+
+  def not_equal_to?(num)
+    self != num
+  end
+
+  alias not_eq? not_equal_to?
+  alias inequal_to? not_equal_to?
+  alias ineq? not_equal_to?
+
+  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 ordinalize
+    "#{self}#{ordinal}"
+  end
+
+  def outside?(start, finish)
+    (start > self) || (finish < self)
+  end
+
+  def pad(options = {})
+    pad_number = options[:pad_number] || 0
+    precision = options[:precision] || 3
+
+    to_s.rjust(precision, pad_number.to_s)
+  end
+
+  # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+  # rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity
+  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/CyclomaticComplexity
+  # rubocop:enable Metrics/MethodLength, Metrics/PerceivedComplexity
+
+  def percentage_of(number)
+    return 0 if zero? || number.zero?
+
+    (self / number.to_f) * 100.0
+  end
+
+  def power(num)
+    self**num
+  end
+
+  def root(num)
+    self**(1.0 / num)
+  end
+
+  def subtract(num)
+    self - num
+  end
+
+  def to_currency(options = {})
+    unit = options[:unit] || '$'
+
+    "#{unit}#{pad_precision(options.only(:precision))}"
+  end
+
+  def to_nearest_value(values = [])
+    return self if values.length.zero?
+
+    value = values.first
+    difference = (self - value).abs
+
+    values.each do |val|
+      next unless (self - val).abs < difference
+
+      difference = (self - val).abs
+      value = val
+    end
+
+    value
+  end
+
+  def to_percentage(options = {})
+    unit = options[:unit] || '%'
+
+    "#{pad_precision(options.only(:precision))}#{unit}"
+  end
+
+  def within?(number, epsilon = 0.01)
+    return number == self if epsilon.zero?
+
+    alpha = to_f
+    beta = number.to_f
+
+    if alpha.zero? || beta.zero?
+      (alpha - beta).abs < epsilon
+    else
+      (alpha / beta - 1).abs < epsilon
+    end
+  end
+
+end