ettu 3.2.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b1a5e5a4fa5edd6f0599a6fc900eae50f7cf25c0
-  data.tar.gz: bacdad06438bbc50ae3fb847a6f649dba2fa7b82
+  metadata.gz: bdc3e36dd4f21333678bb4d88ad7a963040c6545
+  data.tar.gz: 85d2b61d41d2b4e8e28ce2c58355beb08fb6f282
 SHA512:
-  metadata.gz: 8b195b10a8128e2d0ac5fd5449e95c51f4c4ac7fee5a2f14bf7560ed72d6bed06205d2a5d755213ea3fe82f6281c4f64518be10d16d489be92aa4856fd52c3e7
-  data.tar.gz: b6f133486cdc146eefd50ec7a788045e9547e032e95d8553674eb31fd85038b12d3325e12e1f2b3e289f29b1d7b084a794bbf4ef2b51d6acd88cfae6dc20cd98
+  metadata.gz: 6894aba4eda3847150eacd85f0cfbd725b3689219857d83221cf6662c6c9485a9df11dfcd56e1e446d6db15ee585935b938cfdfb798b1f731bd0b029d3570787
+  data.tar.gz: 88edb98c24ee25bed3f4194ec6a1d8b402d2516f9d345d45553f6882fd9603d7006a7071930a1c3dfd1adc9fc6b5d89da3e4988792bc8e0b27200bbb70eafe4e

data/.travis.yml

@@ -3,4 +3,4 @@ rvm:
   - 1.9.3
   - 2.0.0
   - jruby-19mode
-  - rbx
+  - rbx-19mode

data/README.md

@@ -1,7 +1,7 @@
-Ettu [![Build Status](https://travis-ci.org/cloudspace/ettu.png?branch=v3)](https://travis-ci.org/cloudspace/ettu)
+Ettu
 ====
 
-Using Rails 3's `stale?` or `fresh_when`? Are your users seeing old view
+Using Rails 4's `stale?` or `fresh_when`? Are your users seeing old view
 code even after new deploys? The Rails way `fresh_when(@product)`
 doesn't account for changes in your view code, you have to do it
 yourself.
@@ -19,10 +19,9 @@ changes to your view code.
 Installation
 ------------
 
-Add Ettu and [cache_digests](https://github.com/rails/cache_digests) to
-your Gemfile:
+Add Ettu to your Gemfile:
 
-    gem 'ettu', '~> 3.0'
+    gem 'ettu'
 
 And `$ bundle install`
 
@@ -46,9 +45,10 @@ end
 ```
 
 Ettu wants you to keep using either syntax, and let it worry about the
-view code. By default, it will add in the fingerprints of your
-precompiled assets along with the cache digest of the current action
-into the calculation for the final ETag sent to the browser.
+view code. By default, it will add in the asset fingerprints of
+`application.js` and `application.css` along with the cache digest of
+the current action into the calculation for the final ETag sent to the
+browser.
 
 ### Configuring
 
@@ -67,24 +67,34 @@ Of course, you can override Ettu's default behavior:
 ```ruby
 # config/initializers/ettu.rb
 Ettu.configure do |config|
+  # Set the default js file
+  config.js = 'app.js'
+  # Or don't account for javascript
+  # config.js = false
+
+  # Set the default css file
+  config.css = 'style.css'
+  # Or don't account for css
+  # config.css = false
+
   # Add in extra assets to account for
-  config.assets += ['first.js', 'second.css']
+  config.assets = ['first.js', 'second.css']
 end
 ```
 
 Or each can be passed on an individual basis:
 
-    fresh_when @product, assets: 'super.css'
+    fresh_when @product, js: 'app.js', css: 'style.css', assets: 'super.css'
 
 Additionally, you can specify a different template to calculate with the
 `view` option:
 
-    fresh_when @product, view: 'products/index'
+    fresh_when @product, view: "products/index"
 
 You can even stop Ettu from accounting for any of them by setting the
 value to `false`:
 
-    fresh_when @product, assets: false, view: false
+    fresh_when @product, js: false, css: false, view: false
 
 ### What about Rails' default `fresh_when`?
 
@@ -93,16 +103,21 @@ implementation. Ettu makes sure to pass all the options you specify to
 Rails (like the `public` option). It's even coded as a drop-in gem that
 won't cause problems if it's not installed.
 
-RAILS_ENV=development Gotchas
------------------------------
+RAILS_ENV=development Issues
+----------------------------
+
+Until [rails/rails#10791](https://github.com/rails/rails/pull/10791)
+gets merged in, Ettu will not be able to detect changes in templates
+while in the **development** environment. This is not an issue that
+affects staging or production, because the template cache will be
+recreated after each deploy.
 
-In order for Rails to detect changes to templates when testing `perform_caching`
-in the **development** environment, you must disable `cache_template_loading`.
+In the mean time, you can enable a monkey-patch with:
 
 ```ruby
 # config/environments/development.rb
 My::Application.configure do
-  config.action_view.cache_template_loading = false
+  config.ettu.development_hack = true
 end
 ```
 

data/ROADMAP.md

@@ -6,4 +6,4 @@ Ettu Roadmap
     - Separate gem into branches
     - v3 branch will track Rails 3
     - v4 branch will track Rails 4
-- [x] Default assets to those set in Rails.application.config.assets
+- [ ] Default assets to those set in Rails.application.config.assets.precompile

data/ettu.gemspec

@@ -8,7 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = Ettu::VERSION
   spec.author        = 'Justin Ridgewell'
   spec.email         = 'jridgewell@cloudspace.com'
-  spec.summary       = %q{Add Assets and Views into the Rails ETag Equation.}
+  spec.description   = %q{Account for js, css, and views when using ETags.}
+  spec.summary       = %q{Account for view code when using ETags.}
   spec.homepage      = 'http://github.com/cloudspace/ettu'
   spec.license       = 'MIT'
 
@@ -18,9 +19,9 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 1.9'
 
-  spec.add_dependency 'rails', '~> 3.0'
-  spec.add_dependency 'cache_digests'
+  spec.add_dependency 'rails', '~> 4.0'
   spec.add_development_dependency 'bundler', '~> 1.3'
   spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rspec-rails'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'simplecov'
 end

data/lib/ettu/configuration.rb

@@ -13,7 +13,9 @@ class Ettu
     private
 
     def set_defaults
-      self.assets = LateLoadAssets.new(self, :assets)
+      self.js = 'application.js'
+      self.css = 'application.css'
+      self.assets = []
 
       # Don't actually set view by default.
       # This'll allow #fetch to return the real default
@@ -21,42 +23,30 @@ class Ettu
       # self.view = "#{controller_name}/#{action_name}"
       delete :view if key? :view
 
-      self.template_digestor = LateLoadTemplateDigestor.new(self, :template_digestor)
+      # Don't attempt to reset the template_digestor
+      # if one has already been found
+      unless self.template_digestor
+        self.template_digestor = LateLoadTemplateDigestor.new(self)
+      end
     end
 
-    class LateLoad
-      def initialize(config, name)
+    class LateLoadTemplateDigestor
+      def initialize(config)
         @config = config
-        @name = name
-      end
-
-      def method_missing(method, *args, &block)
-        late_load = defaults
-        @config[@name] = late_load
-        late_load.send method, *args, &block
       end
-    end
 
-    class LateLoadAssets < LateLoad
-      def to_a
-        super
+      def digest(*args)
+        digestor = attempt_late_template_digestor_set
+        digestor.digest(*args)
       end
 
-      def defaults
-        ::Rails.application.config.assets.digests.try(:keys) || []
-      end
-    end
+      private
 
-    class LateLoadTemplateDigestor < LateLoad
-      def defaults
-        unless defined? CacheDigests::TemplateDigestor
-          # Attempt to load cache_digets
-          require 'cache_digests'
+      def attempt_late_template_digestor_set
+        # Attempt to use ActionView::Digestor
+        if defined? ActionView::Digestor
+          @config.template_digestor = ActionView::Digestor
         end
-        # Attempt to use CacheDigests::TemplateDigestor on Rails 3
-        ::CacheDigests::TemplateDigestor
-      rescue LoadError
-        raise "Ettu requires the cache_digests gem in Rails v#{Rails::VERSION::STRING}"
       end
     end
   end

data/lib/ettu/fresh_when.rb

@@ -2,12 +2,22 @@ class Ettu
   module FreshWhen
     extend ActiveSupport::Concern
 
-    def fresh_when(record_or_options, additional_options = {})
-      ettu = Ettu.new record_or_options, additional_options, self
+    included do
+      alias_method :old_fresh_when, :fresh_when
 
-      ettu_params = {etag: ettu.etags, last_modified: ettu.last_modified}
+      def fresh_when(record_or_options, additional_options = {})
+        ettu = ettu_instance(record_or_options, additional_options, self)
 
-      super nil, ettu.options.merge(ettu_params)
+        ettu_params = {etag: ettu.etags, last_modified: ettu.last_modified}
+
+        old_fresh_when nil, ettu.options.merge(ettu_params)
+      end
+    end
+
+    private
+
+    def ettu_instance(record_or_options, additional_options, controller)
+      Ettu.new record_or_options, additional_options, controller
     end
   end
 end

data/lib/ettu/railtie.rb

@@ -9,6 +9,17 @@ class Ettu
         ActiveSupport.on_load :action_controller do
           ActionController::Base.send :include, FreshWhen
         end
+
+        if app.config.ettu.development_hack
+          class BlackHole < Hash
+            def []=(k, v); end
+          end
+          module ::ActionView
+            class Digestor
+              @@cache = BlackHole.new
+            end
+          end
+        end
       end
 
     end

data/lib/ettu/version.rb

@@ -1,3 +1,3 @@
 class Ettu
-  VERSION = '3.2.0'
+  VERSION = '4.0.0'
 end

data/lib/ettu.rb

@@ -32,8 +32,11 @@ class Ettu
   def etags
     etags = [*response_etag]
     etags << view_etag
+    if @controller.request.format.try(:html?)
+      etags << js_etag
+      etags << css_etag
+    end
     etags.concat asset_etags
-    etags.compact
   end
 
   def last_modified
@@ -50,6 +53,16 @@ class Ettu
     @view_etag ||= view_digest(view)
   end
 
+  def js_etag
+    js = @options.fetch(:js, @@config.js)
+    asset_etag js
+  end
+
+  def css_etag
+    css = @options.fetch(:css, @@config.css)
+    asset_etag css
+  end
+
   def asset_etags
     assets = @options.fetch(:assets, @@config.assets)
     [*assets].map { |asset| asset_etag(asset) }
@@ -78,11 +91,10 @@ class Ettu
   def asset_digest(asset)
     return nil unless asset.present?
     # Check already computed assets (production)
-    manifest = Rails.application.config.assets.digests
-    if digest = manifest.try(:[], asset)
+    if digest = ActionView::Base.assets_manifest.assets[asset]
       digest
     else
-      # Compute it in
+      # Compute it
       Rails.application.assets[asset].digest
     end
   end

data/spec/{ettu/ettu_spec.rb → ettu_spec.rb}

@@ -1,35 +1,27 @@
 require 'spec_helper'
 
 describe Ettu do
-  subject(:ettu) { Ettu.new(hash, {}, controller) }
-
   let(:controller) { Controller.new }
   let(:record) { Record.new(DateTime.now) }
   let(:hash) { { etag: record, last_modified: DateTime.now } }
+  before(:all) do
+    Ettu.configure { |config| config.template_digestor = Digestor }
+  end
 
-  # NOTE: assets were created by running `rake assets:precompile`.
-  # It compiled application.js and application.css (but NOT
-  # test.js)
-  let(:assets) { Rails.application.config.assets.digests }
-  let(:files) { assets.keys.reject { |f| f[/index/] } }
-  let(:digests) { assets.values }
+  context 'when supplied with options' do
+    let(:hash) { { js: 'custom.js', css: 'custom.css', assets: 'first.ext', view: 'custom/action' } }
+    subject(:ettu) { Ettu.new(hash, {}, controller) }
 
-  before(:each) do
-    Ettu.configure do |config|
-      config.reset
-      config.template_digestor = Digestor
+    it 'will use :js option over default' do
+      expect(ettu.js_etag).to eq('custom.js.digest')
     end
-  end
 
-  after(:all) do
-    Ettu.configure { |config| config.reset }
-  end
-
-  context 'when supplied with options' do
-    let(:hash) { { assets: files.first, view: 'custom/action' } }
+    it 'will use :css option over default' do
+      expect(ettu.css_etag).to eq('custom.css.digest')
+    end
 
     it 'will use :asset option over default' do
-      expect(ettu.asset_etags).to eq([digests.first])
+      expect(ettu.asset_etags).to eq(['first.ext.digest'])
     end
 
     it 'will use :view option over default' do
@@ -37,84 +29,68 @@ describe Ettu do
     end
   end
 
-  context 'when given asset that is not precompiled' do
-    it 'will digest the file if it exists' do
-      # NOTE: test.js is located at dummy/app/assets/javascripts/test.js
-      # It was added AFTER running `rake assets:precompile` (which compiled
-      # application.js and application.css).
-      def hash; { assets: 'test.js' }; end
-
-      expect(ettu.asset_etags).not_to be_empty
-    end
+  describe '.configure' do
+    subject(:ettu) { Ettu.new(nil, {}, controller) }
+    after(:all) { Ettu.configure { |config| config.reset } }
 
-    it 'will throw error if file does not exist' do
-      def hash; { assets: 'does_not_exist' }; end
+    context 'when no options are specified' do
+      before(:all) do
+        Ettu.configure do |config|
+          config.js = 'custom.js'
+          config.css = 'custom.css'
+          config.assets = ['first.ext', 'second.ext']
+          config.view = 'custom/view'
+        end
+      end
 
-      expect{ ettu.asset_etags }.to raise_error
-    end
-  end
+      it 'will use the default js file' do
+        expect(ettu.js_etag).to eq('custom.js.digest')
+      end
 
-  describe '.configure' do
-    let(:hash) { nil }
+      it 'will use the default css file' do
+        expect(ettu.css_etag).to eq('custom.css.digest')
+      end
 
-    context 'when no options are specified' do
       it 'will use the default asset files' do
-        expect(ettu.asset_etags).to eq(digests)
+        expect(ettu.asset_etags).to eq(['first.ext.digest', 'second.ext.digest'])
       end
 
       it 'will use the default view file' do
-        Ettu.configure { |config| config.view = 'custom/view' }
-
         expect(ettu.view_etag).to eq('custom/view.digest')
       end
     end
 
-    context 'can append additional assets' do
-      let(:configuration) { Ettu::Configuration.new }
-      let(:random_string) { SecureRandom.hex }
-
-      it 'with +=' do
-        configuration.assets += [random_string]
-        expect(configuration.assets).to include(random_string)
+    context 'when setting default to false' do
+      before(:all) do
+        Ettu.configure do |config|
+          config.js = false
+          config.css = false
+          config.view = false
+        end
       end
 
-      it 'with <<' do
-        configuration.assets << random_string
-        expect(configuration.assets).to include(random_string)
+      it 'will disable js etag' do
+        expect(ettu.js_etag).to eq(nil)
       end
-    end
 
-    context 'when setting default to false' do
-      it 'will disable asset etags' do
-        Ettu.configure { |config| config.assets = false }
-
-        expect(ettu.asset_etags).to eq([nil])
+      it 'will disable css etag' do
+        expect(ettu.css_etag).to eq(nil)
       end
 
       it 'will disable view etags' do
-        Ettu.configure { |config| config.view = false }
-
         expect(ettu.view_etag).to eq(nil)
       end
     end
   end
 
   describe '#etags' do
-    subject(:ettu) { Ettu.new(record, {}, controller) }
-
+    let(:ettu) { Ettu.new(record, {}, controller) }
     it 'will collect all etags' do
-      expected = [record, 'controller_name/action_name.digest'] | digests
+      expected = [record, 'controller_name/action_name.digest', 'application.js.digest', 'application.css.digest']
       result = ettu.etags
-
-      expect(result).to include(*expected)
+      expect(ettu.etags).to include(*expected)
       expect(expected).to include(*result)
     end
-
-    it 'will not allow nils' do
-      ettu = Ettu.new(nil, {assets: [nil, nil, nil]}, controller )
-
-      expect(ettu.etags).not_to include(nil)
-    end
   end
 
   context 'when given only a record' do

data/spec/fixtures.rb

@@ -0,0 +1,52 @@
+class Nester < ActiveSupport::OrderedOptions
+  def initialize
+    super { |h, k| h[k] = Nester.new }
+  end
+end
+
+class Controller < Nester
+  def initialize
+    super
+
+    self.request.format['html?'] = true
+    self.controller_name = 'controller_name'
+    self.action_name = 'action_name'
+  end
+
+  def fresh_when(*args)
+    :old_fresh_when
+  end
+
+  include ::Ettu::FreshWhen
+end
+
+class Digestor
+  def self.method_missing(name, *args, &block)
+    args.first.to_s + '.digest'
+  end
+end
+
+class Record
+  attr_accessor :updated_at
+
+  def initialize(updated_at)
+    @updated_at = updated_at
+  end
+end
+
+module Rails
+  module VERSION
+    MAJOR = ''
+  end
+  def self.application
+    @nested ||= Nester.new
+  end
+end
+Rails.application.assets['application.js'].digest = 'application.js.digest'
+Rails.application.assets['application.css'].digest = 'application.css.digest'
+Rails.application.assets['custom.js'].digest = 'custom.js.digest'
+Rails.application.assets['custom.css'].digest = 'custom.css.digest'
+Rails.application.assets['first.ext'].digest = 'first.ext.digest'
+Rails.application.assets['second.ext'].digest = 'second.ext.digest'
+Rails.application.config.assets.digests = nil
+

data/spec/fresh_when_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+
+describe Ettu::FreshWhen do
+  before(:all) do
+    Ettu.configure { |config| config.template_digestor = Digestor }
+  end
+
+  let(:ettu) { double }
+  let(:record) { Record.new(DateTime.now) }
+  let(:hash) { { random: true, options: true } }
+  subject(:controller) { Controller.new }
+
+  before(:each) do
+    controller.stub(ettu_instance: ettu)
+    ettu.stub(:etags)
+    ettu.stub(:last_modified)
+    ettu.stub(options: {})
+  end
+
+  it 'calls Ettu#etags' do
+    ettu.should_receive(:etags)
+    controller.fresh_when record, hash
+  end
+
+  it 'calls Ettu#last_modified' do
+    ettu.should_receive(:last_modified)
+    controller.fresh_when record, hash
+  end
+
+  it 'passes nil as the first argument to original fresh_when' do
+    controller.should_receive(:old_fresh_when) do |r, h|
+      r.nil?
+    end
+    controller.fresh_when record, hash
+  end
+
+  it 'passes extra options to original fresh_when' do
+    controller.should_receive(:old_fresh_when) do |r, h|
+      hash.each_pair.all? do |k, v|
+        h[k] == v
+      end
+    end
+    controller.fresh_when record, hash
+  end
+end

data/spec/spec_helper.rb

@@ -1,29 +1,20 @@
-ENV['RAILS_ENV'] ||= 'test'
-require File.expand_path('../dummy/config/environment', __FILE__)
-require 'rspec/rails'
-require 'rspec/autorun'
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
 require 'date'
 require 'active_support/ordered_options'
-require 'securerandom'
 
-# Requires supporting ruby files with custom matchers and macros, etc,
-# in spec/support/ and its subdirectories.
-Dir[File.join(File.expand_path('..', __FILE__), 'support/**/*.rb')].each { |f| require f }
+require 'simplecov'
+SimpleCov.start { add_filter '/spec/' }
 
 require 'ettu'
-
+require 'fixtures'
 
 RSpec.configure do |config|
   config.run_all_when_everything_filtered = true
-
-  # If true, the base class of anonymous controllers will be inferred
-  # automatically. This will be the default behavior in future versions of
-  # rspec-rails.
-  config.infer_base_class_for_anonymous_controllers = false
-
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
   config.order = 'random'
 end