babl-json 0.1.4 → 0.2.0

data/lib/babl/operators/switch.rb

@@ -1,71 +1,28 @@
+require 'babl/nodes/switch'
+require 'babl/nodes/internal_value'
+require 'babl/nodes/terminal_value'
+
 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
-                    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
+                # Conditional switching between different templates
                 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))
+                                .precompile(Nodes::InternalValue.instance, context.merge(continue: nil))
 
                             value_node = unscoped.call(value).builder
-                                .precompile(Rendering::TerminalValueNode.instance, context.merge(continue: node))
+                                .precompile(Nodes::TerminalValue.instance, context.merge(continue: node))
 
                             [cond_node, value_node]
                         }.to_h
 
-                        SwitchNode.new(nodes)
+                        Nodes::Switch.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

@@ -1,3 +1,6 @@
+require 'babl/nodes/with'
+require 'babl/nodes/internal_value'
+
 module Babl
     module Operators
         module With
@@ -5,47 +8,15 @@ module Babl
                 # 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|
+                        Nodes::With.new(node, templates.map do |t|
                             unscoped.call(t).builder.precompile(
-                                Rendering::InternalValueNode.instance,
+                                Nodes::InternalValue.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

@@ -12,7 +12,7 @@ module Babl
                     # 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)
+                        Babl.compile { #{template.source} }.json(local_assigns)
                     RUBY
                 end
             end
@@ -22,7 +22,7 @@ module Babl
     class Railtie < Rails::Railtie
         initializer "babl.initialize" do
             ActiveSupport.on_load(:action_view) do
-                ::ActionView::Template.register_template_handler(:babl, ::Babl::ActionView::Template::Handler)
+                ::ActionView::Template.register_template_handler(:babl, Babl::ActionView::Template::Handler)
             end
         end
     end

data/lib/babl/rendering/compiled_template.rb

@@ -1,26 +1,18 @@
 require 'oj'
+require 'babl/rendering/context'
+require 'values'
 
 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
-
+        class CompiledTemplate < Value.new(:node, :dependencies, :preloader, :pretty, :json_schema)
             def json(root)
                 data = render(root)
-                Oj.dump(data, indent: pretty ? 4 : 0, mode: :strict)
+                ::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)
+                ctx = Context.new(preloaded_data)
                 node.render(ctx)
             end
         end

data/lib/babl/rendering/context.rb

@@ -1,9 +1,11 @@
+require 'babl/errors'
+
 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)
+        # - 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.
@@ -24,14 +26,14 @@ module Babl
 
             # Go back to parent
             def move_backward
-                raise Babl::RenderingError, 'There is no parent element' unless parent
+                raise Errors::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
+                raise Errors::RenderingError, 'Pin reference cannot be used here' unless pin
                 Context.new(pin.object, pin.key, pin.parent, (pin.pins || {}).merge(pins))
             end
 
@@ -42,13 +44,17 @@ module Babl
 
             # 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
+            # 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
+                raise Errors::RenderingError, "#{e.message}\n" + formatted_stack(key), e.backtrace
+            end
+
+            def formatted_stack(*additional_stack_items)
+                stack_trace = ([:__root__] + stack + additional_stack_items).join('.')
+                "BABL @ #{stack_trace}"
             end
 
             # Return an array containing the navigation history

data/lib/babl/schema/any_of.rb

@@ -0,0 +1,137 @@
+require 'values'
+require 'set'
+require 'babl/schema/static'
+require 'babl/schema/object'
+
+module Babl
+    module Schema
+        class AnyOf < Value.new(:choice_set)
+            attr_reader :choices
+
+            def initialize(choices)
+                flattened_choices = choices.flat_map { |doc| AnyOf === doc ? doc.choices : [doc] }.uniq
+                @choices = flattened_choices
+                super(flattened_choices.to_set)
+            end
+
+            def json
+                { anyOf: choices.map(&:json) }
+            end
+
+            # Perform simple transformations in order to reduce the size of the generated
+            # schema.
+            def simplify
+                simplify_single ||
+                    simplify_nullability ||
+                    simplify_empty_array ||
+                    simplify_push_down_dyn_array ||
+                    simplify_dyn_and_fixed_array ||
+                    simplify_many_objects_only_one_difference ||
+                    self
+            end
+
+            private
+
+            # We can completely get rid of the AnyOf element of there is only one possible schema.
+            def simplify_single
+                choices.size == 1 ? choices.first : nil
+            end
+
+            # Try to merge nullability into one of the object elements if they support that
+            # (Object, DynArray and FixedArray).
+            def simplify_nullability
+                if choices.include?(Static::NULL)
+                    others = choices - [Static::NULL]
+                    others.each do |other|
+                        new_other =
+                            case other
+                            when Object then Object.new(other.properties, other.additional, true)
+                            when DynArray then DynArray.new(other.item, true)
+                            when FixedArray then FixedArray.new(other.items, true)
+                            when Anything then other
+                            end
+                        return AnyOf.new(others - [other] + [new_other]).simplify if new_other
+                    end
+                end
+
+                nil
+            end
+
+            # An always empty FixedArray is just a special case of a DynArray
+            # We can get rid of the former and only keep the DynArray
+            def simplify_empty_array
+                fixed_array = choices.find { |s| FixedArray === s && s.items.empty? }
+                if fixed_array
+                    others = choices - [fixed_array]
+                    others.each do |other|
+                        next unless DynArray === other
+                        new_other = DynArray.new(other.item, other.nullable || fixed_array.nullable)
+                        return AnyOf.new(others - [other] + [new_other]).simplify
+                    end
+                end
+
+                nil
+            end
+
+            # If the static array is an instance of another dyn array, then the fixed array can be
+            # removed.
+            def simplify_dyn_and_fixed_array
+                dyns = choices.select { |s| DynArray === s }
+                fixeds = choices.select { |s| FixedArray === s && s.items.uniq.size == 1 }
+
+                dyns.each do |dyn|
+                    fixeds.each do |fixed|
+                        new_dyn = DynArray.new(dyn.item, dyn.nullable || fixed.nullable)
+                        return AnyOf.new(choices - [fixed, dyn] + [new_dyn]).simplify if dyn.item == fixed.items.first
+                    end
+                end
+
+                nil
+            end
+
+            # If two objects have exactly the same structure, with the exception of only one property
+            # having a different type, then AnyOf can be pushed down to this property.
+            def simplify_many_objects_only_one_difference
+                return unless choices.all? { |s| Object === s }
+
+                choices.each_with_index { |obj1, index1|
+                    choices.each_with_index { |obj2, index2|
+                        next if index2 <= index1
+                        next unless Object === obj1 && Object === obj2
+                        next unless obj1.nullable == obj2.nullable && obj1.additional == obj2.additional
+                        next unless obj1.properties.map { |p| [p.name, p.required] }.to_set ==
+                                obj2.properties.map { |p| [p.name, p.required] }.to_set
+
+                        diff1 = obj1.properties - obj2.properties
+                        diff2 = obj2.properties - obj1.properties
+
+                        next unless diff1.size == 1 && diff2.size == 1 && diff1.first.name == diff2.first.name
+
+                        merged = Object.new(
+                            obj1.properties.map { |p|
+                                next p unless p == diff1.first
+                                Object::Property.new(
+                                    p.name,
+                                    AnyOf.new([diff1.first.value, diff2.first.value]).simplify,
+                                    p.required
+                                )
+                            },
+                            obj1.additional,
+                            obj1.nullable
+                        )
+
+                        return AnyOf.new(choices - [obj1, obj2] + [merged]).simplify
+                    }
+                }
+
+                nil
+            end
+
+            # Push down the AnyOf to the item if all outputs are of type DynArray
+            def simplify_push_down_dyn_array
+                return unless choices.all? { |s| DynArray === s }
+                DynArray.new(AnyOf.new(choices.map(&:item)).simplify, choices.any?(&:nullable))
+            end
+        end
+    end
+end

data/lib/babl/schema/anything.rb

@@ -0,0 +1,13 @@
+require 'singleton'
+
+module Babl
+    module Schema
+        class Anything
+            include Singleton
+
+            def json
+                {}
+            end
+        end
+    end
+end

data/lib/babl/schema/dyn_array.rb

@@ -0,0 +1,11 @@
+require 'values'
+
+module Babl
+    module Schema
+        class DynArray < Value.new(:item, :nullable)
+            def json
+                { type: nullable ? %w[array null] : 'array', items: item.json }
+            end
+        end
+    end
+end

data/lib/babl/schema/fixed_array.rb

@@ -0,0 +1,13 @@
+require 'values'
+
+module Babl
+    module Schema
+        class FixedArray < Value.new(:items, :nullable)
+            EMPTY = new([], false)
+
+            def json
+                { type: nullable ? %w[array null] : 'array', items: items.map(&:json) }
+            end
+        end
+    end
+end

data/lib/babl/schema/object.rb

@@ -0,0 +1,35 @@
+require 'values'
+require 'set'
+
+module Babl
+    module Schema
+        class Object < Value.new(:property_set, :additional, :nullable)
+            attr_reader :properties
+
+            def initialize(properties, additional, nullable)
+                @properties = properties
+                super(properties.to_set, additional, nullable)
+            end
+
+            class Property < Value.new(:name, :value, :required)
+                def initialize(name, value, required)
+                    super(name, value, required)
+                end
+            end
+
+            EMPTY = new([], false, false)
+            EMPTY_WITH_ADDITIONAL = new([], true, false)
+
+            def json
+                { type: nullable ? %w[object null] : 'object' }.tap { |out|
+                    next if properties.empty?
+                    out[:properties] = properties.map { |property| [property.name, property.value.json] }.to_h
+                    out[:additionalProperties] = additional
+                    required_properties = properties.select(&:required)
+                    next if required_properties.empty?
+                    out[:required] = properties.select(&:required).map(&:name).map(&:to_s)
+                }
+            end
+        end
+    end
+end