active_object 2.5.2 → 3.0.0

data/lib/active_object/object.rb

@@ -1,19 +1,17 @@
-class Object
+module ActiveObject::Object
 
   def array?
     is_a?(Array)
   end
 
-  unless defined?(Rails)
-    def blank?
-      object = self
-      object = object.strip if respond_to?(:strip)
-      respond_to?(:empty?) ? object.empty? : !object
-    end
+  def blank?
+    object = self
+    object = object.strip if respond_to?(:strip)
+    respond_to?(:empty?) ? object.empty? : !object
   end
 
   def boolean?
-    [false, "false", true, "true", nil, 0, "0", 1, "1"].freeze.include?(self)
+    [false, "false", true, "true", nil, 0, "0", 1, "1"].include?(self)
   end
 
   def false?
@@ -21,7 +19,7 @@ class Object
   end
 
   def falsey?
-    [false, "false", nil, 0, "0", "1"].freeze.include?(self)
+    [false, "false", nil, 0, "0", "1"].include?(self)
   end
 
   def float?
@@ -48,10 +46,8 @@ class Object
     to_s == to_s.reverse
   end
 
-  unless defined?(Rails)
-    def present?
-      !blank?
-    end
+  def present?
+    !blank?
   end
 
   def range?
@@ -78,20 +74,18 @@ class Object
     !falsey?
   end
 
-  unless defined?(Rails)
-    def try(*a, &b)
-      try!(*a, &b) if a.empty? || respond_to?(a.first)
-    end
+  def try(*a, &b)
+    try!(*a, &b) if a.empty? || respond_to?(a.first)
   end
 
-  unless defined?(Rails)
-    def try!(*a, &b)
-      if a.empty? && block_given?
-        b.arity.zero? ? instance_eval(&b) : yield(self)
-      else
-        public_send(*a, &b)
-      end
+  def try!(*a, &b)
+    if a.empty? && block_given?
+      b.arity.zero? ? instance_eval(&b) : yield(self)
+    else
+      public_send(*a, &b)
     end
   end
 
-end
+end
+
+Object.send(:include, ActiveObject::Object) if ActiveObject.configuration.autoload_object

data/lib/active_object/range.rb

@@ -1,24 +1,20 @@
-class Range
+module ActiveObject::Range
 
   def combine(other)
     to_a.concat(other.to_a)
   end
 
-  unless defined?(Rails)
-    def include_with_range?(other)
-      if other.is_a?(::Range)
-        operator = exclude_end? && !other.exclude_end? ? :< : :<=
-        include?(other.first) && other.last.send(operator, last)
-      else
-        include?(other)
-      end
+  def include_with_range?(other)
+    if other.is_a?(::Range)
+      operator = exclude_end? && !other.exclude_end? ? :< : :<=
+      include?(other.first) && other.last.send(operator, last)
+    else
+      include?(other)
     end
   end
 
-  unless defined?(Rails)
-    def overlaps?(other)
-      cover?(other.first) || other.cover?(first)
-    end
+  def overlaps?(other)
+    cover?(other.first) || other.cover?(first)
   end
 
   def sample
@@ -33,4 +29,6 @@ class Range
     cover?(other.first) && cover?(other.last)
   end
 
-end
+end
+
+Range.send(:include, ActiveObject::Range) if ActiveObject.configuration.autoload_range

data/lib/active_object/string.rb

@@ -1,4 +1,4 @@
-class String
+module ActiveObject::String
 
   def any?(*keys)
     included = false
@@ -6,93 +6,64 @@ class String
     included
   end
 
-  unless defined?(Rails)
-    def at(position)
-      self[position]
-    end
+  def at(position)
+    self[position]
   end
 
-  unless defined?(Rails)
-    def camelize(first_letter=:upper)
-      if first_letter.to_sym != :lower
-        to_s.
-        gsub(/\/(.?)/) { "::#{$1.upcase}" }.
-        gsub(/(?:^|_)(.)/) { $1.upcase }
-      else
-        "#{to_s.first.chr.downcase}#{camelize(self)[1..-1]}"
-      end
+  def camelize(first_letter=:upper)
+    if first_letter.to_sym != :lower
+      to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    else
+      "#{to_s.first.chr.downcase}#{camelize(self)[1..-1]}"
     end
-
-    alias_method :camelcase, :camelize
   end
 
-  unless defined?(Rails)
-    def camelize!(first_letter=:upper)
-      replace(camelize(first_letter))
-    end
+  alias_method :camelcase, :camelize
 
-    alias_method :camelcase!, :camelize!
+  def camelize!(first_letter=:upper)
+    replace(camelize(first_letter))
   end
 
-  unless defined?(Rails)
-    def classify
-      to_s.
-      sub(/.*\./, ''.freeze).
-      camelize
-    end
+  alias_method :camelcase!, :camelize!
+
+  def classify
+    to_s.sub(/.*\./, "").camelize
   end
 
-  unless defined?(Rails)
-    def classify!
-      replace(classify)
-    end
+  def classify!
+    replace(classify)
   end
 
-  unless defined?(Rails)
-    def constantize
-      Object.const_get(self)
-    end
+  def constantize
+    Object.const_get(self)
   end
 
-  unless defined?(Rails)
-    def dasherize
-      gsub(/_/, '-'.freeze)
-    end
+  def dasherize
+    gsub(/_/, "-")
   end
 
-  unless defined?(Rails)
-    def dasherize!
-      replace(dasherize)
-    end
+  def dasherize!
+    replace(dasherize)
   end
 
-  unless defined?(Rails)
-    def deconstantize
-      to_s[0, rindex('::'.freeze) || 0]
-    end
+  def deconstantize
+    to_s[0, rindex("::") || 0]
   end
 
-  unless defined?(Rails)
-    def deconstantize!
-      replace(deconstantize)
-    end
+  def deconstantize!
+    replace(deconstantize)
   end
 
-  unless defined?(Rails)
-    def demodulize
-      to_s.gsub(/^.*::/, ''.freeze)
-    end
+  def demodulize
+    to_s.gsub(/^.*::/, "")
   end
 
-  unless defined?(Rails)
-    def demodulize!
-      replace(demodulize)
-    end
+  def demodulize!
+    replace(demodulize)
   end
 
   def domain
-    string = dup
-    string =~ (/^(?:\w+:\/\/)?([^\/?]+)(?:\/|\?|$)/) ? $1 : string
+    self =~ (/^(?:\w+:\/\/)?([^\/?]+)(?:\/|\?|$)/) ? $1 : self
   end
 
   def downcase?
@@ -100,87 +71,81 @@ class String
   end
 
   def ellipsize(ellipsize_at, options={})
-     return(self)if length <= ellipsize_at
+     return(self) if length <= ellipsize_at
 
-     separator = options.fetch(:separator, '...'.freeze)
-     offset    = options.fetch(:offset, 4)
+     separator = options.fetch(:separator, "...")
+     offset = options.fetch(:offset, 4)
 
      "#{self[0, offset]}#{separator}#{self[-offset, offset]}"
   end
 
-  unless defined?(Rails)
-    def exclude?(string)
-      !include?(string)
-    end
+  def exclude?(string)
+    !include?(string)
   end
 
-  unless defined?(Rails)
-    def first(limit=1)
-      return(''.freeze) if limit.zero?
+  def first(limit=1)
+    return("") if limit.zero?
 
-      limit >= length ? self.dup : to(limit - 1)
-    end
+    limit >= length ? self : to(limit - 1)
   end
 
-  unless defined?(Rails)
-    def from(position)
-      self[position..-1]
-    end
+  def format(*args)
+    super(self, *(args.flatten))
   end
 
-  unless defined?(Rails)
-    def humanize(options={})
-      underscore.
-      gsub(/_id\z/, ''.freeze).
-      tr('_'.freeze, ' '.freeze).
-      squish.
-      gsub(/([a-z\d]*)/i) { |s| s.downcase }.
-      gsub(/\A\w/) { |s| options.fetch(:capitalize, true) ? s.upcase : s }
-    end
+  def from(position)
+    self[position..-1]
   end
 
-  unless defined?(Rails)
-    def humanize!(options={})
-      replace(humanize(options))
-    end
+  def humanize(options={})
+    capitalize = options.fetch(:capitalize, true)
+
+    underscore.
+    gsub(/_id\z/, "").
+    tr("_", " ").
+    squish.
+    gsub(/([a-z\d]*)/i) { |s| s.downcase }.
+    gsub(/\A\w/) { |s| capitalize ? s.upcase : s }
   end
 
-  unless defined?(Rails)
-    def indent(amount, indent_string=nil, indent_empty_lines=false)
-      indent_string = indent_string || self[/^[ \t]/] || ' '.freeze
-      substitutes   = indent_empty_lines ? /^/ : /^(?!$)/
+  def humanize!(options={})
+    replace(humanize(options))
+  end
 
-      gsub(substitutes, indent_string * amount)
-    end
+  def indent(amount, indent_string=nil, indent_empty_lines=false)
+    indent_string = indent_string || self[/^[ \t]/] || " "
+    substitutes = indent_empty_lines ? /^/ : /^(?!$)/
+
+    gsub(substitutes, indent_string * amount)
   end
 
-  unless defined?(Rails)
-    def indent!(amount, indent_string=nil, indent_empty_lines=false)
-      replace(indent(amount, indent_string, indent_empty_lines))
-    end
+  def indent!(amount, indent_string=nil, indent_empty_lines=false)
+    replace(indent(amount, indent_string, indent_empty_lines))
   end
 
   def index_all(pattern)
-    pattern     = pattern.to_s if pattern.is_a?(Numeric)
+    pattern = pattern.to_s if pattern.is_a?(Numeric)
     arr_indexes = []
-    srch_index  = rindex(pattern)
+    srch_index = rindex(pattern)
 
     while srch_index do
       temp_string = self[0..(srch_index - 1)]
       arr_indexes << srch_index
-      srch_index  = srch_index.zero? ? nil : temp_string.rindex(pattern)
+      srch_index = srch_index.zero? ? nil : temp_string.rindex(pattern)
     end
 
     arr_indexes.reverse
   end
 
   def labelize(options={})
+    capitalize = options.fetch(:capitalize, true)
+
     underscore.
-    tr('_'.freeze, ' '.freeze).
+    tr("_", " ").
     squish.
     gsub(/([a-z\d]*)/i) { |s| s.downcase }.
-    gsub(/\A\w/) { |s| options.fetch(:capitalize, true) ? s.upcase : s }.
-    gsub(/ id\z/, ' ID'.freeze)
+    gsub(/\A\w/) { |s| capitalize ? s.upcase : s }.
+    gsub(/ id\z/, " ID")
   end
 
   alias_method :labelcase, :labelize
@@ -191,50 +156,38 @@ class String
 
   alias_method :labelcase!, :labelize!
 
-  unless defined?(Rails)
-    def last(limit=1)
-      return(''.freeze) if limit.zero?
 
-      limit >= length ? self.dup : from(-limit)
-    end
+  def last(limit=1)
+    return("") if limit.zero?
+
+    limit >= length ? self : from(-limit)
   end
 
   def mixedcase?
     !upcase? && !downcase?
   end
 
-  unless defined?(Rails)
-    def ordinal
-      to_i.ordinal
-    end
+  def ordinal
+    to_i.ordinal
   end
 
-  unless defined?(Rails)
-    def ordinalize
-      to_i.ordinalize
-    end
+  def ordinalize
+    to_i.ordinalize
   end
 
-  unless defined?(Rails)
-    def parameterize(seperator='-'.freeze)
-      underscore.
-      gsub(/\s+/, '_'.freeze).
-      gsub('_'.freeze, seperator).
-      downcase
-    end
+  def parameterize(seperator="-")
+    underscore.gsub(/\s+/, seperator).downcase
   end
 
-  unless defined?(Rails)
-    def parameterize!(seperator='-'.freeze)
-      replace(parameterize(seperator))
-    end
+  def parameterize!(seperator="-")
+    replace(parameterize(seperator))
   end
 
-  def pollute(delimiter='^--^--^'.freeze)
-    split(''.freeze).map { |c| "#{c}#{delimiter}" }.join
+  def pollute(delimiter="^--^--^")
+    split("").map { |c| "#{c}#{delimiter}" }.join
   end
 
-  def pollute!(delimiter='^--^--^'.freeze)
+  def pollute!(delimiter="^--^--^")
     replace(pollute(delimiter))
   end
 
@@ -246,41 +199,37 @@ class String
     replace(concat(string))
   end
 
-  unless defined?(Rails)
-    def remove(*patterns)
-      string = dup
+  def remove(*patterns)
+    string = dup
 
-      patterns.flatten.each do |p|
-        if p.is_a?(Range)
-          string.slice!(p)
-        else
-          string.gsub!(p, ''.freeze)
-        end
+    patterns.flatten.each do |p|
+      if p.is_a?(Range)
+        string.slice!(p)
+      else
+        string.gsub!(p, "")
       end
-
-      string
     end
+
+    string
   end
 
-  unless defined?(Rails)
-    def remove!(*patterns)
-      replace(remove(*patterns))
-    end
+  def remove!(*patterns)
+    replace(remove(*patterns))
   end
 
   def remove_tags
-    gsub(/<\/?[^>]*>/, ''.freeze)
+    gsub(/<\/?[^>]*>/, "")
   end
 
   def remove_tags!
     replace(remove_tags)
   end
 
-  def sample(separator=' '.freeze)
+  def sample(separator=" ")
     split(separator).sample
   end
 
-  def sample!(separator=' '.freeze)
+  def sample!(separator=" ")
     replace(sample(separator))
   end
 
@@ -289,7 +238,7 @@ class String
       self[0]
     else
       string = dup
-      patterns.flatten.each { |p| string.sub!(p, ''.freeze) }
+      patterns.flatten.each { |p| string.sub!(p, "") }
       string
     end
   end
@@ -298,19 +247,19 @@ class String
     replace(shift(*patterns))
   end
 
-  def shuffle(separator=''.freeze)
+  def shuffle(separator="")
     split(separator).shuffle.join
   end
 
-  def shuffle!(separator=''.freeze)
+  def shuffle!(separator="")
     replace(shuffle(separator))
   end
 
   def sift(chars_to_keep)
     chars_to_keep = case chars_to_keep
                     when String then chars_to_keep.chars
-                    when Array  then chars_to_keep.map { |c| c.to_s }
-                    when Range  then chars_to_keep.to_a.map { |c| c.to_s }
+                    when Array then chars_to_keep.map { |c| c.to_s }
+                    when Range then chars_to_keep.to_a.map { |c| c.to_s }
                     else
                       raise TypeError, "Invalid parameter"
                     end
@@ -323,10 +272,10 @@ class String
   end
 
   def slugify
-    gsub(/[^\x00-\x7F]+/, ''.freeze).
-    gsub(/[^\w_ \-]+/i,   ''.freeze).
-    gsub(/[ \-]+/i,      '-'.freeze).
-    gsub(/^\-|\-$/i,      ''.freeze).
+    gsub(/[^\x00-\x7F]+/, "").
+    gsub(/[^\w_ \-]+/i, "").
+    gsub(/[ \-]+/i, "-").
+    gsub(/^\-|\-$/i, "").
     downcase
   end
 
@@ -334,17 +283,12 @@ class String
     replace(slugify)
   end
 
-  unless defined?(Rails)
-    def squish
-      strip.
-      gsub(/\s+/, ' '.freeze)
-    end
+  def squish
+    strip.gsub(/\s+/, " ")
   end
 
-  unless defined?(Rails)
-    def squish!
-      replace(squish)
-    end
+  def squish!
+    replace(squish)
   end
 
   def sort
@@ -355,81 +299,65 @@ class String
     replace(sort)
   end
 
-  unless defined?(Rails)
-    def titleize
-      underscore.
-      humanize.
-      gsub(/\b(?<!['’`])[a-z]/) { $&.capitalize }
-    end
-
-    alias_method :titlecase, :titleize
+  def titleize
+    underscore.humanize.gsub(/\b(?<!['’`])[a-z]/) { $&.capitalize }
   end
 
-  unless defined?(Rails)
-    def titleize!
-      replace(titleize)
-    end
+  alias_method :titlecase, :titleize
 
-    alias_method :titlecase!, :titleize!
+  def titleize!
+    replace(titleize)
   end
 
-  unless defined?(Rails)
-    def to(position)
-      self[0..position]
-    end
-  end
+  alias_method :titlecase!, :titleize!
 
-  unless defined?(Rails)
-    def truncate(truncate_at, options={})
-      return(dup) unless length > truncate_at
+  def to(position)
+    self[0..position]
+  end
 
-      omission = options.fetch(:omission, '...'.freeze)
-      size_with_room_for_omission = truncate_at - omission.length
+  def truncate(truncate_at, options={})
+    return(dup) unless length > truncate_at
 
-      stop = if options.fetch(:separator, false)
-        rindex(options.fetch(:separator, ''.freeze), size_with_room_for_omission) || size_with_room_for_omission
-      else
-        size_with_room_for_omission
-      end
+    omission = options.fetch(:omission, "...")
+    size_with_room_for_omission = truncate_at - omission.length
 
-      "#{self[0, stop]}#{omission}"
+    stop = if options.fetch(:separator, false)
+      rindex(options.fetch(:separator, ""), size_with_room_for_omission) || size_with_room_for_omission
+    else
+      size_with_room_for_omission
     end
+
+    "#{self[0, stop]}#{omission}"
   end
 
-  unless defined?(Rails)
-    def truncate_words(words_count, options={})
-      sep = options.fetch(:separator, /\s+/)
-      sep = Regexp.escape(sep.to_s) unless Regexp === sep
+  def truncate_words(words_count, options={})
+    sep = options.fetch(:separator, /\s+/)
+    sep = Regexp.escape(sep.to_s) unless Regexp === sep
 
-      if self =~ /\A((?:.+?#{sep}){#{words_count - 1}}.+?)#{sep}.*/m
-        "#{$1}#{options.fetch(:omission, '...'.freeze)}"
-      else
-        dup
-      end
+    if self =~ /\A((?:.+?#{sep}){#{words_count - 1}}.+?)#{sep}.*/m
+      "#{$1}#{options.fetch(:omission, '...')}"
+    else
+      self
     end
   end
 
-  unless defined?(Rails)
-    def underscore
-      gsub(/::/, '/'.freeze).
-      gsub(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2'.freeze).
-      gsub(/([a-z\d])([A-Z])/, '\1_\2'.freeze).
-      tr('-'.freeze, '_'.freeze).
-      downcase
-    end
+  def underscore
+    gsub(/::/, "/").
+    gsub(/([A-Z\d]+)([A-Z][a-z])/, "\1_\2").
+    gsub(/([a-z\d])([A-Z])/, "\1_\2").
+    tr("-", "_").
+    downcase
   end
 
-  unless defined?(Rails)
-    def underscore!
-      replace(underscore)
-    end
+  def underscore!
+    replace(underscore)
   end
 
-  def unpollute(delimiter='^--^--^'.freeze)
-    gsub(delimiter, ''.freeze)
+  def unpollute(delimiter="^--^--^")
+    gsub(delimiter, "")
   end
 
-  def unpollute!(delimiter='^--^--^'.freeze)
+  def unpollute!(delimiter="^--^--^")
     replace(unpollute(delimiter))
   end
 
@@ -438,7 +366,7 @@ class String
   end
 
   def unshift(*patterns)
-    string = ''
+    string = ""
     patterns.flatten.each { |p| string.concat(p) }
     string.concat(self)
     string
@@ -448,4 +376,6 @@ class String
     replace(unshift(*patterns))
   end
 
-end
+end
+
+String.send(:include, ActiveObject::String) if ActiveObject.configuration.autoload_string