HornsAndHooves-moribus 0.4.4 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a9af55b2fc41dd5db61bc98f44e6a3f2b4de950d
-  data.tar.gz: f646aafaf86ec6389dbe8b39fe3664cb2909257e
+SHA256:
+  metadata.gz: 030306473aaa6548bb98b95cce958cc4861fbf923ac99e33df4c31c5e5e54298
+  data.tar.gz: 8fa274a49fd8f7aaefdb30fb388281c089c0029fb0d861299ca760d5544d3ed8
 SHA512:
-  metadata.gz: 1ad85d605b3e35f1cf1e9c62ccb94be44d02b72af11f3b7abd5b6bfbea604ffdd1e209c8cd1a95da71e35a71dfbd02a67c27088aacb14f5a22f01e4295b4ebbd
-  data.tar.gz: a366ed36337e2516002bc426122715c49e8c4b15e58c2a8d56d479e5b1fd82de4941f23319f52bafe611f4ad07b7350684a91a1b9181dda2a140a187e19dd5d4
+  metadata.gz: e541ea1a31728d2156e52602601abb8a1e24181b7dcd90a0799e6a588cc78e48e2ba7833e236ca7a4230ac8fc29ea50e741e2914adaedb8f21291f4e924c6929
+  data.tar.gz: 0e744f9a43ac59e002928c05fe12c8ee69d06245733ad85d7417042ccf1d1a544a9c56f0b40cfad97d48e4f7476cefdb5c1d6e742b6edf14aeebf2f50c7ca473

data/.ruby-version

@@ -1 +1 @@
-2.2
+2.4.6

data/.simplecov

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

data/HornsAndHooves-moribus.gemspec

@@ -20,12 +20,12 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   # specify any dependencies here; for example:
-  s.add_dependency "rails",      "> 4.0", "< 5"
+  s.add_dependency "rails",      "~> 5"
   s.add_dependency "power_enum", ">= 2.7.0"
   s.add_dependency "yard",       ">= 0"
 
   s.add_development_dependency "rake"
   s.add_development_dependency "rspec"
   s.add_development_dependency "rspec-rails"
-  s.add_development_dependency "sqlite3"
+  s.add_development_dependency "sqlite3", "~> 1.3.6"
 end

data/README.md

@@ -6,7 +6,7 @@ Moribus is a set of tools for managing complex graphs of ActiveRecord objects
 for which there are many inbound foreign keys, attributes and associations with
 high rates of change, and business demands for well-tracked change history.
 
-##AggregatedBehavior
+## AggregatedBehavior
 
 AggregatedBehavior implements a pattern in which an object's identity
 is modeled apart from its attributes and outbound associations. This enables
@@ -26,7 +26,7 @@ to change. This is useful for objects with many inbound foreign keys and
 high-traffic attributes/associations, such as statuses. Without this pattern
 it would be difficult to avoid many StaleObjectErrors.
 
-##TrackedBehavior
+## TrackedBehavior
 
 TrackedBehavior implements history tracking on the stack of objects
 representing the identity object's attributes and outbound associations.
@@ -36,7 +36,7 @@ and will be saved as a new record with new attribute values and the
 'is_current' column as 'true'. Thus, under the hood, new attributes
 will supersede old attributes, leaving the old record as historical.
 
-##Macros, Associations and Combination
+## Macros, Associations and Combination
 
 Despite the fact that Moribus may be used by models on its own,
 its main purpose is to be used within associations, and in conjunction
@@ -105,6 +105,6 @@ rake spec
 
 ## Copyright
 
-Copyright (c) 2014 HornsAndHooves.
+Copyright (c) 2014-2018 HornsAndHooves.
 
 Copyright (c) 2013 TMX Credit.

data/lib/moribus.rb

@@ -96,9 +96,13 @@ module Moribus
       self.id         = existing.id
       self.created_at = existing.created_at if respond_to?(:created_at)
       self.updated_at = existing.updated_at if respond_to?(:updated_at)
-      @changed_attributes = {}
+
+      clear_changes_information
     else
       restore_before_to_new_record_values
+
+      clear_attribute_change(:created_at) if respond_to?(:created_at)
+      clear_attribute_change(:updated_at) if respond_to?(:updated_at)
     end
     @new_record = false
     true
@@ -145,14 +149,12 @@ module Moribus
 
     if respond_to?(:updated_at=)
       self.updated_at = nil
-      @changed_attributes =
-        ActiveSupport::HashWithIndifferentAccess.new(changed_attributes.dup.merge(updated_at: nil))
+      self.updated_at_will_change!
     end
 
     if respond_to?(:created_at=)
       self.created_at = nil
-      @changed_attributes =
-        ActiveSupport::HashWithIndifferentAccess.new(changed_attributes.dup.merge(created_at: nil))
+      self.created_at_will_change!
     end
 
     # mark all other attributes is changing

data/lib/moribus/alias_association.rb

@@ -23,30 +23,25 @@ module Moribus
       # association-specific methods. See module description for example.
       def alias_association(alias_name, association_name)
         if reflection = reflect_on_association(association_name)
-          # Use Rails 4.1.x+ behavior, if available:
-          if ActiveRecord::Reflection.respond_to? :add_reflection then
-            ActiveRecord::Reflection.add_reflection self, alias_name, reflection
-          else
-            # Rails 4.0.x behavior:
-            reflections[alias_name] = reflections[association_name]
-          end
+          ActiveRecord::Reflection.add_reflection self, alias_name, reflection
+
           alias_association_methods(alias_name, reflection)
           reflection
         end
       end
 
       # Allows :alias option to alias belongs_to association
-      def belongs_to(name, scope = nil, options = {})
+      def belongs_to(name, scope = nil, **options)
         options = scope if scope.is_a?(Hash)
 
         alias_name = options.delete(:alias)
-        reflection = super(name, scope, options)
+        reflection = super(name, scope, **options)
         alias_association(alias_name, name) if alias_name
         reflection
       end
 
       # Allows :alias option to alias has_many association
-      def has_many(name, scope = nil, options = {}, &extension)
+      def has_many(name, scope = nil, **options, &extension)
         options = scope if scope.is_a?(Hash)
 
         alias_name = options.delete(:alias)
@@ -56,7 +51,7 @@ module Moribus
       end
 
       # Allows :alias option to alias has_one association
-      def has_one(name, scope = nil, options = {})
+      def has_one(name, scope = nil, **options)
         options = scope if scope.is_a?(Hash)
 
         alias_name = options.delete(:alias)

data/lib/moribus/extensions.rb

@@ -24,12 +24,12 @@ module Moribus
     def association(name)
       association = super
       reflection = self.class.reflect_on_association(name)
-      case reflection.macro
-      when :belongs_to
-        association.extend(HasAggregatedExtension) if reflection.options[:aggregated]
-      when :has_one
-        association.extend(HasCurrentExtension) if reflection.options[:is_current]
-      else # do nothing
+      case reflection.try(:macro)
+        when :belongs_to
+          association.extend(HasAggregatedExtension) if reflection.options[:aggregated]
+        when :has_one
+          association.extend(HasCurrentExtension) if reflection.options[:is_current]
+        else # do nothing
       end
       association
     end

data/lib/moribus/extensions/delegate_associated.rb

@@ -33,7 +33,7 @@ module Moribus
       # presented in Customer, the code will result in exception without
       # the following hook:
       def column_for_attribute(name)
-        unless (column = super).nil?
+        unless (column = super).nil? || column.is_a?(ActiveRecord::ConnectionAdapters::NullColumn)
           return column
         end
 

data/lib/moribus/extensions/has_aggregated_extension.rb

@@ -71,7 +71,7 @@ module Moribus
             [name, "#{name}="]
           end
           klass.define_attribute_methods
-          attribute_methods = klass.generated_attribute_methods.instance_methods.select{ |m| m !~ EXCLUDE_METHODS_REGEXP }
+          attribute_methods = klass.__send__(:generated_attribute_methods).instance_methods.select{ |m| m !~ EXCLUDE_METHODS_REGEXP }
           custom_writers = klass.instance_methods(false).map(&:to_s) & klass.column_names.map{ |name| "#{name}=" }
           (attribute_methods + enum_methods.flatten + custom_writers).map(&:to_sym)
         end

data/lib/moribus/extensions/has_current_extension.rb

@@ -11,14 +11,12 @@ module Moribus
         else
           # 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 }
+          klass = target.class
 
           sql =  "UPDATE #{klass.quoted_table_name} " \
-                 "SET \"is_current\" = #{klass.quote_value(false, is_current_col)} "
+                 "SET \"is_current\" = #{klass.connection.quote(false)} "
           sql << "WHERE #{klass.quoted_primary_key} = " \
-                 "#{klass.quote_value(target.send(klass.primary_key), id_column)} "
+                 "#{klass.connection.quote(target.send(klass.primary_key))} "
 
           klass.connection.update sql
         end

data/lib/moribus/tracked_behavior.rb

@@ -75,8 +75,20 @@ module Moribus
           result[parent_key] = read_attribute(parent_key)
           result
         end
+        relation = klass.unscoped.where(criteria)
 
-        lock_value = klass.unscoped.where(criteria).count
+        sql = <<-SQL
+          #{relation.select("COUNT(#{lock_column_name}) AS value, 0 sort_order").to_sql}
+          UNION
+          #{relation.select("MAX(#{lock_column_name}) AS value, 1 sort_order").to_sql}
+          ORDER BY sort_order
+        SQL
+
+        result = klass.connection.execute(sql)
+        current_count = result[0]["value"]
+        current_max   = result[1]["value"]
+
+        lock_value = (current_count.to_s == "0" ? 0 : current_max.to_i + 1)
 
         write_attribute(lock_column_name, lock_value)
       end
@@ -104,7 +116,6 @@ module Moribus
     # 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         = current_lock_value
       lock_column        = if lock_value
@@ -112,17 +123,16 @@ module Moribus
                            else
                              nil
                            end
-      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|
+      "SET \"is_current\" = #{klass.connection.quote(false)} ".tap do |sql|
         sql << "WHERE #{klass.quoted_primary_key} = " \
-               "#{klass.quote_value(@_before_to_new_record_values[:id], id_column)}"
+               "#{klass.connection.quote(@_before_to_new_record_values[:id])}"
 
         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)}"
+          sql << " AND \"is_current\" = #{klass.connection.quote(true)}"
+          sql << " AND #{quoted_lock_column} = #{klass.connection.quote(lock_value)}"
         end
       end
     end

data/lib/moribus/version.rb

@@ -1,3 +1,3 @@
 module Moribus # :nodoc:
-  VERSION = "0.4.4" # :nodoc:
+  VERSION = "0.7.2" # :nodoc:
 end

data/spec/dummy/tmp/development_secret.txt

@@ -0,0 +1 @@
+02c924139ba4207bce788dd378b8f1f99976099325bbad4e85204e34d04970e039409db0f08ceea070238f4f5a41bdbc94fb6e51aeb0996a4ee32bcd3c31ede1

data/spec/moribus/aggregated_behavior_spec.rb

@@ -0,0 +1,147 @@
+require "spec_helper"
+
+describe Moribus::AggregatedBehavior do
+  before do
+    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")
+    end
+
+    class SpecTag < MoribusSpecModel()
+      has_and_belongs_to_many :person_names
+    end
+
+    class SpecPersonNamesTags < MoribusSpecModel(spec_tag_id: :integer,
+                                                 spec_person_name_id: :integer
+                                                )
+    end
+
+    class SpecPersonName < MoribusSpecModel(first_name:     :string,
+                                            last_name:      :string,
+                                            spec_suffix_id: :integer
+                                          )
+      acts_as_aggregated
+      has_enumerated :spec_suffix, default: ""
+      has_and_belongs_to_many :spec_tags
+
+      validates_presence_of :first_name, :last_name
+
+      # custom writer that additionally strips first name
+      def first_name=(value)
+        self[:first_name] = value.strip
+      end
+    end
+
+    class SpecCustomerFeature < MoribusSpecModel(feature_name: :string)
+      acts_as_aggregated cache_by: :feature_name
+    end
+  end
+
+  after do
+    MoribusSpecModel.cleanup!
+  end
+
+  describe "Aggregated" do
+    it "supports has_and_belongs_to_many association reflections which do not have a macro" do
+      tags = [SpecTag.new, SpecTag.new]
+      name = SpecPersonName.create!(first_name: "John", last_name: "Smith", spec_tags: tags)
+      expect(name.spec_tags.size).to eq(2)
+    end
+
+    context "definition" do
+      it "raises an error on an unknown option" do
+        expect{
+          Class.new(ActiveRecord::Base).class_eval do
+            acts_as_aggregated invalid_key: :error
+          end
+        }.to raise_error(ArgumentError)
+      end
+
+      it "raises an error when including AggregatedCacheBehavior without AggregatedBehavior" do
+        expect{
+          Class.new(ActiveRecord::Base).class_eval do
+            include Moribus::AggregatedCacheBehavior
+          end
+        }.to raise_error(Moribus::AggregatedCacheBehavior::NotAggregatedError)
+      end
+    end
+
+    before do
+      @existing = SpecPersonName.create! first_name: "John", last_name: "Smith"
+    end
+
+    it "doesn't duplicate records" do
+      expect {
+        SpecPersonName.create first_name: " John ", last_name: "Smith"
+      }.not_to change(SpecPersonName, :count)
+    end
+
+    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 "creates a new record if lookup fails" do
+      expect {
+        SpecPersonName.create first_name: "Alice", last_name: "Smith"
+      }.to change(SpecPersonName, :count).by(1)
+    end
+
+    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
+
+    it "calls super in save if any aggregated behaviour non content columns wasn't changed" do
+      name = SpecPersonName.create first_name: "Alice", last_name: "Smith"
+      expect {
+        name.save
+      }.to change(SpecPersonName, :count).by(0)
+    end
+
+    it "raises the expected error when 'save!' fails" do
+      name = SpecPersonName.create first_name: "Alice", last_name: "Smith"
+      name.last_name = nil
+      expect {
+        name.save!
+      }.to raise_error(ActiveRecord::RecordNotSaved)
+    end
+
+    context "with caching" do
+      before do
+        @existing = SpecCustomerFeature.create(feature_name: "Pays")
+        SpecCustomerFeature.clear_cache
+      end
+
+      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.id).to eq @existing.id
+      end
+
+      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 "freezes the cached object" do
+        feature = SpecCustomerFeature.create(feature_name: "Cancelled")
+        expect(SpecCustomerFeature.aggregated_records_cache[feature.feature_name]).to be_frozen
+      end
+
+      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
+end

data/spec/moribus/alias_association_spec.rb

@@ -1,26 +1,26 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Moribus::AliasAssociation do
   before do
-    class SpecPost < MoribusSpecModel(:spec_author_id => :integer, :body => :string)
-      belongs_to :spec_author   , :alias => :creator
-      has_many   :spec_comments , :alias => :remarks
-      has_one    :spec_post_info, :alias => :information
+    class SpecPost < MoribusSpecModel(spec_author_id: :integer, body: :string)
+      belongs_to :spec_author   , alias: :creator
+      has_many   :spec_comments , alias: :remarks
+      has_one    :spec_post_info, alias: :information
 
       alias_association :author   , :spec_author
       alias_association :comments , :spec_comments
       alias_association :post_info, :spec_post_info
     end
 
-    class SpecAuthor < MoribusSpecModel(:name => :string)
+    class SpecAuthor < MoribusSpecModel(name: :string)
       has_many :spec_posts
     end
 
-    class SpecPostInfo < MoribusSpecModel(:spec_post_id => :integer, :ip => :string)
-      belongs_to :spec_post, :alias => :note
+    class SpecPostInfo < MoribusSpecModel(spec_post_id: :integer, ip: :string)
+      belongs_to :spec_post, alias: :note
     end
 
-    class SpecComment < MoribusSpecModel(:spec_post_id => :integer, :body => :string)
+    class SpecComment < MoribusSpecModel(spec_post_id: :integer, body: :string)
       belongs_to :spec_post
     end
   end
@@ -30,10 +30,10 @@ describe Moribus::AliasAssociation do
   end
 
   before do
-    author = SpecAuthor.create(:name => 'John')
-    @post = author.spec_posts.create(:body => 'Post Body')
-    @post.spec_comments.create(:body => 'Fabulous!')
-    @post.create_spec_post_info(:ip => '127.0.0.1')
+    author = SpecAuthor.create(name: "John")
+    @post  = author.spec_posts.create(body: "Post Body")
+    @post.spec_comments.create(body: "Fabulous!")
+    @post.create_spec_post_info(ip: "127.0.0.1")
   end
 
   describe "reflection aliasing" do
@@ -41,7 +41,7 @@ describe Moribus::AliasAssociation do
       expect(SpecPost.reflect_on_association(:author)).not_to be_nil
     end
 
-    it "should not raise error when using aliased name in scopes" do
+    it "does not raise error when using aliased name in scopes" do
       expect{
         SpecPost.includes(:comments).first
       }.not_to raise_error