ohm 1.0.0.rc1 → 1.0.0.rc2

data/lib/ohm/transaction.rb

@@ -1,5 +1,3 @@
-require "set"
-
 module Ohm
 
   # Transactions in Ohm are designed to be composable and atomic. They use
@@ -42,27 +40,27 @@ module Ohm
   #
   # @see http://redis.io/topic/transactions Transactions in Redis.
   class Transaction
-    class Store < BasicObject
-      class EntryAlreadyExistsError < ::RuntimeError
+    class Store
+      class EntryAlreadyExistsError < RuntimeError
       end
 
-      def method_missing(writer, value = nil)
-        super unless writer[-1] == "="
+      class NoEntryError < RuntimeError
+      end
 
-        reader = writer[0..-2].to_sym
+      def initialize
+        @dict = Hash.new
+      end
 
-        __metaclass__.send(:define_method, reader) do
-          value
-        end
+      def [](key)
+        raise NoEntryError unless @dict.member?(key)
 
-        __metaclass__.send(:define_method, writer) do |*_|
-          ::Kernel.raise EntryAlreadyExistsError
-        end
+        @dict[key]
       end
 
-    private
-      def __metaclass__
-        class << self; self end
+      def []=(key, value)
+        raise EntryAlreadyExistsError if @dict.member?(key)
+
+        @dict[key] = value
       end
     end
 
@@ -83,7 +81,7 @@ module Ohm
     end
 
     def watch(*keys)
-      phase[:watch] += keys
+      phase[:watch].concat(keys - phase[:watch])
     end
 
     def read(&block)
@@ -117,6 +115,8 @@ module Ohm
         break if db.multi do
           run(phase[:write], store)
         end
+
+        store = nil
       end
 
       phase[:after].each(&:call)
@@ -126,4 +126,8 @@ module Ohm
       procs.each { |p| p.call(store) }
     end
   end
+
+  def self.transaction(&block)
+    Transaction.new(&block)
+  end
 end

data/test/association.rb

@@ -10,7 +10,7 @@ end
 
 setup do
   u = User.create
-  p = Post.create(user: u)
+  p = Post.create(:user => u)
 
   [u, p]
 end

data/test/connection.rb

@@ -5,7 +5,7 @@ require File.expand_path("./helper", File.dirname(__FILE__))
 prepare.clear
 
 test "no rewriting of settings hash when using Ohm.connect" do
-  settings = { url: "redis://127.0.0.1:6379/15" }.freeze
+  settings = { :url => "redis://127.0.0.1:6379/15" }.freeze
 
   ex = nil
 

data/test/counters.rb

@@ -43,7 +43,7 @@ test "an attribute gets saved properly" do
   Ad.attribute :name
   Ad.counter :hits
 
-  ad = Ad.create(name: "foo")
+  ad = Ad.create(:name => "foo")
   ad.incr :hits, 10
   assert_equal 10, ad.hits
 

data/test/extensibility.rb

@@ -38,7 +38,7 @@ if defined?(Ohm::Model::PureRuby)
   end
 
   test do
-    u = User.create(email: "FOO@BAR.COM", foo: "bar")
+    u = User.create(:email => "FOO@BAR.COM", :foo => "bar")
     assert_equal "foo@bar.com", u.email
     assert_equal ["bar"], u.key[:foos].smembers
 

data/test/filtering.rb

@@ -10,51 +10,51 @@ class User < Ohm::Model
 end
 
 setup do
-  u1 = User.create(fname: "John", lname: "Doe", status: "active")
-  u2 = User.create(fname: "Jane", lname: "Doe", status: "active")
+  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 => "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)
+  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)
+    User.find(:lname => "Doe").add(john)
   end
 
   assert_raise NoMethodError do
-    User.find(lname: "Doe", fname: "John").add(john)
+    User.find(:lname => "Doe", :fname => "John").add(john)
   end
 end
 
 test "#first" do |john, jane|
-  set = User.find(lname: "Doe", status: "active")
+  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")
+  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")
+  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")
+  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|
-  out = User.create(status: "inactive", lname: "Doe")
+  out = User.create(:status => "inactive", :lname => "Doe")
 
-  res = User.find(lname: "Doe").except(status: "inactive")
+  res = User.find(:lname => "Doe").except(:status => "inactive")
 
   assert_equal 2, res.size
   assert res.include?(john)
@@ -62,10 +62,10 @@ test "#except" do |john, jane|
 end
 
 test "#union" do |john, jane|
-  included = User.create(status: "inactive", lname: "Doe")
-  excluded = User.create(status: "super", lname: "Doe")
+  included = User.create(:status => "inactive", :lname => "Doe")
+  excluded = User.create(:status => "super", :lname => "Doe")
 
-  res = User.find(status: "active").union(status: "inactive")
+  res = User.find(:status => "active").union(:status => "inactive")
 
   assert_equal 3, res.size
   assert res.include?(john)

data/test/helper.rb

@@ -7,6 +7,7 @@ begin
 rescue LoadError
 end
 
+require "rubygems"
 require "cutest"
 
 def silence_warnings

data/test/indices.rb

@@ -27,13 +27,13 @@ class User < Ohm::Model
 end
 
 setup do
-  @user1 = User.create(email: "foo", activation_code: "bar", update: "baz")
-  @user2 = User.create(email: "bar")
-  @user3 = User.create(email: "baz qux")
+  @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
+  assert @user1 == User.find(:email => "foo").first
 end
 
 test "raise an error if the parameter supplied is not a hash" do
@@ -47,7 +47,7 @@ test "raise an error if the parameter supplied is not a hash" do
 end
 
 test "avoid intersections with the all collection" do
-  assert_equal "User:indices:email:foo", User.find(email: "foo").key
+  assert_equal "User:indices:email:foo", User.find(:email => "foo").key
 end
 
 test "cleanup the temporary key after use" do

data/test/json.rb

@@ -35,7 +35,7 @@ test "export a hash with the errors" do
   person = Venue.new
   person.valid?
 
-  assert_equal({ errors: { name: [:not_present] }}, person.to_hash)
+  assert_equal({ :errors => { :name => [:not_present] }}, person.to_hash)
 end
 
 test "export a hash with the its id" do
@@ -48,7 +48,7 @@ test "export a hash with its id and the errors" do
   person.name = nil
   person.valid?
 
-  expected_hash = { id: '1', errors: { name: [:not_present] }}
+  expected_hash = { :id => '1', :errors => { :name => [:not_present] }}
   assert expected_hash == person.to_hash
 end
 
@@ -68,19 +68,19 @@ test "just be the to_hash of a model" do
 end
 
 test "export an array of records to json" do
-  Programmer.create(language: "Ruby")
-  Programmer.create(language: "Python")
+  Programmer.create(:language => "Ruby")
+  Programmer.create(:language => "Python")
 
-  expected = [{ id: "1", language: "Ruby" }, { id: "2", language: "Python"}].to_json
+  expected = [{ :id => "1", :language => "Ruby" }, { :id => "2", :language => "Python"}].to_json
   assert_equal expected, Programmer.all.to_json
 end
 
 test "export an array of lists to json" do
-  venue = Venue.create(name: "Foo")
+  venue = Venue.create(:name => "Foo")
 
-  venue.programmers.push(Programmer.create(language: "Ruby"))
-  venue.programmers.push(Programmer.create(language: "Python"))
+  venue.programmers.push(Programmer.create(:language => "Ruby"))
+  venue.programmers.push(Programmer.create(:language => "Python"))
 
-  expected = [{ id: "1", language: "Ruby" }, { id: "2", language: "Python"}].to_json
+  expected = [{ :id => "1", :language => "Ruby" }, { :id => "2", :language => "Python"}].to_json
   assert_equal expected, venue.programmers.to_json
 end

data/test/lua-save.rb

@@ -23,8 +23,8 @@ else
 
   test "empty email doesn't choke" do |lua|
     res = lua.run_file("save",
-      keys: ["User"],
-      argv: ["email", nil])
+      :keys => ["User"],
+      :argv => ["email", nil])
 
     assert_equal [200, ["id", "1"]], res
     assert_equal "1", redis.hget("User:uniques:email", nil)
@@ -32,8 +32,8 @@ else
 
   test "empty fname / lname doesn't choke" do |lua|
     res = lua.run_file("save",
-      keys: ["User"],
-      argv: ["email", nil, "fname", nil, "lname", nil])
+      :keys => ["User"],
+      :argv => ["email", nil, "fname", nil, "lname", nil])
 
     assert_equal [200, ["id", "1"]], res
     assert redis.sismember("User:indices:fname:", 1)
@@ -42,24 +42,24 @@ else
 
   test "returns the unique constraint error" do |lua|
     res = lua.run_file("save",
-      keys: ["User"],
-      argv: ["email", "foo@bar.com"])
+      :keys => ["User"],
+      :argv => ["email", "foo@bar.com"])
 
     assert_equal [500, ["email", "not_unique"]], res
   end
 
   test "persists the unique entry properly" do |lua|
     lua.run_file("save",
-      keys: ["User"],
-      argv: ["email", "bar@baz.com"])
+      :keys => ["User"],
+      :argv => ["email", "bar@baz.com"])
 
     assert_equal "1", redis.hget("User:uniques:email", "bar@baz.com")
   end
 
   test "adds the entry to User:all" do |lua|
     lua.run_file("save",
-      keys: ["User"],
-      argv: ["email", "bar@baz.com"])
+      :keys => ["User"],
+      :argv => ["email", "bar@baz.com"])
 
     assert_equal 1, redis.scard("User:all")
   end
@@ -67,8 +67,8 @@ else
 
   test "saves the attributes" do |lua|
     lua.run_file("save",
-      keys: ["User"],
-      argv: ["email", "bar@baz.com", "fname", "John", "lname", "Doe"])
+      :keys => ["User"],
+      :argv => ["email", "bar@baz.com", "fname", "John", "lname", "Doe"])
 
     assert_equal "bar@baz.com", redis.hget("User:1", "email")
     assert_equal "John", redis.hget("User:1", "fname")
@@ -77,8 +77,8 @@ else
 
   test "indexes fname / lname" do |lua|
     lua.run_file("save",
-      keys: ["User"],
-      argv: ["email", "bar@baz.com", "fname", "John", "lname", "Doe"])
+      :keys => ["User"],
+      :argv => ["email", "bar@baz.com", "fname", "John", "lname", "Doe"])
 
     assert redis.sismember("User:indices:fname:John", 1)
     assert redis.sismember("User:indices:lname:Doe", 1)
@@ -86,30 +86,30 @@ else
 
   test "unique constraint during update" do |lua|
     lua.run_file("save",
-      keys: ["User"],
-      argv: ["email", "bar@baz.com", "fname", "John", "lname", "Doe"])
+      :keys => ["User"],
+      :argv => ["email", "bar@baz.com", "fname", "John", "lname", "Doe"])
 
     res = lua.run_file("save",
-      keys: ["User", "User:1"],
-      argv: ["email", "bar@baz.com", "fname", "John", "lname", "Doe"])
+      :keys => ["User", "User:1"],
+      :argv => ["email", "bar@baz.com", "fname", "John", "lname", "Doe"])
 
     assert_equal [200, ["id", "1"]], res
 
     res = lua.run_file("save",
-      keys: ["User", "User:1"],
-      argv: ["email", "foo@bar.com", "fname", "Jane", "lname", "Doe"])
+      :keys => ["User", "User:1"],
+      :argv => ["email", "foo@bar.com", "fname", "Jane", "lname", "Doe"])
 
     assert_equal [200, ["id", "1"]], res
   end
 
   test "cleanup of existing indices during update" do |lua|
     lua.run_file("save",
-      keys: ["User"],
-      argv: ["email", "bar@baz.com", "fname", "John", "lname", "Doe"])
+      :keys => ["User"],
+      :argv => ["email", "bar@baz.com", "fname", "John", "lname", "Doe"])
 
     res = lua.run_file("save",
-      keys: ["User", "User:1"],
-      argv: ["email", "foo@bar.com", "fname", "Jane", "lname", "Smith"])
+      :keys => ["User", "User:1"],
+      :argv => ["email", "foo@bar.com", "fname", "Jane", "lname", "Smith"])
 
     assert ! redis.sismember("User:indices:fname:John", 1)
     assert ! redis.sismember("User:indices:fname:Doe", 1)
@@ -117,12 +117,12 @@ else
 
   test "cleanup of existing uniques during update" do |lua|
     lua.run_file("save",
-      keys: ["User"],
-      argv: ["email", "bar@baz.com", "fname", "John", "lname", "Doe"])
+      :keys => ["User"],
+      :argv => ["email", "bar@baz.com", "fname", "John", "lname", "Doe"])
 
     res = lua.run_file("save",
-      keys: ["User", "User:1"],
-      argv: ["email", "foo@bar.com", "fname", "Jane", "lname", "Smith"])
+      :keys => ["User", "User:1"],
+      :argv => ["email", "foo@bar.com", "fname", "Jane", "lname", "Smith"])
 
     assert_equal nil, redis.hget("User:uniques:email", "bar@baz.com")
   end
@@ -147,9 +147,9 @@ test "stress test for lua scripting" do |lua|
   t = Benchmark.measure do
     threads = 100.times.map do |i|
       Thread.new do
-        User.create(email: "foo#{i}@bar.com",
-                    fname: "Jane#{i}",
-                    lname: "Smith#{i}")
+        User.create(:email => "foo#{i}@bar.com",
+                    :fname => "Jane#{i}",
+                    :lname => "Smith#{i}")
       end
     end
 
@@ -167,9 +167,9 @@ test "stress test for postgres + sequel (as a comparison)" do
   t = Benchmark.measure do
     threads = 100.times.map do |i|
       Thread.new do
-        DB[:users].insert(email: "foo#{i}@bar.com",
-                          fname: "John#{i}",
-                          lname: "Doe#{i}")
+        DB[:users].insert(:email => "foo#{i}@bar.com",
+                          :fname => "John#{i}",
+                          :lname => "Doe#{i}")
       end
     end
 

data/test/lua.rb

@@ -15,14 +15,14 @@ else
   test do |lua|
     lua.redis.set("foo", "baz")
 
-    res = lua.run_file("getset", keys: ["foo"], argv: ["bar"])
+    res = lua.run_file("getset", :keys => ["foo"], :argv => ["bar"])
     assert_equal ["baz", "bar"], res
   end
 
   test do |lua|
     res = lua.run_file("ohm-save",
-      keys: ["User"],
-      argv: ["fname", "John", "lname", "Doe"])
+      :keys => ["User"],
+      :argv => ["fname", "John", "lname", "Doe"])
 
     assert lua.redis.sismember("User:all", 1)
     assert_equal({ "fname" => "John", "lname" => "Doe" },
@@ -34,8 +34,8 @@ else
     lua.redis.sadd("User:indices", "lname")
 
     res = lua.run_file("save-with-indices",
-      keys: ["User:1", "User:all", "User:indices"],
-      argv: ["fname", "John", "lname", "Doe"])
+      :keys => ["User:1", "User:all", "User:indices"],
+      :argv => ["fname", "John", "lname", "Doe"])
 
     assert lua.redis.sismember("User:all", 1)