config_layers 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c3f2439ed377f78c7280ee7eb27b2d6b077688a5
+  data.tar.gz: e4ddb0c54bdbfd14a249e209dabfba7aaa87cdab
+SHA512:
+  metadata.gz: 82c7d7d882993984abe7d452df09753e87d9f63b6d68a1f12351658ea25f774e32b44fe15edf9503710d907a2d39da6d79df1da62425ee6bdac6722e8640af34
+  data.tar.gz: 88de4f1b5081874d8da6dbb19627f5343952b059fc5c732d3283bac3eed3a8fee1e03bfc228de641a2212cd37ce66b6ab1264d6309eaf30778b1aea2756eef4d

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.gitreview

@@ -0,0 +1,4 @@
+[gerrit]
+host=review.forj.forj.io
+port=29418
+project=forj-oss/config-layers.git

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,33 @@
+# Copyright 2013 Hewlett-Packard Development Company, L.P.
+#
+#   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 the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+# use: rubocop --show-cops
+#      to validate configuration.
+# rubocop config
+AllCops:
+  Include:
+    - '**/Rakefile'
+Style/HashSyntax:
+  EnforcedStyle: hash_rockets
+
+# lets start with 40, but 10 is way to small..
+Metrics/MethodLength:
+  Max: 40
+# If Method length is increased, class length need to be extended as well.
+Metrics/ClassLength:
+  Max: 150
+
+# allow arguments to be longer than 15
+Metrics/AbcSize:
+  Max: 40

data/Gemfile

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

data/README.md

@@ -0,0 +1,161 @@
+# ConfigLayers
+
+ConfigLayers is a library which help to manage a complex configuration hierarchy, (Hash of Hashes/Array/...) 
+per layers.
+
+* What kind of complexity are we trying to resolve?
+
+  If you are using yaml or json, you can write anything in that format in some configuration file.
+  Ex: 
+
+      :global:
+        :url: http://url.example.org
+        :options: 
+          :timeout: 60
+          :port: 4708
+      :application
+        :publish: [ help, about, main, go ]
+
+  When you load this yaml, you are going to get a Hash containing hash/array/string/... etc...
+  then, when you want to access :timeout, you access it like that:
+
+      timeout = data[:global][:options][:timeout]
+
+  If your data has this Hash of Hash of Hash, loaded in memory, then you get the data.
+  But you need to manage the exception or do some test for each Hash, otherwise you get a
+  nil exception.
+
+  ConfigLayers simplify this:
+
+  - access ':timeout' :
+    
+      config = PRC::BaseConfig.new(data)
+
+      timeout = config[:global, :options, :timeout]
+
+    No need to add any test.
+
+  - set ':timeout' :
+
+      config[:global, :options, :timeout] = 60
+
+    No need to create the Hash structure to set the ':timeout'
+
+  ConfigLayer embed YAML, so you can load and save this data from/to a yaml file...
+  
+      config.save(filename)
+      config.load(filename)
+
+  You can check the key existence as well!
+
+      if config.exist?(:global, :options, :timeout)
+         <do things>
+      end
+
+* What is that layer notion in ConfigLayers?
+
+  If you have an application which has some predefine default, a system config, a user config
+  and an account config, you may want to get a consolidated environment that you want to use.
+
+  if we are back in the previous ':timeout' example, let's say that :
+  - application default for timeout is. 60
+  - the system config has no timeout data.
+  - the user config has 120
+  - and the user load an account file that also has a timeout to 90
+
+  If the application run, with the account data loaded, when the application wants to get the timeout data
+
+  you expect to just read it! But you need to check if found in account, use it, otherwise check in user 
+  config, etc... until the application defaults if none of those previous configuration file has the :timeout
+  setting...
+
+  Here with ConfigLayers, you create a class based on CoreConfig and you define those layers.
+  then you just access you data!
+
+  Ex: This is a real simple example.
+
+      # We define layers
+      class MyConfigApp < PRC::CoreConfig
+        def initialize(files)
+          config_layers = []
+
+          # Application default layer
+          config_layers << define_default_layer
+
+          # runtime Config layer
+          config_layers << define_layer('system', files[0])
+
+          # User Config layer
+          config_layers << define_layer('user', files[1])
+
+          # Account config layer
+          config_layers << define_layer('account', files[2]))
+
+          initialize_layers(config_layers)
+        end
+        
+        def define_layer(name, filename)
+          config = PRC::BaseConfig.new()
+          config.load(filename)
+          PRC::CoreConfig.define_layer(:name => name,
+                                   :config   => config,
+                                   :file_set => true,
+                                   :load     => true, :save     => true)
+        end
+
+        def define_default_layer
+          config = PRC.BaseConfig()
+          config[:global, :options, :timeout] = 60
+          PRC::CoreConfig.define_layer(:name => 'default',
+                                   :config   => config)
+        end
+     end
+
+     # Using my ConfigLayers
+     files = ['/etc/myapp.yaml', '~/.myapp.yaml', '~/.conf/account/myaccount.yaml']
+     config = MyConfigApp.new(files)
+
+     [...]
+
+     puts config[:global, :options, :timeout]
+
+
+  As you saw, we define the layer, load or set it, assign a name and declare in a new class
+  and just use that class...
+
+You can do strongly more.
+
+You can define you own layer, you can redefine how your access data.
+For example, you can ignore some layers...
+
+You can get a full consolidated data, with merge!
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'config_layers'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install config_layers
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/config_layers/fork )
+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 a new Pull Request

data/Rakefile

@@ -0,0 +1,27 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+require 'rdoc/task'
+
+task :default => [:lint, :spec]
+
+desc 'Run the specs.'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = 'spec/*_spec.rb'
+  t.rspec_opts = '-f doc'
+end
+
+desc 'Generate lorj documentation'
+RDoc::Task.new do |rdoc|
+  rdoc.main = 'README.md'
+  rdoc.rdoc_files.include('README.md', 'lib', 'example', 'bin')
+end
+
+desc 'Run RuboCop on the project'
+RuboCop::RakeTask.new(:lint) do |task|
+  task.formatters = ['progress']
+  task.verbose = true
+  task.fail_on_error = true
+end
+
+task :build => [:lint, :spec]

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'config_layers'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require 'pry'
+Pry.start
+
+# require "irb"
+# IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/config_layers.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'config_layers/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "config_layers"
+  spec.version       = ConfigLayers::VERSION
+  spec.authors       = ["Christophe Larsonneur"]
+  spec.email         = ["clarsonneur@gmail.com"]
+
+  spec.summary       = %q{ConfigLayers, a simple multiple configuration management.}
+  spec.description   = %q{Manage your application configuration files easily.}
+  spec.homepage      = "http://github.com/forj-oss/config_layers"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "subhash", '~> 0.1.0'
+  spec.add_runtime_dependency "pry"
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.1.0"
+  spec.add_development_dependency "rubocop", "~> 0.30.0"
+end

data/lib/config_layers/version.rb

@@ -0,0 +1,4 @@
+# Config Layers
+module ConfigLayers
+  VERSION = '0.1.0'
+end

data/lib/config_layers.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+#--
+# (c) Copyright 2014 Hewlett-Packard Development Company, L.P.
+#
+#    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 the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#++
+
+require 'config_layers/version'
+
+# This is the config_layers library.
+#
+# To use it, add require 'config_layers'
+
+require 'subhash'               # recursive Hash
+
+require 'prc_base_config'       # PRC::BaseConfig class
+require 'prc_section_config'    # PRC::SectionConfig class
+require 'prc_core_config'       # PRC::CoreConfig class
+
+# Redefine Object to add a boolean? function.
+class Object
+  # Simplify boolean test on objects
+  def boolean?
+    self.is_a?(TrueClass) || self.is_a?(FalseClass)
+  end
+end

data/lib/prc_base_config.rb

@@ -0,0 +1,309 @@
+# encoding: UTF-8
+
+# (c) Copyright 2014 Hewlett-Packard Development Company, L.P.
+#
+#    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 the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+require 'yaml'
+
+module PRC
+  # This class is Base config system of lorj.
+  #
+  # It implements basic config features:
+  # * #erase        - To cleanup all data in self config
+  # * #[]           - To get a value for a key or tree of keys
+  # * #[]=          - To set a value for a key in the tree.
+  # * #exist?       - To check the existence of a value from a key
+  # * #del          - To delete a key tree.
+  # * #save         - To save all data in a yaml file
+  # * #load         - To load data from a yaml file
+  # * #data_options - To influence on how exist?, [], []=, load and save will
+  #   behave
+  #
+  # Config Data are managed as Hash of Hashes.
+  # It uses actively Hash.rh_* functions. See rh.rb.
+  class BaseConfig
+    # internal Hash data of this config.
+    # Do not use it except if you know what you are doing.
+    attr_reader :data
+
+    # * *set*: set the config file name. It accepts relative or absolute path to
+    #   the file.
+    # * *get*: get the config file name used by #load and #save.
+    attr_accessor :filename
+
+    # config layer version
+    attr_accessor :version
+
+    # config layer latest version
+    attr_reader :latest_version
+
+    # initialize BaseConfig
+    #
+    # * *Args*
+    #   - +keys+ : Array of key path to found
+    #
+    # * *Returns*
+    #   - boolean : true if the key path was found
+    #
+    # ex:
+    # value = CoreConfig.New({ :test => {:titi => 'found'}})
+    # # => creates a CoreConfig with this Hash of Hash
+    def initialize(value = nil, latest_version = nil)
+      @data = {}
+      @data = value if value.is_a?(Hash)
+      @data_options = {} # Options for exist?/set/get/load/save
+      @latest_version = latest_version
+      @version = latest_version
+    end
+
+    # data_options set data options used by exist?, get, set, load and save
+    # functions.
+    #
+    # CoreConfig class type, call data_options to set options, before calling
+    # functions: exist?, get, set, load and save.
+    #
+    # Currently, data_options implements:
+    # - :data_readonly : The data cannot be updated. set will not update
+    #   the value.
+    # - :file_readonly : The file used to load data cannot be updated.
+    #   save will not update the file.
+    #
+    # The child class can superseed or replace data options with their own
+    # options.
+    # Ex: If your child class want to introduce notion of sections,
+    # you can define the following with get:
+    #
+    #    class MySection < PRC::BaseConfig
+    #      # by default, section name to use by get/set is :default
+    #      def data_options(options = {:section => :default})
+    #        p_data_options(options)
+    #      end
+    #
+    #      def [](*keys)
+    #        p_get(@data_options[:section], *keys)
+    #      end
+    #
+    #      def []=(*keys, value)
+    #        p_set(@data_options[:section], *keys, value)
+    #      end
+    #    end
+    #
+    # * *Args*
+    #   - +keys+ : Array of key path to found
+    #
+    # * *Returns*
+    #   - boolean : true if the key path was found
+    def data_options(options = nil)
+      p_data_options options
+    end
+
+    # exist?
+    #
+    # * *Args*
+    #   - +keys+ : Array of key path to found
+    #
+    # * *Returns*
+    #   - boolean : true if the key path was found
+    #
+    # ex:
+    # { :test => {:titi => 'found'}}
+    def exist?(*keys)
+      p_exist?(*keys)
+    end
+
+    # Erase the data in the object. internal version is cleared as well.
+    #
+    # * *Returns*
+    #   - Hash : {}.
+    #
+    def erase
+      @version = @latest_version
+      @data = {}
+    end
+
+    # Get function
+    #
+    # * *Args*
+    #   - +keys+ : Array of key path to found
+    #
+    # * *Returns*
+    #   -
+    #
+    def [](*keys)
+      p_get(*keys)
+    end
+
+    # Set function
+    #
+    # * *Args*
+    #   - +keys+ : set a value in the Array of key path.
+    #
+    # * *Returns*
+    #   - The value set or nil
+    #
+    # ex:
+    # value = CoreConfig.New
+    #
+    # value[:level1, :level2] = 'value'
+    # # => {:level1 => {:level2 => 'value'}}
+
+    def del(*keys)
+      p_del(*keys)
+    end
+
+    # Set function
+    #
+    # * *Args*
+    #   - +keys+ : set a value in the Array of key path.
+    #
+    # * *Returns*
+    #   - The value set or nil
+    #
+    # ex:
+    #    value = CoreConfig.New
+    #
+    #    value[:level1, :level2] = 'value'
+    #    # => {:level1 => {:level2 => 'value'}}
+    def []=(*keys, value)
+      p_set(*keys, value)
+    end
+
+    # Load from a file
+    #
+    # * *Args*    :
+    #   - +filename+ : file name to load. This file name will become the default
+    #     file name to use next time.
+    # * *Returns* :
+    #   - true if loaded.
+    # * *Raises* :
+    #   - ++ ->
+    def load(filename = nil)
+      p_load(filename)
+    end
+
+    # Save to a file
+    #
+    # * *Args*    :
+    #   - +filename+ : file name to save. This file name will become the default
+    #                  file name to use next time.
+    # * *Returns* :
+    #   - boolean if saved or not. true = saved.
+    def save(filename = nil)
+      p_save(filename)
+    end
+
+    # transform keys from string to symbol until deep level. Default is 1.
+    #
+    # * *Args*    :
+    #   - +level+ : Default 1. level to transform
+    #
+    # * *Returns* :
+    #   - it self, with config updated.
+    def rh_key_to_symbol(level = 1)
+      data.rh_key_to_symbol level
+    end
+
+    # Check the need to transform keys from string to symbol until deep level.
+    # Default is 1.
+    #
+    # * *Args*    :
+    #   - +level+ : Default 1: levels to verify
+    #
+    # * *Returns* :
+    #   - true if need to be updated.
+    #
+    def rh_key_to_symbol?(level = 1)
+      data.rh_key_to_symbol? level
+    end
+
+    # Redefine the file name attribute set.
+    #
+    # * *Args*    :
+    #   - +filename+ : default file name to use.
+    # * *Returns* :
+    #   - filename
+    def filename=(filename) #:nodoc:
+      @filename = File.expand_path(filename) unless filename.nil?
+    end
+
+    # Print a representation of the Layer data
+    def to_s
+      msg = format("File : %s\n", @filename)
+      msg += data.to_yaml
+      msg
+    end
+
+    def latest_version?
+      (@version == @latest_version)
+    end
+
+    private
+
+    def p_data_options(options = nil)
+      @data_options = options unless options.nil?
+      @data_options
+    end
+
+    def p_exist?(*keys)
+      return nil if keys.length == 0
+
+      (@data.rh_exist?(*keys))
+    end
+
+    def p_get(*keys)
+      return nil if keys.length == 0
+
+      @data.rh_get(*keys)
+    end
+
+    def p_del(*keys)
+      return nil if keys.length == 0
+
+      @data.rh_del(*keys)
+    end
+
+    def p_set(*keys, value)
+      return nil if keys.length == 0
+      return p_get(*keys) if @data_options[:data_readonly]
+
+      @data.rh_set(value, keys)
+    end
+
+    def p_load(file = nil)
+      self.filename = file unless file.nil?
+
+      fail 'Config filename not set.' if @filename.nil?
+
+      @data = YAML.load_file(File.expand_path(@filename))
+
+      if @data.key?(:file_version)
+        @version = @data[:file_version]
+        @data.delete(:file_version)
+      end
+      true
+    end
+
+    def p_save(file = nil)
+      return false if @data_options[:file_readonly]
+      self.filename = file unless file.nil?
+
+      fail 'Config filename not set.' if @filename.nil?
+      @data_dup = @data.dup
+      @data_dup[:file_version] = @version unless @version.nil?
+
+      File.open(@filename, 'w+') { |out| YAML.dump(@data_dup, out) }
+      true
+    end
+  end
+end