hyper-pure-sys 0.0.1

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

@@ -0,0 +1,61 @@
+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(limit = nil)
+          result = origin_first(limit)
+          Bullet::Detector::NPlusOneQuery.add_impossible_object(result) if result
+          result
+        end
+
+        def last(limit = nil)
+          result = origin_last(limit)
+          Bullet::Detector::NPlusOneQuery.add_impossible_object(result) if result
+          result
+        end
+
+        def each(&block)
+          return to_enum unless block_given?
+
+          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 do |doc|
+            Bullet::Detector::NPlusOneQuery.add_object_associations(doc, associations)
+          end
+          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)
+          unless association.embedded?
+            Bullet::Detector::NPlusOneQuery.call_association(self, name)
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/bullet-8.1.3/lib/bullet/mongoid9x.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

data/bullet-8.1.3/lib/bullet/notification/base.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Bullet
+  module Notification
+    class Base
+      attr_accessor :notifier, :url
+      attr_reader :base_class, :associations, :path
+
+      def initialize(base_class, association_or_associations, path = nil)
+        @base_class = base_class
+        @associations =
+          association_or_associations.is_a?(Array) ? association_or_associations : [association_or_associations]
+        @path = path
+      end
+
+      def title
+        raise NoMethodError, 'no method title defined'
+      end
+
+      def body
+        raise NoMethodError, 'no method body defined'
+      end
+
+      def call_stack_messages
+        ''
+      end
+
+      def whoami
+        @user ||=
+          ENV['USER'].presence ||
+          (
+            begin
+              `whoami`.chomp
+            rescue StandardError
+              ''
+            end
+          )
+        @user.present? ? "user: #{@user}" : ''
+      end
+
+      def body_with_caller
+        "#{body}\n#{call_stack_messages}\n"
+      end
+
+      def notify_inline
+        notifier.inline_notify(notification_data)
+      end
+
+      def notify_out_of_channel
+        notifier.out_of_channel_notify(notification_data)
+      end
+
+      def short_notice
+        parts = []
+        parts << whoami.presence unless Bullet.skip_user_in_notification
+        parts << url
+        parts << title
+        parts << body
+
+        parts.compact.join('  ')
+      end
+
+      def notification_data
+        hash = {}
+        hash[:user] = whoami unless Bullet.skip_user_in_notification
+        hash[:url] = url
+        hash[:title] = title
+        hash[:body] = body_with_caller
+        hash
+      end
+
+      def eql?(other)
+        self.class == other.class && klazz_associations_str == other.klazz_associations_str
+      end
+
+      def hash
+        [self.class, klazz_associations_str].hash
+      end
+
+      protected
+
+      def klazz_associations_str
+        "  #{@base_class} => [#{@associations.map(&:inspect).join(', ')}]"
+      end
+
+      def associations_str
+        ".includes(#{@associations.map { |a| a.to_s.to_sym }
+.inspect})"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Bullet
+  module Notification
+    class CounterCache < Base
+      def body
+        klazz_associations_str
+      end
+
+      def title
+        'Need Counter Cache with Active Record size'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Bullet
+  module Notification
+    class NPlusOneQuery < Base
+      def initialize(callers, base_class, associations, path = nil)
+        super(base_class, associations, path)
+
+        @callers = callers
+      end
+
+      def body
+        "#{klazz_associations_str}\n  Add to your query: #{associations_str}"
+      end
+
+      def title
+        "USE eager loading #{@path ? "in #{@path}" : 'detected'}"
+      end
+
+      def notification_data
+        super.merge(backtrace: [])
+      end
+
+      protected
+
+      def call_stack_messages
+        (['Call stack'] + @callers).join("\n  ")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Bullet
+  module Notification
+    class UnusedEagerLoading < Base
+      def initialize(callers, base_class, associations, path = nil)
+        super(base_class, associations, path)
+
+        @callers = callers
+      end
+
+      def body
+        "#{klazz_associations_str}\n  Remove from your query: #{associations_str}"
+      end
+
+      def title
+        "AVOID eager loading #{@path ? "in #{@path}" : 'detected'}"
+      end
+
+      def notification_data
+        super.merge(backtrace: [])
+      end
+
+      protected
+
+      def call_stack_messages
+        (['Call stack'] + @callers).join("\n  ")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Bullet
+  module Notification
+    autoload :Base, 'bullet/notification/base'
+    autoload :UnusedEagerLoading, 'bullet/notification/unused_eager_loading'
+    autoload :NPlusOneQuery, 'bullet/notification/n_plus_one_query'
+    autoload :CounterCache, 'bullet/notification/counter_cache'
+
+    class UnoptimizedQueryError < StandardError
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Bullet
+  class NotificationCollector
+    attr_reader :collection
+
+    def initialize
+      reset
+    end
+
+    def reset
+      @collection = Set.new
+    end
+
+    def add(value)
+      @collection << value
+    end
+
+    def notifications_present?
+      !@collection.empty?
+    end
+  end
+end

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

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require 'rack/request'
+require 'json'
+require 'cgi'
+
+module Bullet
+  class Rack
+    include Dependency
+
+    NONCE_MATCHER = /(script|style)-src .*'nonce-(?<nonce>[A-Za-z0-9+\/]+={0,2})'/
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      return @app.call(env) unless Bullet.enable?
+
+      Bullet.start_request
+      status, headers, response = @app.call(env)
+
+      response_body = nil
+
+      if Bullet.notification? || Bullet.always_append_html_body
+        request = ::Rack::Request.new(env)
+        if Bullet.inject_into_page? && !skip_html_injection?(request) && !file?(headers) && !sse?(headers) && !empty?(response) && status == 200
+          if html_request?(headers, response)
+            response_body = response_body(response)
+
+            with_security_policy_nonce(headers) do |nonce|
+              response_body = append_to_html_body(response_body, footer_note(nonce)) if Bullet.add_footer
+              response_body = append_to_html_body(response_body, Bullet.gather_inline_notifications)
+              if Bullet.add_footer && !Bullet.skip_http_headers
+                response_body = append_to_html_body(response_body, xhr_script(nonce))
+              end
+            end
+
+            headers['Content-Length'] = response_body.bytesize.to_s
+          elsif !Bullet.skip_http_headers
+            set_header(headers, 'X-bullet-footer-text', Bullet.footer_info.uniq) if Bullet.add_footer
+            set_header(headers, 'X-bullet-console-text', Bullet.text_notifications) if Bullet.console_enabled?
+          end
+        end
+        Bullet.perform_out_of_channel_notifications(env)
+      end
+      [status, headers, response_body ? [response_body] : response]
+    ensure
+      Bullet.end_request
+    end
+
+    # fix issue if response's body is a Proc
+    def empty?(response)
+      # response may be ["Not Found"], ["Move Permanently"], etc, but
+      # those should not happen if the status is 200
+      return true if !response.respond_to?(:body) && !response.respond_to?(:first)
+
+      body = response_body(response)
+      body.nil? || body.empty?
+    end
+
+    def append_to_html_body(response_body, content)
+      body = response_body.dup
+      content = content.html_safe if content.respond_to?(:html_safe)
+      if body.include?('</body>')
+        position = body.rindex('</body>')
+        body.insert(position, content)
+      else
+        body << content
+      end
+    end
+
+    def footer_note(nonce = nil)
+      %(<details id="bullet-footer" data-is-bullet-footer><summary>Bullet Warnings</summary><div>#{Bullet.footer_info.uniq.join('<br>')}#{footer_console_message(nonce)}</div>#{footer_style(nonce)}</details>)
+    end
+
+    # Make footer styles work with ContentSecurityPolicy style-src as self
+    def footer_style(nonce = nil)
+      css = <<~CSS
+        details#bullet-footer {cursor: pointer; position: fixed; left: 0px; bottom: 0px; z-index: 9999; background: #fdf2f2; color: #9b1c1c; font-size: 12px; border-radius: 0px 8px 0px 0px; border: 1px solid #9b1c1c;}
+        details#bullet-footer summary {font-weight: 600; padding: 2px 8px;}
+        details#bullet-footer div {padding: 8px; border-top: 1px solid #9b1c1c;}
+      CSS
+      if nonce
+        %(<style type="text/css" nonce="#{nonce}">#{css}</style>)
+      else
+        %(<style type="text/css">#{css}</style>)
+      end
+    end
+
+    def set_header(headers, header_name, header_array)
+      # Many proxy applications such as Nginx and AWS ELB limit
+      # the size a header to 8KB, so truncate the list of reports to
+      # be under that limit
+      header_array.pop while JSON.generate(header_array).length > 8 * 1024
+      headers[header_name] = JSON.generate(header_array)
+    end
+
+    def skip_html_injection?(request)
+      query_string = request.env['QUERY_STRING']
+      return false if query_string.nil? || query_string.empty?
+
+      params = simple_parse_query_string(query_string)
+      params['skip_html_injection'] == 'true'
+    end
+
+    # Simple query string parser
+    def simple_parse_query_string(query_string)
+      params = {}
+      query_string.split('&').each do |pair|
+        key, value = pair.split('=', 2).map { |s| CGI.unescape(s) }
+        params[key] = value if key && !key.empty?
+      end
+      params
+    end
+
+    def file?(headers)
+      headers['Content-Transfer-Encoding'] == 'binary' || headers['Content-Disposition']
+    end
+
+    def sse?(headers)
+      headers['Content-Type'] == 'text/event-stream'
+    end
+
+    def html_request?(headers, response)
+      headers['Content-Type']&.include?('text/html')
+    end
+
+    def response_body(response)
+      if response.respond_to?(:body)
+        Array === response.body ? response.body.first : response.body
+      elsif response.respond_to?(:first)
+        response.first
+      end
+    end
+
+    private
+
+    def footer_console_message(nonce = nil)
+      if Bullet.console_enabled?
+        footer = %(<br/><span id="console-message">See 'Uniform Notifier' in JS Console for Stacktrace</span>)
+        css = "details#bullet-footer #console-message {font-style: italic;}"
+        style =
+          if nonce
+            %(<style type="text/css" nonce="#{nonce}">#{css}</style>)
+          else
+            %(<style type="text/css">#{css}</style>)
+          end
+
+        footer + style
+      end
+    end
+
+    # Make footer work for XHR requests by appending data to the footer
+    def xhr_script(nonce = nil)
+      script = File.read("#{__dir__}/bullet_xhr.js")
+
+      if nonce
+        "<script type='text/javascript' nonce='#{nonce}'>#{script}</script>"
+      else
+        "<script type='text/javascript'>#{script}</script>"
+      end
+    end
+
+    def with_security_policy_nonce(headers)
+      csp = headers['Content-Security-Policy'] || headers['Content-Security-Policy-Report-Only'] || ''
+      matched = csp.match(NONCE_MATCHER)
+      nonce = matched[:nonce] if matched
+
+      if nonce
+        console_enabled = UniformNotifier.console
+        alert_enabled = UniformNotifier.alert
+
+        UniformNotifier.console = { attributes: { nonce: nonce } } if console_enabled
+        UniformNotifier.alert = { attributes: { nonce: nonce } } if alert_enabled
+
+        yield nonce
+
+        UniformNotifier.console = console_enabled
+        UniformNotifier.alert = alert_enabled
+      else
+        yield
+      end
+    end
+  end
+end

data/bullet-8.1.3/lib/bullet/registry/association.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Bullet
+  module Registry
+    class Association < Base
+      def merge(base, associations)
+        @registry.merge!(base => associations)
+      end
+
+      def similarly_associated(base, associations)
+        @registry.select { |key, value| key.include?(base) && value == associations }
+                 .collect(&:first).flatten
+      end
+    end
+  end
+end

data/bullet-8.1.3/lib/bullet/registry/base.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Bullet
+  module Registry
+    class Base
+      attr_reader :registry
+
+      def initialize
+        @registry = {}
+      end
+
+      def [](key)
+        @registry[key]
+      end
+
+      def each(&block)
+        @registry.each(&block)
+      end
+
+      def delete(base)
+        @registry.delete(base)
+      end
+
+      def select(*args, &block)
+        @registry.select(*args, &block)
+      end
+
+      def add(key, value)
+        @registry[key] ||= Set.new
+        if value.is_a? Array
+          @registry[key] += value
+        else
+          @registry[key] << value
+        end
+      end
+
+      def include?(key, value)
+        key?(key) && @registry[key].include?(value)
+      end
+
+      def key?(key)
+        @registry.key?(key)
+      end
+    end
+  end
+end

data/bullet-8.1.3/lib/bullet/registry/call_stack.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Bullet
+  module Registry
+    class CallStack < Base
+      # remembers found association backtrace
+      # if backtrace is provided, it will be used and override any existing value
+      def add(key, backtrace = nil)
+        if backtrace
+          @registry[key] = backtrace
+        else
+          @registry[key] ||= Thread.current.backtrace
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+using Bullet::Ext::Object
+using Bullet::Ext::String
+
+module Bullet
+  module Registry
+    class Object < Base
+      def add(bullet_key)
+        super(bullet_key.bullet_class_name, bullet_key)
+      end
+
+      def include?(bullet_key)
+        super(bullet_key.bullet_class_name, bullet_key)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Bullet
+  module Registry
+    autoload :Base, 'bullet/registry/base'
+    autoload :Object, 'bullet/registry/object'
+    autoload :Association, 'bullet/registry/association'
+    autoload :CallStack, 'bullet/registry/call_stack'
+  end
+end