babl-json 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 656d75b72add7bd391267cf72e6e45959a5aaf7d
+  data.tar.gz: 34c2a76f614a357da5ac05a18c37f7bd585c8e5c
+SHA512:
+  metadata.gz: 8c651ce6396f0c2ea87fe1d1be350074c3425ff6c2718940e0ff404a889e805c483fa88e4442d7dc5d9e1b4457af62bec0650d301f7aa1882d5034895e84c383
+  data.tar.gz: '08b57f384167c02bf9268bab025261394726d285051e8a583f76bf0f8a47264c12af1dcc7427ff8bd1e560fc081a11abe7bb9289cf8e4bcb9855adfb410695ed'

data/.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+Gemfile.lock
+*.gem

data/.rubocop.yml

@@ -0,0 +1,228 @@
+AllCops:
+  Include:
+    - Gemfile
+    - '**/*.babl'
+  TargetRubyVersion: 2.3
+
+# Begin -- Keep the following
+CaseIndentation:
+    EnforcedStyle: end
+
+Metrics/LineLength:
+    Max: 130
+
+Metrics/PerceivedComplexity:
+    Max: 12
+
+ParameterLists:
+    Max: 5
+    CountKeywordArgs: false
+
+Rails:
+    Enabled: False
+
+Style/AlignParameters:
+    EnforcedStyle: with_fixed_indentation
+
+Style/AndOr:
+    EnforcedStyle: conditionals
+
+Style/BlockDelimiters:
+    Enabled: False
+
+Style/CollectionMethods:
+    Enabled: True
+
+Style/Documentation:
+    Enabled: False
+
+Style/ExtraSpacing:
+    Enabled: True
+
+Style/IndentationWidth:
+    Width: 4
+
+Style/IndentHash:
+    EnforcedStyle: consistent
+
+Style/Lambda:
+    Enabled: False
+
+Style/MultilineIfModifier:
+    Enabled: False
+
+Style/MultilineOperationIndentation:
+    EnforcedStyle: indented
+
+Style/NumericLiterals:
+    Enabled: False
+
+Style/SignalException:
+    EnforcedStyle: only_raise
+# End -- Keep the following
+
+Lint/AmbiguousBlockAssociation:
+    Enabled: False
+
+Lint/EmptyWhen:
+    Enabled: False
+
+Lint/EndAlignment:
+    Enabled: False
+
+Lint/InheritException:
+    Enabled: False
+
+Lint/NestedMethodDefinition:
+    Enabled: False
+
+Lint/SafeNavigationChain:
+    Enabled: True
+
+Lint/UnneededSplatExpansion:
+    Enabled: False
+
+Lint/UselessAccessModifier:
+    Enabled: False
+
+
+Metrics/AbcSize:
+    Enabled: False
+    Max: 30
+
+Metrics/BlockLength:
+    Enabled: False
+    Max: 25
+
+Metrics/ClassLength:
+    Enabled: False
+    Max: 200
+
+Metrics/CyclomaticComplexity:
+    Enabled: False
+    Max: 10
+
+Metrics/MethodLength:
+    Enabled: False
+    Max: 20
+
+Metrics/ModuleLength:
+    Enabled: False
+
+
+Performance/Casecmp:
+    Enabled: False
+
+
+Rails/Blank:
+    Enabled: False
+
+Rails/Date:
+    Enabled: False
+
+Rails/DynamicFindBy:
+    Enabled: False
+
+Rails/FilePath:
+    Enabled: False
+
+Rails/PluralizationGrammar:
+    Enabled: False
+
+Rails/RelativeDateConstant:
+    Enabled: False
+
+Rails/SkipsModelValidations:
+    Enabled: False
+
+Rails/TimeZone:
+    Enabled: False
+
+
+Security/YAMLLoad:
+    Enabled: False
+
+
+Style/Alias:
+    Enabled: False
+
+Style/ConditionalAssignment:
+    Enabled: False
+
+Style/ClassVars:
+    Enabled: False
+
+Style/EmptyCaseCondition:
+    Enabled: False
+
+Style/EmptyLineAfterMagicComment:
+    Enabled: False
+
+Style/EmptyMethod:
+    Enabled: False
+
+Style/FileName:
+    Enabled: False
+
+Style/FrozenStringLiteralComment:
+    Enabled: False
+
+Style/GuardClause:
+    Enabled: False
+
+Style/IndentArray:
+    Enabled: False
+
+Style/IndentHeredoc:
+    Enabled: False
+
+Style/MixinGrouping:
+    Enabled: False
+
+Style/MultilineBlockChain:
+    Enabled: False
+
+Style/MultilineMemoization:
+    Enabled: False
+
+Style/MultilineMethodCallIndentation:
+    Enabled: False
+
+Style/MutableConstant:
+    Enabled: False
+
+Style/NestedParenthesizedCalls:
+    Enabled: False
+
+Style/Next:
+    Enabled: False
+
+Style/NumericPredicate:
+    Enabled: False
+
+Style/ParallelAssignment:
+    Enabled: False
+
+Style/RedundantParentheses:
+    Enabled: False
+
+Style/RedundantSelf:
+    Enabled: False
+
+Style/SafeNavigation:
+    Enabled: False
+
+Style/SingleLineBlockParams:
+    Enabled: False
+
+Style/CaseEquality:
+    Enabled: False
+
+Style/StringLiterals:
+    Enabled: False
+
+Style/SymbolArray:
+    Enabled: False
+
+Style/VariableNumber:
+    Enabled: False

data/.ruby-version

@@ -0,0 +1 @@
+2.3.1

data/.travis.yml

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

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# BABL Changelog
+
+## 0.1 (May 16, 2017)
+
+- First released version

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,87 @@
+# BABL #
+
+[![Build Status](https://travis-ci.org/getbannerman/babl.svg?branch=master)](https://travis-ci.org/getbannerman/babl)
+
+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), 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. The approach makes it possible to detect errors earlier and document the output schema automatically, without data.
+
+### 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"
+    }
+}
+```
+
+## Documentation
+
+TODO
+
+## 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. Hopefully, it will be available soon :-)
+
+### Automatic documentation
+
+Support for automatic documentation is very limited, and the output is indecently ugly. It is more a proof-of-concept that a useful feature.
+
+The mid-term goal is to generate a [JSON schema](http://json-schema.org/) documentation.
+
+### 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

@@ -0,0 +1,23 @@
+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_dependency 'oj', '~> 3.0'
+end

data/lib/babl.rb

@@ -0,0 +1,41 @@
+require 'babl/railtie' if defined?(Rails)
+require 'babl/template'
+require 'babl/version'
+
+module Babl
+    class BablError < StandardError; end
+    class InvalidTemplateError < BablError; end
+    class RenderingError < BablError; end
+
+    class Config
+        attr_accessor :search_path, :preloader, :pretty
+
+        def initialize
+            @search_path = nil
+            @preloader = Babl::Rendering::NoopPreloader
+            @pretty = true
+        end
+    end
+
+    class << self
+        def compile(template: ::Babl::Template.new, &source)
+            if config.search_path
+                ctx = ::Babl::Operators::Partial::AbsoluteLookupContext.new(config.search_path)
+                template = template.with_lookup_context(ctx)
+            end
+
+            template.source(&source).compile(
+                pretty: config.pretty,
+                preloader: config.preloader
+            )
+        end
+
+        def configure
+            yield(config)
+        end
+
+        def config
+            @config ||= Config.new
+        end
+    end
+end

data/lib/babl/builder/chain_builder.rb

@@ -0,0 +1,85 @@
+module Babl
+    module Builder
+        # Builder provides a simple framework for defining & chaining BABL's operators easily.
+        #
+        # Compiling a template is a multi-phase process:
+        #
+        # 1- [BABL => ChainBuilder] Template definition (via Builder#construct_node & Builder#construct_terminal) :
+        #        The operator chain is created by wrapping blocks (current block stored in 'scope')
+        #
+        # 2- [Builder => BoundOperator] Template binding (via Builder#bind) :
+        #        A BoundOperator is created for each operator and passed to the next, in left-to-right
+        #        order. This step is necessary to propagate context from root to leaves. A typical
+        #        use-case is the 'enter' operator, which requires the parent context in which it is called.
+        #
+        # 3- [BoundOperator => Node] Node precompilation (via Builder#precompile):
+        #        BoundOperators are transformed into a Node tree, in right-to-left order. Each node
+        #        contains its own rendering logic, dependency tracking & documentation generator.
+        #
+        # 4- [Node => CompiledTemplate] Compilation output: (via Template#compile):
+        #        The resulting Node is used to compute the dependencies & generate the documentation.
+        #        Finally, we pack everything is a CompiledTemplate which is exposed to the user.
+        #
+        class ChainBuilder
+            def initialize(&block)
+                @scope = block
+            end
+
+            def precompile(node, **context)
+                bind(BoundOperator.new(context)).precompile(node)
+            end
+
+            def bind(bound)
+                @scope[bound]
+            end
+
+            # Append a terminal operator, and return a new Builder object
+            def construct_terminal
+                construct_node do |node, context|
+                    unless [Rendering::InternalValueNode.instance, Rendering::TerminalValueNode.instance].include?(node)
+                        raise ::Babl::InvalidTemplateError, 'Chaining is not allowed after a terminal operator'
+                    end
+                    yield context
+                end
+            end
+
+            # Append an operator to the chain, and return a new Builder object
+            def construct_node(**new_context)
+                wrap { |bound|
+                    bound.nest(bound.context.merge(new_context)) { |node|
+                        yield(node, bound.context)
+                    }
+                }
+            end
+
+            def wrap
+                rescope { |bound| yield bind(bound) }
+            end
+
+            def rescope(&block)
+                dup.tap { |tb| tb.instance_variable_set(:@scope, block) }
+            end
+        end
+
+        class BoundOperator
+            attr_reader :context
+
+            def initialize(context, &scope)
+                @context = context
+                @scope = scope || :itself.to_proc
+            end
+
+            def precompile(node)
+                scope[node]
+            end
+
+            def nest(context)
+                self.class.new(context) { |node| scope[yield node] }
+            end
+
+            private
+
+            attr_reader :scope
+        end
+    end
+end