attribute-filters 1.3.2 → 1.4.0

data/lib/attribute-filters/dsl_sets.rb

@@ -22,18 +22,29 @@ module ActiveModel
     # Returns the attribute set of the given name or the set containing
     # all attributes (if the argument is not given).
     # 
+    # If the given +set_name+ is a kind of String or Symbol then the method
+    # returns a copy of a set that is stored within a model class. The copy
+    # is wrapped in a `AttributeSet::AttrQuery` instance.
+    # 
+    # If the argument is a kind of {AttributeSet} then the local set
+    # is taken and wrapped in a {AttributeSet::AttrQuery} instance.
+    # 
+    # If the argument is other kind than the specified above then
+    # the method tries to initialize new, local set object and wraps
+    # it in a `AttributeSet::AttrQuery` instance.
+    # 
     # @note The returned value is a duplicate. Adding or removing
-    #  elements to it will have no effect. Altering attribute sets
-    #  is possible on a class-level only, since attribute sets
+    #  elements to it will have no effect on class-level set.
+    #  Altering attribute sets is possible on a class-level only, since attribute sets
     #  are part of models' interfaces.
     # 
-    # @param set_name [Symbol] name of attribute set
+    # @param set_name [Symbol] name of attribute set, attribute object or any object that can initialize a set
     # @return [AttributeSet] attribute set
     def attribute_set(set_name=nil)
       if set_name.nil?
         all_attributes
       else
-        ActiveModel::AttributeSet::Query.new(self.class.attribute_set(set_name), self)
+        ActiveModel::AttributeSet::Query.new(set_name, self)
       end
     end
     alias_method :attributes_that_are,        :attribute_set
@@ -49,42 +60,83 @@ module ActiveModel
     alias_method :attributes_set,             :attribute_set
     alias_method :properties_that,            :attribute_set
 
-    # Returns a set containing all attributes.
+    # Returns the attribute set of the given name without wrapping
+    # the result in proxy methods.
+    # 
+    # @note The returned value is a duplicate. Adding or removing
+    #  elements to it will have no effect. Altering attribute sets
+    #  is possible on a class-level only, since attribute sets
+    #  are part of models' interfaces.
+    # 
+    # @param set_name [Symbol] name of attribute set
+    # @return [AttributeSet] attribute set
+    def attribute_set_simple(set_name)
+      self.class.attribute_set(set_name).dup
+    end
+
+    # Returns a set containing all known attributes
+    # without wrapping it in a proxy.
+    # 
+    # @return [AttributeSet] attribute set
+    def all_attributes_simple(no_presence_check = true)
+      (ActiveModel::AttributeSet.new(attributes.keys) +
+      all_accessible_attributes(true) +
+      all_protected_attributes(true)  +
+      __vatrf(no_presence_check)).delete("")
+    end
+
+    # Returns a set containing all known attributes.
+    # 
     # @return [AttributeSet] attribute set
     def all_attributes
-      ActiveModel::AttributeSet::Query.new(AttributeSet.new(attributes.keys), self)
+      ActiveModel::AttributeSet::Query.new(all_attributes_simple, self)
     end
     alias_method :all_attributes_set, :all_attributes
 
     # Returns a set containing all accessible attributes.
+    # 
+    # @param simple [Boolean] optional parameter that disables
+    #   wrapping a resulting set in a proxy (defaults to +false+)
     # @return [AttributeSet] attribute set
-    def all_accessible_attributes
-      all_attributes & self.class.accessible_attributes
+    def all_accessible_attributes(simple = false)
+      c = self.class.class_eval { respond_to?(:accessible_attributes) ? accessible_attributes : [] }
+      simple ? AttributeSet.new(c) : AttributeSet::Query.new(c)
     end
     alias_method :accessible_attributes_set, :all_accessible_attributes
 
     # Returns a set containing all protected attributes.
+    # 
+    # @param simple [Boolean] optional parameter that disables
+    #   wrapping a resulting set in a proxy (defaults to +false+)
     # @return [AttributeSet] attribute set
-    def all_protected_attributes
-      all_attributes & self.class.protected_attributes
+    def all_protected_attributes(simple = false)
+      c = self.class.class_eval { respond_to?(:protected_attributes) ? protected_attributes : [] }
+      simple ? AttributeSet.new(c) : AttributeSet::Query.new(c)
     end
     alias_method :protected_attributes_set, :all_protected_attributes
 
     # Returns a set containing all attributes that are not accessible attributes.
     # @return [AttributeSet] attribute set
     def all_inaccessible_attributes
-      all_attributes - self.class.accessible_attributes
+      all_attributes - all_accessible_attributes(true)
     end
     alias_method :all_non_accessible_attributes,  :all_inaccessible_attributes
     alias_method :inaccessible_attributes_set,    :all_inaccessible_attributes
 
     # Gets all the defined attribute sets.
+    # 
     # @note Use +key+ method explicitly to check if the given set exists. The hash returned by this method
     #  will always return {AttributeSet} object. If there is no such set defined then the returned,
     #  matching set will be empty.
+    # 
     # @return [Hash{Symbol => AttributeSet<String>}] the collection of attribute sets indexed by their names
     def attribute_sets
-      self.class.attribute_sets
+      s = self.class.attribute_sets
+      s.merge!(s) do |set_name, set_object|
+        ActiveModel::AttributeSet::Query.new(set_object, self)
+      end
+      s.default = ActiveModel::AttributeSet::Query.new(ActiveModel::AttributeSet.new.freeze, self)
+      s
     end
     alias_method :attributes_sets, :attribute_sets
     alias_method :properties_sets, :attribute_sets
@@ -108,9 +160,11 @@ module ActiveModel
     alias_method :are_the_attributes,   :filtered_attribute
 
     # Gets all the defined attribute set names hashed by attribute names.
+    # 
     # @note Use +key+ method explicitly to check if the given attribute is assigned to any set. The hash
     #  returned by this method will always return {AttributeSet} object. If the attribute is not assigned
     #  to any set then the returned, matching set will be empty.
+    # 
     # @return [Hash{String => AttributeSet<Symbol>}] the collection of attribute set names indexed by attribute names
     def attributes_to_sets
       self.class.attributes_to_sets
@@ -121,13 +175,13 @@ module ActiveModel
     # that create DSL for managing attribute sets.
     module ClassMethods
       # @overload attribute_set()
-      #   Gets all the defined attribute sets.
+      #   Gets all the defined attribute sets by calling +attribute_sets+.
       #   @return [Hash{Symbol => AttributeSet<String>}] the collection of attribute sets indexed by their names
       # 
       # @overload attribute_set(set_name)
-      #   Gets the contents of an attribute set of the given name.
+      #   Gets the attribute set of the given name from internal storage.
       #   @param set_name [Symbol,String] name of a set
-      #   @return [AttributeSet<String>] the collection of attribute sets
+      #   @return [AttributeSet<String>] the attribute set
       # 
       # @overload attribute_set(set_name, *attribute_names)
       #   Adds new attributes to a set of attributes.
@@ -148,13 +202,12 @@ module ActiveModel
       #   @param attribute_names [Array<Symbol,String>] names of additional attributes to be stored in set
       #   @return [nil]
       def attribute_set(*args)
-        AttributeFiltersHelpers.check_wanted_methods(self)
         case args.size
         when 0
           attribute_sets
         when 1
           first_arg = args.first
-          if first_arg.is_a?(Hash)
+          if first_arg.is_a?(Hash) # multiple sets defined
             first_arg.each_pair { |k, v| attribute_set(k, v) }
             nil
           else
@@ -162,19 +215,13 @@ module ActiveModel
           end
         else
           first_arg = args.shift
-          if first_arg.is_a?(Hash)
+          if first_arg.is_a?(Hash) # multiple sets defined
             first_arg.each_pair do |k, v|
               attribute_set(k, v, args)
             end
           else
-            set_name = first_arg.to_sym
-            atrs = args.flatten.compact.map{|a|a.to_s}.freeze
-            atrs.each do |atr_name|
-              __attributes_to_sets_map[atr_name] ||= ActiveModel::AttributeSet.new
-              __attributes_to_sets_map[atr_name] << set_name
-            end
-            __attribute_sets[set_name] ||= ActiveModel::AttributeSet.new
-            __attribute_sets[set_name] << atrs
+            AttributeFiltersHelpers.check_wanted_methods(self)
+            add_atrs_to_set(first_arg.to_sym, *args)
           end
           nil
         end
@@ -236,7 +283,13 @@ module ActiveModel
           else
             first_arg = first_arg.to_s
             args.flatten.compact.each do |set_name|
-              attribute_set(set_name, first_arg)
+              if set_name.is_a?(Hash) # annotation
+                set_name.each_pair do |set_name_b, a_defs|
+                  attribute_set(set_name_b, first_arg => a_defs)
+                end
+              else
+                attribute_set(set_name, first_arg)
+              end
             end
           end
           nil
@@ -250,26 +303,34 @@ module ActiveModel
       alias_method :filtered_attributes,  :filter_attribute
 
       # Gets all the defined attribute sets.
+      # 
       # @note Use +key+ method explicitly to check if the given set exists. The hash returned by this method
       #  will always return {AttributeSet} object. If there is no such set defined then the returned,
-      #  matching set will be empty.
+      #  matching set will be empty. All set objects are duplicates of the defined sets.
+      # 
       # @return [Hash{Symbol => AttributeSet<String>}] the collection of attribute sets indexed by their names
       def attribute_sets
-        d = __attribute_sets.dup
-        d.default = ActiveModel::AttributeSet.new
+        d = Hash.new(ActiveModel::AttributeSet.new.freeze)
+        __attribute_sets.each_pair do |set_name, set_object|
+          d[set_name] = set_object.dup
+        end
         d
       end
       alias_method :attributes_sets, :attribute_sets
       alias_method :properties_sets, :attribute_sets
 
       # Gets all the defined attribute set names hashed by attribute names.
+      # 
       # @note Use +key+ method explicitly to check if the given attribute is assigned to any set. The hash
       #  returned by this method will always return {AttributeSet} object. If the attribute is not assigned
       #  to any set then the returned, matching set will be empty.
+      # 
       # @return [Hash{String => AttributeSet<Symbol>}] the collection of attribute set names indexed by attribute names
       def attributes_to_sets
-        d = __attributes_to_sets_map.dup
-        d.default = ActiveModel::AttributeSet.new
+        d = Hash.new(ActiveModel::AttributeSet.new.freeze)
+        __attributes_to_sets_map.each_pair do |set_name, set_object|
+          d[set_name] = set_object.dup
+        end
         d
       end
       alias_method :attribute_sets_map, :attributes_to_sets
@@ -284,6 +345,35 @@ module ActiveModel
         @__attribute_sets ||= Hash.new
       end
 
+      def add_atrs_to_set(set_name, *atrs)
+        atrs = atrs.flatten.compact
+        atrs.each do |atr_name|
+          if atr_name.is_a?(Hash) # annotation
+            atr_name.each_pair do |atr_name_b, a_defs|
+              add_atrs_to_set(set_name, atr_name_b)
+              s = __attribute_sets[set_name] and a_defs.nil? or a_defs.each_pair { |n, v| s.annotate(atr_name_b, n, v) }
+            end
+            return
+          else
+            atr_name = atr_name.to_s
+            __attributes_to_sets_map[atr_name] ||= ActiveModel::AttributeSet.new
+            __attributes_to_sets_map[atr_name] << set_name
+          end
+        end
+        __attribute_sets[set_name] ||= ActiveModel::AttributeSet.new
+        __attribute_sets[set_name] << atrs.map{ |a| a.to_s }.freeze
+      end
     end # module ClassMethods
+
+    private
+
+    # Helper that collects untracked virtual attributes that
+    # have setters and getters.
+    def __vatrf(no_presence_check = false)
+      tar = self.class.send(:__treat_as_real)
+      return tar if no_presence_check || tar.empty?
+      tar.select { |a| respond_to?(a) && respond_to?("#{a}=") }
+    end
+
   end # module AttributeMethods
 end # module ActiveModel

data/lib/attribute-filters/helpers.rb

@@ -35,6 +35,20 @@ module ActiveModel
       end
       module_function :check_wanted_methods
 
+      # @private
+      def each_element(value, must_be = nil, &block)
+        if value.is_a?(Array)
+          value.map { |v| each_element(v, must_be, &block) }
+        elsif value.is_a?(Hash)
+          value.merge(value) { |k, ov| each_element(ov, must_be, &block) }
+        elsif must_be.nil? || value.is_a?(must_be)
+          yield(value)
+        else
+          value
+        end
+      end
+      module_function :each_element
+
     end # module AttributeFiltersHelpers
   end # module AttributeFilters
 end # module ActiveModel

data/lib/attribute-filters/version.rb

@@ -14,7 +14,7 @@ module ActiveModel
     # @private
     EMAIL       = 'pw@gnu.org'
     # @private
-    VERSION     = '1.3.2'
+    VERSION     = '1.4.0'
     # @private
     NAME        = 'attribute-filters'
     # @private

data/spec/attribute-filters_spec.rb

@@ -6,9 +6,16 @@ describe ActiveModel::AttributeFilters do
 
   describe TestModel do
     before do
+      TestModel.attributes_that(:should_be_stripped, :email, :real_name)
+      TestModel.attributes_that(:should_be_titleized, :real_name)
       @tm = TestModel.new
     end
 
+    it "should return list of sets attribute belongs to" do
+      @tm.the_attribute(:email).should include :should_be_stripped
+      @tm.the_attribute('email').should include :should_be_stripped
+    end
+
     it "should be able to filter model attributes properly" do
       @tm.username          = " UPCASEĄĘŚĆ      "
       @tm.email             = " Some@EXAMPLE.com   "
@@ -19,6 +26,16 @@ describe ActiveModel::AttributeFilters do
       @tm.real_name.should  == "Sir Rails"
     end
 
+    it "should filter model attributes that are arrays" do
+      @tm.username          = [" UPCASEĄĘŚĆ      "]
+      @tm.email             = [" Some@EXAMPLE.com   ", "  x "]
+      @tm.real_name         = ["       sir    rails ", nil]
+      @tm.save
+      @tm.username.should   == ["upcaseąęść"]
+      @tm.email.should      == ["Some@EXAMPLE.com", "x"]
+      @tm.real_name.should  == ["Sir Rails", nil]
+    end
+
     it "should not filter model attributes that are blank" do
       @tm.username = nil
       @tm.save
@@ -45,19 +62,323 @@ describe ActiveModel::AttributeFilters do
       @tm.test_attribute.should == 'unchanged'
     end
 
+    it "should operate on annotations" do
+      s = @tm.attributes_that(:should_be_stripped)
+      c = @tm.attributes_that(:should_be_titleized)
+      s.annotate(:real_name, :operation, :first_value)
+      s.annotate(:email,     :operation, :e_value)
+      c.annotate(:real_name, :operation, :some_value)
+      c.annotate(:real_name, :operation, :other_value)
+      s.instance_eval{annotations}.should ==  { 'real_name' => { :operation => :first_value }, 'email' => { :operation => :e_value } }
+      c.instance_eval{annotations}.should ==  { 'real_name' => { :operation => :other_value } }
+      -> {TestModel.class_eval do
+        attributes_that should_be_sth: [ :abc, :atr_one => {:ak => "av"}, :atr_two => {:sk => "sv"} ]
+        attributes_that should_be_sth: [:atr_three, :atr_two, :yy]
+        attributes_that should_be_sth: {:atr_three => {:fak => "fav"}, :atr_two => {:flala => "flala2"}, :fyy => nil}
+        annotate_attribute_set should_be_sth: {:atr_three => {:ak => "av"}, :atr_two => {:lala => "lala2"}, :yy => nil}
+        annotate_attribute_set should_be_sth: [:atr_three, :oo => "oe"]
+        annotate_attribute_set should_be_sth: [:atr_three, :aa, "bb"]
+        annotate_attribute_set should_be_sth: [:atr_three, :hh, "hh"]
+        annotate_attributes_that :should_be_sth, :atr_three, :six => 6
+        annotate_attribute_set :should_be_sth => [:atr_three, :cc, "dd"]
+        annotate_attribute_set :should_be_sth => [:atr_three, :ccc, "ddd"]
+        delete_annotation_from_set :should_be_sth, :atr_three, :ccc
+        delete_annotation_from_set :should_be_sth => { :atr_three => [ :hh ] }
+      end}.should_not raise_error
+      @tm.attributes_that(:should_be_sth).annotation(:atr_one).should == {:ak => "av"}
+      @tm.attributes_that(:should_be_sth).annotation(:atr_two, :lala).should == "lala2"
+      @tm.attributes_that(:should_be_sth).annotation(:atr_x, :lalax).should == nil
+      @tm.attributes_that(:should_be_sth).annotation(:atr_three, :oo).should == "oe"
+      @tm.attributes_that(:should_be_sth).annotation(:atr_three, :aa).should == "bb"
+      @tm.attributes_that(:should_be_sth).annotation(:atr_three, :cc).should == "dd"
+      @tm.attributes_that(:should_be_sth).annotation(:atr_three, :ccc).should == nil
+      @tm.attributes_that(:should_be_sth).annotation(:atr_three, :six).should == 6
+      @tm.attributes_that(:should_be_sth).has_annotations?.should == true
+      @tm.attributes_that(:should_be_sth).has_annotation?(:atr_three).should == true
+      @tm.attributes_that(:should_be_sth).has_annotation?(:atr_three, :ak).should == true
+      @tm.attributes_that(:should_be_sth).has_annotation?(:atr_nope).should == false
+      @tm.attributes_that(:should_be_sth).has_annotation?(:atr_three, :nope).should == false
+      @tm.attributes_that(:should_be_sth).delete_annotation(:atr_three, :cc)
+      @tm.attributes_that(:should_be_sth).annotation(:atr_three, :cc).should == "dd"
+      @tm.attributes_that(:should_be_sth).annotation(:atr_three, :hh).should == nil
+      dupx = TestModel.attributes_that(:should_be_sth)
+      dupy = @tm.attributes_that(:should_be_sth)
+      dupx.send(:annotations).should == dupy.send(:annotations) 
+      dupx.object_id.should_not == dupy.object_id
+      -> {TestModel.class_eval do
+        annotate_attributes_that :should_be_sth => { :atr_three => { :cc => "ee" } }
+        annotate_attribute_set should_be_sth: [:atr_three, :oo => "of"]
+        attributes_that should_be_sth: { :atr_one => {:ak => "ax"} }
+      end}.should_not raise_error
+      @tm.attributes_that(:should_be_sth).annotation(:atr_three, :cc).should == "ee"
+      @tm.attributes_that(:should_be_sth).annotation(:atr_three, :oo).should == "of"
+      @tm.attributes_that(:should_be_sth).annotation(:atr_one).should == {:ak => "ax"}
+      @tm.attributes_that(:should_be_sth).annotation(:atr_two, :lala).should == "lala2"
+    end
+  end
+
+  describe "AttributeSet set operations" do
+    before do
+      TestModel.attributes_that(:should_be_stripped, :email, :real_name)
+      TestModel.attributes_that(:should_be_titleized, :real_name)
+      @tm = TestModel.new
+      @s = @tm.attributes_that(:should_be_stripped)
+      @c = @tm.attributes_that(:should_be_titleized)
+      @s.annotate(:real_name, :operation, :first_value)
+      @s.annotate(:email,     :operation, :e_value)
+      @c.annotate(:real_name, :operation, :some_value)
+      @c.annotate(:real_name, :operation, :other_value)
+    end
+  
+    it "should be able to relatively complement sets" do
+      r = @s - @c
+      r.to_a.sort.should == [ "email", "username" ]
+      r.instance_eval{annotations}.should == { 'email' => { :operation => :e_value } }
+    end
+  
+    it "should be able to join sets (union)" do
+      r = @s + @c
+      r.to_a.sort.should == [ "email", "real_name", "username" ]
+      r.instance_eval{annotations}.should == { 'email' => { :operation => :e_value }, 'real_name' => { :operation => :first_value } }
+    end
+  
+    it "should be able to intersect sets" do
+      r = @s & @c
+      r.to_a.sort.should == [ "real_name" ]
+      r.instance_eval{annotations}.should == { 'real_name' => { :operation => :first_value } }
+    end
+  
+    it "should be able to exclusively disjunct sets" do
+      r = @s ^ @c
+      r.to_a.sort.should == [ "email", "username" ]
+      r.instance_eval{annotations}.should == { 'email' => { :operation => :e_value } }
+      sp = @s.dup
+      sp.annotate(:username, 'k', 'v')
+      r = sp ^ @c
+      r.to_a.sort.should == [ "email", "username" ]
+      r.instance_eval{annotations}.should == { 'email' => { :operation => :e_value }, 'username' => { :k => "v" } }
+    end
+  
+    it "should be able to delete elements from a set" do
+      @s.annotate(:username, :some_key, 'string_val')
+      @s.instance_eval{annotations}.should == { 'email' => { :operation => :e_value }, 'real_name' => { :operation => :first_value },
+                                 'username' => { :some_key => 'string_val' } }
+      @s.delete_if { |o| o == 'username' }
+      @s.include?('username').should == false
+      @s.instance_eval{annotations}.should == { 'email' => { :operation => :e_value }, 'real_name' => { :operation => :first_value } }
+    end
+  
+    it "should be able to keep elements in a set using keep_if" do
+      @s.keep_if { |o| o == 'email' }
+      @s.include?('email').should == true
+      @s.instance_eval{annotations}.should == { 'email' => { :operation => :e_value } }
+    end
   end
 
-  # do the above with ActiveRecord -- look in heisepath for testing examples
-      #it "is able to filter model attributes with Active Record as ORM" do
-      #  @tm = TestModelAR.new
-      #  @tm.username  = " UPCASEĄĘŚĆ      "
-      #  @tm.email     = " Some@EXAMPLE.com   "
-      #  @tm.real_name = "       sir    rails "
-      #  -> { @tm.save }.should_not raise_error
-      #  @tm.username.should   == "upcaseąęść"
-      #  @tm.email.should      == "Some@EXAMPLE.com"
-      #  @tm.real_name.should  == "Sir Rails"
-      #end
-      
+  describe ActiveModel::AttributeFilters::Common do
+
+    before do
+      TestModel.class_eval do
+        include ActiveModel::AttributeFilters::Common
+        @__attribute_sets = nil
+      end
+      @tm = TestModel.new
+    end
+
+    after do
+      TestModel.class_eval{@__attribute_sets = nil}
+      @tm.attributes_that(:should_be_splitted).should be_empty
+      @tm.attributes_that(:should_be_joined).should be_empty
+      @tm.attributes_that(:should_be_splitted).annotation(:real_name).should == nil
+      @tm.attributes_that(:should_be_joined).annotation(:real_name).should == nil 
+    end
+
+    shared_examples "splitting" do |ev|
+      before { TestModel.class_eval{before_save :split_attributes} }
+      it "should split attributes using syntax: #{ev}" do
+        TestModel.class_eval(ev)
+        @tm.real_name = "Paweł Wilk Trzy"
+        @tm.first_name = nil
+        @tm.last_name = nil
+        #-> { @tm.save }.should_not raise_error
+        @tm.save
+        @tm.first_name.should == 'Paweł'
+        @tm.last_name.should == 'Wilk'
+        @tm.first_name = nil
+        @tm.last_name = nil
+        @tm.real_name = "Paweł"
+        -> { @tm.save }.should_not raise_error
+        @tm.first_name.should == 'Paweł'
+        @tm.last_name.should == nil
+      end
+    end
+
+    shared_examples "splitting_array" do |de, ev, rn|
+      before do
+        TestModel.class_eval{before_save :split_attributes}
+      end
+      it "should split array attribute #{de}" do
+        TestModel.class_eval(ev)
+        @tm.real_name = rn
+        @tm.first_name = nil
+        @tm.last_name = nil
+        -> { @tm.save }.should_not raise_error
+        @tm.first_name.should == 'Paweł'
+        @tm.last_name.should == 'Wilk'
+      end
+    end
+
+    context "with split_attribute" do
+      include_examples "splitting", "split_attribute :real_name => [ :first_name, :last_name ]"
+      include_examples "splitting", "split_attribute :real_name, [ :first_name, :last_name ]"
+      include_examples "splitting", "split_attribute :real_name => { :into => [ :first_name, :last_name ] }"
+      include_examples "splitting", "split_attribute :real_name, :into => [ :first_name, :last_name ]"
+    end
+
+    context "with attributes_that" do
+      include_examples "splitting", "attributes_that :should_be_splitted => { :real_name => { :split_into => [:first_name, :last_name] } }"
+      include_examples "splitting", "attributes_that :should_be_splitted => [ :real_name => { :split_into => [:first_name, :last_name] } ]"
+    end
+
+    context "with the_attribute" do
+      include_examples "splitting", "the_attribute :real_name => { :should_be_splitted => { :split_into => [:first_name, :last_name] } }"
+      include_examples "splitting", "the_attribute :real_name => [ :should_be_splitted => { :split_into => [:first_name, :last_name] } ]"
+      include_examples "splitting", "the_attribute :real_name, [ :should_be_splitted => { :split_into => [:first_name, :last_name] } ]"
+    end
     
-end
+    context "with no pattern and no limit" do
+      include_examples "splitting_array", "", "split_attribute :real_name => { :into => [ :first_name, :last_name ], :flatten => true }",
+                                          ["Paweł", "Wilk", "Trzy"]
+    end
+
+    context "with a single space pattern and without a limit" do
+      include_examples  "splitting_array", "having 3 elements",
+                        "split_attribute :real_name => {:pattern => ' ', :into => [ :first_name, :last_name ], :flatten => true}",
+                        ["Paweł", "Wilk", "Trzy"]
+      include_examples  "splitting_array", "having 2 elements and first containing pattern (space)",
+                        "split_attribute :real_name => {:pattern => ' ', :into => [ :first_name, :last_name ], :flatten => true}",
+                        ["Paweł Wilk", "Trzy"]
+    end
+
+    context "with a single space pattern and with a limit" do
+      include_examples  "splitting_array", "having 3 elements",
+                        "split_attribute :real_name => {:pattern => ' ', :limit => 2, :into => [ :first_name, :last_name ], :flatten => true}",
+                        ["Paweł", "Wilk", "Trzy"]
+      include_examples  "splitting_array", "having 2 elements and first containing pattern (space)",
+                        "split_attribute :real_name => {:pattern => ' ', :limit => 2, :into => [ :first_name, :last_name ], :flatten => true}",
+                        ["Paweł Wilk", "Trzy"]
+      include_examples  "splitting_array", "having 2 elements and first containing pattern (space)",
+                        "split_attribute :real_name => {:pattern => ' ', :limit => 10, :into => [ :first_name, :last_name ], :flatten => true}",
+                        ["Paweł", "Wilk"]
+      include_examples  "splitting_array", "having 1 element and first containing pattern (space)",
+                        "split_attribute :real_name => {:pattern => ' ', :limit => 2, :into => [ :first_name, :last_name ], :flatten => true}",
+                        ["Paweł Wilk"]
+      it "should split array attribute having 2 elements and second containing pattern (space)" do
+        TestModel.class_eval{split_attribute :real_name => {:pattern => ' ', :limit => 2, :into => [ :first_name, :last_name ], :flatten => true}}
+        @tm.real_name = ["Paweł", "Wilk Trzy", "Cztery"]
+        @tm.first_name = nil
+        @tm.last_name = nil
+        -> { @tm.save }.should_not raise_error
+        @tm.first_name.should == 'Paweł'
+        @tm.last_name.should == 'Wilk'
+      end
+    end
+
+    context "without a pattern and with a limit" do
+      include_examples  "splitting_array", "having 3 elements",
+                        "split_attribute :real_name => {:limit => 2, :into => [ :first_name, :last_name ], :flatten => true}",
+                        ["Paweł", "Wilk", "Trzy"]
+      include_examples  "splitting_array", "having 2 elements",
+                        "split_attribute :real_name => {:limit => 2, :into => [ :first_name, :last_name ], :flatten => true}",
+                        ["Paweł", "Wilk"]
+    end
+
+    it "should split array attribute with the destination in the same place" do
+      TestModel.class_eval{split_attribute :real_name => { :flatten => true } }
+      TestModel.class_eval{before_save :split_attributes}
+      @tm.real_name = ["Paweł", "Wilk Trzy", "Cztery"]
+      @tm.first_name = nil
+      @tm.last_name = nil
+      -> { @tm.save }.should_not raise_error
+      @tm.first_name.should == nil
+      @tm.last_name.should == nil
+      @tm.real_name.should == ["Paweł", "Wilk", "Trzy", "Cztery"]
+
+      TestModel.class_eval{split_attribute :real_name => {:limit => 2}}
+      @tm.real_name = ["Paweł", "Wilk Trzy Osiem Dziewiec", "Cztery"]
+      -> { @tm.save }.should_not raise_error
+      @tm.real_name.should == [["Paweł"], ["Wilk", "Trzy Osiem Dziewiec"], ["Cztery"]]
+
+      TestModel.class_eval{split_attribute :real_name => {:limit => 2, :pattern => ' '}}
+      @tm.real_name = ["Paweł", "Wilk Trzy", "Cztery"]
+      -> { @tm.save }.should_not raise_error
+      @tm.real_name.should == [["Paweł"], ["Wilk", "Trzy"], ["Cztery"]]
+
+      TestModel.class_eval{split_attribute :real_name => {:pattern => ' '}}
+      @tm.real_name = ["Paweł", "Wilk Trzy", "Cztery"]
+      -> { @tm.save }.should_not raise_error
+      @tm.real_name.should == [["Paweł"], ["Wilk", "Trzy"], ["Cztery"]]
+    end
+
+    shared_examples "joining" do |ev,rn,rns,rnt|
+      before do
+        TestModel.class_eval do
+          before_save :join_attributes
+        end
+      end
+      it "should join attributes using syntax: #{ev}" do
+        TestModel.class_eval(ev)
+        # source attributes are strings:
+        @tm.real_name = rn
+        @tm.first_name = "Paweł"
+        @tm.last_name = "Wilk"
+        -> { @tm.save }.should_not raise_error
+        @tm.first_name.should == 'Paweł'
+        @tm.last_name.should == 'Wilk'
+        @tm.real_name.should == 'Paweł Wilk'
+        # source attributes are strings and nils:
+        @tm.first_name = "Paweł"
+        @tm.last_name = nil
+        @tm.real_name = rns
+        @tm.class.annotate_attributes_that(:should_be_joined, :real_name, :join_compact, true)
+        -> { @tm.save }.should_not raise_error
+        @tm.first_name.should == 'Paweł'
+        @tm.last_name.should == nil
+        @tm.real_name.should == 'Paweł'
+        # source attributes are arrays and strings:
+        @tm.first_name = ["Paweł", "Wilk"]
+        @tm.last_name = "Trzeci"
+        @tm.real_name = rnt
+        -> { @tm.save }.should_not raise_error
+        @tm.real_name.should == 'Paweł Wilk Trzeci'
+        
+      end
+    end
+
+    context "with join_attributes" do
+      include_examples "joining", "join_attributes :real_name", ["Paweł", "Wilk"], ["Paweł"], ["Paweł", "Wilk", "Trzeci"] 
+      include_examples "joining", "join_attributes :real_name", ["Paweł Wilk"], ["Paweł"], ["Paweł Wilk", "Trzeci"]
+      include_examples "joining", "join_attributes :real_name", "Paweł Wilk", "Paweł", "Paweł Wilk Trzeci"
+      include_examples "joining", "join_attributes :real_name => [ :first_name, :last_name ]"
+      include_examples "joining", "join_attributes :real_name, [ :first_name, :last_name ]"
+      include_examples "joining", "join_attributes :real_name => { :from => [ :first_name, :last_name ] }"
+      include_examples "joining", "join_attributes :real_name, :from => [ :first_name, :last_name ]"
+      include_examples "joining", "join_attributes [ :first_name, :last_name ] => :real_name"
+      include_examples "joining", "join_attributes [ :first_name, :last_name ], :real_name"
+      include_examples "joining", "join_attributes [ :first_name, :last_name ] => { :into => :real_name }"
+    end
+
+    context "with attributes_that" do
+      include_examples "joining", "attributes_that :should_be_joined => { :real_name => { :join_from => [:first_name, :last_name] } }"
+      include_examples "joining", "attributes_that :should_be_joined => [ :real_name => { :join_from => [:first_name, :last_name] } ]"
+    end
+
+    context "with the_attribute" do
+      include_examples "joining", "the_attribute :real_name => { :should_be_joined => { :join_from => [:first_name, :last_name] } }"
+      include_examples "joining", "the_attribute :real_name => [ :should_be_joined => { :join_from => [:first_name, :last_name] } ]"
+      include_examples "joining", "the_attribute :real_name, [ :should_be_joined => { :join_from => [:first_name, :last_name] } ]"
+    end
+
+  end # describe ActiveModel::AttributeFilters::Common
+
+end # describe ActiveModel::AttributeFilters