lite-ruby 1.0.0

data/docs/TIME.md

@@ -0,0 +1,86 @@
+# Time
+
+`format`
+------
+Converts a `time` object to `strftime` it using a human readable string.
+
+**Note:** The following values are to be used in combination with one's available in
+[Date](https://github.com/drexed/lite-ruby/blob/master/docs/DATE.md#format) `format`.
+
+| Directive | Type | Key | `strftime` | Result |
+| --- | --- | --- | --- | --- |
+| Hour | 24h zero-padded | `h`, `hour`, `hour_padded` | %H | (00..23) |
+| Hour | 24h blank-padded | `hh`, `HOUR`, `hour_blank` | %k | ( 0..23) |
+| Hour | 12h zero-padded | `hhh`, `hour_12`, `hour_12_padded` | %I | (01..12) |
+| Hour | 12h blank-padded | `hhhh`, `HOUR_12`, `hour_12_blank` | %l | ( 1..12) |
+| Minute | Minute | `n`, `minute` | %M | (00..59) |
+| Second | Second | `s`, `second` | %S | (00..59) |
+| Meridian | Lowercase | `ampm`, `meridian` | %P | am..pm |
+| Meridian | Uppercase | `AMPM`, `MERIDIAN` | %p | AM..PM |
+| Time zone | Zone | `z`, `time_zone` | %z | +0900 |
+| Time zone | Offset | `zz`, `time_zone_offset` | %:z | +09:00 |
+| Time zone | Full-offset | `zzz`, `time_zone_offset_full` | %::z | +09:00:00 |
+| Time zone | Name | `zzzz`, `time_zone_name` | %Z | UTC |
+
+```ruby
+Time.now.format('month_name day, year hour:minute ampm') #=> 'January 09, 2014 02:31 pm'
+```
+
+`stamp` aka `to_format`
+------
+Converts a `time` object to a predefined format.
+
+**Note:** The following values are to be used in combination with one's available in
+[Date](https://github.com/drexed/lite-ruby/blob/master/docs/DATE.md#stamp-aka-to_format) `stamp`.
+
+#### Base
+
+| Directive | Type | Key | `strftime` | Result |
+| --- | --- | --- | --- | --- |
+| Hour | 24h zero-padded | `:hour`, `:hour_padded` | %H | (00..23) |
+| Hour | 24h blank-padded | `:hour_blank` | %k | ( 0..23) |
+| Hour | 12h zero-padded | `hour_12`, `:hour_12_padded` | %I | (01..12) |
+| Hour | 12h blank-padded | `:hour_12_blank` | %l | ( 1..12) |
+| Minute | Minute | `:minute` | %M | (00..59) |
+| Second | Second | `:second` | %S | (00..59) |
+| Meridian | Lowercase | `:ampm` | %P | am..pm |
+| Meridian | Uppercase | `:meridian` | %p | AM..PM |
+| Time zone | Zone | `:time_zone` | %z | +0900 |
+| Time zone | Offset | `:time_zone_offset` | %:z | +09:00 |
+| Time zone | Full-offset | `:time_zone_offset_full` | %::z | +09:00:00 |
+| Time zone | Name | `:time_zone_name` | %Z | UTC |
+
+#### Combinations
+
+| Directive | Type | Key | `strftime` | Result |
+| --- | --- | --- | --- | --- |
+| Combo | 24h time | `:time`, `:time_padded` | %H:%M | 00:31 |
+| Combo | 24h time | `:time_blank` | %k:%M %z | 0:31 |
+| Combo | 24h time | `:time_tz` | %H:%M %z | 00:31 +0000 |
+| Combo | 24h time | `:time_tzn` | %H:%M %Z | 00:31 UTC |
+| Combo | 12h time | `:time_12`, `:time_12_padded` | %I:%M %P | 07:31 |
+| Combo | 12h time | `:time_12_blank` | %l:%M %P | 7:31 |
+| Combo | 12h Time | `:time_12_tz` | %I:%M %z | 07:31 am +0000 |
+| Combo | 12h Time | `:time_12_tzn` | %I:%M %Z | 07:31 am UTC |
+| Combo | 24h daytime | `:daytime` | %B %-d %H:%M | January 9 00:31 |
+| Combo | 24h daytime | `:daytime_abbr` | %b %-d %H:%M | Jan 9 00:31 |
+| Combo | 24h daytime | `:daytime_iso` | %m-%d %H:%M | 01-09 00:31 |
+| Combo | 12h daytime | `:daytime_12` | %B %-d %H:%M | January 9 12:31 am |
+| Combo | 12h daytime | `:daytime_12_abbr` | %b %-d %H:%M | Jan 9 12:31 am |
+| Combo | 12h daytime | `:daytime_12_iso` | %m-%d %H:%M | 01-09 12:31 am |
+| Combo | 24h datetime | `:datetime` | %B %-d, %Y %H:%M | January 9, 2014 00:31 |
+| Combo | 24h datetime | `:datetime_abbr` | %b %-d, %Y %H:%M | Jan 9, 2014 00:31 |
+| Combo | 24h datetime | `:datetime_iso` | %Y-%m-%d %H:%M | 2014-01-09 00:31 |
+| Combo | 24h datetime | `:datetime_tzn` | %B %-d, %Y %H:%M %Z | January 9, 2014 00:31 UTC |
+| Combo | 24h datetime | `:datetime_abbr_tzn` | %b %-d, %Y %H:%M %Z | Jan 9, 2014 00:31 UTC |
+| Combo | 24h datetime | `:datetime_iso_tzn` | %Y-%m-%d %H:%M %z | 2014-01-09 00:31 +0000 |
+| Combo | 12h datetime | `:datetime_12` | %B %-d, %Y %H:%M | January 9, 2014 12:31 am |
+| Combo | 12h datetime | `:datetime_12_abbr` | %b %-d, %Y %H:%M | Jan 9, 2014 12:31 am |
+| Combo | 12h datetime | `:datetime_12_iso` | %Y-%m-%d %H:%M | 2014-01-09 12:31 am |
+| Combo | 12h datetime | `:datetime_12_tzn` | %B %-d, %Y %H:%M %Z | January 9, 2014 12:31 am UTC |
+| Combo | 12h datetime | `:datetime_12_abbr_tzn` | %b %-d, %Y %H:%M %Z | Jan 9, 2014 12:31 am UTC |
+| Combo | 12h datetime | `:datetime_12_iso_tzn` | %Y-%m-%d %H:%M %z | 2014-01-09 12:31 am +0000 |
+
+```ruby
+Time.now.stamp(:datetime) #=> 'January 09, 2014 02:31 pm'
+```

data/lib/generators/lite/ruby/install_generator.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+
+module Lite
+  module Ruby
+    class InstallGenerator < Rails::Generators::Base
+
+      source_root File.expand_path('../templates', __FILE__)
+
+      def copy_initializer_file
+        copy_file('install.rb', 'config/initializers/lite-ruby.rb')
+      end
+
+    end
+  end
+end

data/lib/generators/lite/ruby/templates/install.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+Lite::Ruby.configure do |config|
+  config.array = true
+  config.date = true
+  config.enumerable = true
+  config.hash = true
+  config.integer = true
+  config.kernel = true
+  config.numeric = true
+  config.object = true
+  config.range = true
+  config.string = true
+  config.time = true
+end

data/lib/lite/ruby.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'lite/ruby/version'
+require 'lite/ruby/configuration'
+
+%w[date time].each do |filename|
+  require "lite/ruby/helpers/#{filename}_helper"
+end
+
+%w[array date enumerable hash integer kernel numeric object range string time].each do |filename|
+  next unless Lite::Ruby.configuration.send(filename)
+
+  require "lite/ruby/#{filename}"
+end
+
+require 'generators/lite/ruby/install_generator'

data/lib/lite/ruby/array.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+class Array
+
+  def assert_valid_values!(*valid_values)
+    each 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 array is not allowed'
+  end
+
+  def after(value)
+    return unless include?(value)
+
+    self[(index(value) + 1) % size]
+  end
+
+  def before(value)
+    return unless include?(value)
+
+    self[(index(value) - 1) % size]
+  end
+
+  # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+  # rubocop:disable Metrics/PerceivedComplexity, Style/GuardClause, Style/IfInsideElse
+  def bury(*args)
+    if args.count < 2
+      raise ArgumentError, '2 or more arguments required'
+    elsif args.count == 2
+      if args[0].is_a?(Integer)
+        self[args[0]] = args[1]
+      else
+        self << { args[0] => args[1] }
+      end
+    else
+      if args[0].is_a?(Integer)
+        arg = args.shift
+        self[arg] = [] unless self[arg]
+        self[arg].bury(*args)
+      else
+        self << {}.bury(*args)
+      end
+    end
+
+    self
+  end
+  # rubocop:enable Metrics/PerceivedComplexity, Style/GuardClause, Style/IfInsideElse
+  # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+  def delete_first
+    self[1..-1]
+  end
+
+  def delete_first!
+    replace(delete_first)
+  end
+
+  def delete_last
+    self[0...-1]
+  end
+
+  def delete_last!
+    replace(delete_last)
+  end
+
+  def delete_values(*args)
+    args.each_with_object([]) { |val, array| array << delete(val) }
+  end
+
+  def demote(value)
+    sort_by { |val| val == value ? 0 : -1 }
+  end
+
+  def demote!(value)
+    replace(demote(value))
+  end
+
+  def denillify(identity = 0)
+    map { |val| val.nil? ? identity : val }
+  end
+
+  def denillify!(identity = 0)
+    replace(denillify(identity))
+  end
+
+  def duplicates(minimum = 2)
+    hash = Hash.new(0)
+    each { |val| hash[val] += 1 }
+    hash.delete_if { |_, val| val < minimum }.keys
+  end
+
+  def from(position)
+    self[position, size] || []
+  end
+
+  def fulfill(value, amount)
+    return self if amount <= size
+
+    fill(value, size..(amount - 1))
+  end
+
+  def groups(number)
+    return [] if number <= 0
+
+    num, rem = size.divmod(number)
+    collection = (0..(num - 1)).collect { |val| self[(val * number), number] }
+    return collection unless rem.positive?
+
+    collection << self[-rem, rem]
+  end
+
+  # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+  def in_groups(number, fill_with = nil)
+    collection_size = size
+    division = collection_size.div(number)
+    modulo = collection_size % number
+
+    collection = []
+    start = 0
+    number.times do |int|
+      mod_gt_zero = modulo.positive?
+      grouping = division + (mod_gt_zero && modulo > int ? 1 : 0)
+      collection << last_group = slice(start, grouping)
+      last_group << fill_with if (fill_with != false) && mod_gt_zero && (grouping == division)
+      start += grouping
+    end
+
+    return collection unless block_given?
+
+    collection.each { |val| yield(val) }
+  end
+  # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+
+  # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Style/GuardClause
+  def in_groups_of(number, fill_with = nil)
+    if number.to_i <= 0
+      raise ArgumentError, "Group size must be a positive integer, was #{number.inspect}"
+    elsif fill_with == false
+      collection = self
+    else
+      padding = (number - size % number) % number
+      collection = dup.concat(Array.new(padding, fill_with))
+    end
+
+    sliced_collection = collection.each_slice(number)
+    return sliced_collection.to_a unless block_given?
+
+    sliced_collection { |val| yield(val) }
+  end
+  # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Style/GuardClause
+
+  def indexes(value)
+    array = []
+    each_with_index { |val, i| array << i if value == val }
+    array
+  end
+
+  alias indices indexes
+
+  def merge(*values)
+    dup.merge!(*values)
+  end
+
+  def merge!(*values)
+    values.each_with_object(self) { |val, arr| arr.concat(val) }
+  end
+
+  def nillify
+    map { |val| !val.nil? && (val.try(:blank?) || val.try(:to_s).blank?) ? nil : val }
+  end
+
+  def nillify!
+    replace(nillify)
+  end
+
+  def position(value)
+    idx = index(value)
+    return idx if idx.nil?
+
+    idx + 1
+  end
+
+  def positions(value)
+    indexes(value).map { |val| val + 1 }
+  end
+
+  def probability
+    hash = Hash.new(0.0)
+    differ = 0.0
+
+    each do |val|
+      hash[val] += 1.0
+      differ += 1.0
+    end
+
+    hash.each_key { |val| hash[val] /= differ }
+    hash
+  end
+
+  def promote(value)
+    sort_by { |val| val == value ? -1 : 0 }
+  end
+
+  def promote!(value)
+    replace(promote(value))
+  end
+
+  def reject_values(*args)
+    reject { |val| args.include?(val) }
+  end
+
+  def rposition(value)
+    idx = rindex(value)
+    return idx if idx.nil?
+
+    idx + 1
+  end
+
+  def sample!
+    delete_at(Random.rand(size - 1))
+  end
+
+  # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+  def split(number = nil)
+    array = [[]]
+
+    if block_given?
+      each { |val| yield(val) ? (array << []) : (array .last << val) }
+    else
+      dup_arr = dup
+
+      until dup_arr.empty?
+        if (idx = dup_arr.index(number))
+          array.last << dup_arr.shift(idx)
+          dup_arr.shift
+          array << []
+        else
+          array.last << arr.shift(dup_arr.size)
+        end
+      end
+    end
+
+    array
+  end
+  # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+  def strip
+    reject(&:blank?)
+  end
+
+  def strip!
+    replace(strip)
+  end
+
+  def swap(from, to)
+    self[from], self[to] = self[to], self[from]
+    self
+  end
+
+  def to(position)
+    return first(position + 1) if position >= 0
+
+    self[0..position]
+  end
+
+  # rubocop:disable Metrics/CyclomaticComplexity
+  def to_sentence(options = {})
+    words_connector = options[:words_connector] || ', '
+    two_words_connector = options[:two_words_connector] || ' and '
+    last_word_connector = options[:last_word_connector] || ', and '
+
+    case size
+    when 0 then ''
+    when 1 then self[0].to_s.dup
+    when 2 then "#{self[0]}#{two_words_connector}#{self[1]}"
+    else "#{self[0...-1].join(words_connector)}#{last_word_connector}#{self[-1]}"
+    end
+  end
+  # rubocop:enable Metrics/CyclomaticComplexity
+
+end

data/lib/lite/ruby/configuration.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Lite
+  module Ruby
+
+    class Configuration
+
+      attr_accessor :array, :date, :enumerable, :hash, :integer, :kernel, :numeric, :object, :range,
+                    :string, :time
+
+      # rubocop:disable Metrics/MethodLength
+      def initialize
+        @array = true
+        @date = true
+        @enumerable = true
+        @hash = true
+        @integer = true
+        @kernel = true
+        @numeric = true
+        @object = true
+        @range = true
+        @string = true
+        @time = true
+      end
+      # rubocop:enable Metrics/MethodLength
+
+    end
+
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+
+    def self.configuration=(config)
+      @configuration = config
+    end
+
+    def self.configure
+      yield(configuration)
+    end
+
+  end
+end