finitio 0.7.0.pre.rc4 → 0.10.0

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-rc4"
+    MINOR = 10
+    TINY  = 0
 
     def self.to_s
       [ MAJOR, MINOR, TINY ].join('.')

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

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/json_schema/test_ad_type.rb

@@ -0,0 +1,20 @@
+module Finitio
+  module JsonSchema
+    describe "AdType" do
+
+      let(:type) {
+        type = AdType.new(Color, [rgb_contract, hex_contract])
+      }
+
+      it 'works as expected' do
+        expect(type.to_json_schema).to eql({
+          anyOf: [
+            { type: "integer" },
+            { type: "string" }
+          ]
+        })
+      end
+
+    end
+  end
+end

data/spec/json_schema/test_alias_type.rb

@@ -0,0 +1,15 @@
+module Finitio
+  module JsonSchema
+    describe "AliasType" do
+
+      let(:alias_type) {
+        AliasType.new(anyType, "X")
+      }
+
+      it 'works as expected' do
+        expect(alias_type.to_json_schema).to eql({})
+      end
+
+    end
+  end
+end

data/spec/json_schema/test_any_type.rb

@@ -0,0 +1,11 @@
+module Finitio
+  module JsonSchema
+    describe "AnyType" do
+
+      it 'works as expected' do
+        expect(anyType.to_json_schema).to eql({})
+      end
+
+    end
+  end
+end

data/spec/json_schema/test_builtin_type.rb

@@ -0,0 +1,51 @@
+module Finitio
+  module JsonSchema
+    describe "BuiltinType" do
+
+      let(:builtin_type) {
+        BuiltinType.new(ruby_type)
+      }
+
+      subject {
+        builtin_type.to_json_schema
+      }
+
+      context 'with NilClass' do
+        let(:ruby_type){ NilClass }
+
+        it 'works' do
+          expect(subject).to eql({ type: "null" })
+        end
+      end
+
+      context 'with String' do
+        let(:ruby_type){ String }
+
+        it 'works' do
+          expect(subject).to eql({ type: "string" })
+        end
+      end
+
+      [Fixnum, Bignum, Integer].each do |rt|
+        context "with #{rt}" do
+          let(:ruby_type){ rt }
+
+          it 'works' do
+            expect(subject).to eql({ type: "integer" })
+          end
+        end
+      end
+
+      [Float, Numeric].each do |rt|
+        context "with #{rt}" do
+          let(:ruby_type){ rt }
+
+          it 'works' do
+            expect(subject).to eql({ type: "number" })
+          end
+        end
+      end
+
+    end
+  end
+end