babl-json 0.3.4 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 36cb4d94d13851bb8c5a28ab9d8c4ab5a19fa6de
-  data.tar.gz: '0298c5489089f88c5ce9a171568e418fb8cb0dc6'
+  metadata.gz: 03dff31c23ccad4de2970e0e9f1e8c0ac2df3257
+  data.tar.gz: 88bfe61b0d2fcfc20ff71a4e009d6ddf15416e00
 SHA512:
-  metadata.gz: a0b1e9ce1e461766292ad33f43aa528d61c8fde897a94a7791a8c4b9ffcfb0f53806fbaea2dad7b981c8d2131552b20f22550aaa1eb01888449a2af08cedec50
-  data.tar.gz: 8ad1d7732551481f3309dd06797fe11faaa3aec11c8bc222972c4789c721b427c37f22fbedd987e139fc37174f87c3933dea272c7bd9054be7ced88dadaf725c
+  metadata.gz: c9c04e5150dd7aeda65aefcb989f4a72eb5aed5b5afd0f18edae0495818e45b6fad658c1d693375ff711329c0c036e0c333d0d5ce99349f100c8a2da0b98f07c
+  data.tar.gz: 720f05f879639374ab4a26bc7be49b4d32c6fb7c8534621643d09bb2d3a4f402cedc8af994682268760fcdc2418ac72e6cf7e9ffd9bda8dbf14d4d914683cec7

data/lib/babl/nodes.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require 'babl/nodes/concat'
 require 'babl/nodes/create_pin'
 require 'babl/nodes/dep'
 require 'babl/nodes/each'

data/lib/babl/nodes/concat.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+require 'babl/errors'
+require 'babl/utils'
+require 'babl/schema'
+
+module Babl
+    module Nodes
+        class Concat < Utils::Value.new(:nodes)
+            def dependencies
+                nodes.map(&:dependencies).reduce(Utils::Hash::EMPTY) { |a, b| Babl::Utils::Hash.deep_merge(a, b) }
+            end
+
+            def pinned_dependencies
+                nodes.map(&:pinned_dependencies).reduce(Utils::Hash::EMPTY) { |a, b| Babl::Utils::Hash.deep_merge(a, b) }
+            end
+
+            def schema
+                nodes.map(&:schema).reduce(Schema::FixedArray::EMPTY) { |a, b| merge_doc(a, b) }
+            end
+
+            def render(ctx)
+                out = []
+                nodes.each { |node|
+                    values = node.render(ctx)
+                    case values
+                    when ::NilClass then nil
+                    when ::Array then out.concat(values)
+                    else raise Errors::RenderingError, "Only arrays can be concatenated\n" + ctx.formatted_stack
+                    end
+                }
+                out
+            end
+
+            def optimize
+                optimize_empty ||
+                    optimize_single ||
+                    optimize_concatenated_arrays ||
+                    optimize_preconcat_constant ||
+                    self
+            end
+
+            private
+
+            def optimize_empty
+                Constant.new(Utils::Array::EMPTY, Schema::FixedArray::EMPTY) if nodes.empty?
+            end
+
+            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
+                end
+            end
+
+            def optimize_concatenated_arrays
+                optimized_nodes = nodes.map(&:optimize)
+                return if optimized_nodes == nodes
+                Concat.new(optimized_nodes).optimize
+            end
+
+            def optimize_preconcat_constant
+                nodes.each_cons(2).each_with_index do |(obj1, obj2), idx|
+                    obj1 = constant_to_array(obj1) if Constant === obj1
+                    obj2 = constant_to_array(obj2) if Constant === obj2
+                    next unless FixedArray === obj1 && FixedArray === obj2
+                    new_nodes = nodes.dup
+                    new_nodes[idx] = FixedArray.new(obj1.nodes + obj2.nodes)
+                    new_nodes[idx + 1] = nil
+                    return Concat.new(new_nodes.compact).optimize
+                end
+                nil
+            end
+
+            def constant_to_array(constant)
+                case constant.schema
+                when Schema::FixedArray
+                    FixedArray.new(constant.schema.items.each_with_index.map { |item, index|
+                        Constant.new(constant.value[index], item)
+                    })
+                when Schema::Primitive::NULL
+                    FixedArray::EMPTY
+                end
+            end
+
+            # Merging documentations from concatenated hashes is lossy, because neither JSON-Schema
+            # or our internal representation of arrays is able to model that.
+            def merge_doc(doc1, doc2)
+                doc1 = Schema::FixedArray::EMPTY if doc1 == Schema::Primitive::NULL
+                doc2 = Schema::FixedArray::EMPTY if doc2 == Schema::Primitive::NULL
+
+                case
+                when Schema::Anything === doc1 || Schema::Anything === doc2
+                    Schema::DynArray.new(Schema::Anything.instance)
+                when Schema::FixedArray === doc1 && Schema::FixedArray === doc2
+                    Schema::FixedArray.new(doc1.items + doc2.items)
+                when Schema::AnyOf === doc2
+                    Schema::AnyOf.canonicalized(doc2.choice_set.map { |c| merge_doc(doc1, c) })
+                when Schema::AnyOf === doc1
+                    Schema::AnyOf.canonicalized(doc1.choice_set.map { |c| merge_doc(c, doc2) })
+                when Schema::DynArray === doc1 && Schema::FixedArray === doc2
+                    Schema::DynArray.new(Schema::AnyOf.canonicalized([doc1.item] + doc2.items))
+                when Schema::FixedArray === doc1 && Schema::DynArray === doc2
+                    Schema::DynArray.new(Schema::AnyOf.canonicalized(doc1.items + [doc2.item]))
+                when Schema::DynArray === doc1 && Schema::DynArray === doc2
+                    Schema::DynArray.new(Schema::AnyOf.canonicalized([doc1.item, doc2.item]))
+                else raise Errors::InvalidTemplate, 'Only arrays can be concatenated'
+                end
+            end
+        end
+    end
+end

data/lib/babl/nodes/fixed_array.rb

@@ -6,6 +6,8 @@ require 'babl/nodes/constant'
 module Babl
     module Nodes
         class FixedArray < Utils::Value.new(:nodes)
+            EMPTY = new(Utils::Array::EMPTY)
+
             def schema
                 Schema::FixedArray.new(nodes.map(&:schema))
             end

data/lib/babl/nodes/merge.rb

@@ -29,8 +29,8 @@ module Babl
             def optimize
                 optimize_empty ||
                     optimize_single ||
-                    optimize_merged_objects ||
                     optimize_nested_merges ||
+                    optimize_merged_objects ||
                     optimize_premergeable_objects ||
                     self
             end
@@ -45,14 +45,17 @@ module Babl
                 return unless nodes.size == 1
                 optimized = nodes.first.optimize
                 case
-                when Object === optimized then optimized
-                when Constant === optimized && optimized.value.nil? then Object::EMPTY
+                when Object === optimized
+                    optimized
+                when Constant === optimized
+                    optimized.value.nil? ? Object::EMPTY : optimized
                 end
             end
 
             def optimize_merged_objects
                 optimized_nodes = nodes.map(&:optimize)
-                optimized_nodes == nodes ? nil : Merge.new(optimized_nodes).optimize
+                return if optimized_nodes == nodes
+                Merge.new(optimized_nodes).optimize
             end
 
             def optimize_nested_merges
@@ -80,6 +83,8 @@ module Babl
                     Object.new(constant.schema.property_set.map { |property|
                         [property.name, Constant.new(constant.value[property.name], property.value)]
                     }.to_h)
+                when Schema::Primitive::NULL
+                    Object::EMPTY
                 end
             end
 

data/lib/babl/operators.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require 'babl/operators/array'
 require 'babl/operators/call'
+require 'babl/operators/concat'
 require 'babl/operators/continue'
 require 'babl/operators/default'
 require 'babl/operators/dep'

data/lib/babl/operators/concat.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+require 'babl/nodes'
+
+module Babl
+    module Operators
+        module Concat
+            module DSL
+                # Produce an array by concatening the provided result of the given templates.
+                # (they therefor have to produce arrays, or nil, which is interpreted as an empty array)
+                def concat(*templates)
+                    templates = templates.map { |t| unscoped.call(t) }
+
+                    construct_terminal { |context|
+                        Nodes::Concat.new(
+                            templates.map { |t|
+                                t.builder.precompile(
+                                    Nodes::TerminalValue.instance,
+                                    context.merge(continue: nil)
+                                )
+                            }
+                        )
+                    }
+                end
+            end
+        end
+    end
+end

data/lib/babl/schema/any_of.rb

@@ -26,6 +26,8 @@ module Babl
                     simplify_push_down_dyn_array ||
                     simplify_dyn_and_fixed_array ||
                     simplify_merge_objects ||
+                    simplify_integer_is_number ||
+                    simplify_many_fixed_arrays ||
                     self
             end
 
@@ -35,6 +37,31 @@ module Babl
 
             private
 
+            def simplify_integer_is_number
+                return unless choice_set.include?(Typed::INTEGER) && choice_set.include?(Typed::NUMBER)
+                AnyOf.canonicalized(choice_set - [Typed::INTEGER])
+            end
+
+            # AnyOf[FixedArray(Item1, Item2), FixedArray(Item3, Item4)] can be summarized
+            # by DynArray(AnyOf(Item1, Item2, Item3, Item4)). It is a lossy transformation
+            # but it will help reducing the number of permutations when the operator concat() is used.
+            def simplify_many_fixed_arrays
+                choice_set.each_with_index { |obj1, index1|
+                    next unless FixedArray === obj1
+
+                    choice_set.each_with_index { |obj2, index2|
+                        break if index2 >= index1
+                        next unless FixedArray === obj2
+
+                        return AnyOf.canonicalized(choice_set - [obj1, obj2] + [
+                            DynArray.new(AnyOf.new(obj1.items + obj2.items))
+                        ])
+                    }
+                }
+
+                nil
+            end
+
             # We can completely get rid of the AnyOf element of there is only one possible schema.
             def simplify_single
                 choice_set.size == 1 ? choice_set.first : nil
@@ -96,7 +123,7 @@ module Babl
                 nil
             end
 
-            # Merge all objects together. This is the only lossy simplification, but it will greatly reduce the size
+            # Merge all objects together. This is a lossy simplification, but it will greatly reduce the size
             # of the generated schema. On top of that, when the JSON-Schema is translated into Typescript, it produces
             # a much more workable type definition (union of anonymous object types is not practical to use)
             def simplify_merge_objects

data/lib/babl/schema/fixed_array.rb

@@ -7,7 +7,11 @@ module Babl
             EMPTY = new([])
 
             def json
-                { type: 'array', items: items.map(&:json) }
+                if items.empty?
+                    { enum: [[]] }
+                else
+                    { type: 'array', items: items.map(&:json), additionalItems: false }
+                end
             end
         end
     end

data/lib/babl/template.rb

@@ -6,6 +6,7 @@ module Babl
     class Template < Babl::Builder::TemplateBase
         include Operators::Array::DSL
         include Operators::Call::DSL
+        include Operators::Concat::DSL
         include Operators::Continue::DSL
         include Operators::Default::DSL
         include Operators::Dep::DSL

data/lib/babl/utils.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require 'babl/utils/array'
 require 'babl/utils/hash'
 require 'babl/utils/ref'
 require 'babl/utils/value'

data/lib/babl/utils/array.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+module Babl
+    module Utils
+        class Array
+            EMPTY = [].freeze
+        end
+    end
+end

data/lib/babl/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: babl-json
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.4.0
 platform: ruby
 authors:
 - Frederic Terrazzoni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-01 00:00:00.000000000 Z
+date: 2017-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -135,6 +135,7 @@ files:
 - lib/babl/builder/template_base.rb
 - lib/babl/errors.rb
 - lib/babl/nodes.rb
+- lib/babl/nodes/concat.rb
 - lib/babl/nodes/constant.rb
 - lib/babl/nodes/create_pin.rb
 - lib/babl/nodes/dep.rb
@@ -154,6 +155,7 @@ files:
 - lib/babl/operators.rb
 - lib/babl/operators/array.rb
 - lib/babl/operators/call.rb
+- lib/babl/operators/concat.rb
 - lib/babl/operators/continue.rb
 - lib/babl/operators/default.rb
 - lib/babl/operators/dep.rb
@@ -189,6 +191,7 @@ files:
 - lib/babl/schema/typed.rb
 - lib/babl/template.rb
 - lib/babl/utils.rb
+- lib/babl/utils/array.rb
 - lib/babl/utils/dsl_proxy.rb
 - lib/babl/utils/hash.rb
 - lib/babl/utils/ref.rb