babl-json 0.5.6 → 0.5.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ea8f407140ea61dc83be26fece70b85e47280b09
-  data.tar.gz: d2503155b43b8ae0064d30808c30843c56b25702
+  metadata.gz: 3d16dfb585fb3f79b1242b92cd8ddf20663e8f18
+  data.tar.gz: 6fb4483228832e5d1016d92ef561c9dca4e34352
 SHA512:
-  metadata.gz: 0725f1502d153f9de8dbd126dd3b5c03c9211c696b39a778aa756f9d8bc85f6db4fe10260bd39626edaf71b59d074af20b9af6aba49cba736e0eb72a70aca759
-  data.tar.gz: 4e213c4de1d6bcd517e7b945b6eb3cd0004891c1356065a2c4716269f669b8fee63049897cbc4c4fc7be504ee8a6b02c209e3ba0a282fe1cd541331efaef2d9f
+  metadata.gz: 98ca371092e8bfdb4a49165439521aed3b7456bc350ae8908a700329f9da876133b91ae2c4adf982638f35a31a5d02efe1b540f647bd30f96699c745cf8a6d62
+  data.tar.gz: c30279d940b40fd1887a0e28b2885124bc1d84a2faac887dc667caf74ef2ef0dd92f4b4d67da443a3e08ab7197d4f3378003d692fbc3b1b5980a2b384d63168c

data/lib/babl.rb

@@ -75,12 +75,12 @@ module Babl
 
         def template
             cached = @cached_template
-            return cached.last if cached && config.using == cached.first
+            return cached.last if cached && [config.using].flatten == cached.first
             # Calling 'using' is a very inefficient operation, because
             # it creates a new class. We can avoid that cost most of the
             # time, assuming 'config.using' does not change often (typically
             # it should only change once at startup)
-            modules = config.using.dup
+            modules = [config.using].flatten.dup
             template = Template.new.using(*modules)
             @cached_template = [modules, template]
             template

data/lib/babl/builder/chain_builder.rb

@@ -70,16 +70,12 @@ module Babl
             end
 
             def precompile(node)
-                scope[node]
+                @scope[node]
             end
 
             def nest(context)
-                self.class.new(context) { |node| scope[yield node] }
+                self.class.new(context) { |node| @scope[yield node] }
             end
-
-            private
-
-            attr_reader :scope
         end
     end
 end

data/lib/babl/builder/template_base.rb

@@ -17,33 +17,25 @@ module Babl
             end
 
             def compile(preloader: Rendering::NoopPreloader, pretty: true, optimize: true, lookup_context: nil)
-                # Compute dependencies & schema on the non-simplified node tree in order
-                # to catch all errors.
                 tree = precompile(lookup_context: lookup_context)
+                tree = tree.optimize if optimize
                 validate(tree)
 
-                dependencies = tree.dependencies
-                schema = tree.schema
-
-                # Recompute dependencies & schema on the simplified tree before
-                # exposing them to the user.
-                if optimize
-                    tree = tree.optimize
-                    dependencies = tree.dependencies
-                    schema = tree.schema
-                end
-
                 Rendering::CompiledTemplate.with(
                     preloader: preloader,
                     pretty: pretty,
                     node: tree,
-                    dependencies: dependencies,
-                    schema: schema
+                    dependencies: tree.dependencies,
+                    schema: tree.schema
                 )
             end
 
+            def self.unscoped
+                @unscoped ||= new
+            end
+
             def unscoped
-                self.class.new
+                self.class.unscoped
             end
 
             protected

data/lib/babl/nodes/concat.rb

@@ -48,11 +48,14 @@ module Babl
             def optimize_single
                 return unless nodes.size == 1
                 optimized = nodes.first.optimize
-                case
-                when FixedArray === optimized
-                    optimized
-                when Constant === optimized
-                    optimized.value.nil? ? FixedArray::EMPTY : optimized
+
+                case optimized
+                when FixedArray then optimized
+                when Constant
+                    case optimized.value
+                    when ::Array then optimized
+                    when ::NilClass then FixedArray::EMPTY
+                    end
                 end
             end
 

data/lib/babl/nodes/merge.rb

@@ -45,11 +45,14 @@ module Babl
             def optimize_single
                 return unless nodes.size == 1
                 optimized = nodes.first.optimize
-                case
-                when Object === optimized
-                    optimized
-                when Constant === optimized
-                    optimized.value.nil? ? Object::EMPTY : optimized
+
+                case optimized
+                when Object then optimized
+                when Constant
+                    case optimized.value
+                    when ::Hash then optimized
+                    when ::NilClass then Object::EMPTY
+                    end
                 end
             end
 

data/lib/babl/nodes/nav.rb

@@ -26,7 +26,7 @@ module Babl
 
             memoize def optimize
                 optimized = node.optimize
-                return optimized if Constant === optimized
+                return optimized if Constant === optimized || GotoPin === optimized
                 return optimized.node if Parent === optimized
                 return self if optimized.equal?(node)
                 Nav.new(property, optimized)

data/lib/babl/nodes/parent.rb

@@ -21,7 +21,7 @@ module Babl
 
             memoize def optimize
                 optimized = node.optimize
-                return optimized if Constant === optimized
+                return optimized if Constant === optimized || GotoPin === optimized
                 return self if optimized.equal?(node)
                 Parent.new(optimized)
             end

data/lib/babl/nodes/with.rb

@@ -22,17 +22,31 @@ module Babl
 
             memoize def optimize
                 optimized = node.optimize
-                return optimized if Constant === optimized
+                return optimized if Constant === optimized || GotoPin === optimized
                 return optimized.node if Parent === optimized
+                return self if nodes.empty?
+
                 optimized_nodes = nodes.map(&:optimize)
+
+                if optimized_nodes.all? { |n| Constant === n }
+                    value = begin
+                        block.call(*optimized_nodes.map(&:value))
+                    rescue StandardError => e
+                        raise Errors::InvalidTemplate, e.message, e.backtrace
+                    end
+                    constant_block = Utils::Proc.constant(value)
+                    return With.new(optimized, Utils::Array::EMPTY, constant_block)
+                end
+
                 return self if optimized.equal?(node) && optimized_nodes.each_with_index.all? { |n, idx| n.equal?(nodes[idx]) }
                 With.new(optimized, optimized_nodes, block)
             end
 
             def render(frame)
-                values = nodes.empty? ? nil : nodes.map { |n| n.render(frame) }
+                values = nodes.map { |n| n.render(frame) }
+
                 value = begin
-                    nodes.empty? ? frame.object.instance_exec(&block) : block.call(*values)
+                    block.call(*values)
                 rescue StandardError => e
                     raise Errors::RenderingError, "#{e.message}\n" + frame.formatted_stack(:__block__), e.backtrace
                 end

data/lib/babl/operators/call.rb

@@ -10,7 +10,11 @@ module Babl
                 def call(*args, &block)
                     if block
                         raise Errors::InvalidTemplate, 'call() expects no argument when a block is given' unless args.empty?
-                        return with(&block)
+
+                        # The 'block' is wrapped by #selfify such that there is no implicit closure referencing the current
+                        # template. Ideally, once a template has been compiled, all intermediate template objects should be
+                        # garbage collectable.
+                        return with(unscoped, &Utils::Proc.selfify(block))
                     end
 
                     raise Errors::InvalidTemplate, 'call() expects exactly 1 argument (unless block)' unless args.size == 1

data/lib/babl/operators/extends.rb

@@ -3,10 +3,12 @@ module Babl
     module Operators
         module Extends
             module DSL
-                def extends(partial_path, *args)
+                def extends(*partial_paths, extended_with)
                     source {
-                        partial_template = partial(partial_path)
-                        args.empty? ? partial_template : merge(partial_template, *args)
+                        merge(
+                            *partial_paths.map { |path| partial(path) },
+                            extended_with
+                        )
                     }
                 end
             end

data/lib/babl/utils.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require 'babl/utils/array'
+require 'babl/utils/dsl_proxy'
 require 'babl/utils/hash'
+require 'babl/utils/proc'
 require 'babl/utils/ref'
 require 'babl/utils/value'
-require 'babl/utils/dsl_proxy'

data/lib/babl/utils/hash.rb

@@ -4,16 +4,18 @@ module Babl
         class Hash
             EMPTY = {}.freeze
 
-            def self.deep_merge(*hashes)
-                filtered_hashes = hashes.reject(&:empty?)
-                return EMPTY if filtered_hashes.empty?
-                return filtered_hashes.first if filtered_hashes.size == 1
-                filtered_hashes.reduce({}) { |out, hash| deep_merge_inplace(out, hash) }
-            end
+            class << self
+                def deep_merge(*hashes)
+                    filtered_hashes = hashes.reject(&:empty?)
+                    return EMPTY if filtered_hashes.empty?
+                    return filtered_hashes.first if filtered_hashes.size == 1
+                    filtered_hashes.reduce({}) { |out, hash| deep_merge_inplace(out, hash) }
+                end
 
-            def self.deep_merge_inplace(target, source)
-                source.each { |k, v| target[k] = deep_merge_inplace(target[k] || {}, v) }
-                target
+                def deep_merge_inplace(target, source)
+                    source.each { |k, v| target[k] = deep_merge_inplace(target[k] || {}, v) }
+                    target
+                end
             end
         end
     end

data/lib/babl/utils/proc.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module Babl
+    module Utils
+        class Proc
+            class << self
+                # Wrap a proc in a lambda, so that it is executed in the context of its first (and only) argument.
+                def selfify(proc)
+                    ->(this) { this.instance_exec(&proc) }
+                end
+
+                # Create a lambda returning a constant.
+                def constant(value)
+                    -> { value }
+                end
+            end
+        end
+    end
+end

data/lib/babl/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: babl-json
 version: !ruby/object:Gem::Version
-  version: 0.5.6
+  version: 0.5.7
 platform: ruby
 authors:
 - Frederic Terrazzoni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-05 00:00:00.000000000 Z
+date: 2018-07-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coveralls
@@ -195,6 +195,7 @@ files:
 - lib/babl/utils/array.rb
 - lib/babl/utils/dsl_proxy.rb
 - lib/babl/utils/hash.rb
+- lib/babl/utils/proc.rb
 - lib/babl/utils/ref.rb
 - lib/babl/utils/value.rb
 - lib/babl/version.rb