chamber 2.8.0 → 2.9.0

data/spec/lib/chamber/filters/failed_decryption_filter_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'rspectacular'
 require 'chamber/filters/failed_decryption_filter'
 
@@ -5,7 +6,7 @@ module    Chamber
 module    Filters
 describe  FailedDecryptionFilter do
   it 'raises an exception if any of the settings are not decrypted' do
-    expect do
+    expect {
       FailedDecryptionFilter.execute(
         data: {
           _secure_my_secure_setting: 'cJbFe0NI5wknmsp2fVgpC/YeBD2pvcdVD+p0pUdnMoYThaV4m' \
@@ -17,12 +18,12 @@ describe  FailedDecryptionFilter do
                                      'TcdgbE9NcAhNr1+WfNxMnz84XzmUp2Y0H1jPgGkBKQJKArfQ==',
         },
       )
-    end.
+    }.
     to raise_error Chamber::Errors::DecryptionFailure
   end
 
   it 'does not raise an exception if it is not a secure key' do
-    expect do
+    expect {
       FailedDecryptionFilter.execute(
         data: {
           my_secure_setting: 'cJbFe0NI5wknmsp2fVgpC/YeBD2pvcdVD+p0pUdnMoYThaV4m' \
@@ -34,18 +35,18 @@ describe  FailedDecryptionFilter do
                              'TcdgbE9NcAhNr1+WfNxMnz84XzmUp2Y0H1jPgGkBKQJKArfQ==',
         },
       )
-    end.
+    }.
     not_to raise_error
   end
 
   it 'does not raise an exception if it is not a secure value' do
-    expect do
+    expect {
       FailedDecryptionFilter.execute(
         data: {
           _secure_my_secure_setting: 'hello',
         },
       )
-    end.
+    }.
     not_to raise_error
   end
 end

data/spec/lib/chamber/filters/insecure_filter_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'rspectacular'
 require 'chamber/filters/insecure_filter'
 
@@ -6,14 +7,16 @@ module    Filters
 describe  InsecureFilter do
   it 'will return values which are marked as "secure" if they are unencrypted' do
     filtered_settings = InsecureFilter.execute(data: {
-                                                 _secure_my_secure_setting: 'hello' })
+                                                 _secure_my_secure_setting: 'hello',
+                                               })
 
     expect(filtered_settings._secure_my_secure_setting).to match 'hello'
   end
 
   it 'will not return values which are not marked as "secure"' do
     filtered_settings = InsecureFilter.execute(data: {
-                                                 my_secure_setting: 'hello' })
+                                                 my_secure_setting: 'hello',
+                                               })
 
     expect(filtered_settings.my_secure_setting).to be_nil
   end
@@ -24,7 +27,9 @@ describe  InsecureFilter do
                                                  secure_setting:  'goodbye',
                                                  secure_group:    {
                                                    _secure_nested_setting:  'movie',
-                                                   insecure_nested_setting: 'dinner' } })
+                                                   insecure_nested_setting: 'dinner',
+                                                 },
+                                               })
 
     expect(filtered_settings._secure_setting).to                      eql 'hello'
     expect(filtered_settings.secure_setting).to                       be_nil
@@ -60,7 +65,10 @@ describe  InsecureFilter do
                                         'gfXc86wdgUKc8aaoX8OQA1kKTcdgbE9NcAhNr1+WfNxMn' \
                                         'z84XzmUp2Y0H1jPgGkBKQJKArfQ==',
           _secure_other_nested_setting: 'goodbye',
-          insecure_nested_setting:      'dinner' } })
+          insecure_nested_setting:      'dinner',
+        },
+      },
+    )
 
     expect(filtered_settings._secure_setting?).to                          eql false
     expect(filtered_settings.secure_setting?).to                           eql false

data/spec/lib/chamber/filters/namespace_filter_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'rspectacular'
 require 'chamber/filters/namespace_filter'
 require 'chamber/namespace_set'
@@ -9,10 +10,14 @@ describe  NamespaceFilter do
     filtered_settings = NamespaceFilter.execute(
       data:       {
         namespace_value:       {
-          namespace_setting: 'value 1' },
+          namespace_setting: 'value 1',
+        },
         other_namespace_value: {
-          other_namespace_setting: 'value 2' } },
-      namespaces: %w{namespace_value other_namespace_value})
+          other_namespace_setting: 'value 2',
+        },
+      },
+      namespaces: %w{namespace_value other_namespace_value},
+    )
 
     expect(filtered_settings.namespace_setting).to eql 'value 1'
     expect(filtered_settings.other_namespace_setting).to eql 'value 2'
@@ -22,11 +27,16 @@ describe  NamespaceFilter do
     filtered_settings = NamespaceFilter.execute(
       data:       {
         namespace_value:      {
-          namespace_setting: 'value 1' },
+          namespace_setting: 'value 1',
+        },
         non_namespaced_value: {
-          non_namespaced_setting: 'value 2' } },
+          non_namespaced_setting: 'value 2',
+        },
+      },
       namespaces: [
-        'namespace_value'])
+                    'namespace_value',
+                  ],
+    )
 
     expect(filtered_settings.namespace_setting).to eql 'value 1'
     expect(filtered_settings.non_namespaced_setting).to be_nil
@@ -36,8 +46,11 @@ describe  NamespaceFilter do
     filtered_settings = NamespaceFilter.execute(
       data:       {
         namespace_value: {
-          namespace_setting: 'value 1' } },
-      namespaces: %w{namespace_value other_namespace_value})
+          namespace_setting: 'value 1',
+        },
+      },
+      namespaces: %w{namespace_value other_namespace_value},
+    )
 
     expect(filtered_settings.namespace_setting).to eql 'value 1'
   end
@@ -45,8 +58,10 @@ describe  NamespaceFilter do
   it 'does not filter data if it does not include any namespaces' do
     filtered_settings = NamespaceFilter.execute(
       data:       {
-        non_namespaced_setting: 'value 1' },
-      namespaces: [])
+        non_namespaced_setting: 'value 1',
+      },
+      namespaces: [],
+    )
 
     expect(filtered_settings.non_namespaced_setting).to eql 'value 1'
   end
@@ -56,12 +71,16 @@ describe  NamespaceFilter do
       data:       {
         namespace_value:       {
           namespace_setting:         'value 1',
-          another_namespace_setting: 'value 2' },
+          another_namespace_setting: 'value 2',
+        },
         other_namespace_value: {
           namespace_setting_1:         'value 1',
-          another_namespace_setting_2: 'value 2' },
-        non_namespaced_value:  'value 3' },
-      namespaces: NamespaceSet.new(%w{namespace_value other_namespace_value}))
+          another_namespace_setting_2: 'value 2',
+        },
+        non_namespaced_value:  'value 3',
+      },
+      namespaces: NamespaceSet.new(%w{namespace_value other_namespace_value}),
+    )
 
     expect(filtered_settings.to_hash).to eql('namespace_setting'           => 'value 1',
                                              'another_namespace_setting'   => 'value 2',

data/spec/lib/chamber/filters/secure_filter_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'rspectacular'
 require 'chamber/filters/secure_filter'
 
@@ -6,14 +7,16 @@ module    Filters
 describe  SecureFilter do
   it 'will return values which are marked as "secure"' do
     filtered_settings = SecureFilter.execute(data: {
-                                               _secure_my_secure_setting: 'hello' })
+                                               _secure_my_secure_setting: 'hello',
+                                             })
 
     expect(filtered_settings._secure_my_secure_setting).to match 'hello'
   end
 
   it 'will not return values which are not marked as "secure"' do
     filtered_settings = SecureFilter.execute(data: {
-                                               my_secure_setting: 'hello' })
+                                               my_secure_setting: 'hello',
+                                             })
 
     expect(filtered_settings.my_secure_setting).to be_nil
   end
@@ -24,7 +27,9 @@ describe  SecureFilter do
                                                secure_setting:  'goodbye',
                                                secure_group:    {
                                                  _secure_nested_setting:  'movie',
-                                                 insecure_nested_setting: 'dinner' } })
+                                                 insecure_nested_setting: 'dinner',
+                                               },
+                                             })
 
     expect(filtered_settings._secure_setting).to                      eql 'hello'
     expect(filtered_settings.secure_setting).to                       be_nil

data/spec/lib/chamber/filters/translate_secure_keys_filter_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'rspectacular'
 require 'chamber/filters/translate_secure_keys_filter'
 
@@ -7,7 +8,9 @@ describe  TranslateSecureKeysFilter do
   it 'will translate keys if they start with "_secure_"' do
     filtered_settings = TranslateSecureKeysFilter.execute(
       data: {
-        _secure_my_secure_setting: 'hello' })
+        _secure_my_secure_setting: 'hello',
+      },
+    )
 
     expect(filtered_settings.my_secure_setting).to eql 'hello'
   end
@@ -15,7 +18,9 @@ describe  TranslateSecureKeysFilter do
   it 'will not translate keys if they do not start with "_secure_"' do
     filtered_settings = TranslateSecureKeysFilter.execute(
       data: {
-        my_secure_setting: 'hello' })
+        my_secure_setting: 'hello',
+      },
+    )
 
     expect(filtered_settings.my_secure_setting).to eql 'hello'
   end
@@ -23,7 +28,9 @@ describe  TranslateSecureKeysFilter do
   it 'will not translate the key if it starts with "secure"' do
     filtered_settings = TranslateSecureKeysFilter.execute(
       data: {
-        secure_setting: 'hello' })
+        secure_setting: 'hello',
+      },
+    )
 
     expect(filtered_settings.secure_setting).to eql 'hello'
   end

data/spec/lib/chamber/namespace_set_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'rspectacular'
 require 'chamber/namespace_set'
 
@@ -11,8 +12,10 @@ describe  NamespaceSet do
   end
 
   it 'can create a set from an array' do
-    namespace_set = NamespaceSet.new([:development,
-                                      'my host'])
+    namespace_set = NamespaceSet.new([
+                                       :development,
+                                       'my host',
+                                     ])
 
     expect(namespace_set).to eq ['development', 'my host']
   end
@@ -56,7 +59,7 @@ describe  NamespaceSet do
     original_set  = NamespaceSet[:development, 'my host']
     namespace_set = NamespaceSet.new(original_set)
 
-    expect(namespace_set.send(:raw_namespaces)).not_to be_a NamespaceSet
+    expect(namespace_set.__send__(:raw_namespaces)).not_to be_a NamespaceSet
   end
 
   it 'can turn itself into an array' do

data/spec/lib/chamber/settings_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'rspectacular'
 require 'chamber/settings'
 
@@ -55,17 +56,21 @@ describe  Settings do
   it 'sorts environment variables by name when converted to an environment hash so ' \
      'that they are easier to parse for humans' do
 
-    settings = Settings.new(settings: { 'C' => 'value',
-                                        'D' => 'value',
-                                        'A' => 'value',
-                                        'E' => 'value',
-                                        'B' => 'value' })
-
-    expect(settings.to_environment.to_a).to eql([%w{A value},
-                                                 %w{B value},
-                                                 %w{C value},
-                                                 %w{D value},
-                                                 %w{E value}])
+    settings = Settings.new(settings: {
+                              'C' => 'value',
+                              'D' => 'value',
+                              'A' => 'value',
+                              'E' => 'value',
+                              'B' => 'value',
+                            })
+
+    expect(settings.to_environment.to_a).to eql([
+                                                  %w{A value},
+                                                  %w{B value},
+                                                  %w{C value},
+                                                  %w{D value},
+                                                  %w{E value},
+                                                ])
   end
 
   it 'can convert itself into a string' do
@@ -82,12 +87,12 @@ describe  Settings do
                             })
 
     expect(settings.to_s).to eql %w{
-      LEVEL_1_BODY="gracias"
-      LEVEL_1_LEVEL_2_ANOTHER="goodbye"
-      LEVEL_1_LEVEL_2_SOME_SETTING="hello"
-      MY_SETTING="value"
-      THERE="was not that easy?"
-    }.join(' ')
+                                   LEVEL_1_BODY="gracias"
+                                   LEVEL_1_LEVEL_2_ANOTHER="goodbye"
+                                   LEVEL_1_LEVEL_2_SOME_SETTING="hello"
+                                   MY_SETTING="value"
+                                   THERE="was not that easy?"
+                                 }.join(' ')
   end
 
   it 'can convert itself into a string with custom options' do
@@ -137,7 +142,8 @@ HEREDOC
 
     expect(merged_settings).to eql Settings.new(settings:   {
                                                   setting:       'value',
-                                                  other_setting: 'another value' },
+                                                  other_setting: 'another value',
+                                                },
                                                 namespaces: %w{good bad})
   end
 
@@ -172,7 +178,7 @@ HEREDOC
                               there:      'was not that easy?',
                             })
 
-    expect(settings.to_flattened_name_hash).to     eql(
+    expect(settings.to_flattened_name_hash).to eql(
       %w{my_setting}                   => 'value',
       %w{level_1 level_2 some_setting} => 'hello',
       %w{level_1 level_2 another}      => 'goodbye',
@@ -191,7 +197,7 @@ HEREDOC
     settings_hash = settings.to_hash
     settings_hash['setting'] = 'foo'
 
-    expect(settings.send(:data).object_id).not_to eql settings_hash.object_id
+    expect(settings.__send__(:data).object_id).not_to eql settings_hash.object_id
     expect(settings.setting).to eql 'value'
   end
 
@@ -216,9 +222,11 @@ HEREDOC
   it 'only includes namespaced data if any exists' do
     settings = Settings.new(settings:   {
                               namespace_value:       {
-                                namespace_setting: 'value' },
+                                namespace_setting: 'value',
+                              },
                               other_namespace_value: {
-                                other_namespace_setting: 'value' },
+                                other_namespace_setting: 'value',
+                              },
                               non_namespace_setting: 'other value',
                             },
                             namespaces: %w{namespace_value other_namespace_value})
@@ -239,7 +247,8 @@ HEREDOC
                                       'wdgUKc8aaoX8OQA1kKTcdgbE9NcAhNr1+WfNxMnz84XzmU' \
                                       'p2Y0H1jPgGkBKQJKArfQ==',
       },
-      decryption_key: './spec/spec_key')
+      decryption_key: './spec/spec_key',
+    )
 
     expect(settings).to eq('my_encrypted_setting' => 'hello')
   end
@@ -291,7 +300,8 @@ HEREDOC
         _secure_my_unencrypted_setting: 'nifty',
         my_insecure_setting:            'goodbye',
       },
-      decryption_key: './spec/spec_key')
+      decryption_key: './spec/spec_key',
+    )
 
     secured_settings = settings.securable
 
@@ -314,7 +324,8 @@ HEREDOC
         _secure_my_unencrypted_setting: 'nifty',
         my_insecure_setting:            'goodbye',
       },
-      decryption_key: './spec/spec_key')
+      decryption_key: './spec/spec_key',
+    )
 
     secured_settings = settings.insecure
 

data/spec/lib/chamber_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'rspectacular'
 require 'chamber'
 require 'fileutils'
@@ -118,7 +119,8 @@ describe 'Chamber' do
   it 'can load files based on the namespace passed in' do
     Chamber.load(basepath:   '/tmp/chamber',
                  namespaces: {
-                   my_namespace: -> { 'blue' } })
+                   my_namespace: -> { 'blue' },
+                 })
 
     expect(Chamber.other.everything).to        eql 'works'
     expect(Chamber.test.my_dynamic_setting).to eql 2
@@ -128,24 +130,29 @@ describe 'Chamber' do
     Chamber.load(basepath:   '/tmp/chamber',
                  namespaces: {
                    first_namespace_call:  -> { :first },
-                   second_namespace_call: -> { :second } })
+                   second_namespace_call: -> { :second },
+                 })
 
     expect(Chamber.namespaces.to_a).to eql %w{first second}
   end
 
+  # rubocop:disable Lint/DuplicatedKey
   it 'does not load the same namespace twice' do
     Chamber.load(basepath:   '/tmp/chamber',
                  namespaces: {
                    first_namespace_call: -> { :first },
-                   first_namespace_call: -> { :first } })
+                   first_namespace_call: -> { :first },
+                 })
 
     expect(Chamber.namespaces.to_a).to eql ['first']
   end
+  # rubocop:enable Lint/DuplicatedKey
 
   it 'will load settings files which are only namespaced' do
     Chamber.load(basepath:   '/tmp/chamber',
                  namespaces: {
-                   my_namespace: -> { 'blue' } })
+                   my_namespace: -> { 'blue' },
+                 })
 
     expect(Chamber[:only_namespaced_sub_settings][:another_sub_setting]).to eql 'namespaced'
   end
@@ -153,7 +160,8 @@ describe 'Chamber' do
   it 'clears all settings each time the settings are loaded' do
     Chamber.load(basepath:   '/tmp/chamber',
                  namespaces: {
-                   my_namespace: -> { 'blue' } })
+                   my_namespace: -> { 'blue' },
+                 })
 
     expect(Chamber[:only_namespaced_sub_settings][:another_sub_setting]).to eql 'namespaced'
 
@@ -171,7 +179,8 @@ describe 'Chamber' do
   it 'does not raise an exception if a namespaced file does not exist' do
     Chamber.load(basepath:   '/tmp/chamber',
                  namespaces: {
-                   non_existant_namespace: -> { false } })
+                   non_existant_namespace: -> { false },
+                 })
 
     expect { Chamber.load(basepath: '/tmp/chamber') }.not_to raise_error
   end
@@ -179,7 +188,8 @@ describe 'Chamber' do
   it 'merges (not overrides) subsequent settings' do
     Chamber.load(basepath:   '/tmp/chamber',
                  namespaces: {
-                   my_namespace: -> { 'blue' } })
+                   my_namespace: -> { 'blue' },
+                 })
 
     expect(Chamber.test.my_setting).to                eql 'my_value'
     expect(Chamber.test.my_other_setting).to          eql 'my_other_value'
@@ -201,7 +211,8 @@ describe 'Chamber' do
 
     Chamber.load(basepath:   '/tmp/chamber',
                  namespaces: {
-                   my_namespace: -> { 'blue' } })
+                   my_namespace: -> { 'blue' },
+                 })
 
     expect(Chamber['sub_settings']['my_namespaced_sub_setting']).to eql 'my_namespaced_sub_setting_value'
   end
@@ -209,7 +220,8 @@ describe 'Chamber' do
   it 'loads namespaced settings if they are inline in a non-namespaced filename' do
     Chamber.load(basepath:   '/tmp/chamber',
                  namespaces: {
-                   my_namespace: -> { 'blue' } })
+                   my_namespace: -> { 'blue' },
+                 })
 
     expect(Chamber['my_settings_for_inline_namespace']).to eql 'my_value_for_inline_namespace'
   end
@@ -217,7 +229,8 @@ describe 'Chamber' do
   it 'does not load non-namespaced data from a file if inline namespaces are found' do
     Chamber.load(basepath:   '/tmp/chamber',
                  namespaces: {
-                   my_namespace: -> { 'blue' } })
+                   my_namespace: -> { 'blue' },
+                 })
 
     expect(Chamber['my_non_inline_namespaced_setting']).not_to eql 'my_value_for_non_inline_namespace'
   end
@@ -231,6 +244,7 @@ describe 'Chamber' do
     expect(Chamber['my_non_inline_namespaced_setting']).to         eql 'my_value_for_non_inline_namespace'
   end
 
+  # rubocop:disable Lint/DuplicatedKey
   it 'can convert the settings to their environment variable versions' do
     Chamber.load(basepath: '/tmp/chamber')
 
@@ -249,6 +263,7 @@ describe 'Chamber' do
       'MY_NON_INLINE_NAMESPACED_SETTING'        => 'my_value_for_non_inline_namespace',
     )
   end
+  # rubocop:enable Lint/DuplicatedKey
 
   it 'can convert boolean-like strings to actual booleans' do
     expect(Chamber[:test][:my_boolean]).to be_a FalseClass