config.rb in symmetric-encryption-4.0.1

- old
+ new

@@ -27,11 +27,11 @@
 
     # Reads the entire configuration for all environments from the supplied file name.
     def self.read_file(file_name)
       config = YAML.load(ERB.new(File.new(file_name).read).result)
       config = deep_symbolize_keys(config)
-      config.each_pair { |env, cfg| SymmetricEncryption::Config.send(:migrate_old_formats!, cfg) }
+      config.each_pair { |_env, cfg| SymmetricEncryption::Config.send(:migrate_old_formats!, cfg) }
       config
     end
 
     # Write the entire configuration for all environments to the supplied file name.
     def self.write_file(file_name, config)
@@ -48,18 +48,16 @@
 
     # Load the Encryption Configuration from a YAML file.
     #
     # See: `.load!` for parameters.
     def initialize(file_name: nil, env: nil)
-      unless env
-        env = defined?(Rails) ? Rails.env : ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'
-      end
+      env ||= defined?(Rails) ? Rails.env : ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'
 
       unless file_name
         root      = defined?(Rails) ? Rails.root : '.'
         file_name =
-          if env_var = ENV['SYMMETRIC_ENCRYPTION_CONFIG']
+          if (env_var = ENV['SYMMETRIC_ENCRYPTION_CONFIG'])
             File.expand_path(env_var)
           else
             File.join(root, 'config', 'symmetric-encryption.yml')
           end
         raise(ConfigError, "Cannot find config file: #{file_name}") unless File.exist?(file_name)
@@ -71,66 +69,67 @@
 
     # Returns [Hash] the configuration for the supplied environment.
     def config
       @config ||= begin
         raise(ConfigError, "Cannot find config file: #{file_name}") unless File.exist?(file_name)
-        unless env_config = YAML.load(ERB.new(File.new(file_name).read).result)[env]
-          raise(ConfigError, "Cannot find environment: #{env} in config file: #{file_name}")
-        end
-        env_config = self.class.deep_symbolize_keys(env_config)
-        self.class.migrate_old_formats!(env_config)
+
+        env_config = YAML.load(ERB.new(File.new(file_name).read).result)[env]
+        raise(ConfigError, "Cannot find environment: #{env} in config file: #{file_name}") unless env_config
+
+        env_config = self.class.send(:deep_symbolize_keys, env_config)
+        self.class.send(:migrate_old_formats!, env_config)
       end
     end
 
     # Returns [Array(SymmetricEncrytion::Cipher)] ciphers specified in the configuration file.
     def ciphers
       @ciphers ||= config[:ciphers].collect { |cipher_config| Cipher.from_config(cipher_config) }
     end
 
-    private
-
     # Iterate through the Hash symbolizing all keys.
-    def self.deep_symbolize_keys(x)
-      case x
+    def self.deep_symbolize_keys(object)
+      case object
       when Hash
         result = {}
-        x.each_pair do |key, value|
+        object.each_pair do |key, value|
           key         = key.to_sym if key.is_a?(String)
           result[key] = deep_symbolize_keys(value)
         end
         result
       when Array
-        x.collect { |i| deep_symbolize_keys(i) }
+        object.collect { |i| deep_symbolize_keys(i) }
       else
-        x
+        object
       end
     end
+    private_class_method :deep_symbolize_keys
 
     # Iterate through the Hash symbolizing all keys.
-    def self.deep_stringify_keys(x)
-      case x
+    def self.deep_stringify_keys(object)
+      case object
       when Hash
         result = {}
-        x.each_pair do |key, value|
+        object.each_pair do |key, value|
           key         = key.to_s if key.is_a?(Symbol)
           result[key] = deep_stringify_keys(value)
         end
         result
       when Array
-        x.collect { |i| deep_stringify_keys(i) }
+        object.collect { |i| deep_stringify_keys(i) }
       else
-        x
+        object
       end
     end
+    private_class_method :deep_stringify_keys
 
     # Migrate old configuration format for this environment
     def self.migrate_old_formats!(config)
       # Inline single cipher before :ciphers
-      unless config.has_key?(:ciphers)
-        cipher = {}
-        config.keys.each { |key| cipher[key] = config.delete(key) }
-        config[:ciphers] = [cipher]
+      unless config.key?(:ciphers)
+        inline_cipher = {}
+        config.keys.each { |key| inline_cipher[key] = config.delete(key) }
+        config[:ciphers] = [inline_cipher]
       end
 
       # Copy Old :private_rsa_key into each ciphers config
       # Cipher.from_config replaces it with the RSA Kek
       if config[:private_rsa_key]
@@ -138,28 +137,25 @@
         config[:ciphers].each { |cipher| cipher[:private_rsa_key] = private_rsa_key }
       end
 
       # Old :cipher_name
       config[:ciphers].each do |cipher|
-        if old_key_name_cipher = cipher.delete(:cipher)
+        if (old_key_name_cipher = cipher.delete(:cipher))
           cipher[:cipher_name] = old_key_name_cipher
         end
 
         # Only temporarily used during v4 Beta process
-        if cipher[:key_encrypting_key].is_a?(String)
-          cipher[:private_rsa_key] = cipher.delete(:key_encrypting_key)
-        end
+        cipher[:private_rsa_key] = cipher.delete(:key_encrypting_key) if cipher[:key_encrypting_key].is_a?(String)
 
         # Check for a prior env var in encrypted key
         # Example:
         #   encrypted_key: <%= ENV['VAR'] %>
-        if cipher.has_key?(:encrypted_key) && cipher[:encrypted_key].nil?
+        if cipher.key?(:encrypted_key) && cipher[:encrypted_key].nil?
           cipher[:key_env_var] = :placeholder
-          puts "WARNING: :encrypted_key resolved to nil. Please see the migrated config file for the new option :key_env_var."
+          puts 'WARNING: :encrypted_key resolved to nil. Please see the migrated config file for the new option :key_env_var.'
         end
-
       end
       config
     end
-
+    private_class_method :migrate_old_formats!
   end
 end