encoded_id-rails 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0aceb28e50697bb0257054c2731936a7cad5f6617d479543c63999a156c153bf
-  data.tar.gz: 59be3ddf7327f26726df0aa3120f9a70de0ac225d77291ad8e35b10b937e6264
+  metadata.gz: 6cfa444903c74b47cf55b4c8aa45d862f6eecbe843ff0af9b987b713c4b226d4
+  data.tar.gz: 7f530fdd9cd3b8a83a308f45e236c92c2bbdaae394cc8b455178ce1ff3de9802
 SHA512:
-  metadata.gz: 821e8ffcb7f77bdc84160a69bbc504ec891f9b11d925e4aa5d52f1209f426d894671cc603b850ee1a408dfa255c9b00eeaed6938eb1440aec4a31af27209f484
-  data.tar.gz: a168a3da9c882a0e1c9f159cfcfeaeaf02109049aed2f2330b9a51708cee927896a911cae63833ec11955a0139af6aa9a3302a9e970a9f461024d4a870730bf2
+  metadata.gz: e8e9be56253a8956f1a850905c6a9c53e33f7593d419c7348a158e8ff76e3a0285319c116b8a81bfb22d964ceec6aac85fcbe128b3a4ad8265b0b790be27b83b
+  data.tar.gz: bc63195e7d397c41350b80783526d1733e6109ddc9cd9cbace00d827ff95b19046b287030436da09e359bb3f92774efe702bc17dc4fea006192748463c5eb9b7

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/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/version.rb

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

data/lib/encoded_id/rails/with_encoded_id.rb

@@ -7,71 +7,11 @@ module EncodedId
   module Rails
     module WithEncodedId
       def self.included(base)
-        base.extend(ClassMethods)
+        base.extend(EncoderMethods)
+        base.extend(FinderMethods)
+        base.extend(QueryMethods)
       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
@@ -85,14 +25,10 @@ module EncodedId
         ).slugged_id
       end
 
-      # By default slug calls `name` if it exists or returns class name
+      # By default slug created from class name, but can be overridden
       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?
+        raise StandardError, "Class must have a `name`, cannot create a slug" if !class_name || class_name.blank?
         class_name.underscore
       end
     end

data/lib/encoded_id/rails.rb

@@ -6,6 +6,9 @@ require_relative "rails/coder"
 require_relative "rails/slugged_id"
 require_relative "rails/slugged_id_parser"
 require_relative "rails/salt"
+require_relative "rails/encoder_methods"
+require_relative "rails/query_methods"
+require_relative "rails/finder_methods"
 require_relative "rails/with_encoded_id"
 
 module EncodedId

data/sig/encoded_id/rails.rbs

@@ -5,7 +5,7 @@ module EncodedId
     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
@@ -30,9 +30,9 @@ module EncodedId
     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 +52,46 @@ 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
 
     def self.configure: () { (Configuration config) -> void } -> void
 
-    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 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
+
+    interface _ActiveRecordFinderMethod
+      def find_by: (*untyped) -> (nil | untyped)
+    end
+
+    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 WithEncodedId : ActiveRecord::Base
+      extend ActiveRecord::FinderMethods
+      extend ActiveRecord::QueryMethods
+
+      extend EncoderMethods
+      extend FinderMethods
+      extend QueryMethods
 
       @encoded_id: ::String
       @slugged_encoded_id: ::String
@@ -96,11 +99,6 @@ module EncodedId
       def encoded_id: () -> ::String
       def slugged_encoded_id: (?with: ::Symbol) -> ::String
       def name_for_encoded_id_slug: () -> ::String
-
-      # 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
     end
   end
 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.5.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,6 +84,9 @@ 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/query_methods.rb
 - lib/encoded_id/rails/salt.rb
 - lib/encoded_id/rails/slugged_id.rb
 - lib/encoded_id/rails/slugged_id_parser.rb