babl-json 0.1.1

data/lib/babl/builder/template_base.rb

@@ -0,0 +1,37 @@
+module Babl
+    module Builder
+        # TemplateBase is a thin wrapper around Builder.
+        #
+        # Since the BABL code is run via #instance_eval within an instance of this class, we want to
+        # define as few methods as possible here.
+        class TemplateBase
+            def initialize(builder = ChainBuilder.new(&:itself))
+                @builder = builder
+            end
+
+            def compile(**options)
+                Rendering::CompiledTemplate.new(precompile, **options)
+            end
+
+            protected
+
+            def unscoped
+                self.class.new builder.rescope(&:itself)
+            end
+
+            def precompile
+                builder.precompile(Babl::Rendering::TerminalValueNode.instance)
+            end
+
+            def construct_node(**new_context, &block)
+                self.class.new builder.construct_node(**new_context, &block)
+            end
+
+            def construct_terminal(&block)
+                self.class.new builder.construct_terminal(&block)
+            end
+
+            attr_reader :builder
+        end
+    end
+end

data/lib/babl/operators/array.rb

@@ -0,0 +1,42 @@
+module Babl
+    module Operators
+        module Array
+            module DSL
+                # Produce an fixed-size array, using the provided templates to populate its elements.
+                def array(*templates)
+                    construct_terminal { |ctx|
+                        FixedArrayNode.new(templates.map { |t|
+                            unscoped.call(t).builder.precompile(Rendering::TerminalValueNode.instance, ctx.merge(continue: nil))
+                        })
+                    }
+                end
+            end
+
+            class FixedArrayNode
+                def initialize(nodes)
+                    @nodes = nodes
+                end
+
+                def documentation
+                    nodes.map(&:documentation)
+                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 render(ctx)
+                    nodes.map { |node| node.render(ctx) }
+                end
+
+                private
+
+                attr_reader :nodes
+            end
+        end
+    end
+end

data/lib/babl/operators/call.rb

@@ -0,0 +1,25 @@
+module Babl
+    module Operators
+        module Call
+            module DSL
+                # Interpret whatever is passed to this method as BABL template. It is idempotent.
+                def call(*args, &block)
+                    return with(*args, &block) unless block.nil?
+                    raise ::Babl::InvalidTemplateError, 'call() expects exactly 1 argument (unless block)' unless args.size == 1
+
+                    arg = args.first
+
+                    case arg
+                    when self.class then self.class.new(builder.wrap { |bound| arg.builder.bind(bound) })
+                    when ::Symbol then nav(arg)
+                    when ::Proc then call(&arg)
+                    when ::Hash then object(**arg.map { |k, v| [k.to_s.to_sym, v] }.to_h)
+                    when ::Array then array(*arg)
+                    when ::String, ::Numeric, ::NilClass, ::TrueClass, ::FalseClass then unscoped.static(arg)
+                    else raise ::Babl::InvalidTemplateError, "call() received invalid argument: #{arg}"
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/babl/operators/dep.rb

@@ -0,0 +1,48 @@
+module Babl
+    module Operators
+        module Dep
+            module DSL
+                # Declare dependencies as if they were generated by nav()
+                # but without navigating.
+                def dep(*path)
+                    construct_node(continue: nil) { |node| DepNode.new(node, path) }
+                end
+            end
+
+            class DepNode
+                def initialize(node, path)
+                    @node = node
+                    @path = canonicalize(path)
+                end
+
+                def render(ctx)
+                    node.render(ctx)
+                end
+
+                def documentation
+                    node.documentation
+                end
+
+                def pinned_dependencies
+                    node.pinned_dependencies
+                end
+
+                def dependencies
+                    Babl::Utils::Hash.deep_merge(node.dependencies, path)
+                end
+
+                private
+
+                def canonicalize(path)
+                    case path
+                    when ::Array then path.reduce({}) { |a, p| a.merge(canonicalize(p)) }
+                    when ::Hash then path.map { |k, v| [k.to_sym, canonicalize(v)] }.to_h
+                    else { path.to_sym => {} }
+                    end
+                end
+
+                attr_reader :node, :path
+            end
+        end
+    end
+end

data/lib/babl/operators/each.rb

@@ -0,0 +1,45 @@
+module Babl
+    module Operators
+        module Each
+            module DSL
+                # 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| EachNode.new(node) }
+                end
+            end
+
+            class EachNode
+                def initialize(node)
+                    @node = node
+                end
+
+                def dependencies
+                    { __each__: node.dependencies }
+                end
+
+                def documentation
+                    [node.documentation]
+                end
+
+                def pinned_dependencies
+                    node.pinned_dependencies
+                end
+
+                def render(ctx)
+                    collection = ctx.object
+
+                    unless collection.is_a?(Enumerable)
+                        raise RenderingError, "Object is not enumerable : #{collection.inspect}"
+                    end
+
+                    collection.each_with_index.map { |value, idx| node.render(ctx.move_forward(value, idx)) }
+                end
+
+                private
+
+                attr_reader :node
+            end
+        end
+    end
+end

data/lib/babl/operators/enter.rb

@@ -0,0 +1,22 @@
+module Babl
+    module Operators
+        module Enter
+            module DSL
+                # Navigate to a named property of current element. The name
+                # is inferred based on the object()
+                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)
+                    }
+                end
+
+                # Simple convenience alias
+                def _
+                    enter
+                end
+            end
+        end
+    end
+end

data/lib/babl/operators/merge.rb

@@ -0,0 +1,49 @@
+module Babl
+    module Operators
+        module Merge
+            module DSL
+                # Merge multiple JSON objects (non-deep)
+                def merge(*templates)
+                    construct_terminal { |context|
+                        MergeNode.new(
+                            templates.map { |t|
+                                unscoped.call(t).builder.precompile(
+                                    Rendering::TerminalValueNode.instance,
+                                    context.merge(continue: nil)
+                                )
+                            }
+                        )
+                    }
+                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

@@ -0,0 +1,55 @@
+module Babl
+    module Operators
+        module Nav
+            module DSL
+                # Navigate to a named property of the current element
+                # Multiple properties can be chained
+                #
+                # A block can also be passed, but in that case, dependency tracking
+                # 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 })
+                    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
+                end
+            end
+        end
+    end
+end

data/lib/babl/operators/nullable.rb

@@ -0,0 +1,16 @@
+module Babl
+    module Operators
+        module Nullable
+            module DSL
+                # Nullify the current construction if
+                # the current element is Nil.
+                def nullable
+                    switch(
+                        unscoped.nav(&:nil?) => nil,
+                        unscoped.default => unscoped.continue
+                    )
+                end
+            end
+        end
+    end
+end

data/lib/babl/operators/object.rb

@@ -0,0 +1,55 @@
+module Babl
+    module Operators
+        module Object
+            module DSL
+                # 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
+                    end
+
+                    construct_terminal { |ctx|
+                        nodes = attrs
+                            .map { |name| [name.to_sym, unscoped.enter] }.to_h
+                            .merge(nested)
+                            .map { |k, v|
+                                [k, unscoped.call(v).builder.precompile(
+                                    Rendering::TerminalValueNode.instance,
+                                    ctx.merge(key: k, continue: nil)
+                                )]
+                            }
+                            .to_h
+
+                        ObjectNode.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

@@ -0,0 +1,90 @@
+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) }
+                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)
+                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
+end