babl-json 0.1.1

data/lib/babl/operators/partial.rb

@@ -0,0 +1,46 @@
+module Babl
+    module Operators
+        module Partial
+            module DSL
+                # 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
+
+                    path, source, partial_lookup_context = lookup_context.find(partial_name)
+                    raise InvalidTemplateError, "Cannot find partial '#{partial_name}'" unless path
+
+                    with_lookup_context(partial_lookup_context)
+                        .source(source, path, 0)
+                        .with_lookup_context(lookup_context)
+                end
+
+                def with_lookup_context(lookup_context)
+                    self.class.new(builder.dup.tap { |inst| inst.instance_variable_set(:@lookup_context, lookup_context) })
+                end
+
+                def lookup_context
+                    builder.instance_variable_get(:@lookup_context)
+                end
+            end
+
+            class AbsoluteLookupContext
+                attr_reader :search_path
+
+                def initialize(search_path)
+                    @search_path = search_path
+                    raise 'Invalid search path' unless search_path
+                end
+
+                def find(partial_name)
+                    query = File.join(search_path, "{#{partial_name}}{.babl,}")
+                    path = Dir[query].first
+                    return unless path
+
+                    source = File.read(path)
+                    [path, source, self]
+                end
+            end
+        end
+    end
+end

data/lib/babl/operators/pin.rb

@@ -0,0 +1,78 @@
+module Babl
+    module Operators
+        module Pin
+            module DSL
+                # 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])
+                end
+
+                protected
+
+                # 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?
+                    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/source.rb

@@ -0,0 +1,12 @@
+module Babl
+    module Operators
+        module Source
+            module DSL
+                # Parse BABL source into a Template
+                def source(*args, &block)
+                    call(unscoped.instance_eval(*args, &block))
+                end
+            end
+        end
+    end
+end

data/lib/babl/operators/static.rb

@@ -0,0 +1,40 @@
+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
+                    {}
+                end
+
+                def pinned_dependencies
+                    {}
+                end
+
+                private
+
+                attr_reader :serialized_value
+            end
+        end
+    end
+end

data/lib/babl/operators/switch.rb

@@ -0,0 +1,71 @@
+module Babl
+    module Operators
+        module Switch
+            module DSL
+                # To be used as a switch(...) condition. It is strictly equivalent to write 'true' instead,
+                # but convey more meaning.
+                def default
+                    unscoped.static(true)
+                end
+
+                # Return a special placeholder that can be used as a switch(...) value. It tells BABL to continue
+                # the evaluation of the original chain after switch().
+                def continue
+                    construct_terminal { |context|
+                        node = context[:continue]
+                        raise Babl::InvalidTemplateError, 'continue() cannot be used outside switch()' unless node
+                        node
+                    }
+                end
+
+                # Conditional switching
+                def switch(conds = {})
+                    construct_node(continue: nil) { |node, context|
+                        nodes = conds.map { |cond, value|
+                            cond_node = unscoped.call(cond).builder
+                                .precompile(Rendering::InternalValueNode.instance, context.merge(continue: nil))
+
+                            value_node = unscoped.call(value).builder
+                                .precompile(Rendering::TerminalValueNode.instance, context.merge(continue: node))
+
+                            [cond_node, value_node]
+                        }.to_h
+
+                        SwitchNode.new(nodes)
+                    }
+                end
+            end
+
+            class SwitchNode
+                def initialize(nodes)
+                    @nodes = nodes
+                end
+
+                def dependencies
+                    (nodes.values + nodes.keys).map(&:dependencies)
+                        .reduce({}) { |a, b| Babl::Utils::Hash.deep_merge(a, b) }
+                end
+
+                def pinned_dependencies
+                    (nodes.values + nodes.keys).map(&:pinned_dependencies)
+                        .reduce({}) { |a, b| Babl::Utils::Hash.deep_merge(a, b) }
+                end
+
+                def documentation
+                    (nodes.values).map(&:documentation).each_with_index.map { |doc, idx|
+                        [:"Case #{idx + 1}", doc]
+                    }.to_h
+                end
+
+                def render(ctx)
+                    nodes.each { |cond, value| return value.render(ctx) if cond.render(ctx) }
+                    raise Babl::RenderingError, 'A least one switch() condition must be taken'
+                end
+
+                private
+
+                attr_reader :nodes, :default_node
+            end
+        end
+    end
+end

data/lib/babl/operators/with.rb

@@ -0,0 +1,51 @@
+module Babl
+    module Operators
+        module With
+            module DSL
+                # Produce a value by calling the block, passing it the output value of the templates passed as argument.
+                def with(*templates, &block)
+                    construct_node(key: nil, continue: nil) do |node, context|
+                        WithNode.new(node, templates.map do |t|
+                            unscoped.call(t).builder.precompile(
+                                Rendering::InternalValueNode.instance,
+                                context.merge(continue: nil)
+                            )
+                        end, block)
+                    end
+                end
+            end
+
+            class WithNode
+                def initialize(node, nodes, block)
+                    @node = node
+                    @nodes = nodes
+                    @block = block
+                end
+
+                def documentation
+                    node.documentation
+                end
+
+                def dependencies
+                    # Dependencies of 'node' are explicitely ignored
+                    nodes.map(&:dependencies).reduce({}) { |a, b| Babl::Utils::Hash.deep_merge(a, b) }
+                end
+
+                def pinned_dependencies
+                    (nodes + [node]).map(&:pinned_dependencies).reduce({}) { |a, b| Babl::Utils::Hash.deep_merge(a, b) }
+                end
+
+                def render(ctx)
+                    values = nodes.map { |n| n.render(ctx) }
+                    node.render(ctx.move_forward_block(:__block__) do
+                        block.arity.zero? ? ctx.object.instance_exec(&block) : block.call(*values)
+                    end)
+                end
+
+                private
+
+                attr_reader :node, :nodes, :block
+            end
+        end
+    end
+end

data/lib/babl/railtie.rb

@@ -0,0 +1,29 @@
+module Babl
+    module ActionView
+        module Template
+            class Handler
+                class_attribute :default_format
+                self.default_format = Mime[:json]
+
+                def self.call(template)
+                    # This implementation is not efficient: it will recompile the BABL template
+                    # for each request. I still don't get why Rails template handlers MUST
+                    # return Ruby code ?! Sucks too much. Ideally, we would like to keep the compiled
+                    # template somewhere. However, I've not yet measured how much like is wasted.
+                    # Maybe it is negligible ?
+                    <<~RUBY
+                        ::Babl.compile { #{template.source} }.json(local_assigns)
+                    RUBY
+                end
+            end
+        end
+    end
+
+    class Railtie < Rails::Railtie
+        initializer "babl.initialize" do
+            ActiveSupport.on_load(:action_view) do
+                ::ActionView::Template.register_template_handler(:babl, ::Babl::ActionView::Template::Handler)
+            end
+        end
+    end
+end

data/lib/babl/rendering/compiled_template.rb

@@ -0,0 +1,28 @@
+require 'oj'
+
+module Babl
+    module Rendering
+        class CompiledTemplate
+            attr_reader :node, :dependencies, :documentation, :preloader, :pretty
+
+            def initialize(node, preloader: NoopPreloader, pretty: true)
+                @node = node
+                @dependencies = node.dependencies
+                @documentation = node.documentation
+                @preloader = preloader
+                @pretty = pretty
+            end
+
+            def json(root)
+                data = render(root)
+                Oj.dump(data, indent: pretty ? 4 : 0, mode: :strict)
+            end
+
+            def render(root)
+                preloaded_data = preloader.preload([root], dependencies).first
+                ctx = Babl::Rendering::Context.new(preloaded_data)
+                node.render(ctx)
+            end
+        end
+    end
+end

data/lib/babl/rendering/context.rb

@@ -0,0 +1,60 @@
+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 (ParentNode)
+        # - Keep a reference to all pinned contexts, in order to goto a pinned context at any time (GotoPinNode)
+        #
+        # 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
+
+            def initialize(object, key = nil, parent = nil, pins = nil)
+                @key = key
+                @object = object
+                @parent = parent
+                @pins = pins
+            end
+
+            # Standard navigation (enter into property)
+            def move_forward(new_object, key)
+                Context.new(new_object, key, self, pins)
+            end
+
+            # Go back to parent
+            def move_backward
+                raise Babl::RenderingError, 'There is no parent element' unless parent
+                Context.new(parent.object, parent.key, parent.parent, pins)
+            end
+
+            # Go to a pinned context
+            def goto_pin(ref)
+                pin = pins&.[](ref)
+                raise Babl::RenderingError, 'Pin reference cannot be used here' unless pin
+                Context.new(pin.object, pin.key, pin.parent, (pin.pins || {}).merge(pins))
+            end
+
+            # Associate a pin to current context
+            def create_pin(ref)
+                Context.new(object, key, parent, (pins || {}).merge(ref => self))
+            end
+
+            # Wrapper around #move_forward navigating into the return value of
+            # the block. However, if an error occurs, it is wrapped in a
+            # Babl::RenderingError and the navigation stack trace is added
+            # to the error message.
+            def move_forward_block(key)
+                move_forward(yield, key)
+            rescue StandardError => e
+                stack_trace = ([:__root__] + stack + [key]).join('.')
+                raise Babl::RenderingError, "#{e.message}\nBABL @ #{stack_trace}", e.backtrace
+            end
+
+            # Return an array containing the navigation history
+            def stack
+                (parent ? parent.stack : []) + [key].compact
+            end
+        end
+    end
+end

data/lib/babl/rendering/internal_value_node.rb

@@ -0,0 +1,30 @@
+require 'singleton'
+
+module Babl
+    module Rendering
+        # This Node plays a role similar to TerminalValueNode, but it does not perform any
+        # type checking on the produced object, which is allowed to be any Ruby object,
+        # including non-serializable objects.
+        #
+        # It is used when the output is not rendered (conditions in #switch, values passed to block in #with, ...)
+        class InternalValueNode
+            include Singleton
+
+            def documentation
+                :__value__
+            end
+
+            def dependencies
+                {}
+            end
+
+            def pinned_dependencies
+                {}
+            end
+
+            def render(ctx)
+                ctx.object
+            end
+        end
+    end
+end