activerecord-rescue_from_duplicate 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 177b4e3d186607ace00720b9a9aa0ef36c4544ba
-  data.tar.gz: d1572e760fa9e8db750096b2ccf0ff8ce8103951
+  metadata.gz: 95ffd1c815f0296026de14cf92106766488a5472
+  data.tar.gz: 2f54109b6dbb3330942a64ce0644f95529e2431a
 SHA512:
-  metadata.gz: 917489d657451b3efe18181ebcdae646f6b392952f0ee0616b800fa04741b739840d73cd7feb80529df0b077926efadb96f8454602d0d58a2efef1129b4de55f
-  data.tar.gz: 4f8ed33d63076f70e383069c9b97277d5d2efe315afc92f31c96ff63e209eb3d082d5127409221f810b810312b22a221fdbd803a32500a95f29f764d3b05cd0b
+  metadata.gz: 76a7947095f99a17df0607fa139e45949ba4649f6bed2e9e1ee7efe2992863e697c9f0a285060c8003bc8c9282fb21478833859fd583f1fb02a8c54425a0dda4
+  data.tar.gz: 6e9d39085c3614245854a19023cdd4cd06d02ac8e20a7eee7f6ac2119b2b4fc78a92cef7f40f9b564b202af3cf4954c9b02f5bb1b68720e4aec0d664e721bf69

data/lib/rescue_from_duplicate/active_record.rb

@@ -5,10 +5,32 @@ require "rescue_from_duplicate/active_record/version"
 module RescueFromDuplicate
   module ActiveRecord
   end
+
+  def self.missing_unique_indexes
+    ar_subclasses = ObjectSpace.each_object(Class).select{ |klass| klass < ::ActiveRecord::Base }
+    klasses = ar_subclasses.select do |klass|
+      klass.validators.any? { |v| v.is_a?(::ActiveRecord::Validations::UniquenessValidator) || klass._rescue_from_duplicates.any? }
+    end
+
+    missing_unique_indexes = []
+
+    klasses.each do |klass|
+      klass._rescue_from_duplicate_handlers.each do |handler|
+        unique_indexes = klass.connection.indexes(klass.table_name).select(&:unique)
+
+        unless unique_indexes.any? { |index| index.columns.map(&:to_s).sort == handler.columns }
+          missing_unique_indexes << MissingUniqueIndex.new(klass, handler.attributes, handler.columns)
+        end
+      end
+    end
+    missing_unique_indexes
+  end
 end
 
 require 'rescue_from_duplicate/active_record/extension'
+require 'rescue_from_duplicate/uniqueness_rescuer'
 require 'rescue_from_duplicate/rescuer'
+require 'rescue_from_duplicate/missing_unique_index'
 
 ActiveSupport.on_load(:active_record) do
   ::ActiveRecord::Base.send :include, RescueFromDuplicate::ActiveRecord::Extension

data/lib/rescue_from_duplicate/active_record/extension.rb

@@ -8,6 +8,13 @@ module RescueFromDuplicate::ActiveRecord
       def rescue_from_duplicate(attribute, options = {})
         self._rescue_from_duplicates += [RescueFromDuplicate::Rescuer.new(attribute, options)]
       end
+
+      def _rescue_from_duplicate_handlers
+        validator_handlers = self.validators.select { |v| v.is_a?(ActiveRecord::Validations::UniquenessValidator) }.map do |v|
+          RescueFromDuplicate::UniquenessRescuer.new(v)
+        end
+        self._rescue_from_duplicates + validator_handlers
+      end
     end
 
     included do
@@ -18,7 +25,7 @@ module RescueFromDuplicate::ActiveRecord
     def create_or_update(*params, &block)
       super
     rescue ActiveRecord::RecordNotUnique => exception
-      handler = exception_validator(exception) || exception_rescuer(exception)
+      handler = exception_handler(exception)
 
       raise exception unless handler
 
@@ -29,36 +36,25 @@ module RescueFromDuplicate::ActiveRecord
       false
     end
 
-    def exception_validator(exception)
+    private
+
+    def exception_handler(exception)
       columns = exception_columns(exception)
 
-      self._validators.each do |attribute, validators|
-        validators.each do |validator|
-          next unless validator.is_a?(ActiveRecord::Validations::UniquenessValidator)
-          return validator if rescue_with_validator?(columns, validator)
-        end
+      self.class._rescue_from_duplicate_handlers.detect do |handler|
+        handler.rescue? && columns == handler.columns
       end
-
-      nil
     end
 
-    protected
-
     def exception_columns(exception)
-      columns = case
+      case
       when exception.message =~ /SQLite3::ConstraintException/
         sqlite3_exception_columns(exception)
       when exception.message =~ /PG::UniqueViolation/
         postgresql_exception_columns(exception)
       else
         other_exception_columns(exception)
-      end
-    end
-
-    def exception_rescuer(exception)
-      columns = exception_columns(exception)
-
-      _rescue_from_duplicates.detect { |rescuer| rescuer.matches?(columns) }
+      end.sort
     end
 
     def postgresql_exception_columns(exception)
@@ -71,19 +67,12 @@ module RescueFromDuplicate::ActiveRecord
 
     def extract_columns(columns_string)
       return unless columns_string
-      columns_string.split(",").map(&:strip).sort
+      columns_string.split(",").map(&:strip)
     end
 
     def other_exception_columns(exception)
       indexes = self.class.connection.indexes(self.class.table_name)
-      columns = indexes.detect{ |i| exception.message.include?(i.name) }.try(:columns) || []
-      columns.sort
-    end
-
-    def rescue_with_validator?(columns, validator)
-      validator_columns = (Array(validator.options[:scope]) + validator.attributes).map(&:to_s).sort
-      return false unless columns == validator_columns
-      validator.options.fetch(:rescue_from_duplicate) { false }
+      indexes.detect{ |i| exception.message.include?(i.name) }.try(:columns) || []
     end
   end
 end

data/lib/rescue_from_duplicate/active_record/version.rb

@@ -1,5 +1,5 @@
 module Activerecord
   module RescueFromDuplicate
-    VERSION = "0.0.6"
+    VERSION = "0.0.7"
   end
 end

data/lib/rescue_from_duplicate/missing_unique_index.rb

@@ -0,0 +1,11 @@
+module RescueFromDuplicate
+  class MissingUniqueIndex
+    attr_reader :model, :attributes, :columns
+
+    def initialize(model, attributes, columns)
+      @model = model
+      @attributes = attributes
+      @columns = columns
+    end
+  end
+end

data/lib/rescue_from_duplicate/rescuer.rb

@@ -1,6 +1,6 @@
 module RescueFromDuplicate
   class Rescuer
-    attr_reader :attributes, :options
+    attr_reader :attributes, :options, :columns
 
     def initialize(attribute, options)
       @attributes = [attribute]
@@ -8,8 +8,8 @@ module RescueFromDuplicate
       @options = options
     end
 
-    def matches?(columns)
-      @columns == columns.map(&:to_s).sort
+    def rescue?
+      true
     end
   end
 end

data/lib/rescue_from_duplicate/uniqueness_rescuer.rb

@@ -0,0 +1,23 @@
+module RescueFromDuplicate
+  class UniquenessRescuer
+    def initialize(validator)
+      @validator = validator
+    end
+
+    def rescue?
+      @validator.options.fetch(:rescue_from_duplicate, false)
+    end
+
+    def options
+      @validator.options
+    end
+
+    def attributes
+      @validator.attributes
+    end
+
+    def columns
+      (Array(options[:scope]) + attributes).map(&:to_s).sort
+    end
+  end
+end

data/spec/rescue_from_duplicate_spec.rb

@@ -10,67 +10,6 @@ shared_examples 'database error rescuing' do
     allow(Rescuable).to receive(:connection).and_return(double(indexes: [Rescuable.index]))
   end
 
-  describe "#exception_validator" do
-    context "validator can be found" do
-      it "returns the validator" do
-        expect(subject.exception_validator(uniqueness_exception)).to eq Rescuable.uniqueness_validator
-      end
-    end
-
-    context "validator cannot be found" do
-      before {
-        Rescuable.stub(_validators: {name: [Rescuable.presence_validator]})
-      }
-
-      it "returns nil" do
-        expect(subject.exception_validator(uniqueness_exception)).to be_nil
-      end
-    end
-
-    context "validator doesn't specify :rescue_from_duplicate" do
-      before {
-        Rescuable.stub(_validators: {name: [Rescuable.uniqueness_validator_without_rescue]})
-      }
-
-      it "returns nil" do
-        expect(subject.exception_validator(uniqueness_exception)).to be_nil
-      end
-    end
-
-    context "no validator" do
-      before {
-        Rescuable.stub(_validators: {})
-      }
-
-      it "returns nil" do
-        expect(subject.exception_validator(uniqueness_exception)).to be_nil
-      end
-    end
-
-    context "no index on the table" do
-      before {
-        Rescuable.stub(index: nil)
-        Rescuable.stub(connection: double(indexes: []))
-      }
-
-      let(:message) { super().gsub(/column (.*?) is/, 'column toto is').gsub(/Key \((.*?)\)=/, 'Key (toto)=') }
-
-      it "returns nil" do
-        expect(subject.exception_validator(uniqueness_exception)).to be_nil
-      end
-    end
-
-    context "columns part of the index of another table" do
-      before {
-        subject.stub(exception_columns: ['foo', 'baz'])
-      }
-
-      it "returns nil" do
-        expect(subject.exception_validator(uniqueness_exception)).to be_nil
-      end
-    end
-  end
-
   describe "#create_or_update when the validation fails" do
     before { Base.stub(exception: uniqueness_exception) }
 
@@ -82,7 +21,7 @@ shared_examples 'database error rescuing' do
     end
 
     context "when the validator is not present" do
-      before { Rescuable.stub(_validators: {name: [Rescuable.presence_validator]}) }
+      before { Rescuable.stub(validators: [Rescuable.presence_validator]) }
 
       it "raises an exception" do
         expect{ subject.create_or_update }.to raise_error(ActiveRecord::RecordNotUnique)

data/spec/rescuer_spec.rb

@@ -1,17 +1,18 @@
 require 'spec_helper'
 
 describe RescueFromDuplicate::Rescuer do
-  subject { RescueFromDuplicate::Rescuer.new(:shop_id, scope: :name) }
+  subject { RescueFromDuplicate::Rescuer.new(:name, scope: [:type, :shop_id], message: "Derp!") }
 
-  context "#matches?" do
-    it 'is true when the columns are the same' do
-      expect(subject.matches?(["shop_id", "name"])).to be true
-      expect(subject.matches?(["name", "shop_id"])).to be true
-    end
+  it "always rescues" do
+    expect(subject.rescue?).to eq true
+  end
 
-    it 'is false when the columns are not the same' do
-      expect(subject.matches?(["shop_id", "toto"])).to be false
-    end
+  it "sorts the columns" do
+    expect(subject.columns).to eq ['name', 'shop_id', 'type']
+  end
+
+  it "returns the options" do
+    expect(subject.options).to eq scope: [:type, :shop_id], message: "Derp!"
   end
 end
 

data/spec/spec_helper.rb

@@ -43,28 +43,21 @@ module RescueFromDuplicate
       send(attribute)
     end
 
-    def _validators
-      self.class._validators
-    end
-
     def errors
       @errors ||= ActiveModel::Errors.new(self)
     end
 
-    def self._validators
-      @validators ||= {
-        name:
-        [
-          uniqueness_validator,
-          presence_validator
-        ]
-      }
+    def self.validators
+      @validators ||= [
+        uniqueness_validator,
+        presence_validator
+      ]
     end
 
     def self.uniqueness_validator
       @uniqueness_validator ||= ::ActiveRecord::Validations::UniquenessValidator.new(
         attributes: [:name],
-        case_sensitive: true, scope: [:shop_id, :type],
+        case_sensitive: true, scope: [:type, :shop_id],
         rescue_from_duplicate: true
       ).tap { |o| o.setup(self) if o.respond_to?(:setup) }
     end

data/spec/uniqueness_rescuer_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe RescueFromDuplicate::UniquenessRescuer do
+  context "common" do
+    subject { RescueFromDuplicate::UniquenessRescuer.new(Rescuable.uniqueness_validator) }
+
+    it "returns the options" do
+      options = { case_sensitive: true, scope: [:type, :shop_id], rescue_from_duplicate: true }
+      expect(subject.options).to eq options
+    end
+
+    it "sorts the columns" do
+      expect(subject.columns).to eq ['name', 'shop_id', 'type']
+    end
+
+    it "returns the attributes" do
+      expect(subject.attributes).to eq [:name]
+    end
+  end
+
+  context "validator with rescue" do
+    subject { RescueFromDuplicate::UniquenessRescuer.new(Rescuable.uniqueness_validator) }
+    it "rescues" do
+      expect(subject.rescue?).to eq true
+    end
+  end
+
+  context "validator without rescue" do
+    subject { RescueFromDuplicate::UniquenessRescuer.new(Rescuable.uniqueness_validator_without_rescue) }
+    it "doesn't rescues" do
+      expect(subject.rescue?).to eq false
+    end
+  end
+end

data/spec/validator_spec.rb

@@ -45,18 +45,59 @@ shared_examples 'a model with rescued uniqueness validator' do
   end
 end
 
+shared_examples 'missing index finding' do
+  describe do
+    context 'all indexes are satisfied' do
+      it 'returns an empty array' do
+        expect(RescueFromDuplicate.missing_unique_indexes).to be_empty
+      end
+    end
+
+    context 'indexes are missing' do
+      before {
+        described_class.stub(_rescue_from_duplicate_handlers: [
+          RescueFromDuplicate::UniquenessRescuer.new(
+            ::ActiveRecord::Validations::UniquenessValidator.new(
+              attributes: [:name],
+              case_sensitive: true, scope: [:titi, :toto],
+            )
+          ),
+          RescueFromDuplicate::Rescuer.new(:name, scope: [:hello])
+        ])
+      }
+
+      it 'returns the missing indexes' do
+        missing_unique_indexes = RescueFromDuplicate.missing_unique_indexes.select { |mi| mi.model == described_class }
+        expect(missing_unique_indexes).not_to be_empty
+
+        expect(missing_unique_indexes.first.model).to eq described_class
+        expect(missing_unique_indexes.last.model).to eq described_class
+
+        expect(missing_unique_indexes.first.attributes).to eq [:name]
+        expect(missing_unique_indexes.last.attributes).to eq [:name]
+
+        expect(missing_unique_indexes.first.columns).to eq ["name", "titi", "toto"]
+        expect(missing_unique_indexes.last.columns).to eq ["hello", "name"]
+      end
+    end
+  end
+end
+
 describe Sqlite3Model do
   it_behaves_like 'a model with rescued uniqueness validator'
+  it_behaves_like 'missing index finding'
 end
 
 if defined?(MysqlModel)
   describe MysqlModel do
     it_behaves_like 'a model with rescued uniqueness validator'
+    it_behaves_like 'missing index finding'
   end
 end
 
 if defined?(PostgresqlModel)
   describe PostgresqlModel do
     it_behaves_like 'a model with rescued uniqueness validator'
+    it_behaves_like 'missing index finding'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-rescue_from_duplicate
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Guillaume Malette
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-08 00:00:00.000000000 Z
+date: 2014-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -155,7 +155,9 @@ files:
 - lib/rescue_from_duplicate/active_record.rb
 - lib/rescue_from_duplicate/active_record/extension.rb
 - lib/rescue_from_duplicate/active_record/version.rb
+- lib/rescue_from_duplicate/missing_unique_index.rb
 - lib/rescue_from_duplicate/rescuer.rb
+- lib/rescue_from_duplicate/uniqueness_rescuer.rb
 - shipit.rubygems.yml
 - spec/gemfiles/Gemfile.ar-3.2
 - spec/gemfiles/Gemfile.ar-4.0
@@ -165,6 +167,7 @@ files:
 - spec/rescuer_spec.rb
 - spec/spec_helper.rb
 - spec/support/model.rb
+- spec/uniqueness_rescuer_spec.rb
 - spec/validator_spec.rb
 homepage: https://github.com/Shopify/activerecord-rescue_from_duplicate
 licenses:
@@ -200,4 +203,5 @@ test_files:
 - spec/rescuer_spec.rb
 - spec/spec_helper.rb
 - spec/support/model.rb
+- spec/uniqueness_rescuer_spec.rb
 - spec/validator_spec.rb