blog_logic 0.7.2

data/public/javascripts/rails.js

@@ -0,0 +1,191 @@
+(function() {
+  // Technique from Juriy Zaytsev
+  // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
+  function isEventSupported(eventName) {
+    var el = document.createElement('div');
+    eventName = 'on' + eventName;
+    var isSupported = (eventName in el);
+    if (!isSupported) {
+      el.setAttribute(eventName, 'return;');
+      isSupported = typeof el[eventName] == 'function';
+    }
+    el = null;
+    return isSupported;
+  }
+
+  function isForm(element) {
+    return Object.isElement(element) && element.nodeName.toUpperCase() == 'FORM'
+  }
+
+  function isInput(element) {
+    if (Object.isElement(element)) {
+      var name = element.nodeName.toUpperCase()
+      return name == 'INPUT' || name == 'SELECT' || name == 'TEXTAREA'
+    }
+    else return false
+  }
+
+  var submitBubbles = isEventSupported('submit'),
+      changeBubbles = isEventSupported('change')
+
+  if (!submitBubbles || !changeBubbles) {
+    // augment the Event.Handler class to observe custom events when needed
+    Event.Handler.prototype.initialize = Event.Handler.prototype.initialize.wrap(
+      function(init, element, eventName, selector, callback) {
+        init(element, eventName, selector, callback)
+        // is the handler being attached to an element that doesn't support this event?
+        if ( (!submitBubbles && this.eventName == 'submit' && !isForm(this.element)) ||
+             (!changeBubbles && this.eventName == 'change' && !isInput(this.element)) ) {
+          // "submit" => "emulated:submit"
+          this.eventName = 'emulated:' + this.eventName
+        }
+      }
+    )
+  }
+
+  if (!submitBubbles) {
+    // discover forms on the page by observing focus events which always bubble
+    document.on('focusin', 'form', function(focusEvent, form) {
+      // special handler for the real "submit" event (one-time operation)
+      if (!form.retrieve('emulated:submit')) {
+        form.on('submit', function(submitEvent) {
+          var emulated = form.fire('emulated:submit', submitEvent, true)
+          // if custom event received preventDefault, cancel the real one too
+          if (emulated.returnValue === false) submitEvent.preventDefault()
+        })
+        form.store('emulated:submit', true)
+      }
+    })
+  }
+
+  if (!changeBubbles) {
+    // discover form inputs on the page
+    document.on('focusin', 'input, select, texarea', function(focusEvent, input) {
+      // special handler for real "change" events
+      if (!input.retrieve('emulated:change')) {
+        input.on('change', function(changeEvent) {
+          input.fire('emulated:change', changeEvent, true)
+        })
+        input.store('emulated:change', true)
+      }
+    })
+  }
+
+  function handleRemote(element) {
+    var method, url, params;
+
+    var event = element.fire("ajax:before");
+    if (event.stopped) return false;
+
+    if (element.tagName.toLowerCase() === 'form') {
+      method = element.readAttribute('method') || 'post';
+      url    = element.readAttribute('action');
+      params = element.serialize();
+    } else {
+      method = element.readAttribute('data-method') || 'get';
+      url    = element.readAttribute('href');
+      params = {};
+    }
+
+    new Ajax.Request(url, {
+      method: method,
+      parameters: params,
+      evalScripts: true,
+
+      onComplete:    function(request) { element.fire("ajax:complete", request); },
+      onSuccess:     function(request) { element.fire("ajax:success",  request); },
+      onFailure:     function(request) { element.fire("ajax:failure",  request); }
+    });
+
+    element.fire("ajax:after");
+  }
+
+  function handleMethod(element) {
+    var method = element.readAttribute('data-method'),
+        url = element.readAttribute('href'),
+        csrf_param = $$('meta[name=csrf-param]')[0],
+        csrf_token = $$('meta[name=csrf-token]')[0];
+
+    var form = new Element('form', { method: "POST", action: url, style: "display: none;" });
+    element.parentNode.insert(form);
+
+    if (method !== 'post') {
+      var field = new Element('input', { type: 'hidden', name: '_method', value: method });
+      form.insert(field);
+    }
+
+    if (csrf_param) {
+      var param = csrf_param.readAttribute('content'),
+          token = csrf_token.readAttribute('content'),
+          field = new Element('input', { type: 'hidden', name: param, value: token });
+      form.insert(field);
+    }
+
+    form.submit();
+  }
+
+
+  document.on("click", "*[data-confirm]", function(event, element) {
+    var message = element.readAttribute('data-confirm');
+    if (!confirm(message)) event.stop();
+  });
+
+  document.on("click", "a[data-remote]", function(event, element) {
+    if (event.stopped) return;
+    handleRemote(element);
+    event.stop();
+  });
+
+  document.on("click", "a[data-method]", function(event, element) {
+    if (event.stopped) return;
+    handleMethod(element);
+    event.stop();
+  });
+
+  document.on("submit", function(event) {
+    var element = event.findElement(),
+        message = element.readAttribute('data-confirm');
+    if (message && !confirm(message)) {
+      event.stop();
+      return false;
+    }
+
+    var inputs = element.select("input[type=submit][data-disable-with]");
+    inputs.each(function(input) {
+      input.disabled = true;
+      input.writeAttribute('data-original-value', input.value);
+      input.value = input.readAttribute('data-disable-with');
+    });
+
+    var element = event.findElement("form[data-remote]");
+    if (element) {
+      handleRemote(element);
+      event.stop();
+    }
+  });
+
+  document.on("ajax:after", "form", function(event, element) {
+    var inputs = element.select("input[type=submit][disabled=true][data-disable-with]");
+    inputs.each(function(input) {
+      input.value = input.readAttribute('data-original-value');
+      input.removeAttribute('data-original-value');
+      input.disabled = false;
+    });
+  });
+
+  Ajax.Responders.register({
+    onCreate: function(request) {
+      var csrf_meta_tag = $$('meta[name=csrf-token]')[0];
+
+      if (csrf_meta_tag) {
+        var header = 'X-CSRF-Token',
+            token = csrf_meta_tag.readAttribute('content');
+
+        if (!request.options.requestHeaders) {
+          request.options.requestHeaders = {};
+        }
+        request.options.requestHeaders[header] = token;
+      }
+    }
+  });
+})();

data/public/javascripts/sorttable.js

@@ -0,0 +1,115 @@
+/*===========================================================================
+  SORTABLE TABLES by Inventive Labs
+  * Uses Prototype 1.5+ (http://prototype.conio.net/)
+
+  Sort a table by clicking on a column heading. To make a table sortable,
+  give it a class of 'sortable':
+
+  <table class="sortable">
+    <tr>
+      <th sort="integer">ID</th>
+      <th>Summary</th>
+      <th sort="date">Occurred on</th>
+    </tr>
+    <tr> (some cells...) </tr>
+  </table>
+
+  The 'sort' attribute of the table cell headers determines the way that
+  the column is sorted. The default is case-insensitive alphabetical comparison.
+
+  Note: during the sort, every other row is given a class of 'alt' - you can
+  use this to alternate background colours & etc.
+
+  Based on tableSort.js by Inigo Surguy (http://surguy.net). This file is made
+  available under the same Creative Commons Attribution-ShareAlike 2.5 license:
+  http://creativecommons.org/licenses/by-sa/2.5/
+---------------------------------------------------------------------------*/
+SortableTable = function (table) {
+  var me = this;
+
+  this.table = table;
+  this.rows = $A(table.rows).map(function(r) { return $(r) });
+  this.headerRow = this.rows.shift();
+  this.headers = Selector.findChildElements(this.headerRow, ['th']);
+
+  this.headers.each(function(th) {
+    var span = $(document.createElement('span'));
+    $A(th.childNodes).each(function(c) { span.appendChild(c); });
+    th.appendChild(span);
+    span.onclick = function () { me.sortOnColumn(th, span) }
+  });
+}
+
+SortableTable.find = function () {
+  $$('table.sortable').each(function(table) { new SortableTable(table) })
+}
+
+SortableTable.prototype.simpleCompare = function(a,b) {
+  return a < b ? -1 : a == b ? 0 : 1;
+};
+
+SortableTable.prototype.compareComposer = function(normalizeFn) {
+  var me = this;
+  return function(a,b) {return me.simpleCompare(normalizeFn(a), normalizeFn(b))}
+}
+
+// Add any new comparison functions you need to this switch statement.
+SortableTable.prototype.compareFunction = function (sType) {
+  switch (sType) {
+    case "caseSensitive":
+      return this.simpleCompare;
+    case "integer":
+      // Extracts the first numeric part of a string
+      return this.compareComposer(function(a) {
+        return parseInt(a.replace(/^.*?(\d+).*$/,"$1"))
+      });
+    case "float":
+      // Similar, but permits floating points (.)
+      return this.compareComposer(function(a) {
+        return parseFloat(a.replace(/^.*?([\d\.]+).*$/,"$1"))
+      });
+    case "date":
+      // Expects an ISO date format "13 MAR 2006 10:17:02 GMT"
+      return this.compareComposer(Date.parse)
+    default:
+      return this.compareComposer(function(a) { return a.toLowerCase(); });
+  }
+}
+
+SortableTable.prototype.sortOnColumn = function (th, span) {
+  // figure out which column this is
+  var pos = $A(this.headerRow.cells).indexOf(th);
+
+  // do the sort
+  var sortFn = this.compareFunction(th.getAttribute('sort'));
+  span.order = span.order || 1;
+  this.rows.sort(
+    function (rowA, rowB) {
+      return span.order * sortFn(rowA.getCellText(pos), rowB.getCellText(pos));
+    }
+  );
+  span.order *= -1;
+
+  // rearrange the rows based on sort results
+  var alt = 0;
+  var tbody = this.table.tBodies[0];
+  this.rows.each(function(row) {
+    if ((alt += 1) % 2) {
+      if (!row.hasClassName('alt')) { row.addClassName('alt') }
+    } else {
+      row.removeClassName('alt');
+    }
+    tbody.appendChild(row);
+  });
+}
+
+Element.addMethods({
+  getText:function(e){return e.text = e.text||e.textContent||e.innerText||''},
+  getCellText: function(row, pos) {
+    row.cellTexts = row.cellTexts || [];
+    row.cellTexts[pos] = row.cellTexts[pos] || row.down("td", pos).getText();
+    return row.cellTexts[pos];
+  }
+});
+
+Event.observe(window, 'load', SortableTable.find, false);

data/public/robots.txt

@@ -0,0 +1,5 @@
+# See http://www.robotstxt.org/wc/norobots.html for documentation on how to use the robots.txt file
+#
+# To ban all spiders from the entire site uncomment the next two lines:
+# User-Agent: *
+# Disallow: /