protocol 1.0.1 → 2.0.0

data/lib/protocol/core.rb

@@ -20,3 +20,27 @@ Enumerating = Protocol do
 
   include Enumerable
 end
+
+# Checks if indexing behaviour exists as in Array or Hash.
+Indexing = Protocol do
+  understand :[]
+
+  understand :[]=
+end
+
+Synchronizing = Protocol do
+  def lock() end
+
+  def unlock() end
+
+  implementation
+
+  def synchronize
+    lock
+    begin
+      yield
+    ensure
+      unlock
+    end
+  end
+end

data/lib/protocol/message.rb

@@ -167,13 +167,6 @@ module Protocol
                 result = __send__('#{inner_name}', #{args} &block)
               end
               result
-            rescue Protocol::CheckError => e
-              case ObjectSpace._id2ref(#{__id__}).protocol.mode
-              when :error
-                raise e
-              when :warning
-                warn e
-              end
             ensure
               Thread.current[post_name].pop
               Thread.current[post_name].empty? and

data/lib/protocol/protocol_module.rb

@@ -3,14 +3,11 @@ module Protocol
   class ProtocolModule < Module
     # Creates an new ProtocolModule instance.
     def initialize(&block)
-      @descriptor = Descriptor.new(self)
-      @mode = :error
-      module_eval(&block)
+      @descriptor     = Descriptor.new(self)
+      @implementation = false
+      block and module_eval(&block)
     end
 
-    # The current check mode :none, :warning, or :error (the default).
-    attr_reader :mode
-
     # Returns all the protocol descriptions to check against as an Array.
     def descriptors
       descriptors = []
@@ -30,7 +27,6 @@ module Protocol
     # generic argument names.
     def to_ruby(result = '')
       result << "#{name} = Protocol do"
-      first = true
       if messages.empty?
         result << "\n"
       else
@@ -129,39 +125,38 @@ module Protocol
       "#<#{name}: #{messages.map { |m| m.shortcut } * ', '}>"
     end
 
-    # Check the conformity of +object+ recursively. This method returns either
-    # false OR true, if +mode+ is :none or :warning, or raises an
-    # CheckFailed, if +mode+ was :error.
-    def check(object, mode = @mode)
+    # Check the conformity of +object+ recursively and raise an exception if it
+    # doesn't.
+    def check!(object)
       checked = {}
-      result = true
       errors = CheckFailed.new
       each do |message|
         begin
           message.check(object, checked)
         rescue CheckError => e
-          case mode
-          when :error
-            errors << e
-          when :warning
-            warn e.to_s
-            result = false
-          when :none
-            result = false
-          end
+          errors << e
         end
       end
-      raise errors unless errors.empty?
-      result
+      errors.empty? or raise errors
+      true
     end
 
-    alias =~ check
+    alias =~ check!
+
+    # Check the conformity of +object+ recursively and return true iff it does.
+    def check(object)
+      check!(object)
+    rescue CheckFailed
+      false
+    else
+      true
+    end
 
     # Return all messages for whick a check failed.
     def check_failures(object)
-      check object
+      check!(object)
     rescue CheckFailed => e
-      return e.errors.map { |e| e.protocol_message }
+      e.errors.map { |e| e.protocol_message }
     end
 
     # This callback is called, when a module, that was extended with Protocol,
@@ -173,32 +168,19 @@ module Protocol
     # the Protocol
     # module.
     def included(modul)
-      super
-      if modul.is_a? Class and @mode == :error or @mode == :warning
-        $DEBUG and warn "#{name} is checking class #{modul}"
-        check modul
+      result = super
+      if modul.is_a? Class
+        check! modul
       end
+      result
     end
 
     def extend_object(object)
       result = super
-      if @mode == :error or @mode == :warning
-        $DEBUG and warn "#{name} is checking class #{object}"
-        check object
-      end
+      check! object
       result
     end
 
-    # Sets the check mode to +id+. +id+ should be one of :none, :warning, or
-    # :error. The mode to use while doing a conformity check is always the root
-    # module, that is, the modes of the included modules aren't important for
-    # the check.
-    def check_failure(mode)
-      CHECK_MODES.include?(mode) or
-        raise ArgumentError, "illegal check mode #{mode}"
-      @mode = mode
-    end
-
     # This method defines one of the messages, the protocol in question
     # consists of: The messages which the class, that conforms to this
     # protocol, should understand and respond to. An example shows best
@@ -226,12 +208,12 @@ module Protocol
     end
     private :parse_instance_method_signature
 
-    # Inherit a method signature from an instance method named +methodname+ of
+    # Infer a method signature from an instance method named +methodname+ of
     # +modul+. This means that this protocol should understand these instance
     # methods with their arity and block expectation. Note that automatic
     # detection of blocks does not work for Ruby methods defined in C. You can
     # set the +block_expected+ argument if you want to do this manually.
-    def inherit(modul, methodname, block_expected = nil)
+    def infer(modul, methodname = modul.public_instance_methods(false), block_expected = nil)
       Module === modul or
         raise TypeError, "expected Module not #{modul.class} as modul argument"
       methodnames = methodname.respond_to?(:to_ary) ?
@@ -254,7 +236,7 @@ module Protocol
     # Return true, if the ProtocolModule is currently in implementation mode.
     # Otherwise return false.
     def implementation?
-      !!@implementation
+      @implementation
     end
 
     # Switch to specification mode. Defined methods are added to the protocol

data/lib/protocol/version.rb

@@ -1,6 +1,6 @@
 module Protocol
   # Protocol version
-  VERSION         = '1.0.1'
+  VERSION         = '2.0.0'
   VERSION_ARRAY   = VERSION.split('.').map(&:to_i) # :nodoc:
   VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
   VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:

data/lib/protocol/xt.rb

@@ -6,17 +6,22 @@ module Protocol
     # :none or :warning, and conformance of a class to a protocol should be
     # checked later in runtime.
     def conform_to?(protocol)
-      protocol.check(self, :none)
+      protocol.check(self)
     end
 
-    def conform_to!(protocol)
+    def conform_to(protocol)
       extend(protocol)
     end
 
     # Define a protocol configured by +block+. Look at the methods of
     # ProtocolModule to get an idea on how to do that.
-    def Protocol(&block)
-      ProtocolModule.new(&block)
+    def Protocol(modul = nil, &block)
+      pm = ProtocolModule.new(&block)
+      if modul
+        pm.infer(modul)
+      else
+        pm
+      end
     end
 
     alias protocol Protocol
@@ -35,7 +40,7 @@ module Protocol
     # :none or :warning, and conformance of a class to a protocol should be
     # checked later in runtime.
     def conform_to?(protocol)
-      protocol.check(self, :none)
+      protocol.check(self)
     end
   end
 end

data/protocol.gemspec

@@ -1,39 +1,43 @@
 # -*- encoding: utf-8 -*-
+# stub: protocol 2.0.0 ruby lib
 
 Gem::Specification.new do |s|
-  s.name = "protocol"
-  s.version = "1.0.1"
+  s.name = "protocol".freeze
+  s.version = "2.0.0"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Florian Frank"]
-  s.date = "2013-07-19"
-  s.description = "This library offers an implementation of protocols against which you can check\nthe conformity of your classes or instances of your classes. They are a bit\nlike Java Interfaces, but as mixin modules they can also contain already\nimplemented methods. Additionaly you can define preconditions/postconditions\nfor methods specified in a protocol.\n"
-  s.email = "flori@ping.de"
-  s.extra_rdoc_files = ["README.rdoc", "lib/protocol.rb", "lib/protocol/core.rb", "lib/protocol/descriptor.rb", "lib/protocol/errors.rb", "lib/protocol/message.rb", "lib/protocol/method_parser/ruby_parser.rb", "lib/protocol/post_condition.rb", "lib/protocol/protocol_module.rb", "lib/protocol/utilities.rb", "lib/protocol/version.rb", "lib/protocol/xt.rb"]
-  s.files = [".gitignore", ".travis.yml", "CHANGES", "COPYING", "Gemfile", "README.rdoc", "Rakefile", "VERSION", "benchmarks/data/.keep", "benchmarks/method_parser.rb", "examples/assignments.rb", "examples/comparing.rb", "examples/enumerating.rb", "examples/game.rb", "examples/hello_world_patternitis.rb", "examples/indexing.rb", "examples/locking.rb", "examples/queue.rb", "examples/stack.rb", "install.rb", "lib/protocol.rb", "lib/protocol/core.rb", "lib/protocol/descriptor.rb", "lib/protocol/errors.rb", "lib/protocol/message.rb", "lib/protocol/method_parser/ruby_parser.rb", "lib/protocol/post_condition.rb", "lib/protocol/protocol_module.rb", "lib/protocol/utilities.rb", "lib/protocol/version.rb", "lib/protocol/xt.rb", "protocol.gemspec", "tests/protocol_method_parser_test.rb", "tests/protocol_test.rb", "tests/test_helper.rb"]
-  s.homepage = "http://flori.github.com/protocol"
-  s.licenses = ["GPL-2"]
-  s.rdoc_options = ["--title", "Protocol - Method Protocols for Ruby Classes", "--main", "README.rdoc"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = "2.0.4"
-  s.summary = "Method Protocols for Ruby Classes"
-  s.test_files = ["tests/protocol_method_parser_test.rb", "tests/protocol_test.rb", "tests/test_helper.rb"]
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["Florian Frank".freeze]
+  s.date = "2019-11-05"
+  s.description = "This library offers an implementation of protocols against which you can check\nthe conformity of your classes or instances of your classes. They are a bit\nlike Java Interfaces, but as mixin modules they can also contain already\nimplemented methods. Additionaly you can define preconditions/postconditions\nfor methods specified in a protocol.\n".freeze
+  s.email = "flori@ping.de".freeze
+  s.extra_rdoc_files = ["README.rdoc".freeze, "lib/protocol.rb".freeze, "lib/protocol/core.rb".freeze, "lib/protocol/descriptor.rb".freeze, "lib/protocol/errors.rb".freeze, "lib/protocol/message.rb".freeze, "lib/protocol/method_parser/ruby_parser.rb".freeze, "lib/protocol/post_condition.rb".freeze, "lib/protocol/protocol_module.rb".freeze, "lib/protocol/utilities.rb".freeze, "lib/protocol/version.rb".freeze, "lib/protocol/xt.rb".freeze]
+  s.files = [".gitignore".freeze, ".travis.yml".freeze, ".utilsrc".freeze, "CHANGES".freeze, "COPYING".freeze, "Gemfile".freeze, "README.rdoc".freeze, "Rakefile".freeze, "VERSION".freeze, "benchmarks/data/.keep".freeze, "benchmarks/method_parser.rb".freeze, "examples/assignments.rb".freeze, "examples/comparing.rb".freeze, "examples/enumerating.rb".freeze, "examples/game.rb".freeze, "examples/hello_world_patternitis.rb".freeze, "examples/indexing.rb".freeze, "examples/queue.rb".freeze, "examples/stack.rb".freeze, "examples/synchronizing.rb".freeze, "install.rb".freeze, "lib/protocol.rb".freeze, "lib/protocol/core.rb".freeze, "lib/protocol/descriptor.rb".freeze, "lib/protocol/errors.rb".freeze, "lib/protocol/message.rb".freeze, "lib/protocol/method_parser/ruby_parser.rb".freeze, "lib/protocol/post_condition.rb".freeze, "lib/protocol/protocol_module.rb".freeze, "lib/protocol/utilities.rb".freeze, "lib/protocol/version.rb".freeze, "lib/protocol/xt.rb".freeze, "protocol.gemspec".freeze, "tests/protocol_core_test.rb".freeze, "tests/protocol_method_parser_test.rb".freeze, "tests/protocol_test.rb".freeze, "tests/test_helper.rb".freeze]
+  s.homepage = "http://flori.github.com/protocol".freeze
+  s.licenses = ["GPL-2".freeze]
+  s.rdoc_options = ["--title".freeze, "Protocol - Method Protocols for Ruby Classes".freeze, "--main".freeze, "README.rdoc".freeze]
+  s.rubygems_version = "3.0.6".freeze
+  s.summary = "Method Protocols for Ruby Classes".freeze
+  s.test_files = ["tests/protocol_core_test.rb".freeze, "tests/protocol_method_parser_test.rb".freeze, "tests/protocol_test.rb".freeze, "tests/test_helper.rb".freeze]
 
   if s.respond_to? :specification_version then
     s.specification_version = 4
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<gem_hadar>, ["~> 0.3.2"])
-      s.add_development_dependency(%q<simplecov>, [">= 0"])
-      s.add_runtime_dependency(%q<ruby_parser>, ["~> 3.0"])
+      s.add_development_dependency(%q<gem_hadar>.freeze, ["~> 1.9.1"])
+      s.add_development_dependency(%q<simplecov>.freeze, [">= 0"])
+      s.add_development_dependency(%q<test-unit>.freeze, [">= 0"])
+      s.add_runtime_dependency(%q<ruby_parser>.freeze, ["~> 3.0"])
     else
-      s.add_dependency(%q<gem_hadar>, ["~> 0.3.2"])
-      s.add_dependency(%q<simplecov>, [">= 0"])
-      s.add_dependency(%q<ruby_parser>, ["~> 3.0"])
+      s.add_dependency(%q<gem_hadar>.freeze, ["~> 1.9.1"])
+      s.add_dependency(%q<simplecov>.freeze, [">= 0"])
+      s.add_dependency(%q<test-unit>.freeze, [">= 0"])
+      s.add_dependency(%q<ruby_parser>.freeze, ["~> 3.0"])
     end
   else
-    s.add_dependency(%q<gem_hadar>, ["~> 0.3.2"])
-    s.add_dependency(%q<simplecov>, [">= 0"])
-    s.add_dependency(%q<ruby_parser>, ["~> 3.0"])
+    s.add_dependency(%q<gem_hadar>.freeze, ["~> 1.9.1"])
+    s.add_dependency(%q<simplecov>.freeze, [">= 0"])
+    s.add_dependency(%q<test-unit>.freeze, [">= 0"])
+    s.add_dependency(%q<ruby_parser>.freeze, ["~> 3.0"])
   end
 end

data/tests/protocol_core_test.rb

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby
+
+require 'test_helper'
+require 'protocol/core'
+
+class ProtocolCoreTest < Test::Unit::TestCase
+  def test_comparing_numeric
+    assert Numeric.conform_to?(Comparing)
+  end
+
+  def test_comparing_complex
+    assert_false Complex.conform_to?(Comparing)
+  end
+
+  def test_comparing_array
+    assert Array.conform_to?(Comparing)
+  end
+
+  def test_comparing_string
+    assert String.conform_to?(Comparing)
+  end
+
+  def test_enumerating_array
+    assert Array.conform_to?(Enumerating)
+  end
+
+  def test_enumerating_float
+    assert_false Float.conform_to?(Enumerating)
+  end
+
+  def test_enumerating_hash
+    assert Hash.conform_to?(Enumerating)
+  end
+
+  def test_indexing_array
+    assert Array.conform_to?(Indexing)
+  end
+
+  def test_indexing_proc
+    assert_false Proc.conform_to?(Indexing)
+  end
+
+  def test_indexing_hash
+    assert Hash.conform_to?(Indexing)
+  end
+
+  def test_sychronizing_mutex
+    assert Mutex.conform_to?(Synchronizing)
+  end
+
+  def test_sychronizing_hash
+    assert_false Hash.conform_to?(Synchronizing)
+  end
+
+  def test_my_synchronizer
+    s = Class.new do
+      def initialize
+        @lock = false
+      end
+
+      def lock
+        @lock = true
+      end
+
+      def locked?
+        @lock
+      end
+
+      def unlock
+        @lock = false
+      end
+
+      conform_to Synchronizing
+    end.new
+    assert_false s.locked?
+    s.synchronize { assert s.locked? }
+    assert_false s.locked?
+  end
+end

data/tests/protocol_method_parser_test.rb

@@ -52,94 +52,95 @@ class ProtocolMethodParserTest < Test::Unit::TestCase
 
     def complex_end
       a = :end
-      foo { }
+      foo() { }
+      a
     end
 
     def complex
-      foo { }
+      foo() { }
     end
   end
 
   def test_args
     m = :empty; mp = MethodParser.new(A, m)
-    assert_equal 0, mp.arity, "arity failed for A##{m}"
-    assert_equal [ ], mp.args, "args failed for A##{m}"
-    assert_equal [ ], mp.arg_kinds, "args failed for A##{m}"
+    assert_equal(0, mp.arity, "arity failed for A##{m}")
+    assert_equal([ ], mp.args, "args failed for A##{m}")
+    assert_equal([ ], mp.arg_kinds, "args failed for A##{m}")
     assert !mp.complex?
     m = :none; mp = MethodParser.new(A, m)
-    assert_equal 0, mp.arity, "arity failed for A##{m}"
-    assert_equal [ ], mp.args, "args failed for A##{m}"
-    assert_equal [ ], mp.arg_kinds, "args failed for A##{m}"
+    assert_equal(0, mp.arity, "arity failed for A##{m}")
+    assert_equal([ ], mp.args, "args failed for A##{m}")
+    assert_equal([ ], mp.arg_kinds, "args failed for A##{m}")
     assert !mp.complex?
     m = :one_req; mp = MethodParser.new(A, m)
-    assert_equal 1, mp.arity, "arity failed for A##{m}"
-    assert_equal [ :a ], mp.args, "args failed for A##{m}"
-    assert_equal [ :req ], mp.arg_kinds, "args failed for A##{m}"
+    assert_equal(1, mp.arity, "arity failed for A##{m}")
+    assert_equal([ :a ], mp.args, "args failed for A##{m}")
+    assert_equal([ :req ], mp.arg_kinds, "args failed for A##{m}")
     assert !mp.complex?
     m = :two_req; mp = MethodParser.new(A, m)
-    assert_equal 2, mp.arity, "arity failed for A##{m}"
-    assert_equal [ :req, :req ], mp.arg_kinds, "args failed for A##{m}"
-    assert_equal [ :a, :b ], mp.args, "args failed for A##{m}"
+    assert_equal(2, mp.arity, "arity failed for A##{m}")
+    assert_equal([ :req, :req ], mp.arg_kinds, "args failed for A##{m}")
+    assert_equal([ :a, :b ], mp.args, "args failed for A##{m}")
     assert !mp.complex?
     m = :one_req_one_opt; mp = MethodParser.new(A, m)
-    assert_equal -2, mp.arity, "arity failed for A##{m}"
-    assert_equal [ :a, :b ], mp.args, "args failed for A##{m}"
-    assert_equal [ :req, :opt ], mp.arg_kinds, "args failed for A##{m}"
+    assert_equal(-2, mp.arity, "arity failed for A##{m}")
+    assert_equal([ :a, :b ], mp.args, "args failed for A##{m}")
+    assert_equal([ :req, :opt ], mp.arg_kinds, "args failed for A##{m}")
     assert !mp.complex?
     m = :one_opt; mp = MethodParser.new(A, m)
-    assert_equal -1, mp.arity, "arity failed for A##{m}"
-    assert_equal [ :a ], mp.args, "args failed for A##{m}"
-    assert_equal [ :opt ], mp.arg_kinds, "args failed for A##{m}"
+    assert_equal(-1, mp.arity, "arity failed for A##{m}")
+    assert_equal([ :a ], mp.args, "args failed for A##{m}")
+    assert_equal([ :opt ], mp.arg_kinds, "args failed for A##{m}")
     assert !mp.complex?
     m = :two_opt; mp = MethodParser.new(A, m)
-    assert_equal -1, mp.arity, "arity failed for A##{m}"
-    assert_equal [ :a, :b ], mp.args, "args failed for A##{m}"
-    assert_equal [ :opt, :opt ], mp.arg_kinds, "args failed for A##{m}"
+    assert_equal(-1, mp.arity, "arity failed for A##{m}")
+    assert_equal([ :a, :b ], mp.args, "args failed for A##{m}")
+    assert_equal([ :opt, :opt ], mp.arg_kinds, "args failed for A##{m}")
     assert !mp.complex?
     m = :one_req_rest; mp = MethodParser.new(A, m)
-    assert_equal -2, mp.arity, "arity failed for A##{m}"
-    assert_equal [ :a, :'*b' ], mp.args, "args failed for A##{m}"
-    assert_equal [ :req, :rest ], mp.arg_kinds, "args failed for A##{m}"
+    assert_equal(-2, mp.arity, "arity failed for A##{m}")
+    assert_equal([ :a, :'*b' ], mp.args, "args failed for A##{m}")
+    assert_equal([ :req, :rest ], mp.arg_kinds, "args failed for A##{m}")
     assert !mp.complex?
     m = :one_opt_rest; mp = MethodParser.new(A, m)
-    assert_equal -1, mp.arity, "arity failed for A##{m}"
-    assert_equal [ :a, :'*b' ], mp.args, "args failed for A##{m}"
-    assert_equal [ :opt, :rest ], mp.arg_kinds, "args failed for A##{m}"
+    assert_equal(-1, mp.arity, "arity failed for A##{m}")
+    assert_equal([ :a, :'*b' ], mp.args, "args failed for A##{m}")
+    assert_equal([ :opt, :rest ], mp.arg_kinds, "args failed for A##{m}")
     assert !mp.complex?
     m = :block; mp = MethodParser.new(A, m)
-    assert_equal 0, mp.arity, "arity failed for A##{m}"
-    assert_equal [ :'&b' ], mp.args, "args failed for A##{m}"
-    assert_equal [ :block ], mp.arg_kinds, "args failed for A##{m}"
+    assert_equal(0, mp.arity, "arity failed for A##{m}")
+    assert_equal([ :'&b' ], mp.args, "args failed for A##{m}")
+    assert_equal([ :block ], mp.arg_kinds, "args failed for A##{m}")
     assert !mp.complex?
     m = :one_req_block; mp = MethodParser.new(A, m)
-    assert_equal 1, mp.arity, "arity failed for A##{m}"
-    assert_equal [ :a, :'&b' ], mp.args, "args failed for A##{m}"
-    assert_equal [ :req, :block ], mp.arg_kinds, "args failed for A##{m}"
+    assert_equal(1, mp.arity, "arity failed for A##{m}")
+    assert_equal([ :a, :'&b' ], mp.args, "args failed for A##{m}")
+    assert_equal([ :req, :block ], mp.arg_kinds, "args failed for A##{m}")
     assert !mp.complex?
     m = :one_opt_block; mp = MethodParser.new(A, m)
-    assert_equal -1, mp.arity, "arity failed for A##{m}"
-    assert_equal [ :a, :'&b' ], mp.args, "args failed for A##{m}"
-    assert_equal [ :opt, :block ], mp.arg_kinds, "args failed for A##{m}"
+    assert_equal(-1, mp.arity, "arity failed for A##{m}")
+    assert_equal([ :a, :'&b' ], mp.args, "args failed for A##{m}")
+    assert_equal([ :opt, :block ], mp.arg_kinds, "args failed for A##{m}")
     assert !mp.complex?
     m = :yield_block; mp = MethodParser.new(A, m)
-    assert_equal 0, mp.arity, "arity failed for A##{m}"
-    assert_equal [ :'&b' ], mp.args, "args failed for A##{m}"
-    assert_equal [ :block ], mp.arg_kinds, "args failed for A##{m}"
+    assert_equal(0, mp.arity, "arity failed for A##{m}")
+    assert_equal([ :'&b' ], mp.args, "args failed for A##{m}")
+    assert_equal([ :block ], mp.arg_kinds, "args failed for A##{m}")
     assert !mp.complex?
     m = :yield; mp = MethodParser.new(A, m)
-    assert_equal 0, mp.arity, "arity failed for A##{m}"
-    assert_equal [ :'&block' ], mp.args, "args failed for A##{m}"
-    assert_equal [ :block ], mp.arg_kinds, "args failed for A##{m}"
+    assert_equal(0, mp.arity, "arity failed for A##{m}")
+    assert_equal([ :'&block' ], mp.args, "args failed for A##{m}")
+    assert_equal([ :block ], mp.arg_kinds, "args failed for A##{m}")
     assert !mp.complex?
     m = :complex_end; mp = MethodParser.new(A, m)
-    assert_equal 0, mp.arity, "arity failed for A##{m}"
-    assert_equal [ ], mp.args, "args failed for A##{m}"
-    assert_equal [ ], mp.arg_kinds, "args failed for A##{m}"
+    assert_equal(0, mp.arity, "arity failed for A##{m}")
+    assert_equal([ ], mp.args, "args failed for A##{m}")
+    assert_equal([ ], mp.arg_kinds, "args failed for A##{m}")
     assert mp.complex?
     m = :complex; mp = MethodParser.new(A, m)
-    assert_equal 0, mp.arity, "arity failed for A##{m}"
-    assert_equal [ ], mp.args, "args failed for A##{m}"
-    assert_equal [ ], mp.arg_kinds, "args failed for A##{m}"
+    assert_equal(0, mp.arity, "arity failed for A##{m}")
+    assert_equal([ ], mp.args, "args failed for A##{m}")
+    assert_equal([ ], mp.arg_kinds, "args failed for A##{m}")
     assert mp.complex?
   end
 end