babl-json 0.1.4 → 0.2.0

data/lib/babl/nodes/object.rb

@@ -0,0 +1,26 @@
+require 'babl/utils/hash'
+require 'babl/schema/object'
+require 'values'
+
+module Babl
+    module Nodes
+        class Object < Value.new(:nodes)
+            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 schema
+                properties = nodes.map { |k, v| Schema::Object::Property.new(k, v.schema, true) }
+                Schema::Object.new(properties, false, false)
+            end
+
+            def render(ctx)
+                nodes.map { |k, v| [k, v.render(ctx)] }.to_h
+            end
+        end
+    end
+end

data/lib/babl/nodes/parent.rb

@@ -0,0 +1,64 @@
+require 'babl/utils/ref'
+require 'babl/errors'
+require 'values'
+
+module Babl
+    module Nodes
+        class Parent < Value.new(:node)
+            PARENT_MARKER = Utils::Ref.new
+
+            class Resolver < Value.new(:node)
+                def dependencies
+                    backpropagate_dependencies(node.dependencies)
+                end
+
+                def schema
+                    node.schema
+                end
+
+                def pinned_dependencies
+                    node.pinned_dependencies
+                end
+
+                def render(ctx)
+                    node.render(ctx)
+                end
+
+                private
+
+                def backpropagate_dependencies(deps)
+                    raise Errors::InvalidTemplateError, 'Out of context parent dependency' if deps.key? PARENT_MARKER
+                    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_MARKER
+
+                        Babl::Utils::Hash.deep_merge(
+                            Babl::Utils::Hash.deep_merge(out, k => backpropagate_dependencies_one_level(v)),
+                            v[PARENT_MARKER] || {}
+                        )
+                    end
+                end
+            end
+
+            def schema
+                node.schema
+            end
+
+            def pinned_dependencies
+                node.pinned_dependencies
+            end
+
+            def dependencies
+                { PARENT_MARKER => node.dependencies }
+            end
+
+            def render(ctx)
+                node.render(ctx.move_backward)
+            end
+        end
+    end
+end

data/lib/babl/nodes/static.rb

@@ -0,0 +1,34 @@
+require 'babl/nodes/terminal_value'
+require 'babl/schema/static'
+require 'values'
+
+module Babl
+    module Nodes
+        class Static < Value.new(:serialized_value)
+            def initialize(value)
+                super(value)
+            end
+
+            def schema
+                Schema::Static.new(serialized_value)
+            end
+
+            def render(_ctx)
+                serialized_value
+            end
+
+            def dependencies
+                {}
+            end
+
+            def pinned_dependencies
+                {}
+            end
+
+            private
+
+            def generate_doc
+            end
+        end
+    end
+end

data/lib/babl/nodes/switch.rb

@@ -0,0 +1,29 @@
+require 'babl/utils/hash'
+require 'babl/schema/any_of'
+require 'babl/errors'
+require 'values'
+
+module Babl
+    module Nodes
+        class Switch < Value.new(:nodes)
+            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 schema
+                Schema::AnyOf.new(nodes.values.map(&:schema)).simplify
+            end
+
+            def render(ctx)
+                nodes.each { |cond, value| return value.render(ctx) if cond.render(ctx) }
+                raise Errors::RenderingError, 'A least one switch() condition must be taken'
+            end
+        end
+    end
+end

data/lib/babl/nodes/terminal_value.rb

@@ -0,0 +1,76 @@
+require 'singleton'
+require 'babl/schema/anything'
+require 'babl/errors'
+
+module Babl
+    module Nodes
+        # A TerminalValue node is always implicitely added to the end of the
+        # chain during compilation. It basically ensures that the output contains only
+        # primitives, arrays and hashes.
+        class TerminalValue
+            include Singleton
+
+            def schema
+                Schema::Anything.instance
+            end
+
+            def dependencies
+                {}
+            end
+
+            def pinned_dependencies
+                {}
+            end
+
+            def render(ctx)
+                render_object(ctx.object)
+            rescue TerminalValueError => e
+                raise Errors::RenderingError, "#{e.message}\n" + ctx.formatted_stack(e.babl_stack), e.backtrace
+            end
+
+            def render_object(obj, stack = [])
+                case obj
+                when String, Numeric, NilClass, TrueClass, FalseClass then obj
+                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)
+                end
+            end
+
+            private
+
+            def render_array(array, stack)
+                array.each_with_index.map { |obj, index|
+                    stack.push index
+                    render_object(obj, stack)
+                    stack.pop
+                }
+            end
+
+            def render_hash(hash, stack)
+                hash.map { |k, v|
+                    key = render_key(k, stack)
+                    stack.push key
+                    out = [key, render_object(v, stack)]
+                    stack.pop
+                    out
+                }.to_h
+            end
+
+            def render_key(key, stack)
+                case key
+                when Symbol, String, Numeric, NilClass, TrueClass, FalseClass then :"#{key}"
+                else raise TerminalValueError.new("Invalid key for JSON object: #{key}", stack)
+                end
+            end
+
+            class TerminalValueError < Errors::RenderingError
+                attr_reader :babl_stack
+                def initialize(message, babl_stack)
+                    @babl_stack = babl_stack
+                    super(message)
+                end
+            end
+        end
+    end
+end

data/lib/babl/nodes/with.rb

@@ -0,0 +1,28 @@
+require 'babl/utils/hash'
+require 'values'
+
+module Babl
+    module Nodes
+        class With < Value.new(:node, :nodes, :block)
+            def schema
+                node.schema
+            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
+        end
+    end
+end

data/lib/babl/operators/array.rb

@@ -1,3 +1,6 @@
+require 'babl/nodes/fixed_array'
+require 'babl/nodes/terminal_value'
+
 module Babl
     module Operators
         module Array
@@ -5,38 +8,12 @@ module Babl
                 # 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))
+                        Nodes::FixedArray.new(templates.map { |t|
+                            unscoped.call(t).builder.precompile(Nodes::TerminalValue.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

@@ -1,3 +1,5 @@
+require 'babl/errors'
+
 module Babl
     module Operators
         module Call
@@ -5,7 +7,7 @@ module Babl
                 # 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
+                    raise Errors::InvalidTemplateError, 'call() expects exactly 1 argument (unless block)' unless args.size == 1
 
                     arg = args.first
 
@@ -16,7 +18,7 @@ module Babl
                     when ::Hash then object(**arg.map { |k, v| [:"#{k}", v] }.to_h)
                     when ::Array then array(*arg)
                     when ::String, ::Numeric, ::NilClass, ::TrueClass, ::FalseClass then static(arg)
-                    else raise ::Babl::InvalidTemplateError, "call() received invalid argument: #{arg}"
+                    else raise Errors::InvalidTemplateError, "call() received invalid argument: #{arg}"
                     end
                 end
             end

data/lib/babl/operators/continue.rb

@@ -0,0 +1,19 @@
+require 'babl/errors'
+
+module Babl
+    module Operators
+        module Continue
+            module DSL
+                # 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 Errors::InvalidTemplateError, 'continue() cannot be used outside switch()' unless node
+                        node
+                    }
+                end
+            end
+        end
+    end
+end

data/lib/babl/operators/default.rb

@@ -0,0 +1,13 @@
+module Babl
+    module Operators
+        module Default
+            module DSL
+                # To be used as a switch(...) condition. It is strictly equivalent to write 'true' instead,
+                # but it conveys more meaning.
+                def default
+                    static(true)
+                end
+            end
+        end
+    end
+end

data/lib/babl/operators/dep.rb

@@ -1,3 +1,5 @@
+require 'babl/nodes/dep'
+
 module Babl
     module Operators
         module Dep
@@ -5,43 +7,8 @@ module Babl
                 # 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
+                    construct_node(continue: nil) { |node| Nodes::Dep.new(node, path) }
                 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

data/lib/babl/operators/each.rb

@@ -1,3 +1,5 @@
+require 'babl/nodes/each'
+
 module Babl
     module Operators
         module Each
@@ -5,40 +7,8 @@ module Babl
                 # 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]
+                    construct_node(key: nil, continue: nil) { |node| Nodes::Each.new(node) }
                 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