persistence-rails 0.0.1

data/vendor/assets/javascript/persistence.jquery.js

@@ -0,0 +1,103 @@
+//= require persistence.core
+
+/**
+ * Copyright (c) 2010 Roberto Saccon <rsaccon@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+if (!window.jQuery) {
+  throw new Error("jQuery should be loaded before persistence.jquery.js");
+}
+
+if (!window.persistence) {
+  throw new Error("persistence.js should be loaded before persistence.jquery.js");
+} 
+
+persistence.jquery = {};
+
+/**
+ * crossbrowser implementation for entity-property
+ */
+persistence.defineProp = function(scope, field, setterCallback, getterCallback) {
+    scope[field] = function(value) {
+        if (value === undefined) {
+            return getterCallback();
+        } else {
+            setterCallback(value);
+            return scope;
+        }
+    };
+};
+
+/**
+ * crossbrowser implementation for entity-property setter
+ */
+persistence.set = function(scope, fieldName, value) {
+    if (persistence.isImmutable(fieldName)) throw new Error("immutable field: "+fieldName);
+    scope[fieldName](value);
+    return scope;
+};
+
+/**
+ * crossbrowser implementation for entity-property getter
+ */
+persistence.get = function(arg1, arg2) {
+    var val = (arguments.length == 1) ? arg1 : arg1[arg2];
+    return (typeof val === "function") ? val() : val;
+};
+
+
+(function($){
+    var originalDataMethod = $.fn.data;
+
+    $.fn.data = function(name, data) {
+        if (this[0] && this[0]._session && (this[0]._session === window.persistence)) {
+            if (data) {
+                this[0][name](data);
+                return this;
+            } else {
+                return this[0][name]();
+            }
+        } else {
+            return originalDataMethod.apply(this, arguments);
+        }
+    };
+
+    if (persistence.sync) {
+        persistence.sync.getJSON = function(url, success) {
+            $.getJSON(url, null, success);
+        };
+
+        persistence.sync.postJSON = function(url, data, success) {
+            $.ajax({
+                url: url,
+                type: 'POST',
+                data: data,
+                dataType: 'json',
+                success: function(response) {
+                    success(JSON.parse(response));
+                }
+            });
+        };
+    }
+})(jQuery);

data/vendor/assets/javascript/persistence.jquery.mobile.js

@@ -0,0 +1,256 @@
+/**
+ * Copyright (c) 2010 Roberto Saccon <rsaccon@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+if (!window.persistence.jquery) {
+  throw new Error("persistence.jquery.js should be loaded before persistence.jquery.mobile.js");
+}
+
+persistence.jquery.mobile = {};
+
+(function($){   
+    var $pjqm = persistence.jquery.mobile;
+    
+    if (window.openDatabase) {
+        $pjqm.pageEntityName = "Page";
+        $pjqm.imageEntityName = "Image";
+        $pjqm.pathField = "path";
+        $pjqm.dataField = "data";
+
+        var originalAjaxMethod = $.ajax;
+
+        function expand(docPath, srcPath) {
+            var basePath = (/\/$/.test(location.pathname) || (location.pathname == "")) ?
+                location.pathname :
+                location.pathname.substring(0, location.pathname.lastIndexOf("/"));
+            if (/^\.\.\//.test(srcPath)) {
+                // relative path with upward directory traversal
+                var count = 1, splits = docPath.split("/");
+                while (/^\.\.\//.test(srcPath)) {
+                    srcPath = srcPath.substring(3);
+                    count++;
+                }
+                return basePath + ((count >= splits.length) ?
+                    srcPath :
+                    splits.slice(0, splits.length-count).join("/") + "/" + srcPath);
+            } else if (/^\//.test(srcPath)) {
+                // absolute path
+                return srcPath;
+            } else {
+                // relative path without directory traversal
+                return basePath + docPath + "/" + srcPath;
+            }
+        }
+
+        function base64Image(img, type) {
+            var canvas = document.createElement("canvas");
+            canvas.width = img.width;
+            canvas.height = img.height;
+
+            // Copy the image contents to the canvas
+            var ctx = canvas.getContext("2d");
+            ctx.drawImage(img, 0, 0);
+
+            return canvas.toDataURL("image/" + type);
+        }
+
+        // parseUri 1.2.2
+        // (c) Steven Levithan <stevenlevithan.com>
+        // MIT License
+
+        var parseUriOptions = {
+            strictMode: false,
+            key: ["source","protocol","authority","userInfo","user","password","host","port","relative","path","directory","file","query","anchor"],
+            q:   {
+                name:   "queryKey",
+                parser: /(?:^|&)([^&=]*)=?([^&]*)/g
+            },
+            parser: {
+                strict: /^(?:([^:\/?#]+):)?(?:\/\/((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?))?((((?:[^?#\/]*\/)*)([^?#]*))(?:\?([^#]*))?(?:#(.*))?)/,
+                loose:  /^(?:(?![^:@]+:[^:@\/]*@)([^:\/?#.]+):)?(?:\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/
+            }
+        };
+
+        function parseUri (str) {
+            var o   = parseUriOptions,
+                m   = o.parser[o.strictMode ? "strict" : "loose"].exec(str),
+                uri = {},
+                i   = 14;
+
+            while (i--) uri[o.key[i]] = m[i] || "";
+
+            uri[o.q.name] = {};
+            uri[o.key[12]].replace(o.q.parser, function ($0, $1, $2) {
+                if ($1) uri[o.q.name][$1] = $2;
+            });
+
+            return uri;
+        }
+
+        function getImageType(parsedUri) {
+            if (parsedUri.queryKey.type) {
+                return parsedUri.queryKey.type;
+            }  else {
+                return (/\.png$/i.test(parsedUri.path)) ? "png" : "jpeg";
+            }
+        }
+
+        $.ajax = function(settings) {
+            var parsedUrl = parseUri(settings.url);
+            var entities = {}, urlPathSegments = parsedUrl.path.split("/");
+            if ((settings.type == "post") && (urlPathSegments.length > 1)) {
+                var entityName = (urlPathSegments[1].charAt(0).toUpperCase() + urlPathSegments[1].substring(1));
+                if (persistence.isDefined(entityName)) {
+                    var Form = persistence.define(entityName);
+
+                    var persistFormData = function() {
+                        var obj = {};
+                        settings.data.replace(/(?:^|&)([^&=]*)=?([^&]*)/g, function ( $0, $1, $2 ) {
+                            if ($1) {
+                                obj[$1] = $2;
+                            }
+                        });
+
+                        var entity = new Form(obj);
+                        persistence.add(entity);
+                        persistence.flush();
+                    };
+
+                    if (!navigator.hasOwnProperty("onLine") || navigator.onLine) {
+                        originalAjaxMethod({
+                            url: settings.url,
+                            success: function(data) {
+                                settings.success(data);
+                                persistFormData();
+                            },
+                            error: settings.error
+                        });
+                    } else {
+                        persistFormData();
+                    }
+                } else {
+                    originalAjaxMethod(settings);
+                }
+            } else if (persistence.urlExcludeRx && persistence.urlExcludeRx.test(parsedUrl.path)) {
+                originalAjaxMethod(settings);
+            } else {
+                if (persistence.isDefined($pjqm.pageEntityName)) {
+                    var Page = persistence.define($pjqm.pageEntityName);
+                    Page.findBy($pjqm.pathField, settings.url, function(page) {
+                        if (page) {
+                            //
+                            // load page and images from persistencejs
+                            //
+                            if (settings.success) {
+                                var pos = 0, countOuter = 0, countInner = 0;
+                                var inStr = page[$pjqm.dataField](), outStr = "";
+                                var regExp = /(<img[^>]+src\s*=\s*[\'\"])([^\'\"]+)([\'\"][^>]*>)/ig;
+                                var replaced = inStr.replace(regExp, function($0, $1, $2, $3, offset) {
+                                    countOuter++;
+                                    if (persistence.isDefined($pjqm.imageEntityName)) {
+                                        var Img = persistence.define($pjqm.imageEntityName);
+                                        Img.findBy($pjqm.pathField, expand(settings.url, $2), function(image){
+                                            countInner++;
+                                            if (image) {
+                                                var imgTagStr = $1 + image[$pjqm.dataField]() + $3;
+                                                outStr += inStr.substring(pos, offset) + imgTagStr;
+                                                pos = offset + imgTagStr.length;
+                                            } else {
+                                                outStr += inStr.substring(pos, offset) + imgTagStr;
+                                                pos = offset;
+                                            }
+                                            if (countInner == countOuter) {
+                                                settings.success(outStr);
+                                            }
+                                            return "";
+                                        });
+                                    } else {
+                                        outStr += inStr.substring(pos, offset) + imgTagStr;
+                                        pos = offset;
+                                    }
+                                });
+                                if (replaced == inStr) {
+                                    settings.success(inStr);
+                                } else if (!persistence.isDefined($pjqm.imageEntityName)) {
+                                    settings.success(outStr);
+                                };
+                            }
+                        } else {
+                            //
+                            // ajax-load page and persist page and images
+                            //
+                            originalAjaxMethod({
+                                url: settings.url,
+                                success: function(data) {
+                                    settings.success(data);
+                                    if (persistence.isDefined($pjqm.pageEntityName)) {
+                                        var entities = [], crawlImages = false;
+                                        var Page = persistence.define($pjqm.pageEntityName);
+                                        if (persistence.isDefined($pjqm.imageEntityName)) {
+                                            var Img = persistence.define($pjqm.imageEntityName), count = 0;
+                                            $("#"+settings.url.replace(/\//g,"\\/").replace(/\./g,"\\.")+" img").each(function(i, img){
+                                                crawlImages = true;
+                                                count++;
+                                                $(img).load(function() {
+                                                  var obj = {}, parsedImgSrc = parseUri(img.src);
+                                                  obj[$pjqm.pathField] = parsedImgSrc.path;
+                                                  obj[$pjqm.dataField] = base64Image(img, getImageType(parsedImgSrc));
+                                                  entities.push(new Img(obj));
+
+                                                  if (crawlImages && (--count == 0)) {
+                                                      for (var j=0; j<entities.length; j++) {
+                                                          persistence.add(entities[j]);
+                                                      }
+                                                      persistence.flush();
+                                                  }
+                                                });
+                                                $(img).error(function() {
+                                                    crawlImages = false;
+                                                });
+                                            });
+                                        }
+
+                                        var obj = {};
+                                        obj[$pjqm.pathField] = settings.url;
+                                        obj[$pjqm.dataField] = data;
+
+                                        entities.push(new Page(obj));
+
+                                        if (!crawlImages) {
+                                            persistence.add(entities[0]);
+                                            persistence.flush();
+                                        }
+                                    }
+                                },
+                                error: settings.error
+                            });
+                        }
+                    });
+                } else {
+                    originalAjaxMethod(settings);
+                }
+            }
+        };
+    }
+})(jQuery);

data/vendor/assets/javascript/persistence.js

@@ -0,0 +1,5 @@
+//= require persistence.core
+//= require persistence.store.sql
+//= require persistence.store.websql
+//= require persistence.sync
+//= require persistence.search

data/vendor/assets/javascript/persistence.migrations.js

@@ -0,0 +1,303 @@
+//= require persistence.core
+
+/**
+ * @license
+ * Copyright (c) 2010 Fábio Rehm <fgrehm@gmail.com>
+ * 
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ * 
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+if(!window.persistence) { // persistence.js not loaded!
+  throw new Error("persistence.js should be loaded before persistence.migrations.js");
+}
+
+(function() {
+  
+    var Migrator = {
+      migrations: [],
+      
+      version: function(callback) {
+        persistence.transaction(function(t){
+          t.executeSql('SELECT current_version FROM schema_version', null, function(result){
+            if (result.length == 0) {
+              t.executeSql('INSERT INTO schema_version VALUES (0)', null, function(){
+                callback(0);
+              });
+            } else {
+              callback(result[0].current_version);
+            }
+          });
+        });
+      },
+      
+      setVersion: function(v, callback) {
+        persistence.transaction(function(t){
+          t.executeSql('UPDATE schema_version SET current_version = ?', [v], function(){
+            Migrator._version = v;
+            if (callback) callback();
+          });
+        });
+      },
+      
+      setup: function(callback) {
+        persistence.transaction(function(t){
+          t.executeSql('CREATE TABLE IF NOT EXISTS schema_version (current_version INTEGER)', null, function(){
+            // Creates a dummy migration just to force setting schema version when cleaning DB
+            Migrator.migration(0, { up: function() { }, down: function() { } });
+            if (callback) callback();
+          });
+        });
+      },
+      
+      // Method should only be used for testing
+      reset: function(callback) {
+        // Creates a dummy migration just to force setting schema version when cleaning DB
+        Migrator.migrations = [];
+        Migrator.migration(0, { up: function() { }, down: function() { } });
+        Migrator.setVersion(0, callback);
+      },
+      
+      migration: function(version, actions) {
+        Migrator.migrations[version] = new Migration(version, actions);
+        return Migrator.migrations[version];
+      },
+      
+      migrateUpTo: function(version, callback) {
+        var migrationsToRun = [];
+        
+        function migrateOne() {
+          var migration = migrationsToRun.pop();
+          
+          if (!migration) callback();
+          
+          migration.up(function(){
+            if (migrationsToRun.length > 0) {
+              migrateOne();
+            } else if (callback) {
+              callback();
+            }
+          });
+        }
+        
+        this.version(function(currentVersion){
+          for (var v = currentVersion+1; v <= version; v++)
+            migrationsToRun.unshift(Migrator.migrations[v]);
+          
+          if (migrationsToRun.length > 0) {
+            migrateOne();
+          } else if (callback) {
+            callback();
+          }
+        });
+      },
+      
+      migrateDownTo: function(version, callback) {
+        var migrationsToRun = [];
+        
+        function migrateOne() {
+          var migration = migrationsToRun.pop();
+          
+          if (!migration) callback();
+          
+          migration.down(function(){
+            if (migrationsToRun.length > 0) {
+              migrateOne();
+            } else if (callback) {
+              callback();
+            }
+          });
+        }
+        
+        this.version(function(currentVersion){
+          for (var v = currentVersion; v > version; v--)
+            migrationsToRun.unshift(Migrator.migrations[v]);
+          
+          if (migrationsToRun.length > 0) {
+            migrateOne();
+          } else if (callback) {
+            callback();
+          }
+        });
+      },
+      
+      migrate: function(version, callback) {
+        if ( arguments.length === 1 ) {
+          callback = version;
+          version = this.migrations.length-1;
+        }
+        
+        this.version(function(curVersion){
+          if (curVersion < version)
+            Migrator.migrateUpTo(version, callback);
+          else if (curVersion > version)
+            Migrator.migrateDownTo(version, callback);
+          else
+            callback();
+        });
+      }
+    }
+    
+    var Migration = function(version, body) {
+      this.version = version;
+      // TODO check if actions contains up and down methods
+      this.body = body;
+      this.actions = [];
+    };
+    
+    Migration.prototype.executeActions = function(callback, customVersion) {
+      var actionsToRun = this.actions;
+      var version = (customVersion!==undefined) ? customVersion : this.version;
+      
+      persistence.transaction(function(tx){
+        function nextAction() {
+          if (actionsToRun.length == 0)
+            Migrator.setVersion(version, callback);
+          else {
+            var action = actionsToRun.pop();
+            action(tx, nextAction);
+          }
+        }
+        
+        nextAction();
+      });
+    }
+    
+    Migration.prototype.up = function(callback) {
+      if (this.body.up) this.body.up.apply(this);
+      this.executeActions(callback);
+    }
+    
+    Migration.prototype.down = function(callback) {
+      if (this.body.down) this.body.down.apply(this);
+      this.executeActions(callback, this.version-1);
+    }
+    
+    Migration.prototype.createTable = function(tableName, callback) {
+      var table = new ColumnsHelper();
+      
+      if (callback) callback(table);
+      
+      var column;
+      var sql = 'CREATE TABLE ' + tableName + ' (id VARCHAR(32) PRIMARY KEY';
+      while (column = table.columns.pop())
+        sql += ', ' + column;
+      
+      this.executeSql(sql + ')');
+    }
+    
+    Migration.prototype.dropTable = function(tableName) {
+      var sql = 'DROP TABLE ' + tableName;
+      this.executeSql(sql);
+    }
+    
+    Migration.prototype.addColumn = function(tableName, columnName, columnType) {
+      var sql = 'ALTER TABLE ' + tableName + ' ADD ' + columnName + ' ' + columnType;
+      this.executeSql(sql);
+    }
+    
+    Migration.prototype.removeColumn = function(tableName, columnName) {
+      this.action(function(tx, nextCommand){
+        var sql = 'select sql from sqlite_master where type = "table" and name == "'+tableName+'"';
+        tx.executeSql(sql, null, function(result){
+          var columns = new RegExp("CREATE TABLE `\\w+` |\\w+ \\((.+)\\)").exec(result[0].sql)[1].split(', ');
+          var selectColumns = [];
+          var columnsSql = [];
+          
+          for (var i = 0; i < columns.length; i++) {
+            var colName = new RegExp("((`\\w+`)|(\\w+)) .+").exec(columns[i])[1];
+            if (colName == columnName) continue;
+            
+            columnsSql.push(columns[i]);
+            selectColumns.push(colName);
+          }
+          columnsSql = columnsSql.join(', ');
+          selectColumns = selectColumns.join(', ');
+          
+          var queries = [];
+          queries.unshift(["ALTER TABLE " + tableName + " RENAME TO " + tableName + "_bkp;", null]);
+          queries.unshift(["CREATE TABLE " + tableName + " (" + columnsSql + ");", null]);
+          queries.unshift(["INSERT INTO " + tableName + " SELECT " + selectColumns + " FROM " + tableName + "_bkp;", null]);
+          queries.unshift(["DROP TABLE " + tableName + "_bkp;", null]);
+          
+          persistence.executeQueriesSeq(tx, queries, nextCommand);
+        });
+      });
+    }
+    
+    Migration.prototype.addIndex = function(tableName, columnName, unique) {
+      var sql = 'CREATE ' + (unique === true ? 'UNIQUE' : '') + ' INDEX ' + tableName + '_' + columnName + ' ON ' + tableName + ' (' + columnName + ')';
+      this.executeSql(sql);
+    }
+    
+    Migration.prototype.removeIndex = function(tableName, columnName) {
+      var sql = 'DROP INDEX ' + tableName + '_' + columnName;
+      this.executeSql(sql);
+    }
+    
+    Migration.prototype.executeSql = function(sql, args) {
+      this.action(function(tx, nextCommand){
+        tx.executeSql(sql, args, nextCommand);
+      });
+    }
+    
+    Migration.prototype.action = function(callback) {
+      this.actions.unshift(callback);
+    }
+    
+    var ColumnsHelper = function() {
+      this.columns = [];
+    }
+    
+    ColumnsHelper.prototype.text = function(columnName) {
+      this.columns.unshift(columnName + ' TEXT');
+    }
+    
+    ColumnsHelper.prototype.integer = function(columnName) {
+      this.columns.unshift(columnName + ' INT');
+    }
+    
+    ColumnsHelper.prototype.real = function(columnName) {
+      this.columns.unshift(columnName + ' REAL');
+    }
+    
+    ColumnsHelper.prototype['boolean'] = function(columnName) {
+      this.columns.unshift(columnName + ' BOOL');
+    }
+    
+    ColumnsHelper.prototype.date = function(columnName) {
+      this.columns.unshift(columnName + ' DATE');
+    }
+    
+    ColumnsHelper.prototype.json = function(columnName) {
+      this.columns.unshift(columnName + ' TEXT');
+    }
+    
+    // Makes Migrator and Migration available to tests
+    persistence.migrations = {};
+    persistence.migrations.Migrator = Migrator;
+    persistence.migrations.Migration = Migration;
+    persistence.migrations.init = function() { Migrator.setup.apply(Migrator, Array.prototype.slice.call(arguments, 0))};
+    
+    persistence.migrate = function() { Migrator.migrate.apply(Migrator, Array.prototype.slice.call(arguments, 0))};
+    persistence.defineMigration = function() { Migrator.migration.apply(Migrator, Array.prototype.slice.call(arguments, 0))};
+    
+}());