render-later 1.1.0 → 1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 55370f11139243c05ff90f7daf2c71d46fe1f20c
-  data.tar.gz: 70b2a0834e7502ea42de2525157eea36fc07fdb1
+SHA256:
+  metadata.gz: c449ac1241d0e451f19d9ec51844d1fb3912aaac0e20ed145d2312f99e0404cc
+  data.tar.gz: 592d40821bb0a7c981e9105a5dc24ad48900daa8c400786adc75d59bfe33d4ac
 SHA512:
-  metadata.gz: bfdd1c0a4dbda416582e61c88dbdf5da2d503c1908adff8f2ba2964020908514fe4d526d64105e069ad959ddd0d888eb345d1d0856e421646041d56b4bc3c508
-  data.tar.gz: 9f02642e7c9cc19d81c3d233d22cb08b153e067ae8160fea10005f86b56de54ee276dd15181da16aec924544f877981a69987794b4f951dbcfc144ff1be4b4b2
+  metadata.gz: 428f8bd70f8f0056e2b84bf1e82c1b5c100713b20b7f95e01f7d2d2a5d474b46b5ed77244e5cf651fd50013d1b1696184b25edf5e7badd39bc22e0785b05e3b3
+  data.tar.gz: c7321d1e1190a62c9b2d332e6d516227b6c02597f923cf3c180ceab03d9c329d7d6445c62003d96f0dd08e0e13dcb566936f4f741fec11e8b8232e89e96b6785

data/.travis.yml

@@ -1,13 +1,17 @@
 language: ruby
 cache: bundler
 rvm:
-  - 2.3.4
-  - 2.4.1
+  - 2.5.8
+  - 2.6.6
+  - 2.7.2
 gemfile:
-  - test/gemfiles/rails-4.2.gemfile
   - test/gemfiles/rails-5.0.gemfile
   - test/gemfiles/rails-5.1.gemfile
+  - test/gemfiles/rails-5.2.gemfile
+  - test/gemfiles/rails-6.0.gemfile
 matrix:
   include:
-    - rvm: 2.3.4
-      gemfile: test/gemfiles/rails-4.1.gemfile
+    - rvm: 2.3.8
+      gemfile: test/gemfiles/rails-4.1.gemfile
+    - rvm: 2.4.9
+      gemfile: test/gemfiles/rails-4.2.gemfile

data/CHANGELOG.md

@@ -1,9 +1,23 @@
+# v1.2
+
+* Add support and documentation for new rack 2.2.x ETag bug
+* Add new test for streaming capabilities of Rails stack.
+* Update default rails server in Readme and in tests
+* Loosen dev dependencies (rails and bundler)
+* Removes sprockets from dumy app to better support Rails 6
+* Update build matrix ruby version (+add 2.7)
+* Update my last name <3
+
+_Nov 23, 2020_
+
 # v1.1.0
 
 Add support for render-later in tables and other elements:
 * Add ability to customize placeholder tag (#2)
 * Fix javascript temporary element to match parent one (#2)
 
+_Aug 3, 2017_
+
 # v1.0.0
 
 Initial production release

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2016 Adrien Jarthon
+Copyright (c) 2016 Adrien Rey-Jarthon
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -47,6 +47,9 @@ And finally in your controller, you need to render with the `stream` option:
 
 ```ruby
   def index
+    # You may also need (see Gotcha section):
+    # form_authenticity_token; flash
+    # headers['Last-Modified'] = Time.now.httpdate
     render stream: true
   end
 ```
@@ -54,7 +57,7 @@ And finally in your controller, you need to render with the `stream` option:
 ## Performance
 
 Performance-wise, this approach is quite interesting, let me explain why:
-We know for a time that with bandwidth always increasing, web performance is getting more and more constrained by latency.
+We know that bandwidth is always increasing, web performance is getting more and more constrained by latency.
 
 For cases like this, there is usually two ways:
 
@@ -65,18 +68,21 @@ The first solution is, IMO, decent **if using streaming**, because the browser c
 
 The second solution gets the first page rendered quickly but is much more complex to setup (needs another endpoint to expose the data, an Ajax call to fetch them, and some js to put the data back where it belongs, handle loading spinner, errors, etc.). It is also much **slower to load**, because the browser needs to load & parse all the javascript, wait to the entire page to be ready (domready), and only then it will start the ajax call, adding the whole round-trip time once again to the page loading.
 
-Whereas with async-render, you leverage the existing open socket currently downloading the document to stream the deferred data:
+Whereas with render-later, you leverage the existing open socket currently downloading the document to stream the deferred data:
 - You don't have to handle errors, because it's the same request. So if it fails at this point, the browser will simply show it's native error page.
 - You don't have to show any kind of spinner because the browser is still showing it's native loading indicator.
-- You don't increase latency because the additional data start streaming right after the page is sent. And even better, the deferred data **starts rendering even if the browser didn't receive a single byte yet**, so if you're on a slow network (ex: 3G, 500ms rtt), instead of delaying even more (Ajax call), you'll actually receive the document **already complete**, because while the network lagged, the server was working :)
+- You don't increase latency because the additional data start streaming right away after the page is sent. And even better, the deferred data **starts rendering even if the browser didn't receive a single byte yet**, so if you're on a slow network (ex: 3G, 500ms rtt), instead of delaying even more (Ajax call), you'll actually receive the document **already complete**, because while the network lagged, the server was working :)
 
 So in the end, this solutions is the best of both world: you get the first paint time of the Ajax version, but with the simplicity and time-to-full-document of the simple inline version.
 
-The only downside of this approach is that the domeady event will only be executed at the end of the request, once the body is complete. See the [Gotcha section](#gotcha) for more details.
+The only downsides of this approach IMO are:
+1. The `domready` event will only be executed at the end of the end of the streaming, once the body is complete.
+2. Rails/rack support for streaming is bad and you may need to workaround some bugs.
+See the [Gotcha section](#gotcha) for more details.
 
 ## Compatibility
 
-On the server side, the gem is tested against `ruby 2.1+` and `rails 4.1+`.
+On the server side, the gem is tested against `ruby 2.3+` and `rails 4.1+`.
 The dependency is not strictly enforced though and it may work with others versions but we don't guaranty anything.
 
 The generated javascript is a simple inline function using nothing else than DOM Core level 2 properties, so it should work flawlessly on IE6+, Firefox 2+, Chrome 1+, Edge, Safari, etc.
@@ -97,11 +103,11 @@ Server            | Supported  | Comment
 ------------------|------------| -------
 Phusion Passenger | ✔️         |
 Unicorn           | ✔️         | _with `tcp_nopush: false`_
-puma              | ✔️         |
-WEBrick           | ❌         | _default for `rails s`_
+puma              | ✔️         | _default for `rails s`_
+WEBrick           | ❌         |
 Thin              | ❌         |
 
-To try it in development, I recommend adding `gem 'unicorn-rails'` to your `Gemfile`'s development group and use `UNICORN_WORKERS=4 rails s` to start it. We need multiple processes in development to avoid blocking CSS requests during the page load. It's totally fine to develop with a single process or a server which doesn't support streaming, you just won't see the effects of the gem.
+To try it in development, I recommend using `puma` (the default Rails server) with `rails s`. We need the multiple threads in development to avoid blocking CSS/JS requests during the page streaming. It's totally fine to develop with a single thread/process or a server which doesn't support streaming, you just won't see the effects of the gem.
 
 ### gzip
 
@@ -129,6 +135,7 @@ Slim            | ✔️         |
 Haml            | ❌         |
 
 #### Flash message & CSRF token
+
 There is currently an [issue with Rails i'm trying to revive](https://github.com/rails/rails/issues/11476) about streaming causing trouble with flash messages and CSRF tokens. This is because rails waits the end of the request to check if you have used the flash message, if so it is removed from the store, otherwise it stays for the next request. But with streaming on, rails considers the requests as ended very early, before the flash message ever gets a change to be rendered. So this logic fails and keeps the flash message forever. The problem is exactly the same with the CSRF token.
 
 The best **workaround** we currently have is to fool rails by accessing the flash message and CSRF token before the render call:
@@ -141,7 +148,22 @@ The best **workaround** we currently have is to fool rails by accessing the flas
   end
 ```
 
+#### Rack 2.2.x & ETag Middleware
+
+There's a recent change in `rack 2.2.x` which broke streaming in Rails as can [be seen in this issue](https://github.com/rack/rack/issues/1619). The problem is that the ETag middleware used to ignore streaming response because of the `Cache-Control: no-cache` header (which is set by Rails for streaming response) and now it doesn't any more (because this behavior wasn't really valid). But the ETag middleware now has to process the whole body to generate the ETag header and thus blocks the response until everything is ready.
+
+The best **workaround** we currently have is to fool the ETag middleware by setting the `Last-Modified` header (if set, the ETag middleware is skipped):
+
+```ruby
+  # in the controller, before every streaming render.
+  def index
+    headers['Last-Modified'] = Time.now.httpdate
+    render stream: true
+  end
+```
+
 #### Caching
+
 Finally, before your scratch your head, be careful not to put fragment caching **outside** a `render_later` block, because that would actually cache the empty span but not the inline script (which is generated by `render_now`), so it would be a waste and the real content will never be injected. It's totally **fine/recommended** to use fragment caching **inside** the `render_later` block.
 
 ## Contributing
@@ -150,6 +172,23 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/jartho
 
 After checking out the repo, run `bundle install` to install dependencies. Then, run `rake` to run the tests.
 
+Start the demo server:
+```bash
+cd test/dummy && rails s
+```
+
+Verify the streaming behavior in browser (http://localhost:3000) or curl:
+```bash
+curl http://localhost:3000
+```
+
+Test with a specific Rails version:
+```bash
+cd test/dummy
+bundle install --gemfile=../gemfiles/rails-5.0.gemfile
+bundle exec --gemfile=../gemfiles/rails-5.0.gemfile rails s
+```
+
 ## Ideas for improvement
 
 - Wider test coverage across browsers using [Sauce Labs](https://saucelabs.com/opensauce/)

data/lib/render-later/version.rb

@@ -1,3 +1,3 @@
 module RenderLater
-  VERSION = "1.1.0"
+  VERSION = "1.2"
 end

data/rails-streaming.rb

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'bundler/inline'
+rescue LoadError => e
+  $stderr.puts 'Bundler version 1.10 or later is required. Please update your Bundler'
+  raise e
+end
+
+gemfile(true) do
+  source 'https://rubygems.org'
+  gem 'rails', '4.2.5'
+end
+
+require 'rack/test'
+require 'action_controller/railtie'
+
+class TestApp < Rails::Application
+  config.root = File.dirname(__FILE__)
+  config.session_store :cookie_store, key: 'cookie_store_key'
+  secrets.secret_token    = 'secret_token'
+  secrets.secret_key_base = 'secret_key_base'
+
+  config.logger = Logger.new($stdout)
+  Rails.logger  = config.logger
+
+  routes.draw do
+    get '/' => 'test#index'
+    get '/set_flash' => 'test#set_flash'
+  end
+end
+
+class TestController < ActionController::Base
+  include Rails.application.routes.url_helpers
+
+  def index
+    render file: 'template.html.erb', stream: params[:stream]
+  end
+
+  def set_flash
+    flash.notice = 'notice'
+    render text: 'ok'
+  end
+end
+
+require 'minitest/autorun'
+
+# Ensure backward compatibility with Minitest 4
+Minitest::Test = MiniTest::Unit::TestCase unless defined?(Minitest::Test)
+
+class BugTest < Minitest::Test
+  include Rack::Test::Methods
+
+  def setup
+    IO.write('template.html.erb', '<%= csrf_meta_tag %><%= flash.notice %>')
+  end
+
+  def teardown
+    File.unlink('template.html.erb')
+  end
+
+  def test_works_without_stream
+    get '/set_flash'
+    assert last_response.ok?
+    get '/'
+    assert last_response.ok?
+    assert_match /notice/, last_response.body
+    get '/'
+    assert last_response.ok?
+    refute_match /notice/, last_response.body
+  end
+
+  def test_works_with_stream
+    get '/set_flash'
+    assert last_response.ok?
+    get '/', stream: true
+    assert last_response.ok?
+    assert_match /notice/, last_response.body
+    get '/', stream: true
+    assert last_response.ok?
+    refute_match /notice/, last_response.body
+  end
+
+  private
+
+  def app
+    Rails.application
+  end
+end

data/render-later.gemspec

@@ -6,7 +6,7 @@ require 'render-later/version'
 Gem::Specification.new do |spec|
   spec.name          = "render-later"
   spec.version       = RenderLater::VERSION
-  spec.authors       = ["Adrien Jarthon"]
+  spec.authors       = ["Adrien Rey-Jarthon"]
   spec.email         = ["me@adrienjarthon.com"]
 
   spec.summary       = %q{Defer rendering of slow parts to the end of the page}
@@ -19,10 +19,10 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "minitest"
-  spec.add_development_dependency "rails", "~> 5.1"
+  spec.add_development_dependency "rails", ">= 4.1"
   spec.add_development_dependency "puma"
   spec.add_development_dependency "poltergeist"
 end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: render-later
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: '1.2'
 platform: ruby
 authors:
-- Adrien Jarthon
+- Adrien Rey-Jarthon
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-08-03 00:00:00.000000000 Z
+date: 2020-11-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.11'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.11'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -56,16 +56,16 @@ dependencies:
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '4.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '4.1'
 - !ruby/object:Gem::Dependency
   name: puma
   requirement: !ruby/object:Gem::Requirement
@@ -114,6 +114,7 @@ files:
 - lib/render-later.rb
 - lib/render-later/engine.rb
 - lib/render-later/version.rb
+- rails-streaming.rb
 - render-later.gemspec
 homepage: https://github.com/jarthod/render-later
 licenses:
@@ -134,8 +135,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Defer rendering of slow parts to the end of the page