lite-ruby 1.0.14 → 1.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4c106fb56b079e4cbec739ab066194d9bd9ad04efd4f937d1e1dc517a99c0f7
-  data.tar.gz: 256b601530f417a689026780dd0d70b6a75663fa7793733ee06ac0dbbc229ce5
+  metadata.gz: a56a9fed1ae0986131374f5cc62aeb0ff75db166a63bbb91a6530cbf15ac6ccc
+  data.tar.gz: f8f29474d5b6e38f978304278a442e96b6d1c98dd685bc234db1823c9452f67d
 SHA512:
-  metadata.gz: 19ba4210ce3f80451a59958ab7420f714104fffe6ca8af39199842dc34d696247b065380466a82e4d0c0ca3e441cdc3bb4065ba0ccc54b6a474bf9f0fd5cc5cf
-  data.tar.gz: cfd656670786c5b0f98ffbe92c484e4dd4f9fa10760e250a442bd6095a1c433641a47cebcd89dd8738b4c52916c0cd37bd12aecaa711db9ed42c536aa01d838c
+  metadata.gz: 96f161d9040d4247cc924ccdea3318412828174ba2972e3a445faa0f0cfe7cd8e3ce71870420d78dbd884aa518f3cba467ace1507bf38c65787da3793903b0b1
+  data.tar.gz: 1498b714da8ea3a2f3a8ac542cf77f42e574bd1dadbe3a066e02bbaef9d012ec7f18b55cc29ede07aee4fdf5c95a3ef559b5eea67130e7baa1378daaaac4f35f

data/CHANGELOG.md

@@ -6,7 +6,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [1.0.13] - 2019-08-17
+## [1.0.15] - 2019-08-17
+### Changed
+- Added config check for each monkey patch
+
+## [1.0.14] - 2019-08-17
 ### Changed
 - Changed how hash deep_merge works
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    lite-ruby (1.0.14)
+    lite-ruby (1.0.15)
 
 GEM
   remote: https://rubygems.org/

data/lib/lite/ruby/array.rb

@@ -1,290 +1,292 @@
 # frozen_string_literal: true
 
-class Array
+if Lite::Ruby.configuration.monkey_patches.include?('array')
+  class Array
 
-  def assert_valid_values!(*valid_values)
-    each do |value|
-      next if valid_values.include?(value)
+    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(', ')}"
+        raise ArgumentError,
+              "Invalid value: #{value.inspect}." \
+              "Allowed values are: #{valid_values.map(&:inspect).join(', ')}"
+      end
     end
-  end
 
-  def assert_all_valid_values!(*valid_values)
-    return assert_valid_values!(*valid_values) unless empty?
+    def assert_all_valid_values!(*valid_values)
+      return assert_valid_values!(*valid_values) unless empty?
 
-    raise ArgumentError, 'An empty array is not allowed'
-  end
+      raise ArgumentError, 'An empty array is not allowed'
+    end
 
-  def after(value)
-    return unless include?(value)
+    def after(value)
+      return unless include?(value)
 
-    self[(index(value) + 1) % size]
-  end
+      self[(index(value) + 1) % size]
+    end
 
-  def before(value)
-    return unless include?(value)
+    def before(value)
+      return unless include?(value)
 
-    self[(index(value) - 1) % size]
-  end
+      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)
+    # rubocop:disable Metrics/AbcSize, Metrics/BlockNesting, 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
-        self << {}.bury(*args)
+        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/BlockNesting, Metrics/MethodLength
 
-    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
-    self[1..-1]
-  end
+    def delete_first!
+      replace(delete_first)
+    end
 
-  def delete_first!
-    replace(delete_first)
-  end
+    def delete_last
+      self[0...-1]
+    end
 
-  def delete_last
-    self[0...-1]
-  end
+    def delete_last!
+      replace(delete_last)
+    end
 
-  def delete_last!
-    replace(delete_last)
-  end
+    def delete_values(*args)
+      args.each_with_object([]) { |val, array| array << delete(val) }
+    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)
-    sort_by { |val| val == value ? 0 : -1 }
-  end
+    def demote!(value)
+      replace(demote(value))
+    end
 
-  def demote!(value)
-    replace(demote(value))
-  end
+    def denillify(identity = 0)
+      map { |val| val || identity }
+    end
 
-  def denillify(identity = 0)
-    map { |val| val || identity }
-  end
+    def denillify!(identity = 0)
+      replace(denillify(identity))
+    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 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 from(position)
-    self[position, size] || []
-  end
+    def fulfill(value, amount)
+      return self if amount <= size
 
-  def fulfill(value, amount)
-    return self if amount <= size
+      fill(value, size..(amount - 1))
+    end
 
-    fill(value, size..(amount - 1))
-  end
+    def groups(number)
+      return [] if number <= 0
 
-  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?
 
-    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
 
-    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
 
-  # 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
+      return collection unless block_given?
 
-    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
+      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
 
-    return collection unless block_given?
-
-    collection.each { |val| yield(val) }
-  end
-  # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+      sliced_collection = collection.each_slice(number)
+      return sliced_collection.to_a unless block_given?
 
-  # 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))
+      sliced_collection { |val| yield(val) }
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Style/GuardClause
 
-    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
 
-  def indexes(value)
-    array = []
-    each_with_index { |val, i| array << i if value == val }
-    array
-  end
+    alias indices indexes
 
-  alias indices indexes
+    def merge(*values)
+      dup.merge!(*values)
+    end
 
-  def merge(*values)
-    dup.merge!(*values)
-  end
+    def merge!(*values)
+      values.each_with_object(self) { |val, arr| arr.concat(val) }
+    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
-    map { |val| !val.nil? && (val.try(:blank?) || val.try(:to_s).blank?) ? nil : val }
-  end
+    def nillify!
+      replace(nillify)
+    end
 
-  def nillify!
-    replace(nillify)
-  end
+    def position(value)
+      idx = index(value)
+      return idx if idx.nil?
 
-  def position(value)
-    idx = index(value)
-    return idx if idx.nil?
+      idx + 1
+    end
 
-    idx + 1
-  end
+    def positions(value)
+      indexes(value).map { |val| val + 1 }
+    end
 
-  def positions(value)
-    indexes(value).map { |val| val + 1 }
-  end
+    def probability
+      hash = Hash.new(0.0)
+      differ = 0.0
 
-  def probability
-    hash = Hash.new(0.0)
-    differ = 0.0
+      each do |val|
+        hash[val] += 1.0
+        differ += 1.0
+      end
 
-    each do |val|
-      hash[val] += 1.0
-      differ += 1.0
+      hash.each_key { |val| hash[val] /= differ }
+      hash
     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 promote(value)
+      sort_by { |val| val == value ? -1 : 0 }
+    end
 
-  def reject_values(*args)
-    reject { |val| args.include?(val) }
-  end
+    def promote!(value)
+      replace(promote(value))
+    end
 
-  def rposition(value)
-    idx = rindex(value)
-    return idx if idx.nil?
+    def reject_values(*args)
+      reject { |val| args.include?(val) }
+    end
 
-    idx + 1
-  end
+    def rposition(value)
+      idx = rindex(value)
+      return idx if idx.nil?
 
-  def sample!
-    delete_at(Random.rand(size - 1))
-  end
+      idx + 1
+    end
 
-  # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-  def split(number = nil)
-    array = [[]]
+    def sample!
+      delete_at(Random.rand(size - 1))
+    end
 
-    if block_given?
-      each { |val| yield(val) ? (array << []) : (array .last << val) }
-    else
-      dup_arr = dup
+    # rubocop:disable Metrics/AbcSize, Metrics/BlockNesting, Metrics/MethodLength
+    def split(number = nil)
+      array = [[]]
 
-      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)
+      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
-    end
 
-    array
-  end
-  # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
-
-  def strip
-    reject(&:blank?)
-  end
+      array
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/BlockNesting, Metrics/MethodLength
 
-  def strip!
-    replace(strip)
-  end
+    def strip
+      reject(&:blank?)
+    end
 
-  def swap(from, to)
-    self[from], self[to] = self[to], self[from]
-    self
-  end
+    def strip!
+      replace(strip)
+    end
 
-  def to(position)
-    return first(position + 1) if position >= 0
+    def swap(from, to)
+      self[from], self[to] = self[to], self[from]
+      self
+    end
 
-    self[0..position]
-  end
+    def to(position)
+      return first(position + 1) if position >= 0
 
-  # 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 '
+      self[0..position]
+    end
 
-    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]}"
+    # 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
-  end
-  # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/CyclomaticComplexity
 
+  end
 end

data/lib/lite/ruby/boolean.rb

@@ -1,29 +1,31 @@
 # frozen_string_literal: true
 
-class FalseClass
+if Lite::Ruby.configuration.monkey_patches.include?('boolean')
+  class FalseClass
 
-  def to_bool
-    self
-  end
+    def to_bool
+      self
+    end
+
+    alias to_b to_bool
 
-  alias to_b to_bool
+    def to_i
+      0
+    end
 
-  def to_i
-    0
   end
 
-end
+  class TrueClass
 
-class TrueClass
+    def to_bool
+      self
+    end
 
-  def to_bool
-    self
-  end
+    alias to_b to_bool
 
-  alias to_b to_bool
+    def to_i
+      1
+    end
 
-  def to_i
-    1
   end
-
 end

data/lib/lite/ruby/date.rb

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