babl-json 0.1.4 → 0.2.0

data/spec/operators/source_spec.rb

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

data/spec/operators/static_spec.rb

@@ -1,19 +1,27 @@
 require 'spec_helper'
 
-describe ::Babl::Operators::Static do
-    include SpecHelper::Operators
+describe Babl::Operators::Static do
+    extend SpecHelper::OperatorTesting
 
     describe '#static' do
-        let(:template) { dsl.source { static('1': 'cava') } }
-        let(:object) { nil }
+        context 'static object' do
+            template { static('1': 'cava') }
 
-        it { expect(json).to eq('1' => 'cava') }
-        it { expect(dependencies).to eq({}) }
-        it { expect(documentation).to eq('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
-            let(:template) { dsl.source { static(test: Object.new) } }
-            it { expect { compiled }.to raise_error Babl::InvalidTemplateError }
+            template { static(test: Object.new) }
+
+            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplateError }
         end
     end
 end

data/spec/operators/switch_spec.rb

@@ -1,81 +1,121 @@
 require 'spec_helper'
 
-describe ::Babl::Operators::Switch do
-    include SpecHelper::Operators
+describe Babl::Operators::Switch do
+    extend SpecHelper::OperatorTesting
 
     describe '#switch' do
-        context do
-            let(:template) {
-                dsl.source {
-                    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')
-                }
+        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(documentation).to eq [
-                    'Case 1': :__value__,
-                    'Case 2': :__value__,
-                    'Case 3': 'WTF'
-                ]
-            }
+            it { expect(schema).to eq s_dyn_array(s_any_of(s_static('WTF'), s_anything)) }
         end
 
         context 'static condition' do
-            let(:template) { dsl.source { switch(true => 42) } }
+            template { switch(true => 42) }
+
             let(:object) { {} }
+
             it { expect(json).to eq 42 }
         end
 
-        context 'navigation before continue' do
-            let(:template) { dsl.source { nav(:abc).switch(false => 1, default => nav(:lol).continue).object(val: nav(:ok)) } }
+        context 'only one output possible' do
+            template { switch(false => 2, true => 2) }
 
-            it { expect { compiled }.to raise_error Babl::InvalidTemplateError }
+            it { expect(schema).to eq s_static(2) }
         end
 
-        context 'continue in sub-object' do
-            let(:template) { dsl.source { object(a: switch(default => object(x: continue))) } }
+        context 'no branch taken' do
+            template { switch(false => 1) }
 
-            it { expect { compiled }.to raise_error Babl::InvalidTemplateError }
-        end
-
-        context 'unhandled default' do
             let(:object) { { abc: { lol: { ok: 42 } } } }
-            let(:template) { dsl.source { switch(false => 1) } }
 
             it { expect(dependencies).to eq({}) }
-            it { expect { json }.to raise_error Babl::RenderingError }
-        end
-
-        context 'continue without switch' do
-            let(:template) { dsl.source { continue } }
-
-            it { expect { compiled }.to raise_error Babl::InvalidTemplateError }
+            it { expect { json }.to raise_error Babl::Errors::RenderingError }
         end
 
         context 'non serializable objects are allowed internally' do
-            let(:template) { dsl.source { switch(test: 42) } }
+            template { switch(test: 42) }
+
             let(:object) { { test: Object.new } }
 
             it { expect(json).to eq 42 }
         end
 
-        context do
-            let(:template) {
-                dsl.source {
-                    nav(:test).switch(nav(:keke) => parent.nav(:lol))
-                }
+        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_dyn_array(s_static(1), nullable: true) }
+        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')) }
+
+            it { expect(schema).to eq s_dyn_array(s_any_of(s_static('a'), s_static('b'))) }
+        end
+
+        context 'with dependencies' do
+            template { nav(:test).switch(nav(:keke) => parent.nav(:lol)) }
+
             it { expect(dependencies).to eq(test: { keke: {} }, lol: {}) }
         end
     end

data/spec/operators/with_spec.rb

@@ -1,32 +1,30 @@
 require 'spec_helper'
 
-describe ::Babl::Operators::With do
-    include SpecHelper::Operators
+describe Babl::Operators::With do
+    extend SpecHelper::OperatorTesting
 
     describe '#with' do
         context 'everything is fine' do
-            let(:template) {
-                dsl.source {
-                    object(
-                        result: with(
-                            unscoped,
-                            :msg,
-                            _.parent.nav(:msg).dep(:lol)
-                        ) { |obj, a, b| "#{a} #{b} #{obj[:msg]}" }
-                    )
-                }
+            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(documentation).to eq(result: :__value__) }
+            it { expect(schema).to eq s_object(s_property(:result, s_anything)) }
         end
 
         context 'when the block raise an exception' do
-            let(:object) { nil }
-            let(:template) { dsl.source { with { raise 'lol' } } }
+            template { with { raise 'lol' } }
+
             it { expect { json }.to raise_error(/\__root__\.__block__/) }
         end
     end

data/spec/spec_helper.rb

@@ -1,31 +1,2 @@
-require 'babl'
-require 'oj'
-
-module SpecHelper
-    module Operators
-        def self.included(base)
-            base.let(:dsl) { ::Babl::Template.new }
-            base.let(:compiled) { template.compile }
-            base.let(:json) { ::Oj.load(compiled.json(object)) }
-            base.let(:dependencies) { compiled.dependencies }
-            base.let(:documentation) { compiled.documentation }
-
-            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
+require 'spec_helper/operator_testing'
+require 'spec_helper/schema_utils'

data/spec/spec_helper/operator_testing.rb

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,33 @@
+require 'babl'
+
+module SpecHelper
+    module SchemaUtils
+        def s_any_of(*args)
+            Babl::Schema::AnyOf.new(args)
+        end
+
+        def s_anything
+            Babl::Schema::Anything.instance
+        end
+
+        def s_dyn_array(schema, nullable: false)
+            Babl::Schema::DynArray.new(schema, nullable)
+        end
+
+        def s_fixed_array(*schemas, nullable: false)
+            Babl::Schema::FixedArray.new(schemas, nullable)
+        end
+
+        def s_object(*properties, additional: false, nullable: false)
+            Babl::Schema::Object.new(properties, additional, nullable)
+        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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: babl-json
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Frederic Terrazzoni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-06 00:00:00.000000000 Z
+date: 2017-07-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.48'
+- !ruby/object:Gem::Dependency
+  name: json-schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
 - !ruby/object:Gem::Dependency
   name: oj
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: values
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
 description: JSON templating on steroids
 email:
 - frederic.terrazzoni@gmail.com
@@ -85,8 +113,25 @@ files:
 - lib/babl.rb
 - lib/babl/builder/chain_builder.rb
 - lib/babl/builder/template_base.rb
+- lib/babl/errors.rb
+- lib/babl/nodes/create_pin.rb
+- lib/babl/nodes/dep.rb
+- lib/babl/nodes/each.rb
+- lib/babl/nodes/fixed_array.rb
+- lib/babl/nodes/goto_pin.rb
+- lib/babl/nodes/internal_value.rb
+- lib/babl/nodes/merge.rb
+- lib/babl/nodes/nav.rb
+- lib/babl/nodes/object.rb
+- lib/babl/nodes/parent.rb
+- lib/babl/nodes/static.rb
+- lib/babl/nodes/switch.rb
+- lib/babl/nodes/terminal_value.rb
+- lib/babl/nodes/with.rb
 - lib/babl/operators/array.rb
 - lib/babl/operators/call.rb
+- lib/babl/operators/continue.rb
+- lib/babl/operators/default.rb
 - lib/babl/operators/dep.rb
 - lib/babl/operators/each.rb
 - lib/babl/operators/enter.rb
@@ -106,14 +151,22 @@ files:
 - lib/babl/railtie.rb
 - lib/babl/rendering/compiled_template.rb
 - lib/babl/rendering/context.rb
-- lib/babl/rendering/internal_value_node.rb
 - lib/babl/rendering/noop_preloader.rb
-- lib/babl/rendering/terminal_value_node.rb
+- lib/babl/schema/any_of.rb
+- lib/babl/schema/anything.rb
+- lib/babl/schema/dyn_array.rb
+- lib/babl/schema/fixed_array.rb
+- lib/babl/schema/object.rb
+- lib/babl/schema/static.rb
+- lib/babl/schema/typed.rb
 - lib/babl/template.rb
 - lib/babl/utils/hash.rb
+- lib/babl/utils/ref.rb
 - lib/babl/version.rb
 - spec/operators/array_spec.rb
 - spec/operators/call_spec.rb
+- spec/operators/continue_spec.rb
+- spec/operators/default_spec.rb
 - spec/operators/dep_spec.rb
 - spec/operators/each_spec.rb
 - spec/operators/enter_spec.rb
@@ -131,6 +184,8 @@ files:
 - spec/operators/switch_spec.rb
 - spec/operators/with_spec.rb
 - spec/spec_helper.rb
+- spec/spec_helper/operator_testing.rb
+- spec/spec_helper/schema_utils.rb
 homepage: https://github.com/getbannerman/babl
 licenses:
 - MIT
@@ -158,6 +213,8 @@ summary: JSON templating on steroids
 test_files:
 - spec/operators/array_spec.rb
 - spec/operators/call_spec.rb
+- spec/operators/continue_spec.rb
+- spec/operators/default_spec.rb
 - spec/operators/dep_spec.rb
 - spec/operators/each_spec.rb
 - spec/operators/enter_spec.rb
@@ -175,3 +232,5 @@ test_files:
 - spec/operators/switch_spec.rb
 - spec/operators/with_spec.rb
 - spec/spec_helper.rb
+- spec/spec_helper/operator_testing.rb
+- spec/spec_helper/schema_utils.rb