caricature 0.7.6 → 0.7.7

data/lib/caricature/core_ext/string.rb

@@ -1,17 +1,17 @@
-class String
-
-  # converts a camel cased word to an underscored word
-  def underscore
-    self.gsub(/::/, '/').
-        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-        gsub(/([a-z\d])([A-Z])/,'\1_\2').
-        tr("-", "_").
-        downcase
-  end
-
-  # Gets the constant when it is defined that corresponds to this string
-  def classify
-    Object.const_get self
-  end
-  
+class String
+
+  # converts a camel cased word to an underscored word
+  def underscore
+    self.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+  end
+
+  # Gets the constant when it is defined that corresponds to this string
+  def classify
+    Object.const_get self
+  end
+  
 end

data/lib/caricature/core_ext/system/string.rb

@@ -1,21 +1,21 @@
-module System
-
-  class String
-
-    # converts a camel cased word to an underscored word
-    def underscore
-      self.gsub(/::/, '/').
-        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-        gsub(/([a-z\d])([A-Z])/,'\1_\2').
-        tr("-", "_").
-        downcase
-    end
-
-    # Gets the constant when it is defined that corresponds to this string
-    def classify
-      Object.const_get self
-    end
-    
-  end
-  
+module System
+
+  class String
+
+    # converts a camel cased word to an underscored word
+    def underscore
+      self.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+
+    # Gets the constant when it is defined that corresponds to this string
+    def classify
+      Object.const_get self
+    end
+    
+  end
+  
 end

data/lib/caricature/core_ext/system/type.rb

@@ -1,27 +1,27 @@
-module System
-
-  class Type
-
-    # collects all the methods defined on an interface and its parents
-    def collect_interface_methods
-      iface_methods = []
-      iface_methods += self.get_interfaces.collect { |t| t.collect_interface_methods }
-      self.get_methods + iface_methods.flatten
-    end
-
-    # collects the properties defined on an interface an its parents
-    def collect_interface_properties
-      iface_properties = []
-      iface_properties += self.get_interfaces.collect { |t| t.collect_interface_properties }
-      self.get_properties + iface_properties.flatten
-    end
-
-    def collect_interface_events
-      iface_events = []
-      iface_events += self.get_interfaces.collect { |t| t.collect_interface_events }
-      self.get_events + iface_events.flatten.uniq
-    end
-
-  end
-
+module System
+
+  class Type
+
+    # collects all the methods defined on an interface and its parents
+    def collect_interface_methods
+      iface_methods = []
+      iface_methods += self.get_interfaces.collect { |t| t.collect_interface_methods }
+      self.get_methods + iface_methods.flatten
+    end
+
+    # collects the properties defined on an interface an its parents
+    def collect_interface_properties
+      iface_properties = []
+      iface_properties += self.get_interfaces.collect { |t| t.collect_interface_properties }
+      self.get_properties + iface_properties.flatten
+    end
+
+    def collect_interface_events
+      iface_events = []
+      iface_events += self.get_interfaces.collect { |t| t.collect_interface_events }
+      self.get_events + iface_events.flatten.uniq
+    end
+
+  end
+
 end

data/lib/caricature/descriptor.rb

@@ -1,74 +1,74 @@
-module Caricature
-
-  # Describes a class/type so it can be proxied more easily
-  # This is the base class from which other more specialised descriptors can be
-  # used to provide the metadata need to generate the proxy classes
-  class TypeDescriptor
-
-    # Gets the instance members of the described type/class
-    attr_reader :instance_members
-
-    # Gets the class members for the described type/class
-    attr_reader :class_members
-
-    # initializes a new instance of a type descriptor
-    def initialize(klass)
-      @instance_members = []
-      @class_members = []
-
-      unless klass == :in_unit_test_for_class
-        initialize_instance_members_for klass
-        initialize_class_members_for klass
-      end
-    end
-
-    # collects the instance members of the provided type
-    def initialize_instance_members_for(klass)
-      raise NotImplementedError.new("Override in implementing class")
-    end
-
-    # collects the class members of the provided type
-    def initialize_class_members_for(klass)
-      raise NotImplementedError.new("Override in implementing class")
-    end
-  end
-
-  # Describes a member of a class
-  # this contains the metadata needed to generate the member
-  # and perhaps a default value for the property type if necessary
-  class MemberDescriptor
-
-    # the return type of this member
-    attr_reader :return_type
-
-    # the name of this member
-    attr_reader :name
-
-    # initializes a nem instance of member descriptor
-    def initialize(name, return_type=nil, is_instance_member=true)
-      @name, @return_type, @instance_member = name, return_type, is_instance_member
-    end
-
-    # indicates whether this member is a class member or an instance member
-    def instance_member?
-      @instance_member
-    end
-
-  end
-
-  # Describes a ruby object.
-  class RubyObjectDescriptor < TypeDescriptor
-
-    # collects all the members that are defined by this class
-    def initialize_instance_members_for(klass)
-      @instance_members += (klass.instance_methods - Object.instance_methods).collect { |mn| MemberDescriptor.new(mn) }
-    end
-
-    # collects all the members that aren't a member of Object.singleton_methods
-    def initialize_class_members_for(klass)
-      @class_members += klass.methods(false).collect { |mn| MemberDescriptor.new(mn) }
-    end
-
-  end  
-
+module Caricature
+
+  # Describes a class/type so it can be proxied more easily
+  # This is the base class from which other more specialised descriptors can be
+  # used to provide the metadata need to generate the proxy classes
+  class TypeDescriptor
+
+    # Gets the instance members of the described type/class
+    attr_reader :instance_members
+
+    # Gets the class members for the described type/class
+    attr_reader :class_members
+
+    # initializes a new instance of a type descriptor
+    def initialize(klass)
+      @instance_members = []
+      @class_members = []
+
+      unless klass == :in_unit_test_for_class
+        initialize_instance_members_for klass
+        initialize_class_members_for klass
+      end
+    end
+
+    # collects the instance members of the provided type
+    def initialize_instance_members_for(klass)
+      raise NotImplementedError.new("Override in implementing class")
+    end
+
+    # collects the class members of the provided type
+    def initialize_class_members_for(klass)
+      raise NotImplementedError.new("Override in implementing class")
+    end
+  end
+
+  # Describes a member of a class
+  # this contains the metadata needed to generate the member
+  # and perhaps a default value for the property type if necessary
+  class MemberDescriptor
+
+    # the return type of this member
+    attr_reader :return_type
+
+    # the name of this member
+    attr_reader :name
+
+    # initializes a nem instance of member descriptor
+    def initialize(name, return_type=nil, is_instance_member=true)
+      @name, @return_type, @instance_member = name, return_type, is_instance_member
+    end
+
+    # indicates whether this member is a class member or an instance member
+    def instance_member?
+      @instance_member
+    end
+
+  end
+
+  # Describes a ruby object.
+  class RubyObjectDescriptor < TypeDescriptor
+
+    # collects all the members that are defined by this class
+    def initialize_instance_members_for(klass)
+      @instance_members += (klass.instance_methods - Object.instance_methods).collect { |mn| MemberDescriptor.new(mn) }
+    end
+
+    # collects all the members that aren't a member of Object.singleton_methods
+    def initialize_class_members_for(klass)
+      @class_members += klass.methods(false).collect { |mn| MemberDescriptor.new(mn) }
+    end
+
+  end  
+
 end

data/lib/caricature/expectation.rb

@@ -1,264 +1,265 @@
-module Caricature
-
-  # A collection of expectations with some methods to make it easier to work with them.
-  # It allows you to add and find expectations based on certain criteria.
-  class Expectations
-
-    #initializes a new empty instance of the +Expectation+ collection
-    def initialize
-      @instance_expectations = []
-      @class_expectations = []
-    end
-
-    # Adds an expectation to this collection. From then on it can be found in the collection.
-    def add_expectation(expectation, mode=:instance)
-      @instance_expectations << expectation unless mode == :class
-      @class_expectations << expectation if mode == :class
-    end
-
-    # Finds an expectation in the collection. It matches by +method_name+ first.
-    # Then it tries to figure out if you care about the arguments. You can say you don't care by providing
-    # the symbol +:any+ as first argument to this method. When you don't care the first match is being returned
-    # When you specify arguments other than +:any+ it will try to match the specified arguments in addition
-    # to the method name. It will then also return the first result it can find.
-    def find(method_name, mode=:instance, *args)
-      expectations = mode == :class ? @class_expectations : @instance_expectations
-
-      candidates = expectations.select { |exp| exp.method_name.to_s.underscore =~ /#{method_name}|#{method_name.to_s.underscore}/ }
-      with_arguments_candidates = candidates.select { |exp| exp.args == args }
-      
-      with_arguments_candidates.first || candidates.select { |exp| exp.any_args?  }.first
-    end
-
-  end
-
-  # contains the syntax for building up an expectation
-  # This is shared between the +ExpecationBuilder+ and the +Expectation+
-  module ExpectationSyntax
-    
-    # tell the expection which arguments it needs to respond to
-    # there is a magic argument here +any+ which configures
-    # the expectation to respond to any arguments
-    def with(*ags, &b)
-      collected[:any_args] = ags.first.is_a?(Symbol) and ags.first == :any
-      collected[:args] = ags   
-      collected[:callback] = b unless b.nil?
-      self
-    end
-
-    # tell the expectation it nees to return this value or the value returned by the block
-    # you provide to this method.
-    def return(value=nil, &b)
-      collected[:return_value] = value
-      collected[:return_callback] = b if b
-      self
-    end
-
-    # Sets up arguments for the block that is being passed into the isolated method call
-    def pass_block(*ags, &b)
-      collected[:any_block_args] = ags.first.is_a?(Symbol) and args.first == :any
-      collected[:block_args] = ags
-      collected[:block_callback] = b unless b.nil?
-      self
-    end
-
-    # tell the expectation it needs to raise an error with the specified arguments
-    alias_method :actual_raise, :raise
-    def raise(*args)
-      collected[:error_args] = args
-      self
-    end
-    
-    # tell the expecation it needs to call the super before the expectation exectution
-    def super_before(&b)
-      collected[:super] = :before
-      collected[:block] = b if b
-      self
-    end
-    
-    # tell the expectation it needs to call the super after the expecation execution
-    def super_after(&b)
-      collected[:super] = :after
-      collected[:block] = b if b
-      self
-    end
-
-    # indicates whether this expectation should match with any arguments
-    # or only for the specified arguments
-    def any_args?
-      collected[:any_args]
-    end
-    
-    
-    private
-    
-      def collected
-        @collected ||= {}
-      end
-  end
-
-  # A description of an expectation.
-  # An expectation has the power to call the proxy method or completely ignore it
-  class Expectation
-
-    include ExpectationSyntax
-
-    # the error_args that this expectation will raise an error with
-    def error_args
-      collected[:error_args]
-    end
-
-    # the value that this expecation will return when executed
-    def return_value
-      collected[:return_value]
-    end
-
-    # indicator for the mode to call the super +:before+, +:after+ and +nil+
-    def super 
-      collected[:super]
-    end  
-
-    # contains the callback if one is given
-    def callback
-      collected[:callback]
-    end
-
-    # contains the callback that is used to return the value when this expectation
-    # is executed
-    def return_callback
-      collected[:return_callback]
-    end
-
-    # contains the arguments that will be passed on to the block
-    def block_args
-      collected[:block_args]
-    end
-
-    # The block that will be used as value provider for the block in the method
-    def block_callback
-      collected[:block_callback]
-    end
-
-    # the block that will be used
-    def block
-      collected[:block]
-    end
-    
-    # sets the block callback 
-    def block=(val)
-      collected[:block] = val
-    end
-    
-    # gets the method_name to which this expectation needs to listen to
-    def method_name 
-      collected[:method_name]
-    end
-    
-    # the arguments that this expectation needs to be constrained by
-    def args
-      collected[:args]
-    end
-    
-    # Initializes a new instance of an expectation
-    def initialize(options={})
-      collected[:any_args] = true
-      collected.merge!(options)
-    end
-    
-    # indicates whether this expecation will raise an event.
-    def has_error_args?
-      !collected[:error_args].nil?
-    end
-
-    # indicates whether this expectation will return a value.
-    def has_return_value?
-      !collected[:return_value].nil?
-    end
-
-    # call the super before the expectation
-    def super_before?
-      collected[:super] == :before
-    end
-
-    # indicates whether super needs to be called somewhere
-    def call_super?
-      !collected[:super].nil?
-    end      
-    
-    # indicates whether this expecation has a callback it needs to execute
-    def has_callback? 
-      !collected[:callback].nil?
-    end
-    
-    # indicates whether this expectation has a block as value provider for the method call block
-    def has_block_callback?
-      !collected[:block_callback].nil?
-    end
-
-    # a flag to indicate it has a return value callback
-    def has_return_callback?
-      !collected[:return_callback].nil?
-    end
-    
-    # executes this expectation with its configuration
-    def execute(*margs,&b)
-      ags = any_args? ? :any : (margs.empty? ? collected[:args] : margs)
-      do_raise_error
-      do_callback(ags)
-      do_block_callback(&b)
-      do_event_raise if respond_to?(:events)
-
-      return collected[:return_callback].call(*margs) if has_return_callback?
-      return return_value if has_return_value? 
-      nil
-    end
-
-    def to_s #:nodoc:
-      "<Caricature::Expecation, method_name: #{method_name}, args: #{args}, error args: #{error_args}>"
-    end
-    alias :inspect :to_s
-    
-    
-    private 
-    
-    def do_raise_error #:nodoc:
-      actual_raise *collected[:error_args] if has_error_args?
-    end
-    
-    def do_callback(ags) #:nodoc:
-      callback.call(*ags) if has_callback?
-    end
-    
-    def do_block_callback(&b) #:nodoc:
-      if b
-        ags = has_block_callback? ? collected[:block_callback].call : collected[:block_args]
-        b.call(*ags)
-      end
-    end
-    
-    
-  end
-
-  # Constructs the expecation object.
-  # Used as a boundary between the definition and usage of the expectation
-  class ExpectationBuilder
-
-    include ExpectationSyntax
-
-    # initialises a new instance of the expectation builder
-    # this builder is passed into the block to allow only certain
-    # operations in the block.
-    def initialize(method_name)
-      @collected = { :method_name => method_name, :args => [], :any_args => true }
-    end
-
-
-
-    # build up the expectation with the provided arguments
-    def build
-      Expectation.new collected
-    end
-
-  end
-
+module Caricature
+
+  # A collection of expectations with some methods to make it easier to work with them.
+  # It allows you to add and find expectations based on certain criteria.
+  class Expectations
+
+    #initializes a new empty instance of the +Expectation+ collection
+    def initialize
+      @instance_expectations = []
+      @class_expectations = []
+    end
+
+    # Adds an expectation to this collection. From then on it can be found in the collection.
+    def add_expectation(expectation, mode=:instance)
+      @instance_expectations << expectation unless mode == :class
+      @class_expectations << expectation if mode == :class
+    end
+
+    # Finds an expectation in the collection. It matches by +method_name+ first.
+    # Then it tries to figure out if you care about the arguments. You can say you don't care by providing
+    # the symbol +:any+ as first argument to this method. When you don't care the first match is being returned
+    # When you specify arguments other than +:any+ it will try to match the specified arguments in addition
+    # to the method name. It will then also return the first result it can find.
+    def find(method_name, mode=:instance, *args)
+      expectations = mode == :class ? @class_expectations : @instance_expectations
+
+      candidates = expectations.select { |exp| exp.method_name.to_s.underscore =~ /#{method_name}|#{method_name.to_s.underscore}/ }
+      with_arguments_candidates = candidates.select { |exp| exp.args == args }
+      
+      with_arguments_candidates.first || candidates.select { |exp| exp.any_args?  }.first
+    end
+
+  end
+
+  # contains the syntax for building up an expectation
+  # This is shared between the +ExpecationBuilder+ and the +Expectation+
+  module ExpectationSyntax
+    
+    # tell the expection which arguments it needs to respond to
+    # there is a magic argument here +any+ which configures
+    # the expectation to respond to any arguments
+    def with(*ags, &b)
+      collected[:any_args] = ags.first.is_a?(Symbol) and ags.first == :any
+      collected[:args] = ags   
+      collected[:callback] = b unless b.nil?
+      self
+    end
+
+    # tell the expectation it nees to return this value or the value returned by the block
+    # you provide to this method.
+    def return(value=nil, &b)
+      collected[:return_value] = value
+      collected[:return_callback] = b if b
+      self
+    end
+    alias_method :returns, :return
+
+    # Sets up arguments for the block that is being passed into the isolated method call
+    def pass_block(*ags, &b)
+      collected[:any_block_args] = ags.first.is_a?(Symbol) and args.first == :any
+      collected[:block_args] = ags
+      collected[:block_callback] = b unless b.nil?
+      self
+    end
+
+    # tell the expectation it needs to raise an error with the specified arguments
+    alias_method :actual_raise, :raise
+    def raise(*args)
+      collected[:error_args] = args
+      self
+    end
+    
+    # tell the expecation it needs to call the super before the expectation exectution
+    def super_before(&b)
+      collected[:super] = :before
+      collected[:block] = b if b
+      self
+    end
+    
+    # tell the expectation it needs to call the super after the expecation execution
+    def super_after(&b)
+      collected[:super] = :after
+      collected[:block] = b if b
+      self
+    end
+
+    # indicates whether this expectation should match with any arguments
+    # or only for the specified arguments
+    def any_args?
+      collected[:any_args]
+    end
+    
+    
+    private
+    
+      def collected
+        @collected ||= {}
+      end
+  end
+
+  # A description of an expectation.
+  # An expectation has the power to call the proxy method or completely ignore it
+  class Expectation
+
+    include ExpectationSyntax
+
+    # the error_args that this expectation will raise an error with
+    def error_args
+      collected[:error_args]
+    end
+
+    # the value that this expecation will return when executed
+    def return_value
+      collected[:return_value]
+    end
+
+    # indicator for the mode to call the super +:before+, +:after+ and +nil+
+    def super 
+      collected[:super]
+    end  
+
+    # contains the callback if one is given
+    def callback
+      collected[:callback]
+    end
+
+    # contains the callback that is used to return the value when this expectation
+    # is executed
+    def return_callback
+      collected[:return_callback]
+    end
+
+    # contains the arguments that will be passed on to the block
+    def block_args
+      collected[:block_args]
+    end
+
+    # The block that will be used as value provider for the block in the method
+    def block_callback
+      collected[:block_callback]
+    end
+
+    # the block that will be used
+    def block
+      collected[:block]
+    end
+    
+    # sets the block callback 
+    def block=(val)
+      collected[:block] = val
+    end
+    
+    # gets the method_name to which this expectation needs to listen to
+    def method_name 
+      collected[:method_name]
+    end
+    
+    # the arguments that this expectation needs to be constrained by
+    def args
+      collected[:args]
+    end
+    
+    # Initializes a new instance of an expectation
+    def initialize(options={})
+      collected[:any_args] = true
+      collected.merge!(options)
+    end
+    
+    # indicates whether this expecation will raise an event.
+    def has_error_args?
+      !collected[:error_args].nil?
+    end
+
+    # indicates whether this expectation will return a value.
+    def has_return_value?
+      !collected[:return_value].nil?
+    end
+
+    # call the super before the expectation
+    def super_before?
+      collected[:super] == :before
+    end
+
+    # indicates whether super needs to be called somewhere
+    def call_super?
+      !collected[:super].nil?
+    end      
+    
+    # indicates whether this expecation has a callback it needs to execute
+    def has_callback? 
+      !collected[:callback].nil?
+    end
+    
+    # indicates whether this expectation has a block as value provider for the method call block
+    def has_block_callback?
+      !collected[:block_callback].nil?
+    end
+
+    # a flag to indicate it has a return value callback
+    def has_return_callback?
+      !collected[:return_callback].nil?
+    end
+    
+    # executes this expectation with its configuration
+    def execute(*margs,&b)
+      ags = any_args? ? :any : (margs.empty? ? collected[:args] : margs)
+      do_raise_error
+      do_callback(ags)
+      do_block_callback(&b)
+      do_event_raise if respond_to?(:events)
+
+      return collected[:return_callback].call(*margs) if has_return_callback?
+      return return_value if has_return_value? 
+      nil
+    end
+
+    def to_s #:nodoc:
+      "<Caricature::Expecation, method_name: #{method_name}, args: #{args}, error args: #{error_args}>"
+    end
+    alias :inspect :to_s
+    
+    
+    private 
+    
+    def do_raise_error #:nodoc:
+      actual_raise *collected[:error_args] if has_error_args?
+    end
+    
+    def do_callback(ags) #:nodoc:
+      callback.call(*ags) if has_callback?
+    end
+    
+    def do_block_callback(&b) #:nodoc:
+      if b
+        ags = has_block_callback? ? collected[:block_callback].call : collected[:block_args]
+        b.call(*ags)
+      end
+    end
+    
+    
+  end
+
+  # Constructs the expecation object.
+  # Used as a boundary between the definition and usage of the expectation
+  class ExpectationBuilder
+
+    include ExpectationSyntax
+
+    # initialises a new instance of the expectation builder
+    # this builder is passed into the block to allow only certain
+    # operations in the block.
+    def initialize(method_name)
+      @collected = { :method_name => method_name, :args => [], :any_args => true }
+    end
+
+
+
+    # build up the expectation with the provided arguments
+    def build
+      Expectation.new collected
+    end
+
+  end
+
 end