sohm 0.0.1

data/makefile

@@ -0,0 +1,4 @@
+.PHONY: test
+
+test:
+	cutest -r ./test/helper.rb ./test/*.rb

data/sohm.gemspec

@@ -0,0 +1,18 @@
+Gem::Specification.new do |s|
+  s.name = "sohm"
+  s.version = "0.0.1"
+  s.summary = %{Slim ohm for twemproxy-like system}
+  s.description = %Q{Slim ohm is a forked ohm that works with twemproxy-like redis system, only a limited set of features in ohm is supported}
+  s.authors = ["Xuejie Xiao"]
+  s.email = ["xxuejie@gmail.com"]
+  s.homepage = "https://github.com/xxuejie/sohm"
+  s.license = "MIT"
+
+  s.files = `git ls-files`.split("\n")
+
+  s.add_dependency "redic", "~> 1.4.1"
+  s.add_dependency "nido", "~> 0.0.1"
+  s.add_dependency "msgpack", "~> 0.5.11"
+
+  s.add_development_dependency "cutest", "~> 1.2.2"
+end

data/test/association.rb

@@ -0,0 +1,33 @@
+require_relative "helper"
+
+class User < Ohm::Model
+  collection :posts, :Post
+end
+
+class Post < Ohm::Model
+  reference :user, :User
+end
+
+setup do
+  u = User.create
+  p = Post.create(:user => u)
+
+  [u, p]
+end
+
+test "basic shake and bake" do |u, p|
+  assert u.posts.include?(p)
+
+  p = Post[p.id]
+  assert_equal u, p.user
+end
+
+test "memoization" do |u, p|
+  # This will read the user instance once.
+  p.user
+  assert_equal p.user, p.instance_variable_get(:@_memo)[:user]
+
+  # This will un-memoize the user instance
+  p.user = u
+  assert_equal nil, p.instance_variable_get(:@_memo)[:user]
+end

data/test/command.rb

@@ -0,0 +1,55 @@
+require_relative "helper"
+
+scope do
+  setup do
+    redis = Redic.new
+    redis.call("FLUSHDB")
+
+    nido = Nido.new("User:tmp")
+
+    [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.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.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, 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, nido|
+    cmd1 = Ohm::Command[:sinterstore, "A", "B"]
+
+    res = cmd1.call(nido, redis)
+    assert_equal ["1"], redis.call("SMEMBERS", res)
+
+    cmd1.clean
+    assert_equal 0, redis.call("EXISTS", res)
+
+    cmd2 = Ohm::Command[:sinterstore, "C", "D", "E"]
+    cmd3 = Ohm::Command[:sunionstore, cmd1, cmd2]
+
+    res = cmd3.call(nido, redis)
+    assert_equal ["1", "12"], redis.call("SMEMBERS", res)
+
+    cmd3.clean
+    assert redis.call("KEYS", nido["*"]).empty?
+
+    cmd4 = Ohm::Command[:sinterstore, "F", "G", "H"]
+    cmd5 = Ohm::Command[:sdiffstore, cmd3, cmd4]
+
+    res = cmd5.call(nido, redis)
+    assert_equal ["1"], redis.call("SMEMBERS", res)
+
+    cmd5.clean
+    assert redis.call("KEYS", nido["*"]).empty?
+  end
+end

data/test/connection.rb

@@ -0,0 +1,16 @@
+require_relative 'helper'
+
+test "model inherits Ohm.redis connection by default" do
+  class C < Ohm::Model
+  end
+
+  assert_equal C.redis.url, Ohm.redis.url
+end
+
+test "model can define its own connection" do
+  class B < Ohm::Model
+    self.redis = Redic.new("redis://localhost:6379/1")
+  end
+
+  assert B.redis.url != Ohm.redis.url
+end

data/test/core.rb

@@ -0,0 +1,24 @@
+require_relative "helper"
+
+class Event < Ohm::Model
+  attribute :name
+  attribute :location
+end
+
+test "assign attributes from the hash" do
+  event = Event.new(name: "Ruby Tuesday")
+  assert_equal event.name, "Ruby Tuesday"
+end
+
+test "assign an ID and save the object" do
+  event1 = Event.create(name: "Ruby Tuesday")
+  event2 = Event.create(name: "Ruby Meetup")
+
+  assert_equal "1", event1.id
+  assert_equal "2", event2.id
+end
+
+test "save the attributes in UTF8" do
+ event = Event.create(name: "32° Kisei-sen")
+ assert_equal "32° Kisei-sen", Event[event.id].name
+end

data/test/counters.rb

@@ -0,0 +1,67 @@
+require_relative "helper"
+
+$VERBOSE = false
+
+class Ad < Ohm::Model
+end
+
+test "counters aren't overwritten by competing saves" do
+  Ad.counter :hits
+
+  instance1 = Ad.create
+  instance1.incr :hits
+
+  instance2 = Ad[instance1.id]
+
+  instance1.incr :hits
+  instance1.incr :hits
+
+  instance2.save
+
+  instance1 = Ad[instance1.id]
+  assert_equal 3, instance1.hits
+end
+
+test "you can increment counters even when attributes is empty" do
+  Ad.counter :hits
+
+  ad = Ad.create
+  ad = Ad[ad.id]
+
+  ex = nil
+
+  begin
+    ad.incr :hits
+  rescue ArgumentError => e
+    ex = e
+  end
+
+  assert_equal nil, ex
+end
+
+test "an attribute gets saved properly" do
+  Ad.attribute :name
+  Ad.counter :hits
+
+  ad = Ad.create(:name => "foo")
+  ad.incr :hits, 10
+  assert_equal 10, ad.hits
+
+  # Now let's just load and save it.
+  ad = Ad[ad.id]
+  ad.save
+
+  # The attributes should remain the same
+  ad = Ad[ad.id]
+  assert_equal "foo", ad.name
+  assert_equal 10, ad.hits
+
+  # If we load and save again while we incr behind the scenes,
+  # the latest counter values should be respected.
+  ad = Ad[ad.id]
+  ad.incr :hits, 5
+  ad.save
+
+  ad = Ad[ad.id]
+  assert_equal 15, ad.hits
+end

data/test/enumerable.rb

@@ -0,0 +1,79 @@
+require_relative "helper"
+
+scope do
+  class Contact < Ohm::Model
+    attribute :name
+  end
+
+  setup do
+    john = Contact.create(name: "John Doe")
+    jane = Contact.create(name: "Jane Doe")
+
+    [john, jane]
+  end
+
+  test "Set#size doesn't do each" do
+    set = Contact.all
+
+    def set.each
+      raise "Failed"
+    end
+
+    assert_equal 2, set.size
+  end
+
+  test "Set#each as an Enumerator" do |john, jane|
+    enum = Contact.all.each
+
+    enum.each do |c|
+      assert c == john || c == jane
+    end
+  end
+
+  test "select" do |john, jane|
+    assert_equal 2, Contact.all.count
+    assert_equal [john], Contact.all.select { |c| c.id == john.id }
+  end
+end
+
+scope do
+  class Comment < Ohm::Model
+  end
+
+  class Post < Ohm::Model
+    list :comments, :Comment
+  end
+
+  setup do
+    c1 = Comment.create
+    c2 = Comment.create
+
+    post = Post.create
+    post.comments.push(c1)
+    post.comments.push(c2)
+
+    [post, c1, c2]
+  end
+
+  test "List#select" do |post, c1, c2|
+    assert_equal [c1], post.comments.select { |comment| comment == c1 }
+  end
+
+  test "List#each as Enumerator" do |post, c1, c2|
+    enum = post.comments.each
+
+    enum.each do |comment|
+      assert comment == c1 || comment == c2
+    end
+  end
+
+  test "List#size doesn't do each" do |post, c1, c2|
+    list = post.comments
+
+    def list.each
+      raise "Failed"
+    end
+
+    assert_equal 2, list.size
+  end
+end

data/test/filtering.rb

@@ -0,0 +1,185 @@
+require_relative "helper"
+
+class User < Ohm::Model
+  attribute :fname
+  attribute :lname
+  attribute :status
+
+  index :fname
+  index :lname
+  index :status
+end
+
+setup do
+  u1 = User.create(:fname => "John", :lname => "Doe", :status => "active")
+  u2 = User.create(:fname => "Jane", :lname => "Doe", :status => "active")
+
+  [u1, u2]
+end
+
+test "findability" do |john, jane|
+  assert_equal 1, User.find(:lname => "Doe", :fname => "John").size
+  assert User.find(:lname => "Doe", :fname => "John").include?(john)
+
+  assert_equal 1, User.find(:lname => "Doe", :fname => "Jane").size
+  assert User.find(:lname => "Doe", :fname => "Jane").include?(jane)
+end
+
+test "sets aren't mutable" do |john, jane|
+  assert_raise NoMethodError do
+    User.find(:lname => "Doe").add(john)
+  end
+
+  assert_raise NoMethodError do
+    User.find(:lname => "Doe", :fname => "John").add(john)
+  end
+end
+
+test "#first" do |john, jane|
+  set = User.find(:lname => "Doe", :status => "active")
+
+  assert_equal jane, set.first(:by => "fname", :order => "ALPHA")
+  assert_equal john, set.first(:by => "fname", :order => "ALPHA DESC")
+
+  assert_equal "Jane", set.first(:by => "fname", :order => "ALPHA", :get => "fname")
+  assert_equal "John", set.first(:by => "fname", :order => "ALPHA DESC", :get => "fname")
+end
+
+test "#[]" do |john, jane|
+  set = User.find(:lname => "Doe", :status => "active")
+
+  assert_equal john, set[john.id]
+  assert_equal jane, set[jane.id]
+end
+
+test "#except" do |john, jane|
+  User.create(:status => "inactive", :lname => "Doe")
+
+  res = User.find(:lname => "Doe").except(:status => "inactive")
+
+  assert_equal 2, res.size
+  assert res.include?(john)
+  assert res.include?(jane)
+
+  res = User.all.except(:status => "inactive")
+
+  assert_equal 2, res.size
+  assert res.include?(john)
+  assert res.include?(jane)
+end
+
+test "#except unions keys when passing an array" do |john, jane|
+  expected = User.create(:fname => "Jean", :status => "inactive")
+
+  res = User.find(:status => "inactive").except(:fname => [john.fname, jane.fname])
+
+  assert_equal 1, res.size
+  assert res.include?(expected)
+
+  res = User.all.except(:fname => [john.fname, jane.fname])
+
+  assert_equal 1, res.size
+  assert res.include?(expected)
+end
+
+test "indices bug related to a nil attribute" do |john, jane|
+  # First we create a record with a nil attribute
+  out = User.create(:status => nil, :lname => "Doe")
+
+  # Then, we update the old nil attribute to a different
+  # non-nil, value.
+  out.update(status: "inactive")
+
+  # At this point, the index for the nil attribute should
+  # have been cleared.
+  assert_equal 0, User.redis.call("SCARD", "User:indices:status:")
+end
+
+test "#union" do |john, jane|
+  User.create(:status => "super", :lname => "Doe")
+  included = User.create(:status => "inactive", :lname => "Doe")
+
+  res = User.find(:status => "active").union(:status => "inactive")
+
+  assert_equal 3, res.size
+  assert res.include?(john)
+  assert res.include?(jane)
+  assert res.include?(included)
+
+  res = User.find(:status => "active").union(:status => "inactive").find(:lname => "Doe")
+
+  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
+    collection :authors, :Author
+  end
+
+  class Author < Ohm::Model
+    reference :book, :Book
+
+    attribute :mood
+    index :mood
+  end
+
+  setup do
+    book1 = Book.create
+    book2 = Book.create
+
+    Author.create(:book => book1, :mood => "happy")
+    Author.create(:book => book1, :mood => "sad")
+    Author.create(:book => book2, :mood => "sad")
+
+    [book1, book2]
+  end
+
+  test "straight up intersection + union" do |book1, book2|
+    result = book1.authors.find(:mood => "happy").
+      union(:book_id => book1.id, :mood => "sad")
+
+    assert_equal 2, result.size
+  end
+
+  test "appending an empty set via union" do |book1, book2|
+    res = Author.find(:book_id => book1.id, :mood => "happy").
+      union(:book_id => book2.id, :mood => "sad").
+      union(:book_id => book2.id, :mood => "happy")
+
+    assert_equal 2, res.size
+  end
+
+  test "revert by applying the original intersection" do |book1, book2|
+    res = Author.find(:book_id => book1.id, :mood => "happy").
+      union(:book_id => book2.id, :mood => "sad").
+      find(:book_id => book1.id, :mood => "happy")
+
+    assert_equal 1, res.size
+  end
+
+  test "remove original intersection by doing diff" do |book1, book2|
+    res = Author.find(:book_id => book1.id, :mood => "happy").
+      union(:book_id => book2.id, :mood => "sad").
+      except(:book_id => book1.id, :mood => "happy")
+
+    assert_equal 1, res.size
+    assert res.map(&:mood).include?("sad")
+    assert res.map(&:book_id).include?(book2.id)
+  end
+
+  test "@myobie usecase" do |book1, book2|
+    res = book1.authors.find(:mood => "happy").
+      union(:mood => "sad", :book_id => book1.id)
+
+    assert_equal 2, res.size
+  end
+end

data/test/hash_key.rb

@@ -0,0 +1,31 @@
+require_relative "helper"
+
+class Tag < Ohm::Model
+  attribute :name
+end
+
+test "using a new record as a hash key" do
+  tag = Tag.new
+  hash = { tag => "Ruby" }
+
+  assert "Ruby" == hash[tag]
+  assert hash[Tag.new].nil?
+end
+
+test "on a persisted model" do
+  tag = Tag.create(:name => "Ruby")
+
+  assert "Ruby" == { tag => "Ruby" }[tag]
+end
+
+test "on a reloaded model" do
+  tag = Tag.create(:name => "Ruby")
+  hash = { tag => "Ruby" }
+
+  tag = Tag[tag.id]
+  assert "Ruby" == hash[tag]
+end
+
+test "on attributes class method" do
+  assert [:name] == Tag.attributes
+end

data/test/helper.rb

@@ -0,0 +1,23 @@
+begin
+  require "ruby-debug"
+rescue LoadError
+end
+
+require "cutest"
+
+def silence_warnings
+  original_verbose, $VERBOSE = $VERBOSE, nil
+  yield
+ensure
+  $VERBOSE = original_verbose
+end unless defined?(silence_warnings)
+
+$VERBOSE = true
+
+require_relative "../lib/ohm"
+
+Ohm.redis = Redic.new("redis://127.0.0.1:6379")
+
+prepare do
+  Ohm.redis.call("FLUSHALL")
+end

data/test/indices.rb

@@ -0,0 +1,133 @@
+require_relative "helper"
+
+class User < Ohm::Model
+  attribute :email
+  attribute :update
+  attribute :activation_code
+  attribute :sandunga
+  index :email
+  index :email_provider
+  index :working_days
+  index :update
+  index :activation_code
+
+  def working_days
+    @working_days ||= []
+  end
+
+  def email_provider
+    email.split("@").last
+  end
+
+  def before_save
+    self.activation_code ||= "user:#{id}"
+  end
+end
+
+setup do
+  @user1 = User.create(:email => "foo", :activation_code => "bar", :update => "baz")
+  @user2 = User.create(:email => "bar")
+  @user3 = User.create(:email => "baz qux")
+end
+
+test "be able to find by the given attribute" do
+  assert @user1 == User.find(:email => "foo").first
+end
+
+test "raise if the index doesn't exist" do
+  assert_raise Ohm::IndexNotFound do
+    User.find(:address => "foo")
+  end
+end
+
+test "raise an error if the parameter supplied is not a hash" do
+  begin
+    User.find(1)
+  rescue => ex
+  ensure
+    assert ex.kind_of?(ArgumentError)
+    assert ex.message == "You need to supply a hash with filters. If you want to find by ID, use User[id] instead."
+  end
+end
+
+test "avoid intersections with the all collection" do
+  assert_equal "User:indices:email:foo", User.find(:email => "foo").key
+end
+
+test "cleanup the temporary key after use" do
+  assert User.find(:email => "foo", :activation_code => "bar").to_a
+
+  assert Ohm.redis.call("KEYS", "User:temp:*").empty?
+end
+
+test "allow multiple chained finds" do
+  assert 1 == User.find(:email => "foo").find(:activation_code => "bar").find(:update => "baz").size
+end
+
+test "return nil if no results are found" do
+  assert User.find(:email => "foobar").empty?
+  assert nil == User.find(:email => "foobar").first
+end
+
+test "update indices when changing attribute values" do
+  @user1.email = "baz"
+  @user1.save
+
+  assert [] == User.find(:email => "foo").to_a
+  assert [@user1] == User.find(:email => "baz").to_a
+end
+
+test "remove from the index after deleting" do
+  @user2.delete
+
+  assert [] == User.find(:email => "bar").to_a
+end
+
+test "work with attributes that contain spaces" do
+  assert [@user3] == User.find(:email => "baz qux").to_a
+end
+
+# Indexing arbitrary attributes
+setup do
+  @user1 = User.create(:email => "foo@gmail.com")
+  @user2 = User.create(:email => "bar@gmail.com")
+  @user3 = User.create(:email => "bazqux@yahoo.com")
+end
+
+test "allow indexing by an arbitrary attribute" do
+  gmail = User.find(:email_provider => "gmail.com").to_a
+  assert [@user1, @user2] == gmail.sort_by { |u| u.id }
+  assert [@user3] == User.find(:email_provider => "yahoo.com").to_a
+end
+
+scope do
+  # Just to give more context around this bug, basically it happens
+  # when you define a virtual unique or index.
+  #
+  # Previously it was unable to cleanup the indices mainly because
+  # it relied on the attributes being set.
+  class Node < Ohm::Model
+    index :available
+    attribute :capacity
+
+    unique :available
+
+    def available
+      capacity.to_i <= 90
+    end
+  end
+
+  test "index bug" do
+    n = Node.create
+    n.update(capacity: 91)
+
+    assert_equal 0, Node.find(available: true).size
+  end
+
+  test "uniques bug" do
+    n = Node.create
+    n.update(capacity: 91)
+
+    assert_equal nil, Node.with(:available, true)
+  end
+end