ledermann-rails-settings 1.2.0 → 2.5.0

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/ci/Gemfile.rails-3.1.x

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

data/ci/Gemfile.rails-3.2.x

@@ -1,5 +0,0 @@
-source :rubygems
-
-gem 'activerecord', '~> 3.2.2'
-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/null_store.rb

@@ -1,48 +0,0 @@
-unless defined?(ActiveSupport::Cache::NullStore)
-  # Copied from Rails 3
-  # https://github.com/rails/rails/blob/master/activesupport/lib/active_support/cache/null_store.rb
-  module ActiveSupport
-    module Cache
-      # A cache store implementation which doesn't actually store anything. Useful in
-      # development and test environments where you don't want caching turned on but
-      # need to go through the caching interface.
-      #
-      # This cache does implement the local cache strategy, so values will actually
-      # be cached inside blocks that utilize this strategy. See
-      # ActiveSupport::Cache::Strategy::LocalCache for more details.
-      class NullStore < Store
-        def initialize(options = nil)
-          super()
-          extend Strategy::LocalCache
-        end
-
-        def clear(options = nil)
-        end
-
-        def cleanup(options = nil)
-        end
-
-        def increment(name, amount = 1, options = nil)
-        end
-
-        def decrement(name, amount = 1, options = nil)
-        end
-
-        def delete_matched(matcher, options = nil)
-        end
-
-        protected
-          def read_entry(key, options) # :nodoc:
-          end
-
-          def write_entry(key, entry, options) # :nodoc:
-            true
-          end
-
-          def delete_entry(key, options) # :nodoc:
-            false
-          end
-      end
-    end
-  end
-end

data/lib/rails-settings/scoped_settings.rb

@@ -1,14 +0,0 @@
-class ScopedSettings < Settings
-  def self.for_target(target)
-    @target = target
-    self
-  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,142 +0,0 @@
-class Settings < ActiveRecord::Base
-  class SettingNotFound < RuntimeError; end
-  
-  cattr_accessor :defaults
-  self.defaults = {}.with_indifferent_access
-
-  # cache must follow the contract of ActiveSupport::Cache. Defaults to no-op.
-  cattr_accessor :cache
-  self.cache = ActiveSupport::Cache::NullStore.new
-
-  # options passed to cache.fetch() and cache.write(). example: {:expires_in => 5.minutes}
-  cattr_accessor :cache_options
-  self.cache_options = {}
-
-  def self.cache_key(var_name)
-    [target_id, target_type, var_name].compact.join("::")
-  end
-
-  # Support old plugin
-  if defined?(SettingsDefaults::DEFAULTS)
-    self.defaults = SettingsDefaults::DEFAULTS.with_indifferent_access
-  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
-      cache.delete(cache_key(var_name))
-      true
-    rescue NoMethodError
-      raise SettingNotFound, "Setting variable \"#{var_name}\" not found"
-    end
-  end
-
-  def self.delete_all(conditions = nil)
-    cache.clear
-    super
-  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
-    defaults = @@defaults.select{ |k, v| k =~ /^#{starting_with}/ }
-    defaults = Hash[defaults] if defaults.is_a?(Array)
-    defaults.merge(result).with_indifferent_access
-  end
-  
-  #get a setting value by [] notation
-  def self.[](var_name)
-    cache.fetch(cache_key(var_name), cache_options) do
-      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
-  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!
-    cache.write(cache_key(var_name), value, cache_options)
-    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,252 +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_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_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
-
-  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
-
-class CachedSettingsTest < SettingsTest
-  def setup
-    Settings.cache = ActiveSupport::Cache::MemoryStore.new
-    Settings.cache_options = { :expires_in => 5.minutes }
-    super
-  end
-
-  def test_caching_is_in_place
-    Settings.progress = "boing"
-    Settings.connection.execute("delete from settings")
-    assert_equal "boing", Settings.progress
-    Settings.cache.clear
-    assert_nil Settings.progress
-  end
-
-  def teardown
-    Settings.cache.clear
-    super
-  end
-end