kiss 1.1 → 1.7

data/lib/kiss/bench.rb

@@ -25,28 +25,37 @@ class Kiss
   color: #930;
   text-decoration: underline;
 }
+.kiss_bench small {
+  font-family: arial, sans-serif;
+  color: #a60;
+  float: right;
+  margin-left: 8px;
+  position: relative;
+  text-align: right;
+  white-space: nowrap;
+}
 </style>
 EOT
-      html += @benchmarks.map do |item|
+      html += @_benchmarks.map do |item|
         start_link = context_link(item[:start_context])
         end_link = context_link(item[:end_context])
         
         <<-EOT
 <div class="kiss_bench">
-<tt><b>#{item[:label].to_s.gsub(/\</,'&lt;')} duration: #{sprintf("%0.3f",item[:end_time].to_f - item[:start_time].to_f)} s</b></tt>
-<small style="line-height: 105%; display: block; padding-bottom: 3px">kiss bench<br/>started at #{start_link}<br/>ended at #{end_link || 'controller completion'}</small>
+<small style="line-height: 105%; display: block; top: -4px">kiss bench started at #{start_link}<br/>ended at #{end_link || 'request completion'}</small>
+<tt><b>#{(item[:label] || 'unlabeled bench').to_s.gsub(/\</, '&lt;')} - duration: #{sprintf("%0.3f", item[:end_time].to_f - item[:start_time].to_f)} s</b></tt>
 </div>
 EOT
       end.join
       
-      Kiss.html_prepend(html,document,'body')
+      document.prepend_html(html, 'body')
     end
     
     def context_link(context)
       return nil unless context
       
       filename, line, method = context.split(/:/)
-      textmate_url = "txmt://open?url=file://" + h(Kiss.absolute_path(filename)) + '&amp;line=' + line
+      textmate_url = "txmt://open?url=file://" + (Kiss.absolute_path(filename).html_escape) + '&amp;line=' + line
       %Q(<a href="#{textmate_url}">#{filename}:#{line}</a> #{method})
     end
   end

data/lib/kiss/debug.rb

@@ -18,27 +18,35 @@ font-size: 12px;
 color: #101;
 }
 .kiss_debug a {
-color: #707;
+color: #606;
 text-decoration: none;
 }
 .kiss_debug a:hover {
 color: #707;
 text-decoration: underline;
 }
+.kiss_debug small {
+  font-family: arial, sans-serif;
+  color: #949;
+  float: right;
+  margin-left: 8px;
+  text-align: right;
+  white-space: nowrap;
+}
 </style>
 EOT
-      html += @debug_messages.map do |object,context|
+      html += @_debug_messages.map do |object, context|
         filename, line, method = context.split(/:/)
-        textmate_url = "txmt://open?url=file://" + Kiss.url_escape(Kiss.absolute_path(filename)) + '&line=' + line
+        textmate_url = "txmt://open?url=file://" + Kiss.absolute_path(filename).url_escape + '&line=' + line
         <<-EOT
 <div class="kiss_debug">
-<tt><b>#{object.gsub(/\</,'&lt;')}</b></tt>
-<br><small>kiss debug output at <a href="#{textmate_url}">#{filename}:#{line}</a> #{method}</small>
+<small>kiss debug at <a href="#{textmate_url}">#{filename}:#{line}</a> #{method}</small>
+<tt><b>#{object.gsub(/\</, '&lt;')}</b></tt>
 </div>
 EOT
       end.join
       
-      Kiss.html_prepend(html,document,'body')
+      document.prepend_html(html, 'body')
     end
   end
 end

data/lib/kiss/exception_report.rb

@@ -15,7 +15,6 @@ class Kiss
         end
       
         backtrace = exception.backtrace
-        #backtrace.shift while (backtrace[0] =~ /\/lib\/kiss(\/|\.rb)/) || (backtrace[0] =~ /\/lib\/sequel/)
         
         frames = backtrace.map { |line|
           frame = {}
@@ -42,6 +41,13 @@ class Kiss
           end
         }.compact
         
+        i = 0
+        while true do
+          break unless (frames[i].filename =~ /\/lib\/kiss(\/|\.rb)/) || (frames[i].filename =~ /\/lib\/sequel/)
+          i += 1
+        end
+        toggle_frame = frames[i] || frames[0]
+        
         if env
           env["rack.errors"].puts "#{exception.class}: #{exception.message}"
           env["rack.errors"].puts exception.backtrace.map { |l| "\t" + l }
@@ -51,7 +57,11 @@ class Kiss
         db_query = begin (Sequel::MySQL::Database.last_query) rescue nil end
         
         @@erubis ||= Erubis::Eruby.new(template)
-        @@erubis.result(binding)
+        begin
+          @@erubis.result(binding)
+        rescue => e
+          gdebug e.message
+        end
       end
     
       def textmate_href(frame)
@@ -59,308 +69,21 @@ class Kiss
       end
       
       def w(str)
-        str.gsub(/([;\/])/,'\1<wbr/>')
+        str.gsub(/([;\/])/, '\1<wbr/>')
       end
       
-      def h(*args)
-        Kiss.html_escape(*args)
+      def h(str)
+        str.html_escape
       end
-
+      
       # :stopdoc:
-
-  # adapted from Rack::ShowExceptions
-  # Used under the MIT license
-  #
-  # adapted from Django <djangoproject.com>
-  # Copyright (c) 2005, the Lawrence Journal-World
-  # Used under the modified BSD license:
-  # http://www.xfree86.org/3.3.6/COPYRIGHT2.html#5
+      
       def template
-        <<-EOT
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
-<html lang="en">
-<head>
-  <meta http-equiv="content-type" content="text/html; charset=utf-8" />
-  <meta name="robots" content="NONE,NOARCHIVE" />
-  <title>Exception: <%=h exception.class %> - <%=h url %></title>
-  <style type="text/css">
-    html * { padding:0; margin:0; }
-    body *, .body * { padding:10px 20px; }
-    body * *, .body * * { padding:0; }
-    body { font:small sans-serif; }
-    body>div { border-bottom:1px solid #ddd; }
-    h1 { font-weight:normal; font-size: 18px; font-style: italic; color: #d96 }
-    h2 { font-size: 16px; margin-bottom:.8em; }
-    h2 span { font-size:80%; color:#000; font-weight:normal; }
-    h3 { margin:1em 0 .5em 0; }
-    h4 { margin:0 0 .5em 0; font-weight: normal; }
-    small { color #444; }
-    table {
-        border:1px solid #ccc; border-collapse: collapse; background:white; }
-    tbody td, tbody th { vertical-align:top; padding:2px 3px; }
-    thead th {
-        padding:1px 6px 1px 3px; background:#fefefe; text-align:left;
-        font-weight:normal; font-size:11px; border:1px solid #ddd; }
-    tbody th { text-align:right; color:#666; padding-right:.5em; }
-    table.vars { margin:5px 0 2px 40px; }
-    table.vars td, table.req td { font-family:monospace; }
-    table td.code { width:100%;}
-    table td.code div { overflow:hidden; }
-    table.source th { color:#666; }
-    table.source td {
-        font-family:monospace; white-space:pre; border-bottom:1px solid #eee; }
-    ul.traceback { list-style-type:none; }
-    ul.traceback li.frame { padding: 8px; border-top: 1px solid #ccc; }
-    div.context { margin: 6px 0 2px 40px; background-color: #fff; }
-    div.context ol {
-        padding: 1px; margin-bottom: -1px; }
-    div.context ol li {
-        font-family:monospace; color:#666; cursor:pointer; padding: 0 2px; }
-    div.context ol.context-line li { color:black; background-color:#eca; }
-    div.context ol.context-line li span { float: right; }
-    div.commands { margin-left: 40px; }
-    div.commands a { color:black; text-decoration:none; }
-    #summary { background: #ffd; }
-    #summary h2 { font-weight: normal; color: #a10; font-size: 14px; font-weight: bold }
-    #summary ul#quicklinks { list-style-type: none; margin: 0 -8px 2em -8px; font-size: 12px }
-    #summary ul#quicklinks li { float: left; padding: 0 8px; }
-    #summary ul#quicklinks>li+li { border-left: 1px #999 solid; }
-    #summary .info th,#summary .info td { padding-top: 6px }
-    #explanation { background:#eee; }
-    #template, #template-not-exist { background:#f6f6f6; }
-    #template-not-exist ul { margin: 0 0 0 20px; }
-    #traceback { background:#eee; }
-    #requestinfo { background:#f6f6f6; padding-left:120px; }
-    #summary table { border:none; background:transparent; }
-    #requestinfo h2, #requestinfo h3 { position:relative; left:-100px; }
-    #requestinfo h3 { width:100px; margin-right:-100px; margin-bottom:-1.1em; }
-    .error { background: #ffc; }
-    .specific { color:#cc3300; font-weight:bold; }
-  </style>
-  <script type="text/javascript">
-  //<!--
-    function getElementsByClassName(oElm, strTagName, strClassName){
-        // Written by Jonathan Snook, http://www.snook.ca/jon;
-        // Add-ons by Robert Nyman, http://www.robertnyman.com
-        var arrElements = (strTagName == "*" && document.all)? document.all :
-        oElm.getElementsByTagName(strTagName);
-        var arrReturnElements = new Array();
-        strClassName = strClassName.replace(/\-/g, "\\-");
-        var oRegExp = new RegExp("(^|\\s)" + strClassName + "(\\s|$$)");
-        var oElement;
-        for(var i=0; i<arrElements.length; i++){
-            oElement = arrElements[i];
-            if(oRegExp.test(oElement.className)){
-                arrReturnElements.push(oElement);
-            }
-        }
-        return (arrReturnElements)
-    }
-    function hideAll(elems) {
-      for (var e = 0; e < elems.length; e++) {
-        elems[e].style.display = 'none';
-      }
-    }
-    window.onload = function() {
-      hideAll(getElementsByClassName(document, 'table', 'vars'));
-      hideAll(getElementsByClassName(document, 'ol', 'pre-context'));
-      hideAll(getElementsByClassName(document, 'ol', 'post-context'));
-      toggle('pre<%=h frames.first.object_id %>', 'post<%=h frames.first.object_id %>')
-    }
-    function toggle() {
-      for (var i = 0; i < arguments.length; i++) {
-        var e = document.getElementById(arguments[i]);
-        if (e) {
-          e.style.display = e.style.display == 'none' ? 'block' : 'none';
-        }
-      }
-      return false;
-    }
-    
-    function varToggle(link, id) {
-      toggle('v' + id);
-      var s = link.getElementsByTagName('span')[0];
-      var uarr = String.fromCharCode(0x25b6);
-      var darr = String.fromCharCode(0x25bc);
-      s.innerHTML = s.innerHTML == uarr ? darr : uarr;
-      return false;
-    }
-    //-->
-  </script>
-</head>
-<body>
-
-<div id="summary">
-  <a name="summary"></a>
-  <h1><%=h exception.class %></h1>
-  <h2><code><%=(h exception.message).gsub(/\n/,'<br>') %></code></h2>
-  <% if env %>
-  <table class="info"><tr>
-    <th>Ruby</th>
-    <td><code><%=h frames.first.filename %></code>: in <code><%=h frames.first.function %></code>, <a href="<%= textmate_href(frames.first) %>">line <%=h frames.first.lineno %></a></td>
-  </tr><tr>
-    <th>Web</th>
-    <td><code><%=h req.request_method %> <%=h(url)%></code></td>
-  </tr><tr>
-    <th>More</th>
-    <td><ul id="quicklinks">
-    <li><a href="#get-info">GET</a></li>
-    <li><a href="#post-info">POST</a></li>
-    <li><a href="#cache">Cache</a></li>
-    <li><a href="#last-sql">Last SQL</a></li>
-    <li><a href="#cookie-info">Cookies</a></li>
-    <li><a href="#env-info">ENV</a></li>
-  </ul></td>
-  </tr></table>
-  <% end %>
-</div>
-
-<div id="traceback">
-  <h2>Traceback <span>(innermost first)</span></h2>
-  <ul class="traceback">
-<% frames.each { |frame| %>
-      <li class="frame">
-        <a href="<%= textmate_href(frame) %>">line <%= h frame.lineno %></a> of <code><%=w h frame.filename %></code> (in <code><b><%=h frame.function %></b></code>)
-
-          <% if frame.context_line %>
-          <div class="context" id="c<%=h frame.object_id %>">
-              <% if frame.pre_context %>
-              <ol start="<%=h frame.pre_context_lineno+1 %>" class="pre-context" id="pre<%=h frame.object_id %>">
-                <% frame.pre_context.each { |line| %>
-                <li onclick="toggle('pre<%=h frame.object_id %>', 'post<%=h frame.object_id %>')"><%=h line %></li>
-                <% } %>
-              </ol>
-              <% end %>
-
-            <ol start="<%=h frame.lineno %>" class="context-line">
-              <li onclick="toggle('pre<%=h frame.object_id %>', 'post<%=h frame.object_id %>')"><%=h frame.context_line %></li></ol>
-
-              <% if frame.post_context %>
-              <ol start='<%=h frame.lineno+1 %>' class="post-context" id="post<%=h frame.object_id %>">
-                <% frame.post_context.each { |line| %>
-                <li onclick="toggle('pre<%=h frame.object_id %>', 'post<%=h frame.object_id %>')"><%=h line %></li>
-                <% } %>
-              </ol>
-              <% end %>
-          </div>
-          <% end %>
-      </li>
-<% } %>
-  </ul>
-</div>
-
-<% if env %>
-<div id="requestinfo">
-  <h2>Additional information</h2>
-
-  <a name="get-info"></a>
-  <h3 id="get-info">GET</h3>
-  <% unless req.GET.empty? %>
-    <table class="req">
-      <thead>
-        <tr>
-          <th>Variable</th>
-          <th>Value</th>
-        </tr>
-      </thead>
-      <tbody>
-          <% req.GET.sort_by { |k, v| k.to_s }.each { |key, val| %>
-          <tr>
-            <td><%=h key %></td>
-            <td class="code"><div><%=h val.inspect %></div></td>
-          </tr>
-          <% } %>
-      </tbody>
-    </table>
-  <% else %>
-    <p>No GET data.</p>
-  <% end %>
-
-  <a name="post-info"></a>
-  <h3 id="post-info">POST</h3>
-  <% unless req.POST.empty? %>
-    <table class="req">
-      <thead>
-        <tr>
-          <th>Variable</th>
-          <th>Value</th>
-        </tr>
-      </thead>
-      <tbody>
-          <% req.POST.sort_by { |k, v| k.to_s }.each { |key, val| %>
-          <tr>
-            <td><%=h key %></td>
-            <td class="code"><div><%=h val.inspect %></div></td>
-          </tr>
-          <% } %>
-      </tbody>
-    </table>
-  <% else %>
-    <p>No POST data.</p>
-  <% end %>
-    
-  <a name="cache"></a>
-  <h3 id="cache">Cache</h3>
-    <p><code><%=h cache.inspect %></code></p>
-    
-  <a name="last-sql"></a>
-  <h3 id="last-sql">Last SQL</h3>
-    <p><% if sql %><code><%=(h sql).gsub(/\n/,'<br/>') %></code><% else %>n/a<% end %></p>
-
-  <a name="cookie-info"></a>
-  <h3 id="cookie-info">Cookies</h3>
-  <% unless req.cookies.empty? %>
-    <table class="req">
-      <thead>
-        <tr>
-          <th>Variable</th>
-          <th>Value</th>
-        </tr>
-      </thead>
-      <tbody>
-        <% req.cookies.each { |key, val| %>
-          <tr>
-            <td><%=h key %></td>
-            <td class="code"><div><%=h val.inspect %></div></td>
-          </tr>
-        <% } %>
-      </tbody>
-    </table>
-  <% else %>
-    <p>No cookie data.</p>
-  <% end %>
-
-  <a name="env-info"></a>
-  <h3 id="env-info">Rack ENV</h3>
-    <table class="req">
-      <thead>
-        <tr>
-          <th>Variable</th>
-          <th>Value</th>
-        </tr>
-      </thead>
-      <tbody>
-          <% env.sort_by { |k, v| k.to_s }.each { |key, val| %>
-          <tr>
-            <td><%=h key %></td>
-            <td class="code"><div><%=w h val %></div></td>
-          </tr>
-          <% } %>
-      </tbody>
-    </table>
-
-</div>
-<% end %>
-
-<div id="explanation">
-  <p>
-    Generated by Kiss::ExceptionReport.
-  </p>
-</div>
-
-</body>
-</html>
-EOT
+        @@template ||= File.read( template_dir + '/exception_report.html' )
+      end
+      
+      def template_dir
+        @@template_dir = File.dirname(__FILE__) + '/html'
       end
 
       # :startdoc:

data/lib/kiss/ext/core.rb

@@ -0,0 +1,700 @@
+def gdebug(object)
+  Kernel::print %Q(Content-type: text/html\n\n<div style="background-color: #fff">) unless $gdebug_filename || $previous_gdebug
+  $previous_gdebug = true
+  
+  if $gdebug_filename
+    file = File.open($gdebug_filename, 'a')
+    file.print "#{object.inspect}\n    at #{Kernel.caller[0]}\n\n"
+    file.close
+  else
+    Kernel::print "#{object.inspect}<br/><small>at #{Kernel.caller[0]}</small><br/><hr/>"
+  end
+  
+  object
+end
+def gdebug_filename(filename)
+  $gdebug_filename = filename
+end
+alias :debug :gdebug
+
+def trace(object)
+  debug(object)
+end
+
+
+class Module
+  # adapted from Rails, re-written for speed (only one class_eval call)
+  def cattr_reader(*syms)
+    class_eval(
+      syms.flatten.map do |sym|
+        sym.is_a?(Hash) ? '' : %Q(
+          @@#{sym} = nil unless defined? @@#{sym}
+          def self.#{sym}; @@#{sym}; end
+          def #{sym}; @@#{sym}; end
+        )
+      end.join, __FILE__, __LINE__
+    )
+  end
+  
+  # adapted from Rails, re-written for speed (only one class_eval call)
+  def cattr_accessor(*syms)
+    class_eval(
+      syms.flatten.map do |sym|
+        sym.is_a?(Hash) ? '' : %Q(
+          @@#{sym} = nil unless defined? @@#{sym}
+          def self.#{sym}; @@#{sym}; end
+          def self.#{sym}=(v); @@#{sym} = v; end
+          def #{sym}; @@#{sym}; end
+          def #{sym}=(v); @@#{sym} = v; end
+        )
+      end.join, __FILE__, __LINE__
+    )
+  end
+  
+  # protected attribute (ivar) reader
+  def _attr_reader(*syms)
+    class_eval(
+      syms.flatten.map do |sym|
+        sym.is_a?(Hash) ? '' : %Q(
+          @_#{sym} = nil unless defined? @_#{sym}
+          def #{sym}; @_#{sym}; end
+        )
+      end.join, __FILE__, __LINE__
+    )
+  end
+  
+  # protected attribute (ivar) accessor
+  def _attr_accessor(*syms)
+    class_eval(
+      syms.flatten.map do |sym|
+        sym.is_a?(Hash) ? '' : %Q(
+          @_#{sym} = nil unless defined? @_#{sym}
+          def #{sym}; @_#{sym}; end
+          def #{sym}=(v); @_#{sym} = v; end
+        )
+      end.join, __FILE__, __LINE__
+    )
+  end
+  
+  def dsl_accessor(*symbols)
+    class_eval(
+      symbols.map { |sym|
+        %{
+          def #{sym}(*val)
+            if val.empty?
+              @_#{sym}
+            else
+              @_#{sym} = val.size == 1 ? val[0] : val
+            end
+          end
+          def #{sym}=(val)
+            @_#{sym} = val
+          end
+        }
+      }.join)
+  end
+end
+
+class Object
+  def instance_variables_hash
+    new Hash[ instance_variables.map {|k| [k, instance_variable_get(k)] }.flatten ]
+  end
+  def instance_variables_set(h)
+    h.each_pair {|k, v| instance_variable_set(k, v)}
+  end
+  
+  def _instance_variables_set_from_attrs(attrs)
+    attrs.each_pair {|k, v| instance_variable_set(:"@_#{k}", v) }
+  end
+  
+  def import_instance_variables(object)
+    object.instance_variables.each do |v|
+      # skip vars that start with underscore
+      unless v[1, 1] == '_'
+        instance_variable_set(v, object.instance_variable_get(v))
+      end
+    end
+  end
+  def export_instance_variables(object)
+    object.import_instance_variables(self)
+  end
+  
+  def validate(*args)
+    to_s.validate(*args)
+  end
+  def url_escape(*args)
+    to_s.url_escape(*args)
+  end
+  def html_escape(*args)
+    to_s.html_escape(*args)
+  end
+end
+
+# Methods to enable hash.attr == hash[attr] syntax,
+# including hash.id and hash.type
+class Hash
+  def method_missing(meth, *args)
+    meth = meth.id2name
+    if meth =~ /=\Z/
+      self[meth[0...-1]] = (args.length<2 ? args[0] : args)
+    elsif meth.to_s =~ /(\w+)\?\Z/
+      !(self[$1] || self[$1.to_sym]).zero?
+    else
+      self[meth] || self[meth.to_sym]
+    end
+  end
+  def id
+    self['id'] || self [:id]
+  end
+  def type
+    self['type'] || self [:type] || Hash
+  end
+  
+  def prepend_html(*args)
+    self[:body].prepend_html(*args)
+  end
+  
+  def to_query_string
+    self.keys.map {|k| "#{k.url_escape}=#{self[k]}" }.join('&')
+  end
+end
+
+module Enumerable
+  def hash_by_key(key)
+    hash = {}
+    each do |item|
+      hash[item[key]] = item
+    end
+    hash
+  end
+  
+  def hash_by_keys(*keys)
+    last_key = keys.pop
+    raise 'no keys given' unless last_key
+    
+    hash = {}
+    each do |item|
+      h = hash
+      keys.each do |key|
+        h = (h[item[key]] ||= {})
+      end
+      h[item[last_key]] = item
+    end
+    hash
+  end
+  
+  def hash_by_id
+    hash_by_key(:id)
+  end
+  
+  def hash_values_by_key(value_key, hash_key)
+    hash = {}
+    each do |item|
+      hash[item[hash_key]] = item[value_key]
+    end
+    hash
+  end
+  
+  def hash_values_by_keys(value_key, *hash_keys)
+    last_key = hash_keys.pop
+    raise 'no keys given' unless last_key
+    
+    hash = {}
+    each do |item|
+      h = hash
+      hash_keys.each do |key|
+        h = (h[item[key]] ||= {})
+      end
+      h[item[hash_key]] = item[value_key]
+    end
+    hash
+  end
+  
+  def hash_arrays_by_key(key)
+    hash = {}
+    each do |item|
+      (hash[item[key]] ||= []) << item
+    end
+    hash
+  end
+  
+  def hash_arrays_by_keys(*keys)
+    last_key = keys.pop
+    hash = {}
+    each do |item|
+      h = hash
+      keys.each do |key|
+        h = (h[item[key]] ||= {})
+      end
+      (h[item[last_key]] ||= []) << item
+    end
+    hash
+  end
+  
+  def hash_arrays_by_id
+    hash_arrays_by_key(:id)
+  end
+  
+  def hash_with_keys(*args)
+    first_arg = args.first
+    args = first_arg if first_arg.is_a?(Array)
+    
+    hash = {}
+    (0...length).each do |i|
+      hash[args[i]] = self[i]
+    end
+    hash
+  end
+  
+  def hash_pairs
+    Hash[*self]
+  end
+  
+  def ids
+    map {|item| item.id }
+  end
+  
+  def join_unless_empty(delimiter, none = 'None')
+    self.empty? ? none : self.join(delimiter)
+  end
+  
+  def conjoin(conjunction = 'and')
+    size = self.size
+    return join if size < 2
+    return join(" #{conjunction} ") if size == 2
+
+    array = clone
+    last = array.pop
+    "#{array.join(', ')}, #{conjunction} #{last}"
+  end
+  alias_method :join_with_conjunction, :conjoin
+  
+  def to_table(*columns)
+    options = columns.last.is_a?(Hash) ? columns.pop : {}
+    raise 'no columns specified' if columns.empty?
+    
+    column_delimiter = options[:column_delimiter] || "\t"
+    line_delimiter = options[:line_delimiter] || "\r\n"
+    
+    [
+      columns.map do |column|
+        column = column[0] if column.is_a?(Array)
+        column.is_a?(String) ? column : column.to_s.titlecase
+      end.flatten.join(column_delimiter),
+    
+      *(map do |object|
+        columns.map do |column|
+          column = column[1] if column.is_a?(Array)
+          column.is_a?(Proc) ? column.call(object) : object[column]
+        end.flatten.join(column_delimiter)
+      end + [nil])
+    ].join(line_delimiter)
+  end
+end
+
+class Array
+  def of(unit)
+    size.of(unit)
+  end
+  
+  def resize(new_size, filler = nil)
+    current_size = size
+    if new_size < current_size
+      slice!(new_size, current_size)
+    else
+      fill(filler, current_size, new_size - current_size)
+    end
+    self
+  end
+  
+  # Convert array of function parameters to a single attributes hash.
+  # Each parameter must be a Symbol, except for the last, which may be
+  # a Symbol or an attributes hash.
+  def to_attrs
+    attrs = last.is_a?(Hash) ? pop : {}
+    self.each {|arg| attrs[arg] = true }
+    attrs
+  end
+end
+
+# Enables FixNum conversion to time duration values (in seconds).
+class Fixnum
+  # 2.weeks = 14.days
+  def weeks
+    self * 7.days
+  end
+  # 1.days = 24.hours
+  def days
+    self * 24.hours
+  end
+  # 1.hours = 60.minutes = 3600 (seconds)
+  def hours
+    self * 60.minutes
+  end
+  # 1.minutes = 60 (seconds)
+  # 5.minutes = 300 (seconds)
+  def minutes
+    self * 60
+  end
+  # 5.minutes.ago = Time.now - 300
+  def ago
+    Time.now - self
+  end
+  
+  # format thousands
+  def format_thousands
+    to_s.reverse.gsub(/(\d{3})/, '\1,').sub(/\,(-?)$/, '\1').reverse
+  end
+end
+
+TimeMethods = proc do
+  # timezone conversion
+  alias_method :old_zone, :zone
+  def zone
+    @timezone ? @timezone.period_for_utc(@utc).abbreviation.to_s : old_zone
+  end
+  
+  def set_timezone!(timezone, utc)
+    @timezone = timezone
+    @utc = utc
+    self
+  end
+  
+  def to_timezone(timezone)
+    timezone = TZInfo::Timezone.get(timezone) if timezone.is_a?(String)
+    timezone.utc_to_local(to_utc).set_timezone!(timezone, self)
+  end
+  
+  def from_timezone(timezone)
+    timezone = TZInfo::Timezone.get(timezone) if timezone.is_a?(String)
+    timezone.local_to_utc(self)
+  end
+  
+  def to_utc
+    @timezone ? from_timezone(@timezone) : self
+  end
+  
+  # string representations
+  
+  def md
+    strftime("%m/%d")
+  end
+  
+  def md_full
+    strftime("%B %e")
+  end
+  alias_method :md_long, :md_full
+  
+  def md_abbrev
+    strftime("%b %e")
+  end
+  
+  def my_full
+    strftime("%B %Y")
+  end
+  alias_method :my_long, :my_full
+  
+  def my_abbrev
+    strftime("%b %Y")
+  end
+  
+  def mdy
+    strftime("%m/%d/%Y")
+  end
+  def ymd
+    strftime("%Y-%m-%d")
+  end
+  
+  def mdy_full
+    strftime("%B %e, %Y")
+  end
+  alias_method :mdy_long, :mdy_full
+  
+  def mdy_abbrev
+    strftime("%b %e, %Y")
+  end
+  
+  def mdy_hm
+    strftime("%m/%d/%Y %l:%M %p")
+  end
+  def mdy_hmz
+    strftime("%m/%d/%Y %l:%M %p " + zone)
+  end
+  def mdy_hms
+    strftime("%m/%d/%Y %l:%M:%S %p")
+  end
+  def mdy_hmsz
+    strftime("%m/%d/%Y %l:%M:%S %p " + zone)
+  end
+  
+  def ymd_hm
+    strftime("%Y-%m-%d %l:%M %p")
+  end
+  def ymd_hmz
+    strftime("%Y-%m-%d %l:%M %p " + zone)
+  end
+  def ymd_hms
+    strftime("%Y-%m-%d %l:%M:%S %p")
+  end
+  def ymd_hmsz
+    strftime("%Y-%m-%d %l:%M:%S %p " + zone)
+  end
+  
+  def sql
+    strftime("%Y-%m-%d %H:%M:%S")
+  end
+  
+  def mdy_hm_full
+    strftime("%B %e, %Y, %l:%M %p")
+  end
+  alias_method :mdy_hm_long, :mdy_hm_full
+  def mdy_hmz_full
+    strftime("%B %e, %Y, %l:%M %p " + zone)
+  end
+  alias_method :mdy_hmz_long, :mdy_hmz_full
+  
+  def mdy_at_hm_full
+    strftime("%B %e, %Y at %l:%M %p")
+  end
+  alias_method :mdy_at_hm_long, :mdy_at_hm_full
+  def mdy_at_hmz_full
+    strftime("%B %e, %Y at %l:%M %p " + zone)
+  end
+  alias_method :mdy_at_hmz_long, :mdy_at_hmz_full
+  
+  def hm
+    strftime("%l:%M %p")
+  end
+  def hmz
+    strftime("%l:%M %p " + zone)
+  end
+  def hms
+    strftime("%l:%M:%S %p")
+  end
+  def hmsz
+    strftime("%l:%M:%S %p " + zone)
+  end
+  
+  def hm_mdy
+    strftime("%l:%M %p, %m/%d/%Y")
+  end
+  def hmz_mdy
+    strftime("%l:%M %p #{zone}, %m/%d/%Y")
+  end
+  def hms_mdy
+    strftime("%l:%M:%S %p, %m/%d/%Y")
+  end
+  def hmsz_mdy
+    strftime("%l:%M:%S %p #{zone}, %m/%d/%Y")
+  end
+  
+  def hm_mdy_full
+    strftime("%l:%M %p, %B %e, %Y")
+  end
+  alias_method :hm_mdy_long, :hm_mdy_full
+  def hmz_mdy_full
+    strftime("%l:%M %p #{zone}, %B %e, %Y")
+  end
+  alias_method :hmz_mdy_long, :hmz_mdy_full
+  
+  def zero?; false; end
+  
+  def is_between?(start_date, end_date)
+    self >= start_date && self < end_date
+  end
+end
+
+Date.class_eval &TimeMethods
+Time.class_eval &TimeMethods
+
+class NilClass
+  def mdy; ''; end
+  def mdy_hm; ''; end
+  def mdy_hms; ''; end
+  def mdy_hm_full; ''; end
+  def mdy_hm_long; ''; end
+  def hm_mdy; ''; end
+  def hms_mdy; ''; end
+  def hm_mdy_full; ''; end
+  def hm_mdy_long; ''; end
+  def ymd_hm; ''; end
+  def ymd_hms; ''; end
+  def sql; ''; end
+  
+  def to_dollars; ''; end
+  def to_dollars_cents; ''; end
+  
+  def size; 0; end
+  def length; 0; end
+  
+  def empty?; true; end
+  def blank?; true; end
+  def zero?; true; end
+  
+  def unless_blank(blank_value); blank_value; end
+  
+  # Ruby default: nil.id == 4 (now deprecated, but still present in 1.8)
+  # can cause unexpected results when using id from nil Sequel results
+  # so we'll raise an error instead, effectively undefining 'id' method
+  def id
+    raise NoMethodError, "undefined method `id' for nil:NilClass"
+  end
+end
+
+class String
+  class << self
+    # Generates string of random text of the specified length.
+    def random(length)
+      chars = [('A'..'H'), ('J'..'N'), ('P'..'R'), ('T'..'Y'), ('3'..'4'), ('6'..'9')].map {|r| r.to_a }.flatten  # array
+  
+      text = ''
+      size = chars.size
+      length.times { text += chars[rand(size)] }
+    
+      text
+    end
+  end
+  
+  def commaize(places = 3)
+    s = reverse
+    while s.sub!(/(\d{3})(\d)/, '\1,\2')
+      next
+    end
+    s.reverse
+  end
+  def blank?
+    self !~ /\S/
+  end
+  
+  def to_const(klass = Kernel)
+    begin
+      parts = self.split(/::/)
+      while (next_part = parts.shift)
+        klass = klass.const_get(next_part)
+      end
+      
+      klass
+    rescue
+      raise "Constant '#{self}' not defined"
+    end
+  end
+  
+  def content_length
+    bytesize rescue length
+  end
+  
+  def remove_tags
+    gsub(/<\/?[^>]*>/, "")
+  end
+  alias_method :strip_tags, :remove_tags
+  
+  # adapt underscore method to convert whitespace to underscores
+  alias_method :original_sequel_underscore, :underscore
+  def underscore
+    original_sequel_underscore.gsub(/\W+/, '_').sub(/_\Z/, '')
+  end
+  
+  # adapt titlecase method to downcase short prepositions in middle
+  alias_method :original_sequel_titlecase, :titlecase
+  def titlecase
+    original_sequel_titlecase.gsub(/(\S)( +)(at|for|in|of|on|to)( +)(\S)/i) {"#{$1}#{$2}#{$3.downcase}#{$4}#{$5}"}
+  end
+  alias_method :titleize, :titlecase
+  
+  def adjective
+    gsub(/\s/, '-')
+  end
+  alias_method :adjectivize, :adjective
+  
+  def unless_blank(alt_value = nil)
+    self.blank? ? alt_value : self
+  end
+  def unless_equal_to(value, alt_value = nil)
+    (self == value) ? alt_value : self
+  end
+  
+  # Prepend addition just inside the specified tag of document.
+  def prepend_html(addition, tag)
+    regexp = /(\<#{tag}[^\>]*\>)/i
+    self =~ regexp ? sub(regexp, '\1' + addition) : (addition + self)
+  end
+  
+  def html_escape
+    Rack::Utils.escape_html(self)
+  end
+  
+  def url_escape
+  	# encode space to '+'; don't encode letters, numbers, periods
+    gsub(/([^\w\.])/) { sprintf("%%%02X", $&.unpack("C")[0]) }
+  end
+  alias_method :url_encode, :url_escape
+  
+  # Adapted from Rack::Utils.unescape.
+  def url_unescape
+    self.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n) do
+      [$1.delete('%')].pack('H*')
+    end
+  end
+  
+  # Validates value against specified format.
+  # If required is true, value must contain a non-whitespace character.
+  # If required is false, value need not match format if and only if value contains only whitespace.
+  def validate(format, options = {})
+    label = options[:label] || 'value'
+    if options[:required] && (self.blank?)
+      # value required
+      raise "#{label} required and missing"
+    elsif format && !self.blank?
+      format_class = Kiss::Format.lookup(format)
+      
+      begin
+        format_class.validate(self, options[:context] || {})
+      rescue Kiss::Format::ValidateError => e
+        raise "validation error on #{label}: #{e.message}"
+      end
+    end
+  end
+end
+
+class Symbol
+  def to_const
+    self.to_s.to_const
+  end
+end
+
+class Numeric
+  def commaize
+    to_s.commaize
+  end
+  
+  def to_places(num_places)
+    sprintf("%0.#{num_places}f", self)
+  end
+  
+  def to_dollars
+    commaize
+  end
+  
+  def to_dollars_cents
+    to_places(2).commaize
+  end
+  alias_method :format_currency, :to_dollars_cents
+  
+  def quantity(unit)
+    "#{self.commaize} #{ self != 1 ? unit.pluralize : unit }"
+  end
+  alias_method :of, :quantity
+end
+
+module Digest
+  {
+    :MD5 => "digest/md5",
+    :RMD160 => "digest/rmd160",
+    :SHA1 => "digest/sha1",
+    :SHA256 => "digest/sha2",
+    :SHA384 => "digest/sha2",
+    :SHA512 => "digest/sha2"
+  }.each_pair do |type, path|
+    autoload type, path
+  end
+end