finitio 0.7.0.pre.rc4 → 0.10.0

data/spec/json_schema/test_multi_relation_type.rb

@@ -0,0 +1,58 @@
+module Finitio
+  module JsonSchema
+    describe "MultiRelationType" do
+
+      context 'with a true allow extra and some optional attribute' do
+        let(:heading){
+          Heading.new([
+            Attribute.new(:a, anyType),
+            Attribute.new(:b, anyType, false),
+          ], allow_extra: true)
+        }
+
+        let(:multi_relation_type) {
+          MultiRelationType.new(heading)
+        }
+
+        it 'works as expected' do
+          expect(multi_relation_type.to_json_schema).to eql({
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                a: {},
+                b: {}
+              },
+              required: [:a],
+              additionalProperties: {}
+            },
+            uniqueItems: true
+          })
+        end
+      end
+
+      context 'with a allow extra requiring Strings' do
+        let(:heading){
+          Heading.new([
+          ], allow_extra: BuiltinType.new(String))
+        }
+
+        let(:multi_relation_type) {
+          MultiRelationType.new(heading)
+        }
+
+        it 'works as expected' do
+          expect(multi_relation_type.to_json_schema).to eql({
+            type: "array",
+            items: {
+              type: "object",
+              additionalProperties: { type: "string" }
+            },
+            uniqueItems: true
+          })
+        end
+      end
+
+    end
+  end
+end

data/spec/json_schema/test_multi_tuple_type.rb

@@ -0,0 +1,50 @@
+module Finitio
+  module JsonSchema
+    describe "MultiTupleType" do
+
+      context 'with a true allow extra and some optional attribute' do
+        let(:heading){
+          Heading.new([
+            Attribute.new(:a, anyType),
+            Attribute.new(:b, anyType, false),
+          ], allow_extra: true)
+        }
+
+        let(:multi_tuple_type) {
+          MultiTupleType.new(heading)
+        }
+
+        it 'works as expected' do
+          expect(multi_tuple_type.to_json_schema).to eql({
+            type: "object",
+            properties: {
+              a: {},
+              b: {}
+            },
+            required: [:a],
+            additionalProperties: {}
+          })
+        end
+      end
+
+      context 'with a allow extra requiring Strings' do
+        let(:heading){
+          Heading.new([
+          ], allow_extra: BuiltinType.new(String))
+        }
+
+        let(:multi_tuple_type) {
+          MultiTupleType.new(heading)
+        }
+
+        it 'works as expected' do
+          expect(multi_tuple_type.to_json_schema).to eql({
+            type: "object",
+            additionalProperties: { type: "string" }
+          })
+        end
+      end
+
+    end
+  end
+end

data/spec/json_schema/test_relation_type.rb

@@ -0,0 +1,30 @@
+module Finitio
+  module JsonSchema
+    describe "RelationType" do
+
+      let(:heading){
+        Heading.new([Attribute.new(:a, anyType)])
+      }
+
+      let(:tuple_type) {
+        RelationType.new(heading)
+      }
+
+      it 'works as expected' do
+        expect(tuple_type.to_json_schema).to eql({
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              a: {}
+            },
+            required: [:a],
+            additionalProperties: false
+          },
+          uniqueItems: true
+        })
+      end
+
+    end
+  end
+end

data/spec/json_schema/test_seq_type.rb

@@ -0,0 +1,18 @@
+module Finitio
+  module JsonSchema
+    describe "SeqType" do
+
+      let(:type) {
+        SeqType.new(anyType)
+      }
+
+      it 'works as expected' do
+        expect(type.to_json_schema).to eql({
+          type: "array",
+          items: {}
+        })
+      end
+
+    end
+  end
+end

data/spec/json_schema/test_set_type.rb

@@ -0,0 +1,19 @@
+module Finitio
+  module JsonSchema
+    describe "SetType" do
+
+      let(:type) {
+        SetType.new(anyType)
+      }
+
+      it 'works as expected' do
+        expect(type.to_json_schema).to eql({
+          type: "array",
+          items: {},
+          uniqueItems: true
+        })
+      end
+
+    end
+  end
+end

data/spec/json_schema/test_struct_type.rb

@@ -0,0 +1,18 @@
+module Finitio
+  module JsonSchema
+    describe "StructType" do
+
+      let(:type) {
+        StructType.new([anyType,anyType])
+      }
+
+      it 'works as expected' do
+        expect(type.to_json_schema).to eql({
+          type: "array",
+          items: [{},{}]
+        })
+      end
+
+    end
+  end
+end

data/spec/json_schema/test_sub_type.rb

@@ -0,0 +1,17 @@
+module Finitio
+  module JsonSchema
+    describe "SubType" do
+
+      let(:type) {
+        byte
+      }
+
+      it 'skips constraints (for now)' do
+        expect(byte.to_json_schema).to eql({
+          type: "integer"
+        })
+      end
+
+    end
+  end
+end

data/spec/json_schema/test_tuple_type.rb

@@ -0,0 +1,26 @@
+module Finitio
+  module JsonSchema
+    describe "TupleType" do
+
+      let(:heading){
+        Heading.new([Attribute.new(:a, anyType)])
+      }
+
+      let(:tuple_type) {
+        TupleType.new(heading)
+      }
+
+      it 'works as expected' do
+        expect(tuple_type.to_json_schema).to eql({
+          type: "object",
+          properties: {
+            a: {}
+          },
+          required: [:a],
+          additionalProperties: false
+        })
+      end
+
+    end
+  end
+end

data/spec/json_schema/test_union_type.rb

@@ -0,0 +1,17 @@
+module Finitio
+  module JsonSchema
+    describe "UnionType" do
+
+      let(:union_type) {
+        UnionType.new([anyType])
+      }
+
+      it 'works as expected' do
+        expect(union_type.to_json_schema).to eql({
+          anyOf: [{}]
+        })
+      end
+
+    end
+  end
+end

data/spec/regression/test_heading_extra_are_proxy_resolved.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe "Heading extra are properly resolved" do
+
+  describe "When the extra map to a type" do
+    let(:schema){
+      Finitio.system <<~F
+        Type = { ... : World }
+        World = .String
+        Type
+      F
+    }
+
+    it 'works' do
+      expect(schema.dress("hello" => "World")).to eql(hello: "World")
+    end
+  end
+
+  describe "When the extra maps to nothing" do
+    let(:schema){
+      Finitio.system <<~F
+        {
+          hello: .String
+          ...
+        }
+      F
+    }
+
+    it 'works' do
+      expect(schema.dress("hello" => "World")).to eql(hello: "World")
+    end
+
+    it 'supports extra' do
+      expect(schema.dress({
+        "hello" => "World",
+        "extra" => "Foo"
+      })).to eql(hello: "World")
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -2,6 +2,8 @@ $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'path'
 require 'finitio'
 require 'finitio/syntax'
+require 'finitio/generation'
+require 'finitio/json_schema'
 
 require 'coveralls'
 Coveralls.wear!
@@ -49,15 +51,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 +95,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 +122,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(stringType, 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