babl-json 0.2.3 → 0.2.4

data/spec/operators/merge_spec.rb

@@ -1,124 +0,0 @@
-require 'spec_helper'
-
-describe Babl::Operators::Merge do
-    extend SpecHelper::OperatorTesting
-
-    describe '#merge' do
-        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(schema).to eq(
-                    s_object(
-                        s_property(:a, s_static('A')),
-                        s_property(:b, s_anything)
-                    )
-                )
-            }
-        end
-
-        context 'merge inside object' do
-            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::InvalidTemplate }
-        end
-
-        context 'merge only one static value' do
-            template { merge(42) }
-
-            it { expect { schema }.to raise_error Babl::Errors::InvalidTemplate }
-        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

data/spec/operators/nav_spec.rb

@@ -1,71 +0,0 @@
-require 'spec_helper'
-
-describe Babl::Operators::Nav do
-    extend SpecHelper::OperatorTesting
-
-    describe '#nav' do
-        template { nav(:a) }
-
-        context 'hash navigation' do
-            let(:object) { { a: '42' } }
-            it { expect(json).to eq('42') }
-            it { expect(dependencies).to eq(a: {}) }
-
-            context 'method navigation propagate dependency chain' do
-                template { nav(:a).nav(:to_i) }
-                it { expect(json).to eq(42) }
-                it { expect(dependencies).to eq(a: { to_i: {} }) }
-            end
-        end
-
-        context 'navigate to non serializable' do
-            template { nav(:a) }
-            let(:object) { { a: :test } }
-            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
-            let(:object) { Struct.new(:a).new(42) }
-            it { expect(json).to eq(42) }
-            it { expect(dependencies).to eq(a: {}) }
-        end
-
-        context 'block navigation' do
-            template { nav { |x| x * 2 } }
-
-            let(:object) { 42 }
-
-            it { expect(json).to eq(84) }
-            it { expect(dependencies).to eq({}) }
-
-            context 'block navigation breaks dependency chain' do
-                template { nav { |x| x * 2 }.nav(:to_i) }
-                it { expect(dependencies).to eq({}) }
-            end
-        end
-
-        context '#nav should stop key propagation for #enter' do
-            template { object(a: nav._) }
-            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplate }
-        end
-
-        context 'nav to array of complex objects' do
-            template { nav(:arr) }
-            let(:object) { { arr: [nil, 1, 'lol', { a: [1] }, [], {}, true, false] } }
-            it { expect(json).to eq([nil, 1, 'lol', { 'a' => [1] }, [], {}, true, false]) }
-            it { expect(schema).to eq s_anything }
-        end
-    end
-end

data/spec/operators/null_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-describe Babl::Operators::Null do
-    extend SpecHelper::OperatorTesting
-
-    describe '#null' do
-        template { { val: null } }
-
-        let(:object) { {} }
-
-        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
-end

data/spec/operators/nullable_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-describe Babl::Operators::Nullable do
-    extend SpecHelper::OperatorTesting
-
-    describe '#nullable' do
-        let(:object) { { nullprop: nil, notnullprop: { abc: 12 } } }
-
-        template {
-            object(
-                nullprop: nav(:nullprop).nullable.nav(:abc),
-                notnullprop: nav(:notnullprop).nullable.object(:abc)
-            )
-        }
-
-        it { expect(json).to eq('nullprop' => nil, 'notnullprop' => { 'abc' => 12 }) }
-
-        it {
-            expect(schema).to eq(
-                s_object(
-                    s_property(:nullprop, s_anything),
-                    s_property(:notnullprop, s_any_of(s_object(s_property(:abc, s_anything)), s_null))
-                )
-            )
-        }
-
-        it { expect(dependencies).to eq(nullprop: { abc: {} }, notnullprop: { abc: {} }) }
-    end
-end

data/spec/operators/object_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-describe Babl::Operators::Object do
-    extend SpecHelper::OperatorTesting
-
-    describe '#object' do
-        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(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
-            template { object(:a).object(:b) }
-
-            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplate }
-        end
-    end
-end

data/spec/operators/parent_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-
-describe Babl::Operators::Parent do
-    extend SpecHelper::OperatorTesting
-
-    describe '#parent' do
-        context 'valid usage' do
-            template { nav(:box).dep(:box_dep).parent.dep(:root_dep) }
-
-            let(:object) { { box: 42 } }
-
-            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 } } } }
-
-            it { expect { json }.to raise_error(/\__root__\.a\.b\.x/) }
-        end
-
-        context 'invalid usage' do
-            template { parent }
-
-            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplate }
-        end
-
-        context 'deeply nested parent chain' do
-            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
-            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
-end

data/spec/operators/partial_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe Babl::Operators::Partial do
-    extend SpecHelper::OperatorTesting
-
-    let(:custom_lookup_context) {
-        TestLookupContext.new(
-            blabla: TestLookupContext.new(
-                "[partial('navi').partial('miche'), partial('muche')]",
-
-                miche: TestLookupContext.new(
-                    "partial('blabla')",
-
-                    blabla: TestLookupContext.new('call { 1 + self }')
-                ),
-
-                muche: TestLookupContext.new('23'),
-                navi: TestLookupContext.new(':some_property')
-            )
-        )
-    }
-    let(:dsl) { Babl::Template.new.with_lookup_context(custom_lookup_context) }
-    let(:object) { { some_property: 12 } }
-
-    context 'missing partial' do
-        template { partial('i_do_not_exist') }
-
-        it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplate }
-    end
-
-    context 'found partial' do
-        template { partial('blabla') }
-
-        it { expect(json).to eq [13, 23] }
-    end
-end

data/spec/operators/pin_spec.rb

@@ -1,172 +0,0 @@
-require 'spec_helper'
-
-describe Babl::Operators::Pin do
-    extend SpecHelper::OperatorTesting
-
-    describe '#pin' do
-        context 'simple pinning' do
-            template {
-                nav(:a).pin { |a|
-                    nav(:b).object(
-                        x: _,
-                        y: a.nav(:y)
-                    )
-                }
-            }
-
-            let(:object) {
-                { a: { b: { x: 42 }, y: 13 } }
-            }
-
-            it { expect(json).to eq('x' => 42, 'y' => 13) }
-            it { expect(dependencies).to eq(a: { y: {}, b: { x: {} } }) }
-            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
-            template {
-                nav(:a).pin { |p1|
-                    object(x: _, y: p1.parent.pin { |p2| p2.nav(:a, :b) })
-                }
-            }
-
-            let(:object) { { a: { x: 12, b: 42 } } }
-
-            it { expect(json).to eq('x' => 12, 'y' => 42) }
-            it { expect(dependencies).to eq(a: { x: {}, b: {} }) }
-            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
-            template {
-                pinref = nil
-                object(
-                    a: pin { |p| pinref = p },
-                    b: pinref.nav(:lol)
-                )
-            }
-
-            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplate }
-        end
-
-        context 'when pinning is mixed with a "with" context' do
-            template {
-                pin { |root|
-                    with(:a) { |a| a }.object(
-                        x: _,
-                        y: root.nav(:lol)
-                    )
-                }
-            }
-
-            let(:object) { { a: { x: 34 }, lol: 1 } }
-
-            it { expect(json).to eq('x' => 34, 'y' => 1) }
-            it { expect(dependencies).to eq(a: {}, lol: {}) }
-            it {
-                expect(schema).to eq(
-                    s_object(
-                        s_property(:x, s_anything),
-                        s_property(:y, s_anything)
-                    )
-                )
-            }
-        end
-
-        context 'navigating pinning' do
-            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(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
-            template {
-                nav(:a).pin { |a|
-                    object(
-                        h: nav(:h),
-                        a: a.object(
-                            x: _,
-                            y: a.nav(:lol).parent.nav(:mdr)
-                        )
-                    )
-                }
-            }
-
-            let(:object) { { a: { h: 42, x: 13, lol: 11, mdr: 34 } } }
-
-            it { expect(json).to eq('h' => 42, 'a' => { 'x' => 13, 'y' => 34 }) }
-            it { expect(dependencies).to eq(a: { h: {}, x: {}, lol: {}, mdr: {} }) }
-
-            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
-            template {
-                pin { |root|
-                    nav(:a).pin { |a|
-                        object(
-                            a: a.nav(:x),
-                            root: root.nav(:y)
-                        )
-                    }
-                }
-            }
-
-            let(:object) { { a: { x: 42 }, y: 13 } }
-
-            it { expect(json).to eq('a' => 42, 'root' => 13) }
-
-            it {
-                expect(schema).to eq(
-                    s_object(
-                        s_property(:a, s_anything),
-                        s_property(:root, s_anything)
-                    )
-                )
-            }
-        end
-    end
-end