hyper-mesh 0.5.2 → 0.5.3

data/examples/word-game/public/robots.txt

@@ -0,0 +1,5 @@
+# See http://www.robotstxt.org/robotstxt.html for documentation on how to use the robots.txt file
+#
+# To ban all spiders from the entire site uncomment the next two lines:
+# User-agent: *
+# Disallow: /

data/examples/word-game/test/test_helper.rb

@@ -0,0 +1,10 @@
+ENV['RAILS_ENV'] ||= 'test'
+require File.expand_path('../../config/environment', __FILE__)
+require 'rails/test_help'
+
+class ActiveSupport::TestCase
+  # Setup all fixtures in test/fixtures/*.yml for all tests in alphabetical order.
+  fixtures :all
+
+  # Add more helper methods to be used by all tests here...
+end

data/lib/active_record_base.rb

@@ -20,7 +20,6 @@ module ActiveRecord
       end
 
       alias pre_synchromesh_scope scope
-      alias pre_synchromesh_default_scope default_scope
 
       def do_not_synchronize
         @do_not_synchronize = true
@@ -32,6 +31,8 @@ module ActiveRecord
 
       if RUBY_ENGINE != 'opal'
 
+        alias pre_synchromesh_default_scope default_scope
+
         def scope(name, *args, &block)
           opts = _synchromesh_scope_args_check(args)
           pre_synchromesh_scope(name, opts[:server], &block)
@@ -46,6 +47,15 @@ module ActiveRecord
           define_method name, &block
         end
 
+        def finder_method(name, &block)
+          singleton_class.send(:define_method, "_#{name}") do |*args|
+            [block.call(*args)]
+          end
+          singleton_class.send(:define_method, name) do |*args|
+            block.call(*args)
+          end
+        end
+
       else
 
         alias pre_synchromesh_method_missing method_missing
@@ -103,6 +113,15 @@ module ActiveRecord
             .new(self, nil, nil, self, 'unscoped')
             .extend(ReactiveRecord::UnscopedCollection)
         end
+
+        def finder_method(name)
+          ReactiveRecord::ScopeDescription.new(self, "_#{name}", {})
+          [name, "#{name}!"].each do |method|
+            singleton_class.send(:define_method, method) do |*vargs|
+              all.apply_scope("_#{method}", *vargs).first
+            end
+          end
+        end
       end
     end
 

data/lib/hyper-mesh.rb

@@ -15,6 +15,7 @@ if RUBY_ENGINE == 'opal'
   require 'active_support'
   require 'time'
   require 'date'
+  require 'kernel/itself' unless Object.instance_methods.include?(:itself)
   require "reactive_record/active_record/error"
   require "reactive_record/server_data_cache"
   require "reactive_record/active_record/reactive_record/while_loading"

data/lib/hypermesh/version.rb

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

data/lib/kernel/itself.rb

@@ -0,0 +1,5 @@
+module Kernel
+  def itself
+    self
+  end
+end

data/lib/reactive_record/active_record/class_methods.rb

@@ -53,10 +53,95 @@ module ActiveRecord
       # when we implement schema validation we should also implement value checking
     end
 
+    # ignore any of these methods if they get called on the client.   This list should be trimmed down to include only
+    # methods to be called as "macros" such as :after_create, etc...
+    SERVER_METHODS = [
+      :attribute_type_decorations, :defined_enums, :_validators, :timestamped_migrations, :lock_optimistically, :lock_optimistically=,
+      :local_stored_attributes=, :lock_optimistically?, :attribute_aliases?, :attribute_method_matchers?, :defined_enums?,
+      :has_many_without_reactive_record_add_changed_method, :has_many_with_reactive_record_add_changed_method,
+      :belongs_to_without_reactive_record_add_changed_method, :belongs_to_with_reactive_record_add_changed_method,
+      :cache_timestamp_format, :composed_of_with_reactive_record_add_changed_method, :schema_format, :schema_format=,
+      :error_on_ignored_order_or_limit, :error_on_ignored_order_or_limit=, :timestamped_migrations=, :dump_schema_after_migration,
+      :dump_schema_after_migration=, :dump_schemas, :dump_schemas=, :warn_on_records_fetched_greater_than=,
+      :belongs_to_required_by_default, :default_connection_handler, :connection_handler=, :default_connection_handler=,
+      :skip_time_zone_conversion_for_attributes, :skip_time_zone_conversion_for_attributes=, :time_zone_aware_types,
+      :time_zone_aware_types=, :protected_environments, :skip_time_zone_conversion_for_attributes?, :time_zone_aware_types?,
+      :partial_writes, :partial_writes=, :composed_of_without_reactive_record_add_changed_method, :logger, :partial_writes?,
+      :after_initialize, :record_timestamps, :record_timestamps=, :after_find, :after_touch, :before_save, :around_save,
+      :belongs_to_required_by_default=, :default_connection_handler?, :before_create, :around_create, :before_update, :around_update,
+      :after_save, :before_destroy, :around_destroy, :after_create, :after_destroy, :after_update, :_validation_callbacks,
+      :_validation_callbacks?, :_validation_callbacks=, :_initialize_callbacks, :_initialize_callbacks?, :_initialize_callbacks=,
+      :_find_callbacks, :_find_callbacks?, :_find_callbacks=, :_touch_callbacks, :_touch_callbacks?, :_touch_callbacks=, :_save_callbacks,
+      :_save_callbacks?, :_save_callbacks=, :_create_callbacks, :_create_callbacks?, :_create_callbacks=, :_update_callbacks,
+      :_update_callbacks?, :_update_callbacks=, :_destroy_callbacks, :_destroy_callbacks?, :_destroy_callbacks=, :record_timestamps?,
+      :_synchromesh_scope_args_check, :pre_synchromesh_scope, :pre_synchromesh_default_scope, :do_not_synchronize, :do_not_synchronize?,
+      :logger=, :maintain_test_schema, :maintain_test_schema=, :scope, :time_zone_aware_attributes, :time_zone_aware_attributes=,
+      :default_timezone, :default_timezone=, :_attr_readonly, :warn_on_records_fetched_greater_than, :configurations, :configurations=,
+      :_attr_readonly?, :table_name_prefix=, :table_name_suffix=, :schema_migrations_table_name=, :internal_metadata_table_name,
+      :internal_metadata_table_name=, :primary_key_prefix_type, :_attr_readonly=, :pluralize_table_names=, :protected_environments=,
+      :ignored_columns=, :ignored_columns, :index_nested_attribute_errors, :index_nested_attribute_errors=, :primary_key_prefix_type=,
+      :table_name_prefix?, :table_name_suffix?, :schema_migrations_table_name?, :internal_metadata_table_name?, :protected_environments?,
+      :pluralize_table_names?, :ignored_columns?, :store_full_sti_class, :store_full_sti_class=, :nested_attributes_options,
+      :nested_attributes_options=, :store_full_sti_class?, :default_scopes, :default_scope_override, :default_scopes=, :default_scope_override=,
+      :nested_attributes_options?, :cache_timestamp_format=, :cache_timestamp_format?, :reactive_record_association_keys, :_validators=,
+      :has_many, :belongs_to, :composed_of, :belongs_to_without_reactive_record_add_is_method, :_rollback_callbacks, :_commit_callbacks,
+      :_before_commit_callbacks, :attribute_type_decorations=, :_commit_callbacks=, :_commit_callbacks?, :_before_commit_callbacks?,
+      :_before_commit_callbacks=, :_rollback_callbacks=, :_before_commit_without_transaction_enrollment_callbacks?,
+      :_before_commit_without_transaction_enrollment_callbacks=, :_commit_without_transaction_enrollment_callbacks,
+      :_commit_without_transaction_enrollment_callbacks?, :_commit_without_transaction_enrollment_callbacks=, :_rollback_callbacks?,
+      :_rollback_without_transaction_enrollment_callbacks?, :_rollback_without_transaction_enrollment_callbacks=,
+      :_rollback_without_transaction_enrollment_callbacks, :_before_commit_without_transaction_enrollment_callbacks, :aggregate_reflections,
+      :_reflections=, :aggregate_reflections=, :pluralize_table_names, :public_columns_hash, :attributes_to_define_after_schema_loads,
+      :attributes_to_define_after_schema_loads=, :table_name_suffix, :schema_migrations_table_name, :attribute_aliases,
+      :attribute_method_matchers, :connection_handler, :attribute_aliases=, :attribute_method_matchers=, :_validate_callbacks,
+      :_validate_callbacks?, :_validate_callbacks=, :_validators?, :_reflections?, :aggregate_reflections?, :include_root_in_json,
+      :_reflections, :include_root_in_json=, :include_root_in_json?, :local_stored_attributes, :default_scope, :table_name_prefix,
+      :attributes_to_define_after_schema_loads?, :attribute_type_decorations?, :defined_enums=, :suppress, :has_secure_token,
+      :generate_unique_secure_token, :store, :store_accessor, :_store_accessors_module, :stored_attributes, :reflect_on_aggregation,
+      :reflect_on_all_aggregations, :_reflect_on_association, :reflect_on_all_associations, :clear_reflections_cache, :reflections,
+      :reflect_on_association, :reflect_on_all_autosave_associations, :no_touching, :transaction, :after_commit, :after_rollback, :before_commit,
+      :before_commit_without_transaction_enrollment, :after_create_commit, :after_update_commit, :after_destroy_commit,
+      :after_commit_without_transaction_enrollment, :after_rollback_without_transaction_enrollment, :raise_in_transactional_callbacks,
+      :raise_in_transactional_callbacks=, :accepts_nested_attributes_for, :has_secure_password, :has_one, :has_and_belongs_to_many,
+      :before_validation, :after_validation, :serialize, :primary_key, :dangerous_attribute_method?, :get_primary_key, :quoted_primary_key,
+      :define_method_attribute, :reset_primary_key, :primary_key=, :define_method_attribute=, :attribute_names, :initialize_generated_modules,
+      :column_for_attribute, :define_attribute_methods, :undefine_attribute_methods, :instance_method_already_implemented?, :method_defined_within?,
+      :dangerous_class_method?, :class_method_defined_within?, :attribute_method?, :has_attribute?, :generated_attribute_methods,
+      :attribute_method_prefix, :attribute_method_suffix, :attribute_method_affix, :attribute_alias?, :attribute_alias, :define_attribute_method,
+      :update_counters, :locking_enabled?, :locking_column, :locking_column=, :reset_locking_column, :decorate_attribute_type,
+      :decorate_matching_attribute_types, :attribute, :define_attribute, :reset_counters, :increment_counter, :decrement_counter,
+      :validates_absence_of, :validates_length_of, :validates_size_of, :validates_presence_of, :validates_associated, :validates_uniqueness_of,
+      :validates_acceptance_of, :validates_confirmation_of, :validates_exclusion_of, :validates_format_of, :validates_inclusion_of,
+      :validates_numericality_of, :define_callbacks, :normalize_callback_params, :__update_callbacks, :get_callbacks, :set_callback,
+      :set_callbacks, :skip_callback, :reset_callbacks, :deprecated_false_terminator, :define_model_callbacks, :validate, :validators,
+      :validates_each, :validates_with, :clear_validators!, :validators_on, :validates, :_validates_default_keys, :_parse_validates_options,
+      :validates!, :_to_partial_path, :sanitize, :sanitize_sql, :sanitize_conditions, :quote_value, :sanitize_sql_for_conditions, :sanitize_sql_array,
+      :sanitize_sql_for_assignment, :sanitize_sql_hash_for_assignment, :sanitize_sql_for_order, :expand_hash_conditions_for_aggregates, :sanitize_sql_like,
+      :replace_named_bind_variables, :replace_bind_variables, :raise_if_bind_arity_mismatch, :replace_bind_variable, :quote_bound_value, :all,
+      :default_scoped, :valid_scope_name?, :scope_attributes?, :before_remove_const, :ignore_default_scope?, :unscoped, :build_default_scope,
+      :evaluate_default_scope, :ignore_default_scope=, :current_scope, :current_scope=, :scope_attributes, :base_class, :abstract_class?,
+      :finder_needs_type_condition?, :sti_name, :descends_from_active_record?, :abstract_class, :compute_type, :abstract_class=, :table_name, :columns,
+      :table_exists?, :columns_hash, :column_names, :attribute_types, :prefetch_primary_key?, :sequence_name, :quoted_table_name, :_default_attributes,
+      :type_for_attribute, :inheritance_column, :attributes_builder, :inheritance_column=, :reset_table_name, :table_name=, :reset_column_information,
+      :full_table_name_prefix, :full_table_name_suffix, :reset_sequence_name, :sequence_name=, :next_sequence_value, :column_defaults, :content_columns,
+      :readonly_attributes, :attr_readonly, :create, :create!, :instantiate, :find, :type_caster, :arel_table, :find_by, :find_by!, :initialize_find_by_cache,
+      :generated_association_methods, :arel_engine, :arel_attribute, :predicate_builder, :collection_cache_key, :relation_delegate_class,
+      :initialize_relation_delegate_cache, :enum, :collecting_queries_for_explain, :exec_explain, :i18n_scope, :lookup_ancestors, :human_attribute_name,
+      :references, :uniq, :maximum, :none, :exists?, :second, :limit, :order, :eager_load, :update, :delete_all, :destroy, :ids, :many?, :pluck, :third,
+      :delete, :fourth, :fifth, :forty_two, :second_to_last, :third_to_last, :preload, :sum, :take!, :first!, :last!, :second!, :offset, :select, :fourth!,
+      :third!, :third_to_last!, :fifth!, :where, :first_or_create, :second_to_last!, :forty_two!, :first, :having, :any?, :one?, :none?, :find_or_create_by,
+      :from, :first_or_create!, :first_or_initialize, :except, :find_or_create_by!, :find_or_initialize_by, :includes, :destroy_all, :update_all, :or,
+      :find_in_batches, :take, :joins, :find_each, :last, :in_batches, :reorder, :group, :left_joins, :left_outer_joins, :rewhere, :readonly, :create_with,
+      :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
+    ]
+
     def method_missing(name, *args, &block)
       if args.count == 1 && name =~ /^find_by_/ && !block
         find_by(name.gsub(/^find_by_/, "") => args[0])
-      else
+      elsif !SERVER_METHODS.include?(name)
         raise "#{self.name}.#{name}(#{args}) (called class method missing)"
       end
     end
@@ -109,7 +194,7 @@ module ActiveRecord
         name = args.first
         define_method(name) { @backing_record.reactive_get!(name, nil) }
         define_method("#{name}=") do |val|
-          @backing_record.reactive_set!(name, backing_record.convert(name, val))
+          @backing_record.reactive_set!(name, backing_record.convert(name, val).itself)
         end
         opts = (args.count > 1 and args.last.is_a? Hash) ? args.last : {}
         Associations::AssociationReflection.new(self, macro, name, opts)
@@ -160,15 +245,6 @@ module ActiveRecord
       end
     end
 
-    [
-      "table_name=", "before_validation", "with_options", "validates_presence_of", "validates_format_of",
-      "accepts_nested_attributes_for", "before_create", "after_create", "before_save", "after_save", "before_destroy", "where", "validate",
-      "attr_protected", "validates_numericality_of", "default_scope", "has_attached_file", "attr_accessible",
-      "serialize"
-    ].each do |method|
-      define_method(method.to_s) { |*args, &block| }
-    end
-
     def _react_param_conversion(param, opt = nil)
       param = Native(param)
       param = JSON.from_object(param.to_n) if param.is_a? Native::Object

data/lib/reactive_record/active_record/instance_methods.rb

@@ -17,10 +17,12 @@ module ActiveRecord
         # we have to build the backing record first then initialize it so associations work correctly
         @backing_record = ReactiveRecord::Base.new(self.class, {}, self)
         @backing_record.instance_eval do
+          h = Hash.new
+          hash.each { |a, v| h[a] = convert(a, v).itself }
           self.class.load_data do
-            hash.each do |attribute, value|
+            h.each do |attribute, value|
               unless attribute == primary_key
-                reactive_set!(attribute, convert(attribute, value))
+                reactive_set!(attribute, value)
                 changed_attributes << attribute
               end
             end

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

@@ -205,18 +205,11 @@ module ReactiveRecord
       @pre_sync_related_records = nil
     end
 
-    # def in_this_collection(related_records)
-    #   related_records.delete_if do |r|
-    #     # BELOW IS WRONG... its more complicated isn't it...
-    #     if @association.through_association
-    #
-    #     else
-    #       r.backing_record.attributes[@association.inverse_of] != @owner
-    #   end
-    # end
-
     def apply_scope(name, *vector)
-      build_child_scope(ScopeDescription.find(@target_klass, name), *name, *vector)
+      description = ScopeDescription.find(@target_klass, name)
+      collection = build_child_scope(description, *description.name, *vector)
+      collection.reload_from_db if name == "#{description.name}!"
+      collection
     end
 
     def child_scopes
@@ -367,6 +360,7 @@ module ReactiveRecord
     end
 
     def push(item)
+      item.itself # force get of at least the id
       if collection
         self.force_push item
       else
@@ -486,8 +480,11 @@ module ReactiveRecord
     def method_missing(method, *args, &block)
       if [].respond_to? method
         all.send(method, *args, &block)
-      elsif @target_klass.respond_to?(method) or (args.count == 1 && method =~ /^find_by_/)
+      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
       end

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

@@ -226,74 +226,74 @@ module ReactiveRecord
       end
 
       def save(validate, force, &block)
-
         if data_loading?
-
           sync!
-
         elsif force or changed?
+          HyperMesh.load do
+            ReactiveRecord.loads_pending! unless self.class.pending_fetches.empty?
+          end.then { save_to_server(validate, force, &block) }
+          #save_to_server(validate, force, &block)
+        else
+          promise = Promise.new
+          yield true, nil, [] if block
+          promise.resolve({success: true})
+          promise
+        end
+      end
 
-          begin
-
-            models, associations, backing_records = self.class.gather_records([self], force, self)
+      def save_to_server(validate, force, &block)
+        models, associations, backing_records = self.class.gather_records([self], force, self)
 
-            backing_records.each { |id, record| record.saving! }
+        backing_records.each { |id, record| record.saving! }
 
-            promise = Promise.new
+        promise = Promise.new
 
-            HTTP.post(`window.ReactiveRecordEnginePath`+"/save",
-              payload: {
-                json: {
-                  models:       models,
-                  associations: associations,
-                  validate:     validate
-                }.to_json
-              }
-            ).then do |response|
-              begin
-                response.json[:models] = response.json[:saved_models].collect do |item|
-                  backing_records[item[0]].ar_instance
-                end
+        HTTP.post(`window.ReactiveRecordEnginePath`+"/save",
+          payload: {
+            json: {
+              models:       models,
+              associations: associations,
+              validate:     validate
+            }.to_json
+          }
+        ).then do |response|
+          begin
+            response.json[:models] = response.json[: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]
-                  end
-                else
-                  log("Reactive Record Save Failed: #{response.json[:message]}", :error)
-                  response.json[:saved_models].each do | item |
-                    log("  Model: #{item[1]}[#{item[0]}]  Attributes: #{item[2]}  Errors: #{item[3]}", :error) if item[3]
-                  end
-                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]
+              end
+            else
+              log("Reactive Record Save Failed: #{response.json[:message]}", :error)
+              response.json[: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 |
-                  backing_records[item[0]].sync_unscoped_collection!
-                  backing_records[item[0]].errors! item[3]
-                end
+            response.json[: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.json[:success], response.json[:message], response.json[:models]  if block
+            promise.resolve response.json
 
-                backing_records.each { |id, record| record.saved! }
+            backing_records.each { |id, record| record.saved! }
 
-              rescue Exception => e
-                log("Exception raised while saving - #{e}", :error)
-              end
-            end
-            promise
           rescue Exception => e
             log("Exception raised while saving - #{e}", :error)
-            yield false, e.message, [] if block
-            promise.resolve({success: false, message: e.message, models: []})
-            promise
           end
-        else
-          promise = Promise.new
-          yield true, nil, [] if block
-          promise.resolve({success: true})
-          promise
         end
+        promise
+      rescue Exception => e
+        log("Exception raised while saving - #{e}", :error)
+        yield false, e.message, [] if block
+        promise.resolve({success: false, message: e.message, models: []})
+        promise
       end
 
     else

data/lib/reactive_record/active_record/reactive_record/while_loading.rb

@@ -3,7 +3,7 @@ module HyperMesh
     ReactiveRecord.load &block
   end
 end
-    
+
 module ReactiveRecord
 
   # will repeatedly execute the block until it is loaded
@@ -14,7 +14,7 @@ module ReactiveRecord
     @load_stack ||= []
     @load_stack << @loads_pending
     @loads_pending = nil
-    result = block.call
+    result = block.call.itself
     if @loads_pending
       @blocks_to_load ||= []
       @blocks_to_load << [Base.last_fetch_at, promise, block]
@@ -24,7 +24,6 @@ module ReactiveRecord
     @loads_pending = @load_stack.pop
     promise
   rescue Exception => e
-    debugger
     React::IsomorphicHelpers.log "ReactiveRecord.load exception raised during initial load: #{e}", :error
   end