frise 0.3.0.pre → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 72db98e097cb7abccf1a1208a53efa9a2486d49d3f58422a70e6f32ac7cbb2a8
-  data.tar.gz: 52f15d4c10262d54dc7534fa35c16abb66ad33d0498ceff612cc78124154fcf4
+  metadata.gz: 5923c848338d6a2f7dfc35211200ab51a789ad9e9967742e4eb57430346785e9
+  data.tar.gz: e08f1fdf3a14fe288ad67a0baa6a9e557294de9ac5ea814426e9b92792b1be95
 SHA512:
-  metadata.gz: 75b318b997eb2ab66dada979b270e468430ca372982d035bba4de12a68a0622f6897d928e173b67d7e046be2ecdee0d7b1374e0a0d50da55e80354d60285eb9f
-  data.tar.gz: b25a7625181eaf4d90f202ca0aa9dc9095ada98318272c2d5c999beb8ea28e0e7af397b1612692bd18709a59dca4cab758d30ee515563806d6def511500243e7
+  metadata.gz: a578f2042b86832986bed1cecbe435330e509e2f6f166ff7302c3eeca37e445bc7acbbcbd4fe16d3cf9c23be68603cd9d4e13f17c508edaeff5e96169b41eaa9
+  data.tar.gz: 1c4378dcec5e8738f25248d6a45fcc96b4392f7144995e08d57407abd3bf1ad5bfe506fe6e1117aa4caef7900dcedfba9dc8b4267b1c4cd6d273c5395313cd2f

data/CHANGELOG.md

@@ -1,11 +1,26 @@
+### 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/ShiftForward/frise/pull/5)).
+    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/ShiftForward/frise/pull/4)).
+    ([#4](https://github.com/velocidi/frise/pull/4)).
 
 ### 0.1.0 (August 10, 2017)
 

data/README.md

@@ -1,12 +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.
 
@@ -24,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')
@@ -44,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,
@@ -75,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,
@@ -106,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/frise.gemspec

@@ -20,12 +20,12 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
   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 'rake', '~> 12.3'
   spec.add_development_dependency 'rspec', '~> 3.4'
-  spec.add_development_dependency 'rubocop', '~> 0.53.0'
+  spec.add_development_dependency 'rubocop', '0.55.0'
   spec.add_development_dependency 'simplecov', '~> 0.14.1'
 end

data/lib/frise/defaults_loader.rb

@@ -7,67 +7,75 @@ 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
-      SYMBOLS = %w[$all $optional].freeze
+  class DefaultsLoader
+    SYMBOLS = %w[$all $optional].freeze
 
-      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
+    def initialize(include_sym: '$include', content_include_sym: '$content_include', schema_sym: '$schema')
+      @include_sym = include_sym
+      @content_include_sym = content_include_sym
+      @schema_sym = schema_sym
+    end
 
-      def merge_defaults_obj(config, defaults)
-        if defaults.nil?
-          config
+    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
 
-        elsif config.nil?
-          if defaults.class != Hash then defaults
-          elsif defaults['$optional'] then nil
-          else merge_defaults_obj({}, defaults)
-          end
+    def merge_defaults_obj(config, defaults)
+      config_class = widened_class(config)
+      defaults_class = widened_class(defaults)
 
-        elsif defaults.class == Array && config.class == Array
-          defaults + config
+      if defaults.nil?
+        config
 
-        elsif defaults.class == Hash && defaults['$all'] && config.class == Array
-          config.map { |elem| merge_defaults_obj(elem, defaults['$all']) }
+      elsif config.nil?
+        if defaults_class != 'Hash' then defaults
+        elsif defaults['$optional'] then nil
+        else merge_defaults_obj({}, defaults)
+        end
 
-        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 == 'Array' && config_class == 'Array'
+        defaults + config
 
-        elsif widened_class(defaults) != widened_class(config)
-          raise "Cannot merge config #{config.inspect} (#{widened_class(config)}) " \
-            "with default #{defaults.inspect} (#{widened_class(defaults)})"
+      elsif defaults_class == 'Hash' && defaults['$all'] && config_class == 'Array'
+        config.map { |elem| merge_defaults_obj(elem, defaults['$all']) }
 
-        else
-          config
+      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
-      end
+        new_config
 
-      def merge_defaults_obj_at(config, at_path, defaults)
-        at_path.reverse.each { |key| defaults = { key => defaults } }
-        merge_defaults_obj(config, defaults)
-      end
+      elsif defaults_class != config_class
+        raise "Cannot merge config #{config.inspect} (#{widened_class(config)}) " \
+          "with default #{defaults.inspect} (#{widened_class(defaults)})"
 
-      def merge_defaults(config, defaults_file, symbol_table = config)
-        defaults = Parser.parse(defaults_file, symbol_table) || {}
-        merge_defaults_obj(config, defaults)
+      else
+        config
       end
+    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
+    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

@@ -10,12 +10,25 @@ module Frise
   #
   # The load method loads a configuration file, merges the applicable includes and validates its schema.
   class Loader
-    def initialize(include_sym: '$include', schema_sym: '$schema', pre_loaders: [], validators: nil, exit_on_fail: true)
+    def initialize(include_sym: '$include',
+                   content_include_sym: '$content_include',
+                   schema_sym: '$schema',
+                   pre_loaders: [],
+                   validators: nil,
+                   exit_on_fail: true)
+
       @include_sym = include_sym
+      @content_include_sym = content_include_sym
       @schema_sym = schema_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
+      )
     end
 
     def load(config_file, global_vars = {})
@@ -36,35 +49,49 @@ module Frise
     def process_includes(config, at_path, root_config, global_vars)
       return config unless config.class == Hash
 
-      config, defaults_confs = extract_include(config)
-      if defaults_confs.empty?
+      # 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
+
+      # process $include directives
+      config, include_confs = extract_include(config, at_path)
+      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
-          defaults_confs.each do |defaults_conf|
-            extra_vars = (defaults_conf['vars'] || {}).map { |k, v| [k, root_config.dig(*v.split('.'))] }.to_h
-            extra_consts = defaults_conf['constants'] || {}
-            symbol_table = merge_at(root_config, at_path, config)
-                           .merge(global_vars).merge(extra_vars).merge(extra_consts).merge('_this' => config)
+          include_confs.each do |include_conf|
+            symbol_table = build_symbol_table(root_config, at_path, config, global_vars, include_conf)
+            included_config = Parser.parse(include_conf['file'], symbol_table)
 
-            config = DefaultsLoader.merge_defaults_obj(config, Parser.parse(defaults_conf['file'], symbol_table))
+            config = @defaults_loader.merge_defaults_obj(config, included_config)
+            config = process_includes(config, at_path, merge_at(root_config, at_path, config), global_vars)
           end
-          process_includes(config, at_path, merge_at(root_config, at_path, config), global_vars)
+          updated_root_config = merge_at(root_config, at_path, config)
+          config.map { |k, v| [k, process_includes(v, at_path + [k], updated_root_config, global_vars)] }.to_h
         end
       end
     end
 
-    def process_schema_includes(schema, global_vars)
+    def process_schema_includes(schema, at_path, global_vars)
       return schema unless schema.class == Hash
 
-      schema, included_schemas = extract_include(schema)
+      schema, included_schemas = extract_include(schema, at_path)
       if included_schemas.empty?
-        schema.map { |k, v| [k, process_schema_includes(v, global_vars)] }.to_h
+        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, global_vars)
+        process_schema_includes(schema, at_path, global_vars)
       end
     end
 
@@ -77,10 +104,10 @@ module Frise
         [k, new_v]
       end.to_h
 
-      config, schema_files = extract_schema(config)
+      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, global_vars)
+        schema = process_schema_includes(schema, at_path, global_vars)
 
         errors = Validator.validate_obj(config,
                                         schema,
@@ -93,37 +120,68 @@ module Frise
       config
     end
 
-    def extract_schema(config)
-      extract_special(config, @schema_sym) do |value|
+    def extract_schema(config, at_path)
+      extract_special(config, @schema_sym, at_path) do |value|
         case value
         when String then value
-        else raise "Illegal value for a #{@schema_sym} element: #{value.inspect}"
+        else raise "At #{build_path(at_path)}: illegal value for a #{@schema_sym} element: #{value.inspect}"
         end
       end
     end
 
-    def extract_include(config)
-      extract_special(config, @include_sym) do |value|
+    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 "Illegal value for a #{@include_sym} element: #{value.inspect}"
+        else raise "At #{build_path(at_path)}: illegal value for a #{sym} element: #{value.inspect}"
         end
       end
     end
 
-    def extract_special(config, key)
+    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 "Illegal value for #{key}: #{config[key].inspect}"
+      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
+
+    # 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'] || {}
+
+      (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/parser.rb

@@ -10,15 +10,20 @@ module Frise
     class << self
       def parse(file, symbol_table = nil)
         return nil unless File.file? file
-        content = File.open(file).read
+        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
-        YAML.safe_load(content, [], [], true) || {}
+        content
       end
 
       private
 
       def with_internal_vars(file, symbol_table)
-        symbol_table.merge('_file_dir' => File.dirname(file))
+        symbol_table.merge('_file_dir' => File.expand_path(File.dirname(file)))
       end
     end
   end

data/lib/frise/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Frise
-  VERSION = '0.3.0.pre'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: frise
 version: !ruby/object:Gem::Version
-  version: 0.3.0.pre
+  version: 0.3.0
 platform: ruby
 authors:
 - ShiftForward
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-02 00:00:00.000000000 Z
+date: 2018-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: liquid
@@ -16,14 +16,14 @@ 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
@@ -84,16 +84,16 @@ dependencies:
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.53.0
+        version: 0.55.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.53.0
+        version: 0.55.0
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -147,9 +147,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.7.6