encoded_id-rails 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0aceb28e50697bb0257054c2731936a7cad5f6617d479543c63999a156c153bf
-  data.tar.gz: 59be3ddf7327f26726df0aa3120f9a70de0ac225d77291ad8e35b10b937e6264
+  metadata.gz: 599b4c236c59881b00eefbe0feaf4fa6f1a04015573ba5d807f041ba2932e602
+  data.tar.gz: ff6ee760d956606accfb98a75be00cf04a545695e0dcce56e9eb271b1d824fee
 SHA512:
-  metadata.gz: 821e8ffcb7f77bdc84160a69bbc504ec891f9b11d925e4aa5d52f1209f426d894671cc603b850ee1a408dfa255c9b00eeaed6938eb1440aec4a31af27209f484
-  data.tar.gz: a168a3da9c882a0e1c9f159cfcfeaeaf02109049aed2f2330b9a51708cee927896a911cae63833ec11955a0139af6aa9a3302a9e970a9f461024d4a870730bf2
+  metadata.gz: 9f176effb4bc926a4aa61dcbb7d0ca0e88b972186438ffe03a96b68d5e78e1eb0b6a485efcad924aff2070097356b8ced016fb1da0253b38f1d9e80eef21e18e
+  data.tar.gz: 2f318e0a04cbd5a45fc3edca02c1a8e053590b70963f4b851f8aac150ea465018aea6f21d3f5951bf4c8f7e31bd650a05a8a46328c2ce0812e8e26d2d4e92099

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 ## [Unreleased]
 
-## [0.1.0] - 2022-10-11
+## [0.6.0] - 2022-12-21
+
+- Rename mixin to `Model`
+- Introduce optional mixins for overriding `#to_param`
+
+## [0.5.0] - 2022-12-21
+
+- `name_for_encoded_id_slug` no longer uses the return value from name but rather just uses the `class` `name`.
+- If you want to change the name used in the slug, override `name_for_encoded_id_slug`
+
+## [0.4.0] - 2022-12-18
+
+- Refactor internals, remove any methods not actually related to creating `encoded_id`, (eg `slugged_id` was removed).
+
+## [0.3.1] - 2022-12-15
+
+- Fix default config
+
+## [0.3.0] - 2022-12-15
+
+- Updates gem `encoded_id` dependency and fixes configuration
+
+## [0.2.0] - 2022-12-14
+
+- No notes...
+
+## [0.1.0] - 2022-11-17
 
 - Initial release

data/README.md

@@ -6,16 +6,16 @@ EncodedID lets you turn numeric or hex IDs into reversible and human friendly ob
 
 ```ruby
 class User < ApplicationRecord
-  include EncodedId::WithEncodedId
-  
+  include EncodedId::Model
+
   def name_for_encoded_id_slug
-    full_name.parameterize
+    full_name
   end
 end
 
-user = User.find_by_encoded_id("p5w9-z27j")  # => #<User id: 78>
-user.encoded_id  # => "p5w9-z27j"
-user.slugged_encoded_id  # => "bob-smith--p5w9-z27j"
+user = User.find_by_encoded_id("p5w9-z27j") # => #<User id: 78>
+user.encoded_id                             # => "p5w9-z27j"
+user.slugged_encoded_id                     # => "bob-smith--p5w9-z27j"
 ```
 
 # Features
@@ -85,21 +85,45 @@ You can configure:
 
 ### ActiveRecord model setup
 
-Include `EncodedId::WithEncodedId` in your model and optionally specify a encoded id salt (or not if using a global one):
+Include `EncodedId::Model` in your model and optionally specify a encoded id salt (or not if using a global one):
 
 ```ruby
 class User < ApplicationRecord
-  include EncodedId::WithEncodedId
-  
+  include EncodedId::Model
+
   # and optionally the model's salt
   def encoded_id_salt
     "my-user-model-salt"
   end
-  
+
   # ...
 end
 ```
 
+### Optional mixins
+
+You can optionally include one of the following mixins to add default overrides to `#to_param`.
+
+- `EncodedId::PathParam`
+- `EncodedId::SluggedPathParam`
+
+This is so that an instance of the model can be used in path helpers and 
+return the encoded ID string instead of the record ID by default.
+
+```ruby
+class User < ApplicationRecord
+  include EncodedId::Model
+  include EncodedId::SluggedPathParam
+
+  def name_for_encoded_id_slug
+    full_name
+  end
+end
+
+user = User.create(full_name: "Bob Smith")
+Rails.application.routes.url_helpers.user_path(user) # => "/users/bob-smith--p5w9-z27j"
+```
+
 ## Documentation
 
 ### `.find_by_encoded_id`
@@ -164,12 +188,13 @@ Otherwise override this method to return a salt specific to the model.
 
 ```ruby
 class User < ApplicationRecord
-  include EncodedId::WithEncodedId
-  
+  include EncodedId::Model
+
   def encoded_id_salt
     "my-user-model-salt"
   end
 end
+
 User.encoded_id_salt  # => "my-user-model-salt"
 ```
 
@@ -201,8 +226,8 @@ By default it calls `#name` on the instance, or if the instance does not respond
 
 ```ruby
 class User < ApplicationRecord
-  include EncodedId::WithEncodedId
-  
+  include EncodedId::Model
+
   # If User has an attribute `name`, that will be used for the slug, 
   # otherwise `user` will be used as determined by the class name.
 end
@@ -217,8 +242,8 @@ You can optionally override this method to define your own slug:
 
 ```ruby
 class User < ApplicationRecord
-  include EncodedId::WithEncodedId
-  
+  include EncodedId::Model
+
   def name_for_encoded_id_slug
     superhero_name
   end
@@ -232,11 +257,11 @@ user.slugged_encoded_id  # => "super-dev--37nw-8nh7"
 
 Simply add the mixin to your `ApplicationRecord`:
 
-```ruby 
+```ruby
 class ApplicationRecord < ActiveRecord::Base
   self.abstract_class = true
-  include EncodedId::WithEncodedId
-  
+  include EncodedId::Model
+
   ...
 end
 ```

data/Steepfile

@@ -1,5 +1,5 @@
 target :lib do
-  check "lib/encoded_id/rails"
+  check "lib/encoded_id"
   signature "sig"
 
   library "encoded_id"

data/lib/encoded_id/rails/encoder_methods.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module EncodedId
+  module Rails
+    module EncoderMethods
+      def encode_encoded_id(ids, options = {})
+        raise StandardError, "You must pass an ID or array of IDs" if ids.blank?
+        encoded_id_coder(options).encode(ids)
+      end
+
+      def decode_encoded_id(slugged_encoded_id, options = {})
+        return if slugged_encoded_id.blank?
+        encoded_id = encoded_id_parser(slugged_encoded_id).id
+        return if !encoded_id || encoded_id.blank?
+        encoded_id_coder(options).decode(encoded_id)
+      end
+
+      # This can be overridden in the model to provide a custom salt
+      def encoded_id_salt
+        # @type self: Class
+        EncodedId::Rails::Salt.new(self, EncodedId::Rails.configuration.salt).generate!
+      end
+
+      def encoded_id_parser(slugged_encoded_id)
+        SluggedIdParser.new(slugged_encoded_id, separator: EncodedId::Rails.configuration.slugged_id_separator)
+      end
+
+      def encoded_id_coder(options = {})
+        config = EncodedId::Rails.configuration
+        EncodedId::Rails::Coder.new(
+          salt: options[:salt] || encoded_id_salt,
+          id_length: options[:id_length] || config.id_length,
+          character_group_size: options[:character_group_size] || config.character_group_size,
+          alphabet: options[:alphabet] || config.alphabet,
+          separator: options[:separator] || config.group_separator
+        )
+      end
+    end
+  end
+end

data/lib/encoded_id/rails/finder_methods.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module EncodedId
+  module Rails
+    module FinderMethods
+      # Find by encoded ID and optionally ensure record ID is the same as constraint (can be slugged)
+      def find_by_encoded_id(slugged_encoded_id, with_id: nil)
+        decoded_id = decode_encoded_id(slugged_encoded_id)
+        return if decoded_id.blank?
+        record = find_by(id: decoded_id)
+        return unless record
+        return if with_id && with_id != record.send(:id)
+        record
+      end
+
+      def find_by_encoded_id!(slugged_encoded_id, with_id: nil)
+        decoded_id = decode_encoded_id(slugged_encoded_id)
+        raise ActiveRecord::RecordNotFound if decoded_id.blank?
+        record = find_by(id: decoded_id)
+        if !record || (with_id && with_id != record.send(:id))
+          raise ActiveRecord::RecordNotFound
+        end
+        record
+      end
+    end
+  end
+end

data/lib/encoded_id/rails/model.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "encoded_id"
+
+module EncodedId
+  module Rails
+    module Model
+      def self.included(base)
+        base.extend(EncoderMethods)
+        base.extend(FinderMethods)
+        base.extend(QueryMethods)
+      end
+
+      def encoded_id
+        @encoded_id ||= self.class.encode_encoded_id(id)
+      end
+
+      def slugged_encoded_id(with: :name_for_encoded_id_slug)
+        @slugged_encoded_id ||= EncodedId::Rails::SluggedId.new(
+          self,
+          slug_method: with,
+          id_method: :encoded_id,
+          separator: EncodedId::Rails.configuration.slugged_id_separator
+        ).slugged_id
+      end
+
+      # By default slug created from class name, but can be overridden
+      def name_for_encoded_id_slug
+        class_name = self.class.name
+        raise StandardError, "Class must have a `name`, cannot create a slug" if !class_name || class_name.blank?
+        class_name.underscore
+      end
+    end
+  end
+end

data/lib/encoded_id/rails/path_param.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "encoded_id"
+
+module EncodedId
+  module Rails
+    module PathParam
+      def to_param
+        encoded_id
+      end
+    end
+  end
+end

data/lib/encoded_id/rails/query_methods.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module EncodedId
+  module Rails
+    module QueryMethods
+      def where_encoded_id(slugged_encoded_id)
+        decoded_id = decode_encoded_id(slugged_encoded_id)
+        raise ActiveRecord::RecordNotFound if decoded_id.nil?
+        where(id: decoded_id)
+      end
+    end
+  end
+end

data/lib/encoded_id/rails/slugged_path_param.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "encoded_id"
+
+module EncodedId
+  module Rails
+    module SluggedPathParam
+      def to_param
+        slugged_encoded_id
+      end
+    end
+  end
+end

data/lib/encoded_id/rails/version.rb

@@ -2,6 +2,6 @@
 
 module EncodedId
   module Rails
-    VERSION = "0.4.0"
+    VERSION = "0.6.0"
   end
 end

data/lib/encoded_id/rails.rb

@@ -6,7 +6,12 @@ require_relative "rails/coder"
 require_relative "rails/slugged_id"
 require_relative "rails/slugged_id_parser"
 require_relative "rails/salt"
-require_relative "rails/with_encoded_id"
+require_relative "rails/encoder_methods"
+require_relative "rails/query_methods"
+require_relative "rails/finder_methods"
+require_relative "rails/path_param"
+require_relative "rails/slugged_path_param"
+require_relative "rails/model"
 
 module EncodedId
   module Rails
@@ -24,5 +29,7 @@ module EncodedId
   end
 
   # Expose directly on EncodedId
-  WithEncodedId = Rails::WithEncodedId
+  Model = Rails::Model
+  PathParam = Rails::PathParam
+  SluggedPathParam = Rails::SluggedPathParam
 end

data/sig/encoded_id/rails.rbs

@@ -2,10 +2,25 @@ module EncodedId
   module Rails
     VERSION: ::String
 
+    class Configuration
+      attr_accessor salt: ::String
+      attr_accessor group_separator: ::String
+      attr_accessor character_group_size: ::Integer
+      attr_accessor alphabet: ::EncodedId::Alphabet
+      attr_accessor id_length: ::Integer
+      attr_accessor slugged_id_separator: ::String
+
+      def initialize: () -> void
+    end
+
+    attr_reader self.configuration: Configuration
+
+    def self.configure: () { (Configuration config) -> void } -> void
+
     class Coder
       def initialize: (salt: ::String, id_length: ::Integer, character_group_size: ::Integer, separator: ::String, alphabet: ::EncodedId::Alphabet) -> void
       def encode: (::Integer | ::Array[::Integer]) -> String
-      def decode: (::String) -> (nil | ::Array[::Integer])
+      def decode: (::String) -> ::Array[::Integer]?
 
       @salt: ::String
       @id_length: ::Integer
@@ -18,21 +33,10 @@ module EncodedId
       def coder: -> ::EncodedId::ReversibleId
     end
 
-    class Configuration
-      attr_accessor salt: ::String
-      attr_accessor group_separator: ::String
-      attr_accessor character_group_size: ::Integer
-      attr_accessor alphabet: ::EncodedId::Alphabet
-      attr_accessor id_length: ::Integer
-      attr_accessor slugged_id_separator: ::String
-
-      def initialize: () -> void
-    end
-
     class Salt
-      def initialize: (untyped klass, ::String salt) -> void
+      def initialize: (Class klass, ::String salt) -> void
 
-      @klass: untyped
+      @klass: Class
       @salt: ::String
 
       def generate!: -> ::String
@@ -52,43 +56,42 @@ module EncodedId
     class SluggedIdParser
       def initialize: (::String slugged_id, ?separator: ::String) -> void
 
-      attr_reader slug: (nil | ::String)
-      attr_reader id: (nil | ::String)
+      attr_reader slug: ::String?
+      attr_reader id: ::String?
     end
 
-    attr_reader self.configuration: Configuration
+    module EncoderMethods
+      def encode_encoded_id: (untyped id, ?::Hash[::Symbol, untyped] options) -> ::String
+      def decode_encoded_id: (::String slugged_encoded_id, ?::Hash[::Symbol, untyped] options) -> ::Array[::Integer]?
+      def encoded_id_salt: () -> ::String
+      def encoded_id_parser: (::String slugged_encoded_id) -> ::EncodedId::Rails::SluggedIdParser
+      def encoded_id_coder: (?::Hash[::Symbol, untyped] options) -> ::EncodedId::Rails::Coder
+    end
 
-    def self.configure: () { (Configuration config) -> void } -> void
+    interface _ActiveRecordFinderMethod
+      def find_by: (*untyped) -> (nil | untyped)
+    end
 
-    module WithEncodedId
-      module ClassMethods
-        def find_by_encoded_id: (::String slugged_encoded_id, ?with_id: ::Symbol?) -> (nil | untyped)
-        def find_by_encoded_id!: (::String slugged_encoded_id, ?with_id: ::Symbol?) -> untyped
-        def where_encoded_id: (::String slugged_encoded_id) -> untyped
-        def encode_encoded_id: (untyped id, ?::Hash[::Symbol, untyped] options) -> ::String
-        def decode_encoded_id: (::String slugged_encoded_id, ?::Hash[::Symbol, untyped] options) -> (nil | ::Array[::Integer])
-        def encoded_id_salt: () -> ::String
-        def encoded_id_parser: (::String slugged_encoded_id) -> ::EncodedId::Rails::SluggedIdParser
-        def encoded_id_coder: (?::Hash[::Symbol, untyped] options) -> ::EncodedId::Rails::Coder
-
-        # FIXME: Methods defined on AR, how to tell steep that this will be composed with AR?
-        def where: (*untyped) -> untyped
-        def find: (*untyped) -> (nil | untyped)
-        def find!: (*untyped) -> untyped
-        def find_by: (*untyped) -> (nil | untyped)
-        def find_by!: (*untyped) -> untyped
-      end
-
-      # FIXME: steep doesnt understand that methods defined in ClassMethods will be added to the class, hence
-      # the duplication here
-      def self.find_by_encoded_id: (::String slugged_encoded_id, ?with_id: ::Symbol?) -> (nil | untyped)
-      def self.find_by_encoded_id!: (::String slugged_encoded_id, ?with_id: ::Symbol?) -> untyped
-      def self.where_encoded_id: (::String slugged_encoded_id) -> untyped
-      def self.encode_encoded_id: (untyped id, ?::Hash[::Symbol, untyped] options) -> ::String
-      def self.decode_encoded_id: (::String slugged_encoded_id, ?::Hash[::Symbol, untyped] options) -> (nil | ::Array[::Integer])
-      def self.encoded_id_salt: () -> ::String
-      def self.encoded_id_parser: (::String slugged_encoded_id) -> ::EncodedId::Rails::SluggedIdParser
-      def self.encoded_id_coder: (?::Hash[::Symbol, untyped] options) -> ::EncodedId::Rails::Coder
+    module FinderMethods : EncoderMethods, _ActiveRecordFinderMethod
+      def find_by_encoded_id: (::String slugged_encoded_id, ?with_id: ::Symbol?) -> untyped?
+      def find_by_encoded_id!: (::String slugged_encoded_id, ?with_id: ::Symbol?) -> untyped
+    end
+
+    interface _ActiveRecordQueryMethod
+      def where: (*untyped) -> untyped
+    end
+
+    module QueryMethods : EncoderMethods, _ActiveRecordQueryMethod
+      def where_encoded_id: (::String slugged_encoded_id) -> untyped
+    end
+
+    module Model : ActiveRecord::Base
+      extend ActiveRecord::FinderMethods
+      extend ActiveRecord::QueryMethods
+
+      extend EncoderMethods
+      extend FinderMethods
+      extend QueryMethods
 
       @encoded_id: ::String
       @slugged_encoded_id: ::String
@@ -96,11 +99,20 @@ module EncodedId
       def encoded_id: () -> ::String
       def slugged_encoded_id: (?with: ::Symbol) -> ::String
       def name_for_encoded_id_slug: () -> ::String
+    end
 
-      # FIXME: To make type check happy, but may not exist!
-      # We call if respond_to? but type checker doesn't know that
-      def name: () -> ::String
-      def id: () -> ::String
+    interface _ActiveRecordToParam
+      def to_param: () -> ::String
+    end
+
+    module PathParam : Model, _ActiveRecordToParam
+    end
+
+    module SluggedPathParam : Model, _ActiveRecordToParam
     end
   end
+
+  Model: singleton(Rails::Model)
+  PathParam: singleton(Rails::PathParam)
+  SluggedPathParam: singleton(Rails::SluggedPathParam)
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: encoded_id-rails
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Stephen Ierodiaconou
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-12-18 00:00:00.000000000 Z
+date: 2022-12-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -84,11 +84,16 @@ files:
 - lib/encoded_id/rails.rb
 - lib/encoded_id/rails/coder.rb
 - lib/encoded_id/rails/configuration.rb
+- lib/encoded_id/rails/encoder_methods.rb
+- lib/encoded_id/rails/finder_methods.rb
+- lib/encoded_id/rails/model.rb
+- lib/encoded_id/rails/path_param.rb
+- lib/encoded_id/rails/query_methods.rb
 - lib/encoded_id/rails/salt.rb
 - lib/encoded_id/rails/slugged_id.rb
 - lib/encoded_id/rails/slugged_id_parser.rb
+- lib/encoded_id/rails/slugged_path_param.rb
 - lib/encoded_id/rails/version.rb
-- lib/encoded_id/rails/with_encoded_id.rb
 - lib/generators/encoded_id/rails/USAGE
 - lib/generators/encoded_id/rails/install_generator.rb
 - lib/generators/encoded_id/rails/templates/encoded_id.rb

data/lib/encoded_id/rails/with_encoded_id.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-require "active_record"
-require "encoded_id"
-
-module EncodedId
-  module Rails
-    module WithEncodedId
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      module ClassMethods
-        # Find by encoded ID and optionally ensure record ID is the same as constraint (can be slugged)
-        def find_by_encoded_id(slugged_encoded_id, with_id: nil)
-          decoded_id = decode_encoded_id(slugged_encoded_id)
-          return if decoded_id.blank?
-          record = find_by(id: decoded_id)
-          return unless record
-          return if with_id && with_id != record.send(:id)
-          record
-        end
-
-        def find_by_encoded_id!(slugged_encoded_id, with_id: nil)
-          decoded_id = decode_encoded_id(slugged_encoded_id)
-          raise ActiveRecord::RecordNotFound if decoded_id.blank?
-          record = find_by(id: decoded_id)
-          if !record || (with_id && with_id != record.send(:id))
-            raise ActiveRecord::RecordNotFound
-          end
-          record
-        end
-
-        def where_encoded_id(slugged_encoded_id)
-          decoded_id = decode_encoded_id(slugged_encoded_id)
-          raise ActiveRecord::RecordNotFound if decoded_id.nil?
-          where(id: decoded_id)
-        end
-
-        def encode_encoded_id(ids, options = {})
-          raise StandardError, "You must pass an ID or array of IDs" if ids.blank?
-          encoded_id_coder(options).encode(ids)
-        end
-
-        def decode_encoded_id(slugged_encoded_id, options = {})
-          return if slugged_encoded_id.blank?
-          encoded_id = encoded_id_parser(slugged_encoded_id).id
-          return if !encoded_id || encoded_id.blank?
-          encoded_id_coder(options).decode(encoded_id)
-        end
-
-        # This can be overridden in the model to provide a custom salt
-        def encoded_id_salt
-          EncodedId::Rails::Salt.new(self, EncodedId::Rails.configuration.salt).generate!
-        end
-
-        def encoded_id_parser(slugged_encoded_id)
-          SluggedIdParser.new(slugged_encoded_id, separator: EncodedId::Rails.configuration.slugged_id_separator)
-        end
-
-        def encoded_id_coder(options = {})
-          config = EncodedId::Rails.configuration
-          EncodedId::Rails::Coder.new(
-            salt: options[:salt] || encoded_id_salt,
-            id_length: options[:id_length] || config.id_length,
-            character_group_size: options[:character_group_size] || config.character_group_size,
-            alphabet: options[:alphabet] || config.alphabet,
-            separator: options[:separator] || config.group_separator
-          )
-        end
-      end
-
-      # Instance methods
-
-      def encoded_id
-        @encoded_id ||= self.class.encode_encoded_id(id)
-      end
-
-      def slugged_encoded_id(with: :name_for_encoded_id_slug)
-        @slugged_encoded_id ||= EncodedId::Rails::SluggedId.new(
-          self,
-          slug_method: with,
-          id_method: :encoded_id,
-          separator: EncodedId::Rails.configuration.slugged_id_separator
-        ).slugged_id
-      end
-
-      # By default slug calls `name` if it exists or returns class name
-      def name_for_encoded_id_slug
-        if respond_to? :name
-          given_name = name
-          return given_name if given_name.present?
-        end
-        class_name = self.class.name
-        raise StandardError, "No name or class name found, cannot create a slug" if !class_name || class_name.blank?
-        class_name.underscore
-      end
-    end
-  end
-end