strict-loading 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a2e19110075e341793904808b1faf3c6409d44f8bb4ac546810867cafc8ab3ea
+  data.tar.gz: d3afb64736eae88dd4c0676b3aff34a6e29139d1cf2bebc384cc274f98f9b565
+SHA512:
+  metadata.gz: 5e59b8a982935eecbd347f2525a40d6aaf1c61eafd33060f050a38220d9249bf0e3645f3dd0e9a2302761fc8c092d13f7354b0071faa6d77e77ff77aa0032ee0
+  data.tar.gz: 4f04540ffe96ea74815953716a3cd1e2cb01a5633fd8947bc2e8aa764d653155499825ffb1671d90b8bb39da2e846271793d190620ceedc0070bea07df4f8fc9

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+## 1.0.0
+* Birthday

data/Gemfile

@@ -0,0 +1,22 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "concurrent-ruby", "< 1.3.5"
+
+group :development, :test do
+  gem "rake"
+end
+
+group :development do
+  gem "appraisal"
+  gem "appraisal-run", "~> 1.0"
+  gem "pry-byebug"
+end
+
+group :test do
+  gem "combustion"
+  gem "database_cleaner"
+  gem "rspec-rails"
+  gem "sqlite3"
+end

data/README.md

@@ -0,0 +1,41 @@
+# strict-loading
+
+Backport of Rails 6.1's [strict loading](https://guides.rubyonrails.org/active_record_querying.html#strict-loading) feature for earlier versions of Rails.
+
+## Usage
+
+Add this line to your Gemfile:
+
+```ruby
+gem "strict-loading"
+```
+
+Then execute:
+```ruby
+bundle install
+```
+
+This backport is designed to mimic the Rails 6.1 feature in both behavior and API (although it is currently not a complete implementation). Please see the official Rails [documentation](https://guides.rubyonrails.org/active_record_querying.html#strict-loading) for additional usage information.
+
+### Violation Modes
+
+Strict loading can report violations in two ways:
+
+1. `:raise`: Violations will raise errors indicating which association on which model was accessed.
+2. `:log`: Violations use the `ActiveSupport::Notifications` system and log violation messages under the notification name `strict_loading_violation.active_record`.
+
+The default violation mode is `:raise`. To set the violation mode, add the following line to application.rb or one of your environments (eg. config/development.rb):
+
+```ruby
+config.active_record.action_on_strict_loading_violation = :log
+```
+
+Setting up a subscriber to listen for violations can be done like so:
+
+```ruby
+ActiveSupport::Notifications.subscribe("strict_loading_violation.active_record") do |name, start, finish, id, payload|
+  # payload is a hash of the form { reflection:, owner: } where the reflection is the
+  # association, eg. ActiveRecord::Reflection::HasManyReflection, and `owner:` is the
+  # ActiveRecord model class.
+end
+```

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler"
+require "rspec/core/rake_task"
+require "rubygems/package_task"
+
+Bundler::GemHelper.install_tasks
+
+task default: :spec
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "./spec/**/*_spec.rb"
+end

data/lib/strict-loading/abstract_reflection.rb

@@ -0,0 +1,9 @@
+module StrictLoading
+  module AbstractReflection
+    def strict_loading_violation_message(owner)
+      message = "`#{owner}` is marked for strict_loading."
+      message << " The #{polymorphic? ? "polymorphic association" : "#{klass} association"}"
+      message << " named `:#{name}` cannot be lazily loaded."
+    end
+  end
+end

data/lib/strict-loading/association.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module StrictLoading
+  module Association
+    private
+
+    def find_target
+      if violates_strict_loading?
+        ::ActiveRecord::Base.strict_loading_violation!(owner: owner.class, reflection: reflection)
+      end
+
+      super
+    end
+
+    def violates_strict_loading?
+      return unless owner.validation_context.nil?
+      owner.strict_loading?
+    end
+  end
+end

data/lib/strict-loading/core.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module StrictLoading
+  module Core
+    def self.included(base)
+      base.include(InstanceMethods)
+      base.extend(ClassMethods)
+
+      base.delegate :strict_loading, to: :all
+      base.mattr_accessor(:action_on_strict_loading_violation, instance_writer: false)
+      base.action_on_strict_loading_violation = :raise
+    end
+
+    module InstanceMethods
+      def strict_loading!
+        @strict_loading = true
+      end
+
+      def strict_loading?
+        @strict_loading
+      end
+
+      def strict_loading #(value = true)
+        spawn.strict_loading! #(value)
+      end
+    end
+
+    module ClassMethods
+      delegate :strict_loading, to: :all
+
+      def strict_loading_violation!(owner:, reflection:)
+        case ActiveRecord::Base.action_on_strict_loading_violation
+        when :raise
+          message = reflection.strict_loading_violation_message(owner)
+          raise ActiveRecord::StrictLoadingViolationError.new(message)
+        when :log
+          name = "strict_loading_violation.active_record"
+          ActiveSupport::Notifications.instrument(name, owner: owner, reflection: reflection)
+        end
+      end
+    end
+  end
+end

data/lib/strict-loading/query_methods.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module StrictLoading
+  module QueryMethods
+    def strict_loading
+      spawn.strict_loading!
+    end
+
+    def strict_loading!
+      self.strict_loading_value = true
+      self
+    end
+
+    def strict_loading_value
+      @values.fetch(:strict_loading, nil)
+    end
+
+    def strict_loading_value=(value)
+      raise ImmutableRelation if @loaded
+      __check_relation
+      @values[:strict_loading] = value
+    end
+
+    if ActiveRecord::VERSION::STRING >= "5.0"
+      def __check_relation
+        assert_mutability!
+      end
+    else
+      def __check_relation
+        check_cached_relation
+      end
+    end
+  end
+end

data/lib/strict-loading/railtie.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module StrictLoading
+  class Railtie < Rails::Railtie
+    initializer "strict_loading.initialize" do
+      ActiveSupport.on_load(:active_record) do
+        ::ActiveRecord::Relation.prepend(::StrictLoading::Relation)
+        ::ActiveRecord::Relation.include(::StrictLoading::QueryMethods)
+        ::ActiveRecord::Associations::HasManyAssociation.prepend(::StrictLoading::Association)
+        ::ActiveRecord::Associations::SingularAssociation.prepend(::StrictLoading::Association)
+        ::ActiveRecord::Associations::HasManyThroughAssociation.prepend(::StrictLoading::Association)
+        ::ActiveRecord::Associations::CollectionAssociation.prepend(::StrictLoading::Association)
+        ::ActiveRecord::Reflection::AbstractReflection.include(::StrictLoading::AbstractReflection)
+
+        if (action = Rails.application.config.active_record.action_on_strict_loading_violation)
+          self.action_on_strict_loading_violation = action
+        end
+      end
+    end
+  end
+end

data/lib/strict-loading/relation.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module StrictLoading
+  module Relation
+    private
+
+    def exec_queries
+      super.tap do |records|
+        unless strict_loading_value.nil?
+          records.each do |record|
+            record.strict_loading!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/strict-loading/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module StrictLoading
+  VERSION = "1.0.0"
+end

data/lib/strict-loading.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module StrictLoading
+  autoload :AbstractReflection, "strict-loading/abstract_reflection"
+  autoload :Association,        "strict-loading/association"
+  autoload :Core,               "strict-loading/core"
+  autoload :QueryMethods,       "strict-loading/query_methods"
+  autoload :Relation,           "strict-loading/relation"
+end
+
+require "active_record"
+
+module ActiveRecord
+  class StrictLoadingViolationError < ::ActiveRecord::ActiveRecordError; end
+
+  class Base
+    # we can't do this in the railtie's initializer because we need to load it
+    # earlier than ActiveRecord's own initializer
+    include ::StrictLoading::Core
+  end
+end
+
+if defined?(Rails)
+  require "strict-loading/railtie"
+end

data/lib/strict_loading.rb

@@ -0,0 +1 @@
+require "strict-loading"

data/spec/internal/app/models/todo_item.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class TodoItem < ActiveRecord::Base
+  belongs_to :todo_list
+end

data/spec/internal/app/models/todo_list.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class TodoList < ActiveRecord::Base
+  has_many :todo_items
+end

data/spec/internal/config/database.yml

@@ -0,0 +1,6 @@
+default: &default
+  adapter: sqlite3
+  database: db/combustion_test.sqlite
+
+test:
+  <<: *default

data/spec/internal/db/schema.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+ActiveRecord::Schema.define do
+  create_table :todo_lists do |t|
+    t.column :name, :string
+  end
+
+  create_table :todo_items do |t|
+    t.column :name, :string
+    t.references :todo_list
+  end
+end