deface 0.8.0 → 0.9.0

data/lib/deface/dsl/loader.rb

@@ -0,0 +1,125 @@
+require 'polyglot'
+
+require 'deface/dsl/context'
+
+module Deface
+  module DSL
+    class Loader
+      def self.load(filename, options = nil, &block)
+        unless File.basename(filename) =~ /^[^\.]+(.html.(erb|haml)){0,1}.deface$/
+          raise "Deface::DSL does not know how to read '#{filename}'. Override files should end with just .deface, .html.erb.deface, or .html.haml.deface"
+        end
+
+        unless file_in_dir_below_overrides?(filename)
+          raise "Deface::DSL overrides must be in a sub-directory that matches the views virtual path. Move '#{filename}' into a sub-directory."
+        end
+
+        File.open(filename) do |file|
+          context_name = File.basename(filename).gsub('.deface', '')
+
+          file_contents = file.read
+
+          if context_name.end_with?('.html.erb')
+            dsl_commands, the_rest = extract_dsl_commands_from_erb(file_contents)
+
+            context_name = context_name.gsub('.html.erb', '')
+            context = Context.new(context_name)
+            context.virtual_path(determine_virtual_path(filename))
+            context.instance_eval(dsl_commands)
+            context.erb(the_rest)
+            context.create_override
+          elsif context_name.end_with?('.html.haml')
+            dsl_commands, the_rest = extract_dsl_commands_from_haml(file_contents)
+
+            context_name = context_name.gsub('.html.haml', '')
+            context = Context.new(context_name)
+            context.virtual_path(determine_virtual_path(filename))
+            context.instance_eval(dsl_commands)
+            context.haml(the_rest)
+            context.create_override            
+          else
+            context = Context.new(context_name)
+            context.virtual_path(determine_virtual_path(filename))
+            context.instance_eval(file_contents)
+            context.create_override
+          end
+        end
+      end
+
+      def self.register
+        Polyglot.register('deface', Deface::DSL::Loader)
+      end
+
+      def self.extract_dsl_commands_from_erb(html_file_contents)
+        dsl_commands = ''
+
+        while starts_with_html_comment?(html_file_contents)
+          first_open_comment_index = html_file_contents.lstrip.index('<!--')
+          first_close_comment_index = html_file_contents.index('-->')
+
+          unless first_close_comment_index.nil?
+            comment = html_file_contents[first_open_comment_index..first_close_comment_index+2]
+          end
+
+          dsl_commands << comment.gsub('<!--', '').gsub('-->', '').strip + "\n"
+
+          html_file_contents = html_file_contents.gsub(comment, '')
+        end
+
+        [dsl_commands, html_file_contents]
+      end
+
+      def self.extract_dsl_commands_from_haml(file_contents)
+        dsl_commands = ''
+
+        while starts_with_haml_comment?(file_contents)
+          first_open_comment_index = file_contents.lstrip.index('/')
+          first_close_comment_index = file_contents.index("\n")
+
+          unless first_close_comment_index.nil?
+            comment = file_contents[first_open_comment_index..first_close_comment_index]
+          end
+
+          dsl_commands << comment.gsub('/', '').strip + "\n"
+
+          file_contents = file_contents.gsub(comment, '')
+
+          while file_contents.start_with?(' ')
+            first_newline_index = file_contents.index("\n")
+            comment = file_contents[0..first_newline_index]
+            dsl_commands << comment.gsub('/', '').strip + "\n"
+            file_contents = file_contents.gsub(comment, '')
+          end
+        end
+
+        [dsl_commands, file_contents]
+      end
+
+      private 
+
+      def self.starts_with_html_comment?(line)
+        line.lstrip.index('<!--') == 0
+      end
+
+      def self.starts_with_haml_comment?(line)
+        line.lstrip.index('/') == 0
+      end
+
+      def self.file_in_dir_below_overrides?(filename)
+        File.fnmatch?("**/overrides/**/#{File.basename(filename)}", filename)
+      end
+
+      def self.determine_virtual_path(filename)
+        result = ''
+        pathname = Pathname.new(filename)
+        pathname.ascend do |parent|
+          if parent.basename.to_s == 'overrides'
+            result = pathname.sub(parent.to_s + '/', '').dirname.to_s
+            break
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/deface/environment.rb

@@ -23,18 +23,14 @@ module Deface
     def load_all(app)
       #clear overrides before reloading them
       app.config.deface.overrides.all.clear
+      Deface::DSL::Loader.register
 
-      # check application for specified overrides paths
-      override_paths = app.paths["app/overrides"]
-      enumerate_and_load(override_paths, app.root)
-
-      # check all railties / engines / extensions for overrides
-      app.railties.all.each do |railtie|
+      # check all railties / engines / extensions / application for overrides
+      app.railties.all.dup.push(app).each do |railtie|
         next unless railtie.respond_to? :root
-
-        override_paths = railtie.respond_to?(:paths) ? railtie.paths["app/overrides"] : nil
-        enumerate_and_load(override_paths, railtie.root)
+        load_overrides(railtie)
       end
+
     end
 
     def early_check
@@ -46,15 +42,30 @@ module Deface
     end
 
     private
+
+      def load_overrides(railtie)
+        Override.current_railtie = railtie
+        paths = railtie.respond_to?(:paths) ? railtie.paths["app/overrides"] : nil
+        enumerate_and_load(paths, railtie.root)
+      end
+
       def enumerate_and_load(paths, root)
         paths ||= ["app/overrides"]
 
         paths.each do |path|
-          Dir.glob(root.join path, "*.rb") do |c|
+          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
+
+          Dir.glob(root.join path, "**/*.rb") do |c|
             Rails.application.config.cache_classes ? require(c) : load(c)
           end
+          Dir.glob(root.join path, "**/*.deface") do |c|
+            Rails.application.config.cache_classes ? require(c) : Deface::DSL::Loader.load(c)
+          end
         end
-
       end
   end
 end

data/lib/deface/haml_converter.rb

@@ -40,25 +40,37 @@ module Deface
       # 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) }
+        attributes = {}
+        scanner = StringScanner.new(attrs)
+        scanner.scan(/\s+/)
+
+        until scanner.eos?
+          return unless key = scanner.scan(/:(\w*)|(["'])((?![\\#]|\2).|\\.)*\2|(\w*):/) #matches :key, 'key', "key" or key:
+          return unless scanner.scan(/\s*(=>)?\s*/) #match => or just white space
+          return unless value = scanner.scan(/(["'])((?![\\#]|\1).|\\.)*\1|[^\s,]*/) #match 'value', "value", value, @value, some-value
+          return unless scanner.scan(/\s*(?:,|$)\s*/)
+          attributes[key.to_s] = value
         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]} %>"}
+        attrs = []
+        attributes.each do |key, value|
+          #only need to convert non-literal values
+          if value[0] != ?' && value[0] != ?" && value[0] != ?:
+            key = %Q{"data-erb-#{key.gsub(/:|'|"/,'')}"}
+            value = %Q{"<%= #{value} %>"}
           end
 
-          a
+          if key[-1] == ?:
+            attrs << "#{key} #{value}"
+          else
+            attrs << "#{key} => #{value}"
+          end
         end
 
-        attrs.map{ |a| a.join " => " }.join(', ')
+        attrs.join(', ')
       end
 
   end

data/lib/deface/override.rb

@@ -5,66 +5,17 @@ module Deface
     extend Applicator::ClassMethods
     extend Search::ClassMethods
 
-    cattr_accessor :actions, :_early
-    attr_accessor :args
+    cattr_accessor :actions, :sources, :_early, :current_railtie
+    attr_accessor :args, :parsed_document
 
     @@_early = []
     @@actions = [:remove, :replace, :replace_contents, :surround, :surround_contents, :insert_after, :insert_before, :insert_top, :insert_bottom, :set_attributes, :add_to_attributes, :remove_from_attributes]
-    @@sources = [:text, :erb, :haml, :partial, :template]
+    @@sources = [:text, :erb, :haml, :partial, :template, :cut, :copy]
 
     # Initializes new override, you must supply only one Target, Action & Source
     # parameter for each override (and any number of Optional parameters).
     #
-    # ==== Target
-    #
-    # * <tt>:virtual_path</tt> - The path of the template / partial where
-    #   the override should take effect eg: "shared/_person", "admin/posts/new"
-    #   this will apply to all controller actions that use the specified template
-    #
-    # ==== Action
-    #
-    # * <tt>:remove</tt> - Removes all elements that match the supplied selector
-    # * <tt>:replace</tt> - Replaces all elements that match the supplied selector
-    # * <tt>:replace_contents</tt> - Replaces the contents of all elements that match the supplied selector
-    # * <tt>:surround</tt> - Surrounds all elements that match the supplied selector, expects replacement markup to contain <%= render_original %> placeholder
-    # * <tt>:surround_contents</tt> - Surrounds the contents of all elements that match the supplied selector, expects replacement markup to contain <%= render_original %> placeholder
-    # * <tt>:insert_after</tt> - Inserts after all elements that match the supplied selector
-    # * <tt>:insert_before</tt> - Inserts before all elements that match the supplied selector
-    # * <tt>:insert_top</tt> - Inserts inside all elements that match the supplied selector, before all existing child
-    # * <tt>:insert_bottom</tt> - Inserts inside all elements that match the supplied selector, after all existing child
-    # * <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
-    #
-    # * <tt>:text</tt> - String containing markup
-    # * <tt>:partial</tt> - Relative path to partial
-    # * <tt>:template</tt> - Relative path to template
-    #
-    # ==== Optional
-    #
-    # * <tt>:name</tt> - Unique name for override so it can be identified and modified later.
-    #   This needs to be unique within the same :virtual_path
-    # * <tt>:disabled</tt> - When set to true the override will not be applied.
-    # * <tt>:original</tt> - String containing original markup that is being overridden.
-    #   If supplied Deface will log when the original markup changes, which helps highlight overrides that need
-    #   attention when upgrading versions of the source application. Only really warranted for :replace overrides.
-    #   NB: All whitespace is stripped before comparsion.
-    # * <tt>:closing_selector</tt> - A second css selector targeting an end element, allowing you to select a range
-    #   of elements to apply an action against. The :closing_selector only supports the :replace, :remove and
-    #   :replace_contents actions, and the end element must be a sibling of the first/starting element. Note the CSS
-    #   general sibling selector (~) is used to match the first element after the opening selector.
-    # * <tt>:sequence</tt> - Used to order the application of an override for a specific virtual path, helpful when
-    #   an override depends on another override being applied first.
-    #   Supports:
-    #   :sequence => n - where n is a positive or negative integer (lower numbers get applied first, default 100).
-    #   :sequence => {:before => "override_name"} - 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.
-    #   :sequence => {:after => "override_name") - 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"}
-    #
+    # See READme for more!
     def initialize(args, &content)
       if Rails.application.try(:config).try(:deface).try(:enabled)
         unless Rails.application.config.deface.try(:overrides)
@@ -110,6 +61,10 @@ 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
+      @args[:railtie] = self.class.current_railtie
+
       self.class.all[virtual_key][name_key] = self
 
       expire_compiled_template
@@ -125,6 +80,10 @@ module Deface
       @args[:name]
     end
 
+    def railtie
+      @args[:railtie]
+    end
+
     def sequence
       return 100 unless @args.key?(:sequence)
       if @args[:sequence].is_a? Hash
@@ -167,22 +126,61 @@ module Deface
     end
 
     def source
-      erb = if @args.key? :partial
+      erb = case source_argument
+      when :partial
         load_template_source(@args[:partial], true)
-      elsif @args.key? :template
+      when :template
         load_template_source(@args[:template], false)
-      elsif @args.key? :text
+      when :text
         @args[:text]
-      elsif @args.key? :erb
+      when :erb
         @args[:erb]
-      elsif @args.key?(:haml) && Rails.application.config.deface.haml_support
-        haml_engine = Deface::HamlConverter.new(@args[:haml])
-        haml_engine.render
+      when :cut
+        cut = @args[:cut]
+
+        if cut.is_a? Hash
+          starting, ending = self.class.select_endpoints(self.parsed_document, cut[:start], cut[:end])
+
+          range = self.class.select_range(starting, ending)
+          range.map &:remove
+
+          Deface::Parser.undo_erb_markup! range.map(&:to_s).join
+
+        else
+          Deface::Parser.undo_erb_markup! self.parsed_document.css(cut).first.remove.to_s.clone
+        end
+
+      when :copy
+        copy = @args[:copy]
+
+        if copy.is_a? Hash
+          starting, ending = self.class.select_endpoints(self.parsed_document, copy[:start], copy[:end])
+
+          range = self.class.select_range(starting, ending)
+
+          Deface::Parser.undo_erb_markup! range.map(&:to_s).join
+        else
+         Deface::Parser.undo_erb_markup! parsed_document.css(copy).first.to_s.clone
+        end
+
+      when :haml
+        if Rails.application.config.deface.haml_support
+          haml_engine = Deface::HamlConverter.new(@args[:haml])
+          haml_engine.render
+        else
+          raise Deface::NotSupportedError, "`#{self.name}` supplies :haml source, but haml_support is not detected."
+        end
       end
 
       erb
     end
 
+    # Returns a :symbol for the source argument present
+    #
+    def source_argument
+      @@sources.detect { |source| @args.key? source }
+    end
+
     def source_element
       Deface::Parser.convert(source.clone)
     end
@@ -193,27 +191,42 @@ module Deface
 
     def end_selector
       return nil if @args[:closing_selector].blank?
-      "#{self.selector} ~ #{@args[:closing_selector]}"
+      @args[:closing_selector]
     end
 
     def attributes
       @args[:attributes] || []
     end
 
-    def digest
-      Digest::MD5.new.update(@args.to_s).hexdigest
+    # Alters digest of override to force view method
+    # recompilation (when source template/partial changes)
+    #
+    def touch
+      @args[:updated_at] = Time.zone.now.to_f
     end
 
-    def self.all
-      Rails.application.config.deface.overrides.all
+    # Creates MD5 hash of args sorted keys and values
+    # used to determine if an override has changed
+    #
+    def digest
+      Digest::MD5.new.update(@args.keys.map(&:to_s).sort.concat(@args.values.map(&:to_s).sort).join).hexdigest
     end
 
+    # Creates MD5 of all overrides that apply to a particular
+    # virtual_path, used in CompiledTemplates method name
+    # so we can support re-compiling of compiled method
+    # when overrides change. Only of use in production mode.
+    #
     def self.digest(details)
       overrides = self.find(details)
 
       Digest::MD5.new.update(overrides.inject('') { |digest, override| digest << override.digest }).hexdigest
     end
 
+    def self.all
+      Rails.application.config.deface.overrides.all
+    end
+
     private
 
       # check if method is compiled for the current virtual path

data/lib/deface/railtie.rb

@@ -65,6 +65,10 @@ module Deface
 
         # catchs any overrides that we required manually
         app.config.deface.overrides.early_check
+
+        if Dir.glob(app.root.join("app/compiled_views", "**/*.erb")).present?
+          puts "[WARNING] Precompiled views present and Deface is enabled, this can result in overrides being applied twice."
+        end
       else
         # deface is disabled so clear any overrides
         # that might have been manually required