dfect 1.1.0 → 2.0.0

data/lib/dfect/auto.rb

@@ -2,10 +2,6 @@
 #
 # Simply require() this file and Dfect will be available for use anywhere
 # in your program and will execute all tests before your program exits.
-#--
-# Copyright protects this work.
-# See LICENSE file for details.
-#++
 
 require 'dfect'
 
@@ -17,8 +13,8 @@ at_exit do
   Dfect.run
 
   # reflect number of failures in exit status
-  stats = Dfect.report[:statistics]
-  fails = stats[:failed_assertions] + stats[:uncaught_exceptions]
+  stats = Dfect.report[:stats]
+  fails = stats[:fail] + stats[:error]
 
   exit [fails, 255].min
 end

data/lib/dfect/inochi.rb

@@ -0,0 +1,48 @@
+module Dfect
+
+  INSTDIR = File.expand_path('../../..', __FILE__)
+
+  # load inochi configuration
+  inochi_file = __FILE__.sub(/rb$/, 'yaml')
+  begin
+
+    configs = File.open(inochi_file) do |f|
+      require 'yaml'
+      YAML.load_stream(f).documents
+    end
+
+    INOCHI = configs.shift.to_hash
+    INOCHI[:runtime] ||= {}
+    INOCHI[:devtime] ||= {}
+
+    INOCHI2 = (configs.shift || {}).to_hash
+
+  rescue => error
+    error.message.insert 0,
+      "Could not load Inochi configuration file: #{inochi_file.inspect}\n"
+    raise error
+  end
+
+  # make values available as constants
+  INOCHI.each do |param, value|
+    const_set param.to_s.upcase, value
+  end
+
+  def self.inspect
+    "#{PROJECT} #{VERSION} (#{RELEASE})"
+  end
+
+  # establish gem version dependencies
+  if respond_to? :gem
+    [:runtime, :devtime].each do |key|
+      INOCHI[key].each do |gem_name, gem_version|
+        begin
+          gem gem_name, *Array(gem_version)
+        rescue LoadError => error
+          warn "#{inspect} #{key}: #{error}"
+        end
+      end
+    end
+  end
+
+end

data/lib/dfect/inochi.yaml

@@ -0,0 +1,75 @@
+--- # information about your project -----------------------------------------
+
+# Name of your project.
+:project: Dfect
+
+# Name of your project when packaged as a directory.
+:package: dfect
+
+# Name of Ruby module that namespaces your project.
+:library: Dfect
+
+# A short, single-line description of your project.
+:tagline: Assertion testing library for Ruby
+
+# Address of your project's published website.
+:website: http://snk.tuxfamily.org/lib/dfect/
+
+# A list of the core developers of your project.
+#
+# :authors:
+#   - An Example <an@example.com>  # with email
+#   - Another Example              # without email
+#
+:authors:
+  - Suraj N. Kurapati <sunaku@gmail.com>
+
+# Number of the current release of your project.
+:version: 2.0.0
+
+# Date of the current release of your project.
+:release: 2010-03-21
+
+# A list of gems required by your project during runtime.
+#
+# :runtime:
+#   # your project needs exactly version 1.2.3 of the "an_example" gem
+#   an_example: 1.2.3
+#
+#   # your project needs at least version 1.2 (but not
+#   # version 1.2.4 or newer) of the "another_example" gem
+#   another_example: [ >= 1.2 , < 1.2.4 ]
+#
+#   # your project needs any version of the "yet_another_example" gem
+#   yet_another_example:
+#
+:runtime:
+
+# A list of gems required by your project during development.
+#
+# :devtime:
+#   # your project needs exactly version 1.2.3 of the "an_example" gem
+#   an_example: 1.2.3
+#
+#   # your project needs at least version 1.2 (but not
+#   # version 1.2.4 or newer) of the "another_example" gem
+#   another_example: [ >= 1.2 , < 1.2.4 ]
+#
+#   # your project needs any version of the "yet_another_example" gem
+#   yet_another_example:
+#
+:devtime:
+
+--- # parameters for the `inochi` command ------------------------------------
+
+# Location where project documentation will be uploaded by `inochi pub:doc`.
+:pub_doc_target: ~/www/lib/dfect/
+
+# Options for the `rsync` command used to upload your project's documentation.
+:pub_doc_options: --verbose --compress --archive --update --delete
+
+# Path to YAML file containing login information for publishing announcements.
+:pub_ann_logins: ~/.config/inochi/pub_ann_logins.yaml
+
+# Your project's unique identifier in the RAA (Ruby Application Archive).
+:pub_ann_raa_id: dfect

data/lib/dfect/mini.rb

@@ -1,14 +1,10 @@
 # MiniTest emulation layer.
-#--
-# Copyright protects this work.
-# See LICENSE file for details.
-#++
 
 require 'dfect'
 require 'dfect/unit'
 require 'dfect/spec'
 
-module Kernel
+module Dfect
   instance_methods(false).each do |meth|
     if meth =~ /^assert_not/
       alias_method 'refute' + $', meth

data/lib/dfect/spec.rb

@@ -1,18 +1,11 @@
 # RSpec emulation layer.
-#--
-# Copyright protects this work.
-# See LICENSE file for details.
-#++
 
 require 'dfect'
 
-module Kernel
-  def describe *args, &block
-    Dfect.D args.join(' '), &block
-  end
-
-  alias context describe
-  alias it      describe
+module Dfect
+  alias describe D
+  alias context  D
+  alias it       D
 
   def before what, &block
     meth =
@@ -22,7 +15,7 @@ module Kernel
       else raise ArgumentError, what
       end
 
-    Dfect.send meth, &block
+    send meth, &block
   end
 
   def after what, &block
@@ -33,6 +26,6 @@ module Kernel
       else raise ArgumentError, what
       end
 
-    Dfect.send meth, &block
+    send meth, &block
   end
 end

data/lib/dfect/unit.rb

@@ -1,19 +1,12 @@
 # Test::Unit emulation layer.
-#--
-# Copyright protects this work.
-# See LICENSE file for details.
-#++
 
 require 'dfect'
 
-module Kernel
-  def setup &block
-    Dfect.<(&block)
-  end
-
-  def teardown &block
-    Dfect.>(&block)
-  end
+module Dfect
+  alias setup     <
+  alias setup!    <<
+  alias teardown  >
+  alias teardown! >>
 
   [
     [:assert,     nil,  nil   ],
@@ -26,29 +19,24 @@ module Kernel
     #      block parameters in define_method()
     #
     file, line = __FILE__, __LINE__ ; eval %{
-      def #{prefix} boolean, message = nil
-        Dfect.T#{polarity}(message) { boolean }
-      end
-
-      def #{prefix}_block message = nil, &block
-        Dfect.T#{polarity}(&block)
-      end
+      alias #{prefix} T#{polarity}
+      alias #{prefix} T#{polarity}
 
       def #{prefix}_empty collection, message = nil
         message ||= 'collection must #{action}be empty'
-        Dfect.T#{polarity}(message) { collection.empty? }
+        T#{polarity}(message) { collection.empty? }
       end
 
       def #{prefix}_equal expected, actual, message = nil
         message ||= 'actual must #{action}equal expected'
-        Dfect.T#{polarity}(message) { actual == expected }
+        T#{polarity}(message) { actual == expected }
       end
 
       def #{prefix}_in_delta expected, actual, delta = nil, message = nil
         message ||= 'actual must #{action}be within delta of expected'
         delta   ||= 0.001
 
-        Dfect.T#{polarity}(message) do
+        T#{polarity}(message) do
           Math.abs(expected - actual) <= Math.abs(delta)
         end
       end
@@ -57,55 +45,55 @@ module Kernel
 
       def #{prefix}_include item, collection, message = nil
         message ||= 'collection must #{action}include item'
-        Dfect.T#{polarity}(messsage) { collection.include? item }
+        T#{polarity}(messsage) { collection.include? item }
       end
 
       def #{prefix}_instance_of _class, object, message = nil
         message ||= 'object must #{action}be an instance of class'
-        Dfect.T#{polarity}(message) { object.instance_of? _class }
+        T#{polarity}(message) { object.instance_of? _class }
       end
 
       def #{prefix}_kind_of _class, object, message = nil
         message ||= 'object must #{action}be a kind of class'
-        Dfect.T#{polarity}(message) { object.kind_of? _class }
+        T#{polarity}(message) { object.kind_of? _class }
       end
 
       def #{prefix}_nil object, message = nil
         message ||= 'object must #{action}be nil'
-        Dfect.T#{polarity}(message) { object == nil }
+        T#{polarity}(message) { object == nil }
       end
 
       def #{prefix}_match pattern, string, message = nil
         message ||= 'string must #{action}match pattern'
-        Dfect.T#{polarity}(message) { string =~ pattern }
+        T#{polarity}(message) { string =~ pattern }
       end
 
       def #{prefix}_same expected, actual, message = nil
         message ||= 'actual must #{action}be same as expected'
-        Dfect.T#{polarity}(message) { actual.equal? expected }
+        T#{polarity}(message) { actual.equal? expected }
       end
 
       def #{prefix}_operator object, operator, operand, message = nil
         message ||= 'object must #{action}support operator with operand'
-        Dfect.T#{polarity} { object.__send__ operator, operand }
+        T#{polarity} { object.__send__ operator, operand }
       end
 
       def #{prefix}_raise *args, &block
-        Dfect.E#{polarity}(args.pop, *args, &block)
+        E#{polarity}(args.pop, *args, &block)
       end
 
       def #{prefix}_respond_to object, query, message = nil
         message ||= 'object must #{action}respond to query'
-        Dfect.T#{polarity}(message) { object.respond_to? query }
+        T#{polarity}(message) { object.respond_to? query }
       end
 
       def #{prefix}_throw symbol, message = nil, &block
-        Dfect.C#{polarity}(message, symbol, &block)
+        C#{polarity}(message, symbol, &block)
       end
 
       def #{prefix}_send object, query, *args
         response = object.__send__(query, *args)
-        Dfect.T#{polarity} { response }
+        T#{polarity} { response }
       end
     }, binding, file, line
   end

data/test/dfect/inochi_test.rb

@@ -0,0 +1,17 @@
+require 'dfect/inochi'
+
+unless defined? Dfect::INOCHI
+  fail "Dfect module must be established by Inochi"
+end
+
+Dfect::INOCHI.each do |param, value|
+  const = param.to_s.upcase
+
+  unless Dfect.const_defined? const
+    fail "Dfect::#{const} must be established by Inochi"
+  end
+
+  unless Dfect.const_get(const) == value
+    fail "Dfect::#{const} is not what Inochi established"
+  end
+end

data/test/{dfect.rb → dfect_test.rb}

@@ -1,10 +1,3 @@
-#--
-# Copyright protects this work.
-# See LICENSE file for details.
-#++
-
-require 'dfect/auto'
-
 D 'T()' do
   T { true   }
   T { !false }
@@ -72,6 +65,7 @@ end
 
 D 'E()' do
   E(SyntaxError) { raise SyntaxError }
+  E(SyntaxError, 'must raise SyntaxError') { raise SyntaxError }
 
   D 'forbids block to not raise anything' do
     F { E? {} }
@@ -106,6 +100,7 @@ end
 
 D 'E!()' do
   E!(SyntaxError) { raise ArgumentError }
+  E!(SyntaxError, 'must not raise SyntaxError') { raise ArgumentError }
 
   D 'allows block to not raise anything' do
     E!(SyntaxError) {}
@@ -137,8 +132,16 @@ D 'E!()' do
   end
 end
 
+D 'E?()' do
+  T E?(SyntaxError) { raise SyntaxError }
+  T E?(SyntaxError, 'must raise SyntaxError') { raise SyntaxError }
+  F E?(SyntaxError) { raise ArgumentError }
+  F E?(SyntaxError, 'must not raise SyntaxError') { raise ArgumentError }
+end
+
 D 'C()' do
   C(:foo) { throw :foo }
+  C(:foo, 'must throw :foo') { throw :foo }
 
   D 'forbids block to not throw anything' do
     F { C?(:bar) {} }
@@ -168,6 +171,7 @@ end
 
 D 'C!()' do
   C!(:bar) { throw :foo }
+  C!(:bar, 'must not throw :bar') { throw :foo }
 
   D 'allows block to not throw anything' do
     C!(:bar) {}
@@ -196,6 +200,13 @@ D 'C!()' do
   end
 end
 
+D 'C?()' do
+  T C?(:foo) { throw :foo }
+  T C?(:foo, 'must throw :foo') { throw :foo }
+  F C?(:bar) { throw :foo }
+  F C?(:bar, 'must not throw :bar') { throw :foo }
+end
+
 D 'D()' do
   history = []
 
@@ -281,6 +292,155 @@ D 'YAML must be able to serialize a class' do
   T { SyntaxError.to_yaml == "--- SyntaxError\n" }
 end
 
+D 'insulated root-level describe' do
+  @insulated = :insulated
+  non_closured = :non_closured
+end
+
+closured = :closured
+
+D 'another insulated root-level describe' do
+  # without insulation, instance variables
+  # from previous root-level describe
+  # environments will spill into this one
+  F { defined? @insulated }
+  F { @insulated == :insulated }
+
+  # however, this insulation must
+  # not prevent closure access to
+  # surrounding local variables
+  T { defined? closured }
+  T { closured == :closured }
+
+  # except local variables defined
+  # within another insulated environment
+  F { defined? non_closured }
+  E(NameError) { non_closured }
+
+  @insulated_again = :insulated_again
+
+  D 'non-insulated nested describe' do
+    D 'inherits instance variables' do
+      T { defined? @insulated_again }
+      T { @insulated_again == :insulated_again }
+    end
+
+    D 'inherits instance methods' do
+      E!(NoMethodError) { instance_level_helper_method }
+      T { instance_level_helper_method == :instance_level_helper_method }
+    end
+
+    D 'inherits class methods' do
+      E!(NoMethodError) { self.class_level_helper_method }
+      T { self.class_level_helper_method == :class_level_helper_method }
+
+      E!(NoMethodError) { class_level_helper_method }
+      T { class_level_helper_method == self.class_level_helper_method }
+    end
+
+    @non_insulated_from_nested = :non_insulated_from_nested
+  end
+
+  D! 'nested but explicitly insulated describe' do
+    D 'does not inherit instance variables' do
+      F { defined? @insulated_again }
+      F { @insulated_again == :insulated_again }
+    end
+
+    D 'does not inherit instance methods' do
+      E(NameError) { instance_level_helper_method }
+    end
+
+    D 'does not inherit class methods' do
+      E(NoMethodError) { self.class_level_helper_method }
+      E(NameError) { class_level_helper_method }
+    end
+
+    @non_insulated_from_nested = 123
+  end
+
+  D 'another non-insulated nested describe' do
+    T { defined? @non_insulated_from_nested }
+    T { @non_insulated_from_nested == :non_insulated_from_nested }
+  end
+
+  def instance_level_helper_method
+    :instance_level_helper_method
+  end
+
+  def self.class_level_helper_method
+    :class_level_helper_method
+  end
+end
+
+D 'yet another insulated root-level describe' do
+  F { defined? @insulated_again }
+  F { @insulated_again == :insulated_again }
+
+  F { defined? @non_insulated_from_nested }
+  F { @non_insulated_from_nested == :non_insulated_from_nested }
+end
+
+S :knowledge do
+  @sharing_is_fun = :share_knowledge
+end
+
+S :money do
+  @sharing_is_fun = :share_money
+end
+
+D 'share knowledge' do
+  F { defined? @sharing_is_fun }
+  S :knowledge
+  T { defined? @sharing_is_fun }
+  T { @sharing_is_fun == :share_knowledge }
+
+  F { S? :power }
+  S! :power do
+    @sharing_is_fun = :share_power
+  end
+  T { S? :power }
+end
+
+D 'share money' do
+  F { defined? @sharing_is_fun }
+  S :money
+  T { defined? @sharing_is_fun }
+  T { @sharing_is_fun == :share_money }
+
+  S :power
+  T { defined? @sharing_is_fun }
+  T { @sharing_is_fun == :share_power }
+
+  D! 'share knowledge inside nested but explicitly insulated describe' do
+    F { defined? @sharing_is_fun }
+    S :knowledge
+    T { defined? @sharing_is_fun }
+    T { @sharing_is_fun == :share_knowledge }
+  end
+end
+
+D 're-sharing under a previously shared identifier' do
+  E ArgumentError, 'must raise an error' do
+    S :knowledge do
+      @sharing_is_fun = :overwrite_previous_share
+    end
+  end
+
+  F { defined? @sharing_is_fun }
+  F { @sharing_is_fun == :overwrite_previous_share }
+end
+
+D 'injecting an unshared code block' do
+  E ArgumentError, 'must raise an error' do
+    S :foobar
+  end
+end
+
+E 'injecting shared block outside of a test' do
+  S :knowledge
+end
+
 D 'stoping #run' do
   Dfect.stop
   raise 'this must not be reached!'