finitio 0.4.1 → 0.5.0

data/lib/finitio/type/relation_type.rb

@@ -22,60 +22,19 @@ module Finitio
   #     dress :: Object -> Set[Hash[...]]  throws TypeError
   #
   class RelationType < Type
+    include HeadingBasedType
+    include RelBasedType
 
-    def initialize(heading, name = nil)
-      unless heading.is_a?(Heading)
-        raise ArgumentError, "Heading expected, got `#{heading}`"
+    def initialize(heading, name = nil, metadata = nil)
+      super
+      if heading.multi?
+        raise ArgumentError, "Multi heading forbidden"
       end
-
-      super(name)
-      @heading = heading
     end
-    attr_reader :heading
 
     def default_name
       "{{#{heading.to_name}}}"
     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
-
-    def ==(other)
-      return false unless other.is_a?(RelationType)
-      heading == other.heading
-    end
-    alias :eql? :==
-
-    def hash
-      self.class.hash ^ heading.hash
-    end
-
-  private
-
-    def tuple_type
-      @tuple_type ||= TupleType.new(heading)
-    end
-
   end # class RelationType
 end # module Finitio

data/lib/finitio/type/seq_type.rb

@@ -26,6 +26,10 @@ module Finitio
   class SeqType < Type
     include CollectionType
 
+    def representator
+      [elmType]
+    end
+
     def include?(value)
       value.is_a?(::Array) and value.all?{|v| elm_type.include?(v) }
     end

data/lib/finitio/type/set_type.rb

@@ -25,6 +25,10 @@ module Finitio
   class SetType < Type
     include CollectionType
 
+    def representator
+      [elmType].to_set
+    end
+
     def default_name
       "{#{elm_type.name}}"
     end

data/lib/finitio/type/struct_type.rb

@@ -0,0 +1,84 @@
+module Finitio
+  #
+  # The Struct type generator allows capturing positional sequences of values,
+  # such as pairs, triples and so forth. For instance, a Point type could be
+  # defined as follows:
+  #
+  #     Point = <Length, Angle>
+  #
+  # This class allows capturing those information types, as in:
+  #
+  #     Length = BuiltinType.new(Fixnum)
+  #     Angle  = BuiltinType.new(Float)
+  #     Point  = StructType.new([Length, Angle])
+  #
+  # A simple Array is used as concrete ruby representation for structs. The
+  # values map to the concrete representations of each component type:
+  #
+  #     R(Point) = Array[R(Length) ^ R(Angle)]
+  #              = Array[Fixnum ^ Float]
+  #              = Array[Numeric]
+  #
+  # where `^` denotes the `least common super type` operator on ruby classes.
+  #
+  # Accordingly, the `dress` transformation function has the signature below.
+  # It expects it's Alpha/Object argument to be an Array with all and only the
+  # expected components. The `dress` function applies on every component
+  # according to its type.
+  #
+  #     dress :: Alpha  -> Point          throws TypeError
+  #     dress :: Object -> Array[Numeric] throws TypeError
+  #
+  class StructType < Type
+
+    def initialize(component_types, name = nil, metadata = nil)
+      unless component_types.is_a?(Array) &&
+             component_types.all?{|c| c.is_a?(Type) }
+        raise ArgumentError, "[Finitio::Type] expected, got `#{component_types}`"
+      end
+
+      super(name, metadata)
+      @component_types = component_types
+    end
+    attr_reader :component_types
+
+    def representator
+      component_types.map(&:representator)
+    end
+
+    def default_name
+      "<" + @component_types.map(&:name).join(', ') + ">"
+    end
+
+    def include?(value)
+      value.is_a?(Array) &&
+      value.size==component_types.size &&
+      value.zip(component_types).all?{|v,t| t.include?(v) }
+    end
+
+    def dress(value, handler = DressHelper.new)
+      handler.failed!(self, value) unless value.is_a?(Array)
+
+      # check the size
+      cs, vs = component_types.size, value.size
+      handler.fail!("Struct size mismatch (#{vs} for #{cs})") unless cs==vs
+
+      # dress components
+      array = []
+      handler.iterate(value) do |elm, index|
+        array << component_types[index].dress(elm, handler)
+      end
+      array
+    end
+
+    def ==(other)
+      super || (other.is_a?(StructType) && other.component_types == component_types)
+    end
+    alias :eql? :==
+
+    def hash
+      self.class.hash ^ component_types.hash
+    end
+
+  end # class StructType
+end # module Finitio

data/lib/finitio/type/sub_type.rb

@@ -27,28 +27,35 @@ module Finitio
   #
   class SubType < Type
 
-    DEFAULT_CONSTRAINT_NAMES = [:default, :predicate].freeze
-
-    def initialize(super_type, constraints, name = nil)
+    def initialize(super_type, constraints, name = nil, metadata = nil)
       unless super_type.is_a?(Type)
         raise ArgumentError, "Finitio::Type expected, got #{super_type}"
       end
 
-      unless constraints.is_a?(Hash)
-        raise ArgumentError, "Hash expected for constraints, got #{constraints}"
+      unless constraints.is_a?(Array) &&
+             constraints.all?{|v| v.is_a?(Constraint) }
+        raise ArgumentError, "[Constraint] expected for constraints, got #{constraints}"
       end
 
-      super(name)
+      super(name, metadata)
       @super_type, @constraints = super_type, constraints.freeze
     end
     attr_reader :super_type, :constraints
 
+    def representator
+      super_type.representator
+    end
+
+    def [](name)
+      constraints.find{|c| c.name == name }
+    end
+
     def default_name
-      constraints.keys.first.to_s.capitalize
+      constraints.first.name.to_s.capitalize
     end
 
     def include?(value)
-      super_type.include?(value) && constraints.all?{|_,c| c===value }
+      super_type.include?(value) && constraints.all?{|c| c===value }
     end
 
     # Check that `value` can be uped through the supertype, then verify all
@@ -61,10 +68,12 @@ module Finitio
       end
 
       # Check each constraint in turn
-      constraints.each_pair do |name, constraint|
+      constraints.each do |constraint|
         next if constraint===uped
         msg = handler.default_error_message(self, value)
-        msg << " (not #{name})" unless default_constraint?(name)
+        if constraint.named? && constraints.size>1
+          msg << " (not #{constraint.name})"
+        end
         handler.fail!(msg)
       end
 
@@ -73,22 +82,16 @@ module Finitio
     end
 
     def ==(other)
-      return false unless other.is_a?(SubType)
-      other.super_type == super_type and \
-      set_equal?(constraints.values, other.constraints.values)
+      super || (
+        other.is_a?(SubType) && (other.super_type == super_type) &&
+        set_equal?(constraints, other.constraints)
+      )
     end
     alias :eql? :==
 
     def hash
-      self.class.hash ^ super_type.hash ^ set_hash(constraints.values)
-    end
-
-  private
-
-    def default_constraint?(name)
-      DEFAULT_CONSTRAINT_NAMES.include?(name) or \
-        name.to_s.capitalize == self.name
+      self.class.hash ^ super_type.hash ^ set_hash(constraints)
     end
 
-  end # class BuiltinType
+  end # class SubType
 end # module Finitio

data/lib/finitio/type/tuple_type.rb

@@ -30,70 +30,19 @@ module Finitio
   #     dress :: Object -> Hash[r: Fixnum, theta: Float] throws TypeError
   #
   class TupleType < Type
+    include HeadingBasedType
+    include HashBasedType
 
-    def initialize(heading, name = nil)
-      unless heading.is_a?(Heading)
-        raise ArgumentError, "Heading expected, got `#{heading}`"
+    def initialize(heading, name = nil, metadata = nil)
+      super
+      if heading.multi?
+        raise ArgumentError, "Multi heading forbidden"
       end
-
-      super(name)
-      @heading = heading
     end
-    attr_reader :heading
 
     def default_name
       "{#{heading.to_name}}"
     end
 
-    def include?(value)
-      return false unless value.is_a?(Hash)
-      return false if value.size > heading.size
-      heading.all? do |attribute|
-        attr_val = value.fetch(attribute.name){
-          return false
-        }
-        attribute.type.include?(attr_val)
-      end
-    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 value.is_a?(Hash)
-
-      # Uped values, i.e. tuple under construction
-      uped = {}
-
-      # Check the tuple arity and fail fast if extra attributes
-      # (missing attributes are handled just after)
-      if value.size > heading.size
-        extra = value.keys.map(&:to_s) - heading.map{|attr| attr.name.to_s }
-        handler.fail!("Unrecognized attribute `#{extra.first}`")
-      end
-
-      # Up each attribute in turn now. Fail on missing ones.
-      heading.each do |attribute|
-        val = attribute.fetch_on(value) do
-          handler.fail!("Missing attribute `#{attribute.name}`")
-        end
-        handler.deeper(attribute.name) do
-          uped[attribute.name] = attribute.type.dress(val, handler)
-        end
-      end
-
-      uped
-    end
-
-    def ==(other)
-      return false unless other.is_a?(TupleType)
-      heading == other.heading
-    end
-    alias :eql? :==
-
-    def hash
-      self.class.hash ^ heading.hash
-    end
-
   end # class TupleType
 end # module Finitio

data/lib/finitio/type/union_type.rb

@@ -29,16 +29,20 @@ module Finitio
   #
   class UnionType < Type
 
-    def initialize(candidates, name = nil)
+    def initialize(candidates, name = nil, metadata = nil)
       unless candidates.all?{|c| c.is_a?(Type) }
         raise ArgumentError, "[Finitio::Type] expected, got #{candidates}"
       end
 
-      super(name)
+      super(name, metadata)
       @candidates = candidates.freeze
     end
     attr_reader :candidates
 
+    def representator
+      raise NotImplementedError
+    end
+
     def include?(value)
       candidates.any?{|c| c.include?(value) }
     end
@@ -47,6 +51,7 @@ module Finitio
     # returned by the first one that does not fail. Fail with an TypeError if no
     # candidate succeeds at tranforming `value`.
     def dress(value, handler = DressHelper.new)
+      error = nil
 
       # Do nothing on TypeError as the next candidate could be the good one!
       candidates.each do |c|
@@ -54,10 +59,11 @@ module Finitio
           c.dress(value, handler)
         end
         return uped if success
+        error ||= uped
       end
 
       # No one succeed, just fail
-      handler.failed!(self, value)
+      handler.failed!(self, value, error)
     end
 
     def default_name
@@ -65,8 +71,9 @@ module Finitio
     end
 
     def ==(other)
-      return false unless other.is_a?(UnionType)
-      set_equal?(candidates, other.candidates)
+      super || (
+        other.is_a?(UnionType) && set_equal?(candidates, other.candidates)
+      )
     end
     alias :eql? :==
 

data/lib/finitio/version.rb

@@ -2,8 +2,8 @@ module Finitio
   module Version
 
     MAJOR = 0
-    MINOR = 4
-    TINY  = 1
+    MINOR = 5
+    TINY  = 0
 
     def self.to_s
       [ MAJOR, MINOR, TINY ].join('.')

data/spec/{unit/attribute → attribute}/test_equality.rb

@@ -5,21 +5,24 @@ module Finitio
     let(:attr1){ Attribute.new(:red, intType) }
     let(:attr2){ Attribute.new(:red, intType) }
     let(:attr3){ Attribute.new(:blue, intType) }
+    let(:attr4){ Attribute.new(:red, intType, false) }
 
     it 'should apply structural equality' do
-      (attr1 == attr2).should be_true
+      expect(attr1 == attr2).to eq(true)
     end
 
     it 'should distinguish different attributes' do
-      (attr1 == attr3).should be_false
+      expect(attr1 == attr3).to eq(false)
+      expect(attr1 == attr4).to eq(false)
     end
 
-    it 'should return nil if not equal' do
-      (attr1 == 12).should be_nil
+    it 'should false against non Attribute' do
+      expect(attr1 == 12).to eq(false)
     end
 
     it 'should implement hash accordingly' do
-      attr1.hash.should eq(attr2.hash)
+      expect(attr1.hash).to eq(attr2.hash)
+      expect(attr1.hash).not_to eq(attr4.hash)
     end
 
   end

data/spec/{unit/attribute → attribute}/test_fetch_on.rb

@@ -10,9 +10,9 @@ module Finitio
       let(:arg){ 12 }
 
       it 'should raise an error' do
-        ->{
+        expect{
           subject
-        }.should raise_error(ArgumentError, "Object responding to `fetch` expected")
+        }.to raise_error(ArgumentError, "Object responding to `fetch` expected")
       end
     end
 
@@ -32,9 +32,9 @@ module Finitio
       let(:arg){ { other: 123 } }
 
       it 'should raise an error' do
-        ->{
+        expect{
           attr.fetch_on(arg)
-        }.should raise_error(KeyError)
+        }.to raise_error(KeyError)
       end
     end
 
@@ -42,7 +42,7 @@ module Finitio
       let(:arg){ { other: 123 } }
 
       it 'should yield the block' do
-        attr.fetch_on(arg){ "none" }.should eq("none")
+        expect(attr.fetch_on(arg){ "none" }).to eq("none")
       end
     end