deface 0.9.1 → 1.0.0.rc1

data/lib/deface/sources/source.rb

@@ -0,0 +1,11 @@
+module Deface
+  module Sources
+    class Source
+      class << self
+        def to_sym
+          self.to_s.demodulize.underscore.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/deface/sources/template.rb

@@ -0,0 +1,13 @@
+module Deface
+  module Sources
+    class Template < Source
+      class << self
+        include TemplateHelper
+      end
+
+      def self.execute(override)
+        load_template_source(override.args[:template], false)
+      end
+    end
+  end
+end

data/lib/deface/sources/text.rb

@@ -0,0 +1,9 @@
+module Deface
+  module Sources
+    class Text < Source
+      def self.execute(override)
+        override.args[:text]
+      end
+    end
+  end
+end

data/lib/deface/utils/failure_finder.rb

@@ -0,0 +1,41 @@
+module Deface
+  module Utils
+    module FailureFinder
+      def overrides_by_virtual_path(virtual_path)
+        begin
+          load_template_source(virtual_path, false, true).dup
+        rescue Exception => e
+          puts "Error processing overrides for :virtual_path => '#{virtual_path}'"
+          puts " #{e.message}"
+          return nil
+        end
+        Deface::Override.find(:virtual_path => virtual_path)
+      end
+
+      def output_results_by_virtual_path(virtual_path)
+        has_failz = 0
+
+        fails = overrides_by_virtual_path(virtual_path)
+        return(has_failz += 1) if fails.nil?
+
+        count = fails.group_by{ |o| !o.failure.nil? }
+        if count.key?(true)
+          has_failz += count[true].count
+          puts "#{count[true].count} of #{fails.count} override(s) failed for :virtual_path => '#{virtual_path}'"
+        else
+          puts "0 of #{fails.count} override(s) failed for :virtual_path => '#{virtual_path}'"
+        end
+
+        fails.each do |override|
+          if override.failure.nil?
+            puts " '#{override.name}' reported no failures".green
+          else
+            puts " '#{override.name}' #{override.failure}".red
+          end
+        end
+
+        has_failz
+      end
+    end
+  end
+end

data/spec/deface/action_view_template_spec.rb

@@ -62,7 +62,33 @@ module ActionView
       end
     end
 
-  end
-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 "should return unmodified source" do
+        #if processed, source would include "=>"
+        @template.source.should == "xml.post => :blah"
+      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)})
+          @template.is_a?(ActionView::Template).should == true
+          @template.send(:should_be_defaced?, handler).should eq(expected), "unexpected result for handler "+handler.to_s
+        end
+      end
+    end
+  end
+end

data/spec/deface/actions/add_to_attributes_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+module Deface
+  module Actions
+    describe AddToAttributes do
+      include_context "mock Rails.application"
+      before { Dummy.all.clear }
+
+      describe "with a single add_to_attributes override (containing only text) defined" do
+        before { Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :add_to_attributes => 'img', 
+                                        :attributes => {:class => 'pretty', :alt => 'something interesting'}) }
+        let(:source) { "<img class=\"button\" src=\"path/to/button.png\">" }
+
+        it "should return modified source" do
+          attrs = attributes_to_sorted_array(Dummy.apply(source, {:virtual_path => "posts/index"}))
+
+          attrs["class"].value.should == "button pretty"
+          attrs["alt"].value.should == "something interesting"
+        end
+      end
+
+      describe "with a single add_to_attributes override (containing erb) defined" do
+        before { Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :add_to_attributes => 'img', 
+                                        :attributes => {:class => '<%= add_class %>'}) }
+        let(:source) { "<img class=\"button\" src=\"path/to/button.png\">" }
+
+        it "should return modified source" do
+          attrs = attributes_to_sorted_array(Dummy.apply(source, {:virtual_path => "posts/index"}))
+
+          attrs["class"].value.should == "button <%= add_class %>"
+          attrs["src"].value.should == "path/to/button.png"
+        end
+      end
+
+      describe "with a single add_to_attributes override (containing erb) defined using pseudo attribute name" do
+        before { Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :add_to_attributes => 'img', 
+                                        :attributes => {'data-erb-class' => '<%= add_class %>'}) }
+        let(:source) { "<img class=\"button\" src=\"path/to/button.png\">" }
+
+        it "should return modified source" do
+          attrs = attributes_to_sorted_array(Dummy.apply(source, {:virtual_path => "posts/index"}))
+
+          attrs["class"].value.should == "button <%= add_class %>"
+          attrs["src"].value.should == "path/to/button.png"
+        end
+      end
+
+      describe "with a single add_to_attributes override (containing erb) defined targetting an existing pseudo attribute" do
+        before { Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :add_to_attributes => 'img', 
+                                        :attributes => {:class => '<%= get_some_other_class %>'}) }
+        let(:source) { "<img class=\"<%= get_class %>\" src=\"path/to/button.png\">" }
+
+        it "should return modified source" do
+          attrs = attributes_to_sorted_array(Dummy.apply(source, {:virtual_path => "posts/index"}))
+
+          attrs["class"].value.should == "<%= get_class %> <%= get_some_other_class %>"
+          attrs["src"].value.should == "path/to/button.png"
+        end
+      end
+    end
+  end
+end

data/spec/deface/actions/insert_after_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module Deface
+  module Actions
+    describe ReplaceContents do
+      include_context "mock Rails.application"
+      before { Dummy.all.clear }
+
+      describe "with a single insert_after override defined" do
+        before { Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :insert_after => "img.button", :text => "<% help %>") }
+        let(:source) { "<div><img class=\"button\" src=\"path/to/button.png\"></div>" }
+
+        it "should return modified source" do
+          Dummy.apply(source, {:virtual_path => "posts/index"}).gsub("\n", "").should == "<div><img class=\"button\" src=\"path/to/button.png\"><% help %></div>"
+        end
+      end
+    end
+  end
+end

data/spec/deface/actions/insert_before_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module Deface
+  module Actions
+    describe InsertBefore do
+      include_context "mock Rails.application"
+      before { Dummy.all.clear }
+
+      describe "with a single insert_before override defined" do
+        before  { Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :insert_after => "ul li:last", :text => "<%= help %>") }
+        let(:source) { "<ul><li>first</li><li>second</li><li>third</li></ul>" }
+
+        it "should return modified source" do
+          Dummy.apply(source, {:virtual_path => "posts/index"}).gsub("\n", "").should == "<ul><li>first</li><li>second</li><li>third</li><%= help %></ul>"
+        end
+      end
+    end
+  end
+end

data/spec/deface/actions/insert_bottom_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+module Deface
+  module Actions
+    describe InsertBottom do
+      include_context "mock Rails.application"
+      before { Dummy.all.clear }
+
+      describe "with a single insert_bottom override defined" do
+        before { Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :insert_bottom => "ul", :text => "<li>I'm always last</li>") }
+        let(:source) { "<ul><li>first</li><li>second</li><li>third</li></ul>" }
+
+        it "should return modified source" do
+          Dummy.apply(source, {:virtual_path => "posts/index"}).gsub("\n", "").should == "<ul><li>first</li><li>second</li><li>third</li><li>I'm always last</li></ul>"
+        end
+      end
+
+      describe "with a single insert_bottom override defined when targetted elemenet has no children" do
+        before { Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :insert_bottom => "ul", :text => "<li>I'm always last</li>") }
+        let(:source) { "<ul></ul>" }
+
+        it "should return modified source" do
+          Dummy.apply(source, {:virtual_path => "posts/index"}).gsub("\n", "").should == "<ul><li>I'm always last</li></ul>"
+        end
+      end
+    end
+  end
+end

data/spec/deface/actions/insert_top_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+module Deface
+  module Actions
+    describe InsertTop do
+      include_context "mock Rails.application"
+      before { Dummy.all.clear }
+
+      describe "with a single insert_top override defined" do
+        before { Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :insert_top => "ul", :text => "<li>me first</li>") }
+        let(:source) { "<ul><li>first</li><li>second</li><li>third</li></ul>" }
+
+        it "should return modified source" do
+          Dummy.apply(source, {:virtual_path => "posts/index"}).gsub("\n", "").should == "<ul><li>me first</li><li>first</li><li>second</li><li>third</li></ul>"
+        end
+      end
+
+      describe "with a single insert_top override defined when targetted elemenet has no children" do
+        before { Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :insert_top => "ul", :text => "<li>first</li><li>second</li><li>third</li>") }
+        let(:source) { "<ul></ul>" }
+
+        it "should return modified source" do
+          Dummy.apply(source, {:virtual_path => "posts/index"}).gsub("\n", "").should == "<ul><li>first</li><li>second</li><li>third</li></ul>"
+        end
+      end
+    end
+  end
+end

data/spec/deface/actions/remove_from_attributes_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+module Deface
+  module Actions
+    describe RemoveFromAttributes do
+      include_context "mock Rails.application"
+      before { Dummy.all.clear }
+
+      describe "with a single remove_from_attributes override (containing only text) defined" do
+        before { Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :remove_from_attributes => 'img', 
+                                        :attributes => {:class => 'pretty'}) }
+        let(:source) { "<img class=\"pretty button\" src=\"path/to/button.png\">" }
+
+        it "should return modified source" do
+          attrs = attributes_to_sorted_array(Dummy.apply(source, {:virtual_path => "posts/index"}))
+
+          attrs["class"].value.should == "button"
+        end
+      end
+
+      describe "with a single remove_from_attributes override (containing erb) defined" do
+        before { Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :remove_from_attributes => 'img', 
+                                        :attributes => {:class => '<%= add_class %>'}) }
+        let(:source) { "<img class=\"button <%= add_class %>\" src=\"path/to/button.png\">" }
+
+        it "should return modified source" do
+          attrs = attributes_to_sorted_array(Dummy.apply(source, {:virtual_path => "posts/index"}))
+
+          attrs["class"].value.should == "button"
+          attrs["src"].value.should == "path/to/button.png"
+        end
+      end
+
+      describe "with a single remove_from_attributes override (containing erb) defined using pseudo attribute name" do
+        before { Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :remove_from_attributes => 'img', 
+                                        :attributes => {'data-erb-class' => '<%= add_class %>'}) }
+        let(:source) { "<img class=\"button <%= add_class %>\" src=\"path/to/button.png\">" }
+
+        it "should return modified source" do
+          attrs = attributes_to_sorted_array(Dummy.apply(source, {:virtual_path => "posts/index"}))
+
+          attrs["class"].value.should == "button"
+          attrs["src"].value.should == "path/to/button.png"
+        end
+      end
+
+      describe "with a single remove_from_attributes override (containing only text) defined where value is not present in attribute" do
+        before { Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :remove_from_attributes => 'img', 
+                                        :attributes => {:class => 'pretty'}) }
+        let(:source) { "<img class=\"button\" src=\"path/to/button.png\">" }
+
+        it "should return unmodified source" do
+          Dummy.apply(source, {:virtual_path => "posts/index"}).should == "<img class=\"button\" src=\"path/to/button.png\">" 
+        end
+      end
+
+      describe "with a single remove_from_attributes override (containing only text) defined where value is not present in attribute" do
+        before { Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :remove_from_attributes => 'img', 
+                                        :attributes => {:class => 'pretty'}) }
+        let(:source) { "<img src=\"path/to/button.png\">" }
+
+        it "should return unmodified source" do
+          Dummy.apply(source, {:virtual_path => "posts/index"}).should == "<img src=\"path/to/button.png\">" 
+        end
+      end
+
+      describe "with a single remove_from_attributes override (containing erb) defined targetting an existing pseudo attribute" do
+        before { Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :remove_from_attributes => 'img', 
+                                        :attributes => {:class => '<%= get_some_other_class %>'}) }
+        let(:source) { "<img class=\"<%= get_class %> <%= get_some_other_class %>\" src=\"path/to/button.png\">" }
+
+        it "should return modified source" do
+          attrs = attributes_to_sorted_array(Dummy.apply(source, {:virtual_path => "posts/index"}))
+
+          attrs["class"].value.should == "<%= get_class %>"
+          attrs["src"].value.should == "path/to/button.png"
+        end
+      end
+    end
+  end
+end

data/spec/deface/actions/remove_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+module Deface
+  module Actions
+    describe Remove do
+      include_context "mock Rails.application"
+      before { Dummy.all.clear }
+
+      describe "with a single remove override defined" do
+        before { Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :remove => "p", :text => "<h1>Argh!</h1>") }
+        let(:source) { "<p>test</p><%= raw(text) %>" }
+
+        it "should return modified source" do
+          Dummy.apply(source, {:virtual_path => "posts/index"}).should == "<%= raw(text) %>"
+        end
+
+      end
+
+      describe "with a single remove override with closing_selector defined" do
+        before { Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :remove => "h1", :closing_selector => "h2") }
+        let(:source) { "<h2>I should be safe</h2><span>Before!</span><h1>start</h1><p>some junk</p><div>more junk</div><h2>end</h2><span>After!</span>" }
+
+        it "should return modified source" do
+          Dummy.apply(source, {:virtual_path => "posts/index"}).should == "<h2>I should be safe</h2><span>Before!</span><span>After!</span>"
+        end
+      end
+
+    end
+  end
+end

data/spec/deface/actions/replace_contents_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+module Deface
+  module Actions
+    describe ReplaceContents do
+      include_context "mock Rails.application"
+      before { Dummy.all.clear }
+
+      describe "with a single replace_contents override defined" do
+        before { Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :replace_contents => "p", :text => "<h1>Argh!</h1>") }
+        let(:source) { "<p><span>Hello</span>I am not a <em>pirate</em></p>" }
+
+        it "should return modified source" do
+          Dummy.apply(source, {:virtual_path => "posts/index"}).should == "<p><h1>Argh!</h1></p>"
+        end
+      end
+
+      describe "with a single replace_contents override with closing_selector defined" do
+        before { Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :replace_contents => "h1", :closing_selector => "h2", :text => "<span>Argh!</span>") }
+        let(:source) { "<h1>start</h1><p>some junk</p><div>more junk</div><h2>end</h2>" }
+
+        it "should return modified source" do
+          Dummy.apply(source, {:virtual_path => "posts/index"}).should == "<h1>start</h1><span>Argh!</span><h2>end</h2>"
+        end
+      end
+    end
+  end
+end
+

data/spec/deface/actions/replace_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+module Deface
+  module Actions
+    describe Replace do
+      include_context "mock Rails.application"
+      before { Dummy.all.clear }
+
+      describe "with a single replace override defined" do
+        before { @override = Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :replace => "p", :text => "<h1>Argh!</h1>") }
+        let(:source) { "<p>test</p>" }
+
+        it "should return modified source" do
+          Dummy.apply(source, {:virtual_path => "posts/index"}).should  == "<h1>Argh!</h1>"
+          @override.failure.should be_false
+        end
+      end
+
+      describe "with a single replace override with closing_selector defined" do
+        before { @override = Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :replace => "h1", :closing_selector => "h2", :text => "<span>Argh!</span>") }
+        let(:source) { "<h1>start</h1><p>some junk</p><div>more junk</div><h2>end</h2>" }
+
+        it "should return modified source" do
+          Dummy.apply(source, {:virtual_path => "posts/index"}).should == "<span>Argh!</span>"
+          @override.failure.should be_false
+        end
+      end
+
+      describe "with a single replace override with bad closing_selector defined" do
+        before { @override = Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :replace => "h1", :closing_selector => "h3", :text => "<span>Argh!</span>") }
+        let(:source) { "<h1>start</h1><p>some junk</p><div>more junk</div><h2>end</h2>" }
+
+        it "should log error and return unmodified source" do
+          Rails.logger.should_receive(:info).with(/failed to match with end selector/)
+          Dummy.apply(source, {:virtual_path => "posts/index"}).should == source
+          @override.failure.should be_true
+        end
+      end
+
+      describe "with a single replace override with bad selector defined" do
+        before { @override = Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :replace => "h3", :closing_selector => "h2", :text => "<span>Argh!</span>") }
+        let(:source) { "<h1>start</h1><p>some junk</p><div>more junk</div><h2>end</h2>" }
+
+        it "should log error and return unmodified source" do
+          Rails.logger.should_receive(:info).with(/failed to match with starting selector/)
+          Dummy.apply(source, {:virtual_path => "posts/index"}).should == source
+          @override.failure.should be_true
+        end
+      end
+    end
+  end
+end