zermelo 1.0.0

data/lib/zermelo/associations/belongs_to.rb

@@ -0,0 +1,115 @@
+# The other side of a has_one, has_many, or has_sorted_set association
+
+module Zermelo
+  module Associations
+    class BelongsTo
+
+      # NB a single instance of this class doesn't need to care about the hash
+      # used for storage, that should be done in the save method of the parent
+
+      def initialize(parent, name)
+        @parent = parent
+        @name   = name
+
+        @backend = parent.send(:backend)
+
+        @record_ids_key = Zermelo::Records::Key.new(
+          :klass  => parent.class.send(:class_key),
+          :id     => parent.id,
+          :name   => 'belongs_to',
+          :type   => :hash,
+          :object => :association
+        )
+
+        parent.class.send(:with_association_data, name.to_sym) do |data|
+          @associated_class = data.data_klass
+          @lock_klasses     = [data.data_klass] + data.related_klasses
+          @inverse          = data.inverse
+          @callbacks        = data.callbacks
+        end
+
+        raise ':inverse_of must be set' if @inverse.nil?
+        @inverse_key = "#{name}_id"
+      end
+
+      def value=(record)
+        if record.nil?
+          @parent.class.lock(*@lock_klasses) do
+            r = @associated_class.send(:load, @backend.get(@record_ids_key)[@inverse_key.to_s])
+            bc = @callbacks[:before_clear]
+            if bc.nil? || !@parent.respond_to?(bc) || !@parent.send(bc, r).is_a?(FalseClass)
+              new_txn = @backend.begin_transaction
+              @backend.delete(@record_ids_key, @inverse_key)
+              @backend.commit_transaction if new_txn
+              ac = @callbacks[:after_clear]
+              @parent.send(ac, r) if !ac.nil? && @parent.respond_to?(ac)
+            end
+          end
+        else
+          raise 'Invalid record class' unless record.is_a?(@associated_class)
+          raise 'Record must have been saved' unless record.persisted?
+          @parent.class.lock(*@lock_klasses) do
+            bs = @callbacks[:before_set]
+            if bs.nil? || !@parent.respond_to?(bs) || !@parent.send(bs, r).is_a?(FalseClass)
+              new_txn = @backend.begin_transaction
+              @backend.add(@record_ids_key, @inverse_key => record.id)
+              @backend.commit_transaction if new_txn
+              as = @callbacks[:after_set]
+              @parent.send(as, record) if !as.nil? && @parent.respond_to?(as)
+            end
+          end
+        end
+      end
+
+      def value
+        @parent.class.lock(*@lock_klasses) do
+          # FIXME uses hgetall, need separate getter for hash/list/set
+          if id = @backend.get(@record_ids_key)[@inverse_key.to_s]
+          # if id = @backend.get_hash_value(@record_ids_key, @inverse_key.to_s)
+            @associated_class.send(:load, id)
+          else
+            nil
+          end
+        end
+      end
+
+      private
+
+      # on_remove already runs inside a lock & transaction
+      def on_remove
+        unless value.nil?
+          assoc = value.send("#{@inverse}_proxy".to_sym)
+          if assoc.respond_to?(:delete)
+            assoc.send(:delete, @parent)
+          elsif assoc.respond_to?(:value=)
+            assoc.send(:value=, nil)
+          end
+        end
+        @backend.clear(@record_ids_key)
+      end
+
+      def self.associated_ids_for(backend, class_key, name, inversed, *these_ids)
+        these_ids.each_with_object({}) do |this_id, memo|
+          key = Zermelo::Records::Key.new(
+            :klass  => class_key,
+            :id     => this_id,
+            :name   => 'belongs_to',
+            :type   => :hash,
+            :object => :association
+          )
+
+          assoc_id = backend.get(key)["#{name}_id"]
+          # assoc_id = backend.get_hash_value(key, "#{name}_id")
+
+          if inversed
+            memo[assoc_id] ||= []
+            memo[assoc_id] << this_id
+          else
+            memo[this_id] = assoc_id
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/zermelo/associations/class_methods.rb

@@ -0,0 +1,244 @@
+require 'zermelo/associations/association_data'
+require 'zermelo/associations/index_data'
+
+require 'zermelo/associations/belongs_to'
+require 'zermelo/associations/has_and_belongs_to_many'
+require 'zermelo/associations/has_many'
+require 'zermelo/associations/has_one'
+require 'zermelo/associations/has_sorted_set'
+require 'zermelo/associations/index'
+require 'zermelo/associations/unique_index'
+
+# NB: this module gets mixed in to Zermelo::Record as class methods
+
+# TODO update other side of associations without having to load the record (?)
+# TODO callbacks on before/after add/delete on association?
+
+module Zermelo
+  module Associations
+    module ClassMethods
+
+      protected
+
+      # used by classes including a Zermelo Record to set up
+      # indices and associations
+      def index_by(*args)
+        att_types = attribute_types
+        args.each do |arg|
+          index(::Zermelo::Associations::Index, arg, :type => att_types[arg])
+        end
+        nil
+      end
+
+      def unique_index_by(*args)
+        att_types = attribute_types
+        args.each do |arg|
+          index(::Zermelo::Associations::UniqueIndex, arg, :type => att_types[arg])
+        end
+        nil
+      end
+
+      def has_many(name, args = {})
+        associate(::Zermelo::Associations::HasMany, name, args)
+        nil
+      end
+
+      def has_one(name, args = {})
+        associate(::Zermelo::Associations::HasOne, name, args)
+        nil
+      end
+
+      def has_sorted_set(name, args = {})
+        associate(::Zermelo::Associations::HasSortedSet, name, args)
+        nil
+      end
+
+      def has_and_belongs_to_many(name, args = {})
+        associate(::Zermelo::Associations::HasAndBelongsToMany, name, args)
+        nil
+      end
+
+      def belongs_to(name, args = {})
+        associate(::Zermelo::Associations::BelongsTo, name, args)
+        nil
+      end
+      # end used by client classes
+
+      # used internally by other parts of Zermelo to implement the above
+      # configuration
+
+      # Works out which classes should be locked when updating associations
+      # TODO work out if this can be replaced by 'related_klasses' assoc data
+      def associated_classes(visited = [], cascade = true)
+        visited |= [self]
+        return visited unless cascade
+        @lock.synchronize do
+          @association_data ||= {}
+          @association_data.values.each do |data|
+            klass = data.data_klass
+            next if visited.include?(klass)
+            visited |= klass.associated_classes(visited, false)
+          end
+        end
+        visited
+      end
+
+      # TODO for each association: check whether it has changed
+      # would need an instance-level hash with association name as key,
+      #   boolean 'changed' value
+      def with_associations(record)
+        @lock.synchronize do
+          @association_data ||= {}
+          @association_data.keys.each do |name|
+            yield record.send("#{name}_proxy".to_sym)
+          end
+        end
+      end
+
+      def with_association_data(name = nil)
+        @lock.synchronize do
+          @association_data ||= {}
+          assoc_data = name.nil? ? @association_data : @association_data[name]
+          yield assoc_data unless assoc_data.nil?
+        end
+      end
+
+      def with_index_data(name = nil)
+        @lock.synchronize do
+          @index_data ||= {}
+          idx_data = name.nil? ? @index_data : @index_data[name]
+          yield idx_data unless idx_data.nil?
+        end
+       end
+      # end used internally within Zermelo
+
+      # # TODO  can remove need for some of the inverse mapping
+      # # was inverse_of(source, klass)
+      # with_association_data do |d|
+      #   d.detect {|name, data| data.klass == klass && data.inverse == source}
+      # end
+
+      private
+
+      def add_index_data(klass, name, args = {})
+        return if name.nil?
+
+        data = Zermelo::Associations::IndexData.new(
+          :name            => name,
+          :type            => args[:type],
+          :index_klass     => klass
+        )
+
+        @lock.synchronize do
+          @index_data ||= {}
+          @index_data[name] = data
+        end
+      end
+
+      def index(klass, name, args = {})
+        return if name.nil?
+
+        add_index_data(klass, name, args)
+
+        idx = %Q{
+          private
+
+          def #{name}_index
+            @#{name}_index ||= #{klass.name}.new(self, '#{name}')
+            @#{name}_index
+          end
+        }
+        instance_eval idx, __FILE__, __LINE__
+      end
+
+      def add_association_data(klass, name, args = {})
+
+        # TODO have inverse be a reference (or copy?) of the association data
+        # record for that inverse association; would need to defer lookup until
+        # all data in place for all assocs, so might be best if looked up and
+        # cached on first use
+        inverse = if args[:inverse_of].nil? || args[:inverse_of].to_s.empty?
+          nil
+        else
+          args[:inverse_of].to_s
+        end
+
+        callbacks = case klass.name
+        when ::Zermelo::Associations::HasMany.name,
+             ::Zermelo::Associations::HasSortedSet.name,
+             ::Zermelo::Associations::HasAndBelongsToMany.name
+          [:before_add, :after_add, :before_remove, :after_remove]
+        when ::Zermelo::Associations::HasOne.name,
+             ::Zermelo::Associations::BelongsTo.name
+          [:before_set, :after_set, :before_clear, :after_clear]
+        else
+          []
+        end
+
+        data = Zermelo::Associations::AssociationData.new(
+          :name                => name,
+          :data_klass_name     => args[:class_name],
+          :type_klass          => klass,
+          :inverse             => inverse,
+          :related_klass_names => args[:related_class_names],
+          :callbacks           => callbacks.each_with_object({}) {|c, memo|
+                                    memo[c] = args[c]
+                                  }
+        )
+
+        if klass.name == Zermelo::Associations::HasSortedSet.name
+          data.sort_key = (args[:key] || :id)
+        end
+
+        @lock.synchronize do
+          @association_data ||= {}
+          @association_data[name] = data
+        end
+      end
+
+      def associate(klass, name, args = {})
+        return if name.nil?
+
+        add_association_data(klass, name, args)
+
+        assoc = case klass.name
+        when ::Zermelo::Associations::HasMany.name,
+             ::Zermelo::Associations::HasSortedSet.name,
+             ::Zermelo::Associations::HasAndBelongsToMany.name
+
+          %Q{
+            def #{name}
+              #{name}_proxy
+            end
+          }
+
+        when ::Zermelo::Associations::HasOne.name,
+             ::Zermelo::Associations::BelongsTo.name
+
+          %Q{
+            def #{name}
+              #{name}_proxy.value
+            end
+
+            def #{name}=(obj)
+              #{name}_proxy.value = obj
+            end
+          }
+        end
+
+        return if assoc.nil?
+
+        proxy = %Q{
+          def #{name}_proxy
+            raise "Associations cannot be invoked for records without an id" if self.id.nil?
+
+            @#{name}_proxy ||= #{klass.name}.new(self, '#{name}')
+          end
+          private :#{name}_proxy
+        }
+        class_eval proxy, __FILE__, __LINE__
+        class_eval assoc, __FILE__, __LINE__
+      end
+    end
+  end
+end

data/lib/zermelo/associations/has_and_belongs_to_many.rb

@@ -0,0 +1,128 @@
+require 'forwardable'
+
+# much like a has_many, but with different add/remove behaviour, as it's paired
+# with another has_and_belongs_to_many association. both sides must set the
+# inverse association name.
+
+module Zermelo
+  module Associations
+    class HasAndBelongsToMany
+
+      extend Forwardable
+
+      def_delegators :filter, :intersect, :union, :diff, :sort,
+                       :find_by_id, :find_by_ids, :find_by_id!, :find_by_ids!,
+                       :page, :all, :each, :collect, :map,
+                       :select, :find_all, :reject, :destroy_all,
+                       :ids, :count, :empty?, :exists?,
+                       :associated_ids_for
+
+      def initialize(parent, name)
+        @parent = parent
+
+        @backend = parent.send(:backend)
+
+        @record_ids_key = Zermelo::Records::Key.new(
+          :klass  => parent.class.send(:class_key),
+          :id     => parent.id,
+          :name   => "#{name}_ids",
+          :type   => :set,
+          :object => :association
+        )
+
+        parent.class.send(:with_association_data, name.to_sym) do |data|
+          @associated_class = data.data_klass
+          @lock_klasses     = [data.data_klass] + data.related_klasses
+          @inverse          = data.inverse
+          @callbacks        = data.callbacks
+        end
+      end
+
+      def <<(record)
+        add(record)
+        self  # for << 'a' << 'b'
+      end
+
+      def add(*records)
+        raise 'No records to add' if records.empty?
+        raise 'Invalid record class' unless records.all? {|r| r.is_a?(@associated_class)}
+        raise "Record(s) must have been saved" unless records.all? {|r| r.persisted?}
+        @parent.class.lock(*@lock_klasses) do
+          ba = @callbacks[:before_add]
+          if ba.nil? || !@parent.respond_to?(ba) || !@parent.send(ba, *records).is_a?(FalseClass)
+            records.each do |record|
+              @associated_class.send(:load, record.id).send(@inverse.to_sym).
+                send(:add_without_inverse, @parent)
+            end
+            add_without_inverse(*records)
+            aa = @callbacks[:after_add]
+            @parent.send(aa, *records) if !aa.nil? && @parent.respond_to?(aa)
+          end
+        end
+      end
+
+      # TODO support dependent delete, for now just deletes the association
+      def delete(*records)
+        raise 'No records to delete' if records.empty?
+        raise 'Invalid record class' unless records.all? {|r| r.is_a?(@associated_class)}
+        raise "Record(s) must have been saved" unless records.all? {|r| r.persisted?}
+        @parent.class.lock(*@lock_klasses) do
+          br = @callbacks[:before_remove]
+          if br.nil? || !@parent.respond_to?(br) || !@parent.send(br, *records).is_a?(FalseClass)
+            records.each do |record|
+              @associated_class.send(:load, record.id).send(@inverse.to_sym).
+                send(:delete_without_inverse, @parent)
+            end
+            delete_without_inverse(*records)
+            ar = @callbacks[:after_remove]
+            @parent.send(ar, *records) if !ar.nil? && @parent.respond_to?(ar)
+          end
+        end
+      end
+
+      private
+
+      def add_without_inverse(*records)
+        new_txn = @backend.begin_transaction
+        @backend.add(@record_ids_key, records.map(&:id))
+        @backend.commit_transaction if new_txn
+      end
+
+      def delete_without_inverse(*records)
+        new_txn = @backend.begin_transaction
+        @backend.delete(@record_ids_key, records.map(&:id))
+        @backend.commit_transaction if new_txn
+      end
+
+      # associated will be the other side of the HaBTM; on_remove is always
+      # called inside a lock
+      def on_remove
+        ids.each do |record_id|
+          @associated_class.send(:load, record_id).send(@inverse.to_sym).
+            send(:delete_without_inverse, @parent)
+        end
+        @backend.purge(@record_ids_key)
+      end
+
+      # creates a new filter class each time it's called, to store the
+      # state for this particular filter chain
+      def filter
+        @backend.filter(@record_ids_key, @associated_class)
+      end
+
+      def self.associated_ids_for(backend, class_key, name, *these_ids)
+        these_ids.each_with_object({}) do |this_id, memo|
+          key = Zermelo::Records::Key.new(
+            :klass  => class_key,
+            :id     => this_id,
+            :name   => "#{name}_ids",
+            :type   => :set,
+            :object => :association
+          )
+          memo[this_id] = backend.get(key)
+        end
+      end
+
+    end
+  end
+end

data/lib/zermelo/associations/has_many.rb

@@ -0,0 +1,120 @@
+require 'forwardable'
+
+module Zermelo
+  module Associations
+    class HasMany
+
+      extend Forwardable
+
+      def_delegators :filter, :intersect, :union, :diff, :sort,
+                       :find_by_id, :find_by_ids, :find_by_id!, :find_by_ids!,
+                       :page, :all, :each, :collect, :map,
+                       :select, :find_all, :reject, :destroy_all,
+                       :ids, :count, :empty?, :exists?,
+                       :associated_ids_for
+
+      def initialize(parent, name)
+        @parent = parent
+
+        @backend = parent.send(:backend)
+
+        @record_ids_key = Zermelo::Records::Key.new(
+          :klass  => parent.class.send(:class_key),
+          :id     => parent.id,
+          :name   => "#{name}_ids",
+          :type   => :set,
+          :object => :association
+        )
+
+        parent.class.send(:with_association_data, name.to_sym) do |data|
+          @associated_class = data.data_klass
+          @lock_klasses     = [data.data_klass] + data.related_klasses
+          @inverse          = data.inverse
+          @callbacks        = data.callbacks
+        end
+      end
+
+      def <<(record)
+        add(record)
+        self  # for << 'a' << 'b'
+      end
+
+      def add(*records)
+        raise 'No records to add' if records.empty?
+        raise 'Invalid record class' if records.any? {|r| !r.is_a?(@associated_class)}
+        raise 'Record(s) must have been saved' unless records.all? {|r| r.persisted?} # may need to be moved
+        @parent.class.lock(*@lock_klasses) do
+          ba = @callbacks[:before_add]
+          if ba.nil? || !@parent.respond_to?(ba) || !@parent.send(ba, *records).is_a?(FalseClass)
+            unless @inverse.nil?
+              records.each do |record|
+                @associated_class.send(:load, record.id).send("#{@inverse}=", @parent)
+              end
+            end
+
+            new_txn = @backend.begin_transaction
+            @backend.add(@record_ids_key, records.map(&:id))
+            @backend.commit_transaction if new_txn
+            aa = @callbacks[:after_add]
+            @parent.send(aa, *records) if !aa.nil? && @parent.respond_to?(aa)
+          end
+        end
+      end
+
+      # TODO support dependent delete, for now just deletes the association
+      def delete(*records)
+        raise 'No records to delete' if records.empty?
+        raise 'Invalid record class' if records.any? {|r| !r.is_a?(@associated_class)}
+        raise 'Record(s) must have been saved' unless records.all? {|r| r.persisted?} # may need to be moved
+        @parent.class.lock(*@lock_klasses) do
+          br = @callbacks[:before_remove]
+          if br.nil? || !@parent.respond_to?(br) || !@parent.send(br, *records).is_a?(FalseClass)
+            unless @inverse.nil?
+              records.each do |record|
+                @associated_class.send(:load, record.id).send("#{@inverse}=", nil)
+              end
+            end
+
+            new_txn = @backend.begin_transaction
+            @backend.delete(@record_ids_key, records.map(&:id))
+            @backend.commit_transaction if new_txn
+            ar = @callbacks[:after_remove]
+            @parent.send(ar, *records) if !ar.nil? && @parent.respond_to?(ar)
+          end
+        end
+      end
+
+      private
+
+      # associated will be a belongs_to; on remove already runs inside a lock and transaction
+      def on_remove
+        unless @inverse.nil?
+          self.ids.each do |record_id|
+            @associated_class.send(:load, record_id).send("#{@inverse}=", nil)
+          end
+        end
+        @backend.clear(@record_ids_key)
+      end
+
+      # creates a new filter class each time it's called, to store the
+      # state for this particular filter chain
+      def filter
+        @backend.filter(@record_ids_key, @associated_class)
+      end
+
+      def self.associated_ids_for(backend, class_key, name, *these_ids)
+        these_ids.each_with_object({}) do |this_id, memo|
+          key = Zermelo::Records::Key.new(
+            :klass  => class_key,
+            :id     => this_id,
+            :name   => "#{name}_ids",
+            :type   => :set,
+            :object => :association
+          )
+          memo[this_id] = backend.get(key)
+        end
+      end
+
+    end
+  end
+end