mocha 0.10.5 → 0.11.0

data/lib/mocha/return_values.rb

@@ -1,19 +1,19 @@
 require 'mocha/single_return_value'
 
-module Mocha # :nodoc:
-  
-  class ReturnValues # :nodoc:
-    
+module Mocha
+
+  class ReturnValues
+
     def self.build(*values)
       new(*values.map { |value| SingleReturnValue.new(value) })
     end
-    
+
     attr_accessor :values
-    
+
     def initialize(*values)
       @values = values
     end
-    
+
     def next
       case @values.length
         when 0 then nil
@@ -21,11 +21,11 @@ module Mocha # :nodoc:
         else @values.shift.evaluate
       end
     end
-    
+
     def +(other)
       self.class.new(*(@values + other.values))
     end
-    
+
   end
-  
-end
+
+end

data/lib/mocha/sequence.rb

@@ -1,42 +1,51 @@
-module Mocha # :nodoc:
-  
+module Mocha
+
+  # Used to constrain the order in which expectations can occur.
+  #
+  # @see API#sequence
+  # @see Expectation#in_sequence
   class Sequence
-    
+
+    # @private
     class InSequenceOrderingConstraint
-      
+
       def initialize(sequence, index)
         @sequence, @index = sequence, index
       end
-      
+
       def allows_invocation_now?
         @sequence.satisfied_to_index?(@index)
       end
-      
+
       def mocha_inspect
         "in sequence #{@sequence.mocha_inspect}"
       end
-      
+
     end
-    
+
+    # @private
     def initialize(name)
       @name = name
       @expectations = []
     end
-    
+
+    # @private
     def constrain_as_next_in_sequence(expectation)
       index = @expectations.length
       @expectations << expectation
       expectation.add_ordering_constraint(InSequenceOrderingConstraint.new(self, index))
     end
-    
+
+    # @private
     def satisfied_to_index?(index)
       @expectations[0...index].all? { |expectation| expectation.satisfied? }
     end
-    
+
+    # @private
     def mocha_inspect
       "#{@name.mocha_inspect}"
     end
-    
+
   end
-  
-end
+
+end

data/lib/mocha/single_return_value.rb

@@ -1,17 +1,17 @@
 require 'mocha/is_a'
 
-module Mocha # :nodoc:
-  
-  class SingleReturnValue # :nodoc:
-    
+module Mocha
+
+  class SingleReturnValue
+
     def initialize(value)
       @value = value
     end
-    
+
     def evaluate
       @value
     end
-    
+
   end
-  
+
 end

data/lib/mocha/single_yield.rb

@@ -1,18 +1,18 @@
-module Mocha # :nodoc:
-  
-  class SingleYield # :nodoc:
-    
+module Mocha
+
+  class SingleYield
+
     attr_reader :parameters
-    
+
     def initialize(*parameters)
       @parameters = parameters
     end
-    
+
     def each
       yield(@parameters)
     end
-    
+
   end
-  
+
 end
-    
+

data/lib/mocha/standalone.rb

@@ -1 +1 @@
-require 'mocha/api'
+require 'mocha/api'

data/lib/mocha/state_machine.rb

@@ -1,91 +1,106 @@
-module Mocha # :nodoc:
+module Mocha
 
   # A state machine that is used to constrain the order of invocations.
-  # An invocation can be constrained to occur when a state is, or is_not, active.
+  # An invocation can be constrained to occur when a state {#is}, or {#is_not}, active.
   class StateMachine
-  
-    class State # :nodoc:
-    
+
+    # Provides a mechanism to change the state of a {StateMachine} at some point in the future.
+    class State
+
+      # @private
       def initialize(state_machine, state)
         @state_machine, @state = state_machine, state
       end
-    
+
+      # @private
       def activate
         @state_machine.current_state = @state
       end
-    
+
+      # @private
       def active?
         @state_machine.current_state == @state
       end
-    
+
+      # @private
       def mocha_inspect
         "#{@state_machine.name} is #{@state.mocha_inspect}"
       end
-    
+
     end
-    
-    class StatePredicate # :nodoc:
-      
+
+    # Provides the ability to determine whether a {StateMachine} is in a specified state at some point in the future.
+    class StatePredicate
+
+      # @private
       def initialize(state_machine, state)
         @state_machine, @state = state_machine, state
       end
-    
+
+      # @private
       def active?
         @state_machine.current_state != @state
       end
-    
+
+      # @private
       def mocha_inspect
         "#{@state_machine.name} is not #{@state.mocha_inspect}"
       end
-      
+
     end
-    
-    attr_reader :name # :nodoc:
-    
-    attr_accessor :current_state # :nodoc:
-    
-    def initialize(name) # :nodoc:
+
+    # @private
+    attr_reader :name
+
+    # @private
+    attr_accessor :current_state
+
+    # @private
+    def initialize(name)
       @name = name
       @current_state = nil
     end
-    
-    # :call-seq: starts_as(initial_state) -> state_machine
+
+    # Put the {StateMachine} into the state specified by +initial_state_name+.
     #
-    # Put the +state_machine+ into the +initial_state+.
-    def starts_as(initial_state)
-      become(initial_state)
+    # @param [String] initial_state_name name of initial state
+    # @return [StateMachine] state machine, thereby allowing invocations of other {StateMachine} methods to be chained.
+    def starts_as(initial_state_name)
+      become(initial_state_name)
       self
     end
-  
-    # :call-seq: become(next_state)
+
+    # Put the {StateMachine} into the +next_state_name+.
     #
-    # Put the +state_machine+ into the +next_state+.
-    def become(next_state)
-      @current_state = next_state
+    # @param [String] next_state_name name of new state
+    def become(next_state_name)
+      @current_state = next_state_name
     end
-  
-    # :call-seq: is(state)
+
+    # Provides a mechanism to change the {StateMachine} into the state specified by +state_name+ at some point in the future.
     #
-    # Determines whether the +state_machine+ is in the specified +state+.
-    def is(state)
-      State.new(self, state)
-    end
-  
-    # :call-seq: is_not(state)
+    # Or provides a mechanism to determine whether the {StateMachine} is in the state specified by +state_name+ at some point in the future.
     #
-    # Determines whether the +state_machine+ is not in the specified +state+.
-    def is_not(state)
-      StatePredicate.new(self, state)
+    # @param [String] state_name name of new state
+    # @return [State] state which, when activated, will change the {StateMachine} into the state with the specified +state_name+.
+    def is(state_name)
+      State.new(self, state_name)
+    end
+
+    # Provides a mechanism to determine whether the {StateMachine} is not in the state specified by +state_name+ at some point in the future.
+    def is_not(state_name)
+      StatePredicate.new(self, state_name)
     end
-  
-    def mocha_inspect # :nodoc:
+
+    # @private
+    def mocha_inspect
       if @current_state
         "#{@name} is #{@current_state.mocha_inspect}"
       else
         "#{@name} has no current state"
       end
     end
-  
+
   end
 
-end
+end

data/lib/mocha/stubbing_error.rb

@@ -1,16 +1,19 @@
 require 'mocha/backtrace_filter'
 
-module Mocha # :nodoc:
-  
-  # Exception raised when an action prevented by Configuration#prevent is attempted.
+module Mocha
+
+  # Exception raised when stubbing a particular method is not allowed.
+  #
+  # @see Configuration.prevent
   class StubbingError < StandardError
 
-    def initialize(message = nil, backtrace = []) # :nodoc:
+    # @private
+    def initialize(message = nil, backtrace = [])
       super(message)
       filter = BacktraceFilter.new
       set_backtrace(filter.filtered(backtrace))
     end
 
   end
-  
+
 end

data/lib/mocha/thrower.rb

@@ -1,6 +1,6 @@
-module Mocha # :nodoc:
+module Mocha
 
-  class Thrower # :nodoc:
+  class Thrower
 
     def initialize(tag, object = nil)
       @tag, @object = tag, object

data/lib/mocha/unexpected_invocation.rb

@@ -1,18 +1,21 @@
-module Mocha # :nodoc:
+module Mocha
 
+  # Exception raised when an unexpected method is invoked
   class UnexpectedInvocation
-    
+
+    # @private
     def initialize(mock, symbol, *arguments)
       @mock = mock
       @method_matcher = MethodMatcher.new(symbol)
       @parameters_matcher = ParametersMatcher.new(arguments)
     end
-    
+
+    # @private
     def to_s
       method_signature = "#{@mock.mocha_inspect}.#{@method_matcher.mocha_inspect}#{@parameters_matcher.mocha_inspect}"
       "unexpected invocation: #{method_signature}\n"
     end
-    
+
   end
-  
-end
+
+end

data/lib/mocha/version.rb

@@ -1,3 +1,3 @@
 module Mocha
-  VERSION = "0.10.5"
+  VERSION = "0.11.0"
 end

data/lib/mocha/yield_parameters.rb

@@ -2,14 +2,14 @@ require 'mocha/no_yields'
 require 'mocha/single_yield'
 require 'mocha/multiple_yields'
 
-module Mocha # :nodoc:
-  
-  class YieldParameters # :nodoc:
-    
+module Mocha
+
+  class YieldParameters
+
     def initialize
       @parameter_groups = []
     end
-    
+
     def next_invocation
       case @parameter_groups.length
         when 0 then NoYields.new
@@ -17,15 +17,15 @@ module Mocha # :nodoc:
         else @parameter_groups.shift
       end
     end
-    
+
     def add(*parameters)
       @parameter_groups << SingleYield.new(*parameters)
     end
-    
+
     def multiple_add(*parameter_groups)
       @parameter_groups << MultipleYields.new(*parameter_groups)
     end
-    
+
   end
-  
-end
+
+end

data/lib/mocha_standalone.rb

@@ -1,2 +1,2 @@
 require 'mocha/api'
-require 'mocha/object'
+require 'mocha/object'

data/mocha.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |s|
 
   s.files = `git ls-files`.split("\n") - ["TODO", ".travis.yml", ".gitignore"]
 
-  s.homepage = "http://mocha.rubyforge.org"
+  s.homepage = "http://floehopper.github.com/mocha/"
   s.rdoc_options = ["--title", "Mocha", "--main", "README.rdoc", "--line-numbers"]
   s.require_paths = ["lib"]
   s.rubyforge_project = "mocha"
@@ -29,18 +29,15 @@ Gem::Specification.new do |s|
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_development_dependency("rake", ">= 0")
       s.add_development_dependency("introspection", "~> 0.0.1")
-      s.add_development_dependency("rdoc", "~> 3.1")
-      s.add_development_dependency("coderay", "~> 0.1")
+      s.add_development_dependency("yard")
     else
       s.add_dependency("rake", ">= 0")
       s.add_dependency("introspection", "~> 0.0.1")
-      s.add_dependency("rdoc", "~> 3.1")
-      s.add_dependency("coderay", "~> 0.1")
+      s.add_dependency("yard")
     end
   else
     s.add_dependency("rake", ">= 0")
     s.add_dependency("introspection", "~> 0.0.1")
-    s.add_dependency("rdoc", "~> 3.1")
-    s.add_dependency("coderay", "~> 0.1")
+    s.add_dependency("yard")
   end
 end