aslakjo-aslakjo-comatose 2.0.5.1

data/lib/support/class_options.rb

@@ -0,0 +1,36 @@
+class Class
+  def define_option(name, default=nil)
+    sym = name.to_sym
+    cattr_reader(sym)
+    cattr_writer(sym)
+    send("#{name.to_s}=", default)
+  end
+  
+  def blockable_attr_accessor(sym)
+    module_eval(<<-EVAL, __FILE__, __LINE__)
+      def #{sym}(&block)
+        if block_given?
+          @#{sym} = block
+        else
+          @#{sym}
+        end
+      end
+      def #{sym}=(value)
+        @#{sym} = value
+      end
+    EVAL
+  end
+end
+
+class Module
+  def attr_accessor_with_default(sym, default = nil, &block)
+    raise 'Default value or block required' unless !default.nil? || block
+    define_method(sym, block_given? ? block : Proc.new { default })
+    module_eval(<<-EVAL, __FILE__, __LINE__)
+      def #{sym}=(value)
+        class << self; attr_reader :#{sym} end
+        @#{sym} = value
+      end
+    EVAL
+  end
+end

data/lib/support/inline_rendering.rb

@@ -0,0 +1,48 @@
+# Extends the view to support rendering inline comatose pages...
+ActionView::Base.class_eval do
+  alias_method :render_otherwise, :render
+  
+  def render(options = {}, old_local_assigns = {}, &block) #:nodoc:
+    if options.is_a?(Hash) && page_name = options.delete(:comatose)
+      render_comatose(page_name, options[:params] || options)
+    else
+      render_otherwise(options, old_local_assigns, &block)
+    end
+  end
+  
+  def render_comatose(page_path, params = {})
+    params = {
+      :silent => false,
+      :use_cache => true,
+      :locals => {}
+    }.merge(params)
+    if params[:use_cache] and params[:locals].empty?
+      render_cached_comatose_page(page_path, params)
+    else
+      render_comatose_page(page_path, params)
+    end
+  end
+  
+protected
+  
+  def render_cached_comatose_page(page_path, params)
+    key = page_path.gsub(/\//, '+')
+    unless html = controller.read_fragment(key)
+      html = render_comatose_page( page_path, params )
+      controller.write_fragment(key, html) unless Comatose.config.disable_caching
+    end
+    html
+  end
+  
+  def render_comatose_page(page_path, params)
+    if page = ComatosePage.find_by_path(page_path)
+      # Add the request params to the context...
+      params[:locals]['params'] = controller.params
+      html = page.to_html( params[:locals] )
+    else
+      html = params[:silent] ? '' : "<p><tt>#{page_path}</tt> not found</p>"
+    end
+  end
+  
+end
+

data/lib/support/route_mapper.rb

@@ -0,0 +1,50 @@
+# For use with 'Edge Rails'
+class ActionController::Routing::RouteSet::Mapper
+
+  # For mounting a page to a path
+  def comatose_root( path, options={} )
+    opts = {
+      :index      => '',
+      :layout     => 'comatose_content.html.erb',
+      :use_cache  => 'true',
+      :cache_path => nil,
+      :named_route=> nil
+    }.merge(options)
+    # Ensure the controller is aware of the mount point...
+    Comatose.add_mount_point(path, opts)
+    # Add the route...
+    opts[:controller] = 'comatose'
+    opts[:action] ='show'
+    route_name = opts.delete(:named_route)
+    unless route_name.nil?
+      named_route( route_name, "#{path}/*page", opts )
+    else
+      if opts[:index] == '' # if it maps to the root site URI, name it comatose_root
+        named_route( 'comatose_root', "#{path}/*page", opts )
+      else
+        connect( "#{path}/*page", opts )
+      end
+    end
+  end
+
+  # For mounting the admin
+  def comatose_admin( path='comatose_admin', options={} )
+    opts = {
+      :controller  => 'comatose_admin',
+      :named_route => 'comatose_admin'
+    }.merge(options)
+    route_name = opts.delete(:named_route)
+    named_route( route_name, "#{path}/:action/:id", opts )
+  end
+    
+  def method_missing( name, *args, &proc )
+    if name.to_s.starts_with?( 'comatose_' )
+      opts = (args.last.is_a?(Hash)) ? args.pop : {}
+      opts[:named_route] = name.to_s #[9..-1]
+      comatose_root( *(args << opts) )
+    else
+      super unless args.length >= 1 && proc.nil?
+      @set.add_named_route(name, *args)
+    end
+  end
+end

data/lib/text_filters.rb

@@ -0,0 +1,140 @@
+require 'support/class_options'
+
+class TextFilters
+  
+  define_option :default_processor, :liquid
+  define_option :default_filter,    "Textile"
+  define_option :logger,            nil
+  
+  @registered_filters = {}
+  @registered_titles  = {}
+
+  attr_reader :name
+  attr_reader :title
+  def initialize(name, title)
+    @name = name
+    @title = title
+  end
+
+  # The default create_link method...
+  # Override for your specific filter, if needed, in the #define block
+  def create_link(title, url)
+    %Q|<a href="#{url}">#{title}</a>|
+  end
+  
+  # Process the text with using the specified context
+  def process_text(text, context, processor=nil)
+    case (processor || TextFilters.default_processor)
+    when :erb then process_with_erb(text, context)
+    when :liquid then process_with_liquid(text, context)
+    else raise "Unknown Text Processor '#{processor.to_s}'"
+    end
+  end
+  
+  class << self
+    private :new
+    attr_reader :registered_filters
+    attr_reader :registered_titles
+    
+    # Use this to create and register your TextFilters
+    def define(name, title, &block)
+      begin
+        p = new(name, title)
+        p.instance_eval(&block)
+        if p.respond_to? :render_text
+          registered_titles[title] = name
+          registered_filters[name] = p
+        else
+          raise "#render_text isn't implemented in this class"
+        end
+      rescue LoadError
+        TextFilters.logger.debug "Filter '#{name}' was not included: #{$!}" unless TextFilters.logger.nil?
+      rescue
+        TextFilters.logger.debug "Filter '#{name}' was not included: #{$!}" unless TextFilters.logger.nil?
+      end
+    end
+    
+    def get_filter(name)
+      name = TextFilters.default_filter if name.nil?
+      name = registered_titles[name] if name.is_a? String
+      filter = registered_filters[name]
+      raise "No filter found for '#{name}' in registered_titles: #{registered_titles.inspect} or registered_filters: #{registered_filters.inspect}" unless filter
+      filter
+    end
+
+    def [](name)
+      get_filter(name)
+    end
+    
+    def all
+      registered_filters
+    end
+    
+    def all_titles
+      registered_titles.keys
+    end
+
+    def render_text(text, name=nil)
+      get_filter(name).render_text(text)
+    end
+
+    def process_text(text, context=nil, name=nil, processor=nil)
+      get_filter(name).process_text(text, context, processor)
+    end
+
+    # Call
+    def transform(text, context=nil, name=nil, processor=nil)
+      render_text( process_text(text, context, name, processor), name )
+    end
+  end
+  
+private
+
+  # This is an instance method so that it won't puke on requiring
+  # a non-existant library until it's being registered -- the only
+  # place I can really capture the LoadError
+  def require(name)
+    Kernel.require name
+  end
+
+  # Use ERB to process text...
+  def process_with_erb(text, context)
+    begin
+      ERB.new( text ).result( context.get_binding )
+    rescue
+      raise "ERB Error: #{$!}"
+    end
+  end
+
+  # Use Liquid to process text...
+  def process_with_liquid(text, context={})
+    begin
+      context = context.stringify_keys if context.respond_to? :stringify_keys
+      Liquid::Template.parse(text).render(context)
+    rescue
+      raise "Liquid Error: #{$!}"
+    end
+  end
+  
+end
+
+class Hash
+  # Having the method_missing catchall in conjunction with get_binding 
+  # allows us to use the hash as a Context for ERB
+  def method_missing(meth, *arg)
+    if self.has_key? meth.to_s
+      self[meth.to_s]
+    else
+      super
+    end
+  end
+  # Gets the binding object for use with ERB
+  def get_binding
+    binding
+  end
+end
+
+
+Dir[File.join(File.dirname(__FILE__), 'text_filters', '*.rb')].each do |path|
+  require "text_filters/#{File.basename(path)}"
+end

data/lib/text_filters/markdown.rb

@@ -0,0 +1,14 @@
+#
+# MARKDOWN
+#
+TextFilters.define :markdown, "Markdown" do
+  require 'bluecloth'
+  
+  def render_text(text)
+    BlueCloth.new(text).to_html
+  end
+  
+  def create_link(title, url)
+    "[#{title}](#{url})"
+  end
+end

data/lib/text_filters/markdown_smartypants.rb

@@ -0,0 +1,15 @@
+#
+# MARKDOWN + SMARTYPANTS
+#
+TextFilters.define :markdown_smartypants, "Markdown + SmartyPants" do
+  require 'bluecloth'
+  require 'rubypants'
+  
+  def render_text(text)
+    RubyPants.new( BlueCloth.new(text).to_html ).to_html
+  end
+  
+  def create_link(title, url)
+    "[#{title}](#{url})"
+  end
+end

data/lib/text_filters/none.rb

@@ -0,0 +1,8 @@
+#
+# NONE
+#
+TextFilters.define :none, "[No Filter]" do
+  def render_text(text)
+    text
+  end
+end

data/lib/text_filters/rdoc.rb

@@ -0,0 +1,13 @@
+#
+# RDOC
+#
+TextFilters.define :rdoc, "RDoc" do
+  require 'rdoc/markup/simple_markup'
+  require 'rdoc/markup/simple_markup/to_html'
+
+  def render_text(text)
+    p = SM::SimpleMarkup.new
+    h = SM::ToHtml.new
+    p.convert(text, h)  
+  end
+end

data/lib/text_filters/simple.rb

@@ -0,0 +1,8 @@
+#
+# SIMPLE
+#
+TextFilters.define :simple, "Simple" do
+  def render_text(text)
+    text.gsub("\n", '<br/>')
+  end
+end

data/lib/text_filters/textile.rb

@@ -0,0 +1,15 @@
+#
+# TEXTILE
+#
+TextFilters.define :textile, "Textile" do
+  require 'redcloth'
+  
+  def render_text(text)
+    RedCloth.new(text).to_html(:refs_markdown, :textile, :markdown)
+  end
+  
+  def create_link(title, url)
+    %Q|"#{title}":#{url}|
+  end
+  
+end

data/rails/init.rb

@@ -0,0 +1,3 @@
+# Init for gem version of Comatose
+
+require 'comatose'

data/resources/layouts/comatose_admin_template.html.erb

@@ -0,0 +1,28 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html class="noscript" xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=<%%= Comatose.config.content_type %>"/>
+    <title>Comatose Admin</title>
+    <%= style_contents %>
+    <%%= javascript_include_tag :defaults %>
+    <%= script_contents %>
+  </head>
+  <body>
+    <div id="page-container">
+      <div id="header">
+        <h1><%%= link_to Comatose.config.admin_title, :controller=>controller.controller_name, :action=>'index' %></h1>
+        <div id="flash">
+          <span id="flash-content"><%%= flash[:notice] %></span>
+        </div>
+        <h5><%%= Comatose.config.admin_sub_title %></h5>
+      </div>
+      <div id="content">
+        <%%= yield %>
+      </div>
+      <div id="footer">
+        Powered by <a href="http://comatose.rubyforge.org" target="_new_window">Comatose <%%= Comatose::VERSION_STRING %></a>, created by <a href="http://www.mattmccray.com"  target="_new_window">M@ McCray</a>.
+      </div>
+    </div>
+  </body>
+</html>

data/resources/public/javascripts/comatose_admin.js

@@ -0,0 +1,401 @@
+// CSS Browser Selector   v0.2.3b (M@: added noscript support)
+// Documentation:         http://rafael.adm.br/css_browser_selector
+// License:               http://creativecommons.org/licenses/by/2.5/
+// Author:                Rafael Lima (http://rafael.adm.br)
+// Contributors:          http://rafael.adm.br/css_browser_selector#contributors
+var css_browser_selector = function() {
+  var 
+    ua = navigator.userAgent.toLowerCase(),
+    is = function(t){ return ua.indexOf(t) != -1; },
+    h = document.getElementsByTagName('html')[0],
+    b = (!(/opera|webtv/i.test(ua)) && /msie (\d)/.test(ua)) ? ((is('mac') ? 'ieMac ' : '') + 'ie ie' + RegExp.$1)
+      : is('gecko/') ? 'gecko' : is('opera') ? 'opera' : is('konqueror') ? 'konqueror' : is('applewebkit/') ? 'webkit safari' : is('mozilla/') ? 'gecko' : '',
+    os = (is('x11') || is('linux')) ? ' linux' : is('mac') ? ' mac' : is('win') ? ' win' : '';
+  var c = b+os+' js'; 
+  h.className = h.className.replace('noscript', '') + h.className?' '+c:c;
+}();
+
+// List View Functions
+var ComatoseList = {
+  save_node_state: true,
+  state_store: 'cookie', // Only 'cookie' for now
+  state_key: 'ComatoseTreeState',
+
+  init: function() {
+    var items = ComatoseList._read_state();
+    items.each(function(node){
+      ComatoseList.expand_node(node.replace('page_controller_', ''))
+    });
+  },
+  
+  toggle_tree_nodes : function(img, id) {
+    if(/expanded/.test(img.src)) {
+      $('page_list_'+ id).addClassName('collapsed');
+      img.src = img.src.replace(/expanded/, 'collapsed')
+      if(ComatoseList.save_node_state) {
+        var items = ComatoseList._read_state();
+        items = items.select(function(id){ return id != img.id; })
+        ComatoseList._write_state(items);
+      }
+    } else {
+      $('page_list_'+ id).removeClassName('collapsed');
+      img.src = img.src.replace(/collapsed/, 'expanded')
+      if(ComatoseList.save_node_state) {
+        var items = ComatoseList._read_state();
+        items.push(img.id);
+        ComatoseList._write_state(items);
+      }
+    }
+  },
+  
+  expand_node: function(id) {
+    $('page_list_'+ id).removeClassName('collapsed');
+    $('page_controller_'+ id).src = $('page_controller_'+ id).src.replace(/collapsed/, 'expanded')    
+  },
+  
+  collapse_node: function(id) {
+    $('page_list_'+ id).addClassName('collapsed');
+    $('page_controller_'+ id).src = $('page_controller_'+ id).src.replace(/expanded/, 'collapsed')    
+  },
+  
+  item_hover : function(node, state, is_delete) {
+    if( state == 'over') {
+      $(node).addClassName( (is_delete) ? 'hover-delete' : 'hover' );
+    } else {
+      $(node).removeClassName( (is_delete) ? 'hover-delete' : 'hover' );
+    }
+  },
+  
+  toggle_reorder: function(node, anc, id) {
+    if( $(node).hasClassName('do-reorder') ) {
+      $(node).removeClassName( 'do-reorder' );
+      $(anc).removeClassName('reordering');
+      $(anc).innerHTML = "reorder children";
+    } else {
+      $(node).addClassName( 'do-reorder' );
+      $(anc).addClassName('reordering');
+      $(anc).innerHTML = "finished reordering";
+      // Make sure the children are visible...
+      ComatoseList.expand_node(id);
+    }
+  },
+  
+  _write_state: function(items) {
+    var cookie = {}; var options = {}; var expiration = new Date();
+    cookie[ ComatoseList.state_key ] = items.join(',');
+    expiration.setDate(expiration.getDate()+30)
+    options['expires'] = expiration;
+    Cookie.write( cookie, options );
+  },
+  
+  _read_state: function() {
+    var state = Cookie.read( ComatoseList.state_key );
+    return (state != "" && state != null) ? state.split(',') : [];
+  }
+}
+
+// Edit Form Functions
+var ComatoseEditForm = {
+
+  default_data: {},
+  last_preview: {},
+  last_title_slug: '',
+  mode : null,
+  liquid_horiz: true,
+  width_offset: 325,
+
+  // Initialize the page...
+  init : function(mode) {
+    this.mode = mode;
+    this.default_data = Form.serialize(document.forms[0]);
+    if(mode == 'new') {
+      this.last_title_slug = $('page_title').value.toSlug();
+      Event.observe('page_title', 'blur', ComatoseEditForm.title_updated_aggressive);
+    } else {
+      Event.observe('page_title', 'blur', ComatoseEditForm.title_updated);
+    }
+    $('page_title').focus();
+    Hide.these(
+      'preview-area',
+      'slug_row',
+      'parent_row',
+      'keywords_row',
+      'filter_row',
+      'created_row'
+    );
+    $('page_title').select();
+    // Create the horizontal liquidity of the fields
+    if(this.liquid_horiz) {
+      xOffset = this.width_offset;
+      new Layout.LiquidHoriz((xOffset + 50), 'page_title');
+      new Layout.LiquidHoriz(xOffset, 'page_slug','page_keywords','page_parent','page_body');
+    }
+  },
+  // For use when updating an existing page...
+  title_updated : function() {
+    slug = $('page_slug');
+    if(slug.value == "") {
+      title = $('page_title');
+      slug.value = title.value.toSlug();
+    }
+  },
+  // For use when creating a new page...
+  title_updated_aggressive : function() {
+    slug = $('page_slug');
+    title = $('page_title');
+    if(slug.value == "" || slug.value == this.last_title ) {
+      slug.value = title.value.toSlug();
+    }
+    this.last_title = slug.value;
+  },
+  // Todo: Make the meta fields remember their visibility?
+  toggle_extra_fields : function(anchor) {
+    if(anchor.innerHTML == "More...") {
+      Show.these(
+        'slug_row',
+        'keywords_row',
+        'parent_row',
+        'filter_row',
+        'created_row'
+      );
+      anchor.innerHTML = 'Less...';
+    } else {
+      Hide.these(
+        'slug_row',
+        'keywords_row',
+        'parent_row',
+        'filter_row',
+        'created_row'
+      );
+      anchor.innerHTML = 'More...';
+    }
+  },
+  // Uses server to create preview of content...
+  preview_content : function(preview_url) {
+    $('preview-area').show();
+    var params = Form.serialize(document.forms[0]);
+    if( params != this.last_preview ) {
+      $('preview-panel').innerHTML = "<span style='color:blue;'>Loading Preview...</span>";
+      new Ajax.Updater(
+         'preview-panel',
+         preview_url,
+         { parameters: params }
+      );
+    }
+    this.last_preview = params;
+  },
+  cancel : function(url) {
+    var current_data = Form.serialize(document.forms[0]);
+    var data_changed = (this.default_data != current_data) 
+    if(data_changed) {
+      if( confirm('Changes detected. You will lose all the updates you have made if you proceed...') ) {
+        location.href = url;
+      }
+    } else {
+      location.href = url;      
+    }
+    
+  }
+}
+
+var Hide = {
+  these : function() {
+    for (var i = 0; i < arguments.length; i++) {
+      try {
+        $(arguments[i]).hide();
+      } catch (e) {}
+    }
+  }
+}
+
+var Show = {
+  these : function() {
+    for (var i = 0; i < arguments.length; i++) {
+      try {
+        $(arguments[i]).show();
+      } catch (e) {}
+    }
+  }
+}
+
+// Layout namespace
+var Layout = {};
+
+// This class allows dom objects to stretch with the browser 
+// (for when a good, cross-browser, CSS approach can't be found)
+Layout.LiquidBase = Class.create();
+// Base class for all Liquid* layouts...
+Object.extend(Layout.LiquidBase.prototype, {
+  enabled: true,
+  elems: [],
+  offset: null,
+  // Constructor is (offset, **array_of_elements)
+  initialize: function() {
+    args = $A(arguments)
+    this.offset = args.shift();
+    this.elems = args.select( function(elem){ return ($(elem) != null) } );
+    if( this.elems.length > 0 ) {
+      this.on_resize(); // Initial size
+      Event.observe(window, 'resize', this.on_resize.bind(this) );
+      Event.observe(window, 'load', this.on_resize.bind(this) );
+    }
+  },
+  resize_in: function(timeout) {
+    setTimeout( this.on_resize.bind(this), timeout );
+  },
+  on_resize: function() {       
+    // Need to override!
+    alert('Override on_resize, please!');
+  }
+});
+
+
+// Liquid vertical layout
+Layout.LiquidVert = Class.create();
+Object.extend(Layout.LiquidVert.prototype, Object.extend(Layout.LiquidBase.prototype, {
+  on_resize: function() {       
+    if( this.offset != null && this.enabled ) {
+      var new_height = ((window.innerHeight || document.documentElement.clientHeight || document.body.clientHeight) - this.offset) +"px";
+      this.elems.each(function(e){ $(e).style.height = new_height; })
+    }
+  }
+}) );
+
+
+// Liquid horizontal layout
+Layout.LiquidHoriz = Class.create();
+Object.extend(Layout.LiquidHoriz.prototype, Object.extend(Layout.LiquidBase.prototype, {
+  on_resize: function() {       
+    if( this.offset != null && this.enabled ) {
+      var new_width = ((window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth) - this.offset) +"px";
+      this.elems.each( function(e){ $(e).style.width = new_width; })
+    }
+  }
+}) );
+
+// String Extensions... Yes, these are from Radiant! ;-)
+Object.extend(String.prototype, {
+  upcase: function() {
+    return this.toUpperCase();
+  },
+  downcase: function() {
+    return this.toLowerCase();
+  },
+  strip: function() {
+    return this.replace(/^\s+/, '').replace(/\s+$/, '');
+  },
+  toInteger: function() {
+    return parseInt(this);
+  },
+  toSlug: function() {
+    // M@: Modified from Radiant's version, removes multple --'s next to each other
+    // This is the same RegExp as the one on the page model...
+    return this.strip().downcase().replace(/[^-a-z0-9~\s\.:;+=_]/g, '').replace(/[\s\.:;=_+]+/g, '-').replace(/[\-]{2,}/g, '-');
+  }
+});
+
+// Run a spinner when an AJAX request in running...
+var ComatoseAJAXSpinner = {
+  busy : function () {
+    if($('spinner') && Ajax.activeRequestCount > 0) {
+      Effect.Appear('spinner',{duration:0.5,queue:'end'});
+    }
+  },
+
+  notBusy: function() {
+    if($('spinner') && Ajax.activeRequestCount == 0) {
+      Effect.Fade('spinner',{duration:0.5,queue:'end'});
+    }
+  }  
+}
+// Register it with Prototype...
+Ajax.Responders.register({
+  onCreate: ComatoseAJAXSpinner.busy, 
+  onComplete: ComatoseAJAXSpinner.notBusy
+});
+
+
+if(!window.Cookie)
+  (function (){
+    // From Mephisto!
+    window.Cookie = {
+      version: '0.7',
+      cookies: {},
+      _each: function(iterator) {
+        $H(this.cookies).each(iterator);
+      },
+  
+      getAll: function() {
+        this.cookies = {};
+        $A(document.cookie.split('; ')).each(function(cookie) {
+          var seperator = cookie.indexOf('=');
+          this.cookies[cookie.substring(0, seperator)] = 
+              unescape(cookie.substring(seperator + 1, cookie.length));
+        }.bind(this));
+        return this.cookies;
+      },
+  
+      read: function() {
+        var cookies = $A(arguments), results = [];
+        this.getAll();
+        cookies.each(function(name) {
+          if (this.cookies[name]) results.push(this.cookies[name]);
+          else results.push(null);
+        }.bind(this));
+        return results.length > 1 ? results : results[0];
+      },
+  
+      write: function(cookies, options) {
+        if (cookies.constructor == Object && cookies.name) cookies = [cookies];
+        if (cookies.constructor == Array) {
+          $A(cookies).each(function(cookie) {
+            this._write(cookie.name, cookie.value, cookie.expires,
+                        cookie.path, cookie.domain);
+          }.bind(this));
+        } else {
+          options = options || {expires: false, path: '', domain: ''};
+          for (name in cookies){
+            this._write(name, cookies[name],
+                        options.expires, options.path, options.domain);
+          }
+        }
+      },
+  
+      _write: function(name, value, expires, path, domain) {
+        if (name.indexOf('=') != -1) return;
+        var cookieString = name + '=' + escape(value);
+        if (expires) cookieString += '; expires=' + expires.toGMTString();
+        if (path) cookieString += '; path=' + path;
+        if (domain) cookieString += '; domain=' + domain;
+        document.cookie = cookieString;
+      },
+  
+      erase: function(cookies) {
+        var cookiesToErase = {};
+        $A(arguments).each(function(cookie) {
+          cookiesToErase[cookie] = '';
+        });
+    
+        this.write(cookiesToErase, {expires: (new Date((new Date()).getTime() - 1e11))});
+        this.getAll();
+      },
+  
+      eraseAll: function() {
+        this.erase.apply(this, $H(this.getAll()).keys());
+      }
+    };
+
+    Object.extend(Cookie, {
+      get: Cookie.read,
+      set: Cookie.write,
+  
+      add: Cookie.read,
+      remove: Cookie.erase,
+      removeAll: Cookie.eraseAll,
+  
+      wipe: Cookie.erase,
+      wipeAll: Cookie.eraseAll,
+      destroy: Cookie.erase,
+      destroyAll: Cookie.eraseAll
+    });
+  })();