deface 0.7.2 → 0.8.0

data/Gemfile

@@ -1,3 +1,3 @@
 source :rubygems
- 
+
 gemspec

data/README.markdown

@@ -59,7 +59,11 @@ Action
 
 * <tt>:insert_bottom</tt> - Inserts inside all elements that match the supplied selector, as the last child.
 
-* <tt>:set_attributes</tt> - Sets (or adds) attributes to all elements that match the supplied selector, expects :attributes option to be passed.
+* <tt>:set_attributes</tt> - Sets attributes on all elements that match the supplied selector, replacing existing attribute value if present or adding if not. Expects :attributes option to be passed.
+
+* <tt>:add_to_attributes</tt> - Appends value to attributes on all elements that match the supplied selector, adds attribute if not present. Expects :attributes option to be passed.
+
+* <tt>:remove_from_attributes</tt> - Removes value from attributes on all elements that match the supplied selector. Expects :attributes option to be passed.
 
 Source
 ------
@@ -85,7 +89,7 @@ Optional
   * <tt>:sequence => {:before => "*override_name*"}</tt> - where "*override_name*" is the name of an override defined for the 
                                               same virutal_path, the current override will be appplied before 
                                               the named override passed.
-  * <tt>:sequence => {:after => "*override_name*")</tt> - the current override will be applied after the named override passed.
+  * <tt>:sequence => {:after => "*override_name*"}</tt> - the current override will be applied after the named override passed.
 
 * <tt>:attributes</tt> - A hash containing all the attributes to be set on the matched elements, eg: :attributes => {:class => "green", :title => "some string"}
 

data/deface.gemspec

@@ -1,10 +1,10 @@
 Gem::Specification.new do |s|
   s.name = "deface"
-  s.version = "0.7.2"
+  s.version = "0.8.0"
 
   s.authors = ["Brian D Quinn"]
-  s.description = "Deface is a library that allows you to customize ERB views in a Rails application without editing the underlying view."
-  s.email = "brian@railsdog.com"
+  s.description = "Deface is a library that allows you to customize ERB & HAML views in a Rails application without editing the underlying view."
+  s.email = "brian@spreecommerce.com"
   s.extra_rdoc_files = [
     "README.markdown"
   ]
@@ -13,10 +13,11 @@ Gem::Specification.new do |s|
   s.homepage = "http://github.com/railsdog/deface"
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.summary = "Deface is a library that allows you to customize ERB views in Rails"
+  s.summary = "Deface is a library that allows you to customize ERB & HAML views in Rails"
 
   s.add_dependency('nokogiri', '~> 1.5.0')
   s.add_dependency('rails', '>= 3.0.9')
 
-  s.add_development_dependency('rspec', '>= 2.7.0')
+  s.add_development_dependency('rspec', '>= 2.8.0')
+  s.add_development_dependency('haml', '>= 3.1.4')
 end

data/lib/deface.rb

@@ -1,7 +1,9 @@
 require "action_view"
 require "action_controller"
-require "deface/action_view_extensions"
 require "deface/template_helper"
+require "deface/original_validator"
+require "deface/applicator"
+require "deface/search"
 require "deface/override"
 require "deface/parser"
 require "deface/environment"

data/lib/deface/action_view_extensions.rb

@@ -1,12 +1,44 @@
 ActionView::Template.class_eval do
-  alias_method :rails_initialize, :initialize
+  alias_method :initialize_without_deface, :initialize
 
   def initialize(source, identifier, handler, details)
     if Rails.application.config.deface.enabled
-      source = Deface::Override.apply(source, details)
+      haml = handler.to_s == "Haml::Plugin"
+
+      processed_source = Deface::Override.apply(source, details, true, haml )
+
+      if haml && processed_source != source
+        handler = ActionView::Template::Handlers::ERB
+      end
+    else
+      processed_source = source
+    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 @compiled && !view.respond_to?(method_name)
+      @compiled = false
+      @source = refresh(view).source
     end
+    render_without_deface(view, locals, buffer, &block)
+  end
+
+
+  alias_method :method_name_without_deface, :method_name
 
-    rails_initialize(source, identifier, handler, details)
+  # 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)
+    "_#{deface_hash}_#{method_name_without_deface}"
   end
 end
 

data/lib/deface/applicator.rb

@@ -0,0 +1,192 @@
+module Deface
+  module Applicator
+    module ClassMethods
+      # applies all applicable overrides to given source
+      #
+      def apply(source, details, log=true, haml=false)
+        overrides = find(details)
+
+        if log && overrides.size > 0
+          Rails.logger.info "\e[1;32mDeface:\e[0m #{overrides.size} overrides found for '#{details[:virtual_path]}'"
+        end
+
+        unless overrides.empty?
+          if haml
+            #convert haml to erb before parsing before
+            source = Deface::HamlConverter.new(source).result
+          end
+
+          doc = Deface::Parser.convert(source)
+
+          overrides.each do |override|
+            if override.disabled?
+              Rails.logger.info("\e[1;32mDeface:\e[0m '#{override.name}' is disabled") if log
+              next
+            end
+
+            if override.end_selector.blank?
+              # single css selector
+
+              matches = doc.css(override.selector)
+
+              if log
+                Rails.logger.send(matches.size == 0 ? :error : :info, "\e[1;32mDeface:\e[0m '#{override.name}' matched #{matches.size} times with '#{override.selector}'")
+              end
+
+              matches.each do |match|
+                override.validate_original(match)
+
+                case override.action
+                  when :remove
+                    match.replace ""
+                  when :replace
+                    match.replace override.source_element
+                  when :replace_contents
+                    match.children.remove
+                    match.add_child(override.source_element)
+                  when :surround, :surround_contents
+
+                    new_source = override.source_element.clone(1)
+
+                    if original = new_source.css("code:contains('render_original')").first
+                      if override.action == :surround
+                        original.replace match.clone(1)
+                        match.replace new_source
+                      elsif override.action == :surround_contents
+                        original.replace match.children
+                        match.children.remove
+                        match.add_child new_source
+                      end
+                    else
+                      #maybe we should log that the original wasn't found.
+                    end
+
+                  when :insert_before
+                    match.before override.source_element
+                  when :insert_after
+                    match.after override.source_element
+                  when :insert_top
+                    if match.children.size == 0
+                      match.children = override.source_element
+                    else
+                      match.children.before(override.source_element)
+                    end
+                  when :insert_bottom
+                    if match.children.size == 0
+                      match.children = override.source_element
+                    else
+                      match.children.after(override.source_element)
+                    end
+                  when :set_attributes
+                    override.attributes.each do |name, value|
+                      name = normalize_attribute_name(name)
+
+                      match.remove_attribute(name)
+                      match.remove_attribute("data-erb-#{name}")
+
+                      if match.attributes.key? name
+                        match.set_attribute name, value.to_s
+                      else
+                        match.set_attribute "data-erb-#{name}", value.to_s
+                      end
+                    end
+                  when :add_to_attributes
+                    override.attributes.each do |name, value|
+                      name = normalize_attribute_name(name)
+
+                      if match.attributes.key? name
+                        match.set_attribute name, match.attributes[name].value << " #{value}"
+                      elsif match.attributes.key? "data-erb-#{name}"
+                        match.set_attribute "data-erb-#{name}", match.attributes["data-erb-#{name}"].value << " #{value}"
+                      else
+                        match.set_attribute "data-erb-#{name}", value.to_s
+                      end
+
+                    end
+                  when :remove_from_attributes
+                    override.attributes.each do |name, value|
+                      name = normalize_attribute_name(name)
+
+                      if match.attributes.key? name
+                        match.set_attribute name, match.attributes[name].value.gsub(value.to_s, '').strip
+                      elsif match.attributes.key? "data-erb-#{name}"
+                        match.set_attribute "data-erb-#{name}", match.attributes["data-erb-#{name}"].value.gsub(value.to_s, '').strip
+                      end
+                    end
+
+                end
+
+              end
+            else
+              # targeting range of elements as end_selector is present
+              starting    = doc.css(override.selector).first
+
+              if starting && starting.parent
+                ending = starting.parent.css(override.end_selector).first
+              else
+                ending = doc.css(override.end_selector).first
+              end
+
+              if starting && ending
+                if log
+                  Rails.logger.info("\e[1;32mDeface:\e[0m '#{override.name}' matched starting with '#{override.selector}' and ending with '#{override.end_selector}'")
+                end
+
+                elements = select_range(starting, ending)
+
+                case override.action
+                  when :remove
+                    elements.map &:remove
+                  when :replace
+                    starting.before(override.source_element)
+                    elements.map &:remove
+                  when :replace_contents
+                    elements[1..-2].map &:remove
+                    starting.after(override.source_element)
+                end
+              else
+                if starting.nil?
+                  Rails.logger.info("\e[1;32mDeface:\e[0m '#{override.name}' failed to match with starting selector '#{override.selector}'")
+                else
+                  Rails.logger.info("\e[1;32mDeface:\e[0m '#{override.name}' failed to match with end selector '#{override.end_selector}'")
+                end
+
+              end
+            end
+
+          end
+
+          #prevents any caching by rails in development mode
+          details[:updated_at] = Time.now
+
+          source = doc.to_s
+
+          Deface::Parser.undo_erb_markup!(source)
+        end
+
+        source
+      end
+
+      private
+        # finds all elements upto closing sibling in nokgiri document
+        #
+        def select_range(first, last)
+          first == last ? [first] : [first, *select_range(first.next, last)]
+        end
+
+        def normalize_attribute_name(name)
+          name = name.to_s.gsub /"|'/, ''
+
+          if /\Adata-erb-/ =~ name
+            name.gsub! /\Adata-erb-/, ''
+          end
+
+          name
+        end
+
+        def set_attributes(match, name, value)
+
+        end
+    end
+  end
+end

data/lib/deface/environment.rb

@@ -1,10 +1,11 @@
 module Deface
 
   class Environment
-    attr_accessor :overrides, :enabled
+    attr_accessor :overrides, :enabled, :haml_support
     def initialize
-      @overrides = Overrides.new
-      @enabled   = true
+      @overrides    = Overrides.new
+      @enabled      = true
+      @haml_support = false
     end
   end
 
@@ -20,9 +21,10 @@ module Deface
     end
 
     def load_all(app)
+      #clear overrides before reloading them
+      app.config.deface.overrides.all.clear
+
       # check application for specified overrides paths
-      #
-      #
       override_paths = app.paths["app/overrides"]
       enumerate_and_load(override_paths, app.root)
 
@@ -43,7 +45,7 @@ module Deface
       Deface::Override._early.clear
     end
 
-    private 
+    private
       def enumerate_and_load(paths, root)
         paths ||= ["app/overrides"]
 
@@ -56,4 +58,3 @@ module Deface
       end
   end
 end
-

data/lib/deface/haml_converter.rb

@@ -0,0 +1,65 @@
+module Deface
+  class HamlConverter < Haml::Engine
+    def result
+      Deface::Parser.undo_erb_markup! String.new(render)
+    end
+
+    def push_script(text, preserve_script, in_tag = false, preserve_tag = false,
+                    escape_html = false, nuke_inner_whitespace = false)
+      push_text "<%= #{text.strip} %>"
+
+      if block_given?
+        yield
+        push_silent('end')
+      end
+    end
+
+    def push_silent(text, can_suppress = false)
+      push_text "<% #{text.strip} %>"
+    end
+
+    def parse_old_attributes(line)
+      attributes_hash, rest, last_line = super(line)
+
+      attributes_hash = deface_attributes(attributes_hash)
+
+      return attributes_hash, rest, last_line
+    end
+
+
+    def parse_new_attributes(line)
+      attributes, rest, last_line = super(line)
+
+      attributes[1] = deface_attributes(attributes[1])
+
+      return attributes, rest, last_line
+    end
+
+    private
+
+      # coverts { attributes into deface compatibily attributes
+      def deface_attributes(attrs)
+        return if attrs.nil?
+        attrs.gsub! /\{|\}/, ''
+        attrs = attrs.split(',')
+
+        if attrs.join.include? "=>"
+          attrs.map!{|a| a.split("=>").map(&:strip) }
+        else
+          attrs.map!{|a| a.split(": ").map(&:strip) }
+        end
+
+        attrs.map! do |a|
+          if a[1][0] != ?' && a[1][0] != ?"
+            a[0] = %Q{"data-erb-#{a[0].gsub(/:|'|"/,'')}"}
+            a[1] = %Q{"<%= #{a[1]} %>"}
+          end
+
+          a
+        end
+
+        attrs.map{ |a| a.join " => " }.join(', ')
+      end
+
+  end
+end

data/lib/deface/original_validator.rb

@@ -0,0 +1,34 @@
+module Deface
+  module OriginalValidator
+
+    def original_source
+      return nil unless @args[:original].present?
+
+      Deface::Parser.convert(@args[:original].clone)
+    end
+
+    # logs if original source has changed
+    def validate_original(match)
+      hashed_original = Digest::SHA1.hexdigest(match.to_s.gsub(/\s/, ''))
+
+      if @args[:original].present?
+        valid = @args[:original] == hashed_original
+
+        unless valid
+          valid = self.original_source.to_s.gsub(/\s/, '') == match.to_s.gsub(/\s/, '')
+        end
+
+        if !valid && defined?(Rails.logger)
+          Rails.logger.error "\e[1;32mDeface: [ERROR]\e[0m The original source for '#{self.name}' has changed, this override should be reviewed to ensure it's still valid."
+        end
+
+        return valid
+      else
+        Rails.logger.info "\e[1;32mDeface: [WARNING]\e[0m No :original defined for '#{self.name}', you should change its definition to include:\n :original => '#{hashed_original}' "
+
+        return nil
+      end
+    end
+
+  end
+end