ohm 0.1.5 → 1.0.0.alpha1

data/lib/ohm/transaction.rb

@@ -0,0 +1,129 @@
+require "set"
+
+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/topic/transactions Transactions in Redis.
+  class Transaction
+    class Store < BasicObject
+      class EntryAlreadyExistsError < ::RuntimeError
+      end
+
+      def method_missing(writer, value)
+        super unless writer[-1] == "="
+
+        reader = writer[0..-2].to_sym
+
+        __metaclass__.send(:define_method, reader) do
+          value
+        end
+
+        __metaclass__.send(:define_method, writer) do |*_|
+          ::Kernel.raise EntryAlreadyExistsError
+        end
+      end
+
+    private
+      def __metaclass__
+        class << self; self end
+      end
+    end
+
+    attr :phase
+
+    def initialize
+      @phase = Hash.new { |h, k| h[k] = ::Set.new }
+
+      yield self if block_given?
+    end
+
+    def append(t)
+      t.phase.each do |key, values|
+        phase[key].merge(values)
+      end
+
+      self
+    end
+
+    def watch(*keys)
+      phase[:watch] += keys
+    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
+      end
+
+      phase[:after].each(&:call)
+    end
+
+    def run(procs, store)
+      procs.each { |p| p.call(store) }
+    end
+  end
+end

data/test/association.rb

@@ -0,0 +1,33 @@
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+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,72 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+prepare.clear
+
+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 "model can define its own connection" do
+  class B < Ohm::Model
+    connect(:url => "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"}
+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
+end

data/test/core.rb

@@ -0,0 +1,26 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+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 "32° Kisei-sen" == Event[event.id].name
+end

data/test/counters.rb

@@ -0,0 +1,67 @@
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+$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/extensibility.rb

@@ -0,0 +1,48 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+if defined?(Ohm::Model::PureRuby)
+  class User < Ohm::Model
+    attribute :email
+
+    attr_accessor :foo
+
+    def save
+      super do |t|
+        t.before do
+          self.email = email.downcase
+        end
+
+        t.after do
+          if @foo
+            key[:foos].sadd(@foo)
+          end
+        end
+      end
+    end
+
+    def delete
+      super do |t|
+        foos = nil
+
+        t.before do
+          foos = key[:foos].smembers
+        end
+
+        t.after do
+          foos.each { |foo| key[:foos].srem(foo) }
+        end
+      end
+    end
+  end
+
+  test do
+    u = User.create(email: "FOO@BAR.COM", foo: "bar")
+    assert_equal "foo@bar.com", u.email
+    assert_equal ["bar"], u.key[:foos].smembers
+
+    u.delete
+    assert_equal [], User.key[u.id][:foos].smembers
+  end
+end

data/test/filtering.rb

@@ -0,0 +1,42 @@
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+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 "#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

data/test/indices.rb

@@ -0,0 +1,97 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+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 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.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