babl-json 0.3.3 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b410d536ca032602510a9af64d29a29dc91f536c
-  data.tar.gz: 9a002b4137992699842abce14054d9a21d48a92a
+  metadata.gz: 36cb4d94d13851bb8c5a28ab9d8c4ab5a19fa6de
+  data.tar.gz: '0298c5489089f88c5ce9a171568e418fb8cb0dc6'
 SHA512:
-  metadata.gz: bd1979b476227686cd13d3b994629a36fa95fbd1d55ff7d7cec466fa2304c1a414f5f1cec0a816d879d7eeb667e12934f18561c4a4920aa9be4dabd87d7d4ee0
-  data.tar.gz: 6b23b6086b16a94a5594cb1390fc0307881fd3fefeb8ee4e59ee67aede28c564ae7cce2d0d2a069c1417a0f108e426c16d7294bc9f5b717217fc425a546897fd
+  metadata.gz: a0b1e9ce1e461766292ad33f43aa528d61c8fde897a94a7791a8c4b9ffcfb0f53806fbaea2dad7b981c8d2131552b20f22550aaa1eb01888449a2af08cedec50
+  data.tar.gz: 8ad1d7732551481f3309dd06797fe11faaa3aec11c8bc222972c4789c721b427c37f22fbedd987e139fc37174f87c3933dea272c7bd9054be7ced88dadaf725c

data/lib/babl/builder/template_base.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require 'babl/nodes'
+require 'babl/utils'
 require 'babl/builder'
 require 'babl/rendering'
 
@@ -9,9 +10,9 @@ module Babl
         #
         # 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
+        class TemplateBase < Utils::Value.new(:builder)
             def initialize(builder = ChainBuilder.new(&:itself))
-                @builder = builder
+                super(builder)
             end
 
             def compile(preloader: Rendering::NoopPreloader, pretty: true, optimize: true)
@@ -56,7 +57,7 @@ module Babl
                 self.class.new builder.construct_terminal(&block)
             end
 
-            attr_reader :builder
+            protected :builder
         end
     end
 end

data/lib/babl/nodes/dep.rb

@@ -4,10 +4,6 @@ require 'babl/utils'
 module Babl
     module Nodes
         class Dep < Utils::Value.new(:node, :path)
-            def initialize(node, path)
-                super(node, canonicalize(path))
-            end
-
             def render(ctx)
                 node.render(ctx)
             end
@@ -27,16 +23,6 @@ module Babl
             def optimize
                 Dep.new(node.optimize, path)
             end
-
-            private
-
-            def canonicalize(path)
-                case path
-                when ::Array then path.reduce(Utils::Hash::EMPTY) { |a, p| a.merge(canonicalize(p)) }
-                when ::Hash then path.map { |k, v| [k.to_sym, canonicalize(v)] }.to_h
-                else { path.to_sym => Utils::Hash::EMPTY }
-                end
-            end
         end
     end
 end

data/lib/babl/nodes/each.rb

@@ -7,7 +7,13 @@ module Babl
     module Nodes
         class Each < Utils::Value.new(:node)
             def dependencies
-                { __each__: node.dependencies }
+                node_deps = node.dependencies
+                child_deps = node.dependencies.reject { |key, _| key == Parent::PARENT_MARKER }
+
+                Babl::Utils::Hash.deep_merge(
+                    node_deps[Parent::PARENT_MARKER] || Utils::Hash::EMPTY,
+                    __each__: child_deps
+                )
             end
 
             def schema

data/lib/babl/nodes/fixed_array.rb

@@ -26,7 +26,7 @@ module Babl
                 optimized_nodes = nodes.map(&:optimize)
                 fixed_array = FixedArray.new(optimized_nodes)
                 return fixed_array unless optimized_nodes.all? { |node| Constant === node }
-                Constant.new(fixed_array.render(nil), fixed_array.schema)
+                Constant.new(fixed_array.nodes.map(&:value).freeze, fixed_array.schema)
             end
         end
     end

data/lib/babl/nodes/merge.rb

@@ -38,7 +38,7 @@ module Babl
             private
 
             def optimize_empty
-                Constant.new({}, Schema::Object::EMPTY) if nodes.empty?
+                Constant.new(Utils::Hash::EMPTY, Schema::Object::EMPTY) if nodes.empty?
             end
 
             def optimize_single

data/lib/babl/nodes/nav.rb

@@ -5,9 +5,15 @@ require 'babl/nodes/parent'
 
 module Babl
     module Nodes
-        class Nav < Utils::Value.new(:through, :node)
+        class Nav < Utils::Value.new(:property, :node)
             def dependencies
-                { through => node.dependencies }
+                node_deps = node.dependencies
+                child_deps = node.dependencies.reject { |key, _| key == Parent::PARENT_MARKER }
+
+                Babl::Utils::Hash.deep_merge(
+                    node_deps[Parent::PARENT_MARKER] || Utils::Hash::EMPTY,
+                    property => child_deps
+                )
             end
 
             def schema
@@ -20,18 +26,18 @@ module Babl
 
             def render(ctx)
                 value = begin
-                    ::Hash === ctx.object ? ctx.object.fetch(through) : ctx.object.send(through)
+                    ::Hash === ctx.object ? ctx.object.fetch(property) : ctx.object.send(property)
                 rescue StandardError => e
-                    raise Errors::RenderingError, "#{e.message}\n" + ctx.formatted_stack(through), e.backtrace
+                    raise Errors::RenderingError, "#{e.message}\n" + ctx.formatted_stack(property), e.backtrace
                 end
-                node.render(ctx.move_forward(value, through))
+                node.render(ctx.move_forward(value, property))
             end
 
             def optimize
                 optimized = node.optimize
                 return optimized if Constant === optimized
                 return optimized.node if Parent === optimized
-                Nav.new(through, optimized)
+                Nav.new(property, optimized)
             end
         end
     end

data/lib/babl/nodes/object.rb

@@ -6,7 +6,7 @@ require 'babl/nodes/constant'
 module Babl
     module Nodes
         class Object < Utils::Value.new(:nodes)
-            EMPTY = new({})
+            EMPTY = new(Utils::Hash::EMPTY)
 
             def dependencies
                 nodes.values.map(&:dependencies).reduce(Utils::Hash::EMPTY) { |a, b| Babl::Utils::Hash.deep_merge(a, b) }
@@ -32,7 +32,7 @@ module Babl
                 optimized_nodes = nodes.map { |k, v| [k, v.optimize] }.to_h
                 optimized_object = Object.new(optimized_nodes)
                 return optimized_object unless optimized_nodes.values.all? { |node| Constant === node }
-                Constant.new(optimized_object.render(nil), optimized_object.schema)
+                Constant.new(optimized_object.nodes.map { |k, v| [k, v.value] }.to_h.freeze, optimized_object.schema)
             end
         end
     end

data/lib/babl/nodes/parent.rb

@@ -7,9 +7,11 @@ module Babl
         class Parent < Utils::Value.new(:node)
             PARENT_MARKER = Utils::Ref.new
 
-            class Resolver < Utils::Value.new(:node)
+            class Verifier < Utils::Value.new(:node)
                 def dependencies
-                    backpropagate_dependencies(node.dependencies)
+                    deps = node.dependencies
+                    raise Errors::InvalidTemplate, 'Out of context parent dependency' if deps.key? PARENT_MARKER
+                    deps
                 end
 
                 def schema
@@ -25,26 +27,7 @@ module Babl
                 end
 
                 def optimize
-                    Resolver.new(node.optimize)
-                end
-
-                private
-
-                def backpropagate_dependencies(deps)
-                    raise Errors::InvalidTemplate, '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(Utils::Hash::EMPTY) 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] || Utils::Hash::EMPTY
-                        )
-                    end
+                    Verifier.new(node.optimize)
                 end
             end
 

data/lib/babl/nodes/switch.rb

@@ -38,11 +38,18 @@ module Babl
                     optimize_truthy_conditions ||
                     optimize_always_same_outputs ||
                     optimize_same_conditions ||
+                    optimize_continue_to_switch ||
                     self
             end
 
             private
 
+            def optimize_continue_to_switch
+                cond, val = nodes.last
+                return unless Switch === val && Constant === cond && cond.value
+                Switch.new(nodes[0...-1] + val.nodes).optimize
+            end
+
             def optimize_same_conditions
                 conds = Set.new
                 new_nodes = nodes.map { |cond, val|

data/lib/babl/nodes/typed.rb

@@ -2,33 +2,83 @@
 require 'babl/utils'
 require 'babl/schema'
 require 'babl/nodes/terminal_value'
+require 'singleton'
 
 module Babl
     module Nodes
-        class Typed < Utils::Value.new(:schema)
-            BOOLEAN = new(Schema::Typed::BOOLEAN)
-            INTEGER = new(Schema::Typed::INTEGER)
-            NUMBER = new(Schema::Typed::NUMBER)
-            STRING = new(Schema::Typed::STRING)
-
-            def dependencies
-                Utils::Hash::EMPTY
+        module Typed
+            class Base
+                include Singleton
+
+                def dependencies
+                    Utils::Hash::EMPTY
+                end
+
+                def pinned_dependencies
+                    Utils::Hash::EMPTY
+                end
+
+                def optimize
+                    self
+                end
             end
 
-            def pinned_dependencies
-                Utils::Hash::EMPTY
+            class String < Base
+                def schema
+                    Schema::Typed::STRING
+                end
+
+                def render(ctx)
+                    value = ctx.object
+                    return value if ::String === value
+                    return value.to_s if ::Symbol === value
+
+                    raise Errors::RenderingError,
+                        "Expected a string, got #{value}\n#{ctx.formatted_stack}"
+                end
             end
 
-            def render(ctx)
-                value = ctx.object
-                if schema.classes.any? { |clazz| clazz === value }
-                    return ::Numeric === value ? TerminalValue.instance.render_object(value) : value
+            class Integer < Base
+                def schema
+                    Schema::Typed::INTEGER
+                end
+
+                def render(ctx)
+                    value = ctx.object
+                    return value if ::Integer === value
+
+                    raise Errors::RenderingError,
+                        "Expected an integer, got #{value}\n#{ctx.formatted_stack}"
                 end
-                raise Errors::RenderingError, "Expected type '#{schema.type}': #{value}\n#{ctx.formatted_stack}"
             end
 
-            def optimize
-                self
+            class Number < Base
+                def schema
+                    Schema::Typed::NUMBER
+                end
+
+                def render(ctx)
+                    value = ctx.object
+                    return value if ::Integer === value
+                    return value.to_f if ::Numeric === value
+
+                    raise Errors::RenderingError,
+                        "Expected a number, got #{value}\n#{ctx.formatted_stack}"
+                end
+            end
+
+            class Boolean < Base
+                def schema
+                    Schema::Typed::BOOLEAN
+                end
+
+                def render(ctx)
+                    value = ctx.object
+                    return value if true == value || false == value
+
+                    raise Errors::RenderingError,
+                        "Expected a boolean, got #{value}\n#{ctx.formatted_stack}"
+                end
             end
         end
     end

data/lib/babl/nodes/with.rb

@@ -10,8 +10,12 @@ module Babl
             end
 
             def dependencies
-                # Dependencies of 'node' are explicitely ignored
-                nodes.map(&:dependencies).reduce(Utils::Hash::EMPTY) { |a, b| Babl::Utils::Hash.deep_merge(a, b) }
+                Babl::Utils::Hash.deep_merge(
+                    node.dependencies[Parent::PARENT_MARKER] || Utils::Hash::EMPTY,
+                    nodes.map(&:dependencies).reduce(Utils::Hash::EMPTY) { |a, b|
+                        Babl::Utils::Hash.deep_merge(a, b)
+                    }
+                )
             end
 
             def pinned_dependencies
@@ -32,6 +36,7 @@ module Babl
             def optimize
                 optimized = node.optimize
                 return optimized if Constant === optimized
+                return optimized.node if Parent === optimized
                 With.new(optimized, nodes.map(&:optimize), block)
             end
         end

data/lib/babl/operators/array.rb

@@ -7,9 +7,11 @@ module Babl
             module DSL
                 # Produce an fixed-size array, using the provided templates to populate its elements.
                 def array(*templates)
+                    templates = templates.map { |t| unscoped.call(t) }
+
                     construct_terminal { |ctx|
                         Nodes::FixedArray.new(templates.map { |t|
-                            unscoped.call(t).builder.precompile(Nodes::TerminalValue.instance, ctx.merge(continue: nil))
+                            t.builder.precompile(Nodes::TerminalValue.instance, ctx.merge(continue: nil))
                         })
                     }
                 end

data/lib/babl/operators/call.rb

@@ -18,7 +18,7 @@ module Babl
                     when Utils::DslProxy then call(arg.itself)
                     when ::Symbol then nav(arg)
                     when ::Proc then call(&arg)
-                    when ::Hash then object(**arg.map { |k, v| [:"#{k}", v] }.to_h)
+                    when ::Hash then object(arg)
                     when ::Array then array(*arg)
                     when ::String, ::Numeric, ::NilClass, ::TrueClass, ::FalseClass then static(arg)
                     else raise Errors::InvalidTemplate, "call() received invalid argument: #{arg}"

data/lib/babl/operators/dep.rb

@@ -4,10 +4,19 @@ require 'babl/nodes'
 module Babl
     module Operators
         module Dep
+            def self.canonicalize(path)
+                case path
+                when ::Array then path.reduce(Utils::Hash::EMPTY) { |a, p| a.merge(canonicalize(p)) }
+                when ::Hash then path.map { |k, v| [k.dup.freeze, canonicalize(v)] }.to_h
+                else { path.dup.freeze => Utils::Hash::EMPTY }
+                end
+            end
+
             module DSL
                 # Declare dependencies as if they were generated by nav()
                 # but without navigating.
                 def dep(*path)
+                    path = Dep.canonicalize(path)
                     construct_node(continue: nil) { |node| Nodes::Dep.new(node, path) }
                 end
             end

data/lib/babl/operators/merge.rb

@@ -9,11 +9,12 @@ module Babl
                 # Merge multiple JSON objects (non-deep)
                 def merge(*templates)
                     return call(Utils::Hash::EMPTY) if templates.empty?
+                    templates = templates.map { |t| unscoped.call(t) }
 
                     construct_terminal { |context|
                         Nodes::Merge.new(
                             templates.map { |t|
-                                unscoped.call(t).builder.precompile(
+                                t.builder.precompile(
                                     Nodes::TerminalValue.instance,
                                     context.merge(continue: nil)
                                 )

data/lib/babl/operators/nav.rb

@@ -14,8 +14,8 @@ module Babl
                     if path.empty?
                         return (block ? with(unscoped, &block) : construct_node(key: nil, continue: nil) { |node| node })
                     end
-
-                    construct_node(key: nil, continue: nil) { |node| Nodes::Nav.new(path.first, node) }
+                    property = path.first.dup.freeze
+                    construct_node(key: nil, continue: nil) { |node| Nodes::Nav.new(property, node) }
                         .nav(*path[1..-1], &block)
                 end
             end

data/lib/babl/operators/object.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require 'babl/nodes'
+require 'babl/utils'
 require 'babl/errors'
 
 module Babl
@@ -7,24 +8,28 @@ module Babl
         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).each_value do |keys|
+                def object(*args)
+                    kwargs = ::Hash === args.last ? args.pop : Utils::Hash::EMPTY
+
+                    (args.map(&:to_sym) + kwargs.keys.map(&:to_sym)).group_by(&:itself).each_value do |keys|
                         raise Errors::InvalidTemplate, "Duplicate key in object(): #{keys.first}" if keys.size > 1
                     end
 
+                    templates = args
+                        .map { |name| [name.to_sym, unscoped.nav(name)] }.to_h
+                        .merge(kwargs)
+                        .map { |k, v| [k, unscoped.call(v)] }
+
                     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(
+                        Nodes::Object.new(templates.map { |key, template|
+                            [
+                                key.to_sym,
+                                template.builder.precompile(
                                     Nodes::TerminalValue.instance,
-                                    ctx.merge(key: k, continue: nil)
-                                )]
-                            }
-                            .to_h
-
-                        Nodes::Object.new(nodes)
+                                    ctx.merge(key: key, continue: nil)
+                                )
+                            ]
+                        }.to_h)
                     }
                 end
             end

data/lib/babl/operators/parent.rb

@@ -14,7 +14,7 @@ module Babl
 
                 # Override TemplateBase#precompile to add parent dependencies verification
                 def precompile
-                    Nodes::Parent::Resolver.new(super)
+                    Nodes::Parent::Verifier.new(super)
                 end
             end
         end

data/lib/babl/operators/source.rb

@@ -6,7 +6,9 @@ module Babl
             module DSL
                 # Parse BABL source into a Template
                 def source(*args, &block)
-                    call(block ? Utils::DslProxy.eval(unscoped, &block) : unscoped.instance_eval(*args))
+                    raise Errors::InvalidTemplate, 'source() expects a block xor a string' unless args.empty? ^ block.nil?
+                    block ||= proc { instance_eval(*args) }
+                    call Utils::DslProxy.eval(unscoped, &block)
                 end
             end
         end

data/lib/babl/operators/static.rb

@@ -12,7 +12,10 @@ module Babl
 
                     case sanitized_val
                     when ::String, ::Numeric, ::NilClass, ::TrueClass, ::FalseClass
-                        construct_terminal { Nodes::Constant.new(sanitized_val, Schema::Primitive.new(sanitized_val)) }
+                        frozen_val = sanitized_val.dup.freeze
+                        construct_terminal {
+                            Nodes::Constant.new(frozen_val, Schema::Primitive.new(frozen_val))
+                        }
                     else call(sanitized_val)
                     end
                 rescue Errors::RenderingError => exception

data/lib/babl/operators/switch.rb

@@ -8,13 +8,19 @@ module Babl
             module DSL
                 # Conditional switching between different templates
                 def switch(conds = Utils::Hash::EMPTY)
+                    conds = conds.map { |cond, value| [unscoped.call(cond), unscoped.call(value)] }
+
                     construct_node(continue: nil) { |node, context|
                         nodes = conds.map { |cond, value|
-                            cond_node = unscoped.call(cond).builder
-                                .precompile(Nodes::InternalValue.instance, context.merge(continue: nil))
+                            cond_node = cond.builder.precompile(
+                                Nodes::InternalValue.instance,
+                                context.merge(continue: nil)
+                            )
 
-                            value_node = unscoped.call(value).builder
-                                .precompile(Nodes::TerminalValue.instance, context.merge(continue: node))
+                            value_node = value.builder.precompile(
+                                Nodes::TerminalValue.instance,
+                                context.merge(continue: node)
+                            )
 
                             [cond_node, value_node]
                         }

data/lib/babl/operators/typed.rb

@@ -6,19 +6,19 @@ module Babl
         module Typed
             module DSL
                 def integer
-                    construct_terminal { Nodes::Typed::INTEGER }
+                    construct_terminal { Nodes::Typed::Integer.instance }
                 end
 
                 def number
-                    construct_terminal { Nodes::Typed::NUMBER }
+                    construct_terminal { Nodes::Typed::Number.instance }
                 end
 
                 def string
-                    construct_terminal { Nodes::Typed::STRING }
+                    construct_terminal { Nodes::Typed::String.instance }
                 end
 
                 def boolean
-                    construct_terminal { Nodes::Typed::BOOLEAN }
+                    construct_terminal { Nodes::Typed::Boolean.instance }
                 end
             end
         end

data/lib/babl/operators/with.rb

@@ -7,13 +7,15 @@ module Babl
             module DSL
                 # Produce a value by calling the block, passing it the output value of the templates passed as argument.
                 def with(*templates, &block)
+                    templates = templates.map { |t| unscoped.call(t) }
+
                     construct_node(key: nil, continue: nil) do |node, context|
-                        Nodes::With.new(node, templates.map do |t|
-                            unscoped.call(t).builder.precompile(
+                        Nodes::With.new(node, templates.map { |t|
+                            t.builder.precompile(
                                 Nodes::InternalValue.instance,
                                 context.merge(continue: nil)
                             )
-                        end, block)
+                        }, block)
                     end
                 end
             end

data/lib/babl/utils/dsl_proxy.rb

@@ -9,7 +9,8 @@ module Babl
         # correctly.
         class DslProxy
             NON_PROXIED_METHODS = Set[
-                :__send__, :send, :object_id, :__id__, :equal?, :instance_eval
+                :__send__, :send, :object_id, :__id__, :equal?, :instance_eval, :instance_exec,
+                :respond_to?, :method, :freeze
             ]
 
             instance_methods.each do |method|
@@ -31,7 +32,7 @@ module Babl
                     @__fallback__.respond_to?(method, include_private)
             end
 
-            def self.eval(dsl, *args, &block)
+            def self.eval(dsl, &block)
                 new(dsl, block.binding.receiver).instance_eval(&block)
             end
 

data/lib/babl/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Babl
-    VERSION = '0.3.3'
+    VERSION = '0.3.4'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: babl-json
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.4
 platform: ruby
 authors:
 - Frederic Terrazzoni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-20 00:00:00.000000000 Z
+date: 2017-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry