safer 0.1.0

data/.autotest

@@ -0,0 +1,23 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+# Autotest.add_hook :initialize do |at|
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception 'vendor'
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/History.txt

@@ -0,0 +1,4 @@
+=== 0.1.0 / 2010-09-22
+
+* First release
+

data/Manifest.txt

@@ -0,0 +1,10 @@
+.autotest
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/safer.rb
+lib/safer/ivar.rb
+lib/safer/protocol.rb
+test/test_safer_ivar.rb
+test/test_safer_protocol.rb

data/README.txt

@@ -0,0 +1,69 @@
+= safer
+
+http://safer.rubyforge.org/
+
+== DESCRIPTION:
+
+Safer is an umbrella library, with components designed to make it simple to
+verify and improve the safety of your ruby code.  There are at present two
+modules under the safer umbrella:
+
+[<tt>Safer::IVar</tt>]          generates specially-named accessor functions
+                                for class instance variables.
+[<tt>Safer::ClassProtocol</tt>] is used to provide a ruby analogue to
+                                Objective-C Protocols (which are similar to
+                                Java interfaces, but do not require
+                                inheritance).
+
+== FEATURES/PROBLEMS:
+
+* Name instance variables after the class in which they are defined.  Generate
+  accessor functions for these instance variables.
+* Define an "Protocol" class, and derive a signature from it.  Verify that
+  another class (or an instance of that class) implements the protocol
+  signature.
+
+== SYNOPSIS:
+
+  require 'safer/ivar'
+  require 'safer/protocol'
+
+  module MyModule
+    class MyProtocolClass
+      def self.class_method_foo(arg1, arg2)
+      end
+      def instance_method(arg3)
+      end
+    end
+    PROTOCOL = Safer::Protocol.create_from_class(MyProtocolClass)
+    class MyClass
+      Safer::IVar.instance_variable(self, :var1, :var2)
+      def initialize(var1, var2)
+        PROTOCOL.check_instance_conforms(var1)
+        PROTOCOL.check_instance_conforms(var2)
+        self.mymodule_myclass__var1 = var1
+        self.mymodule_myclass__var2 = var2
+      end
+    end
+  end
+
+== REQUIREMENTS:
+
+* None
+
+== INSTALL:
+
+* sudo gem install
+
+== DEVELOPERS:
+
+After checking out the source, run:
+
+  $ rake newb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the RDoc.
+
+== LICENSE:
+
+This software is placed into the public domain.

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'hoe'
+
+Hoe.spec 'safer' do
+  developer('Aidan Cully', 'aidan@panix.com')
+
+  self.rubyforge_name = 'aidancully'
+end

data/lib/safer/ivar.rb

@@ -0,0 +1,127 @@
+module Safer
+  ##
+  # Create accessor functions for instance variables, in which the accessor
+  # function is prefixed with the name of the class in which the instance
+  # variable is defined.
+  module IVar
+
+    ##
+    # Given a class name, derive the prefix string for the accessor functions
+    # that instance_variable will create.
+    def self.class_symbol_prefix(klass)
+      klass.to_s.split('::').inject(nil) do |memo, el|
+        # reset the symbol name when an anonymous class is encountered.
+        if /^\#<.*>$/.match(el)
+          nil
+        elsif memo
+          memo + '_' + el.downcase
+        else
+          el.downcase
+        end
+      end
+    end
+
+    ##
+    # compute accessor routine symbol names, so that the names include the
+    # entire class namespace.
+    # [+klass+] Class object for which to generate a symbol name.
+    # [+nmlist+] Array of +Symbol+ objects.
+    # [_return_] Array of +Symbol+ objects generated from +klass+ and each
+    #            element of +nmlist+.
+    # For example, given the following listing:
+    #   class MyClass
+    #     class SubClass
+    #       SYMNM = Safer::IVar::symbol_names(self, :foo)
+    #       puts(SYMNM)
+    #     end
+    #   end
+    # the following output would be produced:
+    #   myclass_subclass__foo
+    def self.symbol_names(klass, nmlist)
+      kname = self.class_symbol_prefix(klass)
+
+      nmlist.map do |nm|
+        (kname + '__' + nm.to_s).to_sym
+      end
+    end # Safer::IVar::symbol_names
+
+    ##
+    # create accessor routines for an instance variable, with variable name
+    # determined by the class in which the instance variable was declared.
+    # [+klass+] Class object into which to generate the variable accessor
+    #           functions.
+    # [+nmlist+] List of symbols for which to create accessor routines.
+    # Uses Safer::IVar::symbol_names to determine the symbol names of the
+    # accessor routines.
+    # For example, the listing:
+    #   class MyClass
+    #     class SubClass
+    #       Safer::IVar::instance_variable(self, :foo, :bar)
+    #     end
+    #   end
+    # is equivalent to the following code:
+    #   class MyClass
+    #     class SubClass
+    #       attr_accessor :myclass_subclass__foo
+    #       attr_accessor :myclass_subclass__bar
+    #     end
+    #   end
+    # The name-mangling signals that these instance variables are, for all
+    # intents and purposes, private to +klass+.
+    def self.instance_variable(klass, *nmlist)
+      self.symbol_names(klass, nmlist).each do |symnm|
+        klass.class_eval do
+          attr_accessor symnm
+        end
+      end
+    end # Safer::IVar::instance_variable
+
+    ##
+    # export the reader routines for instance variables in a nicer way.
+    # [+klass+] Class object for which to define reader accessors for
+    #           instance variables defined by Safer::IVar::instance_variables.
+    # [+nmlist+] List of symbols for which to define reader accessors.
+    #            Each symbol in +nmlist+ should have previously been given as
+    #            an argument to Safer::IVar::instance_variables(+klass+).
+    def self.export_reader(klass, *nmlist)
+      symlist = self.symbol_names(klass, nmlist)
+      nmlist.size.times do |index|
+        thisnm = nmlist[index]
+        thissym = symlist[index]
+        klass.class_eval("def #{thisnm} ; self.#{thissym} ; end")
+      end
+    end # Safer::IVar::export_reader
+
+    ##
+    # export the writer routines for instance variables in a nicer way.
+    # [+klass+] Class object for which to define writer accessors for
+    #           instance variables defined by Safer::IVar::instance_variables.
+    # [+nmlist+] List of symbols for which to define writer accessors.
+    #            Each symbol in +nmlist+ should have previously been given as
+    #            an argument to Safer::IVar::instance_variables(+klass+).
+    def self.export_writer(klass, *nmlist)
+      symlist = self.symbol_names(klass, nmlist)
+      nmlist.size.times do |index|
+        thisnm = nmlist[index]
+        thissym = symlist[index]
+        klass.class_eval(
+          "def #{thisnm}=(value) ; self.#{thissym} = value ; end"
+        )
+      end
+    end # Safer::IVar::export_writer
+
+    ##
+    # export both reader and writer routines for instance variables in a
+    # nicer way.
+    # [+klass+] Class object for which to define accessors for
+    #           instance variables defined by Safer::IVar::instance_variables.
+    # [+nmlist+] List of symbols for which to define accessors.
+    #            Each symbol in +nmlist+ should have previously been given as
+    #            an argument to Safer::IVar::instance_variables(+klass+).
+    def self.export_accessor(klass, *nmlist)
+      self.export_reader(klass, *nmlist)
+      self.export_writer(klass, *nmlist)
+    end # Safer::IVar::export_accessor
+
+  end # Safer::IVar
+end # Safer

data/lib/safer/protocol.rb

@@ -0,0 +1,335 @@
+require 'safer/ivar'
+
+module Safer
+  ## Safer::ClassProtocol
+  # Named set of class- and instance- methods, with associated numbers of
+  # arguments.  Call +create_from_class+ or +create_from_instance+ to create a
+  # new +ClassProtocol+ object.  Call +class_conforms?+ or +instance_conforms?+
+  # to verify that a Class or instance of the class (respectively) conforms to
+  # a protocol.
+  class ClassProtocol
+
+    ##
+    # Utility function used during ClassProtocol operations.  Given an
+    # +Array+, construct a +Hash+ with the values in the +Array+ as keys.
+    # If no block is provided, then the values for all keys in the +Hash+ will
+    # be +true+.  If a block is provided, the block is called for each value
+    # in the +Array+, and its return value will be stored as the value for
+    # that element in the +Hash+.  If the block returns +nil+, then the element
+    # will not be stored in the resulting +Hash+.
+    def self._array_to_table(array, &block)
+      if ! block
+        block = proc do |el| true ; end
+      end
+      array.inject(Hash::new) do |h, el|
+        newval = block.call(h, el)
+        if newval
+          h[el] = newval
+        end
+        h
+      end
+    end
+
+    ##
+    # Describes a set of methods that should be implemented by an object, but
+    # are not implemented.  The ClassProtocol::Error object will contain two
+    # ClassProtocol::Violation objects: one for class-method protocol
+    # violations, and one for instance-method protocol violations.
+    class Violation
+      Safer::IVar::instance_variable(self, :table)
+      Safer::IVar::instance_variable(self, :report)
+
+      ##
+      # :attr_reader: table
+      # Hash describing method violations.  Keys are the names of methods
+      # containing errors.  If a method was unimplemented in the class, the
+      # value for that method will be +true+.  If a method was implemented, but
+      # had a different arity (number of required / optional arguments) than
+      # the protocol, the value for that method will be the arity discovered in
+      # the object.  (The desired arity can be accessed through the
+      # ClassProtocol::Signature for that method.)
+      Safer::IVar::export_reader(self, :table)
+      ##
+      # :attr_reader: report
+      # String describing the errors from +table+ in a more human-readable
+      # fashion.
+      Safer::IVar::export_reader(self, :report)
+
+      ##
+      # Create a new ClassProtocol::Violation object.
+      def initialize(table, report)
+        self.safer_classprotocol_violation__table = table
+        self.safer_classprotocol_violation__report = report
+      end
+      ##
+      # Compare two ClassProtocol::Violation objects for content equality.
+      def ==(other_object)
+        self.class == other_object.class &&
+          self.safer_classprotocol_violation__table == other_object.safer_classprotocol_violation__table
+      end
+    end
+
+    ##
+    # Hash of method_name => method.arity, describing a set of methods that
+    # we expect to see implemented in another class.  ClassProtocol will contain
+    # two of these objects - one describing class methods, and one describing
+    # instance methods.
+    class Signature
+      Safer::IVar::instance_variable(self, :table)
+      ##
+      # :attr_reader: table
+      # +Hash+ object, in which the keys are the names of methods, and the
+      # value for a key is the required arity of that method.
+      Safer::IVar::export_reader(self, :table)
+
+      ##
+      # Create a ClassProtocol::Signature object.
+      def initialize(table)
+        self.safer_classprotocol_signature__table = table
+      end
+      ##
+      # Compare two ClassProtocol::Signature objects for content equality.
+      def ==(other_object)
+        self.class == other_object.class &&
+          self.safer_classprotocol_signature__table == other_object.safer_classprotocol_signature__table
+      end
+
+      ##
+      # Given an object, and the name of the method for getting a named method
+      # from that object, check that the object implements this function
+      # signature.
+      def find_violations(object, get_method)
+        report = ''
+        have_error = false
+        error_table = Hash::new
+        self.safer_classprotocol_signature__table.each_pair do |name, arity|
+          begin
+            m = object.send(get_method, name)
+            if m.arity != arity
+              report += "#{get_method}(#{name}) arity #{m.arity} != desired #{arity}.\n"
+              error_table[name] = m.arity
+              have_error = true
+            end
+          rescue NameError => e
+            report += "#{get_method}(#{name}) unimplemented.\n"
+            error_table[name] = true
+            have_error = true
+          end
+        end
+
+        if have_error
+          Safer::ClassProtocol::Violation.new(error_table, report)
+        else
+          nil
+        end
+      end
+
+      ##
+      # Derive a Signature from an object.
+      def self.create(object, get_methods, get_method, &filter)
+        method_names = object.send(get_methods)
+        method_table = Safer::ClassProtocol._array_to_table(method_names) do
+          |h, method_name|
+          if filter.call(method_name)
+            m = object.send(get_method, method_name)
+            m.arity
+          end
+        end
+        self.new(method_table)
+      end
+    end
+
+    ## Safer::ClassProtocol::Error
+    # Error generated when a class does not conform to a protocol signature.
+    class Error < StandardError
+      Safer::IVar::instance_variable(self, :error_object)
+      Safer::IVar::instance_variable(self, :protocol)
+      Safer::IVar::instance_variable(self, :class_violations)
+      Safer::IVar::instance_variable(self, :instance_violations)
+      Safer::IVar::instance_variable(self, :report)
+
+      ##
+      # :attr_reader: error_object
+      # Object that does not properly implement a desired method protocol.
+      Safer::IVar::export_reader(self, :error_object)
+      ##
+      # :attr_reader: protocol
+      # ClassProtocol object describing the signature that error_object failed
+      # to properly implement.
+      Safer::IVar::export_reader(self, :protocol)
+      ##
+      # :attr_reader: class_violations
+      # ClassProtocol::Violation describing class-method protocol violations.
+      Safer::IVar::export_reader(self, :class_violations)
+      ##
+      # :attr_reader: instance_violations
+      # ClassProtocol::Violation describing instance-method protocol violations.
+      Safer::IVar::export_reader(self, :instance_violations)
+      ##
+      # :attr_reader: report
+      # String for displaying human-readable error message describing protocol
+      # violations.
+      Safer::IVar::export_reader(self, :report)
+
+
+      ##
+      # Create a Safer::ClassProtocol::Error object.
+      # Used internally.
+      def initialize(message, error_object, protocol, class_violations, instance_violations)
+        super(message)
+        self.safer_classprotocol_error__error_object = error_object
+        self.safer_classprotocol_error__protocol = protocol
+        self.safer_classprotocol_error__class_violations = class_violations
+        self.safer_classprotocol_error__instance_violations = instance_violations
+        report = ''
+        if class_violations
+          report +=
+            "Class method errors:\n" +
+            self.safer_classprotocol_error__class_violations.report
+          if instance_violations
+            report += "\n\n"
+          end
+        end
+        if instance_violations
+          report +=
+            "Instance method errors:\n" +
+            self.safer_classprotocol_error__instance_violations.report
+        end
+        self.safer_classprotocol_error__report = report
+      end # Safer::ClassProtocol::Error#initialize
+
+      ##
+      # Compare two Safer::ClassProtocol::Error objects for content equality.
+      def ==(other_object)
+        self.class == other_object.class &&
+          self.error_object == other_object.error_object &&
+          self.protocol == other_object.protocol &&
+          self.class_violations == other_object.class_violations &&
+          self.instance_violations == other_object.instance_violations
+      end
+
+      ##
+      # Error generated when a Class object does not conform to a desired
+      # protocol.
+      class ClassError < Safer::ClassProtocol::Error
+        ##
+        # Create a Safer::ClassProtocol::Error::ClassError object.
+        def initialize(error_object, protocol, class_violations, instance_violations)
+          super(
+            "Class #{error_object} does not implement protocol" +
+              "#{protocol.name}.",
+            error_object, protocol, class_violations, instance_violations)
+        end
+      end # Safer::ClassProtocol::Error::ClassError
+
+      ##
+      # Error generated when an instance object does not conform to a desired
+      # protocol.
+      class InstanceError < Safer::ClassProtocol::Error
+        ##
+        # Create a Safer::ClassProtocol::Error::InstanceError object.
+        def initialize(error_object, protocol, class_violations, instance_violations)
+          super(
+            "Instance of #{error_object.class} does not implement protocol" +
+              "#{protocol.name}.",
+            error_object, protocol, class_violations, instance_violations)
+        end
+      end # Safer::ClassProtocol::Error::InstanceError
+    end # Safer::ClassProtocol::Error
+
+
+    Safer::IVar::instance_variable(self, :name)
+    Safer::IVar::instance_variable(self, :class_signature)
+    Safer::IVar::instance_variable(self, :instance_signature)
+
+    ##
+    # :attr_reader: name
+    # Name of this protocol signature.  Typically derived from the class name
+    # from which this signature is derived.
+    Safer::IVar::export_reader(self, :name)
+    ##
+    # :attr_reader: class_signature
+    # Signatures of required class methods for objects implementing this
+    # protocol.
+    Safer::IVar::export_reader(self, :class_signature)
+    ##
+    # :attr_reader: instance_signature
+    # Signatures of required instance methods for objects implementing this
+    # protocol.
+    Safer::IVar::export_reader(self, :instance_signature)
+
+    ##
+    # Create a +ClassProtocol+ object.
+    # Used internally.
+    # [+name+] Value for +name+ field object.
+    # [+class_signature+] Value for +class_signature+ field.
+    # [+instance_signature+] Value for +instance_signature+ field.
+    def initialize(name, class_signature, instance_signature)
+      self.safer_classprotocol__name = name
+      self.safer_classprotocol__class_signature = class_signature
+      self.safer_classprotocol__instance_signature = instance_signature
+    end # Safer::ClassProtocol#initialize
+
+    ##
+    # Check that a Class object conforms to this protocol.
+    def class_conforms?(klass)
+      class_violations = self.safer_classprotocol__class_signature.find_violations(klass, :method)
+      instance_violations = self.safer_classprotocol__instance_signature.find_violations(klass, :instance_method)
+      if class_violations || instance_violations
+        raise(Error::ClassError.new(klass, self, class_violations, instance_violations))
+      end
+      true
+    end # Safer::ClassProtocol#class_conforms?
+    ##
+    # Check that an instance object conforms to this protocol.
+    def instance_conforms?(instance)
+      class_violations = self.safer_classprotocol__class_signature.find_violations(instance.class, :method)
+      instance_violations = self.safer_classprotocol__instance_signature.find_violations(instance, :method)
+      if class_violations || instance_violations
+        raise(Error::InstanceError.new(instance, self, class_violations, instance_violations))
+      end
+      true
+    end # Safer::ClassProtocol#instance_conforms?
+
+    ##
+    # Given a +Class+ object +klass+ and a +Class+ object +base+, create a
+    # +ClassProtocol+ object representing the methods implemented in +klass+
+    # that are not present in +base+.
+    # [+klass+] +Class+ object from which to derive a +ClassProtocol+.
+    # [+base+] +Class+ object describing routines that will be implemented by
+    #          +klass+, but which should not be included in the returned
+    #          +ClassProtocol+.
+    def self.create_from_class(klass, base = Object)
+      class_signature = Signature.create(klass, :methods, :method) do
+        |method_name|
+        ! Class.respond_to?(method_name)
+      end
+      baseinstance_table = self._array_to_table(base.instance_methods)
+      instance_signature = Signature.create(klass, :instance_methods, :instance_method) do
+        |method_name|
+        ! baseinstance_table.has_key?(method_name)
+      end
+
+      self.new(klass.to_s, class_signature, instance_signature)
+    end # Safer::ClassProtocol.create_from_class
+
+    ##
+    # Given an instance object +instance+ and a +Class+ object +baseclass+,
+    # create a +ClassProtocol+ object representing the methods implemented in
+    # +klass+ that are not present in +base+.
+    def self.create_from_instance(instance, baseclass = Object)
+      class_signature = Signature.create(instance.class, :methods, :method) do
+        |method_name|
+        ! Class.method_defined?(method_name)
+      end
+      baseinstance_table = self._array_to_table(base.instance_methods)
+      instance_signature = Signature.create(instance, :methods, :method) do
+        |method_name|
+        ! baseinstance_table.has_key?(method_name)
+      end
+
+      self.new(instance.class.to_s, class_signature, instance_signature)
+    end # Safer::ClassProtocol.create_from_instance
+
+  end # Safer::ClassProtocol
+end # Safer

data/lib/safer.rb

@@ -0,0 +1,8 @@
+##
+# Safer is an umbrella library, whose components are designed to improve
+# the safety of your code.
+module Safer
+  ##
+  # Current release of Safer.
+  VERSION = "0.1.0"
+end

data/test/test_safer_ivar.rb

@@ -0,0 +1,85 @@
+require 'safer/ivar'
+require 'test/unit'
+
+module Root
+  class Test
+    class Instance
+      Safer::IVar::instance_variable(self, :instance)
+    end
+    class Reader
+      Safer::IVar::instance_variable(self, :instance)
+      Safer::IVar::export_reader(self, :instance)
+    end
+    class Writer
+      Safer::IVar::instance_variable(self, :instance)
+      Safer::IVar::export_writer(self, :instance)
+    end
+    class Accessor
+      Safer::IVar::instance_variable(self, :instance)
+      Safer::IVar::export_accessor(self, :instance)
+    end
+  end
+end
+
+class TC_SaferIVar < Test::Unit::TestCase
+  def setup
+  end
+  def teardown
+  end
+
+  def assert_no_respond_to(object, method, message="")
+    _wrap_assertion do
+      full_message = 
+        build_message(
+          nil,
+          "<?>\ngiven as the method name argument to #assert_no_respond_to " +
+            "must be a Symbol or #respond_to\\?(:to_str).",
+          method
+        )
+
+      assert_block(full_message) do
+        method.kind_of?(Symbol) || method.respond_to?(:to_str)
+      end
+      full_message = 
+        build_message(
+          message, "<?>\nof type <?>\nnot expected to respond_to\\\\?<?>.\n",
+          object, object.class, method
+        )
+      assert_block(full_message) { not object.respond_to?(method) }
+    end
+  end
+
+  def test_class_symbol_prefix
+    assert_equal("root", Safer::IVar::class_symbol_prefix(Root))
+    assert_equal("root_test", Safer::IVar::class_symbol_prefix(Root::Test))
+    assert_equal("root_test_instance", Safer::IVar::class_symbol_prefix(Root::Test::Instance))
+    k = Root.class_eval("$k = Class::new(Root::Test::Instance)")
+    assert_same(nil, Safer::IVar::class_symbol_prefix(k))
+    b = k.class_eval("class Blah ; end ; Blah")
+    assert_equal("blah", Safer::IVar::class_symbol_prefix(b))
+  end
+
+  def test_instance
+    test_accessors = proc do |obj, expectRead, expectWrite|
+      if expectRead
+        assert_respond_to(obj, :instance)
+      else
+        assert_no_respond_to(obj, :instance)
+      end
+      if expectWrite
+        assert_respond_to(obj, :instance=)
+      else
+        assert_no_respond_to(obj, :instance=)
+      end
+    end
+    ti = Root::Test::Instance::new
+    assert_respond_to(ti, :root_test_instance__instance)
+    test_accessors.call(ti, false, false)
+    tr = Root::Test::Reader::new
+    test_accessors.call(tr, true, false)
+    tw = Root::Test::Writer::new
+    test_accessors.call(tw, false, true)
+    ta = Root::Test::Accessor::new
+    test_accessors.call(ta, true, true)
+  end
+end

data/test/test_safer_protocol.rb

@@ -0,0 +1,144 @@
+require 'safer/protocol'
+require 'test/unit'
+
+module ArityModule
+  def arity_empty
+  end
+  def arity_1(one)
+  end
+  def arity_2(one, two)
+  end
+  def arity_any(*args)
+  end
+  def arity_2_any(one, two, *args)
+  end
+  METHODS = %w(empty 1 2 any 2_any).map do |suffix| "arity_#{suffix}".to_sym end
+end
+
+class TestArityClass
+  extend ArityModule
+end
+class TestArityInstance
+  include ArityModule
+end
+class TestArityBoth
+  extend ArityModule
+  include ArityModule
+end
+
+class TestArityError
+  include ArityModule
+  def arity_empty(blah)
+  end
+end
+
+class TC_SaferProtocol < Test::Unit::TestCase
+  def setup
+    @class_protocol = Safer::ClassProtocol.create_from_class(TestArityClass)
+    @instance_protocol = Safer::ClassProtocol.create_from_class(TestArityInstance)
+    @both_protocol = Safer::ClassProtocol.create_from_class(TestArityBoth)
+
+    @class_instance = TestArityClass::new
+    @instance_instance = TestArityInstance::new
+    @both_instance = TestArityBoth::new
+    @error_instance = TestArityError::new
+  end
+  def teardown
+    @class_protocol = nil
+    @instance_protocol = nil
+    @both_protocol = nil
+
+    @class_instance = nil
+    @instance_instance = nil
+    @both_instance = nil
+    @error_instance = nil
+  end
+
+  def get_methods(useinstance)
+    if useinstance
+      [ :instance_conforms?, proc do |obj| obj ; end, Safer::ClassProtocol::Error::InstanceError ]
+    else
+      [ :class_conforms?, proc do |obj| obj.class ; end, Safer::ClassProtocol::Error::ClassError ]
+    end
+  end
+
+  def test_signaturesCorrect
+    assert_equal(@both_protocol.class_signature, @class_protocol.class_signature)
+    assert_equal(@both_protocol.instance_signature, @instance_protocol.instance_signature)
+    assert_equal(@class_protocol.class_signature, @instance_protocol.instance_signature)
+    arity_methods = ArityModule::METHODS.map do |meth| meth.to_s end.sort
+    assert_equal(@class_protocol.class_signature.table.keys.sort, arity_methods)
+  end
+
+  def run_shouldConform(useinstance)
+    conforms_method, object_get, except_type = get_methods(useinstance)
+    assert_nothing_thrown do
+      @class_protocol.send(conforms_method, object_get.call(@class_instance))
+      @instance_protocol.send(conforms_method, object_get.call(@instance_instance))
+      @both_protocol.send(conforms_method, object_get.call(@both_instance))
+      @class_protocol.send(conforms_method, object_get.call(@both_instance))
+      @instance_protocol.send(conforms_method, object_get.call(@both_instance))
+    end
+  end
+  def test_shouldConform
+    run_shouldConform(false)
+    run_shouldConform(true)
+  end
+
+  def run_arity(useinstance)
+    conforms_method, object_get, except_type = get_methods(useinstance)
+    begin
+      @instance_protocol.send(conforms_method, object_get.call(@error_instance))
+      flunk("Expected exception.")
+    rescue Safer::ClassProtocol::Error => e
+      assert_same(e.class, except_type)
+      assert_same(object_get.call(@error_instance), e.error_object)
+      assert_same(@instance_protocol, e.protocol)
+      assert_same(nil, e.class_violations)
+      assert_equal({ 'arity_empty' => 1 }, e.instance_violations.table)
+    end
+  end
+  def test_arity
+    run_arity(false)
+    run_arity(true)
+  end
+
+  def run_classInstanceError(useinstance)
+    conforms_method, object_get, except_type = get_methods(useinstance)
+
+    class_instance_error = nil
+    begin
+      @instance_protocol.send(conforms_method, object_get.call(@class_instance))
+      flunk("Expected exception.")
+    rescue Safer::ClassProtocol::Error => e
+      assert_same(e.class, except_type)
+      assert_same(e.error_object, object_get.call(@class_instance))
+      assert_same(e.protocol, @instance_protocol)
+      assert_same(nil, e.class_violations)
+      assert_equal(e.instance_violations.table.keys.size, @instance_protocol.instance_signature.table.keys.size)
+      @instance_protocol.instance_signature.table.each_pair do |key, arity|
+        assert(e.instance_violations.table.has_key?(key))
+        assert_same(e.instance_violations.table[key], true)
+      end
+      class_instance_error = e
+    end
+
+    begin
+      @both_protocol.send(conforms_method, object_get.call(@class_instance))
+      flunk("Expected exception.")
+    rescue Safer::ClassProtocol::Error => e
+      assert_same(e.class, except_type)
+      assert_same(e.error_object, object_get.call(@class_instance))
+      assert_same(e.protocol, @both_protocol)
+      assert_equal(
+        e.instance_violations, class_instance_error.instance_violations)
+      assert_same(
+        e.class_violations, class_instance_error.class_violations)
+      assert_equal(e.report, class_instance_error.report)
+    end
+  end
+  def test_classInstanceError
+    run_classInstanceError(false)
+    run_classInstanceError(true)
+  end
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification 
+name: safer
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Aidan Cully
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-23 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rubyforge
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        - 0
+        - 4
+        version: 2.0.4
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 2
+        - 6
+        - 2
+        version: 2.6.2
+  type: :development
+  version_requirements: *id002
+description: |-
+  Safer is an umbrella library, with components designed to make it simple to
+  verify and improve the safety of your ruby code.  There are at present two
+  modules under the safer umbrella:
+  
+  [<tt>Safer::IVar</tt>]          generates specially-named accessor functions
+                                  for class instance variables.
+  [<tt>Safer::ClassProtocol</tt>] is used to provide a ruby analogue to
+                                  Objective-C Protocols (which are similar to
+                                  Java interfaces, but do not require
+                                  inheritance).
+email: 
+- aidan@panix.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- .autotest
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/safer.rb
+- lib/safer/ivar.rb
+- lib/safer/protocol.rb
+- test/test_safer_ivar.rb
+- test/test_safer_protocol.rb
+has_rdoc: true
+homepage: http://safer.rubyforge.org/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: aidancully
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Safer is an umbrella library, with components designed to make it simple to verify and improve the safety of your ruby code
+test_files: 
+- test/test_safer_ivar.rb
+- test/test_safer_protocol.rb