assay 0.3.0 → 0.4.0

data/lib/assay/case_assay.rb

@@ -0,0 +1,17 @@
+require_relative 'equality_assay'
+
+# Equality assertion using `#===`, the case equality method.
+#
+class CaseAssay < EqualityAssay
+
+  register :===, :case
+
+  #
+  # Check assertion via `#===` method.
+  #
+  def self.pass?(subject, criterion)
+    subject === criterion
+  end
+
+end
+

data/lib/assay/compare_assay.rb

@@ -0,0 +1,38 @@
+require_relative 'assertion'
+
+# Compare assertion serves primarily as a base class
+# for other more specific comparison assertions.
+#
+# In itself it can be used to test a comparision
+# made by #<=>.
+#
+class CompareAssay < Assertion
+
+  # TODO: What about #cmp alias?
+
+  register :<=>, :compare
+
+  #
+  # Check assertion using `<=>`.
+  #
+  def self.pass?(subject, criterion, result=0)
+    (subject <=> criterion) == result
+  end
+
+  #
+  # Error message for campare assertion.
+  #
+  def self.assert_message(subject, criterion, result=0)
+    a  = subject.inspect
+    b  = criterion.inspect
+    r  = result.inspect
+
+    if a.size > SIZE_LIMIT or b.size > SIZE_LIMIT
+      "a <=> b == #{r}\na) #{a}\nb) #{b}"
+    else
+      "#{a} <=> #{b} == #{r}"
+    end
+  end
+
+end
+

data/lib/assay/core_ext/kernel.rb

@@ -0,0 +1,52 @@
+module Kernel
+
+  # Do two references have the same `#object_id`, and hence are the
+  # same object.
+  #
+  # @param [Object] other
+  #   Any object reference.
+  #
+  def identical?(other)
+    object_id == other.object_id
+  end
+
+  # Ascertain likeness, returns true if any of `equal?`, `eql?`, `==`,
+  # `===` or `=~` evaluate truthfully, either with `self` as the receiver
+  # or `other` as the receiver.
+  #
+  # @todo Should `#=~` be apart of this comparison?
+  #
+  # @param [Object] other
+  #   Any object reference.
+  #
+  # @return [Boolean] +true+ if alike.
+  #
+  def like?(other)
+    self.equal?(other) ||
+    self.eql?(other)   ||
+    self.==(other)     ||
+    self.===(other)    ||
+    self.=~(other)     ||
+    other.equal?(self) ||
+    other.eql?(self)   ||
+    other.==(self)     ||
+    other.===(self)    ||
+    other.=~(self)
+  end
+
+  #
+  def true?
+    TrueClass === self
+  end
+
+  #
+  def false?
+    FalseClass === self
+  end
+
+  #
+  def boolean?
+    true? || false?
+  end
+
+end

data/lib/assay/core_ext/na.rb

@@ -0,0 +1,9 @@
+
+class << NA = ArgumentError.new
+  def inspect ; 'N/A' ; end
+  def method_missing(*); self; end
+end
+
+def __
+  NA
+end

data/lib/assay/directory_assay.rb

@@ -0,0 +1,20 @@
+require_relative 'path_assay'
+
+# Assert the existance of a directory with `File.directory?` call.
+#
+class DirectoryAssay < PathAssay
+
+  register :directory
+
+  #
+  # Check assertion using `File.file?` method.
+  #
+  def self.pass?(path)
+    File.directory?(path)
+  end
+
+end
+
+# I would prefer this name. 
+#FolderAssay = DirectoryAssay
+

data/lib/assay/empty_assay.rb

@@ -0,0 +1,17 @@
+require_relative 'include_assay'
+
+# Empty assertion tests an object with `#empty?` method.
+#
+class EmptyAssay < IncludeAssay
+
+  register :empty
+
+  #
+  # Check assertion with `#empty?`.
+  #
+  def self.pass?(subject)
+    subject.empty?
+  end
+
+end
+

data/lib/assay/equal_assay.rb

@@ -0,0 +1,35 @@
+require_relative 'like_assay'
+
+# EqualAssay coers the assertion comparing two objects with `#==` operator.
+#
+class EqualAssay < LikeAssay
+
+  register :==, :equal
+
+  #
+  # Test assertion of `#==` method.
+  #
+  def self.pass?(subject, criterion)
+    subject == criterion
+  end
+
+  #
+  # Error message for equal assertion.
+  #
+  def self.assert_message(subject, criterion)
+    a = subject.inspect
+    b = criterion.inspect
+  
+    if a.size > SIZE_LIMIT or b.size > SIZE_LIMIT
+      if $ansi
+        d = ANSI::Diff.new(a, b)
+        a, b = d.diff1, d.diff2  # *d.to_a
+      end
+      "a == b\na) #{a}\nb) #{b}"
+    else
+      "#{a} == #{b}"
+    end
+  end
+
+end
+

data/lib/assay/equality_assay.rb

@@ -0,0 +1,18 @@
+require_relative 'equal_assay'
+
+# EqualityAssay defines the assertion for the `#eql?`, the strict
+# equality method.
+#
+class EqualityAssay < EqualAssay
+
+  register :eql
+
+  #
+  # Check assertion via `#eql?` method.
+  #
+  def self.pass?(subject, criterion)
+    subject.eql?(criterion)
+  end
+
+end
+

data/lib/assay/execution_assay.rb

@@ -0,0 +1,59 @@
+require_relative 'assertion'
+
+# Assert that a block of coded executes without error and does
+# not return +nil+ or +false+.
+#
+# NOTE: To test only for successful execution regardless of return value
+# use a negated {RaiseAssay} on the Exception class. But generally 
+# this would be pretty silly, if you think about it, this is exactly
+# what testing is for!
+#
+class ExecutionAssay < Assertion
+
+  register :executes
+
+  #
+  # Check assertion.
+  #
+  def self.pass?(*arguments, &block)
+    begin
+      block.call(*arguments)
+    rescue Exception
+      false
+    end
+  end
+
+  #
+  # Check negated assertion.
+  #
+  def self.fail?(*arguments, &block)
+    begin
+      ! block.call(*arguments)
+    rescue Exception
+      true
+    end
+  end
+
+  #
+  #def self.assert!(*criteria, &block)
+  #  options = (Hash === criteria.last ? criteria.pop : {})
+  #  assay = new(nil, *criteria) #, &block)
+  #  assay.assert!(options, &block)
+  #end
+
+  #
+  #def self.refute!(*criteria, &block)
+  #  options = (Hash === criteria.last ? criteria.pop : {})
+  #  assay = new(nil, *criteria) #, &block)
+  #  assay.refute!(options, &block)
+  #end
+
+  #
+  #
+  #
+  def self.assert_message(*arguments, &block)
+    "#{block}.call(*#{arguments.inspect})"
+  end
+
+end
+

data/lib/assay/false_assay.rb

@@ -0,0 +1,17 @@
+require_relative 'boolean_assay'
+
+# Assert and object if strictly `false`.
+#
+class FalseAssay < BooleanAssay
+
+  register :false
+
+  #
+  # Check assertion.
+  #
+  def self.pass?(subject)
+    subject.false?  #FalseClass === subject
+  end
+
+end
+

data/lib/assay/file_assay.rb

@@ -0,0 +1,17 @@
+require_relative 'path_assay'
+
+# Assert the existance of a file with `File.file?` call.
+#
+class FileAssay < PathAssay
+
+  register :file
+
+  #
+  # Check assertion using `File.file?` method.
+  #
+  def self.pass?(path)
+    File.file?(path)
+  end
+
+end
+

data/lib/assay/identity_assay.rb

@@ -0,0 +1,49 @@
+require_relative 'equality_assay'
+
+# Check that two objects are one and the same object.
+#
+# NOTE: Ruby defines #equal? to mean #identical? but I believe
+# this to be a misnomer, at the very least. So we use the term
+# `identical` instead.
+#
+class IdentityAssay < EqualityAssay
+
+  register :identical
+
+  #
+  # Check assertion using `object_id == object_id`.
+  #
+  def self.pass?(subject, criterion)
+    subject.identical?(criterion)  #subject.object_id == criterion.object_id
+  end
+
+#  #
+#  #
+#  #
+#  def assert_message(subject)
+#    a = subject.inspect
+#    b = criteria.first.inspect
+#
+#    if a.size > SIZE_LIMIT or b.size > SIZE_LIMIT
+#      "a.identical?object_id == b.object.id\na) #{criterion}\nb) #{actual}"
+#    else
+#      "#{criterion}.object_id == #{actual}.object.id"
+#    end
+#  end
+#
+#  #
+#  #
+#  #
+#  def refute_message(subject)
+#    actual    = subject.inspect
+#    criterion = criteria.first.inspect
+#
+#    if actual.size > SIZE_LIMIT or criterion.size > SIZE_LIMIT
+#      "a.object_id != b.object.id\na) #{criterion}\nb) #{actual}"
+#    else
+#      "#{criterion}.object_id != #{actual}.object.id"
+#    end
+#  end
+
+end
+

data/lib/assay/include_assay.rb

@@ -0,0 +1,17 @@
+require_relative 'assertion'
+
+# Assert that a container includes some object.
+#
+class IncludeAssay < Assertion
+
+  register :include
+
+  #
+  # Check assertion using `#include?` method.
+  #
+  def self.pass?(container, member)
+    container.include?(member)
+  end
+
+end
+

data/lib/assay/instance_assay.rb

@@ -0,0 +1,17 @@
+require_relative 'kind_assay'
+
+# Assert that an object is an instance of a class.
+#
+class InstanceAssay < KindAssay
+
+  register :instance_of
+
+  #
+  # Check assertion.
+  #
+  def self.pass?(object, class_type)
+    object.instance_of?(class_type)
+  end
+
+end
+

data/lib/assay/kind_assay.rb

@@ -0,0 +1,18 @@
+require_relative 'assertion'
+
+# Comparison assertion for #kind_of?
+#
+#   KindAssay.pass?(1, Integer)  #=> true
+#   KindAssay.fail?(1, String)   #=> true
+#
+class KindAssay < Assertion
+
+  register :kind_of
+
+  # Check assertion.
+  def self.pass?(object, class_type)
+    object.kind_of?(class_type)
+  end
+
+end
+

data/lib/assay/less_assay.rb

@@ -0,0 +1,18 @@
+require_relative 'compare_assay'
+
+# Compare assertion is used to test a comparision
+# made by `#<`.
+#
+class LessAssay < CompareAssay
+
+  register :<, :less_than
+
+  #
+  # Check assertion.
+  #
+  def self.pass?(subject, criterion)
+    subject < criterion
+  end
+
+end
+

data/lib/assay/less_equal_assay.rb

@@ -0,0 +1,25 @@
+require_relative 'compare_assay'
+
+# Compare assertion is used to test a comparision made by `#<=`.
+#
+# NOTE: We are taking some leeway here with the name of this class,
+# which ordinarily would be called `LesserThanOrEqualAssay`.
+# However, such a name is a bit winded. The shortest name then,
+# without resorting to abbreviations, is _less-equal_, a monosyllabic
+# reading of the operator itself. Since it is ordinarily meaningless
+# to say something is "more equal" than something else, why not allow
+# it to be meaningful and save ourselves all that uneccessary verbage?
+#
+class LessEqualAssay < CompareAssay
+
+  register :<=, :less_equal
+
+  #
+  # Check assertion.
+  #
+  def self.pass?(subject, criterion)
+    subject <= criterion
+  end
+
+end
+