schnecke 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2e509bff01283a06b873a93ce83938d8b1330534f661d5fe13dc8235f764da7
-  data.tar.gz: d2fb750754fa8959baca1ff1236a9ecb83b9e908ca749d3fa25b94b8cc2dab17
+  metadata.gz: bdf704d77a580357657db281c7fd5021045fcd5c2b7cca9f32f6f468cf33d895
+  data.tar.gz: 995fc538958ecf0ae7b1ce67cb81498e4223b3538782cc036a9763eefa1c0e4f
 SHA512:
-  metadata.gz: 9f8280a41d8289520a8a2f99a2fed9c0713c075805d134b16e66b02dbb53121d070f2acf3d7458744d1bf4517eaf5c2eacaf8d880ba73ad0167e3334ef82d2d3
-  data.tar.gz: 8f526df3095aa6e092eb95aee7c52258824ce4dccd8c312ff20660a14cfe1d60251f528b80a0b3ce8c22238f4f96222a525605cf81f899b69338fd50abe87f4b
+  metadata.gz: fd373216be05945333cc1ddd6850892151549db1e887cc64ce462ae4f98ee4e86b698e34d591b71f6fd667f5cb65ae8a3634a175a9186f88ee3c97035fcc06af
+  data.tar.gz: d62fc13e0f3151f338314d79e7664267812b2de7f5a70ef6e1ba5fbb24ae550a569bf7266858906ee8f7502387aa76bf7687b9f8cf3c73a6a65a0a584213604f

data/.rubocop.yml

@@ -44,6 +44,8 @@ Metrics/MethodLength:
 
 Metrics/ModuleLength:
   Max: 100
+  Exclude:
+    - 'lib/schnecke/schnecke.rb'
 
 Minitest/MultipleAssertions:
   Max: 10

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    schnecke (0.1.0)
+    schnecke (0.3.0)
       activerecord (> 4.2.0)
       activesupport (> 4.2.0)
 

data/README.md

@@ -22,10 +22,10 @@ Or install it yourself as:
 
 ## Usage
 
-Given a class `A` which has the attribute `name` and has a `slug` column defined, we can do the following:
+Given a class `SomeObject` which has the attribute `name` and has a `slug` column defined, we can do the following:
 
 ```ruby
-class A
+class SomeObject
   include Schnecke
   slug :name
 end
@@ -34,18 +34,37 @@ end
 This will take the value in `name` and automatically set the slug based on it. If the slug needs to be based on multiple attributes of a model, simply pass in the array of attributes as follows:
 
 ```ruby
-class A
+class SomeObject
   include Schnecke
   slug [:first_name, :last_name]
 end
 ```
 
+Under the hood, this library adds a `before_validate` callback that automatically runs a method called `assign_slug`. You are welcome to call this method explicity if you so desire.
+
+```ruby
+obj = SomeObject.new(name: 'Hello World!')
+obj.assign_slug
+```
+
+It is important to note that if the attribute used to hold the slug (`slug` by default, see next section) already contains a value, the slug assignment **WILL NOT HAPPEN**. This means, if you manually assign the slug by explicitly setting the slug value yourself, it will not be modified. If you would like the slug to be overwrriten you can explicitly call the `reassign_slug` method.
+
+```ruby
+obj = SomeObject.new(name: 'Hello World!', slug: 'hi')
+
+# This will do nothing as the slug was already set
+obj.assign_slug
+
+# This will cause the slug to be assigned
+obj.reassign_slug
+```
+
 ### Slug column
 
 By default it is assumed that the generated slug will be assigned to the `slug` attribute of the model. If one needs to place the slug in a different columm, this can be done by defining the `column` attribute:
 
 ```ruby
-class A
+class SomeObject
   include Schnecke
   slug :name, column: :some_other_column
 end
@@ -53,36 +72,57 @@ end
 
 The above will place the generated slug in `some_other_column`.
 
+### Setting the maximum length of a slug
+
+By default the maxium length of a slug is 32 characters *NOT INCLUDING* any potential sequence numbers added to make it unique (see the "Handling non-unique slugs" section). You can either change the maximum or remove it entirely as follows
+
+
+```ruby
+class SomeObject
+  include Schnecke
+  slug :name, limit_length: 15
+end
+```
+
+```ruby
+class SomeObject
+  include Schnecke
+  slug :name, limit_length: false
+end
+```
+
 ### Slug Uniquness
 
-By default slugs are unique to the object that defines the slug. For example if we have the 2 objects, `A` and `B` as defined as below, then the slugs will be unique for all slugs for all type `A` objcets and all type `B` objects. 
+By default slugs are unique to the object that defines the slug. For example if we have the 2 objects, `SomeObject` and `SomeOtherObject` as defined as below, then the slugs will be unique for all slugs for all type `SomeObject` objcets and all type `SomeOtherObject` objects. 
 
 ```ruby
-class A
+class SomeObject
   include Schnecke
   slug :name
 end
 
-class B
+class SomeOtherObject
   include Schnecke
   slug :name
 end
 ```
 
-This means that the slug `foo` can exists 2 times; once for any object of type `A` and once for any object of type `B`. Currently there is no way to create globally unique slugs. If this is something that is required, then something like [`friendly_id`](https://github.com/norman/friendly_id) might be more appropriate for your use case.
+This means that the slug `foo` can exists 2 times; once for any object of type `SomeObject` and once for any object of type `SomeOtherObject`. Currently there is no way to create globally unique slugs. If this is something that is required, then something like [`friendly_id`](https://github.com/norman/friendly_id) might be more appropriate for your use case.
 
 ### Handling non-unique slugs
 
 If a duplicate slug is to be created, a number is automatically appended to the end of the slug. For example, if there is a slug `foo`, the second one would become `foo-2`, the third `foo-3`, and so forth.
 
+It is important to note that the maximum length of a slug does not include the addition of the sequence identifier at the end. By default the maximum length of a slug is 32 characters, but if a sequence number is added, it will be 34 characters when we append the `-2`, `-3`, etc. This was done on purpose so that the base slug always remains constant and does not get truncated.
+
 ### Defining a custom uniqueness scope
 
-There are times when we want slugs not be unique for all objects of type `A`, but rather for a smaller scope. For example, let's say we have a system with multiple `Accounts`, each containing `Record`s. If we want the slug for the `Record` to be unique only within the scope of an `account` we can do by providing the uniqueness scope when setting up the slug.
+There are times when we want slugs not be unique for all objects of type `SomeObject`, but rather for a smaller scope. For example, let's say we have a system with multiple `Accounts`, each containing `Record`s. If we want the slug for the `Record` to be unique only within the scope of an `account` we can do by providing the uniqueness scope when setting up the slug.
 
 ```ruby
 class Record
   include Schnecke
-  slug :name, uniqueness: { scope: :account}
+  slug :name, uniqueness: { scope: :account }
 
   belongs_to :account
 end
@@ -93,19 +133,40 @@ When we do this, this will let us have the same slug 'foo' for multiple `record`
 ```ruby
 class Tag
   include Schnecke
-  slug :name, uniqueness: { scope: [:account, :record]}
+  slug :name, uniqueness: { scope: [:account, :record] }
 
   belongs_to :account
   belongs_to :record
 end
 ```
 
+### Callbacks
+
+Two callbacks, `before_assign_slug` and `after_assign_slug`, are provided so that you can run arbitrary code before and after the slug assignment process. Both of these callbacks will always run regardless of whether or not a slug is to be assigned. The only time `after_assign_slug` is not run is if there is an exception raised during the assignment process.
+
+Note, since `reassign_slug` is just a forced assignment of a slug, both callbacks will run as well.
+
+```ruby
+class SomeObject
+  include Schnecke
+  slug :name
+
+  def before_assign_slug(opts={})
+    puts 'Hello world! I get run before the slug assignment process'
+  end
+
+  def after_assign_slug(opts={})
+    puts 'Goodbye world! I get run after the slug assignment process'
+  end
+end
+```
+
 ### Advanced Usage
 
 If you need to change how the slug is generated, how duplicates are handled, etc., you can overwrite the methods in your class. For example to change how slugs are generated you can overwrite the `slugify` method.
 
 ```ruby
-class A
+class SomeObject
   include Schnecke
   slug :name
 
@@ -119,7 +180,7 @@ end
 Note, by default the library will validate to ensure that the slug only contains lowercase alpphanumeric letters and '-' or '_'. If your new method changes the alloweable set of characters you can either disable this validation, or pass in your own validation pattern.
 
 ```ruby
-class A
+class SomeObject
   include Schnecke
   slug :name, require_format: false
 
@@ -128,7 +189,7 @@ class A
   end
 end
 
-class B
+class SomeOtherObject
   include Schnecke
   slug :name, require_format: /\A[a-z]+\z/
 

data/lib/schnecke/schnecke.rb

@@ -10,9 +10,11 @@ module Schnecke
 
   DEFAULT_SLUG_COLUMN = :slug
   DEFAULT_SLUG_SEPARATOR = '-'
+  DEFAULT_MAX_LENGTH = 32
   DEFAULT_REQUIRED_FORMAT = /\A[a-z0-9\-_]+\z/
 
   class_methods do
+    # rubocop:disable Metrics/AbcSize
     def slug(source, opts = {})
       class_attribute :schnecke_config
 
@@ -21,6 +23,7 @@ module Schnecke
         slug_source: source,
         slug_column: opts.fetch(:column, DEFAULT_SLUG_COLUMN),
         slug_separator: opts.fetch(:separator, DEFAULT_SLUG_SEPARATOR),
+        limit_length: opts.fetch(:limit_length, DEFAULT_MAX_LENGTH),
         required: opts.fetch(:required, true),
         generate_on_blank: opts.fetch(:generate_on_blank, true),
         require_format: opts.fetch(:require_format, DEFAULT_REQUIRED_FORMAT),
@@ -50,6 +53,7 @@ module Schnecke
       include InstanceMethods
     end
   end
+  # rubocop:enable Metrics/AbcSize
 
   # Instance methods to include
   module InstanceMethods
@@ -60,7 +64,47 @@ module Schnecke
     # Note, a slug will not be assigned if one already exists. If one needs to
     # force the assignment of a slug, pass `force: true`
     def assign_slug(opts = {})
-      validate_source
+      before_assign_slug(opts)
+      perform_slug_assign(opts)
+      after_assign_slug(opts)
+    end
+
+    # Reassign the slug
+    #
+    # Unlike assign_slug, this will cause a slug to be created even if one
+    # already exists.
+    def reassign_slug(opts = {})
+      opts[:force] = true
+      assign_slug(opts)
+    end
+
+    # Callback that is handled before the slug assignment process.
+    #
+    # When this is called, no validations, or decisions about whether or not
+    # a slug should be created have been made. As such, this will always run
+    # regardless of whether or not the slug assignment process proceeds or not.
+    def before_assign_slug(opts = {})
+      # Left blank, but can be implemented by user
+    end
+
+    # Callback that is handled after the slug is assigned
+    #
+    # Unless an error is raised during the slug assignment process, this method
+    # will always be called regardless of whether or not the slug was assigned
+    def after_assign_slug(opts = {})
+      # Left blank, but can be implemented by user
+    end
+
+    protected
+
+    # Assign the slug
+    #
+    # This is automatically called before model validation.
+    #
+    # Note, a slug will not be assigned if one already exists. If one needs to
+    # force the assignment of a slug, pass `force: true`
+    def perform_slug_assign(opts = {})
+      validate_slug_source
       validate_slug_column
 
       return if !should_create_slug? && !opts[:force]
@@ -74,6 +118,9 @@ module Schnecke
         candidate_slug = slugify_blank
       end
 
+      # Make sure it is not too long
+      candidate_slug = truncate_slug(candidate_slug)
+
       # If there is a duplicate, create a unique one
       if slug_exists?(candidate_slug)
         candidate_slug = slugify_duplicate(candidate_slug)
@@ -82,16 +129,6 @@ module Schnecke
       self[schnecke_config[:slug_column]] = candidate_slug
     end
 
-    # Reassign the slug
-    #
-    # Unlike assign_slug, this will cause a slug to be created even if one
-    # already exists.
-    def reassign_slug
-      assign_slug(force: true)
-    end
-
-    protected
-
     # Slugify a string
     #
     # This will take a string and convert it to a slug by removing punctuation
@@ -99,9 +136,9 @@ module Schnecke
     #
     # This can be overriden if a different slug generation method is needed
     def slugify(str)
-      return if str.blank?
+      return str if str.blank?
 
-      str.gsub!(/[\p{Pc}\p{Ps}\p{Pe}\p{Pi}\p{Pf}\p{Po}]/, '')
+      str = str.gsub(/[\p{Pc}\p{Ps}\p{Pe}\p{Pi}\p{Pf}\p{Po}]/, '')
       str.parameterize
     end
 
@@ -124,7 +161,7 @@ module Schnecke
     #
     # This can be overriden if a different behavior is desired
     def slugify_duplicate(slug)
-      return if slug.blank?
+      return slug if slug.blank?
 
       seq = 2
       new_slug = slug_concat([slug, seq])
@@ -149,7 +186,7 @@ module Schnecke
 
     private
 
-    def validate_source
+    def validate_slug_source
       source = arrayify(schnecke_config[:slug_source])
       source.each do |attr|
         unless respond_to?(attr)
@@ -178,6 +215,13 @@ module Schnecke
       parts.join(schnecke_config[:slug_separator])
     end
 
+    def truncate_slug(slug)
+      return slug if slug.blank?
+      return slug if schnecke_config[:limit_length].blank?
+
+      slug[0, schnecke_config[:limit_length]]
+    end
+
     def slug_exists?(slug)
       slug_scope.exists?(schnecke_config[:slug_column] => slug)
     end

data/lib/schnecke/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Schnecke
-  VERSION = '0.1.0'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: schnecke
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Patrick R. Schmid
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-10-01 00:00:00.000000000 Z
+date: 2022-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler