deface 1.4.0 → 1.6.0

data/lib/deface/applicator.rb

@@ -48,8 +48,8 @@ module Deface
             end
           end
 
-          #prevents any caching by rails in development mode
-          details[:updated_at] = Time.now
+          # 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/haml_converter.rb

@@ -37,6 +37,7 @@ module Deface
       # coverts { attributes into deface compatibily attributes
       def deface_attributes(attrs)
         return if attrs.nil?
+        return attrs if attrs.scan(/\{/).count > 1
 
         attrs.gsub! /\{|\}/, ''
 

data/lib/deface/override.rb

@@ -211,21 +211,22 @@ module Deface
 
     private
 
-      # check if method is compiled for the current virtual path
-      #
-      def expire_compiled_template
-        if compiled_method_name = ActionView::Base.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::Base.send :remove_method, compiled_method_name
-          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/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Deface
+  VERSION = "1.6.0"
+end

data/spec/deface/action_view_template_spec.rb

@@ -1,95 +1,146 @@
 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
+describe Deface::ActionViewExtensions do
+  include_context "mock Rails.application"
 
-      it "should initialize new template object" do
-        expect(@template.is_a?(ActionView::Template)).to eq(true)
-      end
+  before supports_updated_at: true do
+    skip "Current Rails doesn't support the updated_at attribute on ActionView" unless supports_updated_at?
+  end
 
-      it "should return unmodified source" do
-        expect(@template.source).to eq("<p>test</p>")
-      end
+  let(:template) { ActionView::Template.new(
+    source,
+    path,
+    handler,
+    **options,
+    **(supports_updated_at? ? {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(:supports_updated_at?) { Deface.before_rails_6? }
+  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
 
-      it "should not change updated_at" do
-        expect(@template.updated_at).to eq(@updated_at)
-      end
+    it "should return unmodified source" do
+      expect(template.source).to eq("<p>test</p>")
+    end
 
+    it "should not change updated_at", :supports_updated_at do
+      expect(template.updated_at).to eq(updated_at)
     end
+  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
+  describe "with a single remove override defined" do
+    let(:updated_at) { Time.now - 300 }
+    let(:source) { "<p>test</p><%= raw(text) %>" }
 
-      it "should return modified source" do
-        expect(@template.source).to eq("<%= raw(text) %>")
-      end
+    before do
+      Deface::Override.new(virtual_path: "posts/index", name: "Posts#index", remove: "p", text: "<h1>Argh!</h1>")
+    end
 
-      it "should change updated_at" do
-        expect(@template.updated_at).to be > @updated_at
-      end
+    it "should return modified source" do
+      expect(template.source).to eq("<%= raw(text) %>")
+    end
+
+    it "should change updated_at", :supports_updated_at do
+      expect(template.updated_at).to be > updated_at
     end
+  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)}) }
+  describe "#method_name" do
+    before do
+      ActionView::Template.define_method(
+        :method_name_without_deface,
+        ActionView::Template.instance_method(:method_name)
+      )
+    end
 
-      it "should return hash of overrides plus original method_name " do
-        deface_hash = Deface::Override.digest(:virtual_path => 'posts/index')
+    it "returns hash of overrides plus original method_name " do
+      deface_hash = Deface::Override.digest(virtual_path: 'posts/index')
+      super_method = template.method(:method_name).super_method
+      method_name = "_#{Digest::MD5.new.update("#{deface_hash}_#{super_method.call}").hexdigest}"
 
-        expect(template.send(:method_name)).to eq("_#{Digest::MD5.new.update("#{deface_hash}_#{template.send(:method_name_without_deface)}").hexdigest}")
-      end
+      expect(template.send(:method_name)).to eq(method_name)
+    end
+  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
+  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 }
+
+    before(:each) do
+      Deface::Override.new(virtual_path: "posts/index", name: "Posts#index", remove: "p")
     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)})
-      end
+    it "should return unmodified source" do
+      expect(template.source).to eq("xml.post => :blah")
+      expect(template.source).not_to include("=&gt;")
+    end
+  end
 
-      it "should return unmodified source" do
-        #if processed, source would include "=&gt;"
-        expect(@template.source).to eq("xml.post => :blah")
+  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
 
-    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
+  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
+    } }
+
+    let!(:deface) {
+      Deface::Override.new(
+        virtual_path: virtual_path,
+        name: "Posts#index",
+        replace: "p",
+        text: "<h1>Argh!</h1>"
+      )
+    }
+
+    it 'renders the template modified by deface' do
+      expect(template.render(view, local_assigns)).to eq(%{"<h1>Argh!</h1>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

data/spec/deface/haml_converter_spec.rb

@@ -24,18 +24,28 @@ module Deface
       end
 
       it "should handle simple haml attributes" do
-        expect(haml_to_erb("%meta{:charset => 'utf-8'}")).to eq("<meta charset='utf-8'>")
+        expect(haml_to_erb("%meta{:charset => 'utf-8'}")).to eq("<meta charset='utf-8' />")
         expect(haml_to_erb("%p(alt='hello world')Hello World!")).to eq("<p alt='hello world'>Hello World!</p>")
       end
 
+      it "should handle recursive attributes" do
+        expect(haml_to_erb("%div{:data => {:foo => 'bar'}}")).to eq("<div data-foo='bar'></div>")
+        expect(haml_to_erb("%div{:data => {:foo => { :bar => 'baz' }, :qux => 'corge'}}")).to eq("<div data-foo-bar='baz' data-qux='corge'></div>")
+
+        if RUBY_VERSION > "1.9"
+          expect(haml_to_erb("%div{data: {foo: 'bar'}}")).to eq("<div data-foo='bar'></div>")
+          expect(haml_to_erb("%div{data: {foo: { bar: 'baz' }, qux: 'corge'}}")).to eq("<div data-foo-bar='baz' data-qux='corge'></div>")
+        end
+      end
+
       it "should handle haml attributes with commas" do
-        expect(haml_to_erb("%meta{'http-equiv' => 'X-UA-Compatible', :content => 'IE=edge,chrome=1'}")).to eq("<meta content='IE=edge,chrome=1' http-equiv='X-UA-Compatible'>")
-        expect(haml_to_erb("%meta(http-equiv='X-UA-Compatible' content='IE=edge,chrome=1')")).to eq("<meta content='IE=edge,chrome=1' http-equiv='X-UA-Compatible'>")
-        expect(haml_to_erb('%meta{:name => "author", :content => "Example, Inc."}')).to eq("<meta content='Example, Inc.' name='author'>")
-        expect(haml_to_erb('%meta(name="author" content="Example, Inc.")')).to eq("<meta content='Example, Inc.' name='author'>")
+        expect(haml_to_erb("%meta{'http-equiv' => 'X-UA-Compatible', :content => 'IE=edge,chrome=1'}")).to eq("<meta content='IE=edge,chrome=1' http-equiv='X-UA-Compatible' />")
+        expect(haml_to_erb("%meta(http-equiv='X-UA-Compatible' content='IE=edge,chrome=1')")).to eq("<meta content='IE=edge,chrome=1' http-equiv='X-UA-Compatible' />")
+        expect(haml_to_erb('%meta{:name => "author", :content => "Example, Inc."}')).to eq("<meta content='Example, Inc.' name='author' />")
+        expect(haml_to_erb('%meta(name="author" content="Example, Inc.")')).to eq("<meta content='Example, Inc.' name='author' />")
 
         if RUBY_VERSION > "1.9"
-          expect(haml_to_erb('%meta{name: "author", content: "Example, Inc."}')).to eq("<meta content='Example, Inc.' name='author'>")
+          expect(haml_to_erb('%meta{name: "author", content: "Example, Inc."}')).to eq("<meta content='Example, Inc.' name='author' />")
         end
       end