typelib 0.0.1 → 0.0.3

data/README.rdoc

@@ -0,0 +1,80 @@
+= TypeLib
+
+Typelib is a way of checking and converting data. It operates as a "filter
+chain" system which allows it to gradually normalize disparate data into a
+common type. Each chain is optionally a part of a list which allows it to
+provide several paths in a single external execution.
+
+The library is arguably very simple and therefore has simple requirements and
+needs. This is intentional.
+
+= Synopsis
+
+Here's a basic example which converts strings OR integers to integers. This
+sounds anti-climactic, but it allows us to take any kind of integer data and
+convert it safely.
+        
+    filters = TypeLib::FilterList.new
+    check   = proc { |obj| obj.kind_of?(Integer) }
+    convert = proc { |obj| obj }
+
+    check2   = proc { |obj| obj.kind_of?(String) and obj =~ /^\d+$/ }
+    convert2 = proc { |obj| Integer(obj) }
+
+    filters << TypeLib::Filter.new(check, convert)
+    filters << TypeLib::Filter.new(check2, convert2)
+
+    filters.execute(1)     # => 1
+    filters.execute("1")   # => 1
+    filters.execute("1.0") # => "1.0"
+
+TypeLib will just not do anything with data it doesn't understand, and return
+it. This is why the float in this example does nothing -- it doesn't match
+either of the checks.
+
+Filters can also take arguments that propogate into the checks and conversions
+via TypeLib::Filter#check and TypeLib::Filter#convert. Additionally, these
+arguments will be passed on from TypeLib::FilterList#execute.
+
+As mentioned prior, TypeLib can also chain. This allows us to say "if this
+check passes, do/try this, then run this next set of checks/conversions". This
+is the foundation of portable conversion, allowing us to sew together many
+checks and conversions to handle coercing any data into the right type.
+
+In the below check, any integers are converted to strings, and any string that
+looks like an integer gets coerced to float. Additionally, any string from the
+start that looks like an integer will also get converted to float. This is
+reuse of the chain without implying recursion. All parts of TypeLib can be
+reused at any point within the library's storage.
+
+    filters = TypeLib::FilterList.new
+
+    check   = proc { |obj| obj.kind_of?(Integer) }
+    convert = proc { |obj| obj.to_s }
+
+    check2   = proc { |obj| obj.kind_of?(String) and obj =~ /^\d+$/ }
+    convert2 = proc { |obj| obj.to_f }
+    
+    string_to_float = TypeLib::Filter.new(check2, convert2)
+
+    filters << TypeLib::Filter.new(
+        check, 
+        convert, 
+        TypeLib::FilterList.new([string_to_float])
+    )
+
+    filters << string_to_float
+
+    filters.execute(1)     # => 1.0
+    filters.execute("1.0") # => 1.0
+
+TypeLib also comes with a (slowly growing) number of canned checks that are
+optionally available. These are accessible in the 'typelib/canned' library and
+live in the TypeLib::Canned namespace.
+
+= Thanks
+
+== Contributed to design and review of the initial product
+
+* Dav3xor (David Case)
+* raggi (James Tucker)

data/Rakefile

@@ -12,7 +12,7 @@ include FileUtils::Verbose
 task :default => [ :test, :dist ]
 
 task :fixperms do
-    chmod(0755, Dir['bin/*'])  
+  chmod(0755, Dir['bin/*'])  
 end
 
 #
@@ -20,9 +20,9 @@ end
 #
 
 Rake::TestTask.new do |t|
-    t.libs << 'lib'
-    t.test_files = FileList['test/test*.rb']
-    t.verbose = true 
+  t.libs << 'lib'
+  t.test_files = FileList['test/test*.rb']
+  t.verbose = true 
 end
 
 #
@@ -38,11 +38,11 @@ task :clean     => [:distclean]
 #
 
 RDoc::Task.new do |rd|
-    rd.rdoc_dir = "rdoc"
-    rd.main = "README.rdoc"
-    rd.rdoc_files.include("README.rdoc")
-    rd.rdoc_files.include("./lib/**/*.rb")
-    rd.options = %w(-a)
+  rd.rdoc_dir = "rdoc"
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("README.rdoc")
+  rd.rdoc_files.include("./lib/**/*.rb")
+  rd.options = %w(-a)
 end
 
 #
@@ -50,25 +50,31 @@ end
 # 
 
 spec = Gem::Specification.new do |s|
-    s.name = "typelib"
-    s.version = TypeLib::VERSION
-    s.author = "Erik Hollensbe"
-    s.email = "erik@hollensbe.org"
-    s.summary = "An on-demand arbitrary check and conversion library that won't destroy your data."
+  s.name = "typelib"
+  s.version = TypeLib::VERSION
+  s.author = "Erik Hollensbe"
+  s.email = "erik@hollensbe.org"
+  s.summary = "An on-demand arbitrary check and conversion library that won't destroy your data."
+  s.homepage = "http://erik.hollensbe.org/docs/typelib/"
+  s.files = Dir["Rakefile"] + Dir["README.rdoc"] + Dir["lib/**/*"] + Dir['test/**/*']
 
-    s.files = Dir["Rakefile"] + Dir["README"] + Dir["lib/**/*"] + Dir['test/**/*']
-
-    s.has_rdoc = true
+  s.has_rdoc = true
+  s.add_development_dependency 'test-unit'
+  s.rdoc_options = %w(-a)
 end
 
 Rake::GemPackageTask.new(spec) do |s|
 end
 
 Rake::PackageTask.new(spec.name, spec.version) do |p|
-    p.need_tar_gz = true
-    p.need_zip = true
-    p.package_files.include("./bin/**/*")
-    p.package_files.include("./Rakefile")
-    p.package_files.include("./lib/**/*.rb")
-    p.package_files.include("README")
+  p.need_tar_gz = true
+  p.need_zip = true
+  p.package_files.include("./bin/**/*")
+  p.package_files.include("./Rakefile")
+  p.package_files.include("./lib/**/*.rb")
+  p.package_files.include("README")
+end
+
+task :to_blog => [:clobber_rdoc, :rdoc] do
+  sh "rm -fr $git/blog/content/docs/typelib && mv rdoc $git/blog/content/docs/typelib"
 end

data/lib/typelib.rb

@@ -12,62 +12,73 @@ require 'delegate'
 #
 module TypeLib
 
-    VERSION = "0.0.1"
+  VERSION = "0.0.3"
 
-    # A FilterList is a ... list of filters. It includes all the methods that
-    # Array contains, plus an additional method -- execute. See
-    # TypeLib::Filter.
-    class FilterList < DelegateClass(Array)
-        # Create a new FilterList. An array of TypeLib::Filter objects is
-        # accepted for construction.
-        def initialize(ary=[])
-            @filters = ary
-            super(@filters)
-        end
+  # A FilterList is a ... list of filters. It includes all the methods that
+  # Array contains, plus an additional method -- execute. See
+  # TypeLib::Filter.
+  class FilterList < DelegateClass(Array)
+    # Create a new FilterList. An array of TypeLib::Filter objects is
+    # accepted for construction.
+    def initialize(ary=[])
+      @filters = ary
+      super(@filters)
+    end
 
-        # Execute the checks in this list against +obj+, passing in +addl+
-        # if any additional arguments are provided. If the check passes, the
-        # conversion is run and the chain supplied to the constructor is
-        # followed. If no checks pass, the original item is returned.
-        def execute(obj, *addl)
-            ret = obj 
-            @filters.each do |filter|
-                if filter.check(obj, *addl)
-                    ret = filter.convert(obj, *addl)
-                    break
-                end
-            end
-            return ret
+    # Execute the checks in this list against +obj+, passing in +addl+
+    # if any additional arguments are provided. If the check passes, the
+    # conversion is run and the chain supplied to the constructor is
+    # followed. If no checks pass, the original item is returned.
+    def execute(obj, *addl)
+      ret = obj 
+      @filters.each do |filter|
+        if filter.check(obj, *addl)
+          ret = filter.convert(obj, *addl)
+          break
         end
+      end
+      return ret
     end
+  end
 
-    # TypeLib::Filter is a way of checking, then optionally converting data
-    # based on whether or not the check passes. At that point, an additional
-    # TypeLib::FilterList may be provided which indicates that more checks need
-    # to be followed with the new data.
-    class Filter
-        attr_reader :check_proc, :convert_proc, :filters
+  # TypeLib::Filter is a way of checking, then optionally converting data
+  # based on whether or not the check passes. At that point, an additional
+  # TypeLib::FilterList may be provided which indicates that more checks need
+  # to be followed with the new data.
+  class Filter
+    attr_reader :check_proc, :convert_proc, :filters
 
-        # A TypeLib::Filter consists of a check procedure, a conversion procedure,
-        # and a TypeLib::FilterList which may be empty. Checks return boolean
-        # which indicates whether or not the conversion will be attempted. 
-        def initialize(check, convert, filters=FilterList.new)
-            @check_proc   = check 
-            @convert_proc = convert
-            @filters      = filters
-        end
+    # A TypeLib::Filter consists of a check procedure, a conversion procedure,
+    # and a TypeLib::FilterList which may be empty. Checks return boolean
+    # which indicates whether or not the conversion will be attempted. 
+    def initialize(check, convert, filters=FilterList.new)
+      @check_proc   = check 
+      @convert_proc = convert
+      @filters      = filters
+    end
 
-        # Check this object against the filter. If additional data is supplied,
-        # it will be provided to the Filter#check_proc.
-        def check(obj, *addl)
-            check_proc.call(obj, *addl)
-        end
+    # Check this object against the filter. If additional data is supplied,
+    # it will be provided to the Filter#check_proc.
+    def check(obj, *addl)
+      check_proc.call(obj, *addl)
+    end
 
-        # Convert this object unconditionally. If additional data is supplied,
-        # it will be provided to the Filter#convert_proc.
-        def convert(obj, *addl)
-            ret = convert_proc.call(obj, *addl)
-            filters.execute(ret, *addl)
-        end
+    # Convert this object unconditionally. If additional data is supplied,
+    # it will be provided to the Filter#convert_proc.
+    def convert(obj, *addl)
+      ret = convert_proc.call(obj, *addl)
+      filters.execute(ret, *addl)
+    end
+
+    #
+    # Same as TypeLib::FilterList#execute, only just for this filter.
+    #
+    def execute(obj, *addl)
+      ret = obj
+      if check(obj, *addl)
+        ret = convert(obj, *addl)
+      end
+      return ret
     end
+  end
 end

data/lib/typelib/canned.rb

@@ -3,64 +3,65 @@ require 'date'
 require 'typelib'
 
 module TypeLib
-    # Canned checks are just that -- already written for you.
-    module Canned
-        #
-        # build_strptime_filter works with DateTime objects and a format that
-        # you provide. It will build and return a new TypeLib::Filter that can
-        # check strings for the format you provide and if they pass, convert
-        # them to a DateTime object.
-        #
-        # Due to limitations in the DateTime system itself, you must include
-        # zone information -- if not, you will get a value that is offset to
-        # GMT, which is not what DateTime.now and pals will return. An
-        # ArgumentError will be raised if you do not supply this in the filter.
-        #
-        def build_strptime_filter(format)
-            if format !~ /%z/
-                raise ArgumentError, "format must include %z due to DateTime fail"
-            end
+  # Canned checks are just that -- already written for you.
+  module Canned
+    #
+    # build_strptime_filter works with DateTime objects and a format that
+    # you provide. It will build and return a new TypeLib::Filter that can
+    # check strings for the format you provide and if they pass, convert
+    # them to a DateTime object.
+    #
+    # Due to limitations in the DateTime system itself, you must include
+    # zone information -- if not, you will get a value that is offset to
+    # GMT, which is not what DateTime.now and pals will return. An
+    # ArgumentError will be raised if you do not supply this in the filter.
+    #
+    def build_strptime_filter(format)
+      if format !~ /%z/
+        raise ArgumentError, "format must include %z due to DateTime fail"
+      end
 
-            check = proc do |obj|
-                (DateTime.strptime(obj, format).strftime(format) == obj) rescue false 
-            end
+      check = proc do |obj|
+        (DateTime.strptime(obj, format).strftime(format) == obj) rescue false 
+      end
 
-            convert = proc { |obj| DateTime.strptime(obj, format) }
+      convert = proc { |obj| DateTime.strptime(obj, format) }
 
-            return Filter.new(check, convert)
-        end
+      return Filter.new(check, convert)
+    end
 
-        module_function :build_strptime_filter
+    module_function :build_strptime_filter
 
-        # Canned Checks.
-        module Checks
-            STR_IS_INT = proc { |obj| obj.kind_of?(String) and obj =~ /^\d+$/ }
-            STR_IS_DEC = proc { |obj| obj.kind_of?(String) and obj =~ /^[\d.]+$/ }
+    # Canned Checks.
+    module Checks
+      STR_IS_INT = proc { |obj| obj.kind_of?(String) and obj =~ /^-?\d+$/ }
+      STR_IS_DEC = proc { |obj| obj.kind_of?(String) and obj =~ /^-?[\d.]+$/ }
 
-            IS_NUMERIC = proc { |obj| obj.kind_of?(Numeric) }
-            IS_INTEGER = proc { |obj| obj.kind_of?(Integer) }
-        end
+      IS_STRING  = proc { |obj| obj.kind_of?(String)  }
+      IS_NUMERIC = proc { |obj| obj.kind_of?(Numeric) }
+      IS_INTEGER = proc { |obj| obj.kind_of?(Integer) }
+    end
 
-        # Canned Conversions.
-        module Conversions
-            TO_INTEGER         = proc { |obj| obj.to_i }
-            TO_FLOAT           = proc { |obj| obj.to_f }
-            TO_STRING          = proc { |obj| obj.to_s }
-            TO_BINARY          = proc { |obj| obj.to_s(2) }
-            TO_HEX             = proc { |obj| obj.to_s(16) }
+    # Canned Conversions.
+    module Conversions
+      TO_INTEGER         = proc { |obj| obj.to_i }
+      TO_FLOAT           = proc { |obj| obj.to_f }
+      TO_STRING          = proc { |obj| obj.to_s }
+      TO_BINARY          = proc { |obj| obj.to_s(2) }
+      TO_HEX             = proc { |obj| obj.to_s(16) }
 
-            STR_TO_BIGDECIMAL  = proc { |obj| BigDecimal.new(obj.to_s) }
-        end
+      STR_TO_BIGDECIMAL  = proc { |obj| BigDecimal.new(obj.to_s) }
+    end
 
-        # Fully canned filters.
-        module Filters
-            STR_TO_INT   = Filter.new(Checks::STR_IS_INT, Conversions::TO_INTEGER)
-            STR_TO_FLOAT = Filter.new(Checks::STR_IS_DEC, Conversions::TO_FLOAT)
-            STR_TO_DEC   = Filter.new(Checks::STR_IS_DEC, Conversions::STR_TO_BIGDECIMAL)
+    # Fully canned filters.
+    module Filters
+      STR_TO_INT   = Filter.new(Checks::STR_IS_INT, Conversions::TO_INTEGER)
+      STR_TO_FLOAT = Filter.new(Checks::STR_IS_DEC, Conversions::TO_FLOAT)
+      STR_TO_DEC   = Filter.new(Checks::STR_IS_DEC, Conversions::STR_TO_BIGDECIMAL)
 
-            NUM_TO_STR = Filter.new(Checks::IS_NUMERIC, Conversions::TO_STRING)
-            INT_TO_BIN = Filter.new(Checks::IS_INTEGER, Conversions::TO_BINARY)
-            INT_TO_HEX = Filter.new(Checks::IS_INTEGER, Conversions::TO_HEX)
-        end
+      NUM_TO_STR = Filter.new(Checks::IS_NUMERIC, Conversions::TO_STRING)
+      INT_TO_BIN = Filter.new(Checks::IS_INTEGER, Conversions::TO_BINARY)
+      INT_TO_HEX = Filter.new(Checks::IS_INTEGER, Conversions::TO_HEX)
     end
+  end
 end

data/test/test_01_basic.rb

@@ -6,85 +6,85 @@ $:.unshift 'lib'
 require 'typelib'
 
 class TestBasic < Test::Unit::TestCase
-    def test_01_classes
-        assert(TypeLib)
-        assert(TypeLib::FilterList)
-        assert(TypeLib::Filter)
+  def test_01_classes
+    assert(TypeLib)
+    assert(TypeLib::FilterList)
+    assert(TypeLib::Filter)
+  end
+
+  def test_02_object_properties
+    filters = TypeLib::FilterList.new
+
+    assert_respond_to(filters, :[])
+    assert_respond_to(filters, :<<)
+    assert_respond_to(filters, :execute) 
+
+    check   = proc { }
+    convert = proc { }
+    filter  = TypeLib::Filter.new(check, convert)
+
+    assert_respond_to(filter, :check_proc)
+    assert_respond_to(filter, :convert_proc)
+    assert_respond_to(filter, :filters)
+    assert_respond_to(filter, :check)
+    assert_respond_to(filter, :convert)
+
+    assert_kind_of(Proc, filter.check_proc)
+    assert_kind_of(Proc, filter.convert_proc)
+    assert_kind_of(TypeLib::FilterList, filter.filters)
+  end
+
+  def test_03_basic_conversions
+    filters = TypeLib::FilterList.new
+    check   = proc { |obj| obj.kind_of?(Integer) }
+    convert = proc { |obj| obj }
+
+    check2   = proc { |obj| obj.kind_of?(String) and obj =~ /^\d+$/ }
+    convert2 = proc { |obj| Integer(obj) }
+
+    filters << TypeLib::Filter.new(check, convert)
+    filters << TypeLib::Filter.new(check2, convert2)
+
+    assert_equal(2, filters.count)
+    assert_equal(1, filters.execute(1))
+    assert_equal(1, filters.execute("1"))
+
+    10.times do
+      x = rand(250000).to_i
+      assert_equal(x, filters.execute(x))
+      assert_equal(x, filters.execute(x.to_s))
     end
 
-    def test_02_object_properties
-        filters = TypeLib::FilterList.new
+    assert_equal("1.25", filters.execute("1.25"))
 
-        assert_respond_to(filters, :[])
-        assert_respond_to(filters, :<<)
-        assert_respond_to(filters, :execute) 
+    filters << TypeLib::Filter.new(proc { true }, proc { |obj| Integer(obj) })
+    assert_raises(ArgumentError) { filters.execute("1.25") }
+  end
 
-        check   = proc { }
-        convert = proc { }
-        filter  = TypeLib::Filter.new(check, convert)
+  def test_04_args
+    check   = proc { |obj, *addl| addl[0] }
+    convert = proc { |obj, *addl| addl[0] } 
+    filter  = TypeLib::Filter.new(check, convert)
 
-        assert_respond_to(filter, :check_proc)
-        assert_respond_to(filter, :convert_proc)
-        assert_respond_to(filter, :filters)
-        assert_respond_to(filter, :check)
-        assert_respond_to(filter, :convert)
+    assert(filter.check(true, true))
+    assert(!filter.check(true, false))
+    assert_equal("fart", filter.convert(true, "fart"))
+  end
 
-        assert_kind_of(Proc, filter.check_proc)
-        assert_kind_of(Proc, filter.convert_proc)
-        assert_kind_of(TypeLib::FilterList, filter.filters)
-    end
-
-    def test_03_basic_conversions
-        filters = TypeLib::FilterList.new
-        check   = proc { |obj| obj.kind_of?(Integer) }
-        convert = proc { |obj| obj }
-
-        check2   = proc { |obj| obj.kind_of?(String) and obj =~ /^\d+$/ }
-        convert2 = proc { |obj| Integer(obj) }
-
-        filters << TypeLib::Filter.new(check, convert)
-        filters << TypeLib::Filter.new(check2, convert2)
-
-        assert_equal(2, filters.count)
-        assert_equal(1, filters.execute(1))
-        assert_equal(1, filters.execute("1"))
-
-        10.times do
-            x = rand(250000).to_i
-            assert_equal(x, filters.execute(x))
-            assert_equal(x, filters.execute(x.to_s))
-        end
-
-        assert_equal("1.25", filters.execute("1.25"))
+  def test_05_chains
+    filters = TypeLib::FilterList.new
 
-        filters << TypeLib::Filter.new(proc { true }, proc { |obj| Integer(obj) })
-        assert_raises(ArgumentError) { filters.execute("1.25") }
-    end
-
-    def test_04_args
-        check   = proc { |obj, *addl| addl[0] }
-        convert = proc { |obj, *addl| addl[0] } 
-        filter  = TypeLib::Filter.new(check, convert)
-
-        assert(filter.check(true, true))
-        assert(!filter.check(true, false))
-        assert_equal("fart", filter.convert(true, "fart"))
-    end
+    check   = proc { |obj| obj.kind_of?(Integer) }
+    convert = proc { |obj| obj.to_s }
 
-    def test_05_chains
-        filters = TypeLib::FilterList.new
+    check2   = proc { |obj| obj.kind_of?(String) and obj =~ /^\d+$/ }
+    convert2 = proc { |obj| obj.to_f }
 
-        check   = proc { |obj| obj.kind_of?(Integer) }
-        convert = proc { |obj| obj.to_s }
+    filters << TypeLib::Filter.new(check, convert, TypeLib::FilterList.new([TypeLib::Filter.new(check2, convert2)]))
+    filters << TypeLib::Filter.new(check2, convert2)
 
-        check2   = proc { |obj| obj.kind_of?(String) and obj =~ /^\d+$/ }
-        convert2 = proc { |obj| obj.to_f }
-
-        filters << TypeLib::Filter.new(check, convert, TypeLib::FilterList.new([TypeLib::Filter.new(check2, convert2)]))
-        filters << TypeLib::Filter.new(check2, convert2)
-
-        assert_equal(1.0, filters.execute(1))
-        assert_kind_of(Float, filters.execute(1))
-        assert_equal(1.0, filters.execute("1"))
-    end
+    assert_equal(1.0, filters.execute(1))
+    assert_kind_of(Float, filters.execute(1))
+    assert_equal(1.0, filters.execute("1"))
+  end
 end

data/test/test_02_canned.rb

@@ -7,50 +7,54 @@ require 'typelib'
 require 'typelib/canned'
 
 class TestCanned < Test::Unit::TestCase
-    include TypeLib::Canned
-    include TypeLib::Canned::Filters
-
-    def create_filterlist(arg)
-        filters = TypeLib::FilterList.new 
-        filters << arg
-        return filters
-    end
-
-    def test_01_string_to_numeric
-        filters = create_filterlist(STR_TO_INT)
-        assert_equal(1, filters.execute("1"))
-        assert_kind_of(Integer, filters.execute("1"))
-        
-        filters = create_filterlist(STR_TO_FLOAT)
-        assert_equal(1.0, filters.execute("1"))
-        assert_kind_of(Float, filters.execute("1"))
-        
-        filters = create_filterlist(STR_TO_DEC)
-        assert_equal(BigDecimal.new("1.0"), filters.execute("1"))
-        assert_kind_of(BigDecimal, filters.execute("1"))
-    end
-
-    def test_02_numeric_to_string
-        filters = create_filterlist(NUM_TO_STR)
-        assert_equal("1", filters.execute(1))
-        assert_kind_of(String, filters.execute(1))
-
-        filters = create_filterlist(INT_TO_BIN)
-        assert_equal("10", filters.execute(2))
-        assert_kind_of(String, filters.execute(2))
-        
-        filters = create_filterlist(INT_TO_HEX)
-        assert_equal("a", filters.execute(10))
-        assert_kind_of(String, filters.execute(10))
-
-    end
-
-    def test_03_datetime
-        filters = create_filterlist(build_strptime_filter("%H:%M:%S%z"))
-        time = DateTime.now
-        newtime = filters.execute(time.strftime("%H:%M:%S%z"))
-        assert_equal(time.to_s, newtime.to_s)
-
-        assert_raises(ArgumentError.new("format must include %z due to DateTime fail")) { build_strptime_filter("%H:%M:%S") } 
-    end
+  include TypeLib::Canned
+  include TypeLib::Canned::Filters
+
+  def create_filterlist(arg)
+    filters = TypeLib::FilterList.new 
+    filters << arg
+    return filters
+  end
+
+  def test_01_string_to_numeric
+    filters = create_filterlist(STR_TO_INT)
+    assert_equal(1, filters.execute("1"))
+    assert_kind_of(Integer, filters.execute("1"))
+    
+    filters = create_filterlist(STR_TO_INT)
+    assert_equal(-1, filters.execute("-1"))
+    assert_kind_of(Integer, filters.execute("-1"))
+
+    filters = create_filterlist(STR_TO_FLOAT)
+    assert_equal(1.0, filters.execute("1"))
+    assert_kind_of(Float, filters.execute("1"))
+
+    filters = create_filterlist(STR_TO_DEC)
+    assert_equal(BigDecimal.new("1.0"), filters.execute("1"))
+    assert_kind_of(BigDecimal, filters.execute("1"))
+  end
+
+  def test_02_numeric_to_string
+    filters = create_filterlist(NUM_TO_STR)
+    assert_equal("1", filters.execute(1))
+    assert_kind_of(String, filters.execute(1))
+
+    filters = create_filterlist(INT_TO_BIN)
+    assert_equal("10", filters.execute(2))
+    assert_kind_of(String, filters.execute(2))
+
+    filters = create_filterlist(INT_TO_HEX)
+    assert_equal("a", filters.execute(10))
+    assert_kind_of(String, filters.execute(10))
+
+  end
+
+  def test_03_datetime
+    filters = create_filterlist(build_strptime_filter("%H:%M:%S%z"))
+    time = DateTime.now
+    newtime = filters.execute(time.strftime("%H:%M:%S%z"))
+    assert_equal(time.to_s, newtime.to_s)
+
+    assert_raises(ArgumentError.new("format must include %z due to DateTime fail")) { build_strptime_filter("%H:%M:%S") } 
+  end
 end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: typelib
 version: !ruby/object:Gem::Version 
+  hash: 25
   prerelease: false
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Erik Hollensbe
@@ -14,10 +15,23 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-17 00:00:00 -04:00
+date: 2010-06-18 00:00:00 -04:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: test-unit
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
 description: 
 email: erik@hollensbe.org
 executables: []
@@ -28,37 +42,42 @@ extra_rdoc_files: []
 
 files: 
 - Rakefile
+- README.rdoc
 - lib/typelib/canned.rb
 - lib/typelib.rb
 - test/test_01_basic.rb
 - test/test_02_canned.rb
 has_rdoc: true
-homepage: 
+homepage: http://erik.hollensbe.org/docs/typelib/
 licenses: []
 
 post_install_message: 
-rdoc_options: []
-
+rdoc_options: 
+- -a
 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: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: An on-demand arbitrary check and conversion library that won't destroy your data.