nobiru 0.0.1

data/lib/nobiru/extensions/enumerable_extension.rb

@@ -0,0 +1,141 @@
+module Enumerable
+
+  unless method_defined?(:sum)
+    def sum(identity=0)
+      inject(:+) || identity
+    end
+  end
+
+  def drop_last(n)
+    array = to_a
+
+    return array if n > array.size
+    array[0...(array.size - n)]
+  end
+
+  def drop_last_while
+    return to_enum(:drop_last_while) unless block_given?
+
+    result   = []
+    dropping = true
+    reverse_each do |value|
+      result.unshift(value) unless dropping &&= yield(value)
+    end
+    result
+  end
+
+  def exactly?(n)
+    found_count = 0
+
+    if block_given?
+      each do |*o|
+        found_count += 1 if yield(*o)
+      end
+    else
+      each do |o|
+        found_count += 1 if o
+      end
+    end
+
+    (found_count > n) ? false : n == found_count
+  end
+
+  def frequencies
+    each_with_object(Hash.new(0)) { |e, a| a[e] += 1 }
+  end
+
+  def max(identity=0)
+    size > 0 ? sort.last : identity
+  end
+
+  def min(identity=0)
+    size > 0 ? sort.first : identity
+  end
+
+  def mean(identity=0)
+    collection_size = size
+    collection_size > 0 ? inject(:+) / collection_size.to_f : identity
+  end
+
+  def median(identity=0)
+    collection_size   = size
+    collection_sorted = sort
+
+    if collection_size > 0
+      if collection_size % 2 == 0
+        (collection_sorted[(collection_size / 2) -1] + collection_sorted[collection_size / 2]) / 2.0
+      else
+        collection_sorted[collection_size / 2]
+      end
+    else
+      identity
+    end
+  end
+
+  def mode(identity=0)
+    if size > 0
+      frequency_distribution = inject(Hash.new(0)) { |h, v| h[v] += 1; h }
+      frequency_top_2        = frequency_distribution.sort { |a, b| b[1] <=> a[1] }.take(2)
+
+      if frequency_top_2.length == 1
+        frequency_top_2.first.first
+      elsif frequency_top_2.first.last == frequency_top_2.last.last
+        nil
+      else
+        frequency_top_2.first.first
+      end
+    else
+      identity
+    end
+  end
+
+  def range(identity=0)
+    collection_sorted = sort
+    size > 0 ? collection_sorted.last - collection_sorted.first : identity
+  end
+
+  def several?
+    found_count = 0
+
+    if block_given?
+      each do |*o|
+        found_count += 1 if yield(*o)
+      end
+    else
+      each do |o|
+        found_count += 1 if o
+      end
+    end
+
+    (found_count > 1) ? true : false
+  end
+
+  def standard_deviation
+    return 0 if length < 2
+    Math.sqrt(variance)
+  end
+
+  def take_last(n)
+    array = to_a
+
+    return array if n > array.size
+    array[(array.size - n)..-1]
+  end
+
+  def take_last_while
+    return to_enum(:take_last_while) unless block_given?
+
+    result = []
+    reverse_each { |e| yield(e) ? result.unshift(e) : break }
+    result
+  end
+
+  def variance
+    collection_length = length
+
+    return 0 if collection_length <= 1
+    sum = inject(0) { |accumulator, value| accumulator + (value - mean) ** 2 }
+    sum / (collection_length.to_f - 1)
+  end
+
+end

data/lib/nobiru/extensions/hash_extension.rb

@@ -0,0 +1,70 @@
+class Hash
+
+  unless method_defined?(:stringify_keys)
+    def stringify_keys
+      inject({}) do |options, (key, value)|
+        options[key.to_s] = value
+        options
+      end
+    end
+  end
+
+  unless method_defined?(:stringify_keys!)
+    def stringify_keys!
+      replace(stringify_keys)
+    end
+  end
+
+  unless method_defined?(:symbolize_keys)
+    def symbolize_keys
+      inject({}) do |options, (key, value)|
+        options[(key.to_sym rescue key) || key] = value
+        options
+      end
+    end
+  end
+
+  unless method_defined?(:symbolize_keys!)
+    def symbolize_keys!
+      replace(symbolize_keys)
+    end
+  end
+
+  unless method_defined?(:except)
+    def except(*args)
+      hash = dup
+      args.each {|k| hash.delete(k) }
+      hash
+    end
+  end
+
+  unless method_defined?(:only)
+    def only(*args)
+      hash = {}
+      args.each {|k| hash[k] = self[k] if self.has_key?(k) }
+      hash
+    end
+  end
+
+  def rename_keys(*args)
+    keys = Hash[*args.flatten]
+    keys.each { |k, v| self[v] = delete(k) if self[k] }
+    self
+  end
+
+  def rename_keys!(*args)
+    replace(rename_keys(*args))
+  end
+
+  def symbolize_and_underscore_keys
+    inject({}) do |options, (key, value)|
+      options[(key.to_s.underscore.to_sym rescue key) || key] = value
+      options
+    end
+  end
+
+  def symbolize_and_underscore_keys!
+    replace(symbolize_and_underscore_keys)
+  end
+
+end

data/lib/nobiru/extensions/numeric_extension.rb

@@ -0,0 +1,102 @@
+class Numeric
+
+  unless method_defined?(:multiple_of?)
+    def multiple_of?(number)
+      number != 0 ? modulo(number).zero? : zero?
+    end
+  end
+
+  def negative?
+    self < 0
+  end
+
+  def positive?
+    self > 0
+  end
+
+  def to_byte(from=:b, to=:kb)
+    scalers = { b: 1, kb: 1024 ** 1, mb: 1024 ** 2, gb: 1024 ** 3, tb: 1024 ** 4, pb: 1024 ** 5, eb: 1024 ** 6 }
+
+    to_f * scalers[from] / scalers[to]
+  end
+
+  def to_length(from=:mm, to=:in)
+    imperical_scalers = {
+      mm: 25.4, cm: 2.54, m: 0.0254, km: 0.0000254,
+      in: 1, ft: 12, yd: 36, mi: 63360, nm: 72913.4
+    }
+    metric_scalers    = {
+      mm: 1, cm: 10, m: 1000, km: 1000000,
+      in: 0.039370078740157, ft: 0.0032808398950131, yd: 0.0010936132983377, mi: 0.00000062137119223733, nm: 0.00000053995680345572
+    }
+
+    case to
+    when from
+      self
+    when :mm, :cm, :m, :km
+      if [:in, :ft, :yd, :mi, :nm].include?(from)
+        to_f * imperical_scalers[from] * imperical_scalers[to]
+      else
+        to_f * metric_scalers[from] / metric_scalers[to]
+      end
+    when :in, :ft, :yd, :mi, :nm
+      if [:mm, :cm, :m, :km].include?(from)
+        to_f * metric_scalers[from] * metric_scalers[to]
+      else
+        to_f * imperical_scalers[from] / imperical_scalers[to]
+      end
+    end
+  end
+
+  def to_temperature(from=:c, to=:f)
+    case to
+    when from
+      self
+    when :c, :celsius
+      (to_f - 32) * 5 / 9
+    when :f, :fahrenheit
+      (to_f * 9 / 5) + 32
+    when :k, :kelvin
+      if [:c, :celsius].include?(from)
+        to_f + 273.15
+      else
+        ((to_f - 32) * 5 / 9) + 273.15
+      end
+    end
+  end
+
+  def to_time_unit(from=:sec, to=:min)
+    scalers = { sec: 1, min: 60 ** 1, hr: 60 ** 2, day: (60 ** 2) * 24, yr: (60 ** 2) * 24 * 365 }
+
+    to_f * scalers[from] / scalers[to]
+  end
+
+  def to_weight(from=:g, to=:oz)
+    imperical_scalers = {
+      mg: 28349.523125, cg: 2834.9523125, g: 28.349523125, kg: 0.028349523125, mt: 0.000028349523125,
+      oz: 1, lb: 16, tn: 32000
+    }
+    metric_scalers    = {
+      mg: 1, cg: 10, g: 1000, kg: 1000000, mt: 1000000000,
+      oz: 0.00003527396194958, lb: 0.0000022046226218488, tn: 0.0000000011023113109244
+    }
+
+    case to
+    when from
+      self
+    when :mg, :cg, :g, :kg, :mt
+      if [:oz, :lb, :tn].include?(from)
+        to_f * imperical_scalers[from] * imperical_scalers[to]
+      else
+        to_f * metric_scalers[from] / metric_scalers[to]
+      end
+    when :oz, :lb, :tn
+      if [:mg, :cg, :g, :kg, :mt].include?(from)
+        to_f * metric_scalers[from] * metric_scalers[to]
+      else
+        to_f * imperical_scalers[from] / imperical_scalers[to]
+      end
+    end
+  end
+
+end

data/lib/nobiru/extensions/object_extension.rb

@@ -0,0 +1,29 @@
+class Object
+
+  unless method_defined?(:blank?)
+    def blank?
+      respond_to?(:empty?) ? !!empty? : !self
+    end
+  end
+
+  unless method_defined?(:present?)
+    def present?
+      !blank?
+    end
+  end
+
+  unless method_defined?(:try)
+    def try(method)
+      send(method) if respond_to?(method)
+    end
+  end
+
+  def numeric?
+    !to_s.match(/\A[+-]?\d+?(\.\d+)?\Z/).nil?
+  end
+
+  def palindrome?
+    to_s == to_s.reverse
+  end
+
+end

data/lib/nobiru/extensions/string_extension.rb

@@ -0,0 +1,183 @@
+class String
+
+  unless method_defined?(:camelize)
+    def camelize(first_letter_in_uppercase = true)
+      if first_letter_in_uppercase != :lower
+        to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+      else
+        to_s[0].chr.downcase + camelize(self)[1..-1]
+      end
+    end
+  end
+
+  unless method_defined?(:camelize!)
+    def camelize!(first_letter_in_uppercase = true)
+      replace(camelize(first_letter_in_uppercase))
+    end
+  end
+
+  unless method_defined?(:ends_with?)
+    def ends_with?(suffix)
+      suffix = suffix.to_s
+      self[-suffix.length, suffix.length] == suffix
+    end
+  end
+
+  unless method_defined?(:humanize)
+    def humanize(options = {})
+      underscore.
+      gsub(/_id$/, "").
+      tr('_', ' ').
+      gsub(/([a-z\d]*)/i) { |match| match.downcase }.
+      gsub(/^\w/) { |match| match.upcase } if options.fetch(:capitalize, true)
+    end
+  end
+
+  unless method_defined?(:humanize!)
+    def humanize!(options = {})
+      replace(humanize)
+    end
+  end
+
+  unless method_defined?(:titleize)
+    def titleize
+      underscore.
+      humanize.
+      gsub(/\b(?<!['’`])[a-z]/) { $&.capitalize }
+    end
+  end
+
+  unless method_defined?(:titleize!)
+    def titleize!
+      replace(titleize)
+    end
+  end
+
+  unless method_defined?(:starts_with?)
+    def starts_with?(prefix)
+      prefix = prefix.to_s
+      self[0, prefix.length] == prefix
+    end
+  end
+
+  unless method_defined?(:underscore)
+    def underscore
+      gsub(/::/, '/').
+      gsub(/([A-Z]+)([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 domain(options={})
+    url = dup
+    url =~ (/^(?:\w+:\/\/)?([^\/?]+)(?:\/|\?|$)/) ? $1 : url
+  end
+
+  def downcase?
+    downcase == self
+  end
+
+  def ellipsize(options={})
+     length    = options[:length]    || 30
+     separator = options[:separator] || '...'
+     return self if size <= length
+     offset    = options[:offset]    || 4
+     self[0,offset] + separator + self[-offset,offset]
+  end
+
+  def gnix(string)
+    gsub(string, "")
+  end
+
+  def gnix!(string)
+    gsub!(string, "")
+  end
+
+  def mixedcase?
+    !upcase? && !downcase?
+  end
+
+  def nix(string)
+    sub(string, "")
+  end
+
+  def nix!(string)
+    sub!(string, "")
+  end
+
+  def pollute(delimiter="^--^--^")
+    split('').map{ |letter| "#{letter}#{delimiter}" }.join
+  end
+
+  def slugify
+    gsub(/[^\x00-\x7F]+/, '').    # Remove anything non-ASCII entirely (e.g. diacritics).
+    gsub(/[^\w_ \-]+/i,   '').    # Remove unwanted chars.
+    gsub(/[ \-]+/i,      '-').    # No more than one of the separator in a row.
+    gsub(/^\-|\-$/i,      '').    # Remove leading/trailing separator.
+    downcase
+  end
+
+  def slugify!
+    replace(slugify)
+  end
+
+  def squish
+    strip.gsub(/\s+/, ' ')
+  end
+
+  def squish!
+    replace(squish)
+  end
+
+  def strip_tags
+    gsub(/<\/?[^>]*>/, "")
+  end
+
+  def strip_tags!
+    replace(strip_tags)
+  end
+
+  def strip_whitespace
+    gnix("\t").split(" ").remove_blanks.join(" ")
+  end
+
+  def strip_whitespace!
+    replace(strip_whitespace)
+  end
+
+  def truncate_preserving_words(options={})
+    separator = options[:separator] || '...'
+    max_words = options[:max_words] || nil
+    if max_words
+      words = split
+      return self if words.size < max_words
+      words = words[0..(max_words-1)]
+      words << separator
+      words.join(" ")
+    else
+      max_chars = options[:max_chars] || 30
+      return self if size < max_chars
+      out = self[0..(max_chars-1)].split(" ")
+      out.pop
+      out << separator
+      out.join(" ")
+    end
+  end
+
+  def unpollute(delimiter="^--^--^")
+    gsub(delimiter, "")
+  end
+
+  def upcase?
+    upcase == self
+  end
+
+end

data/lib/nobiru/extensions/time_extension.rb

@@ -0,0 +1,166 @@
+class Time
+
+  def format(string="yyyy-m-d h:n z")
+    delimiters = string.scan /\W+/
+    formatters = string.scan /[a-z0-9_]+/i
+
+    format_units = {
+      ## Date keys
+      "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",
+
+      ## Time keys
+      "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(
+      if string.empty? || string.nil?
+        "%Y-%m-%d %H:%M %z"
+      else
+        formatters.map do |f|
+          "%#{format_units[f]}#{delimiters.shift || ''}"
+        end.join
+      end
+    )
+  end
+
+  def to_format(key=:datetime_iso_tzn)
+    format_units = {
+      ## Date keys
+      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",
+
+      ## Time keys
+      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",
+
+      ## Datetime keys
+      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[key])
+  end
+
+end

data/lib/nobiru/version.rb

@@ -0,0 +1,3 @@
+module Nobiru
+  VERSION = "0.0.1"
+end

data/lib/nobiru.rb

@@ -0,0 +1,8 @@
+require 'nobiru/version'
+require 'nobiru/extensions/array_extension'
+require 'nobiru/extensions/enumerable_extension'
+require 'nobiru/extensions/hash_extension'
+require 'nobiru/extensions/numeric_extension'
+require 'nobiru/extensions/object_extension'
+require 'nobiru/extensions/string_extension'
+require 'nobiru/extensions/time_extension'