finitio 0.7.0.pre.rc3 → 0.9.1

data/lib/finitio/type/ad_type.rb

@@ -132,7 +132,7 @@ module Finitio
     end
 
     def hash
-      [ ruby_type, contracts ].hash
+      ruby_type.hash ^ contracts.hash
     end
 
     def ==(other)
@@ -144,5 +144,13 @@ module Finitio
     end
     alias :eql? :==
 
+    def resolve_proxies(system)
+      AdType.new(ruby_type, contracts.map{|t| t.resolve_proxies(system)}, name, metadata)
+    end
+
+    def unconstrained
+      AdType.new(ruby_type, contracts.map{|c| c.unconstrained}, name, metadata)
+    end
+
   end # class AdType
 end # module Finitio

data/lib/finitio/type/alias_type.rb

@@ -33,5 +33,13 @@ module Finitio
       end
     end
 
+    def resolve_proxies(system)
+      AliasType.new(target.resolve_proxies(system), name, metadata)
+    end
+
+    def unconstrained
+      AliasType.new(target.unconstrained, name, metadata)
+    end
+
   end # class AliasType
 end # module Finitio

data/lib/finitio/type/any_type.rb

@@ -38,6 +38,14 @@ module Finitio
       value
     end
 
+    def suppremum(other)
+      self
+    end
+
+    def _suppremum(other)
+      self
+    end
+
     def ==(other)
       super || other.is_a?(AnyType)
     end
@@ -47,5 +55,9 @@ module Finitio
       self.class.hash ^ 37
     end
 
+    def resolve_proxies(system)
+      self
+    end
+
   end # class AnyType
 end # module Finitio

data/lib/finitio/type/builtin_type.rb

@@ -53,5 +53,9 @@ module Finitio
       self.class.hash ^ ruby_type.hash
     end
 
+    def resolve_proxies(system)
+      self
+    end
+
   end # class BuiltinType
 end # module Finitio

data/lib/finitio/type/collection_type.rb

@@ -20,5 +20,20 @@ module Finitio
       self.class.hash ^ self.elm_type.hash
     end
 
+    def suppremum(other)
+      return super unless other.is_a?(CollectionType)
+      return self if other.is_a?(CollectionType) && elm_type == other.elm_type
+      builder = self.class == other.class ? self.class : SeqType
+      builder.new(elm_type.suppremum(other.elm_type))
+    end
+
+    def resolve_proxies(system)
+      self.class.new(elm_type.resolve_proxies(system), name, metadata)
+    end
+
+    def unconstrained
+      self.class.new(elm_type.unconstrained, name, metadata)
+    end
+
   end # module CollectionType
 end # module Finitio

data/lib/finitio/type/heading_based_type.rb

@@ -15,6 +15,15 @@ module Finitio
       heading.fetch(attrname)
     end
 
+    def suppremum(other, simple_class, multi_class)
+      return self if self == other
+      return super(other) unless other.is_a?(simple_class) or other.is_a?(multi_class)
+      return super(other) unless heading.looks_similar?(other.heading)
+      result_heading = heading.suppremum(other.heading)
+      builder = result_heading.multi? ? multi_class : simple_class
+      builder.new(result_heading)
+    end
+
     def ==(other)
       super || (other.is_a?(self.class) && heading == other.heading)
     end
@@ -24,5 +33,13 @@ module Finitio
       self.class.hash ^ heading.hash
     end
 
+    def resolve_proxies(system)
+      self.class.new(heading.resolve_proxies(system), name, metadata)
+    end
+
+    def unconstrained
+      self.class.new(heading.unconstrained, name, metadata)
+    end
+
   end # module HeadingBasedType
 end # module Finitio

data/lib/finitio/type/high_order_type.rb

@@ -0,0 +1,39 @@
+module Finitio
+  class HighOrderType < Type
+
+    def initialize(vars, defn, name = nil, metadata = nil)
+      super(name, metadata)
+      @vars = vars
+      @defn = defn
+    end
+    attr_reader :vars, :defn
+
+    def default_name
+      "Type<#{vars.join(',')}>"
+    end
+
+    def suppremum(other)
+      raise NotImplementedError, "Suppremum is not defined on high order types"
+    end
+
+    def ==(other)
+      super || other.is_a?(HighOrderType) \
+            && other.vars == self.vars \
+            && other.defn = self.defn
+    end
+
+    def resolve_proxies(system)
+      self
+    end
+
+    def instantiate(compilation, sub_types)
+      overrides = Hash[vars.zip(sub_types)]
+      defn.resolve_proxies(compilation.with_scope(overrides))
+    end
+
+    def unconstrained
+      HighOrderType.new(vars, defn.unconstrained, name, metadata)
+    end
+
+  end # class HighOrderType
+end # module Finitio

data/lib/finitio/type/multi_relation_type.rb

@@ -30,5 +30,9 @@ module Finitio
       "{{#{heading.to_name}}}"
     end
 
+    def suppremum(other)
+      super(other, RelationType, MultiRelationType)
+    end
+
   end # class MultiRelationType
 end # module Finitio

data/lib/finitio/type/multi_tuple_type.rb

@@ -25,5 +25,9 @@ module Finitio
       "{#{heading.to_name}}"
     end
 
+    def suppremum(other)
+      super(other, TupleType, MultiTupleType)
+    end
+
   end # class MultiTupleType
 end # module Finitio

data/lib/finitio/type/proxy_type.rb

@@ -11,30 +11,20 @@ module Finitio
     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, "No such type `#{@target_name}` (proxy not resolved?)" unless @target
-        @target.send(meth, *args, &bl)
-      end
+    def default_name
+      "_#{target_name}_"
     end
 
-    def resolve(system)
-      @target = system.fetch(target_name){
-        raise Error, "No such type `#{target_name}`"
+    def resolve_proxies(system)
+      system.fetch(target_name){
+        raise Error, "No such type `#{target_name}` in #{system}"
       }
     end
 
+    def unconstrained
+      return @target.unconstrained if @target
+      raise Error, "`unconstrained` cannot be call whithout proxies being resolved"
+    end
+
   end # class ProxyType
 end # module Finitio

data/lib/finitio/type/relation_type.rb

@@ -36,5 +36,9 @@ module Finitio
       "{{#{heading.to_name}}}"
     end
 
+    def suppremum(other)
+      super(other, RelationType, MultiRelationType)
+    end
+
   end # class RelationType
 end # module Finitio

data/lib/finitio/type/seq_type.rb

@@ -27,7 +27,7 @@ module Finitio
     include CollectionType
 
     def representator
-      [elmType]
+      [elm_type]
     end
 
     def include?(value)

data/lib/finitio/type/struct_type.rb

@@ -80,5 +80,13 @@ module Finitio
       self.class.hash ^ component_types.hash
     end
 
+    def resolve_proxies(system)
+      StructType.new(component_types.map{|t| t.resolve_proxies(system)}, name, metadata)
+    end
+
+    def unconstrained
+      StructType.new(component_types.map{|t| t.unconstrained}, name, metadata)
+    end
+
   end # class StructType
 end # module Finitio

data/lib/finitio/type/sub_type.rb

@@ -81,6 +81,10 @@ module Finitio
       uped
     end
 
+    def unconstrained
+      super_type.unconstrained
+    end
+
     def ==(other)
       super || (
         other.is_a?(SubType) && (other.super_type == super_type) &&
@@ -93,5 +97,9 @@ module Finitio
       self.class.hash ^ super_type.hash ^ set_hash(constraints)
     end
 
+    def resolve_proxies(system)
+      SubType.new(super_type.resolve_proxies(system), constraints, name, metadata)
+    end
+
   end # class SubType
 end # module Finitio

data/lib/finitio/type/tuple_type.rb

@@ -44,5 +44,9 @@ module Finitio
       "{#{heading.to_name}}"
     end
 
+    def suppremum(other)
+      super(other, TupleType, MultiTupleType)
+    end
+
   end # class TupleType
 end # module Finitio

data/lib/finitio/type/union_type.rb

@@ -70,6 +70,17 @@ module Finitio
       candidates.map(&:name).join('|')
     end
 
+    def suppremum(other)
+      return self if other == self
+      cs = if (other.is_a?(UnionType))
+        candidates + other.candidates
+      else
+        candidates + [other]
+      end
+      UnionType.new(cs.uniq)
+    end
+    alias :_suppremum :suppremum
+
     def ==(other)
       super || (
         other.is_a?(UnionType) && set_equal?(candidates, other.candidates)
@@ -81,5 +92,13 @@ module Finitio
       self.class.hash ^ set_hash(self.candidates)
     end
 
+    def resolve_proxies(system)
+      UnionType.new(candidates.map{|t| t.resolve_proxies(system)}, name, metadata)
+    end
+
+    def unconstrained
+      UnionType.new(candidates.map{|c| c.unconstrained }, name, metadata)
+    end
+
   end # class UnionType
 end # module Finitio

data/lib/finitio/version.rb

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

data/spec/finitio/test_stdlib_memoization.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+describe Finitio, "stdlib memoization" do
+
+  describe "is_stdlib_source?" do
+
+    it 'says false when source code' do
+      expect(Finitio.is_stdlib_source?(".String")).to be_falsy
+    end
+
+    it 'says false when a source file' do
+      expect(Finitio.is_stdlib_source?(Path.dir/"system.fio")).to be_falsy
+    end
+
+    it 'says true when a stdlib file' do
+      source = Path.dir.parent.parent/"lib/finitio/stdlib/finitio/data.fio"
+      expect(source).to be_file
+      expect(Finitio.is_stdlib_source?(source)).to be_truthy
+    end
+
+  end
+
+end

data/spec/finitio/test_system.rb

@@ -29,15 +29,4 @@ describe Finitio, "system" do
     end
   end
 
-  context "feedback about duplicate types" do
-    before {
-      Finitio.stdlib_path(Path.dir.parent)
-    }
-    subject{
-      Finitio.system(Path.dir/"with-duplicates.fio").check_and_warn
-    }
-
-    it{ should be_a(Finitio::System) }
-  end
-
 end

data/spec/generation/test_generation.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+module Finitio
+  describe Generation do
+
+    subject {
+      Generation.new({
+        :heuristic  => Generation::Heuristic::Constant.new,
+        :generators => generators
+      })
+    }
+
+    let(:generators) {
+      {}
+    }
+
+    class SubString < String
+    end
+
+    describe 'when called on scalar types' do
+
+      it 'works for nil' do
+        expect(subject.call(nilType)).to eql(nil)
+      end
+
+      it 'works for ints' do
+        expect(subject.call(intType)).to eql(99)
+      end
+
+      it 'works for floats' do
+        expect(subject.call(floatType)).to eql(99.99)
+      end
+
+      it 'works for strings' do
+        expect(subject.call(stringType)).to eql("Hello world")
+      end
+
+      it 'works for true' do
+        expect(subject.call(trueType)).to be(true)
+      end
+
+      it 'works for false' do
+        expect(subject.call(falseType)).to be(false)
+      end
+
+      it 'works on ruby sub types' do
+        expect(subject.call(BuiltinType.new(SubString))).to eql("Hello world")
+      end
+
+    end
+
+    describe 'when called on Any type' do
+
+      it 'works' do
+        expect {
+          subject.call(anyType)
+        }.not_to raise_error
+      end
+
+    end
+
+    describe 'when called on an alias type' do
+
+      it 'works' do
+        expect(subject.call(AliasType.new(intType, "x"))).to eql(99)
+      end
+
+    end
+
+    describe 'when called on an sub type' do
+
+      it 'works' do
+        expect(subject.call(byte)).to eql(99)
+      end
+
+    end
+
+    describe 'when called on a collection type' do
+
+      it 'works on a SeqType' do
+        got = subject.call(SeqType.new(intType))
+        expect(got).to be_a(Array)
+        expect(got.all?{|x| x==99 }).to be_truthy
+      end
+
+      it 'works on a SetType' do
+        got = subject.call(SetType.new(intType))
+        expect(got).to be_a(Array)
+        expect(got.all?{|x| x==99 }).to be_truthy
+      end
+
+    end
+
+    describe 'when called on tuple types' do
+
+      it 'works as expected' do
+        type = TupleType.new(Heading.new [Attribute.new(:i, intType)])
+        expect(subject.call(type)).to eql({i: 99})
+      end
+
+      it 'works as expected' do
+        type = MultiTupleType.new(Heading.new [Attribute.new(:i, intType)])
+        expect(subject.call(type)).to eql({i: 99})
+      end
+
+    end
+
+    describe 'when called on relation types' do
+
+      it 'works as expected' do
+        type = RelationType.new(Heading.new [Attribute.new(:i, intType)])
+        expect(subject.call(type)).to eql([{i: 99}])
+      end
+
+      it 'works as expected' do
+        type = MultiRelationType.new(Heading.new [Attribute.new(:i, intType)])
+        expect(subject.call(type)).to eql([{i: 99}])
+      end
+    end
+
+    describe 'when called on a union type' do
+
+      it 'works as expected' do
+        type = UnionType.new([trueType, falseType])
+        expect([true, false].include? subject.call(type)).to be_truthy
+      end
+
+    end
+
+    describe 'when called on an AD type' do
+
+      it 'works' do
+        type = AdType.new(Color, [rgb_contract])
+        expect(subject.call(byte)).to eql(99)
+      end
+
+    end
+
+    describe 'when examples are provided in metadata' do
+
+      it 'takes the priority' do
+        type = AliasType.new(intType, "X", { examples: [97] })
+        expect(subject.call(type)).to eql(97)
+      end
+
+    end
+
+    describe 'when a generator exists' do
+
+      let(:generators) {
+        {
+          "X" => ->(type, gen, _) { 96 },
+          "Y" => ->(type, gen, world) { world }
+        }
+      }
+
+      it 'takes the priority even over examples' do
+        type = AliasType.new(intType, "X", { examples: [97] })
+        expect(subject.call(type)).to eql(96)
+      end
+
+      it 'lets pass a world' do
+        type = AliasType.new(intType, "Y", { examples: [97] })
+        expect(subject.call(type, 17)).to eql(17)
+      end
+
+    end
+
+  end
+end