serial_preference 0.2.2 → 1.0.0

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+spec/*.log

data/.rspec

@@ -0,0 +1 @@
+-c

data/Gemfile

@@ -2,3 +2,5 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in serial_preference.gemspec
 gemspec
+
+gem 'debugger'

data/README.md

@@ -36,38 +36,47 @@ Or install it yourself as:
 ````ruby
     class Company < ActiveRecord::Base
 
-      include HasPreferenceMap
+      include SerialPreference::HasSerialPreferences
 
-      preference_map :preferences do
+      preferences do
 
-        preference :taxable data_type: :boolean, required: true, label: "Taxable?", hint: "Is this business taxable?"
-        preference :vat_no required: false, label: "VAT"
+        preference :taxable data_type: :boolean, required: true
+        preference :vat_no required: false
         preference :max_invoice_items data_type: :integer
 
+        float :rate_of_interest
+
         # default data type is :string
-        # default label is name of preference titleized
         # if the preference is required, then a validation is added to the model
         # if the data type is numerical, then a numericality validation is added
         # preferences can be grouped in preference groups
 
-        preference_group :ledgers, label: "Preferred Ledgers" do
+        preference_group "Preferred Ledgers" do
           income_ledger_id data_type: :integer, default: 1
         end
 
-        # Let me know what you think of this experimental new DSL?
+        password field_type: :password
 
-        + :name_of_preference, data_type: :string
-        + :name_of_another_preference, default: "Hello"
+      end
 
-        * :name_of_preference_group, label: "Notifications" do
-          + :email_delivery, data_type: :boolean, default: true
-        end
+    end
+````
 
-      end
+* Fetching Preference/Groups
 
+````ruby
+    # something you can customize in your form perhaps?
+    Company.preference_groups.each do |pg| # => returns an array of preference groups
+      # pg.name => Name of Preference Group as specified in map e.g. Preferred Ledgers
+      # pg.preferences => Hash of Preference Definitions keyed by Preference Name e.g. :taxable, :vat_no etc.
+      pg.preferences.values.each do |preference|
+        # preference => PreferenceDefinition
+        f.input preference.name, required: preference.required?, placeholder: preference.default, as: preference.field_type
+      end
     end
 ````
 
+
 ## Contributing
 
 1. Fork it

data/Rakefile

@@ -1 +1,7 @@
+#!/usr/bin/env rake
 require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/serial_preference/has_preference_map.rb

@@ -1,78 +1,67 @@
-module HasPreferenceMap
-  extend ActiveSupport::Concern
+module SerialPreference
+  module HasSerialPreferences
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :_preferences_attribute
+      self._preferences_attribute = :preferences
+      class_attribute :_preference_map
+      self._preference_map = SerialPreference::Preferenzer.new
+    end
 
-  included do
-    class_attribute :preference_context
-    class_attribute :preference_storage_attribute
-    self.preference_storage_attribute = :preferences
-    self.preference_context = "#{preference_storage_attribute}_#{table_name.downcase}".to_sym
-  end
+    module ClassMethods
 
-  def default_preference_for(name)
-    self.class.default_preference_for(name)
-  end
+      def preference_groups
+        _preference_map.preference_groups
+      end
 
-  def preferences_for(group_name)
-    send(preference_storage_attribute).slice(*self.class.preferences_for(group_name))
-  end
+      def preferences(storage_attribute = nil, &block)
+        self._preferences_attribute = storage_attribute || self._preferences_attribute
+        _preference_map.draw(&block)
+        build_preference_definitions
+      end
 
-  def preference_map
-    SerialPreference::Preferenzer.preferences_for(self.class.preference_context)
-  end
+      private
 
-  module ClassMethods
+      def build_preference_definitions
+        serialize self._preferences_attribute, Hash
 
-    def preference_groups
-      SerialPreference::Preferenzer.group_for(preference_context).try(:values) || []
-    end
+        _preference_map.all_preference_definitions.each do |preference|
 
-    def preferences_for(group_name)
-      SerialPreference::Preferenzer.group_for(preference_context)[group_name].try(:preference_keys) || []
-    end
+          key = preference.name
+          define_method("#{key}=") do |value|
+            write_preference_attribute(_preferences_attribute,key,preference.value(value))
+          end
 
-    def preference_map(store_attribute = nil, &block)
-      self.preference_storage_attribute = store_attribute || preference_storage_attribute
-      self.preference_context = "#{preference_storage_attribute}_#{table_name.downcase}".to_sym
-      SerialPreference::Preferenzer.reset(preference_context)
-      preferences = SerialPreference::Preferenzer.draw(preference_context,&block)
+          define_method(key) do
+            value = read_preference_attribute(_preferences_attribute,key)
+            preference.value(value)
+          end
 
-      make_functions(preferences,store_attribute,preference_context)
-    end
+          if preference.boolean?
+            define_method("#{key}?") do
+              read_preference_attribute(_preferences_attribute,key).present?
+            end
+          end
 
-    def default_preference_for(name)
-      SerialPreference::Preferenzer.preference(name,nil,preference_context)
-    end
-
-    private
-
-    def make_functions(preferences,store_attribute,context)
-      serialize store_attribute, Hash
-
-      preferences.each do |preference|
-        key = preference.name
-        define_method("#{key}=") do |value|
-          send(store_attribute)[key] = SerialPreference::Preferenzer.preference(key,value,context)
-          send("#{store_attribute}_will_change!")
         end
+      end
+    end
 
-        define_method(key) do
-          value = send(store_attribute)[key]
-          SerialPreference::Preferenzer.preference(key,value,context)
-        end
+    protected
 
-        opts = {}
-        if preference.required?
-          opts[:presence] = true
-        end
-        if preference.numerical?
-          opts[:numericality] = true
-          opts[:allow_blank] = true unless opts[:presence].present?
-        end
-        validates key, opts if opts.present?
+    def read_preference_attribute(store_attribute, key)
+      attribute = send(store_attribute)
+      attribute[key]
+    end
 
+    def write_preference_attribute(store_attribute, key, value)
+      attribute = send(store_attribute)
+      if value != attribute[key]
+        send :"#{store_attribute}_will_change!"
+        attribute[key] = value
       end
     end
 
   end
-
-end
+end

data/lib/serial_preference/preference_definition.rb

@@ -0,0 +1,83 @@
+module SerialPreference
+  class PreferenceDefinition
+
+    SUPPORTED_TYPES = [:string,:integer,:decimal,:float,:boolean]
+
+    attr_accessor :data_type, :name, :default, :required, :field_type
+
+    def initialize(name,*args)
+      opts = args.extract_options!
+      self.name = name.to_s
+      opts.assert_valid_keys(:data_type,:default,:required,:field_type)
+      self.data_type = @type = opts[:data_type] || :string
+      @column = ActiveRecord::ConnectionAdapters::Column.new(name.to_s,opts[:default],@type.to_s)
+      self.default = opts[:default]
+      self.required = !!opts[:required]
+      self.field_type = opts[:field_type]
+    end
+
+    def name
+      @column.name
+    end
+
+    def default_value
+      @column.default
+    end
+
+    def required?
+      required
+    end
+
+    def numerical?
+      @column.number?
+    end
+
+    def boolean?
+      @column.type == :boolean
+    end
+
+    def type_cast(value)
+      v = @column.type_cast(value)
+      v.nil? ? default_value : v
+    end
+
+    def field_type
+      @field_type || (numerical? ? :string : data_type)
+    end
+
+    def query(value)
+      if !(value = type_cast(value))
+        false
+      elsif numerical?
+        !value.zero?
+      else
+        !value.blank?
+      end
+    end
+
+    def value(v)
+      v = v.nil? ? default : v
+      if !v.nil?
+        case data_type
+        when :string, :password
+          v.to_s
+        when  :integer
+          v.respond_to?(:to_i) ? v.to_i : nil
+        when :float, :real
+          v.respond_to?(:to_f) ? v.to_f : nil
+        when :boolean
+          return false if v == 0
+          return false if v == ""
+          return false if v == nil
+          return false if v.to_s.downcase == "false"
+          return false if v == "0"
+          return false if v.to_s.downcase == "no"
+          !!v
+        else
+          nil
+        end
+      end
+    end
+
+  end
+end

data/lib/serial_preference/preferenzer.rb

@@ -0,0 +1,81 @@
+module SerialPreference
+  class Preferenzer
+    PreferenceGroup = Struct.new(:name,:preferences)
+
+    attr_reader :preference_groups, :current_group
+
+    def initialize
+      @preference_names_cache = HashWithIndifferentAccess.new
+      @preference_groups = []
+      activate_group
+    end
+
+    def draw(&block)
+      instance_exec(&block)
+    end
+
+    def respond_to?(name)
+      [:string, :integer, :boolean, :float].include?(name) || @preference_names_cache[name].present? || super
+    end
+
+    def method_missing(name,*args,&block)
+      preference(name,args.extract_options!)
+    end
+
+    [:string,:integer,:boolean,:float].each do |dt|
+      define_method(dt) do |name,opts = {}|
+        preference(name,opts.merge!(:data_type => dt))
+      end
+    end
+
+    def preference(name,opts = {})
+      Array(name).each do |n|
+        push_preference SerialPreference::PreferenceDefinition.new(n.to_sym,opts)
+      end
+    end
+    alias :pref :preference
+
+    def preference_group(name,&block)
+      activate_group(name)
+      instance_exec(&block)
+    end
+
+    def all_preference_definitions
+      preference_groups.map{|x|x.preferences.values}.flatten
+    end
+
+    def all_preference_names
+      @preference_names_cache.keys
+    end
+
+    def all_groups
+      @preference_groups.map{|x|x.name}
+    end
+
+    private
+
+    def activate_group(group_name = :base)
+      @current_group = find_or_create_group(group_name)
+    end
+
+    def push_preference(preference)
+      @preference_names_cache[preference.name] = 1
+      @current_group.preferences[preference.name] = preference
+    end
+
+    def find_or_create_group(name)
+      find_group(name) || create_group(name)
+    end
+
+    def find_group(name)
+      @preference_groups.find{|x|x.name == name}
+    end
+
+    def create_group(name = :base)
+      PreferenceGroup.new(name,{}).tap do |pg|
+        @preference_groups.push(pg)
+      end
+    end
+
+  end
+end

data/lib/serial_preference/version.rb

@@ -1,3 +1,3 @@
 module SerialPreference
-  VERSION = "0.2.2"
+  VERSION = "1.0.0"
 end

data/lib/serial_preference.rb

@@ -1,100 +1,6 @@
-require 'singleton'
+require 'active_support/all'
+require 'active_record'
 require "serial_preference/version"
-require 'serial_preference/preference'
-require 'serial_preference/preference_group'
+require 'serial_preference/preference_definition'
+require "serial_preference/preferenzer"
 require "serial_preference/has_preference_map"
-
-module SerialPreference
-  class Preferenzer
-
-    include Singleton
-
-    attr_accessor :preference_groups, :current_context
-
-    def self.draw(context = :base, &block)
-      i = instance
-      i.preference_groups ||= {}
-      i.preference_groups[context] ||= {}
-      i.current_context = context
-      i.instance_exec(&block)
-      i.preferences_for(context)
-    end
-
-    def +(name,opts = {})
-      preference(name,opts)
-    end
-
-    def *(name,opts = {},&block)
-      preference_group(name,opts,&block)
-    end
-
-    def reset(context = :base)
-      self.preference_groups.try(:delete,context)
-    end
-
-    def preference(name,opts = {})
-      pg = base_group
-      pg.pref(name,opts)
-    end
-
-    def preference_group(name, opts={},&block)
-      self.preference_groups[current_context] ||= {}
-      self.preference_groups[current_context][name] ||= SerialPreference::PreferenceGroup.new(name,opts)
-      self.preference_groups[current_context][name].instance_exec(&block)
-    end
-
-    def self.method_missing(name,*args,&block)
-      if instance.respond_to?(name)
-        instance.send(name,*args,&block)
-      else
-        super
-      end
-    end
-
-    def all_preference_names(context = :base)
-      group_for(context).values.map do |pg|
-        pg.preferences.map do |pref|
-          pref.name
-        end
-      end.flatten
-    end
-
-    def preferences_for(context = :base)
-      group_for(context).values.map do |pg|
-        pg.preferences.map do |pref|
-          pref
-        end
-      end.flatten
-    end
-
-    def each_preference(context = :base)
-      group_for(context).values.each do |pg|
-        pg.preferences.each do |pref|
-          yield(pref)
-        end
-      end
-    end
-
-    def preference(name,value,context = :base)
-      p = preferences_for(context).find{|x| x.name == name }
-      p ? p.value(value) : nil
-    end
-
-    def group_for(context = :base)
-      preference_groups[context] || {}
-    end
-
-    private
-
-    def base_group
-      @base_group ||= begin
-        pg = SerialPreference::PreferenceGroup.new(:base,:label => current_context.to_s.titleize)
-        self.preference_groups[current_context] ||= {}
-        self.preference_groups[current_context][:base] = pg
-        pg
-      end
-    end
-
-  end
-end
-

data/serial_preference.gemspec

@@ -18,5 +18,10 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
 
   gem.add_runtime_dependency "activesupport", ">= 3.0.0"
+  gem.add_runtime_dependency "activerecord", ">= 3.0.0"
+
+  gem.add_development_dependency 'sqlite3'
+  gem.add_development_dependency 'rspec-rails'
+  gem.add_development_dependency "shoulda"
 
 end

data/spec/database.yml

@@ -0,0 +1,3 @@
+test:
+  adapter: sqlite3
+  database: ":memory:"

data/spec/fixtures/dummy_class.rb

@@ -0,0 +1,12 @@
+class DummyClass < ActiveRecord::Base
+  include SerialPreference::HasSerialPreferences
+  preferences do
+    preference :taxable, data_type: :boolean, required: true
+    preference :required_number, data_type: :integer, required: :true
+    preference :vat_no, required: false
+    preference :max_invoice_items, data_type: :integer
+    preference_group "Preferred Ledgers" do
+      income_ledger_id data_type: :integer, default: 1
+    end
+  end
+end

data/spec/has_preference_map_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+require 'fixtures/dummy_class'
+describe SerialPreference::HasSerialPreferences do
+
+  before(:all) do
+    rebuild_model
+  end
+
+  context "default behaviour" do
+    it "should return preferences as a default _preferences_attribute" do
+      DummyClass._preferences_attribute.should eq(:preferences)
+    end
+    it "should return settings as a _preferences_attribute" do
+      class OverriddenPreferenceAttributeClass < ActiveRecord::Base
+        include SerialPreference::HasSerialPreferences
+        preferences :settings  do
+          preference :abc
+        end
+      end
+      OverriddenPreferenceAttributeClass._preferences_attribute.should eq(:settings)
+    end
+  end
+
+  context "class methods behaviour" do
+    it "should be possible to describe preference map thru preferences" do
+      DummyClass.respond_to?(:preferences).should be_true
+    end
+
+    it "should be possble to retrieve preference groups from class" do
+      DummyClass.respond_to?(:preference_groups).should be_true
+    end
+  end
+
+
+  context "should define accessors" do
+    it "should have readers available" do
+      d = DummyClass.new
+      d.respond_to?(:taxable).should be_true
+      d.respond_to?(:vat_no).should be_true
+      d.respond_to?(:max_invoice_items).should be_true
+      d.respond_to?(:income_ledger_id).should be_true
+      d.respond_to?(:read_preference_attribute).should be_true
+      d.respond_to?(:write_preference_attribute).should be_true
+    end
+
+    it "should have writers available" do
+      d = DummyClass.new
+      d.respond_to?(:taxable=).should be_true
+      d.respond_to?(:vat_no=).should be_true
+      d.respond_to?(:max_invoice_items=).should be_true
+      d.respond_to?(:income_ledger_id=).should be_true
+    end
+
+    it "should have query methods available for booleans" do
+      DummyClass.new.respond_to?(:taxable?)
+    end
+
+  end
+
+=begin
+  context "should define validations" do
+    it "should define presence validation on required preferences" do
+      d = DummyClass.new
+      d.should validate_presence_of(:taxable)
+    end
+
+    it "should define presence and numericality on required preference which are numeric" do
+      d = DummyClass.new
+      d.taxable = true
+      d.should validate_presence_of(:required_number)
+      d.should validate_numericality_of(:required_number)
+    end
+
+    it "should define numericality on preference which are numeric" do
+      d = DummyClass.new
+      d.should validate_numericality_of(:required_number)
+      d.should validate_numericality_of(:income_ledger_id)
+    end
+  end
+
+=end
+
+end

data/spec/preference_definition_spec.rb

@@ -0,0 +1,184 @@
+require 'spec_helper'
+
+describe SerialPreference::PreferenceDefinition do
+
+  before do
+    @blank_pref = described_class.new("whatever")
+  end
+
+  it "should have proper accessors" do
+    [:data_type, :name, :default, :required, :field_type].each do |a|
+      @blank_pref.respond_to?(a).should be_true
+    end
+  end
+
+  it "should declare supported data types" do
+    described_class.constants.should include(:SUPPORTED_TYPES)
+  end
+
+  it "should stringify its name" do
+    described_class.new(:whatever).name.should eq("whatever")
+  end
+
+  context "required behaviour" do
+    it "should not be required when no required option provided" do
+      @blank_pref.should_not be_required
+    end
+
+    it "should be required when required option is truthy" do
+      [0,"yes","no","false",true].each do |truthy_values|
+        p = described_class.new("whatever",{required: truthy_values})
+        p.should be_required
+      end
+    end
+
+    it "should not be required when required option is falsy" do
+      [false,nil].each do |falsy_values|
+        p = described_class.new("whatever",{required: falsy_values})
+        p.should_not be_required
+      end
+    end
+  end
+
+  context "numericality behaviour" do
+    it "should not be numerical when no data_type is provided" do
+      @blank_pref.should_not be_numerical
+    end
+
+    it "should be numerical when data_type is numerical" do
+      [:integer,:float,:decimal].each do |dt|
+        described_class.new("whatever",{data_type: dt}).should be_numerical
+      end
+    end
+
+    it "should be not numerical when data_type is non numerical" do
+      [:string,:boolean,:password,:whatever].each do |dt|
+        described_class.new("whatever",{data_type: dt}).should_not be_numerical
+      end
+    end
+  end
+
+  context "default behaviour" do
+    it "should report correct name" do
+      @blank_pref.name.should eq("whatever")
+    end
+    it "should be a string" do
+      @blank_pref.data_type.should eq(:string)
+    end
+    it "should have nil default" do
+      @blank_pref.default.should be_nil
+    end
+    it "should be false for required" do
+      @blank_pref.required.should be_false
+    end
+    it "should have string field_type" do
+      @blank_pref.field_type.should eq(:string)
+    end
+  end
+
+  context "field_type behaviour" do
+    it "should report field_type as provided" do
+      described_class.new("whatever",{field_type: :xyz}).field_type.should eq(:xyz)
+    end
+    it "should report string for numerical data types" do
+      described_class.new("whatever",{data_type: :integer}).field_type.should eq(:string)
+    end
+    it "should report data type for non numeric data types" do
+      p = described_class.new("whatever",{data_type: :xyz})
+      p.field_type.should eq(p.data_type)
+    end
+  end
+
+  context "should report correct preferred values" do
+
+    context "when input is nil" do
+      it "should report nil when no default is given" do
+        @blank_pref.value(nil).should be_nil
+      end
+
+      it "should report default when input is nil" do
+        p = described_class.new("whatever",{default: "dog"})
+        p.value(nil).should eq("dog")
+      end
+
+      it "should report default in appropriate data type when input is nil" do
+        p = described_class.new("whatever",{default: "dog", data_type: :integer})
+        p.value(nil).should eq("dog".to_i)
+      end
+    end
+
+    context "should report correct string/password values" do
+      before do
+        @preference = described_class.new("whatever",{data_type: :string})
+      end
+
+      it "should return correct strings as passthru" do
+        ["",3.0,[],{},"dog",1].each do |input_val|
+          @preference.value(input_val).should eq(input_val.to_s)
+        end
+      end
+
+    end
+
+    context "should report correct integer values" do
+      before do
+        @preference = described_class.new("whatever",{data_type: :integer})
+      end
+
+      it "should return correct integers" do
+        ["",1,3.0,"dog"].each do |input_val|
+          @preference.value(input_val).should eq(input_val.to_i)
+        end
+      end
+
+      it "should report nil for non numeric input" do
+        [[],{}].each do |input_val|
+          @preference.value(input_val).should be_nil
+        end
+      end
+    end
+
+    context "should report correct floaty/real values" do
+      before do
+        @preference = described_class.new("whatever",{data_type: :float})
+      end
+
+      it "should return correct floats" do
+        ["",1,3.0,"dog"].each do |input_val|
+          @preference.value(input_val).should eq(input_val.to_f)
+        end
+      end
+
+      it "should report nil for non numeric input" do
+        [[],{}].each do |input_val|
+          @preference.value(input_val).should be_nil
+        end
+      end
+    end
+
+    context "should report correct boolean values" do
+      before do
+        @preference = described_class.new("whatever",{data_type: :boolean})
+      end
+      it "should report false for falsy values" do
+        [nil,false].each do |falsy|
+          @preference.value(falsy).should be_false
+        end
+      end
+
+      it "should report false for false looking values" do
+        [0,"0","false","FALSE","False","no","NO","No"].each do |falsy|
+          @preference.value(falsy).should be_false
+        end
+      end
+
+      it "should report true for truthy values" do
+        ["yes",true,100,0.1,[],{}].each do |truthy_value|
+          @preference.value(truthy_value).should be_true
+        end
+      end
+    end
+
+  end
+
+end

data/spec/preferenzer_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe SerialPreference::Preferenzer do
+
+  before(:each) do
+    @base = described_class::PreferenceGroup.new(:base,{})
+    @preferenzer = described_class.new
+  end
+
+  it "should have proper readers" do
+    [:preference_groups,:preference,:preference_groups,:all_preference_definitions,:all_preference_names,:current_group].each do |a|
+      @preferenzer.should respond_to(a)
+    end
+  end
+
+  context "default instance behaviour" do
+    it "should report empty preference groups" do
+      @preferenzer.preference_groups.should include(@base)
+    end
+    it "should report current_contex to be nil" do
+      @preferenzer.current_group.should eq(@base)
+    end
+    it "should report all preference name to be empty" do
+      @preferenzer.all_preference_names.should be_empty
+    end
+    it "should report all preference definitions to be empty" do
+      @preferenzer.all_preference_definitions.should be_empty
+    end
+  end
+
+  context "allows for preferences/groups to be setup using instance" do
+
+    it "should allow for addition of preference using pref" do
+      @preferenzer.pref("whatever")
+      @preferenzer.all_preference_names.should include("whatever")
+    end
+
+    it "should allow for addition of preference using preference" do
+      @preferenzer.preference("whatever")
+      @preferenzer.all_preference_names.should include("whatever")
+    end
+
+    it "should alias preference to pref" do
+      described_class.instance_method(:pref).should eq(described_class.instance_method(:preference))
+    end
+
+    it "should allow for addition of preference group" do
+      @preferenzer.preference_group(:new_group) do
+        preference :new_preference
+      end
+      @preferenzer.all_preference_names.should include("new_preference")
+    end
+
+  end
+
+  context "allows for drawing of preference map" do
+    it "should setup preferences using draw" do
+      @preferenzer.draw do
+        preference :name
+        pref :age, data_type: :integer
+        pref :sex, default: "male"
+        preference_group "Email Notifications" do
+          email default: false
+          switch_off_hour default: 23
+        end
+      end
+      @preferenzer.all_preference_names.should include("age","name","sex","email","switch_off_hour")
+    end
+
+    it "should allow for addition of preference in given context" do
+      @preferenzer.all_groups.should_not include(:new_group)
+      @preferenzer.preference_group(:new_group) do
+        preference "addition"
+      end
+      @preferenzer.all_preference_names.should include("addition")
+    end
+
+    it "should allow overriding of preference if defined twice" do
+      @preferenzer.preference_group(:overriding) do
+        preference :overriding_name
+        preference :overriding_name
+      end
+      @preferenzer.all_preference_names.should include("overriding_name", "overriding_name")
+    end
+
+    it "should allow addition of preference to an existing preference group" do
+      @preferenzer.preference_group(:notifications) do
+        preference :new_preference
+      end
+      @preferenzer.all_preference_names.should include("new_preference")
+    end
+
+    it "should allow for preference names to be strings or symbols" do
+      @preferenzer.preference_group(:notifications) do
+        preference "string"
+        preference :symbol
+      end
+      @preferenzer.all_preference_names.should include("string", "symbol")
+    end
+
+    it "should allow for preference_group names to be strings or symbols" do
+      @preferenzer.preference_group(:symbol) do
+        preference "string"
+      end
+      @preferenzer.preference_group("string") do
+        preference :symbol
+      end
+      @preferenzer.all_groups.should include("string", :symbol)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+$:.unshift File.expand_path('..', __FILE__)
+$:.unshift File.expand_path('../../lib', __FILE__)
+require 'active_support/all'
+require 'active_record'
+require 'rspec'
+require 'shoulda'
+require "serial_preference/version"
+require 'serial_preference/preference_definition'
+require "serial_preference/preferenzer"
+require "serial_preference/has_preference_map"
+
+FIXTURES_DIR = File.join(File.dirname(__FILE__), "fixtures")
+config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+ActiveRecord::Base.logger = ActiveSupport::BufferedLogger.new(File.dirname(__FILE__) + "/debug.log")
+ActiveRecord::Base.establish_connection(config['test'])
+
+RSpec.configure do |config|
+end
+
+def rebuild_model options = {}
+  ActiveRecord::Base.connection.create_table :dummy_classes, :force => true do |table|
+    table.column :preferences, :text
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: serial_preference
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-09 00:00:00.000000000 Z
+date: 2012-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -27,6 +27,70 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Serialized Preferences for your models
 email:
 - aditya.sanghi@risingsuntech.net
@@ -35,16 +99,23 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/serial_preference.rb
 - lib/serial_preference/has_preference_map.rb
-- lib/serial_preference/preference.rb
-- lib/serial_preference/preference_group.rb
+- lib/serial_preference/preference_definition.rb
+- lib/serial_preference/preferenzer.rb
 - lib/serial_preference/version.rb
 - serial_preference.gemspec
+- spec/database.yml
+- spec/fixtures/dummy_class.rb
+- spec/has_preference_map_spec.rb
+- spec/preference_definition_spec.rb
+- spec/preferenzer_spec.rb
+- spec/spec_helper.rb
 homepage: ''
 licenses: []
 post_install_message: 
@@ -57,16 +128,28 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 617750894719650316
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 617750894719650316
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Serialized Preferences for your models
-test_files: []
+test_files:
+- spec/database.yml
+- spec/fixtures/dummy_class.rb
+- spec/has_preference_map_spec.rb
+- spec/preference_definition_spec.rb
+- spec/preferenzer_spec.rb
+- spec/spec_helper.rb

data/lib/serial_preference/preference.rb

@@ -1,55 +0,0 @@
-module SerialPreference
-  class Preference
-
-    SUPPORTED_TYPES = [:string,:integer,:real,:float,:boolean,:password]
-
-    attr_accessor :data_type, :name, :default, :required, :label, :hint, :field_type
-
-    def initialize(name,opts = {})
-      self.data_type = opts[:data_type] || :string
-      self.name = name
-      self.default = opts[:default]
-      self.required = !!opts[:required]
-      self.label = opts[:label]
-      self.hint = opts[:hint]
-      self.field_type = opts[:field_type]
-    end
-
-    def required?
-      required
-    end
-
-    def numerical?
-      [:integer,:float,:real].include?(data_type)
-    end
-
-    def field_type
-      @field_type || (numerical? ? :string : data_type)
-    end
-
-    def value(value)
-      value = value.nil? ? default : value
-      if !value.nil?
-        case data_type
-        when :string, :password
-          value.to_s
-        when  :integer
-          value.to_i
-        when :float, :real
-          value.to_f
-        when :boolean
-          return false if value == 0
-          return false if value == ""
-          return false if value == nil
-          return false if value.to_s.downcase == "false"
-          return false if value == "0"
-          return false if value.to_s.downcase == "no"
-          !!value
-        else
-          nil
-        end
-      end
-    end
-
-  end
-end

data/lib/serial_preference/preference_group.rb

@@ -1,51 +0,0 @@
-module SerialPreference
-  class PreferenceGroup
-
-    attr_accessor :name, :label
-
-    def initialize(name, opts = {})
-      @preferences = {}
-      @name = name
-      @label = opts[:label]
-    end
-
-    def to_s
-      name.to_s
-    end
-
-    def titleize
-      label
-    end
-
-    def label
-      @label.presence || name.to_s.titleize
-    end
-
-    def preference_keys
-      @preferences.keys
-    end
-
-    def preferences
-      @preferences.values
-    end
-
-    def pref(name,opts = {})
-      @preferences[name] = Preference.new(name,opts)
-    end
-
-    SerialPreference::Preference::SUPPORTED_TYPES.each do |dt|
-      define_method dt do |name,opts = {}|
-        pref(name,opts.merge!(:data_type => dt))
-      end
-    end
-
-    def respond_to?(name,*opts)
-      @preferences[name].present?
-    end
-
-    def method_missing(name,*opts,&block)
-      pref(name,*opts)
-    end
-
-  end
-end