ricordami 0.0.1

data/lib/ricordami/is_persisted.rb

@@ -0,0 +1,123 @@
+require "ricordami/has_attributes"
+
+module Ricordami
+  module IsPersisted
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      attr_reader :save_queue, :delete_queue
+
+      def create(*args)
+        new(*args).tap do |instance|
+          instance.save
+        end
+      end
+
+      def load_attributes_for(id)
+        key_name = attributes_key_name_for(id)
+        redis.hgetall(key_name)
+      end
+
+      [[:saving, :save_queue], [:deleting, :delete_queue]].each do |action, queue|
+        var_name = :"@#{queue}"
+        define_method(:"queue_#{action}_operations") do |&block|
+          raise ArgumentError.new("missing block") unless block
+          raise ArgumentError.new("expecting block with 2 arguments") unless block.arity == 2
+          instance_variable_set(var_name, []) unless instance_variable_get(var_name)
+          instance_variable_get(var_name) << block
+        end
+      end
+
+      def redis
+        @redis ||= Ricordami.driver
+      end
+    end
+
+    module InstanceMethods
+      def initialize(*args)
+        super(*args)
+        @persisted = false unless instance_variable_defined?(:@persisted)
+        @deleted = false
+      end
+
+      def persisted?
+        @persisted
+      end
+
+      def new_record?
+        !@persisted
+      end
+
+      def deleted?
+        @deleted
+      end
+
+      def save(opts = {})
+        raise ModelHasBeenDeleted.new("can't save a deleted model") if deleted?
+        set_initial_attribute_values if new_record?
+        redis.tap do |driver|
+          session = {}
+          driver.multi
+          driver.hmset(attributes_key_name, *attributes.to_a.flatten)
+          self.class.save_queue.each { |block| block.call(self, session) } if self.class.save_queue
+          driver.exec
+        end
+        @persisted = true
+        attributes_synced_with_db!
+      rescue Exception => ex
+        raise ex if ex.is_a?(ModelHasBeenDeleted)
+        false
+      end
+
+      def reload
+        attrs = self.class.send(:load_attributes_for, id)
+        update_mem_attributes(attrs) unless attrs.empty?
+        attributes_synced_with_db!
+        self
+      end
+
+      def update_attributes(attrs)
+        raise ModelHasBeenDeleted.new("can't update the attributes of a deleted model") if deleted?
+        update_mem_attributes!(attrs) unless attrs.empty?
+        save
+      end
+
+      def delete
+        raise ModelHasBeenDeleted.new("can't delete a model already deleted") if deleted?
+        db_commands, models = [], []
+        # TODO: use watch (Redis 2.2) and re-run prepare + execute if change
+        session = Struct.new(:models, :commands).new(models, db_commands)
+        prepare_delete(session)
+        execute_delete(db_commands)
+        models.each { |model| model.mark_as_deleted }
+      end
+
+      def prepare_delete(session)
+        session.models << self
+        session.commands << [:del, [attributes_key_name]]
+        self.class.delete_queue.reverse.each { |block| block.call(self, session) } if self.class.delete_queue
+      end
+
+      def execute_delete(db_commands)
+        redis.tap do |driver|
+          driver.multi
+          db_commands.each do |message, args|
+            driver.send(message, *args)
+          end
+          driver.exec
+        end
+      end
+
+      def mark_as_deleted
+        attributes_synced_with_db!
+        @deleted = true
+        freeze
+        true
+      end
+
+      def redis
+        self.class.redis
+      end
+    end
+  end
+end

data/lib/ricordami/is_retrievable.rb

@@ -0,0 +1,35 @@
+require "ricordami/is_persisted"
+require "ricordami/has_indices"
+
+module Ricordami
+  module IsRetrievable
+    extend ActiveSupport::Concern
+
+    included do
+      index :unique => :id
+    end
+
+    module ClassMethods
+      def get(id)
+        attributes = load_attributes_for(id)
+        raise NotFound.new("id = #{id}") if attributes.empty?
+        new(attributes).tap do |instance|
+          instance.instance_eval do
+            @persisted = true
+            attributes_synced_with_db!
+          end
+        end
+      end
+      alias :[] :get
+
+      def all(expressions = nil)
+        ids = indices[:id].all
+        ids.map { |id| get(id) }
+      end
+
+      def count
+        indices[:id].count
+      end
+    end
+  end
+end

data/lib/ricordami/key_namer.rb

@@ -0,0 +1,63 @@
+require "base64"
+
+module Ricordami
+  module KeyNamer
+    extend self
+
+    def sequence(model, opts = {})
+      "#{model}:seq:#{opts[:type]}"
+    end
+
+    def attributes(model, opts = {})
+        "#{model}:att:#{opts[:id]}"
+    end
+
+    def unique_index(model, opts = {})
+      "#{model}:udx:#{opts[:name]}"
+    end
+
+    def hash_ref(model, opts = {})
+      fields = opts[:fields].join("_") + "_to_id"
+      "#{model}:hsh:#{fields}"
+    end
+
+    def index(model, opts = {})
+      value = encode(opts[:value])
+      "#{model}:idx:#{opts[:field]}:#{value}"
+    end
+
+    def volatile_set(model, opts = {})
+      info = opts[:info].dup
+      op = info.shift
+      if info.empty?
+        info = [op]
+      else
+        info = ["#{op}(#{info.join(",")})"]
+      end
+      unless opts[:key].nil?
+        key = opts[:key].sub("~:#{model}:set:", "")
+        info.unshift(key)
+      end
+      "~:#{model}:set:#{info.join(":")}"
+    end
+
+    def temporary(model)
+      lock_id = model.redis.incr("#{model}:seq:lock")
+      "#{model}:val:_tmp:#{lock_id}"
+    end
+
+    def lock(model, opts = {})
+      "#{model}:val:#{opts[:id]}:_lock"
+    end
+
+    def sort(model, opts = {})
+      "#{model}:att:*->#{opts[:sort_by]}"
+    end
+
+    private
+
+    def encode(value)
+      Base64.encode64(value.to_s).gsub("\n", "")
+    end
+  end
+end

data/lib/ricordami/model.rb

@@ -0,0 +1,29 @@
+module Ricordami
+  module Model
+    extend ActiveSupport::Concern
+
+    included do
+      extend  ActiveModel::Naming
+      include ActiveModel::Conversion
+      include ActiveModel::AttributeMethods
+      include IsLockable
+      include HasAttributes
+      include HasIndices
+      include IsPersisted
+      include IsRetrievable
+    end
+
+    module ClassMethods
+      def model_can(*features)
+        features.each do |feature|
+          require File.expand_path("../can_#{feature}", __FILE__)
+          feature_module = Ricordami.const_get(:"Can#{feature.to_s.camelize}")
+          include feature_module
+        end
+      end
+    end
+  end
+
+  include Configuration
+  include Connection
+end

data/lib/ricordami/query.rb

@@ -0,0 +1,68 @@
+module Ricordami
+  class Query
+    attr_reader :expressions, :runner, :builder, :sort_by, :sort_dir
+
+    def initialize(runner, builder = nil)
+      @expressions = []
+      @runner = runner
+      @builder = builder || runner
+    end
+
+    [:and, :not, :any].each do |op|
+      define_method(op) do |*args|
+        options = args.first || {}
+        @expressions << [op, options.dup]
+        self
+      end
+    end
+    alias :where :and
+
+    [:all, :paginate, :first, :last, :rand].each do |cmd|
+      define_method(cmd) do |*args|
+        return runner unless runner.respond_to?(cmd)
+        options = args.first || {}
+        options[:expressions] = expressions
+        options[:sort_by] = @sort_by unless @sort_by.nil?
+        options[:order] = order_for(@sort_dir) unless @sort_dir.nil?
+        runner.send(cmd, options)
+      end
+    end
+
+    def sort(attribute, dir = :asc_alpha)
+      unless [:asc_alpha, :asc_num, :desc_alpha, :desc_num].include?(dir)
+        raise ArgumentError.new("sorting direction #{dir.inspect} is invalid")
+      end
+      @sort_by, @sort_dir = attribute, dir
+      self
+    end
+
+    def build(attributes = {})
+      initial_values = {}
+      expressions.each do |operation, filters|
+        next unless operation == :and
+        initial_values.merge!(filters)
+      end
+      obj = builder.new(initial_values.merge(attributes))
+    end
+
+    def create(attributes = {})
+      build(attributes).tap { |obj| obj.save }
+    end
+
+    private
+
+    def order_for(dir)
+      case dir
+      when nil         then nil
+      when :asc_alpha  then "ALPHA ASC"
+      when :asc_num    then "ASC"
+      when :desc_alpha then "ALPHA DESC"
+      else                  "DESC"
+      end
+    end
+
+    def method_missing(meth, *args, &blk)
+      all.send(meth, *args, &blk)
+    end
+  end
+end

data/lib/ricordami/relationship.rb

@@ -0,0 +1,40 @@
+module Ricordami
+  class Relationship
+    SUPPORTED_TYPES = [:references_many, :references_one, :referenced_in]
+    MANDATORY_ARGS = [:other, :self]
+
+    attr_reader :type, :name, :object_kind, :dependent, :self_kind, :alias
+
+    def initialize(type, options = {})
+      options.assert_valid_keys(:other, :as, :self, :alias, :dependent)
+      raise TypeNotSupported.new(type.to_s) unless SUPPORTED_TYPES.include?(type)
+      missing = find_missing_args(options)
+      raise MissingMandatoryArgs.new(missing.map(&:to_s).join(", ")) unless missing.empty?
+      if options[:dependent] && ![:delete, :nullify].include?(options[:dependent])
+        raise OptionValueInvalid.new(options[:dependent].to_s)
+      end
+      @name = options[:as] || options[:other]
+      @type = type
+      @object_kind = options[:other].to_s.singularize.to_sym
+      @self_kind = options[:self].to_s.singularize.to_sym
+      @alias = options[:alias] || options[:self]
+      @dependent = options[:dependent]
+    end
+
+    def object_class
+      @object_kind.to_s.camelize.constantize
+    end
+
+    def referrer_id
+      return @referrer_id unless @referrer_id.nil?
+      referrer = type == :referenced_in ? @name.to_s : @alias.to_s.singularize
+      @referrer_id = referrer.foreign_key
+    end
+
+    private
+
+    def find_missing_args(options)
+      MANDATORY_ARGS - options.keys
+    end
+  end
+end

data/lib/ricordami/unique_index.rb

@@ -0,0 +1,59 @@
+require "ricordami/key_namer"
+
+module Ricordami
+  class UniqueIndex
+    SEPARATOR = "_-::-_"
+
+    attr_reader :model, :fields, :name, :need_get_by
+
+    def initialize(model, fields, options = {})
+      @model = model
+      @fields = [fields].flatten.map(&:to_sym)
+      @need_get_by = options[:get_by] && @fields != [:id]
+      @name = @fields.join("_").to_sym
+    end
+
+    def uidx_key_name
+      @uidx_key_name ||= KeyNamer.unique_index(@model, :name => @name)
+    end
+
+    def ref_key_name
+      @ref_key_name ||= KeyNamer.hash_ref(@model, :fields => @fields)
+    end
+
+    def add(id, value)
+      value = value.join(SEPARATOR) if value.is_a?(Array)
+      @model.redis.sadd(uidx_key_name, value)
+      @model.redis.hset(ref_key_name, value, id) if @need_get_by
+    end
+
+    def rem(id, value, return_command = false)
+      if return_command
+        commands = []
+        commands << [:hdel, [ref_key_name, id]] if @need_get_by
+        commands << [:srem, [uidx_key_name, value]]
+        return commands
+      end
+      @model.redis.hdel(ref_key_name, id) if @need_get_by
+      value = value.join(SEPARATOR) if value.is_a?(Array)
+      @model.redis.srem(uidx_key_name, value)
+    end
+
+    def id_for_values(*values)
+      values = values.flatten.join(SEPARATOR)
+      @model.redis.hget(ref_key_name, values)
+    end
+
+    def all
+      @model.redis.smembers(uidx_key_name)
+    end
+
+    def count
+      @model.redis.scard(uidx_key_name)
+    end
+
+    def include?(value)
+      @model.redis.sismember(uidx_key_name, value)
+    end
+  end
+end

data/lib/ricordami/unique_validator.rb

@@ -0,0 +1,21 @@
+require "active_model/validator"
+
+module Ricordami
+  class UniqueValidator < ActiveModel::EachValidator
+    def validate_each(record, attribute, value)
+      return true unless record.new_record? || record.send(:attribute_changed?, attribute)
+      index_name = attribute.to_sym
+      index = record.class.indices[index_name]
+      if index.include?(value)
+        attr_def = record.class.attributes[attribute]
+        unless record.persisted? && attr_def.read_only?
+          record.errors.add(attribute, options[:message] || "is already used")
+        end
+      end
+    end
+
+    def setup(klass)
+      attributes.each { |attribute| klass.index :unique => attribute }
+    end
+  end
+end

data/lib/ricordami/value_index.rb

@@ -0,0 +1,26 @@
+require "ricordami/key_namer"
+
+module Ricordami
+  class ValueIndex
+    attr_reader :model, :field, :name
+
+    def initialize(model, field)
+      @model = model
+      @field = field.to_sym
+      @name = @field
+    end
+
+    def key_name_for_value(value)
+      KeyNamer.index(@model, :field => @field, :value => value)
+    end
+
+    def add(id, value)
+      @model.redis.sadd(key_name_for_value(value), id)
+    end
+
+    def rem(id, value, return_command = false)
+      return [[:srem, [key_name_for_value(value), id]]] if return_command
+      @model.redis.srem(key_name_for_value(value), id)
+    end
+  end
+end

data/lib/ricordami/version.rb

@@ -0,0 +1,3 @@
+module Ricordami
+  VERSION = "0.0.1"
+end

data/lib/ricordami.rb

@@ -0,0 +1,26 @@
+require "digest/sha1"
+
+require "active_support/concern"
+require "active_support/core_ext/hash/slice"
+require "active_support/core_ext/hash/keys"
+require "active_support/core_ext/hash/indifferent_access"
+require "active_support/core_ext/object/blank"
+require "active_model"
+require "active_model/naming"
+require "active_model/conversion"
+require "active_model/attribute_methods"
+require "redis"
+
+module Ricordami
+  extend self
+end
+
+require "ricordami/exceptions"
+require "ricordami/configuration"
+require "ricordami/connection"
+require "ricordami/has_attributes"
+require "ricordami/has_indices"
+require "ricordami/is_lockable"
+require "ricordami/is_persisted"
+require "ricordami/is_retrievable"
+require "ricordami/model"

data/spec/acceptance/manage_relationships_spec.rb

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+require "acceptance_helper"
+require "ricordami/can_have_relationships"
+
+class Performer
+  include Ricordami::Model
+  include Ricordami::CanHaveRelationships
+
+  attribute :first_name
+  attribute :last_name
+
+  references_many :albums, :dependent => :delete
+end
+
+class Album
+  include Ricordami::Model
+  include Ricordami::CanHaveRelationships
+
+  attribute :title
+  attribute :year, :indexed => :value
+
+  referenced_in :performer
+end
+
+feature "Manage relationships" do
+  scenario "has many / belongs to" do
+    serge = Performer.create(:first_name => "Serge", :last_name => "Gainsbourg")
+    serge.albums.create(:title => "Melody Nelson", :year => "1971").should be_true
+
+    marseillaise = serge.albums.build(:title => "Aux Armes et cætera", :year => "1979")
+    marseillaise.save.should be_true
+
+    performer = Performer.first
+    performer.albums.map(&:title).should =~ ["Melody Nelson", "Aux Armes et cætera"]
+    performer.albums.where(:year => "1979").map(&:title).should =~ ["Aux Armes et cætera"]
+    performer.albums.sort(:year, :desc_num).map(&:title).should == ["Aux Armes et cætera", "Melody Nelson"]
+
+    Album.all.map(&:title).should =~ ["Melody Nelson", "Aux Armes et cætera"]
+    performer.delete
+    Album.all.should be_empty
+  end
+end

data/spec/acceptance/model_with_validation_spec.rb

@@ -0,0 +1,78 @@
+require "acceptance_helper"
+require "ricordami/can_be_validated"
+
+class Singer
+  include Ricordami::Model
+  include Ricordami::CanBeValidated
+
+  attribute :username
+  attribute :email
+  attribute :first_name
+  attribute :last_name
+  attribute :deceased, :default => "false", :indexed => :value
+
+  index :unique => :username, :get_by => true
+
+  validates_presence_of   :username, :email, :deceased
+  validates_uniqueness_of :username
+  validates_format_of     :email, :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i,
+                                  :allow_blank => true, :message => "is not a valid email"
+  validates_inclusion_of  :deceased, :in => ["true", "false"]
+end
+
+feature "Basic model features with validation" do
+  scenario "validate, update, save and delete a model" do
+    serge = Singer.new
+    serge.should_not be_valid
+    serge.should have(2).errors
+    serge.errors.full_messages.should =~ ["Email can't be blank", "Username can't be blank"]
+
+    serge.email = "what's up?"
+    serge.save.should be_false
+    serge.errors[:email].should == ["is not a valid email"]
+
+    serge.update_attributes(:username => "lucien", :email => "serge@gainsbourg.com",
+                            :first_name => "Serge", :last_name => "Gainsbourg")
+    serge.should be_valid
+    serge.should be_persisted
+    serge.should_not be_a_new_record
+    serge.reload.should be_persisted
+
+    lucien = Singer.new(:username => "lucien", :email => "lucien@blahblah.com")
+    lucien.should_not be_valid
+    lucien.errors.full_messages.should == ["Username is already used"]
+    lucien.username = "lucien2"
+    lucien.save.should be_true
+    lucien.should be_persisted
+
+    Singer.count.should == 2
+    deleteme = Singer.get_by_username("lucien2")
+    deleteme.delete
+    deleteme.should be_deleted
+    Singer.count.should == 1
+    Singer.get_by_username("lucien").should be_persisted
+  end
+
+  scenario "dirty state of models" do
+    Singer.create(:username => "bashung", :email => "alain@bashung.com",
+                   :first_name => "Alain", :last_name => "Bashung")
+    alain = Singer.get_by_username("bashung")
+    alain.changed?.should be_false
+
+    alain.first_name = "Bob"
+    alain.changed?.should be_true
+    alain.first_name_changed?.should be_true
+    alain.first_name_was.should == "Alain"
+    alain.first_name_change.should == ["Alain", "Bob"]
+    alain.changed.should == ["first_name"]
+    alain.changes.should == {"first_name" => ["Alain", "Bob"]}
+
+    alain.save
+    alain.changed?.should be_false
+    alain.first_name_changed?.should be_false
+    alain.first_name = "Bob"
+    alain.changed?.should be_false
+    alain.first_name_changed?.should be_false
+    alain.previous_changes.should == {"first_name" => ["Alain", "Bob"]}
+  end
+end