deface 1.5.0 → 1.9.0

data/lib/deface/template_helper.rb

@@ -1,32 +1,58 @@
 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 = nil
         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
+
+          syntax = Deface::ActionViewExtensions.determine_syntax(view.handler)
+          overrides = Deface::Override.find(
+            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),
+          )
+
+          if syntax && overrides.any?
+            source = Deface::Override.convert_source(source, syntax: syntax)
+            source = Deface::Override.apply_overrides(source, overrides: overrides)
+          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.9.0'
+
+  def gem_version
+    Gem::Version.new(VERSION)
+  end
+end

data/lib/deface.rb

@@ -1,5 +1,6 @@
 require "action_view"
 require "action_controller"
+require "deface/errors"
 require "deface/template_helper"
 require "deface/original_validator"
 require "deface/applicator"
@@ -38,18 +39,21 @@ require "deface/matchers/range"
 require "deface/environment"
 require "deface/precompiler"
 
+require "deface/railtie" if defined?(Rails)
+
 module Deface
-  if defined?(Rails)
-    require "deface/railtie"
+  @before_rails_6 = ActionView.gem_version < Gem::Version.new('6.0.0')
+  @template_class = @before_rails_6 ? ActionView::CompiledTemplates : ActionDispatch::DebugView
+
+  def self.before_rails_6?
+    @before_rails_6
+  end
+
+  def self.template_class
+    @template_class
   end
 
   if defined?(ActiveSupport::Digest)
     Deface::Digest.digest_class = ActiveSupport::Digest
   end
-
-  # Exceptions
-  class DefaceError < StandardError; end
-
-  class NotSupportedError < DefaceError; end
-
 end

data/spec/deface/action_view_template_spec.rb

@@ -1,94 +1,152 @@
 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 after_rails_6: true do
+    skip "This spec is targeted at Rails v6+" if Deface.before_rails_6?
+  end
 
-      it "should return unmodified source" do
-        expect(@template.source).to eq("<p>test</p>")
-      end
+  before before_rails_6: true do
+    skip "This spec is targeted at Rails before v6+" unless Deface.before_rails_6?
+  end
 
-      it "should not change updated_at" do
-        expect(@template.updated_at).to eq(@updated_at)
-      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
 
+    it "should return unmodified source" do
+      expect(template.source).to eq("<p>test</p>")
     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 not change updated_at", :before_rails_6 do
+      expect(template.updated_at).to eq(updated_at)
+    end
+  end
 
-      it "should return modified source" do
-        expect(@template.source).to eq("<%= raw(text) %>")
-      end
+  describe "unsupported 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 }
 
-      it "should change updated_at" do
-        expect(@template.updated_at).to be > @updated_at
-      end
+    before(:each) do
+      Deface::Override.new(virtual_path: "posts/index", name: "Posts#index", remove: "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 return hash of overrides plus original method_name " do
-        deface_hash = Deface::Override.digest(:virtual_path => 'posts/index')
+    it "should return unmodified source" do
+      expect(template.source).to eq("xml.post => :blah")
+      expect(template.source).not_to include("=&gt;")
+    end
+  end
 
-        expect(template.send(:method_name)).to eq("_#{Digest::MD5.new.update("#{deface_hash}_#{template.send(:method_name_without_deface)}").hexdigest}")
+  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 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/
+  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 "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 'renders the template modified by deface using :remove' do
+      Deface::Override.new(
+        virtual_path: virtual_path,
+        name: "Posts#index",
+        remove: "p",
+      )
 
-      it "should return unmodified source" do
-        #if processed, source would include "=&gt;"
-        expect(@template.source).to eq("xml.post => :blah")
+      expect(template.render(view, local_assigns)).to eq(%{"some <br> text"})
+    end
+
+    context 'with a haml template' do
+      let(:source) { "%p test\n= raw(text)\n" }
+      let(:handler) { Haml::Plugin }
+
+      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(%{\nsome <br> text})
       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
+    context 'with a slim template' do
+      let(:source) { "p test\n= raw(text)\n" }
+      let(:handler) { Slim::RailsTemplate.new }
+
+      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(%{\nsome <br> text\n})
       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

@@ -28,6 +28,16 @@ module Deface
         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' />")

data/spec/deface/override_spec.rb

@@ -561,7 +561,7 @@ module Deface
 
     describe "#expire_compiled_template" do
       it "should remove compiled method when method name matches virtual path but not digest" do
-        if Rails.version < "6.0.0.beta1"
+        if Deface.before_rails_6?
           instance_methods_count = ActionView::CompiledTemplates.instance_methods.size
 
           module ActionView::CompiledTemplates
@@ -598,7 +598,7 @@ module Deface
       end
 
       it "should not remove compiled method when virtual path and digest matach" do
-        if Rails.version < "6.0.0.beta1"
+        if Deface.before_rails_6?
           instance_methods_count = ActionView::CompiledTemplates.instance_methods.size
 
           module ActionView::CompiledTemplates

data/spec/deface/search_spec.rb

@@ -20,6 +20,12 @@ module Deface
       it "should return empty array when no details hash passed" do
         expect(Deface::Override.find({})).to eq([])
       end
+
+      context 'with a frozen string as virtual_path' do
+        it 'works' do
+          expect(Deface::Override.find({:virtual_path => "posts/index".freeze}).size).to eq(1)
+        end
+      end
     end
 
     describe "#find_using" do

data/spec/spec_helper.rb

@@ -2,13 +2,12 @@ require 'simplecov'
 SimpleCov.start 'rails'
 require 'rspec'
 require 'active_support'
-require 'action_view'
-require 'action_controller'
 require 'deface'
 require 'rails/generators'
 # have to manually require following for testing purposes
 require 'deface/action_view_extensions'
 require 'rails/version'
+require 'pry'
 
 #adding fake class as it's needed by haml 4.0, don't
 #want to have to require the entire rails stack in specs.
@@ -42,7 +41,7 @@ RSpec.configure do |config|
   config.mock_framework = :rspec
 end
 
-if Rails.version < "6.0.0.beta1"
+if Deface.before_rails_6?
   module ActionView::CompiledTemplates
     #empty module for testing purposes
   end
@@ -69,9 +68,7 @@ shared_context "mock Rails" do
     allow(Rails.application.config).to receive(:deface).and_return ActiveSupport::OrderedOptions.new
     Rails.application.config.deface.enabled = true
 
-    if Rails.version[0..2] >= '3.2'
-      allow(Rails.application.config).to receive(:watchable_dirs).and_return({})
-    end
+    allow(Rails.application.config).to receive(:watchable_dirs).and_return({})
 
     allow(Rails).to receive(:root).and_return Pathname.new('spec/dummy')