hyper-pure-sys 0.0.1

data/bullet-8.1.3/lib/bullet/detector/counter_cache.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+using Bullet::Ext::Object
+
+module Bullet
+  module Detector
+    class CounterCache < Base
+      class << self
+        def add_counter_cache(object, associations)
+          return unless Bullet.start?
+          return unless Bullet.counter_cache_enable?
+          return unless object.bullet_primary_key_value
+
+          Bullet.debug(
+            'Detector::CounterCache#add_counter_cache',
+            "object: #{object.bullet_key}, associations: #{associations}"
+          )
+          create_notification object.class.to_s, associations if conditions_met?(object, associations)
+        end
+
+        def add_possible_objects(object_or_objects)
+          return unless Bullet.start?
+          return unless Bullet.counter_cache_enable?
+
+          objects = Array.wrap(object_or_objects)
+          return if objects.map(&:bullet_primary_key_value).compact.empty?
+
+          Bullet.debug(
+            'Detector::CounterCache#add_possible_objects',
+            "objects: #{objects.map(&:bullet_key).join(', ')}"
+          )
+          objects.each { |object| possible_objects.add object.bullet_key }
+        end
+
+        def add_impossible_object(object)
+          return unless Bullet.start?
+          return unless Bullet.counter_cache_enable?
+          return unless object.bullet_primary_key_value
+
+          Bullet.debug('Detector::CounterCache#add_impossible_object', "object: #{object.bullet_key}")
+          impossible_objects.add object.bullet_key
+        end
+
+        def conditions_met?(object, _associations)
+          possible_objects.include?(object.bullet_key) && !impossible_objects.include?(object.bullet_key)
+        end
+
+        def possible_objects
+          Thread.current.thread_variable_get(:bullet_counter_possible_objects)
+        end
+
+        def impossible_objects
+          Thread.current.thread_variable_get(:bullet_counter_impossible_objects)
+        end
+
+        private
+
+        def create_notification(klazz, associations)
+          notify_associations = Array.wrap(associations) - Bullet.get_safelist_associations(:counter_cache, klazz)
+
+          if notify_associations.present?
+            notice = Bullet::Notification::CounterCache.new klazz, notify_associations
+            Bullet.notification_collector.add notice
+          end
+        end
+      end
+    end
+  end
+end

data/bullet-8.1.3/lib/bullet/detector/n_plus_one_query.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+using Bullet::Ext::Object
+
+module Bullet
+  module Detector
+    class NPlusOneQuery < Association
+      extend Dependency
+      extend StackTraceFilter
+
+      class << self
+        # executed when object.associations is called.
+        # first, it keeps this method call for object.association.
+        # then, it checks if this associations call is unpreload.
+        #   if it is, keeps this unpreload associations and caller.
+        def call_association(object, associations, caller_stack = nil, inversed: false)
+          return unless Bullet.start?
+          return unless Bullet.n_plus_one_query_enable?
+          return unless object.bullet_primary_key_value
+
+          # Record before early-returns so legitimate reads that bypass SQL
+          # (inversed, nil-polymorphic) aren't flagged as unused preloads.
+          add_call_object_associations(object, associations)
+          call_stacks.add(object.bullet_key, caller_stack) if caller_stack
+
+          return if inversed
+          return if inversed_objects.include?(object.bullet_key, associations)
+          return if optional_polymorphic_belongs_to_with_nil_type?(object, associations)
+
+          Bullet.debug(
+            'Detector::NPlusOneQuery#call_association',
+            "object: #{object.bullet_key}, associations: #{associations}"
+          )
+          if !excluded_stacktrace_path? && conditions_met?(object, associations)
+            Bullet.debug('detect n + 1 query', "object: #{object.bullet_key}, associations: #{associations}")
+            create_notification(caller_in_project(object.bullet_key), object.class.to_s, associations)
+          end
+        end
+
+        def add_possible_objects(object_or_objects)
+          return unless Bullet.start?
+          return unless Bullet.n_plus_one_query_enable?
+
+          objects = Array.wrap(object_or_objects)
+          class_names_match_regex = true
+          primary_key_values_are_empty = true
+
+          keys_joined = objects.map do |obj|
+            unless obj.class.name =~ /^HABTM_/
+              class_names_match_regex = false
+            end
+            unless obj.bullet_primary_key_value.nil?
+              primary_key_values_are_empty = false
+            end
+            obj.bullet_key
+          end.join(", ")
+
+          unless class_names_match_regex || primary_key_values_are_empty
+            Bullet.debug('Detector::NPlusOneQuery#add_possible_objects', "objects: #{keys_joined}")
+            objects.each { |object| possible_objects.add object.bullet_key }
+          end
+        end
+
+        def add_impossible_object(object)
+          return unless Bullet.start?
+          return unless Bullet.n_plus_one_query_enable?
+          return unless object.bullet_primary_key_value
+
+          Bullet.debug('Detector::NPlusOneQuery#add_impossible_object', "object: #{object.bullet_key}")
+          impossible_objects.add object.bullet_key
+        end
+
+        def add_inversed_object(object, association)
+          return unless Bullet.start?
+          return unless Bullet.n_plus_one_query_enable?
+
+          object_key = object.bullet_primary_key_value ? object.bullet_key : object.object_id
+          Bullet.debug(
+            'Detector::NPlusOneQuery#add_inversed_object',
+            "object: #{object_key}, association: #{association}"
+          )
+          inversed_objects.add object_key, association
+        end
+
+        def update_inversed_object(object)
+          if inversed_objects&.key?(object.object_id)
+            Bullet.debug(
+              'Detector::NPlusOneQuery#update_inversed_object',
+              "object from #{object.object_id} to #{object.bullet_key}"
+            )
+            inversed_objects.add(object.bullet_key, inversed_objects[object.object_id].to_a)
+          end
+        end
+
+        # decide whether the object.associations is unpreloaded or not.
+        def conditions_met?(object, associations)
+          possible?(object) && !impossible?(object) && !association?(object, associations)
+        end
+
+        def possible?(object)
+          possible_objects.include? object.bullet_key
+        end
+
+        def impossible?(object)
+          impossible_objects.include? object.bullet_key
+        end
+
+        # check if object => associations already exists in object_associations.
+        def association?(object, associations)
+          value = object_associations[object.bullet_key]
+          value&.each do |v|
+            # associations == v comparison order is important here because
+            # v variable might be a squeel node where :== method is redefined,
+            # so it does not compare values at all and return unexpected results
+            result = v.is_a?(Hash) ? v.key?(associations) : associations == v
+            return true if result
+          end
+
+          false
+        end
+
+        private
+
+        def optional_polymorphic_belongs_to_with_nil_type?(object, associations)
+          return false unless associations.is_a?(Symbol) || associations.is_a?(String)
+          return false unless object.class.respond_to?(:reflect_on_association)
+
+          reflection = object.class.reflect_on_association(associations.to_sym)
+          return false unless reflection
+          return false unless reflection.respond_to?(:polymorphic?) && reflection.polymorphic?
+          return false unless reflection.respond_to?(:foreign_type)
+
+          foreign_type = reflection.foreign_type
+          foreign_type && object.respond_to?(:[]) && object[foreign_type].nil?
+        end
+
+        def create_notification(callers, klazz, associations)
+          notify_associations = Array.wrap(associations) - Bullet.get_safelist_associations(:n_plus_one_query, klazz)
+
+          if notify_associations.present?
+            notice = Bullet::Notification::NPlusOneQuery.new(callers, klazz, notify_associations)
+            Bullet.notification_collector.add(notice)
+          end
+        end
+      end
+    end
+  end
+end

data/bullet-8.1.3/lib/bullet/detector/unused_eager_loading.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+using Bullet::Ext::Object
+using Bullet::Ext::String
+
+module Bullet
+  module Detector
+    class UnusedEagerLoading < Association
+      extend Dependency
+      extend StackTraceFilter
+
+      class << self
+        # check if there are unused preload associations.
+        #   get related_objects from eager_loadings associated with object and associations
+        #   get call_object_association from associations of call_object_associations whose object is in related_objects
+        #   if association not in call_object_association, then the object => association - call_object_association is unused preload associations
+        def check_unused_preload_associations
+          return unless Bullet.start?
+          return unless Bullet.unused_eager_loading_enable?
+
+          object_associations.each do |bullet_key, associations|
+            object_association_diff = diff_object_associations bullet_key, associations
+            next if object_association_diff.empty?
+
+            Bullet.debug('detect unused preload', "object: #{bullet_key}, associations: #{object_association_diff}")
+            create_notification(caller_in_project(bullet_key), bullet_key.bullet_class_name, object_association_diff)
+          end
+        end
+
+        def add_eager_loadings(objects, associations)
+          return unless Bullet.start?
+          return unless Bullet.unused_eager_loading_enable?
+          return if objects.map(&:bullet_primary_key_value).compact.empty?
+
+          Bullet.debug(
+            'Detector::UnusedEagerLoading#add_eager_loadings',
+            "objects: #{objects.map(&:bullet_key).join(', ')}, associations: #{associations}"
+          )
+          bullet_keys = objects.map(&:bullet_key)
+
+          to_add = []
+          to_merge = []
+          to_delete = []
+          eager_loadings.each do |k, _v|
+            key_objects_overlap = k & bullet_keys
+
+            next if key_objects_overlap.empty?
+
+            bullet_keys -= k
+            if key_objects_overlap == k
+              to_add << [k, associations]
+            else
+              to_merge << [key_objects_overlap, eager_loadings[k].dup.merge(Array.wrap(associations))]
+
+              keys_without_objects = k - key_objects_overlap
+              to_merge << [keys_without_objects, eager_loadings[k]]
+              to_delete << k
+            end
+          end
+
+          to_add.each { |k, val| eager_loadings.add k, val }
+          to_merge.each { |k, val| eager_loadings.merge k, val }
+          to_delete.each { |k| eager_loadings.delete k }
+
+          eager_loadings.add bullet_keys, associations unless bullet_keys.empty?
+        end
+
+        private
+
+        def create_notification(callers, klazz, associations)
+          notify_associations = Array.wrap(associations) - Bullet.get_safelist_associations(
+            :unused_eager_loading,
+            klazz
+          )
+
+          if notify_associations.present?
+            notice = Bullet::Notification::UnusedEagerLoading.new(callers, klazz, notify_associations)
+            Bullet.notification_collector.add(notice)
+          end
+        end
+
+        def call_associations(bullet_key, associations)
+          all = Set.new
+          eager_loadings.similarly_associated(bullet_key, associations).each do |related_bullet_key|
+            coa = call_object_associations[related_bullet_key]
+            next if coa.nil?
+
+            all.merge coa
+          end
+          all.to_a
+        end
+
+        def diff_object_associations(bullet_key, associations)
+          potential_associations = associations - call_associations(bullet_key, associations)
+          potential_associations.reject { |a| a.is_a?(Hash) }
+        end
+      end
+    end
+  end
+end

data/bullet-8.1.3/lib/bullet/detector.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Bullet
+  module Detector
+    autoload :Base, 'bullet/detector/base'
+    autoload :Association, 'bullet/detector/association'
+    autoload :NPlusOneQuery, 'bullet/detector/n_plus_one_query'
+    autoload :UnusedEagerLoading, 'bullet/detector/unused_eager_loading'
+    autoload :CounterCache, 'bullet/detector/counter_cache'
+  end
+end

data/bullet-8.1.3/lib/bullet/ext/object.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Bullet
+  module Ext
+    module Object
+      refine ::Object do
+        attr_writer :bullet_key, :bullet_primary_key_value
+
+        def bullet_key
+          return "#{self.class}:" if respond_to?(:persisted?) && !persisted?
+
+          @bullet_key ||= "#{self.class}:#{bullet_primary_key_value}"
+        end
+
+        def bullet_primary_key_value
+          return if respond_to?(:persisted?) && !persisted?
+
+          @bullet_primary_key_value ||=
+            begin
+              primary_key = self.class.try(:primary_keys) || self.class.try(:primary_key) || :id
+
+              bullet_join_potential_composite_primary_key(primary_key)
+            end
+        end
+
+        private
+
+        def bullet_join_potential_composite_primary_key(primary_keys)
+          return read_attribute(primary_keys) unless primary_keys.is_a?(Enumerable)
+
+          primary_keys.map { |primary_key| read_attribute primary_key }
+                      .compact.join(',')
+        end
+      end
+    end
+  end
+end

data/bullet-8.1.3/lib/bullet/ext/string.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Bullet
+  module Ext
+    module String
+      refine ::String do
+        def bullet_class_name
+          last_colon = self.rindex(':')
+          last_colon ? self[0...last_colon].dup : self.dup
+        end
+      end
+    end
+  end
+end

data/bullet-8.1.3/lib/bullet/mongoid4x.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Bullet
+  module Mongoid
+    def self.enable
+      require 'mongoid'
+      ::Mongoid::Contextual::Mongo.class_eval do
+        alias_method :origin_first, :first
+        alias_method :origin_last, :last
+        alias_method :origin_each, :each
+        alias_method :origin_eager_load, :eager_load
+
+        def first
+          result = origin_first
+          Bullet::Detector::NPlusOneQuery.add_impossible_object(result) if result
+          result
+        end
+
+        def last
+          result = origin_last
+          Bullet::Detector::NPlusOneQuery.add_impossible_object(result) if result
+          result
+        end
+
+        def each(&block)
+          return to_enum unless block
+
+          records = []
+          origin_each { |record| records << record }
+          if records.length > 1
+            Bullet::Detector::NPlusOneQuery.add_possible_objects(records)
+          elsif records.size == 1
+            Bullet::Detector::NPlusOneQuery.add_impossible_object(records.first)
+          end
+          records.each(&block)
+        end
+
+        def eager_load(docs)
+          associations = criteria.inclusions.map(&:name)
+          docs.each { |doc| Bullet::Detector::NPlusOneQuery.add_object_associations(doc, associations) }
+          Bullet::Detector::UnusedEagerLoading.add_eager_loadings(docs, associations)
+          origin_eager_load(docs)
+        end
+      end
+
+      ::Mongoid::Relations::Accessors.class_eval do
+        alias_method :origin_get_relation, :get_relation
+
+        private
+
+        def get_relation(name, metadata, object, reload = false)
+          result = origin_get_relation(name, metadata, object, reload)
+          Bullet::Detector::NPlusOneQuery.call_association(self, name) if metadata.macro !~ /embed/
+          result
+        end
+      end
+    end
+  end
+end

data/bullet-8.1.3/lib/bullet/mongoid5x.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Bullet
+  module Mongoid
+    def self.enable
+      require 'mongoid'
+      ::Mongoid::Contextual::Mongo.class_eval do
+        alias_method :origin_first, :first
+        alias_method :origin_last, :last
+        alias_method :origin_each, :each
+        alias_method :origin_eager_load, :eager_load
+
+        def first
+          result = origin_first
+          Bullet::Detector::NPlusOneQuery.add_impossible_object(result) if result
+          result
+        end
+
+        def last
+          result = origin_last
+          Bullet::Detector::NPlusOneQuery.add_impossible_object(result) if result
+          result
+        end
+
+        def each(&block)
+          return to_enum unless block
+
+          records = []
+          origin_each { |record| records << record }
+          if records.length > 1
+            Bullet::Detector::NPlusOneQuery.add_possible_objects(records)
+          elsif records.size == 1
+            Bullet::Detector::NPlusOneQuery.add_impossible_object(records.first)
+          end
+          records.each(&block)
+        end
+
+        def eager_load(docs)
+          associations = criteria.inclusions.map(&:name)
+          docs.each { |doc| Bullet::Detector::NPlusOneQuery.add_object_associations(doc, associations) }
+          Bullet::Detector::UnusedEagerLoading.add_eager_loadings(docs, associations)
+          origin_eager_load(docs)
+        end
+      end
+
+      ::Mongoid::Relations::Accessors.class_eval do
+        alias_method :origin_get_relation, :get_relation
+
+        private
+
+        def get_relation(name, metadata, object, reload = false)
+          result = origin_get_relation(name, metadata, object, reload)
+          Bullet::Detector::NPlusOneQuery.call_association(self, name) if metadata.macro !~ /embed/
+          result
+        end
+      end
+    end
+  end
+end

data/bullet-8.1.3/lib/bullet/mongoid6x.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Bullet
+  module Mongoid
+    def self.enable
+      require 'mongoid'
+      ::Mongoid::Contextual::Mongo.class_eval do
+        alias_method :origin_first, :first
+        alias_method :origin_last, :last
+        alias_method :origin_each, :each
+        alias_method :origin_eager_load, :eager_load
+
+        def first(opt = {})
+          result = origin_first(opt)
+          Bullet::Detector::NPlusOneQuery.add_impossible_object(result) if result
+          result
+        end
+
+        def last(opt = {})
+          result = origin_last(opt)
+          Bullet::Detector::NPlusOneQuery.add_impossible_object(result) if result
+          result
+        end
+
+        def each(&block)
+          return to_enum unless block
+
+          records = []
+          origin_each { |record| records << record }
+          if records.length > 1
+            Bullet::Detector::NPlusOneQuery.add_possible_objects(records)
+          elsif records.size == 1
+            Bullet::Detector::NPlusOneQuery.add_impossible_object(records.first)
+          end
+          records.each(&block)
+        end
+
+        def eager_load(docs)
+          associations = criteria.inclusions.map(&:name)
+          docs.each { |doc| Bullet::Detector::NPlusOneQuery.add_object_associations(doc, associations) }
+          Bullet::Detector::UnusedEagerLoading.add_eager_loadings(docs, associations)
+          origin_eager_load(docs)
+        end
+      end
+
+      ::Mongoid::Relations::Accessors.class_eval do
+        alias_method :origin_get_relation, :get_relation
+
+        private
+
+        def get_relation(name, metadata, object, reload = false)
+          result = origin_get_relation(name, metadata, object, reload)
+          Bullet::Detector::NPlusOneQuery.call_association(self, name) if metadata.macro !~ /embed/
+          result
+        end
+      end
+    end
+  end
+end

data/bullet-8.1.3/lib/bullet/mongoid7x.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Bullet
+  module Mongoid
+    def self.enable
+      require 'mongoid'
+      require 'rubygems'
+      ::Mongoid::Contextual::Mongo.class_eval do
+        alias_method :origin_first, :first
+        alias_method :origin_last, :last
+        alias_method :origin_each, :each
+        alias_method :origin_eager_load, :eager_load
+
+        %i[first last].each do |context|
+          default = Gem::Version.new(::Mongoid::VERSION) >= Gem::Version.new('7.5') ? nil : {}
+          define_method(context) do |opts = default|
+            result = send(:"origin_#{context}", opts)
+            Bullet::Detector::NPlusOneQuery.add_impossible_object(result) if result
+            result
+          end
+        end
+
+        def each(&block)
+          return to_enum unless block_given?
+
+          first_document = nil
+          document_count = 0
+
+          origin_each do |document|
+            document_count += 1
+
+            if document_count == 1
+              first_document = document
+            elsif document_count == 2
+              Bullet::Detector::NPlusOneQuery.add_possible_objects([first_document, document])
+              yield(first_document)
+              first_document = nil
+              yield(document)
+            else
+              Bullet::Detector::NPlusOneQuery.add_possible_objects(document)
+              yield(document)
+            end
+          end
+
+          if document_count == 1
+            Bullet::Detector::NPlusOneQuery.add_impossible_object(first_document)
+            yield(first_document)
+          end
+
+          self
+        end
+
+        def eager_load(docs)
+          associations = criteria.inclusions.map(&:name)
+          docs.each { |doc| Bullet::Detector::NPlusOneQuery.add_object_associations(doc, associations) }
+          Bullet::Detector::UnusedEagerLoading.add_eager_loadings(docs, associations)
+          origin_eager_load(docs)
+        end
+      end
+
+      ::Mongoid::Association::Accessors.class_eval do
+        alias_method :origin_get_relation, :get_relation
+
+        private
+
+        def get_relation(name, association, object, reload = false)
+          result = origin_get_relation(name, association, object, reload)
+          Bullet::Detector::NPlusOneQuery.call_association(self, name) unless association.embedded?
+          result
+        end
+      end
+    end
+  end
+end