iba 0.0.5 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa34cf98d021bff67ebed44e9b62e2445c34793422660c0e221b06ca641c722d
-  data.tar.gz: c23f48c6e815351c9181efb572c98e0849e87d3c35a8b922fad6581e87090157
+  metadata.gz: fdfcd93322a8c4127a2de4efcf83856c0c8a8432224ca5e202e17b6a290d9795
+  data.tar.gz: 78badd47ea46837d1189fb2806dcffa8d3c9a5ed957556200d32908071648a03
 SHA512:
-  metadata.gz: 992248f06af84ad50da540697617ce9980acc400adbf8fe1df08965d54345bd335a98c8071ec8e32920fb1454ae0820dbe74b7b32322125b8769a3d611c93b82
-  data.tar.gz: 4ae83722fa833dd949a6b0ec254f395afbe2bed6fcd26d92cb919932f2c5f8bb101dcce3bcf9082df188a5019e97ceb7348dd4f956bc9e36076983e6970b43e6
+  metadata.gz: d66a5c8de935f7afabeadf5aa6f07da23ee6ade4ec99b2c827b46d0a70e92d162dbf08850e6163e36c408f9b90e83c97437ef96f01d24804daf00d50bbab867c
+  data.tar.gz: 72b770be1f2bd34e296ee3b9d7ca3a2e2c170ec3758d465c44f22092d64c2754f328b3ad431d4dd824b03c712d39c24dc818ab4221d269daa20bbe41e9cb7f13

data/CHANGELOG.md

@@ -0,0 +1,46 @@
+# Changelog
+
+## 0.0.7 / 2024-01-05
+
+* Support Ruby 3.0 through 3.3, and JRuby 9.4 ([#63], [#64] and [#68] by [mvz])
+
+[#63]: https://github.com/mvz/iba/pull/63
+[#64]: https://github.com/mvz/iba/pull/64
+[#68]: https://github.com/mvz/iba/pull/68
+
+## 0.0.6 / 2022-01-21
+
+* Support Ruby 2.6 and up, as well as JRuby 9.3
+* Display more subexpressions ([#13] by [mvz])
+* Add and use VERSION constant ([#49] by [mvz])
+
+[#13]: https://github.com/mvz/iba/pull/13
+[#49]: https://github.com/mvz/iba/pull/49
+
+## 0.0.5 / 2018-03-25
+
+* Target Ruby 2.2 and up
+* Remove all use of eval ([#1] by [mvz])
+
+[mvz]: https://github.com/mvz
+
+[#1]: https://github.com/mvz/iba/pull/1
+
+## 0.0.4 / 2017-12-15
+
+* Target Ruby 2.1 and up
+
+## 0.0.3 / 2014-05-09
+
+* Make Iba work with Ruby 1.9
+
+## 0.0.2 / 2011-02-25
+
+* Properly analyse comparison with arrays and strings
+* Allow instance variables in asserted expression
+
+## 0.0.1 / 2011-01-02
+
+* Initial release
+
+No match for: Prepare version 0.0.7 for release

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010--2011 Matijs van Zuijlen
+Copyright (c) 2010--2011, 2014-2024 Matijs van Zuijlen
 
 Iba is free software; you can redistribute it and/or modify it under the
 terms of the GNU Lesser General Public License as published by the Free Software
@@ -12,5 +12,3 @@ more details.
 
 You should have received a copy of the GNU Lesser General Public License
 along with this library. If not, see <http://www.gnu.org/licenses/>.
-
-

data/README.md

@@ -0,0 +1,67 @@
+# Iba
+
+by Matijs van Zuijlen
+
+## Description
+
+Introspective Block Assertions
+
+## Features/Problems
+
+* Write assertions as a (one-expression) block
+* Assertion message deconstructs the block's expression.
+* Not done yet.
+
+## Synopsis
+
+```ruby
+# In your test helper:
+require 'iba'
+class Test::Unit::TestCase
+  include Iba::BlockAssertion
+end
+
+# In your test:
+foo = 24
+assert { foo == 23 } # => "(foo == 23) is false
+                     #     foo is 24."
+```
+
+## Details
+
+Iba provides an assert method that takes a block. If the block returns
+false, it will try to construct an insightful error message based on the
+contents of the block.
+
+Iba's functionality is inspired by [Wrong], but doesn't use an external
+Ruby parser. This means it will work in contexts where Wrong does not
+(generated code, on the command line). It also means there are more limits
+to the contents of the block.
+
+Current limits:
+
+* Only single-expression blocks are supported.
+* The expression must start with a method-like identifier or an instance
+  variable (like `foo`  or `@foo`, but not `Foo` or `23`). In practice,
+  this produces quite natural results.
+* Local and instance variables whose names start with an underscore should
+  not be used inside the block.
+
+Iba's implementation is inspired by [Arlo], a generic combinator library
+for Python. The implementation of Arlo is now [on github][arlo-code].
+
+## Install
+
+```
+gem install iba
+```
+
+<!-- Links -->
+
+[Wrong]: https://github.com/sconover/wrong
+[Arlo]: https://web.archive.org/web/20081228090759/http://withoutane.com:80/rants/2008/12/arlo-generic-combinators-for-python
+[arlo-code]: https://github.com/tangentstorm/workshop/blob/main/code/arlo.py
+
+## Licence
+
+See the LICENSE file

data/lib/iba/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Iba
+  VERSION = "0.0.7"
+end

data/lib/iba.rb

@@ -1,6 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "iba/version"
+
 module Iba
   class Combinator
-    def initialize &blk
+    def initialize(&blk)
       @block = blk
     end
 
@@ -17,38 +21,24 @@ module Iba
     end
 
     def analyse
-      str = "#{self} is #{call.inspect}"
-      if expression.class == MethodCallExpression && expression._method == :==
-        lft = expression._reciever
-        rgt = expression._args.first
-        exprs = [lft, rgt].map { |e| display_subexpression e }.compact
-        str << "\n"
-        str << exprs.join(', ')
-      end
+      str = +"#{self} is #{call.inspect}"
+      sub = expression._display_subexpressions(@block.binding)
+      str << "\n#{sub}" if sub
       str
     end
-
-    private
-
-    def display_subexpression expr
-      if expr.class == LiteralExpression
-        nil
-      else
-        str = expr._to_s
-        value = expr._evaluate(@block.binding).inspect
-        "#{str} is #{value}"
-      end
-    end
   end
 
   class BaseExpression
-    def method_missing method, *args
-      super if method.to_s =~ /^_/
+    def method_missing(method, *args)
+      # FIXME: Remove to_s once support for Ruby < 2.7 is dropped
+      super if method.to_s.start_with? "_"
       MethodCallExpression.new self, method, args
     end
 
-    def respond_to_missing? method
-      return false if method.to_s =~ /^_/
+    def respond_to_missing?(method)
+      # FIXME: Remove to_s once support for Ruby < 2.7 is dropped
+      return super if method.to_s.start_with? "_"
+
       true
     end
 
@@ -56,11 +46,15 @@ module Iba
       method_missing :to_s
     end
 
-    def == other
+    def ==(other)
       method_missing :==, other
     end
 
-    def _wrap arg
+    def !=(other)
+      method_missing :!=, other
+    end
+
+    def _wrap(arg)
       if arg.is_a? BaseExpression
         arg
       else
@@ -68,13 +62,22 @@ module Iba
       end
     end
 
-    def coerce other
+    def _display(_bnd)
+      nil
+    end
+
+    def _display_subexpressions(_bnd)
+      nil
+    end
+
+    # Handle numeric operator coersion
+    def coerce(other)
       [_wrap(other), self]
     end
   end
 
   class EmptyExpression < BaseExpression
-    def _parse &blk
+    def _parse(&blk)
       bnd = blk.binding
 
       vars = bnd.local_variables
@@ -92,35 +95,42 @@ module Iba
       result
     end
 
-    def _override_instance_variables vars
+    def _override_instance_variables(vars)
       vars.each do |v|
-        next if v =~ /^@_/
+        # FIXME: Remove to_s once support for Ruby < 2.7 is dropped
+        next if v.to_s.start_with? "@_"
+
         instance_variable_set v, Iba::InstanceVariableExpression.new(v.to_sym)
       end
     end
 
-    def _override_local_variables vars, bnd
+    def _override_local_variables(vars, bnd)
       vars.each do |v|
-        next if v =~ /^_/
+        # FIXME: Remove to_s once support for Ruby < 2.7 is dropped
+        next if v.to_s.start_with? "_"
+
         bnd.local_variable_set "_#{v}", bnd.local_variable_get(v)
         bnd.local_variable_set v, LocalVariableExpression.new(v.to_sym)
       end
     end
 
-    def _restore_local_variables vars, bnd
+    def _restore_local_variables(vars, bnd)
       vars.each do |v|
-        next if v =~ /^_/
+        # FIXME: Remove to_s once support for Ruby < 2.7 is dropped
+        next if v.to_s.start_with? "_"
+
         bnd.local_variable_set v, bnd.local_variable_get("_#{v}")
       end
     end
 
     def _to_s
-      ''
+      ""
     end
   end
 
   class LiteralExpression < BaseExpression
-    def initialize val
+    def initialize(val)
+      super()
       @value = val
     end
 
@@ -128,13 +138,22 @@ module Iba
       @value.inspect
     end
 
-    def _evaluate _bnd
+    def _evaluate(_bnd)
       @value
     end
   end
 
-  class InstanceVariableExpression < BaseExpression
-    def initialize ivar_name
+  class DisplayableExpression < BaseExpression
+    def _display(bnd)
+      str = _to_s
+      value = _evaluate(bnd).inspect
+      "#{str} is #{value}"
+    end
+  end
+
+  class InstanceVariableExpression < DisplayableExpression
+    def initialize(ivar_name)
+      super()
       @_ivar_name = ivar_name
     end
 
@@ -142,13 +161,14 @@ module Iba
       @_ivar_name.to_s
     end
 
-    def _evaluate bnd
+    def _evaluate(bnd)
       bnd.receiver.instance_variable_get @_ivar_name
     end
   end
 
-  class LocalVariableExpression < BaseExpression
-    def initialize lvar_name
+  class LocalVariableExpression < DisplayableExpression
+    def initialize(lvar_name)
+      super()
       @_lvar_name = lvar_name
     end
 
@@ -156,69 +176,94 @@ module Iba
       @_lvar_name.to_s
     end
 
-    def _evaluate bnd
+    def _evaluate(bnd)
       bnd.local_variable_get @_lvar_name
     end
   end
 
-  class MethodCallExpression < BaseExpression
+  class MethodCallExpression < DisplayableExpression
     attr_reader :_method, :_reciever, :_args
 
-    def initialize reciever, methodname, args
+    def initialize(reciever, methodname, args)
+      super()
       @_reciever = reciever
       @_method = methodname
       @_args = args.map { |a| _wrap(a) }
     end
 
     def _to_s
-      rcv = @_reciever._to_s
-      args = @_args.map { |a| a.respond_to?(:_to_s) ? a._to_s : a.to_s }
-
       if @_method == :[]
-        "#{rcv}[#{args[0]}]"
+        _index_to_s
       elsif _method_is_operator?
-        case @_args.length
-        when 0
-          "#{@_method.to_s.sub(/@$/, '')}#{rcv}"
-        when 1
-          "(#{rcv} #{@_method} #{args.first})"
-        else
-          raise NotImplementedError
-        end
+        _operator_to_s
       else
-        str = rcv == '' ? '' : "#{rcv}."
-        str << @_method.to_s
-        str << "(#{args.join(', ')})" unless @_args.empty?
-        str
+        _regular_method_to_s
       end
     end
 
-    def _evaluate bnd
+    def _evaluate(bnd)
       rcv = @_reciever._evaluate(bnd)
       args = @_args.map { |arg| arg._evaluate(bnd) }
       rcv.send @_method, *args
     end
 
+    def _display_subexpressions(bnd)
+      rcv = @_reciever._display(bnd)
+      args = @_args.map { |arg| arg._display(bnd) }
+      [rcv, *args].compact.join(", ")
+    end
+
     private
 
+    def _receiver_s
+      @_reciever._to_s
+    end
+
+    def _args_s
+      @_args.map { |a| a.respond_to?(:_to_s) ? a._to_s : a.to_s }
+    end
+
+    def _index_to_s
+      "#{_receiver_s}[#{_args_s[0]}]"
+    end
+
+    def _operator_to_s
+      case @_args.length
+      when 0
+        "#{@_method.to_s.sub(/@$/, '')}#{_receiver_s}"
+      when 1
+        "(#{_receiver_s} #{@_method} #{_args_s.first})"
+      else
+        raise NotImplementedError
+      end
+    end
+
+    def _regular_method_to_s
+      rcv = _receiver_s
+      str = rcv == "" ? +"" : +"#{rcv}."
+      str << @_method.to_s
+      str << "(#{_args_s.join(', ')})" unless @_args.empty?
+      str
+    end
+
     def _method_is_operator?
       @_method.to_s !~ /^[a-z]/
     end
   end
 
   module BlockAssertion
-    def assert *args
-      if block_given?
+    def assert(*args, &block)
+      if block
         if yield
-          assert_block('true') { true }
+          assert_block("true") { true }
         else
-          msg = args.empty? ? '' : "#{args.first}.\n"
-          ana = Combinator.new(&Proc.new).analyse
+          msg = args.empty? ? "" : "#{args.first}.\n"
+          ana = Combinator.new(&block).analyse
           assert_block("#{msg}#{ana}.") { false }
         end
       else
         test, msg = *args
-        super test, msg
+        super(test, msg)
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iba
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.7
 platform: ruby
 authors:
 - Matijs van Zuijlen
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-03-25 00:00:00.000000000 Z
+date: 2024-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -16,14 +16,70 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.0'
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rake-manifest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.52'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.52'
+- !ruby/object:Gem::Dependency
+  name: rubocop-packaging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.2
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.18'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.18'
 - !ruby/object:Gem::Dependency
   name: test-unit
   requirement: !ruby/object:Gem::Requirement
@@ -38,57 +94,51 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.1'
-description: Asserts blocks, prints introspective failure messages.
+description: 'Asserts blocks, prints introspective failure messages.
+
+  '
 email:
 - matijs@matijs.net
 executables: []
 extensions: []
 extra_rdoc_files:
-- README.rdoc
+- README.md
 - LICENSE
 - COPYING.LESSER
 files:
+- CHANGELOG.md
 - COPYING.LESSER
 - LICENSE
-- README.rdoc
-- Rakefile
+- README.md
 - lib/iba.rb
-- test/.rubocop.yml
-- test/analyse_test.rb
-- test/assert_test.rb
-- test/call_test.rb
-- test/display_test.rb
-- test/test_helper.rb
+- lib/iba/version.rb
 homepage: http://www.github.com/mvz/iba
 licenses:
-- LGPL-3
-metadata: {}
-post_install_message: 
+- LGPL-3.0+
+metadata:
+  homepage_uri: http://www.github.com/mvz/iba
+  source_code_uri: https://github.com/mvz/iba
+  changelog_uri: https://github.com/mvz/iba/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options:
 - "--main"
-- README.rdoc
+- README.md
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.2.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.5.3
+signing_key:
 specification_version: 4
 summary: Introspective Block Assertions
-test_files:
-- test/.rubocop.yml
-- test/analyse_test.rb
-- test/assert_test.rb
-- test/call_test.rb
-- test/display_test.rb
-- test/test_helper.rb
+test_files: []

data/README.rdoc

@@ -1,62 +0,0 @@
-= Iba
-
-by Matijs van Zuijlen
-
-== Description
-
-Introspective Block Assertions
-
-== Features/Problems
-
-* Write assertions as a (one-expression) block
-* Assertion message deconstructs the block's expression.
-* Not done yet.
-
-== Synopsis
-
-  # In your test helper:
-  require 'iba'
-  class Test::Unit::TestCase
-    include Iba::BlockAssertion
-  end
-
-  # In your test:
-  foo = 24
-  assert { foo == 23 } # => "(foo == 23) is false
-                       #     foo is 24."
-
-== Details
-
-Iba provides an assert method that takes a block. If the block returns
-false, it will try to construct an insightful error message based on the
-contents of the block.
-
-Iba's functionality is inspired by Wrong[1], but doesn't use an external
-Ruby parser. This means it will work in contexts where Wrong does not
-(generated code, on the command line). It also means there are more limits
-to the contents of the block.
-
-Current limits:
-
-* Only single-expression blocks are supported.
-* The expression must start with a method-like identifier or an instance
-  variable (like 'foo'  or '@foo', but not 'Foo' or '23'). In practice,
-  this produces quite natural results.
-* Local and instance variables whose names start with an underscore should
-  not be used inside the block.
-
-Iba's implementation is inspired by Arlo[2], a generic combinator library
-for Python.
-
-== Install
-
-  gem install iba
-
-== Links
-
-[1] https://github.com/sconover/wrong
-[2] http://withoutane.com/rants/2008/12/arlo-generic-combinators-for-python
-
-== Licence
-
-See the LICENSE file.

data/Rakefile

@@ -1,16 +0,0 @@
-require 'rake/clean'
-require 'bundler/gem_tasks'
-require 'rake/testtask'
-
-namespace :test do
-  Rake::TestTask.new(:run) do |t|
-    t.libs = ['lib']
-    t.test_files = FileList['test/**/*_test.rb']
-    t.ruby_opts += ['-w']
-  end
-end
-
-desc 'Alias to test:run'
-task test: 'test:run'
-
-task default: 'test:run'

data/test/.rubocop.yml

@@ -1,10 +0,0 @@
-inherit_from: ../.rubocop.yml
-
-# We need to rescue Exception to test exceptions thrown by assert
-# TODO: Remove once support for Ruby 1.8 is dropped.
-Lint/RescueException:
-  Enabled: false
-
-# Allow compact syntax when adding to Test::Unit::TestCase
-Style/ClassAndModuleChildren:
-  Enabled: false

data/test/analyse_test.rb

@@ -1,78 +0,0 @@
-require_relative 'test_helper'
-
-# Test how the combinator analyses the parsed block contents.
-class AnalyseTest < Test::Unit::TestCase
-  def test_empty_block
-    assert_equal 'nil is nil', combinator {}.analyse
-  end
-
-  def test_variable
-    foo = 23
-    assert_equal 'foo is 23', combinator { foo }.analyse
-  end
-
-  def test_operator_equals
-    foo = 42
-    bar = 23
-    result = combinator { foo == bar }.analyse
-    assert_equal "(foo == bar) is false\nfoo is 42, bar is 23", result
-  end
-
-  def test_operator_equals_literal
-    foo = 42
-    result = combinator { foo == 23 }.analyse
-    assert_equal "(foo == 23) is false\nfoo is 42", result
-  end
-
-  def test_operator_equals_array_literal
-    foo = [1, 'bar']
-    result = combinator { foo == [2, 'baz'] }.analyse
-    assert_equal "(foo == [2, \"baz\"]) is false\nfoo is [1, \"bar\"]", result
-  end
-
-  def test_string_variable
-    foo = 'blub'
-    assert_equal 'foo is "blub"', combinator { foo }.analyse
-  end
-
-  def test_array_variable
-    foo = [1, 2]
-    assert_equal 'foo is [1, 2]', combinator { foo }.analyse
-  end
-
-  def test_object_variable
-    foo = Object.new
-    insp = foo.inspect
-    assert_equal "foo is #{insp}", combinator { foo }.analyse
-  end
-
-  def test_literal
-    assert_equal '23 is 23', combinator { 23 }.analyse
-  end
-
-  def test_instance_variable
-    @foo = 23
-    assert_equal '@foo is 23', combinator { @foo }.analyse
-  end
-
-  def test_instance_variable_method_call
-    @foo = 23
-    assert_equal "(@foo == 23) is true\n@foo is 23", combinator { @foo == 23 }.analyse
-  end
-
-  def test_instance_variable_as_argument_of_operator
-    @foo = 23
-    assert_equal '(23 + @foo) is 46', combinator { 23 + @foo }.analyse
-  end
-
-  def test_complex_subexpressions
-    @foo = 23
-    bar = 42
-    baz = [42]
-    result = combinator { (@foo + baz.first) == (bar + 23) }.analyse
-    assert_equal \
-      "((@foo + baz.first) == (bar + 23)) is true\n" \
-      '(@foo + baz.first) is 65, (bar + 23) is 65',
-      result
-  end
-end

data/test/assert_test.rb

@@ -1,51 +0,0 @@
-require_relative 'test_helper'
-
-# Test behavior of overridden assert method.
-class AssertTest < Test::Unit::TestCase
-  def test_simple_assert
-    assert { true }
-  end
-
-  def failing_block_assertion_test message, &block
-    assert(&block)
-  rescue Exception => e
-    assert_equal message, e.message
-  end
-
-  def test_simple_failing_assert
-    failing_block_assertion_test('false is false.') { false }
-  end
-
-  def test_operator_equals_assert
-    foo = 24
-    failing_block_assertion_test("(foo == 23) is false\nfoo is 24.") { foo == 23 }
-  end
-
-  def test_instance_variable_assert
-    @foo = 24
-    failing_block_assertion_test("(@foo == 23) is false\n@foo is 24.") { @foo == 23 }
-  end
-
-  # Special cases
-
-  def test_assert_with_custom_message
-    foo = false
-    begin
-      assert('We want foo') { foo }
-    rescue Exception => e
-      assert_equal "We want foo.\nfoo is false.", e.message
-    end
-  end
-
-  def test_blockless_assert
-    assert false
-  rescue Exception => e
-    assert_equal '<false> is not true.', e.message
-  end
-
-  def test_blockless_assert_with_custom_message
-    assert false, 'We want the truth'
-  rescue Exception => e
-    assert_equal "We want the truth.\n<false> is not true.", e.message
-  end
-end

data/test/call_test.rb

@@ -1,18 +0,0 @@
-require File.expand_path('test_helper.rb', File.dirname(__FILE__))
-
-# Test how the combinator calls the passed block.
-class CallTest < Test::Unit::TestCase
-  def test_empty_combinator
-    assert_equal nil, combinator {}.call
-  end
-
-  def test_variable
-    foo = 23
-    assert_equal 23, combinator { foo }.call
-  end
-
-  def test_operator_call
-    foo = 23
-    assert_equal true, combinator { foo == 23 }.call
-  end
-end

data/test/display_test.rb

@@ -1,57 +0,0 @@
-require_relative 'test_helper'
-
-# Test how the combinator displays the parsed block contents.
-class DisplayTest < Test::Unit::TestCase
-  def test_empty_combinator
-    assert_equal 'nil', combinator {}.to_s
-  end
-
-  def test_literal_number
-    assert_equal '23', combinator { 23 }.to_s
-  end
-
-  def test_literal_string
-    assert_equal '"aa"', combinator { 'aa' }.to_s
-  end
-
-  def test_method_calls
-    assert_equal 'foo', combinator { foo }.to_s
-    assert_equal 'foo.foo', combinator { foo.foo }.to_s
-    assert_equal 'foo.foo(1)', combinator { foo.foo 1 }.to_s
-    assert_equal 'foo(1)', combinator { foo 1 }.to_s
-    assert_equal 'foo(bar)', combinator { foo bar }.to_s
-    assert_equal 'foo(1).bar', combinator { foo(1).bar }.to_s
-    assert_equal 'foo.foo.foo', combinator { foo.foo.foo }.to_s
-    assert_equal 'foo(bar.baz)', combinator { foo bar.baz }.to_s
-  end
-
-  def test_operators
-    assert_equal '(foo + 1)', combinator { foo + 1 }.to_s
-    assert_equal '(foo - 1)', combinator { foo - 1 }.to_s
-  end
-
-  def test_operator_equals
-    assert_equal '(foo == 1)', combinator { foo == 1 }.to_s
-  end
-
-  def test_array_index
-    assert_equal 'foo[1]', combinator { foo[1] }.to_s
-  end
-
-  def test_to_s_method
-    assert_equal 'foo.to_s', combinator { foo.to_s }.to_s
-  end
-
-  def test_operator_unary_minus
-    assert_equal '-foo', combinator { -foo }.to_s
-  end
-
-  def test_operator_if_wont_work
-    assert_equal 'bar', combinator { foo ? bar : baz }.to_s
-  end
-
-  def test_defined_instance_variables
-    @foo = 1
-    assert_equal '@foo', combinator { @foo }.to_s
-  end
-end

data/test/test_helper.rb

@@ -1,10 +0,0 @@
-require 'test/unit'
-require 'iba'
-
-class Test::Unit::TestCase
-  include Iba::BlockAssertion
-
-  def combinator &blk
-    Iba::Combinator.new(&blk)
-  end
-end