lazy_chain 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 490f13aa3fc5619f80736a1e222dff5a98f7ae36264d828e27c5bc322fdd7e04
+  data.tar.gz: a06fe7509586c68ec26b9ec3d31c5313bd9391cb9e076cb62a50ad154fdfccfe
+SHA512:
+  metadata.gz: 69ee1ffcf8236e402b4b36dc9fe20c7664ccda22d984052f241445b3039fafbf9c6e09c9c84526b29d9c15f897c6b057ca6c7802f25bdc23dd9591653c29a12b
+  data.tar.gz: f9a684c1721e42005310b22f2300fa56ba0ab00e27359941557140d8688c779a50e3f336e69753f4743903bb7b6919be8705dcc051b7c7d2c56bd0a346f7aac8

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright Andy Cohen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,86 @@
+# LazyChain :chains:
+
+**Render every page immediately, even if your code is slow.**
+
+> ⚠️ **Not usable yet.** `0.0.1` reserves the gem name and ships an empty engine — installing it does nothing. The API described below is the direction, not a promise, and it will change before `1.0`. Watch the repo if you want to know when it's real.
+
+## The problem
+
+Every mature Rails app has a page like this:
+
+```erb
+<td><%= number_to_currency estimate.pricing.all.total_amount %></td>
+<td><%= number_to_currency estimate.pricing.all.margin_amount %></td>
+<td><%= number_to_currency estimate.pricing.all.tax_amount %></td>
+```
+
+Three innocent-looking method calls. Each one walks a tree of associations, and each one takes 800ms. The page takes nine seconds to paint, and the user stares at a blank screen the whole time — including the header, the navigation, and the twenty other values that were ready instantly.
+
+You know how to fix it. Memoize it, denormalize it, precompute it in a background job, rewrite it as one heroic SQL query. All of that is real work, and all of it is work you were not planning to do this week.
+
+## The idea
+
+The page is not slow. A handful of method calls on the page are slow. LazyChain lets you say which ones, and gets them out of the critical path:
+
+```erb
+<td><%= lazy_chain estimate, "pricing.all.total_amount" %></td>
+<td><%= lazy_chain estimate, "pricing.all.margin_amount" %></td>
+<td><%= lazy_chain estimate, "pricing.all.tax_amount" %></td>
+```
+
+The page renders now. Each deferred value arrives on its own, as soon as it's ready, in the spot where it belongs. All you need to do is opt-in to the provided route concern and use the view helper. Everything else is magic :magic_wand:.
+
+```ruby
+  resources :estimates, concerns: %i[lazy_chain]
+```
+
+That's the whole pitch. No new service objects, no background job infrastructure, no cache to invalidate by hand, no JavaScript to write. You point at the slow call and move on with your day.
+
+## What you get
+
+- **A one-line change at the call site.** Wrap the expensive call. Delete the wrapper later when you get around to making it fast. Nothing else in your app needs to know.
+- **Nine seconds becomes nine parallel requests.** The browser fetches deferred values concurrently, so the slowest one sets your page time — not the sum of all of them.
+- **Values that show up where they belong.** Each one lands in its own slot in the markup. No spinners bolted onto the layout, no reflow, no partial rewrites.
+- **Below-the-fold work that never happens.** Values further down the page aren't computed until the user scrolls to them.
+- **Safe by construction.** Method chains are signed automatically, and signatures are validated before execution.
+- **Turbo-native and boring.** Standard Turbo Frames, standard Rails caching, standard controllers. Nothing you'd be surprised to find in a `curl`.
+
+## What it isn't
+
+LazyChain is not a performance fix — it's a way to stop paying for one up front. The slow method is still slow, and it will still be slow after you install this. What changes is that your user isn't waiting on it to see the rest of the page.
+
+If a value is slow *and* the user is blocked on reading it, make it fast. If it's slow and merely nice to have on screen eventually — which describes an enormous number of totals, rollups, and derived figures in real applications — defer it.
+
+## Installation
+
+```ruby
+gem "lazy_chain"
+```
+
+```bash
+$ bundle install
+```
+
+Requires Rails 8.1+ and Turbo.
+
+## Status & roadmap
+
+LazyChain is being extracted from a production estimating application, where it defers several hundred pricing rollups across the app and has been in daily use by a real sales team.
+
+The extraction is in progress. Coming before the first usable release:
+
+- [ ] The `lazy_chain` view helper and its underlying view object
+- [ ] The controller and routing concern that resolve a deferred chain
+- [ ] Signed method chains, verified before anything is called
+- [ ] A pluggable cache strategy, so a computed value is computed once
+- [ ] Pluggable formatting, with sensible defaults
+- [ ] Test helpers for making deferred values behave in system specs
+- [ ] Documentation worth the name
+
+## Contributing
+
+Not yet — there's nothing to contribute to. Once the extraction lands, issues and pull requests are welcome. Until then, if the pitch above describes a page in your app, open an issue and tell me about it. That's genuinely useful.
+
+## License
+
+Released under the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+require "bundler/gem_tasks"

data/config/routes.rb

@@ -0,0 +1,2 @@
+Rails.application.routes.draw do
+end

data/lib/lazy_chain/engine.rb

@@ -0,0 +1,4 @@
+module LazyChain
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/lazy_chain/version.rb

@@ -0,0 +1,3 @@
+module LazyChain
+  VERSION = "0.0.1"
+end

data/lib/lazy_chain.rb

@@ -0,0 +1,6 @@
+require "lazy_chain/version"
+require "lazy_chain/engine"
+
+module LazyChain
+  # Your code goes here...
+end

data/lib/tasks/lazy_chain_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :lazy_chain do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: lazy_chain
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andy Cohen
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.1.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.1.3.1
+description: |-
+  Most slow Rails pages are not slow -- a handful of method calls on them are. LazyChain lets you
+  mark those calls in your templates and moves them off the critical path. The page renders right
+  away, and each deferred value loads on its own in a Turbo Frame as soon as it is ready. Values
+  below the fold are never computed at all unless the user scrolls to them. No background job
+  infrastructure, no cache to invalidate by hand, and no JavaScript to write -- just standard
+  Turbo Frames and standard Rails caching.
+email:
+- outlawandy@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- config/routes.rb
+- lib/lazy_chain.rb
+- lib/lazy_chain/engine.rb
+- lib/lazy_chain/version.rb
+- lib/tasks/lazy_chain_tasks.rake
+homepage: https://github.com/OutlawAndy/lazy_chain
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/OutlawAndy/lazy_chain
+  changelog_uri: https://github.com/OutlawAndy/lazy_chain/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/OutlawAndy/lazy_chain/issues
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Defer expensive method calls into Turbo Frames so every page renders immediately.
+test_files: []