ledermann-rails-settings 1.2.0 → 2.5.0

data/spec/database.yml

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

data/spec/queries_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe 'Queries performed' do
+  context 'New record' do
+    let!(:user) { User.new :name => 'Mr. Pink' }
+
+    it 'should be saved by one SQL query' do
+      expect {
+        user.save!
+      }.to perform_queries(1)
+    end
+
+    it 'should be saved with settings for one key by two SQL queries' do
+      expect {
+        user.settings(:dashboard).foo = 42
+        user.settings(:dashboard).bar = 'string'
+        user.save!
+      }.to perform_queries(2)
+    end
+
+    it 'should be saved with settings for two keys by three SQL queries' do
+      expect {
+        user.settings(:dashboard).foo = 42
+        user.settings(:dashboard).bar = 'string'
+        user.settings(:calendar).bar = 'string'
+        user.save!
+      }.to perform_queries(3)
+    end
+  end
+
+  context 'Existing record without settings' do
+    let!(:user) { User.create! :name => 'Mr. Pink' }
+
+    it 'should be saved without SQL queries' do
+      expect {
+        user.save!
+      }.to perform_queries(0)
+    end
+
+    it 'should be saved with settings for one key by two SQL queries' do
+      expect {
+        user.settings(:dashboard).foo = 42
+        user.settings(:dashboard).bar = 'string'
+        user.save!
+      }.to perform_queries(2)
+    end
+
+    it 'should be saved with settings for two keys by three SQL queries' do
+      expect {
+        user.settings(:dashboard).foo = 42
+        user.settings(:dashboard).bar = 'string'
+        user.settings(:calendar).bar = 'string'
+        user.save!
+      }.to perform_queries(3)
+    end
+  end
+
+  context 'Existing record with settings' do
+    let!(:user) do
+      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)
+    end
+
+    it 'should be saved with settings for one key by one SQL queries' do
+      expect {
+        user.settings(:dashboard).foo = 42
+        user.settings(:dashboard).bar = 'string'
+        user.save!
+      }.to perform_queries(1)
+    end
+
+    it 'should be saved with settings for two keys by two SQL queries' do
+      expect {
+        user.settings(:dashboard).foo = 42
+        user.settings(:dashboard).bar = 'string'
+        user.settings(:calendar).bar = 'string'
+        user.save!
+      }.to perform_queries(2)
+    end
+
+    it 'should be destroyed by two SQL queries' do
+      expect {
+        user.destroy
+      }.to perform_queries(2)
+    end
+
+    it "should update settings by one SQL query" do
+      expect {
+        user.settings(:dashboard).update! :foo => 'bar'
+      }.to perform_queries(1)
+    end
+  end
+end

data/spec/scopes_spec.rb

@@ -0,0 +1,31 @@
+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' }
+
+  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
+    expect(User.with_settings_for(:dashboard)).to eq([user1])
+    expect(User.with_settings_for(:foo)).to eq([])
+  end
+
+  it "should records without settings" do
+    expect(User.without_settings).to eq([user2])
+  end
+
+  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)
+    end
+  end
+end

data/spec/serialize_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe "Serialization" do
+  let!(:user) do
+    User.create! :name => 'Mr. White' do |user|
+      user.settings(:dashboard).theme = 'white'
+      user.settings(:calendar).scope = 'all'
+    end
+  end
+
+  describe 'created settings' 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
+
+      expect(dashboard_settings.var).to eq('dashboard')
+      expect(dashboard_settings.value).to eq({'theme' => 'white'})
+
+      expect(calendar_settings.var).to eq('calendar')
+      expect(calendar_settings.value).to eq({'scope' => 'all'})
+    end
+  end
+
+  describe 'updated settings' do
+    it 'should be serialized' do
+      user.settings(:dashboard).update! :smart => true
+
+      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(calendar_settings.var).to eq('calendar')
+      expect(calendar_settings.value).to eq({'scope' => 'all'})
+    end
+  end
+end

data/spec/setting_object_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+describe RailsSettings::SettingObject do
+  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) }
+  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}}) }
+  end
+
+  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
+        expect(new_setting_object).to respond_to(:foo=)
+        expect(new_setting_object).to respond_to(:bar=)
+      end
+
+      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)
+      end
+
+      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)
+      end
+
+      it "should return nil for unknown attribute" do
+        expect(new_setting_object.foo).to eq(nil)
+        expect(new_setting_object.bar).to eq(nil)
+      end
+
+      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)
+      end
+
+      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
+        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)
+      end
+
+      it "should set and return attributes" do
+        new_setting_object.theme = 'pink'
+        new_setting_object.foo = 42
+        new_setting_object.bar = 'hello'
+
+        expect(new_setting_object.theme).to eq('pink')
+        expect(new_setting_object.foo).to eq(42)
+        expect(new_setting_object.bar).to eq('hello')
+      end
+
+      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
+        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
+        saved_setting_object.theme = nil
+        expect(saved_setting_object.value).to eq({ 'filter' => false })
+      end
+    end
+  end
+
+  describe "update" do
+    it 'should save' do
+      expect(new_setting_object.update(:foo => 42, :bar => 'string')).to be_truthy
+      new_setting_object.reload
+
+      expect(new_setting_object.foo).to eq(42)
+      expect(new_setting_object.bar).to eq('string')
+      expect(new_setting_object).not_to be_new_record
+      expect(new_setting_object.id).not_to be_zero
+    end
+
+    it 'should not save blank hash' do
+      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!(:var => 'calendar', :foo => 42)
+
+        expect(new_setting_object.var).to eq('dashboard')
+        expect(new_setting_object.foo).to eq(42)
+      end
+    end
+  end
+
+  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
+      new_setting_object.reload
+
+      expect(new_setting_object.foo).to eq(42)
+      expect(new_setting_object.bar).to eq('string')
+      expect(new_setting_object).not_to be_new_record
+      expect(new_setting_object.id).not_to be_zero
+    end
+  end
+
+  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
+    end
+  end
+end

data/spec/settings_spec.rb

@@ -0,0 +1,248 @@
+require 'spec_helper'
+
+describe "Defaults" do
+  it "should be stored for simple class" do
+    expect(Account.default_settings).to eq(:portal => {})
+  end
+
+  it "should be stored for parent class" do
+    expect(User.default_settings).to eq(:dashboard => { 'theme' => 'blue', 'view' => 'monthly', 'filter' => true },
+                                    :calendar => { 'scope' => 'company'})
+  end
+
+  it "should be stored for child class" do
+    expect(GuestUser.default_settings).to eq(:dashboard => { 'theme' => 'red', 'view' => 'monthly', 'filter' => true })
+  end
+end
+
+describe "Getter/Setter" do
+  let(:account) { Account.new :subdomain => 'foo' }
+
+  it "should handle method syntax" do
+    account.settings(:portal).enabled = true
+    account.settings(:portal).template = 'black'
+
+    expect(account.settings(:portal).enabled).to eq(true)
+    expect(account.settings(:portal).template).to eq('black')
+  end
+
+  it "should return nil for not existing key" do
+    expect(account.settings(:portal).foo).to eq(nil)
+  end
+end
+
+describe 'Objects' do
+  context 'without defaults' do
+    let(:account) { Account.new :subdomain => 'foo' }
+
+    it 'should have blank settings' do
+      expect(account.settings(:portal).value).to eq({})
+    end
+
+    it 'should allow saving a blank value' do
+      account.save!
+      expect(account.settings(:portal).save).to be_truthy
+    end
+
+    it 'should allow removing all values' do
+      account.settings(:portal).premium = true
+      account.settings(:portal).fee = 42.5
+      account.save!
+
+      account.settings(:portal).premium = nil
+      expect(account.save).to be_truthy
+
+      account.settings(:portal).fee = nil
+      expect(account.save).to be_truthy
+    end
+
+    it 'should not add settings on saving' do
+      account.save!
+      expect(RailsSettings::SettingObject.count).to eq(0)
+    end
+
+    it "should save object with settings" do
+      account.settings(:portal).premium = true
+      account.settings(:portal).fee = 42.5
+      account.save!
+
+      account.reload
+      expect(account.settings(:portal).premium).to eq(true)
+      expect(account.settings(:portal).fee).to eq(42.5)
+
+      expect(RailsSettings::SettingObject.count).to eq(1)
+      expect(RailsSettings::SettingObject.first.value).to eq({ 'premium' => true, 'fee' => 42.5 })
+    end
+
+    it "should save settings separated" do
+      account.save!
+
+      settings = account.settings(:portal)
+      settings.enabled = true
+      settings.template = 'black'
+      settings.save!
+
+      account.reload
+      expect(account.settings(:portal).enabled).to eq(true)
+      expect(account.settings(:portal).template).to eq('black')
+    end
+  end
+
+  context 'with defaults' do
+    let(:user) { User.new :name => 'Mr. Brown' }
+
+    it 'should have default settings' do
+      expect(user.settings(:dashboard).theme).to eq('blue')
+      expect(user.settings(:dashboard).view).to eq('monthly')
+      expect(user.settings(:dashboard).filter).to eq(true)
+      expect(user.settings(:calendar).scope).to eq('company')
+    end
+
+    it 'should have default settings after changing one' do
+      user.settings(:dashboard).theme = 'gray'
+
+      expect(user.settings(:dashboard).theme).to eq('gray')
+      expect(user.settings(:dashboard).view).to eq('monthly')
+      expect(user.settings(:dashboard).filter).to eq(true)
+      expect(user.settings(:calendar).scope).to eq('company')
+    end
+
+    it "should overwrite settings" do
+      user.settings(:dashboard).theme = 'brown'
+      user.settings(:dashboard).filter = false
+      user.save!
+
+      user.reload
+      expect(user.settings(:dashboard).theme).to eq('brown')
+      expect(user.settings(:dashboard).filter).to eq(false)
+      expect(RailsSettings::SettingObject.count).to eq(1)
+      expect(RailsSettings::SettingObject.first.value).to eq({ 'theme' => 'brown', 'filter' => false })
+    end
+
+    it "should merge settings with defaults" do
+      user.settings(:dashboard).theme = 'brown'
+      user.save!
+
+      user.reload
+      expect(user.settings(:dashboard).theme).to eq('brown')
+      expect(user.settings(:dashboard).filter).to eq(true)
+      expect(RailsSettings::SettingObject.count).to eq(1)
+      expect(RailsSettings::SettingObject.first.value).to eq({ 'theme' => 'brown' })
+    end
+  end
+end
+
+describe "Object without settings" do
+  let!(:user) { User.create! :name => 'Mr. White' }
+
+  it "should respond to #settings?" do
+    expect(user.settings?).to eq(false)
+    expect(user.settings?(:dashboard)).to eq(false)
+  end
+
+  it "should have no setting objects" do
+    expect(RailsSettings::SettingObject.count).to eq(0)
+  end
+
+  it "should add settings" do
+    user.settings(:dashboard).update! :smart => true
+
+    user.reload
+    expect(user.settings(:dashboard).smart).to eq(true)
+  end
+
+  it "should not save settings if assigned nil" do
+    expect {
+      user.settings = nil
+      user.save!
+    }.to_not change(RailsSettings::SettingObject, :count)
+  end
+end
+
+describe "Object with settings" do
+  let!(:user) do
+    User.create! :name => 'Mr. White' do |user|
+      user.settings(:dashboard).theme = 'white'
+      user.settings(:calendar).scope = 'all'
+    end
+  end
+
+  it "should respond to #settings?" do
+    expect(user.settings?).to eq(true)
+
+    expect(user.settings?(:dashboard)).to eq(true)
+    expect(user.settings?(:calendar)).to eq(true)
+  end
+
+  it "should have two setting objects" do
+    expect(RailsSettings::SettingObject.count).to eq(2)
+  end
+
+  it "should update settings" do
+    user.settings(:dashboard).update! :smart => true
+    user.reload
+
+    expect(user.settings(:dashboard).smart).to eq(true)
+    expect(user.settings(:dashboard).theme).to eq('white')
+    expect(user.settings(:calendar).scope).to eq('all')
+  end
+
+  it "should update settings by saving object" do
+    user.settings(:dashboard).smart = true
+    user.save!
+
+    user.reload
+    expect(user.settings(:dashboard).smart).to eq(true)
+  end
+
+  it "should destroy settings with nil" do
+    expect {
+      user.settings = nil
+      user.save!
+    }.to change(RailsSettings::SettingObject, :count).by(-2)
+
+    expect(user.settings?).to eq(false)
+  end
+
+  it "should raise exception on assigning other than nil" do
+    expect {
+      user.settings = :foo
+      user.save!
+    }.to raise_error(ArgumentError)
+  end
+end
+
+describe "Customized SettingObject" do
+  let(:project) { Project.create! :name => 'Heist' }
+
+  it "should not accept invalid attributes" do
+    project.settings(:info).owner_name = 42
+    expect(project.settings(:info)).not_to be_valid
+
+    project.settings(:info).owner_name = ''
+    expect(project.settings(:info)).not_to be_valid
+  end
+
+  it "should accept valid attributes" do
+    project.settings(:info).owner_name = 'Mr. Brown'
+    expect(project.settings(:info)).to be_valid
+  end
+end
+
+describe "to_settings_hash" do
+  let(:user) do
+    User.new :name => 'Mrs. Fin' do |user|
+      user.settings(:dashboard).theme = 'green'
+      user.settings(:dashboard).sound = 11
+      user.settings(:calendar).scope = 'some'
+    end
+  end
+
+  it "should return defaults" do
+    expect(User.new.to_settings_hash).to eq({:dashboard=>{"theme"=>"blue", "view"=>"monthly", "filter"=>true}, :calendar=>{"scope"=>"company"}})
+  end
+
+  it "should return merged settings" do
+    expect(user.to_settings_hash).to eq({:dashboard=>{"theme"=>"green", "view"=>"monthly", "filter"=>true, "sound" => 11}, :calendar=>{"scope"=>"some"}})
+  end
+end