strongtyping 2.0.6-x86-mswin32-60

data/strongtyping.h

@@ -0,0 +1,34 @@
+/*
+    StrongTyping - Method parameter checking for Ruby
+    Copyright (C) 2003  Ryan Pavlik
+
+    This library 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 Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+*/
+
+#ifndef __GNUC__
+     /* We can use this extension to get rid of some superfluous warnings */
+#    define __attribute__(x)
+#    define MAXARGS (128)
+#else
+#    define MAXARGS (argc/2)
+#endif
+
+#define UNUSED __attribute__ ((unused))
+
+VALUE mStrongTyping;
+VALUE cQueryParams;
+VALUE eArgumentTypeError, eOverloadError, eArgList;
+ID    id_isa, id_class, id_inspect;
+

data/t/test.rb

@@ -0,0 +1,100 @@
+require 'test/unit'
+require 'strongtyping'
+include StrongTyping
+
+class TS_StrongTyping < Test::Unit::TestCase
+  def test_expect
+    assert_raises(ArgumentTypeError) {
+      foo("hello", 2, 3)
+    }
+
+    assert_nothing_raised {
+      optional(1)
+      optional(1, 2)
+    }
+
+    assert_raises(ArgumentTypeError) {
+      optional(1, "abc")
+    }
+
+    assert_raises(ArgumentTypeError) {
+      optional2(nil, "abc")
+    }
+  end #m:test_expect
+
+  def test_overload
+    assert_nothing_raised {
+      add
+      add 1, 2
+      add "a", "b"
+    }
+
+    assert_raises(RuntimeError) {
+      add "a", 2
+    }
+
+    assert_raises(OverloadError) {
+      add 2, "a"
+    }
+  end #m:test_overload
+
+
+  def test_get_arg_types
+    assert_equal([[]], get_arg_types(method(:blank)))
+
+    assert_equal([[String, Integer, String]],
+                 get_arg_types(method(:foo)))
+
+    assert_equal([[Integer, [Integer, NilClass]]],
+                 get_arg_types(method(:optional)))
+
+    assert_equal([[], [Integer, Integer], [String, String]],
+                 get_arg_types(method(:add)))
+  end #m:test_get_arg_types
+
+
+  def test_verify_args_for
+    a1 = [1, 2]
+    a2 = ["a", 2]
+
+    assert(verify_args_for(method(:add), a1))
+    assert(!verify_args_for(method(:add), a2))
+  end #m:test_verify_args_for
+end #c:TS_StrongTyping
+
+
+##
+## Helpers
+##
+
+def blank
+end #m:blank
+
+def foo(a, b, c)
+  expect(a, String, b, Integer, c, String)
+  print "#{a} found #{b} #{c}\n"
+end
+
+def optional(a, b = nil)
+  expect(a, Integer, b, [Integer, NilClass])
+  return a + b   if b
+  return a
+end
+
+def optional2(a, b)
+  expect(a, [Integer, NilClass], b, Integer)
+end
+
+# useful, but demonstrates it works
+def add (*args)
+  overload(args) { return }
+  overload(args, Integer, Integer) { | a, b | return }
+  overload(args, String, String)   { | a, b | return }
+
+  overload_exception(args, String, Integer) {
+    | a, b |
+    raise "I'm not going there."
+  }
+
+  overload_default args
+end

data/t/timetest.rb

@@ -0,0 +1,28 @@
+require 'strongtyping'
+include StrongTyping
+
+def timeblock(msg = nil)
+  start  = Time::now.to_f
+  yield
+  finish = Time::now.to_f
+
+  print "[#{msg}] " if msg
+  print "Total time: #{finish - start}\n"
+
+  return finish - start
+end
+
+iterations = 100000
+
+time_0 = timeblock("Base Time") {
+  (1..iterations).each do |i| end
+}
+
+time_1 = timeblock("Expect") {
+  (1..iterations).each do
+    |i|
+    expect(1, Integer, "abc", String)
+  end
+}
+
+print "Difference for #{iterations} iterations: #{time_1 - time_0}\n"

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+name: strongtyping
+version: !ruby/object:Gem::Version 
+  version: 2.0.6
+platform: x86-mswin32-60
+authors: 
+- Ryan Pavlik
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-02-06 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Ruby module that provides type checking and method overloading
+email: rpav@mephle.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LGPL
+- README.en
+- MANIFEST
+files: 
+- extconf.rb
+- LGPL
+- MANIFEST
+- README.en
+- strongtyping.c
+- strongtyping.h
+- t/test.rb
+- t/timetest.rb
+- lib/strongtyping.so
+has_rdoc: true
+homepage: http://mephle.org/StrongTyping/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.0
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: shards
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: Ruby module that provides type checking and method overloading
+test_files: 
+- t/test.rb
+- t/timetest.rb