lorj 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eeba3dfb1287558282764e42fab9e32628ebbbd3
-  data.tar.gz: 27119784fb89ca8911f2cc722f1a2d09454d5e7a
+  metadata.gz: 68cdd89f8867872019b885eaeca7358bf1108c61
+  data.tar.gz: 44eac4c611e38053086be179682cef327f8d8341
 SHA512:
-  metadata.gz: d936b458e2a74c00f165a3b3d41d914aab89602ef250cc08c4ede8fc0f649aba765818f3fe2e1beab5abfe72ac03f9a96e73f86230a38f962313818eb1c5eaa6
-  data.tar.gz: ad7e7604d301400b754c1811de06d5711f11563c2e35663cc2bb1f3ce46168772139cdc9979167ca655602f229af954d6bb15cf47beab7754b03bfb3a82a114d
+  metadata.gz: c3fd2b28bfbf55a97b05bbb6626821f2668afead59e991fa05fb5d128111071f15c3814f39dec2b163862550629c9f6188f57784d679e3c213d2d5ecb9985bd8
+  data.tar.gz: e6c9f1f3b9d3869f820c502774944a878a6d8da999239362cd1c502d395a28835b5ac5cdf4a8a9c00840fd980b4a8ed2933d441044efece20668aab81136f1ea

data/Rakefile

@@ -32,3 +32,5 @@ RuboCop::RakeTask.new(:lint) do |task|
   task.verbose = true
   task.fail_on_error = true
 end
+
+task :build => [:lint, :spec]

data/lib/logging.rb

@@ -142,19 +142,19 @@ module PrcLib
 
     # Log to STDOUT and Log file and INFO class message
     def info(message)
-      @out_logger.info(message + ANSI.clear_line)
+      @out_logger.info(message + ANSI.clear_eol)
       @file_logger.info(message)
     end
 
     # Log to STDOUT and Log file and DEBUG class message
     def debug(message)
-      @out_logger.debug(message + ANSI.clear_line)
+      @out_logger.debug(message + ANSI.clear_eol)
       @file_logger.debug(message)
     end
 
     # Log to STDOUT and Log file and ERROR class message
     def error(message)
-      @out_logger.error(message + ANSI.clear_line)
+      @out_logger.error(message + ANSI.clear_eol)
       @file_logger.error(message)
     end
 
@@ -163,17 +163,16 @@ module PrcLib
     # the exception class is given.
     # The exception class should provide message and backtrace.
     def fatal(message, e = nil)
-      @out_logger.fatal(message + ANSI.clear_line)
-      @file_logger.fatal(format("%s\n%s\n%s",
-                                message,
-                                e.message,
-                                e.backtrace.join("\n"))) if e
+      @out_logger.fatal(message + ANSI.clear_eol)
+      return @file_logger.fatal(format("%s\n%s\n%s",
+                                       message, e.message,
+                                       e.backtrace.join("\n"))) if e
       @file_logger.fatal(message)
     end
 
     # Log to STDOUT and Log file and WARNING class message
     def warn(message)
-      @out_logger.warn(message + ANSI.clear_line)
+      @out_logger.warn(message + ANSI.clear_eol)
       @file_logger.warn(message)
     end
 
@@ -186,7 +185,7 @@ module PrcLib
     # Print out a message, not logged in the log file. This message is printed
     # out systematically as not taking care of logger level.
     def unknown(message)
-      @out_logger.unknown(message + ANSI.clear_line)
+      @out_logger.unknown(message + ANSI.clear_eol)
     end
 
     private
@@ -274,7 +273,8 @@ module PrcLib
       p.pop
     end
     log_object.fatal(format(message, *p), e)
-    puts 'Issues found. Please fix it and retry. Process aborted.'
+    puts format('Issues found. Please fix it and retry. Process aborted. '\
+         "See details in log file '%s'.", PrcLib.log_file)
     exit rc
   end
 
@@ -283,16 +283,16 @@ module PrcLib
     nil
   end
 
+  # Print the message to the same line.
   def state(message, *p)
-    print(format("%s ...%s\r",
-                 format(message, *p),
-                 ANSI.clear_line)) if log_object.level <= Logger::INFO
+    print(format("%s%s ...\r", ANSI.clear_line,
+                 format(message, *p))) if log_object.level <= Logger::INFO
     nil
   end
 
   # Not DEBUG and not INFO. Just printed to the output.
-  def high_level_msg(message)
-    print(format('%s', message)) if log_object.level > 1
+  def high_level_msg(message, *p)
+    print(format(message, *p)) if log_object.level > 1
     nil
   end
 end

data/lib/lorj/version.rb

@@ -16,5 +16,5 @@
 
 # Lorj version
 module Lorj
-  VERSION = '1.0.0'
+  VERSION = '1.0.1'
 end

data/lib/lorj_account.rb

@@ -126,8 +126,6 @@ module Lorj
       # runtime Config layer
       config_layers << define_runtime_layer
 
-      Lorj.defaults.load # Loading global application defaults
-
       if PrcLib.data_path.nil?
         PrcLib.fatal(1, 'Internal PrcLib.data_path was not set.')
       end
@@ -168,8 +166,10 @@ module Lorj
       options = { :keys => [key], :section => section }
 
       indexes = _identify_indexes(options, exclusive?(key, section))
+      names = []
+      indexes.each { |index| names << @config_layers[index][:name] }
 
-      options[:data_options] = _set_data_options_per_indexes(indexes)
+      options[:data_options] = _set_data_options_per_names(names)
 
       return _get(options) if _exist?(options)
 
@@ -186,31 +186,38 @@ module Lorj
     # otherwise, search in all layers.
     #
     # * *Args*    :
-    #   - +key+     : key name. It do not support it to be a key tree (Arrays of
-    #                 keys).
-    #   - +default+ : default value, if not found.
+    # - +key+     : key name. It do not support it to be a key tree (Arrays of
+    #               keys).
+    # - +options+ : possible options:
+    #   - +:section+ : Force to use a specific section name.
+    #   - +:name+    : layer to exclusively get data.
+    #   - +:indexes+ : layer index to exclusively get data.
+    #                  If neither :name or :index is set, get will search
+    #                  data on all predefined layers, first found, first listed.
     # * *Returns* :
     #   - key value.
     # * *Raises* :
     #   Nothing
-    def where?(key, section = nil)
+    def where?(key, options = {})
       key = key.to_sym if key.class == String
+      options = {} unless options.is_a?(Hash)
 
+      section = options[:section]
       section = Lorj.defaults.get_meta_section(key) if section.nil?
 
-      options = { :keys => [key], :section => section }
+      indexes = _identify_array_indexes(options, exclusive?(key, section))
 
-      account_exclusive = exclusive?(key, section)
-      if account_exclusive
-        indexes = [0, 1]
-        options[:indexes] = indexes
-      else
-        indexes = [0, 1, 2, 3]
-      end
+      names = []
+      indexes.each { |index| names << @config_layers[index][:name] }
 
-      options[:data_options] = _set_data_options_per_indexes(indexes)
+      where_options = {
+        :keys => [key],
+        :section => section,
+        :indexes => indexes,
+        :data_options => _set_data_options_per_names(names)
+      }
 
-      _where?(options)
+      _where?(where_options)
     end
 
     # check key/value existence in config layers
@@ -244,7 +251,10 @@ module Lorj
 
       indexes = _identify_indexes(options, exclusive?(key, section))
 
-      options[:data_options] = _set_data_options_per_indexes(indexes)
+      names = []
+      indexes.each { |index| names << @config_layers[index][:name] }
+
+      options[:data_options] = _set_data_options_per_names(names)
 
       _exist?(options)
     end
@@ -456,35 +466,62 @@ module Lorj
 
     private
 
+    def _identify_array_indexes(options, account_exclusive)
+      def_indexes = options[:indexes] if options.key?(:indexes)
+      if options[:names].is_a?(Array)
+        def_indexes = layers_indexes(options[:names])
+      end
+
+      indexes = exclusive_indexes(account_exclusive)
+      options[:indexes] = indexes
+
+      return indexes if def_indexes.nil? || def_indexes.length == 0
+
+      def_indexes.delete_if { |index| !indexes.include?(index) }
+
+      def_indexes
+    end
+
+    def layers_indexes(names)
+      return nil unless names.is_a?(Array)
+
+      indexes = [] if names.is_a?(Array)
+      names.each do |name|
+        indexes << layer_index(name) if name.is_a?(String)
+      end
+      indexes
+    end
+
+    def exclusive_indexes(account_exclusive)
+      return [0, 1] if account_exclusive
+      [0, 1, 2, 3]
+    end
+
     def _identify_indexes(options, account_exclusive)
       index = options[:index] if options.key?(:index)
       index = layer_index(options[:name]) if options.key?(:name)
 
-      if account_exclusive
-        indexes = [0, 1]
-        options[:indexes] = indexes
-      else
-        indexes = [0, 1, 2, 3]
-      end
+      indexes = exclusive_indexes(account_exclusive)
+      options[:indexes] = indexes
 
       indexes = [index] if !index.nil? && indexes.include?(index)
       indexes
     end
 
-    def _set_data_options_per_indexes(indexes)
+    def _set_data_options_per_names(names)
       data_options = []
 
-      indexes.each { |index| data_options <<  _data_options_per_layer(index) }
+      names.each { |name| data_options <<  _data_options_per_layer(name) }
 
       data_options
     end
 
     # This internal function defines default section name per config index.
     # TODO: Change local and default way to get default values, not in /:default
-    def _data_options_per_layer(layer_index)
+    def _data_options_per_layer(layer_name)
       # runtime and local and default uses :default section
-      case layer_index
-      when 2, 3
+      case layer_name
+      when 'local', 'default'
         # local & default are SectionConfig and is forced to use :default as
         # section name for each data.
         { :section => :default }

data/lib/lorj_config.rb

@@ -118,8 +118,6 @@ module Lorj
       # runtime Config layer
       config_layers << define_runtime_layer
 
-      Lorj.defaults.load # Loading global application defaults
-
       if PrcLib.data_path.nil?
         PrcLib.fatal(1, 'Internal PrcLib.data_path was not set.')
       end
@@ -169,6 +167,7 @@ module Lorj
     def initialize_local_filename(config_name = nil)
       config_default_name = 'config.yaml'
 
+      config_name = nil unless config_name.is_a?(String)
       if config_name
         if File.dirname(config_name) == '.'
           config_name = File.join(PrcLib.data_path, config_name)

data/lib/prc.rb

@@ -119,7 +119,7 @@ module PrcLib
   def app_defaults=(v)
     return if @app_defaults
 
-    v = File.join(File.dirname(__FILE__), v) unless v[0] == '/'
+    v = File.join(File.dirname(__FILE__), v) unless v.include?('/')
 
     @app_defaults = File.expand_path(v)
   end

data/lib/prc_core_config.rb

@@ -382,7 +382,7 @@ module PRC
     def _do_where?(config_layers, keys, options, data_opts)
       layer_indexes = []
       config_layers.each_index do | index |
-        config = @config_layers[index][:config]
+        config = config_layers[index][:config]
 
         data_options = options.clone
         data_options.delete_if do |key|
@@ -391,7 +391,7 @@ module PRC
         data_options.merge!(data_opts[index]) if data_opts[index].is_a?(Hash)
 
         config.data_options(data_options)
-        layer_indexes << @config_layers[index][:name] if config.exist?(keys)
+        layer_indexes << config_layers[index][:name] if config.exist?(keys)
       end
       return layer_indexes if layer_indexes.length > 0
       false

data/lib/prc_section_config.rb

@@ -30,26 +30,31 @@ module PRC
     # * *Raises* :
     #   Nothing
     def [](*keys)
+      return nil if keys.length == 0
       return _get(:default, *keys) if @data_options[:section].nil?
       _get(@data_options[:section], *keys)
     end
 
     def []=(*keys, value)
+      return nil if keys.length == 0
       return _set(:default, *keys, value) if @data_options[:section].nil?
       _set(@data_options[:section], *keys, value)
     end
 
     def exist?(*keys)
+      return nil if keys.length == 0
       return _exist?(:default, *keys) if @data_options[:section].nil?
       _exist?(@data_options[:section], *keys)
     end
 
     def where?(*keys)
+      return nil if keys.length == 0
       return _exist?(:default, *keys) if @data_options[:section].nil?
       _where?(@data_options[:section], *keys)
     end
 
     def del(*keys)
+      return nil if keys.length == 0
       return _del(:default, *keys) if @data_options[:section].nil?
       _del(@data_options[:section], *keys)
     end

data/spec/03_prc_section_config_spec.rb

@@ -0,0 +1,196 @@
+#!/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 'byebug'
+
+$LOAD_PATH << File.join('..', 'lib')
+
+require 'rh.rb'
+require 'prc.rb'
+require 'prc_base_config.rb' # Load BaseConfig parent class
+require 'prc_section_config.rb' # Load SectionConfig class
+
+describe 'class: PRC::SectionConfig,' do
+  context 'PRC::SectionConfig' do
+    it '.new created a new instance' do
+      config = PRC::SectionConfig.new
+      expect(config).to be
+    end
+
+    it '.new(:default => {:test => :toto},'\
+       ':section => {:key => :value}) set expected default data' do
+      config = PRC::SectionConfig.new(:default => { :test => :toto },
+                                      :section => { :key => :value })
+      expect(config.data).to eq(:default => { :test => :toto },
+                                :section => { :key => :value })
+    end
+  end
+
+  context 'config = nil' do
+    before(:all) do
+      @config = PRC::SectionConfig.new
+    end
+
+    it 'config[:test1] = "value" set internal data to '\
+       ':default=>{:test1=>"value"}' do
+      @config[:test1] = 'value'
+      expect(@config.data).to eq(:default => { :test1 => 'value' })
+    end
+
+    it 'config[:test1, :test2] = "value" set internal data to '\
+       ':default=>{:test1 => { :test2 => "value"}}' do
+      @config[:test1, :test2] = 'value'
+      expect(@config.data).to eq(:default =>
+                                 { :test1 => { :test2 => 'value' } })
+    end
+    context 'config.data_options(:section => :mysection)' do
+      it 'return true' do
+        expect(@config.data_options(:section => :mysection)).to eq(:section =>
+                                                                   :mysection)
+      end
+
+      it 'config[:test1, :test2] = "value2" set '\
+         'mysection=>{:test1 => { :test2 => "value2"}}' do
+        @config[:test1, :test2] = 'value2'
+        expect(@config.data[:mysection]).to eq(:test1 => { :test2 => 'value2' })
+      end
+      it 'config[:test1, :test2] returns "value2"' do
+        expect(@config[:test1, :test2]).to eq('value2')
+      end
+      it 'config.data_options({})' do
+        expect(@config.data_options({})).to eq({})
+      end
+      it 'config[:test1, :test2] returns "value"' do
+        expect(@config[:test1, :test2]).to eq('value')
+      end
+    end
+  end
+
+  context 'SectionConfig.new {:default => {:test => :toto},'\
+          ':section => {:key => :value} }' do
+    before(:all) do
+      @config = PRC::SectionConfig.new(:default => { :test => :toto },
+                                       :section => { :key => :value })
+    end
+
+    it 'config.del(:test) return :toto' do
+      expect(@config.del(:test)).to eq(:toto)
+      expect(@config.data).to eq(:default => {},
+                                 :section => { :key => :value })
+    end
+
+    it 'config.del(:key) returns nil' do
+      expect(@config.del(:key)).to equal(nil)
+      expect(@config.data).to eq(:default => {},
+                                 :section => { :key => :value })
+    end
+  end
+
+  context 'SectionConfig.new {:test1 => { :test2 => "value" }}' do
+    before(:all) do
+      @config = PRC::SectionConfig.new(:test1 => { :test2 => 'value' })
+    end
+
+    it 'config[] return nil' do
+      expect(@config[]).to equal(nil)
+    end
+
+    it 'config[:test1] returns nil.' do
+      expect(@config[:test1]).to equal(nil)
+    end
+
+    it 'config[:test1, :test2] returns nil.' do
+      expect(@config[:test1, :test2]).to equal(nil)
+    end
+
+    it 'config[:test2] returns nil.' do
+      expect(@config[:test2]).to equal(nil)
+    end
+
+    it 'config[:test2] returns nil.' do
+      expect(@config[:test2]).to equal(nil)
+    end
+
+    it 'with config.data_options({:section => :test1})' do
+      expect(@config.data_options(:section =>
+                                  :test1)).to eq(:section => :test1)
+    end
+
+    it 'config[:test1] returns nil.' do
+      expect(@config[:test1]).to equal(nil)
+    end
+
+    it 'config[:test1, :test2] returns nil.' do
+      expect(@config[:test1, :test2]).to equal(nil)
+    end
+
+    it "config[:test2] returns NOW 'value'." do
+      expect(@config[:test2]).to eq('value')
+    end
+  end
+
+  context 'SectionConfig.new {:test1 => { :test2 => "value" }}' do
+    before(:all) do
+      @config = PRC::SectionConfig.new(:test1 => { :test2 => 'value' })
+    end
+
+    it 'config.exist? return nil' do
+      expect(@config.exist?).to equal(nil)
+    end
+
+    it 'config.exist?(test1) return false.' do
+      expect(@config.exist?(:test1)).to equal(false)
+    end
+
+    it 'config.exist?(:test1, :test2) return false.' do
+      expect(@config.exist?(:test1, :test2)).to equal(false)
+    end
+
+    it 'config.exist?(:test) return false.' do
+      expect(@config.exist?(:test)).to equal(false)
+    end
+
+    it 'config.exist?(:test1, :test) return false.' do
+      expect(@config.exist?(:test1, :test)).to equal(false)
+    end
+
+    it 'config.exist?(:test1, :test2, :test3) return false.' do
+      expect(@config.exist?(:test1, :test2, :test3)).to equal(false)
+    end
+
+    it 'with config.data_options({:section => :test1})' do
+      expect(@config.data_options(:section =>
+                                  :test1)).to eq(:section => :test1)
+    end
+
+    it 'config.exist? return nil' do
+      expect(@config.exist?).to equal(nil)
+    end
+
+    it 'config.exist?(test1) return false.' do
+      expect(@config.exist?(:test1)).to equal(false)
+    end
+
+    it 'config.exist?(:test1, :test2) return false.' do
+      expect(@config.exist?(:test1, :test2)).to equal(false)
+    end
+
+    it 'config.exist?(:test2) return true.' do
+      expect(@config.exist?(:test2)).to equal(true)
+    end
+  end
+end

data/spec/12_lorj_account_spec.rb

@@ -73,6 +73,37 @@ describe 'class: Lorj::Account,' do
       expect(@account.where?(:keypair_name)).to eq(%w(local default))
     end
 
+    it 'account.where?(:keypair_name, :names => %w(default)) '\
+       'return %w(default)' do
+      expect(@account.where?(:keypair_name,
+                             :names => %w(default))).to eq(%w(default))
+    end
+
+    it 'account.where?(:keypair_name, :names => %w(runtime account)) '\
+       'return false' do
+      expect(@account.where?(:keypair_name,
+                             :names => %w(runtime account))).to equal(false)
+    end
+
+    it 'account.where?(:keypair_name, :names => %w(default runtime default)) '\
+       'return %w(default default)' do
+      expect(@account.where?(:keypair_name,
+                             :names => %w(default runtime
+                                          default))).to eq(%w(default default))
+    end
+
+    it 'account.where?(:keypair_name, :names => %w(default runtime)) '\
+       'return %w(default)' do
+      expect(@account.where?(:keypair_name,
+                             :names => %w(default runtime))).to eq(%w(default))
+    end
+
+    it 'account.where?(:keypair_name, :names => %w(runtime default)) '\
+       'return %w(default)' do
+      expect(@account.where?(:keypair_name,
+                             :names => %w(runtime default))).to eq(%w(default))
+    end
+
     it "after account.local_del(:keypair_name) value is 'default_key'" do
       expect(@account.local_del(:keypair_name)).to eq('nova_local')
       expect(@account.where?(:keypair_name)).to eq(%w(default))

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lorj
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - forj team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-22 00:00:00.000000000 Z
+date: 2015-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -202,6 +202,7 @@ files:
 - spec/00_lorj_log_spec.rb
 - spec/01_hash_rh_spec.rb
 - spec/02_prc_base_config_spec.rb
+- spec/03_prc_section_config_spec.rb
 - spec/04_prc_core_config_spec.rb
 - spec/11_lorj_config_spec.rb
 - spec/12_lorj_account_spec.rb
@@ -235,6 +236,7 @@ test_files:
 - spec/00_lorj_log_spec.rb
 - spec/01_hash_rh_spec.rb
 - spec/02_prc_base_config_spec.rb
+- spec/03_prc_section_config_spec.rb
 - spec/04_prc_core_config_spec.rb
 - spec/11_lorj_config_spec.rb
 - spec/12_lorj_account_spec.rb