simple_slug 0.3.5 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4e372bf7c9afde482560d5e69ed52ce343e0c08e
-  data.tar.gz: 3f51178cc10919580d3e167839c93d1ceaa5fedd
+SHA256:
+  metadata.gz: ac49bba6dff11ad2a2bce99cef0ff717ca35a626fb22c23ef708369b596c57fe
+  data.tar.gz: eb3955cec13641066e6d15aef572b78491fc8b6c59500658edbd72e05126083d
 SHA512:
-  metadata.gz: e6b3a471ce38ccb23d33ca1be285012b7980d1d5c15f6a982b869c8d348ee879d405728c1fe0eeea80e112b4471a2765e6ceec7b38da3b01c1ea7e1dcd64be6f
-  data.tar.gz: 5872ee8fe9b193d425ec3090c403a19fe7fec864f1fdf94f0a6039a65782248bef837600d49ba3b2679299ba6008353ea83bd8d6d749678f2b867d0bde8431ec
+  metadata.gz: 961d7deede6a55925d4020f2b09f3e40b86012d3574f5745318a69ea34b952cef7f00b251562832ec053fcc61db52b268f647092f57e934e7278f58a34c8b789
+  data.tar.gz: dbc20244f3751330ac668edf4a92b381c9c1b2480a924be0b90cf0d37a194703cd6c9833e6cc1d852f8b912b08c815a93c916666660460b780a7cce02ed1341b

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,10 +4,12 @@ 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\-_]*|--\d+)\z/
@@ -15,48 +17,23 @@ module SimpleSlug
   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
-  ES_LOCALES = [:es].freeze
-
-  ES_NORMALIZE_SINGLE = [
-      'ÀÁÂÃÄÅÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝßàáâãäåçèéêëìíîïñòóôõöøùúûüýÿĀāĂ㥹ĆćĈĉĊċČčĎďĐđĒēĔĕĖėĘęĚěĜĝĞğĠġĢģĤĥĦħĨĩĪīĬĭĮįİıĴĵĶķĹĺĻļĽľĿŀŁłŃńŅņŇňʼnŌōŎŏŐőŔŕŖŗŘřŚśŜŝŞşŠšŢţŤťŦŧŨũŪūŬŭŮůŰűŲųŴŵŶŷŸŹźŻżŽžſƒƠơƯưǍǎǏǐǑǒǓǔǕǖǗǘǙǚǛǜǺǻǾǿ',
-      'AAAAAACEEEEIIIIDNOOOOOOUUUUYsaaaaaaceeeeiiiinoooooouuuuyyAaAaAaCcCcCcCcDdDdEeEeEeEeEeGgGgGgGgHhHhIiIiIiIiIiJjKkLlLlLlLlllNnNnNnnOoOoOoRrRrRrSsSsSsSsTtTtTtUuUuUuUuUuUuWwYyYZzZzZzsfOoUuAaIiOoUuUuUuUuUuAaOo'
-  ].freeze
-
-  ES_NORMALIZE_MULTI = [['Æ', 'AE'], ['æ', 'ae'], ['IJ', 'IJ'], ['ij', 'ij'], ['Œ', 'OE'], ['œ', 'oe'], ['Ǽ', 'AE'], ['ǽ', 'ae']].freeze
+  NUMBER_REGEXP =/\A\d+\z/
+  RESOLVE_SUFFIX_REGEXP = /--\d+\z/
 
   def self.setup
     yield self
   end
-
-  def self.normalize_i18n_fix(base, locale=I18n.locale)
-    locale_sym = locale.to_sym
-    if CYRILLIC_LOCALES.include?(locale_sym)
-      normalize_cyrillic(base)
-    elsif ES_LOCALES.include?(locale_sym)
-      normalize_es(base)
-    else
-      base
-    end
-  end
-
-  def self.normalize_cyrillic(base)
-    base.tr('АаВЕеіКкМНОоРрСсТуХх', 'AaBEeiKkMHOoPpCcTyXx')
-  end
-
-  def self.normalize_es(base)
-    base = base.tr(*ES_NORMALIZE_SINGLE)
-    ES_NORMALIZE_MULTI.each{|d| base.gsub!(*d) }
-    base
-  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.first(options[:max_length]) 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,157 +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) }
+      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_locales
-        Array(simple_slug_options[:locales] || [nil])
-      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]
-        if simple_slug_options[:locales]
-          should_generate_new_slug_for_locales.present?
-        else
-          simple_slug_get.blank?
-        end
-      end
-
-      def should_generate_new_slug_for_locales
-        return unless simple_slug_options[:locales]
-        simple_slug_options[:locales].find_all {|locale| simple_slug_get(locale).blank?}
+        simple_slug_adapter.column_names.any?{|cn| send(cn).blank? }
       end
 
       def simple_slug_generate(force=false)
-        locales = if simple_slug_options[:locales]
-                    ((!force && should_generate_new_slug_for_locales) || simple_slug_options[:locales])
-                  else
-                    [nil]
-                  end
-        locales.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]
-          simple_slug = "__#{id || rand(9999)}" if simple_slug.blank? && simple_slug_options[:fallback_on_blank]
-          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)
-        parameterize_args = ActiveSupport::VERSION::MAJOR > 4 ? {separator: '-'} : '-'
-        normalized = I18n.transliterate(SimpleSlug.normalize_i18n_fix(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.5'
+  VERSION = '0.4.0'
 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'
@@ -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.3'
+  spec.add_dependency 'activerecord', '>= 4.0.0', '< 6.1'
   spec.add_dependency 'i18n', '~> 0.7'
 
   spec.add_development_dependency 'bundler', '~> 1.5'
   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,220 +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 SlugGenerationRspecModelWithFallbackOnBlank < RspecActiveModelBase
-  simple_slug :name, fallback_on_blank: true
+
+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)
-      allow_any_instance_of(SlugGenerationRspecModelWithFallbackOnBlank). to receive(:simple_slug_exists?).and_return(false)
-    end
-
-    it 'after save' do
-      expect(SlugGenerationRspecModel.create(name: 'Hello').slug).to eq 'hello'
-    end
+  before :each do
+    RspecActiveRecordBase.delete_all
+    SimpleSlug::HistorySlug.delete_all
+  end
 
-    it 'skip excludes' do
-      expect(SlugGenerationRspecModel.new(name: 'new')).not_to be_valid
+  describe 'slug' do
+    it 'generate on save' do
+      expect(SlugRspecModel.create(name: 'Hello').slug).to eq 'hello'
     end
 
-    it 'skip integers' do
-      expect(SlugGenerationRspecModel.new(name: '123')).not_to be_valid
+    it 'add prefix for numbers' do
+      expect(SlugRspecModel.create(name: '123').slug).to eq '_123'
     end
 
-    it 'skip spaces' do
-      expect(SlugGenerationRspecModel.new(slug: 'test test')).not_to be_valid
+    it 'reject excludes' do
+      expect(SlugRspecModel.new(name: 'new')).not_to be_valid
     end
 
-    it 'skip punctuation' do
-      expect(SlugGenerationRspecModel.new(slug: 'test.test')).not_to be_valid
+    it 'reject spaces' do
+      expect(SlugRspecModel.new(slug: 'test test')).not_to be_valid
     end
 
-    it 'es chars' do
-      I18n.with_locale(:es) do
-        expect(SlugGenerationRspecModel.create(name: 'áǼßHello').slug).to eq 'aaeshello'
-      end
+    it 'reject punctuation' do
+      expect(SlugRspecModel.new(slug: 'test.test')).not_to be_valid
     end
 
-    it 'fallback on blank' do
-      SlugGenerationRspecModelWithFallbackOnBlank.create({})
-      expect(SlugGenerationRspecModelWithFallbackOnBlank.create({}).slug).to start_with '__'
+    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 generated slugs' do
-        record = SlugGenerationRspecModelLocalized.create(name: 'Hello', name_en: 'Hello en')
-        record.name = 'bye'
-        record.slug_en = nil
-        record.name_en = 'Bye en'
-        expect{ record.save }.not_to change{ record.slug }
+      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 for locales with blank slug' do
-        record = SlugGenerationRspecModelLocalized.create(name: 'Hello', name_en: 'Hello en')
+      it 'generate slug when blank' do
+        record = SlugLocalizedRspecModel.create(name: 'Hello')
         record.name = 'bye'
         record.slug_en = nil
-        record.name_en = 'Bye en'
         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.5
+  version: 0.4.0
 platform: ruby
 authors:
 - Alex Leschenko
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-04 00:00:00.000000000 Z
+date: 2020-01-03 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.3'
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,7 +29,7 @@ dependencies:
         version: 4.0.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5.3'
+        version: '6.1'
 - !ruby/object:Gem::Dependency
   name: i18n
   requirement: !ruby/object:Gem::Requirement
@@ -86,6 +86,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !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
@@ -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
@@ -129,8 +144,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: Friendly url generator with history.