has_setting 0.4.6

data/.gitignore

@@ -0,0 +1,2 @@
+*.sqlite3
+pkg/**

data/README

@@ -0,0 +1,112 @@
+==What is it?
+has_setting is a simple extension that enables ActiveRecord models to
+store settings in a separate settings table as key/value pairs where the key and value are stored as Strings.
+
+==History
+ * 0.4.3:
+   * Changed behaviour of :boolean formatters: Now they treat '0', 0, false, nil and '' as false, everything else as true
+     This is not the same behaviour as ruby (treating only nil and false as false) but should help with input from web forms (i.e. checkboxes)
+     If you want strict ruby boolean behaviour, then use :strict_boolean as :type
+ * 0.4.2:
+   * bug fixes for boolean types default values
+ * 0.3.10:
+   * added boolean and booleans formatters
+ * 0.3.9:
+   * added type :strings, :floats, :ints. They store the contents of an array as a comma separated string. 
+ * 0.3.8:
+   * added dependent destroy option. no more zombie settings lingering around.
+ * 0.3.7: 
+   * Gem is now built using jeweler... after messing around and bumping versions and getting 
+     strange errors, this is 'it works' feeling coming back
+ * 0.3.4: 
+   * Added custom formatter support. no new formatters though...
+ * 0.3.1: 
+   * Bug Fixed: has_many(:settings) is not added to ActiveRecord::Base but only to the classes with has_setting
+   * Bug Fixed: options are not shared between classes
+   * Again changed the way settings are saved. Save is now done on parent.save with an after_save callback. (like this the settings are treated as if they were attributes of the owner)
+ * 0.2.x: 
+   * Added :default option
+   * changed way settings are saved so that unsaved parents can have settings too
+   * changed nameing scheme of setting names (incompatible with versions prior 0.2.x but since nobody uses the gem i dont care :-))
+ * 0.1.x: First Version
+
+
+==Installation
+sudo gem install simplificator-has_setting
+
+==Setup
+ * Add a migration that looks more or less like the one in <em>help/001_create_settings.rb</em>
+ * Make sure the gem is loaded when your application starts
+
+==Config
+The model you want to hold settings (i.e. User, Profile, ...):
+<tt>has_setting(:name_of_the_setting)</tt>
+This will create the following methods for you on the owner class:
+ * <tt>name_of_the_setting=(value)</tt> a standard setter
+ * <tt>name_of_the_setting()</tt> a standard getter (the getter method takes an optional hash to override some options, possible values are the same as the options in has_setting())
+ 
+<tt>has_setting(name, options)</tt> takes an optional hash of options. Following options are supported:
+<em>:type</em> allows you to convert the value:
+  * <em>:string</em> (default) Uses the StringFormatter to convert from/to String (actually this formatter just leaves the value as it is)
+  * <em>:int</em> Uses the IntFormatter to convert from/to int values.
+  * <em>:boolean</em> Uses the BooleanFormatter to convert from/to boolean values; treating 0, '0', false, '' and nil as false.
+  * <em>:strict_boolean</em> Uses the StrictBooleanFormatter to convert from/to boolean values; treating false, and nil as false.
+  * <em>:float</em> Uses the FloatFormatter to convert from/to float values.
+  * <em>:ints</em> Uses the IntsFormatter to convert from/to int[]
+  * <em>:floats</em> Uses the FloatsFormatter to convert from/to float[]
+  * <em>:strings</em> Uses the StringsFormatter to convert from/to string[]
+  * <em>:booleans</em> Uses the BooleansFormatter to convert from/to boolean[]
+  * <em>:strict_booleans</em> Uses the BooleansFormatter to convert from/to boolean[]
+<em>:default</em> allows you to specify a default value that will be returned if the setting does not exist (i.e. has never been written). Note that the default value is _ignored_ if the setting exists, no matter what the value of the setting is. The default value is returned as is, no type conversion takes place.
+
+
+
+==How it works
+A polymorphic parent-child relation is created between Setting and the parent/owning class.
+Getters/setters are added through meta-programming-magic. If the setter is invoked on a unsafed parent then the setting is not saved until the parent is saved, else setting is saved upon creation (i.e. first time the setter is called) / change (subsequent calls).
+The getters/setters can be used in standard AR validations, Rails mass assignments/form helpers and so on.
+
+==Gotchas
+ * Values are stored as Strings in the DB. Values are converted with one of the formatters (depending on selected :type). If you try to store an unsupported type or anything other than the type you selected there might be an exception (i.e. if you try to store "foobar" as an :type => :int)
+ * Currently there are no length validations on the 'name' and 'value' column of Setting. Take care not to store values to big. Especially when using the array formatters (:floats, :ints, :strings)
+ 
+ 
+==Example
+<code>
+class Foo < ActiveRecord::Base
+  has_setting(:string_setting)
+  has_setting(:another_string_setting, :type => :string)
+  has_setting(:int_setting, :type => :int)
+  has_setting(:float_setting, :type => :float, :default => 3.3)
+end
+
+
+foo = Foo.create
+
+foo.string_setting
+=> nil
+foo.string_setting= 'a string'
+foo.string_setting
+=> 'a string'
+
+foo.int_setting = 123
+foo.int_setting
+=> 123
+foo.int_setting = '123'
+foo.int_setting
+=> 123
+
+foo.float_setting
+=> 3.3
+foo.float_setting = nil
+foo.float_setting
+=> nil
+
+</code>
+
+   
+==Todo
+has_setting should stay as simple as possible... still some ideas are around:
+ * Custom formatter (to convert arbitrary objects, i.e. Date/Time/DateTime...)
+ * Add validation options
+

data/Rakefile

@@ -0,0 +1,20 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = false
+end
+
+# require 'rake/rdoctask'
+# Rake::RDocTask.new do |rdoc|
+#   rdoc.rdoc_dir = 'rdoc'
+#   rdoc.title = 'has_setting'
+#   rdoc.options << '--line-numbers' << '--inline-source'
+#   rdoc.rdoc_files.include('README*')
+#   rdoc.rdoc_files.include('lib/**/*.rb')
+# end
+
+task :default => :test

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 4
+:patch: 3
+:major: 0

data/has_setting.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path('../lib/has_setting/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Simplificator GmbH", "Nico Ritsche"]
+  gem.email         = ['info@simplificator.com', "ncrdevmail@gmail.com"]
+  gem.description   = %q{Stores settings as key/value pairs in a settings table and provides accessors for them on the owning object}
+  gem.summary       = %q{Simple setting extension to AR}
+  gem.homepage      = "http://github.com/ncri/has_setting"
+
+  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.name          = "has_setting"
+  gem.require_paths = ["lib"]
+  gem.version       = HasSetting::VERSION
+  gem.has_rdoc      = true
+  gem.rdoc_options  = ["--charset=UTF-8"]
+  gem.test_files    = [
+    "test/bar.rb",
+    "test/baz.rb",
+    "test/foo.rb",
+    "test/test_helper.rb",
+    "test/unit/formatters_test.rb",
+    "test/unit/has_setting_test.rb"
+  ]
+
+end

data/help/001_create_settings.rb

@@ -0,0 +1,15 @@
+class CreateSettings < ActiveRecord::Migration
+  def self.up
+     create_table :settings do |t|
+       t.string(:owner_type,        :null => false)
+       t.integer(:owner_id,         :null => false)
+       t.string(:name,              :null => false,   :length => 64)
+       t.string(:value,             :null => true,    :length => 255)
+       t.timestamps
+      end
+  end
+
+  def self.down
+    drop_table(:settings)
+  end
+end

data/lib/has_setting/ar_extensions.rb

@@ -0,0 +1,70 @@
+module HasSetting
+  
+  module InstanceMethods
+    def write_setting(name, value)
+      # find an existing setting or build a new one
+      setting = self.settings.detect() {|item| item.name == name }
+      setting = self.settings.build(:name => name) if setting.blank?
+      setting.value = value
+    end
+    
+    def read_setting(name)
+      # use detect instead of SQL find. like this the 'cached' has_many-collection is inited 
+      # only once
+      self.settings.detect() {|item| item.name == name }
+    end
+  end
+  
+  module ClassMethods
+    # Setup of the getter/setter
+    def has_setting(name, options = {})
+      name = name.to_s
+      raise ArgumentError.new('Setting name must not be blank') if name.blank?
+      
+      self.class_eval do
+        unless @has_setting_options # define only once
+          # AR association to settings
+          has_many( :settings, :as => :owner, :class_name => 'HasSetting::Setting', 
+                    :foreign_key => :owner_id, :dependent => :destroy)
+          after_save(:save_has_setting_association)
+          @has_setting_options = {}
+          def self.has_setting_options
+            @has_setting_options
+          end
+          
+          private
+          # Callback to save settings
+          def save_has_setting_association
+            self.settings.each do |setting|
+              setting.save if setting.changed?
+            end
+          end
+        end
+      end
+      
+      
+      raise ArgumentError.new("Setting #{name }is already defined on #{self.name}") if self.has_setting_options.has_key?(name)
+      
+      # default options
+      options[:type] ||= :string    # treat as string
+        # default could be false, thats why we use has_key?
+      options[:default] = options.has_key?(:default) ? options[:default] : nil # no default
+      self.has_setting_options[name] = options
+      
+      # setter
+      define_method("#{name}=".intern) do |value|
+        formatter = HasSetting::Formatters.for_type(options[:type])
+        write_setting(name, formatter.to_s(value))
+      end
+      
+      # getter
+      define_method(name) do |*args|
+        setting = read_setting(name)
+        options = args.first || self.class.has_setting_options[name]
+        return options[:default] if setting.nil? 
+        formatter = Formatters.for_type(options[:type])
+        formatter.to_type(setting.value)
+      end
+    end
+  end
+end

data/lib/has_setting/formatters.rb

@@ -0,0 +1,140 @@
+module HasSetting
+  module Formatters
+    @@formatters = {}
+    #
+    # register a formatter:
+    #  * type: a Symbol that is used to identify this formatter in the has_setting options hash via the :type option
+    #  * formatter: the formatter, an object which supports to_type and to_s methods
+    def self.register_formatter(type, formatter)
+      if !formatter.respond_to?(:to_s) || !formatter.respond_to?(:to_type)
+        raise ArgumentError.new('Formatter does not support to_s/to_type')
+      end
+      @@formatters[type] = formatter
+    end
+    
+    # Lookup a Formatter by type symbol
+    # raises ArgumentError if the formatter is not found
+    def self.for_type(type)
+      formatter = @@formatters[type]
+      raise ArgumentError.new("Can not find a formatter for #{type}") unless formatter
+      formatter
+    end    
+    
+    # Helper class which handles nil values
+    class NilSafeFormatter
+      # Converts the String from DB to the specified type
+      # Nil is returned for nil values
+      def to_type(value)
+        safe_to_type(value) unless value == nil
+      end
+      # Converts the value to String for storing in DB
+      # Nil is returned for nil values
+      def to_s(value)
+        safe_to_s(value) unless value == nil
+      end
+    end
+    
+    # Formatter for Strings
+    class StringFormatter < NilSafeFormatter
+      def safe_to_type(value)
+        value
+      end
+      def safe_to_s(value)
+        value.to_s
+      end
+    end
+    # Convert a Boolean to String and Back
+    # nil, '0', false, 0 and '' are considered __false__, everything else is __true__
+    # This is not like ruby where only nil and false are considered __false__
+    class BooleanFormatter < NilSafeFormatter
+      def safe_to_type(value)
+        value == '1'
+      end
+      def safe_to_s(value)
+        value && value != '0' && value != 0 && value != '' ? '1' : '0'
+      end
+    end
+    class BooleansFormatter < NilSafeFormatter
+      def safe_to_type(value)
+        value.split(',').map() {|item| Formatters.for_type(:boolean).to_type(item)}
+      end
+      def safe_to_s(value)
+        Array(value).map() {|item| Formatters.for_type(:boolean).to_s(item)}.join(',')
+      end
+    end
+    
+    class StrictBooleanFormatter < NilSafeFormatter
+      def safe_to_type(value)
+        value == '1'
+      end
+      def safe_to_s(value)
+        value ? '1' : '0'
+      end
+    end
+    class StrictBooleansFormatter < NilSafeFormatter
+      def safe_to_type(value)
+        value.split(',').map() {|item| Formatters.for_type(:strict_boolean).to_type(item)}
+      end
+      def safe_to_s(value)
+        Array(value).map() {|item| Formatters.for_type(:strict_boolean).to_s(item)}.join(',')
+      end
+    end
+    
+    class IntsFormatter < NilSafeFormatter
+      def safe_to_type(value)
+        value.split(',').map() {|item| Formatters.for_type(:int).to_type(item)}
+      end
+      def safe_to_s(value)
+        Array(value).map() {|item| Formatters.for_type(:int).to_s(item)}.join(',')
+      end
+    end
+    
+    class FloatsFormatter < NilSafeFormatter
+      def safe_to_type(value)
+        value.split(',').map() {|item| Formatters.for_type(:float).to_type(item)}
+      end
+      def safe_to_s(value)
+        Array(value).map() {|item| Formatters.for_type(:float).to_s(item)}.join(',')
+      end
+    end
+    
+    class StringsFormatter < NilSafeFormatter
+      def safe_to_type(value)
+        # Ruby does not know "negative look before". Or i dont know how to do it in ruby. Thus
+        # i ended up using some reverse calls... ugly. Anyone out there eager to help me out?
+        value.reverse.split(/,(?!\\)/).map() {|item| item.reverse.gsub('\,', ',')}.reverse
+      end
+      def safe_to_s(value)
+        # Escape the separator character ',' with a backslash
+        Array(value).map() {|item| item.gsub(',', '\,')}.join(',')
+      end
+    end
+    
+    
+    # Formatter for ints
+    # Throws ArgumentError if value can not be converted
+    class IntFormatter < NilSafeFormatter
+      # Integer() does not treat "2.6" the same as 2.6
+      # while 2.6 is a valid Intger() (-> 2), "2.6" is not.
+      # Note that "2" is a valid argument for Integer() and that "".to_i is valid 
+      # while Integer('') is not...
+      # Circumvent this by first convert with Float() so everything obeys to the same rules
+      def safe_to_type(value)
+        Integer(Float(value))
+      end
+      def safe_to_s(value)
+        Integer(Float(value)).to_s
+      end
+    end
+    # Formatter for float values
+    # Throws ArgumentError if value can not be converted
+    class FloatFormatter < NilSafeFormatter
+      def safe_to_type(value)
+        Float(value)
+      end
+      def safe_to_s(value)
+        Float(value).to_s
+      end
+    end
+  end
+end

data/lib/has_setting/setting.rb

@@ -0,0 +1,7 @@
+# ActiveRecord model to store key/value pairs (though the
+# columns are called name/value to avoid upsetting a Database for using a 
+# keyword as column name)
+#
+class HasSetting::Setting < ActiveRecord::Base
+  belongs_to(:owner, :polymorphic => true)
+end

data/lib/has_setting/version.rb

@@ -0,0 +1,3 @@
+module HasSetting
+  VERSION = "0.4.6"
+end

data/lib/has_setting.rb

@@ -0,0 +1,20 @@
+# Intialize the gem by including some extension to ActiveRecord::Base
+require File.dirname(__FILE__) + '/has_setting/ar_extensions'
+require File.dirname(__FILE__) + '/has_setting/formatters'
+require File.dirname(__FILE__) + '/has_setting/setting'
+ActiveRecord::Base.class_eval do
+  include(HasSetting::InstanceMethods)
+  extend(HasSetting::ClassMethods)
+end
+
+
+HasSetting::Formatters.register_formatter(:string, HasSetting::Formatters::StringFormatter.new)
+HasSetting::Formatters.register_formatter(:strings, HasSetting::Formatters::StringsFormatter.new)
+HasSetting::Formatters.register_formatter(:float, HasSetting::Formatters::FloatFormatter.new)
+HasSetting::Formatters.register_formatter(:floats, HasSetting::Formatters::FloatsFormatter.new)
+HasSetting::Formatters.register_formatter(:int, HasSetting::Formatters::IntFormatter.new)
+HasSetting::Formatters.register_formatter(:ints, HasSetting::Formatters::IntsFormatter.new)
+HasSetting::Formatters.register_formatter(:boolean, HasSetting::Formatters::BooleanFormatter.new)
+HasSetting::Formatters.register_formatter(:booleans, HasSetting::Formatters::BooleansFormatter.new)
+HasSetting::Formatters.register_formatter(:strict_boolean, HasSetting::Formatters::StrictBooleanFormatter.new)
+HasSetting::Formatters.register_formatter(:strict_booleans, HasSetting::Formatters::StrictBooleansFormatter.new)

data/test/bar.rb

@@ -0,0 +1,4 @@
+class Bar < ActiveRecord::Base
+  has_setting(:setting_1)
+  has_setting(:setting_2, :type => :int)
+end

data/test/baz.rb

@@ -0,0 +1,2 @@
+class Baz < ActiveRecord::Base
+end

data/test/foo.rb

@@ -0,0 +1,8 @@
+class Foo < ActiveRecord::Base
+  has_setting(:setting_1)
+  has_setting(:setting_2, :type => :float)
+  has_setting(:with_default, :default => 'def')
+  
+  has_setting(:setting_3, :type => :boolean)
+  has_setting(:setting_4, :type => :boolean, :default => false)
+end

data/test/test_helper.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'active_record'
+require 'test/unit'
+
+require File.dirname(__FILE__) + '/../lib/has_setting'
+
+
+ActiveRecord::Base.establish_connection(  
+  :adapter  => 'sqlite3',   
+  :database => 'test.sqlite3',   
+  :timeout => 5000
+)
+
+ActiveRecord::Base.connection.drop_table(:settings) rescue ActiveRecord::StatementInvalid
+[:foos, :bars, :bazs].each do |table|
+  ActiveRecord::Base.connection.drop_table(table) rescue ActiveRecord::StatementInvalid
+end
+
+
+
+ActiveRecord::Base.connection.create_table(:settings) do |table|
+  table.string(:value,      :limit => 255)
+  table.string(:name,       :limit => 64,     :null => false)
+  table.string(:owner_type, :limit => 255,    :null => false)
+  table.integer(:owner_id,                    :null => false)
+end
+[:foos, :bars, :bazs].each do |table|
+  ActiveRecord::Base.connection.create_table(table) do |t|
+  end
+end
+ActiveRecord::Base.logger = Logger.new(STDOUT)
+ActiveRecord::Base.logger.level = Logger::DEBUG # change to DEBUG if you want to see something :-)
+
+require File.join(File.dirname(__FILE__), 'foo')
+require File.join(File.dirname(__FILE__), 'bar')
+require File.join(File.dirname(__FILE__), 'baz')

data/test/unit/formatters_test.rb

@@ -0,0 +1,183 @@
+require File.dirname(__FILE__) + '/../test_helper'
+include HasSetting
+class FormattersTest < Test::Unit::TestCase
+  def test_for_type
+    [:string, :float, :floats, :int, :ints, :strings, :boolean, :booleans, :strict_boolean, :strict_booleans].each do |symbol|
+      assert(Formatters.for_type(symbol), "No formatter for #{symbol}")
+      if symbol == :strict_boolean
+        assert_equal(Formatters.for_type(symbol).class.to_s, "HasSetting::Formatters::StrictBooleanFormatter")
+      elsif symbol == :strict_booleans
+        assert_equal(Formatters.for_type(symbol).class.to_s, "HasSetting::Formatters::StrictBooleansFormatter")
+      else
+        assert_equal(Formatters.for_type(symbol).class.to_s, "HasSetting::Formatters::#{symbol.to_s.capitalize}Formatter")
+      end
+    end
+    assert_raises(ArgumentError) do
+      Formatters.for_type(:rarararararara_i_do_not_exist)
+    end
+  end
+  
+  def test_strings_formatter
+    f = Formatters::StringsFormatter.new
+    assert_equal(nil, f.to_s(nil))
+    assert_equal('bla', f.to_s('bla'))
+    assert_equal('bla', f.to_s(['bla']))
+    assert_equal('bla,bli', f.to_s(['bla', 'bli']))
+    assert_equal('\,schni\,schna\,,bli,\,bla', f.to_s([',schni,schna,', 'bli', ',bla']))
+    assert_equal('\,\,\,\,,\,\,\,,\,\,,\,', f.to_s([',,,,', ',,,', ',,', ',']))
+    
+    assert_equal(nil, f.to_type(nil))
+    assert_equal([], f.to_type(''))
+    assert_equal(['bli'], f.to_type('bli'))
+    assert_equal(['bli','', 'bla'], f.to_type('bli,,bla'))
+    assert_equal([',schni,schna,', 'bli', ',bla'], f.to_type('\,schni\,schna\,,bli,\,bla'))
+    assert_equal([',,,,', ',,,', ',,', ','], f.to_type('\,\,\,\,,\,\,\,,\,\,,\,'))
+  end
+  
+
+  def test_string_formatter()
+    f = Formatters::StringFormatter.new
+    assert_equal('', f.to_s(''))
+    assert_equal('a', f.to_s('a'))
+    assert_equal('', f.to_type(''))
+    assert_equal('a', f.to_type('a'))
+  end
+  
+  def test_boolean_formatter
+    f = Formatters::BooleanFormatter.new
+    assert_equal('0', f.to_s(''))
+    assert_equal('1', f.to_s(true))
+    assert_equal('0', f.to_s(false))
+    assert_equal('0', f.to_s('0'))
+    assert_equal('0', f.to_s(0))
+    assert_equal('0', f.to_s(''))
+    assert_equal(nil, f.to_s(nil))
+    
+    assert_equal(true, f.to_type('1'))
+    assert_equal(false, f.to_type('0'))
+    assert_equal(nil, f.to_type(nil))
+  end
+  
+  def test_strict_boolean_formatter
+    f = Formatters::StrictBooleanFormatter.new
+    assert_equal('1', f.to_s(''))
+    assert_equal('1', f.to_s(true))
+    assert_equal('0', f.to_s(false))
+    assert_equal('1', f.to_s('0'))
+    assert_equal(nil, f.to_s(nil))
+    
+    assert_equal(true, f.to_type('1'))
+    assert_equal(false, f.to_type('0'))
+    assert_equal(nil, f.to_type(nil))
+  end
+  def test_int_formatter()
+    f = Formatters::IntFormatter.new
+    assert_raises(ArgumentError) do 
+      f.to_s('')
+    end
+    assert_raises(ArgumentError) do 
+      f.to_s('asas')
+    end
+    assert_nil(f.to_s(nil))
+    assert_equal('2', f.to_s(2.6))
+    assert_equal('2', f.to_s(2))
+    
+    assert_raises(ArgumentError) do 
+      f.to_type('')
+    end
+    assert_raises(ArgumentError) do 
+      f.to_type('asas')
+    end
+    assert_nil(f.to_type(nil))
+    assert_equal(2, f.to_type('2'))
+    assert_equal(2, f.to_type('2.6'))
+    assert_equal(2, f.to_type(' 2.6 '))
+  end  
+  
+  def test_float_formatter()
+    f = Formatters::FloatFormatter.new
+    assert_raises(ArgumentError) do 
+      f.to_s('')
+    end
+    assert_raises(ArgumentError) do 
+      f.to_s('asas')
+    end
+    assert_nil(f.to_s(nil))
+    assert_equal('2.6', f.to_s(2.6))
+    assert_equal('2.0', f.to_s(2))
+    
+    assert_raises(ArgumentError) do 
+      f.to_type('')
+    end
+    assert_raises(ArgumentError) do 
+      f.to_type('asas')
+    end
+    assert_nil(f.to_type(nil))
+    assert_equal(2.0, f.to_type('2'))
+    assert_equal(2.6, f.to_type('2.6'))
+  end  
+  
+  def test_ints_formatter
+    f = Formatters::IntsFormatter.new
+    assert_equal(nil, f.to_s(nil))
+    assert_equal('1', f.to_s(1))
+    assert_equal('1', f.to_s([1]))
+    assert_equal('1,2', f.to_s([1,2]))
+    
+    assert_equal(nil, f.to_type(nil))
+    assert_equal([], f.to_type(''))
+    assert_equal([1], f.to_type('1'))
+    assert_equal([1,2], f.to_type('1,2'))
+  end
+  def test_floats_formatter
+    f = Formatters::FloatsFormatter.new
+    assert_equal(nil, f.to_s(nil))
+    assert_equal('1.2', f.to_s(1.2))
+    assert_equal('1.2', f.to_s([1.2]))
+    assert_equal('1.2,1.3', f.to_s([1.2,1.3]))
+    
+    assert_equal(nil, f.to_type(nil))
+    assert_equal([], f.to_type(''))
+    assert_equal([1.2], f.to_type('1.2'))
+    assert_equal([1.2,1.3], f.to_type('1.2,1.3'))
+    assert_equal([1.2,1.3], f.to_type('1.2, 1.3'))
+  end
+  def test_booleans_formatter
+    f = Formatters::BooleansFormatter.new
+    assert_equal(nil, f.to_s(nil))
+    assert_equal('1', f.to_s(true))
+    assert_equal('1', f.to_s([true]))
+    assert_equal('1,0', f.to_s([true,false]))
+    assert_equal('0,0,0,0,', f.to_s(['', 0, false, '0', nil]))
+    
+    assert_equal(nil, f.to_type(nil))
+    assert_equal([], f.to_type(''))
+    assert_equal([true], f.to_type('1'))
+    assert_equal([true, false], f.to_type('1,0'))
+    
+    
+    # test boolean with values != true|false
+    assert_equal('1', f.to_s('true'))
+    assert_equal('1', f.to_s(555))
+  end
+  
+  
+  def test_strict_booleans_formatter
+    f = Formatters::StrictBooleansFormatter.new
+    assert_equal(nil, f.to_s(nil))
+    assert_equal('1', f.to_s(true))
+    assert_equal('1', f.to_s([true]))
+    assert_equal('1,0', f.to_s([true,false]))
+    assert_equal('1,1', f.to_s([1,0]))
+    
+    assert_equal(nil, f.to_type(nil))
+    assert_equal([], f.to_type(''))
+    assert_equal([true], f.to_type('1'))
+    assert_equal([true, false], f.to_type('1,0'))
+    
+    
+    # test boolean with values != true|false
+    assert_equal('1', f.to_s('true'))
+    assert_equal('1', f.to_s(555))
+  end
+end

data/test/unit/has_setting_test.rb

@@ -0,0 +1,148 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class HasSettingTest < Test::Unit::TestCase
+  def setup()
+    @foo = Foo.create!
+    @bar = Bar.create!
+    @baz = Baz.create!
+  end
+  
+  
+  def test_setting_has_accessors
+    assert @foo.respond_to?(:setting_1)
+    assert @foo.respond_to?(:setting_1=)
+  end
+  
+  
+  def test_has_many
+    assert @foo.respond_to?(:settings)
+    assert @foo.settings.is_a?(Array)
+  end
+  
+  def test_settings_are_destroyed
+    count_before = HasSetting::Setting.count
+    @foo.setting_1 = 10
+    @foo.save!
+    assert_equal(count_before + 1, HasSetting::Setting.count)
+    @foo.destroy
+    assert_equal(count_before, HasSetting::Setting.count)
+    
+  end
+  
+  def test_write_setting
+    count_before = HasSetting::Setting.count
+    @foo.write_setting('name', 'value1')
+    @foo.save!
+    assert_equal(count_before + 1, HasSetting::Setting.count)
+    setting = @foo.read_setting('name')
+    assert setting
+    assert_equal('value1', setting.value)
+    
+    @foo.write_setting('name', 'value2')
+    assert_equal(count_before + 1, HasSetting::Setting.count) 
+    setting = @foo.read_setting('name')
+    assert setting
+    assert_equal('value2', setting.value)
+  end
+  
+  def test_setting_accessors
+    count_before = HasSetting::Setting.count
+    assert(!@foo.setting_1)
+    @foo.setting_1 = 'bli'
+    @foo.save!
+    assert_equal(count_before + 1, HasSetting::Setting.count)
+    assert_equal('bli', @foo.setting_1)
+    @foo.setting_1 = 'bla'
+    assert_equal('bla', @foo.setting_1)
+  end
+  
+  def test_different_classes_do_not_share_setting
+    count_before = HasSetting::Setting.count
+    @foo.setting_1 = 'foo'
+    @foo.save!
+    @bar.setting_1 = 'bar'
+    @bar.save!
+    assert_equal(count_before + 2, HasSetting::Setting.count)
+    
+    assert_equal('foo', @foo.setting_1)
+    assert_equal('bar', @bar.setting_1)
+  end
+
+  
+  def test_has_nil_setting
+    @foo.setting_1 = nil
+    assert(@foo.read_setting('setting_1'))
+    assert(!@foo.setting_1)
+  end
+  
+  def test_options_on_getter
+    @foo.setting_1 = '12.3'
+    assert_equal('12.3', @foo.setting_1)
+    assert_equal(12, @foo.setting_1(:type => :int))
+    assert_equal(12.3, @foo.setting_1(:type => :float))
+    
+    # Foo.setting_2 is a float setting. Override and get as string
+    @foo.setting_2 = 12.3
+    assert_equal('12.3', @foo.setting_2(:type => :string))
+  end
+  
+  def test_different_classes_do_not_share_options()
+    @foo.setting_2 = 12.3
+    assert_equal(12.3, @foo.setting_2)
+    @bar.setting_2 = 12.3
+    assert_equal(12, @bar.setting_2)
+  end
+  
+  def test_default_values()
+    assert_equal('def', @foo.with_default)
+    assert_equal('override def', @foo.with_default(:default => 'override def'))
+    @foo.with_default = 'not def'
+    assert_equal('not def', @foo.with_default)
+  end
+  
+  def test_write_settings_without_saved_parent
+    my_foo = Foo.new
+    count_before = HasSetting::Setting.count
+    my_foo.with_default = 'radabumm'
+    assert_equal(count_before, HasSetting::Setting.count)
+    assert_equal('radabumm', my_foo.with_default)
+    my_foo.save!
+    assert_equal(count_before + 1, HasSetting::Setting.count)
+    assert_equal('radabumm', my_foo.with_default)
+  end
+  
+  def test_not_everyone_has_settings_association
+    assert_equal(true, @foo.respond_to?(:settings))
+    assert_equal(true, @bar.respond_to?(:settings))
+    assert_equal(false, @baz.respond_to?(:settings))
+  end
+  
+  
+  def test_boolean_setting_without_default
+    assert_equal nil, @foo.setting_3
+    @foo.setting_3 = true
+    @foo.save!
+    
+    @foo = Foo.find @foo.id
+    assert_equal true, @foo.setting_3
+  end
+  def test_boolean_setting_with_default
+    assert_equal false, @foo.setting_4
+    @foo.setting_4 = true
+    @foo.save!
+    @foo = Foo.find @foo.id
+    assert_equal true, @foo.setting_4
+  end
+  
+  def test_boolean_setting_with_default_and_no_saving
+    assert_equal false, @foo.setting_4
+    @foo.setting_4 = true
+    assert_equal true, @foo.setting_4
+    @foo.setting_4 = nil
+    assert_equal nil, @foo.setting_4
+    @foo.setting_4 = false
+    assert_equal false, @foo.setting_4
+  end
+  
+  
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: has_setting
+version: !ruby/object:Gem::Version
+  version: 0.4.6
+  prerelease: 
+platform: ruby
+authors:
+- Simplificator GmbH
+- Nico Ritsche
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-10 00:00:00.000000000 Z
+dependencies: []
+description: Stores settings as key/value pairs in a settings table and provides accessors
+  for them on the owning object
+email:
+- info@simplificator.com
+- ncrdevmail@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- README
+- Rakefile
+- VERSION.yml
+- has_setting.gemspec
+- help/001_create_settings.rb
+- lib/has_setting.rb
+- lib/has_setting/ar_extensions.rb
+- lib/has_setting/formatters.rb
+- lib/has_setting/setting.rb
+- lib/has_setting/version.rb
+- test/bar.rb
+- test/baz.rb
+- test/foo.rb
+- test/test_helper.rb
+- test/unit/formatters_test.rb
+- test/unit/has_setting_test.rb
+homepage: http://github.com/ncri/has_setting
+licenses: []
+post_install_message: 
+rdoc_options:
+- --charset=UTF-8
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Simple setting extension to AR
+test_files:
+- test/bar.rb
+- test/baz.rb
+- test/foo.rb
+- test/test_helper.rb
+- test/unit/formatters_test.rb
+- test/unit/has_setting_test.rb
+has_rdoc: true