watircats 0.2.3

data/lib/watircats/mapper.rb

@@ -0,0 +1,149 @@
+require "open-uri"
+require "xmlsimple"
+
+module WatirCats
+  class Mapper
+
+    def initialize( base_url, scheme )
+      # Class variables that persist throughout the life of the application
+      
+      @limit = WatirCats.config.limit
+      @proxy = WatirCats.config.proxy
+
+      @@master_paths = {}
+      @@new_paths    = {}
+
+      # Subtree is a way to limit screenshots based on a path. It gets placed into a regular expression.
+      restrict_paths
+
+      @base_url = base_url
+  
+      # If the :url_list option is passed, it is assumed to be a file of urls,
+      # one on each line. Otherwise, assume there is a sitemap
+      if WatirCats.config.url_list
+        begin
+          urls = File.readlines WatirCats.config.url_list
+          urls.each { |url| url.strip! }
+        rescue Exception => msg
+          print msg
+          exit 1
+        end
+      else
+        xml        = get_sitemap_as_xml( scheme, @base_url ) 
+        urls       = parse_sitemap_into_urls(xml)
+      end
+
+      @the_paths = paths(urls)
+    end
+
+    def get_sitemap_as_xml(scheme, base_url)
+
+      the_scheme = scheme || "http"
+      if @proxy
+        proxy = the_scheme + "://" + @proxy
+      else
+        proxy = nil
+      end
+
+      begin 
+        sitemap_data = ::OpenURI.open_uri((the_scheme + "://" + base_url + "/sitemap.xml"), :proxy => proxy )
+        sitemap_xml  = ::XmlSimple.xml_in(sitemap_data)
+      rescue Exception => msg
+        print msg
+        exit 1
+      end
+    end
+
+    def parse_sitemap_into_urls(xml)
+      # Empty Array to dump URLs into
+      urls = []
+      xml["url"].each do |key|
+        urls << key["loc"].first
+      end
+      # Return the URLs
+      urls
+    end
+
+    def paths(urls)
+
+      # Determine if this is the first pass
+      if @@master_paths.size == 0
+        mode = :first_run
+      else 
+        mode = :not_first
+      end
+
+      # Create an empty hash to store paths in
+      pending_paths = {}
+      
+      # Iterate through the urls, grab only the valid paths post domain
+      # Store each path_key with the extrapolated path
+      urls.each do |url|
+        path = URI.parse(url).path
+
+        # Handled paths to look for and avoid
+        if @subtree
+          next unless path.match @subtree 
+        end
+        if @avoided_path
+          next if path.match @avoided_path
+        end
+
+        path_key = path.tr("/","-")[1..-2] unless path == "/"
+        path_key ||= "root" # Nil guard to set 'root' for home
+
+        # If this is the first run, definitely process it
+        # If not the first run, ensure path_key exists
+        # If not the first run, path_key not present, put it in @@new_paths
+        if mode == :first_run
+          pending_paths[path_key] = path
+        else
+          if @@master_paths[path_key]
+            pending_paths[path_key] = path
+          else
+            @@new_paths[path_key]   = path
+          end
+        end
+      end
+      
+      # Store master paths if this is the first pass
+      @@master_paths.merge! pending_paths if mode == :first_run
+      # return the paths to crawl
+      pending_paths
+    end
+
+    def the_paths
+      # TODO: Insert logic to limit to a specific subtree here
+      
+      # Return the paths if there is a @limit
+      return @the_paths.first(@limit.to_i) if @limit
+      @the_paths.first(@the_paths.length)
+    end
+
+    def master_paths
+      # Enforce limit on @@master_paths, too, because why not
+      return @@master_paths.first(@limit.to_i) if @limit
+      @@master_paths.first(@@master_paths.length)
+    end
+
+    def new_paths
+      @@new_paths.first(@@new_paths.length)
+    end
+
+    def restrict_paths
+
+      # Only visit paths that match @subtree
+      @subtree = WatirCats.config.limited_path
+      if @subtree 
+        @subtree = /#{WatirCats.config.limited_path}/
+      end
+      
+      # If avoided_path is specified, avoid those
+      @avoided_path = WatirCats.config.avoided_path
+      if @avoided_path
+        @avoided_path = /#{WatirCats.config.avoided_path}/
+      end
+    end
+
+  end
+end

data/lib/watircats/reporter.rb

@@ -0,0 +1,80 @@
+require "haml"
+
+module WatirCats
+  class Reporter
+    # Handles the report generation
+
+    def initialize(results_array)
+      @data = results_array
+    end
+
+    def build_html
+      # Create a report based off of the template data. 
+      # binding gives Haml context, and @data dumps the relevant information in
+      Haml::Engine.new(get_screenshot_template).render binding, :data => @data
+    end
+
+    def get_screenshot_template
+      template = <<TEMPLATE
+!!! 5
+%html
+  %head
+    %title Comparison courtesy of WatirCats
+    %script{:type => "text/javascript",
+            :src => "https://ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"}
+    %script{:type => "text/javascript",
+            :src => "https://cdnjs.cloudflare.com/ajax/libs/masonry/3.1.1/masonry.pkgd.min.js"}
+    :css
+      p { padding-left: 10px; }
+      .item { width:140px;  font-family: sans-serif; font-size: 10px; }
+      div.item { padding: 5px ;border: 2px; border-color: black; overflow: auto; box-shadow: inset 1px 1px 8px 1px gray; margin-top: 10px;}
+      div.item:hover{ transition: .3s; box-shadow: 1px 1px 8px 1px slategray; adding: 8px; margin-left: -3px; margin-top: 6px; }
+      img{ width: 50px; height: 100px; float: left}
+    %script
+      $(function(){$('#container').masonry({itemSelector : '.item',columnWidth : 160});});
+  %body
+    %div#container
+      - data.each do |path| 
+        %div{ :class => "item", :style => "background-color: " + path[:status_color]  }
+          %a{ :href => path[:compared_shot] }
+            - thumb = "thumbs/" + path[:compared_shot]
+            %img{ :src => thumb, :alt => path[:compared_shot], :title => path[:compared_shot] }
+          %p<
+            %strong Pixels Changed: 
+            = path[:result]
+TEMPLATE
+    end
+
+    def self.build_custom_results(hash)
+      AwesomePrint.defaults = { :html => true, :indent => 2, :plain => true}
+      template = <<TEMPLATE
+!!! 5
+%html
+  %head
+    %title Custom Test Results
+    %script{:type => "text/javascript", 
+            :src => "https://google-code-prettify.googlecode.com/svn/loader/run_prettify.js"}
+    %script{:type => "text/javascript",
+            :src => "https://ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"}
+    :css
+      .item { width:auto;  font-family: sans-serif; font-size: 10px; }
+      .clear { float: clear }
+  %body
+    %div#container
+      - hash.each_pair do |key, value|
+        %div{ :class => "item" }
+          %div{:class => "left"}
+            %pre{:class => "prettyprint lang-rb"}
+              = key
+          %div
+            %pre{:class => "prettyprint lang-rb"}
+              != value.to_s.gsub(",",",\n")
+        %div{ :class => "clear" }
+    %script
+      $(window).load("prettyPrint()")
+TEMPLATE
+    Haml::Engine.new(template).render binding, :hash => hash
+    end
+
+  end
+end

data/lib/watircats/runner.rb

@@ -0,0 +1,63 @@
+module WatirCats
+  
+  class Runner
+    def initialize(task, sources)
+      
+      # Setup the directories for screenshots and comparison output
+
+      # Using a case statement to determine how to operate.
+      # case and when are not to be waste an indent level
+      case task
+      when :compare
+        sources.each do |source|
+          # If source is nil, go to the next one (which probably won't exist)
+          next unless source 
+          
+          # Prep the URI object
+          uri      = URI.parse(source)
+          base_url = uri.host
+          scheme   = uri.scheme || "http"
+
+          # Grab a Mapper object to pass to Snapper
+          site_map = WatirCats::Mapper.new( base_url, scheme )
+          
+          # Snapper will snap screenshots, using a site_map object
+          WatirCats::Snapper.new( base_url, site_map )
+        end
+
+        folders        = WatirCats::Snapper.folders
+        base_folder    = folders.first
+        changed_folder = folders.last
+
+        WatirCats::Comparer.new( base_folder, changed_folder )
+
+      # Only take screenshots
+      when :screenshots_only
+        sources.each do |source|
+          # If source is nil, go to the next one (which probably won't exist)
+          next unless source 
+          
+          # Prep the URI object
+          uri      = URI.parse(source)
+          base_url = uri.host
+          scheme   = uri.scheme
+
+          # Grab a Mapper object to pass to Snapper
+          site_map = WatirCats::Mapper.new( base_url, scheme )
+          
+          # Snapper will snap screenshots, using a site_map object
+          WatirCats::Snapper.new( base_url, site_map )
+        end
+
+      # Let's just compare folders
+      when :folders
+        base_folder    = sources.first
+        changed_folder = sources.last
+        WatirCats::Comparer.new( base_folder, changed_folder )
+      # End case
+      end
+
+
+    end
+  end
+end

data/lib/watircats/snapper.rb

@@ -0,0 +1,167 @@
+require 'watir-webdriver'
+
+module WatirCats
+  class Snapper
+    
+    BROWSER_HEIGHT = 5000
+
+    def initialize(base_url, site_map)
+      @base_url       = base_url
+      @screenshot_dir = WatirCats.config.screenshot_dir
+      @widths         = WatirCats.config.widths
+      @images_dir     = WatirCats.config.images_dir
+      
+      # Handle the environments that require profile configuration
+      configure_browser
+
+      # Allowing for custom page class tests
+      @class_tests          = [ ]
+      @class_test_mapping   = { }
+      @@custom_test_results = { }
+
+      if WatirCats.config.custom_body_class_tests
+        load WatirCats.config.custom_body_class_tests
+        $custom_body_class_tests.each do |custom_test|
+          # Store the custom class tests in the class_tests array
+          # Map the class to the relevant method name
+          
+          body_class = custom_test[:body_class_name]
+          @class_tests << body_class
+          if @class_test_mapping[ body_class ] 
+            @class_test_mapping[ body_class ] = @class_test_mapping[ body_class ] + [ custom_test[:method_name] ]
+          else 
+            @class_test_mapping[ body_class ] = [ custom_test[:method_name] ]
+          end
+
+          custom_code = "def #{custom_test[:method_name]}; #{custom_test[:custom_code]}; end"
+          WatirCats::Snapper.class_eval custom_code
+        end
+      end
+
+      # Retrieve the paths from the sitemap
+      @paths      = site_map.the_paths
+      @time_stamp = Time.now.to_i.to_s
+      
+      process_paths
+      @browser.quit
+    end
+
+    def resize_browser(width)
+      # Set a max height using the constant BROWSER_HEIGHT
+      @browser.window.resize_to(width, BROWSER_HEIGHT)
+    end
+
+    def capture_page_image(url, file_name)
+      
+      # skip existing screenshots if we've specified that option
+      if WatirCats.config.skip_existing
+          if FileTest.exists?(file_name)
+             puts "Skipping existing file at " + file_name
+             return
+          end
+      end
+
+
+      @browser.goto url
+      # Wait for page to complete loading by querying document.readyState
+      script = "return document.readyState"
+      @browser.wait_until { @browser.execute_script(script) == "complete" }
+      
+      # Take and save the screenshot      
+      @browser.screenshot.save(file_name)
+    end
+
+    def widths
+      @widths = @widths || [1024]
+    end
+
+    def self.folders
+      # Class variable, to keep track of folders amongst all instances of this class
+      @@folders ||= []
+    end
+
+    def add_folder(folder)
+      @@folders ||= [] # Ensure @@folders exists
+      @@folders << folder
+    end
+
+    def process_paths
+      # Build the unique directory unless it exists
+      FileUtils.mkdir "#{@screenshot_dir}" unless File.directory? "#{@screenshot_dir}"
+
+      stamped_base_url_folder = "#{@screenshot_dir}/#{@base_url}-#{@time_stamp}"
+      if @images_dir
+          stamped_base_url_folder = "#{@screenshot_dir}/#{@images_dir}"
+      end
+	
+      FileUtils.mkdir "#{stamped_base_url_folder}" unless File.directory? "#{stamped_base_url_folder}"
+ 
+      add_folder(stamped_base_url_folder)
+
+      # Some setup for processing
+      paths = @paths
+      widths = self.widths
+
+      # Iterate through the paths, using the key as a label, value as a path
+      paths.each do |label, path|
+        # Create our base array to use to execute tests
+        potential_body_classes = [:all]
+        # Do custom tests here
+        body_classes = @browser.body.class_name
+        # Split the class string for the <body> element on spaces, then shovel
+        # each body_class into the potential_body_classes array
+        body_classes.split.each { |body_class| potential_body_classes << body_class }
+        
+        @@custom_test_results[path] = {}
+
+        potential_body_classes.each do |the_class|
+          if @class_tests.include? the_class
+            methods_to_send = @class_test_mapping[the_class]
+
+            methods_to_send.each do |custom_method|
+              @@custom_test_results[path][custom_method] = self.send( custom_method )
+            end
+          
+          end
+        end
+
+        # For each width, resize the browser, take a screenshot
+        widths.each do |width|
+          resize_browser width
+          file_name = "#{stamped_base_url_folder}/#{label}_#{width}.png"
+          capture_page_image("#{@base_url}#{path}", file_name)
+        end
+      end
+    end
+
+    def configure_browser
+      engine = WatirCats.config.browser || :ff
+
+      # Firefox only stuff, allowing a custom binary location and proxy support
+      if ( engine.to_sym == :ff || engine.to_sym == :firefox )
+
+        bin_path = WatirCats.config.ff_path
+        proxy    = WatirCats.config.proxy
+        ::Selenium::WebDriver::Firefox::Binary.path= bin_path if bin_path.is_a? String
+        
+        profile = ::Selenium::WebDriver::Firefox::Profile.new 
+        
+        if proxy
+          profile.proxy = ::Selenium::WebDriver::Proxy.new :http => proxy, :ssl => proxy
+        end
+
+        profile['app.update.auto']    = false
+        profile['app.update.enabled'] = false
+
+        @browser = ::Watir::Browser.new engine, :profile => profile
+      else
+        @browser = ::Watir::Browser.new engine
+      end
+    end
+
+    def self.custom_test_results
+      @@custom_test_results ||= { }
+    end
+
+  end
+end

data/lib/watircats/version.rb

@@ -0,0 +1,3 @@
+module WatirCats
+  VERSION = "0.2.3"
+end

data/lib/watircats.rb

@@ -0,0 +1,16 @@
+# External requires
+require "open-uri"
+require "xmlsimple"
+require "openssl"
+require "watir-webdriver"
+
+# Internal Requires
+require "watircats/comparer"
+require "watircats/mapper"
+require "watircats/reporter"
+require "watircats/snapper"
+require "watircats/version"
+require "watircats/runner"
+require "watircats/cli"
+require "watircats/config"
+

data/sample_config.yml

@@ -0,0 +1,19 @@
+# Sample parameters for the config file
+# Uncomment any line below and place in your custom values
+# 
+# avoided_path            : string_that_matches_paths_to_avoid
+# browser                 : firefox
+# csv                     : false
+# custom_body_class_tests : path/to/custom_tests_file.rb
+# ff_path                 : /Applications/FirefoxESR.app/Contents/MacOS/firefox-bin
+# limit                   : 1
+# limited_path            : a_string_that_becomes_a_regex_to_narrow_screenshots
+# output_dir              : comparison
+# proxy                   : my_proxy_info:8080
+# reporting_enabled       : true
+# screenshot_dir          : screenshots
+# strip_zero_differences  : true
+# url_list                : path/to/plain_text_list_of_urls.txt
+# verbose                 : false
+# widths                  : [1024, 800]
+# working_dir             : sample_working_dir/

data/test/test_comparer.rb

@@ -0,0 +1,51 @@
+require 'watircats'
+
+class ComparerTest < Minitest::Test
+  
+  def setup
+    # Initial setup
+    WatirCats.configure :output_dir => "test/testables/output"
+
+    @source_a = "test/testables/folder_a/"
+    @source_b = "test/testables/folder_b/"
+    @output   = WatirCats.config.output_dir
+  end
+
+  def test_compare_directories_and_results
+    WatirCats.configure :reporting_enabled => false, :output_dir => "test/testables/output/no_thumbs"
+    output_dir = WatirCats.config.output_dir
+    comparer   = WatirCats::Comparer.new( @source_a, @source_b )
+
+    results  = comparer.results
+    expected = [{ :compared_shot => "watircat_compared.png", 
+                  :result => "832", :status_color => "Khaki" }]
+
+    assert_equal expected, results
+    assert_equal true, File.exists?("#{output_dir}/watircat_compared.png")
+    assert_equal false, File.exists?("#{output_dir}/watircat_no_compare_compared.png")
+    assert_equal false, File.directory?("#{output_dir}/thumbs")
+    FileUtils.rm_rf output_dir
+  end
+
+  def test_compare_directories_and_results_with_reporting
+    WatirCats.configure :reporting_enabled => true, :output_dir => "test/testables/output/with_thumbs"
+    output_dir = WatirCats.config.output_dir
+
+    comparer = WatirCats::Comparer.new( @source_a, @source_b )
+
+    results  = comparer.results
+    expected = [{ :compared_shot => "watircat_compared.png", 
+                  :result => "832", :status_color => "Khaki" }]
+
+    assert_equal expected, results
+    assert_equal true, File.exists?("#{output_dir}/watircat_compared.png")
+    assert_equal false, File.exists?("#{output_dir}/watircat_no_compare_compared.png")
+    assert_equal true, File.directory?("#{output_dir}/thumbs/")
+    assert_equal true, File.exists?("#{output_dir}/thumbs/watircat_compared.png")
+    FileUtils.rm_rf output_dir
+  end
+
+  def teardown
+  end
+
+end

data/test/test_mapper.rb

@@ -0,0 +1,59 @@
+require 'minitest/autorun'
+require 'watircats'
+
+class MapperTest < Minitest::Test
+  
+  def setup
+    @base_url = "www.clockwork.net"
+    @scheme   = "http"
+    options  = { :limit => 1 }
+    @xml_file = XmlSimple.xml_in(File.open("test/testables/sitemap.xml", "r"))
+    WatirCats.configure options
+  end
+
+  def test_parse_sitemap_into_urls
+    map = WatirCats::Mapper.new(
+      @base_url, 
+      @scheme
+      ).parse_sitemap_into_urls(@xml_file)
+
+    expected = [
+      "http://www.clockwork.net/",
+      "http://www.clockwork.net/work/",
+      "http://www.clockwork.net/people/",
+      "http://www.clockwork.net/blog/"
+      ]
+
+    assert_equal map, expected
+  end
+
+  def test_paths
+    urls = [
+      "http://www.clockwork.net/",
+      "http://www.clockwork.net/work/",
+      "http://www.clockwork.net/people/",
+      "http://www.clockwork.net/blog/"
+      ]
+
+    paths = WatirCats::Mapper.new(
+      @base_url,
+      @scheme
+      ).paths(urls)
+
+    expected = {
+        "root"   => "/",
+        "work"   => "/work/",
+        "people" => "/people/",
+        "blog"   => "/blog/"
+    }
+    assert_equal paths, expected
+  end
+
+  def test_mapper
+    mapper = WatirCats::Mapper.new( @base_url, @scheme )
+    expected = [["root", "/"]]
+    assert_equal mapper.the_paths, expected
+    assert_equal mapper.master_paths, expected
+    assert_equal mapper.new_paths, []
+  end
+end

data/test/test_snapper.rb

@@ -0,0 +1,36 @@
+require 'watircats'
+require 'minitest/mock'
+
+class SnapperTest < Minitest::Test
+  def setup
+    @base_url                = "www.clockwork.net"
+    $custom_body_class_tests = []
+    @sitemap                 = Minitest::Mock.new
+    
+    @options = { 
+      :screenshot_dir => "test/testables/screenshot_tmp/",
+      :browser => :ff
+       }
+    # Configure the mock object
+    @sitemap.expect( :the_paths, [["root", "/"]] )
+  end
+
+  def test_snapper_takes_snaps
+    
+    WatirCats.configure(@options)
+
+    snapped = WatirCats::Snapper.new( @base_url, @sitemap )
+
+    working_dir = Dir.pwd
+    Dir.chdir( WatirCats.config.screenshot_dir )
+    target_dir = Dir.glob("*/*.png")
+    expected   = target_dir[0].split( "/" ).include? "root_1024.png"
+    assert_equal 1, target_dir.size
+    assert_equal true, expected
+    Dir.chdir working_dir
+  end
+
+  def teardown
+    FileUtils.rm_rf WatirCats.config.screenshot_dir
+  end
+end

data/test/testables/sitemap.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9 http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd"
+        xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+	
+	<url>
+		<loc>http://www.clockwork.net/</loc>
+	</url>
+	
+	<url>
+		<loc>http://www.clockwork.net/work/</loc>
+	</url>
+	
+	<url>
+		<loc>http://www.clockwork.net/people/</loc>
+	</url>
+	
+	<url>
+		<loc>http://www.clockwork.net/blog/</loc>
+	</url>
+	
+</urlset>