frise 0.1.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 41db8000684dfb7ee23cc7f26a790a57bb38ad76
-  data.tar.gz: 782cf2ff2d3866a754950fd8edd3735a1bb1f425
+SHA256:
+  metadata.gz: 86558df34daa0ba92e7e7a1863ceb5124ea52c39dc82a85924c4db1bd89cf127
+  data.tar.gz: fd286367be54e292a6df52daa6f5255810d6e3980bce538d0c2391d5fdab9ca9
 SHA512:
-  metadata.gz: c37c19e1f9edbad815b30d52f867d4344fd3b3da8a376e30236814a47ddd579b889459b1a702190fe5d1c1d2b99afdc3abef685f54a062616ea632872640a5e2
-  data.tar.gz: c9c87e93dbd3b361a5632431ac8f83650749c7d1de090c3397299b403cda7e1a986767356d8795dc3cf037f9461227a8287dd3870df79a573031ee5928d31931
+  metadata.gz: c48f86d8190c30bf650055dfa7749ecdf9d2545f4a6c34593c29e402c0da06dd5420eb8244c3f112f8501564a5bf26798acae2fbeb006c10bb1c4eb5dc4e7c1a
+  data.tar.gz: 679a4edb6364662160f4e1d6872c8949e3fd6338433da50de5a109addec0a31dec69b3013ca4038fbb40283383b15f160ecf4723c546dea53ab6a8d75db6f77c

data/.rubocop.yml

@@ -1,2 +1,10 @@
+AllCops:
+  TargetRubyVersion: '2.3'
+Layout/EmptyLineAfterGuardClause:
+  Enabled: false
 Metrics:
   Enabled: false
+Naming/BlockParameterName:
+  Enabled: false
+Naming/MethodParameterName:
+  Enabled: false

data/.travis.yml

@@ -1,6 +1,10 @@
 language: ruby
+cache: bundler
 rvm:
-  - 2.1
-  - 2.2
   - 2.3
   - 2.4
+  - 2.5
+  - 2.6
+  - 2.7
+before_install:
+  - gem install bundler

data/CHANGELOG.md

@@ -0,0 +1,43 @@
+### 0.4.1 (July 7, 2020)
+
+- New features
+  - `$delete` directive is now available in config files, allowing users to delete parts of the
+    config sub-tree ([#20](https://github.com/velocidi/frise/pull/20)).
+
+### 0.4.0 (November 29, 2019)
+
+- Breaking changes
+  - Recursive inclusions now respect the hierarchy of configuration files, avoiding inclusions lower
+    in the hiearchy to be resolved before ones higher in the hierarchy
+    ([#14](https://github.com/velocidi/frise/pull/14)).
+- Bug fixes
+  - Fix error messages from validations happening deeper in the config hierarchy, that were wrongly
+    missing the first character in their path ([#16](https://github.com/velocidi/frise/pull/16)).
+
+### 0.3.0 (April 16, 2018)
+
+- Breaking changes
+  - Defaults and schemas are now defined using a directive in the YAML configs instead of
+    implicitly by looking at load paths. See ([#7](https://github.com/velocidi/frise/pull/7)) for
+    more information on migration;
+- New features
+  - `$include` and `$schema` directives are now available in config files, allowing users to
+    validate and include defaults at any part of the config
+    ([#7](https://github.com/velocidi/frise/pull/7));
+  - A new `$content_include` directive allows users to include the content of a file as a YAML
+    string ([#8](https://github.com/velocidi/frise/pull/8));
+  - The `_file_dir` Liquid variable is now available in all included files, containing always the
+    absolute path to the file being loaded ([#7](https://github.com/velocidi/frise/pull/7)).
+
+### 0.2.0 (August 17, 2017)
+
+- New features
+  - New schema types `$enum` and `$one_of` for specifying enumerations and values with multiple
+    possible schemas ([#5](https://github.com/velocidi/frise/pull/5)).
+- Bug fixes
+  - Deal correctly with non-existing schema files in the load path
+    ([#4](https://github.com/velocidi/frise/pull/4)).
+
+### 0.1.0 (August 10, 2017)
+
+Initial version.

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in frise.gemspec

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright 2017 ShiftForward, S.A. [http://www.shiftforward.eu]
+Copyright 2017-2019 Velocidi [http://www.velocidi.com/]
 
 Licensed under the Apache License, Version 2.0 (the "License"); you may not
 use this file except in compliance with the License. You may obtain a copy of

data/README.md

@@ -1,11 +1,13 @@
 # Frise
-[![Build Status](https://travis-ci.org/ShiftForward/frise.svg?branch=master)](https://travis-ci.org/ShiftForward/frise)
-[![Coverage Status](https://coveralls.io/repos/github/ShiftForward/frise/badge.svg?branch=master)](https://coveralls.io/github/ShiftForward/frise?branch=master)
+[![Build Status](https://travis-ci.org/velocidi/frise.svg?branch=master)](https://travis-ci.org/velocidi/frise)
+[![Coverage Status](https://coveralls.io/repos/github/velocidi/frise/badge.svg?branch=master)](https://coveralls.io/github/velocidi/frise?branch=master)
+[![Gem Version](https://badge.fury.io/rb/frise.svg)](https://badge.fury.io/rb/frise)
 
 Frise is a library for loading configuration files as native Ruby structures. Besides reading and
 parsing the files themselves, it also:
 
-- Completes it with default values specified in another file or set of files;
+- Allows defining other files to be merged anywhere in the config, which can be used to provide default values specified
+  in another file or set of files;
 - Interprets [Liquid](https://shopify.github.io/liquid) templates in configs and defaults;
 - Validates the loaded config according to a schema file or set of files.
 
@@ -23,7 +25,6 @@ The simplest example would be to load [a simple configuration](example/config.ym
 
 ```ruby
 require 'frise'
-require 'pp'
 
 loader = Frise::Loader.new
 loader.load('example/config.yml')
@@ -43,12 +44,11 @@ Currently Frise only supports YAML files, but it may support JSON and other form
 
 ### Default values
 
-By defining directories where the files with default values can be found (in this example,
-[example/_defaults](example/_defaults)), Frise can handle its application internally on load time:
+By using the `$include` directive pointing to the files where default values can be found (in this example,
+[example/_defaults/config.yml](example/_defaults/config.yml)), Frise can handle its application internally on load time:
 
 ```ruby
-loader = Frise::Loader.new(defaults_load_paths: ['example/_defaults'])
-loader.load('example/config.yml')
+loader.load('example/config_with_defaults.yml')
 # => {"movies"=>
 #     [{"title"=>"The Shawshank Redemption",
 #       "year"=>1994,
@@ -74,15 +74,11 @@ config.
 ### Schemas
 
 Additionally, configuration files can also be validated against a schema. By specifying
-`schema_load_paths`, users can provide directories where schema files such as
-[example/_schemas/config.yml](example/_schemas/config.yml) can be found:
+`$schema` in the config, users can provide schema files such as
+[example/_schemas/config.yml](example/_schemas/config.yml):
 
 ```ruby
-loader = Frise::Loader.new(
-  schema_load_paths: ['example/_schemas'],
-  defaults_load_paths: ['example/_defaults'])
-
-loader.load('example/config.yml')
+loader.load('example/config_with_defaults_and_schema.yml')
 # {"movies"=>
 #   [{"title"=>"The Shawshank Redemption",
 #     "year"=>1994,
@@ -105,16 +101,14 @@ missing and Frise by default prints a summary of the errors and terminates the p
 
 
 ```ruby
-loader = Frise::Loader.new(schema_load_paths: ['example/_schemas'])
-
-loader.load('example/config.yml')
+loader.load('example/config_with_schema.yml')
 # 2 config error(s) found:
 #  - At movies.0.director: missing required value
 #  - At ui: missing required value
 ```
 
 Once more, the structure of the schema mimics the structure of the config itself, making it easy to
-write schemas and to create a config scaffold from its schema later.
+write schemas first and create a config scaffold from its schema later.
 
 Users can check a whole range of properties in config values besides their type: optional values,
 hashes with validated keys, hashes with unknown keys and even custom validations are also supported.

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'bundler/gem_tasks'
 
 def load_if_available(req_path)

data/frise.gemspec

@@ -1,31 +1,31 @@
-# coding: utf-8
+# frozen_string_literal: true
 
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'frise/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'frise'
   spec.version       = Frise::VERSION
-  spec.authors       = ['ShiftForward']
-  spec.email         = ['info@shiftforward.eu']
+  spec.authors       = ['Velocidi']
+  spec.email         = ['hello@velocidi.com']
 
   spec.summary       = 'Ruby config library with schema validation, default values and templating'
-  spec.homepage      = 'https://github.com/ShiftForward/frise'
+  spec.homepage      = 'https://github.com/velocidi/frise'
   spec.license       = 'Apache-2.0'
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features|example)/})
   end
   spec.require_paths = ['lib']
-  spec.required_ruby_version = '>= 2.1.0'
+  spec.required_ruby_version = '>= 2.3.0'
 
-  spec.add_dependency 'liquid', '~> 3.0'
+  spec.add_dependency 'liquid', '~> 4.0'
 
-  spec.add_development_dependency 'bundler', '~> 1.14'
-  spec.add_development_dependency 'coveralls', '~> 0.8.21'
-  spec.add_development_dependency 'simplecov', '~> 0.14.1'
-  spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'rspec', '~> 3.4'
-  spec.add_development_dependency 'rubocop', '~> 0.49.1'
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'coveralls', '~> 0.8'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec', '~> 3.9'
+  spec.add_development_dependency 'rubocop', '0.77.0'
+  spec.add_development_dependency 'simplecov', '~> 0.16'
 end

data/lib/frise.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require 'frise/defaults_loader'
+require 'frise/loader/lazy'
 require 'frise/loader'
 require 'frise/parser'
 require 'frise/validator'

data/lib/frise/defaults_loader.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'frise/parser'
 
 module Frise
@@ -5,65 +7,79 @@ module Frise
   #
   # The merge_defaults and merge_defaults_at entrypoint methods provide ways to read files with
   # defaults and apply them to configuration objects.
-  module DefaultsLoader
-    class << self
-      def widened_class(obj)
-        class_name = obj.class.to_s
-        return 'Boolean' if %w[TrueClass FalseClass].include? class_name
-        return 'Integer' if %w[Fixnum Bignum].include? class_name
-        class_name
-      end
+  class DefaultsLoader
+    SYMBOLS = %w[$all $optional].freeze
+
+    def initialize(include_sym: '$include', content_include_sym: '$content_include', schema_sym: '$schema', delete_sym: '$delete')
+      @include_sym = include_sym
+      @content_include_sym = content_include_sym
+      @schema_sym = schema_sym
+      @delete_sym = delete_sym
+    end
+
+    def widened_class(obj)
+      class_name = obj.class.to_s
+      return 'String' if class_name == 'Hash' && !obj[@content_include_sym].nil?
+      return 'Boolean' if %w[TrueClass FalseClass].include? class_name
+      return 'Integer' if %w[Fixnum Bignum].include? class_name
+      class_name
+    end
 
-      def merge_defaults_obj(config, defaults)
-        if defaults.nil?
-          config
-
-        elsif config.nil?
-          if defaults.class != Hash then defaults
-          elsif defaults['$optional'] then nil
-          else merge_defaults_obj({}, defaults)
-          end
-
-        elsif defaults.class == Array && config.class == Array
-          defaults + config
-
-        elsif defaults.class == Hash && defaults['$all'] && config.class == Array
-          config.map { |elem| merge_defaults_obj(elem, defaults['$all']) }
-
-        elsif defaults.class == Hash && config.class == Hash
-          new_config = {}
-          (config.keys + defaults.keys).uniq.each do |key|
-            next if key.start_with?('$')
-            new_config[key] = config[key]
-            new_config[key] = merge_defaults_obj(new_config[key], defaults[key]) if defaults.key?(key)
-            new_config[key] = merge_defaults_obj(new_config[key], defaults['$all']) unless new_config[key].nil?
-            new_config.delete(key) if new_config[key].nil?
-          end
-          new_config
-
-        elsif widened_class(defaults) != widened_class(config)
-          raise "Cannot merge config #{config.inspect} (#{widened_class(config)}) " \
-            "with default #{defaults.inspect} (#{widened_class(defaults)})"
-
-        else
-          config
+    def merge_defaults_obj(config, defaults)
+      config_class = widened_class(config)
+      defaults_class = widened_class(defaults)
+
+      if defaults.nil?
+        config
+
+      elsif config.nil?
+        if defaults_class != 'Hash' then defaults
+        elsif defaults['$optional'] then nil
+        else merge_defaults_obj({}, defaults)
         end
-      end
 
-      def merge_defaults_obj_at(config, at_path, defaults)
-        at_path.reverse.each { |key| defaults = { key => defaults } }
-        merge_defaults_obj(config, defaults)
-      end
+      elsif config == @delete_sym
+        config
 
-      def merge_defaults(config, defaults_file, symbol_table = config)
-        defaults = Parser.parse(defaults_file, symbol_table)
-        merge_defaults_obj(config, defaults)
-      end
+      elsif defaults_class == 'Array' && config_class == 'Array'
+        defaults + config
 
-      def merge_defaults_at(config, at_path, defaults_file, symbol_table = config)
-        defaults = Parser.parse(defaults_file, symbol_table)
-        merge_defaults_obj_at(config, at_path, defaults)
+      elsif defaults_class == 'Hash' && defaults['$all'] && config_class == 'Array'
+        config.map { |elem| merge_defaults_obj(elem, defaults['$all']) }
+
+      elsif defaults_class == 'Hash' && config_class == 'Hash'
+        new_config = {}
+        (config.keys + defaults.keys).uniq.each do |key|
+          next if SYMBOLS.include?(key)
+          new_config[key] = config[key]
+          new_config[key] = merge_defaults_obj(new_config[key], defaults[key]) if defaults.key?(key)
+          new_config[key] = merge_defaults_obj(new_config[key], defaults['$all']) unless new_config[key].nil?
+          new_config.delete(key) if new_config[key].nil?
+        end
+        new_config
+
+      elsif defaults_class != config_class
+        raise "Cannot merge config #{config.inspect} (#{widened_class(config)}) " \
+          "with default #{defaults.inspect} (#{widened_class(defaults)})"
+
+      else
+        config
       end
     end
+
+    def merge_defaults_obj_at(config, at_path, defaults)
+      at_path.reverse.each { |key| defaults = { key => defaults } }
+      merge_defaults_obj(config, defaults)
+    end
+
+    def merge_defaults(config, defaults_file, symbol_table = config)
+      defaults = Parser.parse(defaults_file, symbol_table) || {}
+      merge_defaults_obj(config, defaults)
+    end
+
+    def merge_defaults_at(config, at_path, defaults_file, symbol_table = config)
+      defaults = Parser.parse(defaults_file, symbol_table) || {}
+      merge_defaults_obj_at(config, at_path, defaults)
+    end
   end
 end

data/lib/frise/loader.rb

@@ -1,60 +1,200 @@
+# frozen_string_literal: true
+
 require 'frise/defaults_loader'
+require 'frise/loader/lazy'
 require 'frise/parser'
 require 'frise/validator'
 
 module Frise
   # The entrypoint for loading configs from files according to the conventions defined for Frise.
   #
-  # The load method loads a configuration file, merges it with the applicable defaults and validates
-  # its schema. Other methods in Loader perform only parts of the process.
+  # The load method loads a configuration file, merges the applicable includes and validates its schema.
   class Loader
-    def initialize(schema_load_paths: [], defaults_load_paths: [], pre_loaders: [], validators: nil)
-      @schema_load_paths = schema_load_paths
-      @defaults_load_paths = defaults_load_paths
+    def initialize(include_sym: '$include',
+                   content_include_sym: '$content_include',
+                   schema_sym: '$schema',
+                   delete_sym: '$delete',
+                   pre_loaders: [],
+                   validators: nil,
+                   exit_on_fail: true)
+
+      @include_sym = include_sym
+      @content_include_sym = content_include_sym
+      @schema_sym = schema_sym
+      @delete_sym = delete_sym
       @pre_loaders = pre_loaders
       @validators = validators
+      @exit_on_fail = exit_on_fail
+
+      @defaults_loader = DefaultsLoader.new(
+        include_sym: include_sym,
+        content_include_sym: content_include_sym,
+        schema_sym: schema_sym,
+        delete_sym: delete_sym
+      )
     end
 
-    def load(config_file, exit_on_fail = true, symbol_table = {})
-      config = Parser.parse(config_file, symbol_table)
-      config_name = File.basename(config_file)
+    def load(config_file, global_vars = {})
+      config = Parser.parse(config_file, global_vars)
+      return nil unless config
 
       @pre_loaders.each do |pre_loader|
         config = pre_loader.call(config)
       end
 
-      config = merge_defaults(config, config_name, symbol_table)
-      validate(config, config_name, exit_on_fail)
+      config = process_includes(config, [], config, global_vars) unless @include_sym.nil?
+      config = process_schemas(config, [], global_vars) unless @schema_sym.nil?
+      config
     end
 
-    def merge_defaults(config, defaults_name, symbol_table = {})
-      merge_defaults_at(config, [], defaults_name, symbol_table)
-    end
+    private
 
-    def merge_defaults_at(config, at_path, defaults_name, symbol_table = {})
-      @defaults_load_paths.map do |defaults_dir|
-        defaults_file = File.join(defaults_dir, defaults_name)
-        config = DefaultsLoader.merge_defaults_at(
-          config, at_path, defaults_file, symbol_table.merge(config)
-        )
+    def process_includes(config, at_path, root_config, global_vars, include_confs_stack = [])
+      return config unless config.class == Hash
+
+      # process $content_include directives
+      config, content_include_confs = extract_content_include(config, at_path)
+      unless content_include_confs.empty?
+        raise "At #{build_path(at_path)}: a #{@content_include_sym} must not have any sibling key" unless config.empty?
+
+        content = ''
+        content_include_confs.each do |include_conf|
+          symbol_table = build_symbol_table(root_config, at_path, nil, global_vars, include_conf)
+          content += Parser.parse_as_text(include_conf['file'], symbol_table) || ''
+        end
+        return content
       end
-      config
+
+      # process $include directives
+      config, next_include_confs = extract_include(config, at_path)
+      include_confs = next_include_confs + include_confs_stack
+      res = if include_confs.empty?
+              config.map { |k, v| [k, process_includes(v, at_path + [k], root_config, global_vars)] }.to_h
+            else
+              Lazy.new do
+                include_conf = include_confs.first
+                rest_include_confs = include_confs[1..-1]
+                symbol_table = build_symbol_table(root_config, at_path, config, global_vars, include_conf)
+                included_config = Parser.parse(include_conf['file'], symbol_table)
+                config = @defaults_loader.merge_defaults_obj(config, included_config)
+                process_includes(config, at_path, merge_at(root_config, at_path, config), global_vars, rest_include_confs)
+              end
+            end
+      @delete_sym.nil? ? res : omit_deleted(res)
     end
 
-    def validate(config, schema_name, exit_on_fail = true)
-      validate_at(config, [], schema_name, exit_on_fail)
+    def process_schema_includes(schema, at_path, global_vars)
+      return schema unless schema.class == Hash
+
+      schema, included_schemas = extract_include(schema, at_path)
+      if included_schemas.empty?
+        schema.map { |k, v| [k, process_schema_includes(v, at_path + [k], global_vars)] }.to_h
+      else
+        included_schemas.each do |defaults_conf|
+          schema = Parser.parse(defaults_conf['file'], global_vars).merge(schema)
+        end
+        process_schema_includes(schema, at_path, global_vars)
+      end
     end
 
-    def validate_at(config, at_path, schema_name, exit_on_fail = true)
-      @schema_load_paths.map do |schema_dir|
-        schema_file = File.join(schema_dir, schema_name)
-        errors = Validator.validate_at(config, at_path, schema_file,
-                                       validators: @validators,
-                                       print: exit_on_fail,
-                                       fatal: exit_on_fail)
+    def process_schemas(config, at_path, global_vars)
+      return config unless config.class == Hash
+
+      config = config.map do |k, v|
+        new_v = process_schemas(v, at_path + [k], global_vars)
+        return nil if !v.nil? && new_v.nil?
+        [k, new_v]
+      end.to_h
+
+      config, schema_files = extract_schema(config, at_path)
+      schema_files.each do |schema_file|
+        schema = Parser.parse(schema_file, global_vars)
+        schema = process_schema_includes(schema, at_path, global_vars)
+
+        errors = Validator.validate_obj(config,
+                                        schema,
+                                        path_prefix: at_path,
+                                        validators: @validators,
+                                        print: @exit_on_fail,
+                                        fatal: @exit_on_fail)
         return nil if errors.any?
       end
       config
     end
+
+    def extract_schema(config, at_path)
+      extract_special(config, @schema_sym, at_path) do |value|
+        case value
+        when String then value
+        else raise "At #{build_path(at_path)}: illegal value for a #{@schema_sym} element: #{value.inspect}"
+        end
+      end
+    end
+
+    def extract_include(config, at_path)
+      extract_include_base(config, @include_sym, at_path)
+    end
+
+    def extract_content_include(config, at_path)
+      extract_include_base(config, @content_include_sym, at_path)
+    end
+
+    def extract_include_base(config, sym, at_path)
+      extract_special(config, sym, at_path) do |value|
+        case value
+        when Hash then value
+        when String then { 'file' => value }
+        else raise "At #{build_path(at_path)}: illegal value for a #{sym} element: #{value.inspect}"
+        end
+      end
+    end
+
+    def extract_special(config, key, at_path)
+      case config[key]
+      when nil then [config, []]
+      when Array then [config.reject { |k| k == key }, config[key].map { |e| yield e }]
+      else raise "At #{build_path(at_path)}: illegal value for #{key}: #{config[key].inspect}"
+      end
+    end
+
+    # merges the `to_merge` value on `config` at path `at_path`
+    def merge_at(config, at_path, to_merge)
+      return config.merge(to_merge) if at_path.empty?
+      head, *tail = at_path
+      config.merge(head => merge_at(config[head], tail, to_merge))
+    end
+
+    # returns the config without the keys whose values are @delete_sym
+    def omit_deleted(config)
+      config.each_with_object({}) do |(k, v), new_hash|
+        if v.is_a?(Hash)
+          new_hash[k] = omit_deleted(v)
+        else
+          new_hash[k] = v unless v == @delete_sym
+        end
+      end
+    end
+
+    # builds the symbol table for the Liquid renderization of a file, based on:
+    #   - `root_config`: the root of the whole config
+    #   - `at_path`: the current path
+    #   - `config`: the config subtree being built
+    #   - `global_vars`: the global variables
+    #   - `include_conf`: the $include or $content_include configuration
+    def build_symbol_table(root_config, at_path, config, global_vars, include_conf)
+      extra_vars = (include_conf['vars'] || {}).map { |k, v| [k, root_config.dig(*v.split('.'))] }.to_h
+      extra_consts = include_conf['constants'] || {}
+
+      omit_deleted(config ? merge_at(root_config, at_path, config) : root_config)
+        .merge(global_vars)
+        .merge(extra_vars)
+        .merge(extra_consts)
+        .merge('_this' => config)
+    end
+
+    # builds a user-friendly string indicating a path
+    def build_path(at_path)
+      at_path.empty? ? '<root>' : at_path.join('.')
+    end
   end
 end

data/lib/frise/loader/lazy.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Frise
+  class Loader
+    # A basic proxy object.
+    class Lazy < BasicObject
+      def initialize(&callable)
+        @callable = callable
+      end
+
+      def __target_object__
+        @__target_object__ ||= @callable.call
+      end
+
+      # rubocop:disable Style/MethodMissingSuper
+      def method_missing(method_name, *args, &block)
+        __target_object__.send(method_name, *args, &block)
+      end
+      # rubocop:enable Style/MethodMissingSuper
+
+      def respond_to_missing?(method_name, include_private = false)
+        __target_object__.respond_to?(method_name, include_private)
+      end
+    end
+  end
+end

data/lib/frise/parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'liquid'
 require 'yaml'
 
@@ -7,10 +9,21 @@ module Frise
   module Parser
     class << self
       def parse(file, symbol_table = nil)
-        return {} unless File.file? file
-        content = File.open(file).read
-        content = Liquid::Template.parse(content).render symbol_table if symbol_table
-        YAML.safe_load(content, [], [], true) || {}
+        return nil unless File.file? file
+        YAML.safe_load(parse_as_text(file, symbol_table), [], [], true) || {}
+      end
+
+      def parse_as_text(file, symbol_table = nil)
+        return nil unless File.file? file
+        content = File.read(file)
+        content = Liquid::Template.parse(content).render with_internal_vars(file, symbol_table) if symbol_table
+        content
+      end
+
+      private
+
+      def with_internal_vars(file, symbol_table)
+        symbol_table.merge('_file_dir' => File.expand_path(File.dirname(file)))
       end
     end
   end

data/lib/frise/validator.rb

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'frise/parser'
 require 'set'
@@ -26,21 +27,23 @@ module Frise
     end
 
     def add_validation_error(path, msg)
-      logged_path = path.empty? ? '<root>' : path[1..-1]
+      logged_path = path.empty? ? '<root>' : path
       @errors << "At #{logged_path}: #{msg}"
     end
 
     def get_full_schema(schema)
       case schema
-      when Hash then schema
+      when Hash then
+        default_type = schema[:enum] || schema[:one_of] ? 'Object' : 'Hash'
+        { type: default_type }.merge(schema)
       when Symbol then { type: 'Object', validate: schema }
-      when Array then
+      when Array
         if schema.size == 1
           { type: 'Array', all: schema[0] }
         else
           (raise "Invalid schema: #{schema.inspect}")
         end
-      when String then
+      when String
         if schema.end_with?('?')
           { type: schema[0..-2], optional: true }
         else
@@ -80,17 +83,39 @@ module Frise
       if full_schema[:validate]
         begin
           @validators.method(full_schema[:validate]).call(@root, obj)
-        rescue StandardError => ex
-          add_validation_error(path, ex.message)
+        rescue StandardError => e
+          add_validation_error(path, e.message)
         end
       end
       true
     end
 
+    def validate_enum(full_schema, obj, path)
+      if full_schema[:enum] && !full_schema[:enum].include?(obj)
+        add_validation_error(path, "invalid value #{obj.inspect}. " \
+          "Accepted values are #{full_schema[:enum].map(&:inspect).join(', ')}")
+        return false
+      end
+      true
+    end
+
+    def validate_one_of(full_schema, obj, path)
+      if full_schema[:one_of]
+        full_schema[:one_of].each do |schema_opt|
+          opt_validator = Validator.new(@root, @validators)
+          opt_validator.validate_object(path, obj, schema_opt)
+          return true if opt_validator.errors.empty?
+        end
+        add_validation_error(path, "#{obj.inspect} does not match any of the possible schemas")
+        return false
+      end
+      true
+    end
+
     def validate_spec_keys(full_schema, obj, path, processed_keys)
       full_schema.each do |spec_key, spec_value|
         next if spec_key.is_a?(Symbol)
-        validate_object("#{path}.#{spec_key}", obj[spec_key], spec_value)
+        validate_object(path.empty? ? spec_key : "#{path}.#{spec_key}", obj[spec_key], spec_value)
         processed_keys << spec_key
       end
       true
@@ -101,13 +126,11 @@ module Frise
       if expected_types.size == 1 && expected_types[0].ancestors.member?(Enumerable)
         hash = obj.is_a?(Hash) ? obj : Hash[obj.map.with_index { |x, i| [i, x] }]
         hash.each do |key, value|
-          if full_schema[:all_keys] && !key.is_a?(Symbol)
-            validate_object(path, key, full_schema[:all_keys])
-          end
+          validate_object(path, key, full_schema[:all_keys]) if full_schema[:all_keys] && !key.is_a?(Symbol)
 
           next if processed_keys.member? key
           if full_schema[:all]
-            validate_object("#{path}.#{key}", value, full_schema[:all])
+            validate_object(path.empty? ? key : "#{path}.#{key}", value, full_schema[:all])
           elsif !full_schema[:allow_unknown_keys]
             add_validation_error(path, "unknown key: #{key}")
           end
@@ -122,6 +145,8 @@ module Frise
       return unless validate_optional(full_schema, obj, path)
       return unless validate_type(full_schema, obj, path)
       return unless validate_custom(full_schema, obj, path)
+      return unless validate_enum(full_schema, obj, path)
+      return unless validate_one_of(full_schema, obj, path)
 
       processed_keys = Set.new
       return unless validate_spec_keys(full_schema, obj, path, processed_keys)
@@ -138,32 +163,36 @@ module Frise
     end
 
     def self.validate_obj(config, schema, options = {})
-      validator = Validator.new(config, options[:validators])
-      validator.validate_object('', config, schema)
+      validate_obj_at(config, [], schema, **options)
+    end
+
+    def self.validate_obj_at(config, at_path, schema, path_prefix: nil, validators: nil, print: nil, fatal: nil, raise_error: nil)
+      schema = parse_symbols(schema)
+      at_path.reverse.each { |key| schema = { key => schema, :allow_unknown_keys => true } }
+
+      validator = Validator.new(config, validators)
+      validator.validate_object((path_prefix || []).join('.'), config, schema)
 
       if validator.errors.any?
-        if options[:print]
+        if print
           puts "#{validator.errors.length} config error(s) found:"
           validator.errors.each do |error|
             puts " - #{error}"
           end
         end
 
-        exit 1 if options[:fatal]
-        raise ValidationError.new(validator.errors), 'Invalid configuration' if options[:raise_error]
+        exit 1 if fatal
+        raise ValidationError.new(validator.errors), 'Invalid configuration' if raise_error
       end
       validator.errors
     end
 
     def self.validate(config, schema_file, options = {})
-      schema = parse_symbols(Parser.parse(schema_file))
-      validate_obj(config, schema, options)
+      validate_obj_at(config, [], Parser.parse(schema_file) || { allow_unknown_keys: true }, **options)
     end
 
     def self.validate_at(config, at_path, schema_file, options = {})
-      schema = parse_symbols(Parser.parse(schema_file))
-      at_path.reverse.each { |key| schema = { key => schema, :allow_unknown_keys => true } }
-      validate_obj(config, schema, options)
+      validate_obj_at(config, at_path, Parser.parse(schema_file) || { allow_unknown_keys: true }, **options)
     end
   end
 

data/lib/frise/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Frise
-  VERSION = '0.1.0'.freeze
+  VERSION = '0.4.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: frise
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.4.1
 platform: ruby
 authors:
-- ShiftForward
+- Velocidi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-10 00:00:00.000000000 Z
+date: 2020-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: liquid
@@ -16,101 +16,101 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.21
+        version: '0.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.21
+        version: '0.8'
 - !ruby/object:Gem::Dependency
-  name: simplecov
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.14.1
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.14.1
+        version: '13.0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '3.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '3.9'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '3.4'
+        version: 0.77.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '3.4'
+        version: 0.77.0
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.49.1
+        version: '0.16'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.49.1
+        version: '0.16'
 description: 
 email:
-- info@shiftforward.eu
+- hello@velocidi.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -119,6 +119,7 @@ files:
 - ".rspec"
 - ".rubocop.yml"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -127,10 +128,11 @@ files:
 - lib/frise.rb
 - lib/frise/defaults_loader.rb
 - lib/frise/loader.rb
+- lib/frise/loader/lazy.rb
 - lib/frise/parser.rb
 - lib/frise/validator.rb
 - lib/frise/version.rb
-homepage: https://github.com/ShiftForward/frise
+homepage: https://github.com/velocidi/frise
 licenses:
 - Apache-2.0
 metadata: {}
@@ -142,15 +144,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.1.0
+      version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: Ruby config library with schema validation, default values and templating