wanabe-definition 0.0.1

data/Changelog

@@ -0,0 +1,3 @@
+Fri Feb 13 14:25:30 (JST) 2009  wanabe  <matz@ruby-lang.org>
+
+	* initial release.

data/README

@@ -0,0 +1,38 @@
+definition
+==========
+
+Type striction for Ruby.
+
+WARNING
+-------
+This library is very experimental.
+Everything is under construction and fluid.
+
+How to use
+----------
+
+like this:
+
+module IFoo
+  as_interface
+  define::foo(Integer, String, Rest, Block)
+end
+class Foo
+  implement IFoo
+end
+Foo.new #=> NotImplementedError
+
+Licence
+-------
+Modified-BSD Licence.
+
+Copyright (c) 2009, wanabe
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+    * Neither the name of the <ORGANIZATION> nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/definition.gemspec

@@ -0,0 +1,12 @@
+Gem::Specification.new do |s|
+  s.name = "definition"
+  s.version = "0.0.1"
+  s.date = "2009-02-13"
+  s.summary = ""
+  s.email = "s.wanabe@gmail.com"
+  s.homepage = "http://github.com/wanabe/definition"
+  s.description = ""
+  s.has_rdoc = true
+  s.authors = [""]
+  s.files = ["Changelog", "README", "definition.gemspec", "lib/definition.rb", "test/tc_definition.rb"]
+end

data/lib/definition.rb

@@ -0,0 +1,239 @@
+#! /usr/local/bin/ruby
+# -*- coding: UTF-8 -*-
+
+class DefinitionError < StandardError
+end
+class Definition
+  module Const
+    module Block
+    end
+    module Rest
+    end
+    module Any
+      def self.===(other)
+        true
+      end
+    end
+  end
+  class Enroller
+    def initialize(defn, table)
+      @defn = defn
+      @table = table
+    end
+    def method_missing(name, *args)
+      @defn.set(args)
+      @table[name] ||= []
+      @table[name] << @defn
+    end
+  end
+
+  attr_reader :arity
+  def initialize(ret_type, root)
+    @ret_type = ret_type
+    @root = root
+  end
+  def to_enroll(table)
+    Enroller.new(self, table)
+  end
+  def assert_match(name, meth, implement)
+    begin
+      if meth.respond_to?(:parameters)
+        if meth.parameters.length != @arg_types.length
+          message = "%s: arity mismatch (%i for %i)"
+          raise DefinitionError, message, name, meth.parameters.length,
+          @arg_types.length
+        end
+        meth.parameters.each_with_index do |param, i|
+          type, var = param
+          arg_type = @arg_types[i]
+          case type
+          when :req, :opt
+            next if arg_type != Const::Rest && arg_type != Const::Block
+          when :rest
+            next if arg_type == Const::Rest
+          when :block
+            next if arg_type == Const::Block
+          end
+          raise DefinitionError, "%s: arg %i: definition mismatch", name, i
+        end
+      elsif meth.arity != @arity
+        message = "%s: arity mismatch (%i for %i)"
+        raise DefinitionError, message, name, meth.arity, @arity
+      end
+    rescue DefinitionError
+      implement.module_eval { remove_method(name) }
+      Kernel.raise
+    end
+  end
+  def set(arg_types)
+    @arg_types = arg_types
+    @arity = arg_types.length
+    if arg_types.last == Const::Block
+      @arity -= 1
+      @block = true
+    end
+    @arity = -@arity if arg_types.include?(Const::Rest)
+  end
+  def assert_args(args)
+    start_index = 0
+    length = args.length
+    args.each_with_index do |arg, i|
+      next if i < start_index
+      break if i >= length
+      arg_type = @arg_types[i]
+      if arg_type == Definition::Const::Rest
+        start_index = @arity + args.length + i + 1
+      elsif !(arg_type === arg)
+        raise ArgumentError, "arg %i: not %p === %p", i, arg_type, arg
+      end
+    end
+  end
+  def assert_ret(ret)
+    ret_type = @ret_type
+    unless ret_type === ret
+      raise TypeError, "return value: not %p === %p", ret_type, ret
+    end
+  end
+  def raise(exclass, message, *args)
+    message = sprintf(message, *args)
+    if @root.ancestors.include? Interface
+      message << " (interface #{@root})"
+    else
+      message << " (implementation #{@root})"
+    end
+    super exclass, message
+  end
+end
+module Interface
+  include Definition::Const
+  module InterfaceMethods
+    def included(mod)
+      mod.extend InterfaceMethods
+      mod.init_table @define_table
+    end
+    def init_table(table)
+      @define_table ||= {}
+      if table
+        table.each do |name, defs|
+          @define_table[name] = defs.dup
+        end
+      end
+    end
+    def each(&block)
+      @define_table.each(&block)
+    end
+    def define(ret=Definition::Const::Any)
+      defn = Definition.new(ret, self)
+      return defn.to_enroll(@define_table)
+    end
+    def [](name)
+      return @define_table[name]
+    end
+  end
+  extend InterfaceMethods
+end
+module Implementation
+  include Definition::Const
+  def self.included(klass)
+    klass.module_eval do
+      extend Implementation::ImplMethods
+      impl_initialize
+    end
+  end
+  module ImplMethods
+    NEW = Class.instance_method(:new)
+    def new
+      assert_implemented unless @skip_assertion
+      NEW.bind(self).call
+    end
+    def define(ret=Definition::Const::Any)
+      defn = Definition.new(ret, self)
+      return defn.to_enroll(@define_table)
+    end
+    def implement(interface)
+      interface.each do |name, defs|
+        @define_table[name] ||= []
+        @define_table[name] += defs
+      end
+    end
+    def assert_implemented(once = false)
+      nodefs = @define_table.keys - instance_methods(true).map{|m|m.to_sym}
+      unless nodefs.empty?
+        raise NotImplementedError, "not implemented #{nodefs.join(', ')}"
+      end
+      @skip_assertion ||= once
+    end
+    def assert_args(name, args)
+      defns = @define_table[name]
+      defns.each {|defn| defn.assert_args(args)}
+    end
+    def assert_ret(name, ret)
+      defns = @define_table[name]
+      defns.each {|defn| defn.assert_ret(ret)}
+      return ret
+    end
+    def impl_initialize(table = {})
+      @define_table = table
+    end
+    private
+    def included(klass)
+      klass.extend Implementation::ImplMethods
+      inherited(klass)
+    end
+    def inherited(klass)
+      klass.impl_initialize(@define_table)
+      assert_implemented
+    end
+    def method_added(name)
+      return if @in_addition_check
+      begin
+        @in_addition_check = true
+        check_definition(name)
+        add_assertion(name)
+      ensure
+        @in_addition_check = false
+      end
+    end
+    def check_definition(name)
+      @define_table[name].each do |defn|
+        defn.assert_match name, instance_method(name), self
+      end
+    end
+    def add_assertion(name)
+      num = 0
+      new_name = name
+      new_name = "#{name}_#{num += 1}" while method_defined?(new_name)
+      alias_method new_name, name
+      module_eval <<-EOC, __FILE__, __LINE__ + 1
+      def #{name}(*args, &block)
+        self.class.assert_args(:#{name}, args)
+        self.class.assert_ret(:#{name}, #{new_name}(*args, &block))
+      end
+      EOC
+    end
+  end
+end
+class Module
+  def implement(*interfaces)
+    as_implementation
+    interfaces.each do |interface|
+      implement(interface)
+    end
+  end
+  def define(ret=Definition::Const::Any)
+    as_implementation
+    define(ret)
+  end
+  private
+  def as_implementation
+    include Implementation unless include?(Implementation)
+  end
+  def as_interface
+    include Interface unless include?(Interface)
+  end
+end
+
+if __FILE__ == $0
+  $" << "definition.rb"
+  load "../test/tc_definition.rb"
+end

data/test/tc_definition.rb

@@ -0,0 +1,192 @@
+# -*- coding: UTF-8 -*-
+require 'test/unit'
+require 'rubygems'
+require 'definition'
+
+class TC_Foo < Test::Unit::TestCase
+  module IFoo
+    as_interface
+    define::foo(Integer, String, Rest, Block)
+  end
+  module IBar
+    as_interface
+    define(Any).bar(Integer)
+  end
+  module IFooBar
+    include IFoo, IBar
+    define.foo(10..20, Any, Rest, Block)
+  end
+  module IBar2
+    include IBar
+    define(Any).bar(0..10)
+  end
+
+  def test_arity
+    mismatch_arity_class = Class.new
+    mismatch_arity_class.implement IFoo
+    
+    assert_raise(DefinitionError) do
+      mismatch_arity_class.module_eval do
+        implement IFoo
+        def foo(a, b, c, *d, &e)
+        end
+      end
+    end
+    assert_raise(DefinitionError) do
+      mismatch_arity_class.module_eval do
+        def foo(a, *b, &c)
+        end
+      end
+    end
+  end
+  def test_after_rescue
+    defective_module = Module.new
+    defective_class = Class.new
+    defective_module.implement IFoo
+    
+    assert_raise(NotImplementedError) do
+      defective_class.module_eval do
+        include defective_module
+      end
+    end
+    assert_raise(NotImplementedError) do
+      defective_class.new
+    end
+  end
+  def test_rest
+    mismatch_rest_class1 = Class.new
+    mismatch_rest_class1.implement IFoo
+    mismatch_rest_class2 = Class.new
+    mismatch_rest_class2.implement IBar
+    
+    assert_raise(DefinitionError) do
+      mismatch_rest_class1.module_eval do
+        def foo(a, b, c, &d)
+        end
+      end
+    end
+    assert_raise(DefinitionError) do
+      mismatch_rest_class1.module_eval do
+        def foo(a, b, &d)
+        end
+      end
+    end
+    assert_raise(DefinitionError) do
+      mismatch_rest_class2.module_eval do
+        def bar(a, *b)
+        end
+      end
+    end
+    assert_raise(DefinitionError) do
+      mismatch_rest_class2.module_eval do
+        def bar(*a)
+        end
+      end
+    end
+  end
+  def test_correct
+    correct_class = Class.new
+    correct_class.implement IFoo
+    
+    assert_nothing_raised do
+      correct_class.module_eval do
+        def foo(a, b, *c, &d)
+        end
+      end
+      correct_class.new.foo(1, "a")
+    end
+  end
+  def test_defective
+    defective_class = Class.new
+    defective_class.module_eval do
+      define(String).baz
+    end
+    
+    assert_raise(NotImplementedError) do
+      Class.new(defective_class)
+    end
+    assert_raise(NotImplementedError) do
+      defective_class.new
+    end
+  end
+  def test_retval
+    baz_class = Class.new
+    baz_class.module_eval do
+      define(String).baz
+      def baz
+        :ng
+      end
+    end
+    
+    assert_raise(TypeError) do
+      baz_class.new.baz
+    end
+    baz_class.module_eval do
+      def baz
+        "ok"
+      end
+    end
+    assert_equal(baz_class.new.baz, "ok")
+  end
+  def test_argument
+    foobar_class = Class.new
+    foobar_class.module_eval do
+      implement IFooBar, IBar2
+      def foo(a, b, *c, &d)
+      end
+      def bar(a)
+      end
+    end
+    o = foobar_class.new
+    assert_raise(ArgumentError) do
+      o.foo(1,"a")
+    end
+    assert_raise(ArgumentError) do
+      o.foo(10,2)
+    end
+    assert_raise(ArgumentError) do
+      o.bar(:ng)
+    end
+    assert_raise(ArgumentError) do
+      o.bar(-1)
+    end
+    assert_nothing_raised do
+      o.foo(10,"a")
+      o.bar(1)
+    end
+  end
+  if RUBY_VERSION >= "1.9"
+    def test_arg_after_rest
+      class_arg_after_rest = Class.new
+      class_arg_after_rest.module_eval do
+        define.foo(Any, Rest, Range)
+      end
+      assert_raise(DefinitionError) do
+        class_arg_after_rest.module_eval do
+          def foo(a, *b)
+          end
+        end
+      end
+      assert_raise(DefinitionError) do
+        class_arg_after_rest.module_eval do
+          def foo(a, b, *c)
+          end
+        end
+      end
+      assert_nothing_raised do
+        class_arg_after_rest.module_eval do
+          eval "def foo(a, *b, c);end"
+        end
+      end
+    end
+    def test_block
+      assert_raise(DefinitionError) do
+        Class.new.module_eval do
+          define.foo
+          def foo(&a)
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification 
+name: wanabe-definition
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- ""
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-13 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: ""
+email: s.wanabe@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Changelog
+- README
+- definition.gemspec
+- lib/definition.rb
+- test/tc_definition.rb
+has_rdoc: true
+homepage: http://github.com/wanabe/definition
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: ""
+test_files: []
+