active_object 1.0.0

data/lib/active_object/object.rb

@@ -0,0 +1,41 @@
+class Object
+
+  unless method_defined?(:blank?)
+    def blank?
+      object = self
+      object = object.strip if respond_to?(:strip)
+      respond_to?(:empty?) ? !!object.empty? : !object
+    end
+  end
+
+  def numeric?
+    !to_s.match(/\A[+-]?\d+?(\.\d+)?\Z/).nil?
+  end
+
+  def palindrome?
+    to_s == to_s.reverse
+  end
+
+  unless method_defined?(:present?)
+    def present?
+      !blank?
+    end
+  end
+
+  unless method_defined?(:try)
+    def try(*a, &b)
+      try!(*a, &b) if a.empty? || respond_to?(a.first)
+    end
+  end
+
+  unless method_defined?(:try!)
+    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

data/lib/active_object/string.rb

@@ -0,0 +1,311 @@
+class String
+
+  unless method_defined?(:at)
+    def at(position)
+      self[position]
+    end
+  end
+
+  unless method_defined?(:camelize)
+    def camelize(first_letter=:upper)
+      if first_letter != :lower
+        to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+      else
+        to_s.first.chr.downcase + camelize(self)[1..-1]
+      end
+    end
+
+    alias_method :camelcase, :camelize
+  end
+
+  unless method_defined?(:camelize!)
+    def camelize!(first_letter=:upper)
+      replace(camelize(first_letter))
+    end
+
+    alias_method :camelcase!, :camelize!
+  end
+
+  unless method_defined?(:classify)
+    def classify
+      to_s.sub(/.*\./, "").camelize
+    end
+  end
+
+  unless method_defined?(:classify!)
+    def classify!
+      replace(classify)
+    end
+  end
+
+  unless method_defined?(:dasherize)
+    def dasherize
+      gsub(/_/, "-")
+    end
+  end
+
+  unless method_defined?(:dasherize!)
+    def dasherize!
+      replace(dasherize)
+    end
+  end
+
+  unless method_defined?(:demodulize)
+    def demodulize
+      to_s.gsub(/^.*::/, "")
+    end
+  end
+
+  unless method_defined?(:demodulize!)
+    def demodulize!
+      replace(demodulize)
+    end
+  end
+
+  def domain
+    string = dup
+    string =~ (/^(?:\w+:\/\/)?([^\/?]+)(?:\/|\?|$)/) ? $1 : string
+  end
+
+  def downcase?
+    downcase == self
+  end
+
+  def ellipsize(ellipsize_at, options={})
+     return(self)if size <= ellipsize_at
+     separator = options.fetch(:separator, "...")
+     offset    = options.fetch(:offset, 4)
+
+     "#{self[0,offset]}#{separator}#{self[-offset,offset]}"
+  end
+
+  unless method_defined?(:exclude?)
+    def exclude?(string)
+      !include?(string)
+    end
+  end
+
+  unless method_defined?(:first)
+    def first(limit=1)
+      return("") if limit.zero?
+      limit >= size ? self.dup : to(limit - 1)
+    end
+  end
+
+  unless method_defined?(:from)
+    def from(position)
+      self[position..-1]
+    end
+  end
+
+  unless method_defined?(:humanize)
+    def humanize(options = {})
+      underscore.
+      gsub(/_id\z/, "").
+      tr("_", " ").
+      gsub(/([a-z\d]*)/i) { |s| s.downcase }.
+      gsub(/\A\w/) { |s| options.fetch(:capitalize, true) ? s.upcase : s }
+    end
+  end
+
+  unless method_defined?(:humanize!)
+    def humanize!(options={})
+      replace(humanize(options))
+    end
+  end
+
+  unless method_defined?(:indent!)
+    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
+  end
+
+  unless method_defined?(:indent!)
+    def indent!(amount, indent_string=nil, indent_empty_lines=false)
+      replace(indent(amount, indent_string, indent_empty_lines))
+    end
+  end
+
+  unless method_defined?(:last)
+    def last(limit=1)
+      return("") if limit.zero?
+      limit >= size ? self.dup : from(-limit)
+    end
+  end
+
+  def mixedcase?
+    !upcase? && !downcase?
+  end
+
+  unless method_defined?(:ordinal)
+    def ordinal
+      to_i.ordinal
+    end
+  end
+
+  unless method_defined?(:ordinalize)
+    def ordinalize
+      to_i.ordinalize
+    end
+  end
+
+  unless method_defined?(:parameterize)
+    def parameterize(sep="-")
+      underscore.
+      gsub(/\s+/, "_").
+      gsub("_", sep).
+      downcase
+    end
+  end
+
+  unless method_defined?(:parameterize!)
+    def parameterize!(sep="-")
+      replace(parameterize(sep))
+    end
+  end
+
+  def pollute(delimiter="^--^--^")
+    split('').map { |c| "#{c}#{delimiter}" }.join
+  end
+
+  unless method_defined?(:remove)
+    def remove(*patterns)
+      string = dup
+      patterns.each do |pattern|
+        string.gsub!(pattern, "")
+      end
+      string
+    end
+  end
+
+  unless method_defined?(:remove!)
+    def remove!(*patterns)
+      replace(remove(*patterns))
+    end
+  end
+
+  def remove_tags
+    gsub(/<\/?[^>]*>/, "")
+  end
+
+  def remove_tags!
+    replace(remove_tags)
+  end
+
+  def shift(*patterns)
+    string = dup
+    patterns.each do |pattern|
+      string.sub!(pattern, "")
+    end
+    string
+  end
+
+  def shift!(*patterns)
+    replace(shift(*patterns))
+  end
+
+  def slugify
+    gsub(/[^\x00-\x7F]+/, '').
+    gsub(/[^\w_ \-]+/i,   '').
+    gsub(/[ \-]+/i,      '-').
+    gsub(/^\-|\-$/i,      '').
+    downcase
+  end
+
+  def slugify!
+    replace(slugify)
+  end
+
+  unless method_defined?(:squish)
+    def squish
+      strip.gsub(/\s+/, ' ')
+    end
+  end
+
+  unless method_defined?(:squish!)
+    def squish!
+      replace(squish)
+    end
+  end
+
+  unless method_defined?(:titleize)
+    def titleize
+      underscore.
+      humanize.
+      gsub(/\b(?<!['’`])[a-z]/) { $&.capitalize }
+    end
+
+    alias_method :titlecase, :titleize
+  end
+
+  unless method_defined?(:titleize!)
+    def titleize!
+      replace(titleize)
+    end
+
+    alias_method :titlecase!, :titleize!
+  end
+
+  unless method_defined?(:to)
+    def to(position)
+      self[0..position]
+    end
+  end
+
+  unless method_defined?(:truncate)
+    def truncate(truncate_at, options={})
+      return(dup) unless length > truncate_at
+
+      omission = options.fetch(:omission, "...")
+      length_with_room_for_omission = truncate_at - omission.length
+
+      stop = if options.fetch(:separator, false)
+          rindex(options.fetch(:separator, ''), length_with_room_for_omission) || length_with_room_for_omission
+        else
+          length_with_room_for_omission
+        end
+
+      "#{self[0, stop]}#{omission}"
+    end
+  end
+
+  unless method_defined?(:truncate_words)
+    def truncate_words(words_count, options={})
+      sep = options[:separator] || /\s+/
+      sep = Regexp.escape(sep.to_s) unless Regexp === sep
+
+      if self =~ /\A((?:.+?#{sep}){#{words_count - 1}}.+?)#{sep}.*/m
+        $1 + (options[:omission] || '...')
+      else
+        dup
+      end
+    end
+  end
+
+  unless method_defined?(:underscore)
+    def underscore
+      gsub(/::/, '/').
+      gsub(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+    end
+  end
+
+  unless method_defined?(:underscore!)
+    def underscore!
+      replace(underscore)
+    end
+  end
+
+  def unpollute(delimiter="^--^--^")
+    gsub(delimiter, "")
+  end
+
+  def upcase?
+    upcase == self
+  end
+
+end

data/lib/active_object/time.rb

@@ -0,0 +1,150 @@
+class Time
+
+  def format(string)
+    delimiters = string.scan /\W+/
+    formatters = string.scan /[a-z0-9_]+/i
+
+    format_units = {
+      "d"                     => "d",
+      "day"                   => "d",
+      "day_zero"              => "d",
+      "dd"                    => "-d",
+      "Day"                   => "-d",
+      "day_unpadded"          => "-d",
+      "ddd"                   => "_d",
+      "DAY"                   => "_d",
+      "day_blank"             => "_d",
+      "dddd"                  => "j",
+      "day_of_the_year"       => "j",
+      "m"                     => "m",
+      "month"                 => "m",
+      "month_zero"            => "m",
+      "mm"                    => "-m",
+      "Month"                 => "-m",
+      "month_unpadded"        => "-m",
+      "mmm"                   => "_m",
+      "MONTH"                 => "_m",
+      "month_blank"           => "_m",
+      "mmmm"                  => "B",
+      "month_name"            => "B",
+      "mmmmm"                 => "b",
+      "month_name_abbr"       => "b",
+      "w"                     => "u",
+      "weekday"               => "u",
+      "ww"                    => "w",
+      "weekday_offset"        => "w",
+      "www"                   => "A",
+      "weekday_name"          => "A",
+      "wwww"                  => "a",
+      "weekday_name_abbr"     => "a",
+      "wwwww"                 => "W",
+      "week"                  => "W",
+      "wwwwww"                => "U",
+      "week_offset"           => "U",
+      "yy"                    => "y",
+      "yr"                    => "y",
+      "yyyy"                  => "Y",
+      "year"                  => "Y",
+      "h"                     => "H",
+      "hour"                  => "H",
+      "hour_zero"             => "H",
+      "hh"                    => "k",
+      "HOUR"                  => "k",
+      "hour_blank"            => "k",
+      "hhh"                   => "I",
+      "hour_imperical"        => "I",
+      "hour_imperical_zero"   => "I",
+      "hhhh"                  => "l",
+      "HOUR_IMPERICAL"        => "l",
+      "hour_imperical_blank"  => "l",
+      "ampm"                  => "P",
+      "meridian"              => "P",
+      "AMPM"                  => "p",
+      "MERIDIAN"              => "p",
+      "n"                     => "M",
+      "minute"                => "M",
+      "s"                     => "S",
+      "second"                => "S",
+      "z"                     => "z",
+      "time_zone"             => "z",
+      "zz"                    => ":z",
+      "time_zone_offset"      => ":z",
+      "zzz"                   => "::z",
+      "time_zone_offset_full" => "::z",
+      "zzzz"                  => "Z",
+      "time_zone_name"        => "Z"
+    }
+
+    strftime(formatters.map { |f| "%#{format_units.fetch(f)}#{delimiters.shift || ''}" }.join(""))
+  end
+
+  def to_format(key)
+    format_units = {
+      month:                       "%m",
+      month_zero:                  "%m",
+      month_unpadded:              "%-m",
+      month_blank:                 "%_m",
+      month_name:                  "%B",
+      month_name_abbr:             "%b",
+      weekday:                     "%d",
+      weekday_zero:                "%d",
+      weekday_unpadded:            "%-d",
+      weekday_blank:               "%_d",
+      weekday_name:                "%A",
+      weekday_name_abbr:           "%a",
+      yr:                          "%y",
+      year:                        "%Y",
+      hour:                        "%H",
+      hour_zero:                   "%H",
+      hour_blank:                  "%k",
+      hour_imperical:              "%I",
+      hour_imperical_zero:         "%I",
+      hour_imperical_blank:        "%l",
+      ampm:                        "%P",
+      meridian:                    "%P",
+      minute:                      "%M",
+      second:                      "%S",
+      time_zone:                   "%z",
+      time_zone_offset:            "%:z",
+      time_zone_offset_full:       "%::z",
+      time_zone_name:              "%Z",
+      date:                        "%B %-d, %Y",
+      date_abbr:                   "%b %-d, %Y",
+      date_iso:                    "%Y-%m-%d",
+      datetime:                    "%B %-d, %Y %H:%M",
+      datetime_abbr:               "%b %-d, %Y %H:%M",
+      datetime_iso:                "%Y-%m-%d %H:%M",
+      datetime_imperical:          "%B %-d, %Y %I:%M %P",
+      datetime_imperical_abbr:     "%b %-d, %Y %I:%M %P",
+      datetime_imperical_iso:      "%Y-%m-%d %I:%M %P",
+      datetime_tzn:                "%B %-d, %Y %H:%M %Z",
+      datetime_abbr_tzn:           "%b %-d, %Y %H:%M %Z",
+      datetime_iso_tzn:            "%Y-%m-%d %H:%M %z",
+      datetime_imperical_tzn:      "%B %-d, %Y %I:%M %P %Z",
+      datetime_imperical_abbr_tzn: "%b %-d, %Y %I:%M %P %Z",
+      datetime_imperical_iso_tzn:  "%Y-%m-%d %I:%M %P %z",
+      day:                         "%B %-d",
+      day_abbr:                    "%b %-d",
+      day_iso:                     "%m-%d",
+      daytime:                     "%B %-d %H:%M",
+      daytime_abbr:                "%b %-d %H:%M",
+      daytime_iso:                 "%m-%d %H:%M",
+      daytime_imperical:           "%B %-d %I:%M %P",
+      daytime_imperical_abbr:      "%b %-d %I:%M %P",
+      daytime_imperical_iso:       "%m-%d %I:%M %P",
+      time:                        "%H:%M",
+      time_zero:                   "%H:%M",
+      time_blank:                  "%k:%M",
+      time_tz:                     "%H:%M %z",
+      time_tzn:                    "%H:%M %Z",
+      time_imperical:              "%I:%M %P",
+      time_imperical_zero:         "%I:%M %P",
+      time_imperical_blank:        "%l:%M %P",
+      time_imperical_tz:           "%I:%M %P %z",
+      time_imperical_tzn:          "%I:%M %P %Z"
+    }
+
+    strftime(format_units.fetch(key))
+  end
+
+end