lite-ruby 1.3.3 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 191d0fb7e901d29b7faa905a312fee5928439267a5f30d3e729ba76c5545de98
-  data.tar.gz: 1549c4736eeed76d892858775d32cd3914c6baed19d25b0bd4becc164d9cfc60
+  metadata.gz: 29e7241b666924e764cb6109751dde2dd55b5964a1a5ee1656e20d44373ab516
+  data.tar.gz: 875f644d9a7e9bc392b093c0e9d030321e1a1d3230dbd9214f3225df4cdff613
 SHA512:
-  metadata.gz: bd7fb280764490cbfd9a581ae64d8985040bb49410169fd8b6c07e048dda78b995eb618155941f67e0ddfe32313def11ce8e3b86971f1564824d7de1c3177579
-  data.tar.gz: b1981a0e40ffcb31ad5302ace5ecc094e548415fc7e128edc873a2d7b5797450a4c7d6bdfee0e363f90041a0a362f90bb602fa2a4c1085f29700cc6a33948ff4
+  metadata.gz: 3dc8caff79b7ec516abf91f4eaad29b5377ee092d214bed010b1a56cb176abb8c040b1c79e44bf0947cdb6ab20935586378a7d9f82ea85f51ff1e4dbd561342a
+  data.tar.gz: d117f070aaefd4a835efce753781a28f330e009863a5843406430e9bc786750efa8f071f66ce189a1c79153e2a658979302844b37d15e4bd01e844b4e6d3fd4c

data/CHANGELOG.md

@@ -6,6 +6,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.0.3] - 2021-08-05
+### Changed
+- Added Numeric => `negate`
+- Added Numeric => `many?`
+- Added Numeric => `one?`
+- Added Numeric => `none?` to `zero?` alias
+- Added Numeric => `to_range`
+
+## [2.0.2] - 2021-07-22
+### Changed
+- Changed `all.rb` => `monkey_patches.rb`
+
+## [2.0.1] - 2021-07-22
+### Added
+- Added `all.rb` for monkey patching everything with one command.
+
+## [2.0.0] - 2021-07-22
+### Added
+- Added Hash => `deep_key?`
+### Changed
+- Update install generator to reflect configuration changes
+### Removed
+- Removed configuration to use explicit inclusions
+
 ## [1.3.3] - 2021-07-21
 ### Changed
 - Improved generator support

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    lite-ruby (1.3.3)
+    lite-ruby (2.0.3)
 
 GEM
   remote: https://rubygems.org/
@@ -40,14 +40,14 @@ GEM
       railties (>= 3.0.0)
     i18n (1.8.10)
       concurrent-ruby (~> 1.0)
-    loofah (2.10.0)
+    loofah (2.11.0)
       crass (~> 1.0.2)
       nokogiri (>= 1.5.9)
     method_source (1.0.0)
-    mini_portile2 (2.5.3)
+    mini_portile2 (2.6.1)
     minitest (5.14.4)
-    nokogiri (1.11.7)
-      mini_portile2 (~> 2.5.0)
+    nokogiri (1.12.2)
+      mini_portile2 (~> 2.6.1)
       racc (~> 1.4)
     parallel (1.20.1)
     parser (3.0.2.0)
@@ -84,13 +84,13 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.10.0)
     rspec-support (3.10.2)
-    rubocop (1.18.3)
+    rubocop (1.18.4)
       parallel (~> 1.10)
       parser (>= 3.0.0.0)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml
-      rubocop-ast (>= 1.7.0, < 2.0)
+      rubocop-ast (>= 1.8.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 3.0)
     rubocop-ast (1.8.0)
@@ -104,7 +104,7 @@ GEM
       rubocop (~> 1.0)
       rubocop-ast (>= 1.1.0)
     ruby-progressbar (1.11.0)
-    ruby_parser (3.16.0)
+    ruby_parser (3.17.0)
       sexp_processor (~> 4.15, >= 4.15.1)
     sexp_processor (4.15.3)
     thor (1.1.0)

data/README.md

@@ -33,16 +33,36 @@ Or install it yourself as:
 
 ## Configurations
 
+Any and all monkey patches must be explicitly included anywhere you want to use it.
+
+To globally use the monkey patches, just create an initializer requiring them.
+
 `rails g lite:ruby:install` will generate the following file:
 `../config/initalizers/lite_ruby.rb`
 
+They can be disabled by commenting any of them out.
+
 ```ruby
-Lite::Ruby.configure do |config|
-  config.monkey_patches = %w[
-    array boolean date enumerable hash integer kernel numeric object open_struct range string
-    struct time
-  ]
-end
+# frozen_string_literal: true
+
+require 'lite/ruby/monkey_patches'
+
+# - or -
+
+# 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'
 ```
 
 ## Extensions

data/docs/HASH.md

@@ -160,6 +160,19 @@ h2 = { a: false, b: { x: [3, 4, 5] } }
 h1.deep_merge(h2) #=> { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }
 ```
 
+`deep_key`
+------
+Returns if a set of nested keys exists.
+
+```ruby
+h1 = { a: { c: { d: 2 } }, b: 1 }
+
+h1.deep_key?(:a)         #=> true
+h1.deep_key?(:a, :c, :d) #=> true
+h1.deep_key?(:x)         #=> false
+h1.deep_key?(:a, :c, :x) #=> false
+```
+
 `delete_unless`
 ------
 Inverse of `delete_if`.

data/docs/NUMERIC.md

@@ -149,6 +149,15 @@ Returns if self is less than or equal to n.
 3.less_than_or_equal_to?(4) #=> true
 ```
 
+`many?`
+------
+Returns if a number is greater than one.
+
+```ruby
+4.many? #=> true
+1.many? #=> false
+```
+
 `markdown_percentage`
 ------
 Returns the difference of a number and a percentage of it.
@@ -182,6 +191,24 @@ Returns if a number can be evenly divided by n.
 7.multiple_of?(3) #=> false
 ```
 
+`negate`
+------
+Returns the negation of a number.
+
+```ruby
+4.negate  #=> -4
+-2.negate #=> 2
+```
+
+`none?` aka `zero?`
+------
+Returns if a number is to zero.
+
+```ruby
+0.none? #=> true
+1.none? #=> false
+```
+
 `not_equal_to?` aka `not_eq?` aka `inequal_to?` aka `ineq?`
 ------
 Returns if not matching equality using `!=`.
@@ -191,6 +218,16 @@ Returns if not matching equality using `!=`.
 3.not_equal_to?(3) #=> false
 ```
 
+`one?`
+------
+Returns if a number is equal to one.
+
+```ruby
+1.one?   #=> true
+1.0.one? #=> true
+4.one?   #=> false
+```
+
 `ordinal`
 ------
 Returns the suffix that should be added to a number to denote the position in an ordered sequence such as 1st, 2nd, 3rd, 4th.
@@ -317,15 +354,24 @@ unit | string | '$'
 3.to_currency(unit: '@') #=> '@3.00'
 ```
 
-`to_nearest value`
+`to_nearest_value`
 ------
-return the value in values that is nearest to the number.
+Returns the value in values that is nearest to the number.
 
 ```ruby
 5.to_nearest_value([1, 3, 6, 9])           #=> 6
 3.5.to_nearest_value([3.0, 3.3, 3.6, 3.9]) #=> 3.6
 ```
 
+`to_range`
+------
+Returns a range of a number from negative to positive.
+
+```ruby
+5.to_range  #=> -5..5
+-5.to_range #=> -5..5
+```
+
 `to_percentage`
 ------
 Converts a number to percentage string.

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

@@ -1,8 +1,20 @@
 # frozen_string_literal: true
 
-Lite::Ruby.configure do |config|
-  config.monkey_patches = %w[
-    array boolean date enumerable hash integer kernel numeric object open_struct range string
-    struct time
-  ]
-end
+require 'lite/ruby/monkey_patches'
+
+# - or -
+
+# 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.rb

@@ -2,17 +2,4 @@
 
 require 'generators/lite/ruby/install_generator' if defined?(Rails::Generators)
 
-%w[version configuration].each do |filename|
-  require "lite/ruby/#{filename}"
-end
-
-%w[date time].each do |filename|
-  require "lite/ruby/helpers/#{filename}_helper"
-end
-
-%w[
-  array boolean date enumerable hash integer kernel numeric object open_struct range string
-  struct time
-].each do |filename|
-  require "lite/ruby/#{filename}"
-end
+require 'lite/ruby/version'

data/lib/lite/ruby/array.rb

@@ -1,301 +1,299 @@
 # frozen_string_literal: true
 
-if Lite::Ruby.configuration.monkey_patches.include?('array')
-  class Array
+class Array
 
-    def assert_min_values!(*valid_values)
-      return self if empty?
+  def assert_min_values!(*valid_values)
+    return self if empty?
 
-      valid_values.each do |value|
-        next if include?(value)
+    valid_values.each do |value|
+      next if include?(value)
 
-        raise ArgumentError,
-              "Missing value: #{value.inspect}. " \
-              "Minimum values are: #{valid_values.map(&:inspect).join(', ')}"
-      end
-
-      self
+      raise ArgumentError,
+            "Missing value: #{value.inspect}. " \
+            "Minimum values are: #{valid_values.map(&:inspect).join(', ')}"
     end
 
-    def assert_all_min_values!(*valid_values)
-      return assert_min_values!(*valid_values) unless empty?
+    self
+  end
 
-      raise ArgumentError, 'An empty array is not allowed'
-    end
+  def assert_all_min_values!(*valid_values)
+    return assert_min_values!(*valid_values) unless empty?
 
-    def assert_valid_values!(*valid_values)
-      each do |value|
-        next if valid_values.include?(value)
+    raise ArgumentError, 'An empty array is not allowed'
+  end
 
-        raise ArgumentError,
-              "Invalid value: #{value.inspect}. " \
-              "Allowed values are: #{valid_values.map(&:inspect).join(', ')}"
-      end
+  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?
+  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 assert_value_presence!
-      each do |value|
-        next if value.respond_to?(:present?) ? value.present? : value
+  def assert_value_presence!
+    each do |value|
+      next if value.respond_to?(:present?) ? value.present? : value
 
-        raise ArgumentError, "A #{value.inspect} value is not allowed"
-      end
+      raise ArgumentError, "A #{value.inspect} value is not allowed"
     end
+  end
 
-    def assert_all_value_presence!
-      return assert_value_presence! unless empty?
+  def assert_all_value_presence!
+    return assert_value_presence! 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 all_after(value)
-      return unless include?(value)
+  def all_after(value)
+    return unless include?(value)
 
-      i = index(value)
-      return if i == (size - 1)
+    i = index(value)
+    return if i == (size - 1)
 
-      self[(i + 1)..-1]
-    end
+    self[(i + 1)..-1]
+  end
 
-    def all_before(value)
-      return unless include?(value)
+  def all_before(value)
+    return unless include?(value)
 
-      i = index(value)
-      return if i.zero?
+    i = index(value)
+    return if i.zero?
 
-      self[0..(i - 1)]
-    end
+    self[0..(i - 1)]
+  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/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
+  # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
+  # rubocop:disable 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
-        if args[0].is_a?(Integer)
-          arg = args.shift
-          self[arg] = [] unless self[arg]
-          self[arg].bury(*args)
-        else
-          self << {}.bury(*args)
-        end
+        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
-
-      self
-    end
-    # rubocop:enable Metrics/PerceivedComplexity, Style/GuardClause, Style/IfInsideElse
-    # rubocop:enable Metrics/AbcSize, Metrics/BlockNesting, Metrics/MethodLength
-
-    def contains_all?(other)
-      (other & self) == self
     end
 
-    def contains_any?(other)
-      !contains_none?(other)
-    end
+    self
+  end
+  # rubocop:enable Style/GuardClause, Style/IfInsideElse
+  # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
 
-    def contains_none?(other)
-      (other & self).empty?
-    end
+  def contains_all?(other)
+    (other & self) == self
+  end
 
-    def delete_first
-      self[1..-1]
-    end
+  def contains_any?(other)
+    !contains_none?(other)
+  end
 
-    def delete_first!
-      replace(delete_first)
-    end
+  def contains_none?(other)
+    (other & self).empty?
+  end
 
-    def delete_last
-      self[0...-1]
-    end
+  def delete_first
+    self[1..-1]
+  end
 
-    def delete_last!
-      replace(delete_last)
-    end
+  def delete_first!
+    replace(delete_first)
+  end
 
-    def delete_values(*args)
-      args.each_with_object([]) { |val, array| array << delete(val) }
-    end
+  def delete_last
+    self[0...-1]
+  end
 
-    def demote(value)
-      sort_by { |val| val == value ? 0 : -1 }
-    end
+  def delete_last!
+    replace(delete_last)
+  end
 
-    def demote!(value)
-      replace(demote(value))
-    end
+  def delete_values(*args)
+    args.each_with_object([]) { |val, array| array << delete(val) }
+  end
 
-    def denillify(identity = 0)
-      map { |val| val || identity }
-    end
+  def demote(value)
+    sort_by { |val| val == value ? 0 : -1 }
+  end
 
-    def denillify!(identity = 0)
-      replace(denillify(identity))
-    end
+  def demote!(value)
+    replace(demote(value))
+  end
 
-    def divergence(other)
-      (self - other) | (other - self)
-    end
+  def denillify(identity = 0)
+    map { |val| val || identity }
+  end
 
-    def duplicates(minimum = 2)
-      hash = Hash.new(0)
-      each { |val| hash[val] += 1 }
-      hash.delete_if { |_, val| val < minimum }.keys
-    end
+  def denillify!(identity = 0)
+    replace(denillify(identity))
+  end
 
-    def except(*values)
-      reject { |val| values.include?(val) }
-    end
+  def divergence(other)
+    (self - other) | (other - self)
+  end
 
-    def except!(*values)
-      reject! { |val| values.include?(val) }
-      self
-    end
+  def duplicates(minimum = 2)
+    hash = Hash.new(0)
+    each { |val| hash[val] += 1 }
+    hash.delete_if { |_, val| val < minimum }.keys
+  end
 
-    def fulfill(value, amount)
-      return self if amount <= size
+  def except(*values)
+    reject { |val| values.include?(val) }
+  end
 
-      fill(value, size..(amount - 1))
-    end
+  def except!(*values)
+    reject! { |val| values.include?(val) }
+    self
+  end
 
-    def groups(number)
-      return [] if number <= 0
+  def fulfill(value, amount)
+    return self if amount <= size
 
-      num, rem = size.divmod(number)
-      collection = (0..(num - 1)).collect { |val| self[(val * number), number] }
-      return collection unless rem.positive?
+    fill(value, size..(amount - 1))
+  end
 
-      collection << self[-rem, rem]
-    end
+  def groups(number)
+    return [] if number <= 0
 
-    def indexes(value)
-      array = []
-      each_with_index { |val, i| array << i if value == val }
-      array
-    end
+    num, rem = size.divmod(number)
+    collection = (0..(num - 1)).collect { |val| self[(val * number), number] }
+    return collection unless rem.positive?
 
-    def match(value)
-      find { |val| value == val }
-    end
+    collection << self[-rem, rem]
+  end
 
-    def merge(*values)
-      dup.merge!(*values)
-    end
+  def indexes(value)
+    array = []
+    each_with_index { |val, i| array << i if value == val }
+    array
+  end
 
-    def merge!(*values)
-      values.each_with_object(self) { |val, arr| arr.concat(val) }
-    end
+  def match(value)
+    find { |val| value == val }
+  end
 
-    def nillify
-      map { |val| !val.nil? && (val.try(:blank?) || val.try(:to_s).blank?) ? nil : val }
-    end
+  def merge(*values)
+    dup.merge!(*values)
+  end
 
-    def nillify!
-      replace(nillify)
-    end
+  def merge!(*values)
+    values.each_with_object(self) { |val, arr| arr.concat(val) }
+  end
 
-    def only(*values)
-      select { |val| values.include?(val) }
-    end
+  def nillify
+    map { |val| !val.nil? && (val.try(:blank?) || val.try(:to_s).blank?) ? nil : val }
+  end
 
-    def only!(*values)
-      select! { |val| values.include?(val) }
-      self
-    end
+  def nillify!
+    replace(nillify)
+  end
 
-    def position(value)
-      idx = index(value)
-      return idx if idx.nil?
+  def only(*values)
+    select { |val| values.include?(val) }
+  end
 
-      idx + 1
-    end
+  def only!(*values)
+    select! { |val| values.include?(val) }
+    self
+  end
 
-    def positions(value)
-      indexes(value).map { |val| val + 1 }
-    end
+  def position(value)
+    idx = index(value)
+    return idx if idx.nil?
 
-    def probability
-      hash = Hash.new(0.0)
-      differ = 0.0
+    idx + 1
+  end
 
-      each do |val|
-        hash[val] += 1.0
-        differ += 1.0
-      end
+  def positions(value)
+    indexes(value).map { |val| val + 1 }
+  end
 
-      hash.each_key { |val| hash[val] /= differ }
-      hash
-    end
+  def probability
+    hash = Hash.new(0.0)
+    differ = 0.0
 
-    def promote(value)
-      sort_by { |val| val == value ? -1 : 0 }
+    each do |val|
+      hash[val] += 1.0
+      differ += 1.0
     end
 
-    def promote!(value)
-      sort_by! { |val| val == value ? -1 : 0 }
-    end
+    hash.each_key { |val| hash[val] /= differ }
+    hash
+  end
 
-    def rand_sample(max = nil)
-      amount = rand(1..(max || size))
-      sample(amount)
-    end
+  def promote(value)
+    sort_by { |val| val == value ? -1 : 0 }
+  end
 
-    def rposition(value)
-      idx = rindex(value)
-      return idx if idx.nil?
+  def promote!(value)
+    sort_by! { |val| val == value ? -1 : 0 }
+  end
 
-      idx + 1
-    end
+  def rand_sample(max = nil)
+    amount = rand(1..(max || size))
+    sample(amount)
+  end
 
-    def sample!
-      delete_at(Random.rand(size - 1))
-    end
+  def rposition(value)
+    idx = rindex(value)
+    return idx if idx.nil?
 
-    def strip
-      reject(&:blank?)
-    end
+    idx + 1
+  end
 
-    def strip!
-      reject!(&:blank?)
-      self
-    end
+  def sample!
+    delete_at(Random.rand(size - 1))
+  end
 
-    def swap(from, to)
-      self[from], self[to] = self[to], self[from]
-      self
-    end
+  def strip
+    reject(&:blank?)
+  end
 
-    alias indices indexes
-    alias reject_values except
-    alias reject_values! except!
-    alias select_values only
-    alias select_values! only!
+  def strip!
+    reject!(&:blank?)
+    self
+  end
 
+  def swap(from, to)
+    self[from], self[to] = self[to], self[from]
+    self
   end
 
-  require 'lite/ruby/safe/array' unless defined?(ActiveSupport)
+  alias indices indexes
+  alias reject_values except
+  alias reject_values! except!
+  alias select_values only
+  alias select_values! only!
+
 end
+
+require 'lite/ruby/safe/array' unless defined?(ActiveSupport)