zermelo 1.1.0 → 1.2.0

data/lib/zermelo/associations/has_many.rb

@@ -1,120 +0,0 @@
-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,
-          :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, klass, name, *these_ids)
-        these_ids.each_with_object({}) do |this_id, memo|
-          key = Zermelo::Records::Key.new(
-            :klass  => klass,
-            :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_one.rb

@@ -1,109 +0,0 @@
-module Zermelo
-  module Associations
-    class HasOne
-
-      def initialize(parent, name)
-        @parent = parent
-
-        @backend = parent.send(:backend)
-
-        # TODO would be better as a 'has_one' hash, a bit like belongs_to
-        @record_id_key = Zermelo::Records::Key.new(
-          :klass  => parent.class,
-          :id     => parent.id,
-          :name   => "#{name}_id",
-          :type   => :string,
-          :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 value
-        @parent.class.lock(@associated_class) do
-          if id = @backend.get(@record_id_key)
-            @associated_class.send(:load, id)
-          else
-            nil
-          end
-        end
-      end
-
-      def value=(record)
-        if record.nil?
-          @parent.class.lock(*@lock_klasses) do
-           id = @backend.get(@record_id_key)
-           unless id.nil?
-             r = @associated_class.send(:load, id)
-             unless r.nil?
-               bc = @callbacks[:before_clear]
-               if bc.nil? || !@parent.respond_to?(bc) || !@parent.send(bc, r).is_a?(FalseClass)
-                  delete_without_lock(r)
-                  ac = @callbacks[:after_clear]
-                  @parent.send(ac, r) if !ac.nil? && @parent.respond_to?(ac)
-                end
-              end
-            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)
-              unless @inverse.nil?
-                @associated_class.send(:load, record.id).send("#{@inverse}=", @parent)
-              end
-
-              new_txn = @backend.begin_transaction
-              @backend.set(@record_id_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
-
-      private
-
-      def delete_without_lock(record)
-        unless @inverse.nil?
-          record.send("#{@inverse}=", nil)
-        end
-        new_txn = @backend.begin_transaction
-        @backend.clear(@record_id_key)
-        @backend.commit_transaction if new_txn
-      end
-
-      # associated will be a belongs_to; on_remove already runs inside lock and transaction
-      def on_remove
-        unless @inverse.nil?
-          if record_id = @backend.get(@record_id_key)
-            @associated_class.send(:load, record_id).send("#{@inverse}=", nil)
-          end
-        end
-        @backend.clear(@record_id_key)
-      end
-
-      def self.associated_ids_for(backend, klass, name, *these_ids)
-        these_ids.each_with_object({}) do |this_id, memo|
-          key = Zermelo::Records::Key.new(
-            :klass  => klass,
-            :id     => this_id,
-            :name   => "#{name}_id",
-            :type   => :string,
-            :object => :association
-          )
-          memo[this_id] = backend.get(key)
-        end
-      end
-
-    end
-  end
-end

data/lib/zermelo/associations/has_sorted_set.rb

@@ -1,124 +0,0 @@
-require 'forwardable'
-
-module Zermelo
-  module Associations
-    class HasSortedSet
-
-      extend Forwardable
-
-      def_delegators :filter, :intersect, :union, :diff, :sort,
-                       :intersect_range, :union_range, :diff_range,
-                       :find_by_id, :find_by_ids, :find_by_id!, :find_by_ids!,
-                       :all, :each, :collect, :map,
-                       :select, :find_all, :reject, :destroy_all,
-                       :ids, :count, :empty?, :exists?,
-                       :first, :last,
-                       :associated_ids_for
-
-      def initialize(parent, name)
-        @parent = parent
-
-        @backend = parent.send(:backend)
-
-        @record_ids_key = Zermelo::Records::Key.new(
-          :klass  => parent.class,
-          :id     => parent.id,
-          :name   => "#{name}_ids",
-          :type   => :sorted_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
-          @sort_key         = data.sort_key || backend.default_sort_key
-          @callbacks        = data.callbacks
-        end
-      end
-
-      def <<(record)
-        add(record)
-        self  # for << 'a' << 'b'
-      end
-
-      # TODO collect all scores/ids and do a single zadd/single hmset
-      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?}
-        @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 {|r| [r.send(@sort_key.to_sym).to_f, r.id]}.flatten))
-            @backend.commit_transaction if new_txn
-            aa = @callbacks[:after_add]
-            @parent.send(aa, *records) if !aa.nil? && @parent.respond_to?(aa)
-          end
-        end
-      end
-
-      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?}
-        @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|
-            # clear the belongs_to inverse value with this @parent.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, klass, name, *these_ids)
-        these_ids.each_with_object({}) do |this_id, memo|
-          key = Zermelo::Records::Key.new(
-            :klass  => klass,
-            :id     => this_id,
-            :name   => "#{name}_ids",
-            :type   => :sorted_set,
-            :object => :association
-          )
-          memo[this_id] = backend.get(key)
-        end
-      end
-
-    end
-  end
-end

data/lib/zermelo/backends/base.rb

@@ -1,115 +0,0 @@
-require 'active_support/concern'
-
-require 'zermelo/locks/no_lock'
-
-module Zermelo
-
-  module Backends
-
-    module Base
-
-      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 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_i.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, value, key_to)
-        change(:move, key, value, key_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::RedisBackend
-            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
-
-end

data/lib/zermelo/filters/base.rb

@@ -1,212 +0,0 @@
-require 'active_support/concern'
-
-require 'zermelo/records/errors'
-
-require 'zermelo/filters/steps/list_step'
-require 'zermelo/filters/steps/set_step'
-require 'zermelo/filters/steps/sorted_set_step'
-require 'zermelo/filters/steps/sort_step'
-
-module Zermelo
-
-  module Filters
-
-    module Base
-
-      extend ActiveSupport::Concern
-
-      attr_reader :backend, :steps
-
-      # initial set         a Zermelo::Record::Key object
-      # associated_class    the class of the result record
-      def initialize(data_backend, initial_key, associated_class, ancestor = nil, step = nil)
-        @backend          = data_backend
-        @initial_key      = initial_key
-        @associated_class = associated_class
-        @steps            = ancestor.nil? ? [] : ancestor.steps.dup
-        @steps << step unless step.nil?
-      end
-
-      def intersect(attrs = {})
-        self.class.new(@backend, @initial_key, @associated_class, self,
-          ::Zermelo::Filters::Steps::SetStep.new({:op => :intersect}, attrs))
-      end
-
-      def union(attrs = {})
-        self.class.new(@backend, @initial_key, @associated_class, self,
-          ::Zermelo::Filters::Steps::SetStep.new({:op => :union}, attrs))
-      end
-
-      def diff(attrs = {})
-        self.class.new(@backend, @initial_key, @associated_class, self,
-          ::Zermelo::Filters::Steps::SetStep.new({:op => :diff}, attrs))
-      end
-
-      def sort(keys, opts = {})
-        self.class.new(@backend, @initial_key, @associated_class, self,
-          ::Zermelo::Filters::Steps::SortStep.new({:keys => keys,
-            :desc => opts[:desc], :limit => opts[:limit],
-            :offset => opts[:offset]}, {})
-          )
-      end
-
-      def offset(amount, opts = {})
-        self.class.new(@backend, @initial_key, @associated_class, self,
-          ::Zermelo::Filters::Steps::ListStep.new({:offset => amount,
-            :limit => opts[:limit]}, {}))
-      end
-
-      def page(num, opts = {})
-        per_page = opts[:per_page].to_i || 20
-        start  = per_page * (num - 1)
-        finish = start + (per_page - 1)
-        self.class.new(@backend, @initial_key, @associated_class, self,
-          ::Zermelo::Filters::Steps::ListStep.new({:offset => start,
-            :limit => per_page}, {}))
-      end
-
-      def intersect_range(start, finish, attrs_opts = {})
-        self.class.new(@backend, @initial_key, @associated_class, self,
-          ::Zermelo::Filters::Steps::SortedSetStep.new(
-            {:op => :intersect_range, :start => start, :finish => finish,
-             :by_score => attrs_opts.delete(:by_score)},
-            attrs_opts)
-          )
-      end
-
-      def union_range(start, finish, attrs_opts = {})
-        self.class.new(@backend, @initial_key, @associated_class, self,
-          ::Zermelo::Filters::Steps::SortedSetStep.new(
-            {:op => :union_range, :start => start, :finish => finish,
-             :by_score => attrs_opts.delete(:by_score)},
-            attrs_opts)
-          )
-      end
-
-      def diff_range(start, finish, attrs_opts = {})
-        self.class.new(@backend, @initial_key, @associated_class, self,
-          ::Zermelo::Filters::Steps::SortedSetStep.new(
-            {:op => :diff_range, :start => start, :finish => finish,
-             :by_score => attrs_opts.delete(:by_score)},
-            attrs_opts)
-          )
-      end
-
-      # step users
-      def exists?(e_id)
-        lock(false) { _exists?(e_id) }
-      end
-
-      def find_by_id(f_id)
-        lock { _find_by_id(f_id) }
-      end
-
-      def find_by_id!(f_id)
-        ret = lock { _find_by_id(f_id) }
-        raise ::Zermelo::Records::Errors::RecordNotFound.new(@associated_class, f_id) if ret.nil?
-        ret
-      end
-
-      def find_by_ids(*f_ids)
-        lock { f_ids.collect {|f_id| _find_by_id(f_id) } }
-      end
-
-      def find_by_ids!(*f_ids)
-        ret = lock { f_ids.collect {|f_id| _find_by_id(f_id) } }
-        if ret.any? {|r| r.nil? }
-          raise ::Zermelo::Records::Errors::RecordsNotFound.new(@associated_class, f_ids - ret.compact.map(&:id))
-        end
-        ret
-      end
-
-      def ids
-        lock(false) { _ids }
-      end
-
-      def count
-        lock(false) { _count }
-      end
-
-      def empty?
-        lock(false) { _count == 0 }
-      end
-
-      def all
-        lock { _all }
-      end
-
-      def collect(&block)
-        lock { _ids.collect {|id| block.call(_load(id))} }
-      end
-      alias_method :map, :collect
-
-      def each(&block)
-        lock { _ids.each {|id| block.call(_load(id)) } }
-      end
-
-      def select(&block)
-        lock { _all.select {|obj| block.call(obj) } }
-      end
-      alias_method :find_all, :select
-
-      def reject(&block)
-        lock { _all.reject {|obj| block.call(obj)} }
-      end
-
-      def destroy_all
-        lock(*@associated_class.send(:associated_classes)) do
-          _all.each {|r| r.destroy }
-        end
-      end
-
-      def associated_ids_for(name, options = {})
-        klass = @associated_class.send(:with_association_data, name.to_sym) do |data|
-          data.type_klass
-        end
-
-        lock {
-          case klass.name
-          when ::Zermelo::Associations::BelongsTo.name
-            klass.send(:associated_ids_for, @backend,
-              @associated_class, name,
-              options[:inversed].is_a?(TrueClass), *_ids)
-          else
-            klass.send(:associated_ids_for, @backend,
-              @associated_class, name, *_ids)
-          end
-        }
-      end
-
-      protected
-
-      def lock(when_steps_empty = true, *klasses, &block)
-        return(block.call) if !when_steps_empty && @steps.empty?
-        klasses += [@associated_class] if !klasses.include?(@associated_class)
-        @backend.lock(*klasses, &block)
-      end
-
-      private
-
-      def _find_by_id(id)
-        if !id.nil? && _exists?(id)
-          _load(id.to_s)
-        else
-          nil
-        end
-      end
-
-      def _load(id)
-        object = @associated_class.new
-        object.load(id)
-        object
-      end
-
-      def _all
-        _ids.map {|id| _load(id) }
-      end
-
-    end
-
-  end
-
-end