typestrict 0.0.4

data/History.txt

@@ -0,0 +1,26 @@
+=== 0.0.4 / 2010-08-03
+
+* 1 major enhancement
+
+  * Renamed package to typestrict
+
+
+=== 0.0.3 / 2010-08-03
+
+* 1 major enhancement
+
+  * Introduced TypeError and verbose output - now displays list of errors caught and raises single Strict::TypeError
+
+=== 0.0.2 / 2010-08-03
+
+* 1 major enhancement
+
+  * Gemify
+
+
+=== 0.0.1 / 2010-08-02
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,8 @@
+History.txt
+Manifest.txt
+README
+README.txt
+Rakefile
+bin/typestrict
+lib/typestrict.rb
+test/test_strict.rb

data/README

@@ -0,0 +1,89 @@
+strict is a rudimentary static typesystem for ruby objects - it includes easy validation of individual ruby objects and Hash sets.
+
+For an example of validation:
+
+require 'typestrict'
+
+class Rectangle
+  include Strict
+
+  def initialize(p)
+    
+    validate_map!({
+                :width => :natural_number,
+                :height => :natural_number,
+                :float => :boolean
+                }, p)
+
+    @width = p[:width]
+    @height = p[:height]
+    @float = p[:float]
+  end
+
+  def set_dimensions(dimensions)
+    validate_map!({
+                :width => :natural_number,
+                :height => :natural_number
+                }, dimensions) #checks for the presence + validity of all declared parameters
+
+    @height = dimensions[:height]
+    @width = dimensions[:width]
+  end
+
+  def scale_height(scale_coefficent)
+    enforce!(:float, scale_coefficent)
+    return scale_coefficent*@height #alays valid
+  end
+end
+
+Strict defines a number of 'super-types', currently which are:
+:natural_number
+:float
+:boolean
+:string_array
+:numeric_array
+:float_array
+:integer_array
+:hex_color_string
+
+Strict simply implements an extendable static type-checker over dynamic ruby objects. For an example of validation with troublesome datasets:
+
+#enforce!(:string_array, ["one", "two", 3, "four"])
+#./strict.rb:3:in `enforce_primitive!': 3 must be of type String (RuntimeError)
+
+type_matrix = {
+  :fruit => [:apple, :orange, :banana],
+  :height => :natural_number,
+  :width => :float,
+  :broken => :boolean
+  }
+
+invalid_data = {
+  :fruit => :pear,
+  :height => -1,
+  :width => 100,
+  :broken => 1}
+
+
+validate_map!(type_matrix, invalid_data)
+#./strict.rb:27:in `enforce_weak_primitives!': 1 must be of one of the types of [TrueClass, FalseClass] (RuntimeError)
+#./strict.rb:3:in `enforce_primitive!': 10 must be of type Float (RuntimeError)
+#./strict.rb:38:in `enforce!': pear should take on a value within [:apple, :orange, :banana] (RuntimeError)
+#./strict.rb:53:in `enforce!': -1 must be > 0 (RuntimeError)
+
+A valid dataset for this type_matrix would be:
+
+valid_data = {
+  :fruit => :apple,
+  :height => 200,
+  :width => 100.011,
+  :broken => true
+  }
+
+validate_map!(type_matrix, invalid_data) # => all checks pass
+
+TODO
+----
+Implement generic handler for super-types
+Performance analysis
+Implement low-level?

data/README.txt

@@ -0,0 +1,72 @@
+= strict
+
+* http://www.raeez.com/strict
+
+== DESCRIPTION:
+
+Strict implements a traditional static type-system over dynamic ruby objects. Strict is designed to help debug simple type errors.
+
+== FEATURES/PROBLEMS:
+
+Implements a Static typesystem over Object
+Support for ruby Primitives (strict subsets, weak subsets etc.)
+Support for user-defined types
+
+== SYNOPSIS:
+
+def add_nums(a, b)
+  enforce!(:numeric, a)
+  enforce!(:numeric, b)
+  return a + b
+end
+
+def launch_rocket(params)
+  enforce_map!({
+    :destination => [:moon, :mars, :saturn, :jupiter, :iss],
+    :rocket_type => [:appollo, :space_x],
+    :fuel_litres => :numeric,
+    :mission_id => :string}, params)
+  ... #launch the rocket
+end
+
+== REQUIREMENTS:
+
+none
+
+== INSTALL:
+
+sudo gem install strict
+
+== DEVELOPERS:
+
+After checking out the source, run:
+
+  $ rake
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the RDoc.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2010 FIX
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'hoe'
+require 'lib/typestrict'
+
+Hoe.spec 'Strict' do
+  self.name = 'typestrict'
+  self.version = Strict::VERSION
+  self.author = 'Raeez Lorgat'
+  self.description = 'Static typesystem for ruby'
+  self.email = 'raeez@mit.edu'
+  self.summary = 'Strict implements a static typesystem over dynamic ruby objects'
+  self.url = 'http://www.raeez.com/strict'
+end
+
+desc "Release and publish documentation"
+task :repubdoc => [:release, :publish_docs]

data/bin/typestrict

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+abort "you need to write me"

data/lib/typestrict.rb

@@ -0,0 +1,159 @@
+module Strict
+  VERSION = '0.0.4'
+
+  class TypeError < Exception
+    attr :errors
+    def initialize(error_list)
+      enforce!(:string_array, error_list, 'lib/strict')
+      @errors = error_list
+    end
+
+    def inspect
+      msg = "TypeError#{@errors.size > 1 ? "s" : ""} caught:\n"
+      @errors.each do |e|
+        msg += "#{e}\n"
+      end
+      return msg
+    end
+  end
+
+  @@errors = []
+  @@raise_exception = true
+
+  def setmode_raise!
+    @@errors = []
+    @@raise_exception = true
+  end
+
+  def setmode_catch!
+    @@errors = []
+    @@raise_exception = false
+  end
+
+  def catch_error error
+    @@errors << error
+    t = TypeError.new([error])
+    raise(t, t.inspect, caller) if @@raise_exception
+  end
+
+  def raise_hell!
+    t = TypeError.new(@@errors)
+    raise(t, t.inspect, caller) if @@errors.size > 0
+  end
+
+  def header(context, data)
+    "#{context}; #{data.class.inspect}::#{data.inspect}"
+  end
+
+  def enforce_primitive!(type, data, context="Value")
+    catch_error "#{header(context, data)} must be of type #{type}" unless (data.is_a? type and type.is_a? Class)
+    return data
+  end
+
+  def enforce_strict_primitives!(types, data, context="Value")
+    enforce_primitive!(Array, types, 'lib/strict')
+    types.each {|type| enforce_primitive!(Object, type, 'lib/strict')}
+    types.each do |type|
+      enforce_primitive!(type, data, context)
+    end
+    return data
+  end
+
+  def enforce_weak_primitives!(types, data, context="Value")
+    enforce_primitive!(Array, types, 'lib/strict')
+    types.each {|type| enforce_primitive!(Object, type, 'lib/strict')}
+    
+    match_found = false
+    types.each do |type|
+      begin
+        s = @@errors.size
+        enforce_primitive!(type, data, context)
+        match_found = true unless s != @@errors.size
+      rescue
+        next
+      end
+    end
+    catch_error "#{header(context, data)} must be of one of the types of #{types.inspect}" unless match_found
+    return data
+  end
+
+  def enforce_non_nil!(obj, context="Value")
+    catch_error "#{context}: Object is nil!" if obj.nil?
+    return obj
+  end
+
+  def enforce!(supertype, data, context="Value") #write a more generic handler, for new types?
+    enforce_non_nil!(data, context)
+    
+    if supertype.is_a? Array #enumeration of values
+      catch_error "#{header(context, data)} should take on a value within #{supertype.inspect}" unless supertype.include? data
+
+    else if supertype.is_a? Symbol #distinct type
+      case supertype
+        when :string
+          enforce_primitive!(String, data, context)
+          catch_error "#{header(context, data)} can't be empty string" unless (data.size > 0)
+
+        when :hex_color
+          enforce!(:string, data, context)
+          catch_error "#{header(context, data)} must be six characters long" unless (data.size == 6)
+          data.upcase.each_byte {|c| catch_error "#{header(context, data)} must contain only hexadecimal characters" unless ((48 <= c  and c <= 57) or (65 <= c and c <= 70))}
+
+        when :natural_number
+          enforce_primitive!(Fixnum, data, context)
+          catch_error "#{header(context, data)} must be > 0" unless (data > 0)
+
+        when :integer
+          enforce_primitive!(Fixnum, data, context)
+
+        when :numeric
+          enforce_primitive!(Numeric, data, context)
+
+        when :boolean
+          enforce_weak_primitives!([TrueClass, FalseClass], data, context)
+
+        when :float
+          enforce_primitive!(Float, data, context)
+
+        when :string_array
+          enforce_primitive!(Array, data, context)
+          data.each {|item| enforce_primitive!(String, item, context)}
+
+        when :numeric_array
+          enforce_primitive!(Array, data, context)
+          data.each {|item| enforce_primitive!(Numeric, item, context)}
+
+        when :float_array
+          enforce_primitive!(Array, data, context)
+          data.each {|item| enforce_primitive!(Float, item, context)}
+
+        when :integer_array
+          enforce_primitive!(Array, data, context)
+          data.each {|item| enforce_primitive!(Fixnum, item, context)}
+
+        else
+          catch_error "undefined symbol-supertype encountered: #{supertype.inspect}"
+        end
+      end
+    end
+    return data
+  end
+
+  def enforce_map!(matrix, map)
+    enforce_primitive!(Hash, matrix, "lib/strict")
+    enforce_primitive!(Hash, map, "lib/strict")
+
+    setmode_catch!
+
+    matrix.each do |param, type|
+      if map.has_key? param
+        enforce!(type, map[param], "map[#{param.inspect}]")
+      else
+        catch_error "map: missing required param: #{param.inspect}"
+      end
+    end
+    raise_hell!
+    setmode_raise!
+    return map
+  end
+end

data/test/test_strict.rb

@@ -0,0 +1,8 @@
+require "test/unit"
+require "typestrict"
+
+class TestStrict < Test::Unit::TestCase
+  def test_sanity
+    puts "no tests implemented!"
+  end
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification 
+name: typestrict
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 4
+  version: 0.0.4
+platform: ruby
+authors: 
+- Raeez Lorgat
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-03 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rubyforge
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        - 0
+        - 4
+        version: 2.0.4
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 2
+        - 6
+        - 1
+        version: 2.6.1
+  type: :development
+  version_requirements: *id002
+description: Static typesystem for ruby
+email: raeez@mit.edu
+executables: 
+- typestrict
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README
+- README.txt
+- Rakefile
+- bin/typestrict
+- lib/typestrict.rb
+- test/test_strict.rb
+has_rdoc: true
+homepage: http://www.raeez.com/strict
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+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: strict
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Strict implements a static typesystem over dynamic ruby objects
+test_files: 
+- test/test_strict.rb