monet 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4ba54b53a3cb965bdcc834da924e37f3df244e76
+  data.tar.gz: ca5a32475a8411d8dcc61e750ca6e534582a38a2
+SHA512:
+  metadata.gz: e2debbc40dc2411f580a40ee1dd8e8bf6691ca342779ac773a8ca48d059edd35d442a89cbb3cffb28c402f88f0413ff99b7ad16c6313cac9b1607c078545ffd9
+  data.tar.gz: 0308e17eeac8c8e00d60a1e752b74711186f1faa16ec0bc729082b14a8d0f3e1d8dc45132fec54b46441f7eb972a66bfcdc5fc1de0ce56ad323d246fcadfa8e7

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+.gems
+
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.ruby-gemset

@@ -0,0 +1 @@
+monet

data/.ruby-version

@@ -0,0 +1 @@
+2.0

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 2.0
+  - 1.9.3
+  - rbx
+

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in monet.gemspec
+gemspec
+
+group :test do
+  gem 'pry'
+  gem 'webmock'
+  gem 'vcr'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Luke van der Hoeven
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,68 @@
+# Monet
+[![Build Status](https://travis-ci.org/plukevdh/monet.png?branch=master)](https://travis-ci.org/plukevdh/monet)
+[![Code Climate](https://codeclimate.com/github/plukevdh/monet.png)](https://codeclimate.com/github/plukevdh/monet)
+
+Monet is a libary built for making testing interfaces and design easy. We all have interfaces that we've added a new button, changed some CSS, or added new javascript interaction to and had the page layout explode unexpectedly. Monet is meant to make tracking those changes and ensuring consistent automatably easy.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'monet'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install monet
+
+## Usage
+
+The basic gem requires a config file that is somehow called on the app startup. This config primarily exists to give the gem a list of paths it needs to collect and either baseline or compare to previous baselines. This config might look something like this:
+
+```ruby
+Monet.config do |config|
+  config.driver = :poltergeist
+  config.dimensions = [1440,900]
+
+  config.map do |map|
+    map.add 'home/index'
+    map.add 'home/show'
+  end
+
+  # alternatively...
+
+  config.map :spider
+end
+```
+
+## Todo
+- Site spidering
+- Baseline caching
+- Browser/driver config
+- Parallelize PNG diffing
+- Dashboard
+- Rails integration
+- Sinatra/Rack integration
+- Web UI
+
+## Contributing
+
+1. Fork it
+2. Branch it (`git checkout -b my-new-feature`)
+3. Commit it (`git commit -am 'Add some feature'`)
+4. Push it (`git push origin my-new-feature`)
+5. Pull Request it!
+
+Willing to consider commit bit priviledges to anyone who expresses extreme interest in the project.
+
+## Credits
+
+Big shout to __Jeff Kreeftmeijer__ for his blog post on [ChunkyPNG](http://jeffkreeftmeijer.com/2011/comparing-images-and-creating-image-diffs/). The Monet::Compare::CompareStrategy code is basically what he wrote in the post.
+
+## Alternatives
+
+- https://github.com/intridea/green_onion : Mostly the same thing I did here, but I didn't know about it starting out. I like what they did, but I had a different take, so I decided to pursue my version to the end.
+- https://github.com/BBC-News/wraith : Similar idea again, but more limited in features, also doesn't allow for baselining, more of a multi-site/URL compare.

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+desc "Runs the site and grabs baselines"
+
+task :baseline do
+
+end
+
+RSpec::Core::RakeTask.new(:test)
+task :default => :test

data/lib/monet/capture.rb

@@ -0,0 +1,37 @@
+require "capybara"
+require 'capybara/poltergeist'
+require "capybara/dsl"
+
+require 'monet/config'
+
+module Monet
+  class Capture
+    include Capybara::DSL
+
+    def initialize(config={})
+      @config = (config.is_a? Monet::Config) ? config : Monet::Config.new(config)
+
+      # TODO: make configurable
+      Capybara.default_driver = @config.driver
+    end
+
+    def capture(path)
+      visit normalize_path(path)
+      page.driver.render(image_name_from_path(path), full: true)
+    end
+
+    private
+    def capture_path
+      @config.capture_dir
+    end
+
+    def normalize_path(path)
+      "http://#{path}" unless path.start_with?("https?")
+    end
+
+    def image_name_from_path(path)
+      name = path.gsub(/https?:\/\//, '').gsub('.', '_')
+      "#{capture_path}/#{name}-#{Time.now.to_i}.png"
+    end
+  end
+end

data/lib/monet/capture_map.rb

@@ -0,0 +1,72 @@
+require 'spidr'
+
+module Monet
+  class CaptureMap
+    extend Forwardable
+
+    class PathCollection
+      attr_reader :paths, :root_url
+
+      def initialize(root_url)
+        @root_url = root_url
+        @paths = []
+      end
+
+      def add(path)
+        @paths << normalized_path(path)
+      end
+
+      def normalized_path(path)
+        path.chomp "/"
+      end
+    end
+
+    class PathSpider < PathCollection
+      SKIP_EXT = %w(js css png jpg mp4 txt zip ico ogv ogg pdf gz)
+      SKIP_PATHS = [/\?.*/]
+
+      def paths
+        @paths = normalize Spidr.site(@root_url, ignore_links: ignores)
+      end
+
+      def ignores
+        SKIP_EXT.map {|x| Regexp.new x }.concat SKIP_PATHS
+      end
+
+      private
+      def normalize(spider_results)
+        spider_results.history.map &:to_s
+      end
+    end
+
+    InvalidURL = Class.new(StandardError)
+
+    attr_reader :type
+
+    def initialize(root_url, type=:explicit, &block)
+      @type = type
+      @path_helper = type_mapper.new parse_uri(root_url)
+
+      yield(@path_helper) if block_given?
+    end
+
+    def_delegators :@path_helper, :paths, :add, :root_url
+
+    def type_mapper
+      case @type
+      when :explicit
+        PathCollection
+      when :spider
+        PathSpider
+      end
+    end
+
+    private
+    def parse_uri(path)
+      uri = URI.parse path
+      raise InvalidURL, "#{path} is not a valid url" if uri.class == URI::Generic
+
+      uri.to_s
+    end
+  end
+end

data/lib/monet/compare.rb

@@ -0,0 +1,58 @@
+require 'oily_png'
+require 'monet/diff_strategy'
+
+module Monet
+  class Compare
+    extend Forwardable
+
+    class Changeset
+      def initialize(base_image, pixel_array)
+        @base_image = base_image
+        @changed_pixels = pixel_array
+      end
+
+      def modified?
+        pixels_changed > 0
+      end
+
+      def pixels_changed
+        @changed_pixels.count
+      end
+
+      def percentage_changed
+        ((pixels_changed.to_f / @base_image.area.to_f) * 100).round(2)
+      end
+    end
+
+    def initialize(strategy=ColorBlend)
+      @strategy_class = strategy
+    end
+
+    def compare(base_image, new_image)
+      base_png = ChunkyPNG::Image.from_file(base_image)
+      new_png = ChunkyPNG::Image.from_file(new_image)
+
+      diff_stats = []
+
+      # TODO: make configurable
+      diff_strategy = @strategy_class.new(base_png, new_png)
+
+      base_png.height.times do |y|
+        base_png.row(y).each_with_index do |pixel, x|
+          diff_strategy.calculate_for_pixel(pixel, x, y)
+        end
+      end
+
+      changeset = Changeset.new(base_png, diff_strategy.score)
+      diff_strategy.save(diff_filename(base_image)) if changeset.modified?
+
+      changeset
+    end
+
+    private
+
+    def diff_filename(base_filename)
+      base_filename[0..-5] << "-diff.png"
+    end
+  end
+end

data/lib/monet/config.rb

@@ -0,0 +1,45 @@
+require 'monet/capture_map'
+
+module Monet
+  class Config
+    MissingBaseURL = Class.new(Exception)
+
+    DEFAULT_OPTIONS = {
+      driver: :poltergeist,
+      dimensions: [1440],
+      map: nil,
+      base_url: nil,
+      capture_dir: "./captures"
+    }
+
+    attr_accessor *DEFAULT_OPTIONS.keys
+
+    def initialize(opts={})
+      DEFAULT_OPTIONS.each do |opt, default|
+        send "#{opt}=", opts[opt] || default
+      end
+    end
+
+    def self.config(&block)
+      cfg = new
+      block.call cfg
+      cfg
+    end
+
+    def base_url
+      raise MissingBaseURL, "Please set the base_url in the config" unless @base_url
+      @base_url
+    end
+
+    def capture_dir=(path)
+      @capture_dir = File.expand_path(path)
+    end
+
+    def map(type=:explicit, &block)
+      @map ||= CaptureMap.new(base_url, type)
+
+      block.call(@map) if block_given? && type == :explicit
+      @map
+    end
+  end
+end

data/lib/monet/diff_strategy.rb

@@ -0,0 +1,70 @@
+module Monet
+  class DiffStrategy
+    include ChunkyPNG::Color
+
+    attr_reader :score
+
+    def initialize(base_image, diff_image)
+      @base_image = base_image
+      @diff_image = diff_image
+      @score = []
+
+      raise Errors::DifferentDimensions unless dimensions_match?
+    end
+
+    def calculate_for_pixel(pixel, x, y)
+      @score << [x,y] unless pixel == @diff_image[x,y]
+    end
+
+    def save(filename)
+      @output.save(filename)
+    end
+
+    private
+    def dimensions_match?
+      @base_image.width == @diff_image.width &&
+      @base_image.height == @diff_image.height
+    end
+
+    private
+    def for_color(color, *params)
+      send color, *params
+    end
+  end
+
+  class Grayscale < DiffStrategy
+    def initialize(base_image, diff_image)
+      super
+      @output = ChunkyPNG::Image.new(base_image.width, base_image.height, WHITE)
+    end
+
+    def calculate_for_pixel(pixel, x, y)
+      return if pixel == @diff_image[x,y]
+
+      rgb_colors = %w(r g b).map do |color|
+        for_color(color, @diff_image[x,y]) - for_color(color, pixel)
+      end
+
+      score = Math.sqrt(rgb_colors.reduce(0) {|memo, diff| memo += (diff ** 2) } ) / Math.sqrt(MAX ** 2 * 3)
+
+      @output[x,y] = grayscale(MAX - (score * MAX).round)
+      super
+    end
+  end
+
+  class ColorBlend < DiffStrategy
+    def initialize(base_image, diff_image)
+      super
+      @output = ChunkyPNG::Image.new(base_image.width, diff_image.width, BLACK)
+    end
+
+    def calculate_for_pixel(pixel, x, y)
+      rgb_colors = %w(r g b).map do |color|
+        for_color(color, pixel) + for_color(color, @diff_image[x,y]) - 2 * [for_color(color, pixel), for_color(color, @diff_image[x,y])].min
+      end
+
+      @output[x,y] = rgb(*rgb_colors)
+      super
+    end
+  end
+end

data/lib/monet/errors.rb

@@ -0,0 +1,8 @@
+module Monet::Errors
+  class DifferentDimensions < StandardError
+    def message
+      "Images are different dimensions. Cannot compare accurately."
+    end
+  end
+
+end

data/lib/monet/version.rb

@@ -0,0 +1,3 @@
+module Monet
+  VERSION = "0.1.0"
+end

data/lib/monet.rb

@@ -0,0 +1,9 @@
+require "monet/version"
+require "monet/errors"
+require "monet/capture_map"
+require "monet/capture"
+require "monet/compare"
+
+module Monet
+
+end

data/monet.gemspec

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'monet/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "monet"
+  gem.version       = Monet::VERSION
+  gem.authors       = ["Luke van der Hoeven"]
+  gem.email         = ["hungerandthirst@gmail.com"]
+  gem.description   = %q{Monet is a web UI change comparer.}
+  gem.summary       = %q{
+    Monet captures your web pages, sets up a baseline
+    and then ensures that future changes to either backend
+    or front end code leaves your UI intact. No more wondering
+    if CSS changes blow your UI up. Simply capture your page,
+    make changes, run tests and compare the diff!
+  }
+  gem.homepage      = "http://plukevdh.github.com/monet"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency('rake')
+  gem.add_dependency('poltergeist')
+  gem.add_dependency('capybara')
+  # gem.add_dependency('chunky_png')
+  gem.add_dependency('oily_png')
+  gem.add_dependency('spidr')
+
+  if RUBY_ENGINE == 'rbx'
+    gem.add_dependency('rubysl')
+    gem.add_dependency('racc')
+    gem.add_dependency('json')
+  end
+
+  gem.add_development_dependency('rspec-given')
+  gem.add_development_dependency('rspec')
+  gem.add_development_dependency('timecop')
+end

data/spec/capture_map_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+require 'monet/capture_map'
+
+describe Monet::CaptureMap::PathCollection do
+  context "base helper" do
+    Given(:helper) { Monet::CaptureMap::PathCollection.new("http://google.com") }
+    Then { helper.paths.should == [] }
+  end
+
+  context "add items" do
+    Given(:helper) { Monet::CaptureMap::PathCollection.new("http://google.com") }
+    When { helper.add('path') }
+    Then { helper.paths.should == ['path'] }
+  end
+end
+
+describe Monet::CaptureMap::PathSpider do
+  Given(:spider) { Monet::CaptureMap::PathSpider.new("http://spider.io/") }
+
+  context "ignores" do
+    When(:ignores) { spider.ignores }
+    Then { ignores.all? {|x| x.is_a? Regexp}.should be_true }
+  end
+end
+
+describe Monet::CaptureMap do
+  context "no arguments" do
+    When(:result) { Monet::CaptureMap.new }
+    Then { result.should have_failed(ArgumentError) }
+  end
+
+  context "requires full url" do
+    When(:result) { Monet::CaptureMap.new("google.com") }
+    Then { result.should have_failed(Monet::CaptureMap::InvalidURL, /google.com is not a valid url/) }
+  end
+
+  context "requires valid url" do
+    When(:result) { Monet::CaptureMap.new("google") }
+    Then { result.should have_failed(Monet::CaptureMap::InvalidURL, /google is not a valid url/) }
+  end
+
+  context "with name" do
+    Given(:map) { Monet::CaptureMap.new("http://google.com") }
+    Then { map.root_url.should == "http://google.com" }
+    And { map.paths.should == [] }
+  end
+
+  context "with paths" do
+    Given(:map) {
+      Monet::CaptureMap.new("http://google.com") do |map|
+        map.add 'home/'
+        map.add 'test/new'
+      end
+    }
+
+    context "add paths" do
+      Then { map.root_url.should == "http://google.com" }
+      And { map.paths.should == ['home', 'test/new'] }
+    end
+  end
+
+  context "spider mapper", vcr: { cassette_name: "spider", record: :new_episodes } do
+    Given(:map) { Monet::CaptureMap.new("http://www.spider.io", :spider) }
+    When(:paths) { map.paths }
+    Then { paths.should == [
+      "http://www.spider.io",
+      "http://www.spider.io/anti-malware/",
+      "http://www.spider.io/viewability/",
+      "http://www.spider.io/press/",
+      "http://www.spider.io/team/",
+      "http://www.spider.io/blog/",
+      "http://www.spider.io/",
+      "http://www.spider.io/blog/2013/03/chameleon-botnet/",
+      "http://www.spider.io/blog/2013/12/cyber-criminals-defraud-display-advertisers-with-tdss/",
+      "http://www.spider.io/zeus",
+      "http://www.spider.io/blog/2013/11/how-to-defraud-display-advertisers-with-zeus/",
+      "http://www.spider.io/blog/2013/05/a-botnet-primer-for-display-advertisers/",
+      "http://www.spider.io/blog/2013/09/display-advertisers-funding-cybercriminals-since-2011/",
+      "http://www.spider.io/blog/2013/09/securing-the-legitimacy-of-display-ad-inventory/",
+      "http://www.spider.io/blog/2013/04/display-advertising-fraud-is-a-sell-side-problem/",
+      "http://www.spider.io/blog/2012/12/internet-explorer-data-leakage/",
+      "http://www.spider.io/blog/2013/08/sambreel-is-still-injecting-ads-video-advertisers-beware/",
+      "http://www.spider.io/blog/page/2/",
+      "http://www.spider.io/blog/2011/10/the-problem-with-client-side-analytics/",
+      "http://www.spider.io/blog/2012/12/responsible-disclosure/",
+      "http://www.spider.io/blog/2013/05/spider-io-granted-mrc-accreditation-for-viewable-impression-measurement/",
+      "http://www.spider.io/blog/2013/04/at-least-two-percent-of-monitored-display-ad-exchange-inventory-is-hidden/",
+      "http://www.spider.io/blog/2013/03/who-is-behind-the-chameleon-botnet/",
+      "http://www.spider.io/blog/page/3/",
+      "http://www.spider.io/blog/2013/02/which-display-ad-exchange-sells-the-highest-quality-inventory/",
+      "http://www.spider.io/blog/2012/12/there-are-two-ways-to-measure-ad-viewability-there-is-only-one-right-way/",
+      "http://www.spider.io/blog/page/4/",
+      "http://www.spider.io/blog/2012/12/review-of-iab-safeframe-1-0/",
+      "http://www.spider.io/blog/2012/10/qa-about-ad-viewability/",
+      "http://www.spider.io/blog/2012/10/the-first-technology-to-measure-the-viewability-of-iframed-ads-across-all-major-browsers-press-release/",
+      "http://www.spider.io/vSta98h",
+      "http://www.spider.io/blog/2012/07/join-us-for-a-tipple-at-spider-towers/",
+      "http://www.spider.io/blog/2012/07/startups-acquiring-startups-for-equity/",
+      "http://www.spider.io/blog/page/5/",
+      "http://www.spider.io/visibility-demo-screencast/",
+      "http://www.spider.io/blog/2012/07/whats-in-an-ip-address/",
+      "http://www.spider.io/blog/2011/12/physical-hack-day/",
+      "http://www.spider.io/blog/2011/11/our-first-hack-day/",
+      "http://www.spider.io/careers/",
+      "http://www.spider.io/blog/2011/10/extreme-architecting/",
+      "http://www.spider.io/blog/2011/09/how-to-catch-a-bot/",
+      "http://www.spider.io/blog/page/6/",
+      "http://www.spider.io/blog/2011/10/testing-javascript-with-mturk/",
+      "http://www.spider.io/blog/2011/10/demonstration-screencast-verifying-that-display-ads-are-visible-from-within-iframes/",
+      "http://www.spider.io/blog/2011/10/calling-out-to-researchersacademics/",
+      "http://www.spider.io/blog/page/7/"
+    ]}
+    And { paths.any? {|p| p.end_with? "css" }.should be_false }
+  end
+end
+

data/spec/capture_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'monet/capture'
+
+describe Monet::Capture do
+  Given(:path) { File.expand_path './spec/tmp/output' }
+  Given(:capture_agent) { Monet::Capture.new(capture_dir: path) }
+
+  before do
+    Timecop.freeze
+  end
+
+  after do
+    Timecop.return
+
+    Dir.glob("#{path}/*.png").each do |file|
+      File.delete(file)
+    end
+  end
+
+  context "can pass config" do
+    context "as a hash" do
+      Given(:capture_agent) { Monet::Capture.new(capture_dir: path) }
+      When(:config) { capture_agent.instance_variable_get :@config }
+      Then { config.should be_a(Monet::Config) }
+      Then { config.capture_dir.should == path }
+    end
+
+    context "as a Monet::Config" do
+      Given(:config) { Monet::Config.new(capture_dir: path) }
+      Given(:capture_agent) { Monet::Capture.new(config) }
+      When(:final) { capture_agent.instance_variable_get :@config }
+      Then { final.should be_a(Monet::Config) }
+      Then { final.capture_dir.should == path }
+    end
+  end
+
+  context "converts name properly" do
+    When { capture_agent.capture('https://google.com') }
+    Then { File.exist?("#{path}/google_com-#{Time.now.to_i}.png").should be_true }
+  end
+
+  context "prepends default protocol if missing" do
+    When { capture_agent.capture('www.facebook.com') }
+    Then { File.exist?("#{path}/www_facebook_com-#{Time.now.to_i}.png").should be_true }
+  end
+
+end