slug 0.5.7 → 4.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 65d6b738a1e306b5803f1b92e8328ed20632eb0d7706eb2417a198bd1acf8bfc
+  data.tar.gz: b1833f858513babd75d2f94ef776831fab3cc2e105ed9df33bf2912c9d7feb5c
+SHA512:
+  metadata.gz: 9b46a5b3226a1b4adbdf027fe9c7692d2a33431a5aa0b67ef99edd6297974008789407eee80cd614b8d65a5bfdcbadd6c2112c554e7d79e7198571ccee967a52
+  data.tar.gz: d9e07b0b4b55810ab4eaff7f828755bf0bdf0d5e6744cc8ba866e50e96642db707ee459d0c8b31288ef9978cf82677a386163a646e7eff570662587395996b02

data/README.md

@@ -0,0 +1,127 @@
+# slug
+
+Slug provides simple, straightforward slugging for your ActiveRecord models.
+
+Slug is based on code from Norman Clarke's fantastic [friendly_id](https://github.com/norman/friendly_id) project and Nick Zadrozny's [friendly_identifier](http://code.google.com/p/friendly-identifier/).
+
+What's different:
+
+  * Unlike friendly_id's more advanced modes, slugs are stored directly in your model's table.  friendly_id stores its data in a separate sluggable table, which enables cool things like slug versioning—but forces yet another join when trying to do complex find_by_slugs.
+  * Like friendly_id, diacritics (accented characters) are stripped from slug strings.
+  * The number of options is manageable.
+
+## Installation
+
+Add the gem to your Gemfile
+
+```
+gem 'slug'
+```
+
+of your rails project.
+
+This is tested with Rails 5.1.4, MRI Ruby 2.4.1
+
+## Usage
+
+### Creating the database column
+
+It's up to you to set up the appropriate column in your model.  By default, slug saves the slug to a column called 'slug', so in most cases you'll just want to add
+
+```ruby
+add_column :my_table, :slug, :string
+```
+
+in a migration.  You should also add a unque index on the slug field in your migration
+
+```ruby
+add_index :model_name, :slug, unique: true
+```
+
+Though Slug uses `validates_uniqueness_of` to ensue the uniqueness of your slug, two concurrent INSERTs could try to set the same slug.
+
+### Model setup
+
+Once your table is migrated, just add
+
+```ruby
+slug :source_field
+```
+
+to your ActiveRecord model.  `:source_field` is the column you'd like to base the slug on.  For example, it might be `:headline`.
+
+#### Using an instance method as the source column
+
+The source column isn't limited to just database attributes—you can specify any instance method.  This is handy if you need special formatting on your source column before it's slugged, or if you want to base the slug on several attributes.
+
+For example:
+
+```ruby
+class Article < ActiveRecord::Base
+  slug :title_for_slug
+
+  def title_for_slug
+    "#{headline}-#{publication_date.year}-#{publication_date.month}"
+  end
+end
+```
+
+would use `headline-pub year-pub month` as the slug source.
+
+From here, you can work with your slug as if it were a normal column.  `find_by_slug` and named scopes will work as they do for any other column.
+
+### Options
+
+There are two options:
+
+#### Column
+
+If you want to save the slug in a database column that isn't called
+`slug`, just pass the `:column` option. For example:
+
+```
+slug :headline, column: :web_slug
+```
+
+would generate a slug based on `headline` and save it to `web_slug`.
+
+#### Generic Default
+
+If the source column is empty, blank, or only contains filtered
+characters, you can avoid `ActiveRecord::ValidationError` exceptions
+by setting `generic_default: true`. For example:
+
+```ruby
+slug :headline, generic_default: true
+```
+
+will generate a slug based on your model name if the headline is blank.
+
+This is useful if the source column (e.g. headline) is based on user-generated
+input or can be blank (nil or empty).
+
+Some prefer to get the exception in this case. Others want to get a good
+slug and move on.
+
+## Notes
+
+  * Slug validates presence and uniqueness of the slug column.  If you pass something that isn't sluggable as the source (for example, say you set the headline to '---'), a validation error will be set. To avoid this, use the `:generic_default` option.
+  * Slug doesn't update the slug if the source column changes.  If you really need to regenerate the slug, call `@model.set_slug` before save.
+  * If a slug already exists, Slug will automatically append a '-n' suffix to your slug to make it unique.  The second instance of a slug is '-1'.
+  * If you don't like the slug formatting or the accented character stripping doesn't work for you, it's easy to override Slug's formatting functions. Check the source for details.
+
+## Development
+
+`rake test` will run the included unit tests.
+
+## Authors
+
+Ben Koski, ben.koski@gmail.com
+
+With generous contributions from:
+ * [Derek Willis](http://thescoop.org/)
+ * [Douglas Lovell](https://github.com/wbreeze)
+ * [Paul Battley](https://github.com/threedaymonk)
+ * [Yura Omelchuk](https://github.com/jurgens)
+ * others listed in the
+[GitHub contributor list](https://github.com/bkoski/slug/graphs/contributors).

data/Rakefile

@@ -1,23 +1,6 @@
 require 'rake'
 
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |s|
-    s.name = "slug"
-    s.summary = %Q{Simple, straightforward slugs for your ActiveRecord models.}
-    s.email = "ben.koski@gmail.com"
-    s.homepage = "http://github.com/bkoski/slug"
-    s.description = "Simple, straightforward slugs for your ActiveRecord models."
-    s.add_dependency 'activerecord'
-    s.add_dependency 'activesupport'
-    s.authors = ["Ben Koski"]
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
-end
-
-require 'rake/rdoctask'
+require 'rdoc/task'
 Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_dir = 'rdoc'
   rdoc.title = 'slug'
@@ -33,15 +16,4 @@ Rake::TestTask.new(:test) do |t|
   t.verbose = false
 end
 
-begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |t|
-    t.libs << 'test'
-    t.test_files = FileList['test/**/*_test.rb']
-    t.verbose = true
-  end
-rescue LoadError
-  puts "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
-end
-
 task :default => :test

data/lib/slug/slug.rb

@@ -1,6 +1,10 @@
+require 'active_support/concern'
+
 module Slug
-  module ClassMethods
-    
+  extend ActiveSupport::Concern
+
+  class_methods do
+
     # Call this to set up slug handling on an ActiveRecord model.
     #
     # Params:
@@ -8,61 +12,62 @@ module Slug
     #
     # Options:
     # * <tt>:column</tt> - the column the slug will be saved to (defaults to <tt>:slug</tt>)
-    # * <tt>:validates_uniquness_if</tt> - proc to determine whether uniqueness validation runs, same format as validates_uniquness_of :if
+    # * <tt>:validate_uniquness_if</tt> - proc to determine whether uniqueness validation runs, same format as validates_uniquness_of :if
     #
     # Slug will take care of validating presence and uniqueness of slug.
-    
+
     # Before create, Slug will generate and assign the slug if it wasn't explicitly set.
     # Note that subsequent changes to the source column will have no effect on the slug.
     # If you'd like to update the slug later on, call <tt>@model.set_slug</tt>
     def slug source, opts={}
-      class_inheritable_accessor :slug_source, :slug_column
-      include InstanceMethods
-      
+      class_attribute :slug_source, :slug_column, :generic_default
+
       self.slug_source = source
-      
-      self.slug_column = opts.has_key?(:column) ? opts[:column] : :slug
+      self.slug_column = opts.fetch(:column, :slug)
+      self.generic_default = opts.fetch(:generic_default, false)
 
       uniqueness_opts = {}
-      uniqueness_opts.merge!(:if => opts[:validates_uniqueness_if]) if opts[:validates_uniqueness_if].present?
-      
-      validates_presence_of     self.slug_column, :message => "cannot be blank. Is #{self.slug_source} sluggable?"
-      validates_uniqueness_of   self.slug_column, uniqueness_opts
-      validates_format_of       self.slug_column, :with => /^[a-z0-9-]+$/, :message => "contains invalid characters. Only downcase letters, numbers, and '-' are allowed."
-      before_validation_on_create :set_slug 
+      uniqueness_opts.merge!(:if => opts[:validate_uniqueness_if]) if opts[:validate_uniqueness_if].present?
+      validates_uniqueness_of self.slug_column, uniqueness_opts
+
+      validates_presence_of self.slug_column,
+        message: "cannot be blank. Is #{self.slug_source} sluggable?"
+      validates_format_of self.slug_column,
+        with: /\A[a-z0-9-]+\z/,
+        message: "contains invalid characters. Only downcase letters, numbers, and '-' are allowed."
+      before_validation :set_slug, :on => :create
+
+      include SlugInstanceMethods
     end
   end
-  
-  module InstanceMethods
-  
+
+  module SlugInstanceMethods
     # Sets the slug. Called before create.
     # By default, set_slug won't change slug if one already exists.  Pass :force => true to overwrite.
     def set_slug(opts={})
-      validate_slug_columns      
-      return unless self[self.slug_column].blank? || opts[:force] == true
+      validate_slug_columns
+      return if self[self.slug_column].present? && !opts[:force]
 
-      original_slug = self[self.slug_column]
-      self[self.slug_column] = self.send(self.slug_source)
+      self[self.slug_column] = normalize_slug(self.send(self.slug_source))
 
-      strip_diacritics_from_slug
-      normalize_slug
-      assign_slug_sequence unless self[self.slug_column] == original_slug # don't try to increment seq if slug hasn't changed
+      # if normalize_slug returned a blank string, try the generic_default handling
+      if generic_default && self[self.slug_column].blank?
+        self[self.slug_column] = self.class.to_s.demodulize.underscore.dasherize
+      end
+
+      assign_slug_sequence if self.changed_attributes.include?(self.slug_column)
     end
-  
+
     # Overwrite existing slug based on current contents of source column.
     def reset_slug
       set_slug(:force => true)
     end
-  
+
     # Overrides to_param to return the model's slug.
     def to_param
       self[self.slug_column]
     end
-  
-    def self.included(klass)
-      klass.extend(ClassMethods)
-    end
-  
+
     private
     # Validates that source and destination methods exist. Invoked at runtime to allow definition
     # of source/slug methods after <tt>slug</tt> setup in class.
@@ -70,58 +75,27 @@ module Slug
       raise ArgumentError, "Source column '#{self.slug_source}' does not exist!" if !self.respond_to?(self.slug_source)
       raise ArgumentError, "Slug column '#{self.slug_column}' does not exist!"   if !self.respond_to?("#{self.slug_column}=")
     end
-    
+
     # Takes the slug, downcases it and replaces non-word characters with a -.
     # Feel free to override this method if you'd like different slug formatting.
-    def normalize_slug
-      return if self[self.slug_column].blank?
-      s = ActiveSupport::Multibyte.proxy_class.new(self[self.slug_column]).normalize(:kc)
-      s.downcase!
-      s.strip!
-      s.gsub!(/[^a-z0-9\s-]/, '') # Remove non-word characters
-      s.gsub!(/\s+/, '-')     # Convert whitespaces to dashes
-      s.gsub!(/-\z/, '')      # Remove trailing dashes
-      s.gsub!(/-+/, '-')      # get rid of double-dashes
-      self[self.slug_column] = s.to_s
+    def normalize_slug(str)
+      return if str.blank?
+      str.gsub!(/[\p{Pc}\p{Ps}\p{Pe}\p{Pi}\p{Pf}\p{Po}]/, '') # Remove punctuation
+      str.parameterize
     end
-  
-    # Converts accented characters to their ASCII equivalents and removes them if they have no equivalent.
-    # Override this with a void function if you don't want accented characters to be stripped.
-    def strip_diacritics_from_slug
-      return if self[self.slug_column].blank?
-      s = ActiveSupport::Multibyte.proxy_class.new(self[self.slug_column])
-      s = s.normalize(:kd).unpack('U*')
-      s = s.inject([]) do |a,u|
-        if Slug::ASCII_APPROXIMATIONS[u]
-          a += Slug::ASCII_APPROXIMATIONS[u].unpack('U*')
-        elsif (u < 0x300 || u > 0x036F)
-          a << u
-        end
-        a
-      end
-      s = s.pack('U*')
-      self[self.slug_column] = s.to_s
-    end
-  
+
     # If a slug of the same name already exists, this will append '-n' to the end of the slug to
     # make it unique. The second instance gets a '-1' suffix.
     def assign_slug_sequence
       return if self[self.slug_column].blank?
-      idx = next_slug_sequence
-      self[self.slug_column] = "#{self[self.slug_column]}-#{idx}" if idx > 0
-    end
-  
-    # Returns the next unique index for a slug.
-    def next_slug_sequence
-      last_in_sequence = self.class.find(:first, :conditions => ["#{self.slug_column} LIKE ?", self[self.slug_column] + '%'],
-                                           :order => "CAST(REPLACE(#{self.slug_column},'#{self[self.slug_column]}','') AS UNSIGNED)")
-      if last_in_sequence.nil?
-        return 0
-      else
-        sequence_match = last_in_sequence[self.slug_column].match(/^#{self[self.slug_column]}(-(\d+))?/)
-        current = sequence_match.nil? ? 0 : sequence_match[2].to_i
-        return current + 1
+      assoc = self.class.base_class
+      base_slug = self[self.slug_column]
+      seq = 0
+
+      while assoc.where(self.slug_column => self[self.slug_column]).exists? do
+        seq += 1
+        self[self.slug_column] = "#{base_slug}-#{seq}"
       end
     end
   end
-end
+end

data/lib/slug.rb

@@ -1,6 +1,6 @@
 require File.join(File.dirname(__FILE__), 'slug', 'slug')
-require File.join(File.dirname(__FILE__), 'slug', 'ascii_approximations')
 
-if defined?(ActiveRecord)
-  ActiveRecord::Base.instance_eval { extend Slug::ClassMethods }
-end
+ActiveRecord::Base.instance_eval { include Slug }
+if defined?(Rails) && Rails.version.to_i < 4
+  raise "This version of slug requires Rails 4 or higher"
+end

data/slug.gemspec

@@ -1,61 +1,58 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE
-# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
 # -*- encoding: utf-8 -*-
+# stub: slug 4.0.0 ruby lib
 
 Gem::Specification.new do |s|
-  s.name = %q{slug}
-  s.version = "0.5.7"
+  s.name = "slug"
+  s.version = "4.1.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
   s.authors = ["Ben Koski"]
-  s.date = %q{2010-06-25}
-  s.description = %q{Simple, straightforward slugs for your ActiveRecord models.}
-  s.email = %q{ben.koski@gmail.com}
+  s.date = "2018-11-17"
+  s.description = "Simple, straightforward slugs for your ActiveRecord models."
+  s.email = "ben.koski@gmail.com"
   s.extra_rdoc_files = [
     "LICENSE",
-     "README.rdoc"
+    "README.md"
   ]
   s.files = [
-    ".gitignore",
-     "LICENSE",
-     "README.rdoc",
-     "Rakefile",
-     "VERSION.yml",
-     "lib/slug.rb",
-     "lib/slug/ascii_approximations.rb",
-     "lib/slug/slug.rb",
-     "slug.gemspec",
-     "test/models.rb",
-     "test/schema.rb",
-     "test/test_helper.rb",
-     "test/test_slug.rb"
-  ]
-  s.homepage = %q{http://github.com/bkoski/slug}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.5}
-  s.summary = %q{Simple, straightforward slugs for your ActiveRecord models.}
-  s.test_files = [
+    "LICENSE",
+    "README.md",
+    "Rakefile",
+    "lib/slug.rb",
+    "lib/slug/slug.rb",
+    "slug.gemspec",
     "test/models.rb",
-     "test/schema.rb",
-     "test/test_helper.rb",
-     "test/test_slug.rb"
+    "test/schema.rb",
+    "test/test_helper.rb",
+    "test/slug_test.rb"
   ]
+  s.homepage = "http://github.com/bkoski/slug"
+  s.rubygems_version = "2.2.0"
+  s.summary = "Simple, straightforward slugs for your ActiveRecord models."
 
   if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
+    s.specification_version = 4
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<activerecord>, [">= 0"])
-      s.add_runtime_dependency(%q<activesupport>, [">= 0"])
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rake>, [">= 0"])
+      s.add_development_dependency(%q<minitest>, [">= 0"])
+      s.add_development_dependency(%q<sqlite3>, [">= 0"])
+      s.add_runtime_dependency(%q<activerecord>, ["> 3.0.0"])
+      s.add_runtime_dependency(%q<activesupport>, ["> 3.0.0"])
     else
-      s.add_dependency(%q<activerecord>, [">= 0"])
-      s.add_dependency(%q<activesupport>, [">= 0"])
+      s.add_dependency(%q<rake>, [">= 0"])
+      s.add_dependency(%q<minitest>, [">= 0"])
+      s.add_dependency(%q<sqlite3>, [">= 0"])
+      s.add_dependency(%q<activerecord>, ["> 3.0.0"])
+      s.add_dependency(%q<activesupport>, ["> 3.0.0"])
     end
   else
-    s.add_dependency(%q<activerecord>, [">= 0"])
-    s.add_dependency(%q<activesupport>, [">= 0"])
+    s.add_dependency(%q<rake>, [">= 0"])
+    s.add_dependency(%q<minitest>, [">= 0"])
+    s.add_dependency(%q<sqlite3>, [">= 0"])
+    s.add_dependency(%q<activerecord>, ["> 3.0.0"])
+    s.add_dependency(%q<activesupport>, ["> 3.0.0"])
   end
 end
+

data/test/models.rb

@@ -1,6 +1,9 @@
 # Used to test slug behavior in general
 class Article < ActiveRecord::Base
-  slug :headline  
+  slug :headline
+end
+
+class Storyline < Article
 end
 
 # Used to test alternate slug column
@@ -14,14 +17,23 @@ class Company < ActiveRecord::Base
 end
 
 class Post < ActiveRecord::Base
-  slug :headline, :validates_uniqueness_if => Proc.new { false } 
+  slug :headline, :validate_uniqueness_if => Proc.new { false } 
 end
 
 # Used to test slugs based on methods rather than database attributes
 class Event < ActiveRecord::Base
   slug :title_for_slug
-  
+
   def title_for_slug
     "#{title}-#{location}"
   end
-end
+end
+
+# Test generation of generic slugs
+class Generation < ActiveRecord::Base
+  slug :title, generic_default: true
+end
+
+# Test model with no slug column
+class Orphan < ActiveRecord::Base
+end

data/test/schema.rb

@@ -1,30 +1,41 @@
 ActiveRecord::Schema.define(:version => 1) do
-
   create_table "articles", :force => true do |t|
-    t.column "headline", "string"
+    t.column "headline", "string", null: false
     t.column "section", "string"
-    t.column "slug", "string"
+    t.column "slug", "string", null: false
+    t.column "type", "string"
+    t.index ["slug"], name: "index_articles_on_slug", unique: true
   end
-  
+
   create_table "people", :force => true do |t|
     t.column "name", "string"
     t.column "web_slug", "string"
   end
-  
+
   create_table "companies", :force => true do |t|
     t.column "name", "string"
     t.column "slug", "string"
   end
-  
+
   create_table "posts", :force => true do |t|
     t.column "headline", "string"
     t.column "slug", "string"
   end
-  
+
   create_table "events", :force => true do |t|
     t.column "title", "string"
     t.column "location", "string"
     t.column "slug", "string"
   end
-  
-end
+
+  create_table "generations", :force => true do |t|
+    t.column "title", "string"
+    t.column "slug", "string", null: false
+  end
+
+  # table with no slug column
+  create_table "orphans", :force => true do |t|
+    t.column "name", "string"
+    t.column "location", "string"
+  end
+end