ledermann-rails-settings 1.2.0 → 2.5.0

data/ci/Gemfile-rails-6-0

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'activerecord', '~> 6.0.0'
+gem "sqlite3", "~> 1.4"
+
+gemspec :path => "../"

data/lib/generators/rails_settings/migration/migration_generator.rb

@@ -0,0 +1,23 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module RailsSettings
+  class MigrationGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    desc "Generates migration for rails-settings"
+    source_root File.expand_path('../templates', __FILE__)
+
+    def create_migration_file
+      migration_template 'migration.rb', 'db/migrate/rails_settings_migration.rb'
+    end
+
+    def self.next_migration_number(dirname)
+      if ActiveRecord::Base.timestamped_migrations
+        Time.now.utc.strftime("%Y%m%d%H%M%S")
+      else
+        "%.3d" % (current_migration_number(dirname) + 1)
+      end
+    end
+  end
+end

data/lib/generators/rails_settings/migration/templates/migration.rb

@@ -0,0 +1,21 @@
+MIGRATION_BASE_CLASS = if ActiveRecord::VERSION::MAJOR >= 5
+  ActiveRecord::Migration[5.0]
+else
+  ActiveRecord::Migration
+end
+
+class RailsSettingsMigration < MIGRATION_BASE_CLASS
+  def self.up
+    create_table :settings do |t|
+      t.string     :var,    :null => false
+      t.text       :value
+      t.references :target, :null => false, :polymorphic => true
+      t.timestamps :null => true
+    end
+    add_index :settings, [ :target_type, :target_id, :var ], :unique => true
+  end
+
+  def self.down
+    drop_table :settings
+  end
+end

data/lib/ledermann-rails-settings.rb

@@ -0,0 +1 @@
+require 'rails-settings'

data/lib/rails-settings.rb

@@ -1,5 +1,21 @@
-require 'rails-settings/version'
-require 'rails-settings/null_store'
-require 'rails-settings/active_record'
-require 'rails-settings/settings'
-require 'rails-settings/scoped_settings'
+module RailsSettings
+  # In Rails 4, attributes can be protected by using the gem `protected_attributes`
+  # In Rails 5, protecting attributes is obsolete (there are `StrongParameters` only)
+  def self.can_protect_attributes?
+    defined?(ProtectedAttributes)
+  end
+end
+
+require 'rails-settings/setting_object'
+require 'rails-settings/configuration'
+require 'rails-settings/base'
+require 'rails-settings/scopes'
+
+ActiveRecord::Base.class_eval do
+  def self.has_settings(*args, &block)
+    RailsSettings::Configuration.new(*args.unshift(self), &block)
+
+    include RailsSettings::Base
+    extend RailsSettings::Scopes
+  end
+end

data/lib/rails-settings/base.rb

@@ -0,0 +1,48 @@
+module RailsSettings
+  module Base
+    def self.included(base)
+      base.class_eval do
+        has_many :setting_objects,
+                 :as         => :target,
+                 :autosave   => true,
+                 :dependent  => :delete_all,
+                 :class_name => self.setting_object_class_name
+
+        def settings(var)
+          raise ArgumentError unless var.is_a?(Symbol)
+          raise ArgumentError.new("Unknown key: #{var}") unless self.class.default_settings[var]
+
+          if RailsSettings.can_protect_attributes?
+            setting_objects.detect { |s| s.var == var.to_s } || setting_objects.build({ :var => var.to_s }, :without_protection => true)
+          else
+            setting_objects.detect { |s| s.var == var.to_s } || setting_objects.build(:var => var.to_s, :target => self)
+          end
+        end
+
+        def settings=(value)
+          if value.nil?
+            setting_objects.each(&:mark_for_destruction)
+          else
+            raise ArgumentError
+          end
+        end
+
+        def settings?(var=nil)
+          if var.nil?
+            setting_objects.any? { |setting_object| !setting_object.marked_for_destruction? && setting_object.value.present? }
+          else
+            settings(var).value.present?
+          end
+        end
+
+        def to_settings_hash
+          settings_hash = self.class.default_settings.dup
+          settings_hash.each do |var, vals|
+            settings_hash[var] = settings_hash[var].merge(settings(var.to_sym).value)
+          end
+          settings_hash
+        end
+      end
+    end
+  end
+end

data/lib/rails-settings/configuration.rb

@@ -0,0 +1,39 @@
+module RailsSettings
+  class Configuration
+    def initialize(*args, &block)
+      options = args.extract_options!
+      klass = args.shift
+      keys = args
+
+      raise ArgumentError unless klass
+
+      @klass = klass
+
+      if options[:persistent]
+        @klass.class_attribute :default_settings unless @klass.methods.include?(:default_settings)
+      else
+        @klass.class_attribute :default_settings
+      end
+
+      @klass.class_attribute :setting_object_class_name
+      @klass.default_settings ||= {}
+      @klass.setting_object_class_name = options[:class_name] || 'RailsSettings::SettingObject'
+
+      if block_given?
+        yield(self)
+      else
+        keys.each do |k|
+          key(k)
+        end
+      end
+
+      raise ArgumentError.new('has_settings: No keys defined') if @klass.default_settings.blank?
+    end
+
+    def key(name, options={})
+      raise ArgumentError.new("has_settings: Symbol expected, but got a #{name.class}") unless name.is_a?(Symbol)
+      raise ArgumentError.new("has_settings: Option :defaults expected, but got #{options.keys.join(', ')}") unless options.blank? || (options.keys == [:defaults])
+      @klass.default_settings[name] = (options[:defaults] || {}).stringify_keys.freeze
+    end
+  end
+end

data/lib/rails-settings/scopes.rb

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

data/lib/rails-settings/setting_object.rb

@@ -0,0 +1,84 @@
+module RailsSettings
+  class SettingObject < ActiveRecord::Base
+    self.table_name = 'settings'
+
+    belongs_to :target, :polymorphic => true
+
+    validates_presence_of :var, :target_type
+    validate do
+      errors.add(:value, "Invalid setting value") unless value.is_a? Hash
+
+      unless _target_class.default_settings[var.to_sym]
+        errors.add(:var, "#{var} is not defined!")
+      end
+    end
+
+    serialize :value, Hash
+
+    if RailsSettings.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 || _setting?(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 RailsSettings.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_settings[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 _setting?(method_name)
+      _target_class.default_settings[var.to_sym].keys.include?(method_name.to_s)
+    end
+  end
+end

data/lib/rails-settings/version.rb

@@ -1,3 +1,3 @@
 module RailsSettings
-  VERSION = '1.2.0'
-end
+  VERSION = '2.5.0'
+end

data/rails-settings.gemspec

@@ -1,28 +1,29 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path('../lib', __FILE__)
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'rails-settings/version'
 
-Gem::Specification.new do |s|
-  s.name        = 'ledermann-rails-settings'
-  s.version     = RailsSettings::VERSION
-  s.authors     = ['Georg Ledermann']
-  s.email       = ['mail@georg-ledermann.de']
-  s.homepage    = 'https://github.com/ledermann/rails-settings'
-  s.summary     = %q{Settings management for ActiveRecord objects}
-  s.description = %q{Ruby Gem that makes managing a table of key/value pairs easy. Think of it like a Hash stored in you database, that uses simple ActiveRecord like methods for manipulation.}
+Gem::Specification.new do |gem|
+  gem.name          = 'ledermann-rails-settings'
+  gem.version       = RailsSettings::VERSION
+  gem.licenses      = ['MIT']
+  gem.authors       = ['Georg Ledermann']
+  gem.email         = ['mail@georg-ledermann.de']
+  gem.description   = %q{Settings gem for Ruby on Rails}
+  gem.summary       = %q{Ruby gem to handle settings for ActiveRecord instances by storing them as serialized Hash in a separate database table. Namespaces and defaults included.}
+  gem.homepage      = 'https://github.com/ledermann/rails-settings'
+  gem.required_ruby_version = '>= 2.4'
 
-  s.rubyforge_project = 'ledermann-rails-settings'
+  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']
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ['lib']
+  gem.add_dependency 'activerecord', '>= 4.2'
 
-  # specify any dependencies here; for example:
-  s.add_development_dependency "rake"
-  s.add_development_dependency "sqlite3"
-  # s.add_runtime_dependency "rest-client"
-  s.add_dependency 'activerecord', '>= 2.3'
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'sqlite3'
+  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', '>= 0.11.2'
 end

data/spec/configuration_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+module RailsSettings
+  class Dummy
+  end
+
+  describe Configuration, 'successful' 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')
+    end
+
+    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')
+    end
+
+    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')
+
+      expect(Dummy.default_settings).to eq({ :dashboard => {}, :calendar => {} })
+      expect(Dummy.setting_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_settings).to eq({ :dashboard => {}, :calendar => {} })
+      expect(Dummy.setting_object_class_name).to eq('RailsSettings::SettingObject')
+    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_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|
+        c.key :dashboard
+        c.key :calendar
+      end
+
+      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)
+    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