volt-repo_cache 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 474923d9b6d0aea6afc647e672160d1f253105a6
-  data.tar.gz: 08ba0695263b36cdf2280d9b8e30f60205bc3eb1
+  metadata.gz: d6e67fb69f5462671adbe6c70c7d88ff76156bc7
+  data.tar.gz: b7dacb4047656a539f2cc858f5ae88f955185d0a
 SHA512:
-  metadata.gz: 54f2267798305375f6906383145ed98815b6f90e3227eb0030a8fab82cf5f46653ce6c9909835ae91f9b700276ad94930d0c6ebbfce640c210bb7ab6f8670268
-  data.tar.gz: 885be0b3b42845d30c497de78b0201643708e26b4bed691d981f4117e3cce722b666bddf70788afe9e2a76676efe9cc8adae66983f7ba6b9f599641c518651f4
+  metadata.gz: a6438cc77fd305a203677d88ae2805a538fcebb3c672ea1a8e4ad735c1631f191557ca47a4102508692a3786c5e8584c19b94d11637cdf3de6714fb9038b7257
+  data.tar.gz: de00eae7965eb73757fcd19154fab9c8159e345355ecbef617d2af9091158c9ae061f5bfeec206a45887c9a428dfd9933e0e7147edc847cacaa117ead803f748

data/lib/volt/repo_cache/association.rb

@@ -58,13 +58,10 @@ module Volt
       # foreign_collection being lazily initialized.
       def reciprocal
         unless @reciprocal
-          # debug __method__, __LINE__, ""
           @reciprocal = foreign_collection.associations.values.detect do |a|
-            # debug __method__, __LINE__, "#{a.foreign_collection.name} ?==? #{local_collection.name}"
             a.foreign_collection.name == local_collection.name
           end
           @reciprocal = :nil unless @reciprocal
-          # debug __method__, __LINE__, "reciprocal of #{self.inspect} is #{@reciprocal.inspect}"
         end
         @reciprocal == :nil ? nil : @reciprocal
       end

data/lib/volt/repo_cache/cache.rb

@@ -36,7 +36,6 @@ module Volt
       # read_only should be inherited by has_... targets
       #
       def initialize(**options)
-        # debug __method__, __LINE__, "@options = #{@options}"
         @repo = options.delete(:repo) || Volt.current_app.store
         @collection_options = options.delete(:collections) || {}
         load
@@ -62,7 +61,6 @@ module Volt
       def clear
         # debug __method__, __LINE__
         @collections.each do |name, collection|
-          # debug __method__, __LINE__, "name=#{name} collection=#{collection}"
           collection.send(:uncache)
         end
         @collections = {}
@@ -90,20 +88,13 @@ module Volt
         promises = []
         @collection_options.each do |given_name, options|
           name = collection_name(given_name)
-          # debug __method__, __LINE__
           collection = Collection.new(cache: self, name: name, options: options)
-          # debug __method__, __LINE__
           @collections[name] = collection
           promises << collection.loaded
         end
-        # debug __method__, __LINE__, "promises.size = #{promises.size}"
-        t1 = Time.now
         @loaded = Promise.when(*promises).then do
-          # t2 = Time.now
-          # debug __method__, __LINE__, "@@loaded = Promise.when(*promises).then took #{t2-t1} seconds"
           self
         end
-        # debug __method__, __LINE__, "@loaded => #{@loaded.class.name}:#{@loaded.value.class.name}"
       end
 
       def collection_name(given_name)

data/lib/volt/repo_cache/collection.rb

@@ -13,16 +13,14 @@ module Volt
       attr_reader :model_class
       attr_reader :repo_collection
       attr_reader :load_query
-      attr_reader :loaded_ids
+      attr_reader :cached_ids
       attr_reader :loaded # Promise
       attr_reader :marked_for_destruction
       attr_reader :associations
       attr_reader :read_only
 
       def initialize(cache: nil, name: nil, options: {})
-        # debug __method__, __LINE__, "name: #{name} options: #{options}"
         super(observer: self)
-        # debug __method__, __LINE__
         @cache = cache
         @name = name
         @load_query = options[:query] || options[:where]
@@ -33,7 +31,6 @@ module Volt
         @repo_collection = @cache.repo.send(name)
         init_associations(options)
         load
-        # debug __method__, __LINE__
       end
 
       # hide circular reference to cache
@@ -70,7 +67,7 @@ module Volt
         append(hash.to_h)
       end
 
-      # Appends a model to the collection.
+      # Appends a new model to the collection.
       # Model may be a hash which will be converted.
       # (See #induct for more.)
       # If the model belongs_to any other owners, the foreign id(s)
@@ -78,8 +75,8 @@ module Volt
       # in the cache - it is easier to ask the owner for a new
       # instance (e.g. product.recipe.new_ingredient).
       # NB: Returns the newly appended model.
-      def append(model, error_if_present: true, error_unless_new: true,  notify: true)
-        model = induct(model, error_unless_new: error_unless_new, error_if_present: error_if_present)
+      def append(model, notify: true)
+        model = induct(model, loaded_from_repo: false)
         __append__(model, notify: notify)
         model
       end
@@ -123,7 +120,7 @@ module Volt
       # Remove model from marked_for_destruction bucket.
       # Don't worry if we can't find it.
       def destroyed(model)
-        @loaded_ids.delete(model.id)
+        @cached_ids.delete(model.id)
         @marked_for_destruction.delete(model.id)
       end
 
@@ -131,17 +128,13 @@ module Volt
       # that a model has been added or removed. Pass
       # this on to associations.
       def observe(action, model)
-        # debug __method__, __LINE__, "action=#{action} model=#{model} associations=#{associations}"
         # notify owner model(s) of appended model that it has been added
         notify_associations(action, model)
       end
 
       def notify_associations(action, model)
-        # debug __method__, __LINE__, "action=#{action} model=#{model} associations=#{associations}"
         associations.each_value do |assoc|
-          # debug __method__, __LINE__, "calling notify_associates(#{assoc}, #{action}, #{model})"
           notify_associates(assoc, action, model)
-          # debug __method__, __LINE__, "called notify_associates(#{assoc}, #{action}, #{model})"
         end
       end
 
@@ -152,22 +145,17 @@ module Volt
       # association may be owner customer - thus
       # association will be belongs_to
       def notify_associates(assoc, action, model)
-        # debug __method__, __LINE__, "action=#{action} model=#{model} assoc=#{assoc} reciprocate=#{assoc.reciprocal}"
         if assoc.reciprocal
           local_id = model.send(assoc.local_id_field)
-          # debug __method__, __LINE__, "local_id #{assoc.local_id_field}=#{local_id}"
           if local_id # may not be set yet
             assoc.foreign_collection.each do |other|
-              # debug __method__, __LINE__, "calling #{assoc.foreign_id_field} on #{other}"
               foreign_id = other.send(assoc.foreign_id_field)
               if local_id == foreign_id
-                # debug __method__, __LINE__, "foreign_id==local_id of #{other}, calling other.refresh_association(#{assoc.foreign_name})"
                 other.send(:refresh_association, assoc.reciprocal)
               end
             end
           end
         end
-        # debug __method__, __LINE__
       end
 
       # 'Induct' a model into the cache via this collection.
@@ -193,66 +181,64 @@ module Volt
       #   associational integrity in the cache.
       #
       # Returns the inducted model.
-      def induct(model_or_hash, error_unless_new: true, error_if_present: true)
-        created_in_cache = false
-        if model_or_hash.is_a?(Hash)
-          created_in_cache = true
-          model = model_class.new(model_or_hash, options: {persistor: cache.persistor})
-        else
-          model = model_or_hash
-          # unless model.persistor.class == cache.persistor.class
-          #   raise RuntimeError, "model persistor is #{model.persistor} but should be #{cache.persistor}"
-          # end
-          unless model.class == model_class
-            raise ArgumentError, "#{model} must be a #{model_class_name}"
-          end
-          if error_unless_new && (!model.created_in_cache? || model.new?)
-            raise ArgumentError, "#{model} must be new (not stored) or have been created in cache"
+      def induct(model_or_hash, loaded_from_repo: false)
+        model = if Hash === model_or_hash
+          if loaded_from_repo
+            raise TypeError, "cannot induct stored model from a hash #{model_or_hash}"
           end
-          if error_if_present && @loaded_ids.include?(model.id)
-            raise RuntimeError, "cannot add #{model} already in cached collection"
+          model_class.new(model_or_hash, options: {persistor: cache.persistor})
+        else
+          if !loaded_from_repo && model_or_hash.buffer?
+            raise TypeError, "cannot induct new model_or_hash #{model_or_hash} with buffer"
           end
+          model_or_hash
+        end
+        unless model.class == model_class
+          raise ArgumentError, "#{model} must be a #{model_class_name}"
+        end
+        if model.cached?
+          __debug __method__, __LINE__, "id=#{model.id} model.cached?=#{model.cached?}"
+          raise TypeError, "model.id #{model.id} already in cache"
         end
-        @loaded_ids << model.id
-        patch_for_cache(model, created_in_cache)
+        @cached_ids << model.id
+        RepoCache::Model.induct_to_cache(model, self, loaded_from_repo)
         model
       end
 
+      def cached?(model)
+        @cached_ids.include?(model.id)
+      end
+
       def load
-        # debug __method__, __LINE__
-        @loaded_ids = Set.new  # append/delete will update
+        @cached_ids = Set.new  # append/delete will update
         q = @load_query ? repo_collection.where(@load_query) : repo_collection
-        # t1 = Time.now
         @loaded = q.all.collect{|e|e}.then do |models|
-          # t2 = Time.now
-          # debug __method__, __LINE__, "#{name} read_only=#{read_only} query promise resolved to #{models.size} models in #{t2-t1} seconds"
-          models.each do |model|
-            append(read_only ? model : model.buffer, error_unless_new: false, notify: false)
+          models.each do |_model|
+            model = read_only ? _model : _model.buffer
+            induct(model, loaded_from_repo: true)
+            __append__(model, notify: false)
           end
-          # t3 = Time.now
-          # debug __method__, __LINE__, "#{name} loaded ids for #{models.size} #{name} in #{t3-t2} seconds"
           self
         end
-        # debug __method__, __LINE__, "@loaded => #{@loaded.class.name}:#{@loaded.value.class.name}"
       end
 
       def init_associations(options)
-        # debug __method__, __LINE__, "options = #{options}"
         @associations = {}
         [:belongs_to, :has_one, :has_many].each do |type|
           arrify(options[type]).map(&:to_sym).each do |foreign_name|
             @associations[foreign_name] = Association.new(self, foreign_name, type)
-            # debug __method__, __LINE__, "@associations[#{foreign_name}] = #{@associations[foreign_name].inspect}"
           end
         end
       end
 
-      def patch_for_cache(model, created_in_cache)
-        unless model.respond_to?(:patched_for_cache?)
-          RepoCache::Model.patch_for_cache(model, self, created_in_cache)
-        end
-        model
-      end
+      def __debug(method, line, msg = nil)
+         s = "{__FILE__}[#{line}]:#{self.class.name}##{method}: #{msg}"
+         if RUBY_PLATFORM == 'opal'
+           Volt.logger.debug s
+         else
+           puts s
+         end
+       end
 
     end
   end

data/lib/volt/repo_cache/model.rb

@@ -4,19 +4,31 @@
 # methods to the module and provides
 # the instance as argument.
 
+module Volt
+  class Model
+    def stored?
+      false
+    end
+
+    def cached?
+      false
+    end
+  end
+end
+
 module Volt
   module RepoCache
     module Model
       extend Volt::RepoCache::Util
 
-      def self.patch_for_cache(model, collection, created_in_cache)
-        # debug __method__, __LINE__, "patch_for_cache [#{collection.name}] : #{model.to_h}"
+      def self.induct_to_cache(model, collection, loaded_from_repo)
+        # debug_model __method__, __LINE__, "patch_for_cache [#{collection.name}] : #{model.to_h}"
 
         # Volt sets @new to false if any attribute changes - not what we want
-        model.instance_variable_set(:@__cache__created_in_cache, created_in_cache)
-        model.instance_variable_set(:@__cache__collection, collection)
-        model.instance_variable_set(:@__cache__associations, {})
-        model.instance_variable_set(:@__cache__marked_for_destruction, false)
+        model.instance_variable_set(:@cache__stored, loaded_from_repo)
+        model.instance_variable_set(:@cache__collection, collection)
+        model.instance_variable_set(:@cache__associations, {})
+        model.instance_variable_set(:@cache__marked_for_destruction, false)
         # TODO: if model is not buffered, then trap all
         # field set value methods and raise exception -
         # unless buffered the model is read only.
@@ -47,7 +59,7 @@ module Volt
           # e.g. product.recipe
           m = foreign_name
           model.define_singleton_method(m) do
-            # debug __method__, __LINE__, "defining #{model.class.name}##{m}"
+            # debug_model __method__, __LINE__, "defining #{model.class.name}##{m}"
             get_association(assoc)
           end
 
@@ -99,34 +111,38 @@ module Volt
           true
         end
 
-        def model.created_in_cache?
-          @__cache__created_in_cache
+        def model.stored?
+          @cache__stored
         end
 
         # Returns true if the model has been marked
         # for destruction on flush. Otherwise false.
         def model.marked_for_destruction?
-          @__cache__marked_for_destruction
+          @cache__marked_for_destruction
+        end
+
+        def model.cached?
+          @cache__collection.cached?(self)
         end
 
         # Returns the cached collected the model belongs to.
         def model.collection
-          @__cache__collection
+          @cache__collection
         end
 
         # Returns the cache the model belongs to.
         def model.cache
-          @__cache__collection.cache
+          @cache__collection.cache
         end
 
         # Hide circular reference to collection
         # when doing inspection.
         def model.inspect
-          if @__cache__collection
-            __tmp = @__cache__collection
-            @__cache__collection = "{{#{@__cache__collection.name}}}"
+          if @cache__collection
+            __tmp = @cache__collection
+            @cache__collection = "{{#{@cache__collection.name}}}"
             result = super
-            @__cache__collection = __tmp
+            @cache__collection = __tmp
             result
           else
             super
@@ -147,10 +163,10 @@ module Volt
             # prevent collection going in circles on this
             # (we don't know whether initial request was to
             # self or to collection which holds self)
-            unless @__cache__marked_for_destruction
-              # debug __method__, __LINE__, "marking #{self} for destruction"
-              @__cache__marked_for_destruction = true
-              @__cache__collection.send(:mark_model_for_destruction, self)
+            unless @cache__marked_for_destruction
+              # debug_model __method__, __LINE__, "marking #{self} for destruction"
+              @cache__marked_for_destruction = true
+              @cache__collection.send(:mark_model_for_destruction, self)
               mark_associations_for_destruction
             end
           end
@@ -173,22 +189,23 @@ module Volt
           # - any part of it may fail without unwinding the whole
           def model.flush!
             fail_if_read_only(__method__)
-            if @__cache__marked_for_destruction
-              # debug __method__, __LINE__, "marked for destruction so call destroy on #{to_h}"
+            if @cache__marked_for_destruction
+              # debug_model __method__, __LINE__, "marked for destruction so call destroy on #{to_h}"
               __destroy__
             else
-              if @__cache__created_in_cache || dirty?
-                # debug __method__, __LINE__, "is dirty: #{to_h}"
-                if @__cache__created_in_cache
-                  # debug __method__, __LINE__, "new: #{self.class.name}::#{self.id}"
-                  @__cache__created_in_cache = false
-                  @__cache__collection.repo_collection << self
-                else
-                  # debug __method__, __LINE__,"dirty: #{self.class.name}::#{self.id}"
+              if dirty?
+                debug_model __method__, __LINE__, "@cache__stored=#{@cache__stored} dirty?=#{dirty?} to_h=#{to_h}"
+                if stored?
+                  # debug_model __method__, __LINE__,"dirty: #{self.class.name}::#{self.id}"
                   __save__
+                else
+                  debug_model __method__, __LINE__, "<< to repo: #{self.class.name}::#{self.to_h}"
+                  @cache__stored = true
+                  @cache__collection.repo_collection << self
+                  # TODO: big problem! once new model saved it should become buffer in cache!
                 end
               else
-                # debug __method__, __LINE__, "not dirty: #{to_h}"
+                # debug_model __method__, __LINE__, "not dirty: #{to_h}"
                 # neither new nor dirty but
                 # stay in the promise chain
                 Promise.value(self)
@@ -208,7 +225,8 @@ module Volt
             self.class.fields_data.keys.each do |field|
               return true if changed?(field)
             end
-            @__cache__created_in_cache
+            # if not stored then I'm dirty
+            !@cache__stored
           end
 
           # Destroys (deletes) the model in database.
@@ -252,7 +270,7 @@ module Volt
         # #######################################
 
         def model.fail_if_read_only(what)
-          if @__cache__collection.read_only
+          if @cache__collection.read_only
             raise RuntimeError, "cannot #{what} for read only cache collection/model"
           end
         end
@@ -260,26 +278,26 @@ module Volt
 
         # private
         def model.uncache
-          @__cache__associations.clear if @__cache__associations
+          @cache__associations.clear if @cache__associations
           if false
             instance_variables.each do |v|
               if v.to_s =~ /__cache__/
-                # debug __method__, __LINE__, "removing instance variable '#{v}'"
+                # debug_model __method__, __LINE__, "removing instance variable '#{v}'"
                 set_instance_variable(v, nil)
               end
             end
           elsif false
-            @__cache__associations.clear if @__cache__associations
+            @cache__associations.clear if @cache__associations
             instance_variables.each do |v|
               if v.to_s =~ /__cache__/
-                # debug __method__, __LINE__, "removing instance variable '#{v}'"
+                # debug_model __method__, __LINE__, "removing instance variable '#{v}'"
                 remove_instance_variable(v)
               end
             end
             # WARNING - assumes no singleton methods other than those we've attached
             singleton_methods.each do |m|
-              unless m == :debug || m == :uncache
-                # debug __method__, __LINE__, "removing singleton method '#{m}'"
+              unless m == :debug_model || m == :uncache
+                # debug_model __method__, __LINE__, "removing singleton method '#{m}'"
                 @@___m___ = m # m is out of scope in class << self TODO: anything nicer?
                 class << self # weird syntax to remove singleton method
                   remove_method(@@___m___)
@@ -288,7 +306,7 @@ module Volt
             end
             @@___m___ = nil
             class << self
-              remove_method(:debug)
+              remove_method(:debug_model)
               remove_method(:uncache)
             end
           end
@@ -302,10 +320,10 @@ module Volt
         #
         # Raise error unless caller's class namespace is Volt::RepoCache.
         def model.refresh_association(association)
-          # debug __method__, __LINE__, "association=#{association.foreign_name}"
+          # debug_model __method__, __LINE__, "association=#{association.foreign_name}"
           # refresh the association query
           result = get_association(association, refresh: true)
-          # debug __method__, __LINE__, "#{self} association=#{association} result=#{result}"
+          # debug_model __method__, __LINE__, "#{self} association=#{association} result=#{result}"
         end
         model.singleton_class.send(:private, :refresh_association)
 
@@ -322,22 +340,22 @@ module Volt
         # (e.g. console) running.
         # Returns a promise with destroyed model proxy as value.
         def model.__destroy__
-          # debug __method__, __LINE__
+          # debug_model __method__, __LINE__
           fail_if_read_only(__method__)
-          # debug __method__, __LINE__
-          promise = if created_in_cache? || new?
-            Promise.value(self)
-          else
+          # debug_model __method__, __LINE__
+          promise = if stored?
             destroy(caller: self)
+          else
+            Promise.value(self)
           end
-          # debug __method__, __LINE__
+          # debug_model __method__, __LINE__
           promise.then do |m|
-            # debug __method__, __LINE__, "destroy promise resolved to #{m}"
-            @__cache__collection.destroyed(self)
+            # debug_model __method__, __LINE__, "destroy promise resolved to #{m}"
+            @cache__collection.destroyed(self)
             uncache
             self
           end.fail do |errors|
-            # debug __method__, __LINE__, "destroy failed => #{errors}"
+            # debug_model __method__, __LINE__, "destroy failed => #{errors}"
             errors
           end
         end
@@ -355,23 +373,23 @@ module Volt
         # Relies on cached collections notifying
         # associated models when to refresh.
         def model.get_association(assoc, refresh: false)
-          # debug __method__, __LINE__, "#{self.class.name}:#{id} assoc=#{assoc.foreign_name} refresh: #{refresh}"
+          # debug_model __method__, __LINE__, "#{self.class.name}:#{id} assoc=#{assoc.foreign_name} refresh: #{refresh}"
           foreign_name = assoc.foreign_name
-          @__cache__associations[foreign_name] = nil if refresh
-          prior = @__cache__associations[foreign_name]
+          @cache__associations[foreign_name] = nil if refresh
+          prior = @cache__associations[foreign_name]
           local_id = self.send(assoc.local_id_field)
           foreign_id_field = assoc.foreign_id_field
-          # debug __method__, __LINE__, "foreign_id_field=#{foreign_id_field}"
+          # debug_model __method__, __LINE__, "foreign_id_field=#{foreign_id_field}"
           result = if prior && match?(prior, foreign_id_field, local_id)
             prior
           else
             q = {foreign_id_field => local_id}
-            # debug __method__, __LINE__
+            # debug_model __method__, __LINE__
             r = assoc.foreign_collection.query(q) || []
-            # debug __method__, __LINE__
-            @__cache__associations[foreign_name] = assoc.has_many? ? ModelArray.new(contents: r) : r.first
+            # debug_model __method__, __LINE__
+            @cache__associations[foreign_name] = assoc.has_many? ? ModelArray.new(contents: r) : r.first
           end
-          # debug __method__, __LINE__
+          # debug_model __method__, __LINE__
           result
         end
         model.singleton_class.send(:private, :get_association)
@@ -434,7 +452,7 @@ module Volt
         # has_many then any prior associated values
         # will be marked for destruction.
         #
-        # NB we don't immediately update local @__cache__associations,
+        # NB we don't immediately update local @cache__associations,
         # but wait to be notified by associated collections
         # of changes we make to them. This ensures that
         # if changes are made to those collections that
@@ -536,11 +554,11 @@ module Volt
           fail_if_read_only(__method__)
           validate_ownership(assoc, other, require_foreign_id: false) do |prior_foreign_id|
             # after validation we can be sure prior_foreign_id == self.id
-            # debug __method__, __LINE__
+            # debug_model __method__, __LINE__
             unless prior_foreign_id
               other.send(Util.setter(assoc.foreign_id_field), id)
             end
-            # debug __method__, __LINE__
+            # debug_model __method__, __LINE__
           end
         end
         model.singleton_class.send(:private, :set_foreign_id)
@@ -572,9 +590,9 @@ module Volt
         # if it does not match this model's id. Otherwise return true
         # if the foreign id is not nil. Yield to given block if provided.
         def model.validate_ownership(assoc, other, require_foreign_id: true, &block)
-          # debug __method__, __LINE__
+          # debug_model __method__, __LINE__
           foreign_id = other.send(assoc.foreign_id_field)
-          # debug __method__, __LINE__
+          # debug_model __method__, __LINE__
           if (foreign_id && foreign_id != self.id) || (require_foreign_id && foreign_id.nil?)
             raise RuntimeError, "#{other} should belong to #{self} or no-one else"
           end
@@ -617,15 +635,15 @@ module Volt
         # from flushing associates.
         def model.flush_associations
           promises = []
-          @__cache__collection.associations.values.each do |assoc|
+          @cache__collection.associations.values.each do |assoc|
             if assoc.has_any?
-              # debug __method__, __LINE__, "association => '#{association}'"
+              # debug_model __method__, __LINE__, "association => '#{association}'"
               model_or_array = send(assoc.foreign_name)
-              # debug __method__, __LINE__, "model_or_array => '#{model_or_array}'"
+              # debug_model __method__, __LINE__, "model_or_array => '#{model_or_array}'"
               Util.arrify(model_or_array).each do |model|
                 promises << model.flush!
               end
-              # debug __method__, __LINE__
+              # debug_model __method__, __LINE__
             end
           end
           Promise.when(*promises)
@@ -636,31 +654,31 @@ module Volt
         # Marks all has_one or has_many models for destruction
         def model.mark_associations_for_destruction
           fail_if_read_only(__method__)
-          @__cache__collection.associations.values.each do |assoc|
+          @cache__collection.associations.values.each do |assoc|
             if assoc.has_any?
-              # debug __method__, __LINE__, "association => '#{association}'"
+              # debug_model __method__, __LINE__, "association => '#{association}'"
               model_or_array = send(assoc.foreign_name)
               if model_or_array
-                # debug __method__, __LINE__, "model_or_array => '#{model_or_array}'"
+                # debug_model __method__, __LINE__, "model_or_array => '#{model_or_array}'"
                 Util.arrify(model_or_array).each do |model|
                   model.mark_for_destruction!
                 end
-                # debug __method__, __LINE__
+                # debug_model __method__, __LINE__
               end
             end
           end
         end
         model.singleton_class.send(:private, :mark_associations_for_destruction)
 
-        def model.debug(method, line, msg = nil)
-          s = ">>> #{self.class.name}##{method}[#{line}] : #{msg}"
+        def model.debug_model(method, line, msg = nil)
+          s = "#{__FILE__}[#{line}]:#{self.class.name}##{method}: #{msg}"
           if RUBY_PLATFORM == 'opal'
             Volt.logger.debug s
           else
             puts s
           end
         end
-        model.singleton_class.send(:private, :debug)
+        model.singleton_class.send(:private, :debug_model)
 
       end
 

data/lib/volt/repo_cache/model_array.rb

@@ -160,12 +160,9 @@ module Volt
       def __remove__(model, error_if_absent: true)
         index = index {|e| e.id == model.id }
         if index
-          result = __delete_at__(index)
-          # debug __method__, __LINE__, "deleted #{result.class.name} #{result.id}"
-          result
+          __delete_at__(index)
         elsif error_if_absent
           msg = "could not find #{model.class.name} with id #{model.id} to delete"
-          # debug __method__, __LINE__, msg
           raise RuntimeError, msg
         end
       end

data/lib/volt/repo_cache/util.rb

@@ -57,20 +57,11 @@ module Volt
         end
       end
 
-      def debug(method, line, msg = nil)
-        s = ">>> #{self.class.name}##{method}[#{line}] : #{msg}"
-        if RUBY_PLATFORM == 'opal'
-          Volt.logger.debug s
-        else
-          puts s
-        end
-      end
-
       def time(method, line, msg = nil)
         t1 = Time.now
         r = yield
         t2 = Time.now
-        debug(method, line, "#{msg} : took #{t2 - t1} seconds")
+        debug 1, ->{['nil file', line, method, "#{msg} : took #{t2 - t1} seconds"]}
         r
       end
     end

data/lib/volt/repo_cache/version.rb

@@ -1,5 +1,5 @@
 module Volt
   module RepoCache
-    VERSION = "0.1.6"
+    VERSION = "0.1.7"
   end
 end

data/volt-repo_cache.gemspec

@@ -18,21 +18,4 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "volt", "~> 0.9.6"
-  spec.add_development_dependency "rake"
-
-  # Testing gems
-  spec.add_development_dependency 'rspec', '~> 3.2.0'
-  spec.add_development_dependency 'opal-rspec', '~> 0.4.2'
-  spec.add_development_dependency 'capybara', '~> 2.4.4'
-  spec.add_development_dependency 'selenium-webdriver', '~> 2.47.0'
-  spec.add_development_dependency 'chromedriver-helper', '~> 1.0.0'
-  spec.add_development_dependency 'poltergeist', '~> 1.6.0'
-
-  # Gems to run the dummy app
-  spec.add_development_dependency 'volt-mongo', '0.1.1'
-  spec.add_development_dependency 'volt-bootstrap', '~> 0.1.0'
-  spec.add_development_dependency 'volt-bootstrap_jumbotron_theme', '~> 0.1.0'
-  spec.add_development_dependency 'volt-user_templates', '~> 0.4.0'
-  spec.add_development_dependency 'thin', '~> 1.6.0'
 end

metadata

@@ -1,197 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: volt-repo_cache
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Colin Gunn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-03 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: volt
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.9.6
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.9.6
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 3.2.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 3.2.0
-- !ruby/object:Gem::Dependency
-  name: opal-rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.4.2
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.4.2
-- !ruby/object:Gem::Dependency
-  name: capybara
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.4.4
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.4.4
-- !ruby/object:Gem::Dependency
-  name: selenium-webdriver
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.47.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.47.0
-- !ruby/object:Gem::Dependency
-  name: chromedriver-helper
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.0.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.0.0
-- !ruby/object:Gem::Dependency
-  name: poltergeist
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.6.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.6.0
-- !ruby/object:Gem::Dependency
-  name: volt-mongo
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.1.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.1.1
-- !ruby/object:Gem::Dependency
-  name: volt-bootstrap
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.1.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.1.0
-- !ruby/object:Gem::Dependency
-  name: volt-bootstrap_jumbotron_theme
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.1.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.1.0
-- !ruby/object:Gem::Dependency
-  name: volt-user_templates
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.4.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.4.0
-- !ruby/object:Gem::Dependency
-  name: thin
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.6.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.6.0
+date: 2016-04-28 00:00:00.000000000 Z
+dependencies: []
 description: Cache multiple collections or query based subsets from any Volt repository.
   Provides faster and simpler client-side processing. Reduces the burden of promise
   handling. Changes - updates, creates and destroys - can be saved (flushed) back