app_config_loader 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: af7599d6ae9f0d3b78dc84c98ba95af7eba9999d
+  data.tar.gz: 73403a0498d2f8b518cd1f33e6de5267d205938d
+SHA512:
+  metadata.gz: eb5b8805a947bf0bbe9aae295b3f8d0b04369631c6b78cbbc491ba62c4c697dff17375f80465a773a3aa44bea3aa1f4ad0dfa3c1168aea5ddd3790fa3a33bdf8
+  data.tar.gz: 29560b75a9d77fa13ea173de079eb0fbb966ab122df19de33103b3d23a6740edda43a4cc8ce8e6deccd5cb20cc746ef7b6b888c7f9116dbe28c15e6aa9ffd6bf

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rbenv
+.ruby-version
+
+# rubymine
+/.idea

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.0
+before_install: gem install bundler -v 1.10.4

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in app-config-rails.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 lscspirit
+
+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,190 @@
+# AppConfigLoader
+
+A easy way to define application configurations using YAML in your Rails environment.
+
+## Getting Started
+
+Add the following line to your Gemfile:
+
+```ruby
+gem 'app_config_loader'
+```
+
+Run the bundle command to install it.
+
+Create a YAML file in the default directory `config/app_configs` to put your app config. For example:
+
+```YAML
+# config/app_configs/some_service.yml
+
+'*.some_service':
+  'host': dev.someservice.com
+
+'production.some_service':
+  'host': prod.someservice.com
+```
+
+Create an initializer `config/initializers/00_app_config.rb` to configure and initialize AppConfigLoader. Typically, you would want AppConfigLoader to be the first thing to be initialized so that you can access your app config values in the remaining Rails initialization process. This is why the initializer filename has the '00_' prefix.
+
+
+```ruby
+# config/initializers/00_app_config.rb
+
+APP_CONFIG = AppConfigLoader.load
+```
+
+From this point onward, you can access your app config values through `APP_CONFIG`.
+
+```ruby
+# when AppConfigLoader' env is not "production"
+APP_CONFIG['some_service.host']  # => 'dev.someservice.com'
+
+# when AppConfigLoader' env is set to "production"
+APP_CONFIG['some_service.host']  # => 'prod.someservice.com'
+```
+
+## Configuration
+
+You can configure where and how AppConfigLoader load your app config file(s).
+
+```ruby
+APP_CONFIG = AppConfigLoader.load do |config|
+  config.use_domain = true
+  config.domain = 'us'
+  config.config_paths << '/path/to/additional_config.yml'
+end
+```
+
+Below is a list of all the settings available:
+
+* `config.env` - (String) app config environment. This determines which set of app config values to load. **Default:** `Rails.env`.
+* `config.use_domain` - (Boolean) whether the app config key uses a domain. **Default:** `false`.
+* `config.domain` - (String) app config domain. This determines which set of app config values to load. It is only applicable if `use_domain` is set to true. **Default:** `nil`
+* `config.config_paths` - (Array&lt;String&gt;) a list of paths from where app config YAML files should be loaded. Path can either be a file or a directory. With a directory path, all YAML files within that directory will be loaded. **Default:** `['<rails root>/config/app_configs']`.
+* `config.local_overrides` - (String) path to a local overrides app config file. Entries in this file take precedence over all values from other files. **Default:** `<rails root>/config/app_configs/local_overrides.yml`.
+
+## Defining your App Configs
+
+All app configs are defined as key-value entries in YAML format. A app config value can be any valid YAML value, except for Hash. The app config key must follow either of the format below depending on whether `use_domain` is enabled:
+
+* `<env>.<key...>` - when `use_domain` is disabled (e.g. `production.some_service.host`)
+* `<env>.<domain>.<key...>` - when `use_domain` is enabled (e.g. `production.us.some_service.host`)
+
+#### Basic Example
+
+```ruby
+# app config in YAML file
+'test.timeout': 3000
+'test.some_service.host': 'dev.someservice.com'
+
+'production.timeout': 500
+'production.some_service.host': 'prod.someservice.com'
+'production.some_service.port': 8000
+
+# In Rails
+APP_CONFIG = AppConfigLoader.load do |config|
+  config.env = 'test'
+end
+
+APP_CONFIG['timeout']             # => 3000
+APP_CONFIG['some_service.host']   # => dev.someservice.com
+APP_CONFIG['some_service.port']   # => nil
+
+APP_CONFIG = AppConfigLoader.load do |config|
+  config.env = 'production'
+end
+
+APP_CONFIG['timeout']             # => 500
+APP_CONFIG['some_service.host']   # => prod.someservice.com
+APP_CONFIG['some_service.port']   # => 8000
+```
+
+#### Nested Definition
+
+```ruby
+'production.some_service':
+  'host': 'prod.someservice.com'
+  'port': 8000
+
+# In Rails
+APP_CONFIG['some_service.host']   # => prod.someservice.com
+APP_CONFIG['some_service.port']   # => 8000
+```
+
+#### Using Domain in Key
+
+```ruby
+# app config in YAML file
+'production.us.some_service.host': 'prod.someservice.com'
+'production.hk.some_service.host': 'prod.someservice.com.hk'
+
+# In Rails
+APP_CONFIG = AppConfigLoader.load do |config|
+  config.env = 'production'
+  config.use_domain = true
+  config.domain     = 'us'
+end
+
+APP_CONFIG['some_service.host']   # => prod.someservice.com
+
+APP_CONFIG = AppConfigLoader.load do |config|
+  config.env = 'production'
+  config.use_domain = true
+  config.domain     = 'hk'
+end
+
+APP_CONFIG['some_service.host']   # => prod.someservice.com.hk
+```
+
+#### Using Wildcard Env and Domain
+
+You may use the wildcard `*` in place of the env and the domain. This allows you to specify app config entry that is applicable in any env or domain. An app config entry with a specific env or domain always takes precedence over ones with wildcard of the same key.
+
+```ruby
+# app config in YAML file
+'*.some_service.host': 'dev.someservice.com'
+'production.some_service.host': 'prod.someservice.com'
+
+# In Rails
+APP_CONFIG = AppConfigLoader.load do |config|
+  config.env = 'test'
+end
+
+APP_CONFIG['some_service.host']   # => dev.someservice.com
+
+APP_CONFIG = AppConfigLoader.load do |config|
+  config.env = 'production'
+end
+
+APP_CONFIG['some_service.host']   # => prod.someservice.com
+```
+
+### Specificity
+
+When there a multiple app config entries for the same key, the final value is resolved based upon the specificity of the entry. The entry with the highest specificity take precedence over all other entries. In the case when more than one entries have the same specificity, the entry that is last read will take precedence.
+
+```YAML
+'production.us.some_service.host': 'prod.someservice.com'     # highest specificity
+'*.us.some_service.host': 'prod.someservice.com'
+'production.*.some_service.host': 'prod.someservice.com'
+'*.*.some_service.host': 'prod.someservice.com'               # lowest specificity
+```
+
+## Local Overrides File
+
+The local overrides file provides a quick way to override any entries defined in regular app config files. Entries within this file are resolved according to the specificity rule. Once resolved, the resolved entries will override any existing entries regardless of specificity. This is meant for development or testing purposes. Typically, you would not want to check this file into your source repository.
+
+## Contributors
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/lscspirit/app_config_loader. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Copyright
+
+Copyright (c) 2016 Derrick Yeung, released under the MIT license.
+See [MIT License](http://opensource.org/licenses/MIT) for details.

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)

data/app_config_loader.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'app_config_loader/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "app_config_loader"
+  spec.version       = AppConfigLoader::VERSION
+  spec.authors       = ["Derrick Yeung"]
+  spec.email         = ["lscspirit@hotmail.com"]
+
+  spec.summary       = %q{Application configuration using YAML}
+  spec.description   = %q{A easy way to define application configurations using YAML in your Rails environment.}
+  spec.homepage      = 'https://github.com/lscspirit/app_config_loader'
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "faker"
+end

data/lib/app_config_loader/config.rb

@@ -0,0 +1,22 @@
+module AppConfigLoader
+  class Config
+    attr_accessor :env, :domain, :local_overrides
+
+    def config_paths
+      @config_paths ||= []
+    end
+
+    def use_domain
+      @use_domain === true
+    end
+    alias_method :use_domain?, :use_domain
+
+    def use_domain=(use)
+      @use_domain = !!use
+    end
+
+    def domain
+      use_domain? ? @domain : nil
+    end
+  end
+end

data/lib/app_config_loader/config_entry.rb

@@ -0,0 +1,75 @@
+module AppConfigLoader
+  class ConfigEntry
+    attr_reader :env, :domain, :key_components, :value
+
+    #
+    # Constructor
+    #
+    def initialize(full_key, value, use_domain = false)
+      @env, @domain, @key_components = parse_full_key full_key, use_domain
+      @value = value
+    end
+
+    #
+    # Accessor
+    #
+
+    def key
+      @key_components.join('.')
+    end
+
+    def specificity
+      score = 0
+      score += 1  if @env != :any       # add one point if env is specified
+      score += 10 if @domain != :any    # add 10 points if domain is specified
+      score
+    end
+
+    def applicable?(target_env, target_domain = nil)
+      # first matches enviroment
+      return false if env != target_env && env != :any
+
+      # then matches domain
+      return false if target_domain && domain != :any && domain != target_domain
+
+      true
+    end
+
+    def ==(o)
+      o.class == self.class &&
+        o.env == self.env &&
+        o.domain == self.domain &&
+        o.key_components == self.key_components &&
+        o.value == self.value
+    end
+    alias_method :eql?, :==
+
+    private
+
+    def parse_full_key(full_key, use_domain)
+      key_ary = full_key.split('.')
+
+      raise InvalidConfigKey, "invalid config key '#{full_key}': must have a env component" unless key_ary.length > 1
+      raise InvalidConfigKey, "invalid config key '#{full_key}': must have a domain component when 'use_domain' is enabled" unless !use_domain || key_ary.length > 2
+
+      begin
+        env    = normalize_key_component key_ary[0], true
+        domain = use_domain ? normalize_key_component(key_ary[1], true) : :any
+        components = (use_domain ? key_ary[2..-1] : key_ary[1..-1]).map{ |k| normalize_key_component k }
+      rescue => ex
+        raise InvalidConfigKey, "invalid config key component in '#{full_key}': #{ex.message}"
+      end
+
+      return env, domain, components
+    end
+
+    def normalize_key_component(comp, wildcard = false)
+      if comp == '*'
+        raise 'wildcard is only allowed in the \'env\' and \'domain\' component' unless wildcard
+        :any
+      else
+        comp.to_s
+      end
+    end
+  end
+end

data/lib/app_config_loader/config_map.rb

@@ -0,0 +1,90 @@
+module AppConfigLoader
+  class ConfigMap
+    def initialize
+      @key_map = {}
+    end
+
+    def add(entry, overwrite = false)
+      begin
+        deep_add(@key_map, entry.key_components) do |existing|
+          if existing
+            # only override the existing entry if 'force' is true or
+            # the new entry has a higher specificity
+            overwrite || entry.specificity >= existing.specificity ? entry : existing
+          else
+            entry
+          end
+        end
+      rescue => ex
+        raise ConfigKeyConflict, "key conflict for '#{entry.key}': #{ex.message}"
+      end
+    end
+
+    def <<(entry)
+      add entry, false
+    end
+
+    def get(key)
+      components = key.split('.')
+      components.reduce(@key_map) do |parent, comp|
+        # return nil if the parent is not a Hash
+        break nil unless parent.is_a?(Hash)
+        parent[comp.to_sym]
+      end
+    end
+    alias_method :[], :get
+
+    def to_a
+      deep_list @key_map
+    end
+
+    def merge(config_map)
+      config_map.to_a.each { |override| self.add override, true }
+    end
+
+    private
+
+    def deep_add(parent, keys, &block)
+      current_key = keys[0].to_sym
+
+      if keys.count == 1
+        val = parent[current_key]
+
+        #
+        # the last key
+        #
+
+        # check if the key has child configuration
+        raise "key '#{current_key}' has at least one child config" if val.is_a?(Hash)
+
+        # yield to the block to determine what value to assign to the key
+        parent[current_key] = yield val
+      else
+        #
+        # has more keys
+        #
+
+        # check if the key already has a value assigned
+        raise "key '#{current_key}' already has a value assigned" unless val.nil? || val.is_a?(Hash)
+
+        # go to the next level
+        val = (parent[current_key] ||= {})
+        deep_add val, keys[1..-1], &block
+      end
+    end
+
+    def deep_list(root)
+      list = []
+
+      root.each do |key, value|
+        if value.is_a?(Hash)
+          list += deep_list value
+        else
+          list << value
+        end
+      end
+
+      list
+    end
+  end
+end

data/lib/app_config_loader/config_with_indifferent_access.rb

@@ -0,0 +1,25 @@
+module AppConfigLoader
+  class ConfigWithIndifferentAccess
+    def initialize(map, prefix = nil)
+      @config_map = map
+      @prefix     = prefix
+    end
+
+    def get(key)
+      # append prefix to the key if needed
+      target_key = @prefix ? "#{@prefix}.#{key}" : key.to_s
+
+      # return either nil, the value or another ConfigWithIndifferentAccess depending on
+      # what is at the key
+      case (entry = @config_map[target_key])
+        when ConfigEntry
+          entry.value
+        when Hash
+          self.class.new @config_map, target_key
+        else
+          nil
+      end
+    end
+    alias_method :[], :get
+  end
+end

data/lib/app_config_loader/errors.rb

@@ -0,0 +1,5 @@
+module AppConfigLoader
+  class InvalidConfigFile < StandardError; end
+  class InvalidConfigKey  < StandardError; end
+  class ConfigKeyConflict < StandardError; end
+end

data/lib/app_config_loader/loader.rb

@@ -0,0 +1,77 @@
+module AppConfigLoader
+  class Loader
+    def initialize(config)
+      @config = config
+      @parser = Parser.new @config.use_domain
+
+      raise 'Environement is not set in AppConfigLoader::Config' unless @config.env
+    end
+
+    # Load app config entries from yml paths listed in the
+    # AppConfigLoader::Config's 'config_paths' and 'local_override' properties
+    def load
+      cfg_map = ConfigMap.new
+
+      # Reads the raw config entries from the file list configured
+      # in the @config object
+      expanded_paths.each do |path|
+        begin
+          raw_entries = parse_yml path
+          raw_entries.each { |e| cfg_map << e if e.applicable? @config.env, @config.domain }
+        rescue InvalidConfigKey => ex
+          raise InvalidConfigFile, "config key error '#{path}': #{ex.message}"
+        end
+      end
+
+      if (override_path = local_override_path)
+        override_map = ConfigMap.new
+
+        begin
+          override_entries = parse_yml override_path
+          override_entries.each { |e| override_map.add(e, true) if e.applicable? @config.env, @config.domain }
+
+          # merges the override entries into the main config map
+          cfg_map.merge override_map
+        rescue InvalidConfigKey => ex
+          raise InvalidConfigFile, "config key error '#{local_override_path}': #{ex.message}"
+        rescue Errno::ENOENT
+          # ignore file not exists error as local_override file is optional
+        end
+      end
+
+      ConfigWithIndifferentAccess.new cfg_map
+    end
+
+    private
+
+    def parse_yml(path)
+      @parser.parse ERB.new(File.read(path)).result
+    end
+
+    # Expands the list of path entries into absolute paths for each matching files
+    #
+    # @return [Array<String>] absolute paths of all entries in the @config.config_paths
+    def expanded_paths
+      @config.config_paths.reduce(Set.new) do |memo, path|
+        if File.directory? path
+          Dir.chdir(path) do
+            # add all files (recursively) within the directory
+            memo += Dir.glob('**/*').map { |f| File.absolute_path f, path }
+          end
+        elsif File.exists? path
+          # add the file to the list if it exists
+          memo << File.absolute_path(path)
+        else
+          # try to glob the entries and add the result to the list
+          memo += Dir.glob(path).map { |f| File.absolute_path f, path }
+        end
+
+        memo
+      end
+    end
+
+    def local_override_path
+      @config.local_overrides ? File.absolute_path(@config.local_overrides) : nil
+    end
+  end
+end

data/lib/app_config_loader/parser.rb

@@ -0,0 +1,33 @@
+require 'yaml'
+
+module AppConfigLoader
+  class Parser
+    def initialize(use_domain = false)
+      @use_domain = use_domain
+    end
+
+    # Parse a YAML format text and returns flattened list of all key entries
+    #
+    # @return Array<KeyEntry> list of key entries
+    def parse(content)
+      flatten_keys YAML.load(content)
+    end
+
+    private
+
+    def flatten_keys(cfg, current_full_key = nil)
+      cfg.reduce([]) do |flattened, (key, value)|
+        raise InvalidConfigKey, 'config key component must be a string' unless key.is_a?(String)
+
+        this_key = current_full_key ? "#{current_full_key}.#{key}" : key
+        if value.is_a? Hash
+          flattened += flatten_keys value, this_key
+        else
+          flattened << ConfigEntry.new(this_key, value, @use_domain)
+        end
+
+        flattened
+      end
+    end
+  end
+end

data/lib/app_config_loader/version.rb

@@ -0,0 +1,3 @@
+module AppConfigLoader
+  VERSION = '1.0.0'
+end

data/lib/app_config_loader.rb

@@ -0,0 +1,29 @@
+require 'app_config_loader/errors'
+require 'app_config_loader/config'
+require 'app_config_loader/loader'
+require 'app_config_loader/parser'
+require 'app_config_loader/config_entry'
+require 'app_config_loader/config_map'
+require 'app_config_loader/config_with_indifferent_access'
+
+module AppConfigLoader
+  def self.load(config = nil)
+    raise ArgumentError, 'config must be a AppConfigLoader::Config instance' unless config.nil? || config.is_a?(AppConfigLoader::Config)
+
+    active_cfg = config || default_config
+
+    yield active_cfg if block_given?
+
+    Loader.new(active_cfg).load
+  end
+
+  private
+
+  def self.default_config
+    cfg = AppConfigLoader::Config.new
+    cfg.env = Rails.env
+    cfg.config_paths <<   Rails.root.join('config', 'app_configs')
+    cfg.local_overrides = Rails.root.join('config', 'app_configs', 'local_overrides.yml')
+    cfg
+  end
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: app_config_loader
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Derrick Yeung
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A easy way to define application configurations using YAML in your Rails
+  environment.
+email:
+- lscspirit@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- app_config_loader.gemspec
+- lib/app_config_loader.rb
+- lib/app_config_loader/config.rb
+- lib/app_config_loader/config_entry.rb
+- lib/app_config_loader/config_map.rb
+- lib/app_config_loader/config_with_indifferent_access.rb
+- lib/app_config_loader/errors.rb
+- lib/app_config_loader/loader.rb
+- lib/app_config_loader/parser.rb
+- lib/app_config_loader/version.rb
+homepage: https://github.com/lscspirit/app_config_loader
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.7
+signing_key: 
+specification_version: 4
+summary: Application configuration using YAML
+test_files: []