sohm 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 69c6cd0607dd5504902222e7b1f4ba805eed185d
+  data.tar.gz: 58c03e9e6c90b847489688ec014cad18ada039b6
+SHA512:
+  metadata.gz: 50f648882a984944b87026d46e368c529fa9434d8df48db087e58e9f240dec6e9c048bb19b6625b60f8d55782feca4859f0319d53ec233e47d277012020db8f8
+  data.tar.gz: 49f26999c6d7519f7d2b80ef891a179a61f1f24360e3a2cd274d515d6697624a2990daacef21cfd135a454e5bdf96c61d00a0eb5309d7a0c94029a4ed5b4f4df

data/.gems

@@ -0,0 +1,4 @@
+msgpack -v 0.5.11
+nido -v 0.0.1
+redic -v 1.4.1
+cutest -v 1.2.2

data/.gitignore

@@ -0,0 +1,3 @@
+/.yardoc
+/doc
+/.gs

data/CHANGELOG.md

@@ -0,0 +1,312 @@
+## 2.0.0
+
+- Lists now respond to range.
+
+  Example:
+
+  ```ruby
+  class Comment < Ohm::Model
+  end
+
+  class Post < Ohm::Model
+    list :comments, :Comment
+  end
+
+  c1 = Comment.create
+  c2 = Comment.create
+  c3 = Comment.create
+
+  post = Post.create
+  post.comments.push(c1)
+  post.comments.push(c2)
+  post.comments.push(c3)
+
+  post.comments.range(0, 1) == [c1, c2]
+  # => true
+  ```
+
+- When a record is created, `#id` returns a string instead of an integer.
+  This ensures IDs are strings everywhere:
+
+  Example:
+
+  ```ruby
+
+  # Before
+  Meetup.create(name: "Ruby").id # => 1
+  Meetup.with(:name, "Ruby").id  # => "1"
+
+  # Now
+  Meetup.create(name: "Ruby").id # => "1"
+  Meetup.with(:name, "Ruby").id  # => "1"
+  ```
+
+- If an attribute is set to an empty string, Ohm won't delete it.
+
+  Example:
+
+  ```ruby
+  # Before
+  event = Meetup.create(location: "")
+  Meetup[event.id].location # => nil
+
+  # Now
+  event = Meetup.create(location: "")
+  Meetup[event.id].location # => ""
+  ```
+
+- Include `Ohm::List#ids` in the public API. It returns an array with all
+  the ID's in the list.
+
+  Example:
+
+  ```ruby
+  class Comment < Ohm::Model
+  end
+
+  class Post < Ohm::Model
+    list :comments, :Comment
+  end
+
+  post = Post.create
+  post.comments.push(Comment.create)
+  post.comments.push(Comment.create)
+  post.comments.push(Comment.create)
+
+  post.comments.ids
+  # => ["1", "2", "3"]
+  ```
+
+- 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.
+
+  Example:
+
+  ```ruby
+  class Post < Ohm::Model
+  end
+
+  class User < Ohm::Model
+    set :posts, :Post
+  end
+
+  user = User.create
+  user.posts.add(post = Post.create)
+
+  user.posts.exists?(post.id)       # => true
+  user.posts.exists?("nonexistent") # => false
+  ```
+
+- Change `Ohm::MultiSet#except` to union keys instead of intersect them
+  when passing an array.
+
+  Example:
+
+  ```ruby
+  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.
+
+- Add `Ohm::Model.track` method to allow track of custom keys. This key
+  is removed when the model is deleted.
+
+  Example:
+
+  ```ruby
+  class Foo < Ohm::Model
+    track :notes
+  end
+
+  foo = Foo.create
+
+  Foo.redis.call("SET", foo.key[:notes], "something")
+  Foo.redis.call("GET", "Foo:1:notes")
+  # => "something"
+
+  foo.delete
+  Foo.redis.call("GET", "Foo:1:notes")
+  # => nil
+  ```
+
+- `Ohm::Model#reference` accepts strings as model references.
+
+  Example:
+
+  ```ruby
+  class Bar < Ohm::Model
+    reference :foo, "SomeNamespace::Foo"
+  end
+
+  Bar.create.foo.class # => SomeNamespace::Foo
+  ```
+
+- `Ohm::Model#save` sanitizes attributes before sending them to Lua.
+  This complies with the original spec in Ohm v1 where a `to_s`
+  is done on each value.
+
+  Example:
+
+  ```ruby
+  class Post < Ohm::Model
+    attribute :published
+  end
+
+  post = Post.create(published: true)
+  post = Post[post.id]
+
+  # Before
+  post.published # => "1"
+
+  # Now
+  post.published # => "true"
+  ```
+
+- `Ohm::Model#save` don't save values for attributes set to false.
+
+  Example:
+
+  ```ruby
+  class Post < Ohm::Model
+    attribute :published
+  end
+
+  post = Post.create(published: false)
+  post = Post[post.id]
+
+  # Before
+  post.published # => "0"
+
+  # Now
+  post.published # => nil
+  ```
+
+- `nest` dependency has been removed. Now, Ohm uses [nido][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][scrivener] project for more information.
+
+- `redis` dependency has been removed. Ohm 2 uses [redic][redic],
+  a lightweight Redis client. Redic uses the `hiredis` gem for the
+  connection and for parsing the replies. Now, it defaults to a
+  Redic connection to "redis://127.0.0.1:6379". To change it, you
+  will need to provide an instance of `Redic` through the `Ohm.redis=`
+  helper.
+
+  Example:
+
+  ```ruby
+  Ohm.redis = Redic.new("redis://:<passwd>@<host>:<port>/<db>")
+  ```
+
+  Check the Redic README for more details.
+
+- `Ohm::Model#transaction` and `Ohm::Transaction` have been removed.
+
+- Move `save` and `delete` operations to Lua scripts.
+
+- Support for Ruby 1.8 has been removed.
+
+[nido]: https://github.com/soveran/nido
+[scrivener]: https://github.com/soveran/scrivener
+[redic]: https://github.com/amakawa/redic
+
+## 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#&lt;&lt;` is now an alias for `#add`.
+
+## 1.3.1
+
+- Improve memory consumption when indexing persisted attributes.
+  No migration is needed and old indices will be cleaned up as you save
+  instances.
+
+## 1.3.0
+
+- Add Model.attributes.
+
+## 1.2.0
+
+- Enumerable fix.
+
+- Merge Ohm::PipelinedFetch into Ohm::Collection.
+
+- Fix Set, MultiSet, and List enumerable behavior.
+
+- Change dependencies to use latest cutest.
+
+## 1.1.0
+
+- Compatible with redis-rb 3.
+
+## 1.0.0
+
+- Fetching a batch of objects is now done through one pipeline, effectively
+  reducing the IO to just 2 operations (one for SMEMBERS / LRANGE, one for
+  the actual HGET of all the individual HASHes.)
+
+- write_remote / read_remote have been replaced with set / get respectively.
+
+- Ohm::Model.unique has been added.
+
+- Ohm::Model::Set has been renamed to Ohm::Set
+
+- Ohm::Model::List has been renamed to Ohm::List
+
+- Ohm::Model::Collection is gone.
+
+- Ohm::Validations is gone. Ohm now uses Scrivener::Validations.
+
+- Ohm::Key is gone. Ohm now uses Nest directly.
+
+- No more concept of volatile keys.
+
+- Ohm::Model::Wrapper is gone.
+
+- Use Symbols for constants instead of relying on Ohm::Model.const_missing.
+
+- `#sort` / `#sort_by` now uses `limit` as it's used in redis-rb, e.g. you
+  have to pass in an array like so: sort(limit: [0, 1]).
+
+- Set / List have been trimmed to contain only the minimum number
+  of necessary methods.
+
+- You can no longer mutate a collection / set as before, e.g. doing
+  User.find(...).add(User[1]) will throw an error.
+
+- The #union operation has been added. You can now chain it with your filters.
+
+- Temporary keys when doing finds are now automatically cleaned up.
+
+- Counters are now stored in their own key instead, i.e. in
+  User:<id>:counters.
+
+- JSON support has to be explicitly required by doing `require
+  "ohm/json"`.
+
+- All save / delete / update operations are now done using
+  transactions (see http://redis.io/topics/transactions).
+
+- All indices are now stored without converting the values to base64.

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2009 Michel Martens and Damian Janowski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,10 @@
+Sohm
+====
+
+This forks [ohm](https://github.com/soveran/ohm) so as to work with [twemproxy](https://github.com/twitter/twemproxy) or similar systems.
+
+`Sohm` means `Slim ohm`.
+
+If you are able to use full-featured Redis(for example, if you are using Redis cluster via Sentinel), you should definitely think about using the original ohm.
+
+However, if you are using twemproxy-like system, and you are okay with limited features, feel free to take a look at this project :)

data/benchmarks/common.rb

@@ -0,0 +1,33 @@
+require "bench"
+require_relative "../lib/ohm"
+
+Ohm.redis = Redic.new("redis://127.0.0.1:6379/15")
+Ohm.flush
+
+class Event < Ohm::Model
+  attribute :name
+  attribute :location
+
+  index :name
+  index :location
+
+  def validate
+    assert_present :name
+    assert_present :location
+  end
+end
+
+class Sequence
+  def initialize
+    @value = 0
+  end
+
+  def succ!
+    Thread.exclusive { @value += 1 }
+  end
+
+  def self.[](name)
+    @@sequences ||= Hash.new { |hash, key| hash[key] = Sequence.new }
+    @@sequences[name]
+  end
+end

data/benchmarks/create.rb

@@ -0,0 +1,21 @@
+require_relative "common"
+
+benchmark "Create Events" do
+  i = Sequence[:events].succ!
+
+  Event.create(:name => "Redis Meetup #{i}", :location => "London #{i}")
+end
+
+benchmark "Find by indexed attribute" do
+  Event.find(:name => "Redis Meetup 1").first
+end
+
+benchmark "Mass update" do
+  Event[1].update(:name => "Redis Meetup II")
+end
+
+benchmark "Load events" do
+  Event[1].name
+end
+
+run 5000

data/benchmarks/delete.rb

@@ -0,0 +1,13 @@
+require_relative "common"
+
+1000.times do |i|
+  Event.create(:name => "Redis Meetup #{i}", :location => "At my place")
+end
+
+benchmark "Delete event" do
+  Event.all.each do |event|
+    event.delete
+  end
+end
+
+run 1

data/examples/activity-feed.rb

@@ -0,0 +1,162 @@
+### Building an activity feed
+
+#### Common solutions using a relational design
+
+# When faced with this application requirement, the most common approach by
+# far have been to create an *activities* table, and rows in this table would
+# reference a *user*. Activities would typically be generated for each
+# follower (or friend) when a certain user performs an action, like posting a
+# new status update.
+
+#### Problems
+
+# The biggest issue with this design, is that the *activities* table will
+# quickly get very huge, at which point you would need to shard it on
+# *user_id*. Also, inserting thousands of entries per second would quickly
+# bring your database to its knees.
+
+#### Ohm Solution
+
+# As always we need to require `Ohm`.
+require "ohm"
+
+# We create a `User` class, with a `set` for all the other users he
+# would be `following`, and another `set` for all his `followers`.
+class User < Ohm::Model
+  set :followers, User
+  set :following, User
+
+  # Because a `User` literally has a `list` of activities, using a Redis
+  # `list` to model the activities would be a good choice. We default to
+  # getting the first 100 activities, and use
+  # [lrange](http://code.google.com/p/redis/wiki/LrangeCommand) directly.
+  def activities(start = 0, limit = 100)
+    key[:activities].lrange(start, start + limit)
+  end
+
+  # Broadcasting a message to all the `followers` of a user would simply
+  # be prepending the message for each if his `followers`. We also use
+  # the Redis command
+  # [lpush](http://code.google.com/p/redis/wiki/RpushCommand) directly.
+  def broadcast(str)
+    followers.each do |user|
+      user.key[:activities].lpush(str)
+    end
+  end
+
+  # Given that *Jane* wants to follow *John*, we simply do the following
+  # steps:
+  #
+  # 1. *John* is added to *Jane*'s `following` list.
+  # 2. *Jane* is added to *John*'s `followers` list.
+  def follow(other)
+    following << other
+    other.followers << self
+  end
+end
+
+
+#### Testing
+
+# We'll use cutest for our testing framework.
+require "cutest"
+
+# The database is flushed before each test.
+prepare { Ohm.flush }
+
+# We define two users, `john` and `jane`, and yield them so all
+# other tests are given access to these 2 users.
+setup do
+  john = User.create
+  jane = User.create
+
+  [john, jane]
+end
+
+# Let's verify our model for `follow`. When `jane` follows `john`,
+# the following conditions should hold:
+#
+# 1. The followers list of `john` is comprised *only* of `jane`.
+# 2. The list of users `jane` is following is comprised *only* of `john`.
+test "jane following john" do |john, jane|
+  jane.follow(john)
+
+  assert [john] == jane.following.to_a
+  assert [jane] == john.followers.to_a
+end
+
+# Broadcasting a message should simply notify all the followers of the
+# `broadcaster`.
+test "john broadcasting a message" do |john, jane|
+  jane.follow(john)
+  john.broadcast("Learning about Redis and Ohm")
+
+  assert jane.activities.include?("Learning about Redis and Ohm")
+end
+
+#### Total Denormalization: Adding HTML
+
+# This may be a real edge case design decision, but for some scenarios this
+# may work. The beauty of this solution is that you only have to generate the
+# output once, and successive refreshes of the end user will help you save
+# some CPU cycles.
+#
+# This example of course assumes that the code that generates this does all
+# the conditional checks (possibly changing the point of view like *Me:*
+# instead of *John says:*).
+test "broadcasting the html directly" do |john, jane|
+  jane.follow(john)
+
+  snippet = '<a href="/1">John</a> says: How\'s it going ' +
+            '<a href="/user/2">jane</a>?'
+
+  john.broadcast(snippet)
+
+  assert jane.activities.include?(snippet)
+end
+
+#### Saving Space
+
+# In most cases, users don't really care about keeping their entire activity
+# history. This application requirement would be fairly trivial to implement.
+
+# Let's reopen our `User` class and define a new broadcast method.
+class User
+  # We define a constant where we set the maximum number of activity entries.
+  MAX = 10
+
+  # Using `MAX` as the reference, we check if the number of activities exceeds
+  # `MAX`, and use
+  # [ltrim](http://code.google.com/p/redis/wiki/LtrimCommand) to truncate
+  # the activities.
+  def broadcast(str)
+    followers.each do |user|
+      user.key[:activities].lpush(str)
+
+      if user.key[:activities].llen > MAX
+        user.key[:activities].ltrim(0, MAX - 1)
+      end
+    end
+  end
+end
+
+# Now let's verify that this new behavior is enforced.
+test "pushing 11 activities maintains the list to 10" do |john, jane|
+  jane.follow(john)
+
+  11.times { john.broadcast("Flooding your feed!") }
+
+  assert 10 == jane.activities.size
+end
+
+
+#### Conclusion
+
+# As you can see, choosing a more straightforward approach (in this case,
+# actually having a list per user, instead of maintaining a separate
+# `activities` table) will greatly simplify the design of your system.
+#
+# As a final note, keep in mind that the Ohm solution would still need
+# sharding for large datasets, but that would be again trivial to implement
+# using [redis-rb](http://github.com/ezmobius/redis-rb)'s distributed support
+# and sharding it against the *user_id*.