ledermann-rails-settings 2.4.3 → 2.6.0

data/spec/configuration_spec.rb

@@ -5,103 +5,116 @@ module RailsSettings
   end
 
   describe Configuration, 'successful' do
-    it "should define single key" do
+    it 'should define single key' do
       Configuration.new(Dummy, :dashboard)
 
-      expect(Dummy.default_settings).to eq({ :dashboard => {} })
-      expect(Dummy.setting_object_class_name).to eq('RailsSettings::SettingObject')
+      expect(Dummy.default_settings).to eq({ dashboard: {} })
+      expect(Dummy.setting_object_class_name).to eq(
+        'RailsSettings::SettingObject',
+      )
     end
 
-    it "should define multiple keys" do
+    it 'should define multiple keys' do
       Configuration.new(Dummy, :dashboard, :calendar)
 
-      expect(Dummy.default_settings).to eq({ :dashboard => {}, :calendar => {} })
-      expect(Dummy.setting_object_class_name).to eq('RailsSettings::SettingObject')
+      expect(Dummy.default_settings).to eq({ dashboard: {}, calendar: {} })
+      expect(Dummy.setting_object_class_name).to eq(
+        'RailsSettings::SettingObject',
+      )
     end
 
-    it "should define single key with class_name" do
-      Configuration.new(Dummy, :dashboard, :class_name => 'MyClass')
-      expect(Dummy.default_settings).to eq({ :dashboard => {} })
+    it 'should define single key with class_name' do
+      Configuration.new(Dummy, :dashboard, class_name: 'MyClass')
+      expect(Dummy.default_settings).to eq({ dashboard: {} })
       expect(Dummy.setting_object_class_name).to eq('MyClass')
     end
 
-    it "should define multiple keys with class_name" do
-      Configuration.new(Dummy, :dashboard, :calendar, :class_name => 'MyClass')
+    it 'should define multiple keys with class_name' do
+      Configuration.new(Dummy, :dashboard, :calendar, class_name: 'MyClass')
 
-      expect(Dummy.default_settings).to eq({ :dashboard => {}, :calendar => {} })
+      expect(Dummy.default_settings).to eq({ dashboard: {}, calendar: {} })
       expect(Dummy.setting_object_class_name).to eq('MyClass')
     end
 
-    it "should define using block" do
+    it 'should define using block' do
       Configuration.new(Dummy) do |c|
         c.key :dashboard
         c.key :calendar
       end
 
-      expect(Dummy.default_settings).to eq({ :dashboard => {}, :calendar => {} })
-      expect(Dummy.setting_object_class_name).to eq('RailsSettings::SettingObject')
+      expect(Dummy.default_settings).to eq({ dashboard: {}, calendar: {} })
+      expect(Dummy.setting_object_class_name).to eq(
+        'RailsSettings::SettingObject',
+      )
     end
 
-    it "should define using block with defaults" do
+    it 'should define using block with defaults' do
       Configuration.new(Dummy) do |c|
-        c.key :dashboard, :defaults => { :theme => 'red' }
-        c.key :calendar, :defaults => { :scope => 'all' }
+        c.key :dashboard, defaults: { theme: 'red' }
+        c.key :calendar, defaults: { scope: 'all' }
       end
 
-      expect(Dummy.default_settings).to eq({ :dashboard => { 'theme' => 'red' }, :calendar => { 'scope' => 'all'} })
-      expect(Dummy.setting_object_class_name).to eq('RailsSettings::SettingObject')
+      expect(Dummy.default_settings).to eq(
+        { dashboard: { 'theme' => 'red' }, calendar: { 'scope' => 'all' } },
+      )
+      expect(Dummy.setting_object_class_name).to eq(
+        'RailsSettings::SettingObject',
+      )
     end
 
-    it "should define using block and class_name" do
-      Configuration.new(Dummy, :class_name => 'MyClass') do |c|
+    it 'should define using block and class_name' do
+      Configuration.new(Dummy, class_name: 'MyClass') do |c|
         c.key :dashboard
         c.key :calendar
       end
 
-      expect(Dummy.default_settings).to eq({ :dashboard => {}, :calendar => {} })
+      expect(Dummy.default_settings).to eq({ dashboard: {}, calendar: {} })
       expect(Dummy.setting_object_class_name).to eq('MyClass')
     end
+
+    context 'persistent' do
+      it 'should keep settings between multiple configurations initialization' do
+        Configuration.new(Dummy, persistent: true) do |c|
+          c.key :dashboard, defaults: { theme: 'red' }
+        end
+
+        Configuration.new(Dummy, :calendar, persistent: true)
+
+        expect(Dummy.default_settings).to eq(
+          { dashboard: { 'theme' => 'red' }, calendar: {} },
+        )
+      end
+    end
   end
 
   describe Configuration, 'failure' do
-    it "should fail without args" do
-      expect {
-        Configuration.new
-      }.to raise_error(ArgumentError)
+    it 'should fail without args' do
+      expect { Configuration.new }.to raise_error(ArgumentError)
     end
 
-    it "should fail without keys" do
-      expect {
-        Configuration.new(Dummy)
-      }.to raise_error(ArgumentError)
+    it 'should fail without keys' do
+      expect { Configuration.new(Dummy) }.to raise_error(ArgumentError)
     end
 
-    it "should fail without keys in block" do
-      expect {
-        Configuration.new(Dummy) do |c|
-        end
-      }.to raise_error(ArgumentError)
+    it 'should fail without keys in block' do
+      expect { Configuration.new(Dummy) { |c| } }.to raise_error(ArgumentError)
     end
 
-    it "should fail with keys not being symbols" do
-      expect {
-        Configuration.new(Dummy, 42, "string")
-      }.to raise_error(ArgumentError)
+    it 'should fail with keys not being symbols' do
+      expect { Configuration.new(Dummy, 42, 'string') }.to raise_error(
+        ArgumentError,
+      )
     end
 
-    it "should fail with keys not being symbols" do
+    it 'should fail with keys not being symbols' do
       expect {
-        Configuration.new(Dummy) do |c|
-          c.key 42, "string"
-        end
+        Configuration.new(Dummy) { |c| c.key 42, 'string' }
       }.to raise_error(ArgumentError)
     end
 
-    it "should fail with unknown option" do
+    it 'should fail with unknown option' do
       expect {
-        Configuration.new(Dummy) do |c|
-          c.key :dashboard, :foo => {}
-        end
+        Configuration.new(Dummy) { |c| c.key :dashboard, foo: {} }
       }.to raise_error(ArgumentError)
     end
   end

data/spec/database.yml

@@ -1,3 +1,3 @@
 sqlite:
   adapter: sqlite3
-  database: ":memory:"
+  database: ':memory:'

data/spec/queries_spec.rb

@@ -2,12 +2,10 @@ require 'spec_helper'
 
 describe 'Queries performed' do
   context 'New record' do
-    let!(:user) { User.new :name => 'Mr. Pink' }
+    let!(:user) { User.new name: 'Mr. Pink' }
 
     it 'should be saved by one SQL query' do
-      expect {
-        user.save!
-      }.to perform_queries(1)
+      expect { user.save! }.to perform_queries(1)
     end
 
     it 'should be saved with settings for one key by two SQL queries' do
@@ -29,12 +27,10 @@ describe 'Queries performed' do
   end
 
   context 'Existing record without settings' do
-    let!(:user) { User.create! :name => 'Mr. Pink' }
+    let!(:user) { User.create! name: 'Mr. Pink' }
 
     it 'should be saved without SQL queries' do
-      expect {
-        user.save!
-      }.to perform_queries(0)
+      expect { user.save! }.to perform_queries(0)
     end
 
     it 'should be saved with settings for one key by two SQL queries' do
@@ -57,16 +53,14 @@ describe 'Queries performed' do
 
   context 'Existing record with settings' do
     let!(:user) do
-      User.create! :name => 'Mr. Pink' do |user|
+      User.create! name: 'Mr. Pink' do |user|
         user.settings(:dashboard).theme = 'pink'
         user.settings(:calendar).scope = 'all'
       end
     end
 
     it 'should be saved without SQL queries' do
-      expect {
-        user.save!
-      }.to perform_queries(0)
+      expect { user.save! }.to perform_queries(0)
     end
 
     it 'should be saved with settings for one key by one SQL queries' do
@@ -87,14 +81,12 @@ describe 'Queries performed' do
     end
 
     it 'should be destroyed by two SQL queries' do
-      expect {
-        user.destroy
-      }.to perform_queries(2)
+      expect { user.destroy }.to perform_queries(2)
     end
 
-    it "should update settings by one SQL query" do
+    it 'should update settings by one SQL query' do
       expect {
-        user.settings(:dashboard).update_attributes! :foo => 'bar'
+        user.settings(:dashboard).update! foo: 'bar'
       }.to perform_queries(1)
     end
   end

data/spec/scopes_spec.rb

@@ -1,31 +1,39 @@
 require 'spec_helper'
 
 describe 'scopes' do
-  let!(:user1) { User.create! :name => 'Mr. White' do |user| user.settings(:dashboard).theme = 'white' end }
-  let!(:user2) { User.create! :name => 'Mr. Blue' }
+  let!(:user1) do
+    User.create! name: 'Mr. White' do |user|
+      user.settings(:dashboard).theme = 'white'
+    end
+  end
+  let!(:user2) { User.create! name: 'Mr. Blue' }
 
-  it "should find objects with existing settings" do
+  it 'should find objects with existing settings' do
     expect(User.with_settings).to eq([user1])
   end
 
-  it "should find objects with settings for key" do
+  it 'should find objects with settings for key' do
     expect(User.with_settings_for(:dashboard)).to eq([user1])
     expect(User.with_settings_for(:foo)).to eq([])
   end
 
-  it "should records without settings" do
+  it 'should records without settings' do
     expect(User.without_settings).to eq([user2])
   end
 
-  it "should records without settings for key" do
+  it 'should records without settings for key' do
     expect(User.without_settings_for(:foo)).to eq([user1, user2])
     expect(User.without_settings_for(:dashboard)).to eq([user2])
   end
 
-  it "should require symbol as key" do
-    [ nil, "string", 42 ].each do |invalid_key|
-      expect { User.without_settings_for(invalid_key) }.to raise_error(ArgumentError)
-      expect { User.with_settings_for(invalid_key)    }.to raise_error(ArgumentError)
+  it 'should require symbol as key' do
+    [nil, 'string', 42].each do |invalid_key|
+      expect { User.without_settings_for(invalid_key) }.to raise_error(
+        ArgumentError,
+      )
+      expect { User.with_settings_for(invalid_key) }.to raise_error(
+        ArgumentError,
+      )
     end
   end
 end

data/spec/serialize_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
-describe "Serialization" do
+describe 'Serialization' do
   let!(:user) do
-    User.create! :name => 'Mr. White' do |user|
+    User.create! name: 'Mr. White' do |user|
       user.settings(:dashboard).theme = 'white'
       user.settings(:calendar).scope = 'all'
     end
@@ -12,29 +12,31 @@ describe "Serialization" do
     it 'should be serialized' do
       user.reload
 
-      dashboard_settings = user.setting_objects.where(:var => 'dashboard').first
-      calendar_settings = user.setting_objects.where(:var => 'calendar').first
+      dashboard_settings = user.setting_objects.where(var: 'dashboard').first
+      calendar_settings = user.setting_objects.where(var: 'calendar').first
 
       expect(dashboard_settings.var).to eq('dashboard')
-      expect(dashboard_settings.value).to eq({'theme' => 'white'})
+      expect(dashboard_settings.value).to eq({ 'theme' => 'white' })
 
       expect(calendar_settings.var).to eq('calendar')
-      expect(calendar_settings.value).to eq({'scope' => 'all'})
+      expect(calendar_settings.value).to eq({ 'scope' => 'all' })
     end
   end
 
   describe 'updated settings' do
     it 'should be serialized' do
-      user.settings(:dashboard).update_attributes! :smart => true
+      user.settings(:dashboard).update! smart: true
 
-      dashboard_settings = user.setting_objects.where(:var => 'dashboard').first
-      calendar_settings = user.setting_objects.where(:var => 'calendar').first
+      dashboard_settings = user.setting_objects.where(var: 'dashboard').first
+      calendar_settings = user.setting_objects.where(var: 'calendar').first
 
       expect(dashboard_settings.var).to eq('dashboard')
-      expect(dashboard_settings.value).to eq({'theme' => 'white', 'smart' => true})
+      expect(dashboard_settings.value).to eq(
+        { 'theme' => 'white', 'smart' => true },
+      )
 
       expect(calendar_settings.var).to eq('calendar')
-      expect(calendar_settings.value).to eq({'scope' => 'all'})
+      expect(calendar_settings.value).to eq({ 'scope' => 'all' })
     end
   end
 end

data/spec/setting_object_spec.rb

@@ -1,78 +1,97 @@
 require 'spec_helper'
 
 describe RailsSettings::SettingObject do
-  let(:user) { User.create! :name => 'Mr. Pink' }
+  let(:user) { User.create! name: 'Mr. Pink' }
 
   if RailsSettings.can_protect_attributes?
-    let(:new_setting_object) { user.setting_objects.build({ :var => 'dashboard'}, :without_protection => true) }
-    let(:saved_setting_object) { user.setting_objects.create!({ :var => 'dashboard', :value => { 'theme' => 'pink', 'filter' => false}}, :without_protection => true) }
+    let(:new_setting_object) do
+      user.setting_objects.build({ var: 'dashboard' }, without_protection: true)
+    end
+    let(:saved_setting_object) do
+      user.setting_objects.create!(
+        { var: 'dashboard', value: { 'theme' => 'pink', 'filter' => false } },
+        without_protection: true,
+      )
+    end
   else
-    let(:new_setting_object) { user.setting_objects.build({ :var => 'dashboard'}) }
-    let(:saved_setting_object) { user.setting_objects.create!({ :var => 'dashboard', :value => { 'theme' => 'pink', 'filter' => false}}) }
+    let(:new_setting_object) do
+      user.setting_objects.build({ var: 'dashboard' })
+    end
+    let(:saved_setting_object) do
+      user.setting_objects.create!(
+        { var: 'dashboard', value: { 'theme' => 'pink', 'filter' => false } },
+      )
+    end
   end
 
-  describe "serialization" do
-    it "should have a hash default" do
+  describe 'serialization' do
+    it 'should have a hash default' do
       expect(RailsSettings::SettingObject.new.value).to eq({})
     end
   end
 
-  describe "Getter and Setter" do
-    context "on unsaved settings" do
-      it "should respond to setters" do
+  describe 'Getter and Setter' do
+    context 'on unsaved settings' do
+      it 'should respond to setters' do
         expect(new_setting_object).to respond_to(:foo=)
         expect(new_setting_object).to respond_to(:bar=)
+        expect(new_setting_object).to respond_to(:x=)
       end
 
-      it "should not respond to some getters" do
+      it 'should not respond to some getters' do
         expect { new_setting_object.foo! }.to raise_error(NoMethodError)
         expect { new_setting_object.foo? }.to raise_error(NoMethodError)
       end
 
-      it "should not respond if a block is given" do
-        expect {
-          new_setting_object.foo do
-          end
-        }.to raise_error(NoMethodError)
+      it 'should not respond if a block is given' do
+        expect { new_setting_object.foo {} }.to raise_error(NoMethodError)
       end
 
-      it "should not respond if params are given" do
+      it 'should not respond if params are given' do
         expect { new_setting_object.foo(42) }.to raise_error(NoMethodError)
-        expect { new_setting_object.foo(42,43) }.to raise_error(NoMethodError)
+        expect { new_setting_object.foo(42, 43) }.to raise_error(NoMethodError)
       end
 
-      it "should return nil for unknown attribute" do
+      it 'should return nil for unknown attribute' do
         expect(new_setting_object.foo).to eq(nil)
         expect(new_setting_object.bar).to eq(nil)
+        expect(new_setting_object.c).to eq(nil)
       end
 
-      it "should return defaults" do
+      it 'should return defaults' do
         expect(new_setting_object.theme).to eq('blue')
         expect(new_setting_object.view).to eq('monthly')
         expect(new_setting_object.filter).to eq(true)
+        expect(new_setting_object.a).to eq('b')
       end
 
-      it "should return defaults when using `try`" do
+      it 'should return defaults when using `try`' do
         expect(new_setting_object.try(:theme)).to eq('blue')
         expect(new_setting_object.try(:view)).to eq('monthly')
         expect(new_setting_object.try(:filter)).to eq(true)
       end
 
-      it "should store different objects to value hash" do
+      it 'should return value from target method if proc is a default value' do
+        expect(new_setting_object.owner_name).to eq('Mr. Pink')
+      end
+
+      it 'should store different objects to value hash' do
         new_setting_object.integer = 42
-        new_setting_object.float   = 1.234
-        new_setting_object.string  = 'Hello, World!'
-        new_setting_object.array   = [ 1,2,3 ]
-        new_setting_object.symbol  = :foo
-
-        expect(new_setting_object.value).to eq('integer' => 42,
-                                           'float'   => 1.234,
-                                           'string'  => 'Hello, World!',
-                                           'array'   => [ 1,2,3 ],
-                                           'symbol'  => :foo)
+        new_setting_object.float = 1.234
+        new_setting_object.string = 'Hello, World!'
+        new_setting_object.array = [1, 2, 3]
+        new_setting_object.symbol = :foo
+
+        expect(new_setting_object.value).to eq(
+          'integer' => 42,
+          'float' => 1.234,
+          'string' => 'Hello, World!',
+          'array' => [1, 2, 3],
+          'symbol' => :foo,
+        )
       end
 
-      it "should set and return attributes" do
+      it 'should set and return attributes' do
         new_setting_object.theme = 'pink'
         new_setting_object.foo = 42
         new_setting_object.bar = 'hello'
@@ -82,30 +101,30 @@ describe RailsSettings::SettingObject do
         expect(new_setting_object.bar).to eq('hello')
       end
 
-      it "should set dirty trackers on change" do
+      it 'should set dirty trackers on change' do
         new_setting_object.theme = 'pink'
         expect(new_setting_object).to be_value_changed
         expect(new_setting_object).to be_changed
       end
     end
 
-    context "on saved settings" do
-      it "should not set dirty trackers on setting same value" do
+    context 'on saved settings' do
+      it 'should not set dirty trackers on setting same value' do
         saved_setting_object.theme = 'pink'
         expect(saved_setting_object).not_to be_value_changed
         expect(saved_setting_object).not_to be_changed
       end
 
-      it "should delete key on assigning nil" do
+      it 'should delete key on assigning nil' do
         saved_setting_object.theme = nil
         expect(saved_setting_object.value).to eq({ 'filter' => false })
       end
     end
   end
 
-  describe "update_attributes" do
+  describe 'update' do
     it 'should save' do
-      expect(new_setting_object.update_attributes(:foo => 42, :bar => 'string')).to be_truthy
+      expect(new_setting_object.update(foo: 42, bar: 'string')).to be_truthy
       new_setting_object.reload
 
       expect(new_setting_object.foo).to eq(42)
@@ -115,12 +134,12 @@ describe RailsSettings::SettingObject do
     end
 
     it 'should not save blank hash' do
-      expect(new_setting_object.update_attributes({})).to be_truthy
+      expect(new_setting_object.update({})).to be_truthy
     end
 
     if RailsSettings.can_protect_attributes?
       it 'should not allow changing protected attributes' do
-        new_setting_object.update_attributes!(:var => 'calendar', :foo => 42)
+        new_setting_object.update!(var: 'calendar', foo: 42)
 
         expect(new_setting_object.var).to eq('dashboard')
         expect(new_setting_object.foo).to eq(42)
@@ -128,8 +147,8 @@ describe RailsSettings::SettingObject do
     end
   end
 
-  describe "save" do
-    it "should save" do
+  describe 'save' do
+    it 'should save' do
       new_setting_object.foo = 42
       new_setting_object.bar = 'string'
       expect(new_setting_object.save).to be_truthy
@@ -142,9 +161,9 @@ describe RailsSettings::SettingObject do
     end
   end
 
-  describe "validation" do
-    it "should not validate for unknown var" do
-      new_setting_object.var = "unknown-var"
+  describe 'validation' do
+    it 'should not validate for unknown var' do
+      new_setting_object.var = 'unknown-var'
 
       expect(new_setting_object).not_to be_valid
       expect(new_setting_object.errors[:var]).to be_present