ui_changed 0.0.1

data/app/controllers/ui_changed/screenshots_controller.rb

@@ -0,0 +1,266 @@
+require_dependency "ui_changed/application_controller"
+require 'anemone'
+require 'fileutils'
+
+module UiChanged
+  class ScreenshotsController < ScreenshotsControllerBase
+
+    # GET /screenshots
+    def index
+      @crawl_working = is_any_job_running_or_queued ? "true" : "false"
+    end
+
+    # GET /screenshots/crawl_status.json
+    def crawl_status
+      first_status = crawl_statuses.first
+      screenshots = []
+      if first_status
+        screenshots = UiChanged::Screenshot.where("created_at > ?", first_status.time).order("id desc").limit(50).reverse
+      end
+
+      job = job_running
+      if job != nil
+        job_running_status = job.status
+        if job.name && job.name.include?("Control")
+          job_running_type = "control"
+        elsif job.name &&job.name.include?("Test")
+          job_running_type = "test"
+        elsif job.name
+          job_running_type = "compare"
+        end
+      end
+
+      diff_count = UiChanged::Screenshot.not_in_ignored.where(:diff_found => true).count
+      control_count = UiChanged::Screenshot.not_in_ignored.where(:is_control => true).count
+      test_count = UiChanged::Screenshot.not_in_ignored.where(:is_test => true).count
+      compare_count = UiChanged::Screenshot.not_in_ignored.where(:is_compare => true).count
+
+      render :json => [{
+        :screenshots => screenshots,
+        :counts => {
+          :diff => diff_count,
+          :control => control_count,
+          :test => test_count,
+          :compare => compare_count,
+        },
+        :worker => {
+          :running_status => job_running_status,
+          :running_type => job_running_type,
+          :first_status => first_status ? first_status.status : ""
+        }
+      }]
+    end
+
+    # POST /screenshots/ignored
+    def cancel
+      # there has got to be a sexy ruby way of doing this
+      crawl_statuses.each do |job|
+        next unless is_job_running(job.status)
+        job_id = job.uuid
+        puts 'cancelling job_id: ' + job_id.to_s
+        Resque::Plugins::Status::Hash.kill(job_id)
+      end
+
+      # and for good measure
+      `redis-cli FLUSHALL`
+
+      head :ok
+    end
+
+    # GET /screenshots/diffs
+    def diffs
+      params[:sort] ||= "image_file_size desc"
+      @diffs = UiChanged::Screenshot.search(params[:search]).not_in_ignored.where(:diff_found => true).paginate(:page => params[:page],
+                                                                                  :per_page => params[:per_page],
+                                                                                  :order => params[:sort])
+      @all_screenshots = []
+      @diffs.each do |diff|
+        control = UiChanged::Screenshot.find(diff.control_id)
+        test = UiChanged::Screenshot.find(diff.test_id)
+        @all_screenshots << UiChanged::AllScreenshot.new(control, test, diff)
+      end
+    end
+
+    # GET /screenshots/compares
+    def compares
+      params[:sort] ||= "url asc"
+      @screenshots = UiChanged::Screenshot.search(params[:search]).not_in_ignored.where(:is_compare => true)
+                                                                  .paginate(:page => params[:page],
+                                                                            :per_page => params[:per_page],
+                                                                            :order => params[:sort])
+      @type = "Compare"
+      render "ui_changed/screenshots/screenshots"
+    end
+
+    # GET /screenshots/controls
+    def controls
+      params[:sort] ||= "url asc"
+      @screenshots = UiChanged::Screenshot.search(params[:search]).not_in_ignored.where(:is_control => true)
+                                                                  .paginate(:page => params[:page],
+                                                                            :per_page => params[:per_page],
+                                                                            :order => params[:sort])
+      @type = "Control"
+      render "ui_changed/screenshots/screenshots"
+    end
+
+    # GET /screenshots/tests
+    def tests
+      params[:sort] ||= "url asc"
+      @screenshots = UiChanged::Screenshot.search(params[:search]).not_in_ignored.where(:is_test => true)
+                                                                  .paginate(:page => params[:page],
+                                                                            :per_page => params[:per_page],
+                                                                            :order => params[:sort])
+      @type = "Test"
+      render "ui_changed/screenshots/screenshots"
+    end
+
+    # GET /screenshots/diff
+    def diff
+      @diff = UiChanged::Screenshot.find(params[:diff_id])
+      @control = UiChanged::Screenshot.find(@diff.control_id)
+      @test = UiChanged::Screenshot.find(@diff.test_id)
+    end
+
+    # DELETE /screenshots/destroy
+    def destroy
+      UiChanged::Screenshot.destroy_entries_and_images(params[:id].split(","))
+      head :ok
+    end
+
+    # DELETE /screenshots/destroy_all_controls
+    def destroy_all_controls
+      UiChanged::Screenshot.delete_all_controls
+      head :ok
+    end
+
+    # DELETE /screenshots/destroy_all_tests
+    def destroy_all_tests
+      UiChanged::Screenshot.delete_all_tests
+      head :ok
+    end
+
+    # DELETE /screenshots/destroy_all_compares
+    def destroy_all_compares
+      UiChanged::Screenshot.delete_all_compares
+      head :ok
+    end
+
+    # remove all diffs & tests
+    # DELETE /screenshots/remove_all_diffs_and_tests
+    def remove_all_diffs_and_tests
+      UiChanged::Screenshot.remove_all_diffs_and_tests
+      head :ok
+    end
+
+    # DELETE /screenshots/remove_diff_and_test
+    def remove_diff_and_test
+      UiChanged::Screenshot.remove_diffs_and_tests(params[:id].split(","))
+      head :ok
+    end
+
+    # set tests as controls and DELETE controls and DELETE diffs
+    # POST /screenshots/set_all_tests_as_control
+    def set_all_tests_as_control
+      UiChanged::Screenshot.set_all_tests_as_controls
+      head :ok
+    end
+
+    # POST /screenshots/set_test_as_control
+    def set_test_as_control
+      UiChanged::Screenshot.set_tests_as_controls(params[:id].split(","))
+      head :ok
+    end
+
+    # crawling & comparing
+
+    # POST /screenshots/start_all
+    def start_all
+      UiChanged::Screenshot.async_crawl_and_compare
+      head :ok
+    end
+
+    # POST /screenshots/start_control
+    def start_control
+      UiChanged::Screenshot.start_async_crawl_for_control
+      head :ok
+    end
+
+    # POST /screenshots/start_test
+    def start_test
+      UiChanged::Screenshot.start_async_crawl_for_test
+      head :ok
+    end
+
+    # POST /screenshots/start_control_test
+    def start_control_test
+      UiChanged::Screenshot.start_async_crawl_for_control_and_test
+      head :ok
+    end
+
+    # POST /screenshots/start_control_compare
+    def start_control_compare
+      UiChanged::Screenshot.start_async_crawl_for_control_and_compare
+      head :ok
+    end
+
+    # POST /screenshots/start_test_compare
+    def start_test_compare
+      UiChanged::Screenshot.start_async_crawl_for_test_and_compare
+      head :ok
+    end
+
+    # POST /screenshots/start_compare
+    def start_compare
+      UiChanged::Screenshot.start_async_compare
+      head :ok
+    end
+
+    private
+
+    def crawl_statuses
+      Resque::Plugins::Status::Hash.statuses
+    end
+
+    def job_running
+      currently_running = nil
+      crawl_statuses.each do |job|
+        if is_job_running(job.status)
+          currently_running = job
+          break
+        end
+      end
+      currently_running
+    end
+
+    def all_running
+      all = []
+      crawl_statuses.each do |job|
+        if is_job_running(job.status)
+          all << job
+        end
+      end
+      all
+    end
+
+    def job_running_status
+      job = job_running
+      return unless job != nil
+      job.status
+    end
+
+    def is_any_job_running_or_queued
+      crawl_statuses.each do |job|
+        return true unless !is_job_running_or_queued(job.status)
+      end
+      return false
+    end
+
+    def is_job_running_or_queued(status)
+      return status == "working" || status == "queued"
+    end
+
+    def is_job_running(status)
+      return status == "working"
+    end
+  end
+end

data/app/controllers/ui_changed/screenshots_controller_base.rb

@@ -0,0 +1,26 @@
+module UiChanged
+  class ScreenshotsControllerBase < ApplicationController
+    before_filter :authenticate
+    before_filter :screenshot_counts, only: [:index, :diffs, :compares, :controls, :tests, :ignored, :settings, :diff]
+
+    def screenshot_counts
+      @search = params[:search]
+      @diff_count = UiChanged::Screenshot.not_in_ignored.where(:diff_found => true).count
+      @control_count = UiChanged::Screenshot.not_in_ignored.where(:is_control => true).count
+      @test_count = UiChanged::Screenshot.not_in_ignored.where(:is_test => true).count
+      @compare_count = UiChanged::Screenshot.not_in_ignored.where(:is_compare => true).count
+      @ignore_count = UiChanged::ScreenshotIgnoreUrl.count
+    end
+
+    protected
+
+    def authenticate
+      if !UiChanged::ConfigHelper.auth_username
+        return true
+      end
+      authenticate_or_request_with_http_basic do |username, password|
+        username == UiChanged::ConfigHelper.auth_username && password == UiChanged::ConfigHelper.auth_password
+      end
+    end
+  end
+end

data/app/helpers/ui_changed/application_helper.rb

@@ -0,0 +1,45 @@
+module UiChanged
+  module ApplicationHelper
+    def remove_all_path(request_fullpath)
+      if request_fullpath.include?(screenshot_controls_path)
+        screenshot_destroy_all_controls_path
+      elsif request_fullpath.include?(screenshot_tests_path)
+        screenshot_destroy_all_tests_path
+      elsif request_fullpath.include?(screenshot_compares_path)
+        screenshot_destroy_all_compares_path
+      elsif request_fullpath.include?(screenshot_ignore_urls_path)
+        screenshot_ignore_url_destroy_all_path
+      end
+    end
+    def ignore_all_urls_path(request_fullpath)
+      if request_fullpath.include?(screenshot_controls_path)
+        screenshot_ignore_url_add_all_controls_path
+      elsif request_fullpath.include?(screenshot_tests_path)
+        screenshot_ignore_url_add_all_tests_path
+      elsif request_fullpath.include?(screenshot_compares_path)
+        screenshot_ignore_url_add_all_compares_path
+      elsif request_fullpath.include?(screenshot_diffs_path)
+        screenshot_ignore_url_add_all_diffs_path
+      end
+    end
+
+    def show_remove_test_and_diff(request_fullpath)
+      request_fullpath.include?(screenshot_diffs_path) || request_fullpath.include?(screenshot_diff_path)
+    end
+    def show_remove(request_fullpath)
+      request_fullpath.include?(screenshot_controls_path) || 
+      request_fullpath.include?(screenshot_tests_path) ||
+      request_fullpath.include?(screenshot_compares_path) ||
+      request_fullpath.include?(screenshot_ignore_urls_path)
+    end
+    def show_set_test_as_control(request_fullpath)
+      request_fullpath.include?(screenshot_diffs_path) || request_fullpath.include?(screenshot_diff_path) || request_fullpath.include?(screenshot_tests_path)
+    end
+    def show_ignore_url(request_fullpath)
+      request_fullpath.include?(screenshot_diffs_path) || 
+      request_fullpath.include?(screenshot_controls_path) || 
+      request_fullpath.include?(screenshot_tests_path) ||
+      request_fullpath.include?(screenshot_compares_path)
+    end
+  end
+end

data/app/helpers/ui_changed/screenshot_ignore_urls_helper.rb

@@ -0,0 +1,4 @@
+module UiChanged
+  module ScreenshotIgnoreUrlsHelper
+  end
+end

data/app/helpers/ui_changed/screenshots_helper.rb

@@ -0,0 +1,4 @@
+module UiChanged
+  module ScreenshotsHelper
+  end
+end

data/app/mailers/ui_changed/notifications_mailer.rb

@@ -0,0 +1,57 @@
+module UiChanged
+  class NotificationsMailer < ActionMailer::Base
+    include Resque::Mailer
+
+    default :from => "ui_changed@ui_changed.com"
+    default :to => UiChanged::ConfigHelper.email_results_to
+
+    def new_controls_message
+      if !UiChanged::ConfigHelper.email_after_control_crawl
+        puts '----------- NOT sending email after control crawl -------------'
+        return
+      end
+      count = UiChanged::Screenshot.where(:is_control => true).count
+
+      puts '----------- sending email message after control crawl -------------'
+      mail(:subject => "Ui_Changed - saved #{count} control screenshots", :body => "Click here to view them: http://localhost:3000/ui_changed/screenshots/controls")
+    end
+
+    def new_tests_message
+      if !UiChanged::ConfigHelper.email_after_test_crawl
+        puts '----------- NOT sending email after test crawl -------------'
+        return
+      end
+      count = UiChanged::Screenshot.where(:is_test => true).count
+
+      puts '----------- sending email message after test crawl -------------'
+      mail(:subject => "Ui_Changed - saved #{count} test screenshots", :body => "Click here to view them: http://localhost:3000/ui_changed/screenshots/tests")
+    end
+
+    def new_compares_message
+      if !UiChanged::ConfigHelper.email_after_compare
+        puts '----------- NOT sending email after compare -------------'
+        return
+      end
+      count = UiChanged::Screenshot.where(:is_compare => true).count
+
+      puts '----------- sending email message after compare -------------'
+      mail(:subject => "Ui_Changed - saved #{count} compare screenshots", :body => "Click here to view them: http://localhost:3000/ui_changed/screenshots/compares")
+    end
+
+    def new_diffs_message
+      if !UiChanged::ConfigHelper.email_after_compare_with_diffs
+        puts '----------- NOT sending email after compare with diffs -------------'
+        return
+      end
+      count = UiChanged::Screenshot.where(:diff_found => true).count
+
+      if !UiChanged::ConfigHelper.email_after_compare_with_diffs_on_zero_found && count == 0
+        puts '----------- NOT sending email message after compare with diffs b/c zero [diffs] found -------------'
+        return
+      end
+
+      puts '----------- sending email message after compare with diffs -------------'
+      mail(:subject => "Ui_Changed - found #{count} diffs", :body => "Click here to view them: http://localhost:3000/ui_changed/screenshots/diffs")
+    end
+  end
+end

data/app/models/ui_changed/all_screenshot.rb

@@ -0,0 +1,11 @@
+module UiChanged
+  class AllScreenshot
+    attr_accessor :control_ss, :test_ss, :diff_ss
+
+    def initialize(control_ss, test_ss, diff_ss)
+      @control_ss = control_ss
+      @test_ss = test_ss
+      @diff_ss = diff_ss
+    end
+  end
+end

data/app/models/ui_changed/config_helper.rb

@@ -0,0 +1,12 @@
+module UiChanged
+  class ConfigHelper
+    MTC_CONFIG.each do |config|
+      # set the path
+      if Rails.env.test? && config[0].end_with?("_path")
+        define_singleton_method config[0], lambda { "#{Rails.root}/#{config[1]}" }
+      else
+        define_singleton_method config[0], lambda { config[1] }
+      end
+    end
+  end
+end

data/app/models/ui_changed/screenshot.rb

@@ -0,0 +1,258 @@
+require 'anemone'
+require 'selenium-webdriver'
+require 'fileutils'
+
+module UiChanged
+  class Screenshot < ActiveRecord::Base
+    attr_accessible :url,
+                    :is_control,
+                    :is_test,
+                    :is_compare,
+                    :diff_found,
+                    :control_id,
+                    :test_id,
+                    :image_file_name,
+                    :image_file_size,
+                    :image_content_type,
+                    :displayable_image_path_full,
+                    :displayable_image_path_small_full
+
+    validates :url, :presence => true, :format => URI::regexp(%w(http https))
+    validates :image_file_name, :presence => true
+    validates :image_file_size, :presence => true
+    validates :image_content_type, :presence => true
+
+    validate :check_only_one_type
+    validate :check_diff_found
+    validate :check_compare_ids
+    validate :check_image_content_type
+
+    def check_only_one_type
+      types = [is_control, is_test, is_compare]
+      if types.count(true) != 1
+        errors[:base] << 'screenshot can only have one is value set to true'
+      end
+    end
+    def check_diff_found
+      if diff_found && !( !is_control && !is_test && is_compare )
+        errors[:base] << 'when diff found is set it must be of type is_compare'
+      end
+    end
+    def check_compare_ids
+      if is_compare && (control_id == nil || test_id == nil)
+        errors[:base] << 'is_compare screenshots must have their control_id and test_id set'
+      end
+    end
+    def check_image_content_type
+      errors.add(:image_content_type, "can only be png") unless image_content_type == "png"
+    end
+
+    self.per_page = 15
+
+    class << self
+
+      def start_async_crawl_for_control
+        UiChanged::CrawlControl.create
+      end
+
+      def start_async_crawl_for_test
+        UiChanged::CrawlTest.create
+      end
+      def start_async_crawl_for_control_and_test
+        start_async_crawl_for_control
+        start_async_crawl_for_test
+      end
+      def start_async_crawl_for_control_and_compare
+        start_async_crawl_for_control
+        start_async_compare
+      end
+      def start_async_crawl_for_test_and_compare
+        start_async_crawl_for_test
+        start_async_compare
+      end
+      def start_async_compare
+        UiChanged::Compare.create
+      end
+
+      def async_crawl_and_compare
+        start_async_crawl_for_control
+        start_async_crawl_for_test
+        start_async_compare
+      end
+
+      def search(search)
+        UiChanged::Screenshot.where('ui_changed_screenshots.url LIKE ?', "%#{search}%")
+      end
+      def set_all_tests_as_controls
+        delete_all_controls
+        move_all_test_images_to_control
+        UiChanged::Screenshot.update_all({:is_control => true, :is_test => false}, {:is_test => true})
+      end
+      def set_tests_as_controls(test_ids)
+        test_ids.each do |test_id|
+          set_test_as_control(test_id)
+        end
+      end
+      def set_test_as_control(test_id)
+        test_ss = UiChanged::Screenshot.find(test_id)
+        control_ss = UiChanged::Screenshot.find_by_url_and_is_control(test_ss.url, true)
+        compare_ss = UiChanged::Screenshot.find_by_test_id(test_ss.id)
+
+        unless !control_ss
+          control_ss.remove_image
+          control_ss.destroy
+        end
+        unless !compare_ss
+          compare_ss.remove_image
+          compare_ss.destroy
+        end
+
+        test_ss.is_control = true
+        test_ss.is_test = false
+        test_ss.save
+        # move test ss's to control dir
+        test_ss.move_test_image_to_control
+      end
+
+      # delete all entries & images
+      def delete_all_controls
+        UiChanged::Screenshot.delete_all(:is_control => true)
+        UiChanged::Screenshot.delete_all(:is_compare => true)
+        FileUtils.rm_rf(Dir.glob(UiChanged::ConfigHelper.control_path + '*'))
+        FileUtils.rm_rf(Dir.glob(UiChanged::ConfigHelper.compare_path + '*'))
+      end
+      def delete_all_tests
+        UiChanged::Screenshot.delete_all(:is_test => true)
+        UiChanged::Screenshot.delete_all(:is_compare => true)
+        FileUtils.rm_rf(Dir.glob(UiChanged::ConfigHelper.test_path + '*'))
+        FileUtils.rm_rf(Dir.glob(UiChanged::ConfigHelper.compare_path + '*'))
+      end
+      def delete_all_compares
+        UiChanged::Screenshot.delete_all(:is_compare => true)
+        FileUtils.rm_rf(Dir.glob(UiChanged::ConfigHelper.compare_path + '*'))
+      end
+
+      def destroy_entries_and_images(ids)
+        ids.each do |id|
+          destroy_entry_and_image(id)
+        end
+      end
+      def destroy_entry_and_image(id)
+        ss = UiChanged::Screenshot.find(id)
+
+        # remove the corresponding compare screenshot
+        if ss.is_control
+          compare_ss = UiChanged::Screenshot.find_by_control_id(ss.id)
+          if compare_ss
+            compare_ss.remove_image
+            compare_ss.destroy
+          end
+        elsif ss.is_test
+          compare_ss = UiChanged::Screenshot.find_by_test_id(ss.id)
+          if compare_ss
+            compare_ss.remove_image
+            compare_ss.destroy
+          end
+        end
+
+        ss.remove_image
+        ss.destroy
+      end
+
+      def remove_all_diffs_and_tests
+        delete_all_compares
+        delete_all_tests
+      end
+      def remove_diffs_and_tests(diff_ids)
+        diff_ids.split(",").each do |diff_id|
+          remove_diff_and_test(diff_id.first.to_i)
+        end
+      end
+      def remove_diff_and_test(diff_id)
+        ss_diff = UiChanged::Screenshot.find(diff_id)
+        ss_test = UiChanged::Screenshot.find(ss_diff.test_id)
+        ss_diff.remove_image
+        ss_diff.destroy
+
+        ss_test.remove_image
+        ss_test.destroy
+      end
+
+      def move_all_test_images_to_control
+        # delete all control images
+        FileUtils.rm_rf(Dir.glob(UiChanged::ConfigHelper.control_path + '*'))
+
+        # move all test images to control directory
+        Dir.foreach(UiChanged::ConfigHelper.test_path) do |img|
+          next if img == '.' || img == '..'
+          # do work on real items
+          UiChanged::Screenshot.move_test_image_to_control(img)
+        end
+      end
+
+      def move_test_image_to_control(image_file_name_full)
+        FileUtils.mv(UiChanged::ConfigHelper.test_path + image_file_name_full,
+                     UiChanged::ConfigHelper.control_path + image_file_name_full)
+      end
+
+      def not_in_ignored
+        UiChanged::Screenshot.joins("LEFT JOIN ui_changed_screenshot_ignore_urls siu ON siu.url = ui_changed_screenshots.url").where('siu.id is null')
+      end
+    end
+
+    def remove_image
+      FileUtils.rm(image_path_full)
+      FileUtils.rm(image_path_small_full)
+    end
+
+    def move_test_image_to_control
+      UiChanged::Screenshot.move_test_image_to_control(image_file_name_full)
+      UiChanged::Screenshot.move_test_image_to_control(image_file_name_small_full)
+    end
+
+    def image_path_base
+      if is_control
+        UiChanged::ConfigHelper.control_path
+      elsif is_compare
+        UiChanged::ConfigHelper.compare_path
+      else
+        UiChanged::ConfigHelper.test_path
+      end
+    end
+
+    def displayable_image_path_full
+      image_path_full.sub('public','')
+    end
+
+    def displayable_image_path_small_full
+      image_path_small_full.sub('public','')
+    end
+
+    def image_path_full
+      image_path_base + image_file_name_full
+    end
+
+    def image_path_small_full
+      image_path_base + image_file_name_small_full
+    end
+
+    def image_file_name_full
+      if image_file_name == nil || image_content_type == nil
+        return "default.png"
+      end
+      image_file_name + "." + image_content_type
+    end
+
+    def image_file_name_small_full
+      if image_file_name == nil || image_content_type == nil
+        return "default.png"
+      end
+      image_file_name + "_small." + image_content_type
+    end
+
+    def as_json(*a)
+      self.attributes.merge({"displayable_image_path_full" => self.displayable_image_path_full})
+    end
+
+  end
+end