finitio 0.8.0 → 0.11.1

data/spec/inference/test_inference.rb

@@ -4,15 +4,15 @@ module Finitio
   describe Inference do
 
     let(:system) {
-      Finitio.system <<-FIO
-@import finitio/data
+      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
+        Nil = .NilClass
+        Boolean = .TrueClass|.FalseClass
+        Integer = .Integer
+        Date = .Date <iso8601> .String \\( s | Date.iso8601(s) )
+                                       \\( d | d.iso8601       )
+        String = .String
       FIO
     }
 

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

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,75 @@
+module Finitio
+  module JsonSchema
+    describe "UnionType" do
+
+      let(:string_type) {
+        BuiltinType.new(String)
+      }
+
+      let(:int_type) {
+        BuiltinType.new(Integer)
+      }
+
+      let(:true_type) {
+        BuiltinType.new(TrueClass)
+      }
+
+      let(:false_type) {
+        BuiltinType.new(FalseClass)
+      }
+
+      let(:nil_type) {
+        BuiltinType.new(NilClass)
+      }
+
+      context 'when used with a single type' do
+        let(:union_type) {
+          UnionType.new([string_type])
+        }
+
+        it 'works as expected' do
+          expect(union_type.to_json_schema).to eql({
+            :type => "string"
+          })
+        end
+      end
+
+      context 'when used with two types' do
+        let(:union_type) {
+          UnionType.new([string_type, int_type])
+        }
+
+        it 'works as expected' do
+          expect(union_type.to_json_schema).to eql({
+            anyOf: [{:type => "string"}, {:type => "integer"}]
+          })
+        end
+      end
+
+      context 'when used with a |Nil' do
+        let(:union_type) {
+          UnionType.new([string_type, int_type, nil_type])
+        }
+
+        it 'works as expected' do
+          expect(union_type.to_json_schema).to eql({
+            anyOf: [{:type => "string"}, {:type => "integer"}]
+          })
+        end
+      end
+
+      context 'when used with a TrueClass|FalseClass' do
+        let(:union_type) {
+          UnionType.new([true_type, false_type])
+        }
+
+        it 'works as expected' do
+          expect(union_type.to_json_schema).to eql({
+            :type => "boolean"
+          })
+        end
+      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

@@ -3,6 +3,7 @@ require 'path'
 require 'finitio'
 require 'finitio/syntax'
 require 'finitio/generation'
+require 'finitio/json_schema'
 
 require 'coveralls'
 Coveralls.wear!
@@ -126,7 +127,7 @@ module SpecHelpers
   end
 
   def hex_contract
-    @hex_contract ||= Finitio::Contract.new(floatType, Color.method(:hex), Finitio::IDENTITY, :hex)
+    @hex_contract ||= Finitio::Contract.new(stringType, Color.method(:hex), Finitio::IDENTITY, :hex)
   end
 
 end

data/spec/syntax/nodes/test_attribute.rb

@@ -34,6 +34,18 @@ module Finitio
           expect(compiled).not_to be_required
         end
       end
+
+      context 'when using dashes in attribute name' do
+        let(:input){ 'created-at : .Integer' }
+
+        it 'works' do
+          expect(compiled).to be_a(Attribute)
+          expect(compiled.name).to eq(:"created-at")
+          expect(compiled.type).to be_a(BuiltinType)
+          expect(compiled.type.ruby_type).to be(Integer)
+          expect(compiled).to be_required
+        end
+      end
     end
 
     describe 'AST' do
@@ -60,6 +72,6 @@ module Finitio
       end
 
     end
-    
+
   end
 end