babl-json 0.1.4 → 0.2.0

data/lib/babl/operators/enter.rb

@@ -1,3 +1,5 @@
+require 'babl/errors'
+
 module Babl
     module Operators
         module Enter
@@ -7,8 +9,8 @@ module Babl
                 def enter
                     construct_node(key: nil, continue: nil) { |node, context|
                         key = context[:key]
-                        raise InvalidTemplateError, "No key to enter into" unless key
-                        Nav::NavNode.new(key, node)
+                        raise Errors::InvalidTemplateError, "No key to enter into" unless key
+                        Nodes::Nav.new(key, node)
                     }
                 end
 

data/lib/babl/operators/extends.rb

@@ -3,7 +3,10 @@ module Babl
         module Extends
             module DSL
                 def extends(partial_path, *args)
-                    source { merge(partial(partial_path), *args) }
+                    source {
+                        partial_template = partial(partial_path)
+                        args.empty? ? partial_template : merge(partial_template, *args)
+                    }
                 end
             end
         end

data/lib/babl/operators/merge.rb

@@ -1,14 +1,19 @@
+require 'babl/nodes/merge'
+require 'babl/nodes/terminal_value'
+
 module Babl
     module Operators
         module Merge
             module DSL
                 # Merge multiple JSON objects (non-deep)
                 def merge(*templates)
+                    return call({}) if templates.empty?
+
                     construct_terminal { |context|
-                        MergeNode.new(
+                        Nodes::Merge.new(
                             templates.map { |t|
                                 unscoped.call(t).builder.precompile(
-                                    Rendering::TerminalValueNode.instance,
+                                    Nodes::TerminalValue.instance,
                                     context.merge(continue: nil)
                                 )
                             }
@@ -16,34 +21,6 @@ module Babl
                     }
                 end
             end
-
-            class MergeNode
-                def initialize(nodes)
-                    @nodes = nodes
-                end
-
-                def dependencies
-                    nodes.map(&:dependencies).reduce({}) { |a, b| Babl::Utils::Hash.deep_merge(a, b) }
-                end
-
-                def pinned_dependencies
-                    nodes.map(&:pinned_dependencies).reduce({}) { |a, b| Babl::Utils::Hash.deep_merge(a, b) }
-                end
-
-                def documentation
-                    nodes.map(&:documentation).each_with_index.map { |doc, idx|
-                        [:"Merge #{idx + 1}", doc]
-                    }.to_h
-                end
-
-                def render(ctx)
-                    nodes.map { |node| node.render(ctx) }.compact.reduce({}, :merge)
-                end
-
-                private
-
-                attr_reader :nodes
-            end
         end
     end
 end

data/lib/babl/operators/nav.rb

@@ -1,3 +1,5 @@
+require 'babl/nodes/nav'
+
 module Babl
     module Operators
         module Nav
@@ -12,42 +14,8 @@ module Babl
                         return (block ? with(unscoped, &block) : construct_node(key: nil, continue: nil) { |node| node })
                     end
 
-                    construct_node(key: nil, continue: nil) { |node| NavNode.new(path.first, node) }.nav(*path[1..-1], &block)
-                end
-            end
-
-            class NavNode
-                def initialize(through, node)
-                    @through = through
-                    @node = node
-                end
-
-                def dependencies
-                    { through => node.dependencies }
-                end
-
-                def documentation
-                    node.documentation
-                end
-
-                def pinned_dependencies
-                    node.pinned_dependencies
-                end
-
-                def render(ctx)
-                    node.render(ctx.move_forward_block(through) { navigate(ctx.object) })
-                end
-
-                private
-
-                attr_reader :through, :node
-
-                def navigate(object)
-                    if object.is_a?(Hash)
-                        object.fetch(through)
-                    else
-                        object.send(through)
-                    end
+                    construct_node(key: nil, continue: nil) { |node| Nodes::Nav.new(path.first, node) }
+                        .nav(*path[1..-1], &block)
                 end
             end
         end

data/lib/babl/operators/object.rb

@@ -1,3 +1,7 @@
+require 'babl/nodes/object'
+require 'babl/nodes/terminal_value'
+require 'babl/errors'
+
 module Babl
     module Operators
         module Object
@@ -5,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 ::Babl::InvalidTemplateError, "Duplicate key in object(): #{keys.first}" if keys.size > 1
+                        raise Errors::InvalidTemplateError, "Duplicate key in object(): #{keys.first}" if keys.size > 1
                     end
 
                     construct_terminal { |ctx|
@@ -14,42 +18,16 @@ module Babl
                             .merge(nested)
                             .map { |k, v|
                                 [k, unscoped.call(v).builder.precompile(
-                                    Rendering::TerminalValueNode.instance,
+                                    Nodes::TerminalValue.instance,
                                     ctx.merge(key: k, continue: nil)
                                 )]
                             }
                             .to_h
 
-                        ObjectNode.new(nodes)
+                        Nodes::Object.new(nodes)
                     }
                 end
             end
-
-            class ObjectNode
-                def initialize(nodes)
-                    @nodes = nodes
-                end
-
-                def dependencies
-                    nodes.values.map(&:dependencies).reduce({}) { |a, b| Babl::Utils::Hash.deep_merge(a, b) }
-                end
-
-                def pinned_dependencies
-                    nodes.values.map(&:pinned_dependencies).reduce({}) { |a, b| Babl::Utils::Hash.deep_merge(a, b) }
-                end
-
-                def documentation
-                    nodes.map { |k, v| [k, v.documentation] }.to_h
-                end
-
-                def render(ctx)
-                    nodes.map { |k, v| [k, v.render(ctx)] }.to_h
-                end
-
-                private
-
-                attr_reader :nodes
-            end
         end
     end
 end

data/lib/babl/operators/parent.rb

@@ -1,89 +1,20 @@
+require 'babl/nodes/parent'
+
 module Babl
     module Operators
         module Parent
-            PARENT = ::Object.new
-
             module DSL
                 # Navigate to the parent of the current object.
                 def parent
-                    construct_node(key: nil, continue: nil) { |node| ParentNode.new(node) }
+                    construct_node(key: nil, continue: nil) { |node| Nodes::Parent.new(node) }
                 end
 
                 protected
 
                 # Override TemplateBase#precompile to add parent dependencies verification
                 def precompile
-                    ParentResolverNode.new(super)
-                end
-            end
-
-            class ParentResolverNode
-                def initialize(node)
-                    @node = node
-                end
-
-                def dependencies
-                    backpropagate_dependencies(node.dependencies)
-                end
-
-                def documentation
-                    node.documentation
-                end
-
-                def pinned_dependencies
-                    node.pinned_dependencies
-                end
-
-                def render(ctx)
-                    node.render(ctx)
-                end
-
-                private
-
-                attr_reader :node
-
-                def backpropagate_dependencies(deps)
-                    raise InvalidTemplateError, 'Out of context parent dependency' if deps.key? PARENT
-                    new_deps = backpropagate_dependencies_one_level(deps)
-                    deps == new_deps ? new_deps : backpropagate_dependencies(new_deps)
+                    Nodes::Parent::Resolver.new(super)
                 end
-
-                def backpropagate_dependencies_one_level(deps)
-                    deps.reduce({}) do |out, (k, v)|
-                        next out if k == PARENT
-
-                        Babl::Utils::Hash.deep_merge(
-                            Babl::Utils::Hash.deep_merge(out, k => backpropagate_dependencies_one_level(v)),
-                            v[PARENT] || {}
-                        )
-                    end
-                end
-            end
-
-            class ParentNode
-                def initialize(node)
-                    @node = node
-                end
-
-                def documentation
-                    node.documentation
-                end
-
-                def pinned_dependencies
-                    node.pinned_dependencies
-                end
-
-                def dependencies
-                    { PARENT => node.dependencies }
-                end
-
-                def render(ctx)
-                    node.render(ctx.move_backward)
-                end
-
-                private
-
-                attr_reader :node
             end
         end
     end

data/lib/babl/operators/partial.rb

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

data/lib/babl/operators/pin.rb

@@ -1,3 +1,8 @@
+require 'babl/nodes/create_pin'
+require 'babl/nodes/goto_pin'
+require 'babl/utils/ref'
+require 'babl/errors'
+
 module Babl
     module Operators
         module Pin
@@ -5,9 +10,14 @@ module Babl
                 # Create a pin
                 def pin(navigation = nil, &block)
                     return pin { |p| block[p.call(navigation)] } if navigation
-                    ref = ::Object.new
-                    referenced_scope = unscoped.construct_node(key: nil, continue: nil) { |node| GotoPinNode.new(node, ref) }
-                    construct_node(continue: nil) { |node| CreatePinNode.new(node, ref) }.call(block[referenced_scope])
+                    ref = Utils::Ref.new
+
+                    referenced_scope = unscoped.construct_node(key: nil, continue: nil) { |node|
+                        Nodes::GotoPin.new(node, ref)
+                    }
+
+                    construct_node(continue: nil) { |node| Nodes::CreatePin.new(node, ref) }
+                        .call(block[referenced_scope])
                 end
 
                 protected
@@ -15,64 +25,10 @@ module Babl
                 # Override TemplateBase#precompile to ensure that all pin dependencies are satisfied.
                 def precompile
                     super.tap do |node|
-                        raise Babl::InvalidTemplateError, 'Unresolved pin' unless node.pinned_dependencies.empty?
+                        raise Errors::InvalidTemplateError, 'Unresolved pin' unless node.pinned_dependencies.empty?
                     end
                 end
             end
-
-            class CreatePinNode
-                def initialize(node, ref)
-                    @node = node
-                    @ref = ref
-                end
-
-                def render(ctx)
-                    node.render(ctx.create_pin(ref))
-                end
-
-                def documentation
-                    node.documentation
-                end
-
-                def dependencies
-                    Babl::Utils::Hash.deep_merge(node.dependencies, node.pinned_dependencies[ref] || {})
-                end
-
-                def pinned_dependencies
-                    node.pinned_dependencies.reject { |k, _v| k == ref }
-                end
-
-                private
-
-                attr_reader :node, :ref
-            end
-
-            class GotoPinNode
-                def initialize(node, ref)
-                    @node = node
-                    @ref = ref
-                end
-
-                def dependencies
-                    {}
-                end
-
-                def pinned_dependencies
-                    Babl::Utils::Hash.deep_merge(node.pinned_dependencies, ref => node.dependencies)
-                end
-
-                def documentation
-                    node.documentation
-                end
-
-                def render(ctx)
-                    node.render(ctx.goto_pin(ref))
-                end
-
-                private
-
-                attr_reader :node, :ref
-            end
         end
     end
 end

data/lib/babl/operators/static.rb

@@ -1,39 +1,20 @@
+require 'babl/nodes/static'
+require 'babl/nodes/terminal_value'
+require 'babl/errors'
+
 module Babl
     module Operators
         module Static
             module DSL
                 # Create a static JSON value
-                def static(value)
-                    construct_terminal { StaticNode.new(value) }
-                end
-            end
-
-            class StaticNode
-                def initialize(value)
-                    @serialized_value = Rendering::TerminalValueNode.instance.render_object(value)
-                rescue Babl::RenderingError => exception
-                    raise Babl::InvalidTemplateError, exception.message
-                end
-
-                def documentation
-                    serialized_value
-                end
-
-                def render(_ctx)
-                    serialized_value
-                end
-
-                def dependencies
-                    {}
+                def static(val)
+                    case val
+                    when String, Numeric, NilClass, TrueClass, FalseClass then construct_terminal { Nodes::Static.new(val) }
+                    else call(Nodes::TerminalValue.instance.render_object(val))
+                    end
+                rescue Errors::RenderingError => exception
+                    raise Errors::InvalidTemplateError, exception.message
                 end
-
-                def pinned_dependencies
-                    {}
-                end
-
-                private
-
-                attr_reader :serialized_value
             end
         end
     end