active-sync 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 05b5eaee6042b6879380d62ddb365e2437dab84c
-  data.tar.gz: 7042c77f823b44739262be1e605efb38050b3fb0
+SHA256:
+  metadata.gz: 7df1bee7e9b73969455663f528ffe6c0e6bdcf29c51da5fcfe3198435e9c90aa
+  data.tar.gz: d1e8df90405eab22953da90829644acac6c7f3e3003df836d8e32a12f7fb43cf
 SHA512:
-  metadata.gz: 34e3e184be13d599ce39678b7ed1f10cadf85b75a19e4a0c0a33d5b2e1bdbe6bd4625cc2eb19800735a24c4915b8582d042a48b41c00cf0ae56b3e111e3b0873
-  data.tar.gz: e091c678b10a1a8301042b8182a5fa351f57c798f746fc1a18f1810e1b02201f27053855ddbca7ff3377117882ecfcfaf6afc74622a7f0d2d8a0b6163c3f6c07
+  metadata.gz: c31d625e52ef4596916acaa468916c7ea767194a77049026ae1ebfc539ae7c2ff5e5ab05a241cb8ae643c9d376b2da49da5a389780c8ab491379d51d1d6f9609
+  data.tar.gz: 072dcb445cb5288c65cf073bb9dae6a152f393fba25e69031c0e8b7e144468bba4f612e5f2e038c27d5d1318856f4e263481eae2bafe0b0204f25daffaa721b9

data/README.md

@@ -1,10 +1,20 @@
 # ActiveSync
-Short description and motivation.
+Dynamically created and updated front end models. 
+
+Active record adds an active record interface to your front end. Configured models are available 
+within your Javascript application with many active record type functions such as 'where'.
+
+Records are lazy loaded and then dynamically updated through actioncable. So any records looked up
+through ActiveSync will be dynamically updated whether updated by the current user or any one else.
+
+Currently the only Javascript framework supported is Vue
 
 ## Usage
 How to use my plugin.
 
 ## Installation
+
+### Install gem
 Add this line to your application's Gemfile:
 
 ```ruby
@@ -16,11 +26,26 @@ And then execute:
 $ bundle
 ```
 
-Or install it yourself as:
-```bash
-$ gem install active_sync
+### Import package
+In packs/application.js import active-sync and create an instance with a list of Models that you
+want available.
+
+```javascript
+import ActiveSync from 'active-sync'
+
+let activeSync = new ActiveSync({ modelNames: ['Customer', 'Site'] })
+```
+
+### Vue setup
+
+Before creating your Vue instance :
+
+```javascript
+Vue.use( activeSync )
 ```
 
+Then any new Vue instances will have Models globally available
+
 ## Contributing
 Contribution directions go here.
 

data/app/channels/models_channel.rb

@@ -0,0 +1,27 @@
+# Rails currently doesn't allow namespacing channels in an engine
+# module ActiveSync
+  class ModelsChannel < ActionCable::Channel::Base
+    # To change the data sent implement sync_record in the respective model
+
+    def subscribed
+      transmit(subscription_model.where(params[:filter]).map(&:sync_record))
+      stream_from params[:model], coder: ActiveSupport::JSON do |message|
+        if (params[:filter].to_a - message.to_a).blank?
+          transmit([message])
+        end
+      end
+    end
+
+    def unsubscribed
+      # Any cleanup needed when channel is unsubscribed
+    end
+
+    private
+
+    def subscription_model
+      model = params[:model].singularize.camelize.constantize
+      raise "Model '#{params[:model]}' is not set up for syncing model" unless model.sync_model?
+      model
+    end
+  end
+# end

data/app/controllers/active_sync/application_controller.rb

@@ -1,5 +1,5 @@
 module ActiveSync
   class ApplicationController < ActionController::Base
-    protect_from_forgery with: :exception
+    # protect_from_forgery with: :exception
   end
 end

data/app/controllers/active_sync/models_controller.rb

@@ -1,10 +1,22 @@
 module ActiveSync
   class ModelsController < ApplicationController
 
-    def index
+    def update
+      #TODO some oversite on what can be edited for sync records
+      model.find(params[:id]).update(params.permit(model.sync_attributes))
+      head :no_content
+    end
 
-      render json: ActiveSync::Sync.model_descriptions
+    def create
+      #TODO some oversite on what can be created for sync records
+      render json: model.create(params.permit(model.sync_attributes)).id
+    end
 
+    private
+    def model
+      m = params[:model].singularize.camelize.safe_constantize || params[:model].camelize.safe_constantize
+      raise "Cannot edit #{params[:model]} as it is not a sync model" unless m.sync_model?
+      m
     end
   end
 end

data/app/jobs/broadcast_change_job.rb

@@ -0,0 +1,9 @@
+class BroadcastChangeJob < ApplicationJob
+  queue_as :active_sync
+
+  include ActionCable::Channel::Broadcasting
+
+  def perform record
+    ActionCable.server.broadcast(record.class.name, record.sync_record)
+  end
+end

data/app/models/active_sync/broadcaster.rb

@@ -0,0 +1,5 @@
+module ActiveSync
+  class Broadcaster
+    include 'singleton'
+  end
+end

data/app/models/active_sync/model.rb

@@ -0,0 +1,63 @@
+module ActiveSync
+  module Model
+    extend ActiveSupport::Concern
+
+    included do
+      # after_update :sync_update
+      after_commit :sync_change
+    end
+
+    def sync_change
+      if sync_model?
+        BroadcastChangeJob.perform_later(self)
+      end
+    end
+
+    def sync_model?
+      true
+    end
+
+
+    class_methods do
+
+      def sync_model?
+        true
+      end
+
+      # #sync sets the #sync_record method that renders the hash to create the JSON object that is broadcast and sets
+      # #sync_associations which returns a list of associations that are permitted to be broadcast for this model.
+      # define these methods directly in your model if the record sent to the font end needs to be different to what's
+      # available with the below configurations
+      #
+      # This can be passed the following options:
+      #
+      # Example use in Model:
+      # sync :all_attributes, associations: [ :sites ]
+
+      # ATTRIBUTE OPTIONS
+      # Attributes are data that is sent in the actual sync data (this will always include the ID)
+
+      # :all_attributes - sync data will have all attributes
+      # :attributes - an array of symbols that will be called on the record and sent as attributes
+
+      # ASSOCIATION OPTIONS
+      # Associations are lazy loaded, data will not go with the record but if the front end has the association described
+      # then records can be subscribed to through the association.
+
+      # :all_associations - sync data will be associated
+      # :associations - an array of symbols
+
+      def sync *attributes
+        self.class.define_method(:sync_attributes) do
+          ActiveSync::Sync.sync_attributes(self, attributes)
+        end
+        define_method(:sync_record) do
+          ActiveSync::Sync.sync_record(self, attributes)
+        end
+        define_method(:sync_associations) do
+          ActiveSync::Sync.sync_associations(self, attributes)
+        end
+      end
+    end
+  end
+end

data/app/models/active_sync/sync.rb

@@ -1,125 +1,45 @@
 module ActiveSync
   class Sync
 
-    # Describes what of each model should be sent as the sync records,
-    # this is populated through calls to 'sync' in the model class
-    @@model_descriptions = {}
-    @@loaded = false
-
-    def self.model_descriptions
-      ( Rails.application.eager_load! && @@loaded = true ) unless Rails.application.config.cache_classes || @@loaded
-      @@model_descriptions
-    end
-
-    def self.is_sync_model? model
-
-      model_name = model.class == String ? model : model.name
-
-      model_descriptions.keys.include? model_name
-
-    end
-
-
-    #Hash used in all general sync communication for a given model.
-    def self.sync_record record
-      @@model_descriptions[ record.class.name ][ :attributes ].reduce( {} ) do | hash, attribute |
-        hash[ attribute ] = record.send( attribute )
-        hash
-      end
-    end
-
-    def self.configure_model_description model, options
-
-      @@model_descriptions[ model.name ] = {
-        attributes:   [],
-        associations: []
-      }
-
-      options.each do | option |
-
-        case
-        when option == :all_attributes_and_associations
-
-          add_attributes_to_description model, model.attribute_names
-          add_associations_to_description model, model.reflect_on_all_associations.map( &:name )
-
-        when option == :all_attributes
-
-          add_attributes_to_description model, model.attribute_names
-
-        when first_key( option ) == :attributes
-
-          add_attributes_to_description model, option[:attributes].map(&:to_s)
-
-        when option == :all_associations
-
-          add_associations_to_description model, model.reflect_on_all_associations.map( &:name )
-
-        when first_key( option ) == :associations
-
-          add_associations_to_description model, option[ :associations ]
-
+    def self.sync_attributes model, args
+      @@sync_attributes ||= args.reduce([]) do |array, option|
+        case option
+        when :all_attributes_and_associations, :all_attributes
+          array + model.column_names.map(&:to_sym)
+        when ->(option){ option.is_a?(Hash) }
+          array + option[:attributes]
         else
-
-          throw "Unknown sync option: #{option}"
-
+          raise "Unknown sync record option #{option.inspect}"
         end
       end
     end
 
-    def self.add_attributes_to_description model, attributes
-
-      attributes.each{ |attribute| @@model_descriptions[ model.name ][ :attributes ] << attribute.to_s }
-
-    end
-
-    def self.add_associations_to_description model, association_names
-      association_names.each do |association_name|
-
-        association = model.reflect_on_all_associations.find{ |a| a.name == association_name }
-
-        unless association.nil?
-          begin
-
-            @@model_descriptions[ model.name ][ :associations ] << { name: association.name.to_s, class: association.class_name, type: association.association_class.name }
-
-          rescue NotImplementedError
-
-            @@model_descriptions[ model.name ][ :associations ] << { name: association.name.to_s, class: association.class_name, type: 'ActiveRecord::Associations::HasManyThroughAssociation' }
-
-          end
-
+    #Hash used in all general sync communication for a given model.
+    def self.sync_record record, args
+      args.reduce({}) do |hash, option|
+        case option
+        when :all_attributes_and_associations, :all_attributes
+          hash.merge(record.attributes)
+        when ->(option){ option.is_a?(Hash) }
+          option[:attributes]&.reduce(hash) { |h, attr| h[attr] = record.call(attr) }
         else
-
-          throw "Association #{ association_name } not found for #{ model.name }"
-
+          raise "Unknown sync record option #{option.inspect}"
         end
       end
     end
 
-    def self.association_record model_association, record
-      {
-       IsReference: true,
-       id: record.id,
-       model_association[:name] => associated_ids( record, model_association )
-     }
-    end
-
-    def self.associated_ids record, model_association
-      if defined? record.send( model_association[:name] ).pluck
-
-        record.send( model_association[:name] ).pluck(:id)
-      else
-        record.send( model_association[:name] ).id
+    def self.sync_associations record, args
+      args.reduce([]) do |associations, option|
+        case option
+        when :all_attributes_and_associations, :all_attributes
+          associations + record.class.reflect_on_all_associations.map { |a| a.name }
+        when ->(option){ option.is_a?(Hash) }
+          associations + option[:associations]
+        else
+          raise "Unknown sync associations option #{option.inspect}"
+        end
+        associations
       end
     end
-
-    def self.get_model_association model, association_name
-      @@model_descriptions[ model.name ][:associations].find{ |a| a[:name] == association_name }
-    end
-
-    def self.first_key obj
-      obj.respond_to?( :keys ) ? obj.keys.first : nil
-    end
   end
 end

data/config/routes.rb

@@ -1,3 +1,4 @@
 ActiveSync::Engine.routes.draw do
-  resources :models, only: [ :index ]
+  put '/:model/:id', to: 'models#update'
+  post '/:model', to: 'models#create'
 end

data/lib/active_sync/engine.rb

@@ -7,7 +7,6 @@ module ActiveSync
         mount ActiveSync::Engine, at: "/active_sync"
       end
 
-      ActiveRecord::Base.class_eval { include ActiveSync::ActiveRecordExtension }
     end
   end
 end

data/lib/active_sync/version.rb

@@ -1,3 +1,3 @@
 module ActiveSync
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

data/lib/javascript/active-sync.js

@@ -1,68 +1,95 @@
-import ActionCable from 'actioncable'
 import Model from './model.js'
+import CamelCase from 'camelcase'
+import Pluralize from 'pluralize'
+import SnakeCase from "snake-case";
 
 export default class ActiveSync {
-  constructor( args ){
-
-    this._cable = ActionCable.createConsumer()
-    this._models = []
-    this._customModels = args.customModels || []
 
-    this._modelOptions = {
-      addNewRecord: args.addNewRecord,
-      afterFind: args.afterFind
-    }
+  static models = []
+
+  // ActiveSync dynamically creates model classes when a new instance of it is created
+  // Valid arguments are:
+  // models:  Used to define custom model. Pass an array of classes in and they will be set up as ActiveSync models.
+  //          It's expected that models passed in extend ActiveSync's Model class. They will then receive extra functions
+  //          as per anything defined in the modelDescriptions argument (such as associations).
+  //
+  // modelDescriptions: An object that describes all the models for ActiveSync to create. If the model is not defined in
+  //                    the model then an empty model is created. Then all the described associations are added to their
+  //                    respective models.
+  //                    IE { Customer: { hasMany: ['sites']}, Site: { belongsTo: 'customer' }
+  //                    Will add a 'sites' method to the Customer class and a 'customer' method to Site.
+  //
 
-    var modelDescriptions = this.requestModelDescriptions()
-
-    Object.keys( modelDescriptions ).forEach( ( modelName ) =>{
-      modelDescriptions[modelName].name = modelName
-      this.setupModel( modelDescriptions[modelName] )
-    })
+  constructor( args ){
+    this._models = args.models || [];
+    this.buildModels(args.modelDescriptions)
+  }
 
-    this._models.forEach( ( model ) => model.setAssociatedModels( this._models))
-    args.afterSetup( this._models )
+  install( vue ){
+    this._models.forEach((model)=> vue.prototype["$" + model.className] = model)
+  }
 
+  models(){
+    return this._models
   }
 
-  static install( Vue, options ){
-    var rs = new ActiveSync({
-      addNewRecord: (  records, id, record  ) => {
-        if( records[ id ] ){
-          Object.keys( record ).forEach( (key) => Vue.set( records[ id ], key, record[key] ) )
-        } else {
-          Vue.set( records, id, record )
-        }
-      },
+  // Creates the models from the modelDescription arg passed in to the constructor
+  buildModels(modelDescriptions){
+    let modelNames = Object.keys(modelDescriptions || {});
 
-      afterSetup: ( models ) => {
-        models.forEach( ( model ) => {
-          Vue.prototype[ '$' + model.name ] = model
-        })
-      },
+    modelNames.forEach((modelName) => {
+      if(!this._models.find((model) => model.className === modelName)){
+        this._models.push(this.createModel(modelName))
+      }
+    })
 
-      customModels: (options || {}).customModels
+    this._models.forEach((model) => {
+      this.addBelongsToModel(modelDescriptions[model.className], model)
+      this.addHasManyToModel(modelDescriptions[model.className], model)
     })
   }
 
-  requestModelDescriptions(){
-    var xmlHttp = new XMLHttpRequest()
-    xmlHttp.open( "GET", 'active_sync/models', false ) // false for synchronous request
-    xmlHttp.send( null )
-    return JSON.parse(xmlHttp.responseText)
+  createModel(name){
+    let modelClass = Model
+    return eval(`(class ${name} extends modelClass { static className = '${name}' })`)
   }
+  
+  addBelongsToModel(modelDescription, model){
+    ((modelDescription || {}).belongsTo || []).forEach((association) => {
+      let associatedModel = this._models.find((model) => model.className === association)
+      model[association] = function () {
+        return associatedModel.find(this[association + '_id'])
+      }
+    });
+  }
+  
+  addHasManyToModel(modelDescription, model){
+    ((modelDescription || {}).hasMany || []).forEach((association) => {
+      let associatedModel = this._models.find((model) => model.className === CamelCase(Pluralize.singular(association), {pascalCase: true}))
+      model.prototype[association] = function () {
+        let associationQuery = {}
+        associationQuery[SnakeCase(model.className) + '_id'] = this.id
+        return associatedModel.where(associationQuery)
+      }
+    });
+  }
+}
 
-  setupModel( modelDescription ){
-    var CustomModel = this._customModels.find(( m ) => m.name == modelDescription.name )
-
-    if( CustomModel ){
-
-      this._models.push( new CustomModel( modelDescription, this._cable, this._modelOptions ) )
 
-    } else {
 
-      this._models.push( new Model( modelDescription, this._cable, this._modelOptions ) )
+// Code for dynamically requesting Model names and associations.
+//
+// Object.keys( modelDescriptions ).forEach( ( modelName ) =>{
+//   modelDescriptions[modelName].name = modelName
+//   this.setupModel( modelDescriptions[modelName] )
+// })
 
-    }
-  }
-}
+// var modelDescriptions = this.requestModelDescriptions()
+// this._models.forEach( ( model ) => model.setAssociatedModels( this._models))
+// args.afterSetup( this._models )
+// requestModelDescriptions(){
+//   var xmlHttp = new XMLHttpRequest()
+//   xmlHttp.open( "GET", 'active_sync/models', false ) // false for synchronous request
+//   xmlHttp.send( null )
+//   return JSON.parse(xmlHttp.responseText)
+// }

data/lib/javascript/model.js

@@ -1,63 +1,128 @@
-import Records from './records.js'
-
-export default class Model{
-  constructor( description, cable, options ){
-    this._name = description.name
-    this._afterFind = options.afterFind || (( record ) => {})
-    this._records = new Records( {
-      cable: cable,
-      modelName: description.name,
-      addNewRecord: options.addNewRecord,
-      references: new Records( {
-        cable: cable,
-        addNewRecord: options.addNewRecord
-      }),
-      associations: description.associations
-    })
-  }
+import Axios from 'axios'
+import SnakeCase from 'snake-case'
+import CamelCase from 'camelcase'
+import Pluralize from 'pluralize'
 
-  setAssociatedModels( models ){
-    this._records.setAssociatedModels( models )
-  }
+import Actioncable from "actioncable"
+
+import Util from './util'
 
-  get name(){
-    return this._name
+export default class Model {
+
+  // static records = {}
+  static recordsLoaded = false
+  static urlPathBase = 'active_sync/'
+
+  static consumer = Actioncable.createConsumer()
+  
+  constructor(args){
+    if(!args.id) throw 'Can not create record without an id'
+    if(this.constructor.records[args.id]){
+      this.constructor.records[args.id].setProperties(args)
+    } else {
+      this.setProperties(args)
+      this.constructor.records[this.id] = this
+    }
   }
 
-  get all() {
-    var allRecords = []
-    this._records.loadRecords().then( () => {
-      this._records.forEach( ( record ) => {
-        allRecords.push( this._records.getRecord( record.id ) )
-      })
+  setProperties(args){
+    Object.keys(args).forEach((property)=>{
+      this[property] = args[property]
     })
-
-    return allRecords
   }
 
-  find( id ){
+  static get records(){
+    if(!this.recordsObject) this.recordsObject = {}
+    return this.recordsObject
+  }
 
-    if( !this._records.getRecord( id ) ){
+  static get all(){
+    return this.loadOrSearch()
+  }
 
-      this._records.push( { id: id } )
-      this._records.loadRecords( { id: id } )
-      // .then(()=> this._afterFind( this._records.getRecord( id ) ))
+  static modelUrlPath(singular = false){
+    if(singular) {
+      return this.urlPathBase + SnakeCase(this.className)
+    } else {
+      return this.urlPathBase + SnakeCase(Pluralize(this.className))
     }
+  }
 
+  static find(id){
+    return new Promise((resolve,reject)=>{
+      if(!this.records[id]){
+        resolve(this.loadRecords({ id: id }).then(()=> this.records[id]))
+      } else {
+        resolve(this.records[id])
+      }
+    })
+  }
+
+  static where(args){
+    return this.loadOrSearch(Util.snakeCaseKeys(args))
+  }
 
-    return this._records.getRecord( id )
+  static through(model, args){
+    return model.loadRecords(args).then(()=>{
+      var linkingIds = [...new Set(model.searchRecords(args).map((record)=> record[CamelCase(this.className)+'Id']))]
+      return this.where({id: linkingIds})
+    })
   }
 
-  where( properties ){
+  static create(data){
+    return Axios.post(this.modelUrlPath(), Util.snakeCaseKeys(data))
+      .then((response) => {
+        new this(response.data)
+        return response
+      })
+  }
 
-    var records = []
+  static update(data){
+    return Axios.put( `${this.modelUrlPath(true)}/${data.id}`, Util.snakeCaseKeys(data))
+        .then((response) => {
+          // new this(response.data)
+          return response
+        })
+  }
 
-    this._records.loadRecords( properties ).then( () => {
-      this._records.forEachMatch( properties, (record) => {
-        records.push( this._records.getRecord( record.id ) )
+  //Intended as private below here
+  static loadOrSearch(args={}){
+    let subscriptionParams = { channel: 'ModelsChannel', model: this.className, filter: args }
+    if(this.consumer.subscriptions.findAll(JSON.stringify(subscriptionParams)).length === 0){
+      return this.loadRecords(subscriptionParams)
+    } else {
+      return new Promise((resolve, reject) => { resolve(this.searchRecords(args)) } )
+    }
+  }
+  
+  static loadRecords(args){
+    return new Promise((resolve, reject) => {
+      this.consumer.subscriptions.create(args, {
+        received: (data) => {
+          let records = []
+          data.forEach((datum) => {
+            records.push(new this(datum))
+          })
+          resolve(records)
+        }
       })
     })
+  }
 
-    return records
+  static searchRecords(args){
+    var results = []
+    Object.keys(this.records).forEach((id)=>{
+      // Its a match if none of the keys don't match (IE terminates when a property doesn't match), if a property is an array it still matches if the corresponding arg is within it.
+      var match = !Object.keys(args).some((arg)=> {
+        return !(this.records[id][arg] == args[arg] ||
+            (Array.isArray(this.records[id][arg]) && this.records[id][arg].some((i)=> typeof i == 'object' && i.id == args[arg])) ||
+            (Array.isArray(args[arg]) && args[arg].some((a)=> typeof a == 'object' && a.id == this.records[id][arg] || a == this.records[id][arg]))
+        )
+      })
+      if(match) {
+        results.push(this.records[id])
+      }
+    })
+    return results
   }
-}
+}

data/lib/javascript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rails-active-sync",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Javascript for interacting with active-sync ruby gem.",
   "main": "active-sync.js",
   "scripts": {
@@ -20,7 +20,8 @@
   "dependencies": {
     "actioncable": "^5.2.2-1",
     "camelcase": "^5.2.0",
-    "snake-case": "^2.1.0"
+    "snake-case": "^2.1.0",
+    "axios": "^0.21.1"
   },
   "author": "Crammaman",
   "license": "MIT"

data/lib/javascript/util.js

@@ -0,0 +1,10 @@
+
+import SnakeCase from 'snake-case'
+export default{
+    snakeCaseKeys: function( object){
+        return Object.keys( object ).reduce( ( acc, key ) => {
+            acc[ SnakeCase(key) ] = object[key]
+            return acc
+        }, {})
+    },
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active-sync
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - crammaman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-17 00:00:00.000000000 Z
+date: 2021-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -25,47 +25,61 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 5.1.3
 - !ruby/object:Gem::Dependency
-  name: puma
+  name: webpacker
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.11'
-  type: :runtime
+        version: 3.5.5
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.11'
+        version: 3.5.5
 - !ruby/object:Gem::Dependency
-  name: webpacker
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: foreman
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.5.5
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.5.5
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: puma
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.6
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.6
+        version: '0'
 description: With minimal set up ActiveSync presents limited rails model interfaces
   within the JS font end. Records accessed are kept updated through action cable.
 email:
@@ -77,11 +91,13 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
-- app/channels/active_sync_channel.rb
+- app/channels/models_channel.rb
 - app/controllers/active_sync/application_controller.rb
 - app/controllers/active_sync/models_controller.rb
 - app/helpers/active_sync/models_helper.rb
-- app/models/active_sync/active_record_extension.rb
+- app/jobs/broadcast_change_job.rb
+- app/models/active_sync/broadcaster.rb
+- app/models/active_sync/model.rb
 - app/models/active_sync/sync.rb
 - config/routes.rb
 - lib/active-sync.rb
@@ -90,7 +106,7 @@ files:
 - lib/javascript/active-sync.js
 - lib/javascript/model.js
 - lib/javascript/package.json
-- lib/javascript/records.js
+- lib/javascript/util.js
 - lib/tasks/rails_sync_tasks.rake
 homepage: https://github.com/Crammaman/rails-sync
 licenses:
@@ -111,8 +127,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.10
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Live updated JS objects for use in reactive JS frameworks

data/app/channels/active_sync_channel.rb

@@ -1,89 +0,0 @@
-# Rails currently doesn't allow namespacing channels in an engine
-# module ActiveSync
-  class ActiveSyncChannel < ActionCable::Channel::Base
-    # For providing DashData with data from rails models
-    # To change the data sent (like reducing how much is sent)
-    # implement broadcast_model in the respective modelc
-
-    def subscribed
-
-      if filter && filter[:IsReference]
-
-        subscribe_references
-
-      else
-
-        subscribe_models
-
-      end
-    end
-
-    def unsubscribed
-      # Any cleanup needed when channel is unsubscribed
-    end
-
-    private
-    def subscribe_models
-      if filter.nil?
-
-        stream_from "#{subscription_model.name}_All"
-        transmit( subscription_model.sync_all )
-
-      else
-
-        subscription_model.register_sync_subscription "#{subscription_model.name}_#{checksum}", filter
-        stream_from "#{subscription_model.name}_#{checksum}"
-
-        # TODO ensure that params are safe to pass to the model then register for syncing to.
-        transmit( subscription_model.sync_filtered( filter.to_h ) )
-
-      end
-    end
-
-    def subscribe_references
-
-      record = subscription_model.find( filter[:record_id] )
-
-      if model_association
-
-        transmit( ActiveSync::Sync.association_record( model_association, record) )
-
-      else
-
-         raise "#{subscription_model} does not reference #{ filter[:association_name] }"
-
-      end
-
-      subscription_model.register_sync_subscription "#{subscription_model.name}_#{checksum}", filter.merge( subscribed_model: subscription_model )
-      eval( model_association[:class] ).register_sync_subscription "#{subscription_model.name}_#{checksum}", filter.merge( subscribed_model: subscription_model )
-      stream_from "#{subscription_model.name}_#{checksum}"
-
-    end
-
-    def subscription_model
-
-      if ActiveSync::Sync.is_sync_model?( params[:model] )
-
-        eval( params[:model] )
-
-      else
-
-        raise "Model parameter: #{params[:model]} is not a registered sync model"
-
-      end
-    end
-
-    def model_association
-      ActiveSync::Sync.get_model_association( subscription_model, filter[:association_name] )
-    end
-
-    def filter
-      params[:filter]
-    end
-
-    def checksum
-      # A checksum is generated and used in the stream name so all of the same filtered subscriptions should be on the same Stream
-      Digest::MD5.hexdigest( Marshal::dump( filter ) )
-    end
-  end
-# end

data/app/models/active_sync/active_record_extension.rb

@@ -1,110 +0,0 @@
-module ActiveSync
-  module ActiveRecordExtension
-    extend ActiveSupport::Concern
-
-    included do
-      # after_update :sync_update
-      after_commit :sync_change
-
-      @@sync_record_subscriptions = {}
-    end
-
-    def sync_update
-      sync_change if saved_changes?
-    end
-
-    def sync_change
-      if ActiveSync::Sync.is_sync_model? self.class
-        #TODO properly accommodate multi process environment, since sync sync_subscriptions
-        # exists only in one process, if one process has a filter sub but another does not
-        # not all users will necessarily get broadcast to.
-        ActionCable.server.broadcast("#{self.class}_All", ActiveSync::Sync.sync_record( self ) )
-        self.class.sync_record_subscriptions.each do | stream, filter |
-          unless filter[:IsReference]
-
-            match = true
-            filter.each do | key, value |
-              unless self.send( key ) == value
-                match = false
-                break
-              end
-            end
-
-            ActionCable.server.broadcast( stream, ActiveSync::Sync.sync_record( self ) ) if match
-
-          else
-
-            model_association = ActiveSync::Sync.get_model_association( filter[:subscribed_model], filter[:association_name] )
-
-            record = filter[:subscribed_model].find( filter[:record_id] )
-
-            if defined? record.send( model_association[:name] ).pluck
-
-              referenced = record.send( model_association[:name] ).pluck(:id).include? id
-            else
-              referenced = record.send( model_association[:name] ).id == id
-            end
-
-            if referenced
-              ActionCable.server.broadcast( stream, ActiveSync::Sync.association_record( model_association, record ))
-            end
-          end
-        end
-      end
-    end
-
-
-    class_methods do
-
-      def register_sync_subscription stream, filter
-        @@sync_record_subscriptions[ self.name ] = {} if @@sync_record_subscriptions[ self.name ].nil?
-        @@sync_record_subscriptions[ self.name ][ stream ] = filter
-      end
-
-      def sync_record_subscriptions
-        @@sync_record_subscriptions[ self.name ] || {}
-      end
-
-      # Sync configures the data that is used in general sync communication
-      # This can be passed the following options:
-      #
-      # Example use in Model:
-      # sync :all_references, associations: [ :sites ]
-
-      # ATTRIBUTE OPTIONS
-      # Attributes are data that is sent in the actual sync data (this will always include the ID)
-
-      # :all_attributes - sync data will have all attributes
-      # :attributes - an array of symbols that will be called on the record and sent as attributes
-
-      # ASSOCIATION OPTIONS
-      # Associations are lazy loaded, data will not go with the record but the front end will be told that
-      # there is an association to load the data of when accessed.
-
-      # :all_associations - sync data will be associated
-      # :associations - an array of symbols
-
-      def sync *attributes
-
-        ActiveSync::Sync.configure_model_description self, attributes
-
-      end
-
-      # Sync hash for all of self records
-      def sync_all
-
-      	self.all.map do |record|
-          ActiveSync::Sync.sync_record record
-        end
-
-      end
-
-      def sync_filtered filter
-
-        self.where( filter ).map do |record|
-          ActiveSync::Sync.sync_record record
-        end
-      end
-    end
-  end
-end

data/lib/javascript/records.js

@@ -1,216 +0,0 @@
-import CamelCase from 'camelcase'
-import SnakeCase from 'snake-case'
-
-export default class Records {
-  constructor( args = {} ){
-    this._records = {}
-    this._addNewRecord = args.addNewRecord || this.addNewRecord
-    this._associations = args.associations || []
-    this._cable = args.cable
-    this._modelName = args.modelName
-    this._references = args.references
-    // A subscription is just it's filter{}
-    this._subscriptions = []
-    // An ugly object of { filter{}: boolean }
-    this._dataLoading = {}
-  }
-
-  setAssociatedModels( models ){
-    this._associations.forEach( ( association ) => {
-      var model = models.find( ( model ) => model.name == association.class )
-      if( model ){
-        association.model = model
-      } else {
-        throw `Model ${this._modelName} is set up for association with ${association.class} but ${association.class} is not available through Active Sync`
-      }
-    } )
-  }
-
-  getRecord( id ){
-    return this._records[id]
-  }
-
-  push( record ){
-
-    this._associations.forEach( ( association ) => {
-      switch(association.type){
-      case 'ActiveRecord::Associations::HasManyAssociation':
-      case 'ActiveRecord::Associations::HasManyThroughAssociation':
-        record[ association.name ] = [1]
-        break
-      case 'ActiveRecord::Associations::BelongsToAssociation':
-        var standIn = {}
-        Object.defineProperty(standIn, "$count", {
-            enumerable: false,
-            writable: true
-        })
-        standIn.$count = 1
-        //this._addNewRecord( record, association.name, standIn )
-        record[ association.name ] = standIn
-        break
-
-      default:
-        console.log('Unknown know association type ' + association.type)
-      }
-    } )
-
-    var newRecord = new Proxy( this.camelCaseKeys( record ), {
-      get: ( record, property )=> this.getFromRecord( record, property, this )
-    } )
-
-    this._addNewRecord( this._records, newRecord.id, newRecord )
-  }
-
-  addNewRecord( records, recordId, record ){
-    if( records[ recordId ] ){
-      Object.keys( record ).forEach( (key) => records[ recordId ][ key ] = record[ key ] )
-    } else {
-      records[ recordId ] = record
-    }
-  }
-
-  forEach( func ){
-    Object.keys( this._records ).forEach(( id ) => func( this._records[id] ) )
-  }
-
-  camelCaseKeys( record ){
-    return Object.keys( record ).reduce( ( camelRecord, key ) => {
-      camelRecord[ CamelCase(key) ] = record[key]
-      return camelRecord
-    }, {} )
-  }
-  snakeCaseKeys( record ){
-    return Object.keys( record ).reduce( ( camelRecord, key ) => {
-      camelRecord[ SnakeCase(key) ] = record[key]
-      return camelRecord
-    }, {} )
-  }
-
-  getFromRecord( record, property, self ){
-    self.loadIfAssociation( record, property )
-    return record[ property ]
-  }
-  //If the records already exist it will return an instantaneously resolving promise
-  loadRecords( filter = null ){
-    if( !this.isSubscribed( filter ) ){
-
-      this._subscriptions.push( filter ? filter : 'all' )
-      this.subscribeToRecords( filter )
-
-    }
-
-    return new Promise( (resolve, reject)=> this.awaitData(resolve, reject, filter) )
-  }
-
-  awaitData( resolve, reject, filter ){
-    setTimeout( ()=>{
-      if( this._dataLoading[ filter ] ){
-        this.awaitData( resolve, reject, filter )
-      } else {
-        resolve()
-      }
-      //TODO there's something wrong with _dataLoading not working so this wait time has been cranked up.
-    }, 200 )
-  }
-
-  // Adds records that match properties into records
-  forEachMatch( properties, func ){
-
-    let records = []
-
-    this.forEach( ( record ) => {
-
-      var match = true
-      Object.keys( properties ).forEach( ( property ) => {
-        if( properties[ property ] != record[ property ] ){
-          match = false
-        }
-      })
-
-      if( match ){
-        func(record)
-      }
-    })
-
-    return records
-  }
-
-  isSubscribed( filter ){
-    filter = filter ? filter : 'all'
-    if( this._subscriptions.includes( 'all' ) && !filter.IsReference ) {
-      return true
-    } else {
-      return !!this._subscriptions.find( ( sub ) => JSON.stringify(sub) == JSON.stringify(filter) )
-    }
-  }
-
-  // Subscribing to a record is the source of all data communication. With no filter
-  // all records are subscribed to, this is done without checking for existing subscriptions
-  // so that needs to be done before getting here.
-  subscribeToRecords( filter = null ){
-
-  	let subscriptionParameters = { channel: 'ActiveSyncChannel', model: this._modelName }
-    this._dataLoading[ filter ] = true
-
-  	if ( filter !== null ) {
-  		subscriptionParameters.filter = filter.IsReference ? filter : this.snakeCaseKeys(filter)
-  	}
-
-  	this._cable.subscriptions.create( subscriptionParameters ,{
-  		received: (data) => {
-        var records = data.IsReference ? this._references : this
-  			// Will find records and update them, if not found will add them to
-  			// _records or references.
-  			if( data.length > 0){
-
-  				// data is a promise so might not have anything at this point,
-  				// adding with a forEach allows promises to be handled (is there a better way?)
-  				data.forEach((addModel) => {
-  					records.push(addModel)
-  				})
-
-
-  			} else {
-
-          records.push( data )
-
-  			}
-
-        this._dataLoading[ filter ] = false
-
-  		}
-  	})
-  }
-
-  loadIfAssociation( record, property ){
-    var association = this._associations.find( ( a ) => a.name == property )
-
-    if( association ){
-
-      var referencedRecords = []
-
-      if( record[property][0] == 1 ){
-        record[property].pop()
-      } else if( record[property].$count > 0 ){
-        record[property].$count--
-      } else {
-        this.loadRecords({ IsReference: true, record_id: record.id, association_name: property })
-        .then( () => {
-          var references = this._references.getRecord( record.id )[ property ]
-
-          if( references.length > 0 && references.length !== record[property].length ){
-            record[property] = []
-            references.forEach( ( reference ) => {
-              record[property].push( association.model.find( reference ))
-            } )
-
-          } else if( typeof references.length === 'undefined' && record[property].$count == 0 ) {
-
-            this._addNewRecord(record,property, association.model.find( references ))
-
-          }
-        })
-      }
-    }
-  }
-}