babl-json 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3a7476b8f458e689ec9a365ddb484fdfae227131
-  data.tar.gz: 6bd1ae10d995e90dfac925f1700b507590b03975
+  metadata.gz: 4dec3c593ea00b70b6d191739c4c84b1d78492fa
+  data.tar.gz: f9bcac08981d7ed996443692bd7f8752b402bab2
 SHA512:
-  metadata.gz: 1879d4cdbb15a27592e6efa36ef6a76b225d17b98f69d3ce38ccbc2fbdd26f890385b082ecd7a2ca8a3c1c7db354181eb2f4278268190ebb4d2abbaf741bdc04
-  data.tar.gz: 3ba37150e0b32e6e0ce64fdf11a5ffbe3772b937cf2e332e3b1b03cd10ed57233185d8361e44e4f53a14b8d6de95cff0c1560bf9c6cea82d45c347b0752932cc
+  metadata.gz: 15ed5dc2e9baf8cb6b94e178e9a8d743c719d73b229d4e33312525f3e743976702bcba8bc7b90069f17e2ddb8b49d4efaccb9a5518e111686847d8adc6c24f3e
+  data.tar.gz: d18b19d2550f3cac80d054474c3d85b60eb1be7f4ddf2e43172477f5b05b3f4a01f535adfe2f322e60dee0d69265b1162757d7886159dbd52474e1395fc7d6e8

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # BABL Changelog
 
+## 0.2.2 (July 13, 2017)
+
+- Added four typing operators: `integer`, `number`, `string` and `boolean`.
+
 ## 0.2.1 (July 11, 2017)
 
 - Fix: array serialization is broken.

data/README.md

@@ -66,7 +66,7 @@ As of today, the only compatible preloader implementation *has not been released
 
 ### Automatic documentation
 
-The structure of the JSON produced by a BABL template can be documentated using [JSON-Schema](http://json-schema.org/).
+The structure of the JSON produced by a BABL template can be documented using [JSON-Schema](http://json-schema.org/).
 
 ### Rails integration
 

data/lib/babl/builder/chain_builder.rb

@@ -41,7 +41,7 @@ module Babl
             def construct_terminal
                 construct_node do |node, context|
                     unless [Nodes::InternalValue.instance, Nodes::TerminalValue.instance].include?(node)
-                        raise Errors::InvalidTemplateError, 'Chaining is not allowed after a terminal operator'
+                        raise Errors::InvalidTemplate, 'Chaining is not allowed after a terminal operator'
                     end
                     yield context
                 end

data/lib/babl/errors.rb

@@ -1,7 +1,7 @@
 module Babl
     module Errors
-        class BablError < StandardError; end
-        class InvalidTemplateError < BablError; end
-        class RenderingError < BablError; end
+        class Base < StandardError; end
+        class InvalidTemplate < Base; end
+        class RenderingError < Base; end
     end
 end

data/lib/babl/nodes/create_pin.rb

@@ -3,7 +3,7 @@ require 'values'
 
 module Babl
     module Nodes
-        class CreatePin < Value.new(:node, :ref)
+        class CreatePin < ::Value.new(:node, :ref)
             def render(ctx)
                 node.render(ctx.create_pin(ref))
             end

data/lib/babl/nodes/dep.rb

@@ -3,7 +3,7 @@ require 'values'
 
 module Babl
     module Nodes
-        class Dep < Value.new(:node, :path)
+        class Dep < ::Value.new(:node, :path)
             def initialize(node, path)
                 super(node, canonicalize(path))
             end

data/lib/babl/nodes/each.rb

@@ -4,13 +4,13 @@ require 'values'
 
 module Babl
     module Nodes
-        class Each < Value.new(:node)
+        class Each < ::Value.new(:node)
             def dependencies
                 { __each__: node.dependencies }
             end
 
             def schema
-                Schema::DynArray.new(node.schema, false)
+                Schema::DynArray.new(node.schema)
             end
 
             def pinned_dependencies

data/lib/babl/nodes/fixed_array.rb

@@ -4,9 +4,9 @@ require 'values'
 
 module Babl
     module Nodes
-        class FixedArray < Value.new(:nodes)
+        class FixedArray < ::Value.new(:nodes)
             def schema
-                Schema::FixedArray.new(nodes.map(&:schema), false)
+                Schema::FixedArray.new(nodes.map(&:schema))
             end
 
             def dependencies

data/lib/babl/nodes/goto_pin.rb

@@ -3,7 +3,7 @@ require 'values'
 
 module Babl
     module Nodes
-        class GotoPin < Value.new(:node, :ref)
+        class GotoPin < ::Value.new(:node, :ref)
             def dependencies
                 {}
             end

data/lib/babl/nodes/internal_value.rb

@@ -12,7 +12,7 @@ module Babl
             include Singleton
 
             def schema
-                raise Errors::InvalidTemplateError, 'Internal nodes cannot be documented'
+                raise Errors::InvalidTemplate, 'Internal nodes cannot be documented'
             end
 
             def dependencies

data/lib/babl/nodes/merge.rb

@@ -4,11 +4,7 @@ require 'values'
 
 module Babl
     module Nodes
-        class Merge < Value.new(:nodes)
-            def initialize(nodes)
-                super
-            end
-
+        class Merge < ::Value.new(:nodes)
             def dependencies
                 nodes.map(&:dependencies).reduce({}) { |a, b| Babl::Utils::Hash.deep_merge(a, b) }
             end
@@ -45,7 +41,7 @@ module Babl
                 when Schema::Anything === doc1 && Schema::Object === doc2
                     merge_object(Schema::Object::EMPTY_WITH_ADDITIONAL, doc2)
                 else
-                    raise Errors::InvalidTemplateError, 'Only objects can be merged'
+                    raise Errors::InvalidTemplate, 'Only objects can be merged'
                 end
             end
 
@@ -53,11 +49,11 @@ module Babl
             # on left, right or both sides.
             def merge_extended(doc1, doc2)
                 # Ensure doc1 & doc2 are both Schema::AnyOf
-                doc1ext = Schema::AnyOf.new([doc1])
-                doc2ext = Schema::AnyOf.new([doc2])
+                choices1 = Schema::AnyOf === doc1 ? doc1.choices : [doc1]
+                choices2 = Schema::AnyOf === doc2 ? doc2.choices : [doc2]
 
                 # Generate all possible combinations
-                all_docs = doc1ext.choices.product(doc2ext.choices)
+                all_docs = choices1.product(choices2)
                     .map { |choice1, choice2| merge_doc(choice1, choice2) }
 
                 # Analyze each property accross all combination to
@@ -68,13 +64,13 @@ module Babl
                     .map do |name, properties|
                     Schema::Object::Property.new(
                         name,
-                        Schema::AnyOf.new(properties.map(&:value)).simplify,
+                        Schema::AnyOf.canonical(properties.map(&:value)),
                         properties.size == all_docs.size && properties.all?(&:required)
                     )
                 end
 
                 # Generate the final Schema::Object
-                Schema::Object.new(final_properties, all_docs.any?(&:additional), false)
+                Schema::Object.new(final_properties, all_docs.any?(&:additional))
             end
 
             # Merge two Schema::Object
@@ -86,14 +82,14 @@ module Babl
                     doc2.properties
                 ).each_with_object({}) { |property, acc| acc[property.name] = property }.values
 
-                Schema::Object.new properties, additional, false
+                Schema::Object.new(properties, additional)
             end
 
             # Rewrite a property to allow Schema::Anything as value
             def allow_anything(property)
                 Schema::Object::Property.new(
                     property.name,
-                    Schema::AnyOf.new([property.value, Schema::Anything.instance]).simplify,
+                    Schema::AnyOf.canonical([property.value, Schema::Anything.instance]),
                     property.required
                 )
             end

data/lib/babl/nodes/nav.rb

@@ -2,7 +2,7 @@ require 'values'
 
 module Babl
     module Nodes
-        class Nav < Value.new(:through, :node)
+        class Nav < ::Value.new(:through, :node)
             def dependencies
                 { through => node.dependencies }
             end

data/lib/babl/nodes/object.rb

@@ -4,7 +4,7 @@ require 'values'
 
 module Babl
     module Nodes
-        class Object < Value.new(:nodes)
+        class Object < ::Value.new(:nodes)
             def dependencies
                 nodes.values.map(&:dependencies).reduce({}) { |a, b| Babl::Utils::Hash.deep_merge(a, b) }
             end
@@ -15,7 +15,7 @@ module Babl
 
             def schema
                 properties = nodes.map { |k, v| Schema::Object::Property.new(k, v.schema, true) }
-                Schema::Object.new(properties, false, false)
+                Schema::Object.new(properties, false)
             end
 
             def render(ctx)

data/lib/babl/nodes/parent.rb

@@ -4,10 +4,10 @@ require 'values'
 
 module Babl
     module Nodes
-        class Parent < Value.new(:node)
+        class Parent < ::Value.new(:node)
             PARENT_MARKER = Utils::Ref.new
 
-            class Resolver < Value.new(:node)
+            class Resolver < ::Value.new(:node)
                 def dependencies
                     backpropagate_dependencies(node.dependencies)
                 end
@@ -27,7 +27,7 @@ module Babl
                 private
 
                 def backpropagate_dependencies(deps)
-                    raise Errors::InvalidTemplateError, 'Out of context parent dependency' if deps.key? PARENT_MARKER
+                    raise Errors::InvalidTemplate, 'Out of context parent dependency' if deps.key? PARENT_MARKER
                     new_deps = backpropagate_dependencies_one_level(deps)
                     deps == new_deps ? new_deps : backpropagate_dependencies(new_deps)
                 end

data/lib/babl/nodes/static.rb

@@ -4,17 +4,13 @@ require 'values'
 
 module Babl
     module Nodes
-        class Static < Value.new(:serialized_value)
-            def initialize(value)
-                super(value)
-            end
-
+        class Static < ::Value.new(:value)
             def schema
-                Schema::Static.new(serialized_value)
+                Schema::Static.new(value)
             end
 
             def render(_ctx)
-                serialized_value
+                value
             end
 
             def dependencies

data/lib/babl/nodes/switch.rb

@@ -5,7 +5,7 @@ require 'values'
 
 module Babl
     module Nodes
-        class Switch < Value.new(:nodes)
+        class Switch < ::Value.new(:nodes)
             def dependencies
                 (nodes.values + nodes.keys).map(&:dependencies)
                     .reduce({}) { |a, b| Babl::Utils::Hash.deep_merge(a, b) }
@@ -17,7 +17,7 @@ module Babl
             end
 
             def schema
-                Schema::AnyOf.new(nodes.values.map(&:schema)).simplify
+                Schema::AnyOf.canonical(nodes.values.map(&:schema))
             end
 
             def render(ctx)

data/lib/babl/nodes/typed.rb

@@ -0,0 +1,42 @@
+require 'values'
+require 'babl/schema/typed'
+
+module Babl
+    module Nodes
+        class Typed < ::Value.new(:types, :schema, :node)
+            BOOLEAN = method(:new).curry(3).call([TrueClass, FalseClass], Schema::Typed::BOOLEAN)
+            INTEGER = method(:new).curry(3).call([Integer], Schema::Typed::INTEGER)
+            NUMBER = method(:new).curry(3).call([Numeric], Schema::Typed::NUMBER)
+            STRING = method(:new).curry(3).call([String], Schema::Typed::STRING)
+
+            def dependencies
+                node.dependencies
+            end
+
+            def pinned_dependencies
+                node.pinned_dependencies
+            end
+
+            def render(ctx)
+                value = node.render(ctx)
+                unless types.any? { |type| type === value }
+                    raise Errors::RenderingError, "Expected type '#{schema.type}': #{value}\n#{ctx.formatted_stack}"
+                end
+                value
+            end
+
+            private
+
+            def initialize(*)
+                super
+                check_type_compatibility
+            end
+
+            def check_type_compatibility
+                return if schema == node.schema
+                return if node.schema == Schema::Anything.instance
+                raise Errors::InvalidTemplate, "Type cannot be '#{schema.type}' in this context"
+            end
+        end
+    end
+end

data/lib/babl/nodes/with.rb

@@ -3,7 +3,7 @@ require 'values'
 
 module Babl
     module Nodes
-        class With < Value.new(:node, :nodes, :block)
+        class With < ::Value.new(:node, :nodes, :block)
             def schema
                 node.schema
             end

data/lib/babl/operators/call.rb

@@ -7,7 +7,7 @@ module Babl
                 # Interpret whatever is passed to this method as BABL template. It is idempotent.
                 def call(*args, &block)
                     return with(*args, &block) unless block.nil?
-                    raise Errors::InvalidTemplateError, 'call() expects exactly 1 argument (unless block)' unless args.size == 1
+                    raise Errors::InvalidTemplate, 'call() expects exactly 1 argument (unless block)' unless args.size == 1
 
                     arg = args.first
 
@@ -18,7 +18,7 @@ module Babl
                     when ::Hash then object(**arg.map { |k, v| [:"#{k}", v] }.to_h)
                     when ::Array then array(*arg)
                     when ::String, ::Numeric, ::NilClass, ::TrueClass, ::FalseClass then static(arg)
-                    else raise Errors::InvalidTemplateError, "call() received invalid argument: #{arg}"
+                    else raise Errors::InvalidTemplate, "call() received invalid argument: #{arg}"
                     end
                 end
             end

data/lib/babl/operators/continue.rb

@@ -9,7 +9,7 @@ module Babl
                 def continue
                     construct_terminal { |context|
                         node = context[:continue]
-                        raise Errors::InvalidTemplateError, 'continue() cannot be used outside switch()' unless node
+                        raise Errors::InvalidTemplate, 'continue() cannot be used outside switch()' unless node
                         node
                     }
                 end

data/lib/babl/operators/enter.rb

@@ -9,7 +9,7 @@ module Babl
                 def enter
                     construct_node(key: nil, continue: nil) { |node, context|
                         key = context[:key]
-                        raise Errors::InvalidTemplateError, "No key to enter into" unless key
+                        raise Errors::InvalidTemplate, "No key to enter into" unless key
                         Nodes::Nav.new(key, node)
                     }
                 end

data/lib/babl/operators/object.rb

@@ -9,7 +9,7 @@ module Babl
                 # Create a JSON object node with static structure
                 def object(*attrs, **nested)
                     (attrs.map(&:to_sym) + nested.keys).group_by(&:itself).values.each do |keys|
-                        raise Errors::InvalidTemplateError, "Duplicate key in object(): #{keys.first}" if keys.size > 1
+                        raise Errors::InvalidTemplate, "Duplicate key in object(): #{keys.first}" if keys.size > 1
                     end
 
                     construct_terminal { |ctx|

data/lib/babl/operators/partial.rb

@@ -7,10 +7,10 @@ module Babl
                 # Load a partial template given its name
                 # A 'lookup_context' must be defined
                 def partial(partial_name)
-                    raise Errors::InvalidTemplateError, "Cannot use partial without lookup context" unless lookup_context
+                    raise Errors::InvalidTemplate, "Cannot use partial without lookup context" unless lookup_context
 
                     path, source, partial_lookup_context = lookup_context.find(partial_name)
-                    raise Errors::InvalidTemplateError, "Cannot find partial '#{partial_name}'" unless path
+                    raise Errors::InvalidTemplate, "Cannot find partial '#{partial_name}'" unless path
 
                     with_lookup_context(partial_lookup_context)
                         .source(source, path, 0)

data/lib/babl/operators/pin.rb

@@ -25,7 +25,7 @@ module Babl
                 # Override TemplateBase#precompile to ensure that all pin dependencies are satisfied.
                 def precompile
                     super.tap do |node|
-                        raise Errors::InvalidTemplateError, 'Unresolved pin' unless node.pinned_dependencies.empty?
+                        raise Errors::InvalidTemplate, 'Unresolved pin' unless node.pinned_dependencies.empty?
                     end
                 end
             end

data/lib/babl/operators/static.rb

@@ -13,7 +13,7 @@ module Babl
                     else call(Nodes::TerminalValue.instance.render_object(val))
                     end
                 rescue Errors::RenderingError => exception
-                    raise Errors::InvalidTemplateError, exception.message
+                    raise Errors::InvalidTemplate, exception.message
                 end
             end
         end

data/lib/babl/operators/typed.rb

@@ -0,0 +1,25 @@
+require 'babl/nodes/typed'
+
+module Babl
+    module Operators
+        module Typed
+            module DSL
+                def integer
+                    construct_node(continue: nil) { |node| Nodes::Typed::INTEGER.call(node) }
+                end
+
+                def number
+                    construct_node(continue: nil) { |node| Nodes::Typed::NUMBER.call(node) }
+                end
+
+                def string
+                    construct_node(continue: nil) { |node| Nodes::Typed::STRING.call(node) }
+                end
+
+                def boolean
+                    construct_node(continue: nil) { |node| Nodes::Typed::BOOLEAN.call(node) }
+                end
+            end
+        end
+    end
+end

data/lib/babl/rendering/compiled_template.rb

@@ -4,7 +4,7 @@ require 'values'
 
 module Babl
     module Rendering
-        class CompiledTemplate < Value.new(:node, :dependencies, :preloader, :pretty, :json_schema)
+        class CompiledTemplate < ::Value.new(:node, :dependencies, :preloader, :pretty, :json_schema)
             def json(root)
                 data = render(root)
                 ::Oj.dump(data, indent: pretty ? 4 : 0, mode: :strict)

data/lib/babl/schema/any_of.rb

@@ -5,7 +5,7 @@ require 'babl/schema/object'
 
 module Babl
     module Schema
-        class AnyOf < Value.new(:choice_set)
+        class AnyOf < ::Value.new(:choice_set)
             attr_reader :choices
 
             def initialize(choices)
@@ -30,6 +30,10 @@ module Babl
                     self
             end
 
+            def self.canonical(choices)
+                new(choices).simplify
+            end
+
             private
 
             # We can completely get rid of the AnyOf element of there is only one possible schema.
@@ -37,52 +41,34 @@ module Babl
                 choices.size == 1 ? choices.first : nil
             end
 
-            # Try to merge nullability into one of the object elements if they support that
-            # (Object, DynArray and FixedArray).
+            # Try to merge null with another Anything
             def simplify_nullability
-                if choices.include?(Static::NULL)
-                    others = choices - [Static::NULL]
-                    others.each do |other|
-                        new_other =
-                            case other
-                            when Object then Object.new(other.properties, other.additional, true)
-                            when DynArray then DynArray.new(other.item, true)
-                            when FixedArray then FixedArray.new(other.items, true)
-                            when Anything then other
-                            end
-                        return AnyOf.new(others - [other] + [new_other]).simplify if new_other
-                    end
-                end
-
-                nil
+                AnyOf.canonical(choices - [Static::NULL]) if ([Static::NULL, Anything.instance] - choices).empty?
             end
 
             # An always empty FixedArray is just a special case of a DynArray
             # We can get rid of the former and only keep the DynArray
             def simplify_empty_array
-                fixed_array = choices.find { |s| FixedArray === s && s.items.empty? }
-                if fixed_array
-                    others = choices - [fixed_array]
-                    others.each do |other|
-                        next unless DynArray === other
-                        new_other = DynArray.new(other.item, other.nullable || fixed_array.nullable)
-                        return AnyOf.new(others - [other] + [new_other]).simplify
-                    end
+                return unless choices.include?(FixedArray::EMPTY)
+                others = choices - [FixedArray::EMPTY]
+                others.each do |other|
+                    next unless DynArray === other
+                    new_other = DynArray.new(other.item)
+                    return AnyOf.canonical(others - [other] + [new_other])
                 end
-
                 nil
             end
 
             # If the static array is an instance of another dyn array, then the fixed array can be
             # removed.
             def simplify_dyn_and_fixed_array
-                dyns = choices.select { |s| DynArray === s }
-                fixeds = choices.select { |s| FixedArray === s && s.items.uniq.size == 1 }
+                fixed_arrays = choices.select { |s| FixedArray === s && s.items.uniq.size == 1 }
 
-                dyns.each do |dyn|
-                    fixeds.each do |fixed|
-                        new_dyn = DynArray.new(dyn.item, dyn.nullable || fixed.nullable)
-                        return AnyOf.new(choices - [fixed, dyn] + [new_dyn]).simplify if dyn.item == fixed.items.first
+                choices.each do |dyn|
+                    next unless DynArray === dyn
+                    fixed_arrays.each do |fixed|
+                        new_dyn = DynArray.new(dyn.item)
+                        return AnyOf.canonical(choices - [fixed, dyn] + [new_dyn]) if dyn.item == fixed.items.first
                     end
                 end
 
@@ -92,13 +78,10 @@ module Babl
             # If two objects have exactly the same structure, with the exception of only one property
             # having a different type, then AnyOf can be pushed down to this property.
             def simplify_many_objects_only_one_difference
-                return unless choices.all? { |s| Object === s }
-
                 choices.each_with_index { |obj1, index1|
                     choices.each_with_index { |obj2, index2|
                         next if index2 <= index1
-                        next unless Object === obj1 && Object === obj2
-                        next unless obj1.nullable == obj2.nullable && obj1.additional == obj2.additional
+                        next unless Object === obj1 && Object === obj2 && obj1.additional == obj2.additional
                         next unless obj1.properties.map { |p| [p.name, p.required] }.to_set ==
                                 obj2.properties.map { |p| [p.name, p.required] }.to_set
 
@@ -108,19 +91,18 @@ module Babl
                         next unless diff1.size == 1 && diff2.size == 1 && diff1.first.name == diff2.first.name
 
                         merged = Object.new(
-                            obj1.properties.map { |p|
-                                next p unless p == diff1.first
+                            obj1.properties.map { |property|
+                                next property unless property == diff1.first
                                 Object::Property.new(
-                                    p.name,
-                                    AnyOf.new([diff1.first.value, diff2.first.value]).simplify,
-                                    p.required
+                                    property.name,
+                                    AnyOf.canonical([diff1.first.value, diff2.first.value]),
+                                    property.required
                                 )
                             },
-                            obj1.additional,
-                            obj1.nullable
+                            obj1.additional
                         )
 
-                        return AnyOf.new(choices - [obj1, obj2] + [merged]).simplify
+                        return AnyOf.canonical(choices - [obj1, obj2] + [merged])
                     }
                 }
 
@@ -129,8 +111,15 @@ module Babl
 
             # Push down the AnyOf to the item if all outputs are of type DynArray
             def simplify_push_down_dyn_array
-                return unless choices.all? { |s| DynArray === s }
-                DynArray.new(AnyOf.new(choices.map(&:item)).simplify, choices.any?(&:nullable))
+                choices.each_with_index { |arr1, index1|
+                    choices.each_with_index { |arr2, index2|
+                        next if index2 <= index1
+                        next unless DynArray === arr1 && DynArray === arr2
+                        new_arr = DynArray.new(AnyOf.canonical([arr1.item, arr2.item]))
+                        return AnyOf.canonical(choices - [arr1, arr2] + [new_arr])
+                    }
+                }
+                nil
             end
         end
     end

data/lib/babl/schema/dyn_array.rb

@@ -2,9 +2,9 @@ require 'values'
 
 module Babl
     module Schema
-        class DynArray < Value.new(:item, :nullable)
+        class DynArray < ::Value.new(:item)
             def json
-                { type: nullable ? %w[array null] : 'array', items: item.json }
+                { type: 'array', items: item.json }
             end
         end
     end

data/lib/babl/schema/fixed_array.rb

@@ -2,11 +2,11 @@ require 'values'
 
 module Babl
     module Schema
-        class FixedArray < Value.new(:items, :nullable)
-            EMPTY = new([], false)
+        class FixedArray < ::Value.new(:items)
+            EMPTY = new([])
 
             def json
-                { type: nullable ? %w[array null] : 'array', items: items.map(&:json) }
+                { type: 'array', items: items.map(&:json) }
             end
         end
     end

data/lib/babl/schema/object.rb

@@ -3,25 +3,25 @@ require 'set'
 
 module Babl
     module Schema
-        class Object < Value.new(:property_set, :additional, :nullable)
+        class Object < ::Value.new(:property_set, :additional)
             attr_reader :properties
 
-            def initialize(properties, additional, nullable)
+            def initialize(properties, additional)
                 @properties = properties
-                super(properties.to_set, additional, nullable)
+                super(properties.to_set, additional)
             end
 
-            class Property < Value.new(:name, :value, :required)
+            EMPTY = new([], false)
+            EMPTY_WITH_ADDITIONAL = new([], true)
+
+            class Property < ::Value.new(:name, :value, :required)
                 def initialize(name, value, required)
                     super(name, value, required)
                 end
             end
 
-            EMPTY = new([], false, false)
-            EMPTY_WITH_ADDITIONAL = new([], true, false)
-
             def json
-                { type: nullable ? %w[object null] : 'object' }.tap { |out|
+                { type: 'object' }.tap { |out|
                     next if properties.empty?
                     out[:properties] = properties.map { |property| [property.name, property.value.json] }.to_h
                     out[:additionalProperties] = additional

data/lib/babl/schema/static.rb

@@ -2,7 +2,7 @@ require 'values'
 
 module Babl
     module Schema
-        class Static < Value.new(:value)
+        class Static < ::Value.new(:value)
             NULL = new(nil)
 
             def json

data/lib/babl/schema/typed.rb

@@ -0,0 +1,16 @@
+require 'values'
+
+module Babl
+    module Schema
+        class Typed < ::Value.new(:type)
+            INTEGER = new('integer')
+            BOOLEAN = new('boolean')
+            NUMBER = new('number')
+            STRING = new('string')
+
+            def json
+                { type: type }
+            end
+        end
+    end
+end

data/lib/babl/template.rb

@@ -17,6 +17,7 @@ require 'babl/operators/pin'
 require 'babl/operators/source'
 require 'babl/operators/static'
 require 'babl/operators/switch'
+require 'babl/operators/typed'
 require 'babl/operators/with'
 
 require 'babl/builder/template_base'
@@ -42,6 +43,7 @@ module Babl
         include Operators::Source::DSL
         include Operators::Static::DSL
         include Operators::Switch::DSL
+        include Operators::Typed::DSL
         include Operators::With::DSL
     end
 end

data/lib/babl/version.rb

@@ -1,3 +1,3 @@
 module Babl
-    VERSION = '0.2.1'
+    VERSION = '0.2.2'
 end

data/spec/operators/array_spec.rb

@@ -31,7 +31,7 @@ describe Babl::Operators::Array do
             let(:object) { 1 }
 
             it { expect(json).to eq([1]) }
-            it { expect(schema).to eq s_fixed_array(s_anything, nullable: true) }
+            it { expect(schema).to eq s_any_of(s_null, s_fixed_array(s_anything)) }
         end
     end
 end

data/spec/operators/continue_spec.rb

@@ -7,19 +7,19 @@ describe Babl::Operators::Continue 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 }
+            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplate }
         end
 
         context 'continue without switch' do
             template { continue }
 
-            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplateError }
+            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplate }
         end
 
         context 'continue in sub-object' do
             template { object(a: switch(default => object(x: continue))) }
 
-            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplateError }
+            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplate }
         end
     end
 end

data/spec/operators/each_spec.rb

@@ -36,7 +36,7 @@ describe Babl::Operators::Each do
             let(:object) { [1, nil] }
 
             it { expect(json).to eq [{}, nil] }
-            it { expect(schema).to eq s_dyn_array(s_object(nullable: true), nullable: true) }
+            it { expect(schema).to eq s_any_of(s_dyn_array(s_any_of(s_object, s_null)), s_null) }
         end
     end
 end

data/spec/operators/enter_spec.rb

@@ -7,7 +7,7 @@ describe Babl::Operators::Enter do
         context 'invalid usage' do
             template { enter }
 
-            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplateError }
+            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplate }
         end
 
         context 'valid usage' do

data/spec/operators/extends_spec.rb

@@ -25,6 +25,6 @@ describe Babl::Operators::Extends do
 
     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 }
+        it { expect { schema }.to raise_error Babl::Errors::InvalidTemplate }
     end
 end

data/spec/operators/merge_spec.rb

@@ -66,13 +66,13 @@ describe Babl::Operators::Merge do
                 )
             }
 
-            it { expect { schema }.to raise_error Babl::Errors::InvalidTemplateError }
+            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::InvalidTemplateError }
+            it { expect { schema }.to raise_error Babl::Errors::InvalidTemplate }
         end
 
         context 'merge only one dynamic value' do

data/spec/operators/nav_spec.rb

@@ -7,12 +7,13 @@ describe Babl::Operators::Nav do
         template { nav(:a) }
 
         context 'hash navigation' do
-            let(:object) { { a: 42 } }
-            it { expect(json).to eq(42) }
+            let(:object) { { a: '42' } }
+            it { expect(json).to eq('42') }
             it { expect(dependencies).to eq(a: {}) }
 
-            context 'block navigation propagate dependency chain' do
+            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
@@ -57,7 +58,7 @@ describe Babl::Operators::Nav do
 
         context '#nav should stop key propagation for #enter' do
             template { object(a: nav._) }
-            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplateError }
+            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplate }
         end
 
         context 'nav to array of complex objects' do

data/spec/operators/nullable_spec.rb

@@ -19,7 +19,7 @@ describe Babl::Operators::Nullable do
             expect(schema).to eq(
                 s_object(
                     s_property(:nullprop, s_anything),
-                    s_property(:notnullprop, s_object(s_property(:abc, s_anything), nullable: true))
+                    s_property(:notnullprop, s_any_of(s_object(s_property(:abc, s_anything)), s_null))
                 )
             )
         }

data/spec/operators/object_spec.rb

@@ -24,7 +24,7 @@ describe Babl::Operators::Object do
         context 'misused (chaining after object)' do
             template { object(:a).object(:b) }
 
-            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplateError }
+            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplate }
         end
     end
 end

data/spec/operators/parent_spec.rb

@@ -25,7 +25,7 @@ describe Babl::Operators::Parent do
         context 'invalid usage' do
             template { parent }
 
-            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplateError }
+            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplate }
         end
 
         context 'deeply nested parent chain' do

data/spec/operators/partial_spec.rb

@@ -25,7 +25,7 @@ describe Babl::Operators::Partial do
     context 'missing partial' do
         template { partial('i_do_not_exist') }
 
-        it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplateError }
+        it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplate }
     end
 
     context 'found partial' do

data/spec/operators/pin_spec.rb

@@ -60,7 +60,7 @@ describe Babl::Operators::Pin do
                 )
             }
 
-            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplateError }
+            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplate }
         end
 
         context 'when pinning is mixed with a "with" context' do

data/spec/operators/static_spec.rb

@@ -21,7 +21,7 @@ describe Babl::Operators::Static do
         context 'invalid' do
             template { static(test: Object.new) }
 
-            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplateError }
+            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplate }
         end
     end
 end

data/spec/operators/switch_spec.rb

@@ -76,7 +76,7 @@ describe Babl::Operators::Switch do
         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) }
+            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
@@ -108,9 +108,9 @@ describe Babl::Operators::Switch do
         end
 
         context 'switch between two possible dyn arrays' do
-            template { switch(1 => each.static('a'), 2 => each.static('b')) }
+            template { switch(1 => each.static('a'), 2 => each.static('b'), 3 => nullable.each.static('c')) }
 
-            it { expect(schema).to eq s_dyn_array(s_any_of(s_static('a'), s_static('b'))) }
+            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 'with dependencies' do

data/spec/operators/typed_spec.rb

@@ -0,0 +1,84 @@
+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/spec_helper/schema_utils.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: babl-json
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Frederic Terrazzoni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-11 00:00:00.000000000 Z
+date: 2017-07-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -127,6 +127,7 @@ files:
 - lib/babl/nodes/static.rb
 - lib/babl/nodes/switch.rb
 - lib/babl/nodes/terminal_value.rb
+- lib/babl/nodes/typed.rb
 - lib/babl/nodes/with.rb
 - lib/babl/operators/array.rb
 - lib/babl/operators/call.rb
@@ -147,6 +148,7 @@ files:
 - lib/babl/operators/source.rb
 - lib/babl/operators/static.rb
 - lib/babl/operators/switch.rb
+- lib/babl/operators/typed.rb
 - lib/babl/operators/with.rb
 - lib/babl/railtie.rb
 - lib/babl/rendering/compiled_template.rb
@@ -182,6 +184,7 @@ files:
 - spec/operators/source_spec.rb
 - spec/operators/static_spec.rb
 - spec/operators/switch_spec.rb
+- spec/operators/typed_spec.rb
 - spec/operators/with_spec.rb
 - spec/spec_helper.rb
 - spec/spec_helper/operator_testing.rb
@@ -230,6 +233,7 @@ test_files:
 - spec/operators/source_spec.rb
 - spec/operators/static_spec.rb
 - spec/operators/switch_spec.rb
+- spec/operators/typed_spec.rb
 - spec/operators/with_spec.rb
 - spec/spec_helper.rb
 - spec/spec_helper/operator_testing.rb