deface 1.5.2 → 1.7.0

data/lib/deface/applicator.rb

@@ -48,10 +48,8 @@ module Deface
             end
           end
 
-          if Rails.gem_version < Gem::Version.new('6.0.0')
-            #prevents any caching by rails in development mode
-            details[:updated_at] = Time.now
-          end
+          # Prevents any caching by rails in development mode.
+          details[:updated_at] = Time.now if Deface.before_rails_6?
 
           source = doc.to_s
 

data/lib/deface/environment.rb

@@ -57,13 +57,7 @@ module Deface
       Deface::DSL::Loader.register
 
       # check all railties / engines / extensions / application for overrides
-      railties = if Rails.version >= "4.0"
-        app.railties._all
-      else
-        app.railties.all
-      end
-
-      railties.dup.push(app).each do |railtie|
+      app.railties._all.dup.push(app).each do |railtie|
         next unless railtie.respond_to? :root
         load_overrides(railtie)
       end
@@ -89,11 +83,9 @@ module Deface
         paths ||= ["app/overrides"]
 
         paths.each do |path|
-          if Rails.version[0..2] >= "3.2"
-            # add path to watchable_dir so Rails will call to_prepare on file changes
-            # allowing overrides to be updated / reloaded in development mode.
-            Rails.application.config.watchable_dirs[root.join(path).to_s] = [:rb, :deface]
-          end
+          # add path to watchable_dir so Rails will call to_prepare on file changes
+          # allowing overrides to be updated / reloaded in development mode.
+          Rails.application.config.watchable_dirs[root.join(path).to_s] = [:rb, :deface]
 
           Dir.glob(root.join path, "**/*.rb") do |c|
             Rails.application.config.cache_classes ? require(c) : load(c)

data/lib/deface/errors.rb

@@ -0,0 +1,5 @@
+module Deface
+  class DefaceError < StandardError; end
+
+  class NotSupportedError < DefaceError; end
+end

data/lib/deface/override.rb

@@ -211,28 +211,22 @@ module Deface
 
     private
 
-      # check if method is compiled for the current virtual path
-      #
-      def expire_compiled_template
-        if Gem.loaded_specs["rails"].version < Gem::Version.new("6.0.0.beta1")
-          if compiled_method_name = ActionView::CompiledTemplates.instance_methods.detect { |name| name =~ /#{args[:virtual_path].gsub(/[^a-z_]/, '_')}/ }
-            #if the compiled method does not contain the current deface digest
-            #then remove the old method - this will allow the template to be
-            #recompiled the next time it is rendered (showing the latest changes)
-
-            unless compiled_method_name =~ /\A_#{self.class.digest(:virtual_path => @args[:virtual_path])}_/
-              ActionView::CompiledTemplates.send :remove_method, compiled_method_name
-            end
-          end
-        else
-          if compiled_method_name = ActionDispatch::DebugView.instance_methods.detect { |name| name =~ /#{args[:virtual_path].gsub(/[^a-z_]/, '_')}/ }
-            unless compiled_method_name =~ /\A_#{self.class.digest(:virtual_path => @args[:virtual_path])}_/
-              ActionDispatch::DebugView.send :remove_method, compiled_method_name
-            end
-          end
-        end
+    # Check if method is compiled for the current virtual path.
+    #
+    # If the compiled method does not contain the current deface digest
+    # then remove the old method - this will allow the template to be
+    # recompiled the next time it is rendered (showing the latest changes).
+    def expire_compiled_template
+      virtual_path = args[:virtual_path]
+
+      method_name = Deface.template_class.instance_methods.detect do |name|
+        name =~ /#{virtual_path.gsub(/[^a-z_]/, '_')}/
       end
 
+      if method_name && method_name !~ /\A_#{self.class.digest(virtual_path: virtual_path)}_/
+        Deface.template_class.send :remove_method, method_name
+      end
+    end
   end
 
 end

data/lib/deface/railtie.rb

@@ -36,19 +36,15 @@ module Deface
     initializer "deface.tweak_eager_loading", :before => :set_load_path do |app|
 
       # application
-      app.config.eager_load_paths = app.config.eager_load_paths.reject { |path| path.to_s  =~ /app\/overrides\z/ }
+      tweak_eager_loading(app)
 
       # railites / engines / extensions
-      railties = if Rails.version >= "4.0"
-        app.railties._all
-      else
-        app.railties.all
-      end
-
-      railties.each do |railtie|
+      app.railties._all.each do |railtie|
         next unless railtie.respond_to?(:root) && railtie.config.respond_to?(:eager_load_paths)
-        railtie.config.eager_load_paths = railtie.config.eager_load_paths.reject { |path| path.to_s  =~ /app\/overrides\z/ }
+
+        tweak_eager_loading(railtie)
       end
+
     end
 
     # sets up deface environment and requires / loads all
@@ -87,5 +83,15 @@ module Deface
       end
     end
 
+    private
+
+    def tweak_eager_loading(railtie)
+      paths_to_reject = railtie.config.eager_load_paths.select { |path| path.to_s  =~ /app\/overrides\z/ }
+      railtie.config.eager_load_paths = railtie.config.eager_load_paths.reject { |path| path.in?(paths_to_reject) }
+
+      if Rails.configuration.respond_to?(:autoloader) && Rails.configuration.autoloader == :zeitwerk
+        Rails.autoloaders.each { |autoloader| autoloader.ignore(*paths_to_reject) }
+      end
+    end
   end
 end

data/lib/deface/template_helper.rb

@@ -1,32 +1,55 @@
 module Deface
   module TemplateHelper
+    def self.lookup_context
+      @lookup_context ||= ActionView::LookupContext.new(
+        ActionController::Base.view_paths, {:formats => [:html]}
+      )
+    end
 
     # used to find source for a partial or template using virtual_path
-    def load_template_source(virtual_path, partial, apply_overrides=true)
+    def load_template_source(virtual_path, partial, apply_overrides=true, lookup_context: Deface::TemplateHelper.lookup_context)
       parts = virtual_path.split("/")
-      prefix = []
+
       if parts.size == 2
-        prefix << ""
+        prefix = ""
         name = virtual_path
       else
-        prefix << parts.shift
+        prefix = parts.shift
         name = parts.join("/")
       end
 
-      #this needs to be reviewed for production mode, overrides not present
-      Rails.application.config.deface.enabled = apply_overrides
-      @lookup_context ||= ActionView::LookupContext.new(ActionController::Base.view_paths, {:formats => [:html]})
-      view = @lookup_context.disable_cache do
-        @lookup_context.find(name, prefix, partial)
-      end
+      view = lookup_context.disable_cache { lookup_context.find(name, [prefix], partial) }
 
-      if view.handler.to_s == "Haml::Plugin"
-        Deface::HamlConverter.new(view.source).result
-      elsif view.handler.class.to_s == "Slim::RailsTemplate"
-        Deface::SlimConverter.new(view.source).result
-      else
-        view.source
+      source =
+        if view.handler.to_s == "Haml::Plugin"
+          Deface::HamlConverter.new(view.source).result
+        elsif view.handler.class.to_s == "Slim::RailsTemplate"
+          Deface::SlimConverter.new(view.source).result
+        else
+          view.source
+        end
+
+      if apply_overrides
+        begin
+          # This needs to be reviewed for production mode, overrides not present
+          original_enabled = Rails.application.config.deface.enabled
+          Rails.application.config.deface.enabled = apply_overrides
+
+          if (syntax = Deface::ActionViewExtensions.determine_syntax(view.handler))
+            details = {
+              locals: view.instance_variable_get(:@locals),
+              format: view.instance_variable_get(:@format),
+              variant: view.instance_variable_get(:@variant),
+              virtual_path: view.instance_variable_get(:@virtual_path),
+            }
+            source = Deface::Override.apply(source, details, true, syntax)
+          end
+        ensure
+          Rails.application.config.deface.enabled = original_enabled
+        end
       end
+
+      source
     end
 
     #gets source erb for an element

data/lib/deface/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Deface
+  VERSION = '1.7.0'
+
+  def gem_version
+    Gem::Version.new(VERSION)
+  end
+end

data/spec/deface/action_view_template_spec.rb

@@ -1,101 +1,123 @@
 require 'spec_helper'
 
-module ActionView
-  describe Template do
-    include_context "mock Rails.application"
-
-    describe "with no overrides defined" do
-      before(:each) do
-        @updated_at = Time.now - 600
-        @template = ActionView::Template.new("<p>test</p>", "/some/path/to/file.erb", ActionView::Template::Handlers::ERB, {:virtual_path=>"posts/index", :format=>:html, :updated_at => @updated_at})
-        #stub for Rails < 3.1
-        unless defined?(@template.updated_at)
-          allow(@template).to receive(:updated_at).and_return(@updated_at)
-        end
-      end
-
-      it "should initialize new template object" do
-        expect(@template.is_a?(ActionView::Template)).to eq(true)
-      end
+describe Deface::ActionViewExtensions do
+  include_context "mock Rails.application"
 
-      it "should return unmodified source" do
-        expect(@template.source).to eq("<p>test</p>")
-      end
+  before after_rails_6: true do
+    skip "This spec is targeted at Rails v6+" if Deface.before_rails_6?
+  end
 
-      it "should not change updated_at" do
-        expect(@template.updated_at).to eq(@updated_at)
-      end
+  before before_rails_6: true do
+    skip "This spec is targeted at Rails before v6+" unless Deface.before_rails_6?
+  end
 
+  let(:template) { ActionView::Template.new(
+    source,
+    path,
+    handler,
+    **options,
+    **(Deface.before_rails_6? ? {updated_at: updated_at} : {})
+  ) }
+
+  let(:source) { "<p>test</p>" }
+  let(:path) { "/some/path/to/file.erb" }
+  let(:handler) { ActionView::Template::Handlers::ERB }
+  let(:options) {{
+    virtual_path: virtual_path,
+    format: format,
+    locals: {}
+  }}
+  let(:format) { :html }
+  let(:virtual_path) { "posts/index" }
+
+  let(:updated_at) { Time.now - 600 }
+
+  describe "with no overrides defined" do
+    it "should initialize new template object" do
+      expect(template.is_a?(ActionView::Template)).to eq(true)
     end
 
-    describe "with a single remove override defined" do
-      before(:each) do
-        @updated_at = Time.now - 300
-        Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :remove => "p", :text => "<h1>Argh!</h1>")
-        @template = ActionView::Template.new("<p>test</p><%= raw(text) %>", "/some/path/to/file.erb", ActionView::Template::Handlers::ERB, {:virtual_path=>"posts/index", :format=>:html, :updated_at => @updated_at})
-        #stub for Rails < 3.1
-        unless defined?(@template.updated_at)
-          allow(@template).to receive(:updated_at).and_return(@updated_at + 500)
-        end
-      end
-
-      it "should return modified source" do
-        expect(@template.source).to eq("<%= raw(text) %>")
-      end
-
-      if Rails.gem_version >= Gem::Version.new('6.0.0')
-        it "should not change updated_at" do
-          expect(@template.updated_at).to eq(@updated_at)
-        end
-      else
-        it "should change updated_at" do
-          expect(@template.updated_at).to be > @updated_at
-        end
-      end
+    it "should return unmodified source" do
+      expect(template.source).to eq("<p>test</p>")
     end
 
-    describe "method_name" do
-      let(:template) { ActionView::Template.new("<p>test</p>", "/some/path/to/file.erb", ActionView::Template::Handlers::ERB, {:virtual_path=>"posts/index", :format=>:html, :updated_at => (Time.now - 100)}) }
+    it "should not change updated_at", :before_rails_6 do
+      expect(template.updated_at).to eq(updated_at)
+    end
+  end
 
-      it "should return hash of overrides plus original method_name " do
-        deface_hash = Deface::Override.digest(:virtual_path => 'posts/index')
+  describe "non erb or haml template" do
+    let(:source) { "xml.post => :blah" }
+    let(:path) { "/some/path/to/file.erb" }
+    let(:handler) { ActionView::Template::Handlers::Builder }
+    let(:updated_at) { Time.now - 100 }
+    let(:format) { :xml }
 
-        expect(template.send(:method_name)).to eq("_#{Digest::MD5.new.update("#{deface_hash}_#{template.send(:method_name_without_deface)}").hexdigest}")
-      end
+    before(:each) do
+      Deface::Override.new(virtual_path: "posts/index", name: "Posts#index", remove: "p")
+    end
 
-      it "should alias original method_name method" do
-        expect(template.send(:method_name_without_deface)).to match /\A__some_path_to_file_erb_+[0-9]+_+[0-9]+\z/
-      end
+    it "should return unmodified source" do
+      expect(template.source).to eq("xml.post => :blah")
+      expect(template.source).not_to include("=&gt;")
     end
+  end
 
-    describe "non erb or haml template" do
-      before(:each) do
-        Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :remove => "p")
-        @template = ActionView::Template.new("xml.post => :blah", "/some/path/to/file.erb", ActionView::Template::Handlers::Builder, {:virtual_path=>"posts/index", :format=>:xml, :updated_at => (Time.now - 100)})
+  describe ".determine_syntax(handler)" do
+    let(:source) { "xml.post => :blah" }
+    let(:format) { :xml }
+
+    # Not so BDD, but it keeps us from making mistakes in the future for instance,
+    # we test ActionView::Template here with a handler == ....::Handlers::ERB,
+    # while in rails it seems it's an instance of ...::Handlers::ERB.
+    it "recognizes supported syntaxes" do
+      expectations = { Haml::Plugin => :haml,
+                       ActionView::Template::Handlers::ERB => :erb,
+                       ActionView::Template::Handlers::ERB.new => :erb,
+                       ActionView::Template::Handlers::Builder => nil }
+      expectations.each do |handler, expected|
+        expect(template.is_a?(ActionView::Template)).to eq(true)
+        expect(described_class.determine_syntax(handler)).to eq(expected), "unexpected result for handler #{handler}"
       end
+    end
+  end
 
-      it "should return unmodified source" do
-        #if processed, source would include "=&gt;"
-        expect(@template.source).to eq("xml.post => :blah")
+  describe '#render' do
+    let(:source) { "<p>test</p><%= raw(text) %>".inspect }
+    let(:local_assigns) { {text: "some <br> text"} }
+    let(:lookup_context) { ActionView::LookupContext.new(["#{__dir__}/views"]) }
+    let(:view) do
+      if Rails::VERSION::STRING >= '6.1'
+        ActionView::Base.with_empty_template_cache.new(lookup_context, {}, nil)
+      else
+        ActionView::Base.new(lookup_context)
       end
     end
+    let(:options) { {
+      virtual_path: virtual_path,
+      format: format,
+      locals: local_assigns.keys
+    } }
+
+    it 'renders the template modified by deface using :replace' do
+      Deface::Override.new(
+        virtual_path: virtual_path,
+        name: "Posts#index",
+        replace: "p",
+        text: "<h1>Argh!</h1>"
+      )
+
+      expect(template.render(view, local_assigns)).to eq(%{"<h1>Argh!</h1>some <br> text"})
+    end
 
-    describe "#should_be_defaced?(handler) method" do
-      #not so BDD, but it keeps us from making mistakes in the future
-      #for instance, we test ActionView::Template here with a handler == ....::Handlers::ERB,
-      #while in rails it seems it's an instance of ...::Handlers::ERB
-      it "should be truthy only for haml/erb handlers and their instances" do
-        expectations = { Haml::Plugin => true,
-                         ActionView::Template::Handlers::ERB => true,
-                         ActionView::Template::Handlers::ERB.new => true,
-                         ActionView::Template::Handlers::Builder => false }
-        expectations.each do |handler, expected|
-          @template = ActionView::Template.new("xml.post => :blah", "/some/path/to/file.erb", handler, {:virtual_path=>"posts/index", :format=>:xml, :updated_at => (Time.now - 100)})
-          expect(@template.is_a?(ActionView::Template)).to eq(true)
-          syntax = @template.send(:determine_syntax, handler)
-          expect(@template.send(:should_be_defaced?, syntax)).to eq(expected), "unexpected result for handler "+handler.to_s
-        end
-      end
+    it 'renders the template modified by deface using :remove' do
+      Deface::Override.new(
+        virtual_path: virtual_path,
+        name: "Posts#index",
+        remove: "p",
+      )
+
+      expect(template.render(view, local_assigns)).to eq(%{"some <br> text"})
     end
   end
 end

data/spec/deface/environment_spec.rb

@@ -19,8 +19,6 @@ module Deface
       Deface::Override.new(:virtual_path => "posts/new", :name => "Posts#new", :replace => "h1", :text => "<h1>argh!</h1>")
     end
 
-    let(:railties_collection_accessor) { Rails.version >= "4.0" ? :_all : :all }
-
     describe ".overrides" do
 
       it "should return all overrides" do
@@ -37,7 +35,7 @@ module Deface
         before do
           allow(Rails.application).to receive_messages :root => Pathname.new(File.join(File.dirname(__FILE__), '..', "assets"))
           allow(Rails.application).to receive_messages :paths => {}
-          allow(Rails.application).to receive_message_chain :railties, railties_collection_accessor => []
+          allow(Rails.application).to receive_message_chain :railties, :_all => []
 
           expect(Deface::DSL::Loader).to receive(:register)
         end
@@ -54,7 +52,7 @@ module Deface
         end
 
         it "should enumerate_and_load nil when railtie has no app/overrides path set" do
-          allow(Rails.application).to receive_message_chain :railties, railties_collection_accessor => [double('railtie', :root => "/some/path")]
+          allow(Rails.application).to receive_message_chain :railties, :_all => [double('railtie', :root => "/some/path")]
 
           expect(Rails.application.config.deface.overrides).to receive(:enumerate_and_load).with(nil, Rails.application.root)
           expect(Rails.application.config.deface.overrides).to receive(:enumerate_and_load).with(nil, "/some/path")
@@ -62,7 +60,7 @@ module Deface
         end
 
         it "should enumerate_and_load path when railtie has app/overrides path set" do
-          allow(Rails.application).to receive_message_chain :railties, railties_collection_accessor => [ double('railtie', :root => "/some/path", :paths => {"app/overrides" => ["app/some_path"] } )]
+          allow(Rails.application).to receive_message_chain :railties, :_all => [ double('railtie', :root => "/some/path", :paths => {"app/overrides" => ["app/some_path"] } )]
 
           expect(Rails.application.config.deface.overrides).to receive(:enumerate_and_load).with(nil, Rails.application.root)
           expect(Rails.application.config.deface.overrides).to receive(:enumerate_and_load).with(["app/some_path"] , "/some/path")
@@ -70,7 +68,7 @@ module Deface
         end
 
         it "should enumerate_and_load railties first, followed by the application iteslf" do
-          allow(Rails.application).to receive_message_chain :railties, railties_collection_accessor => [ double('railtie', :root => "/some/path", :paths => {"app/overrides" => ["app/some_path"] } )]
+          allow(Rails.application).to receive_message_chain :railties, :_all => [ double('railtie', :root => "/some/path", :paths => {"app/overrides" => ["app/some_path"] } )]
 
           expect(Rails.application.config.deface.overrides).to receive(:enumerate_and_load).with(["app/some_path"] , "/some/path").ordered
           expect(Rails.application.config.deface.overrides).to receive(:enumerate_and_load).with(nil, Rails.application.root).ordered
@@ -79,7 +77,7 @@ module Deface
 
         it "should ignore railtie with no root" do
           railtie = double('railtie')
-          allow(Rails.application).to receive_message_chain :railties, railties_collection_accessor => [railtie]
+          allow(Rails.application).to receive_message_chain :railties, :_all => [railtie]
 
           expect(railtie).to receive(:respond_to?).with(:root)
           expect(railtie).not_to receive(:respond_to?).with(:paths)
@@ -101,7 +99,7 @@ module Deface
 
         it "should keep a reference to which railtie/app defined the override" do
           allow(Rails.application).to receive_messages :root => assets_path, :paths => {"app/overrides" => ["dummy_app"] }
-          allow(Rails.application).to receive_message_chain :railties, railties_collection_accessor => [ engine ]
+          allow(Rails.application).to receive_message_chain :railties, :_all => [ engine ]
 
           Rails.application.config.deface.overrides.load_all(Rails.application)
 
@@ -127,10 +125,8 @@ module Deface
         end
 
         it "should add paths to watchable_dir when running Rails 3.2" do
-          if Rails.version[0..2] >= '3.2'
-            Rails.application.config.deface.overrides.send(:enumerate_and_load, ["app/gold"], root)
-            expect(Rails.application.config.watchable_dirs).to eq({"/some/path/app/gold" => [:rb, :deface] })
-          end
+          Rails.application.config.deface.overrides.send(:enumerate_and_load, ["app/gold"], root)
+          expect(Rails.application.config.watchable_dirs).to eq({"/some/path/app/gold" => [:rb, :deface] })
         end
 
       end