redis-objects 0.9.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4ddda2781d9f2c900706e383d1079321a1499153
-  data.tar.gz: 0120673e2299b6739dd24d4a1e8aea2ee42b1d18
+  metadata.gz: c4689abbe0340e8c683371bac1b94b29893a7c5b
+  data.tar.gz: 41678b7dd50984a9b7c0c974e2a9eadf6d8a712d
 SHA512:
-  metadata.gz: 5e677129dc40412d9a6c11585f84c4703703006d6b02b5a71e047a6bcd8fabf44a22c90073f1f730eec0025776689c75e586ceb8203a7791167f6528b177d96e
-  data.tar.gz: d7c948a177c2dea105ce215e4792f490324331e1f9a2acefaa95ee053be71acb3c4065a3517b801125e7f4952161565bd9bf579aac31639e4857641b88cea5e0
+  metadata.gz: 917dad1c9f8edd6eb355dbdec952d7ade90b45b6fa7b1dd81266dff885ff09bf7d5fbf2e01a3d0ffec05e6c7dccff46d6f14b52fae790e1030a7c30d0c9da84f
+  data.tar.gz: e64a57836c26bcc882517f2de31fb1c9b3a95394c9794f10646fd77f244e3db454bec529e92376fb7ff802dec048ec355b3f7c254e3140022a52b32bbc7fda7b

data/CHANGELOG.rdoc

@@ -1,6 +1,18 @@
 = Changelog for Redis::Objects
 
-== 0.9.1 (25 Mar 2024)
+== 1.0.0 (25 Jul 2014)
+
+* Fix expiration filter to handle atomic blocks, remove method aliasing [nateware]
+
+* Fix incrbyfloat to actually return a float [james-lawrence]
+
+* Allow false as default: value (bugfix) [james-lawrence]
+
+* Allow unionstore and interstore between sorted sets and sets [jrdi]
+
+* Add syntax highlighting to README.md [bartolsthoorn]
+
+== 0.9.1 (25 Mar 2014)
 
 * Fix bad marshal calls in SortedSet [Fleurer, nateware]
 

data/README.md

@@ -32,13 +32,17 @@ Installation and Setup
 ----------------------
 Add it to your Gemfile as:
 
-    gem 'redis-objects'
+~~~ruby
+gem 'redis-objects'
+~~~
 
 Redis::Objects needs a handle created by `Redis.new`. The recommended approach
 is to set `Redis.current` to point to your server, which Redis::Objects will
 pick up automatically.
 
-    Redis.current = Redis.new(:host => '127.0.0.1', :port => 6379)
+~~~ruby
+Redis.current = Redis.new(:host => '127.0.0.1', :port => 6379)
+~~~
 
 (If you're on Rails, `config/initializers/redis.rb` is a good place for this.)
 Remember you can use Redis::Objects in any Ruby code.  There are **no** dependencies
@@ -46,19 +50,23 @@ on Rails.  Standalone, Sinatra, Resque - no problem.
 
 Alternatively, you can set the `redis` handle directly:
 
-    Redis::Objects.redis = Redis.new(...)
+~~~ruby
+Redis::Objects.redis = Redis.new(...)
+~~~
 
 Finally, you can even set different handles for different classes:
 
-    class User
-      include Redis::Objects
-    end
-    class Post
-      include Redis::Objects
-    end
+~~~ruby
+class User
+  include Redis::Objects
+end
+class Post
+  include Redis::Objects
+end
 
-    User.redis = Redis.new(:host => '1.2.3.4')
-    Post.redis = Redis.new(:host => '5.6.7.8')
+User.redis = Redis.new(:host => '1.2.3.4')
+Post.redis = Redis.new(:host => '5.6.7.8')
+~~~
 
 As of `0.7.0`, `redis-objects` now autoloads the appropriate `Redis::Whatever`
 classes on demand.  Previous strategies of individually requiring `redis/list`
@@ -75,95 +83,111 @@ Redis::Objects automatically creates keys that are unique to each object, in the
 
 For illustration purposes, consider this stub class:
 
-    class User
-      include Redis::Objects
-      counter :my_posts
-      def id
-        1
-      end
-    end
-
-    user = User.new
-    user.id  # 1
-    user.my_posts.increment
-    user.my_posts.increment
-    user.my_posts.increment
-    puts user.my_posts  # 3
-    user.my_posts.reset
-    puts user.my_posts.value # 0
-    user.my_posts.reset 5
-    puts user.my_posts.value # 5
+~~~ruby
+class User
+  include Redis::Objects
+  counter :my_posts
+  def id
+    1
+  end
+end
+
+user = User.new
+user.id  # 1
+user.my_posts.increment
+user.my_posts.increment
+user.my_posts.increment
+puts user.my_posts  # 3
+user.my_posts.reset
+puts user.my_posts.value # 0
+user.my_posts.reset 5
+puts user.my_posts.value # 5
+~~~
 
 Here's an example that integrates several data types with an ActiveRecord model:
 
-    class Team < ActiveRecord::Base
-      include Redis::Objects
-
-      lock :trade_players, :expiration => 15  # sec
-      value :at_bat
-      counter :hits
-      counter :runs
-      counter :outs
-      counter :inning, :start => 1
-      list :on_base
-      list :coaches, :marshal => true
-      set  :outfielders
-      hash_key :pitchers_faced  # "hash" is taken by Ruby
-      sorted_set :rank, :global => true
-    end
+~~~ruby
+class Team < ActiveRecord::Base
+  include Redis::Objects
+
+  lock :trade_players, :expiration => 15  # sec
+  value :at_bat
+  counter :hits
+  counter :runs
+  counter :outs
+  counter :inning, :start => 1
+  list :on_base
+  list :coaches, :marshal => true
+  set  :outfielders
+  hash_key :pitchers_faced  # "hash" is taken by Ruby
+  sorted_set :rank, :global => true
+end
+~~~
 
 Familiar Ruby array operations Just Work (TM):
 
-    @team = Team.find_by_name('New York Yankees')
-    @team.on_base << 'player1'
-    @team.on_base << 'player2'
-    @team.on_base << 'player3'
-    @team.on_base    # ['player1', 'player2', 'player3']
-    @team.on_base.pop
-    @team.on_base.shift
-    @team.on_base.length  # 1
-    @team.on_base.delete('player2')
+~~~ruby
+@team = Team.find_by_name('New York Yankees')
+@team.on_base << 'player1'
+@team.on_base << 'player2'
+@team.on_base << 'player3'
+@team.on_base    # ['player1', 'player2', 'player3']
+@team.on_base.pop
+@team.on_base.shift
+@team.on_base.length  # 1
+@team.on_base.delete('player2')
+~~~
 
 Sets work too:
 
-    @team.outfielders << 'outfielder1'
-    @team.outfielders << 'outfielder2'
-    @team.outfielders << 'outfielder1'   # dup ignored
-    @team.outfielders  # ['outfielder1', 'outfielder2']
-    @team.outfielders.each do |player|
-      puts player
-    end
-    player = @team.outfielders.detect{|of| of == 'outfielder2'}
+~~~ruby
+@team.outfielders << 'outfielder1'
+@team.outfielders << 'outfielder2'
+@team.outfielders << 'outfielder1'   # dup ignored
+@team.outfielders  # ['outfielder1', 'outfielder2']
+@team.outfielders.each do |player|
+  puts player
+end
+player = @team.outfielders.detect{|of| of == 'outfielder2'}
+~~~
 
 And you can do unions and intersections between objects (kinda cool):
 
-    @team1.outfielders | @team2.outfielders   # outfielders on both teams
-    @team1.outfielders & @team2.outfielders   # in baseball, should be empty :-)
+~~~ruby
+@team1.outfielders | @team2.outfielders   # outfielders on both teams
+@team1.outfielders & @team2.outfielders   # in baseball, should be empty :-)
+~~~
 
 Counters can be atomically incremented/decremented (but not assigned):
 
-    @team.hits.increment  # or incr
-    @team.hits.decrement  # or decr
-    @team.hits.incr(3)    # add 3
-    @team.runs = 4        # exception
+~~~ruby
+@team.hits.increment  # or incr
+@team.hits.decrement  # or decr
+@team.hits.incr(3)    # add 3
+@team.runs = 4        # exception
+~~~
 
 Defining a different method as the `id` field is easy
 
-    class User
-      include Redis::Objects
-      redis_id_field :uid
-      counter :my_posts
-    end
+~~~ruby
+class User
+  include Redis::Objects
+  redis_id_field :uid
+  counter :my_posts
+end
 
-    user.uid                # 195137a1bdea4473
-    user.my_posts.increment # 1
+user.uid                # 195137a1bdea4473
+user.my_posts.increment # 1
+~~~
 
 Finally, for free, you get a `redis` method that points directly to a Redis connection:
 
-    Team.redis.get('somekey')
-    @team = Team.new
-    @team.redis.get('somekey')
-    @team.redis.smembers('someset')
+~~~ruby
+Team.redis.get('somekey')
+@team = Team.new
+@team.redis.get('somekey')
+@team.redis.smembers('someset')
+~~~
 
 You can use the `redis` handle to directly call any [Redis API command](http://redis.io/commands).
 
@@ -179,17 +203,21 @@ Counters
 --------
 The `counter_name` is the key stored in Redis.
 
-    @counter = Redis::Counter.new('counter_name')
-    @counter.increment  # or incr
-    @counter.decrement  # or decr
-    @counter.increment(3)
-    puts @counter.value
+~~~ruby
+@counter = Redis::Counter.new('counter_name')
+@counter.increment  # or incr
+@counter.decrement  # or decr
+@counter.increment(3)
+puts @counter.value
+~~~
 
 This gem provides a clean way to do atomic blocks as well:
 
-    @counter.increment do |val|
-      raise "Full" if val > MAX_VAL  # rewind counter
-    end
+~~~ruby
+@counter.increment do |val|
+  raise "Full" if val > MAX_VAL  # rewind counter
+end
+~~~
 
 See the section on [Atomic Counters and Locks](#atomicity) for cool uses of atomic counter blocks.
 
@@ -197,10 +225,12 @@ Locks
 -----
 A convenience class that wraps the pattern of [using setnx to perform locking](http://redis.io/commands/setnx).
 
-    @lock = Redis::Lock.new('serialize_stuff', :expiration => 15, :timeout => 0.1)
-    @lock.lock do
-      # do work
-    end
+~~~ruby
+@lock = Redis::Lock.new('serialize_stuff', :expiration => 15, :timeout => 0.1)
+@lock.lock do
+  # do work
+end
+~~~
 
 This can be especially useful if you're running batch jobs spread across multiple hosts.
 
@@ -208,49 +238,59 @@ Values
 ------
 Simple values are easy as well:
 
-    @value = Redis::Value.new('value_name')
-    @value.value = 'a'
-    @value.delete
+~~~ruby
+@value = Redis::Value.new('value_name')
+@value.value = 'a'
+@value.delete
+~~~
 
 Complex data is no problem with :marshal => true:
 
-    @account = Account.create!(params[:account])
-    @newest  = Redis::Value.new('newest_account', :marshal => true)
-    @newest.value = @account.attributes
-    puts @newest.value['username']
+~~~ruby
+@account = Account.create!(params[:account])
+@newest  = Redis::Value.new('newest_account', :marshal => true)
+@newest.value = @account.attributes
+puts @newest.value['username']
+~~~
 
 Lists
 -----
 Lists work just like Ruby arrays:
 
-    @list = Redis::List.new('list_name')
-    @list << 'a'
-    @list << 'b'
-    @list.include? 'c'   # false
-    @list.values  # ['a','b']
-    @list << 'c'
-    @list.delete('c')
-    @list[0]
-    @list[0,1]
-    @list[0..1]
-    @list.shift
-    @list.pop
-    @list.clear
-    # etc
+~~~ruby
+@list = Redis::List.new('list_name')
+@list << 'a'
+@list << 'b'
+@list.include? 'c'   # false
+@list.values  # ['a','b']
+@list << 'c'
+@list.delete('c')
+@list[0]
+@list[0,1]
+@list[0..1]
+@list.shift
+@list.pop
+@list.clear
+# etc
+~~~
 
 You can bound the size of the list to only hold N elements like so:
 
-    # Only holds 10 elements, throws out old ones when you reach :maxlength.
-    @list = Redis::List.new('list_name', :maxlength => 10)
+~~~ruby
+# Only holds 10 elements, throws out old ones when you reach :maxlength.
+@list = Redis::List.new('list_name', :maxlength => 10)
+~~~
 
 Complex data types are now handled with :marshal => true:
 
-    @list = Redis::List.new('list_name', :marshal => true)
-    @list << {:name => "Nate", :city => "San Diego"}
-    @list << {:name => "Peter", :city => "Oceanside"}
-    @list.each do |el|
-      puts "#{el[:name]} lives in #{el[:city]}"
-    end
+~~~ruby
+@list = Redis::List.new('list_name', :marshal => true)
+@list << {:name => "Nate", :city => "San Diego"}
+@list << {:name => "Peter", :city => "Oceanside"}
+@list.each do |el|
+  puts "#{el[:name]} lives in #{el[:city]}"
+end
+~~~
 
 Hashes
 ------
@@ -258,21 +298,25 @@ Hashes work like a Ruby [Hash](http://ruby-doc.org/core/classes/Hash.html), with
 a few Redis-specific additions.  (The class name is "HashKey" not just "Hash", due to
 conflicts with the Ruby core Hash class in other gems.)
 
-    @hash = Redis::HashKey.new('hash_name')
-    @hash['a'] = 1
-    @hash['b'] = 2
-    @hash.each do |k,v|
-      puts "#{k} = #{v}"
-    end
-    @hash['c'] = 3
-    puts @hash.all  # {"a"=>"1","b"=>"2","c"=>"3"}
-    @hash.clear
+~~~ruby
+@hash = Redis::HashKey.new('hash_name')
+@hash['a'] = 1
+@hash['b'] = 2
+@hash.each do |k,v|
+  puts "#{k} = #{v}"
+end
+@hash['c'] = 3
+puts @hash.all  # {"a"=>"1","b"=>"2","c"=>"3"}
+@hash.clear
+~~~
 
 Redis also adds incrementing and bulk operations:
 
-    @hash.incr('c', 6)  # 9
-    @hash.bulk_set('d' => 5, 'e' => 6)
-    @hash.bulk_get('d','e')  # "5", "6"
+~~~ruby
+@hash.incr('c', 6)  # 9
+@hash.bulk_set('d' => 5, 'e' => 6)
+@hash.bulk_get('d','e')  # "5", "6"
+~~~
 
 Remember that numbers become strings in Redis.  Unlike with other Redis data types,
 `redis-objects` can't guess at your data type in this situation, since you may
@@ -283,91 +327,101 @@ Sets
 Sets work like the Ruby [Set](http://ruby-doc.org/core/classes/Set.html) class.
 They are unordered, but guarantee uniqueness of members.
 
-    @set = Redis::Set.new('set_name')
-    @set << 'a'
-    @set << 'b'
-    @set << 'a'  # dup ignored
-    @set.member? 'c'      # false
-    @set.members          # ['a','b']
-    @set.members.reverse  # ['b','a']
-    @set.each do |member|
-      puts member
-    end
-    @set.clear
-    # etc
+~~~ruby
+@set = Redis::Set.new('set_name')
+@set << 'a'
+@set << 'b'
+@set << 'a'  # dup ignored
+@set.member? 'c'      # false
+@set.members          # ['a','b']
+@set.members.reverse  # ['b','a']
+@set.each do |member|
+  puts member
+end
+@set.clear
+# etc
+~~~
 
 You can perform Redis intersections/unions/diffs easily:
 
-    @set1 = Redis::Set.new('set1')
-    @set2 = Redis::Set.new('set2')
-    @set3 = Redis::Set.new('set3')
-    members = @set1 & @set2   # intersection
-    members = @set1 | @set2   # union
-    members = @set1 + @set2   # union
-    members = @set1 ^ @set2   # difference
-    members = @set1 - @set2   # difference
-    members = @set1.intersection(@set2, @set3)  # multiple
-    members = @set1.union(@set2, @set3)         # multiple
-    members = @set1.difference(@set2, @set3)    # multiple
+~~~ruby
+@set1 = Redis::Set.new('set1')
+@set2 = Redis::Set.new('set2')
+@set3 = Redis::Set.new('set3')
+members = @set1 & @set2   # intersection
+members = @set1 | @set2   # union
+members = @set1 + @set2   # union
+members = @set1 ^ @set2   # difference
+members = @set1 - @set2   # difference
+members = @set1.intersection(@set2, @set3)  # multiple
+members = @set1.union(@set2, @set3)         # multiple
+members = @set1.difference(@set2, @set3)    # multiple
+~~~
 
 Or store them in Redis:
 
-    @set1.interstore('intername', @set2, @set3)
-    members = @set1.redis.get('intername')
-    @set1.unionstore('unionname', @set2, @set3)
-    members = @set1.redis.get('unionname')
-    @set1.diffstore('diffname', @set2, @set3)
-    members = @set1.redis.get('diffname')
+~~~ruby
+@set1.interstore('intername', @set2, @set3)
+members = @set1.redis.get('intername')
+@set1.unionstore('unionname', @set2, @set3)
+members = @set1.redis.get('unionname')
+@set1.diffstore('diffname', @set2, @set3)
+members = @set1.redis.get('diffname')
+~~~
 
 And use complex data types too, with :marshal => true:
 
-    @set1 = Redis::Set.new('set1', :marshal => true)
-    @set2 = Redis::Set.new('set2', :marshal => true)
-    @set1 << {:name => "Nate",  :city => "San Diego"}
-    @set1 << {:name => "Peter", :city => "Oceanside"}
-    @set2 << {:name => "Nate",  :city => "San Diego"}
-    @set2 << {:name => "Jeff",  :city => "Del Mar"}
+~~~ruby
+@set1 = Redis::Set.new('set1', :marshal => true)
+@set2 = Redis::Set.new('set2', :marshal => true)
+@set1 << {:name => "Nate",  :city => "San Diego"}
+@set1 << {:name => "Peter", :city => "Oceanside"}
+@set2 << {:name => "Nate",  :city => "San Diego"}
+@set2 << {:name => "Jeff",  :city => "Del Mar"}
 
-    @set1 & @set2  # Nate
-    @set1 - @set2  # Peter
-    @set1 | @set2  # all 3 people
+@set1 & @set2  # Nate
+@set1 - @set2  # Peter
+@set1 | @set2  # all 3 people
+~~~
 
 Sorted Sets
 -----------
 Due to their unique properties, Sorted Sets work like a hybrid between
 a Hash and an Array.  You assign like a Hash, but retrieve like an Array:
 
-    @sorted_set = Redis::SortedSet.new('number_of_posts')
-    @sorted_set['Nate']  = 15
-    @sorted_set['Peter'] = 75
-    @sorted_set['Jeff']  = 24
+~~~ruby
+@sorted_set = Redis::SortedSet.new('number_of_posts')
+@sorted_set['Nate']  = 15
+@sorted_set['Peter'] = 75
+@sorted_set['Jeff']  = 24
 
-    # Array access to get sorted order
-    @sorted_set[0..2]           # => ["Nate", "Jeff", "Peter"]
-    @sorted_set[0,2]            # => ["Nate", "Jeff"]
+# Array access to get sorted order
+@sorted_set[0..2]           # => ["Nate", "Jeff", "Peter"]
+@sorted_set[0,2]            # => ["Nate", "Jeff"]
 
-    @sorted_set['Peter']        # => 75
-    @sorted_set['Jeff']         # => 24
-    @sorted_set.score('Jeff')   # same thing (24)
+@sorted_set['Peter']        # => 75
+@sorted_set['Jeff']         # => 24
+@sorted_set.score('Jeff')   # same thing (24)
 
-    @sorted_set.rank('Peter')   # => 2
-    @sorted_set.rank('Jeff')    # => 1
+@sorted_set.rank('Peter')   # => 2
+@sorted_set.rank('Jeff')    # => 1
 
-    @sorted_set.first           # => "Nate"
-    @sorted_set.last            # => "Peter"
-    @sorted_set.revrange(0,2)   # => ["Peter", "Jeff", "Nate"]
+@sorted_set.first           # => "Nate"
+@sorted_set.last            # => "Peter"
+@sorted_set.revrange(0,2)   # => ["Peter", "Jeff", "Nate"]
 
-    @sorted_set['Newbie'] = 1
-    @sorted_set.members         # => ["Newbie", "Nate", "Jeff", "Peter"]
-    @sorted_set.members.reverse # => ["Peter", "Jeff", "Nate", "Newbie"]
+@sorted_set['Newbie'] = 1
+@sorted_set.members         # => ["Newbie", "Nate", "Jeff", "Peter"]
+@sorted_set.members.reverse # => ["Peter", "Jeff", "Nate", "Newbie"]
 
-    @sorted_set.rangebyscore(10, 100, :limit => 2)   # => ["Nate", "Jeff"]
-    @sorted_set.members(:with_scores => true)        # => [["Newbie", 1], ["Nate", 16], ["Jeff", 28], ["Peter", 76]]
+@sorted_set.rangebyscore(10, 100, :limit => 2)   # => ["Nate", "Jeff"]
+@sorted_set.members(:with_scores => true)        # => [["Newbie", 1], ["Nate", 16], ["Jeff", 28], ["Peter", 76]]
 
-    # atomic increment
-    @sorted_set.increment('Nate')
-    @sorted_set.incr('Peter')   # shorthand
-    @sorted_set.incr('Jeff', 4)
+# atomic increment
+@sorted_set.increment('Nate')
+@sorted_set.incr('Peter')   # shorthand
+@sorted_set.incr('Jeff', 4)
+~~~
 
 The other Redis Sorted Set commands are supported as well; see [Sorted Sets API](http://redis.io/commands#sorted_set).
 
@@ -379,65 +433,79 @@ on the topic, see [An Atomic Rant](http://nateware.com/an-atomic-rant.html).
 
 Atomic counters are a good way to handle concurrency:
 
-    @team = Team.find(1)
-    if @team.drafted_players.increment <= @team.max_players
-      # do stuff
-      @team.team_players.create!(:player_id => 221)
-      @team.active_players.increment
-    else
-      # reset counter state
-      @team.drafted_players.decrement
-    end
+~~~ruby
+@team = Team.find(1)
+if @team.drafted_players.increment <= @team.max_players
+  # do stuff
+  @team.team_players.create!(:player_id => 221)
+  @team.active_players.increment
+else
+  # reset counter state
+  @team.drafted_players.decrement
+end
+~~~
 
 An _atomic block_ gives you a cleaner way to do the above. Exceptions or returning nil
 will rewind the counter back to its previous state:
 
-    @team.drafted_players.increment do |val|
-      raise Team::TeamFullError if val > @team.max_players  # rewind
-      @team.team_players.create!(:player_id => 221)
-      @team.active_players.increment
-    end
+~~~ruby
+@team.drafted_players.increment do |val|
+  raise Team::TeamFullError if val > @team.max_players  # rewind
+  @team.team_players.create!(:player_id => 221)
+  @team.active_players.increment
+end
+~~~
 
 Here's a similar approach, using an if block (failure rewinds counter):
 
-    @team.drafted_players.increment do |val|
-      if val <= @team.max_players
-        @team.team_players.create!(:player_id => 221)
-        @team.active_players.increment
-      end
-    end
+~~~ruby
+@team.drafted_players.increment do |val|
+  if val <= @team.max_players
+    @team.team_players.create!(:player_id => 221)
+    @team.active_players.increment
+  end
+end
+~~~
 
 Class methods work too, using the familiar ActiveRecord counter syntax:
 
-    Team.increment_counter :drafted_players, team_id
-    Team.decrement_counter :drafted_players, team_id, 2
-    Team.increment_counter :total_online_players  # no ID on global counter
+~~~ruby
+Team.increment_counter :drafted_players, team_id
+Team.decrement_counter :drafted_players, team_id, 2
+Team.increment_counter :total_online_players  # no ID on global counter
+~~~
 
 Class-level atomic blocks can also be used.  This may save a DB fetch, if you have
 a record ID and don't need any other attributes from the DB table:
 
-    Team.increment_counter(:drafted_players, team_id) do |val|
-      TeamPitcher.create!(:team_id => team_id, :pitcher_id => 181)
-      Team.increment_counter(:active_players, team_id)
-    end
+~~~ruby
+Team.increment_counter(:drafted_players, team_id) do |val|
+  TeamPitcher.create!(:team_id => team_id, :pitcher_id => 181)
+  Team.increment_counter(:active_players, team_id)
+end
+~~~
 
 ### Locks ###
 
 Locks work similarly. On completion or exception the lock is released:
 
-    class Team < ActiveRecord::Base
-      lock :reorder # declare a lock
-    end
+~~~ruby
+class Team < ActiveRecord::Base
+  lock :reorder # declare a lock
+end
 
-    @team.reorder_lock.lock do
-      @team.reorder_all_players
-    end
+@team.reorder_lock.lock do
+  @team.reorder_all_players
+end
+~~~
 
 Class-level lock (same concept)
 
-    Team.obtain_lock(:reorder, team_id) do
-      Team.reorder_all_players(team_id)
-    end
+~~~ruby
+Team.obtain_lock(:reorder, team_id) do
+  Team.reorder_all_players(team_id)
+end
+~~~
 
 Lock expiration.  Sometimes you want to make sure your locks are cleaned up should
 the unthinkable happen (server failure).  You can set lock expirations to handle
@@ -445,9 +513,11 @@ this.  Expired locks are released by the next process to attempt lock.  Just
 make sure you expiration value is sufficiently large compared to your expected
 lock time.
 
-    class Team < ActiveRecord::Base
-      lock :reorder, :expiration => 15.minutes
-    end
+~~~ruby
+class Team < ActiveRecord::Base
+  lock :reorder, :expiration => 15.minutes
+end
+~~~
 
 Keep in mind that true locks serialize your entire application at that point.  As
 such, atomic counters are strongly preferred.
@@ -456,8 +526,10 @@ such, atomic counters are strongly preferred.
 
 Use :expiration and :expireat options to set default expiration.
 
-    value :value_with_expiration, :expiration => 1.hour
-    value :value_with_expireat, :expireat => Time.now + 1.hour
+~~~ruby
+value :value_with_expiration, :expiration => 1.hour
+value :value_with_expireat, :expireat => Time.now + 1.hour
+~~~
 
 Author
 =======