libis-tools 0.9.4 → 0.9.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fa31aed0ec4adc0f57dcca3d2f816261a0ee956b
-  data.tar.gz: 5d7713ea273850ba3050c6150377d42987a5daea
+  metadata.gz: 29a2f53e5ac6fb5e2432eddac4617092644fc545
+  data.tar.gz: 8576f7fb158f2e8cde213edbe2cbf9d0444ac6fd
 SHA512:
-  metadata.gz: 7e6d7eb3379ca0ba55f5730a8e1b96b7170e206ee10b38dcea7ff6a18861b854b4a534ec7ed7069f553be36b7d86b6d6d2ed5923a8c50518057e3386c6a5ee20
-  data.tar.gz: 8e8d4cb03b0018ed90beb10fe78d538a95aa34455906018b92cfa2b0218296cc8a9d582a1a046f950be818d89ccd36b3caaa59dde30ac6d9a294622b46091c9a
+  metadata.gz: ebbd5da879c6a915be6659b699fbdb5e751c932c11b7f4bf85451f5ced8f612d02f191a6976468a5d55e521323035b408e28e7942d9224232cdf9207b081120b
+  data.tar.gz: 2275268123728cfaf39fa811cdf09a1e154855f5bafcb083c9aefa49f335a5230283a831da39e02a73bb16d85dcbf01dbbf975670bab4e584935e5348fb955e7

data/README.md

@@ -1,9 +1,7 @@
+[![Gem Version](https://badge.fury.io/rb/libis-tools.svg)](http://badge.fury.io/rb/libis-tools)
 [![Build Status](https://travis-ci.org/Kris-LIBIS/LIBIS_Tools.svg?branch=master)](https://travis-ci.org/Kris-LIBIS/LIBIS_Tools)
 [![Coverage Status](https://img.shields.io/coveralls/Kris-LIBIS/LIBIS_Tools.svg)](https://coveralls.io/r/Kris-LIBIS/LIBIS_Tools)
 [![Dependency Status](https://gemnasium.com/Kris-LIBIS/LIBIS_Tools.svg)](https://gemnasium.com/Kris-LIBIS/LIBIS_Tools)
-<!--[![Code Climate](https://codeclimate.com/github/Kris-LIBIS/LIBIS_Tools/badges/gpa.svg)](https://codeclimate.com/github/Kris-LIBIS/LIBIS_Tools)
-[![Test Coverage](https://codeclimate.com/github/Kris-LIBIS/LIBIS_Tools/badges/coverage.svg)](https://codeclimate.com/github/Kris-LIBIS/LIBIS_Tools)
--->
 
 # Libis::Tools
 
@@ -131,11 +129,33 @@ or:
 Note that the Command class uses Open3#popen3 internally. All arguments supplied to Command#run are passed to the popen3
 call. Unfortunately JRuby has some known issues with popen3. Please use and test carefully in JRuby environments.
 
+### DeepStruct
+
+A class that derives from OpenStruct through the RecursiveOpenStruct. A RecursiveOpenStruct is derived from stdlib's
+OpenStruct, but can be made recursive. DeepStruct enforces this behaviour and adds a clear! method.
+
+### ConfigFile
+
+A base class for Config, but useable on it's own. It extends the DeepStruct with << and >> methods that supports
+loading and saving of configuration values from and to files. Note that ERB commands will get lost during a round-trip.
+ 
+```ruby
+    require 'libis/tools/config_file'
+    cfg_file = ::Libis::Tools::ConfigFile.new
+    cfg_file << {foo: 'bar'}
+    cfg_file.my_value = 10
+    p cfg_file[:my_value] # => 10
+    cfg_file{:my_text] = 'abc'
+    p cfg_file['my_text'] # => 'abc'
+    p cfg_file.to_hash # => { :foo => 'bar', 'my_value' => 10, :my_text => 'abc' }
+    cfg >> 'my_config.yml'
+```
 ### Config
 
-The Config class is a convenience method for easy configuration maintenance and loading. It supports code defaults,
-loading configurations from multiple YAML files containing ERB statements. The Config class follows the Singleton
-pattern and behaves like a Hash/OpenStruct/HashWithIndifferentAccess. It also initializes a default Logger instance.
+The Config class is a convenience class for easy configuration maintenance and loading. Based on ConfigFile and 
+DeepStruc, it supports code defaults and loading configurations from multiple YAML files containing ERB statements.
+The Config class follows the Singleton pattern and behaves like a Hash/OpenStruct/HashWithIndifferentAccess with 
+recursion over hashes and arrays. It also initializes a default Logger instance.
 
 For each configuration parameter, the value can be accessed via the class or the Singleton instance through a method
 call or via the Hash operator using the parameter name either as a string or a symbol.
@@ -145,6 +165,7 @@ Examples:
 ```ruby
     require 'libis/tools/config'
     cfg = ::Libis::Tools::Config
+    cfg << 'my_config.yml'
     cfg['my_value'] = 10
     p cfg.instance.my_value # => 10
     cfg.instance.my_text = 'abc'

data/lib/libis/tools/config.rb

@@ -1,17 +1,15 @@
 # encoding: utf-8
 require 'singleton'
-require 'set'
 require 'yaml'
 require 'erb'
 require 'logger'
-require 'backports'
 
-require 'libis/tools/extend/hash'
+require 'libis/tools/config_file'
 
 module Libis
   module Tools
 
-    # The Config class is a convenience method for easy configuration maintenance and loading.
+    # The Config class is a convenience class for easy configuration maintenance, loading and saving.
     # It supports code defaults, loading configurations from multiple YAML files containing ERB statements.
     # The Config class follows the Singleton pattern and behaves like a Hash/OpenStruct/HashWithIndifferentAccess.
     # It also initializes a default Logger instance.
@@ -27,7 +25,7 @@ module Libis
     #         p cfg[:my_text] # => 'abc'
     #         p cfg.logger.warn('message') # => W, [2015-03-16T12:51:01.180548 #28935]  WARN -- : message
     #
-    class Config
+    class Config < ConfigFile
       include Singleton
 
       class << self
@@ -36,37 +34,23 @@ module Libis
 
         # For each configuration parameter, the value can be accessed via the class or the Singleton instance.
         def method_missing(name, *args, &block)
-          instance.send(name, *args, &block)
+          result = instance.send(name, *args, &block)
+          self === result ? self : result
         end
 
       end
 
       # Load configuration parameters from a YAML file or Hash.
       #
-      # The YAML file can contain ERB syntax values that will be evaluated at loading time. Multiple files can be
-      # loaded. Instead of a YAML file, a Hash can be passed. The file paths and Hashes are memorised and loaded again
-      # by the {#reload} methods.
+      # The file paths and Hashes are memorised and loaded again by the {#reload} methods.
       # @param [String,Hash] file_or_hash
       def <<(file_or_hash)
-        return if file_or_hash.nil?
-        hash = case file_or_hash
-                 when Hash
-                   @sources << file_or_hash
-                   file_or_hash
-                 when String
-                   return unless File.exist?(file_or_hash)
-                   @sources << File.absolute_path(file_or_hash)
-                   data = ERB.new(open(file_or_hash).read).result
-                   # noinspection RubyResolve
-                   YAML.load(data).to_hash rescue {}
-                 else
-                   {}
-               end
-        @data.merge! hash.key_symbols_to_strings recursive: true
-        self
+        super(file_or_hash) { |data| @sources << data }
       end
 
-      # Load all files and Hashes again. Will not reset the configuration parameters. Parameters set directly on the
+      # Load all files and Hashes again.
+      #
+      # Will not reset the configuration parameters. Parameters set directly on the
       # configuration are kept intact unless they also exist in the files or hashes in which case they will be overwritten.
       def reload
         sources = @sources.dup
@@ -75,39 +59,28 @@ module Libis
         self
       end
 
-      # Load all files and Hashes again. All configuration parameters are first deleted which means that any parameters
+      alias_method :deep_struct_clear!, :clear!
+
+      # Clear data and load all files and Hashes again.
+      #
+      # All configuration parameters are first deleted which means that any parameters
       # added directly (not via file or hash) will no longer be available. Parameters set explicitly that also exist in
       # the files or hashes will be reset to the values in those files and hashes.
       def reload!
-        @data.clear
+        deep_struct_clear!
         reload
       end
 
-      # Get the value of a parameter.
-      # @param [String, Symbol] name parameter name
-      # @return [Object] parameter value; nil if the parameter does not exist
-      def [](name)
-        @data.fetch(name.to_s) rescue nil
-      end
-
-      # Set the value of a parameter.
-      # If the parameter does not yet exist, it will be created.
-      # @param (see #[])
-      # @param [Object] value the new value for the parameter
-      # @return [Object] parameter value
-      def []=(name, value)
-        @data.store(name.to_s, value)
-      end
-
-      # Return the ::Logger instance.
-      def logger
-        @logger
-      end
-
-      # Set the ::Logger instance.
-      # @param [::Logger] my_logger new logger instance
-      def logger=(my_logger)
-        @logger = my_logger
+      # Clear all data.
+      #
+      # Not only all configuration parameters are deleted, but also the memoirized list of loaded files
+      # and hashes are cleared and the logger configuration is reset to it's default status.
+      def clear!
+        super
+        @sources = Array.new
+        @logger = ::Logger.new(STDOUT)
+        set_log_formatter
+        self
       end
 
       # Set the ::Logger instance's formatter.
@@ -118,40 +91,20 @@ module Libis
       #
       # @param [Proc] formatter the formatter procedure or nil for default formatter
       def set_log_formatter(formatter = nil)
-        logger.formatter = formatter || proc do |severity, time, progname, msg|
+        self.logger.formatter = formatter || proc do |severity, time, progname, msg|
           "%s, [%s#%d] %5s -- %s: %s\n" % [severity[0..0],
                                            (time.strftime('%Y-%m-%dT%H:%M:%S.') << '%06d ' % time.usec),
                                            $$, severity, progname, msg]
         end
       end
 
-      private
+      attr_accessor :logger
 
-      def method_missing(name, *args)
-        key = name.to_s
-        if name.to_s =~ /^(.*)(=)$/
-          key = $1
-        end
-        if @data.has_key?(key)
-          if key =~/^\w+$/ # not all key names are safe to use as method names
-            self.instance_eval <<-END
-              def #{key}
-                self['#{key}']
-              end
-              def #{name}=(value)
-                self['#{name}'] = value
-              end
-            END
-          end
-        end
-        ($2.nil? || $2.empty?) ? (@data.fetch(key) rescue nil) : @data.store(key, args.first)
-      end
+      protected
 
       def initialize
-        @data = Hash.new
-        @sources = Array.new
-        @logger = ::Logger.new(STDOUT)
-        set_log_formatter
+        super
+        clear!
       end
 
     end

data/lib/libis/tools/config_file.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+require 'singleton'
+require 'yaml'
+require 'erb'
+require 'logger'
+
+require 'libis/tools/deep_struct'
+
+module Libis
+  module Tools
+
+    # The ConfigFile class is a convenience class for interfacing with YAML configuration files. These files can
+    # contain ERB statements. An initial hash or file can be loaded during initialization. The class supports loading
+    # and saving of files, but note that any ERB statements in the file are lost by performing such a round trip.
+    # The class is derived from the DeepStruct class and therefore supports nested hashes and arrays and supports
+    # the OpenStruct style of accessors.
+    #
+    # The parameters can be accessed by getter/setter method or using the Hash syntax:
+    #
+    #         require 'libis/tools/config_file'
+    #         cfg_file = ::Libis::Tools::ConfigFile.new
+    #         cfg_file << {foo: 'bar'}
+    #         cfg_file.my_value = 10
+    #         p cfg_file[:my_value] # => 10
+    #         cfg_file{:my_text] = 'abc'
+    #         p cfg_file['my_text'] # => 'abc'
+    #         p cfg_file.to_hash # => { :foo => 'bar', 'my_value' => 10, :my_text => 'abc' }
+    #         cfg >> 'my_config.yml'
+    #
+    class ConfigFile < DeepStruct
+
+      # Create a new ConfigFile instance. The optional argument can either be a Hash or a String. The argument is
+      # passed to the {#<<} method after initialization.
+      #
+      # @param [String,Hash] file_or_hash optional String or Hash argument to initialize the data.
+      def initialize(file_or_hash = nil)
+        super
+        self << file_or_hash
+      end
+
+      # Load configuration parameters from a YAML file or Hash.
+      #
+      # The YAML file can contain ERB syntax values that will be evaluated at loading time. Instead of a YAML file,
+      # a Hash can be passed.
+      #
+      # Note that the method also yields the hash or absolute path to a given block. This is for data management of
+      # derived classes such as ::Libis::Tools::Config.
+      #
+      # @param [String,Hash] file_or_hash optional String or Hash argument to initialize the data.
+      def <<(file_or_hash)
+        return self if file_or_hash.nil?
+        hash = case file_or_hash
+                 when Hash
+                   yield file_or_hash if block_given?
+                   file_or_hash
+                 when String
+                   return unless File.exist?(file_or_hash)
+                   yield File.absolute_path(file_or_hash) if block_given?
+                   # noinspection RubyResolve
+                   YAML.load(ERB.new(open(file_or_hash).read).result) rescue {}
+                 else
+                   {}
+               end
+        return self unless hash.is_a? Hash
+        hash.each { |key, value| self[key] = value }
+        self
+      end
+
+      # Save configuration parameters in a YAML file.
+      #
+      # @param [String] file path of the YAML file to save the configuration to.
+      def >>(file)
+        File.open(file, 'w') { |f| f.write to_hash.to_yaml }
+      end
+
+    end
+  end
+end

data/lib/libis/tools/deep_struct.rb

@@ -3,13 +3,24 @@ require 'recursive-open-struct'
 
 module Libis
   module Tools
+
+    # A class that derives from OpenStruct through the RecursiveOpenStruct. A RecursiveOpenStruct is derived from
+    # stdlib's OpenStruct, but can be made recursive. DeepStruct enforces this behaviour and adds a clear! method.
     class DeepStruct < RecursiveOpenStruct
 
       def initialize(hash = {}, opts = {})
+        hash = {} unless hash
+        opts = {} unless opts
         hash = {default: hash} unless hash.is_a? Hash
         super(hash, {recurse_over_arrays: true}.merge(opts))
       end
 
+      # Delete all data fields
+      def clear!
+        @table.keys.each { |key| delete_field(key) }
+        @sub_elements = {}
+      end
+
     end
   end
 end

data/lib/libis/tools/version.rb

@@ -1,5 +1,5 @@
 module Libis
   module Tools
-    VERSION = '0.9.4'
+    VERSION = '0.9.5'
   end
 end

data/libis-tools.gemspec

@@ -36,6 +36,6 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'nokogiri', '~> 1.6'
   spec.add_runtime_dependency 'gyoku',  '~> 1.2'
   spec.add_runtime_dependency 'nori', '~> 2.4'
-  spec.add_runtime_dependency 'recursive-open-struct', '~>0.6'
+  spec.add_runtime_dependency 'recursive-open-struct', '~>0.6.4'
 
 end

data/spec/command_spec.rb

@@ -4,18 +4,22 @@ require 'libis/tools/command'
 
 describe 'Command' do
 
-  around(:example) do |test|
-    dir = Dir.pwd
-    Dir.chdir(File.join(File.dirname(__FILE__),'data'))
-    test.run
-    Dir.chdir(dir)
-  end
+  let!(:dir) { Dir.pwd }
+  let(:entries) {
+    Dir.entries('.').inject([]) do |array, value|
+      array << value unless File.directory?(value)
+      array
+    end.sort
+  }
+
+  before(:each) { Dir.chdir(File.join(File.dirname(__FILE__),'data')) }
+  after(:each) { Dir.chdir(dir) }
 
   it 'should run ls command' do
 
     result = Libis::Tools::Command.run('ls')
 
-    expect(result[:out]).to eq %w'test.data test.xml test.yml'
+    expect(result[:out].sort).to match entries
     expect(result[:err]).to eq []
     expect(result[:status]).to eq 0
 
@@ -23,15 +27,11 @@ describe 'Command' do
 
   it 'should run ls command with an option' do
 
-    result = Libis::Tools::Command.run('ls', '-l')
+    result = Libis::Tools::Command.run('ls', '-1')
 
     output = result[:out]
-    expect(output.size).to eq 4
-    expect(output.first).to match /^total \d+$/
-    expect(output[1]).to match /^-[rwx-]{9}.+test.data$/
-    expect(output[2]).to match /^-[rwx-]{9}.+test.xml$/
-    expect(output[3]).to match /^-[rwx-]{9}.+test.yml$/
-
+    expect(output.size).to eq (entries.size)
+    expect(output.sort).to match entries
     expect(result[:err]).to eq []
     expect(result[:status]).to eq 0
 
@@ -39,17 +39,13 @@ describe 'Command' do
 
   it 'should run ls command with multiple options' do
 
-    result = Libis::Tools::Command.run('ls', '-l', '-a', '-p')
+    result = Libis::Tools::Command.run('ls', '-1', '-a', '-p')
 
     output = result[:out]
-    expect(output.size).to eq 6
-    expect(output.first).to match /^total \d+$/
-    expect(output[1]).to match /^d[rwx-]{9}.+\d+.+\.\/$/
-    expect(output[2]).to match /^d[rwx-]{9}.+\d+.+\.\.\/$/
-    expect(output[3]).to match /^-[rwx-]{9}.+test.data$/
-    expect(output[4]).to match /^-[rwx-]{9}.+test.xml$/
-    expect(output[5]).to match /^-[rwx-]{9}.+test.yml$/
-
+    expect(output.size).to eq (entries.size + 2)
+    expect(output[0]).to eq './'
+    expect(output[1]).to eq '../'
+    expect(output[2..-1].sort).to match entries
     expect(result[:err]).to eq []
     expect(result[:status]).to eq 0
 

data/spec/config_file_spec.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+require_relative 'spec_helper'
+require 'libis/tools/config_file'
+
+describe ::Libis::Tools::ConfigFile do
+
+  let!(:test_file) { File.join(File.dirname(__FILE__), 'data', 'test_config.yml') }
+
+  let(:hash) {
+    {
+        a: {x: 0, y: 0, z: 0},
+        b: {x: 10, y: -5, z: 2.5},
+        c: [
+            [
+                {a: [{a1: 1, a2: 2}]},
+            ]
+        ]
+    }
+  }
+
+  context 'after default initialization' do
+
+    it 'has empty hash' do
+      # noinspection RubyResolve
+      expect(subject.to_hash).to be_empty
+    end
+
+    it 'loads from file' do
+      subject << test_file
+      expect(subject.to_hash).to eq hash
+    end
+
+  end
+
+end

data/spec/config_spec.rb

@@ -4,83 +4,109 @@ require 'libis/tools/config'
 
 describe 'Config' do
 
-  test_file = File.join(File.dirname(__FILE__), 'data', 'test.yml')
-  config = ::Libis::Tools::Config
-  config << { appname: 'LIBIS Default' }
+  before(:all) do
+    ::Libis::Tools::Config << {appname: 'LIBIS Default'}
+  end
+
+  subject(:config) { ::Libis::Tools::Config.clear! }
 
-  it 'should initialize' do
-    expect(config.appname).to eq 'LIBIS Default'
+  it 'has defaults set' do
     expect(config.logger).to be_a ::Logger
   end
 
-  # noinspection RubyResolve
-  it 'should define setters' do
-    config[:test_value] = 5
-    expect(config.test_value).to eq 5
-  end
+  it 'clears all values' do
+    # noinspection RubyResolve
+    config.test_value = 5
+    config.logger.level = ::Logger::FATAL
+    # noinspection RubyResolve
+    expect(config.test_value).to be 5
+    expect(config.logger.level).to be ::Logger::FATAL
 
-  it 'should load from file' do
-    config << test_file
-    expect(config.process).to eq 'Test Configuration'
+    config.clear!
+    # noinspection RubyResolve
+    expect(config.test_value).to be_nil
+    expect(config.logger.level).to be ::Logger::DEBUG
   end
 
-  # noinspection RubyResolve
-  it 'should allow to set and get in different ways' do
-    config.test_value = 10
-    expect(config.test_value).to be 10
-    expect(config['test_value']).to be 10
-    expect(config[:test_value]).to be 10
-    expect(config.instance.test_value).to be 10
-    expect(config.instance['test_value']).to be 10
-    expect(config.instance[:test_value]).to be 10
-
-    config[:test_value] = 11
-    expect(config.test_value).to be 11
-    expect(config['test_value']).to be 11
-    expect(config[:test_value]).to be 11
-    expect(config.instance.test_value).to be 11
-    expect(config.instance['test_value']).to be 11
-    expect(config.instance[:test_value]).to be 11
-
-    config['test_value'] = 12
-    expect(config.test_value).to be 12
-    expect(config['test_value']).to be 12
-    expect(config[:test_value]).to be 12
-    expect(config.instance.test_value).to be 12
-    expect(config.instance['test_value']).to be 12
-    expect(config.instance[:test_value]).to be 12
-  end
+  context 'adding values with setters' do
 
-  it 'should allow to set and get on class and instance' do
-    expect(config.appname).to be config.instance.appname
-    expect(config['appname']).to be config.instance.appname
-    expect(config[:appname]).to be config.instance.appname
-    expect(config.instance['appname']).to be config.instance.appname
-    expect(config.instance[:appname]).to be config.instance.appname
+    it 'by symbol' do
+      config[:test_value] = 5
+      expect(config['test_value']).to be 5
+    end
 
-    config.instance[:appname] = 'Test App'
-    expect(config.appname).to be == 'Test App'
-  end
+    it 'by name' do
+      config['test_value'] = 6
+      # noinspection RubyResolve
+      expect(config.test_value).to be 6
+    end
+
+    it 'by method' do
+      # noinspection RubyResolve
+      config.test_value = 7
+      expect(config[:test_value]).to be 7
+    end
+
+    it 'allows to set on instance' do
+      config.instance[:test_value] = :abc
+      # noinspection RubyResolve
+      expect(config.test_value).to be :abc
+    end
+
+    it 'allows to set on class' do
+      # noinspection RubyResolve
+      config.test_value = :def
+      expect(config.instance[:test_value]).to be :def
+    end
 
-  # noinspection RubyResolve
-  it 'should reset only values loaded from file' do
-    config[:appname] = 'foo'
-    config[:process] = 'bar'
-    config[:baz] = 'qux'
-
-    expect(config.appname).to eq 'foo'
-    expect(config.process).to eq 'bar'
-    expect(config.baz).to eq 'qux'
-
-    config.reload
-    expect(config.appname).to eq 'LIBIS Default'
-    expect(config.process).to eq 'Test Configuration'
-    expect(config.baz).to eq 'qux'
-
-    config.reload!
-    expect(config.appname).to eq 'LIBIS Default'
-    expect(config.process).to eq 'Test Configuration'
-    expect(config.baz).to be_nil
   end
 
+  context 'loading from file' do
+
+    let(:test_file) { File.join(File.dirname(__FILE__), 'data', 'test.yml') }
+    subject(:config) { Libis::Tools::Config.clear! << test_file }
+
+    it 'has configuration parameters set' do
+      expect(config.process).to eq 'Test Configuration'
+    end
+
+    it 'resets only values loaded from file' do
+      config[:process] = 'foo'
+      config[:bar] = 'qux'
+
+      expect(config.process).to eq 'foo'
+      expect(config.bar).to eq 'qux'
+
+      config.reload
+      expect(config.process).to eq 'Test Configuration'
+      expect(config.bar).to eq 'qux'
+    end
+
+    it 'resets all values' do
+      config[:process] = 'foo'
+      config[:bar] = 'qux'
+
+      expect(config.process).to eq 'foo'
+      expect(config.bar).to eq 'qux'
+
+      config.reload!
+      expect(config.process).to eq 'Test Configuration'
+      expect(config.bar).to be_nil
+    end
+
+    it 'clears all values' do
+      config[:process] = 'foo'
+      config[:bar] = 'qux'
+
+      expect(config.process).to eq 'foo'
+      expect(config.bar).to eq 'qux'
+
+      config.clear!
+      expect(config.process).to be_nil
+      expect(config.bar).to be_nil
+      # noinspection RubyResolve
+      expect(config.to_h).to be_empty
+    end
+
+  end
 end

data/spec/data/test.yml

@@ -1 +1,2 @@
 process: 'Test Configuration'
+

data/spec/data/test_config.yml

@@ -0,0 +1,15 @@
+:a:
+  :x: 0
+  :y: 0
+  :z: 0
+:b:
+  :x: 10
+  :y: -5
+  :z: 2.5
+:c:
+  -
+    -
+      :a:
+       -
+        :a1: 1
+        :a2: 2

data/spec/deep_struct_spec.rb

@@ -4,79 +4,135 @@ require 'libis/tools/deep_struct'
 
 describe 'DeepStruct' do
 
-  hash = {a: 1, 'b' => '2', c: 3.0}
-  recursive_hash = {
-      a: {x: 0, y: 0, z: 0},
-      b: {x: 10, y: -5, z: 2.5},
-      c: [
-          [
-              {a: 1},
-              {a: 2}
-          ]
-      ]
-  }
-
-  it 'should initialize' do
-    ds = Libis::Tools::DeepStruct.new
-    expect(ds).not_to eq nil
-  end
+  context 'default contructor' do
 
-  # noinspection RubyResolve
-  it 'should store Hash values' do
-    ds = Libis::Tools::DeepStruct.new hash
-    expect(ds[:a]).to eq 1
-    expect(ds[:b]).to eq '2'
-    expect(ds[:c]).to eq 3.0
-  end
+    subject(:ds) { Libis::Tools::DeepStruct.new }
+
+    it 'should initialize' do
+      is_expected.not_to be_nil
+      # noinspection RubyResolve
+      expect(ds.to_hash).to be_empty
+    end
 
-  it 'should allow access through methods' do
-    ds = Libis::Tools::DeepStruct.new hash
-    expect(ds.a).to eq 1
-    expect(ds.b).to eq '2'
-    expect(ds.c).to eq 3.0
   end
 
-  it 'should allow access through methods, key strings and key symbols' do
-    ds = Libis::Tools::DeepStruct.new hash
-    expect(ds.a).to eq 1
-    expect(ds.b).to eq '2'
-    expect(ds.c).to eq 3.0
+  context 'contructed with hash' do
 
-    expect(ds['a']).to eq 1
-    expect(ds['b']).to eq '2'
-    expect(ds['c']).to eq 3.0
+    let(:hash) { {a: 1, 'b' => '2', c: 3.0} }
+    subject(:ds) { Libis::Tools::DeepStruct.new(hash)}
 
-    expect(ds[:a]).to eq 1
-    expect(ds[:b]).to eq '2'
-    expect(ds[:c]).to eq 3.0
+    it 'has Hash values initialized' do
+      expect(ds[:a]).to eq 1
+      expect(ds[:b]).to eq '2'
+      expect(ds[:c]).to eq 3.0
+      expect(ds.to_hash).to eq hash
+    end
 
-    expect(ds.b).to be ds[:b]
-    expect(ds.b).to be ds['b']
+    it 'allows access through methods' do
+      expect(ds.a).to eq 1
+      expect(ds.b).to eq '2'
+      expect(ds.c).to eq 3.0
 
-  end
+      ds.a = 5
+      expect(ds.a).to be 5
+      expect(ds[:a]).to be 5
+      expect(ds['a']).to be 5
+    end
 
-  it 'should store non-hashes with :default key' do
-    ds = Libis::Tools::DeepStruct.new 'abc'
-    expect(ds[:default]).to eq 'abc'
-  end
+    it 'allows access through key strings' do
+      expect(ds['a']).to eq 1
+      expect(ds['b']).to eq '2'
+      expect(ds['c']).to eq 3.0
+
+      ds['a'] = 5
+      expect(ds.a).to be 5
+      expect(ds[:a]).to be 5
+      expect(ds['a']).to be 5
+    end
+
+    it 'allows access through key symbols' do
+      expect(ds[:a]).to eq 1
+      expect(ds[:b]).to eq '2'
+      expect(ds[:c]).to eq 3.0
+
+      ds[:a] = 5
+      expect(ds.a).to be 5
+      expect(ds[:a]).to be 5
+      expect(ds['a']).to be 5
+    end
 
-  it 'should store recursive Hashes as DeepStructs' do
-    ds = Libis::Tools::DeepStruct.new(recursive_hash)
-    expect(ds[:a]).to be_a Libis::Tools::DeepStruct
-    expect(ds.b).to be_a Libis::Tools::DeepStruct
   end
 
-  it 'should recurse over arrays by default' do
-    ds = Libis::Tools::DeepStruct.new(recursive_hash)
-    expect(ds.c[0][0]).to be_a Libis::Tools::DeepStruct
-    expect(ds.c.first.first.a).to eq 1
-    expect(ds.c.first[1].a).to eq 2
+  context 'initialized with non-hash' do
+
+    subject(:ds) { Libis::Tools::DeepStruct.new 'abc' }
+
+    it 'stores value in hash with :default key' do
+      expect(ds[:default]).to eq 'abc'
+    end
+
   end
 
-  it 'should deliver hashes if asked' do
-    ds = Libis::Tools::DeepStruct.new(recursive_hash)
-    expect(ds.to_h).to eq recursive_hash
-    expect(ds.b.to_h).to eq recursive_hash[:b]
+  context 'initialized with nil value' do
+
+    subject(:ds) { Libis::Tools::DeepStruct.new nil }
+
+    it 'has no data' do
+      # noinspection RubyResolve
+      expect(ds.to_hash).to be_empty
+    end
+
   end
 
+  context 'initialized with recursive hash' do
+
+    let(:recursive_hash) { {
+        a: {x: 0, y: 0, z: 0},
+        b: {x: 10, y: -5, z: 2.5},
+        c: [
+            [
+                {a: [ {a1: 1, a2: 2}] },
+            ]
+        ]
+    } }
+
+    subject(:ds) { Libis::Tools::DeepStruct.new(recursive_hash) }
+
+    it 'stores recursive Hashes as DeepStructs' do
+      expect(ds[:a]).to be_a Libis::Tools::DeepStruct
+      expect(ds.b).to be_a Libis::Tools::DeepStruct
+    end
+
+    it 'recurses over arrays' do
+      expect(ds.c[0][0]).to be_a Libis::Tools::DeepStruct
+      expect(ds.c.first.first.a.first.a1).to eq 1
+      expect(ds.c.first.first.a.first.a2).to eq 2
+    end
+
+    it 'can reproduce original hash' do
+      expect(ds.to_hash).to eq recursive_hash
+      expect(ds.b.to_hash).to eq recursive_hash[:b]
+    end
+
+    it 'clears data and methods' do
+      expect(ds).to respond_to 'a'
+      expect(ds).to respond_to 'b'
+      expect(ds).to respond_to 'c'
+      expect(ds).to respond_to 'a='
+      expect(ds).to respond_to 'b='
+      expect(ds).to respond_to 'c='
+
+      ds.clear!
+      expect(ds.a).to be_nil
+      expect(ds.b).to be_nil
+      expect(ds.c).to be_nil
+      expect(ds).not_to respond_to 'a'
+      expect(ds).not_to respond_to 'b'
+      expect(ds).not_to respond_to 'c'
+      expect(ds).not_to respond_to 'a='
+      expect(ds).not_to respond_to 'b='
+      expect(ds).not_to respond_to 'c='
+    end
+
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: libis-tools
 version: !ruby/object:Gem::Version
-  version: 0.9.4
+  version: 0.9.5
 platform: ruby
 authors:
 - Kris Dekeyser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-13 00:00:00.000000000 Z
+date: 2015-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -156,14 +156,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: 0.6.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: 0.6.4
 description: Some tool classes for other LIBIS gems.
 email:
 - kris.dekeyser@libis.be
@@ -185,6 +185,7 @@ files:
 - lib/libis/tools/checksum.rb
 - lib/libis/tools/command.rb
 - lib/libis/tools/config.rb
+- lib/libis/tools/config_file.rb
 - lib/libis/tools/dc_record.rb
 - lib/libis/tools/deep_struct.rb
 - lib/libis/tools/extend/empty.rb
@@ -203,10 +204,12 @@ files:
 - spec/assert_spec.rb
 - spec/checksum_spec.rb
 - spec/command_spec.rb
+- spec/config_file_spec.rb
 - spec/config_spec.rb
 - spec/data/test.data
 - spec/data/test.xml
 - spec/data/test.yml
+- spec/data/test_config.yml
 - spec/deep_struct_spec.rb
 - spec/logger_spec.rb
 - spec/parameter_container_spec.rb
@@ -245,10 +248,12 @@ test_files:
 - spec/assert_spec.rb
 - spec/checksum_spec.rb
 - spec/command_spec.rb
+- spec/config_file_spec.rb
 - spec/config_spec.rb
 - spec/data/test.data
 - spec/data/test.xml
 - spec/data/test.yml
+- spec/data/test_config.yml
 - spec/deep_struct_spec.rb
 - spec/logger_spec.rb
 - spec/parameter_container_spec.rb