rhod 0.0.3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 99aa65709753429dc68b3979f9397bf2502e13ad
-  data.tar.gz: cd2856de21b568e00fa7bb7b097125ff722704b5
+  metadata.gz: f1d610e43d6cd0ea21bc4bf99bd68e4728f26cbd
+  data.tar.gz: ea6aba49b9e5df02cedf9988f6ba8915df2e1f99
 SHA512:
-  metadata.gz: 2245e308b5b535497b54e24681d7f512ca906b3dd1936897568b2022715063b66ed972ccb33cf0f68efdd81df5ec970533f0e67845aa01cbebd4e11762de4217
-  data.tar.gz: f8b786cde49e380879e0339513d9470f8a9c222e62e3f21eea915a3f821931b43e1b4a22752f64a9fdc8d4de8c76483b961f5fcc6a5326f58bf12f8480301df4
+  metadata.gz: 0b30aebc6f171b35d4dc581824d7e0a1466d308e4cc1f4927c5d791d3382ef3b75880cb7e1fa7a122daafd4df45b96c5d978d3ea2e6f377cd933c8cbd6142dc5
+  data.tar.gz: 2997412a10c2d10e3a3a2f2eca8df58387459f95fbe6a5da15f6473cb07383bdc5bc6c21ad62d83e0572154144cac0d324f0e0322843ac11ec09b0fc7f3573aa

data/Changes.md

@@ -0,0 +1,8 @@
+# v0.0.3
+Add support for connection pooling to be attached to a Rhod command.
+
+# v0.0.2
+Added syntax sugar around backoff definitions.
+
+# v0.0.1
+First Public Release.

data/README.md

@@ -12,214 +12,107 @@ A Lightweight High Avalibility framework for Ruby, inspired by [Hystrix](https:/
 
 Rhod helps you handle failures gracefully, even during a firefight. When your code has to interact with other services, it also means writing code to keep it running in the event of failure. Failures can include exceptions, timeouts, downed hosts, and any number of issues that are caused by events outside of your application.
 
-Rhod allows you to fully customize how your application reacts when it can't reach a service it needs. but by default it is configured for a 'fail fast' scenario. With some configuration, Rhod can support the following failure scenarios and variations on them:
-
-  - Fail Fast
-  - Retry N times before Fail
-  - Retry N times with progressive backoffs before Fail
-  - Fail Silent
-  - Fail w/ Fallback
-  - Primary / Secondary ("hot spare") switch over
-
-## Installation
-
-Rhod requires Ruby 1.9.2 or greater.
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'rhod'
-```
+# Is it any good?
 
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install rhod
-
-## Configuration
-
-To configure Rhod's defaults, change any of the keys in `Rhod.defaults`
-
-```ruby
-Rhod.defaults
-=> {:retries=>0,
- :backoffs=>#<Enumerator: ...>,
- :fallback=>nil}
-```
+[Yes](https://news.ycombinator.com/item?id=3067434)
 
 ## Usage
 
 Rhod has a very simple API. Design your application as you would normally, then enclose network accessing portions of your code with:
 
 ```ruby
-Rhod.execute do
+Rhod.with_default do
   ...
 end
 ```
 
-This implements the "Fail Fast" scenario by default.
-
-Example, open a remote reasource, fail immediately if it fails:
-
-```ruby
-require 'open-uri'
-require 'rhod'
-
-Rhod.execute { open("http://google.com").read }
-```
-
-## An Important note about arguments:
-
-Do not reach into the outer scope when using Rhod, instead you can pass arguments into your block like so:
-
-```ruby
-address = "http://google.com"
-
-Rhod.execute(address) do |url|
-   open(url).read
-end
-```
-
-If you need to pass options to Rhod, pass them as the last argument:
-
-```ruby
-# Works the same as the above, with but with retires.
-address = "http://google.com"
-
-Rhod.execute(address, :retries => 5) do |url|
-   open(url).read
-end
-```
-
-### Retries with and without backoffs
+This implements the [Fail Fast](https://github.com/dinedal/rhod/wiki/Fail-Fast) scenario by default.
 
-#### Idempotence Caution
-
-Code within a `Rhod::Command` block with reties in use must be _idempotent_, i.e., safe to run multiple times.
+Rhod allows you to fully customize how your application reacts when it can't reach a service it needs. but by default it is configured for a 'fail fast' scenario. With some configuration, Rhod can support the following failure scenarios and variations on them:
 
-Rhod supports retying up to N times. By default it uses a logarithmic backoff:
+  - [Fail Fast](https://github.com/dinedal/rhod/wiki/Fail-Fast)
+  - [Retry N times before Fail](https://github.com/dinedal/rhod/wiki/Retry-N-times-before-Fail)
+  - [Retry N times with progressive backoffs before Fail](Retry-N-times-with-progressive-backoffs-before-Fail)
+  - [Fail Silent](https://github.com/dinedal/rhod/wiki/Fail-Silent)
+  - [Fail w/ Fallback](https://github.com/dinedal/rhod/wiki/Fail-with-Fallback)
+  - [Primary / Secondary ("hot spare") switch over](https://github.com/dinedal/rhod/wiki/Primary-Secondary-Switchover)
 
-```ruby
-Rhod::Backoffs.default.take(5)
-# [0.7570232465074598, 2.403267722339301, 3.444932048942182, 4.208673319629471, 4.811984719351674]
-```
+Check the [wiki](https://github.com/dinedal/rhod/wiki/) for more documentation.
 
-Rhod also comes with exponential and constant (always the same value) backoffs. You can also supply any Enumerator that produces a series of numbers. See `lib/rhod/backoffs.rb` for examples.
+## Upgrading from v0.0.x to v0.1.x
 
-Example, open a remote reasource, fail once it has failed 10 times, with the default (logarithmic) backoff:
+The only breaking API change is that backoffs have changed in their creation, dropping `Enumerator` in favor of a simple threadsafe class. Please switch any custom backoff code subclass `Rhod::Backoffs::Backoff`.
 
-```ruby
-require 'open-uri'
-require 'rhod'
+## Installation
 
-Rhod::Command.execute(:retries => 10) { open("http://google.com").read }
-```
+Rhod requires Ruby 1.9.2 or greater.
 
-Example, open a remote reasource, fail once it has failed 10 times, waiting 0.2 seconds between attempts:
+Add this line to your application's Gemfile:
 
 ```ruby
-require 'open-uri'
-require 'rhod'
-
-    Rhod.execute(:retries => 10, :backoffs => 0.2) do
-      open("http://google.com").read
-    end
+gem 'rhod'
 ```
 
-Example, open a remote reasource, fail once it has failed 10 times, with an exponetially growing wait time between attempts:
-
-```ruby
-require 'open-uri'
-require 'rhod'
+And then execute:
 
-Rhod.execute(:retries => 10, :backoffs => :^) do
-  open("http://google.com").read
-end
-```
+    $ bundle
 
-Example, open a remote reasource, fail once it has failed 10 times, with no waiting between attempts:
+Or install it yourself as:
 
-```ruby
-require 'open-uri'
-require 'rhod'
+    $ gem install rhod
 
-Rhod.execute(:retries => 10, :backoffs => 0) do
-  open("http://google.com").read
-end
-```
+## Configuration
 
-Example, open a remote reasource, fail once it has failed 10 times, with a random wait between 1 and 5 seconds on each attempt
+To configure Rhod's defaults, just overwrite the default profile with any changes you'd like to make.
 
 ```ruby
-require 'open-uri'
-require 'rhod'
-
-Rhod.execute(:retries => 10, :backoffs => 'r1..5') do
-  open("http://google.com").read
-end
+Rhod.create_profile(:default, retries: 10)
+# => {:retries=>10,
+#  :backoffs=>#<Rhod::Backoffs::Logarithmic:0x007f89afaeb4c0 @state=1.3>,
+#  :fallback=>nil,
+#  :pool=>
+#   #<ConnectionPool:0x007f89afaeb470
+#    @available=
+#     #<ConnectionPool::TimedStack:0x007f89afaeb3d0
+#      @mutex=#<Mutex:0x007f89afaeb358>,
+#      @que=[nil],
+#      @resource=
+#       #<ConditionVariable:0x007f89afaeb330
+#        @waiters={},
+#        @waiters_mutex=#<Mutex:0x007f89afaeb2e0>>>,
+#    @key=:"current-70114667354600",
+#    @size=1,
+#    @timeout=0>,
+#  :exceptions=>[Exception, StandardError]}
 ```
 
-
-### Fail Silent
-
-In the event of a failure, Rhod falls back to a `fallback`. The most basic case is to fall back to a constant value.
-
-Example, open a remote reasource, if it fails return them empty string.
+Creating a new profile will copy from the default profile any unspecified options:
 
 ```ruby
-require 'open-uri'
-require 'rhod'
+Rhod.create_profile(:redis,
+  retries: 10,
+  backoffs: :^,
+  pool: ConnectionPool.new(size: 3, timeout: 10) { Redis.new },
+  exceptions: [Redis::BaseError])
 
-Rhod.execute(:fallback => -> {""}) do
-  open("http://google.com").read
-end
+Rhod.with_redis("1") {|r, a| r.set('test',a)}
+# => "OK"
+Rhod.with_redis {|r| r.get('test')}
+# => "1"
 ```
 
-### Fail w/ Fallback
-
-If there is another network call that can be used to fetch the reasource, it's possible to use another `Rhod::Command` once a failure has occurred.
-
-```ruby
-require 'open-uri'
-require 'rhod'
+## Idempotence Caution
 
-search_engine_fallback = Rhod::Command.new(
-  :fallback => -> {""} # couldn't get anything
-) do
-  open("https://yahoo.com").read
-end
+Code within a `Rhod::Command` block with reties in use must be _idempotent_, i.e., safe to run multiple times.
 
-Rhod.execute(:fallback => -> { search_engine_fallback.execute }) do
-  open("http://google.com").read
-end
-```
+## Passing arguments
 
-### Primary / Secondary ("Hot Spare") switch over
+Code within a `Rhod::Command` should avoid leaking memory and/or scope by having arguments passed to it:
 
-Sometimes the fallback is just a part of normal operation. Just code in the state of which back end to access.
+### Good use of argument passing:
 
 ```ruby
-require 'open-uri'
-require 'rhod'
-
-class SearchEngineHTML
-  attr_accessor :secondary
-
-  def fetch
-    url = !@secondary ? "http://google.com" : "https://yahoo.com"
-
-    Rhod.execute(url, :fallback => Proc.new { @secondary = !@secondary; fetch }) do |url|
-      open(url).read
-    end
-  end
-end
-
-search_engine_html = SearchEngineHTML.new
-
-search_engine_html.fetch
+Rhod.with_default("http://google.com") {|url| open(url).read}
 ```
 
 ## Connection Pools
@@ -231,9 +124,12 @@ require 'rhod'
 require 'redis'
 require 'connection_pool'
 
-Rhod.connection_pools[:redis] = ConnectionPool.new(size:3, timeout:5) { Redis.new }
+Rhod.create_profile(:redis,
+  pool: ConnectionPool.new(size: 3, timeout: 5) { Redis.new }
+  )
 
-Rhod.execute(:pool => :redis) {|redis| redis.set("foo", "bar") }
+Rhod.with_redis {|redis| redis.set("foo", "bar") }
+# => "OK"
 ```
 
 The connection is always the first argument passed into the block, the other arguments are passed in their original order after.
@@ -241,7 +137,7 @@ The connection is always the first argument passed into the block, the other arg
 ```ruby
 key   = "foo"
 value = "bar"
-Rhod.execute(key, value, :pool => :redis) {|redis, k, v| redis.set(k, v) }
+Rhod.with_redis(key, value) {|redis, k, v| redis.set(k, v) }
 ```
 
 ## Contributing

data/lib/rhod.rb

@@ -1,27 +1,17 @@
+require 'connection_pool'
 require_relative "rhod/version"
 require_relative "rhod/backoffs"
 require_relative "rhod/command"
-require 'connection_pool'
+require_relative "rhod/profile"
 
 module Rhod
+
   def self.execute(*args, &block)
-    Rhod::Command.execute(*args, &block)
+    Rhod.with_default(*args, &block)
   end
 
-  class << self
-    attr_accessor :defaults
-
-    attr_accessor :connection_pools
+  def self.create_profile(name, options={})
+    Rhod::Profile.new(name, options)
   end
 
-  self.defaults = {
-    retries: 0,
-    backoffs: Rhod::Backoffs.default,
-    fallback: nil,
-  }
-
-  self.connection_pools = {
-    default: ConnectionPool.new(size: 1, timeout: 0) { nil }
-  }
-
 end

data/lib/rhod/backoffs.rb

@@ -3,76 +3,40 @@ module Rhod::Backoffs
   extend self
 
   def backoff_sugar_to_enumerator(backoff)
-    if backoff.is_a?(Enumerator)
+    if backoff.is_a?(Rhod::Backoffs::Backoff)
       backoff
     elsif backoff.is_a?(Numeric)
-      constant_backoff(backoff)
+      Rhod::Backoffs::Constant.new(backoff)
     elsif backoff.is_a?(Range)
-      random_backoffs(backoff)
+      Rhod::Backoffs::Random.new(backoff)
     elsif backoff.is_a?(String)
       n = (backoff[1..-1].to_f)
       case backoff[0]
       when "^"
-        expoential_backoffs(n)
+        Rhod::Backoffs::Exponential.new(n)
       when "l"
-        logarithmic_backoffs(n)
+        Rhod::Backoffs::Logarithmic.new(n)
       when "r"
         min = backoff[1..-1].split("..")[0].to_f
         max = backoff[1..-1].split("..")[1].to_f
-        random_backoffs((min..max))
+        Rhod::Backoffs::Random.new((min..max))
       end
     elsif backoff.is_a?(Symbol)
       case backoff
       when :^
-        expoential_backoffs
+        Rhod::Backoffs::Exponential.new(0)
       when :l
-        logarithmic_backoffs
+        Rhod::Backoffs::Logarithmic.new(1.3)
       when :r
-        random_backoffs
-      end
-    end
-  end
-
-  # Returns a generator of a expoentially increasing series starting at n
-  def expoential_backoffs(n=1)
-    Enumerator.new do |yielder|
-      x = (n - 1)
-      loop do
-        x += 1
-        yielder << 2.0**x
-      end
-    end
-  end
-
-  # Returns a generator of a logarithmicly increasing series starting at n
-  def logarithmic_backoffs(n=0.3)
-    Enumerator.new do |yielder|
-      x = n
-      loop do
-        x += 1
-        yielder << Math.log2(x**2)
-      end
-    end
-  end
-  alias default logarithmic_backoffs
-
-  # Always the same backoff
-  def constant_backoff(n)
-    Enumerator.new do |yielder|
-      loop do
-        yielder << n
-      end
-    end
-  end
-
-  # Returns a generator of random numbers falling inside of a range
-  def random_backoffs(range=(0..10))
-    float_range = (range.min.to_f..range.max.to_f)
-    Enumerator.new do |yielder|
-      loop do
-        yielder << rand(float_range)
+        Rhod::Backoffs::Random.new(0..10)
       end
     end
   end
 
 end
+
+require_relative 'backoffs/backoff.rb'
+require_relative 'backoffs/constant.rb'
+require_relative 'backoffs/exponential.rb'
+require_relative 'backoffs/logarithmic.rb'
+require_relative 'backoffs/random.rb'

data/lib/rhod/backoffs/backoff.rb

@@ -0,0 +1,16 @@
+class Rhod::Backoffs::Backoff
+  attr_reader :state
+
+  def initialize(state = nil)
+    @state = state
+  end
+
+  def iterate
+    raise NotImplementedError
+  end
+
+  def next
+    @state, result = iterate(state)
+    result
+  end
+end

data/lib/rhod/backoffs/constant.rb

@@ -0,0 +1,5 @@
+class Rhod::Backoffs::Constant < Rhod::Backoffs::Backoff
+  def iterate(state)
+    [state, state]
+  end
+end

data/lib/rhod/backoffs/exponential.rb

@@ -0,0 +1,5 @@
+class Rhod::Backoffs::Exponential < Rhod::Backoffs::Backoff
+  def iterate(state)
+    [state + 1, 2.0**(state)]
+  end
+end

data/lib/rhod/backoffs/logarithmic.rb

@@ -0,0 +1,5 @@
+class Rhod::Backoffs::Logarithmic < Rhod::Backoffs::Backoff
+  def iterate(state)
+    [state + 1, Math.log2((state)**2)]
+  end
+end

data/lib/rhod/backoffs/random.rb

@@ -0,0 +1,6 @@
+class Rhod::Backoffs::Random < Rhod::Backoffs::Backoff
+  def iterate(state)
+    @float_range ||= (state.min.to_f..state.max.to_f)
+    [@float_range, rand(@float_range)]
+  end
+end

data/lib/rhod/command.rb

@@ -10,17 +10,19 @@ class Rhod::Command
     @request = block
 
     @retries = opts[:retries]
-    @retries ||= Rhod.defaults[:retries]
+    @retries ||= 0
     @attempts = 0
 
     @backoffs = Rhod::Backoffs.backoff_sugar_to_enumerator(opts[:backoffs])
-    @backoffs ||= Rhod.defaults[:backoffs]
+    @backoffs ||= Rhod::Backoffs::Logarithmic.new(1.3)
 
     @fallback = opts[:fallback]
-    @fallback ||= Rhod.defaults[:fallback]
 
-    @pool = Rhod.connection_pools[opts[:pool]]
-    @pool ||= Rhod.connection_pools[:default]
+    @pool = opts[:pool]
+    @pool ||= ConnectionPool.new(size: 1, timeout: 0) { nil }
+
+    @exceptions = opts[:exceptions]
+    @exceptions ||= EXCEPTIONS
   end
 
   ### Class methods
@@ -40,7 +42,7 @@ class Rhod::Command
 
         @request.call(*@args)
       end
-    rescue *EXCEPTIONS
+    rescue *@exceptions
       @attempts += 1
       if @attempts <= @retries
         sleep(@backoffs.next)

data/lib/rhod/profile.rb

@@ -0,0 +1,37 @@
+class Rhod::Profile < Hash
+  @@profiles = {}
+
+  def initialize(name, options={})
+    # When creating new profiles, copy from the global default, incase it was customized.
+    if @@profiles[:default]
+      default = @@profiles[:default].dup
+    else
+      default = {}
+    end
+
+    default.each {|k,v| self[k] = v }
+
+    options.each {|k,v| self[k] = v }
+
+    # Syntax sugar: named .with_#{profile} methods on this class and the module
+    @@profiles[name] = self
+
+    self.class.__send__(:define_method, :"with_#{name}") do |*args, &block|
+      Rhod::Command.execute(*args, @@profiles[name], &block)
+    end
+
+    Rhod.class.__send__(:define_method, :"with_#{name}") do |*args, &block|
+      Rhod::Command.execute(*args, @@profiles[name], &block)
+    end
+
+    self
+  end
+end
+
+Rhod::Profile.new(:default,
+  retries: 0,
+  backoffs: Rhod::Backoffs::Logarithmic.new(1.3),
+  fallback: nil,
+  pool: ConnectionPool.new(size: 1, timeout: 0) { nil },
+  exceptions: [Exception, StandardError],
+)

data/lib/rhod/version.rb

@@ -1,3 +1,3 @@
 module Rhod
-  VERSION = "0.0.3"
+  VERSION = "0.1.0"
 end

data/test/test_backoffs.rb

@@ -4,7 +4,7 @@ require File.expand_path(File.dirname(__FILE__) + '/helper')
 describe Rhod::Backoffs do
   describe "backoff_sugar_to_enumerator" do
     it "returns enumerators as is" do
-      e = Rhod::Backoffs.constant_backoff(0)
+      e = Rhod::Backoffs::Constant.new(0)
       Rhod::Backoffs.backoff_sugar_to_enumerator(e).must_equal e
     end
 
@@ -14,35 +14,59 @@ describe Rhod::Backoffs do
     end
 
     it "generates expoential backoffs with '^' syntax" do
-      Rhod::Backoffs.backoff_sugar_to_enumerator("^2.0").take(3).must_equal [4.0, 8.0, 16.0]
+      results = []
+      eb = Rhod::Backoffs.backoff_sugar_to_enumerator("^2.0")
+
+      3.times { results << eb.next }
+
+      results.must_equal [4.0, 8.0, 16.0]
     end
 
     it "generates logarithmic backoffs with 'l' syntax" do
-      Rhod::Backoffs.backoff_sugar_to_enumerator("l2.0").
-        take(3).must_equal [3.169925001442312, 4.0, 4.643856189774724]
+      results = []
+      lb = Rhod::Backoffs.backoff_sugar_to_enumerator("l2.0")
+
+      3.times { results << lb.next }
+
+      results.must_equal [2.0, 3.169925001442312, 4.0]
     end
 
     it "generates random backoffs with 'r' syntax" do
-      sample = Rhod::Backoffs.backoff_sugar_to_enumerator("r1..2").
-        take(3)
-      sample.min.floor.must_equal 1
-      sample.max.ceil.must_equal 2
+      results = []
+      rb = Rhod::Backoffs.backoff_sugar_to_enumerator("r1..2")
+
+      10.times { results << rb.next }
+
+      results.min.floor.must_equal 1
+      results.max.ceil.must_equal 2
     end
 
     it "generates expoential backoffs with :^ syntax" do
-      Rhod::Backoffs.backoff_sugar_to_enumerator(:^).take(3).must_equal [2.0, 4.0, 8.0]
+      results = []
+      eb = Rhod::Backoffs.backoff_sugar_to_enumerator(:^)
+
+      3.times { results << eb.next }
+
+      results.must_equal [1.0, 2.0, 4.0]
     end
 
     it "generates logarithmic backoffs with :l syntax" do
-      Rhod::Backoffs.backoff_sugar_to_enumerator(:l).
-        take(3).must_equal [0.7570232465074598, 2.403267722339301, 3.444932048942182]
+      results = []
+      lb = Rhod::Backoffs.backoff_sugar_to_enumerator(:l)
+
+      3.times { results << lb.next }
+
+      results.must_equal [0.7570232465074598, 2.403267722339301, 3.444932048942182]
     end
 
     it "generates random backoffs with :r syntax" do
-      sample = Rhod::Backoffs.backoff_sugar_to_enumerator(:r).
-        take(100)
-      sample.min.floor.must_equal 0
-      sample.max.ceil.must_equal 10
+      results = []
+      rb = Rhod::Backoffs.backoff_sugar_to_enumerator(:r)
+
+      100.times { results << rb.next }
+
+      results.min.floor.must_equal 0
+      results.max.ceil.must_equal 10
     end
   end
 end

data/test/test_command.rb

@@ -34,7 +34,7 @@ describe Rhod::Command do
           backoff = MiniTest::Mock.new
           backoff.expect(:next, 0)
 
-          Rhod::Backoffs.stub(:constant_backoff, backoff) do
+          Rhod::Backoffs::Constant.stub(:new, backoff) do
             begin
               Rhod::Command.new(:retries => 1, :backoffs => 0) do
                 val += 1
@@ -75,14 +75,14 @@ describe Rhod::Command do
 
     describe "with connection pools" do
       it "uses the provided pool" do
-        Rhod.connection_pools[:test] = ConnectionPool.new(size: 1, timeout: 0) { :conn }
+        pool = ConnectionPool.new(size: 1, timeout: 0) { :conn }
         Rhod::Command.new {|a| a}.execute.must_equal nil
-        Rhod::Command.new(pool: :test) {|a| a}.execute.must_equal :conn
+        Rhod::Command.new(pool: pool) {|a| a}.execute.must_equal :conn
       end
 
       it "correctly handles arguements" do
-        Rhod.connection_pools[:test] = ConnectionPool.new(size: 1, timeout: 0) { :conn }
-        Rhod::Command.new(1, pool: :test) {|a, b| [a,b]}.execute.must_equal [:conn, 1]
+        pool = ConnectionPool.new(size: 1, timeout: 0) { :conn }
+        Rhod::Command.new(1, pool: pool) {|a, b| [a,b]}.execute.must_equal [:conn, 1]
       end
     end
 

data/test/test_profile.rb

@@ -0,0 +1,30 @@
+require 'minitest/autorun'
+require File.expand_path(File.dirname(__FILE__) + '/helper')
+
+describe Rhod::Profile do
+  describe "defaults" do
+    it "always has them" do
+      assert_instance_of Rhod::Profile, Rhod::Profile.class_variable_get(:@@profiles)[:default]
+      defined?(Rhod.with_default).must_equal "method"
+      defined?(Rhod::Profile.with_default).must_equal "method"
+    end
+  end
+
+  describe "self.new" do
+    it "copies missing attributes from the defaults" do
+      Rhod::Profile.new(:test1, retries: 55 )
+      Rhod::Profile.class_variable_get(:@@profiles)[:test1][:retries].must_equal 55
+      Rhod::Profile.class_variable_get(:@@profiles)[:test1][:exceptions].must_equal [Exception, StandardError]
+    end
+
+    it "creates a new method on itself and the module for new profiles" do
+      defined?(Rhod.with_test2).must_equal nil
+      defined?(Rhod::Profile.with_test2).must_equal nil
+
+      Rhod::Profile.new(:test2)
+
+      defined?(Rhod.with_test2).must_equal "method"
+      defined?(Rhod::Profile.with_test2).must_equal "method"
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rhod
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors:
 - Paul Bergeron
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-20 00:00:00.000000000 Z
+date: 2013-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -103,18 +103,26 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .pryrc
+- Changes.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/rhod.rb
 - lib/rhod/backoffs.rb
+- lib/rhod/backoffs/backoff.rb
+- lib/rhod/backoffs/constant.rb
+- lib/rhod/backoffs/exponential.rb
+- lib/rhod/backoffs/logarithmic.rb
+- lib/rhod/backoffs/random.rb
 - lib/rhod/command.rb
+- lib/rhod/profile.rb
 - lib/rhod/version.rb
 - rhod.gemspec
 - test/helper.rb
 - test/test_backoffs.rb
 - test/test_command.rb
+- test/test_profile.rb
 homepage: https://github.com/dinedal/rhod
 licenses:
 - MIT
@@ -143,3 +151,4 @@ test_files:
 - test/helper.rb
 - test/test_backoffs.rb
 - test/test_command.rb
+- test/test_profile.rb