mack_ruby_core_extensions 0.0.1

data/lib/extensions/class.rb

@@ -0,0 +1,19 @@
+class Class
+  
+  def self.new_instance_of(klass_name)
+    mod = Module
+    mod = mod.const_get(klass_name)
+    mod.new
+  end
+  
+  def class_is_a?(klass_name)
+    self.ancestors.each do |an|
+      if an == klass_name
+        return true
+      end
+    end
+    return false
+  end
+  
+end
+  

data/lib/extensions/dir.rb

@@ -0,0 +1,25 @@
+class Dir
+  
+  
+  #creates multiple directories
+  def self.make_dirs(path)
+    dir_names = path.split('/')
+    new_path=""
+    dir_names.each do |x|
+       new_path = new_path  << x << '/'
+       if !File.directory?(new_path)
+         Dir.mkdir(new_path)
+       end
+    end
+   end
+   
+   
+   #if a directory exists, it deletes everything in it, otherwise it creates the directory
+   def self.prep_dir(path)
+     if File.directory?(path)
+       Dir.foreach(path) {|x| File.delete(path + x) unless File.directory?(path + x)}
+     else
+       Dir.make_dirs(path)
+     end
+   end
+end

data/lib/extensions/float.rb

@@ -0,0 +1,5 @@
+class Float
+  def prec(x)
+    sprintf("%01.#{x}f", self).to_f
+  end
+end

data/lib/extensions/hash.rb

@@ -0,0 +1,47 @@
+class Hash
+  
+  def join(pair_string, join_string)
+    a = []
+    self.each_pair do |k, v|
+      a << sprintf(pair_string, k, v)
+    end
+    a.join(join_string)
+  end
+  
+  # Deletes the key(s) passed in from the hash.
+  def -(ars)
+    [ars].flatten.each {|a| self.delete(a)}
+    self
+  end
+  
+  # Converts a hash to query string parameters. 
+  # An optional boolean escapes the values if true, which is the default.
+  def to_params(escape = true)
+    params = ''
+    stack = []
+    
+    each do |k, v|
+      if v.is_a?(Hash)
+        stack << [k,v]
+      else
+        v = Rack::Utils.escape(v) if escape
+        params << "#{k}=#{v}&"
+      end
+    end
+    
+    stack.each do |parent, hash|
+      hash.each do |k, v|
+        if v.is_a?(Hash)
+          stack << ["#{parent}[#{k}]", v]
+        else
+          v = Rack::Utils.escape(v) if escape
+          params << "#{parent}[#{k}]=#{v}&"
+        end
+      end
+    end
+    
+    params.chop! # trailing &
+    params
+  end
+  
+end

data/lib/extensions/kernel.rb

@@ -0,0 +1,30 @@
+require 'pp'
+require 'stringio'
+
+module Kernel
+  
+  def self.pp_to_s(object)
+    pp_out = StringIO.new
+    PP.pp(object,pp_out)
+    return pp_out.string
+  end
+  
+  def retryable(options = {}, &block)
+    opts = { :tries => 1, :on => Exception }.merge(options)
+
+    retries = opts[:tries]
+    retry_exceptions = [opts[:on]].flatten
+    
+    x = %{
+      begin
+        return yield
+      rescue #{retry_exceptions.join(", ")} => e
+        retries -= 1
+        retry if retries > 0
+      end        
+    }
+
+    eval(x, &block)
+  end
+  
+end

data/lib/extensions/math.rb

@@ -0,0 +1,15 @@
+module Math
+
+  def self.log2(x)
+     self.log(x)/self.log(2.0)
+  end
+
+  def self.min(a, b)
+     a < b ? a : b
+  end
+
+  def self.max(a, b)
+     a > b ? a : b
+  end
+
+end

data/lib/extensions/method_not_implemented.rb

@@ -0,0 +1,12 @@
+=begin rdoc
+  This exception is thrown if there is a method that has not been implemented that needs to be.
+=end
+class MethodNotImplemented < Exception
+  
+  def initialize(meth, msg = nil)
+    mess = "#{meth} has not been implemented!\nPlease implement this method!\nIf you do not understand what this method is supposed to do, please consult the RDoc for more information."
+    mess += "\n#{msg}" unless msg.nil?
+    super(mess)
+  end
+  
+end

data/lib/extensions/module.rb

@@ -0,0 +1,29 @@
+class Module
+  
+  # Bulk converts the security level of methods in this Module from one level to another.
+  def convert_security_of_methods(old_level = :public, new_level = :protected)
+    eval("#{old_level}_instance_methods").each{ |meth| self.send(new_level, meth) }
+    self
+  end
+  
+  # Includes this module into an Object, and changes all public methods to protected.
+  # 
+  # Examples:
+  #   module MyCoolUtils
+  #     def some_meth
+  #       "hi"
+  #     end
+  #     self.include_safely_into(FooController)
+  #   end
+  # or:
+  #   MyCoolUtils.include_safely_into(FooController, SomeOtherClass)
+  def include_safely_into(*args)
+    [args].flatten.each do |a|
+      if a.is_a?(String) || a.is_a?(Symbol)
+        a = a.to_s.constantize
+      end
+      a.send(:include, self.convert_security_of_methods)
+    end
+  end
+  
+end

data/lib/extensions/nil.rb

@@ -0,0 +1,8 @@
+class NilClass
+  
+  # Will always allow true since nil's are well, nils.
+  def blank?
+    true
+  end
+  
+end

data/lib/extensions/object.rb

@@ -0,0 +1,103 @@
+class Object
+  
+  # This method gets called when a parameter is passed into a named route.
+  # This can be overridden in an Object to provlde custom handling of parameters.
+  def to_param
+    self.to_s
+  end
+  
+  def running_time(message = "", logger = nil)
+    s_time = Time.now
+    s = "---Starting at #{s_time}---"
+    puts s
+    logger.info s unless logger.nil?
+    yield if block_given?
+    e_time = Time.now
+    e = "---Ending at #{e_time}---"
+    puts e
+    logger.info e unless logger.nil?
+    secs = e_time - s_time
+    if secs < 60
+      x = "Running time #{secs} seconds."
+    else
+      x = "Running time roughly #{secs/60} minutes [#{secs} seconds]"
+    end
+    x += " [MESSAGE]: #{message}" unless message.blank?
+    puts x
+    logger.info x unless logger.nil?
+  end
+  
+  def send_with_chain(methods, *args)
+    obj = self
+    methods = [methods] unless methods.is_a?(Array)
+    methods.each {|m| obj = obj.send(m, *args)}
+    obj
+  end
+  
+=begin
+  ivar_cache allows you to cache the results of the block into an instance variable in a class,
+  and then will serve up that instance variable the next time you call that method again.
+
+  old way:
+  def show_page_link
+    unless @show_page_link # check if instance variable exists
+      # if the instance variable doesn't exist let's do some work and assign it to the instance variable.
+      @show_page_link = link_to("show", some_url(:id => self.id, :foo => bar, etc... => etc))
+    end
+    @show_page_link # now return the instance variable
+  end
+
+  new way:
+  def show_page_link
+    ivar_cache do
+      link_to("show", some_url(:id => self.id, :foo => bar, etc... => etc))
+    end
+  end
+
+  this does everything the old way did, but it is much cleaner, and a lot less code!
+  in case you're wondering it caches the result, by default, to an instance variable named after the method,
+  so in our above example the instance variable would be name, @show_page_link. this can be overridden like such:
+
+  def show_page_link
+    ivar_cache("foo_var") do
+      link_to("show", some_url(:id => self.id, :foo => bar, etc... => etc))
+    end
+  end
+
+  now it will cache it to @foo_var
+=end  
+  def ivar_cache(var_name = nil, &block)
+    if var_name.nil?
+      call = caller[0]
+      var_name = call[(call.index('`')+1)...call.index("'")]
+    end
+    var = instance_variable_get("@#{var_name}")
+    unless var
+      return instance_variable_set("@#{var_name}", yield) if block_given?
+    end
+    instance_variable_get("@#{var_name}")
+  end
+  
+  def ivar_cache_clear(var_name = nil, &block)
+    if var_name.nil?
+      call = caller[0]
+      var_name = call[(call.index('`')+1)...call.index("'")]
+    end
+    remove_instance_variable("@#{var_name}") rescue
+    yield if block_given?
+  end
+  
+  def namespaces
+    ivar_cache("object_namespaces") do
+      nss = []
+      full_name = self.class.name.to_s
+      ns = full_name.split("::")
+      ns.each do |n|
+        nss << n
+      end
+      nss.pop
+      nss
+    end
+  end
+  
+end

data/lib/extensions/string.rb

@@ -0,0 +1,261 @@
+require 'digest'
+class String
+  
+  # Camel cases the string.
+  # 
+  # Examples: 
+  #   "user".camelcase # => User
+  #   "my_blog".camelcase # => MyBlog
+  #   "my/blog".camelcase # => My::Blog
+  def camelcase
+    self.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+  end
+  
+  # Returns a constant of the string.
+  # 
+  # Examples:
+  #   "User".constantize # => User
+  #   "HomeController".constantize # => HomeController
+  #   "Mack::Configuration" # => Mack::Configuration
+  def constantize
+    Module.instance_eval("::#{self}")
+  end
+  
+  # If the string is empty, this will return true.
+  def blank?
+    self == ""
+  end
+  
+  # Maps to Mack::Utils::Inflector.instance.pluralize
+  def plural
+    Mack::Utils::Inflector.instance.pluralize(self)
+  end
+  
+  # Maps to Mack::Utils::Inflector.instance.singularize
+  def singular
+    Mack::Utils::Inflector.instance.singularize(self)
+  end
+  
+  def linkify(enabled = true, options = {}, &block)
+    text = self.dup
+    m = text.match(/\"([^"]+)\"\:([^:]+\:\S+)/)
+    until m.nil?
+      y = m.to_s
+      t = m[1]
+      url = m[2]
+
+      # The code below handles punctuation or p tags being mistakenly added to the url when the link is at the end of a sentence or body
+      url_punct_match = /\W*[&nbsp;]*[\<\/p\>]*$/.match(url)
+      punct = ''
+      if url_punct_match && url_punct_match[0] != ""
+        url.chomp!(url_punct_match[0])
+        punct = url_punct_match[0] unless url_punct_match == "="
+      end
+
+      if block_given?
+        if enabled
+          ret = yield t, url, options
+          text.gsub!(y, ret)
+        else
+          text.gsub!(y, t.to_s)
+        end
+      else
+        if enabled
+          text.gsub!(y, "<a href=\"#{url}\" #{options.join("%s=\"%s\"", " ")}>#{t}</a>#{punct}")# punct places punctuation back into proper place
+        else
+          text.gsub!(y, t.to_s)
+        end
+      end
+      m = text.match(/\"([^"]+)\"\:([^:]+\:\S+)/)
+    end
+    return text
+  end
+  
+  def methodize
+    x = self
+    
+    # if we get down to a nil or an empty string raise an exception! 
+    raise NameError.new("#{self} cannot be converted to a valid method name!") if x.nil? || x == ''
+    
+    # get rid of the big stuff in the front/back
+    x.strip!
+    
+    # if we get down to a nil or an empty string raise an exception! 
+    raise NameError.new("#{self} cannot be converted to a valid method name!") if x.nil? || x == ''
+    
+    x = x.underscore
+    
+    # get rid of spaces and make the _
+    x.gsub!(' ', '_')
+    # get rid of everything that isn't 'safe' a-z, 0-9, ?, !, =, _
+    x.gsub!(/([^ a-zA-Z0-9\_\?\!\=]+)/n, '_')
+    
+    # if we get down to a nil or an empty string raise an exception! 
+    raise NameError.new("#{self} cannot be converted to a valid method name!") if x.nil? || x == ''
+    
+    # condense multiple 'safe' non a-z chars to just one.
+    # ie. ___ becomes _ !!!! becomes ! etc...
+    [' ', '_', '?', '!', "="].each do |c|
+      x.squeeze!(c)
+    end
+    
+    # if we get down to a nil or an empty string raise an exception! 
+    raise NameError.new("#{self} cannot be converted to a valid method name!") if x.nil? || x == ''
+    
+    #down case the whole thing
+    x.downcase!
+    
+    # get rid of any characters at the beginning that aren't a-z
+    while !x.match(/^[a-z]/)
+      x.slice!(0)
+      
+      # if we get down to a nil or an empty string raise an exception! 
+      raise NameError.new("#{self} cannot be converted to a valid method name!") if x.nil? || x == ''
+    end
+    
+    # let's trim this bad boy down a bit now that we've cleaned it up, somewhat.
+    # we should do this before cleaning up the end character, because it's possible to end up with a 
+    # bad char at the end if you trim too late.
+    x = x[0..100] if x.length > 100
+    
+    # get rid of any characters at the end that aren't safe
+    while !x.match(/[a-z0-9\?\!\=]$/)
+      x.slice!(x.length - 1)
+      # if we get down to a nil or an empty string raise an exception! 
+      raise NameError.new("#{self} cannot be converted to a valid method name!") if x.nil? || x == ''
+    end
+    
+    # if we get down to a nil or an empty string raise an exception! 
+    raise NameError.new("#{self} cannot be converted to a valid method name!") if x.nil? || x == ''
+    
+    # let's get rid of characters that don't belong in the 'middle' of the method.
+    orig_middle = x[1..(x.length - 2)]
+    n_middle = orig_middle.dup
+    
+    ['?', '!', "="].each do |c|
+      n_middle.gsub!(c, "_")
+    end
+    
+    # the previous gsub can leave us with multiple underscores that need cleaning up.
+    n_middle.squeeze!("_")
+    
+    x.gsub!(orig_middle, n_middle)
+    x.gsub!("_=", "=")
+    x
+  end
+  
+  def underscore
+    camel_cased_word = self.dup
+    camel_cased_word.to_s.gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+  end
+  
+  def starts_with?(x)
+    self.match(/^#{x}/) ? true : false
+  end
+  
+  def ends_with?(x)
+    self.match(/#{x}$/) ? true : false
+  end
+  
+  # Returns "is" or "are" based on the number, i.e. "i=6; There #{isare(i)} #{i} topics here."
+  def self.pluralize_word(num, vals = ["is", "are"])
+    return vals[0] if num.to_i==1
+    return vals[1]
+  end
+  
+  def remove(val)
+    gsub(val, '')
+  end
+  
+  def remove!(val)
+    gsub!(val, '')
+  end
+  
+  # makes long strings of unbroken characters wrap inside elements (hopefully! tested in Safari, Firefox, and IE for Windows)
+  # For documentation about this kind of workaround to this browser compatibility problem please see the following URL's:
+  # http://www.quirksmode.org/oddsandends/wbr.html
+  # http://krijnhoetmer.nl/stuff/css/word-wrap-break-word/
+  # note: if the txt has spaces, this will only try to break up runs of non-space characters longer than "every" characters
+  def breakify(every = 30)
+    every = 1 if every < 1
+    text = self
+    textile_regex = /\"([^\"]+)\":([^:]*:[\/\/]{0,1}[^ ]*)/
+    long_regex = /\S{#{every},}/
+    brokentxt = text.gsub(long_regex) do |longword|
+      if longword =~ textile_regex #if the longword is a textile link...ignore and recheck for the link text only
+        textile_link = textile_regex.match(longword)[0]
+        link_text = textile_regex.match(longword)[1]
+        longword = link_text
+        if longword =~ long_regex #link text is long...allow break
+          textile_link.scan(/.{1,#{every}}/).join("<wbr/>")
+        else
+          textile_link #the url is what triggered the match...so leave it alone
+        end
+      else
+        longword.scan(/.{1,#{every}}/).join("<wbr/>") #no textile link matched
+      end
+    end
+    #text = %Q[<span style='word-wrap:break-word;wbr:after{content:"\\00200B"}'>#{brokentxt}</span>]
+    #brokentxt.gsub("<wbr/>", "<br />")
+    brokentxt.gsub("<wbr/>", " ")
+  end
+  
+  def breakify!(every = 30)
+    self.replace(self.breakify(every))
+  end
+  
+  def hexdigest
+    Digest::SHA1.hexdigest(self.downcase)
+  end                                    
+  
+  def hexdigest!
+    self.replace(self.hexdigest)
+  end
+  
+  def self.randomize(length = 10)
+    chars = ("A".."H").to_a + ("J".."N").to_a + ("P".."T").to_a + ("W".."Z").to_a + ("3".."9").to_a
+    newpass = ""
+    1.upto(length) { |i| newpass << chars[rand(chars.size-1)] }
+    return newpass.upcase
+  end 
+  
+  def truncate(length = 30, truncate_string = "...")
+    if self.nil? then return end
+    l = length - truncate_string.length
+    if $KCODE == "NONE"
+      self.length > length ? self[0...l] + truncate_string : self
+    else
+      chars = self.split(//)
+      chars.length > length ? chars[0...l].join + truncate_string : self
+    end
+  end
+  
+  def truncate!(length = 30, truncate_string = "...")
+    self.replace(self.truncate(length, truncate_string))
+  end
+  
+  def capitalize_all_words
+    self.gsub(/\b\w/) {|s| s.upcase}
+  end
+  
+  def capitalize_all_words!
+    self.replace(self.capitalize_all_words)
+  end
+  
+  # keep adding on to this whenever it becomes apparent that unsafe strings
+  # could get passed through into the database
+  def sql_safe_str
+    if !self.nil?
+      self.gsub(/[\']/, "\'\'")
+    end
+  end
+  
+  def sql_safe_str! 
+    self.replace(self.sql_safe_str)
+  end
+  
+end