anticipate 0.0.1 → 0.0.2

data/README.rdoc

@@ -4,23 +4,20 @@
 
 Anticipate is a fluent interface for retrying blocks of code:
   
-  trying_every(3).seconds.failing_after(9).tries do
+  sleeping(0.1).seconds.between_tries.failing_after(20).tries do
   
-    # Repeatedly calls block until it stops raising errors
+    # Calls block every 0.1 seconds until it stops raising errors
     
   end
   
-The Anticipate module allows the following expressions:
-
-  trying_every(n).seconds {}
-  failing_after(n).tries {}
-  trying_every(x).seconds.failing_after(y).tries {}
+Including the Anticipate module into your class gives you:
   
-Blocks should contain an assertion, i.e. raise a
-descriptive error if some condition is unsatisfied. On
-the last iteration, the error will be wrapped in a
-TimeoutError and re-raised.
+  failing_after(3).tries {}
+  sleeping(0.1).seconds.between_tries {}
+  sleeping(123).seconds.between_tries.failing_after(456).tries {}
+
+Blocks should contain an assertion, i.e. raise a descriptive error if some condition is unsatisfied. On the last iteration, any error will be wrapped in an Anticipate::TimeoutError and re-raised.
+
+The first try is attempted immediately, there is no sleep before the first yield.
 
-I'm aware of a couple of gems supporting the
-begin-rescue-sleep-retry dance, namely 'retry' and 'attempt'.
-The aim of this library is to offer more expressive syntax.
+I'm aware of a couple of gems performing the begin-rescue-sleep-retry dance, namely 'retry' and 'attempt'. The aim of this library is to offer more expressive syntax.

data/lib/anticipate/dsl.rb

@@ -0,0 +1,91 @@
+module Anticipate
+  module DSL
+   
+    def trying_every(amount)
+      anticipation.trying_every(amount)
+    end
+
+    def failing_after(amount)
+      anticipation.failing_after(amount)
+    end
+
+    def sleeping(amount)
+      anticipation.sleeping(amount)
+    end
+
+    def default_tries
+      @default_tries ||= 1
+    end
+
+    def default_interval
+      @default_interval ||= 0.1
+    end
+
+    private
+
+    def anticipator
+      Anticipator.new(Kernel)
+    end  
+    
+    def anticipation
+      Anticipation.new(anticipator, default_interval, default_tries)
+    end
+
+    class Term
+      def initialize(anticipator, interval, timeout)
+        @anticipator, @interval, @timeout = anticipator, interval, timeout
+      end
+
+      private
+
+      def exec
+        @anticipator.anticipate(@interval, @timeout) do
+          yield
+        end
+      end
+
+      def chain
+        Anticipation.new(@anticipator, @interval, @timeout)
+      end
+    end
+
+    class TryingEvery < Term
+      def seconds
+        block_given? ? exec { yield } : chain
+      end
+    end
+
+    class FailingAfter < Term
+      def tries
+        block_given? ? exec { yield } : chain
+      end
+    end
+
+    class AfterSleep < Term
+      def between_tries
+        block_given? ? exec { yield } : chain
+      end
+    end
+
+    class Sleeping < Term
+      def seconds
+        AfterSleep.new(@anticipator, @interval, @timeout)
+      end
+    end
+
+    class Anticipation < Term
+      def trying_every(amount)
+        TryingEvery.new(@anticipator, amount, @timeout)
+      end
+
+      def failing_after(amount)
+        FailingAfter.new(@anticipator, @interval, amount)
+      end
+
+      def sleeping(amount)
+        Sleeping.new(@anticipator, amount, @timeout)
+      end
+    end
+    
+  end
+end

data/lib/anticipate.rb

@@ -2,73 +2,10 @@ lib = File.dirname(__FILE__)
 $:.unshift(lib) unless $:.include?(lib) || $:.include?(File.expand_path(lib))
 
 require 'anticipate/anticipator'
+require 'anticipate/dsl'
 
 module Anticipate
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
   
-  def anticipator
-    Anticipator.new(Kernel)
-  end  
-  
-  def default_tries
-    @default_tries ||= 1
-  end
-  
-  def default_interval
-    @default_interval ||= 0.1
-  end
-  
-  def trying_every(amount)
-    anticipation.trying_every(amount)
-  end
-  
-  def failing_after(amount)
-    anticipation.failing_after(amount)
-  end
-  
-  private
-  
-  def anticipation
-    Anticipation.new(anticipator, default_interval, default_tries)
-  end
-  
-  class Term
-    def initialize(anticipator, interval, timeout)
-      @anticipator, @interval, @timeout = anticipator, interval, timeout
-    end
-    
-    private
-    
-    def exec
-      @anticipator.anticipate(@interval, @timeout) do
-        yield
-      end
-    end
-    
-    def chain
-      Anticipation.new(@anticipator, @interval, @timeout)
-    end
-  end
-    
-  class TimeUnit < Term
-    def seconds
-      block_given? ? exec { yield } : chain
-    end
-  end
-  
-  class CountUnit < Term
-    def tries
-      block_given? ? exec { yield } : chain
-    end
-  end
-
-  class Anticipation < Term
-    def trying_every(amount)
-      TimeUnit.new(@anticipator, amount, @timeout)
-    end
-    
-    def failing_after(amount)
-      CountUnit.new(@anticipator, @interval, amount)
-    end
-  end
+  include DSL
 end

data/spec/anticipate/anticipate_spec.rb

@@ -4,13 +4,12 @@ module Anticipate
   describe Anticipate do
     include Anticipate
     
-    before do
-      @anticipator = mock("anticipator")
-      @anticipator.stub!(:anticipate).and_yield
+    let :anticipator do
+      mock("anticipator")
     end
     
-    def anticipator
-      @anticipator
+    before do
+      anticipator.stub!(:anticipate).and_yield
     end
     
     describe "trying_every(n).seconds" do
@@ -21,16 +20,34 @@ module Anticipate
       end
       
       it "overrides the interval" do
-        @anticipator.should_receive(:anticipate).with(55, anything)
+        anticipator.should_receive(:anticipate).with(55, anything)
         trying_every(55).seconds {}
       end
       
       it "uses the default timeout" do
-        @anticipator.should_receive(:anticipate).with(anything, default_tries)
+        anticipator.should_receive(:anticipate).with(anything, default_tries)
         trying_every(66).seconds {}
       end
     end
     
+    describe "sleeping(n).seconds.between_tries" do
+      it "yields" do
+        called = false
+        sleeping(1).seconds.between_tries { called = true }
+        called.should be_true        
+      end
+      
+      it "overrides the interval" do
+        anticipator.should_receive(:anticipate).with(77, anything)
+        trying_every(77).seconds {}
+      end
+      
+      it "uses the default timeout" do
+        anticipator.should_receive(:anticipate).with(anything, default_tries)
+        trying_every(88).seconds {}
+      end
+    end
+    
     describe "failing_after(n).tries" do
       it "yields" do
         called = false
@@ -39,12 +56,12 @@ module Anticipate
       end
       
       it "overrides the timeout" do
-        @anticipator.should_receive(:anticipate).with(anything, 77)
+        anticipator.should_receive(:anticipate).with(anything, 77)
         failing_after(77).tries {}
       end
       
       it "uses the default interval" do
-        @anticipator.should_receive(:anticipate).with(default_interval, anything)
+        anticipator.should_receive(:anticipate).with(default_interval, anything)
         failing_after(88).tries {}
       end
     end
@@ -57,13 +74,13 @@ module Anticipate
       end
       
       it "overrides the timeout" do
-        @anticipator.should_receive(:anticipate).with(anything, 222)
-        failing_after(222).tries.trying_every(111).seconds {}
+        anticipator.should_receive(:anticipate).with(anything, 1)
+        failing_after(anything).tries.trying_every(1).seconds {}
       end
       
       it "overrides the interval" do
-        @anticipator.should_receive(:anticipate).with(333, anything)
-        failing_after(444).tries.trying_every(333).seconds {}
+        anticipator.should_receive(:anticipate).with(2, anything)
+        failing_after(anything).tries.trying_every(2).seconds {}
       end
     end
     
@@ -75,13 +92,31 @@ module Anticipate
       end
       
       it "overrides the timeout" do
-        @anticipator.should_receive(:anticipate).with(anything, 666)
-        trying_every(555).seconds.failing_after(666).tries {}
+        anticipator.should_receive(:anticipate).with(anything, 3)
+        trying_every(anything).seconds.failing_after(3).tries {}
+      end
+      
+      it "overrides the interval" do
+        anticipator.should_receive(:anticipate).with(4, anything)
+        trying_every(4).seconds.failing_after(anything).tries {}
+      end
+    end
+    
+    describe "sleeping(x).seconds.between_tries.failing_after(y).tries" do
+      it "yields" do
+        called = false
+        sleeping(1).seconds.between_tries.failing_after(2).tries { called = true }
+        called.should be_true
+      end
+      
+      it "overrides the timeout" do
+        anticipator.should_receive(:anticipate).with(anything, 5)
+        sleeping(anything).seconds.between_tries.failing_after(5).tries {}
       end
       
       it "overrides the interval" do
-        @anticipator.should_receive(:anticipate).with(777, anything)
-        trying_every(777).seconds.failing_after(888).tries {}
+        anticipator.should_receive(:anticipate).with(6, anything)
+        trying_every(6).seconds.failing_after(anything).tries {}
       end
     end
   end

data/spec/anticipate/integration_spec.rb

@@ -7,7 +7,7 @@ module Anticipate
     it "raises when a block continually raises" do
       raises = []
       lambda {
-        trying_every(0.01).seconds.failing_after(5).tries {
+        sleeping(0.01).seconds.between_tries.failing_after(5).tries {
           raise (raises << Time.now).to_s
         }
       }.should raise_error(TimeoutError)
@@ -20,7 +20,7 @@ module Anticipate
     it "continues when a block stops raising" do
       raises = 0
       lambda {
-        trying_every(0.01).seconds.failing_after(3).tries {
+        sleeping(0.01).seconds.between_tries.failing_after(3).tries {
           raise (raises += 1).to_s unless raises == 2
         }
       }.should_not raise_error

metadata

@@ -1,75 +1,55 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: anticipate
-version: !ruby/object:Gem::Version 
-  hash: 29
+version: !ruby/object:Gem::Version
+  version: 0.0.2
   prerelease: 
-  segments: 
-  - 0
-  - 0
-  - 1
-  version: 0.0.1
 platform: ruby
-authors: 
+authors:
 - Josh Chisholm
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-01-31 00:00:00 +00:00
-default_executable: 
+date: 2011-11-02 00:00:00.000000000Z
 dependencies: []
-
 description: Fluent interface for try-rescue-sleep-retry-abort
 email: joshuachisholm@gmail.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - README.rdoc
-files: 
+files:
 - README.rdoc
 - anticipate.gemspec
 - lib/anticipate.rb
 - lib/anticipate/anticipator.rb
+- lib/anticipate/dsl.rb
 - lib/anticipate/timeout_error.rb
 - spec/anticipate/anticipate_spec.rb
 - spec/anticipate/anticipator_spec.rb
 - spec/anticipate/integration_spec.rb
 - spec/spec_helper.rb
-has_rdoc: true
 homepage: http://github.com/joshski/anticipate
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.4.1
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
-summary: anticipate-0.0.1
+summary: anticipate-0.0.2
 test_files: []
-