HornsAndHooves-moribus 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e5e4d15715c31a7fc3c7fbc7e5374f27271d735a
-  data.tar.gz: def9ae949ad1d956852b70e23f8652bd2d977f42
+  metadata.gz: cd6054e76e011057a8862362538096a93e561ab1
+  data.tar.gz: 4aba542cca9591c5766a24a6513dc8b793545e80
 SHA512:
-  metadata.gz: dc9fe7bfc87c9a2be5e04781d5345c87bb3b10ba6ed9925641cb60bc80e1e93eb07a1a737c9ffbf2e9e60872451753a27cd42e601245741f85b7b47f26a3c4bc
-  data.tar.gz: c26e4d4ab22786a432b6d6aec34d932b2466b921a0c860b5bf71cd67c9811872bc9c492950e65c0dd3f0aa0406be5d48aa3c681e80a8153928eb1fd2d9872f83
+  metadata.gz: 8f53fb45401fc981d4add1c06d91ffdf6aa15276a203a5ddfd318b4a6154520942436d2ffdb22243f47000a09afdae364ee1c42619eaa40d9240f1257b226092
+  data.tar.gz: 24f83c44a0e8a9d4abaae44f2167a77110b86ab8766bfb44be54e45ffdc93919f00e4daeded5d5a0d33bfe00b7874a31006bb19d4144bacbb939c8e10750e58a

data/.simplecov

@@ -12,7 +12,7 @@ SimpleCov.start do
   # Fail the build when coverage is weak:
   at_exit do
     SimpleCov.result.format!
-    threshold, actual = 97.15, SimpleCov.result.covered_percent
+    threshold, actual = 97.354, SimpleCov.result.covered_percent
     if actual < threshold
       msg = "\nLow coverage: "
       msg << red("#{actual}%")

data/lib/moribus.rb

@@ -22,6 +22,8 @@ module Moribus
 
   # :nodoc:
   module ClassMethods
+    attr_reader :parent_relation_keys
+
     # Adds aggregated behavior to a model.
     def acts_as_aggregated(options = {})
       options.symbolize_keys!
@@ -44,10 +46,11 @@ module Moribus
     def acts_as_tracked(options = {})
       options.symbolize_keys!
 
-      options.assert_valid_keys(:preceding_key)
+      options.assert_valid_keys(:preceding_key, :by)
       include TrackedBehavior
 
       @preceding_key_column = options[:preceding_key]
+      @parent_relation_keys = get_parent_relation_keys(options[:by])
     end
     private :acts_as_tracked
 
@@ -60,6 +63,21 @@ module Moribus
     def acts_as_tracked?
       self < TrackedBehavior
     end
+
+    # Return array of parent relation foreign keys, which is used for lock_version calculation.
+    #
+    # @param parent [Symbol,Array<Symbol>]
+    # @return [Array<String>]
+    def get_parent_relation_keys(parent)
+      parents = Array(parent)
+
+      reflect_on_all_associations.inject([]) do |result, relation|
+        result << relation.foreign_key if parents.include?(relation.name)
+
+        result
+      end
+    end
+    private :get_parent_relation_keys
   end
 
   # Marks +self+ as a new record. Sets +id+ attribute to nil, but memorizes

data/lib/moribus/extensions/has_current_extension.rb

@@ -9,7 +9,18 @@ module Moribus
         if target.new_record?
           target.is_current = false
         else
-          target.update_attribute(:is_current, false)
+          # Use custom update to avoid running ActiveRecord optimistic locking
+          # and to avoid updating lock_version column:
+          klass          = target.class
+          is_current_col = klass.columns.detect { |c| c.name == "is_current" }
+          id_column      = klass.columns.detect { |c| c.name == klass.primary_key }
+
+          sql =  "UPDATE #{klass.quoted_table_name} " \
+                 "SET \"is_current\" = #{klass.quote_value(false, is_current_col)} "
+          sql << "WHERE #{klass.quoted_primary_key} = " \
+                 "#{klass.quote_value(target.send(klass.primary_key), id_column)} "
+
+          klass.connection.update sql
         end
       end
     end

data/lib/moribus/tracked_behavior.rb

@@ -29,11 +29,16 @@ module Moribus
         begin
           # SQL UPDATE statement is executed in first place to prevent
           # crashing on uniqueness constraints with 'is_current' condition.
-          yield if update_current
+          if update_current
+            set_lock
+            yield
+          end
         ensure
           to_persistent! if new_record?
         end
       else
+        set_lock if new_record?
+
         yield
       end
     end
@@ -50,7 +55,9 @@ module Moribus
     # optimistic locking behavior.
     def update_current
       statement = current_to_false_sql_statement
+
       affected_rows = self.class.connection.update statement
+
       unless affected_rows == 1
         raise ActiveRecord::StaleObjectError.new(self, "update_current")
       end
@@ -58,6 +65,24 @@ module Moribus
     end
     private :update_current
 
+    # Set incremental lock_version column.
+    def set_lock
+      klass = self.class
+      lock_column_name = klass.locking_column
+
+      if has_attribute?(lock_column_name) && klass.parent_relation_keys.count > 0
+        criteria = klass.parent_relation_keys.inject({}) do |result, parent_key|
+          result[parent_key] = read_attribute(parent_key)
+          result
+        end
+
+        lock_value = klass.unscoped.where(criteria).count
+
+        write_attribute(lock_column_name, lock_value)
+      end
+    end
+    private :set_lock
+
     # Generate an arel statement to update the 'is_current' state of the
     # record to false. And perform the very same actions AR does for record
     # update, but using only a single 'is_current' column.
@@ -76,11 +101,12 @@ module Moribus
     # private :current_to_false_arel_statement
 
     # Generate SQL statement to be used to update 'is_current' state of record to false.
+    # TODO: need to find way to track stale objects
     def current_to_false_sql_statement
       klass              = self.class
       is_current_col     = klass.columns.detect { |c| c.name == "is_current" }
       lock_column_name   = klass.locking_column
-      lock_value         = respond_to?(lock_column_name) && send(lock_column_name).to_i
+      lock_value         = has_attribute?(lock_column_name) && read_attribute(lock_column_name).to_i
       lock_column        = if lock_value
                              klass.columns.detect { |c| c.name == lock_column_name }
                            else
@@ -89,10 +115,15 @@ module Moribus
       id_column          = klass.columns.detect { |c| c.name == klass.primary_key }
       quoted_lock_column = klass.connection.quote_column_name(lock_column_name)
 
-      "UPDATE #{klass.quoted_table_name} SET \"is_current\" = #{klass.quote_value(false, is_current_col)} ".tap do |sql|
-        sql << ", #{quoted_lock_column} = #{klass.quote_value(lock_value + 1, lock_column)} " if lock_value
-        sql << "WHERE #{klass.quoted_primary_key} = #{klass.quote_value(@_before_to_new_record_values[:id], id_column)} "
-        sql << "AND #{quoted_lock_column} = #{klass.quote_value(lock_value, lock_column)}" if lock_value
+      "UPDATE #{klass.quoted_table_name} " \
+      "SET \"is_current\" = #{klass.quote_value(false, is_current_col)} ".tap do |sql|
+        sql << "WHERE #{klass.quoted_primary_key} = " \
+               "#{klass.quote_value(@_before_to_new_record_values[:id], id_column)}"
+
+        if lock_value
+          sql << " AND \"is_current\" = #{klass.quote_value(true, is_current_col)}"
+          sql << " AND #{quoted_lock_column} = #{klass.quote_value(lock_value, lock_column)}"
+        end
       end
     end
     private :current_to_false_sql_statement

data/lib/moribus/version.rb

@@ -1,3 +1,3 @@
 module Moribus # :nodoc:
-  VERSION = "0.2.1" # :nodoc:
+  VERSION = "0.3.0" # :nodoc:
 end

data/merge.patch

@@ -0,0 +1,22 @@
+diff --git a/.simplecov b/.simplecov
+index d428836..a242fb5 100644
+--- a/.simplecov
++++ b/.simplecov
+@@ -12,7 +12,7 @@ SimpleCov.start do
+   # Fail the build when coverage is weak:
+   at_exit do
+     SimpleCov.result.format!
+-    threshold, actual = 97.15, SimpleCov.result.covered_percent
++    threshold, actual = 97.354, SimpleCov.result.covered_percent
+     if actual < threshold
+       msg = "\nLow coverage: "
+       msg << red("#{actual}%")
+diff --git a/lib/moribus/version.rb b/lib/moribus/version.rb
+index 20963da..629a05d 100644
+--- a/lib/moribus/version.rb
++++ b/lib/moribus/version.rb
+@@ -1,3 +1,3 @@
+ module Moribus # :nodoc:
+-  VERSION = "0.2.1" # :nodoc:
++  VERSION = "0.3.0" # :nodoc:
+ end

data/spec/moribus_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Moribus do
   before do
@@ -6,29 +6,32 @@ describe Moribus do
       acts_as_enumerated
 
       self.enumeration_model_updates_permitted = true
-      create!(:name => 'inactive', :description => 'Inactive')
-      create!(:name => 'active', :description => 'Active')
+      create!(:name => "inactive", :description => "Inactive")
+      create!(:name => "active"  , :description => "Active")
     end
 
     class SpecType < MoribusSpecModel(:name => :string, :description => :string)
       acts_as_enumerated
 
       self.enumeration_model_updates_permitted = true
-      create!(:name => 'important', :description => 'Important')
-      create!(:name => 'unimportant', :description => 'Unimportant')
+      create!(:name => "important"  , :description => "Important")
+      create!(:name => "unimportant", :description => "Unimportant")
     end
 
     class SpecSuffix < MoribusSpecModel(:name => :string, :description => :string)
       acts_as_enumerated
 
       self.enumeration_model_updates_permitted = true
-      create!(:name => 'none', :description => '')
-      create!(:name => 'jr', :description => 'Junior')
+      create!(:name => "none", :description => "")
+      create!(:name => "jr"  , :description => "Junior")
     end
 
-    class SpecPersonName < MoribusSpecModel(:first_name => :string, :last_name => :string, :spec_suffix_id => :integer)
+    class SpecPersonName < MoribusSpecModel(:first_name     => :string,
+                                            :last_name      => :string,
+                                            :spec_suffix_id => :integer
+                                          )
       acts_as_aggregated
-      has_enumerated :spec_suffix, :default => ''
+      has_enumerated :spec_suffix, :default => ""
 
       validates_presence_of :first_name, :last_name
 
@@ -42,7 +45,8 @@ describe Moribus do
       acts_as_aggregated :cache_by => :feature_name
     end
 
-    class SpecCustomerInfo < MoribusSpecModel( :spec_customer_id    => :integer!,
+    class SpecCustomerInfo < MoribusSpecModel(
+                                        :spec_customer_id    => :integer!,
                                         :spec_person_name_id => :integer,
                                         :spec_status_id      => :integer,
                                         :spec_type_id        => :integer,
@@ -50,7 +54,8 @@ describe Moribus do
                                         :lock_version        => :integer,
                                         :created_at          => :datetime,
                                         :updated_at          => :datetime,
-                                        :previous_id         => :integer )
+                                        :previous_id         => :integer
+                              )
       attr :custom_field
 
       belongs_to :spec_customer, :inverse_of => :spec_customer_info, :touch => true
@@ -58,17 +63,40 @@ describe Moribus do
       has_enumerated :spec_status
       has_enumerated :spec_type
 
-      acts_as_tracked :preceding_key => :previous_id
+      acts_as_tracked :by => :spec_customer, :preceding_key => :previous_id
+    end
+
+    class SpecCustomerInfoWithType < MoribusSpecModel(
+                                        :spec_customer_id    => :integer!,
+                                        :spec_status_id      => :integer,
+                                        :spec_type_id        => :integer,
+                                        :is_current          => :boolean,
+                                        :lock_version        => :integer,
+                                        :created_at          => :datetime,
+                                        :updated_at          => :datetime
+                                      )
+      attr :custom_field
+
+      belongs_to :spec_customer, :inverse_of => :spec_customer_info_with_type, :touch => true
+      has_enumerated :spec_status
+      has_enumerated :spec_type
+
+      acts_as_tracked :by => [:spec_customer, :spec_type]
     end
 
     class SpecCustomer < MoribusSpecModel(:spec_status_id => :integer)
       has_one_current :spec_customer_info, :inverse_of => :spec_customer
-      has_enumerated :spec_status, :default => 'inactive'
+      has_one_current :spec_customer_info_with_type, :inverse_of => :spec_customer
+      has_enumerated :spec_status, :default => "inactive"
 
       delegate_associated :spec_person_name, :custom_field, :spec_type, :to => :spec_customer_info
     end
 
-    class SpecCustomerEmail < MoribusSpecModel(:spec_customer_id => :integer, :email => :string, :is_current => :boolean, :status => :string)
+    class SpecCustomerEmail < MoribusSpecModel(:spec_customer_id => :integer,
+                                               :email            => :string,
+                                               :is_current       => :boolean,
+                                               :status           => :string
+                                              )
       connection.add_index table_name, [:email, :is_current], :unique => true
 
       belongs_to :spec_customer
@@ -84,18 +112,19 @@ describe Moribus do
   describe "common behavior" do
     before do
       @info = SpecCustomerInfo.create(
-        :spec_customer_id => 1,
+        :spec_customer_id    => 1,
         :spec_person_name_id => 1,
-        :is_current => true,
-        :created_at => 5.days.ago,
-        :updated_at => 5.days.ago
+        :is_current          => true,
+        :created_at          => 5.days.ago,
+        :updated_at          => 5.days.ago
       )
     end
 
     it "should revert changes if exception is raised" do
-      old_id = @info.id
+      old_id         = @info.id
       old_updated_at = @info.updated_at
       old_created_at = @info.created_at
+
       suppress(Exception) do
         expect {
           @info.update_attributes :spec_customer_id => nil, :spec_person_name_id => 2
@@ -108,7 +137,7 @@ describe Moribus do
     end
   end
 
-  describe 'Aggregated' do
+  describe "Aggregated" do
     context "definition" do
       it "should raise an error on an unknown option" do
         expect{
@@ -128,111 +157,121 @@ describe Moribus do
     end
 
     before do
-      @existing = SpecPersonName.create! :first_name => 'John', :last_name => 'Smith'
+      @existing = SpecPersonName.create! :first_name => "John", :last_name => "Smith"
     end
 
-    it "should not duplicate records" do
+    it "doesn't duplicate records" do
       expect {
-        SpecPersonName.create :first_name => ' John ', :last_name => 'Smith'
+        SpecPersonName.create :first_name => " John ", :last_name => "Smith"
       }.not_to change(SpecPersonName, :count)
     end
 
-    it "should lookup self and replace id with existing on create" do
-      name = SpecPersonName.new :first_name => 'John', :last_name => 'Smith'
+    it "looks up self and replaces id with existing on create" do
+      name = SpecPersonName.new :first_name => "John", :last_name => "Smith"
       name.save
       expect(name.id).to eq @existing.id
     end
 
-    it "should create a new record if lookup fails" do
+    it "creates a new record if lookup fails" do
       expect {
-        SpecPersonName.create :first_name => 'Alice', :last_name => 'Smith'
+        SpecPersonName.create :first_name => "Alice", :last_name => "Smith"
       }.to change(SpecPersonName, :count).by(1)
     end
 
-    it "should lookup self and replace id with existing on update" do
-      name = SpecPersonName.create :first_name => 'Alice', :last_name => 'Smith'
-      name.update_attributes :first_name => 'John'
+    it "looks up self and replaces id with existing on update" do
+      name = SpecPersonName.create :first_name => "Alice", :last_name => "Smith"
+      name.update_attributes :first_name => "John"
       expect(name.id).to eq @existing.id
     end
 
     context "with caching" do
       before do
-        @existing = SpecCustomerFeature.create(:feature_name => 'Pays')
+        @existing = SpecCustomerFeature.create(:feature_name => "Pays")
         SpecCustomerFeature.clear_cache
       end
 
-      it "should lookup the existing value and add it to the cache" do
+      it "looks up the existing value and adds it to the cache" do
         feature = SpecCustomerFeature.new :feature_name => @existing.feature_name
-        expect{ feature.save }.to change(SpecCustomerFeature.aggregated_records_cache, :length).by(1)
+
+        expect{ feature.save }.
+          to change(SpecCustomerFeature.aggregated_records_cache, :length).by(1)
+
         expect(feature.id).to eq @existing.id
       end
 
-      it "should add the freshly-created record to the cache" do
-        expect{ SpecCustomerFeature.create(:feature_name => 'Fraud') }.to change(SpecCustomerFeature.aggregated_records_cache, :length).by(1)
+      it "adds the freshly-created record to the cache" do
+        expect{ SpecCustomerFeature.create(:feature_name => "Fraud") }.
+          to change(SpecCustomerFeature.aggregated_records_cache, :length).by(1)
       end
 
-      it "should freeze the cached object" do
-        feature = SpecCustomerFeature.create(:feature_name => 'Cancelled')
+      it "freezes the cached object" do
+        feature = SpecCustomerFeature.create(:feature_name => "Cancelled")
         expect(SpecCustomerFeature.aggregated_records_cache[feature.feature_name]).to be_frozen
       end
 
-      it "should cache the clone of the record, not the record itself" do
-        feature = SpecCustomerFeature.create(:feature_name => 'Returned')
-        expect(SpecCustomerFeature.aggregated_records_cache[feature.feature_name].object_id).not_to eq feature.object_id
+      it "caches the clone of the record, not the record itself" do
+        feature = SpecCustomerFeature.create(:feature_name => "Returned")
+        expect(SpecCustomerFeature.aggregated_records_cache[feature.feature_name].object_id).
+          not_to eq feature.object_id
       end
     end
   end
 
-  describe 'Tracked' do
+  describe "Tracked" do
     before do
       @customer = SpecCustomer.create
       @info = @customer.create_spec_customer_info :spec_person_name_id => 1
     end
 
-    it "should create a new current record if updated" do
+    it "creates a new current record if updated" do
       expect {
         @info.update_attributes(:spec_person_name_id => 2)
       }.to change(SpecCustomerInfo, :count).by(1)
     end
 
-    it "should replace itself with new id" do
+    it "replaces itself with new id" do
       old_id = @info.id
       @info.update_attributes(:spec_person_name_id => 2)
       expect(@info.id).not_to eq old_id
     end
 
-    it "should set is_current record to false for superseded record" do
+    it "sets is_current record to false for superseded record" do
       old_id = @info.id
       @info.update_attributes(:spec_person_name_id => 2)
       expect(SpecCustomerInfo.find(old_id).is_current).to eq false
     end
 
-    it "should set previous_id to the id of the previous record" do
+    it "sets previous_id to the id of the previous record" do
       old_id = @info.id
       @info.update_attributes(:spec_person_name_id => 2)
       expect(@info.previous_id).to eq old_id
     end
 
-    it "assigning a new current record should change is_current to false for previous one" do
+    it "changes is_current to false for previous one when assigning a new current record" do
       new_info = SpecCustomerInfo.new :spec_person_name_id => 2, :is_current => true
       @customer.spec_customer_info = new_info
       expect(new_info.spec_customer_id).to eq @customer.id
+      @info.reload
       expect(@info.is_current         ).to eq false
     end
 
-    it "should not crash on superseding with 'is_current' conditional constraint" do
-      email = SpecCustomerEmail.create(:spec_customer => @customer, :email => 'foo@bar.com', :status => 'unverified', :is_current => true)
-      expect{ email.update_attributes(:status => 'verified') }.not_to raise_error
+    it "does not crash on superseding with 'is_current' conditional constraint" do
+      email = SpecCustomerEmail.create( :spec_customer => @customer,
+                                        :email         => "foo@bar.com",
+                                        :status        => "unverified",
+                                        :is_current    => true
+                                      )
+      expect{ email.update_attributes(:status => "verified") }.not_to raise_error
     end
 
-    describe 'updated_at and created_at' do
-      let(:first_time)  { Time.zone.parse('2012-07-16 00:00:00') }
-      let(:second_time) { Time.zone.parse('2012-07-17 08:10:15') }
+    describe "updated_at and created_at" do
+      let(:first_time)  { Time.zone.parse("2012-07-16 00:00:00") }
+      let(:second_time) { Time.zone.parse("2012-07-17 08:10:15") }
 
       before { Timecop.freeze(first_time) }
       after  { Timecop.return             }
 
-      it "should be updated on change" do
+      it "is updated on change" do
         info = @customer.create_spec_customer_info :spec_person_name_id => 1
         expect(info.updated_at).to eq first_time
         expect(info.created_at).to eq first_time
@@ -251,28 +290,75 @@ describe Moribus do
         @info2 = @customer.reload.spec_customer_info
       end
 
-      it "should raise stale object error" do
+      it "raises a stale object error" do
         @info1.update_attributes(:spec_person_name_id => 3)
 
-        expect{ @info2.update_attributes(:spec_person_name_id => 4) }.to raise_error(ActiveRecord::StaleObjectError)
+        expect{ @info2.update_attributes(:spec_person_name_id => 4) }.
+          to raise_error(ActiveRecord::StaleObjectError)
+      end
+
+      it "updates lock_version incrementally for each new record" do
+        spec_customer_info = @customer.spec_customer_info
+
+        expect {
+          spec_customer_info.update_attributes(:spec_person_name_id => 3)
+        }.to change { spec_customer_info.lock_version }.from(0).to(1)
+
+        expect {
+          spec_customer_info.update_attributes(:spec_person_name_id => 4)
+        }.to change { spec_customer_info.lock_version }.from(1).to(2)
+      end
+
+      it "does not fail if no locking_column is present" do
+        email = SpecCustomerEmail.create(:spec_customer_id => 1, :email => "foo@bar.com")
+        expect{ email.update_attributes(:email => "foo2@bar.com") }.not_to raise_error
+      end
+
+      it "updates lock_version column based on parent relation" do
+        @other_customer = SpecCustomer.create
+        spec_customer_info = @customer.spec_customer_info
+
+        expect {
+          spec_customer_info.update_attributes(:spec_person_name_id => 3)
+        }.to change { spec_customer_info.lock_version }.from(0).to(1)
+
+        expect {
+          spec_customer_info.update_attributes(:spec_customer => @other_customer)
+        }.to change { spec_customer_info.lock_version }.from(1).to(0)
       end
 
-      it "should not fail if no locking_column present" do
-        email = SpecCustomerEmail.create(:spec_customer_id => 1, :email => 'foo@bar.com')
-        expect{ email.update_attributes(:email => 'foo2@bar.com') }.not_to raise_error
+      it "updates lock_version column base on relation list from 'by' option" do
+        info_with_type =
+          @customer.reload.create_spec_customer_info_with_type(:spec_type => :important)
+
+        expect( info_with_type.lock_version ).to eq 0
+
+        other_info_with_type =
+          @customer.reload.create_spec_customer_info_with_type(:spec_type => :unimportant)
+
+        expect( other_info_with_type.lock_version ).to eq 0
+
+        info_with_type.update_attributes(:spec_status => :active)
+        expect( info_with_type.lock_version ).to eq 1
+
+        info_with_type.update_attributes(:spec_status => :inactive)
+        expect( info_with_type.lock_version ).to eq 2
+
+        expect( other_info_with_type.lock_version ).to eq 0
       end
     end
 
-    describe 'with Aggregated' do
+    describe "with Aggregated" do
       before do
-        @info.spec_person_name = SpecPersonName.create(:first_name => 'John', :last_name => 'Smith')
+        @info.spec_person_name =
+          SpecPersonName.create(:first_name => "John", :last_name => "Smith")
         @info.save
         @info.reload
       end
 
-      it "should supersede when nested record changes" do
+      it "supersedes when nested record changes" do
         old_id = @info.id
-        @customer.spec_customer_info.spec_person_name.first_name = 'Alice'
+        @customer.spec_customer_info.spec_person_name.first_name = "Alice"
         expect{ @customer.save }.to change(@info, :spec_person_name_id)
         expect(@info.id).not_to eq old_id
         expect(@info.is_current).to eq true
@@ -281,19 +367,19 @@ describe Moribus do
     end
   end
 
-  describe 'Delegations' do
+  describe "Delegations" do
     before do
       @customer = SpecCustomer.create(
         :spec_customer_info_attributes => {
-          :spec_person_name_attributes => {:first_name => ' John ', :last_name => 'Smith'} } )
+          :spec_person_name_attributes => {:first_name => " John ", :last_name => "Smith"} } )
       @info = @customer.spec_customer_info
     end
 
-    it "should have delegated column information" do
+    it "has delegated column information" do
       expect(@customer.column_for_attribute(:first_name)).not_to be_nil
     end
 
-    it "should not delegate special methods" do
+    it "does not delegate special methods" do
       expect(@customer).not_to respond_to(:reset_first_name)
       expect(@customer).not_to respond_to(:first_name_was)
       expect(@customer).not_to respond_to(:first_name_before_type_cast)
@@ -302,30 +388,30 @@ describe Moribus do
       expect(@customer).not_to respond_to(:lock_version)
     end
 
-    it "should delegate methods to aggregated parts" do
+    it "delegates methods to aggregated parts" do
       expect(@info).to respond_to(:first_name)
       expect(@info).to respond_to(:first_name=)
       expect(@info).to respond_to(:spec_suffix)
-      expect(@info.last_name).to eq 'Smith'
+      expect(@info.last_name).to eq "Smith"
     end
 
-    it "should delegate methods to representation" do
+    it "delegates methods to representation" do
       expect(@customer).to respond_to(:first_name)
       expect(@customer).to respond_to(:first_name=)
       expect(@customer).to respond_to(:spec_suffix)
-      expect(@customer.last_name).to eq 'Smith'
+      expect(@customer.last_name).to eq "Smith"
       expect(@customer).to respond_to(:custom_field)
       expect(@customer).to respond_to(:custom_field=)
     end
 
-    it 'should properly delegate enumerated attributes' do
+    it "properly delegates enumerated attributes" do
       expect(@customer).to respond_to(:spec_type)
       expect(@customer).to respond_to(:spec_type=)
       @customer.spec_type = :important
       expect(@customer.spec_type === :important).to eq true
     end
 
-    it "should raise NoMethodError if unknown method received" do
+    it "raises NoMethodError if unknown method is received" do
       expect{ @customer.impossibru }.to raise_error(NoMethodError)
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: HornsAndHooves-moribus
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - HornsAndHooves
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-22 00:00:00.000000000 Z
+date: 2015-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -149,6 +149,7 @@ files:
 - lib/moribus/macros.rb
 - lib/moribus/tracked_behavior.rb
 - lib/moribus/version.rb
+- merge.patch
 - spec/dummy/README.rdoc
 - spec/dummy/Rakefile
 - spec/dummy/app/assets/javascripts/application.js