babl-json 0.1.4 → 0.2.0

data/spec/operators/nav_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-describe ::Babl::Operators::Nav do
-    include SpecHelper::Operators
+describe Babl::Operators::Nav do
+    extend SpecHelper::OperatorTesting
 
     describe '#nav' do
-        let(:template) { dsl.source { nav(:a) } }
+        template { nav(:a) }
 
         context 'hash navigation' do
             let(:object) { { a: 42 } }
@@ -12,15 +12,27 @@ describe ::Babl::Operators::Nav do
             it { expect(dependencies).to eq(a: {}) }
 
             context 'block navigation propagate dependency chain' do
-                let(:template) { dsl.source { nav(:a).nav(:to_i) } }
+                template { nav(:a).nav(:to_i) }
                 it { expect(dependencies).to eq(a: { to_i: {} }) }
             end
         end
 
         context 'navigate to non serializable' do
-            let(:template) { dsl.source { nav(:a) } }
+            template { nav(:a) }
             let(:object) { { a: :test } }
-            it { expect { json }.to raise_error Babl::RenderingError }
+            it { expect { json }.to raise_error Babl::Errors::RenderingError }
+        end
+
+        context 'navigate to non serializable in nested object' do
+            template { nav(:a) }
+            let(:object) { { a: { b: [1, 2, { c: 1, d: Object.new }] } } }
+            it { expect { json }.to raise_error Babl::Errors::RenderingError, /\__root__\.a\.b\.2\.d/ }
+        end
+
+        context 'navigate to non serializable in nested object with invalid key' do
+            template { nav(:a) }
+            let(:object) { { a: { b: [1, 2, { c: 1, Object.new => 1 }] } } }
+            it { expect { json }.to raise_error Babl::Errors::RenderingError, /\__root__\.a\.b\.2/ }
         end
 
         context 'object navigation' do
@@ -31,20 +43,20 @@ describe ::Babl::Operators::Nav do
 
         context 'block navigation' do
             let(:object) { 42 }
-            let(:template) { dsl.source { nav { |x| x * 2 } } }
+            template { nav { |x| x * 2 } }
 
             it { expect(json).to eq(84) }
             it { expect(dependencies).to eq({}) }
 
             context 'block navigation breaks dependency chain' do
-                let(:template) { dsl.source { nav { |x| x * 2 }.nav(:to_i) } }
+                template { nav { |x| x * 2 }.nav(:to_i) }
                 it { expect(dependencies).to eq({}) }
             end
         end
 
         context '#nav should stop key propagation for #enter' do
-            let(:template) { dsl.source { object(a: nav._) } }
-            it { expect { compiled }.to raise_error Babl::InvalidTemplateError }
+            template { object(a: nav._) }
+            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplateError }
         end
     end
 end

data/spec/operators/null_spec.rb

@@ -1,13 +1,14 @@
 require 'spec_helper'
 
-describe ::Babl::Operators::Null do
-    include SpecHelper::Operators
+describe Babl::Operators::Null do
+    extend SpecHelper::OperatorTesting
 
     describe '#null' do
-        let(:template) { dsl.source { { val: null } } }
+        template { { val: null } }
+
         let(:object) { {} }
 
-        it { expect(documentation).to eq(val: nil) }
+        it { expect(schema).to eq s_object(s_property(:val, s_static(nil))) }
         it { expect(dependencies).to eq({}) }
         it { expect(json).to eq('val' => nil) }
     end

data/spec/operators/nullable_spec.rb

@@ -1,26 +1,26 @@
 require 'spec_helper'
 
-describe ::Babl::Operators::Nullable do
-    include SpecHelper::Operators
+describe Babl::Operators::Nullable do
+    extend SpecHelper::OperatorTesting
 
     describe '#nullable' do
         let(:object) { { nullprop: nil, notnullprop: { abc: 12 } } }
 
-        let(:template) {
-            dsl.source {
-                object(
-                    nullprop: nav(:nullprop).nullable.nav(:abc),
-                    notnullprop: nav(:notnullprop).nullable.nav(:abc)
-                )
-            }
+        template {
+            object(
+                nullprop: nav(:nullprop).nullable.nav(:abc),
+                notnullprop: nav(:notnullprop).nullable.object(:abc)
+            )
         }
 
-        it { expect(json).to eq('nullprop' => nil, 'notnullprop' => 12) }
+        it { expect(json).to eq('nullprop' => nil, 'notnullprop' => { 'abc' => 12 }) }
 
         it {
-            expect(documentation).to eq(
-                notnullprop: { "Case 1": nil, "Case 2": :__value__ },
-                nullprop: { "Case 1": nil, "Case 2": :__value__ }
+            expect(schema).to eq(
+                s_object(
+                    s_property(:nullprop, s_anything),
+                    s_property(:notnullprop, s_object(s_property(:abc, s_anything), nullable: true))
+                )
             )
         }
 

data/spec/operators/object_spec.rb

@@ -1,19 +1,30 @@
 require 'spec_helper'
 
-describe ::Babl::Operators::Object do
-    include SpecHelper::Operators
+describe Babl::Operators::Object do
+    extend SpecHelper::OperatorTesting
 
     describe '#object' do
-        let(:template) { dsl.source { object(:a, :b, c: _, d: nav(:d)) } }
+        template { object(:a, :b, c: _, d: nav(:d)) }
+
         let(:object) { { a: 1, b: 2, c: 3, d: 4 } }
 
         it { expect(json).to eq('a' => 1, 'b' => 2, 'c' => 3, 'd' => 4) }
-        it { expect(documentation).to eq(a: :__value__, b: :__value__, c: :__value__, d: :__value__) }
+        it {
+            expect(schema).to eq(
+                s_object(
+                    s_property(:a, s_anything),
+                    s_property(:b, s_anything),
+                    s_property(:c, s_anything),
+                    s_property(:d, s_anything)
+                )
+            )
+        }
         it { expect(dependencies).to eq(a: {}, b: {}, c: {}, d: {}) }
 
         context 'misused (chaining after object)' do
-            let(:template) { dsl.source { object(:a).object(:b) } }
-            it { expect { compiled }.to raise_error Babl::InvalidTemplateError }
+            template { object(:a).object(:b) }
+
+            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplateError }
         end
     end
 end

data/spec/operators/parent_spec.rb

@@ -1,53 +1,49 @@
 require 'spec_helper'
 
-describe ::Babl::Operators::Parent do
-    include SpecHelper::Operators
+describe Babl::Operators::Parent do
+    extend SpecHelper::OperatorTesting
 
     describe '#parent' do
         context 'valid usage' do
-            let(:template) {
-                dsl.source {
-                    nav(:box).dep(:box_dep).parent.dep(:root_dep)
-                }
-            }
+            template { nav(:box).dep(:box_dep).parent.dep(:root_dep) }
 
             let(:object) { { box: 42 } }
 
-            it { expect(documentation).to eq :__value__ }
+            it { expect(schema).to eq s_anything }
             it { expect(dependencies).to eq(box: { box_dep: {} }, root_dep: {}) }
             it { expect(json).to eq('box' => 42) }
         end
 
         context 'error while navigating' do
+            template { nav(:a).parent.nav(:a).nav(:b, :x) }
+
             let(:object) { { a: { b: { c: 56 } } } }
-            let(:template) { dsl.source { nav(:a).parent.nav(:a).nav(:b, :x) } }
 
             it { expect { json }.to raise_error(/\__root__\.a\.b\.x/) }
         end
 
         context 'invalid usage' do
-            let(:template) { dsl.source { parent } }
-            it { expect { compiled }.to raise_error Babl::InvalidTemplateError }
+            template { parent }
+
+            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplateError }
         end
 
         context 'deeply nested parent chain' do
-            let(:template) {
-                dsl.source {
-                    nav(:a, :b, :c, :d, :e).parent.parent.parent.nav(:f, :g, :h).parent.parent.parent.parent.nav(:i)
-                }
+            template {
+                nav(:a, :b, :c, :d, :e).parent.parent.parent.nav(:f, :g, :h).parent.parent.parent.parent.nav(:i)
             }
+
             it { expect(dependencies).to eq(a: { b: { f: { g: { h: {} } }, c: { d: { e: {} } } }, i: {} }) }
         end
 
         context 'same-level key + nested parent chain' do
-            let(:template) {
-                dsl.source {
-                    object(
-                        a: _.nav(:b, :c).parent.parent.nav(:h),
-                        b: _.nav(:a).parent.nav(:a)
-                    )
-                }
+            template {
+                object(
+                    a: _.nav(:b, :c).parent.parent.nav(:h),
+                    b: _.nav(:a).parent.nav(:a)
+                )
             }
+
             it { expect(dependencies).to eq(a: { b: { c: {} }, h: {} }, b: { a: {} }) }
         end
     end

data/spec/operators/partial_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe ::Babl::Operators::Partial do
-    include SpecHelper::Operators
+describe Babl::Operators::Partial do
+    extend SpecHelper::OperatorTesting
 
     let(:custom_lookup_context) {
         TestLookupContext.new(
@@ -19,16 +19,18 @@ describe ::Babl::Operators::Partial do
             )
         )
     }
-    let(:ctx_dsl) { dsl.with_lookup_context(custom_lookup_context) }
+    let(:dsl) { Babl::Template.new.with_lookup_context(custom_lookup_context) }
     let(:object) { { some_property: 12 } }
 
     context 'missing partial' do
-        let(:template) { ctx_dsl.partial('i_do_not_exist') }
-        it { expect { compiled }.to raise_error Babl::InvalidTemplateError }
+        template { partial('i_do_not_exist') }
+
+        it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplateError }
     end
 
     context 'found partial' do
-        let(:template) { ctx_dsl.partial('blabla') }
+        template { partial('blabla') }
+
         it { expect(json).to eq [13, 23] }
     end
 end

data/spec/operators/pin_spec.rb

@@ -1,18 +1,16 @@
 require 'spec_helper'
 
-describe ::Babl::Operators::Pin do
-    include SpecHelper::Operators
+describe Babl::Operators::Pin do
+    extend SpecHelper::OperatorTesting
 
     describe '#pin' do
         context 'simple pinning' do
-            let(:template) {
-                dsl.source {
-                    nav(:a).pin { |a|
-                        nav(:b).object(
-                            x: _,
-                            y: a.nav(:y)
-                        )
-                    }
+            template {
+                nav(:a).pin { |a|
+                    nav(:b).object(
+                        x: _,
+                        y: a.nav(:y)
+                    )
                 }
             }
 
@@ -22,15 +20,20 @@ describe ::Babl::Operators::Pin do
 
             it { expect(json).to eq('x' => 42, 'y' => 13) }
             it { expect(dependencies).to eq(a: { y: {}, b: { x: {} } }) }
-            it { expect(documentation).to eq(x: :__value__, y: :__value__) }
+            it {
+                expect(schema).to eq(
+                    s_object(
+                        s_property(:x, s_anything),
+                        s_property(:y, s_anything)
+                    )
+                )
+            }
         end
 
         context 'when visiting parent from pin' do
-            let(:template) {
-                dsl.source {
-                    nav(:a).pin { |p1|
-                        object(x: _, y: p1.parent.pin { |p2| p2.nav(:a, :b) })
-                    }
+            template {
+                nav(:a).pin { |p1|
+                    object(x: _, y: p1.parent.pin { |p2| p2.nav(:a, :b) })
                 }
             }
 
@@ -38,32 +41,35 @@ describe ::Babl::Operators::Pin do
 
             it { expect(json).to eq('x' => 12, 'y' => 42) }
             it { expect(dependencies).to eq(a: { x: {}, b: {} }) }
-            it { expect(documentation).to eq(x: :__value__, y: :__value__) }
+            it {
+                expect(schema).to eq(
+                    s_object(
+                        s_property(:x, s_anything),
+                        s_property(:y, s_anything)
+                    )
+                )
+            }
         end
 
         context 'when pinning is misused (out of context)' do
-            let(:template) {
-                dsl.source {
-                    pinref = nil
-                    object(
-                        a: pin { |p| pinref = p },
-                        b: pinref.nav(:lol)
-                    )
-                }
+            template {
+                pinref = nil
+                object(
+                    a: pin { |p| pinref = p },
+                    b: pinref.nav(:lol)
+                )
             }
 
-            it { expect { compiled }.to raise_error Babl::InvalidTemplateError }
+            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplateError }
         end
 
         context 'when pinning is mixed with a "with" context' do
-            let(:template) {
-                dsl.source {
-                    pin { |root|
-                        with(:a) { |a| a }.object(
-                            x: _,
-                            y: root.nav(:lol)
-                        )
-                    }
+            template {
+                pin { |root|
+                    with(:a) { |a| a }.object(
+                        x: _,
+                        y: root.nav(:lol)
+                    )
                 }
             }
 
@@ -71,35 +77,48 @@ describe ::Babl::Operators::Pin do
 
             it { expect(json).to eq('x' => 34, 'y' => 1) }
             it { expect(dependencies).to eq(a: {}, lol: {}) }
-            it { expect(documentation).to eq(x: :__value__, y: :__value__) }
+            it {
+                expect(schema).to eq(
+                    s_object(
+                        s_property(:x, s_anything),
+                        s_property(:y, s_anything)
+                    )
+                )
+            }
         end
 
         context 'navigating pinning' do
-            let(:template) {
-                dsl.source {
-                    pin(:timezone) { |timezone| object(applicant: _.object(:id, tz: timezone)) }
-                }
+            template {
+                pin(:timezone) { |timezone| object(applicant: _.object(:id, tz: timezone)) }
             }
 
             let(:object) { { applicant: { id: 1 }, timezone: 'LA' } }
 
             it { expect(json).to eq('applicant' => { 'id' => 1, 'tz' => 'LA' }) }
             it { expect(dependencies).to eq(timezone: {}, applicant: { id: {} }) }
-            it { expect(documentation).to eq(applicant: { id: :__value__, tz: :__value__ }) }
+            it {
+                expect(schema).to eq(
+                    s_object(
+                        s_property(:applicant,
+                            s_object(
+                                s_property(:id, s_anything),
+                                s_property(:tz, s_anything)
+                            ))
+                    )
+                )
+            }
         end
 
         context 'pin used twice in same chain' do
-            let(:template) {
-                dsl.source {
-                    nav(:a).pin { |a|
-                        object(
-                            h: nav(:h),
-                            a: a.object(
-                                x: _,
-                                y: a.nav(:lol).parent.nav(:mdr)
-                            )
+            template {
+                nav(:a).pin { |a|
+                    object(
+                        h: nav(:h),
+                        a: a.object(
+                            x: _,
+                            y: a.nav(:lol).parent.nav(:mdr)
                         )
-                    }
+                    )
                 }
             }
 
@@ -107,19 +126,31 @@ describe ::Babl::Operators::Pin do
 
             it { expect(json).to eq('h' => 42, 'a' => { 'x' => 13, 'y' => 34 }) }
             it { expect(dependencies).to eq(a: { h: {}, x: {}, lol: {}, mdr: {} }) }
-            it { expect(documentation).to eq(h: :__value__, a: { x: :__value__, y: :__value__ }) }
+
+            it {
+                expect(schema).to eq(
+                    s_object(
+                        s_property(
+                            :a,
+                            s_object(
+                                s_property(:x, s_anything),
+                                s_property(:y, s_anything)
+                            )
+                        ),
+                        s_property(:h, s_anything)
+                    )
+                )
+            }
         end
 
         context 'nested pinning' do
-            let(:template) {
-                dsl.source {
-                    pin { |root|
-                        nav(:a).pin { |a|
-                            object(
-                                a: a.nav(:x),
-                                root: root.nav(:y)
-                            )
-                        }
+            template {
+                pin { |root|
+                    nav(:a).pin { |a|
+                        object(
+                            a: a.nav(:x),
+                            root: root.nav(:y)
+                        )
                     }
                 }
             }
@@ -127,7 +158,15 @@ describe ::Babl::Operators::Pin do
             let(:object) { { a: { x: 42 }, y: 13 } }
 
             it { expect(json).to eq('a' => 42, 'root' => 13) }
-            it { expect(documentation).to eq(a: :__value__, root: :__value__) }
+
+            it {
+                expect(schema).to eq(
+                    s_object(
+                        s_property(:a, s_anything),
+                        s_property(:root, s_anything)
+                    )
+                )
+            }
         end
     end
 end