tsalzer-typesafe 0.0.0 → 0.0.1

data/README.rdoc

@@ -1,6 +1,6 @@
 = typesafe
 
-Typesafe is a tiny extension to core Ruby to simplify checks for
+TypeSafe is a tiny extension to core Ruby to simplify checks for
 kind_of?.
 
 == Note on Patches/Pull Requests
@@ -10,8 +10,7 @@ kind_of?.
 * Add tests for it. This is important so I don't break it in a
   future version unintentionally.
 * Commit, do not mess with rakefile, version, or history.
-  (if you want to have your own version, that is fine but
-   bump version in a commit by itself I can ignore when I pull)
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
 * Send me a pull request. Bonus points for topic branches.
 
 == Copyright

data/VERSION

@@ -1 +1 @@
-0.0.0
+0.0.1

data/lib/typesafe.rb

@@ -1,51 +1,67 @@
 # additional features for all objects
 
-class TypeCheckError < RuntimeError ; end
-
+# TypeSafe module.
+# This module will be included into Object to provide Object#must_be_kind_of.
+#
+# Usage
+#
+# If you need e.g. an argument be of a specific type, you can simply write
+#
+#  def myfunc(arg)
+#    arg.must_be_kind_of(MyFancyClass)
+#    arg.do_fancy_stuff
+#  end
+#
+# This would raise a TypeError in case you somehow passed in a type not matching
+# your MyFancyClass, which would stop your app dead at a point you know. This is
+# probably better than chasing the wrong parameter all the way down your application.
+#
+# However, being dynamic, you might just need to apply a special treatment to your
+# argument in case it's not what you would expect:
+#
+#  def my2ndfunc(arg)
+#    puts arg.must_be_kind_of(String) {|x| x.to_s}
+#  end
+# 
+# In this second case, no exception is raised, but your block is executed. Most
+# important, the return value of your block is returned as value from the method.
+#
 module TypeSafe
-module ObjectTypeChecks
-  # this object must be kind of a given class.
-  def must_be_kind_of(clss)
-    if clss.kind_of?(Module)
-      raise TypeCheckError.new("#{self} must include module #{clss}") unless self.kind_of?(clss)
-    elsif clss.kind_of?(Class)
-      raise TypeCheckError.new("#{self} must be of type #{clss}") unless self.kind_of?(clss)
+  # this class or object must be kind of a given class.
+  # Method returns <tt>self</tt> unless it raises a TypeError.
+  def must_be_kind_of(clss, &blk)
+    if clss.kind_of?(Module) or clss.kind_of?(Class)
+      matched = if self.kind_of?(Class)
+        # classes are expected to "descend" from comparator
+        if self != clss
+          self.superclass ? self.superclass.must_be_kind_of(clss) : self.kind_of?(clss)
+        else
+          true
+        end
+      else
+        # objects are expected to implement comparator
+        self.kind_of?(clss)
+      end
+      
+      unless matched
+        if blk
+          return yield self.class
+        else
+          raise TypeError.new("#{self} must be of type #{clss}")
+        end
+      end
     else
       raise "class to check #{self} for must be a Class or Module, but is  #{clss}"
     end
-    true
+    self
   end
   alias must_be_a must_be_kind_of
 
-  # this object must be kind of a given class.
-  def must_be_nil_or_kind_of(clss)
-    self.kind_of?(NilClass) ? true : must_be_kind_of(clss)
+  # this class or object must be kind of a given class or nil.
+  # This method is probably a bad idea, so it will be removed.
+  def must_be_nil_or_kind_of(clss, &blk)
+    self.kind_of?(NilClass) ? true : must_be_kind_of(clss, &blk)
   end
-
-end#ObjectTypeChecks
-
-module ClassTypeChecks
-  # this object must be kind of a given class.
-  def class_must_be_kind_of(clss)
-    if clss.kind_of?(Module)
-      raise TypeCheckError.new("#{self} must include module #{clss}") unless self.kind_of?(clss)
-    elsif clss.kind_of?(Class)
-      raise TypeCheckError.new("#{self} must be of type #{clss}") unless self.kind_of?(clss)
-    else
-      raise "class to check #{self} for must be a Class or Module, but is  #{clss}"
-    end
-    true
-  end
-  alias class_must_be_a class_must_be_kind_of
-  
-  # this object must be kind of a given class.
-  def must_be_nil_or_kind_of(clss)
-    self.kind_of?(NilClass) ? true : must_be_kind_of(clss)
-  end
-  
-end#ClassTypeChecks
-
-Object.send :include, ObjectTypeChecks
-Class.send :include, ClassTypeChecks
-
 end#TypeSafe
+
+Object.send :include, TypeSafe

data/spec/spec_helper.rb

@@ -7,3 +7,24 @@ require 'spec/autorun'
 Spec::Runner.configure do |config|
   
 end
+
+# a class hierarchy to check
+
+# plain module
+module ModA
+end
+# plain class
+class ClassA
+end
+# class derived from ClassA
+class ClassB < ClassA
+end
+# plain class, extends module ModA, thereby descending ModA
+class ClassC
+  extend ModA
+end
+# plain class, includes module ModA, thereby not descending ModA
+class Classd
+  include ModA
+end
+

data/spec/typesafe_class_coreclasses_spec.rb

@@ -0,0 +1,16 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe TypeSafe, ".must_be_kind_of" do
+  it "should recognize Class as kind of Object" do
+    lambda{Class.must_be_kind_of(Object)}.should_not raise_error(TypeError)
+  end
+  it "should recognize Object as kind of Class" do
+    lambda{Object.must_be_kind_of(Class)}.should_not raise_error(TypeError)
+  end
+  it "should recognize Fixnum as kind of Integer" do
+    lambda{Fixnum.must_be_kind_of(Integer)}.should_not raise_error(TypeError)
+  end
+  it "should recognize Bignum as kind of Integer" do
+    lambda{Bignum.must_be_kind_of(Integer)}.should_not raise_error(TypeError)
+  end
+end

data/spec/typesafe_class_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe TypeSafe, ".must_be_kind_of" do
+  it "should recognize ClassA as kind of Object" do
+    lambda{ClassA.must_be_kind_of(Object)}.should_not raise_error(TypeError)
+  end
+  it "should recognize ClassB as kind of ClassA" do
+    lambda{ClassB.must_be_kind_of(ClassA)}.should_not raise_error(TypeError)
+  end
+  it "should not recognize ClassC as kind of ClassA" do
+    lambda{ClassC.must_be_kind_of(ClassA)}.should raise_error(TypeError)
+  end
+  it "should not recognize ClassC as kind of ModA" do
+    lambda{ClassC.must_be_kind_of(ModA)}.should raise_error(TypeError)
+  end
+  it "should recognize ClassD as kind of ModA" do
+    lambda{ClassD.must_be_kind_of(ModA)}.should_not raise_error(TypeError)
+  end
+end

data/spec/typesafe_spec.rb

@@ -6,21 +6,46 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
       Object.new.should respond_to(method)
     end
     it "should recognize a simple type" do
-      lambda{1.send method, Fixnum}.should_not raise_error(TypeCheckError)
+      lambda{1.send method, Fixnum}.should_not raise_error(TypeError)
     end
     it "should recognize parent classes" do
-      lambda{self.send method, Object}.should_not raise_error(TypeCheckError)
+      lambda{self.send method, Object}.should_not raise_error(TypeError)
     end
-    it "should raise a TypeCheckError for mismatching types" do
-      lambda{"1".send method, Fixnum}.should raise_error(TypeCheckError)
+    it "should raise a TypeError for mismatching types" do
+      lambda{"1".send method, Fixnum}.should raise_error(TypeError)
     end
+    it "should not raise a TypeError for mismatching types if a block was given" do
+      lambda{"1".send method, Fixnum do |clss|
+        clss.should be_a Class
+        clss.should == String
+        end}.should_not raise_error(TypeError)
+    end
+    it "should execute the given block for mismatching types" do
+      executed = false
+      lambda{"1".send method, Fixnum do |clss|
+        clss.should be_a Class
+        clss.should == String
+        executed = true
+        end}.should_not raise_error(TypeError)
+        executed.should == true
+    end
+    it "should not execute the given block for matching types" do
+      executed = false
+      lambda{1.send method, Fixnum do |clss|
+        clss.should be_a Class
+        clss.should == Fixnum
+        executed = true
+        end}.should_not raise_error(TypeError)
+        executed.should == false
+    end
+    
     it "should raise a RuntimeError if the given match is not a Class" do
       lambda{"1".send method, "Fixnum"}.should raise_error(RuntimeError)
-      lambda{"1".send method, "Fixnum"}.should_not raise_error(TypeCheckError)
+      lambda{"1".send method, "Fixnum"}.should_not raise_error(TypeError)
     end
     
-    it "should #{nil_allowed ? 'not ' : ''}raise a TypeCheckError for mismatching types on nil" do
-      lambda{nil.send method, Fixnum}.send nil_allowed ? :should_not : :should, raise_error(TypeCheckError)
+    it "should #{nil_allowed ? 'not ' : ''}raise a TypeError for mismatching types on nil" do
+      lambda{nil.send method, Fixnum}.send nil_allowed ? :should_not : :should, raise_error(TypeError)
     end
     
     it "should recognize included modules" do
@@ -29,7 +54,7 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
         include TestModule
       end
       o = TestClass.new
-      lambda{o.send method, TestModule}.should_not raise_error(TypeCheckError)
+      lambda{o.send method, TestModule}.should_not raise_error(TypeError)
     end
   end
 end

data/typesafe.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{typesafe}
-  s.version = "0.0.0"
+  s.version = "0.0.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Till Salzer"]
-  s.date = %q{2009-08-24}
+  s.date = %q{2009-08-26}
   s.description = %q{Simplifies typesafe development by providing the additional
       methods Object#must_by_kind_of ad Object#must_be_a.}
   s.email = %q{till.salzer@googlemail.com}
@@ -29,17 +29,20 @@ Gem::Specification.new do |s|
      "features/typesafe.feature",
      "lib/typesafe.rb",
      "spec/spec_helper.rb",
+     "spec/typesafe_class_coreclasses_spec.rb",
+     "spec/typesafe_class_spec.rb",
      "spec/typesafe_spec.rb",
      "typesafe.gemspec"
   ]
-  s.has_rdoc = true
   s.homepage = %q{http://github.com/tsalzer/typesafe}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.2}
+  s.rubygems_version = %q{1.3.5}
   s.summary = %q{provides Object#must_be_kind_of for typesafe development}
   s.test_files = [
     "spec/spec_helper.rb",
+     "spec/typesafe_class_coreclasses_spec.rb",
+     "spec/typesafe_class_spec.rb",
      "spec/typesafe_spec.rb"
   ]
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tsalzer-typesafe
 version: !ruby/object:Gem::Version 
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors: 
 - Till Salzer
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-24 00:00:00 -07:00
+date: 2009-08-26 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -53,9 +53,11 @@ files:
 - features/typesafe.feature
 - lib/typesafe.rb
 - spec/spec_helper.rb
+- spec/typesafe_class_coreclasses_spec.rb
+- spec/typesafe_class_spec.rb
 - spec/typesafe_spec.rb
 - typesafe.gemspec
-has_rdoc: true
+has_rdoc: false
 homepage: http://github.com/tsalzer/typesafe
 licenses: 
 post_install_message: 
@@ -84,4 +86,6 @@ specification_version: 3
 summary: provides Object#must_be_kind_of for typesafe development
 test_files: 
 - spec/spec_helper.rb
+- spec/typesafe_class_coreclasses_spec.rb
+- spec/typesafe_class_spec.rb
 - spec/typesafe_spec.rb