auto_increment 1.6.1 → 1.7.0

data/lib/auto_increment/incrementor.rb

@@ -4,46 +4,47 @@
 module AutoIncrement
   # +AutoIncrement::Incrementor+
   class Incrementor
-    def initialize(column = nil, options = {})
-      if column.is_a? Hash
-        options = column
-        column = nil
-      end
-
-      @column = column || options[:column] || :code
-      @options = options.reverse_merge initial: 1, force: false
-      @options[:scope] = [@options[:scope]].compact unless @options[:scope].is_a?(Array)
-      @options[:model_scope] = [@options[:model_scope]].compact unless @options[:model_scope].is_a?(Array)
+    def initialize(record, column = nil, **options)
+      @record = record
+      @column = column || options.fetch(:column, :code)
+      @initial = resolve_initial(options)
+      @force = options.fetch(:force, false)
+      @scope = Array.wrap(options[:scope]).compact
+      @model_scope = Array.wrap(options[:model_scope]).compact
+      @lock = options.fetch(:lock, false)
     end
 
-    def before_create(record)
-      @record = record
+    def run
       write if can_write?
     end
 
-    alias before_validation before_create
-    alias before_save before_create
-
     private
 
     def can_write?
-      @record.send(@column).blank? || @options[:force]
+      @record.send(@column).blank? || @force
     end
 
     def write
       @record.send :write_attribute, @column, increment
     end
 
+    def maximum_query
+      query = build_scopes(build_model_scope(@record.class))
+      query = query.lock if lock?
+
+      query
+    end
+
     def build_scopes(query)
-      @options[:scope].each do |scope|
-        query = query.where(scope => @record.send(scope)) if scope.present? && @record.respond_to?(scope)
+      @scope.each do |scope|
+        query = query.where(scope => @record.send(scope)) if @record.respond_to?(scope)
       end
 
       query
     end
 
     def build_model_scope(query)
-      @options[:model_scope].reject(&:nil?).each do |scope|
+      @model_scope.each do |scope|
         query = query.send(scope)
       end
 
@@ -51,30 +52,37 @@ module AutoIncrement
     end
 
     def maximum
-      query = build_scopes(build_model_scope(@record.class))
-      query.lock if lock?
+      query = maximum_query
 
-      if string?
-        query.select("#{@column} max")
-             .order(Arel.sql("LENGTH(#{@column}) DESC, #{@column} DESC"))
-             .first.try :max
+      if column_string?
+        quoted_column = @record.class.connection.quote_column_name(@column)
+        query.select("#{quoted_column} max")
+          .order(Arel.sql("LENGTH(#{quoted_column}) DESC, #{quoted_column} DESC"))
+          .first.try :max
       else
         query.maximum @column
       end
     end
 
     def lock?
-      @options[:lock] == true
+      @lock == true
     end
 
     def increment
       max = maximum
 
-      max.blank? ? @options[:initial] : max.next
+      max.blank? ? @initial : max.next
+    end
+
+    def resolve_initial(options)
+      return options[:initial] if options.key?(:initial)
+
+      column_string? ? "1" : 1
     end
 
-    def string?
-      @options[:initial].instance_of?(String)
+    def column_string?
+      col = @record.class.columns_hash[@column.to_s]
+      col&.type&.in?(%i[string text])
     end
   end
 end

data/lib/auto_increment/version.rb

@@ -2,5 +2,5 @@
 
 # +AutoIncrement::VERSION+
 module AutoIncrement
-  VERSION = '1.6.1'
+  VERSION = "1.7.0"
 end

data/lib/auto_increment.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-require 'date'
-require 'i18n'
-require 'active_record'
-require 'active_support'
-require 'active_support/time_with_zone'
-require 'auto_increment/version'
+require "date"
+require "i18n"
+require "active_record"
+require "active_support"
+require "active_support/time_with_zone"
+require "auto_increment/version"
 
 # +AutoIncrement+
 module AutoIncrement
-  autoload :Incrementor, 'auto_increment/incrementor'
-  autoload :ActiveRecord, 'auto_increment/active_record'
+  autoload :Incrementor, "auto_increment/incrementor"
+  autoload :ActiveRecord, "auto_increment/active_record"
 end
 
 ActiveRecord::Base.include AutoIncrement::ActiveRecord

data/spec/lib/active_record_spec.rb

@@ -1,48 +1,54 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-require 'models/account'
-require 'models/user'
+require "spec_helper"
+require "models/account"
+require "models/user"
+require "models/post"
 
 describe AutoIncrement do
   before :all do
-    @account1 = Account.create name: 'My Account'
-    @account2 = Account.create name: 'Another Account', code: 50
+    @account1 = Account.create name: "My Account"
+    @account2 = Account.create name: "Another Account", code: 50
 
-    @user1_account1 = @account1.users.create name: 'Felipe', letter_code: 'Z'
-    @user1_account2 = @account2.users.create name: 'Daniel'
-    @user2_account2 = @account2.users.create name: 'Mark'
-    @user3_account2 = @account2.users.create name: 'Robert'
+    @user1_account1 = @account1.users.create name: "Felipe", letter_code: "Z"
+    @user1_account2 = @account2.users.create name: "Daniel"
+    @user2_account2 = @account2.users.create name: "Mark"
+    @user3_account2 = @account2.users.create name: "Robert"
   end
 
-  describe 'initial' do
+  after :all do
+    Account.delete_all
+    User.delete_all
+  end
+
+  describe "initial" do
     it { expect(@account1.code).to eq 1 }
-    it { expect(@user1_account1.letter_code).to eq 'A' }
+    it { expect(@user1_account1.letter_code).to eq "A" }
   end
 
-  describe 'do not increment outside scope' do
-    it { expect(@user1_account2.letter_code).to eq 'A' }
+  describe "do not increment outside scope" do
+    it { expect(@user1_account2.letter_code).to eq "A" }
   end
 
-  describe 'not set column if is already set' do
+  describe "not set column if is already set" do
     it { expect(@account2.code).to eq 50 }
   end
 
-  describe 'set column if option force is used' do
-    it { expect(@user1_account1.letter_code).to eq 'A' }
+  describe "set column if option force is used" do
+    it { expect(@user1_account1.letter_code).to eq "A" }
   end
 
-  describe 'locks query for increment' do
+  describe "locks query for increment" do
     before :all do
       threads = []
       lock = Mutex.new
-      @account = Account.create name: 'Another Account', code: 50
+      @account = Account.create name: "Another Account", code: 50
       @accounts = []
       5.times do |_t|
         threads << Thread.new do
           lock.synchronize do
             5.times do |_thr|
-              @accounts << (@account.users.create name: 'Daniel')
+              @accounts << (@account.users.create name: "Daniel")
             end
           end
         end
@@ -55,17 +61,73 @@ describe AutoIncrement do
     end
 
     it { expect(@accounts.size).to eq 25 }
-    it { expect(account_last_letter_code).to eq 'Y' }
+    it { expect(account_last_letter_code).to eq "Y" }
   end
 
-  describe 'set before validation' do
+  describe "set before validation" do
     account3 = Account.new
     account3.valid?
 
     it { expect(account3.code).not_to be_nil }
   end
 
-  describe 'uses model scopes' do
-    it { expect(@user3_account2.letter_code).to eq('C') }
+  describe "uses model scopes" do
+    it { expect(@user3_account2.letter_code).to eq("C") }
+  end
+
+  describe "string column with integer initial" do
+    it "increments correctly past the 9-to-10 boundary" do
+      15.times do |i|
+        post = Post.create!
+        expect(post.ref.to_i).to eq(i + 1)
+      end
+    end
+  end
+
+  describe "deprecation warning" do
+    it "warns when initial is a string on an integer column" do
+      expect {
+        Class.new(ActiveRecord::Base) do
+          self.table_name = "accounts"
+          auto_increment :code, initial: "A"
+        end
+      }.to output(/\[DEPRECATION\] The initial value type \(String\) does not match the column type \(integer\) for column 'code'.*raise an error in the future/).to_stderr
+    end
+
+    it "warns when initial is an integer on a string column" do
+      expect {
+        Class.new(ActiveRecord::Base) do
+          self.table_name = "posts"
+          auto_increment :ref, initial: 1
+        end
+      }.to output(/\[DEPRECATION\] The initial value type \(Integer\) does not match the column type \(string\) for column 'ref'.*raise an error in the future/).to_stderr
+    end
+
+    it "does not warn when types match (integer column, integer initial)" do
+      expect {
+        Class.new(ActiveRecord::Base) do
+          self.table_name = "accounts"
+          auto_increment :code, initial: 100
+        end
+      }.not_to output(/\[DEPRECATION\]/).to_stderr
+    end
+
+    it "does not warn when types match (string column, string initial)" do
+      expect {
+        Class.new(ActiveRecord::Base) do
+          self.table_name = "posts"
+          auto_increment :ref, initial: "X"
+        end
+      }.not_to output(/\[DEPRECATION\]/).to_stderr
+    end
+
+    it "does not warn when initial is omitted on a string column (auto-detects)" do
+      expect {
+        Class.new(ActiveRecord::Base) do
+          self.table_name = "posts"
+          auto_increment :ref
+        end
+      }.not_to output(/\[DEPRECATION\]/).to_stderr
+    end
   end
 end

data/spec/lib/incrementor_spec.rb

@@ -1,33 +1,151 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
+require "models/account"
+require "models/user"
+require "models/post"
 
 describe AutoIncrement::Incrementor do
-  {
-    nil => 1,
-    0 => 1,
-    1 => 2,
-    'A' => 'B',
-    'Z' => 'AA',
-    'AA' => 'AB',
-    'AAAAA' => 'AAAAB'
-  }.each do |previous_value, next_value|
-    describe "increment value for #{previous_value}" do
-      it do
-        allow(subject).to receive(:maximum) { previous_value }
-        expect(subject.send(:increment)).to eq next_value
+  def create_account(code:, name: "seed")
+    Account.create!(name: name, code: code)
+  end
+
+  # Raw SQL is required because User has `force: true` — the auto_increment
+  # callback would otherwise overwrite the value on `create!`.
+  def create_user(code:, name: "seed")
+    conn = ActiveRecord::Base.connection
+    conn.execute "INSERT INTO users (name, letter_code) VALUES (#{conn.quote(name)}, #{conn.quote(code)})"
+  end
+
+  describe "#run" do
+    describe "integer column" do
+      it "auto-detects initial value 1 when no initial is given" do
+        account = Account.new
+        AutoIncrement::Incrementor.new(account).run
+        expect(account.code).to eq 1
+      end
+
+      {
+        0 => 1,
+        1 => 2,
+        9 => 10
+      }.each do |previous_value, next_value|
+        it "increments #{previous_value} to #{next_value}" do
+          create_account(code: previous_value)
+
+          account = Account.new
+          AutoIncrement::Incrementor.new(account).run
+          expect(account.code).to eq next_value
+        end
+      end
+    end
+
+    describe "string column" do
+      it "sets initial value when no records exist" do
+        user = User.new
+        AutoIncrement::Incrementor.new(user, column: :letter_code, initial: "A").run
+        expect(user.letter_code).to eq "A"
+      end
+
+      it "auto-detects initial value '1' when no initial is given" do
+        post = Post.new
+        AutoIncrement::Incrementor.new(post, column: :ref).run
+        expect(post.ref).to eq "1"
+      end
+
+      {
+        "A" => "B",
+        "Z" => "AA",
+        "AA" => "AB",
+        "AAAAA" => "AAAAB"
+      }.each do |previous_value, next_value|
+        it "increments #{previous_value} to #{next_value}" do
+          create_user(code: previous_value)
+
+          user = User.new
+          AutoIncrement::Incrementor.new(user, column: :letter_code, initial: "A").run
+          expect(user.letter_code).to eq next_value
+        end
+      end
+
+      it "uses length-aware ordering inferred from the column schema" do
+        %w[1 2 3 4 5 6 7 8 9 10].each { |v| create_user(code: v) }
+
+        user = User.new
+        AutoIncrement::Incrementor.new(user, column: :letter_code, initial: 1).run
+        expect(user.letter_code).to eq "11"
+      end
+    end
+
+    describe "force" do
+      it "does not overwrite an existing value when force is false" do
+        account = Account.new(code: 5)
+        expect { AutoIncrement::Incrementor.new(account).run }
+          .not_to change { account.code }
+      end
+
+      it "overwrites an existing value when force is true" do
+        create_account(code: 10)
+        account = Account.new(code: 5)
+        AutoIncrement::Incrementor.new(account, force: true).run
+        expect(account.code).to eq 11
+      end
+
+      it "sets the initial value when force is true on an empty table" do
+        account = Account.new(code: 5)
+        AutoIncrement::Incrementor.new(account, force: true).run
+        expect(account.code).to eq 1
+      end
+    end
+
+    describe "scope" do
+      it "only considers records within the same scope" do
+        create_account(code: 10, name: "other")
+
+        account = Account.new(name: "mine")
+        AutoIncrement::Incrementor.new(account, scope: :name).run
+        expect(account.code).to eq 1
       end
     end
-  end
 
-  describe 'initial value of string' do
-    subject do
-      AutoIncrement::Incrementor.new initial: 'A'
+    describe "model scope" do
+      it "bypasses default_scope to see all records" do
+        create_user(code: "C", name: "Mark")
+
+        user = User.new
+        AutoIncrement::Incrementor.new(user, column: :letter_code, initial: "A", model_scope: :with_mark).run
+        expect(user.letter_code).to eq "D"
+      end
+
+      it "applies model scopes when building the query" do
+        create_user(code: "C", name: "Mark")
+        create_user(code: "A", name: "Other")
+
+        user = User.new(name: "Mark")
+        AutoIncrement::Incrementor.new(user, column: :letter_code, initial: "A", model_scope: :with_mark).run
+        expect(user.letter_code).to eq "D"
+      end
+
+      it "only considers records matching the model scope" do
+        create_account(code: 10, name: "Mark")
+        create_account(code: 5, name: "Other")
+        account = Account.new(name: "Mark")
+        AutoIncrement::Incrementor.new(account, column: :code, initial: 1, model_scope: :only_mark).run
+        expect(account.code).to eq 11
+      end
     end
 
-    it do
-      allow(subject).to receive(:maximum) { nil }
-      expect(subject.send(:increment)).to eq 'A'
+    describe "lock" do
+      it "increments correctly with lock enabled" do
+        create_account(code: 10)
+        account = Account.new
+        incrementor = AutoIncrement::Incrementor.new(account, lock: true)
+
+        expect(incrementor.send(:maximum_query).lock_value).to eq true
+
+        incrementor.run
+        expect(account.code).to eq 11
+      end
     end
   end
 end

data/spec/models/account.rb

@@ -5,4 +5,6 @@ class Account < ActiveRecord::Base
   auto_increment :code, before: :validation
 
   has_many :users
+
+  scope :only_mark, -> { where(name: "Mark") }
 end

data/spec/models/post.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# Spec +Post+ — string column with default integer initial
+class Post < ActiveRecord::Base
+  auto_increment :ref
+end

data/spec/models/user.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-# + Spec +User+
+# Spec +User+
 class User < ActiveRecord::Base
-  auto_increment :letter_code, scope: :account_id, initial: 'A', force: true,
-                               lock: true, model_scope: :with_mark
+  auto_increment :letter_code, scope: :account_id, initial: "A", force: true,
+    lock: true, model_scope: :with_mark
 
   belongs_to :account
 
-  default_scope -> { where 'name <> ?', 'Mark' }
+  default_scope -> { where "name <> ?", "Mark" }
 
   scope :with_mark, -> { unscoped }
 end

data/spec/spec_helper.rb

@@ -1,12 +1,18 @@
 # frozen_string_literal: true
 
-require 'pry'
-require 'auto_increment'
-require 'database_cleaner'
+require "pry"
+require "auto_increment"
+require "database_cleaner"
 
-ActiveRecord::Base.establish_connection adapter: 'sqlite3',
-                                        database: 'spec/db/sync.db',
-                                        timeout: 5000
+db_path = "spec/db/sync.db"
 
-# require 'support/active_record'
-require 'support/database_cleaner'
+File.delete(db_path) if File.exist?(db_path)
+
+ActiveRecord::Base.establish_connection(
+  adapter: "sqlite3",
+  database: db_path,
+  timeout: 5000
+)
+
+require "support/active_record"
+require "support/database_cleaner"

data/spec/support/active_record.rb

@@ -12,3 +12,8 @@ ActiveRecord::Migration.create_table :users do |t|
   t.integer :account_id
   t.string :letter_code
 end
+
+# +ActiveRecord+ migration for Posts (string column, integer initial)
+ActiveRecord::Migration.create_table :posts do |t|
+  t.string :ref
+end