hyper-mesh 1.0.0.lap27 → 1.0.0.lap28

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

@@ -16,7 +16,6 @@ module ReactiveRecord
         @unsaved_children ||= Set.new
         unless @uc_already_being_called
           @uc_already_being_called = true
-          #@owner.backing_record.update_attribute(@association.attribute)
         end
       else
         @unsaved_children ||= DummySet.new
@@ -72,7 +71,7 @@ module ReactiveRecord
       if (@collection || all).length <= index and @dummy_collection
         (@collection.length..index).each do |i|
           new_dummy_record = ReactiveRecord::Base.new_from_vector(@target_klass, nil, *@vector, "*#{i}")
-          new_dummy_record.backing_record.attributes[@association.inverse_of] = @owner if @association && !@association.through_association?
+          new_dummy_record.attributes[@association.inverse_of] = @owner if @association && !@association.through_association?
           @collection << new_dummy_record
         end
       end
@@ -99,10 +98,35 @@ module ReactiveRecord
     attr_reader   :pre_sync_related_records
 
     def to_s
-      "<Coll-#{object_id} - #{vector}>"
+      "<Coll-#{object_id} owner: #{@owner}, parent: #{@parent} - #{vector}>"
     end
 
     class << self
+
+=begin
+sync_scopes takes a newly broadcasted record change and updates all relevant currently active scopes
+This is particularly hard when the client proc is specified.  For example consider this scope:
+
+class TestModel < ApplicationRecord
+  scope :quicker, -> { where(completed: true) }, client: -> { completed }
+end
+
+and this slice of reactive code:
+
+   DIV { "quicker.count = #{TestModel.quicker.count}" }
+
+then on the server this code is executed:
+
+  TestModel.last.update(completed: false)
+
+This will result in the changes being broadcast to the client, which may cauase the value of
+TestModel.quicker.count to increase or decrease.  Of course we may not actually have the all the records,
+perhaps we just have the aggregate count.
+
+To determine this sync_scopes first asks if the record being changed is in the scope given its value
+
+
+=end
       def sync_scopes(broadcast)
         # record_with_current_values will return nil if data between
         # the broadcast record and the value on the client is out of sync
@@ -156,16 +180,23 @@ module ReactiveRecord
     # is it necessary to check @association in the next 2 methods???
 
     def joins_with?(record)
-      if @association && @association.through_association
+      klass = record.class
+      if @association&.through_association
         @association.through_association.klass == record.class
-      else
-        @target_klass == record.class
+      elsif @target_klass == klass
+        true
+      elsif !klass.inheritance_column
+        false
+      elsif klass.base_class == @target_class
+        klass < @target_klass
+      elsif klass.base_class == klass
+        @target_klass < klass
       end
     end
 
     def related_records_for(record)
       return [] unless @association
-      attrs = record.backing_record.attributes
+      attrs = record.attributes
       return [] unless attrs[@association.inverse_of] == @owner
       if !@association.through_association
         [record]
@@ -196,6 +227,7 @@ module ReactiveRecord
       live_scopes.each { |scope| scope.set_pre_sync_related_records(@pre_sync_related_records) }
     end
 
+    # NOTE sync_scopes is overridden in scope_description.rb
     def sync_scopes(related_records, record, filtering = true)
       #related_records = related_records.intersection([*@collection])
       #related_records = in_this_collection related_records
@@ -341,7 +373,8 @@ module ReactiveRecord
 
     def set_belongs_to(child)
       if @owner
-        child.send("#{@association.inverse_of}=", @owner) if @association
+        # TODO this is major broken...current
+        child.send("#{@association.inverse_of}=", @owner) if @association && !@association.through_association
       elsif @parent
         @parent.set_belongs_to(child)
       end
@@ -354,16 +387,17 @@ module ReactiveRecord
     # means appointment.doctor_value.patients << appointment.patient
     # and we have to appointment.doctor(current value).patients.delete(appointment.patient)
 
-
     def update_child(item)
       backing_record = item.backing_record
       if backing_record && @owner && @association && !@association.through_association? && item.attributes[@association.inverse_of] != @owner
         inverse_of = @association.inverse_of
         current_association = item.attributes[inverse_of]
         backing_record.virgin = false unless backing_record.data_loading?
-        backing_record.update_attribute(inverse_of, @owner)
-        current_association.attributes[@association.attribute].delete(item) if current_association and current_association.attributes[@association.attribute]
-        @owner.backing_record.update_attribute(@association.attribute) # forces a check if association contents have changed from synced values
+        backing_record.update_belongs_to(inverse_of, @owner)
+        if current_association && current_association.attributes[@association.attribute]
+          current_association.attributes[@association.attribute].delete(item)
+        end
+        @owner.backing_record.sync_has_many(@association.attribute)
       end
     end
 
@@ -374,7 +408,7 @@ module ReactiveRecord
       else
         unsaved_children << item
         update_child(item)
-        @owner.backing_record.update_attribute(@association.attribute) if @owner && @association
+        @owner.backing_record.sync_has_many(@association.attribute) if @owner && @association
         if !@count.nil?
           @count += item.destroyed? ? -1 : 1
           notify_of_change self
@@ -454,12 +488,11 @@ module ReactiveRecord
       notify_of_change(
         if @owner && @association && !@association.through_association?
           inverse_of = @association.inverse_of
-          if (backing_record = item.backing_record) && backing_record.attributes[inverse_of] == @owner
+          if (backing_record = item.backing_record) && item.attributes[inverse_of] == @owner
             # the if prevents double update if delete is being called from << (see << above)
-            backing_record.update_attribute(inverse_of, nil)
+            backing_record.update_belongs_to(inverse_of, nil)
           end
-          # forces a check if association contents have changed from synced values
-          delete_internal(item) { @owner.backing_record.update_attribute(@association.attribute) }
+          delete_internal(item) { @owner.backing_record.sync_has_many(@association.attribute) }
         else
           delete_internal(item)
         end
@@ -472,7 +505,7 @@ module ReactiveRecord
       elsif !@count.nil?
         @count -= 1
       end
-      yield item if block_given?
+      yield if block_given? # was yield item, but item is not used
       item
     end
 

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

@@ -5,10 +5,12 @@ module ReactiveRecord
       model.columns_hash
     end
 
+    def self.column_type(column_hash)
+      column_hash && column_hash[:sql_type_metadata] && column_hash[:sql_type_metadata][:type]
+    end
+
     def column_type(attr)
-      column_hash = columns_hash[attr]
-      return nil unless column_hash
-      column_hash[:sql_type_metadata] && column_hash[:sql_type_metadata][:type]
+      Base.column_type(columns_hash[attr])
     end
 
     def convert_datetime(val)

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

@@ -26,10 +26,7 @@ module ReactiveRecord
         column_hash ||= {}
         notify
         @column_hash = column_hash
-        column_type = (
-          @column_hash[:sql_type_metadata] &&
-          @column_hash[:sql_type_metadata][:type]
-        ) || 'nil'
+        column_type = Base.column_type(@column_hash) || 'nil'
         default_value_method = "build_default_value_for_#{column_type}"
         @object = __send__ default_value_method
       rescue ::Exception
@@ -153,6 +150,11 @@ module ReactiveRecord
         ''
       end
 
+      def tap
+        yield self
+        self
+      end
+
       alias inspect to_s
 
       `#{self}.$$proto.toString = Opal.Object.$$proto.toString`

data/lib/reactive_record/active_record/reactive_record/getters.rb

@@ -0,0 +1,133 @@
+module ReactiveRecord
+  # creates getters for various method types
+  # TODO replace sync_attribute calls with direct logic
+  module Getters
+    def get_belongs_to(assoc, reload = nil)
+      getter_common(assoc.attribute, reload) do |has_key, attr|
+        return if new?
+        value = Base.fetch_from_db([@model, [:find, id], attr, @model.primary_key]) if id.present?
+        value = find_association(assoc, value)
+        sync_ignore_dummy attr, value, has_key
+      end&.cast_to_current_sti_type
+    end
+
+    def get_has_many(assoc, reload = nil)
+      getter_common(assoc.attribute, reload) do |_has_key, attr|
+        if new?
+          @attributes[attr] = Collection.new(assoc.klass, @ar_instance, assoc)
+        else
+          sync_attribute attr, Collection.new(assoc.klass, @ar_instance, assoc, *vector, attr)
+        end
+      end
+    end
+
+    def get_attr_value(attr, reload = nil)
+      non_relationship_getter_common(attr, reload) do
+        sync_attribute attr, convert(attr, model.columns_hash[attr][:default])
+      end
+    end
+
+    def get_primary_key_value
+      non_relationship_getter_common(model.primary_key, false)
+    end
+
+    def get_server_method(attr, reload = nil)
+      non_relationship_getter_common(attr, reload) do |has_key|
+        sync_ignore_dummy attr, Base.load_from_db(self, *(vector ? vector : [nil]), attr), has_key
+      end
+    end
+
+    def get_ar_aggregate(aggr, reload = nil)
+      getter_common(aggr.attribute, reload) do |has_key, attr|
+        if new?
+          @attributes[attr] = aggr.klass.new.backing_record.link_aggregate(attr, self)
+        else
+          sync_ignore_dummy attr, new_from_vector(aggr.klass, self, *vector, attr), has_key
+        end
+      end
+    end
+
+    def get_non_ar_aggregate(attr, reload = nil)
+      non_relationship_getter_common(attr, reload)
+    end
+
+    private
+
+    def virtual_fetch_on_server_warning(attr)
+      log(
+        "Warning fetching virtual attributes (#{model.name}.#{attr}) during prerendering "\
+        'on a changed or new model is not implemented.',
+        :warning
+      )
+    end
+
+    def sync_ignore_dummy(attr, value, has_key)
+      # ignore the value if its a Dummy value and there is already a value present
+      # this is used to implement reloading.  During the reload while we are waiting we
+      # want the current attribute (if its present) to not change.  Once the fetch
+      # is complete the fetch process will reload the attribute
+      value = @attributes[attr] if has_key && value.is_a?(Base::DummyValue)
+      sync_attribute(attr, value)
+    end
+
+    def non_relationship_getter_common(attr, reload, &block)
+      getter_common(attr, reload) do |has_key|
+        if new?
+          yield has_key if block
+        elsif on_opal_client?
+          sync_ignore_dummy attr, Base.load_from_db(self, *(vector ? vector : [nil]), attr), has_key
+        elsif id.present?
+          sync_attribute attr, Base.fetch_from_db([@model, [:find, id], attr])
+        else
+          sync_attribute attr, Base.fetch_from_db([*vector, attr])
+        end
+      end
+    end
+
+    def getter_common(attribute, reload)
+      @virgin = false unless data_loading?
+      return if @destroyed
+      if @attributes.key? attribute
+        current_value = @attributes[attribute]
+        current_value.notify if current_value.is_a? Base::DummyValue
+        if reload
+          virtual_fetch_on_server_warning(attribute) if on_opal_server? && changed?
+          yield true, attribute
+        else
+          current_value
+        end
+      else
+        virtual_fetch_on_server_warning(attribute) if on_opal_server? && changed?
+        yield false, attribute
+      end.tap { |value| React::State.get_state(self, attribute) unless data_loading? }
+    end
+
+    def find_association(association, id)
+      inverse_of = association.inverse_of
+      instance = if id
+        find(association.klass, association.klass.primary_key => id)
+      else
+        new_from_vector(association.klass, nil, *vector, association.attribute)
+      end
+      instance_backing_record_attributes = instance.attributes
+      inverse_association = association.klass.reflect_on_association(inverse_of)
+      if inverse_association.collection?
+        instance_backing_record_attributes[inverse_of] = if id and id != ""
+          Collection.new(@model, instance, inverse_association, association.klass, ["find", id], inverse_of)
+        else
+          Collection.new(@model, instance, inverse_association, *vector, association.attribute, inverse_of)
+        end unless instance_backing_record_attributes[inverse_of]
+        instance_backing_record_attributes[inverse_of].replace [@ar_instance]
+      else
+        instance_backing_record_attributes[inverse_of] = @ar_instance
+      end unless association.through_association? || instance_backing_record_attributes.key?(inverse_of)
+      instance
+    end
+
+    def link_aggregate(attr, parent)
+      self.aggregate_owner = parent
+      self.aggregate_attribute = attr
+      @ar_instance
+    end
+  end
+end

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

@@ -14,12 +14,11 @@ module ReactiveRecord
         define_attribute_methods
         @outer_scopes = Set.new
         @fetch_scheduled = nil
-        @records = Hash.new { |hash, key| hash[key] = [] }
-        @class_scopes = Hash.new { |hash, key| hash[key] = {} }
+        initialize_lookup_tables
         if on_opal_client?
           @pending_fetches = []
           @pending_records = []
-          @last_fetch_at = Time.now
+          #@current_fetch_id = nil
           unless `typeof window.ReactiveRecordInitialData === 'undefined'`
             log(["Reactive record prerendered data being loaded: %o", `window.ReactiveRecordInitialData`])
             JSON.from_object(`window.ReactiveRecordInitialData`).each do |hash|
@@ -56,9 +55,9 @@ module ReactiveRecord
       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.when_on_server { @server_data_cache[klass, ["find_by", { attribute => value }], 'id'] }
+    isomorphic_method(:find_in_db) do |f, klass, attrs|
+      f.send_to_server klass.name, attrs if RUBY_ENGINE == 'opal'
+      f.when_on_server { @server_data_cache[klass, ['find_by', attrs], 'id'] }
     end
 
     class << self
@@ -128,50 +127,55 @@ module ReactiveRecord
     class << self
 
       attr_reader :pending_fetches
-      attr_reader :last_fetch_at
+      attr_reader :current_fetch_id
 
     end
 
     def self.schedule_fetch
-      React::State.set_state(WhileLoading, :quiet, false)  # moved from while loading module see loading! method
-      @fetch_scheduled ||= after(0) do
-        if @pending_fetches.count > 0  # during testing we might reset the context while there are pending fetches otherwise this would never normally happen
-          last_fetch_at = @last_fetch_at
-          @last_fetch_at = Time.now
-          pending_fetches = @pending_fetches.uniq
-          models, associations = gather_records(@pending_records, false, nil)
-          log(["Server Fetching: %o", pending_fetches.to_n])
-          start_time = `Date.now()`
-          Operations::Fetch.run(models: models, associations: associations, pending_fetches: pending_fetches)
-            .then do |response|
-              begin
-                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: #{`(Date.now() - fetch_time) / 1000`}s")
-                log(["       Returned: %o", response.to_n])
-                ReactiveRecord.run_blocks_to_load last_fetch_at
-              ensure
-                ReactiveRecord::WhileLoading.loaded_at last_fetch_at
-                ReactiveRecord::WhileLoading.quiet! if @pending_fetches.empty?
-              end
+      React::State.set_state(WhileLoading, :quiet, false) # moved from while loading module see loading! method
+      return if @fetch_scheduled
+      @current_fetch_id = Time.now
+      @fetch_scheduled = after(0) do
+        # Skip the fetch if there are no pending_fetches. This would never normally happen
+        # but during testing we might reset the context while there are pending fetches
+        next unless @pending_fetches.count > 0
+        saved_current_fetch_id = @current_fetch_id
+        saved_pending_fetches = @pending_fetches.uniq
+        models, associations = gather_records(@pending_records, false, nil)
+        log(["Server Fetching: %o", saved_pending_fetches.to_n])
+        start_time = `Date.now()`
+        Operations::Fetch.run(models: models, associations: associations, pending_fetches: saved_pending_fetches)
+        .then do |response|
+          begin
+            fetch_time = `Date.now()`
+            log("       Fetched in:   #{`(fetch_time - start_time)/ 1000`}s")
+            timer = after(0) do
+              log("       Processed in: #{`(Date.now() - fetch_time) / 1000`}s")
+              log(['       Returned: %o', response.to_n])
             end
-            .fail do |response|
-              log("Fetch failed", :error)
-              begin
-                ReactiveRecord.run_blocks_to_load(last_fetch_at, response)
-              ensure
-                ReactiveRecord::WhileLoading.quiet! if @pending_fetches.empty?
-              end
+            begin
+              ReactiveRecord::Base.load_from_json(response)
+            rescue Exception => e
+              `clearTimeout(#{timer})`
+              log("Unexpected exception raised while loading json from server: #{e}", :error)
             end
-          @pending_fetches = []
-          @pending_records = []
-          @fetch_scheduled = nil
+            ReactiveRecord.run_blocks_to_load saved_current_fetch_id
+          ensure
+            ReactiveRecord::WhileLoading.loaded_at saved_current_fetch_id
+            ReactiveRecord::WhileLoading.quiet! if @pending_fetches.empty?
+          end
         end
+        .fail do |response|
+          log("Fetch failed", :error)
+          begin
+            ReactiveRecord.run_blocks_to_load(saved_current_fetch_id, response)
+          ensure
+            ReactiveRecord::WhileLoading.quiet! if @pending_fetches.empty?
+          end
+        end
+        @pending_fetches = []
+        @pending_records = []
+        @fetch_scheduled = nil
       end
     end
 
@@ -241,13 +245,13 @@ module ReactiveRecord
         [models, associations, backing_records]
       end
 
-      def save(validate, force, &block)
+      def save_or_validate(save, validate, force, &block)
         if data_loading?
           sync!
-        elsif force or changed?
+        elsif force || changed?
           HyperMesh.load do
             ReactiveRecord.loads_pending! unless self.class.pending_fetches.empty?
-          end.then { save_to_server(validate, force, &block) }
+          end.then { send_save_to_server(save, validate, force, &block) }
           #save_to_server(validate, force, &block)
         else
           promise = Promise.new
@@ -257,46 +261,54 @@ module ReactiveRecord
         end
       end
 
-      def save_to_server(validate, force, &block)
+      def send_save_to_server(save, validate, force, &block)
         models, associations, backing_records = self.class.gather_records([self], force, self)
 
-        backing_records.each { |id, record| record.saving! }
+        begin
+          backing_records.each { |id, record| record.saving! } if save
 
-        promise = Promise.new
-        Operations::Save.run(models: models, associations: associations, validate: validate)
-        .then do |response|
-          begin
-            response[:models] = response[:saved_models].collect do |item|
-              backing_records[item[0]].ar_instance
-            end
+          promise = Promise.new
+          Operations::Save.run(models: models, associations: associations, save: save, validate: validate)
+          .then do |response|
+            begin
+              response[:models] = response[:saved_models].collect do |item|
+                backing_records[item[0]].ar_instance
+              end
 
-            if response[:success]
-              response[:saved_models].each do | item |
-                Broadcast.to_self backing_records[item[0]].ar_instance, item[2]
+              if save
+                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[: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
               end
-            else
-              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]
+                backing_records[item[0]].sync_unscoped_collection! if save
+                backing_records[item[0]].errors! item[3]
               end
-            end
-
-            response[:saved_models].each do | item |
-              backing_records[item[0]].sync_unscoped_collection!
-              backing_records[item[0]].errors! item[3]
-            end
-
-            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! }
+              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?
 
-          rescue Exception => e
-            log("Exception raised while saving - #{e}", :error)
+            rescue Exception => e
+              # debugger
+              log("Exception raised while saving - #{e}", :error)
+            ensure
+              backing_records.each { |_id, record| record.saved! rescue nil } if save
+            end
           end
+          promise
+        rescue Exception => e
+          backing_records.each { |_id, record| record.saved!(true) rescue nil } if save
         end
-        promise
       rescue Exception => e
+        # debugger
         log("Exception raised while saving - #{e}", :error)
         yield false, e.message, [] if block
         promise.resolve({success: false, message: e.message, models: []})
@@ -357,7 +369,7 @@ module ReactiveRecord
               method
             end
           end
-          reactive_records[model_to_save[:id]] = vectors[vector] = record = find_record(model, id, vector, save)
+          reactive_records[model_to_save[:id]] = vectors[vector] = record = find_record(model, id, vector, save) # ??? || validate ???
           if record and record.respond_to?(:id) and record.id
             # we have an already exising activerecord model
             keys = record.attributes.keys
@@ -447,27 +459,28 @@ module ReactiveRecord
 
           saved_models = reactive_records.collect do |reactive_record_id, model|
             #puts "saving rr_id: #{reactive_record_id} model.object_id: #{model.object_id} frozen? <#{model.frozen?}>"
-            if model and (model.frozen? or dont_save_list.include?(model) or model.changed.include?(model.class.primary_key))
+            next unless model
+            if !save|| model.frozen? || dont_save_list.include?(model) || model.changed.include?(model.class.primary_key)
               # the above check for changed including the private key happens if you have an aggregate that includes its own id
-              #puts "validating frozen model #{model.class.name} #{model} (reactive_record_id = #{reactive_record_id})"
+              # puts "validating frozen model #{model.class.name} #{model} (reactive_record_id = #{reactive_record_id})"
               valid = model.valid?
-              #puts "has_errors before = #{has_errors}, validate= #{validate}, !valid= #{!valid}  (validate and !valid) #{validate and !valid}"
+              # 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}"
+              # 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})"
+              [reactive_record_id, model.class.name, model.__hyperloop_secure_attributes(acting_user), (valid ? nil : model.errors.messages)]
+            elsif !model.id || 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]
+              # puts "saved complete errors = <#{!saved}>, #{messages} has_errors #{has_errors}"
+              [reactive_record_id, model.class.name, model.__hyperloop_secure_attributes(acting_user), messages]
             end
           end.compact
 
-          if has_errors
+          if has_errors && save
             ::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|
@@ -477,12 +490,11 @@ module ReactiveRecord
             raise "HyperModel saving records failed!"
           end
 
-          if save
+          if save || validate
 
             {success: true, saved_models: saved_models }
 
           else
-
             # vectors.each { |vector, model| model.reload unless model.nil? or model.new_record? or model.frozen? }
             vectors