ohm 1.0.0.alpha2 → 1.0.0.rc1

data/{README.markdown → README.md}

@@ -123,47 +123,51 @@ the example below:
 
 ### Example
 
-    class Event < Ohm::Model
-      attribute :name
-      reference :venue, Venue
-      set :participants, Person
-      counter :votes
+```ruby
+class Event < Ohm::Model
+  attribute :name
+  reference :venue, Venue
+  set :participants, Person
+  counter :votes
 
-      index :name
+  index :name
 
-      def validate
-        assert_present :name
-      end
-    end
+  def validate
+    assert_present :name
+  end
+end
 
-    class Venue < Ohm::Model
-      attribute :name
-      collection :events, Event
-    end
+class Venue < Ohm::Model
+  attribute :name
+  collection :events, Event
+end
 
-    class Person < Ohm::Model
-      attribute :name
-    end
+class Person < Ohm::Model
+  attribute :name
+end
+```
 
 All models have the `id` attribute built in, you don't need to declare it.
 
 This is how you interact with IDs:
 
-    event = Event.create :name => "Ohm Worldwide Conference 2031"
-    event.id
-    # => 1
+```ruby
+event = Event.create :name => "Ohm Worldwide Conference 2031"
+event.id
+# => 1
 
-    # Find an event by id
-    event == Event[1]
-    # => true
+# Find an event by id
+event == Event[1]
+# => true
 
-    # Trying to find a non existent event
-    Event[2]
-    # => nil
+# Trying to find a non existent event
+Event[2]
+# => nil
 
-    # Finding all the events
-    Event.all
-    # => [#<Event @values={:id=>1, :name=>"Ohm Worldwide Conference 2031"}>]
+# Finding all the events
+Event.all
+# => [#<Event @values={:id=>1, :name=>"Ohm Worldwide Conference 2031"}>]
+```
 
 This example shows some basic features, like attribute declarations and
 validations. Keep reading to find out what you can do with models.
@@ -233,35 +237,43 @@ For most use cases, this pattern doesn't represent a problem.
 If you need to check for validity before operating on lists, sets or
 counters, you can use this pattern:
 
-    if event.valid?
-      event.comments << Comment.create(:body => "Great event!")
-    end
+```ruby
+if event.valid?
+  event.comments.add(Comment.create(:body => "Great event!"))
+end
+```
 
 If you are saving the object, this will suffice:
 
-    if event.save
-      event.comments << Comment.create(:body => "Wonderful event!")
-    end
+```ruby
+if event.save
+  event.comments.add(Comment.create(:body => "Wonderful event!"))
+end
+```
 
 Working with Sets
 -----------------
 
 Given the following model declaration:
 
-    class Event < Ohm::Model
-      attribute :name
-      set :attendees, Person
-    end
+```ruby
+class Event < Ohm::Model
+  attribute :name
+  set :attendees, Person
+end
+```
 
 You can add instances of `Person` to the set of attendees with the
-`<<` method:
+`add` method:
 
-    event.attendees << Person.create(:name => "Albert")
+```ruby
+event.attendees.add(Person.create(:name => "Albert"))
 
-    # And now...
-    event.attendees.each do |person|
-      # ...do what you want with this person.
-    end
+# And now...
+event.attendees.each do |person|
+  # ...do what you want with this person.
+end
+```
 
 ## Sorting
 
@@ -275,22 +287,25 @@ order. Both methods receive an options hash which is explained below:
 
 Order direction and strategy. You can pass in any of the following:
 
-     1. ASC
-     2. ASC ALPHA (or ALPHA ASC)
-     3. DESC
-     4. DESC ALPHA (or ALPHA DESC)
+1. ASC
+2. ASC ALPHA (or ALPHA ASC)
+3. DESC
+4. DESC ALPHA (or ALPHA DESC)
 
 It defaults to `ASC`.
 
-### :start
+__Important Note:__ Starting with Redis 2.6, `ASC` and `DESC` only
+work with integers or floating point data types. If you need to sort
+by an alphanumeric field, add the `ALPHA` keyword.
+
+### :limit
 
-The offset from which we should start with. Note that
+The offset and limit from which we should start with. Note that
 this is 0-indexed. It defaults to `0`.
 
-### :limit
+Example:
 
-The number of entries to get. If you don't pass in anything, it will
-get all the results from the LIST or SET that you are sorting.
+`limit: [0, 10]` will get the first 10 entries starting from offset 0.
 
 ### :by
 
@@ -300,8 +315,14 @@ using {Ohm::Model::Collection#sort sort} and
 converts the passed argument with the assumption that it is a hash key
 and it's within the current model you are sorting.
 
-    Post.all.sort_by(:title)     # SORT Post:all BY Post:*->title
-    Post.all.sort(:by => :title) # SORT Post:all BY title
+```ruby
+Post.all.sort_by(:title)     # SORT Post:all BY Post:*->title
+Post.all.sort(:by => :title) # SORT Post:all BY title
+```
+
+__Tip:__ Unless you absolutely know what you're doing, use `sort`
+when you want to sort your models by their `id`, and use `sort_by`
+otherwise.
 
 ### :get
 
@@ -310,34 +331,13 @@ the `:by` option, using {Ohm::Model::Collection#sort sort} and
 {Ohm::Model::Collection#sort_by sort_by} has distinct differences in
 that `sort_by` does much of the hand-coding for you.
 
-    Post.all.sort_by(:title, :get => :title)
-    # SORT Post:all BY Post:*->title GET Post:*->title
-
-    Post.all.sort(:by => :title, :get => :title)
-    # SORT Post:all BY title GET title
-
-
-### :store
-
-An optional key which you may use to cache the sorted result. The key
-may or may not exist.
-
-This option can only be used together with `:get`.
+```ruby
+Post.all.sort_by(:title, :get => :title)
+# SORT Post:all BY Post:*->title GET Post:*->title
 
-The type that is used for the STORE key is a LIST.
-
-    Post.all.sort_by(:title, :store => "FOO")
-
-    # Get all the results stored in FOO.
-    Post.db.lrange("FOO", 0, -1)
-
-When using temporary values, it might be a good idea to use a `volatile`
-key. In Ohm, a volatile key means it just starts with a `~` character.
-
-    Post.all.sort_by(:title, :get => :title,
-                     :store => Post.key.volatile["FOO"])
-
-    Post.key.volatile["FOO"].lrange 0, -1
+Post.all.sort(:by => :title, :get => :title)
+# SORT Post:all BY title GET title
+```
 
 
 Associations
@@ -345,16 +345,18 @@ Associations
 
 Ohm lets you declare `references` and `collections` to represent associations.
 
-    class Post < Ohm::Model
-      attribute :title
-      attribute :body
-      collection :comments, Comment
-    end
+```ruby
+class Post < Ohm::Model
+  attribute :title
+  attribute :body
+  collection :comments, Comment
+end
 
-    class Comment < Ohm::Model
-      attribute :body
-      reference :post, Post
-    end
+class Comment < Ohm::Model
+  attribute :body
+  reference :post, Post
+end
+```
 
 After this, every time you refer to `post.comments` you will be talking
 about instances of the model `Comment`. If you want to get a list of IDs
@@ -365,20 +367,22 @@ you can use `post.comments.key.smembers`.
 Doing a {Ohm::Model.reference reference} is actually just a shortcut for
 the following:
 
-    # Redefining our model above
-    class Comment < Ohm::Model
-      attribute :body
-      attribute :post_id
-      index :post_id
+```ruby
+# Redefining our model above
+class Comment < Ohm::Model
+  attribute :body
+  attribute :post_id
+  index :post_id
 
-      def post=(post)
-        self.post_id = post.id
-      end
+  def post=(post)
+    self.post_id = post.id
+  end
 
-      def post
-        Post[post_id]
-      end
-    end
+  def post
+    Post[post_id]
+  end
+end
+```
 
 The only difference with the actual implementation is that the model
 is memoized.
@@ -386,8 +390,9 @@ is memoized.
 The net effect here is we can conveniently set and retrieve `Post` objects,
 and also search comments using the `post_id` index.
 
-    Comment.find(:post_id => 1)
-
+```ruby
+Comment.find(:post_id => 1)
+```
 
 ### Collections explained
 
@@ -397,34 +402,38 @@ just a macro that defines a finder for you, and we know that to find a model
 by a field requires an {Ohm::Model.index index} to be defined for the field
 you want to search.
 
-    # Redefining our post above
-    class Post < Ohm::Model
-      attribute :title
-      attribute :body
+```ruby
+# Redefining our post above
+class Post < Ohm::Model
+  attribute :title
+  attribute :body
 
-      def comments
-        Comment.find(:post_id => self.id)
-      end
-    end
+  def comments
+    Comment.find(:post_id => self.id)
+  end
+end
+```
 
 The only "magic" happening is with the inference of the `index` that was used
 in the other model. The following all produce the same effect:
 
-    # easiest, with the basic assumption that the index is `:post_id`
-    collection :comments, Comment
+```ruby
+# easiest, with the basic assumption that the index is `:post_id`
+collection :comments, Comment
 
-    # we can explicitly declare this as follows too:
-    collection :comments, Comment, :post
+# we can explicitly declare this as follows too:
+collection :comments, Comment, :post
 
-    # finally, we can use the default argument for the third parameter which
-    # is `to_reference`.
-    collection :comments, Comment, to_reference
+# finally, we can use the default argument for the third parameter which
+# is `to_reference`.
+collection :comments, Comment, to_reference
 
-    # exploring `to_reference` reveals a very interesting and simple concept:
-    Post.to_reference == :post
-    # => true
+# exploring `to_reference` reveals a very interesting and simple concept:
+Post.to_reference == :post
+# => true
+```
 
-Indexes
+Indices
 -------
 
 An {Ohm::Model.index index} is a set that's handled automatically by Ohm. For
@@ -442,28 +451,54 @@ validation and the methods {Ohm::Model::Set#find find} and
 
 You can find a collection of records with the `find` method:
 
-    # This returns a collection of users with the username "Albert"
-    User.find(:username => "Albert")
+```ruby
+# This returns a collection of users with the username "Albert"
+User.find(:username => "Albert")
+```
 
 ### Filtering results
 
-    # Find all users from Argentina
-    User.find(:country => "Argentina")
+```ruby
+# Find all users from Argentina
+User.find(:country => "Argentina")
 
-    # Find all activated users from Argentina
-    User.find(:country => "Argentina", :status => "activated")
+# Find all activated users from Argentina
+User.find(:country => "Argentina", :status => "activated")
 
-    # Find all users from Argentina, except those with a suspended account.
-    User.find(:country => "Argentina").except(:status => "suspended")
+# Find all users from Argentina, except those with a suspended account.
+User.find(:country => "Argentina").except(:status => "suspended")
 
-    # Find all users both from Argentina and Uruguay
-    User.find(:country => "Argentina").union(:country => "Uruguay")
+# Find all users both from Argentina and Uruguay
+User.find(:country => "Argentina").union(:country => "Uruguay")
+```
 
 Note that calling these methods results in new sets being created
 on the fly. This is important so that you can perform further operations
 before reading the items to the client.
 
-For more information, see [SINTERSTORE](http://redis.io/commands/sinterstore) and [SDIFFSTORE](http://redis.io/commands/sdiffstore).
+For more information, see [SINTERSTORE](http://redis.io/commands/sinterstore),
+[SDIFFSTORE](http://redis.io/commands/sdiffstore) and
+[SUNIONSTORE](http://redis.io/commands/sunionstore)
+
+Uniques
+-------
+
+Uniques are similar to indices except that there can only be one record per
+entry. The canonical example of course would be the email of your user, e.g.
+
+```ruby
+class User < Ohm::Model
+  attribute :email
+  unique :email
+end
+
+u = User.create(email: "foo@bar.com")
+u == User.with(:email, "foo@bar.com")
+# => true
+
+User.create(email: "foo@bar.com")
+# => raises Ohm::UniqueIndexViolation
+```
 
 Validations
 -----------
@@ -486,37 +521,38 @@ The `assert` method is used by all the other assertions. It pushes the
 second parameter to the list of errors if the first parameter evaluates
 to false.
 
-    def assert(value, error)
-      value or errors.push(error) && false
-    end
+```ruby
+def assert(value, error)
+  value or errors.push(error) && false
+end
+```
 
 ### assert_present
 
 Checks that the given field is not nil or empty. The error code for this
-assertion is :not_present.
+assertion is `:not_present`.
 
-    assert_present :name
+```ruby
+assert_present :name
+```
 
 ### assert_format
 
 Checks that the given field matches the provided format. The error code
 for this assertion is :format.
 
-    assert_format :username, /^\w+$/
+```ruby
+assert_format :username, /^\w+$/
+```
 
 ### assert_numeric
 
 Checks that the given field holds a number as a Fixnum or as a string
 representation. The error code for this assertion is :not_numeric.
 
-    assert_numeric :votes
-
-### assert_unique
-
-Validates that the attribute or array of attributes are unique.
-For this, an index of the same kind must exist. The error code is :not_unique.
-
-    assert_unique :email
+```ruby
+assert_numeric :votes
+```
 
 Errors
 ------
@@ -529,60 +565,37 @@ was issued and the error code.
 
 Given the following example:
 
-    def validate
-      assert_present :foo
-      assert_numeric :bar
-      assert_format :baz, /^\d{2}$/
-      assert_unique :qux
-    end
+```ruby
+def validate
+  assert_present :foo
+  assert_numeric :bar
+  assert_format :baz, /^\d{2}$/
+end
+```
 
 If all the assertions fail, the following errors will be present:
 
-    obj.errors
-    # => [[:foo, :not_present], [:bar, :not_numeric], [:baz, :format], [:qux, :not_unique]]
-
-Presenting errors
------------------
-
-Unlike other ORMs, that define the full error messages in the model
-itself, Ohm encourages you to define the error messages outside. If
-you are using Ohm in the context of a web framework, the views are the
-proper place to write the error messages.
-
-Ohm provides a presenter that helps you in this quest. The basic usage
-is as follows:
-
-    error_messages = @model.errors.present do |e|
-      e.on [:name, :not_present], "Name must be present"
-      e.on [:account, :not_present], "You must supply an account"
-    end
-
-    error_messages
-    # => ["Name must be present", "You must supply an account"]
-
-Having the error message definitions in the views means you can use any
-sort of helpers. You can also use blocks instead of strings for the
-values. The result of the block is used as the error message:
-
-    error_messages = @model.errors.present do |e|
-      e.on [:email, :not_unique] do
-        "The email #{@model.email} is already registered."
-      end
-    end
-
-    error_messages
-    # => ["The email foo@example.com is already registered."]
+```ruby
+obj.errors
+# => { foo: [:not_present], bar: [:not_numeric], baz: [:format] }
+```
 
 Ohm Extensions
 ==============
 
 Ohm is rather small and can be extended in many ways.
 
-A lot of amazing contributions are available at [Ohm Contrib](http://cyx.github.com/ohm-contrib/doc/), make sure to check them if you need to extend Ohm's functionality.
+A lot of amazing contributions are available at [Ohm Contrib][contrib]
+make sure to check them if you need to extend Ohm's functionality.
+
+[contrib]: http://cyx.github.com/ohm-contrib/doc/, 
 
 Tutorials
 =========
 
+NOTE: These tutorials were written against Ohm 0.1.x. Please give us
+a while to fully update all of them.
+
 Check the examples to get a feeling of the design patterns for Redis.
 
 1. [Activity Feed](http://ohm.keyvalue.org/examples/activity-feed.html)
@@ -594,11 +607,12 @@ Check the examples to get a feeling of the design patterns for Redis.
 7. [Slugs and permalinks](http://ohm.keyvalue.org/examples/slug.html)
 8. [Tagging](http://ohm.keyvalue.org/examples/tagging.html)
 
+
 Versions
 ========
 
-Ohm uses features from Redis > 1.3.10. If you are stuck in previous
-versions, please use Ohm 0.0.35 instead.
+Ohm uses features from Redis > 2.6.x. If you are stuck in previous
+versions, please use Ohm 0.1.x instead.
 
 Upgrading from 0.0.x to 0.1
 ---------------------------
@@ -607,11 +621,13 @@ Since Ohm 0.1 changes the persistence strategy (from 1-key-per-attribute
 to Hashes), you'll need to run a script to upgrade your old data set.
 Fortunately, it is built in:
 
-    require "ohm/utils/upgrade"
+```ruby
+require "ohm/utils/upgrade"
 
-    Ohm.connect :port => 6380
+Ohm.connect :port => 6380
 
-    Ohm::Utils::Upgrade.new([:User, :Post, :Comment]).run
+Ohm::Utils::Upgrade.new([:User, :Post, :Comment]).run
+```
 
 Yes, you need to provide the model names. The good part is that you
 don't have to load your application environment. Since we assume it's

data/lib/ohm.rb

@@ -267,45 +267,145 @@ module Ohm
 
     def fetch(ids)
       arr = model.db.pipelined do
-        ids.each { |id| namespace[id].hgetall }
+        ids.each { |id| model.db.hgetall(namespace[id]) }
       end
 
       return [] if arr.nil?
 
       arr.map.with_index do |atts, idx|
-        model.new(atts.update(id: ids[idx]))
+        model.new(Hash[*atts].update(id: ids[idx]))
       end
     end
   end
 
-  class Set < Struct.new(:key, :namespace, :model)
-    include Collection
+  class List < Struct.new(:key, :namespace, :model)
+    include Enumerable
 
-    # Add a model directly to the set.
+    # Returns the total size of the list using LLEN.
+    def size
+      key.llen
+    end
+
+    # Returns the first element of the list using LINDEX.
+    def first
+      model[key.lindex(0)]
+    end
+
+    # Returns the last element of the list using LINDEX.
+    def last
+      model[key.lindex(-1)]
+    end
+
+    # Checks if the model is part of this List.
+    #
+    # An important thing to note is that this method loads all of the
+    # elements of the List since there is no command in Redis that
+    # allows you to actually check the list contents efficiently.
+    #
+    # You may want to avoid doing this if your list has say, 10K entries.
+    def include?(model)
+      ids.include?(model.id.to_s)
+    end
+
+    # Replace all the existing elements of a list with a different
+    # collection of models. This happens atomically in a MULTI-EXEC
+    # block.
     #
     # Example:
     #
     #   user = User.create
-    #   post = Post.create
+    #   p1 = Post.create
+    #   user.posts.push(p1)
     #
-    #   user.posts.add(post)
+    #   p2, p3 = Post.create, Post.create
+    #   user.posts.replace([p2, p3])
     #
-    def add(model)
-      key.sadd(model.id)
+    #   user.posts.include?(p1)
+    #   # => false
+    #
+    def replace(models)
+      ids = models.map { |model| model.id }
+
+      model.db.multi do
+        key.del
+        ids.each { |id| key.rpush(id) }
+      end
     end
 
-    # Remove a model directly from the set.
+    # Fetch the data from Redis in one go.
+    def to_a
+      fetch(ids)
+    end
+
+    def each
+      to_a.each { |element| yield element }
+    end
+
+    def empty?
+      size == 0
+    end
+
+    # Pushes the model to the _end_ of the list using RPUSH.
+    def push(model)
+      key.rpush(model.id)
+    end
+
+    # Pushes the model to the _beginning_ of the list using LPUSH.
+    def unshift(model)
+      key.lpush(model.id)
+    end
+
+    # Delete a model from the list.
+    #
+    # Note: If your list contains the model multiple times, this method
+    # will delete all instances of that model in one go.
     #
     # Example:
     #
-    #   user = User.create
-    #   post = Post.create
+    #   class Comment < Ohm::Model
+    #   end
     #
-    #   user.posts.delete(post)
+    #   class Post < Ohm::Model
+    #     list :comments, Comment
+    #   end
+    #
+    #   p = Post.create
+    #   c = Comment.create
+    #
+    #   p.comments.push(c)
+    #   p.comments.push(c)
+    #
+    #   p.comments.delete(c)
+    #
+    #   p.comments.size == 0
+    #   # => true
     #
     def delete(model)
-      key.srem(model.id)
+      # LREM key 0 <id> means remove all elements matching <id>
+      # @see http://redis.io/commands/lrem
+      key.lrem(0, model.id)
+    end
+
+  private
+    def ids
+      key.lrange(0, -1)
+    end
+
+    def fetch(ids)
+      arr = model.db.pipelined do
+        ids.each { |id| model.db.hgetall(namespace[id]) }
+      end
+
+      return [] if arr.nil?
+
+      arr.map.with_index do |atts, idx|
+        model.new(Hash[*atts].update(id: ids[idx]))
+      end
     end
+  end
+
+  class Set < Struct.new(:key, :namespace, :model)
+    include Collection
 
     # Chain new fiters on an existing set.
     #
@@ -349,6 +449,39 @@ module Ohm
       MultiSet.new([key], namespace, model).union(dict)
     end
 
+  private
+    def execute
+      yield key
+    end
+  end
+
+  class MutableSet < Set
+    # Add a model directly to the set.
+    #
+    # Example:
+    #
+    #   user = User.create
+    #   post = Post.create
+    #
+    #   user.posts.add(post)
+    #
+    def add(model)
+      key.sadd(model.id)
+    end
+
+    # Remove a model directly from the set.
+    #
+    # Example:
+    #
+    #   user = User.create
+    #   post = Post.create
+    #
+    #   user.posts.delete(post)
+    #
+    def delete(model)
+      key.srem(model.id)
+    end
+
     # Replace all the existing elements of a set with a different
     # collection of models. This happens atomically in a MULTI-EXEC
     # block.
@@ -373,13 +506,9 @@ module Ohm
         ids.each { |id| key.sadd(id) }
       end
     end
-
-  private
-    def execute
-      yield key
-    end
   end
 
+
   # Anytime you filter a set with more than one requirement, you
   # internally use a `MultiSet`. `MutiSet` is a bit slower than just
   # a `Set` because it has to `SINTERSTORE` all the keys prior to
@@ -693,7 +822,37 @@ module Ohm
       define_method name do
         model = Utils.const(self.class, model)
 
-        Ohm::Set.new(key[name], model.key, model)
+        Ohm::MutableSet.new(key[name], model.key, model)
+      end
+    end
+
+    # Declare an Ohm::List with the given name.
+    #
+    # Example:
+    #
+    #   class Comment < Ohm::Model
+    #   end
+    #
+    #   class Post < Ohm::Model
+    #     list :comments, :Comment
+    #   end
+    #
+    #   p = Post.create
+    #   p.comments.push(Comment.create)
+    #   p.comments.unshift(Comment.create)
+    #   p.comments.size == 2
+    #   # => true
+    #
+    # Note: You can't use the list until you save the model. If you try
+    # to do it, you'll receive an Ohm::MissingID error.
+    #
+    def self.list(name, model)
+      collections << name unless collections.include?(name)
+
+      define_method name do
+        model = Utils.const(self.class, model)
+
+        Ohm::List.new(key[name], model.key, model)
       end
     end
 
@@ -1027,11 +1186,6 @@ module Ohm
       return attrs
     end
 
-    # Export a JSON representation of the model by encoding `to_hash`.
-    def to_json(*args)
-      to_hash.to_json(*args)
-    end
-
     # Persist the model attributes and update indices and unique
     # indices. The `counter`s and `set`s are not touched during save.
     #
@@ -1210,6 +1364,8 @@ module Ohm
         atts.each do |att, val|
           ret[att] = send(att).to_s unless val.to_s.empty?
         end
+
+        throw :empty if ret.empty?
       end
     end
 
@@ -1218,8 +1374,10 @@ module Ohm
     end
 
     def _save
-      key.del
-      key.hmset(*_skip_empty(attributes).flatten)
+      catch :empty do
+        key.del
+        key.hmset(*_skip_empty(attributes).flatten)
+      end
     end
 
     def _verify_uniques

data/lib/ohm/json.rb

@@ -0,0 +1,24 @@
+require "json"
+
+module Ohm
+  class Model
+    # Export a JSON representation of the model by encoding `to_hash`.
+    def to_json(*args)
+      to_hash.to_json(*args)
+    end
+  end
+
+  module Collection
+    # Sugar for to_a.to_json for all types of Sets
+    def to_json(*args)
+      to_a.to_json(*args)
+    end
+  end
+
+  class List
+    # Sugar for to_a.to_json for lists.
+    def to_json(*args)
+      to_a.to_json(*args)
+    end
+  end
+end

data/lib/ohm/transaction.rb

@@ -46,7 +46,7 @@ module Ohm
       class EntryAlreadyExistsError < ::RuntimeError
       end
 
-      def method_missing(writer, value)
+      def method_missing(writer, value = nil)
         super unless writer[-1] == "="
 
         reader = writer[0..-2].to_sym
@@ -69,14 +69,14 @@ module Ohm
     attr :phase
 
     def initialize
-      @phase = Hash.new { |h, k| h[k] = ::Set.new }
+      @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].merge(values)
+        phase[key].concat(values - phase[key])
       end
 
       self

data/test/connection.rb

@@ -4,13 +4,27 @@ 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
+
+  ex = nil
+
+  begin
+    Ohm.connect(settings)
+  rescue RuntimeError => e
+    ex = e
+  end
+
+  assert_equal ex, nil
+end
+
 test "connects lazily" do
   Ohm.connect(:port => 9876)
 
   begin
     Ohm.redis.get "foo"
   rescue => e
-    assert_equal Redis::CannotConnectError, e.class
+    assert_equal Errno::ECONNREFUSED, e.class
   end
 end
 
@@ -40,7 +54,7 @@ test "supports connecting by URL" do
   begin
     Ohm.redis.get "foo"
   rescue => e
-    assert_equal Redis::CannotConnectError, e.class
+    assert_equal Errno::ECONNREFUSED, e.class
   end
 end
 
@@ -54,6 +68,22 @@ test "connection class" do
   assert conn.redis.kind_of?(Redis)
 end
 
+test "issue #46" do
+  class B < Ohm::Model
+    connect(:url => "redis://localhost:6379/15")
+  end
+
+  # We do this since we did prepare.clear above.
+  B.db.flushall
+
+  b1, b2 = nil, nil
+
+  Thread.new { b1 = B.create }.join
+  Thread.new { b2 = B.create }.join
+
+  assert_equal [b1, b2], B.all.sort.to_a
+end
+
 test "model can define its own connection" do
   class B < Ohm::Model
     connect(:url => "redis://localhost:6379/1")

data/test/filtering.rb

@@ -24,6 +24,16 @@ test "findability" do |john, jane|
   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")
 

data/test/helper.rb

@@ -21,5 +21,5 @@ $VERBOSE = true
 require "ohm"
 
 prepare do
-  Ohm.flush
+  Ohm.redis.flushall
 end

data/test/json.rb

@@ -3,9 +3,11 @@
 require File.expand_path("./helper", File.dirname(__FILE__))
 
 require "json"
+require "ohm/json"
 
 class Venue < Ohm::Model
   attribute :name
+  list :programmers, :Programmer
 
   def validate
     assert_present :name
@@ -70,5 +72,15 @@ test "export an array of records to json" do
   Programmer.create(language: "Python")
 
   expected = [{ id: "1", language: "Ruby" }, { id: "2", language: "Python"}].to_json
-  assert_equal expected, Programmer.all.to_a.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.programmers.push(Programmer.create(language: "Ruby"))
+  venue.programmers.push(Programmer.create(language: "Python"))
+
+  expected = [{ id: "1", language: "Ruby" }, { id: "2", language: "Python"}].to_json
+  assert_equal expected, venue.programmers.to_json
 end

data/test/list.rb

@@ -0,0 +1,69 @@
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+class Post < Ohm::Model
+  list :comments, :Comment
+end
+
+class Comment < Ohm::Model
+end
+
+setup do
+  post = Post.create
+
+  post.comments.push(c1 = Comment.create)
+  post.comments.push(c2 = Comment.create)
+  post.comments.push(c3 = Comment.create)
+
+  [post, c1, c2, c3]
+end
+
+test "include?" do |p, c1, c2, c3|
+  assert p.comments.include?(c1)
+  assert p.comments.include?(c2)
+  assert p.comments.include?(c3)
+end
+
+test "first / last / size / empty?" do |p, c1, c2, c3|
+  assert_equal 3, p.comments.size
+  assert_equal c1, p.comments.first
+  assert_equal c3, p.comments.last
+  assert ! p.comments.empty?
+end
+
+test "replace" do |p, c1, c2, c3|
+  c4 = Comment.create
+
+  p.comments.replace([c4])
+
+  assert_equal [c4], p.comments.to_a
+end
+
+test "push / unshift" do |p, c1, c2, c3|
+  c4 = Comment.create
+  c5 = Comment.create
+
+  p.comments.unshift(c4)
+  p.comments.push(c5)
+
+  assert_equal c4, p.comments.first
+  assert_equal c5, p.comments.last
+end
+
+test "delete" do |p, c1, c2, c3|
+  p.comments.delete(c1)
+  assert_equal 2, p.comments.size
+  assert ! p.comments.include?(c1)
+
+  p.comments.delete(c2)
+  assert_equal 1, p.comments.size
+  assert ! p.comments.include?(c2)
+
+  p.comments.delete(c3)
+  assert p.comments.empty?
+end
+
+test "deleting main model cleans up the collection" do |p, _, _, _|
+  p.delete
+
+  assert ! Ohm.redis.exists(p.key[:comments])
+end

data/test/model.rb

@@ -51,6 +51,28 @@ class Meetup < Ohm::Model
   end
 end
 
+class Invoice < Ohm::Model
+  def _initialize_id
+    @id = "_custom_id"
+  end
+end
+
+test "customized ID" do
+  inv = Invoice.create
+  assert_equal "_custom_id", inv.id
+
+  i = Invoice.create(id: "_diff_id")
+  assert_equal "_diff_id", i.id
+  assert_equal i, Invoice["_diff_id"]
+end
+
+test "empty model is ok" do
+  class Foo < Ohm::Model
+  end
+
+  foo = Foo.create
+end
+
 test "counters are cleaned up during deletion" do
   e = Event.create(name: "Foo")
   e.incr :votes, 10

data/test/transactions.rb

@@ -95,7 +95,7 @@ test "composed transaction" do |db|
 
   assert_equal "bar", db.get("foo")
 
-  assert_equal Set.new(["foo"]), t5.phase[:watch]
+  assert_equal ["foo"], t5.phase[:watch]
   assert_equal 2, t5.phase[:write].size
 end
 
@@ -173,6 +173,18 @@ test "storage in composed transactions" do |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 NoMethodError 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|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ohm
 version: !ruby/object:Gem::Version
-  version: 1.0.0.alpha2
+  version: 1.0.0.rc1
   prerelease: 6
 platform: ruby
 authors:
@@ -10,11 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-23 00:00:00.000000000 Z
+date: 2012-04-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nest
-  requirement: &2156281500 !ruby/object:Gem::Requirement
+  requirement: &2155966540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -22,10 +22,10 @@ dependencies:
         version: '1.0'
   type: :runtime
   prerelease: false
-  version_requirements: *2156281500
+  version_requirements: *2155966540
 - !ruby/object:Gem::Dependency
   name: scrivener
-  requirement: &2156297300 !ruby/object:Gem::Requirement
+  requirement: &2155963980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -33,10 +33,10 @@ dependencies:
         version: 0.0.3
   type: :runtime
   prerelease: false
-  version_requirements: *2156297300
+  version_requirements: *2155963980
 - !ruby/object:Gem::Dependency
   name: cutest
-  requirement: &2156296800 !ruby/object:Gem::Requirement
+  requirement: &2155978980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -44,10 +44,10 @@ dependencies:
         version: '0.1'
   type: :development
   prerelease: false
-  version_requirements: *2156296800
+  version_requirements: *2155978980
 - !ruby/object:Gem::Dependency
   name: batch
-  requirement: &2156296280 !ruby/object:Gem::Requirement
+  requirement: &2155978440 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -55,7 +55,7 @@ dependencies:
         version: 0.0.1
   type: :development
   prerelease: false
-  version_requirements: *2156296280
+  version_requirements: *2155978440
 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.
@@ -66,10 +66,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/ohm/json.rb
 - lib/ohm/transaction.rb
 - lib/ohm/utils/upgrade.rb
 - lib/ohm.rb
-- README.markdown
+- README.md
 - LICENSE
 - Rakefile
 - test/1.8.6_test.rb
@@ -83,6 +84,7 @@ files:
 - test/helper.rb
 - test/indices.rb
 - test/json.rb
+- test/list.rb
 - test/lua-save.rb
 - test/lua.rb
 - test/model.rb
@@ -115,7 +117,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: ohm
-rubygems_version: 1.8.10
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: Object-hash mapping library for Redis.