ricordami 0.0.1

data/lib/ricordami/can_be_queried.rb

@@ -0,0 +1,133 @@
+require "ricordami/key_namer"
+require "ricordami/query.rb"
+
+module Ricordami
+  module CanBeQueried
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      [:where, :and, :not, :any].each do |op|
+        define_method(op) do |*args|
+          options = args.first || {}
+          Query.new(self).send(op, options)
+        end
+      end
+
+      def sort(*args)
+        Query.new(self).send(:sort, *args)
+      end
+
+      def all(opts = {})
+        result_key = run_expressions(opts.delete(:expressions) || [])
+        get_result_ids(result_key, opts).map do |id|
+          self[id]
+        end
+      end
+
+      def paginate(opts = {})
+        result_key = run_expressions(opts.delete(:expressions) || [])
+        page = opts[:page] || 1
+        per_page = opts[:per_page] || 20
+        start = (page - 1) * per_page
+        opts[:limit] = [start, per_page]
+        get_result_ids(result_key, opts).map do |id|
+          self[id]
+        end
+      end
+
+      def first(opts = {})
+        result_key = run_expressions(opts.delete(:expressions) || [])
+        opts[:limit] = [0, 1]
+        ids = get_result_ids(result_key, opts)
+        self[ids.first]
+      end
+
+      def last(opts = {})
+        result_key = run_expressions(opts.delete(:expressions) || [])
+        size = redis.scard(result_key)
+        opts[:limit] = [size - 1, 1]
+        ids = get_result_ids(result_key, opts)
+        self[ids.first]
+      end
+
+      def rand(opts = {})
+        result_key = run_expressions(opts.delete(:expressions) || [])
+        size = redis.scard(result_key)
+        opts[:limit] = [Kernel.rand(size), 1]
+        ids = get_result_ids(result_key, opts)
+        self[ids.first]
+      end
+
+      private
+
+      def run_expressions(expressions)
+        key_all_ids = indices[:id].uidx_key_name
+        result_key = expressions.reduce(key_all_ids) do |key, expression|
+          type, conditions = expression
+          condition_keys = get_keys_for_each_condition(conditions)
+          next key if condition_keys.empty?
+          target_key = key_name_for_expression(type, conditions, key)
+          send("run_#{type}", target_key, key, condition_keys)
+        end
+        result_key.empty?? [] : result_key
+      end
+
+      def get_keys_for_each_condition(conditions)
+        conditions.map do |field, value|
+          index = indices[field]
+          raise MissingIndex.new("class: #{self}, attribute: #{field.inspect}") if index.nil?
+          index.key_name_for_value(value)
+        end
+      end
+
+      def key_name_for_expression(type, conditions, previous_key)
+        KeyNamer.volatile_set(self, :key => previous_key,
+                                    :info => [type] + conditions.keys)
+      end
+
+      def get_result_ids(key, opts)
+        return redis.smembers(key) unless opts[:sort_by] || opts[:limit]
+        sort_key = KeyNamer.sort(self, :sort_by => opts[:sort_by])
+        sort_options = opts.slice(:order, :limit)
+        redis.sort(key, sort_options.merge(:by => sort_key))
+      end
+
+      def run_and(key_name, start_key, keys)
+        # we get the intersection of the start key and the condition keys
+        redis.sinterstore(key_name, start_key, *keys)
+        key_name
+      end
+
+      alias :run_where :run_and
+
+      def run_any(key_name, start_key, keys)
+        tmp_key = KeyNamer.temporary(self)
+        keys.each_with_index do |key, i|
+          if i == 0
+            # if only one condition key, :any condition is same as :and condition
+            redis.sinterstore(key_name, start_key, keys.first)
+          else
+            # we get the intersection of the start key with each condition key
+            # and we make a union of all of those
+          end
+          redis.sinterstore(tmp_key, start_key, key)
+          redis.sunionstore(key_name, key_name, tmp_key)
+        end
+        redis.del(tmp_key)
+        key_name
+      end
+
+      def run_not(key_name, start_key, keys)
+        keys.each_with_index do |key, i|
+          redis.sdiffstore(key_name, i == 0 ? start_key : key_name, key)
+        end
+        key_name
+      end
+
+      def reverse_order(order)
+        return order.sub("DESC", "ASC") if order.index("DESC")
+        order.sub("ASC", "DESC")
+      end
+    end
+  end
+end

data/lib/ricordami/can_be_validated.rb

@@ -0,0 +1,27 @@
+require "active_model/validations"
+require "ricordami/unique_validator"
+
+module Ricordami
+  module CanBeValidated
+    extend ActiveSupport::Concern
+    include ActiveModel::Validations
+
+    module ClassMethods
+      def validates_uniqueness_of(*attr_names)
+        validates_with UniqueValidator, _merge_attributes(attr_names)
+      end
+    end
+
+    module InstanceMethods
+      def valid?
+        raise ModelHasBeenDeleted.new("can't validate a deleted model") if deleted?
+        super
+      end
+
+      def save(opts = {})
+        return false unless opts[:validate] == false || valid?
+        super(opts)
+      end
+    end
+  end
+end

data/lib/ricordami/can_have_relationships.rb

@@ -0,0 +1,152 @@
+require "ricordami/relationship"
+require "ricordami/can_be_queried"
+
+module Ricordami
+  module CanHaveRelationships
+    extend ActiveSupport::Concern
+
+    included do |base|
+      base.send(:include, CanBeQueried)
+    end
+
+    module ClassMethods
+      def relationships
+        @relationships ||= {}
+      end
+
+      Relationship::SUPPORTED_TYPES.each do |type|
+        define_method(type) do |*args|
+          name = args.first
+          options = args[1] || {}
+          options.merge!(:other => name, :self => self.to_s.underscore.to_sym)
+          relationship = Relationship.new(type, options)
+          self.relationships[relationship.name] = relationship
+          setup_method = :"setup_#{type}"
+          send(setup_method, relationship) if respond_to?(setup_method, true)
+        end
+      end
+
+      private
+
+      def set_block_to_delete_dependents(relationship)
+        queue_deleting_operations do |obj, session|
+          ref_objs = obj.send(relationship.name)
+          ref_objs = [ref_objs] if relationship.type == :references_one
+          ref_objs.each { |ref_obj| ref_obj.prepare_delete(session) }
+        end
+      end
+
+      def set_block_to_nullify_dependents(relationship)
+        queue_deleting_operations do |obj, session|
+          ref_objs = obj.send(relationship.name)
+          ref_objs = [ref_objs] if relationship.type == :references_one
+          ref_objs.each do |ref_obj|
+            ref_obj.update_attributes(relationship.referrer_id => nil)
+          end
+        end
+      end
+
+      def lazy_setup_references_many(relationship)
+        klass = relationship.object_class
+        referrer_id_sym = relationship.referrer_id.to_sym
+        define_method(relationship.name) do
+          return Query.new([], klass) unless persisted?
+          klass.where(referrer_id_sym => self.id)
+        end
+        case relationship.dependent
+        when :delete  then set_block_to_delete_dependents(relationship)
+        when :nullify then set_block_to_nullify_dependents(relationship)
+        end
+      end
+
+      def define_builders(name, klass, referrer_id_sym)
+        # define reference build method
+        build_method = :"build_#{name}"
+        define_method(build_method) do |*args|
+          options = args.first || {}
+          klass.new(options.merge(referrer_id_sym => self.id))
+        end
+        # define reference create method
+        define_method(:"create_#{name}") do |*args|
+          send(build_method, *args).tap { |obj| obj.save }
+        end
+      end
+
+      def lazy_setup_references_one(relationship)
+        klass = relationship.object_class
+        referrer_id_sym = relationship.referrer_id.to_sym
+        define_builders(relationship.name, klass, referrer_id_sym)
+        # define reference method reader
+        define_method(relationship.name) do
+          return nil unless persisted?
+          klass.where(referrer_id_sym => self.id).first
+        end
+        case relationship.dependent
+        when :delete  then set_block_to_delete_dependents(relationship)
+        when :nullify then set_block_to_nullify_dependents(relationship)
+        end
+      end
+
+      def setup_referenced_in(relationship)
+        attribute(relationship.referrer_id, :indexed => :value)
+        overide_referrer_id_reader(relationship)
+      end
+
+      def lazy_setup_referenced_in(relationship)
+        klass = relationship.object_class
+        name = relationship.name
+        define_builders(name, klass, relationship.referrer_id.to_sym)
+        referrer_var = :"@#{name}"
+        define_method(name) do
+          referrer = instance_variable_get(referrer_var)
+          return referrer unless referrer.nil?
+          referrer_id_val = send(relationship.referrer_id)
+          return nil if referrer_id_val.nil?
+          klass.get(referrer_id_val).tap do |referrer|
+            instance_variable_set(referrer_var, referrer)
+          end
+        end
+      end
+
+      def overide_referrer_id_reader(relationship)
+        referrer_var = :"@#{relationship.name}"
+        # overide referrer id to sweep cache
+        define_method(:"#{relationship.referrer_id}=") do |value|
+          instance_variable_set(referrer_var, nil)
+          super(value)
+        end
+      end
+    end
+
+    module InstanceMethods
+      private
+
+      RE_METHOD = /^(build|create)_(.*)$/
+
+      def method_missing(meth, *args, &blk)
+        match = RE_METHOD.match(meth.to_s)
+        meth_root = match.nil?? meth : match[2].to_sym
+        if relationship = self.class.relationships[meth_root]
+          self.class.send(:"lazy_setup_#{relationship.type}", relationship)
+          send(meth, *args, &blk)
+        else
+          super
+        end
+      end
+
+      if Object.respond_to?(:respond_to_missing?)
+        def respond_to_missing?(meth, include_private)
+          self.class.relationships.has_key?(meth)
+        end
+      else
+        def respond_to?(meth)
+          match = RE_METHOD.match(meth.to_s)
+          meth_root = match.nil?? meth : match[2].to_sym
+          return true if self.class.relationships.has_key?(meth_root)
+          super
+        end
+        public :respond_to?
+      end
+    end
+  end
+end

data/lib/ricordami/configuration.rb

@@ -0,0 +1,39 @@
+module Ricordami
+  module Configuration
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def configure(&block)
+        raise ArgumentError.new("block missing") unless block_given?
+        yield configuration
+      end
+
+      def configuration
+        @configuration ||= Config.new
+      end
+    end
+  end
+
+  class Config
+    ATTRIBUTE_NAMES = [:redis_host, :redis_port, :redis_db, :thread_safe]
+
+    def initialize
+      @options = {}
+    end
+
+    def from_hash(options)
+      @options = options.slice(*ATTRIBUTE_NAMES)
+    end
+
+    private
+
+    def method_missing(meth, *args, &blk)
+      return @options[meth] if ATTRIBUTE_NAMES.include?(meth)
+      if args.length == 1 && match = /^(.*)=$/.match(meth.to_s)
+        name = match[1].to_sym
+        return @options[name] = args.first if ATTRIBUTE_NAMES.include?(name)
+      end
+      raise AttributeNotSupported.new("attribute #{meth.to_s.inspect} is not supported")
+    end
+  end
+end

data/lib/ricordami/connection.rb

@@ -0,0 +1,22 @@
+module Ricordami
+  module Connection
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def driver
+        @driver ||= create_driver
+      end
+
+      private
+
+      def create_driver
+        c = self.configuration
+        Redis.new(:host         => c.redis_host,
+                  :port         => c.redis_port,
+                  :db           => c.redis_db,
+                  :thread_safe  => c.thread_safe,
+                  :timeout      => 10)
+      end
+    end
+  end
+end

data/lib/ricordami/exceptions.rb

@@ -0,0 +1,14 @@
+module Ricordami
+  Error                   = Class.new(StandardError)
+  NotFound                = Class.new(Error)
+  AttributeNotSupported   = Class.new(Error)
+  ReadOnlyAttribute       = Class.new(Error)
+  InvalidIndexDefinition  = Class.new(Error)
+  ModelHasBeenDeleted     = Class.new(Error)
+  TypeNotSupported        = Class.new(Error)
+  MissingIndex            = Class.new(Error)
+  LockTimeout             = Class.new(Error)
+  EventNotSupported       = Class.new(Error)
+  OptionValueInvalid      = Class.new(Error)
+  MissingMandatoryArgs    = Class.new(Error)
+end

data/lib/ricordami/has_attributes.rb

@@ -0,0 +1,159 @@
+require "ricordami/key_namer"
+require "ricordami/attribute"
+
+module Ricordami
+  module HasAttributes
+    extend ActiveSupport::Concern
+    include ActiveModel::AttributeMethods
+    include ActiveModel::Dirty
+
+    included do
+      attribute_method_suffix('', '=')
+      attribute :id, :read_only => true,
+                     :initial => :sequence,
+                     :type => :string
+    end
+
+    module ClassMethods
+      def attributes
+        @attributes ||= {}
+      end
+
+      def attribute(name, options = {})
+        instance = Attribute.new(name, options)
+        options = OptionsExpander.new(self, options)
+        self.attributes[name.to_sym] = instance
+        index(instance.indexed => name.to_sym) if instance.indexed?
+        instance
+      end
+
+      def attributes_key_name_for(id)
+        KeyNamer.attributes(self.to_s, :id => id)
+      end
+    end
+
+    module InstanceMethods
+      attr_reader :attributes
+
+      def initialize(attrs = {})
+        @attributes = {}.with_indifferent_access
+        @reloading = false
+        update_mem_attributes(attrs) unless attrs.empty?
+        set_default_attribute_values
+      end
+
+      # ActiveModel::AttributeMethods doesn't seem
+      # to generate a reader for id that uses
+      # #attributes["id"] in Ruby 1.8.7, so hard-coding
+      # it now
+      def id
+        @attributes["id"]
+      end
+
+      # Replace attribute values with the hash attrs
+      # Note: attrs keys can be strings or symbols
+      def update_mem_attributes(attrs)
+        @reloading = true
+        update_mem_attributes!(attrs)
+        @reloading = false
+      end
+
+      def update_mem_attributes!(attrs)
+        valid_keys = self.class.attributes.keys
+        attrs.symbolize_keys.slice(*valid_keys).each do |name, value|
+          send(:"#{name}=", value)
+        end
+        true
+      end
+
+      def update_mem_attributes(attrs)
+        valid_keys = self.class.attributes.keys
+        attrs.symbolize_keys.slice(*valid_keys).each do |name, value|
+          write_attribute(name, value)
+        end
+        true
+      end
+
+      private
+
+      def write_attribute(name, value)
+        converted = value.send(self.class.attributes[name].converter) unless value.nil?
+        return converted if @attributes[name] == converted
+        if @persisted_attributes && @persisted_attributes[name] == converted
+          @changed_attributes.delete(name.to_s)
+        else
+          attribute_will_change!(name.to_s)
+        end
+        @attributes[name] = converted
+      end
+
+      def attribute(name)
+        @attributes[name]
+      end
+
+      def attribute=(name, value)
+        raise ModelHasBeenDeleted.new("can't update attribute #{name}") if deleted?
+        assert_can_update!(name) unless @reloading
+        write_attribute(name.to_sym, value)
+      end
+
+      def assert_can_update!(name)
+        definition = self.class.attributes[name.to_sym]
+        if definition.read_only? && @attributes[name].present?
+          raise ReadOnlyAttribute.new("can't change #{name}")
+        end
+      end
+
+      def set_default_attribute_values
+        self.class.attributes.each do |name, attribute|
+          unless @attributes.has_key?(name)
+            @attributes[name] = if attribute.default_value?
+              attribute_will_change!(name.to_s)
+              attribute.default_value
+            else
+              nil
+            end
+          end
+        end
+      end
+
+      def set_initial_attribute_values
+        self.class.attributes.each do |name, attribute|
+          unless @attributes[name].present?
+            @attributes[name] = if attribute.initial_value?
+              attribute_will_change!(name.to_s)
+              attribute.initial_value
+            else
+              nil
+            end
+          end
+        end
+      end
+
+      def attributes_key_name
+        @attributes_key_name ||= self.class.attributes_key_name_for(id)
+      end
+
+      def attributes_synced_with_db!
+        @persisted_attributes = @attributes.clone
+        @previously_changed = changes
+        @changed_attributes.clear if @changed_attributes
+      end
+    end
+
+    class OptionsExpander
+      def initialize(model, opts = {})
+        opts.slice(:initial, :default).each do |name, value|
+          next unless value.is_a?(Symbol) && respond_to?(value)
+          opts[name] = send(value, model)
+        end
+        opts
+      end
+
+      def sequence(model)
+        key = KeyNamer.sequence(model, :type => "id")
+        Proc.new { model.redis.incr(key).to_s }
+      end
+    end
+  end
+end

data/lib/ricordami/has_indices.rb

@@ -0,0 +1,105 @@
+require "ricordami/has_attributes"
+require "ricordami/unique_index"
+require "ricordami/value_index"
+
+module Ricordami
+  module HasIndices
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def indices
+        @indices ||= {}
+      end
+
+      def index(options = {})
+        # for now we can only create unique indices
+        options.assert_valid_keys(:unique, :get_by, :value)
+        fields = options.delete(:unique)
+        return unique_index(fields, options) if fields.present?
+        field = options.delete(:value)
+        return value_index(field) if field.present?
+        raise InvalidIndexDefinition.new(self.class)
+      end
+
+      private
+
+      def add_index(index)
+        return false if self.indices.has_key?(index.name)
+        self.indices[index.name] = index
+      end
+
+      def value_index(field)
+        index = ValueIndex.new(self, field)
+        return nil unless add_index(index)
+        queue_saving_operations do |obj, session|
+          old_v = obj.send("#{field}_was")
+          new_v = obj.send(field)
+          next if old_v == new_v
+          if obj.persisted? && old_v.present?
+            indices[index.name].rem(obj.id, old_v)
+          end
+          indices[index.name].add(obj.id, new_v)
+        end
+        queue_deleting_operations do |obj, session|
+          if value = obj.send("#{field}_was")
+            indices[index.name].rem(obj.id, value, true).each do |command|
+              session.commands << command
+            end
+          end
+        end
+        index
+      end
+
+      def unique_index(fields, options = {})
+        create_unique_index(fields, options).tap do |index|
+          next if index.nil?
+          create_unique_get_method(index) if options[:get_by]
+        end
+      end
+
+      def create_unique_index(fields, options)
+        index = UniqueIndex.new(self, fields, options)
+        return nil unless add_index(index)
+        queue_saving_operations do |obj, session|
+          old_v = serialize_values(index.fields, obj, :previous => true)
+          new_v = serialize_values(index.fields, obj)
+          next if old_v == new_v
+          if obj.persisted? && old_v.present?
+            indices[index.name].rem(obj.id, old_v)
+          end
+          indices[index.name].add(obj.id, new_v)
+        end
+        queue_deleting_operations do |obj, session|
+          if value = serialize_values(index.fields, obj)
+            indices[index.name].rem(obj.id, value, true).each do |command|
+              session.commands << command
+            end
+          end
+        end
+        index
+      end
+
+      def create_unique_get_method(index)
+        meth = :"get_by_#{index.fields.map(&:to_s).join("-")}"
+        define_singleton_method(meth) do |*args|
+          all = redis.hgetall(index.ref_key_name)
+          id = index.id_for_values(*args)
+          get(id)
+        end
+      end
+
+      def serialize_values(fields, obj, opts = {})
+        fields.map do |f|
+          attr = opts[:previous] ? "#{f}_was" : f
+          obj.send(attr)
+        end.join(UniqueIndex::SEPARATOR)
+      end
+
+      def define_singleton_method(*args, &block)
+        class << self
+          self
+        end.send(:define_method, *args, &block)
+      end unless method_defined? :define_singleton_method
+    end
+  end
+end

data/lib/ricordami/is_lockable.rb

@@ -0,0 +1,52 @@
+require "ricordami/key_namer"
+
+module Ricordami
+  module IsLockable
+    extend ActiveSupport::Concern
+
+    module InstanceMethods
+      # Pretty much stolen from redis objects
+      # http://github.com/nateware/redis-objects/blob/master/lib/redis/lock.rb
+      def lock!(options = {}, &block)
+        key           = KeyNamer.lock(self.class, :id => id)
+        start         = Time.now
+        acquired_lock = false
+        expiration    = nil
+        expires_in    = options.fetch(:expiration, 15)
+        timeout       = options.fetch(:timeout, 1)
+
+        while (Time.now - start) < timeout
+          expiration    = generate_expiration(expires_in)
+          acquired_lock = redis.setnx(key, expiration)
+          break if acquired_lock
+
+          old_expiration = redis.get(key).to_f
+
+          if old_expiration < Time.now.to_f
+            expiration     = generate_expiration(expires_in)
+            old_expiration = redis.getset(key, expiration).to_f
+
+            if old_expiration < Time.now.to_f
+              acquired_lock = true
+              break
+            end
+          end
+
+          sleep 0.1
+        end
+
+        raise(LockTimeout.new(key, timeout)) unless acquired_lock
+
+        begin
+          yield
+        ensure
+          redis.del(key) if expiration > Time.now.to_f
+        end
+      end
+
+      def generate_expiration(expiration)
+        (Time.now + expiration.to_f).to_f
+      end
+    end
+  end
+end