live_record 0.3.4 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c5e459f1fd9627b4731cd59fcc25622317d2ecbeb1afe32b4d55328880ba7cf
-  data.tar.gz: a2018fdbcfcdeef038c8a389bf3c5240a4ffa9b05884b6c8d9efb59a23d6c62c
+  metadata.gz: 509801a74ef9c87f3520ed9312e6cf8cb8c6861f4c250dc2075e7ba8822882c2
+  data.tar.gz: 220bc5c24e415c54c215b94b983b41bb7ced614090d82d89d347c4544c52ea95
 SHA512:
-  metadata.gz: aba9f87dc58ad53ee987264795de0ba551c78888fc17725ed5176e036ae5294e50a5c50c84dc082425842eef3132fd48e49063930b6b65ded469e2376cc764cf
-  data.tar.gz: 7a08ddb71528e48371c5406a7616dfcf19d9268adad369cbce537c21426020101d819421f6d1f2adc0418271b292e0140649113541ac1a2593ddec2dcbbe682a
+  metadata.gz: 949adea6b2fecd574a8fa9c69a4168f87c2231d3e4cf5b3e4920c6d19c155533d320b8bc0393fd93ca4eb2e8354a472c623f948eb199a836cacca041c7cdd4a0
+  data.tar.gz: 4822d238761d68875d963456ff7c11248368f9a91dfd40ea3f7f98e7d677104a7bc53166af8fcb05b0938bfebdd5f3d152329e44b9252d1e961ba2dc4530a6d4

data/.blade.yml

@@ -0,0 +1,11 @@
+load_paths:
+  - app/assets/javascripts
+
+logical_paths:
+  - live_record.coffee
+
+build:
+  logical_paths:
+    - live_record.js
+  path: lib/assets/compiled
+  clean: true

data/.gitignore

@@ -1,3 +1,4 @@
+/tmp
 /.bundle
 *.sqlite
 *.sqlite-journal
@@ -5,4 +6,6 @@
 /spec/internal/tmp/*
 .byebug_history
 *.gem
-Gemfile.lock
+Gemfile.lock
+.DS_Store
+/node_modules

data/Gemfile

@@ -8,4 +8,6 @@ group :development, :test do
   gem 'factory_girl_rails', '~> 4.8', require: false
   # do not require to prevent Capybara deprecation warning on rspec run
   gem 'capybara', '~> 3.1', require: false
+
+  gem 'sprockets-export', '~> 1.0.0', require: false
 end

data/README.md

@@ -157,7 +157,7 @@
 1. Add the following to your `Gemfile`:
 
     ```ruby
-    gem 'live_record', '~> 0.3.4'
+    gem 'live_record', '~> 0.3.6'
     ```
 
 2. Run:
@@ -779,7 +779,12 @@ end
 ## License
 * MIT
 
+## Developer Guide
+* see [developer_guide.md](developer_guide.md)
+
 ## Changelog
+* 0.3.6
+  * set up as a Node module
 * 0.3.4
   * now supports Rails `~> 5.2` after being tested to work
   * update dependency to Rails (and other dev gems) to use semantic versioning: `~> 5.0`, instead of `>= 5.0, < 5.3`

data/app/assets/javascripts/live_record.coffee

@@ -1,3 +1,4 @@
+#= export LiveRecord
 #= require_self
 #= require_directory ./live_record/
 

data/app/assets/javascripts/live_record/helpers.coffee

@@ -1,4 +1,4 @@
 #= require_self
 #= require_directory ./helpers/
 
-LiveRecord.helpers ||= {}
+this.LiveRecord.helpers ||= {}

data/app/assets/javascripts/live_record/helpers/case_converter.coffee

@@ -1,6 +1,6 @@
 # ref: https://jamesroberts.name/blog/2010/02/22/string-functions-for-javascript-trim-to-camel-case-to-dashed-and-to-underscore/
 
-LiveRecord.helpers.caseConverter =
+this.LiveRecord.helpers.caseConverter =
   toCamel: (string) ->
     string.replace(
       /(\-[a-z])/g,

data/app/assets/javascripts/live_record/helpers/load_records.coffee

@@ -1,4 +1,4 @@
-LiveRecord.helpers.loadRecords = (args) ->
+this.LiveRecord.helpers.loadRecords = (args) ->
   args['modelName'] || throw new Error(':modelName argument required')
   throw new Error(':modelName is not defined in LiveRecord.Model.all') if LiveRecord.Model.all[args['modelName']] == undefined
 

data/app/assets/javascripts/live_record/helpers/spaceship.coffee

@@ -1,6 +1,6 @@
 # ref: https://stackoverflow.com/questions/34852855/combined-comparison-spaceship-operator-in-javascript
 
-LiveRecord.helpers.spaceship = (val1, val2) ->
+this.LiveRecord.helpers.spaceship = (val1, val2) ->
   if val1 == null or val2 == null or typeof val1 != typeof val2
     return null
   if typeof val1 == 'string'

data/app/assets/javascripts/live_record/model.coffee

@@ -1,4 +1,4 @@
 #= require_self
 #= require_directory ./model/
 
-LiveRecord.Model ||= {}
+this.LiveRecord.Model ||= {}

data/app/assets/javascripts/live_record/model/all.coffee

@@ -1 +1 @@
-LiveRecord.Model.all = {}
+this.LiveRecord.Model.all = {}

data/app/assets/javascripts/live_record/model/create.coffee

@@ -1,4 +1,4 @@
-LiveRecord.Model.create = (config) ->
+this.LiveRecord.Model.create = (config) ->
   config.modelName != undefined || throw new Error('missing :modelName argument')
   config.callbacks != undefined || config.callbacks = {}
   config.plugins != undefined || config.callbacks = {}

data/app/assets/javascripts/live_record/plugins.coffee

@@ -1,3 +1,3 @@
 #= require_self
 
-LiveRecord.plugins ||= {}
+this.LiveRecord.plugins ||= {}

data/app/assets/javascripts/live_record/plugins/live_dom.coffee

@@ -1,7 +1,7 @@
 #= require_self
 #= require_directory ./live_dom/
 
-LiveRecord.plugins.LiveDOM ||= {}
+this.LiveRecord.plugins.LiveDOM ||= {}
 
-if window.jQuery == undefined 
+if window.jQuery == undefined
   throw new Error('jQuery is not loaded yet, and is a dependency of LiveRecord')

data/app/assets/javascripts/live_record/plugins/live_dom/apply_to_model.coffee

@@ -1,4 +1,4 @@
-LiveRecord.plugins.LiveDOM.applyToModel = (Model, pluginValue) ->
+this.LiveRecord.plugins.LiveDOM.applyToModel = (Model, pluginValue) ->
   return if pluginValue != true
 
   # DOM callbacks

data/developer_guide.md

@@ -0,0 +1,24 @@
+## Development
+
+### Publishing as Ruby Gem
+
+```bash
+# [increment gem VERSION]
+gem build live_record
+gem push live_record-X.X.X.gem
+```
+
+### Publishing as Node Module
+
+```bash
+# [increment gem VERSION]
+bundle exec blade build
+# see .blade.yml: which will sprockets-compile app/assets/javascripts/live_record.coffee into lib/assets/compile/live_record.js
+npm publish --access=public
+```
+
+## Test
+
+```bash
+bundle exec rspec
+```

data/lib/assets/compiled/live_record.js

@@ -0,0 +1,603 @@
+(function() {
+  this.LiveRecord || (this.LiveRecord = {});
+
+}).call(this);
+(function() {
+  var base;
+
+  (base = this.LiveRecord).helpers || (base.helpers = {});
+
+}).call(this);
+(function() {
+  this.LiveRecord.helpers.caseConverter = {
+    toCamel: function(string) {
+      return string.replace(/(\-[a-z])/g, function($1) {
+        return $1.toUpperCase().replace('-', '');
+      });
+    },
+    toUnderscore: function(string) {
+      return string.replace(/([A-Z])/g, function($1) {
+        return "_" + $1.toLowerCase();
+      });
+    }
+  };
+
+}).call(this);
+(function() {
+  this.LiveRecord.helpers.loadRecords = function(args) {
+    args['modelName'] || (function() {
+      throw new Error(':modelName argument required');
+    })();
+    if (LiveRecord.Model.all[args['modelName']] === void 0) {
+      throw new Error(':modelName is not defined in LiveRecord.Model.all');
+    }
+    args['url'] || (args['url'] = window.location.href);
+    return $.getJSON(args['url']).done(function(data) {
+      var i, len, record, record_attributes, record_or_records, records, records_attributes;
+      record_or_records = void 0;
+      if ($.isArray(data)) {
+        records_attributes = data;
+        records = [];
+        for (i = 0, len = records_attributes.length; i < len; i++) {
+          record_attributes = records_attributes[i];
+          record = new LiveRecord.Model.all[args['modelName']](record_attributes);
+          record.create();
+          records.push(record);
+        }
+        record_or_records = records;
+      } else if (data) {
+        record_attributes = data;
+        record = new LiveRecord.Model.all[args['modelName']](record_attributes);
+        record.create();
+        record_or_records = record;
+      }
+      if (args['onLoad']) {
+        return args['onLoad'].call(this, record_or_records);
+      }
+    }).fail(function(jqxhr, textStatus, error) {
+      if (args['onError']) {
+        return args['onError'].call(this, jqxhr, textStatus, error);
+      }
+    });
+  };
+
+}).call(this);
+(function() {
+  this.LiveRecord.helpers.spaceship = function(val1, val2) {
+    if (val1 === null || val2 === null || typeof val1 !== typeof val2) {
+      return null;
+    }
+    if (typeof val1 === 'string') {
+      return val1.localeCompare(val2);
+    } else {
+      if (val1 > val2) {
+        return 1;
+      } else if (val1 < val2) {
+        return -1;
+      }
+      return 0;
+    }
+  };
+
+}).call(this);
+(function() {
+  var base;
+
+  (base = this.LiveRecord).Model || (base.Model = {});
+
+}).call(this);
+(function() {
+  this.LiveRecord.Model.all = {};
+
+}).call(this);
+(function() {
+  this.LiveRecord.Model.create = function(config) {
+    var Model, callbackFunction, callbackFunctions, callbackKey, i, index, len, methodKey, methodValue, pluginKey, pluginValue, ref, ref1, ref2, ref3;
+    config.modelName !== void 0 || (function() {
+      throw new Error('missing :modelName argument');
+    })();
+    config.callbacks !== void 0 || (config.callbacks = {});
+    config.plugins !== void 0 || (config.callbacks = {});
+    Model = function(attributes) {
+      if (attributes == null) {
+        attributes = {};
+      }
+      this.attributes = attributes;
+      Object.keys(this.attributes).forEach(function(attribute_key) {
+        if (Model.prototype[attribute_key] === void 0) {
+          return Model.prototype[attribute_key] = function() {
+            return this.attributes[attribute_key];
+          };
+        }
+      });
+      this._callbacks = {
+        'on:connect': [],
+        'on:disconnect': [],
+        'on:responseError': [],
+        'before:create': [],
+        'after:create': [],
+        'before:update': [],
+        'after:update': [],
+        'before:destroy': [],
+        'after:destroy': []
+      };
+      return this;
+    };
+    Model.modelName = config.modelName;
+    Model.associations = {
+      hasMany: config.hasMany,
+      belongsTo: config.belongsTo
+    };
+    if (Model.associations.hasMany) {
+      Object.keys(Model.associations.hasMany).forEach(function(key, index) {
+        var associationConfig, associationName;
+        associationName = key;
+        associationConfig = Model.associations.hasMany[associationName];
+        return Model.prototype[associationName] = function() {
+          var associatedModel, associatedRecords, id, isAssociated, record, ref, self;
+          self = this;
+          associatedModel = LiveRecord.Model.all[associationConfig.modelName];
+          if (!associatedModel) {
+            throw new Error('No defined model for "' + associationConfig.modelName + '"');
+          }
+          associatedRecords = [];
+          ref = associatedModel.all;
+          for (id in ref) {
+            record = ref[id];
+            isAssociated = record[associationConfig.foreignKey]() === self.id();
+            if (isAssociated) {
+              associatedRecords.push(record);
+            }
+          }
+          return associatedRecords;
+        };
+      });
+    }
+    if (Model.associations.belongsTo) {
+      Object.keys(Model.associations.belongsTo).forEach(function(key, index) {
+        var associationConfig, associationName;
+        associationName = key;
+        associationConfig = Model.associations.belongsTo[associationName];
+        return Model.prototype[associationName] = function() {
+          var associatedModel, belongsToID, self;
+          self = this;
+          associatedModel = LiveRecord.Model.all[associationConfig.modelName];
+          if (!associatedModel) {
+            throw new Error('No defined model for "' + associationConfig.modelName + '"');
+          }
+          belongsToID = self[associationConfig.foreignKey]();
+          return associatedModel.all[belongsToID];
+        };
+      });
+    }
+    Model.all = {};
+    Model.subscriptions = [];
+    Model.autoload = function(config) {
+      var subscription;
+      if (config == null) {
+        config = {};
+      }
+      config.callbacks || (config.callbacks = {});
+      config.reload || (config.reload = false);
+      if (config.callbacks.afterReload && !config.reload) {
+        throw new Error('`afterReload` callback only works with `reload: true`');
+      }
+      subscription = App.cable.subscriptions.create({
+        channel: 'LiveRecord::AutoloadsChannel',
+        model_name: Model.modelName,
+        where: config.where
+      }, {
+        connected: function() {
+          if (config.reload) {
+            config.reload = false;
+            this.syncRecords();
+          }
+          if (this.liveRecord._staleSince !== void 0) {
+            this.syncRecords();
+          }
+          if (config.callbacks['on:connect']) {
+            return config.callbacks['on:connect'].call(this);
+          }
+        },
+        disconnected: function() {
+          if (!this.liveRecord._staleSince) {
+            this.liveRecord._staleSince = (new Date()).toISOString();
+          }
+          if (config.callbacks['on:disconnect']) {
+            return config.callbacks['on:disconnect'].call(this);
+          }
+        },
+        received: function(data) {
+          if (data.error) {
+            if (!this.liveRecord._staleSince) {
+              this.liveRecord._staleSince = (new Date()).toISOString();
+            }
+            return this.onError[data.error.code].call(this, data);
+          } else {
+            return this.onAction[data.action].call(this, data);
+          }
+        },
+        onAction: {
+          createOrUpdate: function(data) {
+            var doesRecordAlreadyExist, record;
+            record = Model.all[data.attributes.id];
+            if (record) {
+              doesRecordAlreadyExist = true;
+            } else {
+              record = new Model(data.attributes);
+              doesRecordAlreadyExist = false;
+            }
+            if (config.callbacks['before:createOrUpdate']) {
+              config.callbacks['before:createOrUpdate'].call(this, record);
+            }
+            if (doesRecordAlreadyExist) {
+              record.update(data.attributes);
+            } else {
+              record.create();
+            }
+            if (config.callbacks['after:createOrUpdate']) {
+              return config.callbacks['after:createOrUpdate'].call(this, record);
+            }
+          },
+          afterReload: function(data) {
+            if (config.callbacks['after:reload']) {
+              return config.callbacks['after:reload'].call(this, data.recordIds);
+            }
+          }
+        },
+        onError: {
+          forbidden: function(data) {
+            return console.error('[LiveRecord Response Error]', data.error.code, ':', data.error.message, 'for', this);
+          },
+          bad_request: function(data) {
+            return console.error('[LiveRecord Response Error]', data.error.code, ':', data.error.message, 'for', this);
+          }
+        },
+        syncRecords: function() {
+          this.perform('sync_records', {
+            model_name: Model.modelName,
+            where: config.where,
+            stale_since: this.liveRecord._staleSince
+          });
+          return this.liveRecord._staleSince = void 0;
+        }
+      });
+      subscription.liveRecord = {};
+      subscription.liveRecord.modelName = Model.modelName;
+      subscription.liveRecord.where = config.where;
+      subscription.liveRecord.callbacks = config.callbacks;
+      this.subscriptions.push(subscription);
+      return subscription;
+    };
+    Model.subscribe = function(config) {
+      var subscription;
+      if (config == null) {
+        config = {};
+      }
+      config.callbacks || (config.callbacks = {});
+      config.reload || (config.reload = false);
+      if (config.callbacks.afterReload && !config.reload) {
+        throw new Error('`afterReload` callback only works with `reload: true`');
+      }
+      subscription = App.cable.subscriptions.create({
+        channel: 'LiveRecord::PublicationsChannel',
+        model_name: Model.modelName,
+        where: config.where
+      }, {
+        connected: function() {
+          if (config.reload) {
+            config.reload = false;
+            this.syncRecords();
+          }
+          if (this.liveRecord._staleSince !== void 0) {
+            this.syncRecords();
+          }
+          if (config.callbacks['on:connect']) {
+            return config.callbacks['on:connect'].call(this);
+          }
+        },
+        disconnected: function() {
+          if (!this.liveRecord._staleSince) {
+            this.liveRecord._staleSince = (new Date()).toISOString();
+          }
+          if (config.callbacks['on:disconnect']) {
+            return config.callbacks['on:disconnect'].call(this);
+          }
+        },
+        received: function(data) {
+          if (data.error) {
+            if (!this.liveRecord._staleSince) {
+              this.liveRecord._staleSince = (new Date()).toISOString();
+            }
+            return this.onError[data.error.code].call(this, data);
+          } else {
+            return this.onAction[data.action].call(this, data);
+          }
+        },
+        onAction: {
+          create: function(data) {
+            var record;
+            record = new Model(data.attributes);
+            if (config.callbacks['before:create']) {
+              config.callbacks['before:create'].call(this, record);
+            }
+            record.create();
+            if (config.callbacks['after:create']) {
+              return config.callbacks['after:create'].call(this, record);
+            }
+          },
+          afterReload: function(data) {
+            if (config.callbacks['after:reload']) {
+              return config.callbacks['after:reload'].call(this, data.recordIds);
+            }
+          }
+        },
+        onError: {
+          forbidden: function(data) {
+            return console.error('[LiveRecord Response Error]', data.error.code, ':', data.error.message, 'for', this);
+          },
+          bad_request: function(data) {
+            return console.error('[LiveRecord Response Error]', data.error.code, ':', data.error.message, 'for', this);
+          }
+        },
+        syncRecords: function() {
+          this.perform('sync_records', {
+            model_name: Model.modelName,
+            where: config.where,
+            stale_since: this.liveRecord._staleSince
+          });
+          return this.liveRecord._staleSince = void 0;
+        }
+      });
+      subscription.liveRecord = {};
+      subscription.liveRecord.modelName = Model.modelName;
+      subscription.liveRecord.where = config.where;
+      subscription.liveRecord.callbacks = config.callbacks;
+      this.subscriptions.push(subscription);
+      return subscription;
+    };
+    Model.unsubscribe = function(subscription) {
+      var index;
+      index = this.subscriptions.indexOf(subscription);
+      if (index === -1) {
+        throw new Error('`subscription` argument does not exist in ' + this.modelName + ' subscriptions list');
+      }
+      App.cable.subscriptions.remove(subscription);
+      this.subscriptions.splice(index, 1);
+      return subscription;
+    };
+    ref = config.classMethods;
+    for (methodKey in ref) {
+      methodValue = ref[methodKey];
+      if (Model[methodKey] !== void 0) {
+        throw new Error('Cannot use reserved name as class method: ', methodKey);
+      }
+      Model[methodKey] = methodValue;
+    }
+    Model.prototype.subscribe = function(config) {
+      var subscription;
+      if (config == null) {
+        config = {};
+      }
+      if (this.subscription !== void 0) {
+        return this.subscription;
+      }
+      config.reload || (config.reload = false);
+      subscription = App['live_record_' + this.modelName() + '_' + this.id()] = App.cable.subscriptions.create({
+        channel: 'LiveRecord::ChangesChannel',
+        model_name: this.modelName(),
+        record_id: this.id()
+      }, {
+        record: function() {
+          var identifier;
+          if (this._record) {
+            return this._record;
+          }
+          identifier = JSON.parse(this.identifier);
+          return this._record = Model.all[identifier.record_id];
+        },
+        connected: function() {
+          if (config.reload) {
+            config.reload = false;
+            this.syncRecord(this.record());
+          }
+          if (this.record()._staleSince !== void 0) {
+            this.syncRecord(this.record());
+          }
+          return this.record()._callCallbacks('on:connect', void 0);
+        },
+        disconnected: function() {
+          if (!this.record()._staleSince) {
+            this.record()._staleSince = (new Date()).toISOString();
+          }
+          return this.record()._callCallbacks('on:disconnect', void 0);
+        },
+        received: function(data) {
+          if (data.error) {
+            if (!this.record()._staleSince) {
+              this.record()._staleSince = (new Date()).toISOString();
+            }
+            this.onError[data.error.code].call(this, data);
+            this.record()._callCallbacks('on:responseError', [data.error.code]);
+            return delete this.record()['subscription'];
+          } else {
+            return this.onAction[data.action].call(this, data);
+          }
+        },
+        onAction: {
+          update: function(data) {
+            this.record()._setChangesFrom(data.attributes);
+            this.record().update(data.attributes);
+            return this.record()._unsetChanges();
+          },
+          destroy: function(data) {
+            return this.record().destroy();
+          }
+        },
+        onError: {
+          forbidden: function(data) {
+            return console.error('[LiveRecord Response Error]', data.error.code, ':', data.error.message, 'for', this.record());
+          },
+          bad_request: function(data) {
+            return console.error('[LiveRecord Response Error]', data.error.code, ':', data.error.message, 'for', this.record());
+          }
+        },
+        syncRecord: function() {
+          this.perform('sync_record', {
+            model_name: this.record().modelName(),
+            record_id: this.record().id(),
+            stale_since: this.record()._staleSince
+          });
+          return this.record()._staleSince = void 0;
+        }
+      });
+      return this.subscription = subscription;
+    };
+    Model.prototype.model = function() {
+      return Model;
+    };
+    Model.prototype.modelName = function() {
+      return Model.modelName;
+    };
+    Model.prototype.unsubscribe = function() {
+      if (this.subscription === void 0) {
+        return;
+      }
+      App.cable.subscriptions.remove(this.subscription);
+      return delete this['subscription'];
+    };
+    Model.prototype.isSubscribed = function() {
+      return this.subscription !== void 0;
+    };
+    Model.prototype.create = function(options) {
+      if (Model.all[this.attributes.id]) {
+        throw new Error(Model.modelName + '(' + this.id() + ') is already in the store');
+      }
+      this._callCallbacks('before:create', void 0);
+      Model.all[this.attributes.id] = this;
+      this.subscribe({
+        reload: true
+      });
+      this._callCallbacks('after:create', void 0);
+      return this;
+    };
+    Model.prototype.update = function(attributes) {
+      var self;
+      self = this;
+      Object.keys(attributes).forEach(function(attribute_key) {
+        if (Model.prototype[attribute_key] === void 0) {
+          return Model.prototype[attribute_key] = function() {
+            return this.attributes[attribute_key];
+          };
+        }
+      });
+      this._callCallbacks('before:update', void 0);
+      Object.keys(attributes).forEach(function(attribute_key) {
+        return self.attributes[attribute_key] = attributes[attribute_key];
+      });
+      this._callCallbacks('after:update', void 0);
+      return true;
+    };
+    Model.prototype.destroy = function() {
+      this._callCallbacks('before:destroy', void 0);
+      this.unsubscribe();
+      delete Model.all[this.attributes.id];
+      this._callCallbacks('after:destroy', void 0);
+      return this;
+    };
+    Model._callbacks = {
+      'on:connect': [],
+      'on:disconnect': [],
+      'on:responseError': [],
+      'before:create': [],
+      'after:create': [],
+      'before:update': [],
+      'after:update': [],
+      'before:destroy': [],
+      'after:destroy': []
+    };
+    Model.prototype.addCallback = Model.addCallback = function(callbackKey, callbackFunction) {
+      var index;
+      index = this._callbacks[callbackKey].indexOf(callbackFunction);
+      if (index === -1) {
+        this._callbacks[callbackKey].push(callbackFunction);
+        return callbackFunction;
+      }
+    };
+    Model.prototype.removeCallback = Model.removeCallback = function(callbackKey, callbackFunction) {
+      var index;
+      index = this._callbacks[callbackKey].indexOf(callbackFunction);
+      if (index !== -1) {
+        this._callbacks[callbackKey].splice(index, 1);
+        return callbackFunction;
+      }
+    };
+    Model.prototype._callCallbacks = function(callbackKey, args) {
+      var callback, i, j, len, len1, ref1, ref2, results;
+      ref1 = Model._callbacks[callbackKey];
+      for (i = 0, len = ref1.length; i < len; i++) {
+        callback = ref1[i];
+        callback.apply(this, args);
+      }
+      ref2 = this._callbacks[callbackKey];
+      results = [];
+      for (j = 0, len1 = ref2.length; j < len1; j++) {
+        callback = ref2[j];
+        results.push(callback.apply(this, args));
+      }
+      return results;
+    };
+    Model.prototype._setChangesFrom = function(attributes) {
+      var attributeName, attributeValue, results;
+      this.changes = {};
+      results = [];
+      for (attributeName in attributes) {
+        attributeValue = attributes[attributeName];
+        if (this.attributes[attributeName] !== attributeValue) {
+          results.push(this.changes[attributeName] = [this.attributes[attributeName], attributeValue]);
+        } else {
+          results.push(void 0);
+        }
+      }
+      return results;
+    };
+    Model.prototype._unsetChanges = function() {
+      return delete this['changes'];
+    };
+    ref1 = config.instanceMethods;
+    for (methodKey in ref1) {
+      methodValue = ref1[methodKey];
+      if (Model.prototype[methodKey] !== void 0) {
+        throw new Error('Cannot use reserved name as instance method: ', methodKey);
+      }
+      Model.prototype[methodKey] = methodValue;
+    }
+    ref2 = config.callbacks;
+    for (callbackKey in ref2) {
+      callbackFunctions = ref2[callbackKey];
+      for (i = 0, len = callbackFunctions.length; i < len; i++) {
+        callbackFunction = callbackFunctions[i];
+        Model.addCallback(callbackKey, callbackFunction);
+      }
+    }
+    ref3 = config.plugins;
+    for (pluginKey in ref3) {
+      pluginValue = ref3[pluginKey];
+      if (LiveRecord.plugins) {
+        index = Object.keys(LiveRecord.plugins).indexOf(pluginKey);
+        if (index !== -1) {
+          LiveRecord.plugins[pluginKey].applyToModel(Model, pluginValue);
+        }
+      }
+    }
+    LiveRecord.Model.all[config.modelName] = Model;
+    return Model;
+  };
+
+}).call(this);
+(function() {
+  var base;
+
+  (base = this.LiveRecord).plugins || (base.plugins = {});
+
+}).call(this);

data/lib/live_record/version.rb

@@ -1,3 +1,3 @@
 module LiveRecord
-  VERSION = '0.3.4'.freeze
+  VERSION = '0.3.6'.freeze
 end

data/live_record.gemspec

@@ -22,9 +22,11 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'byebug', '~> 9.0'
 
   s.add_development_dependency 'sprockets-rails', '~> 3.2'
+  s.add_development_dependency 'sprockets-export', '~> 1.0'
   s.add_development_dependency 'coffee-rails', '~> 4.2'
   s.add_development_dependency 'jquery-rails', '~> 4.3'
   s.add_development_dependency 'jbuilder', '~> 2.7'
+  s.add_development_dependency 'blade', '~> 0.7'
 
   s.add_development_dependency 'sqlite3', '~> 1.3'
   s.add_development_dependency 'redis', '~> 3.3'

data/package-lock.json

@@ -0,0 +1,13 @@
+{
+  "name": "@jrpolidario/live_record",
+  "version": "0.3.6",
+  "lockfileVersion": 1,
+  "requires": true,
+  "dependencies": {
+    "actioncable": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/actioncable/-/actioncable-5.2.0.tgz",
+      "integrity": "sha512-5o0wKTz2egSGDf7SubQLqoew/lGJhkjyJSdbMiaAfci/vNMjs7xjL2X+ELhstJmaN5tY17O3Wx6c5q2GgQE/JQ=="
+    }
+  }
+}

data/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@jrpolidario/live_record",
+  "version": "0.3.6",
+  "description": "Auto-syncs records in client-side JS (through a Model DSL) from changes (updates/destroy) in the backend Rails server through ActionCable.\\n Also supports streaming newly created records to client-side JS.\\n Supports lost connection restreaming for both new records (create), and record-changes (updates/destroy).\\n Auto-updates DOM elements mapped to a record attribute, from changes (updates/destroy).",
+  "main": "lib/assets/compiled/live_record.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jrpolidario/live_record.git"
+  },
+  "author": "Jules Roman B. Polidario",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/jrpolidario/live_record/issues"
+  },
+  "homepage": "https://github.com/jrpolidario/live_record#readme",
+  "dependencies": {
+    "actioncable": "^5.0.0"
+  }
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: live_record
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.3.6
 platform: ruby
 authors:
 - Jules Roman B. Polidario
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-25 00:00:00.000000000 Z
+date: 2018-06-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -94,6 +94,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: sprockets-export
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: coffee-rails
   requirement: !ruby/object:Gem::Requirement
@@ -136,6 +150,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: blade
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -272,7 +300,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".blade.yml"
 - ".gitignore"
+- ".npmignore"
 - ".rspec"
 - ".travis.yml"
 - Gemfile
@@ -297,6 +327,8 @@ files:
 - app/channels/live_record/publications_channel.rb
 - config.ru
 - config/puma.rb
+- developer_guide.md
+- lib/assets/compiled/live_record.js
 - lib/live_record.rb
 - lib/live_record/action_view_extensions/view_helper.rb
 - lib/live_record/configure.rb
@@ -313,6 +345,8 @@ files:
 - lib/live_record/model/callbacks.rb
 - lib/live_record/version.rb
 - live_record.gemspec
+- package-lock.json
+- package.json
 - spec/factories/categories.rb
 - spec/factories/posts.rb
 - spec/factories/users.rb