turbo-sprockets-rails4 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 93dc4b63a52cdc1eac49f1cb2465a380d547ae89
-  data.tar.gz: 35b1991e4acb678231774f80f13ef1cdf707c4bc
+  metadata.gz: 586a1535f71f9f7df3acd4db632c697ebc9580f4
+  data.tar.gz: 4eceb9773988542517ccadcd67b2eeafa29c2693
 SHA512:
-  metadata.gz: 06571631ba75f30ee811bca5c54fdb3de1fb8d2e2aa69e7910b44db0ef7e5c427bedcbf52a658cf42dd402af406fa331d88e153098d50af2758d221fb20b9ff8
-  data.tar.gz: 455c9c46852d8e3acc202e8c1891ae36694ce2a5592b1ab4d6b1c701ec4d373342ceaf52f921035f8c0489666794d1a8bd83c3c183e0d3ac2d890e831f6f6fa5
+  metadata.gz: 558451bc96260c09d900bd0c3b7759a4435988996d8688108a15359a0f1ead9604f16b68997158f7ebfdcdcdbe92db3b7bd5b17d41571cef70bdb356363c741b
+  data.tar.gz: 22c72028140da901b39001d3b1da1ad93cfa63c18ff0642731dbc77f48d0c0714d4d030ad1a38449eccfc97054584d970ef0052d52d6fc59db6548d35ab57566

data/README.md

@@ -13,25 +13,47 @@ gem 'turbo-sprockets-rails4'
 
 ### Rationale
 
-In a large Rails application, assets can take a very long time to precompile. It can be a real drag on productivity and deployments to have to wait until your assets are done precompiling. Although the slowness can be attributed to a number of factors, one of the most significant has to do with Ruby's single-threaded execution model. Most servers and laptops these days come with multiple processors or cores, but Rails doesn't take advantage of them. Wouldn't it be nice if we could put all our CPU cores to work precompiling assets?
+Sprockets is slow. Turbo-sprockets uses parallelism to speed it up so your life isn't spent waiting for assets.
 
-That's where this gem comes in. turbo-sprockets is capable of precompiling assets in parallel, using all the CPU cores available on your laptop or server. Generally this translates into a substantial speed increase. In one of the large codebases I've worked on, turbo-sprockets decreased the total precompile time from ~12 minutes to ~2 minutes using the four cores on my laptop.
+Said a little more long-form, a large, long-lived Rails application can have a ton of static assets. It can be a real drag on productivity and deployments to have to wait for Rails to chew through them all. Although the slowness can be attributed to a number of factors, one of the most significant has to do with Ruby's single-threaded execution model. Most servers and laptops these days come with multiple processors or cores, but Rails doesn't take advantage of them. Wouldn't it be nice if we could put all our CPU cores to work precompiling assets? That's where turbo-sprockets comes in.
 
-### Getting Started
+### What's Included?
 
-turbo-sprockets is designed to work as a drop-in addition to your Rails app. Adding it to your Gemfile and running `bundle install` should be all that's necessary to enable your application to precompile assets in parallel.
+Turbo-sprockets includes two major components: the asset precompiler and the asset preloader.
+
+#### Asset Precompiler
+
+The turbo-sprockets precompiler precompiles assets in parallel using potentially all the CPU cores available on your laptop or server. Generally this translates into a substantial speed increase. In one of the large codebases I've worked on, turbo-sprockets decreased the total precompile time from ~12 minutes to ~2 minutes using the four cores on my laptop. Obviously that's a micro benchmark that doesn't mean much, so your mileage may vary. Intuitively however, tasks get done faster when you can do more than one at a time.
+
+#### Asset Preloader
+
+The asset preloader is a little different. As of Sprockets 3, a Rails server running in the development environment will attempt to compile and cache every asset your application might need _on the first page request_. This is different from how things used to work. In the old days, Rails would compile assets on-the-fly. For example, if your app requested dashboard.css but not home_page.css, Rails would only compile dashboard.css. For applications with a large number of assets, compiling all of them on the first page request can be prohibitively time-consuming. The asset preloader tries to alleviate this pain by compiling and caching assets in parallel when your app boots. It's like the precompiler, but for development.
 
 ### Configuration
 
-Rather than guess how many CPU cores your computer has (which can be error prone), turbo-sprockets asks that you set the `SPROCKETS_WORKER_COUNT` environment variable (2 cores are used by default). For example, to precompile using 4 workers, you might run:
+By default, asset preloading is enabled only in the development environment, and only if you're running `rails server`. Precompiling is enabled in every environment _except_ development. You can enable or disable these two components by configuring turbo-sprockets (generally in one of your environment files, or maybe an initializer):
+
+```ruby
+TurboSprockets.configure do |config|
+  config.preloader.enabled = false
+  config.precompiler.enabled = false
+end
+```
+
+#### Parallelism
 
-```bash
-SPROCKETS_WORKER_COUNT=4 bundle exec rake assets:precompile
+By default, parallel preloading and precompiling will spin up two processes to perform the necessary work. You can set this number in one of two ways. Use the `TURBO_SPROCKETS_WORKER_COUNT` environment variable, eg. `TURBO_SPROCKETS_WORKER_COUNT=2 bundle exec rake assets:precompile` or set it when configuring turbo-sprockets:
+
+```ruby
+TurboSprockets.configure do |config|
+  config.preloader.worker_count = 2
+  config.precompiler.worker_count = 2
+end
 ```
 
 ### How Does it Work?
 
-Under the hood, turbo-sprockets uses the [parallel](https://github.com/grosser/parallel) gem to divide your assets up amongst the available CPUs. It works by [forking](https://en.wikipedia.org/wiki/Fork_(system_call)) into multiple system processes which are executed in parallel by your operating system.
+Under the hood, turbo-sprockets uses the [parallel](https://github.com/grosser/parallel) gem to divide your assets up amongst the available CPU cores. It works by [forking](https://en.wikipedia.org/wiki/Fork_(system_call)) into multiple system processes which are executed in parallel by your operating system.
 
 ### Supported Platforms
 

data/lib/turbo-sprockets/version.rb

@@ -1,3 +1,3 @@
 module TurboSprockets
-  VERSION = '1.1.0'
+  VERSION = '1.2.0'
 end

data/lib/turbo-sprockets-rails4.rb

@@ -49,9 +49,10 @@ module TurboSprockets
     end
 
     def configuration
+      # hopefully people think these are sane defaults :|
       @configuration ||= Config.new(
-        precompiler: { enabled: true },
-        preloader:   { enabled: true }
+        precompiler: { enabled: !Rails.env.development? },
+        preloader:   { enabled: Rails.env.development? && Rails.const_defined?(:Server) }
       )
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: turbo-sprockets-rails4
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Cameron Dutro
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-17 00:00:00.000000000 Z
+date: 2017-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parallel