typelib 0.0.1

data/Rakefile

@@ -0,0 +1,74 @@
+# $Id$
+$:.push 'lib'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rdoc/task'
+require 'fileutils'
+require 'typelib'
+
+include FileUtils::Verbose
+
+task :default => [ :test, :dist ]
+
+task :fixperms do
+    chmod(0755, Dir['bin/*'])  
+end
+
+#
+# Tests
+#
+
+Rake::TestTask.new do |t|
+    t.libs << 'lib'
+    t.test_files = FileList['test/test*.rb']
+    t.verbose = true 
+end
+
+#
+# Distribution
+#
+
+task :dist      => [:fixperms, :repackage, :gem, :rdoc]
+task :distclean => [:clobber_package, :clobber_rdoc]
+task :clean     => [:distclean]
+
+#
+# Documentation
+#
+
+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)
+end
+
+#
+# Packaging
+# 
+
+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.files = Dir["Rakefile"] + Dir["README"] + Dir["lib/**/*"] + Dir['test/**/*']
+
+    s.has_rdoc = true
+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")
+end

data/lib/typelib.rb

@@ -0,0 +1,73 @@
+require 'delegate'
+
+# 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.
+#
+# Please see TypeLib::Filter and TypeLib::FilterList for more information.
+#
+module TypeLib
+
+    VERSION = "0.0.1"
+
+    # 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
+        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
+
+        # 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
+
+        # 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
+    end
+end

data/lib/typelib/canned.rb

@@ -0,0 +1,66 @@
+require 'bigdecimal'
+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
+
+            check = proc do |obj|
+                (DateTime.strptime(obj, format).strftime(format) == obj) rescue false 
+            end
+
+            convert = proc { |obj| DateTime.strptime(obj, format) }
+
+            return Filter.new(check, convert)
+        end
+
+        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.]+$/ }
+
+            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) }
+
+            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)
+
+            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

@@ -0,0 +1,90 @@
+require 'rubygems'
+gem 'test-unit'
+require 'test/unit'
+
+$:.unshift 'lib'
+require 'typelib'
+
+class TestBasic < Test::Unit::TestCase
+    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
+
+        assert_equal("1.25", filters.execute("1.25"))
+
+        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
+
+    def test_05_chains
+        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 }
+
+        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
+end

data/test/test_02_canned.rb

@@ -0,0 +1,56 @@
+require 'rubygems'
+gem 'test-unit'
+require 'test/unit'
+
+$:.unshift 'lib'
+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
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: typelib
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Erik Hollensbe
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-17 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: 
+email: erik@hollensbe.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- lib/typelib/canned.rb
+- lib/typelib.rb
+- test/test_01_basic.rb
+- test/test_02_canned.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: An on-demand arbitrary check and conversion library that won't destroy your data.
+test_files: []
+