babl-json 0.2.3 → 0.2.4

data/spec/operators/source_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-describe Babl::Operators::Source do
-    extend SpecHelper::OperatorTesting
-
-    describe '#source' do
-        let(:object) { { abc: { def: 12 } } }
-
-        context 'block returning primitive' do
-            template { source { true } }
-
-            it { expect(json).to eq(true) }
-        end
-
-        context 'block using operators' do
-            template { source { static(3) } }
-
-            it { expect(json).to eq(3) }
-        end
-
-        context 'two level sourcing' do
-            template { source { nav(:abc).source { nav(:def) } } }
-
-            it { expect(json).to eq(12) }
-        end
-
-        context 'string template' do
-            template { source('object(a: static(true))') }
-
-            it { expect(json).to eq('a' => true) }
-        end
-    end
-end

data/spec/operators/static_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe Babl::Operators::Static do
-    extend SpecHelper::OperatorTesting
-
-    describe '#static' do
-        context 'static object' do
-            template { static('1': 'cava') }
-
-            it { expect(json).to eq('1' => 'cava') }
-            it { expect(dependencies).to eq({}) }
-            it { expect(schema).to eq s_object(s_property(:'1', s_static('cava'))) }
-        end
-
-        context 'static primitive' do
-            template { static('ok') }
-
-            it { expect(schema).to eq s_static('ok') }
-        end
-
-        context 'invalid' do
-            template { static(test: Object.new) }
-
-            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplate }
-        end
-    end
-end

data/spec/operators/switch_spec.rb

@@ -1,151 +0,0 @@
-require 'spec_helper'
-
-describe Babl::Operators::Switch do
-    extend SpecHelper::OperatorTesting
-
-    describe '#switch' do
-        context 'realistic use case' do
-            template {
-                even = nullable.nav(:even?)
-                odd = nullable.nav(:odd?)
-
-                each.switch(
-                    even => nav { |x| "#{x} is even" },
-                    odd => nav { |x| "#{x} is odd" },
-                    default => continue
-                ).static('WTF')
-            }
-
-            let(:object) { [1, 2, nil, 5] }
-
-            it { expect(json).to eq ['1 is odd', '2 is even', 'WTF', '5 is odd'] }
-            it { expect(dependencies).to eq(__each__: { even?: {}, odd?: {} }) }
-            it { expect(schema).to eq s_dyn_array(s_any_of(s_static('WTF'), s_anything)) }
-        end
-
-        context 'static condition' do
-            template { switch(true => 42) }
-
-            let(:object) { {} }
-
-            it { expect(json).to eq 42 }
-        end
-
-        context 'only one output possible' do
-            template { switch(false => 2, true => 2) }
-
-            it { expect(schema).to eq s_static(2) }
-        end
-
-        context 'no branch taken' do
-            template { switch(false => 1) }
-
-            let(:object) { { abc: { lol: { ok: 42 } } } }
-
-            it { expect(dependencies).to eq({}) }
-            it { expect { json }.to raise_error Babl::Errors::RenderingError }
-        end
-
-        context 'non serializable objects are allowed internally' do
-            template { switch(test: 42) }
-
-            let(:object) { { test: Object.new } }
-
-            it { expect(json).to eq 42 }
-        end
-
-        context 'switch between empty array and a dyn array' do
-            template { switch(1 => each.object(a: 1), 2 => []) }
-
-            let(:object) { [nil] }
-
-            it { expect(json).to eq(['a' => 1]) }
-            it { expect(schema).to eq s_dyn_array(s_object(s_property(:a, s_static(1)))) }
-        end
-
-        context 'switch between fixed array and a dyn array producing different output' do
-            template { switch(1 => each.static(1), 2 => [2]) }
-
-            it {
-                expect(schema).to eq s_any_of(
-                    s_dyn_array(s_static(1)), s_fixed_array(s_static(2))
-                )
-            }
-        end
-
-        context 'switch between fixed array and a dyn array producing identical output' do
-            template { switch(1 => nullable.each.static(1), 2 => [1]) }
-
-            it { expect(schema).to eq s_any_of(s_null, s_dyn_array(s_static(1))) }
-        end
-
-        context 'switch between similar objects having only one different property' do
-            template { switch(1 => { a: 34, b: 3 }, 2 => { a: 34, b: 1 }, 3 => { b: 2, a: 34 }) }
-
-            it {
-                expect(schema).to eq s_object(
-                    s_property(:a, s_static(34)),
-                    s_property(:b, s_any_of(s_static(1), s_static(2), s_static(3)))
-                )
-            }
-        end
-
-        context 'switch between similar objects having more than one different property' do
-            template { switch(1 => { a: 35, b: 1 }, 2 => { a: 34, b: 2 }) }
-
-            it {
-                expect(schema).to eq s_any_of(
-                    s_object(
-                        s_property(:a, s_static(35)),
-                        s_property(:b, s_static(1))
-                    ),
-                    s_object(
-                        s_property(:a, s_static(34)),
-                        s_property(:b, s_static(2))
-                    )
-                )
-            }
-        end
-
-        context 'switch between two possible dyn arrays' do
-            template { switch(1 => each.static('a'), 2 => each.static('b'), 3 => nullable.each.static('c')) }
-
-            it { expect(schema).to eq s_any_of(s_null, s_dyn_array(s_any_of(s_static('a'), s_static('c'), s_static('b')))) }
-        end
-
-        context 'switch between true and false' do
-            template { switch(1 => true, 2 => false) }
-            it { expect(schema).to eq s_boolean }
-        end
-
-        context 'switch between true and a string' do
-            template { switch(1 => true, 3 => string) }
-            it { expect(schema).to eq s_any_of(s_static(true), s_string) }
-        end
-
-        context 'switch between any string and a specific string' do
-            template { switch(1 => string, 3 => 'lol') }
-            it { expect(schema).to eq s_string }
-        end
-
-        context 'switch between any boolean and a specific boolean' do
-            template { switch(1 => boolean, 3 => true) }
-            it { expect(schema).to eq s_boolean }
-        end
-
-        context 'switch between a specific float, specific integer and any number' do
-            template { switch(1 => 1.2, 2 => 2, 3 => number) }
-            it { expect(schema).to eq s_number }
-        end
-
-        context 'switch between a specific float, specific integer and any integer' do
-            template { switch(1 => 1.2, 2 => 2, 3 => integer) }
-            it { expect(schema).to eq s_any_of(s_integer, s_static(1.2)) }
-        end
-
-        context 'with dependencies' do
-            template { nav(:test).switch(nav(:keke) => parent.nav(:lol)) }
-            it { expect(dependencies).to eq(test: { keke: {} }, lol: {}) }
-        end
-    end
-end

data/spec/operators/typed_spec.rb

@@ -1,84 +0,0 @@
-require 'spec_helper'
-
-describe Babl::Operators::Typed do
-    extend SpecHelper::OperatorTesting
-
-    describe '#integer' do
-        template { [integer] }
-
-        it { expect(schema).to eq s_fixed_array(s_integer) }
-
-        context do
-            let(:object) { 12 }
-            it { expect(json).to eq [12] }
-        end
-
-        context do
-            let(:object) { 12.5 }
-            it { expect { json }.to raise_error Babl::Errors::RenderingError }
-        end
-    end
-
-    describe '#number' do
-        template { [number] }
-
-        it { expect(schema).to eq s_fixed_array(s_number) }
-
-        context do
-            let(:object) { 12 }
-            it { expect(json).to eq [12] }
-        end
-
-        context do
-            let(:object) { 12.5 }
-            it { expect(json).to eq [12.5] }
-        end
-
-        context do
-            let(:object) { '12' }
-            it { expect { json }.to raise_error Babl::Errors::RenderingError }
-        end
-    end
-
-    describe '#string' do
-        template { [string] }
-
-        it { expect(schema).to eq s_fixed_array(s_string) }
-
-        context do
-            let(:object) { [12] }
-            it { expect { json }.to raise_error Babl::Errors::RenderingError }
-        end
-
-        context do
-            let(:object) { '12' }
-            it { expect(json).to eq ['12'] }
-        end
-    end
-
-    describe '#boolean' do
-        template { [boolean] }
-
-        it { expect(schema).to eq s_fixed_array(s_boolean) }
-
-        context do
-            let(:object) { true }
-            it { expect(json).to eq [true] }
-        end
-
-        context do
-            let(:object) { false }
-            it { expect(json).to eq [false] }
-        end
-
-        context do
-            let(:object) { 'true' }
-            it { expect { json }.to raise_error Babl::Errors::RenderingError }
-        end
-    end
-
-    context 'obviously invalid template' do
-        template { integer.string }
-        it { expect { schema }.to raise_error Babl::Errors::InvalidTemplate }
-    end
-end

data/spec/operators/with_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe Babl::Operators::With do
-    extend SpecHelper::OperatorTesting
-
-    describe '#with' do
-        context 'everything is fine' do
-            template {
-                object(
-                    result: with(
-                        unscoped,
-                        :msg,
-                        _.parent.nav(:msg).dep(:lol)
-                    ) { |obj, a, b| "#{a} #{b} #{obj[:msg]}" }
-                )
-            }
-
-            let(:object) { { result: 42, msg: 'Hello C' } }
-
-            it { expect(json).to eq('result' => 'Hello C Hello C Hello C') }
-            it { expect(dependencies).to eq(result: {}, msg: { lol: {} }) }
-            it { expect(schema).to eq s_object(s_property(:result, s_anything)) }
-        end
-
-        context 'when the block raise an exception' do
-            template { with { raise 'lol' } }
-
-            it { expect { json }.to raise_error(/\__root__\.__block__/) }
-        end
-    end
-end

data/spec/spec_helper.rb

@@ -1,2 +0,0 @@
-require 'spec_helper/operator_testing'
-require 'spec_helper/schema_utils'

data/spec/spec_helper/operator_testing.rb

@@ -1,46 +0,0 @@
-require 'babl'
-require 'oj'
-require 'json-schema'
-require 'spec_helper/schema_utils'
-
-module SpecHelper
-    module OperatorTesting
-        def template(*args, &block)
-            let(:template) { dsl.source(*args, &block) }
-        end
-
-        def self.extended(base)
-            base.include SchemaUtils
-
-            base.let(:dsl) { Babl::Template.new }
-            base.let(:compiled) { template.compile }
-            base.let(:unchecked_json) { ::Oj.load(compiled.json(object)) }
-            base.let(:dependencies) { compiled.send(:dependencies) }
-            base.let(:schema) { compiled.send(:node).schema }
-            base.let(:json_schema) { compiled.json_schema }
-            base.let(:object) { nil }
-
-            base.let(:json) {
-                JSON::Validator.validate!(json_schema, unchecked_json, validate_schema: true)
-                unchecked_json
-            }
-
-            base.before {
-                stub_const('TestLookupContext', Class.new {
-                    attr_reader :code, :childs
-
-                    def initialize(code = nil, **childs)
-                        @code = code
-                        @childs = childs
-                    end
-
-                    def find(name)
-                        name = name.to_sym
-                        return unless childs[name]
-                        [name.to_s, childs[name].code, childs[name]]
-                    end
-                })
-            }
-        end
-    end
-end

data/spec/spec_helper/schema_utils.rb

@@ -1,53 +0,0 @@
-require 'babl'
-
-module SpecHelper
-    module SchemaUtils
-        def s_any_of(*args)
-            Babl::Schema::AnyOf.canonicalized(args)
-        end
-
-        def s_anything
-            Babl::Schema::Anything.instance
-        end
-
-        def s_dyn_array(schema)
-            Babl::Schema::DynArray.new(schema)
-        end
-
-        def s_null
-            Babl::Schema::Static::NULL
-        end
-
-        def s_integer
-            Babl::Schema::Typed::INTEGER
-        end
-
-        def s_string
-            Babl::Schema::Typed::STRING
-        end
-
-        def s_boolean
-            Babl::Schema::Typed::BOOLEAN
-        end
-
-        def s_number
-            Babl::Schema::Typed::NUMBER
-        end
-
-        def s_fixed_array(*schemas)
-            Babl::Schema::FixedArray.new(schemas)
-        end
-
-        def s_object(*properties, additional: false)
-            Babl::Schema::Object.new(properties, additional)
-        end
-
-        def s_static(value)
-            Babl::Schema::Static.new(value)
-        end
-
-        def s_property(name, value, required: true)
-            Babl::Schema::Object::Property.new(name, value, required)
-        end
-    end
-end

data/spec/utils/value_spec.rb

@@ -1,54 +0,0 @@
-require 'babl/utils/value'
-
-describe Babl::Utils::Value do
-    let(:clazz) { described_class.new(:val1) }
-    let(:inst1) { clazz.new([1]) }
-    let(:inst2) { clazz.new([1]) }
-
-    it { expect(inst1).to eq inst2 }
-    it { expect(inst1).to eql inst2 }
-    it { expect(inst1.hash).to eq inst2.hash }
-
-    describe 'immutability' do
-        it { expect { inst1.val1 = 2 }.to raise_error ::RuntimeError }
-    end
-
-    describe 'test when not equal' do
-        before { inst2.val1 << 3 }
-
-        it { expect(inst1).not_to eq inst2 }
-        it { expect(inst1.hash).to eq inst2.hash }
-    end
-
-    describe 'use hash for equality test' do
-        let(:inst1dup) { inst1.dup }
-
-        it { expect(inst1dup).to eq inst1 }
-
-        context do
-            before { inst1dup._cached_hash = 42 }
-            it { expect(inst1dup).not_to eq inst1 }
-            it { expect(inst1dup).not_to eq inst2 }
-        end
-    end
-
-    describe 'ensure eql? behavior' do
-        let(:inst1) { clazz.new(1.0) }
-        let(:inst2) { clazz.new(1) }
-
-        it { expect(inst1).not_to eql inst2 }
-        it { expect(inst1).not_to eq inst2 }
-    end
-
-    describe 'no property' do
-        let(:clazz1) { described_class.new }
-        let(:clazz2) { described_class.new }
-
-        let(:clazz1_inst1) { clazz1.new }
-        let(:clazz1_inst2) { clazz1.new }
-        let(:clazz2_inst1) { clazz2.new }
-
-        it { expect(clazz1_inst1).to eq clazz1_inst2 }
-        it { expect(clazz1_inst1).not_to eq clazz2_inst1 }
-    end
-end