hyper-mesh 0.6.0 → 1.0.0.lap22

data/lib/active_record_base.rb

@@ -44,7 +44,7 @@ module ActiveRecord
         end
 
         def server_method(name, opts = {}, &block)
-          define_method name, &block
+          define_method(name, &block)
         end
 
         def finder_method(name, &block)
@@ -63,8 +63,8 @@ module ActiveRecord
         def method_missing(name, *args, &block)
           #return get_by_index(*args).first if name == "[]"
           return all.send(name, *args, &block) if [].respond_to?(name)
-          if name =~ /\!$/
-            return send(name.gsub(/\!$/,''), *args, &block).send(:reload_from_db) rescue nil
+          if name.end_with?('!')
+            return send(name.chop, *args, &block).send(:reload_from_db) rescue nil
           end
           pre_synchromesh_method_missing(name, *args, &block)
         end

data/lib/hypermesh/version.rb

@@ -1,3 +1,3 @@
 module Hypermesh
-  VERSION = '0.6.0'
+  VERSION = '1.0.0.lap22'
 end

data/lib/opal/parse_patch.rb

@@ -6,7 +6,7 @@ rescue Exception => e
       alias old_parse parse
     end
     def self.parse(*args, &block)
-      old_parse *args, &block
+      old_parse(*args, &block)
     rescue Exception => e
       raise StandardError.new e.message
     end

data/lib/reactive_record/active_record/aggregations.rb

@@ -32,7 +32,7 @@ module ActiveRecord
         @klass_name =  options[:class_name] || name.camelize
         @attribute =   name
         if options[:mapping].respond_to? :collect
-          @mapped_attributes = options[:mapping].collect &:last
+          @mapped_attributes = options[:mapping].collect(&:last)
         else
           ReactiveRecord::Base.log("improper aggregate definition #{@owner_class}, :#{name}, class_name: #{@klass_name} - missing mapping", :error)
           @mapped_attributes = []

data/lib/reactive_record/active_record/associations.rb

@@ -33,11 +33,7 @@ module ActiveRecord
         @owner_class = owner_class
         @macro =       macro
         @options =     options
-        @klass_name =  options[:class_name] || (collection? && name.camelize.gsub(/s$/, '')) || name.camelize
-        if @klass_name < ActiveRecord::Base
-          @klass = @klass_name
-          @klass_name = @klass_name.name
-        end rescue nil
+        @klass_name =  options[:class_name] || (collection? && name.camelize.sub(/s$/, '')) || name.camelize
         @association_foreign_key = options[:foreign_key] || (macro == :belongs_to && "#{name}_id") || "#{@owner_class.name.underscore}_id"
         @source = options[:source] || @klass_name.underscore if options[:through]
         @attribute = name

data/lib/reactive_record/active_record/class_methods.rb

@@ -53,6 +53,10 @@ module ActiveRecord
       # when we implement schema validation we should also implement value checking
     end
 
+    def serialize(attr, *args)
+      ReactiveRecord::Base.serialized?[self][attr] = true
+    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 = [
@@ -139,8 +143,8 @@ module ActiveRecord
     ]
 
     def method_missing(name, *args, &block)
-      if args.count == 1 && name =~ /^find_by_/ && !block
-        find_by(name.gsub(/^find_by_/, "") => args[0])
+      if args.count == 1 && name.start_with?("find_by_") && !block
+        find_by(name.sub(/^find_by_/, "") => args[0])
       elsif !SERVER_METHODS.include?(name)
         raise "#{self.name}.#{name}(#{args}) (called class method missing)"
       end
@@ -168,27 +172,6 @@ module ActiveRecord
       ReactiveRecord::Base.class_scopes(self)[:all] = collection
     end
 
-    # def server_methods(*methods)
-    #   methods.each do |method|
-    #     define_method(method) do |*args|
-    #       if args.count == 0
-    #         @backing_record.reactive_get!(method, :initialize)
-    #       else
-    #         @backing_record.reactive_get!([[method]+args], :initialize)
-    #       end
-    #     end
-    #     define_method("#{method}!") do |*args|
-    #       if args.count == 0
-    #         @backing_record.reactive_get!(method, :force)
-    #       else
-    #         @backing_record.reactive_get!([[method]+args], :force)
-    #       end
-    #     end
-    #   end
-    # end
-    #
-    # alias_method :server_method, :server_methods
-
     [:belongs_to, :has_many, :has_one].each do |macro|
       define_method(macro) do |*args| # is this a bug in opal?  saying name, scope=nil, opts={} does not work!
         name = args.first

data/lib/reactive_record/active_record/instance_methods.rb

@@ -86,19 +86,39 @@ module ActiveRecord
     end
 
     def method_missing(name, *args, &block)
-      method_missing_warning("#{name}(#{args})")
-      if name =~ /\!$/
-        name = name.gsub(/\!$/,"")
+      original_name = name
+
+      if name.end_with?('!')
+        name = name.chop # remove '!'
         force_update = true
       end
-      if name =~ /_changed\?$/
-        @backing_record.changed?(name.gsub(/_changed\?$/,""))
-      elsif args.count == 1 && name =~ /=$/ && !block
-        attribute_name = name.gsub(/=$/,"")
+
+      chopped_name = name.end_with?('=') ? name.chop : name
+      is_server_method = self.class.server_methods.has_key?(chopped_name)
+      chopped_name = chopped_name.end_with?('?') ? chopped_name.chop : name
+      is_attribute = attributes.has_key?(chopped_name)
+
+      unless is_server_method || is_attribute
+        if ReactiveRecord::Base.public_columns_hash.has_key?(self.class.name) && ReactiveRecord::Base.public_columns_hash[self.class.name].has_key?(chopped_name)
+          is_attribute = true
+        end
+        method_missing_warning("#{original_name}(#{args})") unless is_attribute
+      end
+
+      if name.end_with?('_changed?')
+        @backing_record.changed?(name[0...-9]) # remove '_changed?'
+      elsif args.count == 1 && name.end_with?('=') && !block
+        attribute_name = name.chop # remove '='
+        # for rails auto generated methods for booleans, remove '?' to get the attribute
+        attribute_name = attribute_name.chop if !is_server_method && is_attribute && attribute_name.end_with?('?')
         @backing_record.reactive_set!(attribute_name, backing_record.convert(attribute_name, args[0]))
       elsif args.count.zero? && !block
+        # for rails auto generated methods for booleans, remove '?' to get the attribute
+        name = name.chop if !is_server_method && is_attribute && name.end_with?('?')
         @backing_record.reactive_get!(name, force_update)
-      elsif !block
+      elsif !block 
+        # for rails auto generated methods for booleans, remove '?' to get the attribute
+        name = name.chop if !is_server_method && is_attribute && name.end_with?('?')
         @backing_record.reactive_get!([[name]+args], force_update)
       else
         super
@@ -116,7 +136,7 @@ module ActiveRecord
       first_time = true
       ReactiveRecord.load do
         results = attributes.collect { |attr| @backing_record.reactive_get!(attr, first_time) }
-        results = yield *results if block
+        results = yield(*results) if block
         first_time = false
         block.nil? && results.count == 1 ? results.first : results
       end
@@ -131,7 +151,7 @@ module ActiveRecord
     end
 
     def destroy(&block)
-      @backing_record.destroy &block
+      @backing_record.destroy(&block)
     end
 
     def destroyed?

data/lib/reactive_record/active_record/public_columns_hash.rb

@@ -1,25 +1,44 @@
 module Hyperloop
-  define_setting :public_model_directories, ['app/models/public', 'app/hyperloop/models']
+  define_setting :public_model_directories, [File.join('app','hyperloop','models'), File.join('app','models','public')]
 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
-  # look through the public folder, and just get those models.
-  # this works because the public folder is currently required to be eaer loaded.
+  # this works because the public folder is currently required to be eager loaded.
   class Base
     def self.public_columns_hash
-      return @public_columns_hash if @public_columns_hash
+      return @public_columns_hash if @public_columns_hash && Rails.env.production?
+      files = []
       Hyperloop.public_model_directories.each do |dir|
-        Dir.glob(Rails.root.join("#{dir}/*.rb")).each do |file|
-          require_dependency(file)
+        dir_length = Rails.root.join(dir).to_s.length + 1
+        Dir.glob(Rails.root.join(dir, '**', '*.rb')).each do |file|
+          require_dependency(file) # still the file is loaded to make sure for development and test env
+          files << file[dir_length..-4]
         end
       end
       @public_columns_hash = {}
+      # descendants only works for already loaded models!
       descendants.each do |model|
-        @public_columns_hash[model.name] = model.columns_hash rescue nil
+        if files.include?(model.name.underscore) && model.name.underscore != 'application_record'
+          @public_columns_hash[model.name] = model.columns_hash rescue nil # why rescue?
+        end
+        # begin
+        #   @public_columns_hash[model.name] = model.columns_hash if model.table_name
+        # rescue Exception => e
+        #   binding.pry
+        #   @public_columns_hash = nil
+        #   raise $!, "Could not read 'columns_hash' for #{model}: #{$!}", $!.backtrace
+        # end if files.include?(model.name.underscore) && model.name.underscore != 'application_record'
       end
       @public_columns_hash
     end
+
+    def self.public_columns_hash_as_json
+      return @public_columns_hash_json if @public_columns_hash_json && Rails.env.production?
+      pch = public_columns_hash
+      return @public_columns_hash_json if @prev_public_columns_hash == pch
+      @prev_public_columns_hash = pch
+      @public_columns_hash_json = pch.to_json
+    end
   end
 end

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

@@ -480,7 +480,7 @@ module ReactiveRecord
     def method_missing(method, *args, &block)
       if [].respond_to? method
         all.send(method, *args, &block)
-      elsif ScopeDescription.find(@target_klass, method) || (args.count == 1 && method =~ /^find_by_/)
+      elsif ScopeDescription.find(@target_klass, method) || (args.count == 1 && method.start_with?("find_by_"))
         apply_scope(method, *args)
       elsif @target_klass.respond_to?(method) && ScopeDescription.find(@target_klass, "_#{method}")
         apply_scope("_#{method}", *args).first

data/lib/reactive_record/active_record/reactive_record/column_types.rb

@@ -56,9 +56,15 @@ module ReactiveRecord
 
     alias convert_string convert_text
 
+    def self.serialized?
+      @serialized_attrs ||= Hash.new { |h, k| h[k] = Hash.new }
+    end
+
     def convert(attr, val)
       column_type = column_type(attr)
-      return val if !column_type || val.loading? || (!val && column_type != :boolean)
+      return val if self.class.serialized?[model][attr] ||
+                    !column_type || val.loading? ||
+                    (!val && column_type != :boolean)
       conversion_method = "convert_#{column_type}"
       return send(conversion_method, val) if respond_to? conversion_method
       val

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

@@ -32,7 +32,7 @@ module ReactiveRecord
         ) || 'nil'
         default_value_method = "build_default_value_for_#{column_type}"
         @object = __send__ default_value_method
-      rescue Exception
+      rescue ::Exception
       end
 
       def build_default_value_for_nil
@@ -41,7 +41,7 @@ module ReactiveRecord
 
       def build_default_value_for_datetime
         if @column_hash[:default]
-          Time.parse(@column_hash[:default].gsub(' ','T')+'+00:00')
+          ::Time.parse(@column_hash[:default].gsub(' ','T')+'+00:00')
         else
           ::ReactiveRecord::Base::DummyValue.dummy_time
         end
@@ -52,7 +52,7 @@ module ReactiveRecord
 
       def build_default_value_for_date
         if @column_hash[:default]
-          Date.parse(@column_hash[:default])
+          ::Date.parse(@column_hash[:default])
         else
           ::ReactiveRecord::Base::DummyValue.dummy_date
         end
@@ -81,9 +81,9 @@ module ReactiveRecord
       alias build_default_value_for_text build_default_value_for_string
 
       def notify
-        return if ReactiveRecord::Base.data_loading?
-        ReactiveRecord.loads_pending!
-        ReactiveRecord::WhileLoading.loading!
+        return if ::ReactiveRecord::Base.data_loading?
+        ::ReactiveRecord.loads_pending!
+        ::ReactiveRecord::WhileLoading.loading!
       end
 
       def loading?
@@ -107,7 +107,7 @@ module ReactiveRecord
       end
 
       def method_missing(method, *args, &block)
-        if method =~ /^build_default_value_for_/
+        if method.start_with?("build_default_value_for_")
           nil
         elsif @object || @object.respond_to?(method)
           notify
@@ -155,7 +155,7 @@ module ReactiveRecord
 
       alias inspect to_s
 
-      `#{self}.$$proto.toString = #{Object}.$$proto.toString`
+      `#{self}.$$proto.toString = Opal.Object.$$proto.toString`
 
       def to_f
         notify
@@ -182,38 +182,51 @@ module ReactiveRecord
       end
 
       def self.dummy_time
-        @dummy_time ||= Time.parse('2001-01-01T00:00:00.000-00:00')
+        @dummy_time ||= ::Time.parse('2001-01-01T00:00:00.000-00:00')
       end
 
       def self.dummy_date
-        @dummy_date ||= Date.parse('1/1/2001')
+        @dummy_date ||= ::Date.parse('1/1/2001')
       end
 
       def to_date
         notify
         return @object.to_date if @object
-        ReactiveRecord::Base::DummyValue.dummy_date
+        ::ReactiveRecord::Base::DummyValue.dummy_date
       end
 
       def to_time
         notify
         return @object.to_time if @object
-        ReactiveRecord::Base::DummyValue.dummy_time
+        ::ReactiveRecord::Base::DummyValue.dummy_time
       end
 
       def acts_as_string?
-        return true if @object.is_a? String
-        return @object.acts_as_string? if @object
+        return true if @object.is_a? ::String
+        return @object.acts_as_string? if @object && @object.respond_to?(:acts_as_string?)
         true
       end
 
+      # this is a hackish way and compatible with any other rendered object
+      # to identify a DummyValue during render
+      # in ReactRenderingContext.run_child_block() and
+      # to convert it to a string, for rendering
+      # advantage over a try(:method) is, that it doesnt raise und thus is faster
+      # which is important during render
+      def respond_to?(method)
+        return true if method == :acts_as_string?
+        return true if %i[inspect to_date to_f to_i to_numeric to_number to_s to_time].include? method
+        return @object.respond_to? if @object
+        false
+      end
+
       def try(*args, &b)
         if args.empty? && block_given?
           yield self
         else
           __send__(*args, &b)
         end
-      rescue
+      rescue ::Exception
         nil
       end
     end

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

@@ -52,12 +52,12 @@ module ReactiveRecord
 
     isomorphic_method(:fetch_from_db) do |f, vector|
       # vector must end with either "*all", or be a simple attribute
-      f.send_to_server [vector.shift.name, *vector] if  RUBY_ENGINE == 'opal'
+      f.send_to_server [vector.shift.name, *vector] if RUBY_ENGINE == 'opal'
       f.when_on_server { @server_data_cache[*vector] }
     end
 
     isomorphic_method(:find_in_db) do |f, klass, attribute, value|
-      f.send_to_server klass.name, attribute, value if  RUBY_ENGINE == 'opal'
+      f.send_to_server klass.name, attribute, value if RUBY_ENGINE == 'opal'
       f.when_on_server { @server_data_cache[klass, ["find_by_#{attribute}", value], :id] }
     end
 
@@ -86,7 +86,7 @@ module ReactiveRecord
       end
       "<script type='text/javascript'>\n"+
         "if (typeof window.ReactiveRecordPublicColumnsHash === 'undefined') { \n" +
-        "  window.ReactiveRecordPublicColumnsHash = #{ActiveRecord::Base.public_columns_hash.to_json}}\n" +
+        "  window.ReactiveRecordPublicColumnsHash = #{ActiveRecord::Base.public_columns_hash_as_json}}\n" +
         "if (typeof window.ReactiveRecordInitialData === 'undefined') { window.ReactiveRecordInitialData = [] }\n" +
         "window.ReactiveRecordInitialData.push(#{json})\n"+
       "</script>\n"
@@ -140,17 +140,17 @@ module ReactiveRecord
           pending_fetches = @pending_fetches.uniq
           models, associations = gather_records(@pending_records, false, nil)
           log(["Server Fetching: %o", pending_fetches.to_n])
-          start_time = Time.now
-          Operations::Fetch(models: models, associations: associations, pending_fetches: pending_fetches)
+          start_time = `Date.now()`
+          Operations::Fetch.run(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")
+              fetch_time = `Date.now()`
+              log("       Fetched in:   #{`(fetch_time - start_time)/ 1000`}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("       Processed in: #{`(Date.now() - fetch_time) / 1000`}s")
               log(["       Returned: %o", response.to_n])
               ReactiveRecord.run_blocks_to_load last_fetch_at
               ReactiveRecord::WhileLoading.loaded_at last_fetch_at
@@ -256,7 +256,7 @@ module ReactiveRecord
         backing_records.each { |id, record| record.saving! }
 
         promise = Promise.new
-        Operations::Save(models: models, associations: associations, validate: validate)
+        Operations::Save.run(models: models, associations: associations, validate: validate)
         .then do |response|
           begin
             response[:models] = response[:saved_models].collect do |item|
@@ -434,6 +434,7 @@ module ReactiveRecord
           #puts "!!!!!!!!!!!!associations updated"
 
           has_errors = false
+          error_messages = []
 
           #puts "ready to start saving... dont_save_list = #{dont_save_list}"
 
@@ -446,18 +447,28 @@ module ReactiveRecord
               #puts "has_errors before = #{has_errors}, validate= #{validate}, !valid= #{!valid}  (validate and !valid) #{validate and !valid}"
               has_errors ||= (validate and !valid)
               #puts "validation complete errors = <#{!valid}>, #{model.errors.messages} has_errors #{has_errors}"
+              error_messages << [model, model.errors.messages] unless valid
               [reactive_record_id, model.class.name, model.attributes,  (valid ? nil : model.errors.messages)]
             elsif model and (!model.id or model.changed?)
               #puts "saving #{model.class.name} #{model} (reactive_record_id = #{reactive_record_id})"
               saved = model.check_permission_with_acting_user(acting_user, new_models.include?(model) ? :create_permitted? : :update_permitted?).save(validate: validate)
               has_errors ||= !saved
               messages = model.errors.messages if (validate and !saved) or (!validate and !model.valid?)
+              error_messages << [model, messages] if messages
               #puts "saved complete errors = <#{!saved}>, #{messages} has_errors #{has_errors}"
               [reactive_record_id, model.class.name, model.attributes, messages]
             end
           end.compact
 
-          raise "Could not save all models" if has_errors
+          if has_errors
+            ::Rails.logger.debug "\033[0;31;1mERROR: HyperModel saving records failed:\033[0;30;21m"
+            error_messages.each do |model, messages|
+              messages.each do |message|
+                ::Rails.logger.debug "\033[0;31;1m\t#{model}: #{message}\033[0;30;21m"
+              end
+            end
+            raise "HyperModel saving records failed!"
+          end
 
           if save
 
@@ -465,7 +476,7 @@ module ReactiveRecord
 
           else
 
-            vectors.each { |vector, model| model.reload unless model.nil? or model.new_record? or model.frozen? }
+            # vectors.each { |vector, model| model.reload unless model.nil? or model.new_record? or model.frozen? }
             vectors
 
           end
@@ -496,7 +507,7 @@ module ReactiveRecord
         promise = Promise.new
 
         if !data_loading? and (id or vector)
-          Operations::Destroy(model: ar_instance.model_name, id: id, vector: vector)
+          Operations::Destroy.run(model: ar_instance.model_name, id: id, vector: vector)
           .then do |response|
             Broadcast.to_self ar_instance
             yield response[:success], response[:message] if block