babl-json 0.5.2 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f5116d890ae716b94f6fcb09fd90591313beb68d
-  data.tar.gz: 4bba953360594c5f46ad6160870a2ab469a932af
+  metadata.gz: 14b097a0829fb4d3a127ec290a6768576c9d20ed
+  data.tar.gz: 4753dead38682900489fff11c25abd23e72d1515
 SHA512:
-  metadata.gz: 4467e3975a1f2f3130f68dc8fed5327b608838f2bcf8eebe61fae29fd5608ecc9de328192a2a2c5797ad54cce7ea68b6e9dc684c7c11ccf1c4a479f0147c54b9
-  data.tar.gz: effc3f204316f2d67f0e74a8f6704fedae840b03ff41129697316c06f169d3a7363a2ccd3f0bfa9042f9398e5fe450b209290d7a1b7c38b1620aff426d086634
+  metadata.gz: '0809d686259d83c42c7053e049427767216ca3be7282f3a427a45125a7fc5f8e848b6b20771a700cea70a9684663eb9cf209c22128b9e33744d27e00f9944928'
+  data.tar.gz: 5f5eff014fd6ea456a1518c6a9dbf3681be309b414ad5f306ea5005cf011c2b001177b836c6b3bbcc18658bbbf5581b7bbb85abf9336fb6dc96b802c35facd3a

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(ctx)
+            def render(context, frame)
                 out = []
                 nodes.each { |node|
-                    values = node.render(ctx)
+                    values = node.render(context, frame)
                     case values
                     when ::NilClass then nil
                     when ::Array then out.concat(values)
-                    else raise Errors::RenderingError, "Only arrays can be concatenated\n" + ctx.formatted_stack
+                    else raise Errors::RenderingError, "Only arrays can be concatenated\n" + context.formatted_stack(frame)
                     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(_ctx)
+            def render(_context, _frame)
                 value
             end
 

data/lib/babl/nodes/create_pin.rb

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

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(ctx)
-                node.render(ctx)
+            def render(context, frame)
+                node.render(context, frame)
             end
 
             def schema

data/lib/babl/nodes/each.rb

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

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(ctx)
-                nodes.map { |node| node.render(ctx) }
+            def render(context, frame)
+                nodes.map { |node| node.render(context, frame) }
             end
 
             def optimize

data/lib/babl/nodes/goto_pin.rb

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

data/lib/babl/nodes/internal_value.rb

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

data/lib/babl/nodes/is_null.rb

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

data/lib/babl/nodes/merge.rb

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

data/lib/babl/nodes/nav.rb

@@ -24,13 +24,17 @@ module Babl
                 node.pinned_dependencies
             end
 
-            def render(ctx)
+            def render(context, frame)
                 value = begin
-                    ::Hash === ctx.object ? ctx.object.fetch(property) : ctx.object.send(property)
+                    object = frame.object
+                    ::Hash === object ? object.fetch(property) : object.send(property)
                 rescue StandardError => e
-                    raise Errors::RenderingError, "#{e.message}\n" + ctx.formatted_stack(property), e.backtrace
+                    raise Errors::RenderingError, "#{e.message}\n" + context.formatted_stack(frame, property), e.backtrace
+                end
+
+                context.move_forward(frame, value, property) do |new_frame|
+                    node.render(context, new_frame)
                 end
-                node.render(ctx.move_forward(value, property))
             end
 
             def optimize

data/lib/babl/nodes/object.rb

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

data/lib/babl/nodes/parent.rb

@@ -22,8 +22,8 @@ module Babl
                     node.pinned_dependencies
                 end
 
-                def render(ctx)
-                    node.render(ctx)
+                def render(context, frame)
+                    node.render(context, frame)
                 end
 
                 def optimize
@@ -43,8 +43,10 @@ module Babl
                 { PARENT_MARKER => node.dependencies }
             end
 
-            def render(ctx)
-                node.render(ctx.move_backward)
+            def render(context, frame)
+                context.move_backward(frame) do |new_frame|
+                    node.render(context, new_frame)
+                end
             end
 
             def optimize

data/lib/babl/nodes/switch.rb

@@ -27,8 +27,8 @@ module Babl
                 Schema::AnyOf.canonicalized(nodes.map(&:last).map(&:schema))
             end
 
-            def render(ctx)
-                nodes.each { |cond, value| return value.render(ctx) if cond.render(ctx) }
+            def render(context, frame)
+                nodes.each { |cond, value| return value.render(context, frame) if cond.render(context, 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(ctx)
-                render_object(ctx.object)
+            def render(context, frame)
+                render_object(frame.object)
             rescue TerminalValueError => e
-                raise Errors::RenderingError, "#{e.message}\n" + ctx.formatted_stack(e.babl_stack), e.backtrace
+                raise Errors::RenderingError, "#{e.message}\n" + context.formatted_stack(frame, e.babl_stack), e.backtrace
             end
 
             def render_object(obj, stack = nil)
@@ -37,7 +37,7 @@ module Babl
                 when ::Symbol then obj.to_s
                 when ::Hash then render_hash(obj, stack || [])
                 when ::Array then render_array(obj, stack || [])
-                else raise TerminalValueError.new("Only primitives can be serialized: #{obj}", stack || [])
+                else raise TerminalValueError.new("Only primitives can be serialized: #{obj.inspect}", stack || [])
                 end
             end
 
@@ -76,7 +76,7 @@ module Babl
                 when ::FalseClass then :false
                 # rubocop:enable Lint/BooleanSymbol
                 when ::Numeric, ::NilClass then :"#{key}"
-                else raise TerminalValueError.new("Invalid key for JSON object: #{key}", stack)
+                else raise TerminalValueError.new("Invalid key for JSON object: #{key.inspect}", stack)
                 end
             end
 

data/lib/babl/nodes/typed.rb

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

data/lib/babl/nodes/with.rb

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

data/lib/babl/rendering/compiled_template.rb

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

data/lib/babl/rendering/context.rb

@@ -4,54 +4,87 @@ require 'babl/utils'
 
 module Babl
     module Rendering
-        # The rendering context stores the 'current' object.
-        # Additionally, the context also:
-        # - Keep a reference to the parent context, in order to implement the parent operation (Parent)
-        # - Keep a reference to all pinned contexts, in order to goto a pinned context at any time (GotoPin)
-        #
-        # It is important to keep this object as small as possible, since an instance is created each time
-        # we navigate into a property.
         class Context
-            attr_reader :key, :object, :parent, :pins
+            class Frame
+                attr_accessor :object, :key, :parent, :pins
 
-            def initialize(object, key = nil, parent = nil, pins = nil)
-                @key = key
-                @object = object
-                @parent = parent
-                @pins = pins
+                def initialize(object = nil)
+                    @object = object
+                end
             end
 
-            # Standard navigation (enter into property)
-            def move_forward(new_object, key)
-                Context.new(new_object, key, self, pins)
+            def initialize
+                @freelist = []
             end
 
-            # Go back to parent
-            def move_backward
-                raise Errors::RenderingError, 'There is no parent element' unless parent
-                Context.new(parent.object, parent.key, parent.parent, pins)
+            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
+
+                    yield new_frame
+                end
             end
 
-            # Go to a pinned context
-            def goto_pin(ref)
-                pin = pins&.[](ref)
-                raise Errors::RenderingError, 'Pin reference cannot be used here' unless pin
-                Context.new(pin.object, pin.key, pin.parent, (pin.pins || Utils::Hash::EMPTY).merge(pins))
+            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
+
+                    new_frame.object = parent_frame.object
+                    new_frame.parent = parent_frame.parent
+                    new_frame.key = parent_frame.key
+                    new_frame.pins = current_frame.pins
+
+                    yield new_frame
+                end
             end
 
-            # Associate a pin to current context
-            def create_pin(ref)
-                Context.new(object, key, parent, (pins || Utils::Hash::EMPTY).merge(ref => self))
+            def goto_pin(current_frame, ref)
+                current_pins = current_frame.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)
+
+                    yield new_frame
+                end
             end
 
-            def formatted_stack(*additional_stack_items)
-                stack_trace = ([:__root__] + stack + additional_stack_items).join('.')
+            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)
+
+                    yield new_frame
+                end
+            end
+
+            def stack(current_frame)
+                parent_frame = current_frame.parent
+                (parent_frame ? stack(parent_frame) : Utils::Array::EMPTY) + [current_frame.key].compact
+            end
+
+            def formatted_stack(current_frame, *additional_stack_items)
+                stack_trace = ([:__root__] + stack(current_frame) + additional_stack_items).join('.')
                 "BABL @ #{stack_trace}"
             end
 
-            # Return an array containing the navigation history
-            def stack
-                (parent ? parent.stack : Utils::Array::EMPTY) + [key].compact
+            private
+
+            def with_frame
+                frame = @freelist.pop || Frame.new
+                yield frame
+            ensure
+                @freelist << frame
             end
         end
     end

data/lib/babl/version.rb

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

metadata

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