monocle-rails 0.0.2 → 0.0.3

data/vendor/assets/javascripts/tests/base64.js

@@ -0,0 +1,58 @@
+/// Code can be found at: https://gist.github.com/1284012
+
+(function() {
+
+	var a64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/', a256 = {
+		indexOf : function(c) {
+			return c.charCodeAt(0);
+		},
+		charAt : String.fromCharCode
+	};
+
+	function code(s, discard, alpha, beta, w1, w2) {
+		s = String(s);
+		var b = 0, x = '', i, c, bs = 1, sb = 1, length = s.length, tmp;
+		for (i = 0; i < length || (!discard && sb > 1); i += 1) {
+			b *= w1;
+			bs *= w1;
+			if (i < length) {
+				c = alpha.indexOf(s.charAt(i));
+				if (c <= -1 || c >= w1) {
+					throw new RangeError();
+				}
+				sb *= w1;
+				b += c;
+			}
+			while (bs >= w2) {
+				bs /= w2;
+				if (sb > 1) {
+					tmp = b;
+					b %= bs;
+					x += beta.charAt((tmp - b) / bs);
+					sb /= w2;
+				}
+			}
+		}
+		return x;
+	}
+
+	if (!("btoa" in window))
+		window.btoa = function(s) {
+			s = code(s, false, a256, a64, 256, 64);
+			return s + '===='.slice((s.length % 4) || 4);
+		};
+
+	if (!("atob" in window))
+		window.atob = function(s) {
+			var i;
+			s = String(s).split('=');
+			for (i = s.length - 1; i >= 0; i -= 1) {
+				if (s[i].length % 4 === 1) {
+					throw new RangeError();
+				}
+				s[i] = code(s[i], true, a64, a256, 64, 256);
+			}
+			return s.join('');
+		};
+
+})();

data/vendor/assets/javascripts/tests/dataview.js

@@ -0,0 +1,212 @@
+
+/* 
+ * DataView.js:
+ * An implementation of the DataView class on top of typed arrays.
+ * Useful for Firefox 4 which implements TypedArrays but not DataView.
+ *
+ * Copyright 2011, David Flanagan
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, 
+ * are permitted provided that the following conditions are met:
+ *
+ *   Redistributions of source code must retain the above copyright notice, 
+ *   this list of conditions and the following disclaimer.
+ *
+ *   Redistributions in binary form must reproduce the above copyright notice, 
+ *   this list of conditions and the following disclaimer in the documentation.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+"use strict";
+
+(function(global) {
+    // If DataView already exists, do nothing
+    if (global.DataView) return;
+
+    // If ArrayBuffer is not supported, fail with an error
+    if (!global.ArrayBuffer) fail("ArrayBuffer not supported");
+
+    // If ES5 is not supported, fail
+    if (!Object.defineProperties) fail("This module requires ECMAScript 5");
+
+    // Figure if the platform is natively little-endian.
+    // If the integer 0x00000001 is arranged in memory as 01 00 00 00 then
+    // we're on a little endian platform. On a big-endian platform we'd get
+    // get bytes 00 00 00 01 instead.
+    var nativele = new Int8Array(new Int32Array([1]).buffer)[0] === 1;
+
+    // A temporary array for copying or reversing bytes into.
+    // Since js is single-threaded, we only need this one static copy
+    var temp = new Uint8Array(8);
+
+    // The DataView() constructor
+    global.DataView = function DataView(buffer, offset, length) {
+        if (!(buffer instanceof ArrayBuffer)) fail("Bad ArrayBuffer");
+
+        // Default values for omitted arguments
+        offset = offset || 0;
+        length = length || (buffer.byteLength - offset);
+
+        if (offset < 0 || length < 0 || offset + length > buffer.byteLength) fail("Illegal offset and/or length");
+
+        // Define the 3 read-only, non-enumerable ArrayBufferView properties
+        Object.defineProperties(this, {
+            buffer: {
+                value: buffer,
+                enumerable: false,
+                writable: false,
+                configurable: false
+            },
+            byteOffset: {
+                value: offset,
+                enumerable: false,
+                writable: false,
+                configurable: false
+            },
+            byteLength: {
+                value: length,
+                enumerable: false,
+                writable: false,
+                configurable: false
+            },
+            _bytes: {
+                value: new Uint8Array(buffer, offset, length),
+                enumerable: false,
+                writable: false,
+                configurable: false
+            }
+        });
+    }
+
+    // The DataView prototype object
+    global.DataView.prototype = {
+        constructor: DataView,
+
+        getInt8: function getInt8(offset) {
+            return get(this, Int8Array, 1, offset);
+        },
+        getUint8: function getUint8(offset) {
+            return get(this, Uint8Array, 1, offset);
+        },
+        getInt16: function getInt16(offset, le) {
+            return get(this, Int16Array, 2, offset, le);
+        },
+        getUint16: function getUint16(offset, le) {
+            return get(this, Uint16Array, 2, offset, le);
+        },
+        getInt32: function getInt32(offset, le) {
+            return get(this, Int32Array, 4, offset, le);
+        },
+        getUint32: function getUint32(offset, le) {
+            return get(this, Uint32Array, 4, offset, le);
+        },
+        getFloat32: function getFloat32(offset, le) {
+            return get(this, Float32Array, 4, offset, le);
+        },
+        getFloat64: function getFloat32(offset, le) {
+            return get(this, Float64Array, 8, offset, le);
+        },
+
+
+        setInt8: function setInt8(offset, value) {
+            set(this, Int8Array, 1, offset, value);
+        },
+        setUint8: function setUint8(offset, value) {
+            set(this, Uint8Array, 1, offset, value);
+        },
+        setInt16: function setInt16(offset, value, le) {
+            set(this, Int16Array, 2, offset, value, le);
+        },
+        setUint16: function setUint16(offset, value, le) {
+            set(this, Uint16Array, 2, offset, value, le);
+        },
+        setInt32: function setInt32(offset, value, le) {
+            set(this, Int32Array, 4, offset, value, le);
+        },
+        setUint32: function setUint32(offset, value, le) {
+            set(this, Uint32Array, 4, offset, value, le);
+        },
+        setFloat32: function setFloat32(offset, value, le) {
+            set(this, Float32Array, 4, offset, value, le);
+        },
+        setFloat64: function setFloat64(offset, value, le) {
+            set(this, Float64Array, 8, offset, value, le);
+        }
+    };
+
+    // The get() utility function used by the get methods
+
+
+    function get(view, type, size, offset, le) {
+        if (offset === undefined) fail("Missing required offset argument");
+
+        if (offset < 0 || offset + size > view.byteLength) fail("Invalid index: " + offset);
+
+        if (size === 1 || !! le === nativele) {
+            // This is the easy case: the desired endianness 
+            // matches the native endianness.
+            // Typed arrays require proper alignment.  DataView does not.
+            if ((view.byteOffset + offset) % size === 0) return (new type(view.buffer, view.byteOffset + offset, 1))[0];
+            else {
+                // Copy bytes into the temp array, to fix alignment
+                for (var i = 0; i < size; i++)
+                temp[i] = view._bytes[offset + i];
+                // Now wrap that buffer with an array of the desired type
+                return (new type(temp.buffer))[0];
+            }
+        } else {
+            // If the native endianness doesn't match the desired, then
+            // we have to reverse the bytes
+            for (var i = 0; i < size; i++)
+            temp[size - i - 1] = view._bytes[offset + i];
+            return (new type(temp.buffer))[0];
+        }
+    }
+
+    // The set() utility function used by the set methods
+
+
+    function set(view, type, size, offset, value, le) {
+        if (offset === undefined) fail("Missing required offset argument");
+        if (value === undefined) fail("Missing required value argument");
+
+        if (offset < 0 || offset + size > view.byteLength) fail("Invalid index: " + offset);
+
+        if (size === 1 || !! le === nativele) {
+            // This is the easy case: the desired endianness 
+            // matches the native endianness.
+            if ((view.byteOffset + offset) % size === 0) {
+                (new type(view.buffer, view.byteOffset + offset, 1))[0] = value;
+            } else {
+                (new type(temp.buffer))[0] = value;
+                // Now copy the bytes into the view's buffer
+                for (var i = 0; i < size; i++)
+                view._bytes[i + offset] = temp[i];
+            }
+        } else {
+            // If the native endianness doesn't match the desired, then
+            // we have to reverse the bytes
+            // Store the value into our temporary buffer
+            (new type(temp.buffer))[0] = value;
+
+            // Now copy the bytes, in reverse order, into the view's buffer
+            for (var i = 0; i < size; i++)
+            view._bytes[offset + i] = temp[size - 1 - i];
+        }
+    }
+
+    function fail(msg) {
+        throw new Error(msg);
+    }
+}(this)); 

data/vendor/assets/javascripts/tests/lorem.txt

@@ -0,0 +1 @@
+Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat. Ut wisi enim ad minim veniam, quis nostrud exerci tation ullamcorper suscipit lobortis nisl ut aliquip ex ea commodo consequat. Duis autem vel eum iriure dolor in hendrerit in vulputate velit esse molestie consequat, vel illum dolore eu feugiat nulla facilisis at vero eros et accumsan et iusto odio dignissim qui blandit praesent luptatum zzril delenit augue duis dolore te feugait nulla facilisi. Nam liber tempor cum soluta nobis eleifend option congue nihil imperdiet doming id quod mazim placerat facer possim assum. Typi non habent claritatem insitam; est usus legentis in iis qui facit eorum claritatem. Investigationes demonstraverunt lectores legere me lius quod ii legunt saepius. Claritas est etiam processus dynamicus, qui sequitur mutationem consuetudium lectorum. Mirum est notare quam littera gothica, quam nunc putamus parum claram, anteposuerit litterarum formas humanitatis per seacula quarta decima et quinta decima. Eodem modo typi, qui nunc nobis videntur parum clari, fiant sollemnes in futurum.

data/vendor/assets/javascripts/tests/test1.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset='utf-8'>
+<title>Demo Blob</title>
+</head>
+<body>
+	<script type="text/javascript" src="../zip.js"></script>
+	<script type="text/javascript" src="../mime-types.js"></script>
+	<script type="text/javascript" src="dataview.js"></script>
+	<script type="text/javascript" src="test1.js"></script>
+</body>
+</html>

data/vendor/assets/javascripts/tests/test1.js

@@ -0,0 +1,46 @@
+var TEXT_CONTENT = "Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat. Ut wisi enim ad minim veniam, quis nostrud exerci tation ullamcorper suscipit lobortis nisl ut aliquip ex ea commodo consequat. Duis autem vel eum iriure dolor in hendrerit in vulputate velit esse molestie consequat, vel illum dolore eu feugiat nulla facilisis at vero eros et accumsan et iusto odio dignissim qui blandit praesent luptatum zzril delenit augue duis dolore te feugait nulla facilisi. Nam liber tempor cum soluta nobis eleifend option congue nihil imperdiet doming id quod mazim placerat facer possim assum. Typi non habent claritatem insitam; est usus legentis in iis qui facit eorum claritatem. Investigationes demonstraverunt lectores legere me lius quod ii legunt saepius. Claritas est etiam processus dynamicus, qui sequitur mutationem consuetudium lectorum. Mirum est notare quam littera gothica, quam nunc putamus parum claram, anteposuerit litterarum formas humanitatis per seacula quarta decima et quinta decima. Eodem modo typi, qui nunc nobis videntur parum clari, fiant sollemnes in futurum.";
+var FILENAME = "lorem.txt";
+var blob;
+
+function onerror(message) {
+	console.error(message);
+}
+
+function zipBlob(blob, callback) {
+	zip.createWriter(new zip.BlobWriter("application/zip"), function(zipWriter) {
+		zipWriter.add(FILENAME, new zip.BlobReader(blob), function() {
+			zipWriter.close(callback);
+		});
+	}, onerror);
+}
+
+function unzipBlob(blob, callback) {
+	zip.createReader(new zip.BlobReader(blob), function(zipReader) {
+		zipReader.getEntries(function(entries) {
+			entries[0].getData(new zip.BlobWriter(zip.getMimeType(entries[0].filename)), function(data) {
+				zipReader.close();
+				callback(data);
+			});
+		});
+	}, onerror);
+}
+
+function logBlobText(blob) {
+	var reader = new FileReader();
+	reader.onload = function(e) {
+		console.log(e.target.result);
+		console.log("--------------");
+	};
+	reader.readAsText(blob);
+}
+
+zip.workerScriptsPath = "../";
+blob = new Blob([ TEXT_CONTENT ], {
+	type : zip.getMimeType(FILENAME)
+});
+logBlobText(blob);
+zipBlob(blob, function(zippedBlob) {
+	unzipBlob(zippedBlob, function(unzippedBlob) {
+		logBlobText(unzippedBlob);
+	});
+});

data/vendor/assets/javascripts/tests/test10.html

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset='utf-8'>
+<title>Demo STORE unzip</title>
+</head>
+<body>
+	<script type="text/javascript" src="../zip.js"></script>
+	<script type="text/javascript" src="../zip-fs.js"></script>
+	<script type="text/javascript" src="../zip-ext.js"></script>
+	<script type="text/javascript" src="dataview.js"></script>
+	<script type="text/javascript" src="test10.js"></script>
+</body>
+</html>

data/vendor/assets/javascripts/tests/test10.js

@@ -0,0 +1,34 @@
+var URL = "lorem_store.zip";
+
+var zipFs = new zip.fs.FS();
+
+function onerror(message) {
+	console.error(message);
+}
+
+function zipImportedZip(callback) {
+	var directory = zipFs.root.addDirectory("import");
+	directory.importHttpContent(URL, false, function() {
+		zipFs.exportBlob(callback);
+	}, onerror);
+}
+
+function unzipBlob(blob, callback) {
+	zipFs.importBlob(blob, function() {
+		var directory = zipFs.root.getChildByName("import");
+		var firstEntry = directory.children[0];
+		firstEntry.getText(callback);
+	}, onerror);
+}
+
+function logText(text) {
+	console.log(text);
+	console.log("--------------");
+}
+
+zip.workerScriptsPath = "../";
+zipImportedZip(function(zippedBlob) {
+	unzipBlob(zippedBlob, function(unzippedText) {
+		logText(unzippedText);
+	});
+});

data/vendor/assets/javascripts/tests/test11.html

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset='utf-8'>
+<title>Demo ZipEntry.prototype.getFileEntry (File)</title>
+</head>
+<body>
+	<script type="text/javascript" src="../zip.js"></script>
+	<script type="text/javascript" src="../zip-fs.js"></script>
+	<script type="text/javascript" src="../zip-ext.js"></script>
+	<script type="text/javascript" src="dataview.js"></script>
+	<script type="text/javascript" src="test11.js"></script>
+</body>
+</html>

data/vendor/assets/javascripts/tests/test11.js

@@ -0,0 +1,67 @@
+var requestFileSystem = window.webkitRequestFileSystem || window.mozRequestFileSystem || window.msRequestFileSystem || window.requestFileSystem;
+var URL = "lorem.zip", FILENAME = "lorem.txt";
+var filesystem, zipFs = new zip.fs.FS();
+
+function onerror(message) {
+	console.error(message);
+}
+
+function removeRecursively(entry, onend, onerror) {
+	var rootReader = entry.createReader();
+	rootReader.readEntries(function(entries) {
+		var i = 0;
+
+		function next() {
+			i++;
+			removeNextEntry();
+		}
+
+		function removeNextEntry() {
+			var entry = entries[i];
+			if (entry) {
+				if (entry.isDirectory)
+					removeRecursively(entry, next, onerror);
+				if (entry.isFile)
+					entry.remove(next, onerror);
+			} else
+				onend();
+		}
+
+		removeNextEntry();
+	}, onerror);
+}
+
+function importZipToFilesystem(callback) {
+	zipFs.importHttpContent(URL, false, function() {
+		filesystem.root.getFile(FILENAME, {
+			create : true
+		}, function(fileEntry) {
+			var zippedFile = zipFs.root.getChildByName(FILENAME);
+			zippedFile.getFileEntry(fileEntry, callback, null, onerror);
+		}, onerror);
+	}, onerror);
+}
+
+function logFile(file) {
+	var reader = new FileReader();
+	reader.onload = function(event) {
+		console.log(event.target.result);
+		console.log("--------------");
+	};
+	reader.onerror = onerror;
+	reader.readAsText(file);
+}
+
+function test() {
+	importZipToFilesystem(function() {
+		filesystem.root.getFile(FILENAME, null, function(fileEntry) {
+			fileEntry.file(logFile, onerror);
+		}, onerror);
+	}, onerror);
+}
+
+zip.workerScriptsPath = "../";
+requestFileSystem(TEMPORARY, 4 * 1024 * 1024 * 1024, function(fs) {
+	filesystem = fs;
+	removeRecursively(filesystem.root, test, onerror);
+}, onerror);