similar_models 0.3.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c7c43faef16009cad0a971ec3afc6efc716bd77723d45395a70365e2a96fa9b
-  data.tar.gz: ac4deb962291c450f53cbf4731ada109ad3a505e009225dcae1f87495c817802
+  metadata.gz: 1512f7d1b0d895cc90aa6bf3357e8379aac8f57848de01f2a0d05816107e8936
+  data.tar.gz: 5001875c74fce6ba9bfbce5af20424742c87564d07a7b16393f953ada0b59cfa
 SHA512:
-  metadata.gz: 228a426d2b7a8f10e0db47034e66a8f166ca957ef05e242fc787eeb2c84add141c4b4ba4b95a38f4eaa909cb13d69b8209db968d06b8f4d90ab46445828791c4
-  data.tar.gz: 3dfee9418bb74aaddc686f96be94a69073b395f7a9edeac5a7a6900044c70cb0386a2da7ac7b84aa69f8766bcb8eb8b12c6c303bbb4f55615846f610c7fa0b1c
+  metadata.gz: 76f8b14e266fc0cf9063c19d5a39c6ce346b05539a450ab100e13e0440b7ea6293b4c02c1250f1e9a68a37fb9a7d952b3b6380bf3ea64bdd5c01984848d001a2
+  data.tar.gz: 51e379dc7d45bd905d0a52d791b8cd9a869ee5fe285848ced7ff3a579e4758ccb677095faadd5b55d812055acc87b4c0dbdc260e95aaa1ef8b51fa983d50b32b

data/README.md

@@ -1,8 +1,16 @@
 # Similar Models
 
-Adds a `similar_{model name plural}` method to an active record model, but can be set to any name using `as: {method name}`. It returns the most similar models of the same class based on associated models in common.
+Adds a `similar_#{model_name.plural}` instance and class method to an active record model, but can be set to any name using `as: {method name}`.
 
-The association(s) have to be many to many, so either [habtm](http://guides.rubyonrails.org/association_basics.html#the-has-and-belongs-to-many-association) or [has_many :through](http://guides.rubyonrails.org/association_basics.html#the-has-many-through-association).
+The instance method returns models that have associated models in common ordered by most in common first.
+
+A practical example for this could be linking to related blog posts when rendering an individual blog post. Related blog posts could be related by author, tag or author and tag combined.
+
+The class method returns models ordered by most associated models in common.
+
+If the commonality count is the same then a second order clause of `created_at` takes precedence if present.
+
+The association(s) have to be many to many, so either [habtm](https://guides.rubyonrails.org/association_basics.html#has-and-belongs-to-many) or [has_many :through](https://guides.rubyonrails.org/association_basics.html#has-many-through).
 
 ## Installation
 
@@ -23,64 +31,80 @@ $ bundle
 Post example
 
 ```ruby
-class Post < ActiveRecord::Base
-    has_many :author_posts
-    has_many :authors, through: :author_posts
-    has_and_belongs_to_many :tags
-
-    has_similar_models :authors
-    has_similar_models :tags, as: :similar_posts_by_tag
-    has_similar_models :authors, :tags, as: :similar_posts_by_author_and_tag
+class Post < ApplicationRecord
+  has_many :author_posts
+  has_many :authors, through: :author_posts
+  has_and_belongs_to_many :tags
+
+  has_similar_models :authors
+  has_similar_models :tags, as: :similar_posts_by_tag
+  has_similar_models :authors, :tags, as: :similar_posts_by_author_and_tag
 end
 
-class Tag < ActiveRecord::Base
+class Tag < ApplicationRecord
 end
 
-class Author < ActiveRecord::Base
-    has_many :author_posts
+class Author < ApplicationRecord
+  has_many :author_posts
 end
 
-class AuthorPosts < ActiveRecord::Base
-    belongs_to :author
-    belongs_to :post
+class AuthorPosts < ApplicationRecord
+  belongs_to :author
+  belongs_to :post
 end
 ```
 
-To return the posts with the most authors in common with `post` in descending order:
+To return posts with authors in common with the `post` model by most in common first:
 
 ```ruby
 post.similar_posts
 ```
 
+To return posts ordered by most authors in common:
+```ruby
+Post.similar_posts
+```
+
 The returned object is an ActiveRecord::Relation and so chaining of other query methods is possible:
 
 ```ruby
-post.similar_posts.where(posts.created_at: 10.days.ago..).limit(5)
+post.similar_posts.where(created_at: 10.days.ago..).limit(5)
 ```
 
-To return the posts with the most tags in common with `post` in descending order:
+To return posts with tags in common with the `post` model by most in common first:
 
 ```ruby
 post.similar_posts_by_tag
 ```
 
-To return the posts with the most authors and tags in common with `post` in descending order:
+To return posts ordered by most tags in common:
+```ruby
+Post.similar_posts_by_tag
+```
+
+To return posts with the authors and tags in common with the `post` model by most in common first:
 
 ```ruby
 post.similar_posts_by_author_and_tag
 ```
 
+To return posts ordered by most authors and tags in common:
+
+```ruby
+Post.similar_posts_by_author_and_tag
+```
+
 The count of the associated models in common is accessible on each returned model:
 
 ```ruby
-post.similar_posts_model_count
-post.similar_posts_by_tag_model_count
-post.similar_posts_by_author_and_tag_model_count
+post.similar_posts_commonality_count
+post.similar_posts_by_tag_commonality_count
+post.similar_posts_by_author_and_tag_commonality_count
 ```
 
-**Note multiple associations do not work with sqlite.**
+**Note multiple associations for the instance method do not work with sqlite.**
 
-Because of the use of `group`, pagination is not supported.
+**Pagination is not supported on the instance method due to the use of `group by`.**
 
 ## In conjunction with acts-as-taggable-on
 

data/lib/similar_models/version.rb

@@ -1,3 +1,3 @@
 module SimilarModels
-  VERSION = '0.3.0'
+  VERSION = '0.4.1'
 end

data/lib/similar_models.rb

@@ -3,9 +3,66 @@ require 'similar_models/version'
 module SimilarModels
 
   def has_similar_models(*many_to_many_associations, as: nil)
-    as = "similar_#{model_name.plural}" unless as
+    as ||= "similar_#{model_name.plural}"
 
-    # defaults to 'def similar_{model name}'
+    # example sql query for one many to many association:
+    #
+    # SELECT posts.*,
+    #   (select count(*) from author_posts where post_id != posts.alt_id and author_id in
+    #     (select author_id from author_posts where post_id = posts.alt_id)) AS similar_posts_commonality_count
+    #   FROM "posts"
+    #   ORDER BY similar_posts_commonality_count DESC, created_at DESC
+    #
+    define_singleton_method as do
+      primary_key_ref = "#{table_name}.#{primary_key}"
+      similarity_counts = []
+
+      many_to_many_associations.each do |many_to_many_association|
+        association = reflect_on_association(many_to_many_association)
+        join_table, foreign_key, association_foreign_key = join_table_values(association)
+
+        similarity_counts <<
+          "(select count(*) from #{join_table} where #{foreign_key} != #{primary_key_ref} and " \
+          "#{association_foreign_key} in " \
+          "(select #{association_foreign_key} from #{join_table} where #{foreign_key} = #{primary_key_ref}))"
+      end
+
+      order_clause = "#{as}_commonality_count DESC"
+      order_clause += ", created_at DESC" if column_names.include?('created_at')
+      select("#{table_name}.*, #{similarity_counts.join(' + ')} AS #{as}_commonality_count").order(order_clause)
+    end
+
+    # example sql query for one many to many association:
+    #
+    # SELECT posts.*, count(posts.alt_id) AS similar_posts_commonality_count
+    #   FROM "posts"
+    #   INNER JOIN author_posts ON author_posts.post_id = posts.alt_id
+    #     WHERE "posts"."alt_id" != ? AND
+    #       author_posts.author_id IN (select author_posts.author_id from author_posts where author_posts.post_id = ?)
+    #   GROUP BY posts.alt_id
+    #   ORDER BY similar_posts_commonality_count DESC, created_at DESC
+    #
+    # example sql query for two many to many associations:
+    #
+    # SELECT posts.*, count(posts.alt_id) AS similar_posts_by_author_and_tag_commonality_count
+    #   FROM (
+    #     (SELECT "posts".* FROM "posts"
+    #       INNER JOIN author_posts ON author_posts.post_id = posts.alt_id
+    #       WHERE (author_posts.author_id IN
+    #         (select author_posts.author_id from author_posts where author_posts.post_id = ?)
+    #       )
+    #     )
+    #   UNION ALL
+    #     (SELECT "posts".* FROM "posts"
+    #       INNER JOIN posts_tags ON posts_tags.post_id = posts.alt_id
+    #       WHERE (posts_tags.tag_id IN
+    #         (select posts_tags.tag_id from posts_tags where posts_tags.post_id = ?)
+    #       )
+    #     )
+    #   )
+    #   AS posts WHERE "posts"."alt_id" != ? GROUP BY posts.alt_id, posts.created_at, posts.updated_at
+    #   ORDER BY similar_posts_by_author_and_tag_commonality_count DESC, created_at DESC
+    #
     define_method as do
       table_name = self.class.table_name
       primary_key = self.class.primary_key
@@ -13,8 +70,8 @@ module SimilarModels
       association_scopes = []
 
       many_to_many_associations.each do |many_to_many_association|
-        assocation = self.class.reflect_on_association(many_to_many_association)
-        join_table, foreign_key, association_foreign_key = self.class.join_table_values(assocation)
+        association = self.class.reflect_on_association(many_to_many_association)
+        join_table, foreign_key, association_foreign_key = self.class.join_table_values(association)
 
         association_scopes << self.class.where(
           "#{join_table}.#{association_foreign_key} IN \
@@ -23,14 +80,16 @@ module SimilarModels
         ).joins("INNER JOIN #{join_table} ON #{join_table}.#{foreign_key} = #{primary_key_ref}")
       end
 
-      scope = self.class.select("#{table_name}.*, count(#{primary_key_ref}) AS #{as}_model_count").
-        where.not(primary_key => self.id).order("#{as}_model_count DESC")
-      group_by_clause = self.class.column_names.map { |column| "#{table_name}.#{column}"}.join(', ')
+      order_clause = "#{as}_commonality_count DESC"
+      order_clause += ", created_at DESC" if self.class.column_names.include?('created_at')
+      scope = self.class.select("#{table_name}.*, count(#{primary_key_ref}) AS #{as}_commonality_count").
+        where.not(primary_key => self.id).order(order_clause)
 
       # if there is only one many-to-many association no need to use UNION sql syntax
       if association_scopes.one?
-        scope.merge(association_scopes.first).group(group_by_clause)
+        scope.merge(association_scopes.first).group(primary_key_ref)
       else
+        group_by_clause = self.class.column_names.map { |column| "#{table_name}.#{column}"}.join(', ')
         scope.from("((#{association_scopes.map(&:to_sql).join(') UNION ALL (')})) AS #{table_name}").group(group_by_clause)
       end
     end

data/similar_models.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = SimilarModels::VERSION
   spec.authors       = ["Jolyon Pawlyn"]
   spec.email         = ["jpawlyn@gmail.com"]
-  spec.description   = %q{Adds an instance method to an active record model that returns the most similar models based on associated models in common}
-  spec.summary       = %q{Returns models that have the most associated models in common}
+  spec.description   = %q{Adds a `similar_#{model_name.plural}` instance and class method to an active record model and returns models based on associated models in common ordered by most in common first}
+  spec.summary       = %q{Returns models that have associated models in common ordered by most in common first}
   spec.homepage      = "https://github.com/jpawlyn/similar_models"
   spec.license       = "MIT"
 

data/spec/post_spec.rb

@@ -5,34 +5,52 @@ describe Post do
   let(:author2) { Author.create! }
   let(:author3) { Author.create! }
   let(:author4) { Author.create! }
+  let(:author5) { Author.create! }
   let(:tag1) { Tag.create! }
   let(:tag2) { Tag.create! }
   let(:tag3) { Tag.create! }
   let(:tag4) { Tag.create! }
 
   context 'has_many through:' do
-    it 'return posts that have the most authors in common with post' do
-      post = Post.create! authors: [author1, author2, author3]
-      post1 = Post.create! authors: [author1, author4]
-      post2 = Post.create! authors: [author1, author2]
-      post3 = Post.create! authors: [author4]
-      post4 = Post.create! authors: [author1, author2, author3]
-
-      expect(post.similar_posts.map(&:similar_posts_model_count)).to eq([3, 2, 1])
-      expect(post.similar_posts).to eq([post4, post2, post1])
+    let!(:post)  { Post.create! authors: [author1, author2, author3] }
+    let!(:post1) { Post.create! authors: [author1] }
+    let!(:post2) { Post.create! authors: [author4] }
+    let!(:post3) { Post.create! authors: [author1, author2, author3, author4] }
+    let!(:post4) { Post.create! authors: [author5] }
+
+    describe '.similar_posts' do
+      it 'return posts ordered by most authors in common' do
+        expect(described_class.similar_posts.map(&:similar_posts_commonality_count)).to eq([5, 4, 2, 1, 0])
+        expect(described_class.similar_posts).to eq([post3, post, post1, post2, post4])
+      end
+    end
+
+    describe '#similar_posts' do
+      it 'return posts that have authors in common with `post` ordered by most in common first' do
+        expect(post.similar_posts.map(&:similar_posts_commonality_count)).to eq([3, 1])
+        expect(post.similar_posts).to eq([post3, post1])
+      end
     end
   end
 
   context 'has_and_belongs_to_many' do
-    it 'return posts that have the most tags in common with post' do
-      post = Post.create! tags: [tag1, tag2, tag3]
-      post1 = Post.create! tags: [tag1, tag4]
-      post2 = Post.create! tags: [tag1, tag2]
-      post3 = Post.create! tags: [tag4]
-      post4 = Post.create! tags: [tag1, tag2, tag3]
-
-      expect(post.similar_posts_by_tag.map(&:similar_posts_by_tag_model_count)).to eq([3, 2, 1])
-      expect(post.similar_posts_by_tag).to eq([post4, post2, post1])
+    let!(:post) { Post.create! tags: [tag1, tag2, tag3] }
+    let!(:post1) { Post.create! tags: [tag1, tag4] }
+    let!(:post2) { Post.create! tags: [tag2] }
+    let!(:post3) { Post.create! tags: [tag2, tag3] }
+
+    describe '.similar_posts_by_tag' do
+      it 'return posts ordered by most tags in common' do
+        expect(described_class.similar_posts_by_tag.map(&:similar_posts_by_tag_commonality_count)).to eq([4, 3, 2, 1])
+        expect(described_class.similar_posts_by_tag).to eq([post, post3, post2, post1])
+      end
+    end
+
+    describe '#similar_posts_by_tag' do
+      it 'return posts that have tags in common with `post` ordered by most in common first' do
+        expect(post.similar_posts_by_tag.map(&:similar_posts_by_tag_commonality_count)).to eq([2, 1, 1])
+        expect(post.similar_posts_by_tag).to eq([post3, post2, post1])
+      end
     end
   end
 
@@ -43,9 +61,19 @@ describe Post do
     let!(:post3) { Post.create! tags: [tag4] }
     let!(:post4) { Post.create! authors: [author1], tags: [tag1, tag2, tag3] }
 
-    it 'return posts that have the most authors and tags in common with post' do
-      expect(post.similar_posts_by_author_and_tag.map(&:similar_posts_by_author_and_tag_model_count)).to eq([5, 4, 1])
-      expect(post.similar_posts_by_author_and_tag).to eq([post1, post4, post2])
+    describe '.similar_posts_by_author_and_tag' do
+      it 'return posts ordered by most authors and tags in common' do
+        expect(described_class.similar_posts_by_author_and_tag.map(&:similar_posts_by_author_and_tag_commonality_count))
+          .to eq([10, 10, 8, 3, 1])
+        expect(described_class.similar_posts_by_author_and_tag).to eq([post1, post, post4, post2, post3])
+      end
+    end
+
+    describe '#similar_posts_by_author_and_tag' do
+      it 'return posts that have authors and tags in common with `post` ordered by most in common first' do
+        expect(post.similar_posts_by_author_and_tag.map(&:similar_posts_by_author_and_tag_commonality_count)).to eq([5, 4, 1])
+        expect(post.similar_posts_by_author_and_tag).to eq([post1, post4, post2])
+      end
     end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: similar_models
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Jolyon Pawlyn
 bindir: bin
 cert_chain: []
-date: 2025-02-24 00:00:00.000000000 Z
+date: 2025-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -107,8 +107,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-description: Adds an instance method to an active record model that returns the most
-  similar models based on associated models in common
+description: Adds a `similar_#{model_name.plural}` instance and class method to an
+  active record model and returns models based on associated models in common ordered
+  by most in common first
 email:
 - jpawlyn@gmail.com
 executables: []
@@ -148,7 +149,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.5
 specification_version: 4
-summary: Returns models that have the most associated models in common
+summary: Returns models that have associated models in common ordered by most in common
+  first
 test_files:
 - spec/post_spec.rb
 - spec/spec_helper.rb