typisch 0.1.5

data/lib/typisch/tuple.rb

@@ -0,0 +1,74 @@
+class Typisch::Type
+  class Tuple < Constructor
+    class << self
+      def top_type(overall_top)
+        new()
+      end
+
+      def check_subtype(x, y, &recursively_check_subtype)
+        if x.length >= y.length
+          (0...y.length).all? {|i| recursively_check_subtype[x[i], y[i]]}
+        end
+      end
+
+      # This l.u.b. isn't as tight as it could be;
+      # (Int, Int) union (Bool, Bool) is a strict subset of
+      # (Int union Bool, Int union Bool), see eg (1, true).
+      #
+      # It makes life simpler to do it this way though;
+      # if you want to keep the distinction, try using
+      # Object types with different type tags.
+      def least_upper_bounds_for_union(*tuples)
+        min_length = tuples.map(&:length).min
+        unions = Array.new(min_length) do |i|
+          Type::Union.union(*tuples.map {|t| t[i]})
+        end
+        [new(*unions)]
+      end
+
+    end
+
+    def initialize(*types)
+      @types = types
+    end
+
+    # For now we're only allowing Array as a tuple.
+    # We could allow any Enumerable, say, but a tuple is really not supposed to be
+    # in any way a lazy data structure, it's something of fixed (usually short) length.
+    def check_type(instance, &recursively_check_type)
+      ::Array === instance &&
+      instance.length == @types.length &&
+      @types.zip(instance).all?(&recursively_check_type)
+    end
+
+    def shallow_check_type(instance)
+      ::Array === instance && instance.length == @types.length
+    end
+
+
+    attr_reader :types
+    alias :subexpression_types :types
+
+    def length
+      @types.length
+    end
+
+    def [](n)
+      @types[n]
+    end
+
+    def tag
+      "Tuple"
+    end
+
+    def to_string(depth, indent)
+      next_indent = "#{indent}  "
+      types = @types.map {|t| t.to_s(depth+1, next_indent)}
+      "tuple(\n#{next_indent}#{types.join(",\n#{next_indent}")}\n#{indent})"
+    end
+
+    def canonicalize!
+      @types.map!(&:target)
+    end
+  end
+end

data/lib/typisch/type.rb

@@ -0,0 +1,138 @@
+# Base class for types, with some convenience methods.
+#
+# Note: since most of the algorithms on types (subtyping, union, intersection, ...)
+# operate on pairs of types, we don't use methods on the actual type subclasses very much,
+# since polymorphic dispatch on just one of the pair of types isn't much use in terms
+# of extensibility.
+#
+# Instead the actual Type classes themselves are kept fairly lightweight, with the algorithms
+# implemented separately in class methods.
+class Typisch::Type
+  def <=(other)
+    Typisch::Type.subtype?(self, other)
+  end
+
+  def <(other)
+    self <= other && !(self >= other)
+  end
+
+  # N.B. equality is based on the subtyping algorithm. So, we cannot rely on
+  # using == on types inside any methods used in the subtyping algorithm.
+  # We must rely only on .equal? instance equality instead.
+  #
+  # Note that we have *not* overridden hash and eql? to be compatible with
+  # this subtyping-based equality, since it's not easy to find a unique
+  # representative of the equivalence class on which to base a hash function.
+  #
+  # This means that hash lookup of types will remain based on instance
+  # equality, and can safely be used inside the subtyping logic without
+  # busting the stack
+  def ==(other)
+    self <= other && self >= other
+  end
+
+  def >=(other)
+    other <= self
+  end
+
+  def >(other)
+    other < self
+  end
+
+  def <=>(other)
+    if other <= self
+      self <= other ? 0 : 1
+    else
+      self <= other ? -1 : nil
+    end
+  end
+
+
+  def inspect
+    "#<Type: #{to_s}>"
+  end
+
+  # overridden on the Placeholder proxy wrapper, otherwise points at self
+  def target; self; end
+
+  def to_s(depth=0, indent='')
+    return @name.inspect if depth > 0 && @name
+    return "..." if depth > 3 # MAX_DEPTH
+    to_string(depth, indent)
+  end
+
+  def to_string(depth, indent)
+    raise NotImplementedError
+  end
+
+  attr_reader :name
+  def name=(name)
+    raise "name already set" if @name
+    @name = name
+  end
+  private :name=
+
+  # types may be annotated with a hash of arbitrary stuff.
+  # could use this to document them, or to add instructions for
+  # other tools which do type-directed metaprogramming.
+
+  def annotations
+    @annotations ||= {}
+  end
+
+  def annotations=(annotations)
+    @annotations = annotations
+  end
+
+  # For convenience. Type::Constructor will implement this as [self], whereas
+  # Type::Union will implement it as its full list of alternative constructor types.
+  def alternative_types
+    raise NotImplementedError
+  end
+
+  # should return a list of any subexpressions which are themselves types.
+  # used by any generic type-graph-traversing logic.
+  def subexpression_types
+    []
+  end
+
+  # should update any references to subexpression types to point at their true
+  # target, eliminating any NamedPlaceholder wrappers.
+  def canonicalize!
+  end
+
+  # Does this type make any use of recursion / is it an 'infinite' type?
+  def recursive?(found_so_far={})
+    found_so_far[self] or begin
+      found_so_far[self] = true
+      result = subexpression_types.any? {|t| t.recursive?(found_so_far)}
+#      subexpression_types.each {|t| raise t.inspect if t.recursive?(found_so_far)}
+      found_so_far.delete(self)
+      result
+    end
+  end
+
+  # should check the type of this instance, but only 'one level deep', ie
+  # typically just check its type tag without recursively type-checking
+  # any child objects.
+  def shallow_check_type(instance)
+    raise NotImplementedError
+  end
+
+  # returns a version of this type which excludes null.
+  # generally will be self, except when a union type which includes null.
+  def excluding_null
+    self
+  end
+
+private
+
+  # Inidividual type subclasses must implement this. If they need to
+  # perform some recursive typecheck, eg on child objects of the object
+  # they're validating, they should call the supplied recursively_check_type
+  # block to do so, rather than calling === directly.
+  def check_type(instance, &recursively_check_type)
+    raise NotImplementedError
+  end
+
+end

data/lib/typisch/type_checking.rb

@@ -0,0 +1,12 @@
+class Typisch::Type
+
+  # This uses essentially the same corecursive algorithm used for subtyping.
+  # Just this time we're comparing with a possible instance rather than a possible
+  # subtype.
+  def ===(instance, already_checked={})
+    return true if already_checked[[self, instance]]
+    already_checked[[self, instance]] = true
+    check_type(instance) {|u,v| u.===(v, already_checked)}
+  end
+
+end

data/lib/typisch/typed.rb

@@ -0,0 +1,133 @@
+module Typisch
+
+  # A module which classes or modules can be extended with in order
+  # to help register an object type for that class or module, associate
+  # it with the class, and auto-define attributes on the class for the
+  # properties of its type.
+  #
+  # To be used like so:
+  #
+  # class Foo
+  #   include Typisch::Typed
+  #   register_type do
+  #     property :foo, :bar
+  #     ...
+  #   end
+  # end
+  module Typed
+    def self.included(klass)
+      super
+      klass.send(:extend, ClassMethods)
+    end
+
+    def type
+      self.class.type
+    end
+
+    def type_check(full_check=false)
+      if full_check
+        self.class.type === self or raise TypeError, "failed to type-check"
+      else
+        self.class.type.property_names.each {|a| type_check_property(a, false)}
+      end
+    end
+
+    def type_check_property(name, full_check=false)
+      type = self.class.type_of(name) or raise NameError, "no typed property #{name} in #{self.class}"
+      value = send(name)
+      if full_check
+        type === send(value)
+      else
+        type.shallow_check_type(value)
+      end or raise TypeError, "property #{name} was expected to be of type #{type}, got instance of #{value.class}"
+    end
+
+    module ClassMethods
+      def type
+        @type || raise("Forgot to register_type for Typisch::Typed class")
+      end
+
+      def type_of(property_name)
+        type[property_name]
+      end
+
+      def version_types
+        @version_types ||= {}
+      end
+
+      def versions
+        version_types.keys
+      end
+
+      def version_type(key)
+        version_types[key]
+      end
+
+    private
+      def register_type(in_registry = Typisch.global_registry, derive_from_type=nil, &block)
+        raise "Type already registered for #{self}" if @type
+
+        # a pox on instance_eval's scoping rules :(
+        callback = method(:type_available); klass = self; type = nil
+        in_registry.register do
+          type = _object(klass, {}, derive_from_type, &block)
+          klass.send(:instance_variable_set, :@type, type)
+          in_registry.register_type(:"#{klass}", type, &callback)
+          in_registry.register_type_for_class(klass, type)
+        end
+        type
+      end
+
+      def register_version_type(version, in_registry = Typisch.global_registry, &block)
+        raise "should register_type before register_version_type" unless @type
+
+        callback = method(:type_available); klass = self; type = nil
+        derive_from_type = @type
+        in_registry.register do
+          type = _object(klass, {}, derive_from_type, &block)
+          klass.version_types[version] = type
+          in_registry.register_type(:"#{klass}__#{version}", type, &callback)
+          in_registry.register_type_for_class(klass, type)
+        end
+        type
+      end
+
+      # Called once the type which you registered is available in a fully canonicalized form
+      # (so eg any forward declarations to types defined in other still-to-be-required classes,
+      # will have been resolved at this point).
+      #
+      # By default declares an attr_accessor for each property, and aliases it with a ? on the
+      # end if it's a boolean property. Override if you want to do something different.
+      def type_available
+        type.property_names_to_types.map do |name, type|
+          attr_accessor(name) unless method_defined?(name)
+          alias_method(:"#{name}?", name) if type.excluding_null.is_a?(Type::Boolean)
+        end
+      end
+
+      def register_subtype(in_registry = Typisch.global_registry, &block)
+        raise "Type already registered for #{self}" if @type
+        raise "register_subtype: superclass was not typed" unless superclass < Typed
+        supertype = superclass.send(:type)
+        callback = method(:type_available); klass = self; type = nil
+        in_registry.register do
+          type = derived_from(supertype, klass) do
+            instance_eval(&block)
+            derive_all_properties
+          end
+          klass.send(:instance_variable_set, :@type, type)
+          in_registry.register_type(:"#{klass}", type, &callback)
+          in_registry.register_type_for_class(klass, type)
+        end
+      end
+    end
+  end
+
+  class Typisch::TypedStruct
+    include Typisch::Typed
+
+    def initialize(properties={})
+      properties.each {|p,v| instance_variable_set("@#{p}", v)}
+    end
+  end
+end

data/lib/typisch/union.rb

@@ -0,0 +1,75 @@
+module Typisch
+  class Type::Union < Type
+    attr_reader :alternative_types
+    alias :subexpression_types :alternative_types
+
+    def initialize(*alternative_types)
+      @alternative_types = alternative_types
+    end
+
+    def check_type(instance, &recursively_check_type)
+      type = @alternative_types.find {|t| t.shallow_check_type(instance)}
+      type && recursively_check_type[type, instance]
+    end
+
+    def shallow_check_type(instance)
+      @alternative_types.any? {|t| t.shallow_check_type(instance)}
+    end
+
+    def excluding_null
+      types = @alternative_types.reject {|t| Type::Null === t}
+      types.length == 1 ? types.first : Type::Union.new(*types)
+    end
+
+    def canonicalize!
+      @alternative_types.map!(&:target)
+
+      unless @alternative_types.all? {|t| Type::Constructor === t} &&
+             (tags = @alternative_types.map(&:tag)).uniq.length == tags.length
+        raise TypeDeclarationError, "the types in a Union must be constructor types with different tags"
+      end
+    end
+
+    def to_string(depth, indent)
+      next_indent = "#{indent}  "
+      types = @alternative_types.map {|t| t.to_s(depth+1, next_indent)}
+      "union(\n#{next_indent}#{types.join(",\n#{next_indent}")}\n#{indent})"
+    end
+
+  end
+
+  # The Nothing (or 'bottom') type is just an empty Union:
+  class Type::Nothing < Type::Union
+    def initialize
+      super
+    end
+
+    def to_s(*); @name.inspect; end
+
+    INSTANCE = new
+    class << self; private :new; end
+    Registry.register_global_type(:nothing, INSTANCE)
+  end
+
+  # The Any (or 'top') type is just a union of all the top types of the various Type::Constructor
+  # subclasses:
+  class Type::Any < Type::Union
+    def initialize
+      super(*Constructor::CONSTRUCTOR_TYPE_SUBCLASSES.map {|klass| klass.top_type(self)})
+    end
+
+    def to_s(*); @name.inspect; end
+
+    def canonicalize!; end
+
+    # skip some unnecessary work checking different alternatives, since we know everything
+    # works here:
+    def check_type(instance)
+      true
+    end
+
+    INSTANCE = new
+    class << self; private :new; end
+    Registry.register_global_type(:any, INSTANCE)
+  end
+end

data/lib/typisch/version.rb

@@ -0,0 +1,3 @@
+module Typisch
+  VERSION = '0.1.5'
+end

data/lib/typisch.rb

@@ -0,0 +1,34 @@
+module Typisch
+end
+
+require 'set'
+
+require 'typisch/type'
+require 'typisch/constructor'
+
+require 'typisch/dsl'
+require 'typisch/registry'
+require 'typisch/named_placeholder'
+
+require 'typisch/boolean'
+require 'typisch/null'
+require 'typisch/numeric'
+require 'typisch/string'
+require 'typisch/datetime'
+
+require 'typisch/tuple'
+require 'typisch/object'
+
+require 'typisch/sequence'
+require 'typisch/constructor'
+
+require 'typisch/union'
+
+require 'typisch/subtyping'
+require 'typisch/type_checking'
+require 'typisch/poset_algorithms'
+require 'typisch/errors'
+
+require 'typisch/meta'
+
+require 'typisch/typed'

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification 
+name: typisch
+version: !ruby/object:Gem::Version 
+  hash: 17
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 5
+  version: 0.1.5
+platform: ruby
+authors: 
+- Matthew Willson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-14 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: autotest
+  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
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 2
+        - 1
+        - 0
+        version: 2.1.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 35
+        segments: 
+        - 0
+        - 9
+        - 12
+        version: 0.9.12
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 41
+        segments: 
+        - 0
+        - 9
+        - 9
+        version: 0.9.9
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: 
+email: 
+- matthew@playlouder.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/typisch/boolean.rb
+- lib/typisch/constructor.rb
+- lib/typisch/datetime.rb
+- lib/typisch/dsl.rb
+- lib/typisch/errors.rb
+- lib/typisch/meta.rb
+- lib/typisch/named_placeholder.rb
+- lib/typisch/null.rb
+- lib/typisch/numeric.rb
+- lib/typisch/object.rb
+- lib/typisch/poset_algorithms.rb
+- lib/typisch/registry.rb
+- lib/typisch/sequence.rb
+- lib/typisch/serialization.rb
+- lib/typisch/string.rb
+- lib/typisch/subtyping.rb
+- lib/typisch/tuple.rb
+- lib/typisch/type.rb
+- lib/typisch/type_checking.rb
+- lib/typisch/typed.rb
+- lib/typisch/union.rb
+- lib/typisch/version.rb
+- lib/typisch.rb
+- README.md
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+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.7
+signing_key: 
+specification_version: 3
+summary: A schema language / type system / validation framework, for semi-structured data and for data in dynamic languages
+test_files: []
+