babl-json 0.1.4 → 0.2.0

data/lib/babl/schema/static.rb

@@ -0,0 +1,14 @@
+require 'values'
+
+module Babl
+    module Schema
+        class Static < Value.new(:value)
+            NULL = new(nil)
+
+            def json
+                return { type: 'null' } if value.nil?
+                { enum: [value] }
+            end
+        end
+    end
+end

data/lib/babl/template.rb

@@ -1,7 +1,7 @@
-require 'babl/utils/hash'
-
 require 'babl/operators/array'
 require 'babl/operators/call'
+require 'babl/operators/continue'
+require 'babl/operators/default'
 require 'babl/operators/dep'
 require 'babl/operators/each'
 require 'babl/operators/enter'
@@ -20,18 +20,13 @@ require 'babl/operators/switch'
 require 'babl/operators/with'
 
 require 'babl/builder/template_base'
-require 'babl/builder/chain_builder'
-
-require 'babl/rendering/compiled_template'
-require 'babl/rendering/context'
-require 'babl/rendering/internal_value_node'
-require 'babl/rendering/terminal_value_node'
-require 'babl/rendering/noop_preloader'
 
 module Babl
     class Template < Babl::Builder::TemplateBase
         include Operators::Array::DSL
         include Operators::Call::DSL
+        include Operators::Continue::DSL
+        include Operators::Default::DSL
         include Operators::Dep::DSL
         include Operators::Each::DSL
         include Operators::Enter::DSL

data/lib/babl/utils/ref.rb

@@ -0,0 +1,6 @@
+module Babl
+    module Utils
+        class Ref
+        end
+    end
+end

data/lib/babl/version.rb

@@ -1,3 +1,3 @@
 module Babl
-    VERSION = '0.1.4'
+    VERSION = '0.2.0'
 end

data/spec/operators/array_spec.rb

@@ -1,13 +1,37 @@
 require 'spec_helper'
 
-describe ::Babl::Operators::Array do
-    include SpecHelper::Operators
+describe Babl::Operators::Array do
+    extend SpecHelper::OperatorTesting
 
     describe '#array' do
-        let(:template) { dsl.source { array('coucou', 45, a: 1, b: [_]) } }
-        let(:object) { { b: 12 } }
-        it { expect(json).to eq ['coucou', 45, { 'a' => 1, 'b' => [12] }] }
-        it { expect(dependencies).to eq(b: {}) }
-        it { expect(documentation).to eq ['coucou', 45, a: 1, b: [:__value__]] }
+        context 'statically defined array' do
+            template { array('coucou', 45, a: 1, b: [_]) }
+
+            let(:object) { { b: 12 } }
+
+            it { expect(json).to eq ['coucou', 45, { 'a' => 1, 'b' => [12] }] }
+            it { expect(dependencies).to eq(b: {}) }
+            it {
+                expect(schema).to eq(
+                    s_fixed_array(
+                        s_static('coucou'),
+                        s_static(45),
+                        s_object(
+                            s_property(:a, s_static(1)),
+                            s_property(:b, s_fixed_array(s_anything))
+                        )
+                    )
+                )
+            }
+        end
+
+        context 'nullable array' do
+            template { nullable.array(itself) }
+
+            let(:object) { 1 }
+
+            it { expect(json).to eq([1]) }
+            it { expect(schema).to eq s_fixed_array(s_anything, nullable: true) }
+        end
     end
 end

data/spec/operators/call_spec.rb

@@ -1,62 +1,64 @@
 require 'spec_helper'
 
-describe ::Babl::Operators::Call do
-    include SpecHelper::Operators
+describe Babl::Operators::Call do
+    extend SpecHelper::OperatorTesting
 
     describe '#call' do
-        let(:object) { nil }
-
         context 'primitive' do
-            let(:template) { dsl.call(false) }
+            template { call(false) }
 
             it { expect(json).to eq false }
             it { expect(dependencies).to eq({}) }
-            it { expect(documentation).to eq false }
+            it { expect(schema).to eq s_static(false) }
 
             context 'call primitive after a conditional' do
-                let(:template) { dsl.nullable.call(34) }
+                template { nullable.call(34) }
+
                 it { expect(json).to eq nil }
             end
         end
 
         context 'block' do
+            template { call { self * 2 } }
+
             let(:object) { 2 }
-            let(:template) { dsl.call { self * 2 } }
 
             it { expect(json).to eq 4 }
         end
 
         context 'hash' do
-            let(:object) { nil }
-            let(:template) { dsl.call('a' => 1, b: 2) }
+            template { call('a' => 1, b: 2) }
 
             it { expect(json).to eq('a' => 1, 'b' => 2) }
             it { expect(dependencies).to eq({}) }
         end
 
         context 'array' do
+            template { call(['a', 2, :b]) }
+
             let(:object) { { b: 42 } }
-            let(:template) { dsl.call(['a', 2, :b]) }
 
             it { expect(json).to eq(['a', 2, 42]) }
             it { expect(dependencies).to eq(b: {}) }
         end
 
         context 'block' do
+            template { call(:lol) }
+
             let(:object) { OpenStruct.new(lol: 'tam') }
-            let(:template) { dsl.call(:lol) }
 
             it { expect(json).to eq 'tam' }
             it { expect(dependencies).to eq(lol: {}) }
         end
 
         context 'template' do
+            template { object(coucou: nav(:a).call(nav(:b))) }
+
             let(:object) { OpenStruct.new(a: OpenStruct.new(b: 1)) }
-            let(:template) { dsl.source { object(coucou: nav(:a).call(nav(:b))) } }
 
             it { expect(dependencies).to eq(a: { b: {} }) }
             it { expect(json).to eq('coucou' => 1) }
-            it { expect(documentation).to eq(coucou: :__value__) }
+            it { expect(schema).to eq(s_object(s_property(:coucou, s_anything))) }
         end
     end
 end

data/spec/operators/continue_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Babl::Operators::Continue do
+    extend SpecHelper::OperatorTesting
+
+    describe '#switch' do
+        context 'navigation before continue' do
+            template { nav(:abc).switch(false => 1, default => nav(:lol).continue).object(val: nav(:ok)) }
+
+            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplateError }
+        end
+
+        context 'continue without switch' do
+            template { continue }
+
+            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplateError }
+        end
+
+        context 'continue in sub-object' do
+            template { object(a: switch(default => object(x: continue))) }
+
+            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplateError }
+        end
+    end
+end

data/spec/operators/default_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+require 'spec_helper'
+
+describe Babl::Operators::Default do
+    extend SpecHelper::OperatorTesting
+
+    describe '#default' do
+        template { default }
+
+        it { expect(json).to eq true }
+        it { expect(schema).to eq s_static(true) }
+        it { expect(dependencies).to eq({}) }
+    end
+end

data/spec/operators/dep_spec.rb

@@ -1,18 +1,14 @@
 require 'spec_helper'
 
-describe ::Babl::Operators::Dep do
-    include SpecHelper::Operators
+describe Babl::Operators::Dep do
+    extend SpecHelper::OperatorTesting
 
     describe '#dep' do
-        let(:template) {
-            dsl.source {
-                dep(a: [:b, :c]).nav(:b).dep(x: :y).nav(:z)
-            }
-        }
+        template { dep(a: [:b, :c]).nav(:b).dep(x: :y).nav(:z) }
 
         let(:object) { { b: { z: 42 } } }
 
-        it { expect(documentation).to eq :__value__ }
+        it { expect(schema).to eq s_anything }
         it { expect(dependencies).to eq(a: { b: {}, c: {} }, b: { x: { y: {} }, z: {} }) }
         it { expect(json).to eq(42) }
     end

data/spec/operators/each_spec.rb

@@ -1,23 +1,42 @@
 require 'spec_helper'
 
-describe ::Babl::Operators::Each do
-    include SpecHelper::Operators
+describe Babl::Operators::Each do
+    extend SpecHelper::OperatorTesting
 
     describe '#each' do
         context 'when everything is fine' do
-            let(:template) { dsl.source { each.nav(:a) } }
+            template { each.nav(:a) }
+
             let(:object) { [{ a: 3 }, { a: 2 }, { a: 1 }] }
 
             it { expect(json).to eq [3, 2, 1] }
             it { expect(dependencies).to eq(__each__: { a: {} }) }
-            it { expect(documentation).to eq [:__value__] }
+            it { expect(schema).to eq s_dyn_array(s_anything) }
         end
 
         context 'error while navigating' do
+            template { nav(:box).each.nav(:trololol) }
+
             let(:object) { { box: [{ trololol: 2 }, 42] } }
-            let(:template) { dsl.source { nav(:box).each.nav(:trololol) } }
 
             it { expect { json }.to raise_error(/\__root__\.box\.1\.trololol/) }
         end
+
+        context 'not enumerable' do
+            template { nav(:lol).each }
+
+            let(:object) { { lol: 'not enumerable' } }
+
+            it { expect { json }.to raise_error(Babl::Errors::RenderingError, /\__root__\.lol/) }
+        end
+
+        context 'nullable array' do
+            template { nullable.each.nullable.object }
+
+            let(:object) { [1, nil] }
+
+            it { expect(json).to eq [{}, nil] }
+            it { expect(schema).to eq s_dyn_array(s_object(nullable: true), nullable: true) }
+        end
     end
 end

data/spec/operators/enter_spec.rb

@@ -1,24 +1,26 @@
 require 'spec_helper'
 
-describe ::Babl::Operators::Enter do
-    include SpecHelper::Operators
+describe Babl::Operators::Enter do
+    extend SpecHelper::OperatorTesting
 
     describe '#enter' do
         context 'invalid usage' do
-            let(:template) { dsl.source { enter } }
-            it { expect { compiled }.to raise_error Babl::InvalidTemplateError }
+            template { enter }
+
+            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplateError }
         end
 
         context 'valid usage' do
-            let(:template) { dsl.source { object(a: enter) } }
+            template { object(a: enter) }
+
             let(:object) { { a: 42 } }
 
-            it { expect(documentation).to eq(a: :__value__) }
+            it { expect(schema).to eq(s_object(s_property(:a, s_anything))) }
             it { expect(dependencies).to eq(a: {}) }
             it { expect(json).to eq('a' => 42) }
 
             context 'using alias' do
-                let(:template) { dsl.source { object(a: _) } }
+                template { object(a: _) }
                 it { expect(json).to eq('a' => 42) }
             end
         end

data/spec/operators/extends_spec.rb

@@ -1,16 +1,30 @@
 require 'spec_helper'
 
-describe ::Babl::Operators::Extends do
-    include SpecHelper::Operators
+describe Babl::Operators::Extends do
+    extend SpecHelper::OperatorTesting
 
     let(:custom_lookup_context) {
-        TestLookupContext.new(base_partial: TestLookupContext.new('object(a: 1, b: 3)'))
+        TestLookupContext.new(
+            object_partial: TestLookupContext.new('object(a: 1, b: 3)'),
+            string_partial: TestLookupContext.new('"lol"')
+        )
     }
-    let(:ctx_dsl) { dsl.with_lookup_context(custom_lookup_context) }
+    let(:dsl) { Babl::Template.new.with_lookup_context(custom_lookup_context) }
     let(:object) { [nil] }
 
     context 'simple use case' do
-        let(:template) { ctx_dsl.source { each.extends('base_partial', object(x: 1), b: 34) } }
+        template { each.extends('object_partial', object(x: 1), b: 34) }
         it { expect(json).to eq(['a' => 1, 'x' => 1, 'b' => 34]) }
     end
+
+    context 'extend a non-object' do
+        template { extends('string_partial') }
+        it { expect(json).to eq('lol') }
+        it { expect(schema).to eq s_static('lol') }
+    end
+
+    context 'extend a non-object and try to add properties' do
+        template { each.extends('string_partial', test: 1) }
+        it { expect { schema }.to raise_error Babl::Errors::InvalidTemplateError }
+    end
 end

data/spec/operators/merge_spec.rb

@@ -1,31 +1,124 @@
 require 'spec_helper'
 
-describe ::Babl::Operators::Merge do
-    include SpecHelper::Operators
+describe Babl::Operators::Merge do
+    extend SpecHelper::OperatorTesting
 
     describe '#merge' do
-        context do
-            let(:template) {
-                dsl.source {
-                    merge(
-                        object(a: static('A')),
-                        b: _
-                    )
-                }
+        context 'merge two objects' do
+            template {
+                merge(
+                    object(a: static('A')),
+                    b: _
+                )
             }
 
             let(:object) { { b: 42 } }
 
             it { expect(json).to eq('a' => 'A', 'b' => 42) }
             it { expect(dependencies).to eq(b: {}) }
-            it { expect(documentation).to eq('Merge 1': { a: 'A' }, 'Merge 2': { b: :__value__ }) }
+            it {
+                expect(schema).to eq(
+                    s_object(
+                        s_property(:a, s_static('A')),
+                        s_property(:b, s_anything)
+                    )
+                )
+            }
         end
 
         context 'merge inside object' do
-            let(:template) { dsl.source { object(toto: merge(_, lol: 42)) } }
+            template { object(toto: merge(_, lol: 42)) }
+
             let(:object) { { toto: { cool: 'ouai' } } }
 
             it { expect(json).to eq('toto' => { 'lol' => 42, 'cool' => 'ouai' }) }
+            it {
+                expect(schema).to eq(
+                    s_object(
+                        s_property(:toto,
+                            s_object(
+                                s_property(:lol, s_static(42)),
+                                additional: true
+                            ))
+                    )
+                )
+            }
+        end
+
+        context 'merge nothing' do
+            template { merge }
+
+            it { expect(json).to eq({}) }
+            it { expect(schema).to eq s_object }
+        end
+
+        context 'merge that could fail in some case' do
+            template {
+                merge(
+                    switch(
+                        false => switch(
+                            true => {},
+                            default => 'not an object'
+                        ),
+                        default => {}
+                    ),
+                    object(test: 1)
+                )
+            }
+
+            it { expect { schema }.to raise_error Babl::Errors::InvalidTemplateError }
+        end
+
+        context 'merge only one static value' do
+            template { merge(42) }
+
+            it { expect { schema }.to raise_error Babl::Errors::InvalidTemplateError }
+        end
+
+        context 'merge only one dynamic value' do
+            template { merge(itself) }
+
+            let(:object) { 43 }
+
+            it { expect { json }.to raise_error Babl::Errors::RenderingError }
+            it { expect(schema).to eq s_object(additional: true) }
+        end
+
+        context 'merge object with static' do
+            template { merge(object(a: 1), static(b: 2)) }
+
+            it { expect(json).to eq('a' => 1, 'b' => 2) }
+            it { expect(schema).to eq s_object(s_property(:a, s_static(1)), s_property(:b, s_static(2))) }
+        end
+
+        context 'merge object with conditionally present properties' do
+            template {
+                merge(
+                    switch(
+                        itself => object(a: 1, b: 2),
+                        default => object(b: 3, c: 4)
+                    ),
+                    itself,
+                    switch(
+                        itself => object(c: 7),
+                        default => object(c: 5)
+                    )
+                )
+            }
+
+            let(:object) { { b: 1 } }
+
+            it { expect(json).to eq('a' => 1, 'b' => 1, 'c' => 7) }
+            it {
+                expect(schema).to eq(
+                    s_object(
+                        s_property(:a, s_any_of(s_anything, s_static(1)), required: false),
+                        s_property(:b, s_any_of(s_anything, s_static(2), s_static(3))),
+                        s_property(:c, s_any_of(s_static(7), s_static(5))),
+                        additional: true
+                    )
+                )
+            }
         end
     end
 end