association_scope 0.2.0 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68f9bb59cba6aef5a515e5e98bc1d2142be093806189a34afabd69ae6c644e1a
-  data.tar.gz: 4fcc7b908d68b66c9225538132018ca9dd0925a8ba6ab5c634df5629cebc11cc
+  metadata.gz: 4a78d72190a884c263ac9dac8d02588505bf530168c8e15faff4a3d3f07e53ad
+  data.tar.gz: ccd5422df4c1c871dacb0b0b8954abffb580ac305d639a8b91438f6ceb8abb85
 SHA512:
-  metadata.gz: da819d457189fb70dc3b4cd4f09af01c6a3547c8c5f5fa36a38efd4bf01f7c65c2110e4852d91ccc857a4965ce19c0b64f6425ab7034f1077c65a291668e1bc9
-  data.tar.gz: 956f163600f9afcc845fe29f3d621661538b529cea40e84c2ba32fede3356760a81692c11ed6500de436aa4b52f9533c4e18649abadc34d58f915b9f9d08187f
+  metadata.gz: 539e2a97b60ecf359a717e8dd4de6a203d16ea91e2fb61dd7a520bb599b79a4b7a5ac742a63f33bddbf199bc4565dfb728c85994cd30e5733a307e915d53ed1d
+  data.tar.gz: f2d1f90636e1e2f5aca7231ef8c8d686d276d5a341b02e6a5b70af77ad7b1c5500bf5ac1c45b64624e12315add3e6ffdbb72d61fddd5adc48e98c3216cd3db6a

data/README.md

@@ -19,7 +19,7 @@ class Topic < ApplicationRecord
   scope :of_users, -> (users) { joins(:user).where(users: users) }
 end
 ```
-over and over again across all of my models to write `Topic.of_users(current_user.friends)` when I wanted to write `current_user.friends.topics` instead.
+over and over again across all of my models to write something like `Topic.of_users(current_user.friends)` when I wanted to write `current_user.friends.topics` instead.
 And `belongs_to` is the easiest part.
 
 When you have this problem, the AssociationScope gem is for you!
@@ -43,11 +43,11 @@ $ gem install association_scope
 ```
 
 ## Usage
-After installation you can use `acts_as_association_scope` in your models:
+After installation you can use `has_association_scope_on` in your models:
 ```ruby
 class Topic < ApplicationRecord
   belongs_to :user
-  acts_as_association_scope
+  has_association_scope_on [:user]
 end
 ```
 Now you can use your associations as scopes and chain other scopes with them.
@@ -57,24 +57,41 @@ Topic.all.users
 ```
 to retrieve the users of all of the topics of your application.
 
+### Migration from `.of_model`
+When you already use any form of `.of_model` scope, you can replace it with association scopes:
+
+```ruby
+# replace
+Topic.of_users(current_user.friends)
+# with
+current_user.friends.topics
+```
+When you chain scopes, you have to merge with the previous scope:
+```ruby
+# replace
+scope.of_users(users)
+# with
+users.topics.merge(scope)
+```
+
 ## Known Issues
 * This gem works with `reflections`.
-To make this work, the `acts_as_association_scope` call has to be below your association definitions.
+To make this work, the `has_association_scope_on` call has to be below your association definitions.
 ```ruby
 # won't work
 class Topic
-  acts_as_association_scope
+  has_association_scope_on [:user]
   belongs_to :user
 end
 
 # works
 class Topic
   belongs_to :user
-  acts_as_association_scope
+  has_association_scope_on [:user]
 end
 ```
-* Database views do not have a primary key.
-To use `distinct` on rows, all values of this row must be of types other than json.
+* Does not work for tables without primary key.
+* To use `distinct` on rows, all values of this row must be of types other than JSON.
 Workaround: Migrate JSON columns to JSONB.
 * Error messages are not raised during application start, but on first instantiation, because of the order in which classes are loaded.
 

data/lib/association_scope/errors/association_missing_error.rb

@@ -11,7 +11,7 @@ module AssociationScope
     end
 
     def message
-      "Association #{association} missing in #{missing_in}!"
+      "Association :#{association} missing in #{missing_in}!"
     end
   end
 end

data/lib/association_scope/scope/belongs_to_reflection.rb

@@ -5,21 +5,11 @@ module AssociationScope
     class BelongsToReflection < Scope
       def apply
         association = @association
-        details = model.reflections[association]
-        class_name = details.options[:class_name]&.constantize || association.camelize.constantize
+        class_name = reflection_details.options[:class_name]&.constantize || association.camelize.constantize
+        foreign_key = reflection_details.options[:foreign_key]
         association_name = association.to_s.underscore.to_sym
-        foreign_key = details.options[:foreign_key]
         own_table_name = class_name.to_s.pluralize.underscore
-
-        inverse_reflection = class_name.reflections[model.to_s.underscore.singularize] || class_name.reflections[model.to_s.underscore.pluralize]
-        case inverse_reflection&.source_reflection&.class&.to_s&.split("::")&.last
-        when "HasOneReflection"
-          table_name = model.to_s.underscore.to_sym
-        when "HasManyReflection"
-          table_name = model.to_s.underscore.pluralize.to_sym
-        else
-          raise AssociationMissingError.new missing_in: class_name, association: model.to_s.underscore.pluralize
-        end
+        table_name = table_name class_name
 
         model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
           scope association.pluralize, -> do
@@ -36,6 +26,27 @@ module AssociationScope
           end
         RUBY
       end
+
+      private
+
+      def table_name(class_name)
+        case inverse_reflection(class_name)&.source_reflection&.class&.to_s&.split("::")&.last
+        when "HasOneReflection"
+          model.to_s.underscore.to_sym
+        when "HasManyReflection"
+          model.to_s.underscore.pluralize.to_sym
+        else
+          raise AssociationMissingError.new missing_in: class_name, association: model.to_s.underscore.pluralize
+        end
+      end
+
+      def inverse_reflection(class_name)
+        class_name.reflections[model.to_s.underscore.singularize] || class_name.reflections[model.to_s.underscore.pluralize]
+      end
+
+      def reflection_details
+        model.reflections[association]
+      end
     end
   end
 end

data/lib/association_scope/scope/has_and_belongs_to_many_reflection.rb

@@ -5,13 +5,12 @@ module AssociationScope
     class HasAndBelongsToManyReflection < Scope
       def apply
         association = @association.pluralize
-        details = model.reflections[association]
-        class_name = details.options[:class_name]&.constantize || association.singularize.camelize.constantize
+        class_name = reflection_details.options[:class_name]&.constantize || association.singularize.camelize.constantize
         table_name = model.to_s.underscore.pluralize.to_sym
 
-        model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          raise AssociationMissingError.new(missing_in: class_name, association: table_name) unless class_name.reflections.has_key?(table_name.to_s)
+        raise AssociationMissingError.new(missing_in: class_name, association: table_name) unless class_name.reflections.has_key?(table_name.to_s)
 
+        model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
           scope association, -> do
             class_name
               .joins(table_name)
@@ -20,6 +19,12 @@ module AssociationScope
           end
         RUBY
       end
+
+      private
+
+      def reflection_details
+        model.reflections[association]
+      end
     end
   end
 end

data/lib/association_scope/scope/has_many_reflection.rb

@@ -4,14 +4,14 @@ module AssociationScope
   class Scope
     class HasManyReflection < Scope
       def apply
-        details = model.reflections[@association]
-        class_name = details.options[:class_name]&.constantize || association.singularize.camelize.constantize
+        class_name = reflection_details.options[:class_name]&.constantize || association.singularize.camelize.constantize
+
         association = @association.pluralize
         column_name = model.to_s.underscore
 
-        model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          raise AssociationMissingError.new(missing_in: class_name, association: column_name) unless class_name.reflections.has_key?(column_name)
+        raise AssociationMissingError.new(missing_in: class_name, association: column_name) unless class_name.reflections.has_key?(column_name)
 
+        model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
           scope association, -> do
             class_name
               .where(column_name => self)
@@ -19,6 +19,12 @@ module AssociationScope
           end
         RUBY
       end
+
+      private
+
+      def reflection_details
+        model.reflections[@association]
+      end
     end
   end
 end

data/lib/association_scope/scope/has_one_reflection.rb

@@ -3,6 +3,7 @@
 module AssociationScope
   class Scope
     class HasOneReflection < HasManyReflection
+      # works the same way like has_many reflections
     end
   end
 end

data/lib/association_scope/scope/through_reflection.rb

@@ -4,24 +4,14 @@ module AssociationScope
   class Scope
     class ThroughReflection < Scope
       def apply
-        details = model.reflections[@association]
         association = @association
-        class_name = details.options[:class_name]&.constantize || association.singularize.camelize.constantize
+        class_name = reflection_details.options[:class_name]&.constantize || association.singularize.camelize.constantize
+        first_join = inverse_reflection(class_name)&.options&.fetch(:through, nil) || inverse_reflection(class_name)&.options&.fetch(:source, nil)
+        second_join = compute_second_join class_name
 
-        inverse = details.options[:inverse_of]&.to_s || model.to_s.underscore
-        inverse_reflection = class_name.reflections[inverse.singularize] || class_name.reflections[inverse.pluralize]
-
-        first_join = inverse_reflection&.options&.fetch(:through, nil) || inverse_reflection&.options&.fetch(:source, nil)
-
-        reflection_type = inverse_reflection&.source_reflection&.class&.to_s&.split("::")&.last
-        second_join = if %w[HasOneReflection BelongsToReflection].include?(reflection_type)
-          model.to_s.underscore.to_sym
-        else
-          model.to_s.underscore.pluralize.to_sym
-        end
+        raise AssociationMissingError.new missing_in: class_name, association: inverse unless inverse_reflection(class_name)
 
         model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          raise AssociationMissingError.new missing_in: class_name, association: inverse unless inverse_reflection
           scope association.pluralize, -> do
             class_name
               .joins(first_join => second_join)
@@ -29,6 +19,32 @@ module AssociationScope
           end
         RUBY
       end
+
+      private
+
+      def reflection_details
+        model.reflections[association]
+      end
+
+      def inverse
+        reflection_details.options[:inverse_of]&.to_s || model.to_s.underscore
+      end
+
+      def inverse_reflection class_name
+        class_name.reflections[inverse.singularize] || class_name.reflections[inverse.pluralize]
+      end
+
+      def reflection_type class_name
+        inverse_reflection(class_name)&.source_reflection&.class&.to_s&.split("::")&.last
+      end
+
+      def compute_second_join class_name
+        if %w[HasOneReflection BelongsToReflection].include?(reflection_type class_name)
+          model.to_s.underscore.to_sym
+        else
+          model.to_s.underscore.pluralize.to_sym
+        end
+      end
     end
   end
 end

data/lib/association_scope/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AssociationScope
-  VERSION = "0.2.0"
+  VERSION = "0.3.3"
 end

data/lib/association_scope.rb

@@ -15,15 +15,9 @@ end
 
 module ActiveRecord
   class Base
-    def self.acts_as_association_scope(only: reflections.keys, except: [])
-      # Apply given filters.
-      # Don't be picky about singular or plural.
-      raise ArgumentError, "Don't use :only and :except together!" unless only == reflections.keys || except == []
-
-      only = only.map { |o| o.to_s }
-      except = except.map { |e| e.to_s }
-
-      ::AssociationScope::Scope.inject_scopes(self, only - except)
+    def self.has_association_scope_on(models)
+      models = models.map(&:to_s)
+      ::AssociationScope::Scope.inject_scopes(self, models)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: association_scope
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.3
 platform: ruby
 authors:
 - datae
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-06 00:00:00.000000000 Z
+date: 2021-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -100,14 +100,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.6.8
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.2.9
 signing_key: 
 specification_version: 4
 summary: AssociationScope adds useful scopes targeting Associations in ActiveRecord.