active-sync 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4af6276356d5f3f9e62fee94ac86418a141aeb0c
+  data.tar.gz: e04dd3659a3265137f315405fd4fbe7c6ba095b5
+SHA512:
+  metadata.gz: bbb474bbb05eebf6aa6be7c700c2b6d94f960d0587316f9dcf70bcc08d1b135029daecd3cc32dd9eb247a4b3b3e170ab51e4b56fb23659dfa351d29b28c9a835
+  data.tar.gz: 0b3d134b824cf89dbd9eef943c5677b197d5dcb1b1ff36c08520fd64d30545778fbb276a2ce0382a637c5678752a95841c93de50821760a3b024e75f83ef9052

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2019 crammaman
+
+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.md

@@ -0,0 +1,28 @@
+# ActiveSync
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active_sync'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install active_sync
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,36 @@
+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    = 'ActiveSync'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  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'
+
+
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/channels/active_sync_channel.rb

@@ -0,0 +1,89 @@
+# 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/controllers/active_sync/application_controller.rb

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

data/app/controllers/active_sync/models_controller.rb

@@ -0,0 +1,10 @@
+module ActiveSync
+  class ModelsController < ApplicationController
+
+    def index
+
+      render json: ActiveSync::Sync.model_descriptions
+
+    end
+  end
+end

data/app/helpers/active_sync/models_helper.rb

@@ -0,0 +1,15 @@
+module ActiveSync
+  module ModelsHelper
+    def self.model_descriptions
+      Rails.application.eager_load! unless Rails.application.config.cache_classes
+      ActiveRecord::Base.subclasses[1].descendants.map do |model|
+        {
+          name: model.name,
+          associations: model.reflect_on_all_associations.map do |a|
+            { name: a.name, class: a.class_name, type: a.association_class.name }
+          end
+        }
+      end
+    end
+  end
+end

data/app/models/active_sync/active_record_extension.rb

@@ -0,0 +1,110 @@
+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/app/models/active_sync/sync.rb

@@ -0,0 +1,125 @@
+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 ]
+
+        else
+
+          throw "Unknown sync option: #{option}"
+
+        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
+
+        else
+
+          throw "Association #{ association_name } not found for #{ model.name }"
+
+        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
+      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

@@ -0,0 +1,3 @@
+ActiveSync::Engine.routes.draw do
+  resources :models, only: [ :index ]
+end

data/lib/active-sync.rb

@@ -0,0 +1,4 @@
+require "active_sync/engine"
+module ActiveSync
+  # Your code goes here...
+end

data/lib/active_sync/engine.rb

@@ -0,0 +1,13 @@
+module ActiveSync
+  class Engine < ::Rails::Engine
+    isolate_namespace ActiveSync
+
+    initializer "active_sync", before: :load_config_initializers do |app|
+      Rails.application.routes.append do
+        mount ActiveSync::Engine, at: "/active_sync"
+      end
+
+      ActiveRecord::Base.class_eval { include ActiveSync::ActiveRecordExtension }
+    end
+  end
+end

data/lib/active_sync/version.rb

@@ -0,0 +1,3 @@
+module ActiveSync
+  VERSION = '0.1.0'
+end

data/lib/javascript/active-sync.js

@@ -0,0 +1,68 @@
+import ActionCable from 'actioncable'
+import Model from 'model'
+
+export default class ActiveSync {
+  constructor( args ){
+
+    this._cable = ActionCable.createConsumer()
+    this._models = []
+    this._customModels = args.customModels || []
+
+    this._modelOptions = {
+      addNewRecord: args.addNewRecord,
+      afterFind: args.afterFind
+    }
+
+    var modelDescriptions = this.requestModelDescriptions()
+
+    Object.keys( modelDescriptions ).forEach( ( modelName ) =>{
+      modelDescriptions[modelName].name = modelName
+      this.setupModel( modelDescriptions[modelName] )
+    })
+
+    this._models.forEach( ( model ) => model.setAssociatedModels( this._models))
+    args.afterSetup( 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 )
+        }
+      },
+
+      afterSetup: ( models ) => {
+        models.forEach( ( model ) => {
+          Vue.prototype[ '$' + model.name ] = model
+        })
+      },
+
+      customModels: (options || {}).customModels
+    })
+  }
+
+  requestModelDescriptions(){
+    var xmlHttp = new XMLHttpRequest()
+    xmlHttp.open( "GET", 'active_sync/models', false ) // false for synchronous request
+    xmlHttp.send( null )
+    return JSON.parse(xmlHttp.responseText)
+  }
+
+  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 ) )
+
+    }
+  }
+}

data/lib/javascript/model.js

@@ -0,0 +1,63 @@
+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
+    })
+  }
+
+  setAssociatedModels( models ){
+    this._records.setAssociatedModels( models )
+  }
+
+  get name(){
+    return this._name
+  }
+
+  get all() {
+    var allRecords = []
+    this._records.loadRecords().then( () => {
+      this._records.forEach( ( record ) => {
+        allRecords.push( this._records.getRecord( record.id ) )
+      })
+    })
+
+    return allRecords
+  }
+
+  find( id ){
+
+    if( !this._records.getRecord( id ) ){
+
+      this._records.push( { id: id } )
+      this._records.loadRecords( { id: id } )
+      // .then(()=> this._afterFind( this._records.getRecord( id ) ))
+    }
+
+
+    return this._records.getRecord( id )
+  }
+
+  where( properties ){
+
+    var records = []
+
+    this._records.loadRecords( properties ).then( () => {
+      this._records.forEachMatch( properties, (record) => {
+        records.push( this._records.getRecord( record.id ) )
+      })
+    })
+
+    return records
+  }
+}

data/lib/javascript/records.js

@@ -0,0 +1,216 @@
+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 ))
+
+          }
+        })
+      }
+    }
+  }
+}

data/lib/tasks/rails_sync_tasks.rake

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

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: active-sync
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- crammaman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-04-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.1.3
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.11'
+- !ruby/object:Gem::Dependency
+  name: webpacker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.5.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.5.5
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+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:
+- smadams00@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/channels/active_sync_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/models/active_sync/sync.rb
+- config/routes.rb
+- lib/active-sync.rb
+- lib/active_sync/engine.rb
+- lib/active_sync/version.rb
+- lib/javascript/active-sync.js
+- lib/javascript/model.js
+- lib/javascript/records.js
+- lib/tasks/rails_sync_tasks.rake
+homepage: https://github.com/Crammaman/rails-sync
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2.1
+signing_key: 
+specification_version: 4
+summary: Live updated JS objects for use in reactive JS frameworks
+test_files: []