ohm_util 0.1

data/makefile

@@ -0,0 +1,9 @@
+.PHONY: all test examples
+
+all: test
+
+test:
+	cutest -r ./test/helper.rb ./test/*.rb
+
+examples:
+	RUBYLIB="./lib" cutest ./examples/*.rb

data/ohm-util.gemspec

@@ -0,0 +1,14 @@
+Gem::Specification.new do |s|
+  s.name = "ohm_util"
+  s.version = "0.1"
+  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 has very good performance.}
+  s.authors = ["Travis Liu"]
+  s.email = ["travisliu.tw@gmail.com"]
+  s.homepage = "https://github.com/travisliu/ohm-util"
+  s.license = "MIT"
+
+  s.files = `git ls-files`.split("\n")
+
+  s.add_dependency "redic", "~> 1.5.0"
+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/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.increment :hits
+
+  instance2 = Ad[instance1.id]
+
+  instance1.increment :hits
+  instance1.increment :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.increment :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.increment :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.increment :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