babl-json 0.5.9 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 329322cf3fa5b7e83cad065409efcd8889146f0f
-  data.tar.gz: 4b492ee8bc38517fcd1c2e138631e95301ea655f
+  metadata.gz: 1b50e6e799274d6d0286709ee0484a75dea2e09f
+  data.tar.gz: 5b728f4581bea01d71aaf62af160f06b1c0551bc
 SHA512:
-  metadata.gz: 3a0b504aa4bfdd699fe1c7bb5d2e42096329d503fe439878a13c9bbe6239f30de74a3c68fbb4d1d2309ec6f3b87a254117489f8d6d874c4d83e8b0daba00952a
-  data.tar.gz: ae23a4755c56670770efdcc4dfa1abf1fed22ef6b48ce954cf2d726908c9652d768571ee8a735eee79606ab0c8ad83c6991a90e753b2ff73fc427f3de6ef2539
+  metadata.gz: b0af0e4fa77e6971d03230617cdf13c211d6587603bd509c531faf9d9e9358b1e88eb982be6df48551ac8033ed190f7d52357988e987ee3bc5c57f609d8528a1
+  data.tar.gz: c88f3b618e4fe2f2dc9181ed07ee6333d7cdfbcd5fff68071cba0a87b9155f9f1e7a13d89cb36cba68b8421773b4330767d1069e290f7522e171b4a9bd9ad532

data/lib/babl.rb

@@ -52,6 +52,7 @@ module Babl
             query = File.join(search_path, "{#{partial_name}}{.babl,}")
             path = Dir[query].first
             return unless path
+
             source = File.read(path)
             [current_template.source(source, path, 0), self]
         end
@@ -76,6 +77,7 @@ module Babl
         def template
             cached = @cached_template
             return cached.last if cached && [config.using].flatten == cached.first
+
             # Calling 'using' is a very inefficient operation, because
             # it creates a new class. We can avoid that cost most of the
             # time, assuming 'config.using' does not change often (typically

data/lib/babl/builder/chain_builder.rb

@@ -29,8 +29,8 @@ module Babl
                 @scope = block
             end
 
-            def precompile(node, **context)
-                bind(BoundOperator.new(context)).precompile(node)
+            def precompile(node, context)
+                bind(BoundOperator.new(context, &:itself)).scope.call(node)
             end
 
             def bind(bound)
@@ -43,38 +43,38 @@ module Babl
                     unless [Nodes::InternalValue.instance, Nodes::TerminalValue.instance].include?(node)
                         raise Errors::InvalidTemplate, 'Chaining is not allowed after a terminal operator'
                     end
+
                     yield context
                 end
             end
 
             # Append an operator to the chain, and return a new Builder object
-            def construct_node(**new_context)
+            def construct_node
+                wrap { |bound|
+                    BoundOperator.new(bound.context) { |node| bound.scope[yield(node, bound.context)] }
+                }
+            end
+
+            def construct_context
                 wrap { |bound|
-                    bound.nest(bound.context.merge(new_context)) { |node|
-                        yield(node, bound.context)
-                    }
+                    new_context = yield(bound.context)
+                    next bound if bound.context.equal?(new_context)
+
+                    BoundOperator.new(new_context, &bound.scope)
                 }
             end
 
             def wrap
-                self.class.new { |bound| yield bind(bound) }
+                ChainBuilder.new { |bound| yield bind(bound) }
             end
         end
 
         class BoundOperator
-            attr_reader :context
+            attr_reader :context, :scope
 
             def initialize(context, &scope)
                 @context = context
-                @scope = scope || :itself.to_proc
-            end
-
-            def precompile(node)
-                @scope[node]
-            end
-
-            def nest(context)
-                self.class.new(context) { |node| @scope[yield node] }
+                @scope = scope
             end
         end
     end

data/lib/babl/builder/template_base.rb

@@ -17,7 +17,7 @@ module Babl
             end
 
             def compile(preloader: Rendering::NoopPreloader, pretty: true, optimize: true, lookup_context: nil)
-                tree = precompile(lookup_context: lookup_context)
+                tree = precompile(Nodes::TerminalValue.instance, lookup_context: lookup_context)
                 tree = tree.optimize if optimize
                 validate(tree)
 
@@ -46,12 +46,16 @@ module Babl
                 # NOOP
             end
 
-            def precompile(node = Nodes::TerminalValue.instance, **context)
-                builder.precompile(node, **context)
+            def precompile(node, context)
+                builder.precompile(node, context)
             end
 
-            def construct_node(**new_context, &block)
-                self.class.new builder.construct_node(**new_context, &block)
+            def construct_node(&block)
+                self.class.new builder.construct_node(&block)
+            end
+
+            def construct_context(&block)
+                self.class.new builder.construct_context(&block)
             end
 
             def construct_terminal(&block)

data/lib/babl/nodes/concat.rb

@@ -7,11 +7,11 @@ module Babl
     module Nodes
         class Concat < Utils::Value.new(:nodes)
             memoize def dependencies
-                Babl::Utils::Hash.deep_merge(*nodes.map(&:dependencies))
+                Babl::Utils::Hash.deep_merge(nodes.map(&:dependencies))
             end
 
             memoize def pinned_dependencies
-                Babl::Utils::Hash.deep_merge(*nodes.map(&:pinned_dependencies))
+                Babl::Utils::Hash.deep_merge(nodes.map(&:pinned_dependencies))
             end
 
             memoize def schema
@@ -47,6 +47,7 @@ module Babl
 
             def optimize_single
                 return unless nodes.size == 1
+
                 optimized = nodes.first.optimize
 
                 case optimized
@@ -62,6 +63,7 @@ module Babl
             def optimize_concatenated_arrays
                 optimized_nodes = nodes.map(&:optimize)
                 return if optimized_nodes == nodes
+
                 Concat.new(optimized_nodes).optimize
             end
 
@@ -70,6 +72,7 @@ module Babl
                     obj1 = constant_to_array(obj1) if Constant === obj1
                     obj2 = constant_to_array(obj2) if Constant === obj2
                     next unless FixedArray === obj1 && FixedArray === obj2
+
                     new_nodes = nodes.dup
                     new_nodes[idx] = FixedArray.new(obj1.nodes + obj2.nodes)
                     new_nodes[idx + 1] = nil

data/lib/babl/nodes/create_pin.rb

@@ -15,7 +15,7 @@ module Babl
             end
 
             memoize def dependencies
-                Babl::Utils::Hash.deep_merge(node.dependencies, node.pinned_dependencies[ref] || Utils::Hash::EMPTY)
+                Babl::Utils::Hash.deep_merge([node.dependencies, node.pinned_dependencies[ref] || Utils::Hash::EMPTY])
             end
 
             memoize def pinned_dependencies

data/lib/babl/nodes/dep.rb

@@ -17,7 +17,7 @@ module Babl
             end
 
             memoize def dependencies
-                Babl::Utils::Hash.deep_merge(node.dependencies, path)
+                Babl::Utils::Hash.deep_merge([node.dependencies, path])
             end
 
             memoize def optimize

data/lib/babl/nodes/each.rb

@@ -10,10 +10,10 @@ module Babl
                 node_deps = node.dependencies
                 child_deps = node_deps.reject { |key, _| key == Parent::PARENT_MARKER }
 
-                Babl::Utils::Hash.deep_merge(
+                Babl::Utils::Hash.deep_merge([
                     node_deps[Parent::PARENT_MARKER] || Utils::Hash::EMPTY,
                     __each__: child_deps
-                )
+                ])
             end
 
             memoize def schema

data/lib/babl/nodes/fixed_array.rb

@@ -13,11 +13,11 @@ module Babl
             end
 
             memoize def dependencies
-                Babl::Utils::Hash.deep_merge(*nodes.map(&:dependencies))
+                Babl::Utils::Hash.deep_merge(nodes.map(&:dependencies))
             end
 
             memoize def pinned_dependencies
-                Babl::Utils::Hash.deep_merge(*nodes.map(&:pinned_dependencies))
+                Babl::Utils::Hash.deep_merge(nodes.map(&:pinned_dependencies))
             end
 
             memoize def optimize

data/lib/babl/nodes/goto_pin.rb

@@ -10,7 +10,7 @@ module Babl
             end
 
             memoize def pinned_dependencies
-                Babl::Utils::Hash.deep_merge(node.pinned_dependencies, ref => node.dependencies)
+                Babl::Utils::Hash.deep_merge([node.pinned_dependencies, ref => node.dependencies])
             end
 
             memoize def schema

data/lib/babl/nodes/merge.rb

@@ -8,11 +8,11 @@ module Babl
     module Nodes
         class Merge < Utils::Value.new(:nodes)
             memoize def dependencies
-                Babl::Utils::Hash.deep_merge(*nodes.map(&:dependencies))
+                Babl::Utils::Hash.deep_merge(nodes.map(&:dependencies))
             end
 
             memoize def pinned_dependencies
-                Babl::Utils::Hash.deep_merge(*nodes.map(&:pinned_dependencies))
+                Babl::Utils::Hash.deep_merge(nodes.map(&:pinned_dependencies))
             end
 
             memoize def schema
@@ -44,6 +44,7 @@ module Babl
 
             def optimize_single
                 return unless nodes.size == 1
+
                 optimized = nodes.first.optimize
 
                 case optimized
@@ -59,11 +60,13 @@ module Babl
             def optimize_merged_objects
                 optimized_nodes = nodes.map(&:optimize)
                 return if optimized_nodes == nodes
+
                 Merge.new(optimized_nodes).optimize
             end
 
             def optimize_nested_merges
                 return unless nodes.any? { |node| Merge === node }
+
                 Merge.new(nodes.flat_map { |node| Merge === node ? node.nodes : [node] }).optimize
             end
 
@@ -73,6 +76,7 @@ module Babl
                     obj2 = constant_to_object(obj2) if Constant === obj2
 
                     next unless Object === obj1 && Object === obj2
+
                     new_nodes = nodes.dup
                     new_nodes[idx] = Object.new(obj1.nodes.merge(obj2.nodes))
                     new_nodes[idx + 1] = nil

data/lib/babl/nodes/nav.rb

@@ -10,10 +10,10 @@ module Babl
                 node_deps = node.dependencies
                 child_deps = node_deps.reject { |key, _| key == Parent::PARENT_MARKER }
 
-                Babl::Utils::Hash.deep_merge(
+                Babl::Utils::Hash.deep_merge([
                     node_deps[Parent::PARENT_MARKER] || Utils::Hash::EMPTY,
                     property => child_deps
-                )
+                ])
             end
 
             memoize def schema
@@ -29,16 +29,17 @@ module Babl
                 return optimized if Constant === optimized || GotoPin === optimized
                 return optimized.node if Parent === optimized
                 return self if optimized.equal?(node)
+
                 Nav.new(property, optimized)
             end
 
             def render(frame)
                 value = begin
-                    object = frame.object
-                    ::Hash === object ? object.fetch(property) : object.send(property)
-                rescue StandardError => e
-                    raise Errors::RenderingError, "#{e.message}\n" + frame.formatted_stack(property), e.backtrace
-                end
+                            object = frame.object
+                            ::Hash === object ? object.fetch(property) : object.send(property)
+                        rescue StandardError => e
+                            raise Errors::RenderingError, "#{e.message}\n" + frame.formatted_stack(property), e.backtrace
+                        end
 
                 frame.move_forward(value, property) do |new_frame|
                     node.render(new_frame)

data/lib/babl/nodes/object.rb

@@ -9,11 +9,11 @@ module Babl
             EMPTY = new(Utils::Hash::EMPTY)
 
             memoize def dependencies
-                Babl::Utils::Hash.deep_merge(*nodes.values.map(&:dependencies))
+                Babl::Utils::Hash.deep_merge(nodes.values.map(&:dependencies))
             end
 
             memoize def pinned_dependencies
-                Babl::Utils::Hash.deep_merge(*nodes.values.map(&:pinned_dependencies))
+                Babl::Utils::Hash.deep_merge(nodes.values.map(&:pinned_dependencies))
             end
 
             memoize def schema
@@ -27,6 +27,7 @@ module Babl
                 object ||= Object.new(optimized_nodes)
 
                 return object unless optimized_nodes.values.all? { |node| Constant === node }
+
                 Constant.new(optimized_nodes.map { |k, v| [k, v.value] }.to_h.freeze, object.schema)
             end
 

data/lib/babl/nodes/parent.rb

@@ -23,6 +23,7 @@ module Babl
                 optimized = node.optimize
                 return optimized if Constant === optimized || GotoPin === optimized
                 return self if optimized.equal?(node)
+
                 Parent.new(optimized)
             end
 

data/lib/babl/nodes/switch.rb

@@ -10,15 +10,16 @@ module Babl
         class Switch < Utils::Value.new(:nodes)
             def initialize(nodes)
                 raise Errors::InvalidTemplate, 'A least one switch() condition must be taken' if nodes.empty?
+
                 super
             end
 
             memoize def dependencies
-                Babl::Utils::Hash.deep_merge(*nodes.flatten(1).map(&:dependencies))
+                Babl::Utils::Hash.deep_merge(nodes.flatten(1).map(&:dependencies))
             end
 
             memoize def pinned_dependencies
-                Babl::Utils::Hash.deep_merge(*nodes.flatten(1).map(&:pinned_dependencies))
+                Babl::Utils::Hash.deep_merge(nodes.flatten(1).map(&:pinned_dependencies))
             end
 
             memoize def schema
@@ -45,6 +46,7 @@ module Babl
             def optimize_continue_to_switch
                 cond, val = nodes.last
                 return unless Switch === val && Constant === cond && cond.value
+
                 Switch.new(nodes[0...-1] + val.nodes).optimize
             end
 
@@ -52,6 +54,7 @@ module Babl
                 conds = Set.new
                 new_nodes = nodes.map { |cond, val|
                     next if conds.include?(cond)
+
                     conds << cond
                     [cond, val]
                 }.compact
@@ -61,6 +64,7 @@ module Babl
             def optimize_always_same_outputs
                 return unless nodes.map(&:first).any? { |node| Constant === node && node.value }
                 return unless nodes.map(&:last).uniq.size == 1
+
                 nodes.first.last.optimize
             end
 

data/lib/babl/nodes/with.rb

@@ -10,14 +10,14 @@ module Babl
             end
 
             memoize def dependencies
-                Babl::Utils::Hash.deep_merge(
+                Babl::Utils::Hash.deep_merge([
                     *nodes.map(&:dependencies),
                     node.dependencies[Parent::PARENT_MARKER] || Utils::Hash::EMPTY
-                )
+                ])
             end
 
             memoize def pinned_dependencies
-                Babl::Utils::Hash.deep_merge(*(nodes + [node]).map(&:pinned_dependencies))
+                Babl::Utils::Hash.deep_merge((nodes + [node]).map(&:pinned_dependencies))
             end
 
             memoize def optimize
@@ -30,15 +30,16 @@ module Babl
 
                 if optimized_nodes.all? { |n| Constant === n }
                     value = begin
-                        block.call(*optimized_nodes.map(&:value))
-                    rescue StandardError => e
-                        raise Errors::InvalidTemplate, e.message, e.backtrace
-                    end
+                                block.call(*optimized_nodes.map(&:value))
+                            rescue StandardError => e
+                                raise Errors::InvalidTemplate, e.message, e.backtrace
+                            end
                     constant_block = Utils::Proc.constant(value)
                     return With.new(optimized, Utils::Array::EMPTY, constant_block)
                 end
 
                 return self if optimized.equal?(node) && optimized_nodes.each_with_index.all? { |n, idx| n.equal?(nodes[idx]) }
+
                 With.new(optimized, optimized_nodes, block)
             end
 

data/lib/babl/operators/array.rb

@@ -7,11 +7,11 @@ module Babl
             module DSL
                 # Produce an fixed-size array, using the provided templates to populate its elements.
                 def array(*templates)
-                    templates = templates.map { |t| unscoped.call(t) }
+                    templates = templates.map { |t| unscoped.reset_continue.call(t) }
 
                     construct_terminal { |ctx|
                         Nodes::FixedArray.new(templates.map { |t|
-                            t.builder.precompile(Nodes::TerminalValue.instance, ctx.merge(continue: nil))
+                            t.builder.precompile(Nodes::TerminalValue.instance, ctx)
                         })
                     }
                 end

data/lib/babl/operators/call.rb

@@ -24,11 +24,10 @@ module Babl
                     case arg
                     when Template then self.class.new(builder.wrap { |bound| arg.builder.bind(bound) })
                     when Utils::DslProxy then call(arg.itself)
-                    when ::Symbol then nav(arg)
                     when ::Proc then call(&arg)
                     when ::Hash then object(arg)
                     when ::Array then array(*arg)
-                    when ::String, ::Numeric, ::NilClass, ::TrueClass, ::FalseClass then static(arg)
+                    when ::String, ::Numeric, ::NilClass, ::TrueClass, ::FalseClass, ::Symbol then static(arg)
                     else raise Errors::InvalidTemplate, "call() received invalid argument: #{arg}"
                     end
                 end

data/lib/babl/operators/concat.rb

@@ -8,14 +8,14 @@ module Babl
                 # Produce an array by concatening the provided result of the given templates.
                 # (they therefor have to produce arrays, or nil, which is interpreted as an empty array)
                 def concat(*templates)
-                    templates = templates.map { |t| unscoped.call(t) }
+                    templates = templates.map { |t| unscoped.reset_continue.call(t) }
 
                     construct_terminal { |context|
                         Nodes::Concat.new(
                             templates.map { |t|
                                 t.builder.precompile(
                                     Nodes::TerminalValue.instance,
-                                    context.merge(continue: nil)
+                                    context
                                 )
                             }
                         )

data/lib/babl/operators/continue.rb

@@ -11,9 +11,21 @@ module Babl
                     construct_terminal { |context|
                         node = context[:continue]
                         raise Errors::InvalidTemplate, 'continue() cannot be used outside switch()' unless node
+
                         node
                     }
                 end
+
+                protected
+
+                # Clear contextual information about parent switch for the rest of the chain
+                def reset_continue
+                    construct_context { |context|
+                        next context unless context.key?(:continue)
+
+                        context.reject { |k, _v| :continue == k }
+                    }
+                end
             end
         end
     end

data/lib/babl/operators/dep.rb

@@ -17,7 +17,7 @@ module Babl
                 # but without navigating.
                 def dep(*path)
                     path = Dep.canonicalize(path)
-                    construct_node(continue: nil) { |node| Nodes::Dep.new(node, path) }
+                    construct_node { |node| Nodes::Dep.new(node, path) }.reset_continue
                 end
             end
         end

data/lib/babl/operators/each.rb

@@ -8,7 +8,7 @@ module Babl
                 # Construct a JSON array by iterating over the current collection,
                 # using the chained template for rendering each element.
                 def each
-                    construct_node(key: nil, continue: nil) { |node| Nodes::Each.new(node) }
+                    construct_node { |node| Nodes::Each.new(node) }.reset_key.reset_continue
                 end
             end
         end

data/lib/babl/operators/enter.rb

@@ -5,21 +5,54 @@ require 'babl/nodes'
 module Babl
     module Operators
         module Enter
+            KEY_QUESTIONIFIER = proc { |context|
+                key = context[:key]
+
+                new_key =
+                    case key
+                    when ::String then "#{key}?"
+                    when ::Symbol then :"#{key}?"
+                    else raise Errors::InvalidTemplate, "Key is expected to key a string or a symbol: #{key}"
+                    end
+
+                context.merge(key: new_key)
+            }
+
             module DSL
-                # Navigate to a named property of current element. The name
-                # is inferred based on the object()
+                # Navigate to a property whose name is inferred based on parent object()'s key
                 def enter
-                    construct_node(key: nil, continue: nil) { |node, context|
-                        key = context[:key]
-                        raise Errors::InvalidTemplate, 'No key to enter into' unless key
-                        Nodes::Nav.new(key, node)
-                    }
+                    construct_node { |node, context|
+                        raise Errors::InvalidTemplate, 'No key to enter into' unless context.key?(:key)
+
+                        Nodes::Nav.new(context[:key], node)
+                    }.reset_key.reset_continue
+                end
+
+                # Navigate to a property whose name is inferred based on parent object()'s key + '?'
+                def enter?
+                    construct_context(&KEY_QUESTIONIFIER).enter
                 end
 
                 # Simple convenience alias
                 def _
                     enter
                 end
+
+                # Simple convenience alias
+                def _?
+                    enter?
+                end
+
+                protected
+
+                # Clear contextual information about current property name for the rest of the chain
+                def reset_key
+                    construct_context { |context|
+                        next context unless context.key?(:key)
+
+                        context.reject { |k, _v| :key == k }
+                    }
+                end
             end
         end
     end

data/lib/babl/operators/merge.rb

@@ -9,15 +9,13 @@ module Babl
                 # Merge multiple JSON objects (non-deep)
                 def merge(*templates)
                     return call(Utils::Hash::EMPTY) if templates.empty?
-                    templates = templates.map { |t| unscoped.call(t) }
+
+                    templates = templates.map { |t| unscoped.reset_continue.call(t) }
 
                     construct_terminal { |context|
                         Nodes::Merge.new(
                             templates.map { |t|
-                                t.builder.precompile(
-                                    Nodes::TerminalValue.instance,
-                                    context.merge(continue: nil)
-                                )
+                                t.builder.precompile(Nodes::TerminalValue.instance, context)
                             }
                         )
                     }

data/lib/babl/operators/nav.rb

@@ -12,10 +12,11 @@ module Babl
                 # is disabled for the rest of the chain.
                 def nav(*path, &block)
                     if path.empty?
-                        return (block ? with(unscoped, &block) : construct_node(key: nil, continue: nil) { |node| node })
+                        return (block ? with(unscoped, &block) : reset_key.reset_continue)
                     end
+
                     property = path.first.dup.freeze
-                    construct_node(key: nil, continue: nil) { |node| Nodes::Nav.new(property, node) }
+                    construct_node { |node| Nodes::Nav.new(property, node) }
                         .nav(*path[1..-1], &block)
                 end
             end

data/lib/babl/operators/object.rb

@@ -18,7 +18,7 @@ module Babl
                     templates = args
                         .map { |name| [name.to_sym, unscoped.nav(name)] }.to_h
                         .merge(kwargs)
-                        .map { |k, v| [k, unscoped.call(v)] }
+                        .map { |k, v| [k, unscoped.reset_continue.call(v)] }
 
                     construct_terminal { |ctx|
                         Nodes::Object.new(templates.map { |key, template|
@@ -26,7 +26,7 @@ module Babl
                                 key.to_sym,
                                 template.builder.precompile(
                                     Nodes::TerminalValue.instance,
-                                    ctx.merge(key: key, continue: nil)
+                                    ctx.merge(key: key)
                                 )
                             ]
                         }.to_h)

data/lib/babl/operators/parent.rb

@@ -7,7 +7,7 @@ module Babl
             module DSL
                 # Navigate to the parent of the current object.
                 def parent
-                    construct_node(key: nil, continue: nil) { |node| Nodes::Parent.new(node) }
+                    construct_node { |node| Nodes::Parent.new(node) }.reset_key.reset_continue
                 end
 
                 protected
@@ -16,6 +16,7 @@ module Babl
                     if tree.dependencies.key? Nodes::Parent::PARENT_MARKER
                         raise Errors::InvalidTemplate, 'Out of context parent dependency'
                     end
+
                     super
                 end
             end

data/lib/babl/operators/partial.rb

@@ -12,8 +12,10 @@ module Babl
                     construct_terminal { |ctx|
                         lookup_context = ctx[:lookup_context]
                         raise Errors::InvalidTemplate, 'Cannot use partial without lookup context' unless lookup_context
+
                         template, new_lookup_context = lookup_context.find(current_template, partial_name)
                         raise Errors::InvalidTemplate, "Cannot find partial '#{partial_name}'" unless template
+
                         template.precompile(Nodes::TerminalValue.instance, lookup_context: new_lookup_context)
                     }
                 end

data/lib/babl/operators/pin.rb

@@ -15,12 +15,12 @@ module Babl
 
                 def named_pin(ref)
                     check_pin_ref(ref)
-                    construct_node(continue: nil) { |node| Nodes::CreatePin.new(node, ref) }
+                    construct_node { |node| Nodes::CreatePin.new(node, ref) }.reset_continue
                 end
 
                 def goto_pin(ref)
                     check_pin_ref(ref)
-                    construct_node(key: nil, continue: nil) { |node| Nodes::GotoPin.new(node, ref) }
+                    construct_node { |node| Nodes::GotoPin.new(node, ref) }.reset_key.reset_continue
                 end
 
                 protected
@@ -28,6 +28,7 @@ module Babl
                 def validate(tree)
                     name = tree.pinned_dependencies.keys.first
                     raise Errors::InvalidTemplate, "Unresolved pin: #{name}" if name
+
                     super
                 end
 

data/lib/babl/operators/source.rb

@@ -7,6 +7,7 @@ module Babl
                 # Parse BABL source into a Template
                 def source(*args, &block)
                     raise Errors::InvalidTemplate, 'source() expects a block xor a string' unless args.empty? ^ block.nil?
+
                     block ||= proc { instance_eval(*args) }
                     call Utils::DslProxy.eval(unscoped, &block)
                 end

data/lib/babl/operators/switch.rb

@@ -8,13 +8,13 @@ module Babl
             module DSL
                 # Conditional switching between different templates
                 def switch(conds = Utils::Hash::EMPTY)
-                    conds = conds.map { |cond, value| [unscoped.call(cond), unscoped.call(value)] }
+                    conds = conds.map { |cond, value| [unscoped.reset_continue.call(cond), unscoped.call(value)] }
 
-                    construct_node(continue: nil) { |node, context|
+                    construct_node { |node, context|
                         nodes = conds.map { |cond, value|
                             cond_node = cond.builder.precompile(
                                 Nodes::InternalValue.instance,
-                                context.merge(continue: nil)
+                                context
                             )
 
                             value_node = value.builder.precompile(
@@ -26,7 +26,7 @@ module Babl
                         }
 
                         Nodes::Switch.new(nodes)
-                    }
+                    }.reset_continue
                 end
             end
         end

data/lib/babl/operators/with.rb

@@ -7,16 +7,16 @@ module Babl
             module DSL
                 # Produce a value by calling the block, passing it the output value of the templates passed as argument.
                 def with(*templates, &block)
-                    templates = templates.map { |t| unscoped.call(t) }
+                    templates = templates.map { |t| unscoped.reset_continue.call(t) }
 
-                    construct_node(key: nil, continue: nil) do |node, context|
+                    construct_node { |node, context|
                         Nodes::With.new(node, templates.map { |t|
                             t.builder.precompile(
                                 Nodes::InternalValue.instance,
-                                context.merge(continue: nil)
+                                context
                             )
                         }, block)
-                    end
+                    }.reset_key.reset_continue
                 end
             end
         end

data/lib/babl/schema/any_of.rb

@@ -67,6 +67,7 @@ module Babl
 
             def simplify_integer_is_number
                 return unless choice_set.include?(Typed::INTEGER) && choice_set.include?(Typed::NUMBER)
+
                 AnyOf.canonicalized(choice_set - [Typed::INTEGER])
             end
 
@@ -103,6 +104,7 @@ module Babl
             # AnyOf[true, false] is just boolean
             def simplify_boolean
                 return unless choice_set.include?(Primitive::TRUE) && choice_set.include?(Primitive::FALSE)
+
                 AnyOf.canonicalized(choice_set - [Primitive::TRUE, Primitive::FALSE] + [Typed::BOOLEAN])
             end
 
@@ -113,10 +115,12 @@ module Babl
             def simplify_typed_and_static
                 choice_set.each do |typed|
                     next unless Typed === typed
+
                     instances = choice_set.select { |instance|
                         Primitive === instance && typed.classes.any? { |clazz| clazz === instance.value }
                     }
                     next if instances.empty?
+
                     return AnyOf.canonicalized(choice_set - instances)
                 end
                 nil
@@ -126,8 +130,10 @@ module Babl
             # We can get rid of the former and only keep the DynArray
             def simplify_empty_array
                 return unless choice_set.include?(FixedArray::EMPTY)
+
                 choice_set.each do |other|
                     next unless DynArray === other
+
                     new_other = DynArray.new(other.item)
                     return AnyOf.canonicalized(choice_set - [other, FixedArray::EMPTY] + [new_other])
                 end
@@ -142,6 +148,7 @@ module Babl
 
                 choice_set.each do |dyn|
                     next unless DynArray === dyn
+
                     fixed_arrays.each do |fixed|
                         new_dyn = DynArray.new(dyn.item)
                         return AnyOf.canonicalized(choice_set - [fixed, dyn] + [new_dyn]) if dyn.item == fixed.items.first
@@ -170,8 +177,8 @@ module Babl
                         next if obj1props.any? { |name, p1|
                             p2 = obj2props[name]
                             next name if p2 && Primitive === p2.value &&
-                                    Primitive === p1.value &&
-                                    p1.value.value != p2.value.value
+                                Primitive === p1.value &&
+                                p1.value.value != p2.value.value
                         }
 
                         new_properties = (obj1props.keys + obj2props.keys).uniq.map { |name|
@@ -197,9 +204,11 @@ module Babl
             def simplify_push_down_dyn_array
                 choice_set.each_with_index { |arr1, index1|
                     next unless DynArray === arr1
+
                     choice_set.each_with_index { |arr2, index2|
                         break if index2 >= index1
                         next unless DynArray === arr2
+
                         new_arr = DynArray.new(AnyOf.canonicalized([arr1.item, arr2.item]))
                         return AnyOf.canonicalized(choice_set - [arr1, arr2] + [new_arr])
                     }

data/lib/babl/schema/object.rb

@@ -21,10 +21,12 @@ module Babl
             def json
                 { type: 'object' }.tap { |out|
                     next if property_set.empty?
+
                     out[:properties] = property_set.map { |property| [property.name, property.value.json] }.to_h
                     out[:additionalProperties] = additional
                     required_properties = property_set.select(&:required)
                     next if required_properties.empty?
+
                     out[:required] = property_set.select(&:required).map(&:name).map(&:to_s)
                 }
             end

data/lib/babl/utils/dsl_proxy.rb

@@ -11,7 +11,7 @@ module Babl
             NON_PROXIED_METHODS = Set[
                 :__send__, :send, :object_id, :__id__, :equal?, :instance_eval, :instance_exec,
                 :respond_to?, :method, :freeze
-            ]
+            ].freeze
 
             instance_methods.each do |method|
                 undef_method(method) unless NON_PROXIED_METHODS.include?(method)

data/lib/babl/utils/hash.rb

@@ -5,10 +5,11 @@ module Babl
             EMPTY = {}.freeze
 
             class << self
-                def deep_merge(*hashes)
+                def deep_merge(hashes)
                     filtered_hashes = hashes.reject(&:empty?)
                     return EMPTY if filtered_hashes.empty?
                     return filtered_hashes.first if filtered_hashes.size == 1
+
                     filtered_hashes.reduce({}) { |out, hash| deep_merge_inplace(out, hash) }
                 end
 

data/lib/babl/utils/value.rb

@@ -45,6 +45,7 @@ module Babl
             class << self
                 def with(hash = Utils::Hash::EMPTY)
                     raise ::ArgumentError unless ::Hash === hash && (hash.keys - self::FIELDS).empty?
+
                     new(*self::FIELDS.map { |f| hash.fetch(f) })
                 end
 

data/lib/babl/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Babl
-    VERSION = '0.5.9'
+    VERSION = '0.6.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: babl-json
 version: !ruby/object:Gem::Version
-  version: 0.5.9
+  version: 0.6.0
 platform: ruby
 authors:
 - Frederic Terrazzoni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-03 00:00:00.000000000 Z
+date: 2018-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coveralls
@@ -187,6 +187,7 @@ files:
 - lib/babl/schema/anything.rb
 - lib/babl/schema/dyn_array.rb
 - lib/babl/schema/fixed_array.rb
+- lib/babl/schema/json_schema.rb
 - lib/babl/schema/object.rb
 - lib/babl/schema/primitive.rb
 - lib/babl/schema/typed.rb