ohm 1.4.0 → 2.0.0.alpha1

data/test/uniques.rb

@@ -64,7 +64,7 @@ test "removes the previous index when changing" do
   u.update(:email => "d@d.com")
 
   assert_equal nil, User.with(:email, "c@c.com")
-  assert_equal nil, User.key[:uniques][:email].hget("c@c.com")
+  assert_equal nil, User.redis.call("HGET", User.key[:uniques][:email], "c@c.com")
   assert_equal u, User.with(:email, "d@d.com")
 end
 
@@ -72,7 +72,7 @@ test "removes the previous index when deleting" do |u|
   u.delete
 
   assert_equal nil, User.with(:email, "a@a.com")
-  assert_equal nil, User.key[:uniques][:email].hget("a@a.com")
+  assert_equal nil, User.redis.call("HGET", User.key[:uniques][:email], "a@a.com")
 end
 
 test "unique virtual attribute" do
@@ -93,33 +93,3 @@ test "unique virtual attribute" do
     User.create(:email => "baz@yahoo.com")
   end
 end
-
-test "assert_unique" do |u|
-  class User
-    def assert_unique(att)
-      result = self.class.with(att, send(att))
-      assert((result.nil? || result.eql?(self)), [att, :not_unique])
-    end
-
-    def validate
-      assert_unique :email
-    end
-  end
-
-  # There's one user with email "a@a.com".
-  user = User.new(:email => "a@a.com")
-
-  # A new user with a conflicting attribute.
-  assert_equal true,  user.new?
-  assert_equal false, user.valid?
-  assert_equal [:not_unique], user.errors[:email]
-
-  user.email = "b@b.com"
-  user.save
-  user.email = "a@a.com"
-
-  # An existing user with a conflicting attribute.
-  assert_equal false, user.new?
-  assert_equal false, user.valid?
-  assert_equal [:not_unique], user.errors[:email]
-end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ohm
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 2.0.0.alpha1
 platform: ruby
 authors:
 - Michel Martens
@@ -10,10 +10,10 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-22 00:00:00.000000000 Z
+date: 2013-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: redis
+  name: redic
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -27,47 +27,47 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: nest
+  name: nido
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: scrivener
+  name: msgpack
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: 0.0.3
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: 0.0.3
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: cutest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '0'
 description: 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.
@@ -99,9 +99,9 @@ files:
 - lib/ohm.rb
 - lib/ohm/command.rb
 - lib/ohm/json.rb
-- lib/ohm/transaction.rb
+- lib/ohm/lua/delete.lua
+- lib/ohm/lua/save.lua
 - ohm.gemspec
-- test/1.8.6_test.rb
 - test/association.rb
 - test/command.rb
 - test/connection.rb
@@ -118,12 +118,9 @@ files:
 - test/json.rb
 - test/list.rb
 - test/model.rb
-- test/pipeline-performance.rb
 - test/test.conf
-- test/transactions.rb
 - test/uniques.rb
-- test/validations.rb
-homepage: http://soveran.github.com/ohm/
+homepage: http://soveran.github.io/ohm/
 licenses:
 - MIT
 metadata: {}
@@ -138,12 +135,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: ohm
-rubygems_version: 2.0.14
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: Object-hash mapping library for Redis.

data/lib/ohm/transaction.rb

@@ -1,133 +0,0 @@
-module Ohm
-
-  # Transactions in Ohm are designed to be composable and atomic. They use
-  # Redis WATCH/MULTI/EXEC to perform the comands sequentially but in a single
-  # step.
-  #
-  # @example
-  #
-  #   redis = Ohm.redis
-  #
-  #   t1 = Ohm::Transaction.new do |t|
-  #     s = nil
-  #
-  #     t.watch("foo")
-  #
-  #     t.read do
-  #       s = redis.type("foo")
-  #     end
-  #
-  #     t.write do
-  #       redis.set("foo", s)
-  #     end
-  #   end
-  #
-  #   t2 = Ohm::Transaction.new do |t|
-  #     t.watch("foo")
-  #
-  #     t.write do
-  #       redis.set("foo", "bar")
-  #     end
-  #   end
-  #
-  #   # Compose transactions by passing them to Ohm::Transaction.new.
-  #   t3 = Ohm::Transaction.new(t1, t2)
-  #   t3.commit(redis)
-  #
-  #   # Compose transactions by appending them.
-  #   t1.append(t2)
-  #   t1.commit(redis)
-  #
-  # @see http://redis.io/topics/transactions Transactions in Redis.
-  class Transaction
-    class Store
-      class EntryAlreadyExistsError < RuntimeError
-      end
-
-      class NoEntryError < RuntimeError
-      end
-
-      def initialize
-        @dict = Hash.new
-      end
-
-      def [](key)
-        raise NoEntryError unless @dict.member?(key)
-
-        @dict[key]
-      end
-
-      def []=(key, value)
-        raise EntryAlreadyExistsError if @dict.member?(key)
-
-        @dict[key] = value
-      end
-    end
-
-    attr :phase
-
-    def initialize
-      @phase = Hash.new { |h, k| h[k] = Array.new }
-
-      yield self if block_given?
-    end
-
-    def append(t)
-      t.phase.each do |key, values|
-        phase[key].concat(values - phase[key])
-      end
-
-      self
-    end
-
-    def watch(*keys)
-      phase[:watch].concat(keys - phase[:watch])
-    end
-
-    def read(&block)
-      phase[:read] << block
-    end
-
-    def write(&block)
-      phase[:write] << block
-    end
-
-    def before(&block)
-      phase[:before] << block
-    end
-
-    def after(&block)
-      phase[:after] << block
-    end
-
-    def commit(db)
-      phase[:before].each(&:call)
-
-      loop do
-        store = Store.new
-
-        if phase[:watch].any?
-          db.watch(*phase[:watch])
-        end
-
-        run(phase[:read], store)
-
-        break if db.multi do
-          run(phase[:write], store)
-        end
-
-        store = nil
-      end
-
-      phase[:after].each(&:call)
-    end
-
-    def run(procs, store)
-      procs.each { |p| p.call(store) }
-    end
-  end
-
-  def self.transaction(&block)
-    Transaction.new(&block)
-  end
-end

data/test/1.8.6_test.rb

@@ -1,25 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("./helper", File.dirname(__FILE__))
-
-prepare.clear
-
-test "String#lines should return the parts when separated with \\n" do
-  assert ["a\n", "b\n", "c\n"] == "a\nb\nc\n".lines.to_a
-end
-
-test "String#lines return the parts when separated with \\r\\n" do
-  assert ["a\r\n", "b\r\n", "c\r\n"] == "a\r\nb\r\nc\r\n".lines.to_a
-end
-
-test "String#lines accept a record separator" do
-  assert ["ax", "bx", "cx"] == "axbxcx".lines("x").to_a
-end
-
-test "String#lines execute the passed block" do
-  lines = ["a\r\n", "b\r\n", "c\r\n"]
-
-  "a\r\nb\r\nc\r\n".lines do |line|
-    assert lines.shift == line
-  end
-end

data/test/pipeline-performance.rb

@@ -1,67 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("./helper", File.dirname(__FILE__))
-
-Ohm.flush
-
-class User < Ohm::Model
-  attribute :fname
-  attribute :lname
-  attribute :bday
-  attribute :gender
-  attribute :city
-  attribute :state
-  attribute :country
-  attribute :zip
-end
-
-create = lambda do |i|
-  User.new(:fname => "John#{i}",
-           :lname => "Doe#{i}",
-           :bday => Time.now.to_s,
-           :gender => "Male",
-           :city => "Los Angeles",
-           :state => "CA",
-           :country => "US",
-           :zip => "90210").save
-end
-
-10.times(&create)
-
-require "benchmark"
-
-t1 = Benchmark.realtime do
-  User.all.sort_by(:fname, :order => "DESC ALPHA").each do |user|
-  end
-end
-
-t2 = Benchmark.realtime do
-  ids = User.key[:all].smembers
-
-  ids.each do |id|
-    User[id]
-  end
-end
-
-test "pipelined approach should be 1.5 at least times faster for 10 records" do
-  assert(t2 / t1 >= 1.5)
-end
-
-90.times(&create)
-
-t1 = Benchmark.realtime do
-  User.all.sort_by(:fname, :order => "DESC ALPHA").each do |user|
-  end
-end
-
-t2 = Benchmark.realtime do
-  ids = User.key[:all].smembers
-
-  ids.each do |id|
-    User[id]
-  end
-end
-
-test "the pipelined approach should be faster for 100 records" do
-  assert(t2 > t1)
-end

data/test/transactions.rb

@@ -1,240 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("./helper", File.dirname(__FILE__))
-require "ohm/transaction"
-
-prepare do
-  Ohm.redis.del("foo")
-end
-
-setup do
-  Ohm.redis
-end
-
-test "basic functionality" do |db|
-  t = Ohm::Transaction.new
-  x = nil
-
-  t.watch("foo")
-
-  t.read do
-    x = db.get("foo")
-  end
-
-  t.write do
-    db.set("foo", x.to_i + 2)
-  end
-
-  t.commit(db)
-
-  assert_equal "2", db.get("foo")
-end
-
-test "new returns a transaction" do |db|
-  t1 = Ohm::Transaction.new do |t|
-    t.write do
-      db.set("foo", "bar")
-    end
-  end
-
-  t1.commit(db)
-
-  assert_equal "bar", db.get("foo")
-end
-
-test "transaction local storage" do |db|
-  t1 = Ohm::Transaction.new do |t|
-    t.read do |s|
-      s[:foo] = db.type("foo")
-    end
-
-    t.write do |s|
-      db.set("foo", s[:foo].reverse)
-    end
-  end
-
-  t1.commit(db)
-
-  assert_equal "enon", db.get("foo")
-end
-
-test "composed transaction" do |db|
-  t1 = Ohm::Transaction.new do |t|
-    t.watch("foo")
-
-    t.write do
-      db.set("foo", "bar")
-    end
-  end
-
-  t2 = Ohm::Transaction.new do |t|
-    t.watch("foo")
-
-    t.write do
-      db.set("foo", "baz")
-    end
-  end
-
-  t3 = Ohm::Transaction.new
-  t3.append(t1)
-  t3.append(t2)
-  t3.commit(db)
-
-  assert_equal "baz", db.get("foo")
-
-  t4 = Ohm::Transaction.new
-  t4.append(t2)
-  t4.append(t1)
-  t4.commit(db)
-
-  assert_equal "bar", db.get("foo")
-
-  t5 = Ohm::Transaction.new
-  t5.append(t4)
-  t5.commit(db)
-
-  assert_equal "bar", db.get("foo")
-
-  assert_equal ["foo"], t5.phase[:watch]
-  assert_equal 2, t5.phase[:write].size
-end
-
-test "composing transactions with append" do |db|
-  t1 = Ohm::Transaction.new do |t|
-    t.write do
-      db.set("foo", "bar")
-    end
-  end
-
-  t2 = Ohm::Transaction.new do |t|
-    t.write do
-      db.set("foo", "baz")
-    end
-  end
-
-  t1.append(t2)
-  t1.commit(db)
-
-  assert_equal "baz", db.get("foo")
-
-  t2.append(t1)
-  t2.commit(db)
-
-  assert_equal "bar", db.get("foo")
-end
-
-test "appending or prepending is determined by when append is called" do |db|
-  t1 = Ohm::Transaction.new do |t|
-    t.write do
-      db.set("foo", "bar")
-    end
-  end
-
-  t2 = Ohm::Transaction.new do |t|
-    t.append(t1)
-
-    t.write do
-      db.set("foo", "baz")
-    end
-  end
-
-  t3 = Ohm::Transaction.new do |t|
-    t.write do
-      db.set("foo", "baz")
-    end
-
-    t.append(t1)
-  end
-
-  t2.commit(db)
-
-  assert_equal "baz", db.get("foo")
-
-  t3.commit(db)
-
-  assert_equal "bar", db.get("foo")
-end
-
-test "storage in composed transactions" do |db|
-  t1 = Ohm::Transaction.new do |t|
-    t.read do |s|
-      s[:foo] = db.type("foo")
-    end
-  end
-
-  t2 = Ohm::Transaction.new do |t|
-    t.write do |s|
-      db.set("foo", s[:foo].reverse)
-    end
-  end
-
-  t1.append(t2).commit(db)
-
-  assert_equal "enon", db.get("foo")
-end
-
-test "reading an storage entries that doesn't exist raises" do |db|
-  t1 = Ohm::Transaction.new do |t|
-    t.read do |s|
-      s[:foo]
-    end
-  end
-
-  assert_raise Ohm::Transaction::Store::NoEntryError do
-    t1.commit(db)
-  end
-end
-
-test "storage entries can't be overriden" do |db|
-  t1 = Ohm::Transaction.new do |t|
-    t.read do |s|
-      s[:foo] = db.type("foo")
-    end
-  end
-
-  t2 = Ohm::Transaction.new do |t|
-    t.read do |s|
-      s[:foo] = db.exists("foo")
-    end
-  end
-
-  assert_raise Ohm::Transaction::Store::EntryAlreadyExistsError do
-    t1.append(t2).commit(db)
-  end
-end
-
-test "banking transaction" do |db|
-  class A < Ohm::Model
-    attribute :amount
-  end
-
-  class B < Ohm::Model
-    attribute :amount
-  end
-
-  def transfer(amount, account1, account2)
-    Ohm.transaction do |t|
-
-      t.watch(account1.key, account2.key)
-
-      t.read do |s|
-        s[:available] = account1.get(:amount).to_i
-      end
-
-      t.write do |s|
-        if s[:available] >= amount
-          account1.key.hincrby(:amount, - amount)
-          account2.key.hincrby(:amount,   amount)
-        end
-      end
-    end
-  end
-
-  a = A.create :amount => 100
-  b = B.create :amount => 0
-
-  transfer(100, a, b).commit(db)
-
-  assert_equal a.get(:amount), "0"
-  assert_equal b.get(:amount), "100"
-end