lorj 1.0.14 → 1.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 87a576b3dc28cb49cdd93e91746117af62bc1be4
-  data.tar.gz: cba9b715107fdb921c4f5f7f5d3400f6f32ead93
+  metadata.gz: df0501318f36deb3f6d31fdce4d63f148d91a818
+  data.tar.gz: 6800e36135d9decb469b1d9dc87e1f3be7385980
 SHA512:
-  metadata.gz: f0c80f5d67e1239406e106e9f3748258f75e6856e098352154f86b93a5bda9d1a09d01b97c249b9ebdc57e00474d9748cb5bb964300901936c4908c39b0085c4
-  data.tar.gz: d0b3371678052bcfc7febbcd7c2052e7815a1d72f37ae445cf1b42f11ea80434fc0fdd54a0c2629bc68ec305415a3a9fb4b607d9ac5ae89cfc0eb06d5d89319f
+  metadata.gz: b14d5a49cfe34e91495e412e1c64041ecad1c38927dda2c555e4b57d2589182863a1bbe6e49492639638d6ecdc8121895f667878d77f91ca5ef32a944b20f87b
+  data.tar.gz: 61d2970cecf4ba70bb01135ecfcc6813bf43ff89c708aa0e29c716975881562cca13b611d533414f263a9d289ddaada7bea8a6fdb83ea43d1abd0ea4b60b6592

data/bin/lorj_account_import.rb

@@ -39,7 +39,6 @@ class Test < Lorj::BaseDefinition
 
   # Internal function to test.
   def_internal '_get_encrypt_key'
-  def_internal '_get_encrypted_value'
 
   def run
     puts 'Checking imported account...'
@@ -53,7 +52,8 @@ class Test < Lorj::BaseDefinition
     entr = _get_encrypt_key
     data = @core.config['credentials#account_key']
 
-    res = _get_encrypted_value(data, entr, 'credentials#account_key')
+    res = Lorj::SSLCrypt.get_encrypted_value(data, entr,
+                                             'credentials#account_key')
 
     test_state(!res.nil?, 'Account key', data)
   end
@@ -69,20 +69,15 @@ class Test < Lorj::BaseDefinition
 end
 
 # TODO: Implement Thor instead of ARGV use.
+# TODO: Support to load local process.
 if ARGV.length <= 3
   puts "Syntax is 'ruby #{__FILE__}' <LorjRef> <key> <CloudDataFile> "\
-       "[<AccountName[@provider]>]\n"\
+       "[<AccountName>]\n"\
        "where:\n"\
        "LorjRef       : Lorj application struture to use. \n"\
-       '                Format: <datapath[|<pdatapath>]>='\
-       "<process>[@<libToLoad]\n"\
+       "                Format: <datapath[|<pdatapath>]>\n"\
        "  datapath    : Path where Lorj store data.\n"\
        "  pdatapath   : Path where Lorj store private data.\n"\
-       "  process     : Lorj process name to load. It can be a path to a\n"\
-       "                process file.\n"\
-       "  libToLoad   : Optional. Ruby library containing The Lorj process.\n"\
-       "                If missing, it will try to load a lib named \n"\
-       "                lorj_<process>\n"\
        'key           : Base64 encoded key. Used to decrypt the <CloudDataFi'\
        "le>\n"\
        "CloudDataFile : File containing the Lorj cloud data to import.\n"\
@@ -94,7 +89,7 @@ end
 
 ref, key_encoded, data_file, account = ARGV
 
-ref_found = ref.match(/^(.*(\|(.*))?)=(.*?)(@(.*))?$/)
+ref_found = ref.match(/^(.*(\|(.*))?)$/)
 
 unless ref_found
   puts 'LorjRef must be formatted as : <datapath[|<pdatapath>]>='\
@@ -105,13 +100,6 @@ end
 datapath = ref_found[1]
 pdatapath = datapath
 pdatapath = ref_found[3] unless ref_found[3].nil?
-process = ref_found[4]
-
-if ref_found[6].nil?
-  lib_name = "lorj_#{process}"
-else
-  lib_name = ref_found[6]
-end
 
 unless File.exist?(data_file)
   puts "#{data_file} doesn't exist. Please check and retry."
@@ -123,12 +111,6 @@ if key_encoded == ''
   exit 1
 end
 
-begin
-  require lib_name
-rescue => e
-  puts "Warning! Unable to load RubyGem '#{lib_name}'.\n#{e}"
-end
-
 if key_encoded.length % 4 > 0
   key_encoded += '=' * (4 - (key_encoded.length % 4))
 end
@@ -154,20 +136,12 @@ else
   end
 end
 
-name, controller = account.split('@') unless account.nil?
-
 PrcLib.data_path = datapath
 PrcLib.pdata_path = pdatapath
 
-keypath = Lorj::KeyPath.new(process)
-
-processes = [{ :process_module => keypath.key_tree }]
-
-core = Lorj::Core.new(Lorj::Account.new, processes)
-
 data = File.read(data_file).strip
 
-core.account_import(entr, data, name, controller)
+core = Lorj.account_import(entr, data, account)
 
 puts 'Import done.'
 

data/lib/core/core.rb

@@ -15,8 +15,6 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 
-# rubocop: disable Metrics/AbcSize
-
 # Module Lorj which contains several classes.
 #
 # Those classes describes :
@@ -317,17 +315,21 @@ module Lorj
 
     # Function to import an encrypted Hash as a Lorj Account.
     #
-    # For details about this functions, see #Lorj::BaseDefinition.account_import
+    # For details about this functions,
+    # see #Lorj::BaseDefinition.account_data_import
+    #
+    # To import an exported data, consider calling Lorj.account_import.
     #
     # * *Args* :
-    #   - +key+      : key to use to decrypt the 'enc_hash'.
-    #   - +enc_hash+ : Encrypted Hash.
+    #   - +data+ : Hash. data to import.
+    #   - +name+ : By default, it import in the same name described in the data.
+    #     But we can change it with this parameter.
     #
     # * *Raises* :
     #   No exceptions
-    def account_import(key, enc_hash, name = nil, controller = nil)
+    def account_import(data, name = nil)
       return nil if @core_object.nil?
-      @core_object.account_import(key, enc_hash, name, controller)
+      @core_object.account_data_import(data, name)
     end
 
     # Function to export a Lorj Account in an encrypted Hash.
@@ -402,6 +404,7 @@ module Lorj
       # (processes & controller)
       initialize_core_object(model)
       PrcLib.model.clear_heap
+      PrcLib.processes model[:processes]
     end
 
     private
@@ -470,20 +473,40 @@ module Lorj
   #     It must be controllers/<controller_name>/<controller_name>.rb
   #     You can change 'controllers' by any name, with :controllers_dir
   #
-  #   - +properties   : Optional.
+  #   - +properties   : required.
   #     - :controllers_dir : Name of the controllers directory.
   #       By default 'controllers'
+  #     - :lib_name : name of the gem library declaring the process.
   #
   #  The process will be added in Lorj.processes Hash
   #
   def declare_process(process_name, path, properties = {})
+    unless properties.is_a?(Hash) && properties[:lib_name].is_a?(String)
+      puts("Lorj: process module error: '#{__method__}"\
+           "('#{process_name}', '#{path}', #{properties})' requires :lib_name"\
+           "\nat line #{caller[0]}")
+      return nil
+    end
     process_data = Lorj::ProcessResource.new(process_name, path, properties)
 
-    return nil if process_data.nil?
+    if process_data.nil?
+      puts("Lorj: process module error: '#{process_name}' fails to be "\
+           "declared:\n"\
+           "process_name: '#{process_name}'\n"\
+           "path        : '#{path}'\n"\
+           "properties  : #{properties.to_yaml}")
+      return nil
+    end
 
     @processes = {} if @processes.nil?
 
-    return nil if process_data.process.nil?
+    if process_data.process.nil?
+      puts("Lorj: process module error: process failure:\n"\
+           "process_name: '#{process_name}'\n"\
+           "path        : '#{path}'\n"\
+           "properties  : #{properties.to_yaml}")
+      return nil
+    end
 
     process_name = process_data.name
 
@@ -492,8 +515,8 @@ module Lorj
     process_data
   end
 
-  # Define module data for lorj library configuration
-  class << self
-    attr_reader :processes
+  def processes
+    @processes = {} if @processes.nil?
+    @processes
   end
 end

data/lib/core/core_import_export.rb

@@ -17,14 +17,57 @@
 
 #
 module Lorj
+  # Function to import an encrypted Hash as a Lorj Account.
+  #
+  # The encrypted Hash will be decrypted by the key provided.
+  # The content of the hash will be stored in the 'account' layer
+  # of config.
+  #
+  # For details on how import work, look in #account_data_import
+  #
+  # * *Args* :
+  #   - +key+         : key to use to decrypt the 'enc_hash'.
+  #   - +import_data+ : import data. This data is structured as follow:
+  #     - :enc_data : The encrypted account data.
+  #     - :processes: Array or models + controllers to load.
+  #   - +name+        : Optional. Name of the account.
+  #
+  # * *returns*:
+  #   - +core+ : Core object, with loaded model, created during the import.
+  #
+  # * *Raises* :
+  #   No exceptions
+  def self.account_import(key, import_data, name = nil)
+    import_data = YAML.load(import_data)
+    hash = Lorj::SSLCrypt.get_encrypted_value(import_data[:enc_data], key,
+                                              'Encrypted account data')
+
+    data = YAML.load(hash)
+
+    processes = import_data[:processes]
+
+    processes.each do |p|
+      next unless p.key?(:process_module)
+
+      PrcLib.debug("Loading module '#{p[:process_module]}' from GEM lib '%s'",
+                   p[:lib_name])
+      begin
+        require "#{p[:lib_name]}"
+      rescue => e
+        PrcLib.error("Unable to load module '#{p[:process_module]}'\n%s", e)
+      end
+    end
+
+    core = Lorj::Core.new(Lorj::Account.new, processes)
+    core.account_import(data, name)
+
+    core
+  end
+
   # Implements account_import and account_export
   # exposed by core.
   class BaseDefinition
-    # Function to import an encrypted Hash as a Lorj Account.
-    #
-    # The encrypted Hash will be decrypted by the key provided.
-    # The content of the hash will be stored in the 'account' layer
-    # of config.
+    # Function to import an account data in Lorj::Account.
     #
     # The 'account' layer is not cleaned before. If you need to
     # clean it up, do:
@@ -39,7 +82,7 @@ module Lorj
     # If you pass 'name' and 'controller', ac_update will be used to update the
     # account data
     # If the imported data contains name and controller data, by default, it
-    # will call ac_update except if name is an empty string.
+    # will call ac_update.
     #
     # The location used comes from PrcLib.data_path
     # Passwords will be encrypted by the internal .key file stored in
@@ -49,19 +92,13 @@ module Lorj
     # verify if some data are missed for any object action (create/delete/...)
     #
     # * *Args* :
-    #   - +key+        : key to use to decrypt the 'enc_hash'.
-    #   - +enc_hash+   : Encrypted Hash.
+    #   - +data+       : Account data to import.
     #   - +name+       : Optional. Name of the account.
-    #   - +controller+ : Optional. Name of the controller.
     #
     # * *Raises* :
     #   No exceptions
-    def account_import(key, enc_hash, name = nil, controller = nil)
-      hash = _get_encrypted_value(enc_hash, key, 'Encrypted account data')
-
-      data = YAML.load(hash)
-
-      _update_account_meta(data, name, controller)
+    def account_data_import(data, name = nil)
+      _update_account_meta(data, name)
 
       entr = _get_encrypt_key
 
@@ -70,7 +107,7 @@ module Lorj
           key = "#{s}##{k}"
           data_def = Lorj.data.auto_section_data(key)
           if data_def && data_def[:encrypted].is_a?(TrueClass)
-            v = _encrypt_value(v, entr)
+            v = Lorj::SSLCrypt.encrypt_value(v, entr)
           end
           config.set(key, v, :name => 'account')
         end
@@ -127,26 +164,42 @@ module Lorj
         rhash_tree = Lorj.data.first_section(k)
         rhash_tree = v[:keys] if v.key?(:keys)
         if !data_def.nil? && data_def[:encrypted].is_a?(TrueClass)
-          data = _get_encrypted_value(data, entr, data_def[:desc])
+          data = Lorj::SSLCrypt.get_encrypted_value(data, entr, data_def[:desc])
         end
         rhash.rh_set(data, *rhash_tree)
       end
 
-      entr = _new_encrypt_key
-      [entr, _encrypt_value(rhash.to_yaml, entr)]
+      entr = Lorj::SSLCrypt.new_encrypt_key
+      export_data = { :enc_data => Lorj::SSLCrypt.encrypt_value(rhash.to_yaml,
+                                                                entr) }
+      export_data[:processes] = _export_processes
+      [entr, export_data.to_yaml]
     end
 
     private
 
-    def _update_account_meta(data, name, controller)
+    def _export_processes
+      export_data = []
+      PrcLib.processes.each do |p|
+        next unless p.key?(:process_name) && p.key?(:lib_name)
+
+        process = {}
+        process[:process_module] = p[:process_name]
+        process[:lib_name] = p[:lib_name]
+        process[:controller] = p[:controller_name] if p.key?(:controller_name)
+        export_data << process if process.length > 0
+      end
+      export_data
+    end
+
+    def _update_account_meta(data, name)
       if name.nil? && data.rh_exist?(:account, :name)
         name = data.rh_get(:account, :name)
       end
-      if controller.nil? && data.rh_exist?(:account, :provider)
-        controller = data.rh_get(:account, :provider)
-      end
+      controller = data.rh_get(:account, :provider)
 
       name = nil if name == ''
+      controller = nil if controller == ''
 
       config.ac_update(name, controller) unless name.nil? || controller.nil?
     end

data/lib/core/core_internal.rb

@@ -14,8 +14,6 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 
-# rubocop: disable Metrics/AbcSize
-
 # - Lorj::Core : Lorj exposed interface.
 #   - Initialization functions
 module Lorj
@@ -331,6 +329,7 @@ module Lorj
       module_process = Lorj.processes[name]
       my_process[:process_name] = name
       my_process[:process_path] = module_process.process
+      my_process[:lib_name] = module_process.lib_name
 
       if a_process[:controller_path]
         my_process[:controller_path] = a_process[:controller_path]
@@ -391,15 +390,20 @@ module Lorj
     def _process_module_set_ctr(my_process, controllers, controller_name)
       return if controller_name.nil?
 
+      unless controller_name.is_a?(String)
+        controller_name = controller_name.to_s
+      end
       controller_path = controllers[controller_name]
 
       if controller_path.nil?
         PrcLib.warning("Controller '%s' was not found. Please check. The "\
-                       'process may not work.', controller_name)
+                       "process may not work. \nValid one are '%s'",
+                       controller_name, controllers.keys)
         return
       end
 
       my_process[:controller_path] = controller_path
+      my_process[:controller_name] = controller_name
     end
 
     # Function analyzing the process class parameter
@@ -474,6 +478,11 @@ module Lorj
 
       the_process_class
     end
+  end
+
+  # Define private Initialize functions for controllers
+  class Core
+    private
 
     # Determine the process file path from the single name.
     # Uses PrcLib.process_path as path to load this process.

data/lib/core/core_object_params.rb

@@ -112,7 +112,8 @@ module Lorj
       end
 
       if param_options[:decrypt].is_a?(TrueClass)
-        value = _get_encrypted_value(value, _get_encrypt_key, attr_name)
+        value = Lorj::SSLCrypt.get_encrypted_value(value, _get_encrypt_key,
+                                                   attr_name)
       end
 
       return unless param_options[:mapping]

data/lib/core/core_setup_encrypt.rb

@@ -26,10 +26,8 @@ require 'base64'
 #                               and setup
 # this task to make it to work.
 module Lorj
-  # Adding encrypt core functions.
-  class BaseDefinition
-    private
-
+  # SSL Encryption feature for Lorj.
+  module SSLCrypt
     # internal runtime function to create a new key
     # *parameters*:
     #   - +new+       : true to create a new key.
@@ -40,7 +38,7 @@ module Lorj
     #     - :key: password
     #     - :salt : String current time number
     #     - :iv: Base64 random iv
-    def _new_encrypt_key(key = rand(36**10).to_s(36))
+    def self.new_encrypt_key(key = rand(36**10).to_s(36))
       random_iv = OpenSSL::Cipher::Cipher.new('aes-256-cbc').random_iv
       {
         :key => key,
@@ -49,6 +47,57 @@ module Lorj
       }
     end
 
+    # internal runtime function for process call #_build_hdata and
+    # #_get_encrypted_value_hidden
+    # Get encrypted value
+    #
+    # *parameters*:
+    #   - +default+     : encrypted default value
+    #   - +entropy+     : Entropy Hash
+    #   - +sDesc+       : data description
+    #
+    # *return*:
+    # - value : decrypted value.
+    #
+    # *raise*:
+    #
+    def self.get_encrypted_value(enc_value, entr, sDesc)
+      return '' if enc_value.nil?
+      begin
+        Encryptor.decrypt(
+          :value => Base64.strict_decode64(enc_value),
+          :key => entr[:key],
+          :iv => Base64.strict_decode64(entr[:iv]),
+          :salt => entr[:salt]
+        )
+      rescue => e
+        PrcLib.error("Unable to decrypt your %s.\n"\
+                     "%s\n"\
+                     ' You will need to re-enter it.',
+                     sDesc, e)
+      end
+    end
+
+    # Function to encrypt a data with a entr key.
+    #
+    # *return*:
+    # - value : encrypted value in Base64 encoded data.
+    def self.encrypt_value(value, entr)
+      Base64.strict_encode64(
+        Encryptor.encrypt(
+          :value => value,
+          :key => entr[:key],
+          :iv => Base64.strict_decode64(entr[:iv]),
+          :salt => entr[:salt]
+        )
+      )
+    end
+  end
+
+  # Adding encrypt core functions.
+  class BaseDefinition
+    private
+
     # internal runtime function for process call
     # Get encrypted value hidden by *
     #
@@ -67,7 +116,7 @@ module Lorj
       key_file = File.join(PrcLib.pdata_path, '.key')
       if !File.exist?(key_file)
         # Need to create a random key.
-        entr = _new_encrypt_key
+        entr = Lorj::SSLCrypt.new_encrypt_key
 
         Lorj.debug(2, "Writing '%s' key file", key_file)
         unless PrcLib.dir_exists?(PrcLib.pdata_path)
@@ -101,7 +150,8 @@ module Lorj
       return '' if enc_value.nil?
       value_hidden = ''
       begin
-        value_hidden = '*' * _get_encrypted_value(enc_value, entr, sDesc).length
+        value_hidden = '*' * Lorj::SSLCrypt.get_encrypted_value(enc_value, entr,
+                                                                sDesc).length
       rescue => e
         PrcLib.error('Unable to decrypt your %s. You will need to re-enter it.'\
                      '\n%s', sDesc, e.message)
@@ -112,52 +162,6 @@ module Lorj
       value_hidden
     end
 
-    # internal runtime function for process call #_build_hdata and
-    # #_get_encrypted_value_hidden
-    # Get encrypted value
-    #
-    # *parameters*:
-    #   - +default+     : encrypted default value
-    #   - +entropy+     : Entropy Hash
-    #   - +sDesc+       : data description
-    #
-    # *return*:
-    # - value : decrypted value.
-    #
-    # *raise*:
-    #
-    def _get_encrypted_value(enc_value, entr, sDesc)
-      return '' if enc_value.nil?
-      begin
-        Encryptor.decrypt(
-          :value => Base64.strict_decode64(enc_value),
-          :key => entr[:key],
-          :iv => Base64.strict_decode64(entr[:iv]),
-          :salt => entr[:salt]
-        )
-      rescue => e
-        PrcLib.error("Unable to decrypt your %s.\n"\
-                     "%s\n"\
-                     ' You will need to re-enter it.',
-                     sDesc, e)
-      end
-    end
-
-    # Function to encrypt a data with a entr key.
-    #
-    # *return*:
-    # - value : encrypted value in Base64 encoded data.
-    def _encrypt_value(value, entr)
-      Base64.strict_encode64(
-        Encryptor.encrypt(
-          :value => value,
-          :key => entr[:key],
-          :iv => Base64.strict_decode64(entr[:iv]),
-          :salt => entr[:salt]
-        )
-      )
-    end
-
     # internal runtime function for process call
     # Ask encrypted function executed by _ask
     #
@@ -194,7 +198,7 @@ module Lorj
           PrcLib.message('%s cannot be empty.', sDesc) if value_free == ''
         end
       end
-      _encrypt_value(value_free, entr)
+      Lorj::SSLCrypt.encrypt_value(value_free, entr)
     end
   end
 end

data/lib/core/definition.rb

@@ -15,8 +15,6 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 
-# rubocop: disable Metrics/AbcSize
-
 # Module Lorj which contains several classes.
 #
 # Those classes describes :

data/lib/core/process.rb

@@ -22,7 +22,8 @@ module Lorj
   #
   #
   class ProcessResource
-    attr_reader :defaults_file, :data_file, :process, :name, :controllers
+    attr_reader :defaults_file, :data_file, :process, :name, :controllers,
+                :lib_name
 
     # ProcessResource initialization
     #
@@ -49,6 +50,7 @@ module Lorj
     #     By default is `<name>/defaults.yaml`
     #   - :data_file    : Use a different file as process data definition.
     #     By default is `<name>/data.yaml`
+    #   - :lib_name     : Is the name of the library declaring the process.
     #
     # * *return*:
     #   - self with at least a process name and a path to it.
@@ -82,6 +84,8 @@ module Lorj
                                                          name, 'data.yaml'))
       @data_file = data_file if data_file
 
+      @lib_name = props[:lib_name] if props.key?(:lib_name)
+
       self
     end
 

data/lib/lorj/version.rb

@@ -16,6 +16,6 @@
 
 # Lorj version
 module Lorj
-  VERSION = '1.0.14'
-  DATE = '2015-06-24'
+  VERSION = '1.0.16'
+  DATE = '2015-06-25'
 end

data/lib/lorj.rb

@@ -82,7 +82,7 @@ module Lorj
   # Internally used with raise.
   # Used to identify the error origin, while an error is thrown.
   class PrcError < RuntimeError
-    attr_reader :lorg_message
+    attr_reader :lorj_message
 
     def initialize(message = nil)
       @lorj_message = message

data/lib/prc.rb

@@ -97,6 +97,10 @@ require 'logger'
 #
 #   Model loaded.
 #
+# - PrcLib.processes
+#
+#   Processes loaded.
+#
 # - PrcLib.log_file
 #
 #   Initialize a log file name (relative or absolute path) instead of default
@@ -148,7 +152,10 @@ module PrcLib
   rescue => e
     fatal_error(1, e.message)
   end
+end
 
+# Defines module parameters.
+module PrcLib
   # Define module data for lorj library configuration
   class << self
     attr_accessor :log, :core_level
@@ -226,7 +233,7 @@ module PrcLib
     end
   end
 
-  # TODO: Low. Be able to support multiple model.
+  # TODO: Low. Be able to support multiple model loaded.
 
   # Lorj::Model object access.
   # If the object doesn't exist, it will be created
@@ -235,6 +242,14 @@ module PrcLib
     @model
   end
 
+  # TODO: Low. Be able to support multiple processes loaded.
+
+  # PrcLib.processes
+  def processes(p = nil)
+    @processes = p unless p.nil?
+    @processes
+  end
+
   # TODO: Support for several defaults, depending on controllers loaded.
 
   # Attribute app_defaults

data/spec/21_lorj_processes_spec.rb

@@ -129,7 +129,8 @@ describe 'Lorj::Process,' do
     end
 
     it 'can declare a module process' do
-      expect(Lorj.declare_process('mock', @process_path)).to be
+      expect(Lorj.declare_process('mock', @process_path,
+                                  :lib_name => 'lorj')).to be
     end
 
     it 'kept module in Lorj.processes' do
@@ -138,14 +139,19 @@ describe 'Lorj::Process,' do
     end
 
     it 'Lorj.declare_process, can declare several module processes' do
-      expect(Lorj.declare_process('mock', @process_path)).to be
-      expect(Lorj.declare_process(:mock2, @process_path)).to be
-      expect(Lorj.declare_process('mock3', @process_path)).to equal(nil)
+      expect(Lorj.declare_process('mock', @process_path,
+                                  :lib_name => 'lorj')).to be
+      expect(Lorj.declare_process(:mock2, @process_path,
+                                  :lib_name => 'lorj')).to be
+      expect(Lorj.declare_process('mock3', @process_path,
+                                  :lib_name => 'lorj')).to equal(nil)
     end
 
     it 'become empty, if name or process_path are incorrect' do
-      expect(Lorj.declare_process(nil, @process_path)).to equal(nil)
-      expect(Lorj.declare_process('mock', nil)).to equal(nil)
+      expect(Lorj.declare_process(nil, @process_path,
+                                  :lib_name => 'lorj')).to equal(nil)
+      expect(Lorj.declare_process('mock', nil,
+                                  :lib_name => 'lorj')).to equal(nil)
     end
 
     it 'all kept module processes in Lorj.processes not duplicated.' do

data/spec/22_lorj_core_spec.rb

@@ -39,8 +39,9 @@ require 'spec_helper'
 describe 'Lorj::Core,' do
   context 'Using lorj-spec process, ' do
     process_path = File.expand_path(File.join(app_path, '..', 'lorj-spec'))
-    Lorj.declare_process('mock', process_path)
+    Lorj.declare_process('mock', process_path, :lib_name => 'lorj')
     Lorj.declare_process('mock2', process_path,
+                         :lib_name => 'lorj',
                          :controllers_path => File.join(process_path,
                                                         'providers_extra'))
   end

data/spec/30_lorj_basedefinition_spec.rb

@@ -54,11 +54,8 @@ describe 'Internal BaseDefinition features' do
         end
 
         # Internal function to test.
-        def_internal '_new_encrypt_key'
         def_internal '_get_encrypt_key'
         def_internal '_get_encrypted_value_hidden'
-        def_internal '_get_encrypted_value'
-        def_internal '_encrypt_value'
         def_internal '_account_map'
       end
 
@@ -73,8 +70,8 @@ describe 'Internal BaseDefinition features' do
       File.delete(@key_file) if File.exist?(@key_file)
     end
 
-    it '_new_encrypt_key return a new entr hash' do
-      ret = @spec_obj.spec_new_encrypt_key
+    it 'Lorj::SSLCrypt.new_encrypt_key return a new entr hash' do
+      ret = Lorj::SSLCrypt.new_encrypt_key
       expect(ret.class).to equal(Hash)
       expect(ret.keys.sort).to eq([:key, :salt, :iv].sort)
       expect(ret[:key].class).to equal(String)
@@ -93,21 +90,21 @@ describe 'Internal BaseDefinition features' do
       expect(@spec_obj.spec_get_encrypt_key).to eq(ret)
     end
 
-    it '_encrypt_value return a strict base64 data' do
+    it 'Lorj::SSLCrypt.encrypt_value return a strict base64 data' do
       to_enc = 'Data to encrypt'
       entr = @spec_obj.spec_get_encrypt_key
-      ret = @spec_obj.spec_encrypt_value(to_enc, entr)
+      ret = Lorj::SSLCrypt.encrypt_value(to_enc, entr)
 
       expect(Base64.strict_decode64(ret).class).to eq(String)
-      expect(ret).to eq(@spec_obj.spec_encrypt_value(to_enc, entr))
+      expect(ret).to eq(Lorj::SSLCrypt.encrypt_value(to_enc, entr))
     end
 
-    it '_get_encrypted_value return is decryptable' do
+    it 'Lorj::SSLCrypt.get_encrypted_value return is decryptable' do
       to_enc = 'Data to encrypt'
       entr = @spec_obj.spec_get_encrypt_key
-      ret = @spec_obj.spec_encrypt_value(to_enc, entr)
+      ret = Lorj::SSLCrypt.encrypt_value(to_enc, entr)
 
-      expect(@spec_obj.spec_get_encrypted_value(ret, entr,
+      expect(Lorj::SSLCrypt.get_encrypted_value(ret, entr,
                                                 'value')).to eq(to_enc)
     end
 
@@ -115,7 +112,7 @@ describe 'Internal BaseDefinition features' do
        'original value' do
       to_enc = 'Data to encrypt'
       entr = @spec_obj.spec_get_encrypt_key
-      ret = @spec_obj.spec_encrypt_value(to_enc, entr)
+      ret = Lorj::SSLCrypt.encrypt_value(to_enc, entr)
       hidden = @spec_obj.spec_get_encrypted_value_hidden('value', ret, entr)
 
       expect(hidden.include?('*')).to equal(true)

data/spec/31_lorj_importexport_spec.rb

@@ -55,8 +55,6 @@ describe 'Internal BaseDefinition features' do
 
         # Internal function to test.
         def_internal '_get_encrypt_key'
-        def_internal '_get_encrypted_value'
-        def_internal '_encrypt_value'
       end
 
       # Spec class for ImportExport feature spec
@@ -89,9 +87,10 @@ describe 'Internal BaseDefinition features' do
       @spec_obj = ImportExportSpec.new(@config)
 
       process_path = File.expand_path(File.join(app_path, '..', 'lorj-spec'))
-      Lorj.declare_process('mock', process_path)
+      Lorj.declare_process('mock', process_path, :lib_name => 'lorj')
 
-      @core = Lorj::Core.new(@config, [{ :process_module => :mock }])
+      @core = Lorj::Core.new(@config, [{ :process_module => :mock,
+                                         :controller_name => :mock }])
 
       @key_file = File.join(PrcLib.pdata_path, '.key')
       @crypt = BaseDefinitionSpec.new
@@ -110,14 +109,20 @@ describe 'Internal BaseDefinition features' do
       expect(@spec_obj.spec_account_map['credentials#key']).to eq({})
     end
 
-    it 'account_export() returns valid [entr, data_enc]' do
+    it 'account_export() returns valid [entr, export_dat]' do
       export = @spec_obj.account_export
       expect(export.class).to equal(Array)
-      entr, data_encrypted = export
-      data_decrypted = @crypt.s_get_encrypted_value(data_encrypted,
-                                                    entr, 'data encrypted')
-      expect(data_decrypted.class).to equal(String)
-      data = YAML.load(data_decrypted)
+      entr, export_dat = export
+      export_dat = YAML.load(export_dat)
+      expect(export_dat.key?(:enc_data)).to equal(true)
+      expect(export_dat.key?(:processes)).to equal(true)
+      expect(export_dat[:processes].class).to equal(Array)
+      expect(export_dat[:processes][0].key?(:process_module)).to equal(true)
+      expect(export_dat[:processes][0].key?(:lib_name)).to equal(true)
+      dat_decrypted = Lorj::SSLCrypt.get_encrypted_value(export_dat[:enc_data],
+                                                         entr, 'data encrypted')
+      expect(dat_decrypted.class).to equal(String)
+      data = YAML.load(dat_decrypted)
       expect(data.rh_exist?(:account, :name)).to equal(true)
       expect(data.rh_get(:account, :name)).to eq('test')
       expect(data.rh_exist?(:credentials, :keypair_name)).to equal(true)
@@ -127,30 +132,33 @@ describe 'Internal BaseDefinition features' do
     end
 
     it 'account_export(nil, false) returns account@name and credentials#key' do
-      entr, data_encrypted = @spec_obj.account_export(nil, false)
-      data_decrypted = @crypt.s_get_encrypted_value(data_encrypted,
-                                                    entr, 'data encrypted')
-      data = YAML.load(data_decrypted)
+      entr, export_dat = @spec_obj.account_export(nil, false)
+      export_dat = YAML.load(export_dat)
+      dat_decrypted = Lorj::SSLCrypt.get_encrypted_value(export_dat[:enc_data],
+                                                         entr, 'data encrypted')
+      data = YAML.load(dat_decrypted)
       expect(data.rh_exist?(:account, :name)).to equal(false)
       expect(data.rh_exist?(:credentials, :key)).to equal(true)
     end
 
     it 'account_export(nil, false, false) returns "runtime" keypair_name'\
        ' value' do
-      entr, data_encrypted = @spec_obj.account_export(nil, false, false)
-      data_decrypted = @crypt.s_get_encrypted_value(data_encrypted,
-                                                    entr, 'data encrypted')
-      data = YAML.load(data_decrypted)
+      entr, export_dat = @spec_obj.account_export(nil, false, false)
+      export_dat = YAML.load(export_dat)
+      dat_decrypted = Lorj::SSLCrypt.get_encrypted_value(export_dat[:enc_data],
+                                                         entr, 'data encrypted')
+      data = YAML.load(dat_decrypted)
       expect(data.rh_exist?(:credentials, :keypair_name)).to equal(true)
       expect(data.rh_get(:credentials, :keypair_name)).to eq('another_key')
     end
 
     it 'account_export({"credentials#key" => {}}) returns key, '\
        'name & provider' do
-      entr, data_encrypted = @spec_obj.account_export('credentials#key' => {})
-      data_decrypted = @crypt.s_get_encrypted_value(data_encrypted,
-                                                    entr, 'data encrypted')
-      data = YAML.load(data_decrypted)
+      entr, export_dat = @spec_obj.account_export('credentials#key' => {})
+      export_dat = YAML.load(export_dat)
+      dat_decrypted = Lorj::SSLCrypt.get_encrypted_value(export_dat[:enc_data],
+                                                         entr, 'data encrypted')
+      data = YAML.load(dat_decrypted)
       expect(data.rh_exist?(:credentials, :keypair_name)).to equal(false)
       expect(data.rh_exist?(:credentials, :key)).to equal(true)
       expect(data.rh_exist?(:account, :name)).to equal(true)
@@ -159,24 +167,39 @@ describe 'Internal BaseDefinition features' do
     it 'account_export({"credentials#key" => {:keys => [:server, :key]}})'\
        ' returns ' do
       map = { 'credentials#key' => { :keys => [:server, :key] } }
-      entr, data_encrypted = @spec_obj.account_export(map)
-      data_decrypted = @crypt.s_get_encrypted_value(data_encrypted,
-                                                    entr, 'data encrypted')
-      data = YAML.load(data_decrypted)
+      entr, export_dat = @spec_obj.account_export(map)
+      export_dat = YAML.load(export_dat)
+      dat_decrypted = Lorj::SSLCrypt.get_encrypted_value(export_dat[:enc_data],
+                                                         entr, 'data encrypted')
+      data = YAML.load(dat_decrypted)
       expect(data.rh_exist?(:credentials, :key)).to equal(false)
       expect(data.rh_exist?(:server, :key)).to equal(true)
       expect(data.rh_exist?(:account, :name)).to equal(true)
     end
 
-    it 'account_import(entr, enc_hash) update the "account layer"' do
-      entr, data_encrypted = @spec_obj.account_export
+    it 'account_data_import(data) update the "account layer"' do
+      entr, export_dat = @spec_obj.account_export
+      export_dat = YAML.load(export_dat)
       @config.ac_erase
-      data = @spec_obj.account_import(entr, data_encrypted)
-      expect(data.class).to equal(Hash)
+      dat_decrypted = Lorj::SSLCrypt.get_encrypted_value(export_dat[:enc_data],
+                                                         entr, 'data encrypted')
+      data = YAML.load(dat_decrypted)
+      res = @spec_obj.account_data_import(data)
+      expect(res.class).to equal(Hash)
       expect(@config['account#name']).to eq('test')
       expect(@config[:keypair_name]).to eq('another_key')
       expect(@config.get(:keypair_name, nil,
                          :name => 'account')).to eq('mykey')
     end
+
+    it 'Lorj.account_import(entr, enc_hash) update the "account layer"' do
+      entr, export_dat = @spec_obj.account_export
+      core = Lorj.account_import(entr, export_dat)
+      expect(core).to be
+      expect(core.config['account#name']).to eq('test')
+      expect(core.config[:keypair_name]).to eq('mykey')
+      expect(core.config.get(:keypair_name, nil,
+                             :name => 'account')).to eq('mykey')
+    end
   end
 end

data/spec/spec_helper.rb

@@ -86,3 +86,29 @@ module Lorj
     a
   end
 end
+
+RSpec.configure do |config|
+  config.before(:all, &:silence_output)
+  config.after(:all,  &:enable_output)
+end
+
+public
+
+# Redirects stderr and stout to /dev/null.txt
+def silence_output
+  # Store the original stderr and stdout in order to restore them later
+  @original_stderr = $stderr
+  @original_stdout = $stdout
+
+  # Redirect stderr and stdout
+  $stderr = File.open(File.join('', 'dev', 'null'), 'w')
+  $stdout = File.open(File.join('', 'dev', 'null'), 'w')
+end
+
+# Replace stderr and stdout so anything else is output correctly
+def enable_output
+  $stderr = @original_stderr
+  $stdout = @original_stdout
+  @original_stderr = nil
+  @original_stdout = nil
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lorj
 version: !ruby/object:Gem::Version
-  version: 1.0.14
+  version: 1.0.16
 platform: ruby
 authors:
 - forj team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-24 00:00:00.000000000 Z
+date: 2015-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler