rails-properties 3.4.3

data/lib/rails-properties/property_object.rb

@@ -0,0 +1,84 @@
+module RailsProperties
+  class PropertyObject < ActiveRecord::Base
+    self.table_name = 'properties'
+
+    belongs_to :target, :polymorphic => true
+
+    validates_presence_of :var, :target_type
+    validate do
+      errors.add(:value, "Invalid property value") unless value.is_a? Hash
+
+      unless _target_class.default_properties[var.to_sym]
+        errors.add(:var, "#{var} is not defined!")
+      end
+    end
+
+    serialize :value, Hash
+
+    if RailsProperties.can_protect_attributes?
+      # attr_protected can not be used here because it touches the database which is not connected yet.
+      # So allow no attributes and override <tt>#sanitize_for_mass_assignment</tt>
+      attr_accessible
+    end
+
+    REGEX_SETTER = /\A([a-z]\w+)=\Z/i
+    REGEX_GETTER = /\A([a-z]\w+)\Z/i
+
+    def respond_to?(method_name, include_priv=false)
+      super || method_name.to_s =~ REGEX_SETTER || _property?(method_name)
+    end
+
+    def method_missing(method_name, *args, &block)
+      if block_given?
+        super
+      else
+        if attribute_names.include?(method_name.to_s.sub('=',''))
+          super
+        elsif method_name.to_s =~ REGEX_SETTER && args.size == 1
+          _set_value($1, args.first)
+        elsif method_name.to_s =~ REGEX_GETTER && args.size == 0
+          _get_value($1)
+        else
+          super
+        end
+      end
+    end
+
+  protected
+    if RailsProperties.can_protect_attributes?
+      # Simulate attr_protected by removing all regular attributes
+      def sanitize_for_mass_assignment(attributes, role = nil)
+        attributes.except('id', 'var', 'value', 'target_id', 'target_type', 'created_at', 'updated_at')
+      end
+    end
+
+  private
+    def _get_value(name)
+      if value[name].nil?
+        _target_class.default_properties[var.to_sym][name]
+      else
+        value[name]
+      end
+    end
+
+    def _set_value(name, v)
+      if value[name] != v
+        value_will_change!
+
+        if v.nil?
+          value.delete(name)
+        else
+          value[name] = v
+        end
+      end
+    end
+
+    def _target_class
+      target_type.constantize
+    end
+
+    def _property?(method_name)
+      _target_class.default_properties[var.to_sym].keys.include?(method_name.to_s)
+    end
+  end
+end

data/lib/rails-properties/scopes.rb

@@ -0,0 +1,34 @@
+module RailsProperties
+  module Scopes
+    def with_properties
+      result = joins("INNER JOIN properties ON #{properties_join_condition}")
+
+      if ActiveRecord::VERSION::MAJOR < 5
+        result.uniq
+      else
+        result.distinct
+      end
+    end
+
+    def with_properties_for(var)
+      raise ArgumentError.new('Symbol expected!') unless var.is_a?(Symbol)
+      joins("INNER JOIN properties ON #{properties_join_condition} AND properties.var = '#{var}'")
+    end
+
+    def without_properties
+      joins("LEFT JOIN properties ON #{properties_join_condition}").
+      where('properties.id IS NULL')
+    end
+
+    def without_properties_for(var)
+      raise ArgumentError.new('Symbol expected!') unless var.is_a?(Symbol)
+      joins("LEFT JOIN properties ON  #{properties_join_condition} AND properties.var = '#{var}'").
+      where('properties.id IS NULL')
+    end
+
+    def properties_join_condition
+      "properties.target_id   = #{table_name}.#{primary_key} AND
+       properties.target_type = '#{base_class.name}'"
+    end
+  end
+end

data/lib/rails-properties/version.rb

@@ -0,0 +1,3 @@
+module RailsProperties
+  VERSION = '3.4.3'
+end

data/rails-properties.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rails-properties/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'rails-properties'
+  gem.version       = RailsProperties::VERSION
+  gem.licenses      = ['MIT']
+  gem.authors       = ['Fletcher Fowler']
+  gem.email         = ['fletch@fzf.me']
+  gem.description   = %q{Properties gem for Ruby on Rails}
+  gem.summary       = %q{Ruby gem to handle properties for ActiveRecord instances by storing them as serialized Hash in a separate database table. Namespaces and defaults included.}
+  gem.homepage      = 'https://github.com/1debit/rails-properties'
+  gem.required_ruby_version = '>= 1.9.3'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_dependency 'activerecord', '>= 3.1'
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'sqlite3'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'coveralls'
+  gem.add_development_dependency 'simplecov', RUBY_VERSION < '2' ? '~> 0.11.2' : '>= 0.11.2'
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+module RailsProperties
+  class Dummy
+  end
+
+  describe Configuration, 'successful' do
+    it "should define single key" do
+      Configuration.new(Dummy, :dashboard)
+
+      expect(Dummy.default_properties).to eq({ :dashboard => {} })
+      expect(Dummy.property_object_class_name).to eq('RailsProperties::PropertyObject')
+    end
+
+    it "should define multiple keys" do
+      Configuration.new(Dummy, :dashboard, :calendar)
+
+      expect(Dummy.default_properties).to eq({ :dashboard => {}, :calendar => {} })
+      expect(Dummy.property_object_class_name).to eq('RailsProperties::PropertyObject')
+    end
+
+    it "should define single key with class_name" do
+      Configuration.new(Dummy, :dashboard, :class_name => 'MyClass')
+      expect(Dummy.default_properties).to eq({ :dashboard => {} })
+      expect(Dummy.property_object_class_name).to eq('MyClass')
+    end
+
+    it "should define multiple keys with class_name" do
+      Configuration.new(Dummy, :dashboard, :calendar, :class_name => 'MyClass')
+
+      expect(Dummy.default_properties).to eq({ :dashboard => {}, :calendar => {} })
+      expect(Dummy.property_object_class_name).to eq('MyClass')
+    end
+
+    it "should define using block" do
+      Configuration.new(Dummy) do |c|
+        c.key :dashboard
+        c.key :calendar
+      end
+
+      expect(Dummy.default_properties).to eq({ :dashboard => {}, :calendar => {} })
+      expect(Dummy.property_object_class_name).to eq('RailsProperties::PropertyObject')
+    end
+
+    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' }
+      end
+
+      expect(Dummy.default_properties).to eq({ :dashboard => { 'theme' => 'red' }, :calendar => { 'scope' => 'all'} })
+      expect(Dummy.property_object_class_name).to eq('RailsProperties::PropertyObject')
+    end
+
+    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_properties).to eq({ :dashboard => {}, :calendar => {} })
+      expect(Dummy.property_object_class_name).to eq('MyClass')
+    end
+  end
+
+  describe Configuration, 'failure' do
+    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)
+    end
+
+    it "should fail without keys in block" do
+      expect {
+        Configuration.new(Dummy) do |c|
+        end
+      }.to raise_error(ArgumentError)
+    end
+
+    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
+      expect {
+        Configuration.new(Dummy) do |c|
+          c.key 42, "string"
+        end
+      }.to raise_error(ArgumentError)
+    end
+
+    it "should fail with unknown option" do
+      expect {
+        Configuration.new(Dummy) do |c|
+          c.key :dashboard, :foo => {}
+        end
+      }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/database.yml

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

data/spec/properties_spec.rb

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