rescue_unique_constraint-cadetstar 1.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 133829749c4c9dd2bcc20628d6544147b7742b4aa389a3569457965f8ad87211
+  data.tar.gz: 1c2f5b4eb84e18e0c44a49680678d0f25b70c807b55b40349c430018bf8f0c27
+SHA512:
+  metadata.gz: 87bafb69b49d6265a0bb3e7fe84d7bcc44e546a08e4a9c380a55b60bc2686cb0e892e3a4f2cee62f259648bf3f25f85bd0878a11508374d779aa824ec17b77bc
+  data.tar.gz: 822ba822132016b8a343957d65a6d94d2d2ff8cd9e3e3585fc67a4abd3e06a66fa3d20374292bbfd64a6aa189b9cfb58b7591c7acc32286d50128042bc747837

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.tags
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rubocop.yml

@@ -0,0 +1,2 @@
+AllCops:
+  TargetRubyVersion: 2.1

data/.ruby-version

@@ -0,0 +1 @@
+2.5.1

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rescue_unique_constraint.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,13 @@
+Copyright 2015 Reverb.com, LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,86 @@
+# RescueUniqueConstraint
+
+ActiveRecord doesn't do a great job of rescuing ActiveRecord::RecordNotUnique
+violations resulting from a duplicate entry on a database level unique constraint.
+
+This gem automatically rescues the error and instead adds a validation error
+on the field in question, making it behave as if you had a normal uniqueness
+validation.
+
+Note that if you have only a unique constraint in the database and no uniqueness validation in ActiveRecord, it
+is possible for your object to validate but then fail to save.
+
+See Usage for more info.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rescue_unique_constraint'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rescue_unique_constraint
+
+## Usage
+
+Assuming you've added unique index:
+
+```ruby
+class AddIndexToThing < ActiveRecord::Migration
+  disable_ddl_transaction!
+
+  def change
+    add_index :things, :somefield, unique: true, algorithm: :concurrently, name: "my_unique_index"
+  end
+end
+```
+
+Before:
+
+```ruby
+class Thing < ActiveRecord::Base
+end
+
+thing = Thing.create(somefield: "foo")
+dupe = Thing.create(somefield: "foo")
+# => raises ActiveRecord::RecordNotUnique
+```
+
+Note that if you have `validates :uniqueness` in your model, it will prevent
+the RecordNotUnique from being raised in _some_ cases, but not all, as race
+conditions between multiple processes will still cause duplicate entries to
+enter your database.
+
+After:
+
+```ruby
+class Thing < ActiveRecord::Base
+  include RescueUniqueConstraint
+  rescue_unique_constraint index: "my_unique_index", field: "somefield"
+end
+
+thing = Thing.create(somefield: "foo")
+dupe = Thing.create(somefield: "foo")
+# => false
+thing.errors[:somefield] == "somefield has already been taken"
+# => true
+# => raises ActiveRecord::RecordNotUnique
+```
+
+## Testing
+
+You'll need a database that supports unique constraints.
+This gem has been tested with PostgreSQL, MySQL and SQLite.
+
+## Contributing
+
+1. [Fork it](https://github.com/reverbdotcom/rescue-unique-constraint/fork)
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+
+begin
+  require "rspec/core/rake_task"
+  RSpec::Core::RakeTask.new(:spec)
+
+  task default: :spec
+rescue LoadError
+end

data/lib/rescue_unique_constraint.rb

@@ -0,0 +1,47 @@
+require 'rescue_unique_constraint/version'
+require 'rescue_unique_constraint/index'
+require 'rescue_unique_constraint/rescue_handler'
+require 'rescue_unique_constraint/adapter/mysql_adapter'
+require 'rescue_unique_constraint/adapter/postgresql_adapter'
+require 'rescue_unique_constraint/adapter/sqlite_adapter'
+require 'active_record'
+
+# Module which will rescue ActiveRecord::RecordNotUnique exceptions
+# and add errors for indexes that are registered with
+# rescue_unique_constraint(index:, field:)
+module RescueUniqueConstraint
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  # methods mixed into ActiveRecord class
+  module ClassMethods
+    def index_rescue_handler
+      @_index_rescue_handler ||= RescueUniqueConstraint::RescueHandler.new(self)
+    end
+
+    def rescue_unique_constraint(index:, field:, scope: nil)
+      unless method_defined?(:create_or_update_with_rescue)
+        define_method(:create_or_update_with_rescue) do |*|
+          begin
+            create_or_update_without_rescue
+          rescue ActiveRecord::RecordNotUnique => e
+            self.class.index_rescue_handler.matching_indexes(e).each do |matching_index|
+              if matching_index.scope
+                errors.add(matching_index.field, :taken, scope: matching_index.scope)
+              else
+                errors.add(matching_index.field, :taken)
+              end
+            end
+            return false
+          end
+          true
+        end
+
+        alias_method :create_or_update_without_rescue, :create_or_update
+        alias_method :create_or_update, :create_or_update_with_rescue
+      end
+      index_rescue_handler.add_index(index, field)
+    end
+  end
+end

data/lib/rescue_unique_constraint/adapter/mysql_adapter.rb

@@ -0,0 +1,9 @@
+module RescueUniqueConstraint
+  module Adapter
+    class MysqlAdapter
+      def index_error?(index, error_message)
+        error_message[/#{index.name}/]
+      end
+    end
+  end
+end

data/lib/rescue_unique_constraint/adapter/postgresql_adapter.rb

@@ -0,0 +1,9 @@
+module RescueUniqueConstraint
+  module Adapter
+    class PostgresqlAdapter
+      def index_error?(index, error_message)
+        error_message[/#{index.name}/]
+      end
+    end
+  end
+end

data/lib/rescue_unique_constraint/adapter/sqlite_adapter.rb

@@ -0,0 +1,19 @@
+module RescueUniqueConstraint
+  module Adapter
+    class SqliteAdapter
+      def initialize(table_name)
+        @table_name = table_name
+      end
+
+      # Sample error message returned by ActiveRecord for Sqlite Unique exception:
+      # 'SQLite3::ConstraintException: UNIQUE constraint failed: things.code, things.score: INSERT INTO "things" ("name", "test", "code", "score") VALUES (?, ?, ?, ?)'
+      #
+      # Step1: extract column names from above message on which unique constraint failed.
+      # Step2: Check if this index's field is among those columns.
+      def index_error?(index, error_message)
+        column_names = error_message.scan(%r{(?<=#{@table_name}\.)\w+})
+        column_names.include?(index.field)
+      end
+    end
+  end
+end

data/lib/rescue_unique_constraint/index.rb

@@ -0,0 +1,10 @@
+module RescueUniqueConstraint
+  class Index
+    attr_reader :name, :field, :scope
+    def initialize(name, field, scope = nil)
+      @name = name
+      @field = field
+      @scope = scope
+    end
+  end
+end

data/lib/rescue_unique_constraint/rescue_handler.rb

@@ -0,0 +1,44 @@
+module RescueUniqueConstraint
+  # Handles storing and matching [index, field] pairs to exceptions
+  class RescueHandler
+    def initialize(model)
+      @model = model
+      @indexes_to_rescue_on = []
+    end
+
+    def add_index(index, field)
+      indexes_to_rescue_on << Index.new(index, field)
+    end
+
+    def matching_indexes(e)
+      indexes = indexes_to_rescue_on.select do |index|
+        database_adapter.index_error?(index, e.message)
+      end
+      raise e unless indexes.any?
+      indexes
+    end
+
+    private
+
+    attr_reader :indexes_to_rescue_on, :model
+
+    def database_adapter
+      @_database_adapter ||= (
+        case database_name
+        when :mysql2
+          Adapter::MysqlAdapter.new
+        when :postgresql
+          Adapter::PostgresqlAdapter.new
+        when :sqlite
+          Adapter::SqliteAdapter.new(@model.table_name)
+        else
+          raise "Database (#{database_name}) not supported"
+        end
+      )
+    end
+
+    def database_name
+      model.connection.adapter_name.downcase.to_sym
+    end
+  end
+end

data/lib/rescue_unique_constraint/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RescueUniqueConstraint
+  VERSION = "1.6.0"
+end

data/rescue_unique_constraint-cadetstar.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rescue_unique_constraint/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rescue_unique_constraint-cadetstar"
+  spec.version       = RescueUniqueConstraint::VERSION
+  spec.authors       = ["Tam Dang", "Yan Pritzker", "Michael Madison"]
+  spec.email         = ["tam.dang@reverb.com","yan@reverb.com", "cadetstar@hotmail.com"]
+  spec.summary       = %q{Turns ActiveRecord::RecordNotUnique errors into ActiveRecord errors}
+  spec.description   = %q{Fork of https://github.com/reverbdotcom/rescue_unique_contraint. Rescues unique constraint violations and turns them into ActiveRecord errors. The fork adds functionality for including scope as an additional option}
+  spec.homepage      = "https://github.com/cadetstar/rescue_unique_contraint"
+  spec.license       = "Apache 2.0"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord", ">= 3.2", "< 7"
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.5"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "sqlite3", "~> 1.3"
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'pry-byebug'
+  spec.add_development_dependency 'gem-release'
+end

data/spec/rescue_unique_constraint_spec.rb

@@ -0,0 +1,58 @@
+require 'active_record'
+require 'rescue_unique_constraint'
+
+describe RescueUniqueConstraint do
+  before :all do
+    ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+    ActiveRecord::Schema.verbose = false
+    ActiveRecord::Schema.define(:version => 1) do
+      create_table :things do |t|
+        t.string :name
+        t.string :test
+        t.integer :code
+        t.integer :score
+      end
+
+      add_index :things, :name, unique: true, name: "idx_things_on_name_unique"
+      add_index :things, :test, unique: true, name: "idx_things_on_test_unique"
+      add_index :things, [:code, :score], unique: true, name: "idx_things_on_code_and_score_unique"
+    end
+  end
+
+  class Thing < ActiveRecord::Base
+    include RescueUniqueConstraint
+    rescue_unique_constraint index: "idx_things_on_name_unique", field: "name"
+    rescue_unique_constraint index: "idx_things_on_test_unique", field: "test"
+    rescue_unique_constraint index: "idx_things_on_code_and_score_unique", field: "score"
+  end
+
+  before :each do
+    Thing.destroy_all
+  end
+
+  it "rescues unique constraint violations as activerecord errors" do
+    thing = Thing.create(name: "foo", test: 'bar', code: 123, score: 1000)
+    dupe = Thing.new(name: "foo", test: 'baz', code: 456, score: 2000)
+    expect(dupe.save).to eql false
+    expect(dupe.errors.messages.keys).to contain_exactly(:name)
+    expect(dupe.errors[:name].first).to match /has already been taken/
+  end
+
+  it "adds error message to atrribute which caused unique-voilation" do
+    thing = Thing.create(name: "foo", test: 'bar', code: 123, score: 1000)
+    dupe = Thing.new(name: "lorem", test: 'bar', code: 456, score: 2000)
+    expect(dupe.save).to eql false
+    expect(dupe.errors.messages.keys).to contain_exactly(:test)
+    expect(dupe.errors[:test].first).to match /has already been taken/
+  end
+
+  context "When unique contraint is voilated by a composite index" do
+    it "adds error message to user defined atrribute" do
+      thing = Thing.create(name: "foo", test: 'bar', code: 123, score: 1000)
+      dupe = Thing.new(name: "lorem", test: 'ipsum', code: 123, score: 1000)
+      expect(dupe.save).to eql false
+      expect(dupe.errors.messages.keys).to contain_exactly(:score)
+      expect(dupe.errors[:score].first).to match /has already been taken/
+    end
+  end
+end

metadata

@@ -0,0 +1,185 @@
+--- !ruby/object:Gem::Specification
+name: rescue_unique_constraint-cadetstar
+version: !ruby/object:Gem::Version
+  version: 1.6.0
+platform: ruby
+authors:
+- Tam Dang
+- Yan Pritzker
+- Michael Madison
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-12-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.5'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: gem-release
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Fork of https://github.com/reverbdotcom/rescue_unique_contraint. Rescues
+  unique constraint violations and turns them into ActiveRecord errors. The fork adds
+  functionality for including scope as an additional option
+email:
+- tam.dang@reverb.com
+- yan@reverb.com
+- cadetstar@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".ruby-version"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rescue_unique_constraint.rb
+- lib/rescue_unique_constraint/adapter/mysql_adapter.rb
+- lib/rescue_unique_constraint/adapter/postgresql_adapter.rb
+- lib/rescue_unique_constraint/adapter/sqlite_adapter.rb
+- lib/rescue_unique_constraint/index.rb
+- lib/rescue_unique_constraint/rescue_handler.rb
+- lib/rescue_unique_constraint/version.rb
+- rescue_unique_constraint-cadetstar.gemspec
+- spec/rescue_unique_constraint_spec.rb
+homepage: https://github.com/cadetstar/rescue_unique_contraint
+licenses:
+- Apache 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Turns ActiveRecord::RecordNotUnique errors into ActiveRecord errors
+test_files:
+- spec/rescue_unique_constraint_spec.rb