seapig-rails 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 25b28f9d7975a6bfd32062f20bc310c01d79735e
+  data.tar.gz: 186a43d3f1e36b1b8b1244d6524b344388d34e74
+SHA512:
+  metadata.gz: 31bd90e20f73825d39bcafd121eaf070a0f35229bfd2d574ca63ae96ed1b00d7b5e33343622acae53dd5c28c9ed02cad3e7d6895ac720cdc660f5dab254d9d7d
+  data.tar.gz: ce55ecb9cfe3acfcb52b8d24992b2ed4b037f15700d6da06590e602b1352754a12ffaf94f9d249b6747c60b14b93de8d8734cffeada736ad30e5abf58363ac57

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 yunta
+
+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.

data/README.rdoc

@@ -0,0 +1,36 @@
+= Seapig
+
+Nothing here yet.
+
+To cover:
+
+* what are seapigs and why they exist? (why not just having a db table?)
+  * link to https://www.youtube.com/watch?v=_y4DbZivHCY
+* properties of seapig system
+  * data is cached in memory
+  * only diffs are sent
+  * data is generated in separate processes
+  * data gets regenerated on dependency change (immediately on db change)
+* describe current limits
+  * one level deps only
+  * single object can have at most one generation process running at all times
+  * cache is dropped when last client unlinks
+  * no client-side timeout detection
+  * postgres only (but is that really a problem? ;))
+* graph of server/client side seapig object states
+* disclaimer on non-efficient code. it's all a draft, a test of idea.
+* rails not needed
+* stuff will change
+* seapig = firebase for apps that need real db
+* works nicely with mithril
+* how to use this shit
+  * dummy app is a minimal demo
+  * bundle exec rails s
+  * bundle exec ruby ../../bin/seapig-server.rb
+  * bundle exec ruby ../../bin/seapig-worker.rb ws://127.0.0.1:3001/seapig
+  * bundle exec ruby ../../bin/seapig-notifier.rb ws://127.0.0.1:3001/seapig
+  * application.js needs: require seapig/seapig
+  * application.js needs: require json-patch
+  * ActiveRecord models that are used for triggering regeneration of data need:
+    * acts_as_seapig_dependency
+    * and seapig_dependency_changed after commits

data/Rakefile

@@ -0,0 +1,37 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Seapig'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+load 'rails/tasks/statistics.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/assets/javascripts/seapig/seapig.js.coffee

@@ -0,0 +1,81 @@
+class @SeapigServer
+
+
+        constructor: (url, options = {})->
+                @url = url
+                @options = options
+                @slave_objects = {}
+                @master_objects = {}
+                @connect()
+
+
+        connect: () ->
+                @connected = false
+
+                @socket = new WebSocket(@url,'SeaPig-0.0')
+
+                @socket.onerror = (error) =>
+                        console.log('Seapig socket error', error)
+                        @socket.close()
+
+                @socket.onclose = () =>
+                        console.log('Seapig connection closed')
+                        for object_id, object of @slave_objects
+                                object.valid = false
+                        setTimeout((=>@connect()), 2000)
+
+                @socket.onopen = () =>
+                        console.log('Seapig connection opened')
+                        @connected = true
+                        @socket.send(JSON.stringify(action: 'client-options-set', options: @options))
+                        for object_id, object of @slave_objects
+                                @socket.send(JSON.stringify(action: 'object-consumer-register', id: object_id, latest_known_version: object.version))
+
+                @socket.onmessage = (event) =>
+                        #console.log('Seapig message received', event)
+                        data = JSON.parse(event.data)
+                        switch data.action
+                                when 'object-update'
+                                        @slave_objects[data.id].patch(data) if @slave_objects[data.id]
+                                else
+                                        console.log('Seapig received a stupid message', data)
+
+
+        slave: (object_id) ->
+                @socket.send(JSON.stringify(action: 'object-consumer-register', id: object_id, latest_known_version: null)) if @connected
+                @slave_objects[object_id] = new SeapigObject(object_id)
+
+
+        unlink: (object_id) ->
+                delete @slave_objects[object_id]
+                @socket.send(JSON.stringify(action: 'unlink', id: object_id)) if @connected
+
+
+
+class SeapigObject
+
+
+        constructor: (id) ->
+                @id = id
+                @valid = false
+                @version = null
+                @object = {}
+                @shadow = {}
+                @onchange = null
+
+
+        patch: (data) ->
+                if not data.old_version?
+                        delete @object[key] for key, value of @object
+                else if not _.isEqual(@version, data.old_version)
+                        console.log("Seapig lost some updates, this shouldn't ever happen", @version, data.old_version)
+                jsonpatch.apply(@object, data.patch)
+                @version = data.new_version
+                @valid = true
+                @onchange() if @onchange?
+
+        changed: () ->
+                @version += 1
+                patch = jsonpatch.compare(@shadow, @object)
+                console.log(patch)
+                @shadow = JSON.parse(JSON.stringify(@object))

data/bin/seapig-notifier

@@ -0,0 +1,66 @@
+#!/bin/env ruby
+
+require './config/environment.rb'
+
+require 'websocket-eventmachine-client'
+require 'json'
+
+
+Rails.application.eager_load!
+notifiers = Hash[*ActiveRecord::Base.descendants.select { |cls| cls.respond_to?('seapig_dependency_version') }.map { |notifier| [notifier.name,notifier] }.flatten ]
+
+$last_versions = {}
+$payloads = Queue.new
+
+EM.run {
+
+	socket = WebSocket::EventMachine::Client.connect(uri: ARGV[0])
+
+	
+	on_database_change = Proc.new {
+		payloads = Set.new
+		payloads << $payloads.pop while not $payloads.empty?
+		payloads.each { |notifier_name|
+			version = notifiers[notifier_name].seapig_dependency_version #F handle wrong names
+			p version
+			if $last_versions[notifier_name] != version	
+				#socket.send(JSON.dump(action: 'object-update', id: notifier_name, version: version))
+				socket.send(JSON.dump(action: 'object-patch', id: notifier_name, new_version: version, old_version: 0))
+				$last_versions[notifier_name] = version
+			end
+		}
+	}
+
+
+	socket.onopen {
+		socket.send(JSON.dump(action: 'client-options-set', options: {name: 'notifier'}))
+		Thread.new {
+			ActiveRecord::Base.connection_pool.with_connection { |connection|
+				connection = connection.instance_variable_get(:@connection)
+				connection.exec("LISTEN seapig_dependency_changed")
+				loop {
+					connection.wait_for_notify { |channel, pid, payloads|
+						puts "Got notification: channel="+channel+", pid="+pid.inspect+", payload="+payloads.inspect
+						payloads.split(",").each { |payload| $payloads << payload }
+						EM.schedule(on_database_change)
+					}
+				}
+			}
+		}
+		EM.schedule on_database_change
+	}
+
+	
+	socket.onclose { |code, reason|
+		EM.stop
+	}
+
+
+	EM.add_periodic_timer(60) {
+#		socket.send(JSON.dump(action: 'object-update', id: 'Minute', version: Time.new.to_i/60))
+		socket.send(JSON.dump(action: 'object-patch', id: 'Minute', new_version: Time.new.to_i/60, old_version: 0))
+	}
+	
+}
+
+	

data/config/routes.rb

@@ -0,0 +1,2 @@
+Rails.application.routes.draw do
+end

data/lib/seapig-rails.rb

@@ -0,0 +1,5 @@
+require "seapig/engine"
+require "seapig/acts_as_seapig_dependency.rb"
+
+module Seapig
+end

data/lib/seapig/acts_as_seapig_dependency.rb

@@ -0,0 +1,34 @@
+module SeapigDependency
+
+	module ActsAsSeapigDependency
+
+		extend ActiveSupport::Concern
+
+		
+		module ClassMethods
+			
+			def acts_as_seapig_dependency(options = {})
+
+				self.instance_eval do
+
+					def seapig_dependency_version
+						self.find_by_sql('SELECT GREATEST(MAX(created_at), MAX(updated_at)) AS version FROM '+table_name).first.version.to_f
+					end
+					
+					def seapig_dependency_changed(*tables)
+						tables << self.name
+						connection.instance_variable_get(:@connection).exec("NOTIFY seapig_dependency_changed,'"+tables.map { |table| table.kind_of?(Class) and table.name or table }.uniq.join(',')+"'")
+					end
+					
+				end
+
+			end
+			
+		end
+
+	end
+
+end
+ 
+
+ActiveRecord::Base.send :include, SeapigDependency::ActsAsSeapigDependency

data/lib/seapig/engine.rb

@@ -0,0 +1,4 @@
+module Seapig
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/seapig/version.rb

@@ -0,0 +1,3 @@
+module Seapig
+  VERSION = "0.0.1"
+end

data/lib/tasks/seapig_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :seapig do
+#   # Task goes here
+# end

data/test/dummy/README.rdoc

@@ -0,0 +1,28 @@
+== README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...
+
+
+Please feel free to use a different markup language if you do not plan to run
+<tt>rake doc:app</tt>.

data/test/dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Rails.application.load_tasks

data/test/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,15 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .
+//= require seapig/seapig
+//= require json-patch

data/test/dummy/app/assets/javascripts/json-patch.js

@@ -0,0 +1,392 @@
+/*!
+* https://github.com/Starcounter-Jack/JSON-Patch
+* json-patch-duplex.js version: 0.5.4
+* (c) 2013 Joachim Wester
+* MIT license
+*/
+var __extends = this.__extends || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    __.prototype = b.prototype;
+    d.prototype = new __();
+};
+var OriginalError = Error;
+
+var jsonpatch;
+(function (jsonpatch) {
+    /* Do nothing if module is already defined.
+    Doesn't look nice, as we cannot simply put
+    `!jsonpatch &&` before this immediate function call
+    in TypeScript.
+    */
+    if (jsonpatch.apply) {
+        return;
+    }
+
+    var _objectKeys = (function () {
+        if (Object.keys)
+            return Object.keys;
+
+        return function (o) {
+            var keys = [];
+            for (var i in o) {
+                if (o.hasOwnProperty(i)) {
+                    keys.push(i);
+                }
+            }
+            return keys;
+        };
+    })();
+
+    function _equals(a, b) {
+        switch (typeof a) {
+            case 'undefined':
+            case 'boolean':
+            case 'string':
+            case 'number':
+                return a === b;
+            case 'object':
+                if (a === null)
+                    return b === null;
+                if (_isArray(a)) {
+                    if (!_isArray(b) || a.length !== b.length)
+                        return false;
+
+                    for (var i = 0, l = a.length; i < l; i++)
+                        if (!_equals(a[i], b[i]))
+                            return false;
+
+                    return true;
+                }
+
+                var bKeys = _objectKeys(b);
+                var bLength = bKeys.length;
+                if (_objectKeys(a).length !== bLength)
+                    return false;
+
+                for (var i = 0; i < bLength; i++)
+                    if (!_equals(a[i], b[i]))
+                        return false;
+
+                return true;
+
+            default:
+                return false;
+        }
+    }
+
+    /* We use a Javascript hash to store each
+    function. Each hash entry (property) uses
+    the operation identifiers specified in rfc6902.
+    In this way, we can map each patch operation
+    to its dedicated function in efficient way.
+    */
+    /* The operations applicable to an object */
+    var objOps = {
+        add: function (obj, key) {
+            obj[key] = this.value;
+            return true;
+        },
+        remove: function (obj, key) {
+            delete obj[key];
+            return true;
+        },
+        replace: function (obj, key) {
+            obj[key] = this.value;
+            return true;
+        },
+        move: function (obj, key, tree) {
+            var temp = { op: "_get", path: this.from };
+            apply(tree, [temp]);
+            apply(tree, [
+                { op: "remove", path: this.from }
+            ]);
+            apply(tree, [
+                { op: "add", path: this.path, value: temp.value }
+            ]);
+            return true;
+        },
+        copy: function (obj, key, tree) {
+            var temp = { op: "_get", path: this.from };
+            apply(tree, [temp]);
+            apply(tree, [
+                { op: "add", path: this.path, value: temp.value }
+            ]);
+            return true;
+        },
+        test: function (obj, key) {
+            return _equals(obj[key], this.value);
+        },
+        _get: function (obj, key) {
+            this.value = obj[key];
+        }
+    };
+
+    /* The operations applicable to an array. Many are the same as for the object */
+    var arrOps = {
+        add: function (arr, i) {
+            arr.splice(i, 0, this.value);
+            return true;
+        },
+        remove: function (arr, i) {
+            arr.splice(i, 1);
+            return true;
+        },
+        replace: function (arr, i) {
+            arr[i] = this.value;
+            return true;
+        },
+        move: objOps.move,
+        copy: objOps.copy,
+        test: objOps.test,
+        _get: objOps._get
+    };
+
+    /* The operations applicable to object root. Many are the same as for the object */
+    var rootOps = {
+        add: function (obj) {
+            rootOps.remove.call(this, obj);
+            for (var key in this.value) {
+                if (this.value.hasOwnProperty(key)) {
+                    obj[key] = this.value[key];
+                }
+            }
+            return true;
+        },
+        remove: function (obj) {
+            for (var key in obj) {
+                if (obj.hasOwnProperty(key)) {
+                    objOps.remove.call(this, obj, key);
+                }
+            }
+            return true;
+        },
+        replace: function (obj) {
+            apply(obj, [
+                { op: "remove", path: this.path }
+            ]);
+            apply(obj, [
+                { op: "add", path: this.path, value: this.value }
+            ]);
+            return true;
+        },
+        move: objOps.move,
+        copy: objOps.copy,
+        test: function (obj) {
+            return (JSON.stringify(obj) === JSON.stringify(this.value));
+        },
+        _get: function (obj) {
+            this.value = obj;
+        }
+    };
+
+    var _isArray;
+    if (Array.isArray) {
+        _isArray = Array.isArray;
+    } else {
+        _isArray = function (obj) {
+            return obj.push && typeof obj.length === 'number';
+        };
+    }
+
+    //3x faster than cached /^\d+$/.test(str)
+    function isInteger(str) {
+        var i = 0;
+        var len = str.length;
+        var charCode;
+        while (i < len) {
+            charCode = str.charCodeAt(i);
+            if (charCode >= 48 && charCode <= 57) {
+                i++;
+                continue;
+            }
+            return false;
+        }
+        return true;
+    }
+
+    /// Apply a json-patch operation on an object tree
+    function apply(tree, patches, validate) {
+        var result = false, p = 0, plen = patches.length, patch, key;
+        while (p < plen) {
+            patch = patches[p];
+            p++;
+
+            // Find the object
+            var path = patch.path || "";
+            var keys = path.split('/');
+            var obj = tree;
+            var t = 1;
+            var len = keys.length;
+            var existingPathFragment = undefined;
+
+            while (true) {
+                key = keys[t];
+
+                if (validate) {
+                    if (existingPathFragment === undefined) {
+                        if (obj[key] === undefined) {
+                            existingPathFragment = keys.slice(0, t).join('/');
+                        } else if (t == len - 1) {
+                            existingPathFragment = patch.path;
+                        }
+                        if (existingPathFragment !== undefined) {
+                            this.validator(patch, p - 1, tree, existingPathFragment);
+                        }
+                    }
+                }
+
+                t++;
+                if (key === undefined) {
+                    if (t >= len) {
+                        result = rootOps[patch.op].call(patch, obj, key, tree); // Apply patch
+                        break;
+                    }
+                }
+                if (_isArray(obj)) {
+                    if (key === '-') {
+                        key = obj.length;
+                    } else {
+                        if (validate && !isInteger(key)) {
+                            throw new JsonPatchError("Expected an unsigned base-10 integer value, making the new referenced value the array element with the zero-based index", "OPERATION_PATH_ILLEGAL_ARRAY_INDEX", p - 1, patch.path, patch);
+                        }
+                        key = parseInt(key, 10);
+                    }
+                    if (t >= len) {
+                        if (validate && patch.op === "add" && key > obj.length) {
+                            throw new JsonPatchError("The specified index MUST NOT be greater than the number of elements in the array", "OPERATION_VALUE_OUT_OF_BOUNDS", p - 1, patch.path, patch);
+                        }
+                        result = arrOps[patch.op].call(patch, obj, key, tree); // Apply patch
+                        break;
+                    }
+                } else {
+                    if (key && key.indexOf('~') != -1)
+                        key = key.replace(/~1/g, '/').replace(/~0/g, '~'); // escape chars
+                    if (t >= len) {
+                        result = objOps[patch.op].call(patch, obj, key, tree); // Apply patch
+                        break;
+                    }
+                }
+                obj = obj[key];
+            }
+        }
+        return result;
+    }
+    jsonpatch.apply = apply;
+
+    var JsonPatchError = (function (_super) {
+        __extends(JsonPatchError, _super);
+        function JsonPatchError(message, name, index, operation, tree) {
+            _super.call(this, message);
+            this.message = message;
+            this.name = name;
+            this.index = index;
+            this.operation = operation;
+            this.tree = tree;
+        }
+        return JsonPatchError;
+    })(OriginalError);
+    jsonpatch.JsonPatchError = JsonPatchError;
+
+    jsonpatch.Error = JsonPatchError;
+
+    /**
+    * Recursively checks whether an object has any undefined values inside.
+    */
+    function hasUndefined(obj) {
+        if (obj === undefined) {
+            return true;
+        }
+
+        if (typeof obj == "array" || typeof obj == "object") {
+            for (var i in obj) {
+                if (hasUndefined(obj[i])) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    /**
+    * Validates a single operation. Called from `jsonpatch.validate`. Throws `JsonPatchError` in case of an error.
+    * @param {object} operation - operation object (patch)
+    * @param {number} index - index of operation in the sequence
+    * @param {object} [tree] - object where the operation is supposed to be applied
+    * @param {string} [existingPathFragment] - comes along with `tree`
+    */
+    function validator(operation, index, tree, existingPathFragment) {
+        if (typeof operation !== 'object' || operation === null || _isArray(operation)) {
+            throw new JsonPatchError('Operation is not an object', 'OPERATION_NOT_AN_OBJECT', index, operation, tree);
+        } else if (!objOps[operation.op]) {
+            throw new JsonPatchError('Operation `op` property is not one of operations defined in RFC-6902', 'OPERATION_OP_INVALID', index, operation, tree);
+        } else if (typeof operation.path !== 'string') {
+            throw new JsonPatchError('Operation `path` property is not a string', 'OPERATION_PATH_INVALID', index, operation, tree);
+        } else if ((operation.op === 'move' || operation.op === 'copy') && typeof operation.from !== 'string') {
+            throw new JsonPatchError('Operation `from` property is not present (applicable in `move` and `copy` operations)', 'OPERATION_FROM_REQUIRED', index, operation, tree);
+        } else if ((operation.op === 'add' || operation.op === 'replace' || operation.op === 'test') && operation.value === undefined) {
+            throw new JsonPatchError('Operation `value` property is not present (applicable in `add`, `replace` and `test` operations)', 'OPERATION_VALUE_REQUIRED', index, operation, tree);
+        } else if ((operation.op === 'add' || operation.op === 'replace' || operation.op === 'test') && hasUndefined(operation.value)) {
+            throw new JsonPatchError('Operation `value` property is not present (applicable in `add`, `replace` and `test` operations)', 'OPERATION_VALUE_CANNOT_CONTAIN_UNDEFINED', index, operation, tree);
+        } else if (tree) {
+            if (operation.op == "add") {
+                var pathLen = operation.path.split("/").length;
+                var existingPathLen = existingPathFragment.split("/").length;
+                if (pathLen !== existingPathLen + 1 && pathLen !== existingPathLen) {
+                    throw new JsonPatchError('Cannot perform an `add` operation at the desired path', 'OPERATION_PATH_CANNOT_ADD', index, operation, tree);
+                }
+            } else if (operation.op === 'replace' || operation.op === 'remove' || operation.op === '_get') {
+                if (operation.path !== existingPathFragment) {
+                    throw new JsonPatchError('Cannot perform the operation at a path that does not exist', 'OPERATION_PATH_UNRESOLVABLE', index, operation, tree);
+                }
+            } else if (operation.op === 'move' || operation.op === 'copy') {
+                var existingValue = { op: "_get", path: operation.from, value: undefined };
+                var error = jsonpatch.validate([existingValue], tree);
+                if (error && error.name === 'OPERATION_PATH_UNRESOLVABLE') {
+                    throw new JsonPatchError('Cannot perform the operation from a path that does not exist', 'OPERATION_FROM_UNRESOLVABLE', index, operation, tree);
+                }
+            }
+        }
+    }
+    jsonpatch.validator = validator;
+
+    /**
+    * Validates a sequence of operations. If `tree` parameter is provided, the sequence is additionally validated against the object tree.
+    * If error is encountered, returns a JsonPatchError object
+    * @param sequence
+    * @param tree
+    * @returns {JsonPatchError|undefined}
+    */
+    function validate(sequence, tree) {
+        try  {
+            if (!_isArray(sequence)) {
+                throw new JsonPatchError('Patch sequence must be an array', 'SEQUENCE_NOT_AN_ARRAY');
+            }
+
+            if (tree) {
+                tree = JSON.parse(JSON.stringify(tree)); //clone tree so that we can safely try applying operations
+                apply.call(this, tree, sequence, true);
+            } else {
+                for (var i = 0; i < sequence.length; i++) {
+                    this.validator(sequence[i], i);
+                }
+            }
+        } catch (e) {
+            if (e instanceof JsonPatchError) {
+                return e;
+            } else {
+                throw e;
+            }
+        }
+    }
+    jsonpatch.validate = validate;
+})(jsonpatch || (jsonpatch = {}));
+
+if (typeof exports !== "undefined") {
+    exports.apply = jsonpatch.apply;
+    exports.validate = jsonpatch.validate;
+    exports.validator = jsonpatch.validator;
+    exports.JsonPatchError = jsonpatch.JsonPatchError;
+    exports.Error = jsonpatch.Error;
+}