lite-ruby 1.0.14 → 1.0.15

data/lib/lite/ruby/object.rb

@@ -1,182 +1,184 @@
 # frozen_string_literal: true
 
-class Object
+if Lite::Ruby.configuration.monkey_patches.include?('object')
+  class Object
+
+    FALSE_VALUES ||= %w[
+      0 f false n no off
+    ].freeze
+    TRUE_VALUES ||= %w[
+      1 t true y yes on
+    ].freeze
+
+    def array?
+      is_a?(Array)
+    end
 
-  FALSE_VALUES ||= %w[
-    0 f false n no off
-  ].freeze
-  TRUE_VALUES ||= %w[
-    1 t true y yes on
-  ].freeze
+    def blank?
+      object = self
+      object = object.strip if respond_to?(:strip)
+      return object.empty? if respond_to?(:empty?)
 
-  def array?
-    is_a?(Array)
-  end
+      !object
+    end
 
-  def blank?
-    object = self
-    object = object.strip if respond_to?(:strip)
-    return object.empty? if respond_to?(:empty?)
+    def bool?
+      true? || false?
+    end
 
-    !object
-  end
+    def boolean?
+      val = to_s.downcase
+      TRUE_VALUES.include?(val) || FALSE_VALUES.include?(val)
+    end
 
-  def bool?
-    true? || false?
-  end
+    def date?
+      is_a?(Date)
+    end
 
-  def boolean?
-    val = to_s.downcase
-    TRUE_VALUES.include?(val) || FALSE_VALUES.include?(val)
-  end
+    # rubocop:disable Style/YodaCondition
+    def false?
+      false == self
+    end
+    # rubocop:enable Style/YodaCondition
 
-  def date?
-    is_a?(Date)
-  end
+    def falsey?
+      nil? || FALSE_VALUES.include?(to_s.downcase)
+    end
 
-  # rubocop:disable Style/YodaCondition
-  def false?
-    false == self
-  end
-  # rubocop:enable Style/YodaCondition
+    def float?
+      is_a?(Float)
+    end
 
-  def falsey?
-    nil? || FALSE_VALUES.include?(to_s.downcase)
-  end
+    def hash?
+      is_a?(Hash)
+    end
 
-  def float?
-    is_a?(Float)
-  end
+    def integer?
+      is_a?(Integer)
+    end
 
-  def hash?
-    is_a?(Hash)
-  end
+    # rubocop:disable Naming/PredicateName
+    def is_any?(*objs)
+      objs.any? { |obj| is_a?(obj) }
+    end
+    # rubocop:enable Naming/PredicateName
 
-  def integer?
-    is_a?(Integer)
-  end
+    def numeral?
+      !to_s.match(/\A[+-]?\d+?(\.\d+)?\Z/).nil?
+    end
 
-  # rubocop:disable Naming/PredicateName
-  def is_any?(*objs)
-    objs.any? { |obj| is_a?(obj) }
-  end
-  # rubocop:enable Naming/PredicateName
+    def numeric?
+      is_a?(Numeric)
+    end
 
-  def numeral?
-    !to_s.match(/\A[+-]?\d+?(\.\d+)?\Z/).nil?
-  end
+    def open_struct?
+      is_a?(OpenStruct)
+    end
 
-  def numeric?
-    is_a?(Numeric)
-  end
+    def palindrome?
+      to_s == to_s.reverse
+    end
 
-  def open_struct?
-    is_a?(OpenStruct)
-  end
+    def present?
+      !blank?
+    end
 
-  def palindrome?
-    to_s == to_s.reverse
-  end
+    def range?
+      is_a?(Range)
+    end
 
-  def present?
-    !blank?
-  end
+    def safe_call(*keys)
+      try_call(*keys) || self
+    end
 
-  def range?
-    is_a?(Range)
-  end
+    def safe_send(*keys)
+      try_send(*keys) || self
+    end
 
-  def safe_call(*keys)
-    try_call(*keys) || self
-  end
+    def safe_try(*obj, &block)
+      try(*obj, &block) || self
+    end
 
-  def safe_send(*keys)
-    try_send(*keys) || self
-  end
+    def salvage(placeholder = '---')
+      blank? ? placeholder : self
+    end
 
-  def safe_try(*obj, &block)
-    try(*obj, &block) || self
-  end
+    def send_chain(*keys)
+      Array(keys).inject(self) { |obj, key| obj.send(*key) }
+    end
 
-  def salvage(placeholder = '---')
-    blank? ? placeholder : self
-  end
+    def send_chain_if(*keys)
+      Array(keys).inject(self) { |obj, key| obj.send_if(*key) }
+    end
 
-  def send_chain(*keys)
-    Array(keys).inject(self) { |obj, key| obj.send(*key) }
-  end
+    def send_if(key, *args)
+      return self unless respond_to?(key)
 
-  def send_chain_if(*keys)
-    Array(keys).inject(self) { |obj, key| obj.send_if(*key) }
-  end
+      send(key, *args)
+    end
 
-  def send_if(key, *args)
-    return self unless respond_to?(key)
+    def set?
+      is_a?(Set)
+    end
 
-    send(key, *args)
-  end
+    def string?
+      is_a?(String)
+    end
 
-  def set?
-    is_a?(Set)
-  end
+    def struct?
+      is_a?(Struct)
+    end
 
-  def string?
-    is_a?(String)
-  end
+    def symbol?
+      is_a?(Symbol)
+    end
 
-  def struct?
-    is_a?(Struct)
-  end
+    def time?
+      is_a?(Time)
+    end
 
-  def symbol?
-    is_a?(Symbol)
-  end
+    def to_bool
+      return true if truthy?
+      return false if falsey?
 
-  def time?
-    is_a?(Time)
-  end
+      nil
+    end
 
-  def to_bool
-    return true if truthy?
-    return false if falsey?
+    alias to_b to_bool
 
-    nil
-  end
+    # rubocop:disable Style/YodaCondition
+    def true?
+      true == self
+    end
+    # rubocop:enable Style/YodaCondition
 
-  alias to_b to_bool
+    def truthy?
+      TRUE_VALUES.include?(to_s.downcase)
+    end
 
-  # rubocop:disable Style/YodaCondition
-  def true?
-    true == self
-  end
-  # rubocop:enable Style/YodaCondition
+    def try(*obj, &block)
+      try!(*obj, &block) if obj.empty? || respond_to?(obj.first)
+    end
 
-  def truthy?
-    TRUE_VALUES.include?(to_s.downcase)
-  end
+    def try!(*obj, &block)
+      if obj.empty? && block_given?
+        block.arity.zero? ? instance_eval(&block) : yield(self)
+      else
+        public_send(*obj, &block)
+      end
+    end
 
-  def try(*obj, &block)
-    try!(*obj, &block) if obj.empty? || respond_to?(obj.first)
-  end
+    def try_call(*keys)
+      return unless respond_to?(:call)
 
-  def try!(*obj, &block)
-    if obj.empty? && block_given?
-      block.arity.zero? ? instance_eval(&block) : yield(self)
-    else
-      public_send(*obj, &block)
+      keys.blank? ? call : call(*keys)
     end
-  end
 
-  def try_call(*keys)
-    return unless respond_to?(:call)
-
-    keys.blank? ? call : call(*keys)
-  end
+    def try_send(*keys)
+      send(*keys)
+    rescue StandardError
+      nil
+    end
 
-  def try_send(*keys)
-    send(*keys)
-  rescue StandardError
-    nil
   end
-
 end

data/lib/lite/ruby/open_struct.rb

@@ -1,42 +1,44 @@
 # frozen_string_literal: false
 
-require 'ostruct'
+if Lite::Ruby.configuration.monkey_patches.include?('open_struct')
+  require 'ostruct'
 
-class OpenStruct
+  class OpenStruct
 
-  def initialize(hash = nil, &block)
-    @table = if block && block.arity == 2
-               Hash.new(&block)
-             else
-               {}
-             end
+    def initialize(hash = nil, &block)
+      @table = if block && block.arity == 2
+                 Hash.new(&block)
+               else
+                 {}
+               end
 
-    hash&.each do |key, val|
-      @table[key.to_sym] = val
-      new_ostruct_member(key)
+      hash&.each do |key, val|
+        @table[key.to_sym] = val
+        new_ostruct_member(key)
+      end
+
+      yield self if block && block.arity == 1
     end
 
-    yield self if block && block.arity == 1
-  end
+    def [](key)
+      key = key.to_sym unless key.is_a?(Symbol)
+      @table[key]
+    end
 
-  def [](key)
-    key = key.to_sym unless key.is_a?(Symbol)
-    @table[key]
-  end
+    def []=(key, val)
+      raise TypeError, "can't modify frozen #{self.class}", caller(1) if frozen?
 
-  def []=(key, val)
-    raise TypeError, "can't modify frozen #{self.class}", caller(1) if frozen?
+      key = key.to_sym unless key.is_a?(Symbol)
+      @table[key] = val
+    end
 
-    key = key.to_sym unless key.is_a?(Symbol)
-    @table[key] = val
-  end
+    def attributes
+      each_pair.with_object({}) { |(key, val), hash| hash[key] = val }
+    end
 
-  def attributes
-    each_pair.with_object({}) { |(key, val), hash| hash[key] = val }
-  end
+    def replace(args)
+      args.each_pair { |key, val| send("#{key}=", val) }
+    end
 
-  def replace(args)
-    args.each_pair { |key, val| send("#{key}=", val) }
   end
-
 end

data/lib/lite/ruby/range.rb

@@ -1,32 +1,34 @@
 # frozen_string_literal: true
 
-class Range
+if Lite::Ruby.configuration.monkey_patches.include?('range')
+  class Range
 
-  def combine(other)
-    to_a.concat(other.to_a)
-  end
+    def combine(other)
+      to_a.concat(other.to_a)
+    end
 
-  def include_with_range?(other)
-    return include?(other) unless other.is_a?(Range)
+    def include_with_range?(other)
+      return include?(other) unless other.is_a?(Range)
 
-    operator = exclude_end? && !other.exclude_end? ? :< : :<=
-    include?(other.first) && other.last.send(operator, last)
-  end
+      operator = exclude_end? && !other.exclude_end? ? :< : :<=
+      include?(other.first) && other.last.send(operator, last)
+    end
 
-  def overlaps?(other)
-    cover?(other.first) || other.cover?(first)
-  end
+    def overlaps?(other)
+      cover?(other.first) || other.cover?(first)
+    end
 
-  def sample
-    to_a.sample
-  end
+    def sample
+      to_a.sample
+    end
 
-  def shuffle
-    to_a.shuffle
-  end
+    def shuffle
+      to_a.shuffle
+    end
 
-  def within?(other)
-    cover?(other.first) && cover?(other.last)
-  end
+    def within?(other)
+      cover?(other.first) && cover?(other.last)
+    end
 
+  end
 end