ricordami 0.0.1

data/spec/ricordami/relationship_spec.rb

@@ -0,0 +1,123 @@
+require "spec_helper"
+require "ricordami/relationship"
+
+describe Ricordami::Relationship do
+  def valid_options
+    {:other => :blih, :self => :blah}
+  end
+  uses_constants("Stuff")
+  subject { Ricordami::Relationship }
+
+  describe "using most options" do
+    subject do
+      Ricordami::Relationship.new(:references_many, :other => :stuffs,
+                                  :as => :things, :self => :person,
+                                  :alias => :owner, :dependent => :delete)
+    end
+
+    it("has a type") { subject.type.should == :references_many }
+
+    it("has a name") { subject.name.should == :things }
+
+    it("has an object kind") { subject.object_kind.should == :stuff }
+
+    it("returns the object class") { subject.object_class.should == Stuff }
+
+    it("has a self kind") { subject.self_kind.should == :person }
+
+    it("has an alias") { subject.alias.should == :owner }
+
+    it("has a referrer id") { subject.referrer_id.should == "owner_id" }
+
+    it("has a dependent attribute") { subject.dependent.should == :delete }
+  end
+
+  describe "other cases" do
+    it "can specify an optional dependent option" do
+      relationship = subject.new(:references_many, valid_options.merge(:dependent => :delete))
+      relationship.dependent.should == :delete
+    end
+
+    it "deducts the object kind from the other parameter" do
+      relationship = subject.new(:references_many, valid_options.merge(:other => :stuffs))
+      relationship.name.should == :stuffs
+      relationship.object_kind.should == :stuff
+    end
+
+    it "can specify an optional as option that is the relationship name" do
+      relationship = subject.new(:references_many, valid_options.merge(:other => :stuffs, :as => :things))
+      relationship.name.should == :things
+      relationship.object_kind.should == :stuff
+    end
+
+    it "deducts the referrer id from the other or as parameter for a referenced_in relationship" do
+      relationship = subject.new(:referenced_in, :self => :ingredient, :other => :cook)
+      relationship.referrer_id.should == "cook_id"
+      relationship = subject.new(:referenced_in, :self => :ingredient, :other => :cook, :as => :chef)
+      relationship.referrer_id.should == "chef_id"
+    end
+
+    it "deducts the referrer id from the self or alias parameter for a references_many relationship" do
+      relationship = subject.new(:references_many, :self => :cook, :other => :ingredients)
+      relationship.referrer_id.should == "cook_id"
+      relationship = subject.new(:references_many, :self => :cook, :alias => :chef, :other => :ingredients, :as => :stuff)
+      relationship.referrer_id.should == "chef_id"
+    end
+
+    it "deducts the referrer id from the self or alias parameter for a references_one relationship" do
+      relationship = subject.new(:references_one, :self => :cook, :other => :hat)
+      relationship.referrer_id.should == "cook_id"
+      relationship = subject.new(:references_one, :self => :cook, :alias => :chef, :other => :hat, :as => :toque)
+      relationship.referrer_id.should == "chef_id"
+    end
+
+    it "can specify an optional alias that is the relationship name for the other party" do
+      relationship = subject.new(:references_many, valid_options.merge(:self => :person, :alias => :owners))
+      relationship.alias.should == :owners
+      relationship.self_kind.should == :person
+    end
+  end
+
+  describe "error cases" do
+    it "raises an error if all the mandatory parameters are not present" do
+      [{}, {:other => :blah}, {:self => :blih}].each do |options|
+        lambda {
+          subject.new(:references_many, options)
+        }.should raise_error(Ricordami::MissingMandatoryArgs)
+      end
+    end
+
+    it "doesn't raise an error if all mandatory parameters are present" do
+      lambda {
+        subject.new(:referenced_in, :other => :blah, :self => :blih)
+      }.should_not raise_error
+    end
+
+    it "raises an error if the type is not supported" do
+      lambda { subject.new(:references_many, valid_options) }.should_not raise_error
+      lambda { subject.new(:referenced_in, valid_options) }.should_not raise_error
+      lambda { subject.new(:references_one, valid_options) }.should_not raise_error
+      lambda {
+        subject.new(:blah, valid_options)
+      }.should raise_error(Ricordami::TypeNotSupported)
+    end
+
+    it "raises an error if dependent is set but not equal to :nullify or :delete" do
+      lambda {
+        subject.new(:references_many, valid_options.merge(:dependent => :nullify))
+      }.should_not raise_error
+      lambda {
+        subject.new(:references_many, valid_options.merge(:dependent => :delete))
+      }.should_not raise_error
+      lambda {
+        subject.new(:references_many, valid_options.merge(:dependent => :what))
+      }.should raise_error(Ricordami::OptionValueInvalid)
+    end
+
+    it "raises an error if an option is not supported" do
+      lambda {
+        subject.new(:references_many, valid_options.merge(:not_supported => :blah))
+      }.should raise_error(ArgumentError)
+    end
+  end
+end

data/spec/ricordami/unique_index_spec.rb

@@ -0,0 +1,87 @@
+require "spec_helper"
+
+describe Ricordami::UniqueIndex do
+  subject { Ricordami::UniqueIndex }
+
+  before(:each) do
+    create_constant("DataSource")
+    DataSource.attribute :name
+    @index = subject.new(DataSource, :id)
+  end
+
+  it "is initialized with a model, a name and the fields to be unique" do
+    @index.model.should == DataSource
+    @index.fields.should == [:id]
+    @index.name.should == :id
+  end
+
+  it "returns its internal index name with #uidx_key_name" do
+    @index.uidx_key_name.should == "DataSource:udx:id"
+  end
+
+  it "returns its internal reference name with #ref_key_name" do
+    @index.ref_key_name.should == "DataSource:hsh:id_to_id"
+  end
+
+  it "adds a string to the index with #add" do
+    @index.add("ze-id", "allo")
+    Ricordami.driver.smembers("DataSource:udx:id").should == ["allo"]
+  end
+
+  it "also indices the hash index with #add if fields is not :id and :get_by is true" do
+    DataSource.attribute :domain
+    other = subject.new(DataSource, [:name, :domain], :get_by => true)
+    other.add("ze-id", ["jobs", "apple.com"])
+    Ricordami.driver.smembers("DataSource:udx:name_domain").should == ["jobs_-::-_apple.com"]
+    Ricordami.driver.hget("DataSource:hsh:name_domain_to_id", "jobs_-::-_apple.com").should == "ze-id"
+  end
+
+  it "doesn't index the has index with #add if :get_by is false or fields is :id" do
+    one = subject.new(DataSource, :name)
+    one.add("ze-id", "jobs")
+    Ricordami.driver.hexists("DataSource:hsh:name_to_id", "jobs").should be_false
+    two = subject.new(DataSource, :id, :get_by => true)
+    two.add("ze-id", "ze-id")
+    Ricordami.driver.hexists("DataSource:hsh:id_to_id", "ze-id").should be_false
+    three = subject.new(DataSource, :name, :get_by => true)
+    three.add("ze-id", "jobs")
+    Ricordami.driver.hexists("DataSource:hsh:name_to_id", "jobs").should be_true
+  end
+
+  it "returns the id from values with #id_for_values if :get_by is true" do
+    DataSource.attribute :domain
+    two_fields = subject.new(DataSource, [:name, :domain], :get_by => true)
+    two_fields.add("ze-id", ["jobs", "apple.com"])
+    two_fields.id_for_values("jobs", "apple.com").should == "ze-id"
+    one_field = subject.new(DataSource, :name, :get_by => true)
+    one_field.add("ze-id", "jobs")
+    one_field.id_for_values("jobs").should == "ze-id"
+  end
+
+  it "removes a string from the index with #rem" do
+    @index.add("ze-id", "allo")
+    @index.rem("ze-id", "allo")
+    Ricordami.driver.smembers("DataSource:udx:id").should == []
+  end
+
+  it "returns the redis command(s) to remove the value from the index when return_command is true" do
+    command = @index.rem("ze-id", "allo", true)
+    command.should == [[:srem, ["DataSource:udx:id", "allo"]]]
+  end
+
+  it "returns the number of entries with #count" do
+    5.times { |i| @index.add("ze-id", i.to_s) }
+    @index.count.should == 5
+  end
+
+  it "returns all the strings from the index with #all" do
+    %w(allo la terre).each { |v| @index.add("ze-id", v) }
+    @index.all.should =~ ["allo", "la", "terre"]
+  end
+
+  it "returns if a string already exists with #include?" do
+    %w(allo la terre).each { |v| @index.add("ze-id", v) }
+    @index.should include("terre")
+    @index.should_not include("earth")
+  end
+end

data/spec/ricordami/unique_validator_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+require "ricordami/can_be_validated"
+
+describe Ricordami::UniqueValidator do
+  uses_constants("Call")
+
+  before(:each) do
+    Call.send(:include, Ricordami::CanBeValidated)
+    Call.attribute :name
+  end
+  let(:record) { Call.new(:name => "sophie") }
+  let(:validator) { Ricordami::UniqueValidator.new(:attributes => [:name]) }
+
+  it "is an active model EachValidator" do
+    validator.is_a?(ActiveModel::EachValidator)
+  end
+
+  it "#setup adds a unique index" do
+    validator.setup(Call)
+    Call.indices[:name].should be_a(Ricordami::UniqueIndex)
+  end
+
+  it "#validate_each adds an error if the value is already used" do
+    validator.setup(Call)
+    record.save
+
+    sophie = Call.new(:name => "sophie")
+    validator.validate_each(sophie, :name, record.name)
+    sophie.should have(1).error
+    sophie.errors[:name].should == ["is already used"]
+  end
+
+  it "accepts an option :message to change the error message" do
+    validator = Ricordami::UniqueValidator.new(:attributes => [:name], :message => "come on, man!")
+    validator.setup(Call)
+    record.save
+    sophie = Call.new(:name => "sophie")
+    validator.validate_each(sophie, :name, record.name)
+    sophie.errors[:name].should == ["come on, man!"]
+  end
+end

data/spec/ricordami/value_index_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+require "ricordami/value_index"
+
+describe Ricordami::ValueIndex do
+  subject { Ricordami::ValueIndex }
+
+  before(:each) do
+    create_constant("Friend")
+    Friend.attribute :first_name
+    @index = subject.new(Friend, :first_name)
+  end
+  let(:index) { @index }
+
+  it "is initialized with a model, a name and a field" do
+    index.model.should == Friend
+    index.field.should == :first_name
+    index.name.should == :first_name
+  end
+
+  it "has a key name for each distinct value with #key_name_for_value" do
+    index.key_name_for_value("VALUE").should == "Friend:idx:first_name:VkFMVUU="
+  end
+
+  it "adds the id to the index value with #add" do
+    index.add("3", "VALUE")
+    Ricordami.driver.smembers("Friend:idx:first_name:VkFMVUU=").should == ["3"]
+  end
+
+  it "removes the id from the index value with #rem" do
+    index.add("1", "VALUE")
+    index.add("2", "VALUE")
+    index.rem("1", "VALUE")
+    Ricordami.driver.smembers("Friend:idx:first_name:VkFMVUU=").should == ["2"]
+  end
+
+  it "returns the redis command to remove the value from the index when return_command is true" do
+    commands = index.rem("1", "VALUE", true)
+    commands.should == [[:srem, ["Friend:idx:first_name:VkFMVUU=", "1"]]]
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+spec_dir = Pathname.new(File.dirname(__FILE__))
+$LOAD_PATH.unshift spec_dir
+
+require "rubygems"
+require "bundler"
+
+Bundler.setup :default, :test
+ENV['RACK_ENV'] ||= "test"
+
+require "rspec"
+require "support/constants"
+require "support/db_manager"
+require "awesome_print"
+
+RSpec.configure do |config|
+  config.include Support::Constants
+  config.include Support::DbManager
+  config.before(:each) do
+    Ricordami.configure do |config|
+      config.from_hash(:redis_host  => "127.0.0.1",
+                       :redis_port  => 6379,
+                       :redis_db    => 7,
+                       :thread_safe => true)
+    end
+    Ricordami.driver.flushdb
+  end
+end
+
+require spec_dir + "../lib/ricordami"

data/spec/support/constants.rb

@@ -0,0 +1,43 @@
+# copied from toystore gem (https://github.com/newtoy/toystore/raw/master/spec/support/constants.rb)
+# and a bit updated for ricordami
+
+module Support
+  module Constants
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def uses_constants(*constants)
+        before { create_constants(*constants) }
+      end
+    end
+
+    def create_constants(*constants)
+      constants.each { |constant| create_constant(constant) }
+    end
+
+    def remove_constants(*constants)
+      constants.each { |constant| remove_constant(constant) }
+    end
+
+    def create_constant(constant)
+      remove_constant(constant)
+      Object.const_set(constant, Model(constant))
+    end
+
+    def remove_constant(constant)
+      Object.send(:remove_const, constant) if Object.const_defined?(constant)
+    end
+
+    def Model(name=nil)
+      Class.new.tap do |model|
+        model.class_eval """
+          def self.name; '#{name}' end
+          def self.to_s; '#{name}' end
+        """ if name
+        model.send(:include, Ricordami::Model)
+      end
+    end
+  end
+end

data/spec/support/db_manager.rb

@@ -0,0 +1,18 @@
+module Support
+  module DbManager
+    def switch_db_to_error
+      @_db_mode_error = true
+      error = Object.new
+      def error.method_missing(meth, *args, &blk)
+        raise Errno::ECONNREFUSED
+      end
+      Ricordami.instance_eval { @driver = error }
+    end
+
+    def switch_db_to_ok
+      return unless @_db_mode_error
+      Ricordami.instance_eval { @driver = nil }
+      @_db_mode_error = false
+    end
+  end
+end

data/test/bin/data_loader.rb

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+require "bundler"
+Bundler.setup :default, :development
+
+require "thor"
+require "thor/actions"
+require "csv"
+require "redis"
+
+class DataLoader < Thor
+  include Thor::Actions
+
+  add_runtime_options!
+  check_unknown_options!
+
+  desc "generate_people FILE_NAME", "Generate a CSV file of random people"
+  method_option :number, :aliases => "-n", :default => 1_000, :type => :numeric, :desc => "number of people to generate"
+
+  def generate_people(file_name)
+    d = load_data
+    CSV.open(file_name, "w") do |csv|
+      csv << %w(first_name last_name email age)
+      options[:number].times do
+        f, l = get_first_name(d), get_last_name(d)
+        csv << [f, l, get_email(d, f, l), get_age]
+      end
+    end
+    puts "File #{file_name} generated with #{options[:number]} people."
+  end
+
+  desc "load_people FILE_NAME", "Load a people file into Redis"
+  method_option :db, :aliases => "-d", :default => 1, :type => :numeric, :desc => "database number"
+
+  def load_people(file_name)
+    r = Redis.new
+    r.select(options[:db])
+    r.flushdb
+    key_ids = "global:people:ids"
+    key_att = "people:"
+    key_seq = "global:seq_id"
+    i = 0
+    CSV.foreach(file_name, :headers => :first_row) do |row|
+      id = r.incr(key_seq)
+      r.multi
+      r.hmset("#{key_att}#{id}", *row.to_a.flatten)
+      r.sadd(key_ids, id)
+      r.exec
+      i += 1
+      if i == 100
+        putc "."
+        i = 0
+      end
+    end
+    puts
+    puts "Db loaded."
+  end
+
+  private
+
+  def load_data
+    data_dir = File.expand_path("../../data", __FILE__)
+    {
+      :first    => read_entries(File.join(data_dir, "first_names.txt")),
+      :last     => read_entries(File.join(data_dir, "last_names.txt")),
+      :domains  => read_entries(File.join(data_dir, "domains.txt"))
+    }
+  end
+
+  def read_entries(path)
+    [].tap do |entries|
+      File.open(path, "r") do |f|
+        f.each_line { |line| entries.push(line.chomp.downcase.capitalize) }
+      end
+    end
+  end
+
+  def get_first_name(d)
+    d[:first].sample(rand(12) == 3 ? 2 : 1).join(" ")
+  end
+
+  def get_last_name(d)
+    d[:last].sample
+  end
+
+  def get_email(d, f, l)
+    one = f[0..(rand(2) - 2)].downcase
+    dot = rand(2) == 0 ? "" : "."
+    two = l.split.join("-").downcase
+    "#{one}#{dot}#{two}@#{d[:domains].sample}"
+  end
+
+  def get_age
+    18 + rand(50)
+  end
+end
+
+require "rubygems" if RUBY_VERSION[0..2].to_f < 1.9
+
+begin
+  DataLoader.start
+rescue Exception => ex
+  STDERR.puts "#{File.basename(__FILE__)}: #{ex}"
+  raise
+end
+