babl-json 0.5.5 → 0.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 06e7d0d6838bd28a3c50434afec9a7ef3673f659
-  data.tar.gz: 8e4d913e0e5b97e9280a2535543a73c069e2cf84
+  metadata.gz: ea8f407140ea61dc83be26fece70b85e47280b09
+  data.tar.gz: d2503155b43b8ae0064d30808c30843c56b25702
 SHA512:
-  metadata.gz: eb6f0a919e68efd724dffbe3ffccdda0b48a780dc73e41b50c963868d7c1ce5ca92d3935f1566eeeff1e02e9f1d8a3ec8627aba46cc052dbc69052b50de5596c
-  data.tar.gz: 263c993251039ad9266380382ad0b41206eed7b554cb917aae4b70b5d693a8246ac249201cc7b8df51567f6ecade0775d5981cf92460430c794f6cad2d87736d
+  metadata.gz: 0725f1502d153f9de8dbd126dd3b5c03c9211c696b39a778aa756f9d8bc85f6db4fe10260bd39626edaf71b59d074af20b9af6aba49cba736e0eb72a70aca759
+  data.tar.gz: 4e213c4de1d6bcd517e7b945b6eb3cd0004891c1356065a2c4716269f669b8fee63049897cbc4c4fc7be504ee8a6b02c209e3ba0a282fe1cd541331efaef2d9f

data/lib/babl/builder/template_base.rb

@@ -11,8 +11,6 @@ module Babl
         # Since the BABL code is run via #instance_exec within an instance of this class, we want to
         # define as few methods as possible here.
         class TemplateBase
-            attr_reader :builder
-
             def initialize(builder = ChainBuilder.new(&:itself))
                 @builder = builder
                 freeze
@@ -40,7 +38,7 @@ module Babl
                     pretty: pretty,
                     node: tree,
                     dependencies: dependencies,
-                    json_schema: schema.json
+                    schema: schema
                 )
             end
 
@@ -50,6 +48,8 @@ module Babl
 
             protected
 
+            attr_reader :builder
+
             def validate(tree)
                 # NOOP
             end
@@ -65,8 +65,6 @@ module Babl
             def construct_terminal(&block)
                 self.class.new builder.construct_terminal(&block)
             end
-
-            protected :builder
         end
     end
 end

data/lib/babl/nodes/concat.rb

@@ -6,18 +6,26 @@ require 'babl/schema'
 module Babl
     module Nodes
         class Concat < Utils::Value.new(:nodes)
-            def dependencies
+            memoize def dependencies
                 Babl::Utils::Hash.deep_merge(*nodes.map(&:dependencies))
             end
 
-            def pinned_dependencies
+            memoize def pinned_dependencies
                 Babl::Utils::Hash.deep_merge(*nodes.map(&:pinned_dependencies))
             end
 
-            def schema
+            memoize def schema
                 nodes.map(&:schema).reduce(Schema::FixedArray::EMPTY) { |a, b| merge_doc(a, b) }
             end
 
+            memoize def optimize
+                optimize_empty ||
+                    optimize_single ||
+                    optimize_concatenated_arrays ||
+                    optimize_preconcat_constant ||
+                    self
+            end
+
             def render(frame)
                 out = []
                 nodes.each { |node|
@@ -31,14 +39,6 @@ module Babl
                 out
             end
 
-            def optimize
-                optimize_empty ||
-                    optimize_single ||
-                    optimize_concatenated_arrays ||
-                    optimize_preconcat_constant ||
-                    self
-            end
-
             private
 
             def optimize_empty

data/lib/babl/nodes/create_pin.rb

@@ -10,21 +10,27 @@ module Babl
                 end
             end
 
-            def schema
+            memoize def schema
                 node.schema
             end
 
-            def dependencies
+            memoize def dependencies
                 Babl::Utils::Hash.deep_merge(node.dependencies, node.pinned_dependencies[ref] || Utils::Hash::EMPTY)
             end
 
-            def pinned_dependencies
+            memoize def pinned_dependencies
                 node.pinned_dependencies.reject { |k, _v| k == ref }
             end
 
-            def optimize
+            memoize def optimize
                 optimized = node.optimize
-                optimized.pinned_dependencies[ref] ? CreatePin.new(optimized, ref) : optimized
+                if !optimized.pinned_dependencies[ref]
+                    optimized
+                elsif optimized.equal?(node)
+                    self
+                else
+                    CreatePin.new(optimized, ref)
+                end
             end
         end
     end

data/lib/babl/nodes/dep.rb

@@ -8,20 +8,21 @@ module Babl
                 node.render(frame)
             end
 
-            def schema
+            memoize def schema
                 node.schema
             end
 
-            def pinned_dependencies
+            memoize def pinned_dependencies
                 node.pinned_dependencies
             end
 
-            def dependencies
+            memoize def dependencies
                 Babl::Utils::Hash.deep_merge(node.dependencies, path)
             end
 
-            def optimize
-                Dep.new(node.optimize, path)
+            memoize def optimize
+                optimized = node.optimize
+                optimized.equal?(node) ? self : Dep.new(optimized, path)
             end
         end
     end

data/lib/babl/nodes/each.rb

@@ -6,7 +6,7 @@ require 'babl/utils'
 module Babl
     module Nodes
         class Each < Utils::Value.new(:node)
-            def dependencies
+            memoize def dependencies
                 node_deps = node.dependencies
                 child_deps = node_deps.reject { |key, _| key == Parent::PARENT_MARKER }
 
@@ -16,14 +16,19 @@ module Babl
                 )
             end
 
-            def schema
+            memoize def schema
                 Schema::DynArray.new(node.schema)
             end
 
-            def pinned_dependencies
+            memoize def pinned_dependencies
                 node.pinned_dependencies
             end
 
+            memoize def optimize
+                optimized = node.optimize
+                optimized.equal?(node) ? self : Each.new(node.optimize)
+            end
+
             def render(frame)
                 collection = frame.object
                 unless Enumerable === collection
@@ -36,10 +41,6 @@ module Babl
                     end
                 end
             end
-
-            def optimize
-                Each.new(node.optimize)
-            end
         end
     end
 end

data/lib/babl/nodes/fixed_array.rb

@@ -8,27 +8,33 @@ module Babl
         class FixedArray < Utils::Value.new(:nodes)
             EMPTY = new(Utils::Array::EMPTY)
 
-            def schema
+            memoize def schema
                 Schema::FixedArray.new(nodes.map(&:schema))
             end
 
-            def dependencies
+            memoize def dependencies
                 Babl::Utils::Hash.deep_merge(*nodes.map(&:dependencies))
             end
 
-            def pinned_dependencies
+            memoize def pinned_dependencies
                 Babl::Utils::Hash.deep_merge(*nodes.map(&:pinned_dependencies))
             end
 
-            def render(frame)
-                nodes.map { |node| node.render(frame) }
+            memoize def optimize
+                optimized_nodes = nodes.map(&:optimize)
+
+                fixed_array = self if optimized_nodes.each_with_index.all? { |v, idx| v.equal?(nodes[idx]) }
+                fixed_array ||= FixedArray.new(optimized_nodes)
+
+                if optimized_nodes.all? { |node| Constant === node }
+                    Constant.new(optimized_nodes.map(&:value).freeze, fixed_array.schema)
+                else
+                    fixed_array
+                end
             end
 
-            def optimize
-                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.nodes.map(&:value).freeze, fixed_array.schema)
+            def render(frame)
+                nodes.map { |node| node.render(frame) }
             end
         end
     end

data/lib/babl/nodes/goto_pin.rb

@@ -5,28 +5,34 @@ require 'babl/nodes/constant'
 module Babl
     module Nodes
         class GotoPin < Utils::Value.new(:node, :ref)
-            def dependencies
+            memoize def dependencies
                 Utils::Hash::EMPTY
             end
 
-            def pinned_dependencies
+            memoize def pinned_dependencies
                 Babl::Utils::Hash.deep_merge(node.pinned_dependencies, ref => node.dependencies)
             end
 
-            def schema
+            memoize def schema
                 node.schema
             end
 
+            memoize def optimize
+                optimized = node.optimize
+                if Constant === optimized
+                    optimized
+                elsif optimized.equal?(node)
+                    self
+                else
+                    GotoPin.new(optimized, ref)
+                end
+            end
+
             def render(frame)
                 frame.goto_pin(ref) do |new_frame|
                     node.render(new_frame)
                 end
             end
-
-            def optimize
-                optimized = node.optimize
-                Constant === optimized ? optimized : GotoPin.new(optimized, ref)
-            end
         end
     end
 end

data/lib/babl/nodes/merge.rb

@@ -7,27 +7,19 @@ require 'babl/nodes/constant'
 module Babl
     module Nodes
         class Merge < Utils::Value.new(:nodes)
-            def dependencies
+            memoize def dependencies
                 Babl::Utils::Hash.deep_merge(*nodes.map(&:dependencies))
             end
 
-            def pinned_dependencies
+            memoize def pinned_dependencies
                 Babl::Utils::Hash.deep_merge(*nodes.map(&:pinned_dependencies))
             end
 
-            def schema
+            memoize def schema
                 nodes.map(&:schema).reduce(Schema::Object::EMPTY) { |a, b| merge_doc(a, b) }
             end
 
-            def render(frame)
-                nodes.map { |node| node.render(frame) }.compact.reduce({}) { |acc, val|
-                    raise Errors::RenderingError, "Only objects can be merged\n" +
-                        frame.formatted_stack unless ::Hash === val
-                    acc.merge!(val)
-                }
-            end
-
-            def optimize
+            memoize def optimize
                 optimize_empty ||
                     optimize_single ||
                     optimize_nested_merges ||
@@ -36,6 +28,14 @@ module Babl
                     self
             end
 
+            def render(frame)
+                nodes.map { |node| node.render(frame) }.compact.reduce({}) { |acc, val|
+                    raise Errors::RenderingError, "Only objects can be merged\n" +
+                        frame.formatted_stack unless ::Hash === val
+                    acc.merge!(val)
+                }
+            end
+
             private
 
             def optimize_empty

data/lib/babl/nodes/nav.rb

@@ -6,7 +6,7 @@ require 'babl/nodes/parent'
 module Babl
     module Nodes
         class Nav < Utils::Value.new(:property, :node)
-            def dependencies
+            memoize def dependencies
                 node_deps = node.dependencies
                 child_deps = node_deps.reject { |key, _| key == Parent::PARENT_MARKER }
 
@@ -16,14 +16,22 @@ module Babl
                 )
             end
 
-            def schema
+            memoize def schema
                 node.schema
             end
 
-            def pinned_dependencies
+            memoize def pinned_dependencies
                 node.pinned_dependencies
             end
 
+            memoize def optimize
+                optimized = node.optimize
+                return optimized if Constant === optimized
+                return optimized.node if Parent === optimized
+                return self if optimized.equal?(node)
+                Nav.new(property, optimized)
+            end
+
             def render(frame)
                 value = begin
                     object = frame.object
@@ -36,13 +44,6 @@ module Babl
                     node.render(new_frame)
                 end
             end
-
-            def optimize
-                optimized = node.optimize
-                return optimized if Constant === optimized
-                return optimized.node if Parent === optimized
-                Nav.new(property, optimized)
-            end
         end
     end
 end

data/lib/babl/nodes/object.rb

@@ -8,31 +8,33 @@ module Babl
         class Object < Utils::Value.new(:nodes)
             EMPTY = new(Utils::Hash::EMPTY)
 
-            def dependencies
+            memoize def dependencies
                 Babl::Utils::Hash.deep_merge(*nodes.values.map(&:dependencies))
             end
 
-            def pinned_dependencies
+            memoize def pinned_dependencies
                 Babl::Utils::Hash.deep_merge(*nodes.values.map(&:pinned_dependencies))
             end
 
-            def schema
+            memoize def schema
                 properties = nodes.map { |k, v| Schema::Object::Property.new(k, v.schema, true) }
                 Schema::Object.new(properties, false)
             end
 
+            memoize def optimize
+                optimized_nodes = nodes.map { |k, v| [k, v.optimize] }.to_h
+                object = self if optimized_nodes.all? { |k, v| v.equal?(nodes[k]) }
+                object ||= Object.new(optimized_nodes)
+
+                return object unless optimized_nodes.values.all? { |node| Constant === node }
+                Constant.new(optimized_nodes.map { |k, v| [k, v.value] }.to_h.freeze, object.schema)
+            end
+
             def render(frame)
                 out = {}
                 nodes.each { |k, v| out[k] = v.render(frame) }
                 out
             end
-
-            def optimize
-                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.nodes.map { |k, v| [k, v.value] }.to_h.freeze, optimized_object.schema)
-            end
         end
     end
 end

data/lib/babl/nodes/parent.rb

@@ -7,28 +7,30 @@ module Babl
         class Parent < Utils::Value.new(:node)
             PARENT_MARKER = Utils::Ref.new
 
-            def schema
+            memoize def schema
                 node.schema
             end
 
-            def pinned_dependencies
+            memoize def pinned_dependencies
                 node.pinned_dependencies
             end
 
-            def dependencies
+            memoize def dependencies
                 { PARENT_MARKER => node.dependencies }
             end
 
+            memoize def optimize
+                optimized = node.optimize
+                return optimized if Constant === optimized
+                return self if optimized.equal?(node)
+                Parent.new(optimized)
+            end
+
             def render(frame)
                 frame.move_backward do |new_frame|
                     node.render(new_frame)
                 end
             end
-
-            def optimize
-                optimized = node.optimize
-                Constant === optimized ? optimized : Parent.new(optimized)
-            end
         end
     end
 end

data/lib/babl/nodes/switch.rb

@@ -13,24 +13,19 @@ module Babl
                 super
             end
 
-            def dependencies
+            memoize def dependencies
                 Babl::Utils::Hash.deep_merge(*nodes.flatten(1).map(&:dependencies))
             end
 
-            def pinned_dependencies
+            memoize def pinned_dependencies
                 Babl::Utils::Hash.deep_merge(*nodes.flatten(1).map(&:pinned_dependencies))
             end
 
-            def schema
+            memoize def schema
                 Schema::AnyOf.canonicalized(nodes.map(&:last).map(&:schema))
             end
 
-            def render(frame)
-                nodes.each { |cond, value| return value.render(frame) if cond.render(frame) }
-                raise Errors::RenderingError, 'A least one switch() condition must be taken'
-            end
-
-            def optimize
+            memoize def optimize
                 optimize_condition_and_values ||
                     optimize_falsy_conditions ||
                     optimize_truthy_conditions ||
@@ -40,6 +35,11 @@ module Babl
                     self
             end
 
+            def render(frame)
+                nodes.each { |cond, value| return value.render(frame) if cond.render(frame) }
+                raise Errors::RenderingError, 'A least one switch() condition must be taken'
+            end
+
             private
 
             def optimize_continue_to_switch

data/lib/babl/nodes/with.rb

@@ -5,25 +5,34 @@ require 'babl/nodes/constant'
 module Babl
     module Nodes
         class With < Utils::Value.new(:node, :nodes, :block)
-            def schema
+            memoize def schema
                 node.schema
             end
 
-            def dependencies
+            memoize def dependencies
                 Babl::Utils::Hash.deep_merge(
                     *nodes.map(&:dependencies),
                     node.dependencies[Parent::PARENT_MARKER] || Utils::Hash::EMPTY
                 )
             end
 
-            def pinned_dependencies
+            memoize def pinned_dependencies
                 Babl::Utils::Hash.deep_merge(*(nodes + [node]).map(&:pinned_dependencies))
             end
 
+            memoize def optimize
+                optimized = node.optimize
+                return optimized if Constant === optimized
+                return optimized.node if Parent === optimized
+                optimized_nodes = nodes.map(&:optimize)
+                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.map { |n| n.render(frame) }
+                values = nodes.empty? ? nil : nodes.map { |n| n.render(frame) }
                 value = begin
-                    block.arity.zero? ? frame.object.instance_exec(&block) : block.call(*values)
+                    nodes.empty? ? frame.object.instance_exec(&block) : block.call(*values)
                 rescue StandardError => e
                     raise Errors::RenderingError, "#{e.message}\n" + frame.formatted_stack(:__block__), e.backtrace
                 end
@@ -32,13 +41,6 @@ module Babl
                     node.render(new_frame)
                 end
             end
-
-            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
     end
 end

data/lib/babl/operators/call.rb

@@ -8,7 +8,11 @@ module Babl
             module DSL
                 # Interpret whatever is passed to this method as BABL template. It is idempotent.
                 def call(*args, &block)
-                    return with(*args, &block) unless block.nil?
+                    if block
+                        raise Errors::InvalidTemplate, 'call() expects no argument when a block is given' unless args.empty?
+                        return with(&block)
+                    end
+
                     raise Errors::InvalidTemplate, 'call() expects exactly 1 argument (unless block)' unless args.size == 1
 
                     arg = args.first

data/lib/babl/rendering/compiled_template.rb

@@ -5,7 +5,7 @@ require 'babl/utils'
 
 module Babl
     module Rendering
-        class CompiledTemplate < Utils::Value.new(:node, :dependencies, :preloader, :pretty, :json_schema)
+        class CompiledTemplate < Utils::Value.new(:node, :dependencies, :preloader, :pretty, :schema)
             def json(root)
                 data = render(root)
                 ::MultiJson.dump(data, pretty: pretty)
@@ -17,6 +17,10 @@ module Babl
                 frame.object = preloaded_data
                 node.render(frame)
             end
+
+            memoize def json_schema
+                schema.json
+            end
         end
     end
 end

data/lib/babl/utils/dsl_proxy.rb

@@ -17,7 +17,7 @@ module Babl
                 undef_method(method) unless NON_PROXIED_METHODS.include?(method)
             end
 
-            # rubocop:disable Style/MethodMissing
+            # rubocop:disable Style/MethodMissingSuper
             def method_missing(method, *args, &block)
                 if @__receiver__.respond_to?(method)
                     @__receiver__.__send__(method, *args, &block)
@@ -25,7 +25,7 @@ module Babl
                     @__fallback__.__send__(method, *args, &block)
                 end
             end
-            # rubocop:enable Style/MethodMissing
+            # rubocop:enable Style/MethodMissingSuper
 
             def respond_to_missing?(method, include_private = false)
                 @__receiver__.respond_to?(method, include_private) ||

data/lib/babl/utils/value.rb

@@ -8,7 +8,6 @@ module Babl
         # - Properties are assumed deeply immutable (#hash is assumed constant & store permanently)
         # - Constructor requires all arguments
         # - #== has the same meaning as #eql?
-        # - The object is frozen
         #
         # Goals :
         # - Create completely immutable value objects
@@ -21,14 +20,17 @@ module Babl
 
                 clazz = super(:_cached_hash, *fields)
                 clazz.const_set(:FIELDS, fields)
-                clazz.class_eval <<-RUBY
+                clazz.class_eval <<-RUBY, __FILE__, __LINE__ + 1
                     def initialize(#{field_aliases.join(',')})
                         super(#{['nil', field_aliases].join(',')})
                         hash
-                        freeze
                     end
                 RUBY
 
+                fields.each { |field|
+                    clazz.send(:define_method, :"#{field}=") { |*| raise ::RuntimeError, 'Object is immutable' }
+                }
+
                 clazz
             end
 
@@ -40,9 +42,25 @@ module Babl
                 eql?(other)
             end
 
-            def self.with(hash = Utils::Hash::EMPTY)
-                raise ::ArgumentError unless ::Hash === hash && (hash.keys - self::FIELDS).empty?
-                new(*self::FIELDS.map { |f| hash.fetch(f) })
+            class << self
+                def with(hash = Utils::Hash::EMPTY)
+                    raise ::ArgumentError unless ::Hash === hash && (hash.keys - self::FIELDS).empty?
+                    new(*self::FIELDS.map { |f| hash.fetch(f) })
+                end
+
+                private
+
+                def memoize(method_name)
+                    old_name = :"_unmemoized_#{method_name}"
+                    alias_method old_name, method_name
+
+                    class_eval <<-RUBY, __FILE__, __LINE__ + 1
+                        def #{method_name}
+                            return @#{old_name} if defined? @#{old_name}
+                            @#{old_name} = #{old_name}
+                        end
+                    RUBY
+                end
             end
         end
     end

data/lib/babl/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: babl-json
 version: !ruby/object:Gem::Version
-  version: 0.5.5
+  version: 0.5.6
 platform: ruby
 authors:
 - Frederic Terrazzoni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-04 00:00:00.000000000 Z
+date: 2018-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coveralls
@@ -100,14 +100,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: '0.51'
+        version: '0.57'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: '0.51'
+        version: '0.57'
 - !ruby/object:Gem::Dependency
   name: multi_json
   requirement: !ruby/object:Gem::Requirement