simplificator-has_setting 0.2.0 → 0.3.6

data/VERSION.yml

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

data/lib/has_setting.rb

@@ -1,7 +1,13 @@
-# Intialises the gem by including some extension to ActiveRecord::Base
+# 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
+end
+
+
+HasSetting::Formatters.register_formatter(:string, HasSetting::Formatters::StringFormatter.new)
+HasSetting::Formatters.register_formatter(:float, HasSetting::Formatters::FloatFormatter.new)
+HasSetting::Formatters.register_formatter(:int, HasSetting::Formatters::IntFormatter.new)

data/lib/has_setting/ar_extensions.rb

@@ -1,17 +1,11 @@
 module HasSetting
+  
   module InstanceMethods
     def write_setting(name, value)
       # find an existing setting or build a new one
-      setting = self.settings.find_by_name(name)
+      setting = self.settings.detect() {|item| item.name == name }
       setting = self.settings.build(:name => name) if setting.blank?
       setting.value = value
-      # save only if parent has been saved. else we expect a parent.save call
-      # which will cascade to the children since they were created with build()
-      unless self.new_record?
-        setting.save
-        # reload collection so the read_setting() finds the settings with 'detect()'
-        self.settings.reload
-      end
     end
     
     def read_setting(name)
@@ -22,45 +16,61 @@ module HasSetting
   end
   
   module ClassMethods
-    def self.extended(extender)
-      extender.class_eval do
-        # AR association to settings
-        has_many(:settings, :as => :owner, :class_name => 'HasSetting::Setting', :foreign_key => :owner_id)
-        # a hash where we can store options for the settings
-        write_inheritable_attribute(:has_setting_options, {})
-        class_inheritable_reader(:has_setting_options)
-      end
-    end
-    
-
-    
-    #
     # 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?
-      # default settings
+      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)
+          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|
+              if setting.changed?
+                setting.save
+              end
+            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
       options[:default] ||= nil     # no default value
-      has_setting_options[name] = options
+      self.has_setting_options[name] = options
       
+      # setter
       define_method("#{name}=".intern) do |value|
-        value = value.nil? ? nil : value.to_s 
-        write_setting(name, value)
+        formatter = HasSetting::Formatters.for_type(options[:type])
+        write_setting(name, formatter.to_s(value))
       end
       
       # getter
-      define_method(name) do |*args| 
+      define_method(name) do |*args|
         setting = read_setting(name)
-        options = args.first || has_setting_options[name]
+        options = args.first || self.class.has_setting_options[name]
         return options[:default] if setting.nil? 
-        
-        case options[:type]
-          when :string : setting.value
-          when :int : setting.value.nil? ? nil : setting.value.to_i
-          when :float : setting.value.nil? ? nil : setting.value.to_f
-          else raise ArgumentError.new("Unsupported type: #{options[:type]}")
-        end
+        formatter = HasSetting::Formatters.for_type(options[:type])
+        formatter.to_type(setting.value)
+        #case options[:type]
+        #  when :string : setting.value
+        #  when :int : setting.value.nil? ? nil : setting.value.to_i
+        #  when :float : setting.value.nil? ? nil : setting.value.to_f
+        #  else raise ArgumentError.new("Unsupported type: #{options[:type]}")
+        #end
       end
     end
   end

data/lib/has_setting/formatters.rb

@@ -0,0 +1,72 @@
+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 to_type(value)
+        value
+      end
+      def safe_to_s(value)
+        value.to_s
+      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

@@ -3,5 +3,5 @@
 # keyword as column name)
 #
 class HasSetting::Setting < ActiveRecord::Base
-  belongs_to(:owner, :polymorphic => true)  
+  belongs_to(:owner, :polymorphic => true)
 end

data/test/baz.rb

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

data/test/test_helper.rb

@@ -12,8 +12,9 @@ ActiveRecord::Base.establish_connection(
 )
 
 ActiveRecord::Base.connection.drop_table(:settings) rescue ActiveRecord::StatementInvalid
-ActiveRecord::Base.connection.drop_table(:foos) rescue ActiveRecord::StatementInvalid
-ActiveRecord::Base.connection.drop_table(:bars) rescue ActiveRecord::StatementInvalid
+[:foos, :bars, :bazs].each do |table|
+  ActiveRecord::Base.connection.drop_table(table) rescue ActiveRecord::StatementInvalid
+end
 
 
 
@@ -23,13 +24,13 @@ ActiveRecord::Base.connection.create_table(:settings) do |table|
   table.string(:owner_type, :limit => 255,    :null => false)
   table.integer(:owner_id,                    :null => false)
 end
-ActiveRecord::Base.connection.create_table(:foos) do |table|
-end
-ActiveRecord::Base.connection.create_table(:bars) do |table|
+[: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__), 'bar')
+require File.join(File.dirname(__FILE__), 'baz')

data/test/unit/formatters_test.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/../test_helper'
+include HasSetting
+class FormattersTest < Test::Unit::TestCase
+  def test_for_type
+    [:string, :float, :int].each do |symbol|
+      assert(Formatters.for_type(symbol), "No formatter for #{symbol}")
+    end
+    assert_raises(ArgumentError) do
+      Formatters.for_type(:rarararararara_i_do_not_exist)
+    end
+  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_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'))
+  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  
+end

data/test/unit/has_setting_test.rb

@@ -4,9 +4,10 @@ class HasSettingTest < Test::Unit::TestCase
   def setup()
     @foo = Foo.create!
     @bar = Bar.create!
+    @baz = Baz.create!
   end
   
-  def test_setting_has_accessor
+  def test_setting_has_accessors
     assert @foo.respond_to?(:setting_1)
     assert @foo.respond_to?(:setting_1=)
   end
@@ -21,6 +22,7 @@ class HasSettingTest < Test::Unit::TestCase
   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
@@ -37,6 +39,7 @@ class HasSettingTest < Test::Unit::TestCase
     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'
@@ -46,12 +49,15 @@ class HasSettingTest < Test::Unit::TestCase
   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
@@ -95,4 +101,9 @@ class HasSettingTest < Test::Unit::TestCase
     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
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: simplificator-has_setting
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.3.6
 platform: ruby
 authors: 
 - Simplificator GmbH
@@ -9,12 +9,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-01 00:00:00 -08:00
+date: 2009-02-04 00:00:00 -08:00
 default_executable: 
 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
+description: TODO
+email: pascal.betz@simplificator.com
 executables: []
 
 extensions: []
@@ -22,19 +22,26 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/has_setting.rb
+- VERSION.yml
+- lib/has_setting
 - lib/has_setting/ar_extensions.rb
+- lib/has_setting/formatters.rb
 - lib/has_setting/setting.rb
+- lib/has_setting.rb
 - test/bar.rb
+- test/baz.rb
 - test/foo.rb
 - test/test_helper.rb
+- test/unit
+- test/unit/formatters_test.rb
 - test/unit/has_setting_test.rb
-- README.rdoc
-has_rdoc: false
-homepage: http://simplificator.com/en/lab
+- test/unit/test.sqlite3
+has_rdoc: true
+homepage: http://github.com/pascalbetz/has_setting
 post_install_message: 
-rdoc_options: []
-
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -55,6 +62,6 @@ rubyforge_project:
 rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
-summary: Basic Setting/Properties for ActiveRecord models
+summary: TODO
 test_files: []