activerecord-quick_read 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b7234e9dcb7b3d4690c49318d07af329d46f031e50d63450a24b57303314f389
-  data.tar.gz: 9517bccc29ba46045530c4028a7be33db00d84d15ad18e6d38561e7d3ec4e83e
+  metadata.gz: 1309eaf96974d8b58dcf9129d7562f9a4a768845f1b90ab14281cd71feeb9325
+  data.tar.gz: 82eed52c3a1fe90420610c53a8f613ead78d7ae38adfa9da9fc95ae32bc1717b
 SHA512:
-  metadata.gz: 27b36deba95df20b5bd391885e4582fa825d91f29a11c3125eab8be2eb2c525803d67dcaadac0cd0debd4bcb7f128a05aa7d43bcfe10e106f4b63ab6bdf22031
-  data.tar.gz: bd9c2b8406e3f80c87d1267f18756915e81506a64f1df228b19c8240b69818ee9dece97f5774608e5e6403736ea0907f46860962b502fab4a0f98cb3ca2875bd
+  metadata.gz: 2881f4c609eed7c8758b0e7f40382e1f432be17fc0df25289d5a7a264bf657c8c9efd0e4801e0020780c2dc12289ff27c58e05a6a41a8fb557ce872cb4465463
+  data.tar.gz: 5f45b9b3d261d5c16e40cc5ff4493de991ce5e73a206e2e655f7dde7607c8ee14eae776ac667334eb44c0e67586bdde414208a5bc4850e9c5d74a9f203081acc

data/.ruby-version

@@ -1 +1 @@
-3.1.2
+3.4.7

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 ## [Unreleased]
 
+## [1.2.0] - 2026-08-26
+
+- Added support for older Rails 5 (`parent` fallback for `module_parent`)
+- Removed the `activerecord` version bounds, enabling Rails 8.x (e.g. 8.0.5.1) that were previously excluded by `<= 8`
+- Fixed `quick_read` and `quick_reads` when called directly on a model
+- Expanded the README and test suite
+
 ## [0.1.0] - 2023-04-21
 
 - Initial release

data/Gemfile

@@ -9,4 +9,12 @@ gem "rake", "~> 13.0"
 
 gem "rspec", "~> 3.0"
 
+gem "sqlite3", "~> 1.6"
+
 gem "standard", "~> 1.3"
+
+# Gems extracted from Ruby's stdlib in Ruby 3.4+ that Rails 7.0 still requires
+gem "mutex_m"
+gem "base64"
+gem "bigdecimal"
+gem "racc"

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    activerecord-quick_read (1.0.0)
-      activerecord (>= 5, <= 8)
+    activerecord-quick_read (1.2.0)
+      activerecord
 
 GEM
   remote: https://rubygems.org/
@@ -18,16 +18,21 @@ GEM
       minitest (>= 5.1)
       tzinfo (~> 2.0)
     ast (2.4.2)
+    base64 (0.3.0)
+    bigdecimal (4.1.2)
     concurrent-ruby (1.2.2)
     diff-lcs (1.5.0)
     i18n (1.12.0)
       concurrent-ruby (~> 1.0)
     json (2.6.3)
     language_server-protocol (3.17.0.3)
+    mini_portile2 (2.8.9)
     minitest (5.18.0)
+    mutex_m (0.3.0)
     parallel (1.23.0)
     parser (3.2.2.0)
       ast (~> 2.4.1)
+    racc (1.8.1)
     rainbow (3.1.1)
     rake (13.0.6)
     regexp_parser (2.8.0)
@@ -61,6 +66,8 @@ GEM
       rubocop (>= 1.7.0, < 2.0)
       rubocop-ast (>= 0.4.0)
     ruby-progressbar (1.13.0)
+    sqlite3 (1.7.3)
+      mini_portile2 (~> 2.8.0)
     standard (1.27.0)
       language_server-protocol (~> 3.17.0.2)
       rubocop (~> 1.50.2)
@@ -75,8 +82,13 @@ PLATFORMS
 
 DEPENDENCIES
   activerecord-quick_read!
+  base64
+  bigdecimal
+  mutex_m
+  racc
   rake (~> 13.0)
   rspec (~> 3.0)
+  sqlite3 (~> 1.6)
   standard (~> 1.3)
 
 BUNDLED WITH

data/README.md

@@ -1,15 +1,37 @@
 # ActiveRecord::QuickRead
 
+[![Gem Version](https://badge.fury.io/rb/activerecord-quick_read.svg)](https://badge.fury.io/rb/activerecord-quick_read)
+
 Makes rails go _faster_. Improve read times 4x!
 
 ### How does it work?
 
-Skips active record instantiation, query just the results and use them as plain hashes, converted
-to structs with the same attributes as your model. The structs will gracefully upgrade to full
-version of your model, in the event that you need to update them.
+A normal ActiveRecord query does more than run SQL. Once the rows come back, ActiveRecord
+instantiates a model object for **every** row: allocating the object, running `initialize`,
+typecasting each column, setting up dirty tracking, and evaluating any `after_initialize` callbacks.
+For large result sets that per-row work adds up fast, and you end up paying for features you may not
+even use (like attribute change tracking) when all you wanted was to *read* the data.
 
-## Installation
+`quick_read` sidesteps all of that. It still runs the exact same scoped SQL through
+`connection.select_all`, which returns each row as a plain hash. Then, instead of building model
+objects, each hash is wrapped in a lightweight `Struct` whose members mirror the model's columns:
+
+```ruby
+# the Lite class generated for your model, e.g.:
+Report::Lite = Struct.new(:id, :message, :status, :created_at, :updated_at)
+```
+
+Because structs are plain Ruby objects there's no typecasting, no dirty tracking, no
+`after_initialize` callbacks, and far less allocation. The result is the same data you asked for,
+returned 4x faster.
 
+The structs are *upgradeable*, not throwaway. Each `Lite` instance knows its source model and can
+lazily materialize a full ActiveRecord object on demand (via `method_missing`). So when you call a
+method the struct doesn't have (like `save`, `update`, or an association such as `report.author`) it
+transparently builds the real model behind the scenes and delegates to it. You only pay the cost of
+instantiation when you actually need to write, not when you're just reading.
+
+## Installation
 
 Install the gem and add to the application's Gemfile by executing:
 
@@ -21,32 +43,102 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
 ## Usage
 
-Use `#quick_read` on your ActiveRecord relations (or `#quick_reads` for all scoped records)
-Use `#quick_build` on your ActiveRecord models
+Add quickness to your models, then call `#quick_read` on an ActiveRecord relation to get a single
+record, or `#quick_reads` to get all scoped records. Use `#quick_build` on your models to build a
+lite instance from a hash.
 
-First, add quickness to your model:
-```
+### Enable on a single model
+
+```ruby
 class Report < ApplicationRecord
   extend ActiveRecord::QuickRead
 end
 ```
 
-Then you're ready to start going faster!
+### Enable for every model via ApplicationRecord
+
+Instead of extending each model individually, extend `ApplicationRecord` once and every subclass
+inherits the quick read behavior:
+
+```ruby
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+
+  extend ActiveRecord::QuickRead
+end
+```
+
+Because models aren't fully defined until boot, the `Lite` structs are built lazily after Rails
+initializes (via the included railtie). Any class that inherits from `ApplicationRecord`, even ones
+defined in engines or gems, automatically gets a `Lite` struct.
+
+### Reading
+
+```ruby
+# A single record
+report = Report.where(id: params[:id]).quick_read
+report.id          # => 1
+report.message     # => "All done"
+report.class       # => Report::Lite
+
+# All scoped records
+reports = Report.where(status: "done").quick_reads
+reports.first.title
+```
 
-It's as simple as:
+The returned `Report::Lite` is a struct with the same attributes (and `#to_h`) as your model:
 
 ```ruby
-Report.where(id: params[:id]).quick_read
+Report.order(:created_at).quick_reads.map(&:to_h)
 ```
 
+### Batching
+
 Load your batches 4x quicker:
+
 ```ruby
-Report.all.in_batches { |batch| batch.quick_reads.map(&:to_h) }
+Report.in_batches do |batch|
+  batch.quick_reads.each do |report|
+    puts report.message
+  end
+end
 ```
 
-Gracefully upgrade to a full-fledged ActiveRecord object, and even issue `update` statements:
+### Building
+
+Build a lite instance from attributes without hitting the database:
+
+```ruby
+draft = Report.quick_build(id: 1, message: "hello")
+```
+
+### Upgrading to a full Active Record object
+
+Lite instances lazily upgrade to full-fledged ActiveRecord objects on demand. Calling any method the
+struct doesn't have (like `save`, `update`, or association accessors) transparently materializes the
+underlying model:
+
+```ruby
+Report.where(status: "queued").quick_reads.each do |report|
+  report.update(status: "done")
+end
+```
+
+```ruby
+report = Report.first.quick_read
+report.author          # => loads the belongs_to association on the full model
+report.save!
+```
+
+### Reloading
+
+Refresh a lite instance with fresh data from the database:
+
 ```ruby
-Report.all.quick_reads.each { |report| report.update(status: "done") if report.message = ?? }
+report = Report.first.quick_read
+# ... the underlying row changes elsewhere ...
+report.reload
+report.message # => updated value
 ```
 
 It just works.
@@ -59,7 +151,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/activerecord-quick_read. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/activerecord-quick_read/blob/main/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/ridiculous/activerecord-quick_reads. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/ridiculous/activerecord-quick_reads/blob/main/CODE_OF_CONDUCT.md).
 
 ## License
 
@@ -67,4 +159,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the ActiveRecord::QuickRead project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/activerecord-quick_read/blob/main/CODE_OF_CONDUCT.md).
+Everyone interacting in the ActiveRecord::QuickRead project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/ridiculous/activerecord-quick_reads/blob/main/CODE_OF_CONDUCT.md).

data/activerecord-quick_read.gemspec

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "lib/activerecord/quick_read/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "activerecord-quick_read"
+  spec.version = ActiveRecord::QuickRead::VERSION
+  spec.authors = ["Ryan Buckley"]
+  spec.email = ["ridiculous@hey.com"]
+
+  spec.summary = "Speed up ActiveRecord reads by skipping model instantiation."
+  spec.description = "Faster ActiveRecord reads. Skips model instantiation and returns lightweight objects (with untypecast values) " \
+                     "just for reading. Fallback to full-fledged ActiveRecords on method_missing."
+  spec.homepage = "https://github.com/ridiculous/activerecord-quick_reads"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  # spec.metadata["allowed_push_host"] = "TODO: Set to your gem server 'https://example.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/ridiculous/activerecord-quick_reads"
+  spec.metadata["changelog_uri"] = "https://github.com/ridiculous/activerecord-quick_reads/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) || f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  spec.add_dependency "activerecord"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/activerecord/quick_read/lite_base.rb

@@ -2,32 +2,34 @@ module ActiveRecord
   module QuickRead
     module LiteBase
       def method_missing(name, *args, &block)
-        return super unless subject.respond_to?(name)
+        return super unless _ar_instance.respond_to?(name)
 
-        subject.send(name, *args, &block)
+        _ar_instance.send(name, *args, &block)
       end
 
       def respond_to_missing?(*args)
-        subject.respond_to?(*args) || super
-      end
-
-      def subject
-        @subject ||= model.from_hash(to_h)
-      end
-
-      # Since the struct that includes this module is defined within the model's namespace
-      def model
-        self.class.module_parent
+        _ar_instance.respond_to?(*args) || super
       end
 
       def reload(*)
-        source = @subject&.reload
-        source ||= model.unscoped.where(id: id).select(members.join(', ')).quick_read
+        source = @_ar_instance&.reload
+        source ||= _ar_model.unscoped.where(id: id).quick_read
         return false unless source
 
         members.each { |attr| send(:"#{attr}=", source.send(attr)) }
         self
       end
+
+      # Private
+
+      def _ar_instance
+        @_ar_instance ||= _ar_model.from_hash(to_h)
+      end
+
+      # Since the struct that includes this module is defined within the model's namespace
+      def _ar_model
+        self.class.respond_to?(:module_parent) ? self.class.module_parent : self.class.parent
+      end
     end
   end
 end

data/lib/activerecord/quick_read/version.rb

@@ -2,6 +2,6 @@
 
 module ActiveRecord
   module QuickRead
-    VERSION = "1.0.0"
+    VERSION = "1.2.0"
   end
 end

data/lib/activerecord/quick_read.rb

@@ -35,7 +35,7 @@ module ActiveRecord
 
       ActiveRecord::Base.logger.debug("QuickRead") { "Defining #{QuickRead.models.size} quick models" }
       time = Benchmark.realtime do
-        while model = models.pop
+        while (model = models.pop)
           define_lite_struct(model)
         end
       end
@@ -64,11 +64,12 @@ module ActiveRecord
     end
 
     def quick_reads
-      connection.select_all(current_scope.to_sql).map { |attrs| quick_build(attrs) }
+      scope = current_scope || all
+      connection.select_all(scope.to_sql).map { |attrs| quick_build(attrs) }
     end
 
     def quick_read
-      current_scope.limit(1).quick_reads.first
+      (current_scope || all).limit(1).quick_reads.first
     end
 
     # Instantiate a new ActiveRecord object from a plain hash, marked as persisted, no changes, typecast

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-quick_read
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Ryan Buckley
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-04-22 00:00:00.000000000 Z
+date: 2026-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,21 +16,17 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5'
-    - - "<="
-      - !ruby/object:Gem::Version
-        version: '8'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5'
-    - - "<="
-      - !ruby/object:Gem::Version
-        version: '8'
-description: Makes rails go _faster_. Improve read times 4x!
+        version: '0'
+description: Faster ActiveRecord reads. Skips model instantiation and returns lightweight
+  objects (with untypecast values) just for reading. Fallback to full-fledged ActiveRecords
+  on method_missing.
 email:
 - ridiculous@hey.com
 executables: []
@@ -48,6 +44,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- activerecord-quick_read.gemspec
 - lib/activerecord/quick_read.rb
 - lib/activerecord/quick_read/lite_base.rb
 - lib/activerecord/quick_read/railtie.rb
@@ -77,5 +74,5 @@ requirements: []
 rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
-summary: Makes rails go _faster_. Improve read times 4x!
+summary: Speed up ActiveRecord reads by skipping model instantiation.
 test_files: []