simple_slug 0.3.4 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4ee4149b3d1f301a58ec9bc4ff2000727be10650
-  data.tar.gz: 8e9554c782d1b5b33187e3848873f0d12b81ca5d
+SHA256:
+  metadata.gz: 355d5d538c1f8ae0da92c5a55c12b61d4920131d68f73bf0cc353fc018b777e1
+  data.tar.gz: 4e9aa08c961ddc1de5811c000b863f191ae3780de257bde157ea3ae7f9ed1d47
 SHA512:
-  metadata.gz: 9392260bc6505c78f5044916e93d79dcfb3d0dc1bb64570da75c859fb5932d6034d87438af8c3ade9e911ccb728879a8c7712b4fab28488d19b356d99e7b7948
-  data.tar.gz: de23e545145e537dce36ca62973648724ef9dd5e748b0998de3cda46a5c10670004dc6f5e6f8a299ca77de997ec045486eef177c3eeb960b10748d1bf3f3bc67
+  metadata.gz: 8d44218bf0da7e4119b32e37790e8f866deccc600aae3c6260297bd88fa8557a2fd39f3216a0e7d3a4a29c5a62af551a0bf910480a84bdbcccf6a8868f45500a
+  data.tar.gz: 00f5b303bc4c2384bcb09356f42f93c58786ceefc3e1e15a1ee26eb99e116c58b36e88ef216844379fa53e5a1f4b982a32fc7b3ce56549f0e8ce0e3bd823d4be

data/.gitignore

@@ -12,6 +12,7 @@ Gemfile.lock
 InstalledFiles
 _yardoc
 coverage
+/bin
 doc/
 lib/bundler/man
 pkg

data/.travis.yml

@@ -1,4 +1,4 @@
 language: ruby
 
 rvm:
-  - 2.3.0
+  - 2.6.3

data/README.md

@@ -1,7 +1,6 @@
 # SimpleSlug
 
 [![Build Status](https://travis-ci.org/leschenko/simple_slug.png?branch=master)](https://travis-ci.org/leschenko/simple_slug)
-[![Dependency Status](https://gemnasium.com/leschenko/simple_slug.png)](https://gemnasium.com/leschenko/simple_slug)
 
 Simple friendly url generator for ActiveRecord models with history.
 
@@ -37,6 +36,14 @@ class User < ActiveRecord::Base
 end
 ```
 
+Add localization with `slug_YOUR_LOCALE` like columns:
+
+```ruby
+class User < ActiveRecord::Base
+  simple_slug :full_name, locales: [nil, :it]
+end
+```
+
 If you want to control when slug is generated, define `should_generate_new_slug?` method:
 
 ```ruby

data/db/migrate/20140113000001_create_simple_slug_history_slug.rb

@@ -1,13 +1,14 @@
 class CreateSimpleSlugHistorySlug < ActiveRecord::Migration
   def change
-    create_table :simple_slug_history_slug do |t|
-      t.string :slug, null: false
+    create_table :simple_slug_history_slugs do |t|
+      t.string :slug, null: false, limit: 191
+      t.string :locale, limit: 10
       t.integer :sluggable_id, null: false
       t.string :sluggable_type, limit: 50, null: false
-      t.datetime :created_at
+      t.timestamps
     end
 
-    add_index :simple_slug_history_slug, [:slug, :sluggable_type], unique: true
-    add_index :simple_slug_history_slug, [:sluggable_type, :sluggable_id]
+    add_index :simple_slug_history_slugs, :slug
+    add_index :simple_slug_history_slugs, [:sluggable_type, :sluggable_id], name: 'simple_slug_history_slugs_on_sluggable_type_and_sluggable_id'
   end
 end

data/lib/simple_slug.rb

@@ -4,34 +4,36 @@ require 'simple_slug/model_addition'
 require 'simple_slug/railtie' if Object.const_defined?(:Rails)
 
 module SimpleSlug
+  autoload :Adapter, 'simple_slug/adapter'
+  autoload :ModelAddition, 'simple_slug/model_addition'
   autoload :HistorySlug, 'simple_slug/history_slug'
 
   mattr_accessor :excludes
-  @@excludes = %w(new edit show index session login logout sign_in sign_out users admin stylesheets assets javascripts images)
+  @@excludes = %w(new edit show index session login logout sign_in sign_out users admin stylesheets javascripts images fonts assets)
 
   mattr_accessor :slug_regexp
-  @@slug_regexp = /\A\w+[\w\d\-_]*\z/
+  @@slug_regexp = /\A(?:\w+[\w\d\-_]*|--\d+)\z/
 
   mattr_accessor :slug_column
   @@slug_column = 'slug'
 
+  mattr_accessor :min_length
+  @@min_length = 3
+
   mattr_accessor :max_length
-  @@max_length = 240
+  @@max_length = 191
 
   mattr_accessor :callback_type
   @@callback_type = :before_validation
 
-  mattr_accessor :add_validation
-  @@add_validation = true
+  mattr_accessor :validation
+  @@validation = true
 
   STARTS_WITH_NUMBER_REGEXP =/\A\d+/
-  CYRILLIC_LOCALES = [:uk, :ru, :be].freeze
+  NUMBER_REGEXP =/\A\d+\z/
+  RESOLVE_SUFFIX_REGEXP = /--\d+\z/
 
   def self.setup
     yield self
   end
-
-  def self.normalize_cyrillic(base)
-    base.tr('АаВЕеіКкМНОоРрСсТуХх', 'AaBEeiKkMHOoPpCcTyXx')
-  end
 end

data/lib/simple_slug/adapter.rb

@@ -0,0 +1,123 @@
+module SimpleSlug
+  class Adapter
+    attr_reader :model, :options, :locales
+    attr_accessor :current_locale
+
+    def initialize(model)
+      @model = model
+      @options = model.simple_slug_options
+      @locales = Array(@options[:locales] || [nil])
+    end
+
+    def finder_method
+      options[:history] ? :find_by : :find_by!
+    end
+
+    def valid_locale?(locale)
+      locales.include?(locale)
+    end
+
+    def current_locale
+      valid_locale?(I18n.locale) ? I18n.locale : nil
+    end
+
+    def column_names
+      locales.map{|l| column_name(l) }
+    end
+
+    def column_name(locale=I18n.locale)
+      [options[:slug_column], (locale if valid_locale?(locale))].compact.join('_')
+    end
+
+    def get(record)
+      record.send(column_name)
+    end
+
+    def get_prev(record)
+      record.send("#{column_name}_was")
+    end
+
+    def set(record, value)
+      record.send("#{column_name}=", value)
+    end
+
+    def each_locale
+      locales.each do |l|
+        with_locale(l || I18n.default_locale) { yield }
+      end
+    end
+
+    def reset(record)
+      each_locale{ set record, get_prev(record) }
+    end
+
+    def save_history(record)
+      each_locale do
+        slug_was = record.saved_change_to_attribute(column_name).try!(:first)
+        next if slug_was.blank?
+        ::SimpleSlug::HistorySlug.where(sluggable_type: record.class.name, slug: slug_was, locale: current_locale).first_or_initialize.update(sluggable_id: record.id)
+      end
+    end
+
+    def generate(record, force: false)
+      each_locale do
+        next unless force || record.should_generate_new_slug?
+        simple_slug = normalize(slug_base(record))
+        simple_slug = "__#{record.id || rand(9999)}" if simple_slug.blank? && options[:fallback_on_blank]
+        return if simple_slug == get(record).to_s.sub(SimpleSlug::RESOLVE_SUFFIX_REGEXP, '')
+        set(record, resolve(record, simple_slug))
+      end
+    end
+
+    def normalize(base)
+      parameterize_args = ActiveSupport::VERSION::MAJOR > 4 ? {separator: '-'} : '-'
+      normalized = I18n.transliterate(base).parameterize(**parameterize_args).downcase
+      normalized = "_#{normalized}" if normalized =~ SimpleSlug::STARTS_WITH_NUMBER_REGEXP
+      normalized = normalized[0..options[:max_length].pred] if options[:max_length]
+      normalized
+    end
+
+    def add_suffix(slug_value)
+      "#{slug_value}--#{rand(99999)}"
+    end
+
+    def slug_base(record)
+      options[:slug_method].map{|m| record.send(m).to_s }.reject(&:blank?).join(' ')
+    end
+
+    def resolve(record, slug_value)
+      return slug_value unless slug_exists?(record, slug_value)
+      loop do
+        slug_with_suffix = add_suffix(slug_value)
+        break slug_with_suffix unless slug_exists?(record, slug_with_suffix)
+      end
+    end
+
+    def slug_exists?(record, slug_value)
+      model_slug_exists?(record, slug_value) || history_slug_exists?(record, slug_value)
+    end
+
+    def model_slug_exists?(record, slug_value)
+      base_scope = record.class.unscoped.where(column_name => slug_value)
+      base_scope = base_scope.where('id != ?', record.id) if record.persisted?
+      base_scope.exists?
+    end
+
+    def history_slug_exists?(record, slug_value)
+      return false unless options[:history]
+      base_scope = SimpleSlug::HistorySlug.where(sluggable_type: record.class.name, slug: slug_value)
+      base_scope = base_scope.where('sluggable_id != ?', record.id) if record.persisted?
+      base_scope.exists?
+    end
+
+    def with_locale(locale)
+      if defined? Globalize
+        Globalize.with_locale(locale) do
+          I18n.with_locale(locale) { yield }
+        end
+      else
+        I18n.with_locale(locale) { yield }
+      end
+    end
+  end
+end

data/lib/simple_slug/history_slug.rb

@@ -1,5 +1,6 @@
 module SimpleSlug
   class HistorySlug < ActiveRecord::Base
+    self.table_name = 'simple_slug_history_slugs'
     belongs_to :sluggable, polymorphic: true
   end
 end

data/lib/simple_slug/model_addition.rb

@@ -6,33 +6,35 @@ module SimpleSlug
 
     module SingletonMethods
       def simple_slug(*args)
-        class_attribute :simple_slug_options, instance_writer: false
+        class_attribute :simple_slug_options, :simple_slug_adapter, instance_writer: false
         options = args.extract_options!
         self.simple_slug_options = options.reverse_merge(
             slug_column: SimpleSlug.slug_column,
             slug_method: args,
             slug_regexp: SimpleSlug.slug_regexp,
+            min_length: SimpleSlug.min_length,
             max_length: SimpleSlug.max_length,
             callback_type: SimpleSlug.callback_type,
-            add_validation: SimpleSlug.add_validation
+            validation: SimpleSlug.validation
         )
+        self.simple_slug_adapter = SimpleSlug::Adapter.new(self)
 
         include InstanceMethods
         extend ClassMethods
 
         send(simple_slug_options[:callback_type], :simple_slug_generate, if: :should_generate_new_slug?) if simple_slug_options[:callback_type]
 
-        if simple_slug_options[:add_validation]
-          simple_slug_locales.each do |locale|
-            validates simple_slug_column(locale),
-                      presence: true,
-                      exclusion: {in: SimpleSlug.excludes},
-                      format: {with: simple_slug_options[:slug_regexp]}
-          end
+        if simple_slug_options[:validation]
+          validates *simple_slug_adapter.column_names,
+                    presence: true,
+                    uniqueness: {case_sensitive: true},
+                    exclusion: {in: SimpleSlug.excludes},
+                    format: {with: simple_slug_options[:slug_regexp]},
+                    length: {minimum: simple_slug_options[:min_length], maximum: simple_slug_options[:max_length]}.reject{|_, v| v.blank? }
         end
 
         if simple_slug_options[:history]
-          after_save :simple_slug_reset_unsaved_slug, :simple_slug_create_history_slug
+          after_save :simple_slug_reset, :simple_slug_save_history
           after_destroy :simple_slug_cleanup_history
           include InstanceHistoryMethods
         end
@@ -42,144 +44,45 @@ module SimpleSlug
     module ClassMethods
       def simple_slug_find(id_param)
         return unless id_param
-        if id_param.is_a?(Integer) || id_param =~ /\A\d+\z/
+        if id_param.is_a?(Integer) || id_param =~ SimpleSlug::NUMBER_REGEXP
           find(id_param)
         else
-          finder_method = simple_slug_options[:history] ? :find_by : :find_by!
-          send(finder_method, simple_slug_column => id_param) or find(::SimpleSlug::HistorySlug.find_by!(slug: id_param).sluggable_id)
+          send(simple_slug_adapter.finder_method, simple_slug_adapter.column_name => id_param) or simple_slug_history_find(id_param)
         end
       end
 
-      alias_method :friendly_find, :simple_slug_find
-
-      def simple_slug_column(locale=I18n.locale)
-        if simple_slug_localized?(locale)
-          [simple_slug_options[:slug_column], locale].compact.join('_')
-        else
-          simple_slug_options[:slug_column]
-        end
-      end
-
-      def simple_slug_columns
-        simple_slug_locales.map{|locale| simple_slug_column(locale) }
-      end
-
-      def simple_slug_locales
-        Array(simple_slug_options[:locales] || [nil])
+      def simple_slug_history_find(slug, locale=I18n.locale)
+        find(SimpleSlug::HistorySlug.find_by!(locale: (locale if simple_slug_adapter.valid_locale?(locale)), slug: slug).sluggable_id)
       end
 
-      def simple_slug_localized?(locale=I18n.locale)
-        return unless locale
-        simple_slug_locales.include?(locale.to_sym)
-      end
+      alias_method :friendly_find, :simple_slug_find
     end
 
     module InstanceMethods
       def to_param
-        simple_slug_stored_slug.presence || super
+        simple_slug_adapter.get_prev(self).presence || super
       end
 
       def should_generate_new_slug?
-        return true if simple_slug_options[:history]
-        return simple_slug_get.blank? unless simple_slug_options[:locales]
-        simple_slug_options[:locales].any? { |locale| simple_slug_get(locale).blank? }
+        simple_slug_adapter.column_names.any?{|cn| send(cn).blank? }
       end
 
       def simple_slug_generate(force=false)
-        (simple_slug_options[:locales] || [nil]).each do |locale|
-          simple_slug_generate_for_locale(locale, force)
-        end
-      end
-
-      def simple_slug_generate_for_locale(locale=I18n.locale, force=false)
-        simple_slug_with_locale(locale) do
-          simple_slug = simple_slug_normalize(simple_slug_base)
-          simple_slug = simple_slug.first(simple_slug_options[:max_length]) if simple_slug_options[:max_length]
-          return if !force && simple_slug == simple_slug_get(locale).to_s.sub(/--\d+\z/, '')
-          resolved_simple_slug = simple_slug_resolve(simple_slug, locale)
-          simple_slug_set(resolved_simple_slug, locale)
-        end
-      end
-
-      def simple_slug_with_locale(locale)
-        if defined? Globalize
-          Globalize.with_locale(locale) do
-            I18n.with_locale(locale) { yield }
-          end
-        else
-          I18n.with_locale(locale) { yield }
-        end
-      end
-
-      def simple_slug_base
-        simple_slug_options[:slug_method].map{|m| send(m).to_s }.reject(&:blank?).join(' ')
-      end
-
-      def simple_slug_normalize(base)
-        base = SimpleSlug.normalize_cyrillic(base) unless SimpleSlug::CYRILLIC_LOCALES.include?(I18n.locale)
-        parameterize_args = ActiveSupport::VERSION::MAJOR > 4 ? {separator: '-'} : '-'
-        normalized = I18n.transliterate(base).parameterize(parameterize_args).downcase
-        normalized.to_s =~ SimpleSlug::STARTS_WITH_NUMBER_REGEXP ? "_#{normalized}" : normalized
-      end
-
-      def simple_slug_resolve(slug_value, locale=I18n.locale)
-        if simple_slug_exists?(slug_value, locale)
-          loop do
-            slug_value_with_suffix = simple_slug_next(slug_value)
-            break slug_value_with_suffix unless simple_slug_exists?(slug_value_with_suffix, locale)
-          end
-        else
-          slug_value
-        end
-      end
-
-      def simple_slug_next(slug_value)
-        "#{slug_value}--#{rand(99999)}"
-      end
-
-      def simple_slug_exists?(slug_value, locale=I18n.locale)
-        simple_slug_base_exists?(slug_value, locale) || simple_slug_history_exists?(slug_value)
-      end
-
-      def simple_slug_base_exists?(slug_value, locale=I18n.locale)
-        base_scope = self.class.unscoped.where(self.class.simple_slug_column(locale) => slug_value)
-        base_scope = base_scope.where('id != ?', id) if persisted?
-        base_scope.exists?
-      end
-
-      def simple_slug_history_exists?(slug_value)
-        return false unless simple_slug_options[:history]
-        base_scope = ::SimpleSlug::HistorySlug.where(sluggable_type: self.class.name, slug: slug_value)
-        base_scope = base_scope.where('sluggable_id != ?', id) if persisted?
-        base_scope.exists?
-      end
-
-      def simple_slug_set(value, locale=I18n.locale)
-        send "#{self.class.simple_slug_column(locale)}=", value
-      end
-
-      def simple_slug_get(locale=I18n.locale)
-        send self.class.simple_slug_column(locale)
-      end
-
-      def simple_slug_stored_slug(locale=I18n.locale)
-        send("#{self.class.simple_slug_column(locale)}_was")
+        simple_slug_adapter.generate(self, force: force)
       end
     end
 
     module InstanceHistoryMethods
-      def simple_slug_reset_unsaved_slug
-        return true if errors.blank?
-        simple_slug_set simple_slug_stored_slug
+      def simple_slug_reset
+        errors.blank? || simple_slug_adapter.reset(self)
       end
 
       def simple_slug_cleanup_history
         ::SimpleSlug::HistorySlug.where(sluggable_type: self.class.name, sluggable_id: id).delete_all
       end
 
-      def simple_slug_create_history_slug
-        return true unless slug_changed?
-        ::SimpleSlug::HistorySlug.where(sluggable_type: self.class.name, slug: simple_slug_get).first_or_create{|hs| hs.sluggable_id = id }
+      def simple_slug_save_history
+        simple_slug_adapter.save_history(self)
       end
     end
   end

data/lib/simple_slug/railtie.rb

@@ -1,11 +1,9 @@
 module SimpleSlug
   class Railtie < Rails::Railtie
     initializer 'simple_slug.model_additions' do
-
       ActiveSupport.on_load :active_record do
         include SimpleSlug::ModelAddition
       end
-
     end
   end
 end

data/lib/simple_slug/version.rb

@@ -1,3 +1,3 @@
 module SimpleSlug
-  VERSION = '0.3.4'
+  VERSION = '0.4.3'
 end

data/simple_slug.gemspec

@@ -1,4 +1,3 @@
-# coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'simple_slug/version'
@@ -9,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Alex Leschenko']
   spec.email         = ['leschenko.al@gmail.com']
   spec.summary       = %q{Friendly url generator with history.}
-  spec.description   = %q{Simple friendly url generator for ActiveRecord with history."}
+  spec.description   = %q{Simple friendly url generator for ActiveRecord with history.}
   spec.homepage      = 'https://github.com/leschenko/simple_slug'
   spec.license       = 'MIT'
 
@@ -18,10 +17,11 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'activerecord', '>= 4.0.0', '< 5.2'
-  spec.add_dependency 'i18n', '~> 0.7'
+  spec.add_dependency 'activerecord', '>= 4.0.0', '< 6.2'
+  spec.add_dependency 'i18n', '~> 1.8.7'
 
-  spec.add_development_dependency 'bundler', '~> 1.5'
+  spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'sqlite3'
 end

data/spec/simple_slug/base_spec.rb

@@ -1,17 +1,17 @@
 require 'spec_helper'
 
 describe SimpleSlug do
-  context 'defaults' do
-    it 'slug column' do
+  describe 'config' do
+    it 'has column name' do
       expect(SimpleSlug.slug_column).to eq 'slug'
     end
 
-    it 'excludes' do
+    it 'has excludes' do
       expect(SimpleSlug.excludes).to include('new', 'edit')
     end
 
-    it 'max length' do
-     expect( SimpleSlug.max_length).to eq 240
+    it 'has max length' do
+     expect( SimpleSlug.max_length).to eq 191
     end
   end
 end

data/spec/simple_slug/history_spec.rb

@@ -1,54 +1,79 @@
 require 'spec_helper'
 
-class SlugHistoryRspecModel < RspecActiveModelBase
+class SlugHistoryRspecModel < RspecActiveRecordBase
   simple_slug :name, history: true
+
+  def should_generate_new_slug?
+    true
+  end
 end
 
-describe 'slug history' do
-  describe 'history records handling' do
-    before do
-      expect_any_instance_of(SlugHistoryRspecModel).to receive(:simple_slug_exists?).and_return(false)
+class SlugLocalizedHistoryRspecModel < RspecActiveRecordBase
+  simple_slug :name_for_slug, history: true, locales: [nil, :en]
+
+  def name_for_slug
+    [name, (I18n.locale unless I18n.locale == I18n.default_locale)].compact.join(' ')
+  end
+
+  def should_generate_new_slug?
+    true
+  end
+end
+
+describe 'history' do
+  before :each do
+    RspecActiveRecordBase.delete_all
+    SimpleSlug::HistorySlug.delete_all
+  end
+
+  describe 'persistence' do
+    it 'save previous on change' do
+      sluggable = SlugHistoryRspecModel.create(id: 1, name: 'Hello')
+      expect(SimpleSlug::HistorySlug.where(sluggable_type: 'SlugHistoryRspecModel', sluggable_id: 1).exists?).to be_falsey
+      sluggable.update(name: 'Bye')
+      hs = SimpleSlug::HistorySlug.where(sluggable_type: 'SlugHistoryRspecModel', sluggable_id: 1).to_a
+      expect(hs.size).to eq 1
+      expect(hs.first.locale).to be_falsey
+      expect(hs.first.slug).to eq 'hello'
     end
 
-    it 'create' do
-      relation = double
-      expect(::SimpleSlug::HistorySlug).to receive(:where).once.ordered.with(sluggable_type: 'SlugHistoryRspecModel', slug: 'hello').and_return(relation)
-      expect(relation).to receive(:first_or_create)
-      SlugHistoryRspecModel.create(id: 1, name: 'Hello')
+    it 'remove on destroy' do
+      sluggable = SlugHistoryRspecModel.create(id: 1, name: 'Hello')
+      sluggable.update(name: 'Bye')
+      expect{ sluggable.destroy }.to change{ SimpleSlug::HistorySlug.where(sluggable_type: 'SlugHistoryRspecModel', sluggable_id: 1).count }.from(1).to(0)
     end
 
-    it 'cleanup' do
-      relation = double
-      expect(relation).to receive(:first_or_create)
-      allow(::SimpleSlug::HistorySlug).to receive(:where).and_return(relation)
-      expect(relation).to receive(:delete_all)
-      SlugHistoryRspecModel.create(name: 'Hello', id: 1).destroy
+    context 'localized' do
+      it 'save previous on change' do
+        SlugLocalizedHistoryRspecModel.create(id: 1, name: 'Hello').update(name: 'Bye')
+        hs = SimpleSlug::HistorySlug.where(sluggable_type: 'SlugLocalizedHistoryRspecModel', sluggable_id: 1).to_a
+        expect(hs.map(&:locale)).to match_array [nil, 'en']
+        expect(hs.map(&:slug)).to match_array %w(hello hello-en)
+      end
     end
   end
 
   describe 'conflicts' do
-    it 'history slug exists' do
-      record = SlugGenerationRspecModel.new(name: 'Hi')
-      allow(record).to receive(:simple_slug_base_exists?).and_return(false)
-      expect(record).to receive(:simple_slug_history_exists?).once.ordered.and_return(true)
-      expect(record).to receive(:simple_slug_history_exists?).once.ordered.and_return(false)
-      record.save
-      expect(record.slug).to start_with('hi--')
+    it 'resolve with suffix' do
+      SlugHistoryRspecModel.create(name: 'Hello').update(name: 'Bye')
+      record = SlugHistoryRspecModel.create(name: 'Hello')
+      expect(record.slug).to start_with('hello--')
     end
-  end
 
-  describe '#friendly_find' do
-    before do
-      allow(SlugHistoryRspecModel).to receive(:find_by)
+    context 'localized' do
+      it 'resolve with suffix' do
+        SlugLocalizedHistoryRspecModel.create(name: 'Hello').update(name: 'Bye')
+        record = SlugLocalizedHistoryRspecModel.create(name: 'Hello')
+        expect(record.slug).to start_with('hello--')
+        expect(record.slug_en).to start_with('hello-en--')
+      end
     end
+  end
 
-    it 'find from history' do
-      record = double('history')
-      allow(record).to receive(:sluggable_id).and_return(1)
-      expect(::SimpleSlug::HistorySlug).to receive(:find_by!).with(slug: 'title').and_return(record)
-      expect(SlugHistoryRspecModel).to receive(:find).with(1).and_return(record)
-      SlugHistoryRspecModel.friendly_find('title')
+  describe 'find' do
+    it 'use history' do
+      SlugLocalizedHistoryRspecModel.create(id: 1, name: 'Hello').update(name: 'Bye')
+      expect(SlugLocalizedHistoryRspecModel.friendly_find('hello')).to be_truthy
     end
   end
-
 end

data/spec/simple_slug/model_addition_spec.rb

@@ -1,186 +1,192 @@
 require 'spec_helper'
 
-class SlugGenerationRspecModel < RspecActiveModelBase
+class SlugRspecModel < RspecActiveRecordBase
   simple_slug :name
 end
 
-class SlugGenerationRspecModelWithoutValidation < RspecActiveModelBase
-  simple_slug :name, add_validation: false
+class SlugWithFallbackOnBlankRspecModel < RspecActiveRecordBase
+  simple_slug :name, fallback_on_blank: true
 end
 
-class SlugGenerationRspecModelWithoutCallback < RspecActiveModelBase
-  simple_slug :name, callback_type: nil
+class SlugWithoutMaxLengthRspecModel < RspecActiveRecordBase
+  simple_slug :name, max_length: nil
+end
+
+
+class SlugWithoutValidationRspecModel < RspecActiveRecordBase
+  simple_slug :name, validation: false
 end
 
-class SlugGenerationRspecModelLocalized < RspecActiveModelBase
-  attr_accessor :slug_en, :name_en
-  alias_method :slug_en_was, :slug_en
+class SlugWithoutCallbackRspecModel < RspecActiveRecordBase
+  simple_slug :name, callback_type: nil
+end
 
-  simple_slug :name, locales: [nil, :en]
+class SlugLocalizedRspecModel < RspecActiveRecordBase
+  simple_slug :name_for_slug, history: true, locales: [nil, :en]
 
-  def name
-    I18n.locale == :en ? name_en : @name
+  def name_for_slug
+    [name, (I18n.locale unless I18n.locale == I18n.default_locale)].compact.join(' ')
   end
 end
 
 describe SimpleSlug::ModelAddition do
-  describe 'slug generation' do
-    before do
-      allow_any_instance_of(SlugGenerationRspecModel). to receive(:simple_slug_exists?).and_return(false)
+  before :each do
+    RspecActiveRecordBase.delete_all
+    SimpleSlug::HistorySlug.delete_all
+  end
+
+  describe 'slug' do
+    it 'generate on save' do
+      expect(SlugRspecModel.create(name: 'Hello').slug).to eq 'hello'
     end
 
-    it 'after save' do
-      expect(SlugGenerationRspecModel.create(name: 'Hello').slug).to eq 'hello'
+    it 'add prefix for numbers' do
+      expect(SlugRspecModel.create(name: '123').slug).to eq '_123'
     end
 
-    it 'skip excludes' do
-      expect(SlugGenerationRspecModel.new(name: 'new')).not_to be_valid
+    it 'reject excludes' do
+      expect(SlugRspecModel.new(name: 'new')).not_to be_valid
     end
 
-    it 'skip integers' do
-      expect(SlugGenerationRspecModel.new(name: '123')).not_to be_valid
+    it 'reject spaces' do
+      expect(SlugRspecModel.new(slug: 'test test')).not_to be_valid
     end
 
-    it 'skip spaces' do
-      expect(SlugGenerationRspecModel.new(slug: 'test test')).not_to be_valid
+    it 'reject punctuation' do
+      expect(SlugRspecModel.new(slug: 'test.test')).not_to be_valid
     end
 
-    it 'skip punctuation' do
-      expect(SlugGenerationRspecModel.new(slug: 'test.test')).not_to be_valid
+    it 'fallback to prefixed id on blank slug source' do
+      expect(SlugWithFallbackOnBlankRspecModel.create({}).slug).to start_with '__'
     end
 
-    it 'skip slug generation' do
-      allow_any_instance_of(SlugGenerationRspecModel).to receive(:should_generate_new_slug?).and_return(false)
-      expect(SlugGenerationRspecModel.create(name: 'Hello').slug).to be_blank
+    describe '#should_generate_new_slug?' do
+      it 'can omit generation' do
+        allow_any_instance_of(SlugRspecModel).to receive(:should_generate_new_slug?).and_return(false)
+        expect(SlugRspecModel.create(name: 'Hello').slug).to be_blank
+      end
     end
   end
 
-  describe 'resolve conflicts' do
-    it 'duplicate slug' do
-      record = SlugGenerationRspecModel.new(name: 'Hi')
-      expect(record).to receive(:simple_slug_exists?).once.ordered.with('hi', nil).and_return(true)
-      expect(record).to receive(:simple_slug_exists?).once.ordered.with(/hi--\d+/, nil).and_return(false)
-      record.save
-      expect(record.slug).to start_with('hi--')
+  describe 'conflicts' do
+    it 'resolve with suffix' do
+      SlugRspecModel.create(name: 'Hello')
+      record = SlugHistoryRspecModel.create(name: 'Hello')
+      expect(record.slug).to start_with('hello--')
     end
 
-    it 'numeric slug' do
-      record = SlugGenerationRspecModel.new(name: '123')
-      expect(record).to receive(:simple_slug_exists?).with('_123', nil).and_return(false)
-      record.save
-      expect(record.slug).to eq '_123'
+    context 'localized' do
+      it 'resolve with suffix' do
+        SlugLocalizedRspecModel.create(name: 'Hello')
+        record = SlugLocalizedRspecModel.create(name: 'Hello')
+        expect(record.slug).to start_with('hello--')
+        expect(record.slug_en).to start_with('hello-en--')
+      end
     end
   end
 
   describe '#to_param' do
     before do
-      allow_any_instance_of(SlugGenerationRspecModel).to receive(:simple_slug_exists?).and_return(false)
+      allow_any_instance_of(SlugRspecModel).to receive(:simple_slug_exists?).and_return(false)
     end
 
-    it 'slug if exists' do
-      expect(SlugGenerationRspecModel.create(name: 'Hello').to_param).to eq 'hello'
+    it 'use slug if present' do
+      expect(SlugRspecModel.create(name: 'Hello').to_param).to eq 'hello'
     end
 
-    it 'id without slug' do
-      expect(SlugGenerationRspecModel.create(id: 1).to_param).to eq '1'
+    it 'do not use unsaved slug' do
+      expect(SlugRspecModel.new(name: 'Hello').to_param).to be_falsey
     end
-  end
 
-  describe '#friendly_find' do
-    it '#find if integer like' do
-      expect(SlugGenerationRspecModel).to receive(:find).with(1)
-      SlugGenerationRspecModel.friendly_find(1)
+    it 'use id if slug blank' do
+      expect(SlugRspecModel.create(id: 1).to_param).to eq '1'
     end
+  end
 
-    it '#find if numeric string' do
-      expect(SlugGenerationRspecModel).to receive(:find).with('1')
-      SlugGenerationRspecModel.friendly_find('1')
+  describe 'find' do
+    it 'by id on integer like param' do
+      expect(SlugRspecModel).to receive(:find).with('1')
+      SlugRspecModel.friendly_find('1')
     end
 
-    it 'find by slug' do
-      expect(SlugGenerationRspecModel).to receive(:find_by!).with('slug' => 'title').and_return(double)
-      SlugGenerationRspecModel.friendly_find('title')
+    it 'by slug' do
+      expect(SlugRspecModel).to receive(:find_by!).with('slug' => 'title').and_return(double)
+      SlugRspecModel.friendly_find('title')
     end
   end
 
   describe 'max length' do
-    before do
-      allow_any_instance_of(SlugGenerationRspecModel).to receive(:simple_slug_exists?).and_return(false)
-    end
-
-    after do
-      SlugGenerationRspecModel.simple_slug_options.delete(:max_length)
-    end
-
     it 'cuts slug to max length' do
-      record = SlugGenerationRspecModel.new(name: 'Hello' * 100)
-      record.simple_slug_generate
-      expect(record.slug.length).to eq 240
-    end
-
-    it 'use max length from per model options' do
-      SlugGenerationRspecModel.simple_slug_options[:max_length] = 100
-      record = SlugGenerationRspecModel.new(name: 'Hello' * 100)
+      record = SlugRspecModel.new(name: 'Hello' * 100)
       record.simple_slug_generate
-      expect(record.slug.length).to eq 100
+      expect(record.slug.length).to eq 191
     end
 
-    it 'omit max length' do
-      SimpleSlug.max_length = nil
-      record = SlugGenerationRspecModel.new(name: 'Hello' * 100)
+    it 'return full slug without max_length option' do
+      record = SlugWithoutMaxLengthRspecModel.new(name: 'Hello' * 100)
       record.simple_slug_generate
       expect(record.slug.length).to eq 500
     end
   end
 
-  describe 'add_validation' do
-    it 'skip validation' do
-      expect(SlugGenerationRspecModelWithoutValidation.validators_on(:slug)).to be_blank
+  describe 'validation' do
+    it 'optionally skip validations' do
+      expect(SlugWithoutValidationRspecModel.validators_on(:slug)).to be_blank
     end
   end
 
-  describe 'callback_type' do
-    it 'skip callback' do
-      expect(SlugGenerationRspecModelWithoutCallback.new).not_to receive(:should_generate_new_slug?)
+  describe 'callbacks' do
+    it 'optionally skip callback' do
+      expect(SlugWithoutCallbackRspecModel.new).not_to receive(:should_generate_new_slug?)
     end
   end
 
   describe 'localized' do
-    before do
-      allow_any_instance_of(SlugGenerationRspecModelLocalized).to receive(:simple_slug_exists?).and_return(false)
-    end
-
     it 'generate slug for locales' do
-      record = SlugGenerationRspecModelLocalized.create(name: 'Hello', name_en: 'Hello en')
+      record = SlugLocalizedRspecModel.create(name: 'Hello')
       expect(record.slug).to eq 'hello'
       expect(record.slug_en).to eq 'hello-en'
     end
 
+    describe '#should_generate_new_slug?' do
+      it 'keep slug when present' do
+        record = SlugLocalizedRspecModel.create(name: 'Hello')
+        expect{ record.update(name: 'Bye') }.not_to change{ record.slug }
+      end
+
+      it 'generate slug when blank' do
+        record = SlugLocalizedRspecModel.create(name: 'Hello')
+        record.name = 'bye'
+        record.slug_en = nil
+        expect{ record.save }.to change{ record.slug_en }.to('bye-en')
+      end
+    end
+
     describe '#to_param' do
-      it 'generate not localized for default locale' do
-        record = SlugGenerationRspecModelLocalized.create(name: 'Hello', name_en: 'Hello en')
+      it 'use unlocalized column for default locale' do
+        record = SlugLocalizedRspecModel.create(name: 'Hello')
         expect(record.to_param).to eq 'hello'
       end
 
-      it 'generate localized' do
-        record = SlugGenerationRspecModelLocalized.create(name: 'Hello', name_en: 'Hello en')
+      it 'use localized column for non-default locales' do
+        record = SlugLocalizedRspecModel.create(name: 'Hello')
         I18n.with_locale(:en) do
           expect(record.to_param).to eq 'hello-en'
         end
       end
     end
 
-    describe '#simple_slug_find' do
-      it 'use default slug column with default locale' do
-        record = SlugGenerationRspecModelLocalized.create(name: 'Hello', name_en: 'Hello en')
-        expect(SlugGenerationRspecModelLocalized).to receive(:find_by!).with('slug' => 'hello').and_return(record)
-        SlugGenerationRspecModelLocalized.simple_slug_find('hello')
+    describe 'find' do
+      it 'use default slug column for default locale' do
+        record = SlugLocalizedRspecModel.create(name: 'Hello')
+        expect(SlugLocalizedRspecModel.simple_slug_find('hello')).to eq record
       end
 
-      it 'use localized slug column' do
-        record = SlugGenerationRspecModelLocalized.create(name: 'Hello', name_en: 'Hello en')
-        expect(SlugGenerationRspecModelLocalized).to receive(:find_by!).with('slug_en' => 'hello-en').and_return(record)
-        I18n.with_locale(:en) { SlugGenerationRspecModelLocalized.simple_slug_find('hello-en') }
+      it 'use localized slug column for non-default locale' do
+        record = SlugLocalizedRspecModel.create(name: 'Hello')
+        I18n.with_locale(:en) do
+          expect(SlugLocalizedRspecModel.simple_slug_find('hello-en')).to eq record
+        end
       end
     end
   end

data/spec/spec_helper.rb

@@ -1,48 +1,44 @@
+require 'sqlite3'
 require 'active_record'
 require 'i18n'
 require 'active_support/core_ext'
 require 'byebug'
 require 'simple_slug'
 
-# just silence warning
 I18n.enforce_available_locales = false
 I18n.default_locale = :uk
 
-class RspecActiveModelBase
-  include ActiveModel::Model
-  include ActiveModel::AttributeMethods
-  extend ActiveModel::Callbacks
-
-  include SimpleSlug::ModelAddition
-
-  define_model_callbacks :validation, :save, :destroy
-
-  attr_accessor :id, :slug, :name, :created_at
-  alias_method :slug_was, :slug
-
-  def self.create(attributes, *)
-    record = new(attributes)
-    record.save
-    record
-  end
-
-  def save
-    run_callbacks(:validation) { run_callbacks(:save) { } }
-  end
-
-  def destroy
-    run_callbacks(:destroy) { @destroyed = true }
-  end
-
-  def persisted?
-    true
+ActiveRecord::Base.establish_connection(
+  adapter: 'sqlite3',
+  database: ':memory:'
+)
+
+# ActiveRecord::Base.logger = Logger.new(STDOUT)
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    ActiveRecord::Migration.verbose = false
+
+    ActiveRecord::Schema.define do
+      create_table :rspec_active_record_bases, force: true do |t|
+        t.string :name
+        t.string :slug, limit: 191
+        t.string :slug_en, limit: 191
+        t.timestamps
+      end
+
+      create_table :simple_slug_history_slugs, force: true do |t|
+        t.string :slug, null: false, limit: 191
+        t.string :locale, limit: 10
+        t.integer :sluggable_id, null: false
+        t.string :sluggable_type, limit: 50, null: false
+        t.timestamps
+      end
+    end
   end
+end
 
-  def slug_changed?
-    slug.present?
-  end
 
-  def destroyed?
-    !!@destroyed
-  end
-end
+class RspecActiveRecordBase < ActiveRecord::Base
+  include SimpleSlug::ModelAddition
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simple_slug
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.4.3
 platform: ruby
 authors:
 - Alex Leschenko
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-05-27 00:00:00.000000000 Z
+date: 2021-01-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -19,7 +19,7 @@ dependencies:
         version: 4.0.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '6.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,35 +29,35 @@ dependencies:
         version: 4.0.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '6.2'
 - !ruby/object:Gem::Dependency
   name: i18n
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.7'
+        version: 1.8.7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.7'
+        version: 1.8.7
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -86,7 +86,21 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Simple friendly url generator for ActiveRecord with history."
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  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: Simple friendly url generator for ActiveRecord with history.
 email:
 - leschenko.al@gmail.com
 executables: []
@@ -101,6 +115,7 @@ files:
 - Rakefile
 - db/migrate/20140113000001_create_simple_slug_history_slug.rb
 - lib/simple_slug.rb
+- lib/simple_slug/adapter.rb
 - lib/simple_slug/history_slug.rb
 - lib/simple_slug/model_addition.rb
 - lib/simple_slug/railtie.rb
@@ -114,7 +129,7 @@ homepage: https://github.com/leschenko/simple_slug
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -129,9 +144,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
-signing_key: 
+rubygems_version: 3.0.6
+signing_key:
 specification_version: 4
 summary: Friendly url generator with history.
 test_files: