assay 0.3.0 → 0.4.0

data/lib/assay/assertion.rb

@@ -1,149 +1,123 @@
-require 'ansi/diff'
-require 'assay/matcher'
+require 'brass'
 
-module Assay
+require_relative 'core_ext/na'
+require_relative 'core_ext/kernel'
 
-  #
-  class Assertion < Exception
+require_relative 'assertor'
+require_relative 'assertable'
 
-    # When displaying errors, use this as a rule of thumb
-    # for determining when the inspected object will be too
-    # big for a single line message.
-    SIZE_LIMIT = 13
+# TODO: Don't care for Proc === subject conditional code, but not
+# sure how else to deal with lambda subjects.
 
-    # Returns Matcher for the failure class.
-    def self.to_matcher(*args, &blk)
-      Matcher.new(self, *args, &blk)
-    end
+# Base class for all Assay classes. This class defines all the logic
+# for assertions as exception classes as well as test assertion matchers.
+#
+class Assertion < Exception
 
-    #
-    def self.assertable_method
-      "assert_#{assertion_name}"
-    end
+  extend Assay::Assertable
 
-    #
-    def self.assert(*args, &blk)
-      opts = Hash === args.last ? args.pop : {}
-
-      backtrace = opts[:backtrace] || caller
-      message   = opts[:message]
-
-      err = new(message, *args, &blk)
-      err.set_backtrace(backtrace)
-      err.assert
-
-      #chk  = check(*args, &blk)
-      #msg  = fail_message(*args, &blk)
-      #if !chk
-      #  msg = opts[:message]
-      #  btr = opts[:backtrace] || caller
-      #  err = new(msg, *args)
-      #  err.set_backtrace(btr)
-      #  fail err
-      #end
-    end
+  #
+  # When displaying errors, use this as a rule of thumb
+  # for determining when the inspected object will be too
+  # big for a single line message.
+  #
+  SIZE_LIMIT = 13
 
-    #
-    def self.refute(*args, &blk)
-      opts = Hash === args.last ? args.pop : {}
-
-      backtrace = opts[:backtrace] || caller
-      message   = opts[:message]
-
-      err = new(message, *args, &blk)
-      err.set_backtrace(backtrace)
-      err.refute
-
-      #opts = Hash === args.last ? args.pop : {}
-      #chk  = check!(*args, &blk)
-      ##msg  = fail_message!(*args, &blk)
-      #if !chk
-      #  msg = opts[:message]
-      #  btr = opts[:backtrace] || caller
-      #  err = new(msg, :backtrace=>btr, :arguments=>args)
-      #  fail err
-      #end
-    end
+  #
+  # Each new subclass must call the +register+ method. This is not an option!
+  # The method must be called in order to add the class to the Assertion
+  # name and operator indicies, so they might be looked-up efficiently by
+  # other libraries.
+  #
+  def self.register(op, name=nil)
+    case op.to_s
+    when /\W/
+      @operator = op.to_sym
+      @assertive_name = name.to_sym if name
+    else
+      @operator = (op.to_s + '?').to_sym
+      @assertive_name = op.to_sym
+    end
+
+    operator_index[operator]   = self
+    name_index[assertive_name] = self
+  end
 
-    #
-    def self.pass?(*args, &blk)
-      raise NotImplementedError
-    end
+  #
+  # When Assertion is inherited, a list of all Assertion subclasses is kept.
+  # This can be used to assertions frameworks with dynamic implementations.
+  #
+  def self.inherited(base)
+    @@by_operator = nil
+    @@by_name     = nil
+    subclasses << base
+  end
 
-    #
-    def self.fail?(*args, &blk)
-      ! pass?(*args, &blk)
-    end
+  #
+  # List of all subclasses of Assertion.
+  #
+  def self.subclasses
+    @@subclasses ||= []
+  end
+
+  #
+  # If operator is not given, returns a hash table of assertion classes
+  # indexed by operator.
+  #
+  def self.by_operator(operator=nil)
+    return operator_index.dup unless operator
+    operator_index[operator.to_sym]
+  end
 
-    #
-    def initialize(message=nil, *arguments, &block)
-      message ? super(message % arguments) : super()
+  #
+  # If operator is not given, returns a hash table of assertion classes
+  # indexed by assertive name.
+  #
+  def self.by_name(name=nil)
+    return name_index.dup unless name
+    name_index[name.to_sym]
+  end
 
-      @mesg      = message  # why isn't this in @mesg from super()?
-      @arguments = arguments
-      @block     = block
+  private
 
-      #set_arguments options[:arguments] if options[:arguments]
-      #set_negative  options[:negated]   if options[:negated]
-      #set_backtrace options[:backtrace] if options[:backtrace]
+    def self.operator_index
+      @@operator_index ||= {}
     end
 
-    # Failure is always a type of assertion.
-    #
-    # This method allows Assay's classes to work in any test framework
-    # that supports this interface.
-    def assertion?
-      true  # @assertion = true if @assertion.nil?
+    def self.name_index
+      @@name_index ||= {}
     end
 
-    #
-    def pass?
-      self.class.pass?(*@arguments, &@block) #^ @negative
-    end
+  #
+  # Setup new Assertion object.
+  #
+  def initialize(msg=nil) #, *criteria, &block)
+    super(msg)
 
-    #
-    def fail?
-      not pass?
-    end
+    #@criteria  = criteria
+    #@block     = block
+    #@not       = false
 
-    #
-    def assert
-      #@negative = false
-      raise self unless pass?
-    end
+    @assertion = true
 
-    #
-    def refute
-      #@negative = true
-      raise self unless fail?
-    end
+    #options = (Hash === criteria.last ? criteria.pop : {})
+    #set_backtrace(options[:backtrace]) if options[:backtrace]
+    #set_negative(options[:negated])    if options[:negated]
+  end
 
-    #
-    def negative?
-      @negative
-    end
+end
 
-    # Set whether this failure was the inverse of it's normal meaning.
-    # For example, `!=` rather than `==`.
-    def set_negative(negative)
-      @negative = !!negative
-    end
 
-    # Set arguments used to make assertion.
-    def set_arguments(arguments)
-      @arguments = arguments
-      #@block    = block
-    end
+=begin
 
-    #
-    def to_s
-      if @negative
-        "NOT " + super()
-      else
-        super()
-      end
-    end
+  #
+  #def to_s
+  #  #if @negative
+  #  #  "NOT " + super()
+  #  #else
+  #    super()
+  #  #end
+  #end
 
-  end
+=end
 
-end

data/lib/assay/assertor.rb

@@ -0,0 +1,187 @@
+module Assay
+
+  # Assertor delegates to Assay class. It provides an object-oriented
+  # interface to makeing assertions, as opposed to the functional
+  # interface of the Assay classes themselves.
+  #
+  class Assertor
+
+    #
+    #
+    def initialize(assay_class, *criteria, &block)
+      @assay    = assay_class
+      @criteria = criteria
+      @block    = block
+      @not      = false
+    end
+
+    #
+    # The assay class to which this assertor delegates.
+    #
+    attr :assay
+
+    #
+    # The criteria for applying the assertor.
+    #
+    attr :criteria
+
+    #
+    # Block criterion.
+    #
+    attr :block
+
+    #    
+    # Is the assertor negated?
+    #
+    def not?
+      @not
+    end
+
+    #
+    #
+    def pass?(subject, &block)
+      arguments, block = complete_criteria(subject, &block)
+      @not ^ @assay.pass?(*arguments, &block)
+    end
+
+    #
+    #
+    def fail?(subject, &block)
+      arguments, block = complete_criteria(subject, &block)
+      @not ^ @assay.fail?(*arguments, &block)
+    end
+
+    #
+    #
+    def assert!(subject, &block)
+      # technically this needs to be controlled by the assay class
+      if block.nil? && Proc === subject
+        block   = subject
+        subject = NA
+      end
+
+      arguments, block = complete_criteria(subject, &block)
+
+      if @not
+        @assay.refute!(*arguments, &block)
+      else
+        @assay.assert!(*arguments, &block)
+      end
+    end
+
+    #
+    #
+    def refute!(subject, &block)
+      # technically this needs to be controlled by the assay class
+      if block.nil? && Proc === subject
+        block   = subject
+        subject = NA
+      end
+
+      arguments, block = complete_criteria(subject, &block)
+
+      if @not
+        @assay.assert!(*arguments, &block)
+      else
+        @assay.refute!(*arguments, &block)
+      end
+    end
+
+    alias_method :==, :pass?
+    alias_method :!=, :fail?
+
+    alias_method :=~, :assert!
+    alias_method :!~, :refute!
+
+    alias_method :===, :assert!
+
+    #
+    # Create a negated form of the matcher.
+    #
+    # @todo Should this be @! method instead?
+    #
+    def !@
+      dup.negate!
+    end
+
+    #
+    # Create a negated form of the matcher.
+    #
+    # @todo Best name for this method?
+    #
+    def not
+      dup.negate!
+    end
+
+    #
+    # Assertion message. This is only used by RSpec compatibility methods.
+    #
+    def assert_message(subject, &block)
+      arguments, block = complete_criteria(subject, &block)
+      @assay.assert_message(*arguments, &block)
+    end
+
+    #
+    # Refutation message. This is only used by RSpec compatibility methods.
+    #
+    def refute_message(subject, &block)
+      arguments, block = complete_criteria(subject, &block)
+      @assay.refute_message(*arguments, &block)
+    end
+
+    # The following methods allow Assay objects to work as RSpec matchers.
+
+    # For RSpec matcher compatability.
+    alias matches? pass?
+
+    # For RSpec matcher compatability.
+    alias does_not_match? fail?
+
+    # For RSpec matcher compatability.
+    alias failure_message_for_should assert_message
+
+    # For RSpec matcher compatability.
+    alias failure_message_for_should_not refute_message
+
+    ##
+    ## Returns Assay instance.
+    ##
+    #def exception(subject, msg=nil)
+    #  @assay.new(msg || message, subject, *criteria, &block)
+    #  #  :negated   => options[:negated],
+    #  #  :backtrace => options[:backtrace] || caller,
+    #end
+
+  protected
+
+    #
+    # Toggle the `@not` flag.
+    #
+    def negate!
+      @not = !@not
+      self
+    end
+
+  private
+
+    #
+    #
+    #
+    def complete_criteria(subject, &block)
+      block = block || @block
+
+      return @criteria, block if subject == NA
+
+      if i = @criteria.index(NA)
+        args = @criteria[0...i] + [subject] + @criteria[i+1..-1]
+      else
+        args = [subject] + @criteria
+      end
+
+      return args, block
+    end
+
+  end
+
+end
+

data/lib/assay/boolean_assay.rb

@@ -0,0 +1,15 @@
+require_relative 'assertion'
+
+class BooleanAssay < Assertion
+
+  register :boolean
+
+  #
+  # Check assertion.
+  #
+  def self.pass?(subject)
+    subject.true? || subject.false?  # TODO: Kernel#boolean? method
+  end
+
+end
+