monet 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4ba54b53a3cb965bdcc834da924e37f3df244e76
-  data.tar.gz: ca5a32475a8411d8dcc61e750ca6e534582a38a2
+  metadata.gz: 6fd195da9656b0fe86982f9ee484dcbf50a0aeb2
+  data.tar.gz: 88a19e81f68e678b6be8885f120848cb2ea63450
 SHA512:
-  metadata.gz: e2debbc40dc2411f580a40ee1dd8e8bf6691ca342779ac773a8ca48d059edd35d442a89cbb3cffb28c402f88f0413ff99b7ad16c6313cac9b1607c078545ffd9
-  data.tar.gz: 0308e17eeac8c8e00d60a1e752b74711186f1faa16ec0bc729082b14a8d0f3e1d8dc45132fec54b46441f7eb972a66bfcdc5fc1de0ce56ad323d246fcadfa8e7
+  metadata.gz: f02f289bc355712dffdb37d0e4ca117d4bcb123559dce5c34ab260fbfbeb0736555f0d105055e6e2e757751477dcccf7e535cdc759f7f1ee25be2cbb8694ec67
+  data.tar.gz: fbb56feae30ce176c1a182a48c557ee986a4eff0d54ce65136d4dc445834c0a391586e6762b19dcd94d66f926b63dc2e360353a8414e20a3375e64b3cafba0da

data/Gemfile

@@ -4,6 +4,7 @@ source 'https://rubygems.org'
 gemspec
 
 group :test do
+  gem 'flexmock'
   gem 'pry'
   gem 'webmock'
   gem 'vcr'

data/README.md

@@ -1,6 +1,4 @@
-# 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 [![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.
 
@@ -20,7 +18,7 @@ Or install it yourself as:
 
 ## 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:
+The basic gem requires a config file that is called in an app initializer or via the built-in rake task. 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|
@@ -38,10 +36,29 @@ Monet.config do |config|
 end
 ```
 
+## Process
+
+Captures are saved into the following structure:
+
+```
+/captures
+	/baselines
+	/captures
+```
+
+- /captures is where the current capture run images are stored, pre-comparison with baseline.
+- /baselines is where all current baseline images are stored. persistent in-between capture runs.
+
+During the capture process, any new captures that do not have a match found in baselines to compare with are considered new baselines.
+Any images that match baseline are discarded.
+Any images that flag differences, are flagged for review.
+
+Review involves checking flagged images and marking as
+1. discard
+2. flag as issue
+3. accept as new baseline
+
 ## Todo
-- Site spidering
-- Baseline caching
-- Browser/driver config
 - Parallelize PNG diffing
 - Dashboard
 - Rails integration

data/Rakefile

@@ -1,10 +1,22 @@
 require "bundler/gem_tasks"
 require 'rspec/core/rake_task'
-desc "Runs the site and grabs baselines"
+require 'monet'
+
+task :clean do
+  config = Monet::Config.load
+  Monet.clean config
+end
 
-task :baseline do
+desc "Runs the site and grabs baselines"
+task :baseline => [:clean, :run] do
+end
 
+desc "Run the baseline comparison"
+task :run do
+  config = Monet::Config.load
+  Monet.capture config
+  Monet.compare config
 end
 
 RSpec::Core::RakeTask.new(:test)
-task :default => :test
+task :default => :run

data/config.yaml

@@ -0,0 +1,11 @@
+:driver: :poltergeist
+:dimensions:
+  - 1024
+
+:base_url: "http://lance.com"
+
+:compare_type: Highlight
+:map:
+  - "/"
+  - "/aboutus"
+  - "/littleleague"

data/lib/monet.rb

@@ -1,9 +1,30 @@
 require "monet/version"
-require "monet/errors"
-require "monet/capture_map"
+require 'monet/config'
 require "monet/capture"
 require "monet/compare"
+require "monet/baseline_control"
 
 module Monet
+  class << self
+    def clean(opts)
+      config = load_config(opts)
+      Dir.glob(File.join(config.baseline_dir, "**", "*.png")).each do |img|
+        File.delete img
+      end
+    end
 
+    def capture(opts)
+      agent = Monet::Capture.new(load_config(opts))
+      agent.capture_all
+    end
+
+    def compare(opts)
+      control = Monet::BaselineControl.new(opts)
+      control.run
+    end
+
+    def load_config(options)
+      Monet::Config.build_config(options)
+    end
+  end
 end

data/lib/monet/baseless_image.rb

@@ -0,0 +1,11 @@
+require 'fileutils'
+
+module Monet
+  class BaselessImage
+    attr_reader :path
+
+    def initialize(path)
+      @path = path
+    end
+  end
+end

data/lib/monet/baseline_control.rb

@@ -0,0 +1,68 @@
+require 'monet/path_router'
+require 'monet/changeset'
+require 'monet/baseless_image'
+require 'monet/compare'
+
+require 'fileutils'
+
+module Monet
+  class BaselineControl
+
+    attr_reader :flags
+
+    def initialize(config)
+      @capture_dir = config.capture_dir
+      @baseline_dir = config.baseline_dir
+
+      strategy = Monet.const_get(config.compare_type)
+
+      @comparer = Monet::Compare.new(strategy)
+      @router = Monet::PathRouter.new(config)
+      @flags = []
+    end
+
+    def run
+      captures.each do |capture|
+        baseline_path = @router.capture_to_baseline(capture)
+        compare @comparer.compare(baseline_path, capture)
+      end
+
+      @flags
+    end
+
+    def compare(diff)
+      return baseline(diff) if diff.is_a? Monet::BaselessImage
+      return discard(diff.path) unless diff.modified?
+
+      puts "diff found #{diff.path}"
+
+      @flags << diff.path
+    end
+
+    def captures
+      Dir.glob File.join(site_dir(@capture_dir), "*.png")
+    end
+
+    def discard(path)
+      puts "discarding #{path}"
+      FileUtils.remove(path)
+    end
+
+    def baseline(diff)
+      path = diff.path
+      to = site_dir(@baseline_dir)
+
+      FileUtils.mkpath to unless Dir.exists? to
+      FileUtils.move(path, to)
+
+      puts "baselining #{path}"
+
+      @router.capture_to_baseline(path)
+    end
+
+    private
+    def site_dir(base)
+      File.join base, @router.root_dir
+    end
+  end
+end

data/lib/monet/capture.rb

@@ -8,30 +8,28 @@ module Monet
   class Capture
     include Capybara::DSL
 
-    def initialize(config={})
-      @config = (config.is_a? Monet::Config) ? config : Monet::Config.new(config)
+    MAX_HEIGHT = 10000
 
-      # TODO: make configurable
-      Capybara.default_driver = @config.driver
-    end
+    def initialize(config)
+      @config = Monet::Config.build_config(config)
+      @router = Monet::PathRouter.new(@config)
 
-    def capture(path)
-      visit normalize_path(path)
-      page.driver.render(image_name_from_path(path), full: true)
+      Capybara.default_driver = @config.driver
     end
 
-    private
-    def capture_path
-      @config.capture_dir
+    def capture_all
+      @config.map.paths.each do |path|
+        capture(path)
+      end
     end
 
-    def normalize_path(path)
-      "http://#{path}" unless path.start_with?("https?")
-    end
+    def capture(path)
+      visit @router.build_url(path)
 
-    def image_name_from_path(path)
-      name = path.gsub(/https?:\/\//, '').gsub('.', '_')
-      "#{capture_path}/#{name}-#{Time.now.to_i}.png"
+      @config.dimensions.each do |width|
+        page.driver.resize(width, MAX_HEIGHT)
+        page.driver.render(@router.route_url_path(path, width), full: true)
+      end
     end
   end
 end

data/lib/monet/capture_map.rb

@@ -1,14 +1,16 @@
 require 'spidr'
+require 'monet/url_helpers'
 
 module Monet
   class CaptureMap
     extend Forwardable
 
     class PathCollection
+      include URLHelpers
       attr_reader :paths, :root_url
 
-      def initialize(root_url)
-        @root_url = root_url
+      def initialize(root_uri)
+        @root_url = parse_uri(root_uri)
         @paths = []
       end
 
@@ -16,6 +18,10 @@ module Monet
         @paths << normalized_path(path)
       end
 
+      def paths=(paths)
+        @paths.concat paths.map {|p| normalized_path(p) }
+      end
+
       def normalized_path(path)
         path.chomp "/"
       end
@@ -39,18 +45,16 @@ module Monet
       end
     end
 
-    InvalidURL = Class.new(StandardError)
-
     attr_reader :type
 
-    def initialize(root_url, type=:explicit, &block)
+    def initialize(root_uri, type=:explicit, &block)
       @type = type
-      @path_helper = type_mapper.new parse_uri(root_url)
+      @path_helper = type_mapper.new root_uri
 
       yield(@path_helper) if block_given?
     end
 
-    def_delegators :@path_helper, :paths, :add, :root_url
+    def_delegators :@path_helper, :paths, :paths=, :add, :root_url
 
     def type_mapper
       case @type
@@ -60,13 +64,5 @@ module Monet
         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/changeset.rb

@@ -0,0 +1,23 @@
+module Monet
+  class Changeset
+    attr_reader :path
+
+    def initialize(base_image, pixel_array, path)
+      @base_image = base_image
+      @changed_pixels = pixel_array
+      @path = path
+    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
+end

data/lib/monet/compare.rb

@@ -1,52 +1,39 @@
 require 'oily_png'
 require 'monet/diff_strategy'
+require 'monet/changeset'
+require 'monet/baseless_image'
 
 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)
+      puts "comparing #{base_image} with #{new_image}"
+      begin
+        new_png = ChunkyPNG::Image.from_file(new_image)
+        base_png = ChunkyPNG::Image.from_file(base_image)
 
-      diff_stats = []
+        diff_stats = []
 
-      # TODO: make configurable
-      diff_strategy = @strategy_class.new(base_png, new_png)
+        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)
+        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
-      end
 
-      changeset = Changeset.new(base_png, diff_strategy.score)
-      diff_strategy.save(diff_filename(base_image)) if changeset.modified?
+        changeset = Changeset.new(base_png, diff_strategy.score, new_image)
+        diff_strategy.save(diff_filename(base_image)) if changeset.modified?
 
-      changeset
+        changeset
+      rescue Errno::ENOENT => e
+        return BaselessImage.new(new_image)
+      end
     end
 
     private

data/lib/monet/config.rb

@@ -1,15 +1,20 @@
 require 'monet/capture_map'
+require 'yaml'
 
 module Monet
   class Config
+    include URLHelpers
+
     MissingBaseURL = Class.new(Exception)
 
     DEFAULT_OPTIONS = {
       driver: :poltergeist,
-      dimensions: [1440],
-      map: nil,
+      dimensions: [1024],
       base_url: nil,
-      capture_dir: "./captures"
+      map: nil,
+      compare_type: "ColorBlend",
+      capture_dir: "./captures",
+      baseline_dir: "./baselines"
     }
 
     attr_accessor *DEFAULT_OPTIONS.keys
@@ -26,20 +31,47 @@ module Monet
       cfg
     end
 
+    def self.load(path="./config.yaml")
+      config = YAML::load(File.open(path))
+      new(config)
+    end
+
+    def self.build_config(opts)
+      (opts.is_a? Monet::Config) ? opts : new(opts)
+    end
+
+    def base_url=(url)
+      @base_url ||= parse_uri(url) unless url.nil?
+    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)
+      @capture_dir = expand_path(path)
+    end
+
+    def baseline_dir=(path)
+      @baseline_dir = expand_path(path)
+    end
+
+    def map=(paths)
+      map.paths = paths unless paths.nil?
     end
 
     def map(type=:explicit, &block)
       @map ||= CaptureMap.new(base_url, type)
 
       block.call(@map) if block_given? && type == :explicit
+
       @map
     end
+
+    private
+    def expand_path(path)
+      File.expand_path(path)
+    end
   end
 end

data/lib/monet/diff_strategy.rb

@@ -1,3 +1,5 @@
+require 'monet/errors'
+
 module Monet
   class DiffStrategy
     include ChunkyPNG::Color
@@ -55,7 +57,7 @@ module Monet
   class ColorBlend < DiffStrategy
     def initialize(base_image, diff_image)
       super
-      @output = ChunkyPNG::Image.new(base_image.width, diff_image.width, BLACK)
+      @output = ChunkyPNG::Image.new(base_image.width, base_image.height, BLACK)
     end
 
     def calculate_for_pixel(pixel, x, y)
@@ -67,4 +69,27 @@ module Monet
       super
     end
   end
+
+  class Highlight < DiffStrategy
+    ALPHA_COMPONENT = 30
+
+    def initialize(base_image, diff_image)
+      super
+      @output = ChunkyPNG::Image.new(base_image.width, base_image.height, WHITE)
+    end
+
+    def colors(pixel)
+      rgb_colors = %w(r g b).map {|color| for_color(color, pixel)}
+    end
+
+    def calculate_for_pixel(pixel, x, y)
+      if pixel == @diff_image[x,y]
+        @output[x,y] = rgba(*colors(pixel), ALPHA_COMPONENT)
+      else
+        @output[x,y] = html_color("blue")
+      end
+
+      super
+    end
+  end
 end

data/lib/monet/path_router.rb

@@ -0,0 +1,64 @@
+require 'monet/url_helpers'
+
+module Monet
+  class PathRouter
+    include URLHelpers
+
+    def initialize(config)
+      @base_url = parse_uri(config.base_url)
+      @capture_path = config.capture_dir
+      @baseline_path = config.baseline_dir
+    end
+
+    def build_url(path)
+      "#{@base_url}#{path}"
+    end
+
+    # takes a url, gives the image path
+    def route_url(url, width="*")
+      uri = parse_uri(url)
+      route_url_path(uri.path, width)
+    end
+
+    # takes a url path, gives the image path
+    def route_url_path(path, width="*")
+      image_name(@capture_path, path, width)
+    end
+
+    def url_to_baseline(url, width)
+      uri = parse_uri(url)
+      url_path_to_baseline(uri.path, width)
+    end
+
+    def url_path_to_baseline(path, width)
+      image_name(@baseline_path, path, width)
+    end
+
+    def capture_to_baseline(path)
+      path.gsub(@capture_path, @baseline_path)
+    end
+
+    # takes a path, returns the URL used to generate the image
+    def route_path(path)
+      url = path.split("/").last
+      path = url.split('>')[1..-1].join("/").gsub(/-\d+\.png/, "")
+
+      "#{@base_url}/#{path}"
+    end
+
+    def host
+      @base_url.host
+    end
+    alias :root_dir :host
+
+    private
+    def image_name(base_dir, path, width)
+      name = normalize_path(path).gsub(/\//, '>')
+      "#{base_dir}/#{host}/#{name}-#{width}.png"
+    end
+
+    def normalize_path(path)
+      "#{host}#{path}"
+    end
+  end
+end

data/lib/monet/url_helpers.rb

@@ -0,0 +1,13 @@
+module Monet
+  module URLHelpers
+    ::Monet::InvalidURL = Class.new(StandardError)
+
+    private
+    def parse_uri(path)
+      uri = path.is_a?(URI) ? path : URI.parse(path)
+      raise InvalidURL, "#{path} is not a valid url" if uri.class == URI::Generic
+
+      uri
+    end
+  end
+end

data/lib/monet/version.rb

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

data/spec/baseline_control_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'monet/baseline_control'
+
+describe Monet::BaselineControl do
+  Given(:control) do
+    config = flexmock("Config", compare_type: "ColorBlend", capture_dir: "./spec/fixtures", baseline_dir: "./baseline", base_url: "http://google.com")
+    flexmock Monet::BaselineControl.new(config)
+  end
+
+  context "makes a capture baseline if no baseline exists" do
+    Given(:diff) { Monet::BaselessImage.new("./fixtures/fake.png") }
+    Given { control.should_receive(:baseline).with(diff).and_return("./baseline/fake.png") }
+
+    When(:result) { control.compare(diff) }
+
+    Then { control.should have_received(:baseline).with(diff) }
+    And { result.should eq("./baseline/fake.png") }
+  end
+
+  context "discards captures that match baseline" do
+    Given(:diff) { flexmock(:on, Monet::Changeset, modified?: false, path: "./fixtures/fake.png") }
+    Given { control.should_receive(:discard).with("./fixtures/fake.png") }
+
+    When(:result) { control.compare(diff) }
+
+    Then { control.should have_received(:discard).with("./fixtures/fake.png") }
+  end
+
+  context "flags changed capture as different" do
+    Given(:diff) { flexmock(:on, Monet::Changeset, modified?: true, path: "./fixtures/fake.png") }
+
+    When(:diffs) { control.compare(diff) }
+
+    Then { diffs.length.should == 1 }
+    And { diffs.should == ["./fixtures/fake.png"] }
+  end
+
+  context "replaces baseline if requested" do
+    Given(:diff) { flexmock(:on, Monet::Changeset, modified?: true, path: "./fixtures/fake.png") }
+    Given { control.should_receive(:baseline).with(diff).and_return("./baseline/fake.png") }
+
+    When(:result) { control.baseline(diff) }
+
+    Then { control.should have_received(:baseline).with(diff) }
+    And { result.should eq("./baseline/fake.png") }
+  end
+end

data/spec/capture_map_spec.rb

@@ -31,17 +31,17 @@ describe Monet::CaptureMap do
 
   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/) }
+    Then { result.should have_failed(Monet::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/) }
+    Then { result.should have_failed(Monet::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" }
+    Then { map.root_url.to_s.should == "http://google.com" }
     And { map.paths.should == [] }
   end
 
@@ -54,7 +54,7 @@ describe Monet::CaptureMap do
     }
 
     context "add paths" do
-      Then { map.root_url.should == "http://google.com" }
+      Then { map.root_url.to_s.should == "http://google.com" }
       And { map.paths.should == ['home', 'test/new'] }
     end
   end

data/spec/capture_spec.rb

@@ -3,30 +3,25 @@ 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
+  Given(:url) { "http://google.com" }
+  Given(:capture_agent) { Monet::Capture.new(capture_dir: path, base_url: url) }
 
   after do
-    Timecop.return
-
-    Dir.glob("#{path}/*.png").each do |file|
+    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) }
+      Given(:capture_agent) { Monet::Capture.new(capture_dir: path, base_url: url) }
       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(:config) { Monet::Config.new(capture_dir: path, base_url: url) }
       Given(:capture_agent) { Monet::Capture.new(config) }
       When(:final) { capture_agent.instance_variable_get :@config }
       Then { final.should be_a(Monet::Config) }
@@ -35,13 +30,22 @@ describe Monet::Capture do
   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 }
+    Given(:capture_agent) { Monet::Capture.new(capture_dir: path, base_url: url, dimensions: [900]) }
+    When { capture_agent.capture("/") }
+    Then { File.exist?("#{path}/google.com/google.com>-900.png").should be_true }
+  end
+
+  context "captures all dimensions requested" do
+    Given(:capture_agent) { Monet::Capture.new(capture_dir: path, base_url: url, dimensions: [900, 1400]) }
+    When { capture_agent.capture("/") }
+    Then { File.exist?("#{path}/google.com/google.com>-900.png").should be_true }
+    Then { File.exist?("#{path}/google.com/google.com>-1400.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 }
+    Given(:capture_agent) { Monet::Capture.new(capture_dir: path, base_url: "http://www.facebook.com") }
+    When { capture_agent.capture('/') }
+    Then { File.exist?("#{path}/www.facebook.com/www.facebook.com>-1024.png").should be_true }
   end
 
 end

data/spec/compare_spec.rb

@@ -12,6 +12,12 @@ describe Monet::Compare do
   context "default compare" do
     Given(:compare) { Monet::Compare.new }
 
+    context "missing baseline" do
+      When(:result) { compare.compare("./missing_image.png", image_same) }
+      Then { result.should be_a(Monet::BaselessImage) }
+      And { result.path.should == image_same }
+    end
+
     context "identical image" do
       When(:result) { compare.compare(image_base, image_same) }
       Then { result.should_not be_modified }
@@ -45,7 +51,7 @@ describe Monet::Compare do
 
     Then { result.should be_modified }
     And { File.exist?(diff_name).should be_true }
-    And { result.pixels_changed.should eq(23800) }
-    And { result.percentage_changed.should eq(5.44) }
+    And { result.pixels_changed.should eq(2387) }
+    And { result.percentage_changed.should eq(0.55) }
   end
 end

data/spec/config_spec.rb

@@ -12,7 +12,7 @@ describe Monet::Config do
     When(:config) { Monet::Config.new(capture_dir: "./faker", base_url: "http://hoodie.io") }
     Then { config.driver.should == :poltergeist }
     And { config.capture_dir.should == File.expand_path("./faker") }
-    And { config.base_url.should == "http://hoodie.io" }
+    And { config.base_url.to_s.should == "http://hoodie.io" }
   end
 
   context "can set options" do

data/spec/path_router_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'monet/path_router'
+require 'monet/config'
+
+describe Monet::PathRouter do
+  Given(:capture) { File.expand_path "./capture" }
+  Given(:baseline) { File.expand_path "./baseline" }
+  Given(:config) { Monet::Config.new(base_url: "http://google.com", capture_dir: "./capture", baseline_dir: "./baseline") }
+  Given(:router) { Monet::PathRouter.new(config) }
+
+  context "knows base dir" do
+    When(:path) { router.root_dir }
+    Then { path.should == "google.com" }
+  end
+
+  context "build url from path" do
+    When(:url) { router.build_url("/space/manager") }
+    Then { url.should == "http://google.com/space/manager" }
+  end
+
+  context "full url to path" do
+    When(:path) { router.route_url("http://google.com/space/manager", 900) }
+    Then { path.should == "#{capture}/google.com/google.com>space>manager-900.png" }
+  end
+
+  context "url path to path" do
+    When(:path) { router.route_url_path("/space/manager", 900) }
+    Then { path.should == "#{capture}/google.com/google.com>space>manager-900.png"}
+  end
+
+  context "path to url" do
+    When(:url) { router.route_path("#{capture}/google.com/google.com>space>manager-900.png") }
+    Then { url.should == "http://google.com/space/manager" }
+  end
+
+  context "path to baseline from url" do
+    When(:path) { router.url_to_baseline("http://google.com/space/manager", 900) }
+    Then { path.should == "#{baseline}/google.com/google.com>space>manager-900.png" }
+  end
+
+  context "path to baseline from path" do
+    When(:path) { router.url_path_to_baseline("/space/manager", 900) }
+    Then { path.should == "#{baseline}/google.com/google.com>space>manager-900.png" }
+  end
+
+  context "capture path to baseline path" do
+    When(:path) { router.capture_to_baseline("#{capture}/google.com/google.com>space>manager-900.png") }
+    Then { path.should == "#{baseline}/google.com/google.com>space>manager-900.png" }
+  end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,7 @@
 require 'vcr'
 require 'rspec/given'
 require 'timecop'
+require 'pry'
 
 VCR.configure do |c|
   c.cassette_library_dir = 'spec/cassettes'
@@ -9,5 +10,6 @@ VCR.configure do |c|
 end
 
 RSpec.configure do |c|
+  c.mock_with :flexmock
   c.treat_symbols_as_metadata_keys_with_true_values = true
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: monet
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Luke van der Hoeven
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-12 00:00:00.000000000 Z
+date: 2013-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -137,15 +137,22 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- config.yaml
 - lib/monet.rb
+- lib/monet/baseless_image.rb
+- lib/monet/baseline_control.rb
 - lib/monet/capture.rb
 - lib/monet/capture_map.rb
+- lib/monet/changeset.rb
 - lib/monet/compare.rb
 - lib/monet/config.rb
 - lib/monet/diff_strategy.rb
 - lib/monet/errors.rb
+- lib/monet/path_router.rb
+- lib/monet/url_helpers.rb
 - lib/monet/version.rb
 - monet.gemspec
+- spec/baseline_control_spec.rb
 - spec/capture_map_spec.rb
 - spec/capture_spec.rb
 - spec/cassettes/spider.yml
@@ -155,6 +162,7 @@ files:
 - spec/fixtures/diff.png
 - spec/fixtures/diff_size.png
 - spec/fixtures/same.png
+- spec/path_router_spec.rb
 - spec/spec_helper.rb
 homepage: http://plukevdh.github.com/monet
 licenses: []
@@ -183,6 +191,7 @@ summary: Monet captures your web pages, sets up a baseline and then ensures that
   if CSS changes blow your UI up. Simply capture your page, make changes, run tests
   and compare the diff!
 test_files:
+- spec/baseline_control_spec.rb
 - spec/capture_map_spec.rb
 - spec/capture_spec.rb
 - spec/cassettes/spider.yml
@@ -192,4 +201,5 @@ test_files:
 - spec/fixtures/diff.png
 - spec/fixtures/diff_size.png
 - spec/fixtures/same.png
+- spec/path_router_spec.rb
 - spec/spec_helper.rb