acts_as_splittable 0.0.7 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 637013ac8fc1b1ed1e0bb79b28fd09caa2ec9172
-  data.tar.gz: 708003b189efb2ef05eba73a960a35cd5190c5ef
+  metadata.gz: 98433cfcbbae56a6573fad6039f2ae0b9cceebe7
+  data.tar.gz: c25a0d2a1dbc32ce93aba8a29edff5d621fa3a7d
 SHA512:
-  metadata.gz: 8d4999d86e3455f1ee8f1a711ba2165035ca7cf2bb6b8123a8a1b84b523235bc3561e9862a6ee870ccd28daedf3a277a0e22c128199e16016f74e5a1389635ba
-  data.tar.gz: 580d2eda99d8b58e629062f99deb5a36fed68a83575ce9aa3e79d57e8bfe7d25287ce01723cfa3d1568d22206c4e69c4cfeaef41c20f5d631e99c184a85d3adf
+  metadata.gz: 101239965067ab75d3334fd76c4b3ec078c3d1d718ae1565556236382293b2653be72f9c6fe8e54a80439ca34a301731c090b441c15e0d2c7321c2ae2db6d9d6
+  data.tar.gz: 5d7de21a6d5f6252209b25ec4c39d77ad29da455b28582d050ab3c5900ed7ab86b28cd12fd8a2ace50747e8897986a2a47e1427c5bf2135c21ec1ee136a5598f

data/.gitignore

@@ -6,3 +6,4 @@ spec/database.yml
 Gemfile.lock
 *.sqlite3
 .DS_Store
+vendor/bundle

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - ruby-head
+bundler_args: --path vendor/bundle
+gemfile:
+  - gemfiles/rails3.gemfile
+  - gemfiles/rails4.gemfile
+before_script:
+  - cp spec/database.yml.sample spec/database.yml
+script:
+  - bundle exec rspec spec

data/README.md

@@ -1,6 +1,8 @@
 ActsAsSplittable
 ====================
 
+[![Build Status](https://travis-ci.org/tatat/acts_as_splittable.png)](https://travis-ci.org/tatat/acts_as_splittable)
+
 Create virtual attributes.
 
 Installation
@@ -190,6 +192,42 @@ class Splittable < ActiveRecord::Base
 end
 ```
 
+### With ActiveModel::Dirty
+
+```ruby
+class Splittable < ActiveRecord::Base
+  acts_as_splittable dirty: true
+  splittable :email, delimiter: '@', attributes: [:email_local, :email_domain]
+end
+
+record = Splittable.find(id)
+record.email_local = 'nyan'
+
+p record.email_local_changed?  #=> true
+p record.email_domain_changed? #=> false
+
+record.save!
+
+p record.email_local_changed? #=> false
+p record.splittable_attributes.class.include?(ActiveModel::Dirty) #=> true
+```
+
+Options
+--------------------
+
+You can change default options
+
+```ruby
+ActsAsSplittable.default_options = {
+  callbacks:       true,
+  predicates:      false,
+  join_on_change:  false,
+  split_on_change: false,
+  allow_nil:       false,
+  dirty:           false,
+}
+```
+
 Contributing
 --------------------
 

data/gemfiles/rails3.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "rails", "~> 3.0"
+
+gemspec path: "../"

data/gemfiles/rails4.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "rails", "~> 4.0"
+
+gemspec path: "../"

data/lib/acts_as_splittable.rb

@@ -1,28 +1,47 @@
 $LOAD_PATH.unshift File.dirname(__FILE__)
 
 require 'active_record'
+require 'acts_as_splittable/utility'
 require 'acts_as_splittable/splittable'
+require 'acts_as_splittable/attributes'
 require 'acts_as_splittable/splitter'
 require 'acts_as_splittable/config'
 
 module ActsAsSplittable
-
-  def acts_as_splittable(options = {})
-    options.reverse_merge!(
+  class << self
+    DEFAULT_OPTIONS = {
       callbacks:       true,
       predicates:      false,
       join_on_change:  false,
       split_on_change: false,
-    )
+      allow_nil:       false,
+      dirty:           false,
+    }
+
+    def default_options(*args)
+      case args.length
+      when 0
+        @default_options ||= DEFAULT_OPTIONS
+      when 1
+        self.default_options = args.first
+      else
+        raise ArgumentError, "wrong number of arguments (#{args.length} for 0..1)"
+      end
+    end
+
+    def default_options=(options)
+      default_options.merge! options
+    end
+  end
+
+  def acts_as_splittable(options = {})
+    options = options.reverse_merge ActsAsSplittable.default_options
 
     extend  ClassMethods
     include Splittable
+    include splittable_module
 
-    self.splittable_options = options
-
-    if splittable_options[:split_on_change]
-      include splittable_module
-    end
+    @splittable_options = options
 
     if splittable_options[:callbacks]
       after_initialize { new_record? or split_column_values! }
@@ -35,35 +54,49 @@ module ActsAsSplittable
   end
 
   module ClassMethods
-    attr_writer :splittable_options
-
     def splittable_options
       @splittable_options ||= {}
     end
 
     def with_splittable_options(other_options = {})
       old = splittable_options
-      self.splittable_options = old.merge(other_options)
+      @splittable_options = old.merge(other_options)
       Proc.new.(splittable_options)
     ensure
-      self.splittable_options = old
+      @splittable_options = old
     end
 
     def splittable_config
       @splittable_config ||= Config.new
     end
 
+    def splittable_attributes_class
+      @splittable_attributes_class ||= Attributes.child
+    end
+
     def splittable(column, options)
-      options.merge!(name: column.to_sym)
-      splitter = Splitter.new(options)
+      options  = options.merge(name: column.to_sym)
+      splitter = Splitter.new(self, options)
+
       splittable_config.splitters << splitter
 
       splitter.attributes.each do |attribute|
+        splittable_attributes_class.define attribute
+
         define_splittable_getter(attribute)
         define_splittable_setter(attribute, splitter)
-        define_splittable_predicator(attribute) if splittable_options[:predicates]
+        define_splittable_predicator(attribute) if splitter.predicates?
+        define_splittable_dirty(attribute) if splitter.dirty?
+
+        if splitter.predicates? and not splitter.dirty?
+          Utility.alias_methods_with_warning_for splittable_module do
+            alias_method :"#{attribute}_changed?", :"#{attribute}_unsynced?"
+          end
+        end
       end
 
+      define_splittable_dirty_callbacks if splitter.dirty?
+
       if splittable_options[:split_on_change]
         define_splittable_setter_hook(splitter.name)
       end
@@ -71,35 +104,33 @@ module ActsAsSplittable
 
     def inherited(child)
       super
-
-      child.splittable_options = splittable_options.dup
-
-      if child.splittable_options[:split_on_change]
-        child.splittable_module = splittable_module.dup
-        child.send(:include, child.splittable_module)
-      end
-        
+      child.__send__ :instance_variable_set, :@splittable_options, splittable_options.dup
+      child.__send__ :instance_variable_set, :@splittable_module, splittable_module.dup
+      child.__send__ :instance_variable_set, :@splittable_attributes_class, splittable_attributes_class.dup
+      child.__send__ :include, child.splittable_module
       child.splittable_config.inherit! splittable_config
     end
 
     protected
 
-    attr_writer :splittable_module
-
     def splittable_module
       @splittable_module ||= Module.new
     end
 
     private
 
+    def define_splittable_method(name, &block)
+      splittable_module.__send__ :define_method, name, &block
+    end
+
     def define_splittable_getter(attribute)
-      define_method attribute do
+      define_splittable_method attribute do
         splittable_attributes[attribute]
       end
     end
 
     def define_splittable_setter(attribute, splitter)
-      define_method :"#{attribute}=" do |value|
+      define_splittable_method :"#{attribute}=" do |value|
         splittable_attributes[attribute] = value
 
         unless splittable_changed_attribute? attribute
@@ -115,27 +146,44 @@ module ActsAsSplittable
     end
 
     def define_splittable_predicator(attribute)
-      define_method :"#{attribute}_changed?" do
+      define_splittable_method :"#{attribute}_unsynced?" do
         splittable_changed_attribute? attribute
       end
+
+      define_splittable_method :"#{attribute}_synced?" do
+        not __send__(:"#{attribute}_unsynced?")
+      end
     end
 
     def define_splittable_setter_hook(name)
-      splittable_module.module_eval do
-        define_method("#{name}=") do |value|
-          if defined?(super)
-            super(value)
-          elsif respond_to?(:write_attribute, true)
-            write_attribute name, value
-          end
+      define_splittable_method "#{name}=" do |value|
+        if defined?(super)
+          super(value)
+        elsif respond_to?(:write_attribute, true)
+          write_attribute name, value
+        end
 
-          self.class.with_splittable_options join_on_change: false do
-            split_column_values! name
-          end
+        self.class.with_splittable_options join_on_change: false do
+          split_column_values! name
         end
       end
     end
 
+    def define_splittable_dirty(attribute)
+      splittable_attributes_class.define_dirty_attribute_method attribute
+
+      %w(change changed? was will_change!).each do |suffix|
+        name = :"#{attribute}_#{suffix}"
+        define_splittable_method(name) {|*args| splittable_attributes.__send__ name, *args }
+      end
+    end
+
+    def define_splittable_dirty_callbacks
+      @splittable_dirty_callbacks_defined ||= true.tap{
+        after_initialize { splittable_attributes.reset! }
+        after_save { splittable_attributes.changed! }
+      }
+    end
   end
 end
 

data/lib/acts_as_splittable/attributes.rb

@@ -0,0 +1,76 @@
+module ActsAsSplittable
+  class Attributes < Hash
+    class << self
+      def child
+        Class.new Attributes
+      end
+
+      def dirty!
+        unless dirty?
+          include ActiveModel::Dirty
+          include Dirty
+        end
+
+        self
+      end
+
+      def dirty?
+        include? ActiveModel::Dirty
+      end
+
+      def define(name)
+        name = name.to_sym
+        define_method(name) { self[name] }
+      end
+
+      def define_dirty_attribute_method(name)
+        dirty!.define_attribute_method name
+      end
+    end
+
+    def []=(key, value)
+      key = key.to_sym
+      __send__ :"#{key}_will_change!" if dirty? and key?(key) and value != self[key]
+
+      super key, value
+    end
+
+    def [](key)
+      super key.to_sym
+    end
+
+    def dirty?
+      @dirty = self.class.dirty? if @dirty.nil?
+      @dirty
+    end
+
+    def changed!; super if defined?(super) end
+    def reset!; super if defined?(super) end
+
+    module Dirty
+      def changed!
+        if respond_to? :changes_applied, true
+          changes_applied
+        else
+          @previously_changed = changes
+          @changed_attributes = changed_attributes.class.new
+        end
+      end
+
+      def reset!
+        if respond_to? :reset_changes, true
+          reset_changes
+        else
+          @previously_changed = changed_attributes.class.new
+          @changed_attributes = changed_attributes.class.new
+        end
+      end
+
+      def initialize_copy(original)
+        super
+        @previously_changed = original.__send__(:instance_variable_get, :@previously_changed).dup
+        @changed_attributes = original.__send__(:instance_variable_get, :@changed_attributes).dup
+      end
+    end
+  end
+end

data/lib/acts_as_splittable/config.rb

@@ -10,6 +10,14 @@ module ActsAsSplittable
       end
     end
 
+    def splitter_has_attribute(attribute)
+      attribute = attribute.to_sym
+
+      splitters.find do |splitter|
+        splitter.attributes.include?(attribute) or splitter.name == attribute
+      end
+    end
+
     def inherit!(other)
       splitters.replace (other.splitters + splitters).uniq(&:name)
     end

data/lib/acts_as_splittable/splittable.rb

@@ -1,15 +1,18 @@
 module ActsAsSplittable
   module Splittable
-
     def splittable_attributes
-      @splittable_attributes ||= {}
+      @splittable_attributes ||= self.class.splittable_attributes_class.new
     end
 
-    alias_method :splittable_partials, :splittable_attributes
-
     def split_column_values!(columns = nil)
       splittable_aggregate_columns(columns) do |column, splitter|
-        value = __send__(column) or next
+        begin
+          value = __send__(column)
+        rescue ActiveModel::MissingAttributeError
+          next
+        end
+
+        next if not splitter.allow_nil? and value.nil?
 
         values = splitter.split(value, self)
         splitter.attributes.zip(values).each do |key, value|
@@ -23,7 +26,7 @@ module ActsAsSplittable
     def join_column_values!(columns = nil)
       splittable_aggregate_columns(columns) do |column, splitter|
         values = splitter.attributes.map {|partial| __send__(partial) }
-        next if values.include?(nil)
+        next if not splitter.allow_nil? and values.include?(nil)
 
         __send__ :"#{column}=", splitter.restore(values, self)
         reset_splittable_changed_attributes splitter.attributes
@@ -48,11 +51,8 @@ module ActsAsSplittable
       self.splittable_changed_attributes -= attributes
     end
 
-    alias_method :splittable_changed_partials, :splittable_changed_attributes
-    alias_method :splittable_changed_partial?, :splittable_changed_attribute?
-    alias_method :reset_splittable_changed_partials, :reset_splittable_changed_attributes
-
     private
+
     def splittable_aggregate_columns(columns = nil)
       config = self.class.splittable_config
       columns = columns ? Array(columns) : config.splitters.collect(&:name)
@@ -71,5 +71,13 @@ module ActsAsSplittable
       end
     end
 
+    Utility.alias_methods_with_warning_for self do
+      alias_method :splittable_partials,               :splittable_attributes
+      alias_method :splittable_changed_partials,       :splittable_changed_attributes
+      alias_method :splittable_changed_partial?,       :splittable_changed_attribute?
+      alias_method :reset_splittable_changed_partials, :reset_splittable_changed_attributes
+
+      protected :splittable_changed_partials, :splittable_changed_partial?, :reset_splittable_changed_partials
+    end
   end
 end

data/lib/acts_as_splittable/splitter.rb

@@ -11,18 +11,21 @@ module ActsAsSplittable
       partials: :attributes,
     }.freeze
 
-    def initialize(options = {})
-      @options = options
-
+    def initialize(klass, options = {})
       options   = DEFAULTS.merge(options)
       delimiter = options.delete(:delimiter)
+      
+      @klass   = klass
+      @options = {}
 
       options.each do |key, value|
         case key
         when *ALIASES.keys
           self[ALIASES[key]] = value
-        else
+        when *members.map(&:to_sym)
           self[key] = value
+        else
+          @options[key.to_sym] = value
         end
       end
 
@@ -51,6 +54,11 @@ module ActsAsSplittable
       delegation(delegate || self, on_join, values)
     end
 
+    def method_missing(name, *args)
+      super unless name.to_s[-1] == '?'
+      define_predicate_method_for_options(name)
+    end
+
     private
     def delegation(target, method, *args)
       if method.is_a?(Proc)
@@ -75,5 +83,15 @@ module ActsAsSplittable
           Object.private_method_defined?(name)
       end || values
     end
+
+    def define_predicate_method_for_options(name)
+      key = name.to_s.chop.to_sym
+
+      self.class.__send__ :define_method, name do
+        !! (@options.key?(key) ? @options[key] : @klass.splittable_options[key])
+      end
+
+      __send__ name
+    end
   end
 end

data/lib/acts_as_splittable/utility.rb

@@ -0,0 +1,26 @@
+module ActsAsSplittable
+  module Utility
+    module_function
+
+    def alias_methods_with_warning_for(mod, &block)
+      AliasWithWarning.new(mod).instance_exec &block
+    end
+
+    def deprecation_warning_of_method_name(old_name, new_name)
+       warn "DEPRECATION WARNING: `#{old_name}' is deprecated. Please use `#{new_name}' instead."
+    end
+
+    class AliasWithWarning < Struct.new(:mod)
+      def alias_method(new_name, original_name)
+        mod.__send__ :define_method, new_name do |*args|
+          Utility.deprecation_warning_of_method_name new_name, original_name
+          __send__ original_name, *args
+        end
+      end
+
+      def method_missing(name, *args)
+        mod.__send__ name, *args
+      end
+    end
+  end
+end

data/lib/acts_as_splittable/version.rb

@@ -1,3 +1,3 @@
 module ActsAsSplittable
-  VERSION = "0.0.7"
+  VERSION = "0.1.0"
 end

data/spec/models.rb

@@ -1,24 +1,33 @@
 EMAIL_SPLIT_PATTERN = /\A(?<email_local>[^@]+)@(?<email_domain>[^@]+)\Z/
 EMAIL_JOIN_PROCESS  = Proc.new{|values| values.join('@') }
 
-class Splittable < ActiveRecord::Base
-
-  acts_as_splittable predicates: true
-
-  splittable :email,        split: ['@', 2], attributes: [:email_local, :email_domain], on_join: EMAIL_JOIN_PROCESS
-  splittable :postal_code,  pattern: /\A(?<postal_code1>[0-9]{3})(?<postal_code2>[0-9]{4})\Z/
-  splittable :phone_number, attributes: [:phone_number1, :phone_number2, :phone_number3], on_split: :split_phone_number, on_join: :join_phone_number
-
-  protected
-
-  def split_phone_number(value)
-    return if value.nil?
-    [value[0, 3], value[3, 4], value[7, 4]]
+module SplittableDefiner
+  def self.include_to(mod, options = {})
+    mod.module_exec do
+      self.table_name = 'splittables'
+      
+      acts_as_splittable ({predicates: true}).merge(options)
+
+      splittable :email,        split: ['@', 2], attributes: [:email_local, :email_domain], on_join: EMAIL_JOIN_PROCESS
+      splittable :postal_code,  pattern: /\A(?<postal_code1>[0-9]{3})(?<postal_code2>[0-9]{4})\Z/
+      splittable :phone_number, attributes: [:phone_number1, :phone_number2, :phone_number3], on_split: :split_phone_number, on_join: :join_phone_number
+
+      protected
+
+      def split_phone_number(value)
+        return if value.nil?
+        [value[0, 3], value[3, 4], value[7, 4]]
+      end
+
+      def join_phone_number(values)
+        values.join
+      end
+    end
   end
+end
 
-  def join_phone_number(values)
-    values.join
-  end
+class Splittable < ActiveRecord::Base
+  SplittableDefiner.include_to self
 end
 
 class SplittableInherited < Splittable; end
@@ -81,3 +90,26 @@ class SplittableUseTypeCasting < ActiveRecord::Base
 
   acts_as_hasty_splittable
 end
+
+class SplittableBase < ActiveRecord::Base
+  self.table_name = 'splittables'
+
+  def self.define_splittable(options = {})
+    acts_as_splittable options
+    splittable :email, delimiter: '@', attributes: [:email_local, :email_domain]
+  end
+end
+
+class SplittableNotAllowNil < SplittableBase
+  define_splittable
+  splittable :email_sub, delimiter: '@', attributes: [:email_sub_local, :email_sub_domain], allow_nil: true
+end
+
+class SplittableAllowNil < SplittableBase
+  define_splittable allow_nil: true
+  splittable :email_sub, delimiter: '@', attributes: [:email_sub_local, :email_sub_domain], allow_nil: false
+end
+
+class SplittableDirty < ActiveRecord::Base
+  SplittableDefiner.include_to self, dirty: true
+end

data/spec/models/splittable_spec.rb

@@ -88,44 +88,51 @@ end
 
 shared_examples_for 'splittable with callbacks' do
 
-  describe '#*_changed?' do
+  describe '#*_unsynced?' do
     before do
       @splittable = described_class.new
     end
 
     it 'should return true when value is changed until #split_column_values! or #join_column_values! is called' do
-      @splittable.email_local_changed?.should_not  be_true
-      @splittable.email_domain_changed?.should_not be_true
+      @splittable.email_local_unsynced?.should_not  be_true
+      @splittable.email_domain_unsynced?.should_not be_true
 
       @splittable.email_local = 'splittable'
-      @splittable.email_local_changed?.should be_true
+      @splittable.email_local_unsynced?.should be_true
 
       @splittable.email_domain = 'example.com'
-      @splittable.email_domain_changed?.should be_true
+      @splittable.email_domain_unsynced?.should be_true
 
       @splittable.join_column_values!
 
-      @splittable.email_local_changed?.should_not  be_true
-      @splittable.email_domain_changed?.should_not be_true
+      @splittable.email_local_unsynced?.should_not  be_true
+      @splittable.email_domain_unsynced?.should_not be_true
 
       @splittable.email_local = nil
-      @splittable.email_local_changed?.should be_true
+      @splittable.email_local_unsynced?.should be_true
 
       @splittable.email_domain = nil
-      @splittable.email_domain_changed?.should be_true
+      @splittable.email_domain_unsynced?.should be_true
 
       @splittable.split_column_values!
 
-      @splittable.email_local_changed?.should_not  be_true
-      @splittable.email_domain_changed?.should_not be_true
+      @splittable.email_local_unsynced?.should_not  be_true
+      @splittable.email_domain_unsynced?.should_not be_true
     end
   end
 
 end
 
+shared_examples_for 'selectable' do
+  it "should select columns" do
+    expect { described_class.select([:id]).first }.not_to raise_error
+  end
+end
+
 describe Splittable do
    it_behaves_like 'splittable'
    it_behaves_like 'splittable with callbacks'
+   it_behaves_like 'selectable'
 
    context 'when was given a proc to callbacks' do
     it 'should call in the record' do
@@ -137,12 +144,12 @@ describe Splittable do
         splittable :birthday, {
           partials: [:birthday_year, :birthday_month, :birthday_day],
 
-          on_split: -> (value) {
+          on_split: ->(value) {
             year, month, day = value.chars.each_slice(2).map(&:join).map(&:to_i)
             [year + birthday_base, month, day]
           },
 
-          on_join: -> (values) {
+          on_join: ->(values) {
             year, month, day = values.map(&:to_i)
             '%02d%02d%02d' % [year - birthday_base, month, day]
           }
@@ -175,16 +182,19 @@ end
 describe SplittableInherited do
   it_behaves_like 'splittable'
   it_behaves_like 'splittable with callbacks'
+  it_behaves_like 'selectable'
 end
 
 
 describe SplittableInheritedInherited do
   it_behaves_like 'splittable'
   it_behaves_like 'splittable with callbacks'
+  it_behaves_like 'selectable'
 end
 
 
 describe SplittableSplitOrJoinOnChange do
+  it_behaves_like 'selectable'
 
   it 'should join partials when one of partials is set and all of them are not nil' do
     splittable = SplittableSplitOrJoinOnChange.new
@@ -239,6 +249,7 @@ describe SplittableSplitOrJoinOnChange do
 end
 
 describe SplittableSplitOrJoinOnChangeWithAliasAttribute do
+  it_behaves_like 'selectable'
 
   it 'should split value when value is set' do
     splittable1 = SplittableSplitOrJoinOnChangeWithAliasAttribute.new(
@@ -262,6 +273,7 @@ describe SplittableSplitOrJoinOnChangeWithAliasAttribute do
 end
 
 describe SplittableUseDelimiter do
+  it_behaves_like 'selectable'
 
   let (:splittable) do
     SplittableUseDelimiter.new(email: 'splittable@example.com')
@@ -281,6 +293,7 @@ describe SplittableUseDelimiter do
 end
 
 describe SplittableUseTypeCasting do
+  it_behaves_like 'selectable'
 
   shared_examples_for 'splittable typecasting' do
 
@@ -327,4 +340,156 @@ describe SplittableUseTypeCasting do
     it_behaves_like 'splittable typecasting'
   end
 
-end
+end
+
+describe SplittableNotAllowNil do
+  it_behaves_like 'selectable'
+
+  it "should join columns" do
+    splittable = described_class.new(email_local: 'splittable', email_domain: 'example.com').join_column_values!
+    splittable.email.should_not be_nil
+  end
+
+  it "should not join columns" do
+    splittable = described_class.new(email_local: 'splittable', email_domain: nil).join_column_values!
+    splittable.email.should be_nil
+  end
+
+  it "should split columns" do
+    splittable = described_class.new(email: 'splittable@example.com').split_column_values!
+    splittable.email_local.should == 'splittable'
+    splittable.email_domain.should == 'example.com'
+  end
+
+  it "should not split columns" do
+    splittable = described_class.new(email: nil, email_local: 'splittable', email_domain: 'example.com').split_column_values!
+    splittable.email_local.should == 'splittable'
+    splittable.email_domain.should == 'example.com'
+  end
+
+  context "when option `allow_nil' is overridden." do
+    it "should join columns" do
+      splittable = described_class.new(email_sub_local: 'splittable', email_sub_domain: nil).join_column_values!
+      splittable.email_sub.should == 'splittable@'
+    end
+
+    it "should split columns" do
+      splittable = described_class.new(email_sub: nil, email_sub_local: 'splittable', email_sub_domain: 'example.com').split_column_values!
+      splittable.email_sub_local.should be_nil
+      splittable.email_sub_domain.should be_nil
+    end
+  end
+end
+
+describe SplittableAllowNil do
+  it_behaves_like 'selectable'
+
+  it "should join columns" do
+    splittable = described_class.new(email_local: 'splittable', email_domain: nil).join_column_values!
+    splittable.email.should == 'splittable@'
+  end
+
+  it "should split columns" do
+    splittable = described_class.new(email: nil, email_local: 'splittable', email_domain: 'example.com').split_column_values!
+    splittable.email_local.should be_nil
+    splittable.email_domain.should be_nil
+  end
+
+  context "when option `allow_nil' is overridden." do
+    it "should not join columns" do
+      splittable = described_class.new(email_sub_local: 'splittable', email_sub_domain: nil).join_column_values!
+      splittable.email_sub.should be_nil
+    end
+
+    it "should not split columns" do
+      splittable = described_class.new(email_sub: nil, email_sub_local: 'splittable', email_sub_domain: 'example.com').split_column_values!
+      splittable.email_sub_local.should == 'splittable'
+      splittable.email_sub_domain.should == 'example.com'
+    end
+  end
+end
+
+describe SplittableDirty do
+  it_behaves_like 'splittable'
+  it_behaves_like 'selectable'
+
+  let(:splittable_new)   { described_class.new }
+  let(:splittable_saved) { described_class.create!(email_local: 'splittable', email_domain: 'example.com') }
+
+  describe "*_change, *_was, *_changed?" do
+    context "new record" do
+      it "should be unchanged" do
+        splittable_new.email_local_change.should   be_nil
+        splittable_new.email_local_was.should      be_nil
+        splittable_new.email_local_changed?.should be_false
+      end
+
+      it "should be unchanged first" do
+        splittable_new.email_local = 'first value'
+        splittable_new.email_local_change.should   be_nil
+        splittable_new.email_local_was.should      == 'first value'
+        splittable_new.email_local_changed?.should be_false
+      end
+
+      it "should be changed from the second time" do
+        splittable_new.email_local  = 'first value'
+        splittable_new.email_local  = 'second value'
+
+        splittable_new.email_local_change.should   == ['first value', 'second value']
+        splittable_new.email_local_was.should      == 'first value'
+        splittable_new.email_local_changed?.should be_true
+
+        splittable_new.email_local = 'third value'
+
+        splittable_new.email_local_change.should   == ['first value', 'third value']
+        splittable_new.email_local_was.should      == 'first value'
+        splittable_new.email_local_changed?.should be_true
+      end
+
+      it "should not ignore if first value is nil" do
+        splittable_new.email_local = nil
+        splittable_new.email_local = 'second value'
+        
+        splittable_new.email_local_change.should   == [nil, 'second value']
+        splittable_new.email_local_was.should      be_nil
+        splittable_new.email_local_changed?.should be_true
+      end
+    end
+
+    context "existent record" do
+      it "should be unchanged" do
+        splittable_saved.email_local.should          == 'splittable'
+        splittable_saved.email_local_change.should   be_nil
+        splittable_saved.email_local_was.should      == 'splittable'
+        splittable_saved.email_local_changed?.should be_false
+      end
+
+      it "should be changed" do
+        splittable_saved.email_local = 'splittable2'
+        splittable_saved.email_local_change.should   == ['splittable', 'splittable2']
+        splittable_saved.email_local_was.should      == 'splittable'
+        splittable_saved.email_local_changed?.should be_true
+      end
+
+      it "should ignore if it is not new record" do
+        record = described_class.where(email: splittable_saved.email).first
+        record.email_local_change.should   be_nil
+        record.email_local_was.should      == splittable_saved.email_local
+        record.email_local_changed?.should be_false
+      end
+    end
+
+    it "should be reset after save" do
+      splittable_saved.email_local = 'splittable2'
+
+      splittable_saved.email_local_changed?.should be_true
+
+      splittable_saved.save!
+
+      splittable_saved.email_local_changed?.should be_false
+      splittable_saved.splittable_attributes.previous_changes.should == {'email_local' => ['splittable', 'splittable2']}
+
+      splittable_saved.tap(&:save!).splittable_attributes.previous_changes.should be_empty
+    end
+  end
+end

data/spec/schema.rb

@@ -3,6 +3,7 @@ ActiveRecord::Schema.define version: 0 do
   create_table "splittables", force: true do |t|
     t.string   "name"
     t.string   "email"
+    t.string   "email_sub"
     t.string   "postal_code"
     t.string   "phone_number"
     t.string   "birthday_era"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acts_as_splittable
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.1.0
 platform: ruby
 authors:
 - tatat
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-26 00:00:00.000000000 Z
+date: 2013-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -85,15 +85,20 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .rspec
+- .travis.yml
 - Gemfile
 - MIT-LICENSE
 - README.md
 - Rakefile
 - acts_as_splittable.gemspec
+- gemfiles/rails3.gemfile
+- gemfiles/rails4.gemfile
 - lib/acts_as_splittable.rb
+- lib/acts_as_splittable/attributes.rb
 - lib/acts_as_splittable/config.rb
 - lib/acts_as_splittable/splittable.rb
 - lib/acts_as_splittable/splitter.rb
+- lib/acts_as_splittable/utility.rb
 - lib/acts_as_splittable/version.rb
 - lib/tasks/acts_as_splittable_tasks.rake
 - spec/database.yml.sample