hyper-mesh 0.5.3 → 0.5.4

data/examples/action-cable/config/initializers/{hyper_mesh.rb → hyperloop.rb}

@@ -1,4 +1,4 @@
 #config/initializers/hyper_mesh.rb
-HyperMesh.configuration do |config|
+Hyperloop.configuration do |config|
   config.transport = :action_cable
 end

data/examples/action-cable/config/routes.rb

@@ -1,5 +1,5 @@
 Rails.application.routes.draw do
   get 'test', to: 'test#app'
-  mount HyperMesh::Engine => '/rr'
+  mount Hyperloop::Engine => '/rr'
   # For details on the DSL available within this file, see http://guides.rubyonrails.org/routing.html
 end

data/hyper-mesh.gemspec

@@ -23,8 +23,10 @@ Gem::Specification.new do |s|
     s.executables    = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
     s.test_files     = `git ls-files -- {test,spec,features}/*`.split("\n")
     s.require_paths  = ['lib']
+
     s.add_dependency 'activerecord', '>= 0.3.0'
-    s.add_dependency 'hyper-react', '>= 0.10.0'
+    s.add_dependency 'hyper-operation', '>= 0.5.0'
+    s.add_dependency 'hyper-component', '>= 0.12.3'
 
     s.add_development_dependency 'bundler', '~> 1.8'
     s.add_development_dependency 'rake', '~> 10.0'
@@ -39,12 +41,15 @@ Gem::Specification.new do |s|
     s.add_development_dependency 'factory_girl_rails'
     s.add_development_dependency 'reactrb-rails-generator'
     s.add_development_dependency 'rspec-wait'
-    s.add_development_dependency 'puma'
+    s.add_development_dependency 'puma', '~> 3.6.0'
 
     s.add_development_dependency 'pusher'
     s.add_development_dependency 'pusher-fake'
     s.add_development_dependency 'opal-browser'
 
+    # Keep linter-rubocop happy
+    s.add_development_dependency 'rubocop'
+
     if RUBY_PLATFORM == 'java'
       s.add_development_dependency 'jdbc-sqlite3'
       s.add_development_dependency 'activerecord-jdbcsqlite3-adapter'
@@ -68,7 +73,7 @@ Gem::Specification.new do |s|
       s.add_development_dependency 'rspec-collection_matchers'
       s.add_development_dependency 'database_cleaner'
       s.add_development_dependency 'capybara'
-      s.add_development_dependency 'selenium-webdriver'
+      s.add_development_dependency 'selenium-webdriver', '< 3'
       s.add_development_dependency 'poltergeist'
       s.add_development_dependency 'spring-commands-rspec'
       s.add_development_dependency 'chromedriver-helper'
@@ -77,6 +82,7 @@ Gem::Specification.new do |s|
       s.add_development_dependency 'unparser'
       s.add_development_dependency 'jquery-rails'
       s.add_development_dependency 'pry-byebug'
-      #s.add_development_dependency 'hyper-trace'
+      s.add_development_dependency 'hyper-spec'
+      s.add_development_dependency 'hyper-trace'
     end
 end

data/lib/active_record_base.rb

@@ -137,17 +137,17 @@ module ActiveRecord
 
       def synchromesh_after_create
         return if do_not_synchronize? #|| previous_changes.empty?
-        HyperMesh.after_commit :create, self
+        ReactiveRecord::Broadcast.after_commit :create, self
       end
 
       def synchromesh_after_change
         return if do_not_synchronize? || previous_changes.empty?
-        HyperMesh.after_commit :change, self
+        ReactiveRecord::Broadcast.after_commit :change, self
       end
 
       def synchromesh_after_destroy
         return if do_not_synchronize?
-        HyperMesh.after_commit :destroy, self
+        ReactiveRecord::Broadcast.after_commit :destroy, self
       end
     else
 

data/lib/hyper-mesh.rb

@@ -1,17 +1,8 @@
-# module ApplicationCable
-#   class Connection < ActionCable::Connection::Base
-#     # we always create a connection, and use the session_id to identify it.
-#     #identified_by :session
-#
-#     # def connect
-#     #   #self.session = cookies.encrypted[Rails.application.config.session_options[:key]]
-#     # end
-#   end
-# end
-
 require 'set'
+require 'hyperloop-config'
+require 'hyper-component'
 if RUBY_ENGINE == 'opal'
-  require "hyper-react"
+  require 'hyper-operation'
   require 'active_support'
   require 'time'
   require 'date'
@@ -19,6 +10,8 @@ if RUBY_ENGINE == 'opal'
   require "reactive_record/active_record/error"
   require "reactive_record/server_data_cache"
   require "reactive_record/active_record/reactive_record/while_loading"
+  require "reactive_record/active_record/reactive_record/operations"
+  require 'reactive_record/broadcast'
   require "reactive_record/active_record/reactive_record/isomorphic_base"
   require 'reactive_record/active_record/reactive_record/dummy_value'
   require 'reactive_record/active_record/reactive_record/column_types'
@@ -39,26 +32,25 @@ if RUBY_ENGINE == 'opal'
   require_relative 'opal/parse_patch'
   require_relative 'opal/set_patches'
   require_relative 'opal/equality_patches'
+  React::IsomorphicHelpers.log(
+    "The gem 'hyper-mesh' is deprecated.  Use gem 'hyper-model' instead.", :warning
+  ) unless defined? Hyperloop::Model
 else
   require 'opal'
-  require 'hyper-react'
+  require 'hyper-operation'
   require "reactive_record/permissions"
-  require "reactive_record/engine"
   require "reactive_record/server_data_cache"
+  require "reactive_record/active_record/reactive_record/operations"
+  require 'reactive_record/broadcast'
   require "reactive_record/active_record/reactive_record/isomorphic_base"
   require "reactive_record/active_record/public_columns_hash"
   require "reactive_record/serializers"
   require "reactive_record/pry"
   require_relative 'active_record_base'
   require 'hypermesh/version'
-  require 'synchromesh/connection'
-  require 'synchromesh/synchromesh'
-  require 'synchromesh/policy'
-  require 'synchromesh/synchromesh_controller'
 
   Opal.append_path File.expand_path('../sources/', __FILE__).untaint
   Opal.append_path File.expand_path('../', __FILE__).untaint
   Opal.append_path File.expand_path('../../vendor', __FILE__).untaint
 end
 require 'enumerable/pluck'
-require_relative 'synchromesh/client_drivers'

data/lib/hyper_mesh/version.rb

@@ -0,0 +1,3 @@
+module Hypermesh
+  VERSION = '0.6.0'
+end

data/lib/hypermesh/version.rb

@@ -1,3 +1,3 @@
 module Hypermesh
-  VERSION = '0.5.3'
+  VERSION = '0.5.4'
 end

data/lib/reactive_record/active_record/class_methods.rb

@@ -135,7 +135,7 @@ module ActiveRecord
       :distinct, :unscope, :calculate, :average, :count_by_sql, :minimum, :lock, :find_by_sql, :count, :cache, :uncached, :connection, :connection_pool,
       :establish_connection, :connected?, :clear_cache!, :clear_reloadable_connections!, :connection_id, :connection_config, :clear_all_connections!,
       :remove_connection, :connection_specification_name, :connection_specification_name=, :retrieve_connection, :connection_id=, :clear_active_connections!,
-      :sqlite3_connection, :direct_descendants, :benchmark, :model_name
+      :sqlite3_connection, :direct_descendants, :benchmark, :model_name, :with_options, :attr_protected, :attr_accessible
     ]
 
     def method_missing(name, *args, &block)
@@ -210,11 +210,11 @@ module ActiveRecord
     end
 
     def column_names
-      HyperMesh::ClientDrivers.public_columns_hash.keys
+      ReactiveRecord::Base.public_columns_hash.keys
     end
 
     def columns_hash
-      HyperMesh::ClientDrivers.public_columns_hash[name] || {}
+      ReactiveRecord::Base.public_columns_hash[name] || {}
     end
 
     def server_methods
@@ -275,6 +275,13 @@ module ActiveRecord
               [key, [value]]
             end
           end
+
+          # We do want to be doing something like this, but this breaks other stuff...
+          #
+          # ReactiveRecord::Base.load_data do
+          #   ReactiveRecord::ServerDataCache.load_from_json(Hash[param], target)
+          # end
+
           ReactiveRecord::ServerDataCache.load_from_json(Hash[param], target)
           target
         end

data/lib/reactive_record/active_record/instance_methods.rb

@@ -73,6 +73,14 @@ module ActiveRecord
       @backing_record == ar_instance.instance_eval { @backing_record }
     end
 
+    def [](attr)
+      send(attr)
+    end
+
+    def []=(attr, val)
+      send("#{attr}=", val)
+    end
+
     def method_missing_warning(name)
       @backing_record.deprecation_warning("Server side method #{name} must be defined using the 'server_method' macro.")
     end

data/lib/reactive_record/active_record/public_columns_hash.rb

@@ -1,3 +1,7 @@
+module Hyperloop
+  define_setting :public_model_directories, ['app/models/public', 'app/hyperloop/models']
+end
+
 module ActiveRecord
   # adds method to get the HyperMesh public column types
   # for now we are just getting all models column types, but we should
@@ -6,8 +10,10 @@ module ActiveRecord
   class Base
     def self.public_columns_hash
       return @public_columns_hash if @public_columns_hash
-      Dir.glob(Rails.root.join('app/models/public/*.rb')).each do |file|
-        require_dependency(file)
+      Hyperloop.public_model_directories.each do |dir|
+        Dir.glob(Rails.root.join("#{dir}/*.rb")).each do |file|
+          require_dependency(file)
+        end
       end
       @public_columns_hash = {}
       descendants.each do |model|

data/lib/reactive_record/active_record/reactive_record/collection.rb

@@ -483,7 +483,6 @@ module ReactiveRecord
       elsif ScopeDescription.find(@target_klass, method) || (args.count == 1 && method =~ /^find_by_/)
         apply_scope(method, *args)
       elsif @target_klass.respond_to?(method) && ScopeDescription.find(@target_klass, "_#{method}")
-        puts "here we are..."
         apply_scope("_#{method}", *args).first
       else
         super

data/lib/reactive_record/active_record/reactive_record/dummy_value.rb

@@ -202,7 +202,8 @@ module ReactiveRecord
       end
 
       def acts_as_string?
-        return @object.acts_as_string if @object
+        return true if @object.is_a? String
+        return @object.acts_as_string? if @object
         true
       end
 

data/lib/reactive_record/active_record/reactive_record/isomorphic_base.rb

@@ -7,10 +7,11 @@ module ReactiveRecord
     include React::IsomorphicHelpers
 
     before_first_mount do |context|
-      HyperMesh::ClientDrivers.on_first_mount
       if RUBY_ENGINE != 'opal'
         @server_data_cache = ReactiveRecord::ServerDataCache.new(context.controller.acting_user, {})
       else
+        @public_columns_hash = get_public_columns_hash
+        define_attribute_methods
         @outer_scopes = Set.new
         @fetch_scheduled = nil
         @records = Hash.new { |hash, key| hash[key] = [] }
@@ -60,6 +61,22 @@ module ReactiveRecord
       f.when_on_server { @server_data_cache[klass, ["find_by_#{attribute}", value], :id] }
     end
 
+    class << self
+      attr_reader :public_columns_hash
+    end
+
+    def self.define_attribute_methods
+      public_columns_hash.keys.each do |model|
+        Object.const_get(model).define_attribute_methods rescue nil
+      end
+    end
+
+    isomorphic_method(:get_public_columns_hash) do |f|
+      f.when_on_client { JSON.parse(`JSON.stringify(window.ReactiveRecordPublicColumnsHash)`) }
+      f.send_to_server
+      f.when_on_server { ActiveRecord::Base.public_columns_hash }
+    end
+
     prerender_footer do
       if @server_data_cache
         json = @server_data_cache.as_json.to_json  # can this just be to_json?
@@ -67,12 +84,9 @@ module ReactiveRecord
       else
         json = {}.to_json
       end
-      path = ::Rails.application.routes.routes.detect do |route|
-        # not sure why the second check is needed.  It happens in the test app
-        route.app == HyperMesh::Engine or (route.app.respond_to?(:app) and route.app.app == HyperMesh::Engine)
-      end.path.spec
       "<script type='text/javascript'>\n"+
-        "window.ReactiveRecordEnginePath = '#{path}';\n"+
+        "if (typeof window.ReactiveRecordPublicColumnsHash === 'undefined') { \n" +
+        "  window.ReactiveRecordPublicColumnsHash = #{ActiveRecord::Base.public_columns_hash.to_json}}\n" +
         "if (typeof window.ReactiveRecordInitialData === 'undefined') { window.ReactiveRecordInitialData = [] }\n" +
         "window.ReactiveRecordInitialData.push(#{json})\n"+
       "</script>\n"
@@ -127,31 +141,26 @@ module ReactiveRecord
           models, associations = gather_records(@pending_records, false, nil)
           log(["Server Fetching: %o", pending_fetches.to_n])
           start_time = Time.now
-          HTTP.post(`window.ReactiveRecordEnginePath`,
-            payload: {
-              json: {
-                models:          models,
-                associations:    associations,
-                pending_fetches: pending_fetches
-              }.to_json
-            }
-          ).then do |response|
-            fetch_time = Time.now
-            log("       Fetched in:   #{(fetch_time-start_time).to_i}s")
-            begin
-              ReactiveRecord::Base.load_from_json(response.json)
-            rescue Exception => e
-              log("Unexpected exception raised while loading json from server: #{e}", :error)
+          Operations::Fetch(models: models, associations: associations, pending_fetches: pending_fetches)
+            .then do |response|
+              fetch_time = Time.now
+              log("       Fetched in:   #{(fetch_time-start_time).to_i}s")
+              begin
+                ReactiveRecord::Base.load_from_json(response)
+              rescue Exception => e
+                log("Unexpected exception raised while loading json from server: #{e}", :error)
+              end
+              log("       Processed in: #{(Time.now-fetch_time).to_i}s")
+              log(["       Returned: %o", response.to_n])
+              ReactiveRecord.run_blocks_to_load last_fetch_at
+              ReactiveRecord::WhileLoading.loaded_at last_fetch_at
+              ReactiveRecord::WhileLoading.quiet! if @pending_fetches.empty?
+            end
+            .fail do |response|
+              log("Fetch failed", :error)
+              # not sure what response was supposed to look like here was response.body before conversion to operations....
+              ReactiveRecord.run_blocks_to_load(last_fetch_at, response)
             end
-            log("       Processed in: #{(Time.now-fetch_time).to_i}s")
-            log(["       Returned: %o", response.json.to_n])
-            ReactiveRecord.run_blocks_to_load last_fetch_at
-            ReactiveRecord::WhileLoading.loaded_at last_fetch_at
-            ReactiveRecord::WhileLoading.quiet! if @pending_fetches.empty?
-          end.fail do |response|
-            log("Fetch failed", :error)
-            ReactiveRecord.run_blocks_to_load(last_fetch_at, response.body)
-          end
           @pending_fetches = []
           @pending_records = []
           @fetch_scheduled = nil
@@ -247,40 +256,31 @@ module ReactiveRecord
         backing_records.each { |id, record| record.saving! }
 
         promise = Promise.new
-
-        HTTP.post(`window.ReactiveRecordEnginePath`+"/save",
-          payload: {
-            json: {
-              models:       models,
-              associations: associations,
-              validate:     validate
-            }.to_json
-          }
-        ).then do |response|
+        Operations::Save(models: models, associations: associations, validate: validate)
+        .then do |response|
           begin
-            response.json[:models] = response.json[:saved_models].collect do |item|
+            response[:models] = response[:saved_models].collect do |item|
               backing_records[item[0]].ar_instance
             end
 
-            if response.json[:success]
-              response.json[:saved_models].each do | item |
-                # was backing_records[item[0]].sync!(item[2])
-                HyperMesh::LocalSync.after_save backing_records[item[0]].ar_instance, item[2]
+            if response[:success]
+              response[:saved_models].each do | item |
+                Broadcast.to_self backing_records[item[0]].ar_instance, item[2]
               end
             else
-              log("Reactive Record Save Failed: #{response.json[:message]}", :error)
-              response.json[:saved_models].each do | item |
+              log("Reactive Record Save Failed: #{response[:message]}", :error)
+              response[:saved_models].each do | item |
                 log("  Model: #{item[1]}[#{item[0]}]  Attributes: #{item[2]}  Errors: #{item[3]}", :error) if item[3]
               end
             end
 
-            response.json[:saved_models].each do | item |
+            response[:saved_models].each do | item |
               backing_records[item[0]].sync_unscoped_collection!
               backing_records[item[0]].errors! item[3]
             end
 
-            yield response.json[:success], response.json[:message], response.json[:models]  if block
-            promise.resolve response.json
+            yield response[:success], response[:message], response[:models]  if block
+            promise.resolve response  # TODO this could be problematic... there was no .json here, so .... what's to do?
 
             backing_records.each { |id, record| record.saved! }
 
@@ -496,19 +496,11 @@ module ReactiveRecord
         promise = Promise.new
 
         if !data_loading? and (id or vector)
-          HTTP.post(`window.ReactiveRecordEnginePath`+"/destroy",
-            payload: {
-              json: {
-                model:  ar_instance.model_name,
-                id:     id,
-                vector: vector
-              }.to_json
-            }
-          ).then do |response|
-            #sync_unscoped_collection!
-            HyperMesh::LocalSync.after_save ar_instance
-            yield response.json[:success], response.json[:message] if block
-            promise.resolve response.json
+          Operations::Destroy(model: ar_instance.model_name, id: id, vector: vector)
+          .then do |response|
+            Broadcast.to_self ar_instance
+            yield response[:success], response[:message] if block
+            promise.resolve response
           end
         else
           destroy_associations

data/lib/reactive_record/active_record/reactive_record/operations.rb

@@ -0,0 +1,51 @@
+module ReactiveRecord
+  module Operations
+  # fetch queued up records from the server
+    class Fetch < Hyperloop::ServerOp
+      param :acting_user, nils: true
+      param models: []
+      param associations: []
+      param :pending_fetches
+      step do
+        ReactiveRecord::ServerDataCache[
+          params.models.map(&:with_indifferent_access),
+          params.associations.map(&:with_indifferent_access),
+          params.pending_fetches,
+          params.acting_user
+        ]
+      end
+    end
+
+    class Save < Hyperloop::ServerOp
+      param :acting_user, nils: true
+      param models: []
+      param associations: []
+      param :validate, type: :boolean
+
+      step do
+        ReactiveRecord::Base.save_records(
+          params.models.map(&:with_indifferent_access),
+          params.associations.map(&:with_indifferent_access),
+          params.acting_user,
+          params.validate,
+          true
+        )
+      end
+    end
+
+    class Destroy < Hyperloop::ServerOp
+      param :acting_user, nils: true
+      param :model
+      param :id
+      param :vector
+      step do
+        ReactiveRecord::Base.destroy_record(
+          params.model,
+          params.id,
+          params.vector,
+          params.acting_user
+        )
+      end
+    end
+  end
+end