ohm 2.0.0.alpha5 → 2.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eddfa837c7904b72acba3e95ea9af454412bef88
-  data.tar.gz: de756a4ef37ea55738cea7636a251a411da4cabd
+  metadata.gz: 60d1fadf47380356ffbc44627e28f9b15ff8528a
+  data.tar.gz: f911d9c462235f7c56f5216b10f1b2d48f3ab287
 SHA512:
-  metadata.gz: cc35a4e810775b5350ccd255035b2659b5559aa277d91a0f4584bf417bf663d4d27173d64ef324c7d305aba6eda8cc1f96bfde9ab71ead4f237b7382613cad45
-  data.tar.gz: 6314ece218f9ad0f82548dfb99b44db51979d14e8282277ae1abb9f4dfba5c96a68cadd8ec573efe6d475aeb0315b33aded1ce26862c28b3ff8cc6be8d761bfb
+  metadata.gz: 67eea41a25fd17691a9cc79700abf248438a7bccefc7624053212d6439d6252bfc2850e0a7905fe8a2ad46eadac6d9d11d150978cec4f937a2bbba89ea05e90b
+  data.tar.gz: 1e17aace64652f6c96cd79fa6ff071a67fbed614951af15e8487d8fee78b21ec69f10313b7e8b1004292d1f97a22c3d8be74d5f892172742fe634fea84989ef2

data/.gitignore

@@ -1,4 +1,3 @@
-/pkg
 /.yardoc
 /doc
-.rbenv-gemsets
+/.gs

data/CHANGELOG

@@ -1,3 +1,63 @@
+(unreleased)
+
+- Include Ohm::BasicSet#exists? in the public API. This makes possible
+	to check if an id is included in a set. Check Ohm::BasicSet#exists?
+	documentation for more details.
+
+- Change Ohm::MultiSet#except to union keys instead of intersect them
+  when passing an array.
+
+      class User < Ohm::Model
+        attribute :name
+      end
+
+      john = User.create(:name => "John")
+      jane = User.create(:name => "Jane")
+
+      res = User.all.except(:name => [john.name, jane.name])
+
+      # before
+      res.size # => 2
+
+      # now
+      res.size # => 0
+
+- Move ID generation to Lua. With this change, it's no longer possible
+	to generate custom ids. All ids are autoincremented.
+
+- Ohm::Model#reference accepts strings as model references. For example:
+
+      class Bar < Ohm::Model
+        reference :foo, "SomeNamespace::Foo"
+      end
+
+- Nest dependency has been removed. Now, Ohm uses Nido
+	(https://github.com/soveran/nido) to generate the keys that hold
+	the data.
+
+- Scrivener dependency has been removed.
+
+- Ohm no longer supports model validations and favors filter validation
+	on the boundary layer. Check Scrivener project
+	(https://github.com/soveran/scrivener) for more information.
+
+- Redis dependency has been removed. Now, Ohm uses Redic
+	(https://github.com/amakawa/redic), a lightweight Redis client.
+	Redic uses the hiredis gem for the connection and for parsing
+	the replies. Check Redic's README for more details.
+
+- Ohm::Model#transaction has been removed.
+
+- Ohm::Transaction has been removed.
+
+1.3.2
+
+- Fetching a batch of objects is now done in batches of 1000 objects at
+  a time. If you are iterating over large collections, this change should
+  provide a significant performance boost both in used memory and total
+  execution time.
+- MutableSet#<< is now an alias for #add.
+
 1.3.1
 
 - Improve memory consumption when indexing persisted attributes.

data/README.md

@@ -7,8 +7,7 @@ Description
 -----------
 
 Ohm is a library for storing objects in [Redis][redis], a persistent key-value
-database. It includes an extensible list of validations and has very good
-performance.
+database. It has very good performance.
 
 Community
 ---------
@@ -17,7 +16,6 @@ Join the mailing list: [http://groups.google.com/group/ohm-ruby](http://groups.g
 
 Meet us on IRC: [#ohm](irc://chat.freenode.net/#ohm) on [freenode.net](http://freenode.net/)
 
-
 Related projects
 ----------------
 
@@ -58,61 +56,55 @@ Now, in an irb session you can test the Redis adapter directly:
 
     >> require "ohm"
     => true
-    >> Ohm.connect
-    => []
-    >> Ohm.redis.set "Foo", "Bar"
+    >> Ohm.redis.call "SET", "Foo", "Bar"
     => "OK"
-    >> Ohm.redis.get "Foo"
+    >> Ohm.redis.call "GET", "Foo"
     => "Bar"
 
-## Connecting to the Redis database
-
-There are a couple of different strategies for connecting to your Redis
-database. The first is to explicitly set the `:host`, `:port`, `:db` and
-`:timeout` options. You can also set only a few of them, and let the other
-options fall back to the default.
-
-The other noteworthy style of connecting is by just doing `Ohm.connect` and
-set the environment variable `REDIS_URL`.
+## Connecting to a Redis database
 
-Here are the options for {Ohm.connect} in detail:
+Ohm uses a lightweight Redis client called [Redic][redic]. To connect
+to a Redis database, you will need to set an instance of `Redic`, with
+an URL of the form `redis://:<passwd>@<host>:<port>/<db>`, through the
+`Ohm.redis=` method, e.g.
 
-### :url (recommended)
-
-A Redis URL of the form `redis://:<passwd>@<host>:<port>/<db>`.
-Note that if you specify a URL and one of the other options at
-the same time, the other options will take precedence. Also, if
-you try and do `Ohm.connect` without any arguments, it will check
-if `ENV["REDIS_URL"]` is set, and will use it as the argument for
-`:url`.
+```ruby
+require "ohm"
 
-### :host
+Ohm.redis = Redic.new("redis://127.0.0.1:6379")
 
-Host where the Redis server is running, defaults to `"127.0.0.1"`.
+Ohm.redis.call "SET", "Foo", "Bar"
 
-### :port
+Ohm.redis.call "GET", "Foo"
+# => "Bar"
+```
 
-Port number, defaults to `6379`.
+Ohm defaults to a Redic connection to "redis://127.0.0.1:6379". The
+example above could be rewritten as:
 
-### :db
+```ruby
+require "ohm"
 
-Database number, defaults to `0`.
+Ohm.redis.call "SET", "Foo", "Bar"
 
-### :password
+Ohm.redis.call "GET", "Foo"
+# => "Bar"
+```
 
-It is the secret that will be sent to the Redis server. Use it if the server
-configuration requires it. Defaults to `nil`.
+All Ohm models inherit the same connection settings from `Ohm.redis`.
+For cases where certain models need to connect to different databases,
+they simple have to override that, i.e.
 
-### :timeout
+```ruby
+require "ohm"
 
-Database timeout in seconds, defaults to `0`.
+Ohm.redis = Redic.new(ENV["REDIS_URL1"])
 
-### :thread_safe
+class User < Ohm::Model
+end
 
-Initializes the client with a monitor. It has a small performance penalty, and
-it's off by default. For thread safety, it is recommended to use a different
-instance per thread. I you have no choice, then pass `:thread_safe => true`
-when connecting.
+User.redis = Redic.new(ENV["REDIS_URL2"])
+```
 
 Models
 ------
@@ -131,10 +123,6 @@ class Event < Ohm::Model
   counter :votes
 
   index :name
-
-  def validate
-    assert_present :name
-  end
 end
 
 class Venue < Ohm::Model
@@ -165,12 +153,12 @@ Event[2]
 # => nil
 
 # Finding all the events
-Event.all
-# => [#<Event @values={:id=>1, :name=>"Ohm Worldwide Conference 2031"}>]
+Event.all.to_a
+# => [<Event: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.
+querying. Keep reading to find out what you can do with models.
 
 Attribute types
 ---------------
@@ -223,31 +211,20 @@ Persistence strategy
 --------------------
 
 The attributes declared with `attribute` are only persisted after
-calling `save`. If the object is in an invalid state, no value is sent
-to Redis (see the section on **Validations** below).
+calling `save`.
 
 Operations on attributes of type `list`, `set` and `counter` are
 possible only after the object is created (when it has an assigned
 `id`). Any operation on these kinds of attributes is performed
-immediately, without running the object validations. This design yields
-better performance than running the validations on each operation or
-buffering the operations and waiting for a call to `save`.
+immediately. This design yields better performance than buffering
+the operations and waiting for a call to `save`.
 
 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:
-
-```ruby
-if event.valid?
-  event.comments.add(Comment.create(:body => "Great event!"))
-end
-```
-
 If you are saving the object, this will suffice:
 
 ```ruby
 if event.save
-  event.comments.add(Comment.create(:body => "Wonderful event!"))
+  event.comments.add(Comment.create(body: "Wonderful event!"))
 end
 ```
 
@@ -267,7 +244,7 @@ You can add instances of `Person` to the set of attendees with the
 `add` method:
 
 ```ruby
-event.attendees.add(Person.create(:name => "Albert"))
+event.attendees.add(Person.create(name: "Albert"))
 
 # And now...
 event.attendees.each do |person|
@@ -317,7 +294,7 @@ and it's within the current model you are sorting.
 
 ```ruby
 Post.all.sort_by(:title)     # SORT Post:all BY Post:*->title
-Post.all.sort(:by => :title) # SORT Post:all BY title
+Post.all.sort(by: :title) # SORT Post:all BY title
 ```
 
 __Tip:__ Unless you absolutely know what you're doing, use `sort`
@@ -332,10 +309,10 @@ the `:by` option, using {Ohm::Model::Collection#sort sort} and
 that `sort_by` does much of the hand-coding for you.
 
 ```ruby
-Post.all.sort_by(:title, :get => :title)
+Post.all.sort_by(:title, get: :title)
 # SORT Post:all BY Post:*->title GET Post:*->title
 
-Post.all.sort(:by => :title, :get => :title)
+Post.all.sort(by: :title, get: :title)
 # SORT Post:all BY title GET title
 ```
 
@@ -360,7 +337,7 @@ 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
-you can use `post.comments.key.smembers`.
+you can use `post.comments.ids`.
 
 ### References explained
 
@@ -391,7 +368,7 @@ The net effect here is we can conveniently set and retrieve `Post` objects,
 and also search comments using the `post_id` index.
 
 ```ruby
-Comment.find(:post_id => 1)
+Comment.find(post_id: 1)
 ```
 
 ### Collections explained
@@ -409,7 +386,7 @@ class Post < Ohm::Model
   attribute :body
 
   def comments
-    Comment.find(:post_id => self.id)
+    Comment.find(post_id: self.id)
   end
 end
 ```
@@ -441,7 +418,7 @@ any index declared, Ohm maintains different sets of objects IDs for quick
 lookups.
 
 In the `Event` example, the index on the name attribute will
-allow for searches like `Event.find(:name => "some value")`.
+allow for searches like `Event.find(name: "some value")`.
 
 Note that the methods {Ohm::Model::Set#find find} and
 {Ohm::Model::Set#except except} need a corresponding index in order to work.
@@ -452,23 +429,23 @@ You can find a collection of records with the `find` method:
 
 ```ruby
 # This returns a collection of users with the username "Albert"
-User.find(:username => "Albert")
+User.find(username: "Albert")
 ```
 
 ### Filtering results
 
 ```ruby
 # Find all users from Argentina
-User.find(:country => "Argentina")
+User.find(country: "Argentina")
 
 # Find all activated users from Argentina
-User.find(:country => "Argentina", :status => "activated")
+User.find(country: "Argentina", status: "activated")
 
 # Find all users from Argentina, except those with a suspended account.
-User.find(:country => "Argentina").except(:status => "suspended")
+User.find(country: "Argentina").except(status: "suspended")
 
 # Find all users both from Argentina and Uruguay
-User.find(:country => "Argentina").union(:country => "Uruguay")
+User.find(country: "Argentina").union(country: "Uruguay")
 ```
 
 Note that calling these methods results in new sets being created
@@ -499,131 +476,6 @@ User.create(email: "foo@bar.com")
 # => raises Ohm::UniqueIndexViolation
 ```
 
-Validations
------------
-
-Before every save, the `validate` method is called by Ohm. In the method
-definition you can use assertions that will determine if the attributes
-are valid. Nesting assertions is a good practice, and you are also
-encouraged to create your own assertions. You can trigger validations at
-any point by calling `valid?` on a model instance.
-
-Assertions
------------
-
-Ohm ships with some basic assertions. Check Ohm::Validations to see
-the method definitions.
-
-### assert
-
-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.
-
-```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`.
-
-```ruby
-assert_present :name
-```
-
-### assert_format
-
-Checks that the given field matches the provided format. The error code
-for this assertion is :format.
-
-```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.
-
-```ruby
-assert_numeric :votes
-```
-
-### assert_url
-
-Provides a pretty general URL regular expression match. An important
-point to make is that this assumes that the URL should start with
-`http://` or `https://`. The error code for this assertion is
-`:not_url`.
-
-### assert_email
-
-In this current day and age, almost all web applications need to
-validate an email address. This pretty much matches 99% of the emails
-out there. The error code for this assertion is `:not_email`.
-
-### assert_member
-
-Checks that a given field is contained within a set of values (i.e.
-like an `ENUM`).
-
-``` ruby
-def validate
-  assert_member :state, %w{pending paid delivered}
-end
-```
-
-The error code for this assertion is `:not_valid`
-
-### assert_length
-
-Checks that a given field's length falls under a specified range.
-
-``` ruby
-def validate
-  assert_length :username, 3..20
-end
-```
-
-The error code for this assertion is `:not_in_range`.
-
-### assert_decimal
-
-Checks that a given field looks like a number in the human sense
-of the word. Valid numbers are: 0.1, .1, 1, 1.1, 3.14159, etc.
-
-The error code for this assertion is `:not_decimal`.
-
-Errors
-------
-
-When an assertion fails, the error report is added to the errors array.
-Each error report contains two elements: the field where the assertion
-was issued and the error code.
-
-### Validation example
-
-Given the following example:
-
-```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:
-
-```ruby
-obj.errors
-# => { foo: [:not_present], bar: [:not_numeric], baz: [:format] }
-```
-
 Ohm Extensions
 ==============
 
@@ -637,10 +489,10 @@ make sure to check them if you need to extend Ohm's functionality.
 Upgrading
 =========
 
-The changes in Ohm 1 break the compatibility with previous versions.
-We will do our best to provide a script to ease the pain of upgrading.
-In the meantime, it's recommended that you use the new version only
-for new projects.
+Ohm 2 breaks the compatibility with previous versions. If you're upgrading an
+existing application, it's nice to have a good test coverage before going in.
+To know about fixes and changes, please refer to the CHANGELOG file.
 
 [redis]: http://redis.io
 [ohm]: http://github.com/soveran/ohm
+[redic]: https://github.com/amakawa/redic

data/Rakefile

@@ -1,5 +1,3 @@
-require "rake/testtask"
-
 REDIS_DIR = File.expand_path(File.join("..", "test"), __FILE__)
 REDIS_CNF = File.join(REDIS_DIR, "test.conf")
 REDIS_PID = File.join(REDIS_DIR, "db", "redis.pid")

data/lib/ohm.rb

@@ -56,11 +56,12 @@ module Ohm
     #     reference :user, User # NameError undefined constant User.
     #   end
     #
-    #   Instead of relying on some clever `const_missing` hack, we can
-    #   simply use a Symbol.
+    #   # Instead of relying on some clever `const_missing` hack, we can
+    #   # simply use a symbol or a string.
     #
     #   class Comment < Ohm::Model
     #     reference :user, :User
+    #     reference :post, "Post"
     #   end
     #
     def self.const(context, name)
@@ -166,7 +167,6 @@ module Ohm
     def size
       redis.call("LLEN", key)
     end
-    alias :count :size
 
     # Returns the first element of the list using LINDEX.
     def first
@@ -342,7 +342,6 @@ module Ohm
     def size
       execute { |key| redis.call("SCARD", key) }
     end
-    alias :count :size
 
     # Syntactic sugar for `sort_by` or `sort` when you only need the
     # first element.
@@ -385,11 +384,29 @@ module Ohm
       model[id] if exists?(id)
     end
 
-  private
+    # Returns +true+ if +id+ is included in the set. Otherwise, returns +false+.
+    #
+    # Example:
+    #
+    #   class Post < Ohm::Model
+    #   end
+    #
+    #   class User < Ohm::Model
+    #     set :posts, :Post
+    #   end
+    #
+    #   user = User.create
+    #   post = Post.create
+    #   user.posts.add(post)
+    #
+    #   user.posts.exists?('nonexistent') # => false
+    #   user.posts.exists?(post.id)       # => true
+    #
     def exists?(id)
       execute { |key| redis.call("SISMEMBER", key, id) == 1 }
     end
 
+  private
     def to_key(att)
       if model.counters.include?(att)
         namespace["*:counters->%s" % att]
@@ -569,7 +586,7 @@ module Ohm
     #
     def except(dict)
       MultiSet.new(
-        namespace, model, Command[:sdiffstore, command, intersected(dict)]
+        namespace, model, Command[:sdiffstore, command, unioned(dict)]
       )
     end
 
@@ -598,6 +615,10 @@ module Ohm
       Command[:sinterstore, *model.filters(dict)]
     end
 
+    def unioned(dict)
+      Command[:sunionstore, *model.filters(dict)]
+    end
+
     def execute
       # namespace[:tmp] is where all the temp keys should be stored in.
       # redis will be where all the commands are executed against.
@@ -677,7 +698,7 @@ module Ohm
       @redis ||= Redic.new(Ohm.redis.url)
     end
 
-    # The namespace for all the keys generated using this model.
+    # Returns the namespace for all the keys generated using this model.
     #
     # Example:
     #
@@ -1018,7 +1039,7 @@ module Ohm
     #   u = User.create
     #   u.incr :points
     #
-    #   Ohm.redis.hget "User:1:counters", "points"
+    #   u.points
     #   # => 1
     #
     # Note: You can't use counters until you save the model. If you
@@ -1049,21 +1070,8 @@ module Ohm
       new(atts).save
     end
 
-    # Manipulate the Redis hash of attributes directly.
-    #
-    # Example:
-    #
-    #   class User < Ohm::Model
-    #     attribute :name
-    #   end
-    #
-    #   u = User.create(:name => "John")
-    #   u.key.hget(:name)
-    #   # => John
-    #
-    # For more details see
-    #   http://github.com/soveran/nest
-    #
+    # Returns the namespace for the keys generated using this model.
+    # Check `Ohm::Model.key` documentation for more details.
     def key
       model.key[id]
     end
@@ -1153,6 +1161,21 @@ module Ohm
       @attributes[att] = val
     end
 
+    # Returns +true+ if the model is not persisted. Otherwise, returns +false+.
+    #
+    # Example:
+    #
+    #   class User < Ohm::Model
+    #     attribute :name
+    #   end
+    #
+    #   u = User.new(:name => "John")
+    #   u.new?
+    #   # => true
+    #
+    #   u.save
+    #   u.new?
+    #   # => false
     def new?
       !defined?(@id)
     end
@@ -1184,6 +1207,20 @@ module Ohm
     end
     alias :eql? :==
 
+    # Returns a hash of the attributes with their names as keys
+    # and the values of the attributes as values. It doesn't
+    # include the ID of the model.
+    #
+    # Example:
+    #
+    #   class User < Ohm::Model
+    #     attribute :name
+    #   end
+    #
+    #   u = User.create(:name => "John")
+    #   u.attributes
+    #   # => { :name => "John" }
+    #
     def attributes
       @attributes
     end

data/lib/ohm/json.rb

@@ -14,11 +14,4 @@ module Ohm
       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/lua/save.lua

@@ -6,10 +6,11 @@
 --
 -- # model
 --
--- Table with three attributes:
---    id (model instance id)
---    key (hash where the attributes will be saved)
+-- Table with one or two attributes:
 --    name (model name)
+--    id (model instance id, optional)
+--
+-- If the id is not provided, it is treated as a new record.
 --
 -- # attrs
 --

data/ohm.gemspec

@@ -1,8 +1,8 @@
 Gem::Specification.new do |s|
   s.name = "ohm"
-  s.version = "2.0.0.alpha5"
+  s.version = "2.0.0.rc1"
   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 includes an extensible list of validations and has very good performance.}
+  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 = ["Michel Martens", "Damian Janowski", "Cyril David"]
   s.email = ["michel@soveran.com", "djanowski@dimaion.com", "me@cyrildavid.com"]
   s.homepage = "http://soveran.github.io/ohm/"

data/test/enumerable.rb

@@ -12,14 +12,14 @@ scope do
     [john, jane]
   end
 
-  test "Set#count doesn't do each" do
+  test "Set#size doesn't do each" do
     set = Contact.all
 
     def set.each
       raise "Failed"
     end
 
-    assert_equal 2, set.count
+    assert_equal 2, set.size
   end
 
   test "Set#each as an Enumerator" do |john, jane|
@@ -67,13 +67,13 @@ scope do
     end
   end
 
-  test "List#count doesn't do each" do |post, c1, c2|
+  test "List#size doesn't do each" do |post, c1, c2|
     list = post.comments
 
     def list.each
       raise "Failed"
     end
 
-    assert_equal 2, list.count
+    assert_equal 2, list.size
   end
 end

data/test/filtering.rb

@@ -1,10 +1,10 @@
-__END__
 require File.expand_path("./helper", File.dirname(__FILE__))
 
 class User < Ohm::Model
   attribute :fname
   attribute :lname
   attribute :status
+
   index :fname
   index :lname
   index :status
@@ -64,9 +64,24 @@ test "#except" do |john, 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")
@@ -77,7 +92,7 @@ test "indices bug related to a nil attribute" do |john, jane|
 
   # At this point, the index for the nil attribute should
   # have been cleared.
-  assert_equal 0, User.db.scard("User:indices:status:")
+  assert_equal 0, User.redis.call("SCARD", "User:indices:status:")
 end
 
 test "#union" do |john, jane|
@@ -150,7 +165,7 @@ scope do
 
     assert_equal 1, res.size
     assert res.map(&:mood).include?("sad")
-    assert res.map(&:book_id).include?(book2.id)
+    assert res.map(&:book_id).include?(book2.id.to_s)
   end
 
   test "@myobie usecase" do |book1, book2|
@@ -160,142 +175,3 @@ scope do
     assert_equal 2, res.size
   end
 end
-
-# test precision of filtering commands
-require "logger"
-require "stringio"
-scope do
-  class Post < Ohm::Model
-    attribute :author
-    index :author
-
-    attribute :mood
-    index :mood
-  end
-
-  setup do
-    io = StringIO.new
-
-    Post.connect(:logger => Logger.new(io))
-
-    Post.create(author: "matz", mood: "happy")
-    Post.create(author: "rich", mood: "mad")
-
-    io
-  end
-
-  def read(io)
-    io.rewind
-    io.read
-  end
-
-  test "SINTERSTORE a b" do |io|
-    Post.find(author: "matz").find(mood: "happy").to_a
-
-    # This is the simple case. We should only do one SINTERSTORE
-    # given two direct keys. Anything more and we're performing badly.
-    expected = "SINTERSTORE Post:tmp:[a-f0-9]{64} " +
-               "Post:indices:author:matz Post:indices:mood:happy"
-
-    assert(read(io) =~ Regexp.new(expected))
-  end
-
-  test "SUNIONSTORE a b" do |io|
-    Post.find(author: "matz").union(mood: "happy").to_a
-
-    # Another simple case where we must only do one operation at maximum.
-    expected = "SUNIONSTORE Post:tmp:[a-f0-9]{64} " +
-               "Post:indices:author:matz Post:indices:mood:happy"
-
-    assert(read(io) =~ Regexp.new(expected))
-  end
-
-  test "SUNIONSTORE c (SINTERSTORE a b)" do |io|
-    Post.find(author: "matz").find(mood: "happy").union(author: "rich").to_a
-
-    # For this case we need an intermediate key. This will
-    # contain the intersection of matz + happy.
-    expected = "SINTERSTORE (Post:tmp:[a-f0-9]{64}) " +
-               "Post:indices:author:matz Post:indices:mood:happy"
-
-    assert(read(io) =~ Regexp.new(expected))
-
-    # The next operation is simply doing a UNION of the previously
-    # generated intermediate key and the additional single key.
-    expected = "SUNIONSTORE (Post:tmp:[a-f0-9]{64}) " +
-               "%s Post:indices:author:rich" % $1
-
-    assert(read(io) =~ Regexp.new(expected))
-  end
-
-  test "SUNIONSTORE (SINTERSTORE c d) (SINTERSTORE a b)" do |io|
-    Post.find(author: "matz").find(mood: "happy").
-         union(author: "rich", mood: "sad").to_a
-
-    # Similar to the previous case, we need to do an intermediate
-    # operation.
-    expected = "SINTERSTORE (Post:tmp:[a-f0-9]{64}) " +
-               "Post:indices:author:matz Post:indices:mood:happy"
-
-    match1 = read(io).match(Regexp.new(expected))
-    assert match1
-
-    # But now, we need to also hold another intermediate key for the
-    # condition of author: rich AND mood: sad.
-    expected = "SINTERSTORE (Post:tmp:[a-f0-9]{64}) " +
-               "Post:indices:author:rich Post:indices:mood:sad"
-
-    match2 = read(io).match(Regexp.new(expected))
-    assert match2
-
-    # Now we expect that it does a UNION of those two previous
-    # intermediate keys.
-    expected = sprintf(
-      "SUNIONSTORE (Post:tmp:[a-f0-9]{64}) %s %s",
-      match1[1], match2[1]
-    )
-
-    assert(read(io) =~ Regexp.new(expected))
-  end
-
-  test do |io|
-    Post.create(author: "kent", mood: "sad")
-
-    Post.find(author: "kent", mood: "sad").
-         union(author: "matz", mood: "happy").
-         except(mood: "sad", author: "rich").to_a
-
-    expected = "SINTERSTORE (Post:tmp:[a-f0-9]{64}) " +
-               "Post:indices:author:kent Post:indices:mood:sad"
-
-    match1 = read(io).match(Regexp.new(expected))
-    assert match1
-
-    expected = "SINTERSTORE (Post:tmp:[a-f0-9]{64}) " +
-               "Post:indices:author:matz Post:indices:mood:happy"
-
-    match2 = read(io).match(Regexp.new(expected))
-    assert match2
-
-    expected = sprintf(
-      "SUNIONSTORE (Post:tmp:[a-f0-9]{64}) %s %s",
-      match1[1], match2[1]
-    )
-
-    match3 = read(io).match(Regexp.new(expected))
-    assert match3
-
-    expected = "SINTERSTORE (Post:tmp:[a-f0-9]{64}) " +
-               "Post:indices:mood:sad Post:indices:author:rich"
-
-    match4 = read(io).match(Regexp.new(expected))
-    assert match4
-
-    expected = sprintf(
-      "SDIFFSTORE (Post:tmp:[a-f0-9]{64}) %s %s",
-      match3[1], match4[1]
-    )
-
-    assert(read(io) =~ Regexp.new(expected))
-  end
-end

data/test/helper.rb

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

data/test/json.rb

@@ -1,70 +1,63 @@
-# encoding: UTF-8
+require_relative 'helper'
 
-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
-  end
 end
 
 class Programmer < Ohm::Model
   attribute :language
 
-  def validate
-    assert_present :language
-  end
+  index :language
 
   def to_hash
-    super.merge(:language => language)
+    super.merge(language: language)
   end
 end
 
-test "export an empty hash via to_hash" do
-  person = Venue.new
-  assert Hash.new == person.to_hash
-end
+test "exports model.to_hash to json" do
+  assert_equal Hash.new, JSON.parse(Venue.new.to_json)
 
-test "export a hash with the its id" do
-  person = Venue.create(:name => "John Doe")
-  assert_equal Hash[:id => 1], person.to_hash
-end
+  venue = Venue.create(name: "foo")
+  json  = JSON.parse(venue.to_json)
+  assert_equal venue.id, json["id"]
+  assert_equal nil, json["name"]
 
-test "return the merged attributes" do
-  programmer = Programmer.create(:language => "Ruby")
-  expected_hash = { :id => 1, :language => 'Ruby' }
+  programmer = Programmer.create(language: "Ruby")
+  json = JSON.parse(programmer.to_json)
 
-  assert expected_hash == programmer.to_hash
+  assert_equal programmer.id, json["id"]
+  assert_equal programmer.language, json["language"]
 end
 
-test "just be the to_hash of a model" do
-  json = JSON.parse(Programmer.create(:language => "Ruby").to_json)
+test "exports a set to json" do
+  Programmer.create(language: "Ruby")
+  Programmer.create(language: "Python")
 
-  assert ["id", "language"] == json.keys.sort
-  assert 1 == json["id"]
-  assert "Ruby" == json["language"]
+  expected = [{ id: "1", language: "Ruby" }, { id: "2", language: "Python"}].to_json
+
+  assert_equal expected, Programmer.all.to_json
 end
 
-test "export an array of records to json" do
-  Programmer.create(:language => "Ruby")
-  Programmer.create(:language => "Python")
+test "exports a multiset to json" do
+  Programmer.create(language: "Ruby")
+  Programmer.create(language: "Python")
 
-  expected = [{ :id => "1", :language => "Ruby" }, { :id => "2", :language => "Python"}].to_json
-  assert_equal expected, Programmer.all.to_json
+  expected = [{ id: "1", language: "Ruby" }, { id: "2", language: "Python"}].to_json
+  result   = Programmer.find(language: "Ruby").union(language: "Python").to_json
+
+  assert_equal expected, result
 end
 
-test "export an array of lists to json" do
-  venue = Venue.create(:name => "Foo")
+test "exports a list to json" do
+  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/model.rb

@@ -7,12 +7,12 @@ require "ostruct"
 class Post < Ohm::Model
   attribute :body
   attribute :published
-  set :related, Post
+  set :related, :Post
 end
 
 class User < Ohm::Model
   attribute :email
-  set :posts, Post
+  set :posts, :Post
 end
 
 class Person < Ohm::Model
@@ -28,7 +28,7 @@ end
 class Event < Ohm::Model
   attribute :name
   counter :votes
-  set :attendees, Person
+  set :attendees, :Person
 
   attribute :slug
 
@@ -51,10 +51,6 @@ end
 class Meetup < Ohm::Model
   attribute :name
   attribute :location
-
-  def validate
-    assert_present :name
-  end
 end
 
 test "booleans" do
@@ -311,8 +307,8 @@ end
 test "delete an existing model" do
   class ModelToBeDeleted < Ohm::Model
     attribute :name
-    set :foos, Post
-    set :bars, Post
+    set :foos, :Post
+    set :bars, :Post
   end
 
   @model = ModelToBeDeleted.create(:name => "Lorem")
@@ -774,7 +770,7 @@ test "be persisted" do
 
   assert "foo" == SomeNamespace::Foo[1].name
   assert "foo" == SomeNamespace::Bar[1].foo.name
-end
+end if RUBY_VERSION >= "2.0.0"
 
 test "typecast attributes" do
   class Option < Ohm::Model

data/test/set.rb

@@ -0,0 +1,20 @@
+require_relative 'helper'
+
+class Post < Ohm::Model
+end
+
+class User < Ohm::Model
+  set :posts, :Post
+end
+
+test '#exists? returns false if the given id is not included in the set' do
+  assert !User.create.posts.exists?('nonexistent')
+end
+
+test '#exists? returns true if the given id is included in the set' do
+  user = User.create
+  post = Post.create
+  user.posts.add(post)
+
+  assert user.posts.exists?(post.id)
+end

data/test/to_hash.rb

@@ -0,0 +1,29 @@
+require_relative 'helper'
+
+class User < Ohm::Model
+end
+
+test "returns an empty hash if model doesn't have set attributes" do
+  assert_equal Hash.new, User.new.to_hash
+end
+
+test "returns a hash with its id if model is persisted" do
+  user = User.create
+
+  assert_equal Hash[id: user.id], user.to_hash
+end
+
+class Person < Ohm::Model
+  attribute :name
+
+  def to_hash
+    super.merge(name: name)
+  end
+end
+
+test "returns additional attributes if the method is overrided" do
+  person   = Person.create(name: "John")
+  expected = { id: person.id, name: person.name }
+
+  assert_equal expected, person.to_hash
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ohm
 version: !ruby/object:Gem::Version
-  version: 2.0.0.alpha5
+  version: 2.0.0.rc1
 platform: ruby
 authors:
 - Michel Martens
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-25 00:00:00.000000000 Z
+date: 2013-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redic
@@ -69,8 +69,7 @@ dependencies:
       - !ruby/object:Gem::Version
         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.
+  key-value database. It has very good performance.
 email:
 - michel@soveran.com
 - djanowski@dimaion.com
@@ -110,7 +109,6 @@ files:
 - test/counters.rb
 - test/db/.gitignore
 - test/enumerable.rb
-- test/extensibility.rb
 - test/filtering.rb
 - test/hash_key.rb
 - test/helper.rb
@@ -119,7 +117,9 @@ files:
 - test/json.rb
 - test/list.rb
 - test/model.rb
+- test/set.rb
 - test/test.conf
+- test/to_hash.rb
 - test/uniques.rb
 homepage: http://soveran.github.io/ohm/
 licenses:

data/test/extensibility.rb

@@ -1,48 +0,0 @@
-# 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