ledermann-rails-settings 1.2.1 → 2.0.0

data/spec/support/matchers/perform_queries.rb

@@ -0,0 +1,18 @@
+RSpec::Matchers.define :perform_queries do |expected|
+  match do |block|
+    query_count(&block) == expected
+  end
+
+  failure_message_for_should do |actual|
+    "Expected to run #{expected} queries, got #{@counter.query_count}"
+  end
+
+  def query_count(&block)
+    @counter = ActiveRecord::QueryCounter.new
+    ActiveSupport::Notifications.subscribe('sql.active_record', @counter.to_proc)
+    yield
+    ActiveSupport::Notifications.unsubscribe(@counter.to_proc)
+
+    @counter.query_count
+  end
+end

data/spec/support/query_counter.rb

@@ -0,0 +1,17 @@
+module ActiveRecord
+  class QueryCounter
+    attr_reader :query_count
+
+    def initialize
+      @query_count = 0
+    end
+
+    def to_proc
+      lambda(&method(:callback))
+    end
+
+    def callback(name, start, finish, message_id, values)
+      @query_count += 1 unless %w(CACHE SCHEMA).include?(values[:name]) || values[:sql] == 'begin transaction' || values[:sql] == 'commit transaction'
+    end
+  end
+end

metadata

@@ -1,99 +1,72 @@
 --- !ruby/object:Gem::Specification
 name: ledermann-rails-settings
 version: !ruby/object:Gem::Version
-  prerelease: 
-  version: 1.2.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Georg Ledermann
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-09 00:00:00.000000000 Z
+date: 2013-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '2.3'
-    none: false
-  type: :runtime
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '2.3'
-    none: false
-- !ruby/object:Gem::Dependency
+        version: '3.1'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
-    none: false
-  type: :development
+        version: '3.1'
+- !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
-    none: false
-- !ruby/object:Gem::Dependency
+        version: '10.0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
-    none: false
-  type: :development
+        version: '10.0'
+- !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
-    none: false
-- !ruby/object:Gem::Dependency
+        version: '1.3'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
-    none: false
-  type: :development
-  name: rake
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
-    none: false
-- !ruby/object:Gem::Dependency
+        version: '2.13'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-    none: false
-  type: :development
-  name: sqlite3
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
-    none: false
-description: 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.
+        version: '2.13'
+description: Settings gem for Ruby on Rails
 email:
 - mail@georg-ledermann.de
 executables: []
@@ -107,43 +80,57 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
-- ci/Gemfile.rails-2.3.x
-- ci/Gemfile.rails-3.0.x
 - ci/Gemfile.rails-3.1.x
 - ci/Gemfile.rails-3.2.x
-- init.rb
+- lib/generators/rails_settings/migration/migration_generator.rb
+- lib/generators/rails_settings/migration/templates/migration.rb
 - lib/rails-settings.rb
-- lib/rails-settings/active_record.rb
-- lib/rails-settings/scoped_settings.rb
-- lib/rails-settings/settings.rb
+- lib/rails-settings/base.rb
+- lib/rails-settings/configuration.rb
+- lib/rails-settings/scopes.rb
+- lib/rails-settings/setting_object.rb
 - lib/rails-settings/version.rb
 - rails-settings.gemspec
-- test/settings_test.rb
-- test/test_helper.rb
+- spec/configuration_spec.rb
+- spec/queries_spec.rb
+- spec/scopes_spec.rb
+- spec/serialize_spec.rb
+- spec/setting_object_spec.rb
+- spec/settings_spec.rb
+- spec/spec_helper.rb
+- spec/support/matchers/perform_queries.rb
+- spec/support/query_counter.rb
 homepage: https://github.com/ledermann/rails-settings
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-  none: false
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-  none: false
 requirements: []
-rubyforge_project: ledermann-rails-settings
-rubygems_version: 1.8.25
+rubyforge_project: 
+rubygems_version: 2.0.2
 signing_key: 
-specification_version: 3
-summary: Settings management for ActiveRecord objects
+specification_version: 4
+summary: 'Handling settings for ActiveRecord objects by storing them as serialized
+  Hash in a separate database table. Optional: Defaults and Namespaces.'
 test_files:
-- test/settings_test.rb
-- test/test_helper.rb
+- spec/configuration_spec.rb
+- spec/queries_spec.rb
+- spec/scopes_spec.rb
+- spec/serialize_spec.rb
+- spec/setting_object_spec.rb
+- spec/settings_spec.rb
+- spec/spec_helper.rb
+- spec/support/matchers/perform_queries.rb
+- spec/support/query_counter.rb

data/ci/Gemfile.rails-2.3.x

@@ -1,5 +0,0 @@
-source :rubygems
-
-gem 'activerecord', '~> 2.3.14'
-gem 'sqlite3'
-gem 'rake'

data/ci/Gemfile.rails-3.0.x

@@ -1,5 +0,0 @@
-source :rubygems
-
-gem 'activerecord', '~> 3.0.12'
-gem 'sqlite3'
-gem 'rake'

data/init.rb

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

data/lib/rails-settings/active_record.rb

@@ -1,38 +0,0 @@
-ActiveRecord::Base.class_eval do
-  def self.has_settings
-    class_eval do
-      def settings
-        ScopedSettings.for_target(self)
-      end
-
-      def self.settings
-        ScopedSettings.for_target(self)
-      end
-
-      def settings=(hash)
-        hash.each { |k,v| settings[k] = v }
-      end
-
-      after_destroy { |user| user.settings.target_scoped.delete_all }
-
-      scope_method = ActiveRecord::VERSION::MAJOR < 3 ? :named_scope : :scope
-      
-      send scope_method, :with_settings, :joins => "JOIN settings ON (settings.target_id = #{self.table_name}.#{self.primary_key} AND
-                                                                      settings.target_type = '#{self.base_class.name}')",
-                                         :select => "DISTINCT #{self.table_name}.*" 
-
-      send scope_method, :with_settings_for, lambda { |var| { :joins => "JOIN settings ON (settings.target_id = #{self.table_name}.#{self.primary_key} AND
-                                                                              settings.target_type = '#{self.base_class.name}') AND
-                                                                              settings.var = '#{var}'" } }
-                                                               
-      send scope_method, :without_settings, :joins => "LEFT JOIN settings ON (settings.target_id = #{self.table_name}.#{self.primary_key} AND
-                                                                 settings.target_type = '#{self.base_class.name}')",
-                                            :conditions => 'settings.id IS NULL'
-                                     
-      send scope_method, :without_settings_for, lambda { |var| { :joins => "LEFT JOIN settings ON (settings.target_id = #{self.table_name}.#{self.primary_key} AND
-                                                                                      settings.target_type = '#{self.base_class.name}') AND
-                                                                                      settings.var = '#{var}'",
-                                                                 :conditions => 'settings.id IS NULL' } }
-    end
-  end
-end

data/lib/rails-settings/scoped_settings.rb

@@ -1,20 +0,0 @@
-class ScopedSettings < Settings
-
-  @klasses = {}
-
-  def self.for_target(target)
-    @klasses[target] ||= self.dup.instance_eval do
-      def name; "ScopedSettings"; end # Required by ActiveModel::Naming
-      @target = target
-      self
-    end
-  end
-  
-  def self.target_id
-    @target.is_a?(Class) ? nil : @target.id
-  end
-  
-  def self.target_type
-    @target.is_a?(Class) ? @target.name : @target.class.base_class.to_s
-  end
-end

data/lib/rails-settings/settings.rb

@@ -1,121 +0,0 @@
-class Settings < ActiveRecord::Base
-  class SettingNotFound < RuntimeError; end
-  
-  def self.defaults
-    Thread.current[:rails_settings_defaults] ||= {}.with_indifferent_access
-  end
-  
-  def self.defaults=(value)
-    Thread.current[:rails_settings_defaults] = value
-  end
-
-  #get or set a variable with the variable as the called method
-  def self.method_missing(method, *args)
-    if self.respond_to?(method)
-      super
-    else
-      method_name = method.to_s
-    
-      #set a value for a variable
-      if method_name =~ /=$/
-        var_name = method_name.gsub('=', '')
-        value = args.first
-        self[var_name] = value
-    
-      #retrieve a value
-      else
-        self[method_name]
-      
-      end
-    end
-  end
-  
-  #destroy the specified settings record
-  def self.destroy(var_name)
-    var_name = var_name.to_s
-    begin
-      target(var_name).destroy
-      true
-    rescue NoMethodError
-      raise SettingNotFound, "Setting variable \"#{var_name}\" not found"
-    end
-  end
-
-  #retrieve all settings as a hash (optionally starting with a given namespace)
-  def self.all(starting_with=nil)
-    options = starting_with ? { :conditions => "var LIKE '#{starting_with}%'"} : {}
-    vars = target_scoped.find(:all, {:select => 'var, value'}.merge(options))
-    
-    result = {}
-    vars.each do |record|
-      result[record.var] = record.value
-    end
-    selected_defaults = defaults.select{ |k, v| k =~ /^#{starting_with}/ }
-    selected_defaults = Hash[selected_defaults] if selected_defaults.is_a?(Array)
-    selected_defaults.merge(result).with_indifferent_access
-  end
-  
-  #get a setting value by [] notation
-  def self.[](var_name)
-    if var = target(var_name)
-      var.value
-    else
-      if target_id.nil?
-        defaults[var_name.to_s]
-      else
-        target_type.constantize.settings[var_name.to_s]
-      end
-    end
-  end
-  
-  #set a setting value by [] notation
-  def self.[]=(var_name, value)
-    record = target_scoped.find_or_initialize_by_var(var_name.to_s)
-    record.value = value
-    record.save!
-    value
-  end
-  
-  def self.merge!(var_name, hash_value)
-    raise ArgumentError unless hash_value.is_a?(Hash)
-    
-    old_value = self[var_name] || {}
-    raise TypeError, "Existing value is not a hash, can't merge!" unless old_value.is_a?(Hash)
-    
-    new_value = old_value.merge(hash_value)
-    self[var_name] = new_value if new_value != old_value
-    
-    new_value
-  end
-
-  def self.target(var_name)
-    target_scoped.find_by_var(var_name.to_s)
-  end
-  
-  #get the value field, YAML decoded
-  def value
-    YAML::load(self[:value])
-  end
-  
-  #set the value field, YAML encoded
-  def value=(new_value)
-    self[:value] = new_value.to_yaml
-  end
-  
-  def self.target_scoped
-    Settings.scoped_by_target_type_and_target_id(target_type, target_id)
-  end
-  
-  #Deprecated!
-  def self.reload # :nodoc:
-    self
-  end
-  
-  def self.target_id
-    nil
-  end
-
-  def self.target_type
-    nil
-  end
-end

data/test/settings_test.rb

@@ -1,258 +0,0 @@
-require 'test_helper'
-
-class SettingsTest < Test::Unit::TestCase
-  setup_db
-  
-  def setup
-    Settings.create!(:var => 'test',  :value => 'foo')
-    Settings.create!(:var => 'test2', :value => 'bar')
-    
-    # Reset defaults
-    Settings.defaults = {}.with_indifferent_access
-  end
-
-  def teardown
-    User.delete_all
-    Settings.delete_all
-  end
-  
-  def test_defaults
-    Settings.defaults[:foo] = 'default foo'
-    
-    assert_nil Settings.target(:foo)
-    assert_equal 'default foo', Settings.foo
-    
-    Settings.foo = 'bar'
-    assert_equal 'bar', Settings.foo
-    assert_not_nil Settings.target(:foo)
-  end
-  
-  def tests_defaults_true
-    Settings.defaults[:foo] = true
-    assert_equal true, Settings.foo
-  end
-
-  def tests_defaults_false
-    Settings.defaults[:foo] = false
-    assert_equal false, Settings.foo
-  end
-  
-  def test_get
-    assert_setting 'foo', :test
-    assert_setting 'bar', :test2
-  end
-
-  def test_update
-    assert_assign_setting '321', :test
-  end
-  
-  def test_create
-    assert_assign_setting '123', :onetwothree
-  end
-  
-  def test_complex_serialization
-    complex = [1, '2', {:three => true}]
-    Settings.complex = complex
-    assert_equal complex, Settings.complex
-  end
-  
-  def test_serialization_of_float
-    Settings.float = 0.01
-    Settings.reload
-    assert_equal 0.01, Settings.float
-    assert_equal 0.02, Settings.float * 2
-  end
-  
-  def test_target_scope
-    user1 = User.create! :name => 'First user'
-    user2 = User.create! :name => 'Second user'
-    
-    assert_assign_setting 1, :one, user1
-    assert_assign_setting 2, :two, user2
-    
-    assert_setting 1, :one, user1
-    assert_setting 2, :two, user2
-    
-    assert_setting nil, :one
-    assert_setting nil, :two
-    
-    assert_setting nil, :two, user1
-    assert_setting nil, :one, user2
-
-    assert_equal({ "one" => 1}, user1.settings.all('one'))
-    assert_equal({ "two" => 2}, user2.settings.all('two'))
-    assert_equal({ "one" => 1}, user1.settings.all('o'))
-    assert_equal({}, user1.settings.all('non_existing_var'))
-  end
-
-  def test_target_scope_is_instance_safe
-    user1 = User.create! :name => 'First user'
-    user2 = User.create! :name => 'Second user'
-
-    assert_assign_setting 'Foo one', :foo, user1
-    assert_assign_setting 'Foo two', :foo, user2
-
-    settings_1 = user1.settings
-    settings_2 = user2.settings
-    assert_equal 'Foo one', settings_1.foo
-  end
-
-  def test_named_scope
-    user_without_settings = User.create! :name => 'User without settings'
-    user_with_settings = User.create! :name => 'User with settings'
-    user_with_settings.settings.one = '1'
-    user_with_settings.settings.two = '2'
-    
-    assert_equal [user_with_settings], User.with_settings
-    assert_equal [user_with_settings], User.with_settings_for('one')
-    assert_equal [user_with_settings], User.with_settings_for('two')
-    assert_equal [], User.with_settings_for('foo')
-    
-    assert_equal [user_without_settings], User.without_settings
-    assert_equal [user_without_settings], User.without_settings_for('one')
-    assert_equal [user_without_settings], User.without_settings_for('two')
-    assert_equal [user_without_settings, user_with_settings], User.without_settings_for('foo')
-  end
-  
-  def test_delete_settings_after_destroying_target
-    user1 = User.create! :name => 'Mr. Foo'
-    user2 = User.create! :name => 'Mr. Bar'
-    user1.settings.example = 42
-    user2.settings.example = 43
-    
-    before_count = Settings.count
-    user1.destroy
-    assert_equal before_count - 1, Settings.count
-    
-    before_count = Settings.count
-    user2.destroy
-    assert_equal before_count - 1, Settings.count
-  end
-  
-  def test_all
-    assert_equal({ "test2" => "bar", "test" => "foo" }, Settings.all)
-    assert_equal({ "test2" => "bar" }, Settings.all('test2'))
-    assert_equal({ "test2" => "bar", "test" => "foo" }, Settings.all('test'))
-    assert_equal({}, Settings.all('non_existing_var'))
-  end
-  
-  def test_merge
-    assert_raise(TypeError) do
-      Settings.merge! :test, { :a => 1 }
-    end
-
-    Settings[:hash] = { :one => 1 }
-    Settings.merge! :hash, { :two => 2 }
-    assert_equal({ :one => 1, :two => 2 }, Settings[:hash])
-    
-    assert_raise(ArgumentError) do
-      Settings.merge! :hash, 123
-    end
-    
-    Settings.merge! :empty_hash, { :two => 2 }
-    assert_equal({ :two => 2 }, Settings[:empty_hash])
-  end
-  
-  def test_association_merge
-    user = User.create! :name => 'Mr. Foo'
-    user.settings.merge! :foo, { :one => 1, :two => 2}
-
-    assert_equal({:one => 1, :two => 2}, user.settings.foo)
-  end
-  
-  def test_destroy
-    Settings.destroy :test
-    assert_equal nil, Settings.test
-    
-    assert_raise(Settings::SettingNotFound) do
-      Settings.destroy :unknown
-    end
-  end
-  
-  def test_false
-    Settings.test3 = false
-    assert_setting(false, 'test3')
-    
-    Settings.destroy :test3
-    assert_setting(nil, 'test3')
-  end
-  
-  def test_class_level_settings
-    assert_equal User.settings.name, "ScopedSettings"
-  end
-
-  def test_object_inherits_class_settings_before_default
-    Settings.defaults[:foo] = 'global default'
-    User.settings.foo = 'model default'
-    
-    user = User.create! :name => 'Dwight'
-    
-    assert_equal user.settings.foo, 'model default'
-    assert_equal 'global default', Settings.foo
-  end
-
-  def test_class_inherits_default_settings
-    Settings.defaults[:foo] = 'bar'
-    assert_equal User.settings.foo, 'bar'
-  end
-
-  def test_sets_settings_with_hash
-    user = User.create! :name => 'Mr. Foo'
-    user.settings[:one] = '1'
-    user.settings[:two] = '2'
-    user.settings = { :two => '2a', :three => '3' }
-    
-    assert_equal '1',  user.settings[:one]   # ensure existing settings remain intact
-    assert_equal '2a', user.settings[:two]   # ensure settings are properly overwritten
-    assert_equal '3',  user.settings[:three] # ensure new setting are created
-  end
-
-  def test_all_includes_defaults
-    Settings.defaults[:foo] = 'bar'
-    user = User.create! :name => 'Mr. Foo'
-    assert_equal({ 'foo' => 'bar' }, user.settings.all)
-  end
-  
-  def test_issue_18
-    Settings.one = 'value1'
-    User.settings.two = 'value2'
-    
-    assert_equal({'two' => 'value2'}, User.settings.all)
-  end
-  
-
-  private
-    def assert_setting(value, key, scope_target=nil)
-      key = key.to_sym
-      
-      if scope_target
-        assert_equal value, scope_target.instance_eval("settings.#{key}")
-        assert_equal value, scope_target.settings[key.to_sym]
-        assert_equal value, scope_target.settings[key.to_s]
-      else
-        assert_equal value, eval("Settings.#{key}")
-        assert_equal value, Settings[key.to_sym]
-        assert_equal value, Settings[key.to_s]
-      end
-    end
-    
-    def assert_assign_setting(value, key, scope_target=nil)
-      key = key.to_sym
-      
-      if scope_target
-        assert_equal value, (scope_target.settings[key] = value)
-        assert_setting value, key, scope_target
-        scope_target.settings[key] = nil
-      
-        assert_equal value, (scope_target.settings[key.to_s] = value)
-        assert_setting value, key, scope_target
-      else
-        assert_equal value, (Settings[key] = value)
-        assert_setting value, key
-        Settings[key] = nil
-      
-        assert_equal value, (Settings[key.to_s] = value)
-        assert_setting value, key
-      end
-    end
-end