ohm 1.4.0 → 2.0.0.alpha1

data/lib/ohm/command.rb

@@ -16,14 +16,17 @@ module Ohm
       @keys = []
     end
 
-    def call(nest, db)
-      newkey(nest) do |key|
-        db.send(@operation, key, *params(nest, db))
+    def call(nido, redis)
+      newkey(nido, redis) do |key|
+        redis.call(@operation, key, *params(nido, redis))
       end
     end
 
     def clean
-      keys.each { |key| key.del }
+      keys.each do |key, redis|
+        redis.call("DEL", key)
+      end
+
       subcommands.each { |cmd| cmd.clean }
     end
 
@@ -32,15 +35,16 @@ module Ohm
       args.select { |arg| arg.respond_to?(:call) }
     end
 
-    def params(nest, db)
-      args.map { |arg| arg.respond_to?(:call) ? arg.call(nest, db) : arg }
+    def params(nido, redis)
+      args.map { |arg| arg.respond_to?(:call) ? arg.call(nido, redis) : arg }
     end
 
-    def newkey(nest)
-      key = nest[SecureRandom.hex(32)]
-      keys << key
+    def newkey(nido, redis)
+      key = nido[SecureRandom.hex(32)]
+      keys << [key, redis]
+
+      yield key
 
-      yield  key
       return key
     end
   end

data/lib/ohm/lua/delete.lua

@@ -0,0 +1,51 @@
+local model       = cmsgpack.unpack(ARGV[1])
+local uniques     = cmsgpack.unpack(ARGV[2])
+local collections = cmsgpack.unpack(ARGV[3])
+
+local function remove_indices(model)
+  local memo = model.key .. ":_indices"
+  local existing = redis.call("SMEMBERS", memo)
+
+  for _, key in ipairs(existing) do
+    redis.call("SREM", key, model.id)
+    redis.call("SREM", memo, key)
+  end
+end
+
+local function remove_uniques(model, uniques)
+  local memo = model.key .. ":_uniques"
+
+  for field, _ in pairs(uniques) do
+    local key = model.name .. ":uniques:" .. field
+
+    redis.call("HDEL", key, redis.call("HGET", memo, key))
+    redis.call("HDEL", memo, key)
+  end
+end
+
+local function remove_collections(model, collections)
+  for _, collection in ipairs(collections) do
+    local key = model.key .. ":" .. collection
+
+    redis.call("DEL", key)
+  end
+end
+
+local function delete(model)
+  local keys = {
+    model.key .. ":counters",
+    model.key .. ":_indices",
+    model.key .. ":_uniques",
+    model.key
+  }
+
+  redis.call("SREM", model.name .. ":all", model.id)
+  redis.call("DEL", unpack(keys))
+end
+
+remove_indices(model)
+remove_uniques(model, uniques)
+remove_collections(model, collections)
+delete(model)
+
+return model.id

data/lib/ohm/lua/save.lua

@@ -0,0 +1,104 @@
+local model      = cmsgpack.unpack(ARGV[1])
+local attrs      = cmsgpack.unpack(ARGV[2])
+local indices    = cmsgpack.unpack(ARGV[3])
+local uniques    = cmsgpack.unpack(ARGV[4])
+
+local function save(model, attrs)
+  redis.call("SADD", model.name .. ":all", model.id)
+  redis.call("DEL", model.key)
+
+  if math.mod(#attrs, 2) == 1 then
+    error("Wrong number of attribute/value pairs")
+  end
+
+  if #attrs > 0 then
+    redis.call("HMSET", model.key, unpack(attrs))
+  end
+end
+
+local function index(model, indices)
+  for field, enum in pairs(indices) do
+    for _, val in ipairs(enum) do
+      local key = model.name .. ":indices:" .. field .. ":" .. tostring(val)
+
+      redis.call("SADD", model.key .. ":_indices", key)
+      redis.call("SADD", key, model.id)
+    end
+  end
+end
+
+local function remove_indices(model)
+  local memo = model.key .. ":_indices"
+  local existing = redis.call("SMEMBERS", memo)
+
+  for _, key in ipairs(existing) do
+    redis.call("SREM", key, model.id)
+    redis.call("SREM", memo, key)
+  end
+end
+
+local function unique(model, uniques)
+  for field, value in pairs(uniques) do
+    local key = model.name .. ":uniques:" .. field
+
+    redis.call("HSET", model.key .. ":_uniques", key, value)
+    redis.call("HSET", key, value, model.id)
+  end
+end
+
+local function remove_uniques(model, uniques)
+  local memo = model.key .. ":_uniques"
+
+  for field, _ in pairs(uniques) do
+    local key = model.name .. ":uniques:" .. field
+
+    redis.call("HDEL", key, redis.call("HGET", memo, key))
+    redis.call("HDEL", memo, key)
+  end
+end
+
+local function verify(model, uniques)
+  local duplicates = {}
+
+  for field, value in pairs(uniques) do
+    local key = model.name .. ":uniques:" .. field
+    local id = redis.call("HGET", key, tostring(value))
+
+    if id and id ~= tostring(model.id) then
+      duplicates[#duplicates + 1] = field
+    end
+  end
+
+  return duplicates, #duplicates ~= 0
+end
+
+local duplicates, err = verify(model, uniques)
+
+if err then
+  error("UniqueIndexViolation: " .. duplicates[1])
+end
+
+local function convertBooleans(list)
+  for index, value in ipairs(list) do
+    if type(value) == "boolean" then
+      if value then
+        list[index] = 1
+      else
+        list[index] = nil
+        list[index - 1] = nil
+      end
+    end
+  end
+end
+
+convertBooleans(attrs)
+
+save(model, attrs)
+
+remove_indices(model)
+index(model, indices)
+
+remove_uniques(model, uniques)
+unique(model, uniques)
+
+return model.id

data/ohm.gemspec

@@ -1,18 +1,20 @@
 Gem::Specification.new do |s|
   s.name = "ohm"
-  s.version = "1.4.0"
+  s.version = "2.0.0.alpha1"
   s.summary = %{Object-hash mapping library for Redis.}
   s.description = %Q{Ohm is a library that allows to store an object in Redis, a persistent key-value database. It includes an extensible list of validations and has very good performance.}
   s.authors = ["Michel Martens", "Damian Janowski", "Cyril David"]
   s.email = ["michel@soveran.com", "djanowski@dimaion.com", "me@cyrildavid.com"]
-  s.homepage = "http://soveran.github.com/ohm/"
+  s.homepage = "http://soveran.github.io/ohm/"
   s.license = "MIT"
 
   s.files = `git ls-files`.split("\n")
 
   s.rubyforge_project = "ohm"
-  s.add_dependency "redis"
-  s.add_dependency "nest", "~> 1.0"
-  s.add_dependency "scrivener", "~> 0.0.3"
-  s.add_development_dependency "cutest", "~> 1.1"
+
+  s.add_dependency "redic"
+  s.add_dependency "nido"
+  s.add_dependency "msgpack"
+
+  s.add_development_dependency "cutest"
 end

data/test/command.rb

@@ -2,56 +2,54 @@ require_relative "helper"
 
 scope do
   setup do
-    redis = Redis.connect
-    redis.flushdb
+    redis = Redic.new
+    redis.call("FLUSHDB")
 
-    # require 'logger'
-    # redis.client.logger = Logger.new(STDOUT)
-    nest  = Nest.new("User:tmp", redis)
+    nido = Nido.new("User:tmp")
 
-    [1, 2, 3].each { |i| redis.sadd("A", i) }
-    [1, 4, 5].each { |i| redis.sadd("B", i) }
+    [1, 2, 3].each { |i| redis.call("SADD", "A", i) }
+    [1, 4, 5].each { |i| redis.call("SADD", "B", i) }
 
-    [10, 11, 12].each { |i| redis.sadd("C", i) }
-    [11, 12, 13].each { |i| redis.sadd("D", i) }
-    [12, 13, 14].each { |i| redis.sadd("E", i) }
+    [10, 11, 12].each { |i| redis.call("SADD", "C", i) }
+    [11, 12, 13].each { |i| redis.call("SADD", "D", i) }
+    [12, 13, 14].each { |i| redis.call("SADD", "E", i) }
 
-    [10, 11, 12].each { |i| redis.sadd("F", i) }
-    [11, 12, 13].each { |i| redis.sadd("G", i) }
-    [12, 13, 14].each { |i| redis.sadd("H", i) }
+    [10, 11, 12].each { |i| redis.call("SADD", "F", i) }
+    [11, 12, 13].each { |i| redis.call("SADD", "G", i) }
+    [12, 13, 14].each { |i| redis.call("SADD", "H", i) }
 
-    [redis, nest]
+    [redis, nido]
   end
 
   test "special condition: single argument returns that arg" do
     assert_equal "A", Ohm::Command[:sinterstore, "A"]
   end
 
-  test "full stack test"  do |redis, nest|
+  test "full stack test"  do |redis, nido|
     cmd1 = Ohm::Command[:sinterstore, "A", "B"]
 
-    res = cmd1.call(nest, redis)
-    assert_equal ["1"], res.smembers
+    res = cmd1.call(nido, redis)
+    assert_equal ["1"], redis.call("SMEMBERS", res)
 
     cmd1.clean
-    assert ! res.exists
+    assert_equal 0, redis.call("EXISTS", res)
 
     cmd2 = Ohm::Command[:sinterstore, "C", "D", "E"]
     cmd3 = Ohm::Command[:sunionstore, cmd1, cmd2]
 
-    res = cmd3.call(nest, redis)
-    assert_equal ["1", "12"], res.smembers
+    res = cmd3.call(nido, redis)
+    assert_equal ["1", "12"], redis.call("SMEMBERS", res)
 
     cmd3.clean
-    assert redis.keys(nest["*"]).empty?
+    assert redis.call("KEYS", nido["*"]).empty?
 
     cmd4 = Ohm::Command[:sinterstore, "F", "G", "H"]
     cmd5 = Ohm::Command[:sdiffstore, cmd3, cmd4]
 
-    res = cmd5.call(nest, redis)
-    assert_equal ["1"], res.smembers
+    res = cmd5.call(nido, redis)
+    assert_equal ["1"], redis.call("SMEMBERS", res)
 
     cmd5.clean
-    assert redis.keys(nest["*"]).empty?
+    assert redis.call("KEYS", nido["*"]).empty?
   end
 end

data/test/connection.rb

@@ -2,105 +2,21 @@
 
 require File.expand_path("./helper", File.dirname(__FILE__))
 
-unless defined?(Redis::CannotConnectError)
-  Redis::CannotConnectError = Errno::ECONNREFUSED
-end
-
-prepare.clear
-
-test "no rewriting of settings hash when using Ohm.connect" do
-  settings = { :url => "redis://127.0.0.1:6379/15" }.freeze
-
-  ex = nil
-
-  begin
-    Ohm.connect(settings)
-  rescue RuntimeError => e
-    ex = e
-  end
-
-  assert_equal ex, nil
-end
-
-test "connects lazily" do
-  Ohm.connect(:port => 9876)
-
-  begin
-    Ohm.redis.get "foo"
-  rescue => e
-    assert_equal Redis::CannotConnectError, e.class
-  end
-end
-
-test "provides a separate connection for each thread" do
-  assert Ohm.redis == Ohm.redis
-
-  conn1, conn2 = nil
-
-  threads = []
-
-  threads << Thread.new do
-    conn1 = Ohm.redis
-  end
-
-  threads << Thread.new do
-    conn2 = Ohm.redis
-  end
-
-  threads.each { |t| t.join }
-
-  assert conn1 != conn2
-end
-
-test "supports connecting by URL" do
-  Ohm.connect(:url => "redis://localhost:9876")
-
-  begin
-    Ohm.redis.get "foo"
-  rescue => e
-    assert_equal Redis::CannotConnectError, e.class
-  end
-end
-
-setup do
-  Ohm.connect(:url => "redis://localhost:6379/0")
-end
-
-test "connection class" do
-  conn = Ohm::Connection.new(:foo, :url => "redis://localhost:6379/0")
-
-  assert conn.redis.kind_of?(Redis)
-end
-
-test "issue #46" do
-  class B < Ohm::Model
-    connect(:url => "redis://localhost:6379/15")
-  end
-
-  # We do this since we did prepare.clear above.
-  B.db.flushall
-
-  b1, b2 = nil, nil
-
-  Thread.new { b1 = B.create }.join
-  Thread.new { b2 = B.create }.join
-
-  assert_equal [b1, b2], B.all.sort.to_a
+unless defined?(Redic::CannotConnectError)
+  Redic::CannotConnectError = Errno::ECONNREFUSED
 end
 
 test "model can define its own connection" do
   class B < Ohm::Model
-    connect(:url => "redis://localhost:6379/1")
+    self.redis = Redic.new("redis://localhost:6379/1")
   end
 
-  assert_equal B.conn.options,   {:url=>"redis://localhost:6379/1"}
-  assert_equal Ohm.conn.options, {:url=>"redis://localhost:6379/0"}
+  assert B.redis.url != Ohm.redis.url
 end
 
 test "model inherits Ohm.redis connection by default" do
-  Ohm.connect(:url => "redis://localhost:9876")
   class C < Ohm::Model
   end
 
-  assert_equal C.conn.options, Ohm.conn.options
+  assert_equal C.redis.url, Ohm.redis.url
 end

data/test/filtering.rb

@@ -1,3 +1,4 @@
+__END__
 require File.expand_path("./helper", File.dirname(__FILE__))
 
 class User < Ohm::Model
@@ -95,14 +96,6 @@ test "#union" do |john, jane|
   assert res.any? { |e| e.status == "inactive" }
 end
 
-test "#combine" do |john, jane|
-  res = User.find(:status => "active").combine(fname: ["John", "Jane"])
-
-  assert_equal 2, res.size
-  assert res.include?(john)
-  assert res.include?(jane)
-end
-
 # book author thing via @myobie
 scope do
   class Book < Ohm::Model
@@ -167,3 +160,142 @@ scope do
     assert_equal 2, res.size
   end
 end
+
+# test precision of filtering commands
+require "logger"
+require "stringio"
+scope do
+  class Post < Ohm::Model
+    attribute :author
+    index :author
+
+    attribute :mood
+    index :mood
+  end
+
+  setup do
+    io = StringIO.new
+
+    Post.connect(:logger => Logger.new(io))
+
+    Post.create(author: "matz", mood: "happy")
+    Post.create(author: "rich", mood: "mad")
+
+    io
+  end
+
+  def read(io)
+    io.rewind
+    io.read
+  end
+
+  test "SINTERSTORE a b" do |io|
+    Post.find(author: "matz").find(mood: "happy").to_a
+
+    # This is the simple case. We should only do one SINTERSTORE
+    # given two direct keys. Anything more and we're performing badly.
+    expected = "SINTERSTORE Post:tmp:[a-f0-9]{64} " +
+               "Post:indices:author:matz Post:indices:mood:happy"
+
+    assert(read(io) =~ Regexp.new(expected))
+  end
+
+  test "SUNIONSTORE a b" do |io|
+    Post.find(author: "matz").union(mood: "happy").to_a
+
+    # Another simple case where we must only do one operation at maximum.
+    expected = "SUNIONSTORE Post:tmp:[a-f0-9]{64} " +
+               "Post:indices:author:matz Post:indices:mood:happy"
+
+    assert(read(io) =~ Regexp.new(expected))
+  end
+
+  test "SUNIONSTORE c (SINTERSTORE a b)" do |io|
+    Post.find(author: "matz").find(mood: "happy").union(author: "rich").to_a
+
+    # For this case we need an intermediate key. This will
+    # contain the intersection of matz + happy.
+    expected = "SINTERSTORE (Post:tmp:[a-f0-9]{64}) " +
+               "Post:indices:author:matz Post:indices:mood:happy"
+
+    assert(read(io) =~ Regexp.new(expected))
+
+    # The next operation is simply doing a UNION of the previously
+    # generated intermediate key and the additional single key.
+    expected = "SUNIONSTORE (Post:tmp:[a-f0-9]{64}) " +
+               "%s Post:indices:author:rich" % $1
+
+    assert(read(io) =~ Regexp.new(expected))
+  end
+
+  test "SUNIONSTORE (SINTERSTORE c d) (SINTERSTORE a b)" do |io|
+    Post.find(author: "matz").find(mood: "happy").
+         union(author: "rich", mood: "sad").to_a
+
+    # Similar to the previous case, we need to do an intermediate
+    # operation.
+    expected = "SINTERSTORE (Post:tmp:[a-f0-9]{64}) " +
+               "Post:indices:author:matz Post:indices:mood:happy"
+
+    match1 = read(io).match(Regexp.new(expected))
+    assert match1
+
+    # But now, we need to also hold another intermediate key for the
+    # condition of author: rich AND mood: sad.
+    expected = "SINTERSTORE (Post:tmp:[a-f0-9]{64}) " +
+               "Post:indices:author:rich Post:indices:mood:sad"
+
+    match2 = read(io).match(Regexp.new(expected))
+    assert match2
+
+    # Now we expect that it does a UNION of those two previous
+    # intermediate keys.
+    expected = sprintf(
+      "SUNIONSTORE (Post:tmp:[a-f0-9]{64}) %s %s",
+      match1[1], match2[1]
+    )
+
+    assert(read(io) =~ Regexp.new(expected))
+  end
+
+  test do |io|
+    Post.create(author: "kent", mood: "sad")
+
+    Post.find(author: "kent", mood: "sad").
+         union(author: "matz", mood: "happy").
+         except(mood: "sad", author: "rich").to_a
+
+    expected = "SINTERSTORE (Post:tmp:[a-f0-9]{64}) " +
+               "Post:indices:author:kent Post:indices:mood:sad"
+
+    match1 = read(io).match(Regexp.new(expected))
+    assert match1
+
+    expected = "SINTERSTORE (Post:tmp:[a-f0-9]{64}) " +
+               "Post:indices:author:matz Post:indices:mood:happy"
+
+    match2 = read(io).match(Regexp.new(expected))
+    assert match2
+
+    expected = sprintf(
+      "SUNIONSTORE (Post:tmp:[a-f0-9]{64}) %s %s",
+      match1[1], match2[1]
+    )
+
+    match3 = read(io).match(Regexp.new(expected))
+    assert match3
+
+    expected = "SINTERSTORE (Post:tmp:[a-f0-9]{64}) " +
+               "Post:indices:mood:sad Post:indices:author:rich"
+
+    match4 = read(io).match(Regexp.new(expected))
+    assert match4
+
+    expected = sprintf(
+      "SDIFFSTORE (Post:tmp:[a-f0-9]{64}) %s %s",
+      match3[1], match4[1]
+    )
+
+    assert(read(io) =~ Regexp.new(expected))
+  end
+end