finitio 0.4.1 → 0.5.0

data/lib/finitio/type/ad_type.rb

@@ -48,29 +48,36 @@ module Finitio
   #
   class AdType < Type
 
-    def initialize(ruby_type, contracts, name = nil)
+    def initialize(ruby_type, contracts, name = nil, metadata = nil)
       unless ruby_type.nil? or ruby_type.is_a?(Module)
         raise ArgumentError, "Module expected, got `#{ruby_type}`"
       end
-      unless contracts.is_a?(Hash)
-        raise ArgumentError, "Hash expected, got `#{contracts}`"
-      end
-      invalid = contracts.values.reject{|v|
-        v.is_a?(Array) and v.size == 3 and v[0].is_a?(Type) and \
-        v[1].respond_to?(:call) and v[2].respond_to?(:call)
-      }
-      unless invalid.empty?
-        raise ArgumentError, "Invalid contracts `#{invalid}`"
+      unless contracts.is_a?(Array) &&
+             contracts.all?{|c| c.is_a?(Contract) }
+        raise ArgumentError, "[Contract] expected, got `#{contracts}`"
       end
 
-      super(name)
+      super(name, metadata)
       @ruby_type = ruby_type
       @contracts = contracts.freeze
     end
     attr_reader :ruby_type, :contracts
 
+    alias :representator :ruby_type
+
+    def ruby_type=(ruby_type)
+      @ruby_type = ruby_type
+      @contracts.each do |contract|
+        contract.bind_ruby_type(ruby_type)
+      end
+    end
+
+    def [](name)
+      contracts.find{|c| c.name == name }
+    end
+
     def contract_names
-      contracts.keys
+      contracts.map(&:name)
     end
 
     def default_name
@@ -85,27 +92,43 @@ module Finitio
       # Up should be idempotent with respect to the ADT
       return value if ruby_type and value.is_a?(ruby_type)
 
+      # Dressed value and first exception
+      dressed, error = nil, nil
+
       # Try each contract in turn. Do nothing on TypeError as
       # the next candidate could be the good one! Return the
       # first successfully dressed.
-      contracts.each_pair do |name, (infotype, dresser, _)|
+      contracts.each do |contract|
 
         # First make the dress transformation on the information type
         success, dressed = handler.just_try do
-          infotype.dress(value, handler)
+          contract.infotype.dress(value, handler)
+        end
+
+        # Save very first error on failure
+        unless success
+          error ||= dressed
+          next
         end
-        next unless success
 
         # Seems nice, just try to get one stage higher now
         success, dressed = handler.just_try(StandardError) do
-          dresser.call(dressed)
+          contract.dresser.call(dressed)
         end
-        return dressed if success
 
+        if success
+          if ruby_type && !dressed.is_a?(ruby_type)
+            raise "Invalid IC dresser (#{contract.dresser}):"\
+                  " #{ruby_type} expected, got #{dressed.class}"
+          end
+          return dressed
+        else
+          error ||= dressed
+        end
       end
 
       # No one succeeded, just fail
-      handler.failed!(self, value)
+      handler.failed!(self, value, error)
     end
 
   end # class AdType

data/lib/finitio/type/alias_type.rb

@@ -0,0 +1,37 @@
+module Finitio
+  class AliasType < Type
+
+    def initialize(target, name, metadata = nil)
+      unless target.is_a?(Type)
+        raise ArgumentError, "Type expected for target type, got `#{target}`"
+      end
+      if name.nil?
+        raise ArgumentError, "Alias name cannot be nil"
+      end
+
+      super(name, metadata)
+      @target = target
+    end
+    attr_reader :target
+
+    def default_name
+      @name
+    end
+
+    [
+      :representator,
+      :dress,
+      :undress,
+      :include?,
+      :==,
+      :eql?,
+      :hash,
+      :to_s
+    ].each do |meth|
+      define_method(meth) do |*args, &bl|
+        @target.send(meth, *args, &bl)
+      end
+    end
+
+  end # class AliasType
+end # module Finitio

data/lib/finitio/type/any_type.rb

@@ -18,14 +18,18 @@ module Finitio
   #
   class AnyType < Type
 
-    def initialize(name = nil)
-      super(name)
+    def initialize(name = nil, metadata = nil)
+      super(name, metadata)
     end
 
     def default_name
       "Any"
     end
 
+    def representator
+      Object
+    end
+
     def include?(value)
       true
     end
@@ -35,7 +39,7 @@ module Finitio
     end
 
     def ==(other)
-      other.is_a?(AnyType)
+      super || other.is_a?(AnyType)
     end
     alias :eql? :==
 

data/lib/finitio/type/builtin_type.rb

@@ -21,12 +21,14 @@ module Finitio
   #
   class BuiltinType < Type
 
-    def initialize(ruby_type, name = nil)
-      super(name)
+    def initialize(ruby_type, name = nil, metadata = nil)
+      super(name, metadata)
       @ruby_type = ruby_type
     end
     attr_reader :ruby_type
 
+    alias :representator :ruby_type
+
     def default_name
       @ruby_type.name.to_s
     end
@@ -43,8 +45,7 @@ module Finitio
     end
 
     def ==(other)
-      return false unless other.is_a?(BuiltinType)
-      other.ruby_type==ruby_type
+      super || (other.is_a?(BuiltinType) && other.ruby_type==ruby_type)
     end
     alias :eql? :==
 

data/lib/finitio/{support → type}/collection_type.rb

@@ -1,19 +1,18 @@
 module Finitio
   module CollectionType
 
-    def initialize(elm_type, name = nil)
+    def initialize(elm_type, name = nil, metadata = nil)
       unless elm_type.is_a?(Type)
         raise ArgumentError, "Finitio::Type expected, got `#{elm_type}`"
       end
 
-      super(name)
+      super(name, metadata)
       @elm_type = elm_type
     end
     attr_reader :elm_type
 
     def ==(other)
-      return false unless other.is_a?(self.class)
-      elm_type == other.elm_type
+      super || (other.is_a?(self.class) && elm_type == other.elm_type)
     end
     alias :eql? :==
 

data/lib/finitio/type/hash_based_type.rb

@@ -0,0 +1,91 @@
+module Finitio
+  module HashBasedType
+
+    def representator
+      rep = {}
+      heading.each do |attr|
+        rep[attr.name] = rep[attr.type.representator]
+      end
+      rep
+    end
+
+    def include?(value)
+      value.is_a?(Hash) &&
+      valid_attrs?(value) &&
+      heading.all?{|a|
+        value.has_key?(a.name) ? a.type.include?(value[a.name]) : true
+      }
+    end
+
+    # Convert `value` (supposed to be Hash) to a Tuple, by checking attributes
+    # and applying `dress` on them in turn. Raise an error if any attribute
+    # is missing or unrecognized, as well as if any sub transformation fails.
+    def dress(value, handler = DressHelper.new)
+      handler.failed!(self, value) unless looks_a_tuple?(value)
+
+      # Check for extra attributes
+      unless heading.allow_extra? or (extra = extra_attrs(value, true)).empty?
+        handler.fail!("Unrecognized attribute `#{extra.first}`")
+      end
+
+      # Check for missing attributes
+      unless (missing = missing_attrs(value, true)).empty?
+        handler.fail!("Missing attribute `#{missing.first}`")
+      end
+
+      # Uped values, i.e. tuple under construction
+      uped = {}
+
+      # Up each attribute in turn now. Fail on missing ones.
+      heading.each do |attribute|
+        present = true
+        val = attribute.fetch_on(value){ present = false }
+        next unless present
+        handler.deeper(attribute.name) do
+          uped[attribute.name] = attribute.type.dress(val, handler)
+        end
+      end
+
+      uped
+    end
+
+  protected
+
+    def looks_a_tuple?(value)
+      value.is_a?(Hash) or value.respond_to?(:fetch)
+    end
+
+    def attr_names
+      @attr_names ||= heading.map(&:name)
+    end
+
+    def req_attr_names
+      @req_attr_names ||= heading.select(&:required).map(&:name)
+    end
+
+    def attrs(as, to_s)
+      to_s ? as.map(&:to_s) : as
+    end
+
+    def extra_attrs(value, to_s = false)
+      attrs(value.keys, to_s) - attrs(attr_names, to_s)
+    end
+
+    def extra_attr?(value, to_s = false)
+      !extra_attrs(value, to_s).empty?
+    end
+
+    def missing_attrs(value, to_s = false)
+      attrs(req_attr_names, to_s) - attrs(value.keys, to_s)
+    end
+
+    def missing_attr?(value, to_s = false)
+      !missing_attrs(value, to_s).empty?
+    end
+
+    def valid_attrs?(value, to_s = false)
+      (heading.allow_extra? || !extra_attr?(value, to_s)) && !missing_attr?(value)
+    end
+
+  end # module HashBasedType
+end # module Finitio

data/lib/finitio/type/heading_based_type.rb

@@ -0,0 +1,28 @@
+module Finitio
+  module HeadingBasedType
+
+    def initialize(heading, name = nil, metadata = nil)
+      unless heading.is_a?(Heading)
+        raise ArgumentError, "Heading expected, got `#{heading}`"
+      end
+
+      super(name, metadata)
+      @heading = heading
+    end
+    attr_reader :heading
+
+    def [](attrname)
+      heading.fetch(attrname)
+    end
+
+    def ==(other)
+      super || (other.is_a?(self.class) && heading == other.heading)
+    end
+    alias :eql? :==
+
+    def hash
+      self.class.hash ^ heading.hash
+    end
+
+  end # module HeadingBasedType
+end # module Finitio

data/lib/finitio/type/multi_relation_type.rb

@@ -0,0 +1,34 @@
+module Finitio
+  #
+  # The MultiRelation type generator allows capturing sets of information
+  # facts, but allowing optional attributes. E. g.,
+  #
+  #     ColoredPoints = {{ point: Point, color :? Color }}
+  #
+  # This class allows capturing those types, in a way similar to
+  # MultiTupleType:
+  #
+  #     ColoredPoints = MultiRelationType.new( Heading[...] )
+  #
+  # A ruby Set is used as concrete representation, and will contain hashes
+  # that are valid representations of the associated multi tuple type:
+  #
+  #     R(ColoredPoints) = Set[ R({...}) ] = Set[Hash[...]]
+  #
+  # Accordingly, the dress transformation function has the signature below.
+  # It expects an Enumerable as input and fails if any duplicate is found
+  # (after tuple transformation), or if any tuple fails at being transformed.
+  #
+  #     dress :: Alpha  -> ColoredPoints   throws TypeError
+  #     dress :: Object -> Set[Hash[...]]  throws TypeError
+  #
+  class MultiRelationType < Type
+    include HeadingBasedType
+    include RelBasedType
+
+    def default_name
+      "{{#{heading.to_name}}}"
+    end
+
+  end # class MultiRelationType
+end # module Finitio

data/lib/finitio/type/multi_tuple_type.rb

@@ -0,0 +1,29 @@
+module Finitio
+  #
+  # The MultiTuple type generator allows capturing information *facts* with
+  # optional attributes. For instance, a Point type with an optional color
+  # could be defined as follows:
+  #
+  #     Point = { r: Length, theta: Angle, color :? Color }
+  #
+  # This class allows capturing those information types. Note that it is
+  # actually syntactic sugar over union types:
+  #
+  #     Point = { r: Length, theta: Angle }
+  #           | { r: Length, theta: Angle, color: Color }
+  #
+  # A Hash with Symbol as keys is used as concrete ruby representation for
+  # multi tuples. The values map to the concrete representations of each
+  # attribute type. The dress function is similar to the one of TupleType
+  # but allows optional attributes to be omitted
+  #
+  class MultiTupleType < Type
+    include HeadingBasedType
+    include HashBasedType
+
+    def default_name
+      "{#{heading.to_name}}"
+    end
+
+  end # class MultiTupleType
+end # module Finitio

data/lib/finitio/type/proxy_type.rb

@@ -0,0 +1,40 @@
+module Finitio
+  class ProxyType < Type
+
+    def initialize(target_name, target = nil)
+      unless target_name.is_a?(String)
+        raise ArgumentError, "String expected for type name, got `#{target_name}`"
+      end
+
+      @target_name = target_name
+      @target = target
+    end
+    attr_reader :target_name, :target
+
+    [
+      :representator,
+      :name,
+      :name=,
+      :default_name,
+      :dress,
+      :undress,
+      :include?,
+      :==,
+      :eql?,
+      :hash,
+      :to_s
+    ].each do |meth|
+      define_method(meth) do |*args, &bl|
+        raise Error, "Proxy not resolved" unless @target
+        @target.send(meth, *args, &bl)
+      end
+    end
+
+    def resolve(system)
+      @target = system.fetch(target_name) do
+        raise Error, "No such type `#{target_name}`"
+      end
+    end
+
+  end # class ProxyType
+end # module Finitio

data/lib/finitio/type/rel_based_type.rb

@@ -0,0 +1,42 @@
+module Finitio
+  module RelBasedType
+
+    def representator
+      [tuple_type.representator]
+    end
+
+    def include?(value)
+      value.is_a?(Set) && value.all?{|tuple|
+        tuple_type.include?(tuple)
+      }
+    end
+
+    # Apply the corresponding TupleType's `dress` to every element of `value`
+    # (any enumerable). Return a Set of transformed tuples. Fail if anything
+    # goes wrong transforming tuples or if duplicates are found.
+    def dress(value, handler = DressHelper.new)
+      handler.failed!(self, value) unless value.respond_to?(:each)
+
+      # Up every tuple and keep results in a Set
+      set = Set.new
+      handler.iterate(value) do |tuple, index|
+        tuple = tuple_type.dress(tuple, handler)
+        handler.fail!("Duplicate tuple") if set.include?(tuple)
+        set << tuple
+      end
+
+      # Return built tuples
+      set
+    end
+
+  private
+
+    def tuple_type
+      @tuple_type ||= begin
+        clazz = heading.multi? ? MultiTupleType : TupleType
+        clazz.new(heading)
+      end
+    end
+
+  end # module RelBasedType
+end # module Finitio