zermelo 1.1.0 → 1.2.0

data/lib/zermelo/associations/multiple.rb

@@ -0,0 +1,247 @@
+require 'forwardable'
+
+module Zermelo
+  module Associations
+    class Multiple
+
+      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(type, parent_klass, parent_id, name)
+        @type         = type
+        @parent_klass = parent_klass
+        @parent_id    = parent_id
+        @name         = name
+
+        @backend      = parent_klass.send(:backend)
+
+        @key_type = case @type
+        when :has_many, :has_and_belongs_to_many
+          :set
+        when :has_sorted_set
+          :sorted_set
+        end
+
+        @record_ids_key = Zermelo::Records::Key.new(
+          :klass  => parent_klass,
+          :id     => parent_id,
+          :name   => "#{name}_ids",
+          :type   => @key_type,
+          :object => :association
+        )
+
+        parent_klass.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
+          @sort_key         = data.sort_key
+          @sort_order       = data.sort_order
+          @callbacks        = data.callbacks
+        end
+
+        raise ':inverse_of must be set' if @inverse.nil?
+      end
+
+      def first
+        # FIXME raise error unless :has_sorted_set.eql?(@type)
+        filter.first
+      end
+
+      def last
+        # FIXME raise error unless :has_sorted_set.eql?(@type)
+        filter.last
+      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_klass.lock(*@lock_klasses) do
+          record_ids = case @type
+          when :has_many, :has_and_belongs_to_many
+            records.is_a?(Zermelo::Filter) ? records.ids : records.map(&:id)
+          when :has_sorted_set
+            records.map {|r| [r.send(@sort_key.to_sym).to_f, r.id]}
+          end
+          _add_ids({:callbacks => true}, *record_ids)
+        end
+      end
+
+      def add_ids(*record_ids)
+        raise 'No record ids to add' if record_ids.empty?
+        @parent_klass.lock(*@lock_klasses) do
+          records = @associated_class.find_by_ids!(*record_ids)
+          _add_ids({:callbacks => true}, *record_ids)
+        end
+      end
+
+      # TODO support dependent delete, for now just removes the association
+      def remove(*records)
+        raise 'No records to remove' 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_klass.lock(*@lock_klasses) do
+          _remove_ids({:callbacks => true},
+            *(records.is_a?(Zermelo::Filter) ? records.ids : records.map(&:id)))
+        end
+      end
+
+      def remove_ids(*record_ids)
+        raise 'No record ids to remove' if record_ids.empty?
+        @parent_klass.lock(*@lock_klasses) do
+          _remove_ids({:callbacks => true}, *record_ids)
+        end
+      end
+
+      def clear
+        @parent_klass.lock(*@lock_klasses) do
+          _remove_ids({:callbacks => true}, *filter.ids) unless filter.empty?
+        end
+      end
+
+      private
+
+      def _inverse
+        return @inverse_obj unless @inverse_obj.nil?
+        @associated_class.send(:with_association_data, @inverse.to_sym) do |data|
+          @inverse_obj = case @type
+          when :has_many, :has_sorted_set
+            # inverse is belongs_to
+            # FIXME neater to do multiple hash keys at once, if backends support it
+            Zermelo::Records::Key.new(
+              :klass  => @associated_class,
+              :name   => 'belongs_to',
+              :type   => :hash,
+              :object => :association
+            )
+          when :has_and_belongs_to_many
+            Zermelo::Records::Key.new(
+              :klass  => @associated_class,
+              :name   => "#{@inverse}_ids",
+              :type   => :set,
+              :object => :association
+            )
+          end
+        end
+        @inverse_obj
+      end
+
+      # associated will be a belongs_to; on remove already runs inside a lock and transaction
+      def on_remove
+        _remove_ids({:callbacks => false}, *filter.ids) unless filter.empty?
+      end
+
+      def _add_ids(opts = {}, *record_ids)
+        ba = @callbacks[:before_add]
+        if ba.nil? || !opts[:callbacks] || !@parent_klass.respond_to?(ba) ||
+          !@parent_klass.send(ba, @parent_id, *record_ids).is_a?(FalseClass)
+
+          new_txn = @backend.begin_transaction
+
+          # FIXME neater to do multiple hash keys at once for inverse, if backends support it
+          case @type
+          when :has_many
+            # inverse is belongs_to
+            record_ids.each do |record_id|
+              _inverse.id = record_id
+              @backend.add(_inverse, "#{@inverse}_id" => @parent_id)
+            end
+          when :has_sorted_set
+            # inverse is belongs_to
+            record_ids.each do |(score, record_id)|
+              _inverse.id = record_id
+              @backend.add(_inverse, "#{@inverse}_id" => @parent_id)
+            end
+          when :has_and_belongs_to_many
+            # inverse is has_and_belongs_to_many
+            record_ids.each do |record_id|
+              _inverse.id = record_id
+              @backend.add(_inverse, @parent_id)
+            end
+          end
+
+          @backend.add(@record_ids_key, record_ids)
+
+          @backend.commit_transaction if new_txn
+          aa = @callbacks[:after_add]
+          if !aa.nil? && opts[:callbacks] && @parent_klass.respond_to?(aa)
+            @parent_klass.send(aa, @parent_id, *record_ids)
+          end
+        end
+      end
+
+      def _remove_ids(opts = {}, *record_ids)
+        br = @callbacks[:before_remove]
+        if br.nil? || !opts[:callbacks] || !@parent_klass.respond_to?(br) ||
+          !@parent_klass.send(br, @parent_id, *record_ids).is_a?(FalseClass)
+
+          new_txn = @backend.begin_transaction
+
+          # FIXME neater to do multiple hash keys at once for inverse, if backends support it
+          case @type
+          when :has_many, :has_sorted_set
+            # inverse is belongs_to
+            record_ids.each do |record_id|
+              _inverse.id = record_id
+              @backend.delete(_inverse, "#{@inverse}_id")
+            end
+          when :has_and_belongs_to_many
+            # inverse is has_and_belongs_to_many
+            record_ids.each do |record_id|
+              _inverse.id = record_id
+              @backend.delete(_inverse, @parent_id)
+            end
+          end
+
+          @backend.delete(@record_ids_key, record_ids)
+
+          @backend.commit_transaction if new_txn
+
+          ar = @callbacks[:after_remove]
+          if !ar.nil? && opts[:callbacks] && @parent_klass.respond_to?(ar)
+            @parent_klass.send(ar, @parent_id, *record_ids)
+          end
+        end
+      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, @parent_klass,
+                        @parent_id, @callbacks, @sort_order)
+      end
+
+      def self.associated_ids_for(backend, type, klass, name, *these_ids)
+        key_type = case type
+        when :has_many, :has_and_belongs_to_many
+          :set
+        when :has_sorted_set
+          :sorted_set
+        end
+
+        these_ids.each_with_object({}) do |this_id, memo|
+          key = Zermelo::Records::Key.new(
+            :klass  => klass,
+            :id     => this_id,
+            :name   => "#{name}_ids",
+            :type   => key_type,
+            :object => :association
+          )
+          memo[this_id] = backend.get(key)
+        end
+      end
+
+    end
+  end
+end

data/lib/zermelo/associations/range_index.rb

@@ -0,0 +1,44 @@
+# NB index instances are all internal to zermelo, not user-accessible
+
+require 'zermelo/records/key'
+
+module Zermelo
+  module Associations
+    class RangeIndex
+
+      def initialize(parent_klass, name)
+        @parent_klass   = parent_klass
+        @attribute_name = name
+
+        @backend   = parent_klass.send(:backend)
+
+        parent_klass.send(:with_index_data, name.to_sym) do |data|
+          @attribute_type = data.type
+        end
+      end
+
+      def delete_id(id, value)
+        @backend.delete(key, id)
+      end
+
+      def add_id(id, value)
+        @backend.add(key, [@backend.safe_value(@attribute_type, value), id])
+      end
+
+      def move_id(id, value_from, indexer_to, value_to)
+        @backend.move(key, [@backend.safe_value(@attribute_type, value_from), id],
+          indexer_to.key, [@backend.safe_value(@attribute_type, value_to), id])
+      end
+
+      def key
+        @indexer ||= Zermelo::Records::Key.new(
+          :klass  => @parent_klass,
+          :name   => "by_#{@attribute_name}",
+          :type   => :sorted_set,
+          :object => :index
+        )
+      end
+
+    end
+  end
+end

data/lib/zermelo/associations/singular.rb

@@ -0,0 +1,193 @@
+module Zermelo
+  module Associations
+    class Singular
+
+      def initialize(type, parent_klass, parent_id, name)
+        @type = type
+        @parent_klass = parent_klass
+        @parent_id = parent_id
+        @name   = name
+
+        @backend = parent_klass.send(:backend)
+
+        @record_id_key = Zermelo::Records::Key.new(
+          :klass  => parent_klass,
+          :id     => parent_id,
+          :name   => type.to_s,
+          :type   => :hash,
+          :object => :association
+        )
+
+        parent_klass.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 = "#{@inverse}_id"
+      end
+
+      def value=(record)
+        if record.nil?
+          @parent_klass.lock(*@lock_klasses) do
+            _clear(:callbacks => true)
+          end
+        else
+          raise 'Invalid record class' unless record.is_a?(@associated_class)
+          raise 'Record must have been saved' unless record.persisted?
+          @parent_klass.lock(*@lock_klasses) do
+            opts = {:callbacks => true}
+            if :sorted_set.eql?(_inverse.type)
+              opts[:score] = @parent_klass.find_by_id!(@parent_id).send(@inverse_sort_key.to_sym).to_f
+            end
+            _set(opts, record.id)
+          end
+        end
+      end
+
+      def value
+        v = nil
+        @parent_klass.lock(*@lock_klasses) do
+          br = @callbacks[:before_read]
+          @parent_klass.send(br, @parent_id) if !br.nil? && @parent_klass.respond_to?(br)
+          id = @backend.get(@record_id_key)["#{@name}_id"]
+          # # TODO maybe: uses hgetall, need separate getter for hash/list/set
+          # @backend.get_hash_value(@record_id_key, "#{@name}_id")
+          v = @associated_class.send(:load, id) unless id.nil?
+          ar = @callbacks[:after_read]
+          @parent_klass.send(ar, @parent_id, v) if !ar.nil? && @parent_klass.respond_to?(ar)
+        end
+        v
+      end
+
+      private
+
+      # on_remove already runs inside a lock & transaction
+      def on_remove
+        _clear(:callbacks => false)
+      end
+
+      def _inverse
+        return @inverse_obj unless @inverse_obj.nil?
+        @associated_class.send(:with_association_data, @inverse.to_sym) do |data|
+          @inverse_obj = case @type
+          when :belongs_to
+            key_name, key_type = case data.data_type
+            when :has_many
+              ["#{@inverse}_ids", :set]
+            when :has_sorted_set
+              ["#{@inverse}_ids", :sorted_set]
+            when :has_one
+              ["has_one", :hash]
+            end
+
+            @inverse_sort_key = data.sort_key
+
+            Zermelo::Records::Key.new(
+              :klass  => @associated_class,
+              :name   => key_name,
+              :type   => key_type,
+              :object => :association
+            )
+          when :has_one
+            # inverse is belongs_to
+            Zermelo::Records::Key.new(
+              :klass  => @associated_class,
+              :name   => 'belongs_to',
+              :type   => :hash,
+              :object => :association
+            )
+          end
+        end
+        @inverse_obj
+      end
+
+      def _clear(opts = {})
+        bc = @callbacks[:before_clear]
+        if bc.nil? || !opts[:callbacks] || !@parent_klass.respond_to?(bc) ||
+          !@parent_klass.send(bc, @parent_id).is_a?(FalseClass)
+
+          record_id = @backend.get(@record_id_key)["#{@name}_id"]
+          _inverse.id = record_id
+
+          new_txn = @backend.begin_transaction
+
+          case @type
+          when :belongs_to, :has_one
+            # FIXME can we access the assoc type instead?
+            case _inverse.type
+            when :set, :sorted_set
+              @backend.delete(_inverse, @parent_id)
+            when :hash
+              @backend.delete(_inverse, "#{@inverse}_id")
+            end
+
+            @backend.delete(@record_id_key, "#{@name}_id")
+          end
+
+          @backend.commit_transaction if new_txn
+
+          ac = @callbacks[:after_clear]
+          if !ac.nil? && opts[:callbacks] && @parent_klass.respond_to?(ac)
+            @parent_klass.send(ac, @parent_id, record_id)
+          end
+        end
+      end
+
+      def _set(opts = {}, record_id)
+        bs = @callbacks[:before_set]
+        if bs.nil? || !opts[:callbacks] || !@parent_klass.respond_to?(bs) ||
+          !@parent_klass.send(bs, @parent_id, record_id).is_a?(FalseClass)
+
+          _inverse.id = record_id
+
+          new_txn = @backend.begin_transaction
+
+          # FIXME can we access the assoc type instead?
+          case _inverse.type
+          when :set
+            @backend.add(_inverse, @parent_id)
+          when :sorted_set
+            @backend.add(_inverse, [opts[:score], @parent_id])
+          when :hash
+            @backend.add(_inverse, @inverse_key => @parent_id)
+          end
+
+          @backend.add(@record_id_key, "#{@name}_id" => record_id)
+
+          @backend.commit_transaction if new_txn
+
+          as = @callbacks[:after_set]
+          if !as.nil? && opts[:callbacks] && @parent_klass.respond_to?(as)
+            @parent_klass.send(as, @parent_id, record_id)
+          end
+        end
+      end
+
+      def self.associated_ids_for(backend, type, klass, name, inversed, *these_ids)
+        these_ids.each_with_object({}) do |this_id, memo|
+          key = Zermelo::Records::Key.new(
+            :klass  => klass,
+            :id     => this_id,
+            :name   => type.to_s,
+            :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/unique_index.rb

@@ -1,5 +1,7 @@
 # NB index instances are all internal to zermelo, not user-accessible
 
+require 'zermelo/records/key'
+
 module Zermelo
   module Associations
     class UniqueIndex
@@ -10,8 +12,6 @@ module Zermelo
 
         @backend   = parent_klass.send(:backend)
 
-        @indexers = {}
-
         parent_klass.send(:with_index_data, name.to_sym) do |data|
           @attribute_type = data.type
         end
@@ -26,7 +26,8 @@ module Zermelo
       end
 
       def move_id(id, value_from, indexer_to, value_to)
-        @backend.move(key, {@backend.index_keys(@attribute_type, value_to).join(':') => id}, indexer_to.key)
+        @backend.move(key, {@backend.index_keys(@attribute_type, value_from).join(':') => id},
+          indexer_to.key, {@backend.index_keys(@attribute_type, value_to).join(':') => id})
       end
 
       def key

data/lib/zermelo/backend.rb

@@ -0,0 +1,120 @@
+require 'active_support/concern'
+
+require 'zermelo/locks/no_lock'
+
+module Zermelo
+
+  module Backend
+
+    extend ActiveSupport::Concern
+
+    def escape_key_name(name)
+      name.gsub(/%/, '%%').gsub(/ /, '%20').gsub(/:/, '%3A')
+    end
+
+    def unescape_key_name(name)
+      name.gsub(/%3A/, ':').gsub(/%20/, ' ').gsub(/%%/, '%')
+    end
+
+    def safe_value(type, value)
+      case type
+      when :string, :integer
+        value.to_s
+      when :float, :timestamp
+        value.to_f
+      when :boolean
+        (!!value).to_s
+      end
+    end
+
+    def index_keys(type, value)
+      return ["null", "null"] if value.nil?
+
+      case type
+      when :string
+        ["string", escape_key_name(value)]
+      when :integer
+        ["integer", escape_key_name(value.to_s)]
+      when :float
+        ["float", escape_key_name(value.to_s)]
+      when :timestamp
+        case value
+        when Integer
+          ["timestamp", escape_key_name(value.to_s)]
+        when Time, DateTime
+          ["timestamp", escape_key_name(value.to_f.to_s)]
+        end
+      when :boolean
+        case value
+        when TrueClass
+          ["boolean", "true"]
+        when FalseClass
+          ["boolean", "false"]
+        end
+      end
+    end
+
+    # for hashes, lists, sets
+    def add(key, value)
+      change(:add, key, value)
+    end
+
+    def delete(key, value)
+      change(:delete, key, value)
+    end
+
+    def move(key_from, value_from, key_to, value_to)
+      change(:move, key_from, value_from, key_to, value_to)
+    end
+
+    def clear(key)
+      change(:clear, key)
+    end
+
+    # works for both simple and complex types (i.e. strings, numbers, booleans,
+    #  hashes, lists, sets)
+    def set(key, value)
+      change(:set, key, value)
+    end
+
+    def purge(key)
+      change(:purge, key)
+    end
+
+    def get(attr_key)
+      get_multiple(attr_key)[attr_key.klass.send(:class_key)][attr_key.id][attr_key.name.to_s]
+    end
+
+    def lock(*klasses, &block)
+      ret = nil
+      # doesn't handle re-entrant case for influxdb, which has no locking yet
+      locking = Thread.current[:zermelo_locking]
+      if locking.nil?
+        lock_proc = proc do
+          begin
+            Thread.current[:zermelo_locking] = klasses
+            ret = block.call
+          ensure
+            Thread.current[:zermelo_locking] = nil
+          end
+        end
+
+        lock_klass = case self
+        when Zermelo::Backends::Redis
+          Zermelo::Locks::RedisLock
+        else
+          Zermelo::Locks::NoLock
+        end
+
+        lock_klass.new.lock(*klasses, &lock_proc)
+      else
+        # accepts any subset of 'locking'
+        unless (klasses - locking).empty?
+          raise "Currently locking #{locking.map(&:name)}, cannot lock different set #{klasses.map(&:name)}"
+        end
+        ret = block.call
+      end
+      ret
+    end
+  end
+end