lite-ruby 1.3.1 → 2.0.1

data/lib/lite/ruby/boolean.rb

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

data/lib/lite/ruby/date.rb

@@ -1,29 +1,22 @@
 # frozen_string_literal: true
 
-if Lite::Ruby.configuration.monkey_patches.include?('date')
-  require 'date'
+require 'date' unless defined?(Date)
+require 'yaml' unless defined?(YAML)
 
-  class Date
+require 'lite/ruby/helpers/date_time_helper' unless defined?(Lite::Ruby::DateTimeHelper)
 
-    include Lite::Ruby::DateHelper
+class Date
 
-    private
+  include Lite::Ruby::DateTimeHelper
 
-    def default_format
-      'year-month-day'
-    end
+  DEFAULT_STAMP = 'date_iso'
+  DEFAULT_UNIT = 'year-month-day'
 
-    def default_stamp
-      :date_iso
-    end
+  STAMPS = YAML.load_file(
+    File.expand_path('formats/date_stamps.yml', File.dirname(__FILE__))
+  ).freeze
+  UNITS = YAML.load_file(
+    File.expand_path('formats/date_units.yml', File.dirname(__FILE__))
+  ).freeze
 
-    def format_for(key)
-      DATE_UNITS[key]
-    end
-
-    def stamp_for(key)
-      DATE_STAMPS[key]
-    end
-
-  end
 end

data/lib/lite/ruby/enumerable.rb

@@ -1,212 +1,210 @@
 # frozen_string_literal: true
 
-if Lite::Ruby.configuration.monkey_patches.include?('enumerable')
-  module Enumerable
+module Enumerable
 
-    def cluster
-      each_with_object([]) do |ele, results|
-        last_res = results.last
+  def cluster
+    each_with_object([]) do |ele, results|
+      last_res = results.last
 
-        if last_res && (yield(ele) == yield(last_res.last))
-          last_res << ele
-        else
-          results << [ele]
-        end
-      end
-    end
-
-    def cluster_by(&block)
-      group_by(&block).sort.transpose.pop || []
-    end
-
-    def deduce(identity = 0, &block)
-      if defined?(yield)
-        map(&block).deduce(identity)
+      if last_res && (yield(ele) == yield(last_res.last))
+        last_res << ele
       else
-        inject { |acc, val| acc - val } || identity
+        results << [ele]
       end
     end
+  end
 
-    def drop_last(num)
-      collection_size = to_a.size
-      return self if num > collection_size
-
-      self[0...(collection_size - num)]
-    end
-
-    def drop_last_if
-      dropping = true
-      reverse_each.with_object([]) do |val, arr|
-        next if dropping &&= yield(val)
+  def cluster_by(&block)
+    group_by(&block).sort.transpose.pop || []
+  end
 
-        arr.unshift(val)
-      end
+  def deduce(identity = 0, &block)
+    if defined?(yield)
+      map(&block).deduce(identity)
+    else
+      inject { |acc, val| acc - val } || identity
     end
+  end
 
-    def exactly?(num)
-      found_count = 0
+  def drop_last(num)
+    collection_size = to_a.size
+    return self if num > collection_size
 
-      if defined?(yield)
-        each { |*opt| found_count += 1 if yield(*opt) }
-      else
-        each { |opt| found_count += 1 if opt }
-      end
+    self[0...(collection_size - num)]
+  end
 
-      found_count > num ? false : num == found_count
-    end
+  def drop_last_if
+    dropping = true
+    reverse_each.with_object([]) do |val, arr|
+      next if dropping &&= yield(val)
 
-    def excase?(object)
-      none?(object)
+      arr.unshift(val)
     end
+  end
 
-    def expand
-      map { |val| val.is_a?(Enumerable) ? val.expand : val }
-    end
+  def exactly?(num)
+    found_count = 0
 
-    def exponential(identity = 0, &block)
-      if defined?(yield)
-        map(&block).exponential(identity)
-      else
-        inject { |acc, val| acc**val } || identity
-      end
+    if defined?(yield)
+      each { |*opt| found_count += 1 if yield(*opt) }
+    else
+      each { |opt| found_count += 1 if opt }
     end
 
-    def frequency
-      each_with_object(Hash.new(0)) { |val, hash| hash[val] += 1 }
-    end
+    found_count > num ? false : num == found_count
+  end
 
-    def incase?(object)
-      any?(object)
-    end
+  def excase?(object)
+    none?(object)
+  end
 
-    # rubocop:disable Metrics/MethodLength
-    def interpose(sep, &block)
-      enum = Enumerator.new do |val|
-        items = each
-
-        loop do
-          begin
-            val << items.next
-          rescue StopIteration
-            break
-          end
-
-          begin
-            items.peek
-          rescue StopIteration
-            break
-          else
-            val << sep
-          end
-        end
-      end
+  def expand
+    map { |val| val.is_a?(Enumerable) ? val.expand : val }
+  end
 
-      block ? enum.each(&block) : enum
+  def exponential(identity = 0, &block)
+    if defined?(yield)
+      map(&block).exponential(identity)
+    else
+      inject { |acc, val| acc**val } || identity
     end
-    # rubocop:enable Metrics/MethodLength
+  end
 
-    def modulate(modulo)
-      if modulo == 1
-        to_a
-      elsif size % modulo != 0
-        raise ArgumentError, "Invalid modulo: #{modulo.inspect}"
-      else
-        (0...size).each_with_object(Array.new(modulo, [])) do |i, array|
-          array[i % modulo] += [self[i]]
-        end
-      end
-    end
+  def frequency
+    each_with_object(Hash.new(0)) { |val, hash| hash[val] += 1 }
+  end
 
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
-    # rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity
-    def occur(amount = nil)
-      result = Hash.new { |hash, key| hash[key] = [] }
+  def incase?(object)
+    any?(object)
+  end
 
-      each do |item|
-        key = item
-        result[key] << item
-      end
+  # rubocop:disable Metrics/MethodLength
+  def interpose(sep, &block)
+    enum = Enumerator.new do |val|
+      items = each
 
-      if defined?(yield)
-        result.select! { |_key, values| yield(values.size) }
-      else
-        raise ArgumentError, 'Invalid occur amount' unless amount
+      loop do
+        begin
+          val << items.next
+        rescue StopIteration
+          break
+        end
 
-        if amount.is_a?(Range)
-          result.select! { |_key, values| amount.include?(values.size) }
+        begin
+          items.peek
+        rescue StopIteration
+          break
         else
-          result.select! { |_key, values| values.size == amount }
+          val << sep
         end
       end
-
-      result.values.flatten.uniq
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
-    # rubocop:enable Metrics/MethodLength, Metrics/PerceivedComplexity
 
-    def produce(identity = 0, &block)
-      if defined?(yield)
-        map(&block).produce(identity)
-      else
-        inject { |acc, val| acc * val } || identity
+    block ? enum.each(&block) : enum
+  end
+  # rubocop:enable Metrics/MethodLength
+
+  def modulate(modulo)
+    if modulo == 1
+      to_a
+    elsif size % modulo != 0
+      raise ArgumentError, "Invalid modulo: #{modulo.inspect}"
+    else
+      (0...size).each_with_object(Array.new(modulo, [])) do |i, array|
+        array[i % modulo] += [self[i]]
       end
     end
+  end
 
-    def quotient(identity = 0, &block)
-      if defined?(yield)
-        map(&block).quotient(identity)
-      else
-        inject { |acc, val| acc / val } || identity
-      end
+  # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+  # rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity
+  def occur(amount = nil)
+    result = Hash.new { |hash, key| hash[key] = [] }
+
+    each do |item|
+      key = item
+      result[key] << item
     end
 
-    def several?
-      found_count = 0
+    if defined?(yield)
+      result.select! { |_key, values| yield(values.size) }
+    else
+      raise ArgumentError, 'Invalid occur amount' unless amount
 
-      if defined?(yield)
-        each { |*opt| found_count += 1 if yield(*opt) }
+      if amount.is_a?(Range)
+        result.select! { |_key, values| amount.include?(values.size) }
       else
-        each { |opt| found_count += 1 if opt }
+        result.select! { |_key, values| values.size == amount }
       end
+    end
+
+    result.values.flatten.uniq
+  end
+  # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+  # rubocop:enable Metrics/MethodLength, Metrics/PerceivedComplexity
 
-      found_count > 1
+  def produce(identity = 0, &block)
+    if defined?(yield)
+      map(&block).produce(identity)
+    else
+      inject { |acc, val| acc * val } || identity
     end
+  end
 
-    # rubocop:disable Metrics/MethodLength
-    def squeeze(*limited_to)
-      first = true
-      current = nil
-
-      each_with_object([]) do |val, array|
-        if !limited_to.empty? && !limited_to.include?(val)
-          array << val
-        elsif first || current != val
-          array << val
-          first = false
-          current = val
-        end
-      end
+  def quotient(identity = 0, &block)
+    if defined?(yield)
+      map(&block).quotient(identity)
+    else
+      inject { |acc, val| acc / val } || identity
     end
-    # rubocop:enable Metrics/MethodLength
+  end
 
-    def take_last(num)
-      collection_size = to_a.size
-      return self if num > collection_size
+  def several?
+    found_count = 0
 
-      self[(collection_size - num)..-1]
+    if defined?(yield)
+      each { |*opt| found_count += 1 if yield(*opt) }
+    else
+      each { |opt| found_count += 1 if opt }
     end
 
-    def take_last_if
-      reverse_each.with_object([]) do |val, arr|
-        break arr unless yield(val)
+    found_count > 1
+  end
 
-        arr.unshift(val)
+  # rubocop:disable Metrics/MethodLength
+  def squeeze(*limited_to)
+    first = true
+    current = nil
+
+    each_with_object([]) do |val, array|
+      if !limited_to.empty? && !limited_to.include?(val)
+        array << val
+      elsif first || current != val
+        array << val
+        first = false
+        current = val
       end
     end
+  end
+  # rubocop:enable Metrics/MethodLength
 
-    alias occurrences frequency
+  def take_last(num)
+    collection_size = to_a.size
+    return self if num > collection_size
 
+    self[(collection_size - num)..-1]
   end
 
-  require 'lite/ruby/safe/enumerable' unless defined?(ActiveSupport)
+  def take_last_if
+    reverse_each.with_object([]) do |val, arr|
+      break arr unless yield(val)
+
+      arr.unshift(val)
+    end
+  end
+
+  alias occurrences frequency
+
 end
+
+require 'lite/ruby/safe/enumerable' unless defined?(ActiveSupport)