deface 1.5.0 → 1.9.0

data/bin/sandbox-setup

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+extend FileUtils
+
+system 'bin/rails g scaffold Post title body'
+system 'bin/rails db:migrate'
+
+mkdir_p 'sandbox/app/overrides'
+
+File.write 'sandbox/app/views/posts/_haml_partial.html.haml', <<~HAML
+  %h2 hello from haml
+HAML
+
+File.write 'sandbox/app/views/posts/_slim_partial.html.slim', <<~SLIM
+  h2 hello from slim
+SLIM
+
+File.write 'sandbox/app/views/posts/_haml_defaced_partial.html.haml', <<~HAML
+  %h3 hello from defaced haml
+HAML
+
+File.write 'sandbox/app/views/posts/_slim_defaced_partial.html.slim', <<~SLIM
+  h3 hello from defaced slim
+SLIM
+
+File.write 'sandbox/app/overrides/improved_posts.rb', <<~RUBY
+  Deface::Override.new(
+    virtual_path: "posts/show",
+    name: "sparkling_post_title",
+    replace: 'p:nth-child(2)',
+    text: "<h1>✨<%= @post.title %>✨</h1>"
+  )
+
+  Deface::Override.new(
+    virtual_path: "posts/show",
+    name: "modern_style_post_body",
+    replace: 'p:nth-child(3)',
+    text: "<p style='border:2px gray solid; padding: 1rem;'><%= @post.body %></p>"
+  )
+
+  Deface::Override.new(
+    virtual_path: "posts/index",
+    name: "sparkling_posts_title",
+    replace: 'tr td:first-child',
+    text: "<td>✨<%= post.title %>✨</td>"
+  )
+
+  Deface::Override.new(
+    virtual_path: "posts/index",
+    name: "modern_style_post_body",
+    replace: 'tr td:nth-child(2)',
+    text: "<td style='border:2px gray solid; padding: 1rem;'><%= post.body %></d>"
+  )
+
+  Deface::Override.new(
+    virtual_path: "posts/index",
+    name: "haml_and_slim_partials",
+    insert_before: 'table',
+    text: "
+      <header><%= render 'haml_partial' %><%= render 'slim_partial' %></header>
+      <section><%= render 'haml_defaced_partial' %><%= render 'slim_defaced_partial' %></section>
+    "
+  )
+
+  Deface::Override.new(
+    virtual_path: "posts/_haml_defaced_partial",
+    name: "haml_deface",
+    insert_before: 'h3',
+    text: "<h4>HAML subtitle</h4>"
+  )
+
+  Deface::Override.new(
+    virtual_path: "posts/_slim_defaced_partial",
+    name: "slim_deface",
+    insert_before: 'h3',
+    text: "<h4>SLIM subtitle</h4>"
+  )
+RUBY
+
+File.write 'sandbox/config/routes.rb', <<~RUBY
+  Rails.application.routes.draw do
+    resources :posts
+    root to: "posts#index"
+  end
+RUBY
+
+system "bin/rails", "runner", "Post.create(title: 'Foo', body: 'Bar '*10)"
+system "bin/rails", "runner", "Post.create(title: 'Baz', body: 'Boz '*10)"

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/deface.gemspec

@@ -1,30 +1,52 @@
-Gem::Specification.new do |s|
-  s.name = "deface"
-  s.version = "1.5.0"
-
-  s.authors = ["Brian D Quinn"]
-  s.description = "Deface is a library that allows you to customize ERB, Haml and Slim views in a Rails application without editing the underlying view."
-  s.email = "brian@spreecommerce.com"
-  s.extra_rdoc_files = [
-    "README.markdown", "CHANGELOG.markdown"
-  ]
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.homepage = "https://github.com/spree/deface"
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.summary = "Deface is a library that allows you to customize ERB, Haml and Slim views in Rails"
-
-  s.add_dependency('nokogiri', '>= 1.6')
-  s.add_dependency('rails', '>= 4.1')
-  s.add_dependency('rainbow', '>= 2.1.0')
-  s.add_dependency('polyglot')
-
-  s.add_development_dependency('appraisal')
-  s.add_development_dependency('erubis')
-  s.add_development_dependency('rspec', '>= 3.1.0')
-  s.add_development_dependency('haml', ['>= 4.0', '< 6'])
-  s.add_development_dependency('slim', '~> 3.0')
-  s.add_development_dependency('simplecov', '>= 0.6.4')
-  s.add_development_dependency('generator_spec', '~> 0.8')
+require_relative 'lib/deface/version'
+
+Gem::Specification.new do |spec|
+  spec.name = "deface"
+  spec.version = Deface::VERSION
+  spec.authors = ["Brian D Quinn"]
+  spec.email = "brian@spreecommerce.com"
+
+  spec.summary = "Deface is a library that allows you to customize ERB, Haml and Slim views in Rails"
+  spec.description = "Deface is a library that allows you to customize ERB, Haml and Slim views in a Rails application without editing the underlying view."
+  spec.homepage = "https://github.com/spree/deface#readme"
+  spec.license = "MIT"
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/spree/deface'
+  spec.metadata['changelog_uri'] = 'https://github.com/spree/deface/releases'
+
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.5.0')
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  files = Dir.chdir(__dir__) { `git ls-files -z`.split("\x0") }
+
+  spec.files = files.grep_v(%r{^(test|spec|features)/})
+  spec.test_files = files.grep(%r{^(test|spec|features)/})
+  spec.bindir = "exe"
+  spec.executables = files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.rdoc_options = ["--charset=UTF-8"]
+  spec.extra_rdoc_files = ["README.markdown"]
+
+  spec.add_dependency('nokogiri', '>= 1.6')
+
+  %w[
+    actionview
+    railties
+  ].each do |rails_gem|
+    spec.add_dependency(rails_gem, '>= 5.2')
+  end
+  spec.add_dependency('rainbow', '>= 2.1.0')
+  spec.add_dependency('polyglot')
+
+  spec.add_development_dependency('appraisal')
+  spec.add_development_dependency('erubis')
+  spec.add_development_dependency('gem-release')
+  spec.add_development_dependency('rspec', '>= 3.1.0')
+  spec.add_development_dependency('haml', ['>= 4.0', '< 6'])
+  spec.add_development_dependency('slim', '~> 4.1')
+  spec.add_development_dependency('simplecov', '>= 0.6.4')
+  spec.add_development_dependency('generator_spec', '~> 0.8')
+  spec.add_development_dependency('pry')
 end

data/gemfiles/rails_5.2.gemfile

@@ -2,7 +2,8 @@
 
 source "https://rubygems.org"
 
-gem "rails", "~> 5.2.0"
+gem "actionview", "~> 5.2.0"
+gem "railties", "~> 5.2.0"
 
 group :test do
   gem "test-unit"

data/gemfiles/rails_6.0.gemfile

@@ -2,7 +2,8 @@
 
 source "https://rubygems.org"
 
-gem "rails", "~> 6.0.0.beta3"
+gem "actionview", "~> 6.0.0"
+gem "railties", "~> 6.0.0"
 
 group :test do
   gem "test-unit"

data/gemfiles/{rails_4.2.gemfile → rails_6.1.gemfile}

@@ -2,7 +2,8 @@
 
 source "https://rubygems.org"
 
-gem "rails", "~> 4.2.0"
+gem "actionview", "~> 6.1.0"
+gem "railties", "~> 6.1.0"
 
 group :test do
   gem "test-unit"

data/gemfiles/{rails_5.0.gemfile → rails_7.0.gemfile}

@@ -2,7 +2,8 @@
 
 source "https://rubygems.org"
 
-gem "rails", "~> 5.0.0"
+gem "actionview", "~> 7.0.0"
+gem "railties", "~> 7.0.0"
 
 group :test do
   gem "test-unit"

data/lib/deface/action_view_extensions.rb

@@ -1,102 +1,86 @@
-ActionView::Template.class_eval do
-  alias_method :initialize_without_deface, :initialize
-
-  def initialize(source, identifier, handler, details)
-    syntax = determine_syntax(handler)
-
-    if Rails.application.config.deface.enabled && should_be_defaced?(syntax)
-
-      processed_source = Deface::Override.apply(source.to_param, details, true, syntax)
-
-      # force change in handler before continuing to original Rails method
-      # as we've just converted some other template language into ERB!
-      #
-      if [:slim, :haml].include?(syntax) && processed_source != source.to_param
-        handler = ActionView::Template::Handlers::ERB
-      end
+module Deface::ActionViewExtensions
+  def self.determine_syntax(handler)
+    return unless Rails.application.config.deface.enabled
+
+    if handler.to_s == "Haml::Plugin"
+      :haml
+    elsif handler.class.to_s == "Slim::RailsTemplate"
+      :slim
+    elsif handler.to_s.demodulize == "ERB" || handler.class.to_s.demodulize == "ERB"
+      :erb
     else
-      processed_source = source.to_param
+      nil
     end
-
-    initialize_without_deface(processed_source, identifier, handler, details)
   end
 
-  alias_method :render_without_deface, :render
-
-  # refresh view to get source again if
-  # view needs to be recompiled
-  #
-  def render(view, locals, buffer=nil, &block)
-
-    if Rails.version < "6.0.0.beta1" && view.is_a?(ActionView::CompiledTemplates)
-      mod = ActionView::CompiledTemplates
-    elsif Rails.version >= "6.0.0.beta1" && view.is_a?(ActionDispatch::DebugView)
-      mod = ActionDispatch::DebugView
-    else
-      mod = view.singleton_class
-    end
+  module DefacedTemplate
+    def encode!
+      return super unless Rails.application.config.deface.enabled
+
+      # Before Rails 6 encode! returns nil
+      source = Deface.before_rails_6? ? (super; @source) : super
+      syntax = Deface::ActionViewExtensions.determine_syntax(@handler)
+      overrides = Deface::Override.find(
+        locals: @locals,
+        format: @format,
+        variant: @variant,
+        virtual_path: @virtual_path,
+      )
+
+      if syntax && overrides.any?
+        # Prevents any caching by rails in development mode.
+        @updated_at = Time.now if Deface.before_rails_6?
+        @handler = ActionView::Template::Handlers::ERB
+
+        # Modify the existing string instead of returning a copy
+        new_source = Deface::Override.apply_overrides(
+          Deface::Override.convert_source(source, syntax: syntax),
+          overrides: overrides
+        )
+
+        if Deface.before_rails_6?
+          @source.replace new_source
+        else
+          source.replace new_source
+        end
+      end
 
-    if @compiled && !mod.instance_methods.map(&:to_s).include?(method_name)
-      @compiled = false
-      @source = refresh(view).source
+      source
     end
-    render_without_deface(view, locals, buffer, &block)
-  end
 
-  protected
+    private
 
-    alias_method :method_name_without_deface, :method_name
+    def compile!(view)
+      return super unless Rails.application.config.deface.enabled
 
-    # inject deface hash into compiled view method name
-    # used to determine if recompilation is needed
-    #
-    def method_name
-      deface_hash = Deface::Override.digest(:virtual_path => @virtual_path)
+      @compile_mutex.synchronize do
+        current_deface_hash = Deface::Override.digest(virtual_path: @virtual_path)
+        @deface_hash = current_deface_hash if @deface_hash.nil?
 
-      #we digest the whole method name as if it gets too long there's problems
-      "_#{Deface::Digest.hexdigest("#{deface_hash}_#{method_name_without_deface}")}"
-    end
-
-  private
+        if @deface_hash != current_deface_hash
+          @compiled = nil
+          @deface_hash = current_deface_hash
+        end
+      end
 
-    def should_be_defaced?(syntax)
-      syntax != :unknown
+      super
     end
 
-    def determine_syntax(handler)
-      if handler.to_s == "Haml::Plugin"
-        :haml
-      elsif handler.class.to_s == "Slim::RailsTemplate"
-        :slim
-      elsif handler.to_s.demodulize == "ERB" || handler.class.to_s.demodulize == "ERB"
-        :erb
-      else
-        :unknown
-      end
-    end
-end
+    ActionView::Template.prepend self
+  end
 
-# Rails 6 fix
-# https://github.com/rails/rails/commit/ec5c946138f63dc975341d6521587adc74f6b441
-# https://github.com/rails/rails/commit/ccfa01c36e79013881ffdb7ebe397cec733d15b2#diff-dfb6e0314ad9639bab460ea64871aa47R27
-if defined?( ActionView::Template::Handlers::ERB::Erubi)
-  ActionView::Template::Handlers::ERB::Erubi.class_eval do
+  # Rails 6 fix.
+  #
+  # https://github.com/rails/rails/commit/ec5c946138f63dc975341d6521587adc74f6b441
+  # https://github.com/rails/rails/commit/ccfa01c36e79013881ffdb7ebe397cec733d15b2#diff-dfb6e0314ad9639bab460ea64871aa47R27
+  module ErubiHandlerFix
     def initialize(input, properties = {})
-      @newline_pending = 0
-
-      # Dup properties so that we don't modify argument
-      properties = Hash[properties]
-      properties[:preamble]   = "@output_buffer = output_buffer || ActionView::OutputBuffer.new;"
-      properties[:postamble]  = "@output_buffer.to_s"
-      properties[:bufvar]     = "@output_buffer"
-      properties[:escapefunc] = ""
-
+      properties[:preamble] = "@output_buffer = output_buffer || ActionView::OutputBuffer.new;"
       super
     end
-  end
-end
 
-#fix for Rails 3.1 not setting virutal_path anymore (BOO!)
-if defined?(ActionView::Resolver::Path)
-  ActionView::Resolver::Path.class_eval { alias_method :virtual, :to_s }
+    # We use include to place the module between the class' call to super and the
+    # actual execution within Erubi::Engine.
+    ActionView::Template::Handlers::ERB::Erubi.include self unless Deface.before_rails_6?
+  end
 end

data/lib/deface/applicator.rb

@@ -6,58 +6,70 @@ module Deface
       def apply(source, details, log=true, syntax=:erb)
         overrides = find(details)
 
-        if log && overrides.size > 0
-          Rails.logger.debug "\e[1;32mDeface:\e[0m #{overrides.size} overrides found for '#{details[:virtual_path]}'"
-        end
+        return source if overrides.empty?
 
-        unless overrides.empty?
-          case syntax
-          when :haml
-            #convert haml to erb before parsing before
-            source = Deface::HamlConverter.new(source.to_param).result
-          when :slim
-            source = Deface::SlimConverter.new(source.to_param).result
-          end
+        Rails.logger.debug "\e[1;32mDeface:\e[0m #{overrides.size} overrides found for '#{details[:virtual_path]}'" if log
 
-          doc = Deface::Parser.convert(source)
+        apply_overrides(
+          convert_source(source, syntax: syntax),
+          overrides: overrides,
+          log: log
+        )
+      end
 
-          overrides.each do |override|
-            if override.disabled?
-              Rails.logger.debug("\e[1;32mDeface:\e[0m '#{override.name}' is disabled") if log
-              next
-            end
+      # applies specified overrides to given source
+      def apply_overrides(source, overrides:, log: true)
 
-            override.parsed_document = doc
-            matches = override.matcher.matches(doc, log)
+        doc = Deface::Parser.convert(source)
 
-            if log
-              Rails.logger.send(matches.size == 0 ? :error : :debug, "\e[1;32mDeface:\e[0m '#{override.name}' matched #{matches.size} times with '#{override.selector}'")
+        overrides.each do |override|
+          if override.disabled?
+            Rails.logger.debug("\e[1;32mDeface:\e[0m '#{override.name}' is disabled") if log
+            next
+          end
 
-              # temporarily check and notify on use of old selector styles.
-              #
-              if matches.empty? && override.selector.match(/code|erb-loud|erb-silent/)
-                Rails.logger.error "\e[1;32mDeface: [WARNING]\e[0m Override '#{override.name}' may be using an invalid selector of '#{override.selector}', <code erb-loud|silent> tags are now <erb loud|silent>"
-              end
-            end
+          override.parsed_document = doc
+          matches = override.matcher.matches(doc, log)
+
+          if log
+            Rails.logger.send(matches.size == 0 ? :error : :debug, "\e[1;32mDeface:\e[0m '#{override.name}' matched #{matches.size} times with '#{override.selector}'")
 
-            if matches.empty?
-              override.failure = "failed to match :#{override.action} selector '#{override.selector}'"
-            else
-              override.failure = nil
-              matches.each {|match| override.execute_action match }
+            # temporarily check and notify on use of old selector styles.
+            #
+            if matches.empty? && override.selector.match(/code|erb-loud|erb-silent/)
+              Rails.logger.error "\e[1;32mDeface: [WARNING]\e[0m Override '#{override.name}' may be using an invalid selector of '#{override.selector}', <code erb-loud|silent> tags are now <erb loud|silent>"
             end
           end
 
-          #prevents any caching by rails in development mode
-          details[:updated_at] = Time.now
+          if matches.empty?
+            override.failure = "failed to match :#{override.action} selector '#{override.selector}'"
+          else
+            override.failure = nil
+            matches.each {|match| override.execute_action match }
+          end
+        end
 
-          source = doc.to_s
+        source = doc.to_s
 
-          Deface::Parser.undo_erb_markup!(source)
-        end
+        Deface::Parser.undo_erb_markup!(source)
 
         source
       end
+
+      # converts the source to a supported syntax (ERB)
+      def convert_source(source, syntax:)
+        # convert haml/slim to erb before parsing before
+        case syntax
+        when :erb
+          source
+        when :haml
+          Deface::HamlConverter.new(source.to_s).result
+        when :slim
+          Deface::SlimConverter.new(source.to_s).result
+        else
+          raise "unsupported syntax: #{syntax}"
+        end
+      end
     end
 
     def execute_action(target_element)

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

@@ -70,8 +70,8 @@ module Deface
         raise(ArgumentError, ":action is invalid") if self.action.nil?
       end
 
-      #set loaded time (if not already present) for hash invalidation
-      @args[:updated_at] ||= Time.zone.now.to_f
+      # Set loaded time (if not already present) for hash invalidation
+      @args[:updated_at] ||= Time.current.to_f
       @args[:railtie_class] = self.class.current_railtie
 
       self.class.all[virtual_key][name_key] = self
@@ -211,28 +211,22 @@ module Deface
 
     private
 
-      # check if method is compiled for the current virtual path
-      #
-      def expire_compiled_template
-        if Rails.version < "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/search.rb

@@ -7,7 +7,7 @@ module Deface
       def find(details)
         return [] if self.all.empty? || details.empty?
 
-        virtual_path = details[:virtual_path]
+        virtual_path = details[:virtual_path].dup
         return [] if virtual_path.nil?
 
         [/^\//, /\.\w+\z/].each { |regex| virtual_path.gsub!(regex, '') }