lite-ruby 1.3.1 → 2.0.1

data/lib/lite/ruby/object.rb

@@ -1,171 +1,169 @@
 # frozen_string_literal: true
 
-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
-
-    # NOTE: There is a class between the PG gem and the `array?` method.
-    #       We only need to skip this on migrations since that action
-    #       happens on a seperate runtime.
-    unless defined?(PG) && ARGV.first.to_s.start_with?('db:')
-      def array?
-        is_a?(Array)
-      end
-    end
-
-    def bool?
-      true? || false?
-    end
-
-    def boolean?
-      val = to_s.downcase
-      TRUE_VALUES.include?(val) || FALSE_VALUES.include?(val)
+class Object
+
+  FALSE_VALUES = %w[
+    0 f false n no off
+  ].freeze
+  TRUE_VALUES = %w[
+    1 t true y yes on
+  ].freeze
+
+  # NOTE: There is a clash between the PG gem and the `array?` method.
+  #       We only need to skip this on migrations since that action
+  #       happens on a seperate runtime.
+  unless defined?(PG) && ARGV.first.to_s.start_with?('db:')
+    def array?
+      is_a?(Array)
     end
+  end
 
-    def date?
-      is_a?(Date)
-    end
+  def bool?
+    true? || false?
+  end
 
-    # rubocop:disable Style/YodaCondition
-    def false?
-      false == self
-    end
-    # rubocop:enable Style/YodaCondition
+  def boolean?
+    val = to_s.downcase
+    TRUE_VALUES.include?(val) || FALSE_VALUES.include?(val)
+  end
 
-    def falsey?
-      nil? || FALSE_VALUES.include?(to_s.downcase)
-    end
+  def date?
+    is_a?(Date)
+  end
 
-    def float?
-      is_a?(Float)
-    end
+  # rubocop:disable Style/YodaCondition
+  def false?
+    false == self
+  end
+  # rubocop:enable Style/YodaCondition
 
-    def hash?
-      is_a?(Hash)
-    end
+  def falsey?
+    nil? || FALSE_VALUES.include?(to_s.downcase)
+  end
 
-    def integer?
-      is_a?(Integer)
-    end
+  def float?
+    is_a?(Float)
+  end
 
-    # rubocop:disable Naming/PredicateName
-    def is_any?(*objs)
-      objs.any? { |obj| is_a?(obj) }
-    end
-    # rubocop:enable Naming/PredicateName
+  def hash?
+    is_a?(Hash)
+  end
 
-    def numeral?
-      !to_s.match(/\A[+-]?\d+?(\.\d+)?\Z/).nil?
-    end
+  def integer?
+    is_a?(Integer)
+  end
 
-    def numeric?
-      is_a?(Numeric)
-    end
+  # rubocop:disable Naming/PredicateName
+  def is_any?(*objects)
+    objects.any? { |obj| is_a?(obj) }
+  end
+  # rubocop:enable Naming/PredicateName
 
-    def open_struct?
-      is_a?(OpenStruct)
-    end
+  def numeral?
+    !to_s.match(/\A[+-]?\d+?(\.\d+)?\Z/).nil?
+  end
 
-    def palindrome?
-      to_s == to_s.reverse
-    end
+  def numeric?
+    is_a?(Numeric)
+  end
 
-    def range?
-      is_a?(Range)
-    end
+  def open_struct?
+    is_a?(OpenStruct)
+  end
 
-    def safe_call(*keys)
-      try_call(*keys) || self
-    end
+  def palindrome?
+    to_s == to_s.reverse
+  end
 
-    def safe_send(*keys)
-      try_send(*keys) || self
-    end
+  def range?
+    is_a?(Range)
+  end
 
-    def safe_try(*obj, &block)
-      try(*obj, &block) || self
-    end
+  def safe_call(...)
+    try_call(...) || self
+  end
 
-    def salvage(placeholder = '---')
-      blank? ? placeholder : self
-    end
+  def safe_send(...)
+    try_send(...) || self
+  end
 
-    def salvage_try(*obj, placeholder: '---', &block)
-      try(*obj, &block).salvage(placeholder)
-    end
+  def safe_try(...)
+    try(...) || 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 salvage_try(method_name = nil, *args, placeholder: '---', &block)
+    try(method_name, *args, &block).salvage(placeholder)
+  end
 
-    def send_if(key, *args)
-      return self unless respond_to?(key)
+  def send_chain(*args)
+    Array(args).inject(self) { |obj, argz| obj.send(*argz) }
+  end
 
-      send(key, *args)
-    end
+  def send_chain_if(*args)
+    Array(args).inject(self) { |obj, argz| obj.send_if(*argz) }
+  end
 
-    def set?
-      is_a?(Set)
-    end
+  def send_if(key, *args, **kwargs, &block)
+    return self unless respond_to?(key)
 
-    def string?
-      is_a?(String)
-    end
+    send(key, *args, **kwargs, &block)
+  end
 
-    def struct?
-      is_a?(Struct)
-    end
+  def set?
+    is_a?(Set)
+  end
 
-    def symbol?
-      is_a?(Symbol)
-    end
+  def string?
+    is_a?(String)
+  end
 
-    def time?
-      is_a?(Time)
-    end
+  def struct?
+    is_a?(Struct)
+  end
 
-    def to_bool
-      return true if truthy?
-      return false if falsey?
+  def symbol?
+    is_a?(Symbol)
+  end
 
-      nil
-    end
+  def time?
+    is_a?(Time)
+  end
 
-    # rubocop:disable Style/YodaCondition
-    def true?
-      true == self
-    end
-    # rubocop:enable Style/YodaCondition
+  def to_bool
+    return true if truthy?
+    return false if falsey?
 
-    def truthy?
-      TRUE_VALUES.include?(to_s.downcase)
-    end
+    nil
+  end
 
-    def try_call(*keys)
-      return unless respond_to?(:call)
+  # rubocop:disable Style/YodaCondition
+  def true?
+    true == self
+  end
+  # rubocop:enable Style/YodaCondition
 
-      keys.blank? ? call : call(*keys)
-    end
+  def truthy?
+    TRUE_VALUES.include?(to_s.downcase)
+  end
 
-    def try_send(*keys)
-      send(*keys)
-    rescue StandardError
-      nil
-    end
+  def try_call(...)
+    return unless respond_to?(:call)
 
-    alias to_b to_bool
+    call(...)
+  end
 
+  def try_send(...)
+    send(...)
+  rescue StandardError
+    nil
   end
 
-  require 'lite/ruby/safe/object' unless defined?(ActiveSupport)
+  alias to_b to_bool
+
 end
+
+require 'lite/ruby/safe/object' unless defined?(ActiveSupport)

data/lib/lite/ruby/open_struct.rb

@@ -1,30 +1,28 @@
 # frozen_string_literal: false
 
-if Lite::Ruby.configuration.monkey_patches.include?('open_struct')
-  require 'ostruct'
+require 'ostruct' unless defined?(OpenStruct)
 
-  class OpenStruct
+class OpenStruct
 
-    def attributes
-      @table
-    end
+  def attributes
+    @table
+  end
 
-    def replace(args)
-      args.each { |key, val| send("#{key}=", val) }
-    end
+  def replace(args)
+    args.each { |key, val| self[key] = val }
+  end
 
-    def to_hash(table: true)
-      return attributes unless table
+  def to_hash(table: true)
+    return attributes unless table
 
-      { table: attributes }
-    end
+    { table: attributes }
+  end
 
-    def to_json(table: true)
-      to_hash(table: table).to_json
-    end
+  def to_json(table: true)
+    to_hash(table: table).to_json
+  end
 
-    alias as_json to_json
-    alias to_h to_hash
+  alias as_json to_json
+  alias to_h to_hash
 
-  end
 end

data/lib/lite/ruby/range.rb

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

data/lib/lite/ruby/safe/object.rb

@@ -5,9 +5,7 @@ class Object
   def blank?
     object = self
     object = object.strip if respond_to?(:strip)
-    return object.empty? if respond_to?(:empty?)
-
-    !object
+    respond_to?(:empty?) ? object.empty? : !object
   end
 
   def deep_dup
@@ -26,15 +24,19 @@ class Object
     self if present?
   end
 
-  def try(*obj, &block)
-    try!(*obj, &block) if obj.empty? || respond_to?(obj.first)
+  def try(method_name = nil, *args, &block)
+    if method_name.nil? && block
+      block.arity.zero? ? instance_eval(&block) : yield(self)
+    elsif respond_to?(method_name)
+      public_send(method_name, *args, &block)
+    end
   end
 
-  def try!(*obj, &block)
-    if obj.empty? && defined?(yield)
+  def try!(method_name = nil, *args, &block)
+    if method_name.nil? && block
       block.arity.zero? ? instance_eval(&block) : yield(self)
     else
-      public_send(*obj, &block)
+      public_send(method_name, *args, &block)
     end
   end
 

data/lib/lite/ruby/safe/string.rb

@@ -151,16 +151,17 @@ class String
 
     omission = options[:omission] || '...'
     seperator = options[:separator]
-
     size_with_room_for_omission = truncate_at - omission.length
+    stop = rindex(seperator || '', size_with_room_for_omission) if seperator
+    "#{self[0, stop || size_with_room_for_omission]}#{omission}"
+  end
 
-    stop = if seperator
-             rindex(seperator || '', size_with_room_for_omission) || size_with_room_for_omission
-           else
-             size_with_room_for_omission
-           end
+  def truncate_words(words_count, options = {})
+    sep = options[:separator] || /\s+/
+    sep = Regexp.escape(sep.to_s) unless sep.is_a?(Regexp)
+    return dup unless self =~ /\A((?>.+?#{sep}){#{words_count - 1}}.+?)#{sep}.*/m
 
-    "#{self[0, stop]}#{omission}"
+    $1 + (options[:omission] || '...')
   end
 
   def underscore