babl-json 0.5.3 → 0.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 14b097a0829fb4d3a127ec290a6768576c9d20ed
-  data.tar.gz: 4753dead38682900489fff11c25abd23e72d1515
+  metadata.gz: 310b4377dc2e8962bd245804fd9ca8ede567748a
+  data.tar.gz: 39aa36ae900752cabc18f484d1dc047439f60391
 SHA512:
-  metadata.gz: '0809d686259d83c42c7053e049427767216ca3be7282f3a427a45125a7fc5f8e848b6b20771a700cea70a9684663eb9cf209c22128b9e33744d27e00f9944928'
-  data.tar.gz: 5f5eff014fd6ea456a1518c6a9dbf3681be309b414ad5f306ea5005cf011c2b001177b836c6b3bbcc18658bbbf5581b7bbb85abf9336fb6dc96b802c35facd3a
+  metadata.gz: 88716be5c080dd4a545234561898aa6c6ae63194d3b5be8de37721a2473934b185ba2f7bb0accf07a811111250c07fd05ffbab2838bda63dbb1e79e9c11bef59
+  data.tar.gz: 7a993254d2dede29615e414a9c82ad1d3023a03aeecd1d6ba512bf3465d61f7f1f2d2addc1ca8c0758e9c11cab9aa356b21ec2276a36e4730a0dd27aaf525d23

data/lib/babl/builder/template_base.rb

@@ -22,6 +22,8 @@ module Babl
                 # Compute dependencies & schema on the non-simplified node tree in order
                 # to catch all errors.
                 tree = precompile(lookup_context: lookup_context)
+                validate(tree)
+
                 dependencies = tree.dependencies
                 schema = tree.schema
 
@@ -48,6 +50,10 @@ module Babl
 
             protected
 
+            def validate(tree)
+                # NOOP
+            end
+
             def precompile(node = Nodes::TerminalValue.instance, **context)
                 builder.precompile(node, **context)
             end

data/lib/babl/nodes/concat.rb

@@ -18,14 +18,14 @@ module Babl
                 nodes.map(&:schema).reduce(Schema::FixedArray::EMPTY) { |a, b| merge_doc(a, b) }
             end
 
-            def render(context, frame)
+            def render(frame)
                 out = []
                 nodes.each { |node|
-                    values = node.render(context, frame)
+                    values = node.render(frame)
                     case values
                     when ::NilClass then nil
                     when ::Array then out.concat(values)
-                    else raise Errors::RenderingError, "Only arrays can be concatenated\n" + context.formatted_stack(frame)
+                    else raise Errors::RenderingError, "Only arrays can be concatenated\n" + frame.formatted_stack
                     end
                 }
                 out

data/lib/babl/nodes/constant.rb

@@ -5,7 +5,7 @@ require 'babl/utils'
 module Babl
     module Nodes
         class Constant < Utils::Value.new(:value, :schema)
-            def render(_context, _frame)
+            def render(_frame)
                 value
             end
 

data/lib/babl/nodes/create_pin.rb

@@ -4,9 +4,9 @@ require 'babl/utils'
 module Babl
     module Nodes
         class CreatePin < Utils::Value.new(:node, :ref)
-            def render(context, frame)
-                context.create_pin(frame, ref) do |new_frame|
-                    node.render(context, new_frame)
+            def render(frame)
+                frame.create_pin(ref) do |new_frame|
+                    node.render(new_frame)
                 end
             end
 

data/lib/babl/nodes/dep.rb

@@ -4,8 +4,8 @@ require 'babl/utils'
 module Babl
     module Nodes
         class Dep < Utils::Value.new(:node, :path)
-            def render(context, frame)
-                node.render(context, frame)
+            def render(frame)
+                node.render(frame)
             end
 
             def schema

data/lib/babl/nodes/each.rb

@@ -24,15 +24,15 @@ module Babl
                 node.pinned_dependencies
             end
 
-            def render(context, frame)
+            def render(frame)
                 collection = frame.object
                 unless Enumerable === collection
-                    raise Errors::RenderingError, "Not enumerable : #{collection.inspect}\n#{context.formatted_stack(frame)}"
+                    raise Errors::RenderingError, "Not enumerable : #{collection.inspect}\n#{frame.formatted_stack}"
                 end
 
-                collection.each_with_index.map do |value, idx|
-                    context.move_forward(frame, value, idx) do |new_frame|
-                        node.render(context, new_frame)
+                collection.map.with_index do |value, idx|
+                    frame.move_forward(value, idx) do |new_frame|
+                        node.render(new_frame)
                     end
                 end
             end

data/lib/babl/nodes/fixed_array.rb

@@ -20,8 +20,8 @@ module Babl
                 nodes.map(&:pinned_dependencies).reduce(Utils::Hash::EMPTY) { |a, b| Babl::Utils::Hash.deep_merge(a, b) }
             end
 
-            def render(context, frame)
-                nodes.map { |node| node.render(context, frame) }
+            def render(frame)
+                nodes.map { |node| node.render(frame) }
             end
 
             def optimize

data/lib/babl/nodes/goto_pin.rb

@@ -17,9 +17,9 @@ module Babl
                 node.schema
             end
 
-            def render(context, frame)
-                context.goto_pin(frame, ref) do |new_frame|
-                    node.render(context, new_frame)
+            def render(frame)
+                frame.goto_pin(ref) do |new_frame|
+                    node.render(new_frame)
                 end
             end
 

data/lib/babl/nodes/internal_value.rb

@@ -27,7 +27,7 @@ module Babl
                 Utils::Hash::EMPTY
             end
 
-            def render(_context, frame)
+            def render(frame)
                 frame.object
             end
 

data/lib/babl/nodes/is_null.rb

@@ -20,7 +20,7 @@ module Babl
                 Utils::Hash::EMPTY
             end
 
-            def render(_context, frame)
+            def render(frame)
                 ::NilClass === frame.object
             end
 

data/lib/babl/nodes/merge.rb

@@ -19,10 +19,10 @@ module Babl
                 nodes.map(&:schema).reduce(Schema::Object::EMPTY) { |a, b| merge_doc(a, b) }
             end
 
-            def render(context, frame)
-                nodes.map { |node| node.render(context, frame) }.compact.reduce({}) { |acc, val|
+            def render(frame)
+                nodes.map { |node| node.render(frame) }.compact.reduce({}) { |acc, val|
                     raise Errors::RenderingError, "Only objects can be merged\n" +
-                        context.formatted_stack(frame) unless ::Hash === val
+                        frame.formatted_stack unless ::Hash === val
                     acc.merge!(val)
                 }
             end

data/lib/babl/nodes/nav.rb

@@ -24,16 +24,16 @@ module Babl
                 node.pinned_dependencies
             end
 
-            def render(context, frame)
+            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" + context.formatted_stack(frame, property), e.backtrace
+                    raise Errors::RenderingError, "#{e.message}\n" + frame.formatted_stack(property), e.backtrace
                 end
 
-                context.move_forward(frame, value, property) do |new_frame|
-                    node.render(context, new_frame)
+                frame.move_forward(value, property) do |new_frame|
+                    node.render(new_frame)
                 end
             end
 

data/lib/babl/nodes/object.rb

@@ -22,9 +22,9 @@ module Babl
                 Schema::Object.new(properties, false)
             end
 
-            def render(context, frame)
+            def render(frame)
                 out = {}
-                nodes.each { |k, v| out[k] = v.render(context, frame) }
+                nodes.each { |k, v| out[k] = v.render(frame) }
                 out
             end
 

data/lib/babl/nodes/parent.rb

@@ -7,30 +7,6 @@ module Babl
         class Parent < Utils::Value.new(:node)
             PARENT_MARKER = Utils::Ref.new
 
-            class Verifier < Utils::Value.new(:node)
-                def dependencies
-                    deps = node.dependencies
-                    raise Errors::InvalidTemplate, 'Out of context parent dependency' if deps.key? PARENT_MARKER
-                    deps
-                end
-
-                def schema
-                    node.schema
-                end
-
-                def pinned_dependencies
-                    node.pinned_dependencies
-                end
-
-                def render(context, frame)
-                    node.render(context, frame)
-                end
-
-                def optimize
-                    Verifier.new(node.optimize)
-                end
-            end
-
             def schema
                 node.schema
             end
@@ -43,9 +19,9 @@ module Babl
                 { PARENT_MARKER => node.dependencies }
             end
 
-            def render(context, frame)
-                context.move_backward(frame) do |new_frame|
-                    node.render(context, new_frame)
+            def render(frame)
+                frame.move_backward do |new_frame|
+                    node.render(new_frame)
                 end
             end
 

data/lib/babl/nodes/switch.rb

@@ -27,8 +27,8 @@ module Babl
                 Schema::AnyOf.canonicalized(nodes.map(&:last).map(&:schema))
             end
 
-            def render(context, frame)
-                nodes.each { |cond, value| return value.render(context, frame) if cond.render(context, frame) }
+            def render(frame)
+                nodes.each { |cond, value| return value.render(frame) if cond.render(frame) }
                 raise Errors::RenderingError, 'A least one switch() condition must be taken'
             end
 

data/lib/babl/nodes/terminal_value.rb

@@ -24,10 +24,10 @@ module Babl
                 Utils::Hash::EMPTY
             end
 
-            def render(context, frame)
+            def render(frame)
                 render_object(frame.object)
             rescue TerminalValueError => e
-                raise Errors::RenderingError, "#{e.message}\n" + context.formatted_stack(frame, e.babl_stack), e.backtrace
+                raise Errors::RenderingError, "#{e.message}\n" + frame.formatted_stack(e.babl_stack), e.backtrace
             end
 
             def render_object(obj, stack = nil)

data/lib/babl/nodes/typed.rb

@@ -28,13 +28,13 @@ module Babl
                     Schema::Typed::STRING
                 end
 
-                def render(context, frame)
+                def render(frame)
                     value = frame.object
                     return value if ::String === value
                     return value.to_s if ::Symbol === value
 
                     raise Errors::RenderingError,
-                        "Expected a string, got #{value.inspect}\n#{context.formatted_stack(frame)}"
+                        "Expected a string, got #{value.inspect}\n#{frame.formatted_stack}"
                 end
             end
 
@@ -43,12 +43,12 @@ module Babl
                     Schema::Typed::INTEGER
                 end
 
-                def render(context, frame)
+                def render(frame)
                     value = frame.object
                     return value if ::Integer === value
 
                     raise Errors::RenderingError,
-                        "Expected an integer, got #{value.inspect}\n#{context.formatted_stack(frame)}"
+                        "Expected an integer, got #{value.inspect}\n#{frame.formatted_stack}"
                 end
             end
 
@@ -57,13 +57,13 @@ module Babl
                     Schema::Typed::NUMBER
                 end
 
-                def render(context, frame)
+                def render(frame)
                     value = frame.object
                     return value if ::Integer === value
                     return value.to_f if ::Numeric === value
 
                     raise Errors::RenderingError,
-                        "Expected a number, got #{value.inspect}\n#{context.formatted_stack(frame)}"
+                        "Expected a number, got #{value.inspect}\n#{frame.formatted_stack}"
                 end
             end
 
@@ -72,12 +72,12 @@ module Babl
                     Schema::Typed::BOOLEAN
                 end
 
-                def render(context, frame)
+                def render(frame)
                     value = frame.object
                     return value if true == value || false == value
 
                     raise Errors::RenderingError,
-                        "Expected a boolean, got #{value.inspect}\n#{context.formatted_stack(frame)}"
+                        "Expected a boolean, got #{value.inspect}\n#{frame.formatted_stack}"
                 end
             end
         end

data/lib/babl/nodes/with.rb

@@ -23,16 +23,16 @@ module Babl
                     .reduce(Utils::Hash::EMPTY) { |a, b| Babl::Utils::Hash.deep_merge(a, b) }
             end
 
-            def render(context, frame)
-                values = nodes.map { |n| n.render(context, frame) }
+            def render(frame)
+                values = nodes.map { |n| n.render(frame) }
                 value = begin
                     block.arity.zero? ? frame.object.instance_exec(&block) : block.call(*values)
                 rescue StandardError => e
-                    raise Errors::RenderingError, "#{e.message}\n" + context.formatted_stack(frame, :__block__), e.backtrace
+                    raise Errors::RenderingError, "#{e.message}\n" + frame.formatted_stack(:__block__), e.backtrace
                 end
 
-                context.move_forward(frame, value, :__block__) do |new_frame|
-                    node.render(context, new_frame)
+                frame.move_forward(value, :__block__) do |new_frame|
+                    node.render(new_frame)
                 end
             end
 

data/lib/babl/operators/parent.rb

@@ -12,9 +12,11 @@ module Babl
 
                 protected
 
-                # Override TemplateBase#precompile to add parent dependencies verification
-                def precompile(*)
-                    Nodes::Parent::Verifier.new(super)
+                def validate(tree)
+                    if tree.dependencies.key? Nodes::Parent::PARENT_MARKER
+                        raise Errors::InvalidTemplate, 'Out of context parent dependency'
+                    end
+                    super
                 end
             end
         end

data/lib/babl/operators/pin.rb

@@ -8,25 +8,31 @@ module Babl
         module Pin
             module DSL
                 # Create a pin
-                def pin(navigation = nil, &block)
-                    return pin { |p| block[p.call(navigation)] } if navigation
+                def pin(navigation = unscoped, &block)
                     ref = Utils::Ref.new
+                    named_pin(ref).call(block[unscoped.goto_pin(ref).call(navigation)])
+                end
 
-                    referenced_scope = unscoped.construct_node(key: nil, continue: nil) { |node|
-                        Nodes::GotoPin.new(node, ref)
-                    }
-
+                def named_pin(ref)
+                    check_pin_ref(ref)
                     construct_node(continue: nil) { |node| Nodes::CreatePin.new(node, ref) }
-                        .call(block[referenced_scope])
+                end
+
+                def goto_pin(ref)
+                    check_pin_ref(ref)
+                    construct_node(key: nil, continue: nil) { |node| Nodes::GotoPin.new(node, ref) }
                 end
 
                 protected
 
-                # Override TemplateBase#precompile to ensure that all pin dependencies are satisfied.
-                def precompile(*)
-                    super.tap do |node|
-                        raise Errors::InvalidTemplate, 'Unresolved pin' unless node.pinned_dependencies.empty?
-                    end
+                def validate(tree)
+                    name = tree.pinned_dependencies.keys.first
+                    raise Errors::InvalidTemplate, "Unresolved pin: #{name}" if name
+                    super
+                end
+
+                def check_pin_ref(ref)
+                    raise Errors::InvalidTemplate, 'Pin name must be a symbol' unless Utils::Ref === ref || ::Symbol === ref
                 end
             end
         end

data/lib/babl/railtie.rb

@@ -18,23 +18,28 @@ module Babl
 
                 def cached_call(template)
                     cached_templates[template.identifier] ||= Babl.compile {
-                        source(template.source, template.identifier)
+                        pin { |root|
+                            nav(:context).named_pin(:rails_context).call(root.nav(:locals))
+                                .source(template.source, template.identifier)
+                        }
                     }
 
                     <<-RUBY
                         compiled = ::Babl::ActionView::TemplateHandler.cached_templates[#{template.identifier.inspect}]
-                        compiled.json(local_assigns)
+                        compiled.json(locals: local_assigns, context: self)
                     RUBY
                 end
 
                 def uncached_call(template)
                     <<-RUBY
                         Babl.compile {
-                            source(
+                            pin do |root|
+                                nav(:context).named_pin(:rails_context).call(root.nav(:locals)).source(
                                 #{template.source.inspect},
                                 #{template.identifier.inspect}
-                            )
-                        }.json(local_assigns)
+                                )
+                            end
+                        }.json(locals: local_assigns, context: self)
                     RUBY
                 end
             end

data/lib/babl/rendering/compiled_template.rb

@@ -13,9 +13,9 @@ module Babl
 
             def render(root)
                 preloaded_data = preloader.preload([root], dependencies).first
-                context = Context.new
-                frame = Context::Frame.new(preloaded_data)
-                node.render(context, frame)
+                frame = Context.new
+                frame.object = preloaded_data
+                node.render(frame)
             end
         end
     end

data/lib/babl/rendering/context.rb

@@ -5,86 +5,79 @@ require 'babl/utils'
 module Babl
     module Rendering
         class Context
-            class Frame
-                attr_accessor :object, :key, :parent, :pins
+            attr_accessor :object, :key, :parent, :pins, :freelist
 
-                def initialize(object = nil)
-                    @object = object
-                end
+            def initialize(freelist = [])
+                @freelist = freelist
             end
 
-            def initialize
-                @freelist = []
-            end
+            def move_forward(new_object, key)
+                new_frame = @freelist.pop || Context.new(freelist)
 
-            def move_forward(current_frame, new_object, key)
-                with_frame do |new_frame|
-                    new_frame.object = new_object
-                    new_frame.key = key
-                    new_frame.parent = current_frame
-                    new_frame.pins = current_frame.pins
+                new_frame.object = new_object
+                new_frame.key = key
+                new_frame.parent = self
+                new_frame.pins = pins
 
-                    yield new_frame
-                end
+                yield new_frame
+            ensure
+                @freelist << new_frame
             end
 
-            def move_backward(current_frame)
-                with_frame do |new_frame|
-                    parent_frame = current_frame.parent
-                    raise Errors::RenderingError, 'There is no parent element' unless parent_frame
+            def move_backward
+                new_frame = @freelist.pop || Context.new(freelist)
+
+                parent_frame = parent
+                raise Errors::RenderingError, 'There is no parent element' unless parent_frame
 
-                    new_frame.object = parent_frame.object
-                    new_frame.parent = parent_frame.parent
-                    new_frame.key = parent_frame.key
-                    new_frame.pins = current_frame.pins
+                new_frame.object = parent_frame.object
+                new_frame.parent = parent_frame.parent
+                new_frame.key = parent_frame.key
+                new_frame.pins = pins
 
-                    yield new_frame
-                end
+                yield new_frame
+            ensure
+                @freelist << new_frame
             end
 
-            def goto_pin(current_frame, ref)
-                current_pins = current_frame.pins || Utils::Hash::EMPTY
+            def goto_pin(ref)
+                current_pins = pins || Utils::Hash::EMPTY
                 pin_frame = current_pins[ref]
                 raise Errors::RenderingError, 'Pin reference cannot be used here' unless pin_frame
 
-                with_frame do |new_frame|
-                    new_frame.object = pin_frame.object
-                    new_frame.parent = pin_frame.parent
-                    new_frame.key = pin_frame.key
-                    new_frame.pins = (pin_frame.pins || Utils::Hash::EMPTY).merge(current_pins)
+                new_frame = @freelist.pop || Context.new(freelist)
+
+                new_frame.object = pin_frame.object
+                new_frame.parent = pin_frame.parent
+                new_frame.key = pin_frame.key
+                new_frame.pins = (pin_frame.pins || Utils::Hash::EMPTY).merge(current_pins)
 
-                    yield new_frame
-                end
+                yield new_frame
+            ensure
+                @freelist << new_frame
             end
 
-            def create_pin(current_frame, ref)
-                with_frame do |new_frame|
-                    new_frame.parent = current_frame.parent
-                    new_frame.object = current_frame.object
-                    new_frame.key = current_frame.key
-                    new_frame.pins = (current_frame.pins || Utils::Hash::EMPTY).merge(ref => new_frame)
+            def create_pin(ref)
+                new_frame = @freelist.pop || Context.new(freelist)
 
-                    yield new_frame
-                end
-            end
+                new_frame.parent = parent
+                new_frame.object = object
+                new_frame.key = key
+                new_frame.pins = (pins || Utils::Hash::EMPTY).merge(ref => new_frame)
 
-            def stack(current_frame)
-                parent_frame = current_frame.parent
-                (parent_frame ? stack(parent_frame) : Utils::Array::EMPTY) + [current_frame.key].compact
+                yield new_frame
+            ensure
+                @freelist << new_frame
             end
 
-            def formatted_stack(current_frame, *additional_stack_items)
-                stack_trace = ([:__root__] + stack(current_frame) + additional_stack_items).join('.')
-                "BABL @ #{stack_trace}"
+            def stack
+                parent_frame = parent
+                (parent_frame ? parent_frame.stack : Utils::Array::EMPTY) + [key].compact
             end
 
-            private
-
-            def with_frame
-                frame = @freelist.pop || Frame.new
-                yield frame
-            ensure
-                @freelist << frame
+            def formatted_stack(*additional_stack_items)
+                stack_trace = ([:__root__] + stack + additional_stack_items).join('.')
+                "BABL @ #{stack_trace}"
             end
         end
     end

data/lib/babl/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: babl-json
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.5.4
 platform: ruby
 authors:
 - Frederic Terrazzoni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-24 00:00:00.000000000 Z
+date: 2018-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coveralls