deface 0.8.0 → 0.9.0

data/lib/deface/search.rb

@@ -17,6 +17,16 @@ module Deface
 
         result.flatten.compact.sort_by &:sequence
       end
+
+      # finds all overrides that are using a template / parital as there source
+      #
+      def find_using(virtual_path)
+        self.all.map do |key, overrides_by_name|
+          overrides_by_name.values.select do |override|
+            [:template, :partial].include?(override.source_argument) && override.args[override.source_argument] == virtual_path
+          end
+        end.flatten
+      end
     end
   end
 end

data/spec/assets/dummy_app/overrides/posts/index/app_override.html.erb.deface

@@ -0,0 +1,2 @@
+<!-- insert_bottom 'li' -->
+Added to li!

data/spec/assets/dummy_engine/overrides/users/index/engine_override.html.erb.deface

@@ -0,0 +1,2 @@
+<!-- insert_bottom 'li' -->
+Added to li!

data/spec/deface/action_view_template_spec.rb

@@ -48,5 +48,21 @@ module ActionView
       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)}) }
+
+      it "should return hash of overrides plus original method_name " do
+        deface_hash = Deface::Override.digest(:virtual_path => 'posts/index')
+
+        template.send(:method_name).should == "_#{Digest::MD5.new.update("#{deface_hash}_#{template.send(:method_name_without_deface)}").hexdigest}"
+      end
+
+      it "should alias original method_name method" do
+        template.send(:method_name_without_deface).should match /\A__some_path_to_file_erb_+[0-9]+_+[0-9]+\z/
+      end
+    end
+
   end
 end
+
+

data/spec/deface/applicator_spec.rb

@@ -4,6 +4,8 @@ class Dummy
   extend Deface::Applicator::ClassMethods
   extend Deface::Search::ClassMethods
 
+  attr_reader :parsed_document
+
   def self.all
     Rails.application.config.deface.overrides.all
   end
@@ -321,6 +323,17 @@ module Deface
       end
     end
 
+    describe "with a single surround override defined using :closing_selector" do
+      before  { Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :surround => "h1", :closing_selector => "p",
+                                     :text => "<% some_method('test') do %><%= render_original %><% end %>") }
+      let(:source) { "<span><h1>Start</h1><h2>middle</h2><p><span>This is the</span> end.</p></span>" }
+
+      it "should return modified source" do
+        Dummy.apply(source, {:virtual_path => "posts/index"}).gsub("\n", '').should == "<span><% some_method('test') do %><h1>Start</h1><h2>middle</h2><p><span>This is the</span> end.</p><% end %></span>"
+      end
+    end
+
+
     describe "with a single html surround_contents override defined" do
       before { Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :surround_contents => "div", :text => "<span><%= render_original %></span>") }
       let(:source) { "<h4>yay!</h4><div><p>test</p></div>" }
@@ -339,6 +352,17 @@ module Deface
       end
     end
 
+    describe "with a single erb surround_contents override defined using :closing_selector" do
+      before { Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :surround_contents => "h1", :closing_selector => "p",
+                                    :text => "<% if 1==1 %><%= render_original %><% end %>") }
+      let(:source) { "<div><h1>Start</h1><h2>middle</h2><h3>child</h3><p><span>This is the</span> end.</p></div>" }
+
+      it "should return modified source" do
+        Dummy.apply(source, {:virtual_path => "posts/index"}).gsub("\n", '').should == "<div><h1>Start</h1><% if 1==1 %><h2>middle</h2><h3>child</h3><% end %><p><span>This is the</span> end.</p></div>"
+      end
+    end
+
+
     describe "with a single disabled override defined" do
       before { Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :remove => "p", :text => "<h1>Argh!</h1>", :disabled => true) }
       let(:source) { "<p>test</p><%= raw(text) %>" }
@@ -349,6 +373,48 @@ module Deface
       end
     end
 
+    describe "with a single :copy override defined" do
+      before { Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :insert_after => "p", :copy => "h1") }
+      let(:source) { "<h1>World</h1><p>Hello</p>" }
+
+
+      it "should return modified source" do
+        Dummy.apply(source, {:virtual_path => "posts/index"}).should == "<h1>World</h1><p>Hello</p><h1>World</h1>"
+      end
+    end
+
+    describe "with a single :copy using :start and :end" do
+      before { Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :insert_before => "h1", 
+                                    :copy => {:start => "code:contains('if true')", :end => "code:contains('end')"}) }
+      let(:source) { "<h1>World</h1><% if true %><p>True that!</p><% end %><p>Hello</p>" }
+
+
+      it "should return modified source" do
+        Dummy.apply(source, {:virtual_path => "posts/index"}).should == "<% if true %><p>True that!</p><% end %><h1>World</h1><% if true %><p>True that!</p><% end %><p>Hello</p>"
+      end
+    end
+
+    describe "with a single :cut override defined" do
+      before { Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :insert_after => "p", :cut => "h1") }
+      let(:source) { "<h1>World</h1><p>Hello</p>" }
+
+
+      it "should return modified source" do
+        Dummy.apply(source, {:virtual_path => "posts/index"}).should == "<p>Hello</p><h1>World</h1>"
+      end
+    end
+
+    describe "with a single :cut using :start and :end" do
+      before { Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :replace => "h1", 
+                                    :cut => {:start => "code:contains('if true')", :end => "code:contains('end')"}) }
+      let(:source) { "<h1>World</h1><% if true %><p>True that!</p><% end %><p>Hello</p>" }
+
+
+      it "should return modified source" do
+        Dummy.apply(source, {:virtual_path => "posts/index"}).should == "<% if true %><p>True that!</p><% end %><p>Hello</p>"
+      end
+    end
+
     describe "with mulitple sequenced overrides defined" do
       before do
         Deface::Override.new(:virtual_path => "posts/index", :name => "third", :insert_after => "li:contains('second')", :text => "<li>third</li>", :sequence => {:after => "second"})
@@ -363,5 +429,18 @@ module Deface
       end
     end
 
+    describe "with incompatible actions and :closing_selector" do
+      let(:source) { "<ul><li>first</li><li>second</li><li>third</li></ul>" }
+
+      it "should return modified source" do
+        [:insert_before, :insert_after, :insert_top, :insert_bottom, :set_attributes, :remove_from_attributes, :add_to_attributes].each do |action|
+          Deface::Override.all.clear
+          Deface::Override.new(:virtual_path => "posts/index", :name => "first", action => "li", :closing_selector => "p", :text => "<li>first</li>")
+
+          expect { Dummy.apply(source, {:virtual_path => "posts/index"}) }.to raise_error(Deface::NotSupportedError)
+        end
+      end
+    end
+
   end
 end

data/spec/deface/dsl/context_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+
+require 'deface/dsl/context'
+
+describe Deface::DSL::Context do
+  include_context "mock Rails"
+
+  context '#create_override' do
+    subject { context = Deface::DSL::Context.new('sample_name') }
+
+    def override_should_be_created_with(expected_hash)
+      Deface::Override.should_receive(:new).with(hash_including(
+        :name => 'sample_name'
+      ))
+
+      subject.create_override
+    end
+
+    it 'should use name passed in through initializer' do
+      override_should_be_created_with(:name => 'sample_name')
+    end
+
+    it 'should use value set with #virtual_path' do
+      subject.virtual_path('test/path')
+
+      override_should_be_created_with(:virtual_path => 'test/path')
+    end
+
+    context 'actions' do
+      Deface::Override.actions.each do |action|
+        it "should use value set with ##{action}" do
+          subject.send(action, "#{action}/selector")
+
+          override_should_be_created_with(action => "#{action}/selector")
+        end
+      end
+
+      it 'should generate a warning if two action values are specified' do
+        subject.insert_top('selector')
+        
+        logger = mock('logger')
+        Rails.should_receive(:logger).and_return(logger)
+        logger.should_receive(:error).with("\e[1;32mDeface: [WARNING]\e[0m Multiple action methods have been called. The last one will be used.")
+
+        subject.insert_bottom('selector')
+      end
+
+      it 'should use the last action that is specified' do
+        Rails.stub_chain(:logger, :error)
+
+        subject.insert_top('insert_top/selector')
+        subject.insert_bottom('insert_bottom/selector')
+
+        override_should_be_created_with(:insert_bottom => 'insert_bottom/selector')        
+      end
+    end
+
+    context 'sources' do
+      Deface::Override.sources.each do |source|
+        it "should use value set with ##{source}" do
+          subject.send(source, "#{source} value")
+
+          override_should_be_created_with(source => "#{source} value")
+        end
+      end
+
+      it 'should generate a warning if two sources are specified' do
+        subject.partial('partial name')
+
+        logger = mock('logger')
+        Rails.should_receive(:logger).and_return(logger)
+        logger.should_receive(:error).with("\e[1;32mDeface: [WARNING]\e[0m Multiple source methods have been called. The last one will be used.")
+
+        subject.template('template/path')
+      end
+
+      it 'should use the last source that is specified' do
+        Rails.stub_chain(:logger, :error)
+
+        subject.partial('partial name')
+        subject.template('template/path')
+
+        override_should_be_created_with(:template => 'template/path')
+      end
+    end
+
+    # * <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.
+    it 'should use value set with #original' do
+      subject.original('<div>original markup</div>')
+
+      override_should_be_created_with(:original => '<div>original markup</div>')
+    end
+
+    # * <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.
+    it 'should use value set wih #closing_selector' do
+      subject.closing_selector('closing/selector')
+
+      override_should_be_created_with(:closing_selector => 'closing/selector')
+    end
+    
+    # * <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.
+    it 'should use hash value set with #sequence' do
+      subject.sequence(:before => 'something')
+
+      override_should_be_created_with(:sequence => {:before => 'something'})
+    end
+
+    it 'should use integer value set with #sequence' do
+      subject.sequence(12)
+
+      override_should_be_created_with(:sequence => 12)
+    end
+
+    ## todo: combine #set_attributes and attributes for clarity
+
+    # * <tt>:attributes</tt> - A hash containing all the attributes to be set on the matched elements, eg: :attributes => {:class => "green", :title => "some string"}
+    it 'should use value set with attributes' do
+      subject.attributes(:class => "green", :title => "some string")
+
+      override_should_be_created_with(:attributes => {:class => "green", :title => "some string"})
+    end
+
+    # * <tt>:disabled</tt> - When set to true the override will not be applied.
+    it 'should pass { :disabled => true } when #disabled is called' do
+      subject.disabled
+
+      override_should_be_created_with(:disabled => true)
+    end
+
+    it 'should pass { :disabled => false} #enabled is called' do
+      subject.enabled
+
+      override_should_be_created_with(:disabled => false)
+    end
+  end
+end

data/spec/deface/dsl/loader_spec.rb

@@ -0,0 +1,197 @@
+require 'spec_helper'
+
+require 'deface/dsl/loader'
+
+describe Deface::DSL::Loader do
+  context '.load' do
+    context 'extension check' do
+      it 'should succeed if file ends with .deface' do
+        file = mock('deface file')
+        filename = 'app/overrides/example_name.deface'
+
+        lambda { Deface::DSL::Loader.load(filename) }.should_not raise_error(
+          "Deface::DSL does not know how to read 'app/overrides/example_name.deface'. Override files should end with just .deface, .html.erb.deface, or .html.haml.deface")        
+      end
+
+      it 'should succeed if file ends with .html.erb.deface' do
+        file = mock('deface file')
+        filename = 'app/overrides/example_name.html.erb.deface'
+
+        lambda { Deface::DSL::Loader.load(filename) }.should_not raise_error(
+          "Deface::DSL does not know how to read 'app/overrides/example_name.html.erb.deface'. Override files should end with just .deface, .html.erb.deface, or .html.haml.deface")        
+      end
+
+      it 'should succeed if file ends with .html.haml.deface' do
+        file = mock('deface file')
+        filename = 'app/overrides/example_name.html.haml.deface'
+
+        lambda { Deface::DSL::Loader.load(filename) }.should_not raise_error(
+          "Deface::DSL does not know how to read 'app/overrides/example_name.html.haml.deface'. Override files should end with just .deface, .html.erb.deface, or .html.haml.deface")
+      end
+
+      it 'should fail if file ends with .blargh.deface' do
+        file = mock('deface file')
+        filename = 'app/overrides/example_name.blargh.deface'
+
+        lambda { Deface::DSL::Loader.load(filename) }.should raise_error(
+          "Deface::DSL does not know how to read 'app/overrides/example_name.blargh.deface'. Override files should end with just .deface, .html.erb.deface, or .html.haml.deface")
+      end
+
+      it "should suceed if parent directory has a dot(.) in it's name" do
+        file = mock('deface file')
+        filename = 'app/overrides/parent.dir.with.dot/example_name.html.haml.deface'
+
+        lambda { Deface::DSL::Loader.load(filename) }.should_not raise_error(
+          "Deface::DSL does not know how to read 'app/overrides/parent.dir.with.dot/example_name.html.haml.deface'. Override files should end with just .deface, .html.erb.deface, or .html.haml.deface")
+      end
+    end
+
+    it 'should fail if .html.erb.deface file is in the root of app/overrides' do
+      file = mock('html/erb/deface file')
+      filename = 'app/overrides/example_name.html.erb.deface'
+
+      lambda { Deface::DSL::Loader.load(filename) }.should raise_error(
+        "Deface::DSL overrides must be in a sub-directory that matches the views virtual path. Move 'app/overrides/example_name.html.erb.deface' into a sub-directory.")
+    end
+ 
+    it 'should set the virtual_path for a .deface file in a directory below overrides' do
+      file = mock('deface file')
+      filename = 'app/overrides/path/to/view/example_name.deface'
+      File.should_receive(:open).with(filename).and_yield(file)
+
+      override_name = 'example_name'
+      context = mock('dsl context')
+      Deface::DSL::Context.should_receive(:new).with(override_name).
+        and_return(context)
+
+      file_contents = mock('file contents')
+      file.should_receive(:read).and_return(file_contents)
+
+      context.should_receive(:virtual_path).with('path/to/view').ordered
+      context.should_receive(:instance_eval).with(file_contents).ordered
+      context.should_receive(:create_override).ordered
+
+      Deface::DSL::Loader.load(filename)
+    end
+
+    it 'should set the virtual_path for a .html.erb.deface file in a directory below overrides' do
+      file = mock('html/erb/deface file')
+      filename = 'app/overrides/path/to/view/example_name.html.erb.deface'
+      File.should_receive(:open).with(filename).and_yield(file)
+
+      override_name = 'example_name'
+      context = mock('dsl context')
+      Deface::DSL::Context.should_receive(:new).with(override_name).
+        and_return(context)
+
+      file_contents = mock('file contents')
+      file.should_receive(:read).and_return(file_contents)
+
+      Deface::DSL::Loader.should_receive(:extract_dsl_commands_from_erb).
+        with(file_contents).
+        and_return(['dsl commands', 'erb'])
+
+      context.should_receive(:virtual_path).with('path/to/view').ordered
+      context.should_receive(:instance_eval).with('dsl commands').ordered
+      context.should_receive(:erb).with('erb').ordered
+      context.should_receive(:create_override).ordered
+
+      Deface::DSL::Loader.load(filename)
+    end
+
+    it 'should set the virtual_path for a .html.haml.deface file in a directory below overrides' do
+      file = mock('html/haml/deface file')
+      filename = 'app/overrides/path/to/view/example_name.html.haml.deface'
+      File.should_receive(:open).with(filename).and_yield(file)
+
+      override_name = 'example_name'
+      context = mock('dsl context')
+      Deface::DSL::Context.should_receive(:new).with(override_name).
+        and_return(context)
+
+      file_contents = mock('file contents')
+      file.should_receive(:read).and_return(file_contents)
+
+      Deface::DSL::Loader.should_receive(:extract_dsl_commands_from_haml).
+        with(file_contents).
+        and_return(['dsl commands', 'haml'])
+
+      context.should_receive(:virtual_path).with('path/to/view').ordered
+      context.should_receive(:instance_eval).with('dsl commands').ordered
+      context.should_receive(:haml).with('haml').ordered
+      context.should_receive(:create_override).ordered
+
+      Deface::DSL::Loader.load(filename)
+    end
+
+  end
+
+  context '.register' do
+    it 'should register the deface extension with the polyglot library' do
+      Polyglot.should_receive(:register).with('deface', Deface::DSL::Loader)
+
+      Deface::DSL::Loader.register
+    end
+  end
+
+  context '.extract_dsl_commands_from_erb' do
+    it 'should work in the simplest case' do
+      example = "<!-- test 'command' --><h1>Wow!</h1>"
+      dsl_commands, the_rest = Deface::DSL::Loader.extract_dsl_commands_from_erb(example)
+      dsl_commands.should == "test 'command'\n"
+      the_rest.should == "<h1>Wow!</h1>"
+    end
+
+    it 'should combine multiple comments' do
+      example = "<!-- test 'command' --><!-- another 'command' --><h1>Wow!</h1>"
+      dsl_commands, the_rest = Deface::DSL::Loader.extract_dsl_commands_from_erb(example)
+      dsl_commands.should == "test 'command'\nanother 'command'\n"
+      the_rest.should == "<h1>Wow!</h1>"
+    end
+
+    it 'should leave internal comments alone' do
+      example = "<br/><!-- test 'command' --><!-- another 'command' --><h1>Wow!</h1>"
+      dsl_commands, the_rest = Deface::DSL::Loader.extract_dsl_commands_from_erb(example)
+      dsl_commands.should == ""
+      the_rest.should == example
+    end
+
+    it 'should work with comments on own lines' do
+      example = "<!-- test 'command' -->\n<!-- another 'command' -->\n<h1>Wow!</h1>"
+      dsl_commands, the_rest = Deface::DSL::Loader.extract_dsl_commands_from_erb(example)
+      dsl_commands.should == "test 'command'\nanother 'command'\n"
+      the_rest.should == "\n<h1>Wow!</h1>"
+    end
+
+    it 'should work with newlines inside the comment' do
+      example = "<!--\n test 'command'\nanother 'command'\n -->\n<h1>Wow!</h1>"
+      dsl_commands, the_rest = Deface::DSL::Loader.extract_dsl_commands_from_erb(example)
+      dsl_commands.should == "test 'command'\nanother 'command'\n"
+      the_rest.should == "\n<h1>Wow!</h1>"
+    end
+  end
+
+  context '.extract_dsl_commands_from_haml' do
+    it 'should work in the simplest case' do
+      example = "/ test 'command'\n/ another 'command'\n%h1 Wow!"
+      dsl_commands, the_rest = Deface::DSL::Loader.extract_dsl_commands_from_haml(example)
+      dsl_commands.should == "test 'command'\nanother 'command'\n"
+      the_rest.should == "%h1 Wow!"
+    end
+
+    it 'should work with a block style comment using spaces' do
+      example = "/\n  test 'command'\n  another 'command'\n%h1 Wow!"
+      dsl_commands, the_rest = Deface::DSL::Loader.extract_dsl_commands_from_haml(example)
+      dsl_commands.should == "\ntest 'command'\nanother 'command'\n"
+      the_rest.should == "%h1 Wow!"
+    end
+
+    it 'should leave internal comments alone' do
+      example = "%br\n/ test 'command'\n/ another 'command'\n%h1 Wow!"
+      dsl_commands, the_rest = Deface::DSL::Loader.extract_dsl_commands_from_erb(example)
+      dsl_commands.should == ""
+      the_rest.should == example
+    end
+
+  end
+end