babl-json 0.2.3 → 0.2.4

data/.ruby-version

@@ -1 +0,0 @@
-2.4.1

data/.travis.yml

@@ -1,4 +0,0 @@
-language: ruby
-install:
-  - bundle install
-script: bundle exec rspec spec && bundle exec rubocop

data/CHANGELOG.md

@@ -1,36 +0,0 @@
-# BABL Changelog
-
-## 0.2.3 (July 21, 2017)
-- Try to simplify JSON-Schema when types are specified.
-- Cut out dependency on [Values](https://github.com/tcrayford/Values).
-
-## 0.2.2 (July 13, 2017)
-
-- Added four typing operators: `integer`, `number`, `string` and `boolean`.
-
-## 0.2.1 (July 11, 2017)
-
-- Fix: array serialization is broken.
-
-## 0.2.0 (July 11, 2017)
-
-- Added support for producing documentation using [JSON-Schema](http://json-schema.org/).
-- Improved some error messages occurring during rendering phase.
-- Stricter validation of templates passed to the `merge` operator. Compilation will fail if at least one of them is not producing object.
-
-## 0.1.4 (July 6, 2017)
-
-- Added operator `extends`, to simplify the common usage pattern `merge(partial(...), ...)`.
-
-## 0.1.3 (June 19, 2017)
-
-- Added operator `null`, in order to make any JSON file a valid BABL template.
-
-## 0.1.2 (May 22, 2017)
-
-- Fixed a bug in `call(primitive)`.
-- Improved test suite.
-
-## 0.1.1 (May 16, 2017)
-
-- First released version.

data/Gemfile

@@ -1,5 +0,0 @@
-ruby File.open('./.ruby-version').readline.split("\n").first
-
-source 'https://rubygems.org' do
-    gemspec
-end

data/LICENSE

@@ -1,7 +0,0 @@
-Copyright 2017 Frederic Terrazzoni
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,89 +0,0 @@
-![BABL Logo](https://github.com/getbannerman/babl/raw/master/logo-babl.png)
-
-[![Build Status](https://travis-ci.org/getbannerman/babl.svg?branch=master)](https://travis-ci.org/getbannerman/babl)
-[![Gem](https://img.shields.io/gem/v/babl-json.svg)](https://rubygems.org/gems/babl-json)
-[![Downloads](https://img.shields.io/gem/dt/babl-json.svg)](https://rubygems.org/gems/babl-json)
-
-BABL (Bannerman API Builder Language) is a templating langage for generating JSON in APIs.
-
-It plays a role similar to [RABL](https://github.com/nesquena/rabl), [JBuilder](https://github.com/rails/jbuilder), [Grape Entity](https://github.com/ruby-grape/grape-entity), [AMS](https://github.com/rails-api/active_model_serializers), and many others. However, unlike existing tools, BABL has several advantages.
-
-
-### Static compilation
-
-BABL is a simple Ruby DSL. Unlike RABL, the template code is fully parsed and executed before any data is available. This approach makes it possible to detect errors earlier and document the output schema automatically, without data. Experimentally, it also makes partials evaluation much faster, because partials are loaded only once.
-
-### Automatic preloading
-
-BABL is also able to infer the "input schema". It can loosely be seen as the list of properties we need to read from the models to construct the JSON output. These *dependencies* can be used to retrieve data more efficiently. For instance, all ActiveRecord associations can be preloaded automatically using this mechanism.
-
-### Simple syntax
-
-JSON is simple, and generating JSON should be as simple as possible.
-
-BABL template:
-
-```ruby
-object(
-    document: object(
-        :id, :title,
-
-        owner: _.nullable.object(:id, :name),
-        authors: _.each.object(:id, :name),
-        category: 'Not implemented'
-    )
-)
-```
-
-Output:
-
-```json
-{
-    "document": {
-        "id": 1,
-        "title": "Hello BABL",
-        "owner": null,
-        "authors": [
-            { "id": 4, "name": "Fred" },
-            { "id": 5, "name": "Vivien" }
-        ],
-        "category": "not implemented"
-    }
-}
-```
-
-Interestingly, this JSON output is also a valid BABL template. This property makes it very easy to mix static JSON and dynamic content during developpement.
-
-## Documentation
-
-Not yet available.
-
-## Current limitations
-
-### Automatic preloading
-
-This feature only works if BABL is configured to use an external preloader.
-
-As of today, the only compatible preloader implementation *has not been released* yet, because it has severe limitations. Hopefully, it will be available soon :-)
-
-### Automatic documentation
-
-The structure of the JSON produced by a BABL template can be documented using [JSON-Schema](http://json-schema.org/).
-
-### Rails integration
-
-This gem implements support of `*.babl` views in [Rails](https://github.com/rails/rails/).
-
-In theory, the template could be compliled once for all and re-used for subsequent requests. In practice, today's implementation will re-compile the template at every request, because Rails templating mechanism doesn't make our life easy.
-
-If it turns out to be a performance bottleneck, we will try to work around this issue.
-
-### Recursion
-
-BABL does not support recursive templates. The first reason is that it makes dependency tracking more complicated (especially on preloader side). The other reason is that it is not as useful as it might seem.
-
-## License
-
-Copyright (c) 2017 [Bannerman](https://www.bannerman.com/), [Frederic Terrazzoni](https://github.com/fterrazzoni)
-
-Licensed under the [MIT license](https://opensource.org/licenses/MIT).

data/babl.gemspec

@@ -1,24 +0,0 @@
-require File.join(File.dirname(__FILE__), 'lib/babl/version')
-
-Gem::Specification.new do |gem|
-    gem.name          = "babl-json"
-    gem.version       = Babl::VERSION
-    gem.licenses      = ['MIT']
-    gem.authors       = ['Frederic Terrazzoni']
-    gem.email         = ['frederic.terrazzoni@gmail.com']
-    gem.description   = "JSON templating on steroids"
-    gem.summary       = gem.description
-    gem.homepage      = 'https://github.com/getbannerman/babl'
-
-    gem.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
-    gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
-    gem.test_files    = gem.files.grep(%r{^spec/})
-    gem.require_paths = ['lib']
-
-    gem.add_development_dependency 'pry', '~> 0'
-    gem.add_development_dependency 'rspec', '~> 3'
-    gem.add_development_dependency 'rubocop', '~> 0.48'
-    gem.add_development_dependency 'json-schema', '~> 2.8'
-
-    gem.add_dependency 'oj', '~> 3.0'
-end

data/spec/operators/array_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-describe Babl::Operators::Array do
-    extend SpecHelper::OperatorTesting
-
-    describe '#array' do
-        context 'statically defined array' do
-            template { array('coucou', 45, a: 1, b: [_]) }
-
-            let(:object) { { b: 12 } }
-
-            it { expect(json).to eq ['coucou', 45, { 'a' => 1, 'b' => [12] }] }
-            it { expect(dependencies).to eq(b: {}) }
-            it {
-                expect(schema).to eq(
-                    s_fixed_array(
-                        s_static('coucou'),
-                        s_static(45),
-                        s_object(
-                            s_property(:a, s_static(1)),
-                            s_property(:b, s_fixed_array(s_anything))
-                        )
-                    )
-                )
-            }
-        end
-
-        context 'nullable array' do
-            template { nullable.array(itself) }
-
-            let(:object) { 1 }
-
-            it { expect(json).to eq([1]) }
-            it { expect(schema).to eq s_any_of(s_null, s_fixed_array(s_anything)) }
-        end
-    end
-end

data/spec/operators/call_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-
-describe Babl::Operators::Call do
-    extend SpecHelper::OperatorTesting
-
-    describe '#call' do
-        context 'primitive' do
-            template { call(false) }
-
-            it { expect(json).to eq false }
-            it { expect(dependencies).to eq({}) }
-            it { expect(schema).to eq s_static(false) }
-
-            context 'call primitive after a conditional' do
-                template { nullable.call(34) }
-
-                it { expect(json).to eq nil }
-            end
-        end
-
-        context 'block' do
-            template { call { self * 2 } }
-
-            let(:object) { 2 }
-
-            it { expect(json).to eq 4 }
-        end
-
-        context 'hash' do
-            template { call('a' => 1, b: 2) }
-
-            it { expect(json).to eq('a' => 1, 'b' => 2) }
-            it { expect(dependencies).to eq({}) }
-        end
-
-        context 'array' do
-            template { call(['a', 2, :b]) }
-
-            let(:object) { { b: 42 } }
-
-            it { expect(json).to eq(['a', 2, 42]) }
-            it { expect(dependencies).to eq(b: {}) }
-        end
-
-        context 'block' do
-            template { call(:lol) }
-
-            let(:object) { OpenStruct.new(lol: 'tam') }
-
-            it { expect(json).to eq 'tam' }
-            it { expect(dependencies).to eq(lol: {}) }
-        end
-
-        context 'template' do
-            template { object(coucou: nav(:a).call(nav(:b))) }
-
-            let(:object) { OpenStruct.new(a: OpenStruct.new(b: 1)) }
-
-            it { expect(dependencies).to eq(a: { b: {} }) }
-            it { expect(json).to eq('coucou' => 1) }
-            it { expect(schema).to eq(s_object(s_property(:coucou, s_anything))) }
-        end
-    end
-end

data/spec/operators/continue_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-describe Babl::Operators::Continue do
-    extend SpecHelper::OperatorTesting
-
-    describe '#switch' do
-        context 'navigation before continue' do
-            template { nav(:abc).switch(false => 1, default => nav(:lol).continue).object(val: nav(:ok)) }
-
-            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplate }
-        end
-
-        context 'continue without switch' do
-            template { continue }
-
-            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplate }
-        end
-
-        context 'continue in sub-object' do
-            template { object(a: switch(default => object(x: continue))) }
-
-            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplate }
-        end
-    end
-end

data/spec/operators/default_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-require 'spec_helper'
-
-describe Babl::Operators::Default do
-    extend SpecHelper::OperatorTesting
-
-    describe '#default' do
-        template { default }
-
-        it { expect(json).to eq true }
-        it { expect(schema).to eq s_static(true) }
-        it { expect(dependencies).to eq({}) }
-    end
-end

data/spec/operators/dep_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-describe Babl::Operators::Dep do
-    extend SpecHelper::OperatorTesting
-
-    describe '#dep' do
-        template { dep(a: [:b, :c]).nav(:b).dep(x: :y).nav(:z) }
-
-        let(:object) { { b: { z: 42 } } }
-
-        it { expect(schema).to eq s_anything }
-        it { expect(dependencies).to eq(a: { b: {}, c: {} }, b: { x: { y: {} }, z: {} }) }
-        it { expect(json).to eq(42) }
-    end
-end

data/spec/operators/each_spec.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-describe Babl::Operators::Each do
-    extend SpecHelper::OperatorTesting
-
-    describe '#each' do
-        context 'when everything is fine' do
-            template { each.nav(:a) }
-
-            let(:object) { [{ a: 3 }, { a: 2 }, { a: 1 }] }
-
-            it { expect(json).to eq [3, 2, 1] }
-            it { expect(dependencies).to eq(__each__: { a: {} }) }
-            it { expect(schema).to eq s_dyn_array(s_anything) }
-        end
-
-        context 'error while navigating' do
-            template { nav(:box).each.nav(:trololol) }
-
-            let(:object) { { box: [{ trololol: 2 }, 42] } }
-
-            it { expect { json }.to raise_error(/\__root__\.box\.1\.trololol/) }
-        end
-
-        context 'not enumerable' do
-            template { nav(:lol).each }
-
-            let(:object) { { lol: 'not enumerable' } }
-
-            it { expect { json }.to raise_error(Babl::Errors::RenderingError, /\__root__\.lol/) }
-        end
-
-        context 'nullable array' do
-            template { nullable.each.nullable.object }
-
-            let(:object) { [1, nil] }
-
-            it { expect(json).to eq [{}, nil] }
-            it { expect(schema).to eq s_any_of(s_dyn_array(s_any_of(s_object, s_null)), s_null) }
-        end
-    end
-end

data/spec/operators/enter_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe Babl::Operators::Enter do
-    extend SpecHelper::OperatorTesting
-
-    describe '#enter' do
-        context 'invalid usage' do
-            template { enter }
-
-            it { expect { compiled }.to raise_error Babl::Errors::InvalidTemplate }
-        end
-
-        context 'valid usage' do
-            template { object(a: enter) }
-
-            let(:object) { { a: 42 } }
-
-            it { expect(schema).to eq(s_object(s_property(:a, s_anything))) }
-            it { expect(dependencies).to eq(a: {}) }
-            it { expect(json).to eq('a' => 42) }
-
-            context 'using alias' do
-                template { object(a: _) }
-                it { expect(json).to eq('a' => 42) }
-            end
-        end
-    end
-end

data/spec/operators/extends_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-describe Babl::Operators::Extends do
-    extend SpecHelper::OperatorTesting
-
-    let(:custom_lookup_context) {
-        TestLookupContext.new(
-            object_partial: TestLookupContext.new('object(a: 1, b: 3)'),
-            string_partial: TestLookupContext.new('"lol"')
-        )
-    }
-    let(:dsl) { Babl::Template.new.with_lookup_context(custom_lookup_context) }
-    let(:object) { [nil] }
-
-    context 'simple use case' do
-        template { each.extends('object_partial', object(x: 1), b: 34) }
-        it { expect(json).to eq(['a' => 1, 'x' => 1, 'b' => 34]) }
-    end
-
-    context 'extend a non-object' do
-        template { extends('string_partial') }
-        it { expect(json).to eq('lol') }
-        it { expect(schema).to eq s_static('lol') }
-    end
-
-    context 'extend a non-object and try to add properties' do
-        template { each.extends('string_partial', test: 1) }
-        it { expect { schema }.to raise_error Babl::Errors::InvalidTemplate }
-    end
-end