finitio 0.7.0 → 0.8.0

data/spec/heading/test_looks_similar.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+module Finitio
+  describe Heading, "looks_similar?" do
+
+    let(:heading){
+      Heading.new([Attribute.new(:a, intType),
+                   Attribute.new(:b, stringType)])
+    }
+
+    subject{
+      heading.looks_similar?(h2)
+    }
+
+    context 'when equal' do
+      let(:h2){ heading }
+
+      it 'says yes' do
+        expect(subject).to be_truthy
+      end
+    end
+
+    context 'when shared attributes are in majority' do
+      let(:h2){
+        Heading.new([Attribute.new(:a, intType),
+                     Attribute.new(:c, stringType)])
+      }
+
+      it 'says yes' do
+        expect(subject).to be_truthy
+      end
+    end
+
+    context 'when shared attributes are in minority' do
+      let(:h2){
+        Heading.new([Attribute.new(:d, intType),
+                     Attribute.new(:c, stringType)])
+      }
+
+      it 'says no' do
+        expect(subject).to be_falsy
+      end
+    end
+
+  end
+end

data/spec/heading/test_suppremum.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+module Finitio
+  describe Heading, "suppremum" do
+
+    subject{
+      left.suppremum(right)
+    }
+
+    let(:left){
+      Heading.new([Attribute.new(:a, intType),
+                   Attribute.new(:b, stringType)])
+    }
+
+    context 'when both are equal' do
+      let(:right){
+        Heading.new([Attribute.new(:a, intType),
+                     Attribute.new(:b, stringType)])
+      }
+
+      it 'works' do
+        expect(subject).to be(left)
+      end
+    end
+
+    context 'when they are different' do
+      let(:right){
+        Heading.new([Attribute.new(:a, nilType),
+                     Attribute.new(:b, stringType)])
+      }
+
+      it 'works' do
+        expect(subject).to be_a(Heading)
+        expect(subject[:a].type).to eql(UnionType.new [intType, nilType])
+        expect(subject[:b].type).to eql(stringType)
+      end
+    end
+
+    context 'when they are different II' do
+      let(:right){
+        Heading.new([Attribute.new(:c, nilType),
+                     Attribute.new(:b, stringType)])
+      }
+
+      it 'works' do
+        expect(subject).to be_a(Heading)
+        expect(subject[:a].type).to eql(intType)
+        expect(subject[:a].required).to eql(false)
+        expect(subject[:b].type).to eql(stringType)
+        expect(subject[:b].required).to eql(true)
+        expect(subject[:c].type).to eql(nilType)
+        expect(subject[:c].required).to eql(false)
+      end
+    end
+
+  end
+end

data/spec/inference/test_inference.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'finitio/inference'
+module Finitio
+  describe Inference do
+
+    let(:system) {
+      Finitio.system <<-FIO
+@import finitio/data
+
+Nil = .NilClass
+Boolean = .TrueClass|.FalseClass
+Integer = .Integer
+Date = .Date <iso8601> .String \\( s | Date.iso8601(s) )
+                               \\( d | d.iso8601       )
+String = .String
+      FIO
+    }
+
+    let(:input) {
+      [
+        { "id" => 1, "createdAt" => "2018-01-12", "size" => "15", "priority" => "XL", "meta" => { foo: true, bar: "foo" }, "hobbies" => [] },
+        { "id" => 2, "createdAt" => "2019-02-23", "size" => "1",  "priority" => "L",  "meta" => { foo: true, bar: "baz" }, "hobbies" => ["testing"] },
+        { "id" => 3, "createdAt" => "2018-07-15", "size" => "7",  "priority" => "S",  "meta" => { foo: true, bar: "bar" } },
+        { "id" => 4, "createdAt" => "2019-12-12", "size" => "9",  "priority" => "M",  "meta" => { foo: true, baz: "baz" } },
+        { "id" => 4, "createdAt" => nil,          "size" => "9",  "priority" => "M"  },
+      ]
+    }
+
+    it 'works as expected' do
+      result = Inference.new(system).call(input)
+      expect(result).to be_a(SeqType)
+      expect(result.elm_type).to be_a(MultiTupleType)
+      expect(result.elm_type[:id].type.name).to eql("Integer")
+      expect(result.elm_type[:createdAt].type.name).to eql("Date|Nil")
+      expect(result.elm_type[:size].type.name).to eql("String")
+      expect(result.elm_type[:priority].type.name).to eql("String")
+
+      puts result
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -2,6 +2,7 @@ $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'path'
 require 'finitio'
 require 'finitio/syntax'
+require 'finitio/generation'
 
 require 'coveralls'
 Coveralls.wear!
@@ -49,15 +50,27 @@ module SpecHelpers
   end
 
   def intType
-    Finitio::BuiltinType.new(Integer, "intType")
+    @intType ||= Finitio::BuiltinType.new(Integer, "intType")
   end
 
   def floatType
-    Finitio::BuiltinType.new(Float, "floatType")
+    @floatType ||= Finitio::BuiltinType.new(Float, "floatType")
   end
 
   def nilType
-    Finitio::BuiltinType.new(NilClass, "nilType")
+    @nilType ||= Finitio::BuiltinType.new(NilClass, "nilType")
+  end
+
+  def trueType
+    @trueType ||= Finitio::BuiltinType.new(TrueClass, "trueType")
+  end
+
+  def falseType
+    @falseType ||= Finitio::BuiltinType.new(FalseClass, "falseType")
+  end
+
+  def stringType
+    @stringType ||= Finitio::BuiltinType.new(String, "stringType")
   end
 
   def byte_full
@@ -81,15 +94,19 @@ module SpecHelpers
   end
 
   def byte
-    Finitio::SubType.new(intType, [byte_full])
+    @byte ||= Finitio::SubType.new(intType, [byte_full])
+  end
+
+  def pos_byte
+    @pos_byte ||= Finitio::SubType.new(byte, [positive])
   end
 
   def posInt
-    Finitio::SubType.new(intType, [positive])
+    @posInt ||= Finitio::SubType.new(intType, [positive])
   end
 
   def negInt
-    Finitio::SubType.new(intType, [negative])
+    @negInt ||= Finitio::SubType.new(intType, [negative])
   end
 
   def type_factory
@@ -104,6 +121,14 @@ module SpecHelpers
     Color.new(138, 43, 226)
   end
 
+  def rgb_contract
+    @rgb_contract ||= Finitio::Contract.new(byte, Color.method(:rgb), Finitio::IDENTITY, :rgb)
+  end
+
+  def hex_contract
+    @hex_contract ||= Finitio::Contract.new(floatType, Color.method(:hex), Finitio::IDENTITY, :hex)
+  end
+
 end
 
 RSpec.configure do |c|

data/spec/support/test_compare_attrs.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+module Finitio
+  describe Support, "compare_attrs" do
+    include Support
+
+    context 'with arrays' do
+      it 'works on same attrs' do
+        h1 = [:a, :b]
+        h2 = [:b, :a]
+        shared, mine, yours = compare_attrs(h1, h2)
+        expect(shared).to eql([:a, :b])
+        expect(mine).to eql([])
+        expect(yours).to eql([])
+      end
+
+      it 'works on not same attrs' do
+        h1 = [ :a, :b ]
+        h2 = [ :c, :a ]
+        shared, mine, yours = compare_attrs(h1, h2)
+        expect(shared).to eql([:a])
+        expect(mine).to eql([:b])
+        expect(yours).to eql([:c])
+      end
+    end
+
+    context 'with hashes' do
+      it 'works on same attrs' do
+        h1 = { a: 1, b: 2 }
+        h2 = { a: 1, b: 2 }
+        shared, mine, yours = compare_attrs(h1, h2)
+        expect(shared).to eql([:a, :b])
+        expect(mine).to eql([])
+        expect(yours).to eql([])
+      end
+
+      it 'works on not same attrs' do
+        h1 = { a: 1, b: 2 }
+        h2 = { a: 1, c: 2 }
+        shared, mine, yours = compare_attrs(h1, h2)
+        expect(shared).to eql([:a])
+        expect(mine).to eql([:b])
+        expect(yours).to eql([:c])
+      end
+    end
+
+    context 'with a block' do
+      it 'works on same attrs' do
+        h1 = [{:name => :a}, {:name => :b}]
+        h2 = [{:name => :b}, {:name => :a}]
+        shared, mine, yours = compare_attrs(h1, h2){|a| a[:name] }
+        expect(shared).to eql([:a, :b])
+        expect(mine).to eql([])
+        expect(yours).to eql([])
+      end
+
+      it 'works on not same attrs' do
+        h1 = [{:name => :a}, {:name => :b}]
+        h2 = [{:name => :c}, {:name => :a}]
+        shared, mine, yours = compare_attrs(h1, h2){|a| a[:name] }
+        expect(shared).to eql([:a])
+        expect(mine).to eql([:b])
+        expect(yours).to eql([:c])
+      end
+    end
+
+  end
+end

data/spec/syntax/test_compile.rb

@@ -37,5 +37,62 @@ module Finitio
       end
     end
 
+    context 'with lots of proxies to resolve' do
+      let(:source){
+        <<-EOF.strip
+        Deep = .String
+        Obj = { i: Deep }
+        Objs = [Obj]
+        EOF
+      }
+
+      it{ should be_a(System) }
+
+      it 'should work fine' do
+        expect {
+          subject['Objs'].dress([{i: "hello"}])
+        }.not_to raise_error
+      end
+    end
+
+    context 'with a recursive def' do
+      let(:source){
+        <<-EOF.strip
+        S = .String
+        NodeLabel = S
+        Tree = { label: NodeLabel, children: [Tree] }
+        EOF
+      }
+
+      it{ should be_a(System) }
+
+      it 'should work ine' do
+        expect {
+          subject['Tree'].dress({ label: "Root", children: [
+            { label: "Child1", children: [] },
+            { label: "Child2", children: [] }
+          ]})
+        }.not_to raise_error
+      end
+    end
+
+    context 'with AD types' do
+      let(:source){
+        <<-EOF.strip
+        Colors = [Color]
+        Color = .Color <rgb> { r: Byte, g: Byte, b: Byte }
+        Byte = Int(i | i>0)
+        Int = .Integer
+        EOF
+      }
+
+      it{ should be_a(System) }
+
+      it 'should work ine' do
+        got = subject['Colors'].dress([{ r: 10, g: 15, b: 20 }])
+        expect(got.first).to be_a(Color)
+      end
+    end
+
   end
 end

data/spec/type/ad_type/test_initialize.rb

@@ -2,16 +2,9 @@ require 'spec_helper'
 module Finitio
   describe AdType, 'initialize' do
 
-    let(:rgb){
-      Contract.new(intType, Color.method(:rgb), Finitio::IDENTITY, :rgb)
-    }
-
-    let(:hex){
-      Contract.new(floatType, Color.method(:hex), Finitio::IDENTITY, :hex)
-    }
 
     subject{
-      AdType.new(Color, [rgb, hex])
+      AdType.new(Color, [rgb_contract, hex_contract])
     }
 
     context 'with valid arguments' do

data/spec/type/relation_type/test_suppremum.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+module Finitio
+  describe RelationType, "suppremum" do
+
+    subject{
+      left.suppremum(right)
+    }
+
+    let(:heading){
+      Heading.new([Attribute.new(:a, intType),
+                   Attribute.new(:b, stringType)])
+    }
+
+    let(:left){
+      RelationType.new(heading)
+    }
+
+    context 'when right is not a tuple type' do
+      let(:right){
+        stringType
+      }
+
+      it 'builds a union type' do
+        expect(subject).to be_a(UnionType)
+        expect(subject.candidates).to eql([left, right])
+      end
+    end
+
+    context 'when right is an equal tuple type' do
+      let(:right){
+        RelationType.new(heading)
+      }
+
+      it 'keeps left' do
+        expect(subject).to be(left)
+      end
+    end
+
+    context 'when right is an non-equal tuple type but compatible with RelationType' do
+      let(:heading2){
+        Heading.new([Attribute.new(:a, nilType),
+                     Attribute.new(:b, stringType)])
+      }
+
+      let(:right){
+        RelationType.new(heading2)
+      }
+
+      it 'builds the suppremum as expected' do
+        expect(subject).to be_a(RelationType)
+        expect(subject.heading[:a].type).to eql(UnionType.new [intType,nilType])
+        expect(subject.heading[:b].type).to eql(stringType)
+      end
+    end
+
+    context 'when right is an non-equal tuple type yielding a MultiRelationType' do
+      let(:heading2){
+        Heading.new([Attribute.new(:c, nilType),
+                     Attribute.new(:b, stringType)])
+      }
+
+      let(:right){
+        RelationType.new(heading2)
+      }
+
+      it 'builds the suppremum as expected' do
+        expect(subject).to be_a(MultiRelationType)
+        expect(subject.heading[:a].type).to eql(intType)
+        expect(subject.heading[:a].required).to eql(false)
+        expect(subject.heading[:b].type).to eql(stringType)
+        expect(subject.heading[:b].required).to eql(true)
+        expect(subject.heading[:c].type).to eql(nilType)
+        expect(subject.heading[:c].required).to eql(false)
+      end
+    end
+
+    context 'when right is an non-equal tuple type yielding a MultiRelationType II' do
+      let(:heading2){
+        Heading.new([Attribute.new(:a, nilType, false),
+                     Attribute.new(:b, stringType)])
+      }
+
+      let(:right){
+        MultiRelationType.new(heading2)
+      }
+
+      it 'builds the suppremum as expected' do
+        expect(subject).to be_a(MultiRelationType)
+        expect(subject.heading[:a].type).to eql(UnionType.new [intType,nilType])
+        expect(subject.heading[:a].required).to eql(false)
+        expect(subject.heading[:b].type).to eql(stringType)
+      end
+
+      it 'works the other way round too' do
+        subject = right.suppremum(left)
+        expect(subject).to be_a(MultiRelationType)
+        expect(subject.heading[:a].type).to eql(UnionType.new [intType,nilType])
+        expect(subject.heading[:a].required).to eql(false)
+        expect(subject.heading[:b].type).to eql(stringType)
+      end
+    end
+
+  end
+end