middleman-caching-proxy 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f6003c2bbd6243a5e3d9c2a0609791e99fa0ca35
-  data.tar.gz: 9016a44ea593344b1b30870118754c02f2740dc6
+  metadata.gz: 55aa289cbda88555e44bd3e30d37cb59b71e241f
+  data.tar.gz: 7ab8901daea4d287e109070e2d9cb1f575483cfa
 SHA512:
-  metadata.gz: a0248d86faa3e48dfdd6ef8224374205f4f09e504774d251c155a8a9be653a1c553ecb58f01618de1cf58fc58db690a7791c250f5c18b086b93d8ec99f7aa5be
-  data.tar.gz: 211f5a438894dff097383a56134e4dfdaf546fe256861b15bbeaf910ee13527cfaff5efad082fc7cc185d3bd41dd4ade434b1c6223db03d633574d2d808471d5
+  metadata.gz: 19da52ec7f45cda78fb0733ce0e50e892c3c84d0cad9a83c9987901ecb3be0a56555ad0ce299c982204338261ad4270da5861f8426bfb45ca471d03252ea39f4
+  data.tar.gz: f38a7becaba16807e730b599370279c13a018e613893f7f713b6b87e15cc56f5500b2b51e4314e6d31fab8d2b67ee8c9c6b4d5106234b063af83ff1f179679c7

data/lib/middleman/caching_proxy/cache.rb

@@ -3,42 +3,46 @@ require "fileutils"
 
 require "middleman/caching_proxy/cache_manifest"
 
-class Cache
-  def initialize(path:, key:)
-    @manifest = nil
-  end
-  include Autostruct::Wrap
-
-  def has?(item)
-    cached_path = full_path(item: item)
-    return false if !::File.exist?(cached_path)
-    manifest.has?(item)
-  end
-
-  def add(item:, source:)
-    manifest.add item
-    cached_path = full_path(item: item)
-    copy_in source, cached_path
-  end
-
-  def full_path(item:)
-    ::File.join(path, "items", item.path)
-  end
-
-  def save
-    manifest.save
-  end
-
-  private
-
-  def manifest
-    @manifest ||= CacheManifest.new(path: path, key: key)
-  end
-
-  def copy_in(source, cached_path)
-    cache_subdirectory = ::File.dirname(cached_path)
-    FileUtils.mkdir_p cache_subdirectory
-
-    FileUtils.cp source, cached_path
+module Middleman::CachingProxy
+  class Cache
+    def initialize(path:, key:)
+      @manifest = nil
+    end
+    include Autostruct::Wrap
+
+    def has?(item)
+      cached_path = full_path(item: item)
+      return false if !File.exist?(cached_path)
+      manifest.has?(item)
+    end
+
+    def add(item:, source:)
+      manifest.add item
+      cached_path = full_path(item: item)
+      copy_in source, cached_path
+    end
+
+    def full_path(item:)
+      File.join(path, "items", item.path)
+    end
+
+    def save
+      manifest.save
+    end
+
+    private
+
+    def manifest
+      @manifest ||= CacheManifest.new(
+        path: path, key: key
+      )
+    end
+
+    def copy_in(source, cached_path)
+      cache_subdirectory = File.dirname(cached_path)
+      FileUtils.mkdir_p cache_subdirectory
+
+      FileUtils.cp source, cached_path
+    end
   end
 end

data/lib/middleman/caching_proxy/cache_item.rb

@@ -1,6 +1,8 @@
 require "autostruct/wrap"
 
-class CacheItem
-  def initialize(path:, template:, proxy_options:, fingerprint:); end
-  include Autostruct::Wrap
+module Middleman::CachingProxy
+  class CacheItem
+    def initialize(path:, template:, proxy_options:, fingerprint:); end
+    include Autostruct::Wrap
+  end
 end

data/lib/middleman/caching_proxy/cache_manifest.rb

@@ -3,77 +3,78 @@ require "fileutils"
 
 require "middleman/caching_proxy/version"
 
-class CacheManifest
-  FILENAME = ".manifest.json"
-  KEY = "key"
-  ITEMS = "items"
-  VERSION = "version"
+module Middleman::CachingProxy
+  class CacheManifest
+    FILENAME = ".manifest.json"
+    KEY = "key"
+    ITEMS = "items"
+    VERSION = "version"
 
-  def initialize(path:, key:)
-    @manifest = nil
-    @items = nil
-  end
-  include Autostruct::Wrap
+    def initialize(path:, key:)
+      @manifest = nil
+      @items = nil
+    end
+    include Autostruct::Wrap
 
-  def has?(item)
-    items[item.path] == item.fingerprint
-  end
+    def has?(item)
+      items[item.path] == item.fingerprint
+    end
 
-  def add(item)
-    items[item.path] = item.fingerprint
-  end
+    def add(item)
+      items[item.path] = item.fingerprint
+    end
+
+    def save
+      ensure_cache_directory
 
-  def save
-    ensure_cache_directory
-    File.open(manifest_path, "w") do |f|
-      f.write build(items: items).to_json
+      File.write manifest_path, build(items: items).to_json
     end
-  end
 
-  private 
+    private 
 
-  def items
-    @items ||= manifest[ITEMS]
-  end
+    def items
+      @items ||= manifest[ITEMS]
+    end
 
-  def manifest_path
-    ::File.join(path, FILENAME)
-  end
+    def manifest_path
+      ::File.join(path, FILENAME)
+    end
 
-  def manifest
-    return @manifest if @manifest
-    @manifest = build
-    if File.exist?(manifest_path)
-      from_disk = JSON.load(File.read(manifest_path))
-      if is_ok?(from_disk)
-        @manifest = from_disk
+    def manifest
+      return @manifest if @manifest
+      @manifest = build
+      if File.exist?(manifest_path)
+        from_disk = JSON.load(File.read(manifest_path))
+        if is_ok?(from_disk)
+          @manifest = from_disk
+        end
       end
+      @manifest
     end
-    @manifest
-  end
 
-  def is_ok?(manifest)
-    return false if manifest.nil?
-    return false if manifest[VERSION] != version
-    # Clear cache if key changes
-    return false if manifest[KEY] != key
-    return false if !manifest[ITEMS].is_a?(Hash)
-    true
-  end
+    def is_ok?(manifest)
+      return false if manifest.nil?
+      return false if manifest[VERSION] != version
+      # Clear cache if key changes
+      return false if manifest[KEY] != key
+      return false if !manifest[ITEMS].is_a?(Hash)
+      true
+    end
 
-  def build(items: {})
-    {
-      KEY => key,
-      ITEMS => items,
-      VERSION => version
-    }
-  end
+    def build(items: {})
+      {
+        KEY => key,
+        ITEMS => items,
+        VERSION => version
+      }
+    end
 
-  def version
-    Middleman::CachingProxy::VERSION
-  end
+    def version
+      Middleman::CachingProxy::VERSION
+    end
 
-  def ensure_cache_directory
-    FileUtils.mkdir_p path
+    def ensure_cache_directory
+      FileUtils.mkdir_p path
+    end
   end
 end

data/lib/middleman/caching_proxy/cached_resource.rb

@@ -1,30 +1,32 @@
 require "autostruct/wrap"
 
-class CachedResource
-  def initialize(path:, cached_path:, build_path:); end
-  include Autostruct::Wrap
+module Middleman::CachingProxy
+  class CachedResource
+    def initialize(path:, cached_path:, build_path:); end
+    include Autostruct::Wrap
 
-  def destination_path
-    path[1..-1]
-  end
+    def destination_path
+      path[1..-1]
+    end
 
-  def ext
-    ""
-  end
+    def ext
+      ""
+    end
 
-  def ignored?
-    false # Seems to mean "actually include in build?"
-  end
+    def ignored?
+      false # Seems to mean "actually include in build?"
+    end
 
-  def binary?
-    true # Seems to mean "do a binary copy or make a rack request?"
-  end
+    def binary?
+      true # Seems to mean "do a binary copy or make a rack request?"
+    end
 
-  def source_file
-    cached_path
-  end
+    def source_file
+      cached_path
+    end
 
-  def content_type
-    "text/html"
+    def content_type
+      "text/html"
+    end
   end
 end

data/lib/middleman/caching_proxy/extension.rb

@@ -5,98 +5,100 @@ require "middleman/caching_proxy/cache"
 require "middleman/caching_proxy/cache_item"
 require "middleman/caching_proxy/cached_resource"
 
-class Middleman::CachingProxy::Extension < ::Middleman::Extension
-  option :cache_directory,
-    "tmp/proxy_cache",
-    "The directory where cache files will be stored"
-  option :cache_key,
-    nil,
-    "A global cache key"
-
-  if Semantic::Version.new(Middleman::VERSION).major >= 4
-    expose_to_config :proxy_with_cache
-  end
+module Middleman::CachingProxy
+  class Extension < ::Middleman::Extension
+    option :cache_directory,
+       "tmp/proxy_cache",
+       "The directory where cache files will be stored"
+    option :cache_key,
+       nil,
+       "A global cache key"
+
+    if Semantic::Version.new(Middleman::VERSION).major >= 4
+      expose_to_config :proxy_with_cache
+    end
 
-  module InstanceMethods
-    def proxy_with_cache(path:, template:, proxy_options:, fingerprint:)
-      item = CacheItem.new(
-        path: path,
-        template: template,
-        proxy_options: proxy_options,
-        fingerprint: fingerprint
-      )
-      will_use_cache = extensions[:caching_proxy].add(item)
-      if !will_use_cache
-        proxy item.path, item.template, item.proxy_options
+    module InstanceMethods
+      def proxy_with_cache(path:, template:, proxy_options:, fingerprint:)
+        item = CacheItem.new(
+          path: path,
+          template: template,
+          proxy_options: proxy_options,
+          fingerprint: fingerprint
+        )
+        will_use_cache = extensions[:caching_proxy].add(item)
+        if !will_use_cache
+          proxy item.path, item.template, item.proxy_options
+        end
       end
     end
-  end
 
-  attr_reader :copy_from_cache
-  attr_reader :add_to_cache
+    attr_reader :copy_from_cache
+    attr_reader :add_to_cache
 
-  def initialize(app, options_hash = {}, &block)
-    super
+    def initialize(app, options_hash = {}, &block)
+      super
 
-    if Semantic::Version.new(Middleman::VERSION).major <= 3
-      app.send :include, InstanceMethods
-    end
+      if Semantic::Version.new(Middleman::VERSION).major <= 3
+        app.send :include, InstanceMethods
+      end
 
-    if !options.cache_key
-      raise "Please supply a cache_key value"
-    end
+      if !options.cache_key
+        raise "Please supply a cache_key value"
+      end
 
-    @copy_from_cache = []
-    @add_to_cache = []
-    @cache = nil
-  end
+      @copy_from_cache = []
+      @add_to_cache = []
+      @cache = nil
+    end
 
-  def manipulate_resource_list(resources)
-    resources + cached_resources
-  end
+    def manipulate_resource_list(resources)
+      resources + cached_resources
+    end
 
-  def after_build(_builder)
-    copy_new_files_to_cache
-    cache.save
-  end
+    def after_build(_builder)
+      copy_new_files_to_cache
+      cache.save
+    end
 
-  def add(item)
-    if cache.has?(item)
-      copy_from_cache << item
-      true
-    else
-      add_to_cache << item
-      false
+    def add(item)
+      if cache.has?(item)
+        copy_from_cache << item
+        true
+      else
+        add_to_cache << item
+        false
+      end
     end
-  end
 
-  private
+    private
 
-  def cache
-    @cache ||= Cache.new(path: options.cache_directory, key: options.cache_key)
-  end
+    def cache
+      @cache ||= Cache.new(path: options.cache_directory, key: options.cache_key)
+    end
 
-  def copy_new_files_to_cache
-    add_to_cache.each do |item|
-      # Handle directory_indexes extension
-      resource = app.sitemap.find_resource_by_path(item.path)
-      build_path = relative_build_path(resource.destination_path)
-      cache.add item: item, source: build_path
+    def copy_new_files_to_cache
+      add_to_cache.each do |item|
+        # Handle directory_indexes extension
+        resource = app.sitemap.find_resource_by_path(item.path)
+        build_path = relative_build_path(resource.destination_path)
+        cache.add item: item, source: build_path
+      end
     end
-  end
 
-  def cached_resources
-    copy_from_cache.map do |item|
-      cached_path = cache.full_path(item: item)
-      # TODO: Handle directory_indexes extension
-      build_path = relative_build_path(item.path)
-      CachedResource.new(
-        path: item.path, cached_path: cached_path, build_path: build_path
-      )
+    def cached_resources
+      copy_from_cache.map do |item|
+        cached_path = cache.full_path(item: item)
+        # TODO: Handle directory_indexes extension
+        build_path = relative_build_path(item.path)
+        CachedResource.new(
+          path: item.path, cached_path: cached_path, build_path: build_path
+        )
+      end
     end
-  end
 
-  def relative_build_path(path)
-    File.join("build", path)
+    def relative_build_path(path)
+      File.join("build", path)
+    end
   end
 end

data/lib/middleman/caching_proxy/version.rb

@@ -1,7 +1,5 @@
 module Middleman; end
 
-module Middleman
-  module CachingProxy
-    VERSION = "0.1.3"
-  end
+module Middleman::CachingProxy
+  VERSION = "0.1.4"
 end

data/middleman-caching-proxy.gemspec

@@ -24,6 +24,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "autostruct"
 
   spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency 'simplecov'
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
 end

data/spec/middleman/caching_proxy/cache_item_spec.rb

@@ -0,0 +1,12 @@
+require "spec_helper"
+require "middleman/caching_proxy/cache_item"
+
+RSpec.describe Middleman::CachingProxy::CacheItem do
+  describe ".new" do
+    %w(path template proxy_options fingerprint).each do |param|
+      it "requires a #{param} parameter" do
+        expect(described_class).to require_parameter(param)
+      end
+    end
+  end
+end

data/spec/middleman/caching_proxy/cache_manifest_spec.rb

@@ -0,0 +1,108 @@
+require "spec_helper"
+require "middleman/caching_proxy/cache_manifest"
+require "middleman/caching_proxy/cache_item"
+
+module Middleman::CachingProxy
+  RSpec.describe CacheManifest do
+    let(:path) { "path" }
+    let(:key) { "key" }
+    let(:manifest_path) { File.join(path, ".manifest.json") }
+    let(:manifest_exists) { true }
+    let(:item) { double(CacheItem, path: item_path, fingerprint: fingerprint) }
+    let(:item_path) { "item/path" }
+    let(:fingerprint) { "fingerprint" }
+    let(:initial_contents) { JSON.generate(initial_data) }
+    let(:initial_data) do
+      {
+        "version" => VERSION,
+        "key" => key,
+        "items" => initial_items
+      }
+    end
+    let(:initial_items) { {} }
+
+    subject { described_class.new(path: path, key: key) }
+
+    before do
+      allow(File).to receive(:exist?).and_call_original
+      allow(File).to receive(:exist?).with(manifest_path) { manifest_exists }
+      allow(File).to receive(:read).and_call_original
+      allow(File).to receive(:read).with(manifest_path) { initial_contents }
+    end
+
+    describe "#has?" do
+      context "when the item was in the JSON file" do
+        let(:initial_items) { {item_path => fingerprint} }
+
+        it "is true" do
+          expect(subject.has?(item)).to be_truthy
+        end
+      end
+
+      context "when the item was not in the JSON file" do
+        it "is false" do
+          expect(subject.has?(item)).to be_falsey
+        end
+      end
+
+      context "when the JSON file did not get loaded" do
+        let(:manifest_exists) { false }
+
+        it "is false" do
+          expect(subject.has?(item)).to be_falsey
+        end
+      end
+
+      context "when the item was added" do
+        it "is true" do
+          subject.add(item)
+          expect(subject.has?(item)).to be_truthy
+        end
+      end
+    end
+
+    describe "#save" do
+      let(:initial_items) { {"foo" => "bar"} }
+
+      before do
+        @parsed = nil
+        allow(File).to receive(:write).with(manifest_path, anything) do |_, j|
+          @parsed = JSON.load(j)
+        end
+        subject.save
+      end
+
+      it "saves to disk" do
+        expect(File).to have_received(:write)
+      end
+      
+      it "saves the version" do
+        expect(@parsed["version"]).to eq(VERSION)
+      end
+
+      it "saves the key" do
+        expect(@parsed["key"]).to eq(key)
+      end
+
+      it "re-saves initial items" do
+        expect(@parsed["items"]["foo"]).to eq("bar")
+      end
+    end
+
+    describe "#add" do
+      before do
+        @parsed = nil
+        allow(File).to receive(:write).with(manifest_path, anything) do |_, j|
+          @parsed = JSON.load(j)
+        end
+      end
+
+      it "is saved in the disk format" do
+        subject.add(item)
+        subject.save
+
+        expect(@parsed["items"][item_path]).to eq(fingerprint)
+      end
+    end
+  end
+end

data/spec/middleman/caching_proxy/cache_spec.rb

@@ -0,0 +1,100 @@
+require "spec_helper"
+require "middleman/caching_proxy/cache"
+require "middleman/caching_proxy/cache_item"
+
+module Middleman::CachingProxy
+  RSpec.describe Cache do
+    let(:manifest) do
+      instance_double(CacheManifest, has?: in_manifest, add: nil, save: nil)
+    end
+    let(:cache_path) { "/cache/path" }
+    let(:key) { "key" }
+    let(:in_manifest) { true }
+    let(:item) { double(CacheItem, path: item_path) }
+    let(:item_path) { "item/path" }
+    let(:item_cache_path) { File.join(cache_path, "items", item_path) }
+    let(:item_cache_directory) { File.dirname(item_cache_path) }
+    let(:item_build_path) { File.join(build_path, item_path) }
+    let(:build_path) { "/build/path" }
+
+    subject { described_class.new(path: cache_path, key: key) }
+
+    before do
+      allow(CacheManifest).to receive(:new) { manifest }
+    end
+
+    describe ".new" do
+      %w(path key).each do |param|
+        it "requires a #{param} parameter" do
+          expect(described_class).to require_parameter(param)
+        end
+      end
+    end
+
+    describe "#has?" do
+      before do
+        allow(File).to receive(:exist?).and_call_original
+        allow(File).to receive(:exist?).with(item_cache_path) { exists }
+      end
+
+      context "when the file exists on disk" do
+        let(:exists) { true }
+
+        context "when the item is in the manifest" do
+          let(:in_manifest) { true }
+
+          it "is true" do
+            expect(subject.has?(item)).to be_truthy
+          end
+        end
+
+        context "when the item is not in the manifest" do
+          let(:in_manifest) { false }
+
+          it "is true" do
+            expect(subject.has?(item)).to be_falsey
+          end
+        end
+      end
+
+      context "when the file does not exist on disk" do
+        let(:exists) { false }
+
+        it "is false" do
+          expect(subject.has?(item)).to be_falsey
+        end
+      end
+    end
+
+    describe "#add" do
+      before do
+        allow(FileUtils).to receive(:mkdir_p).with(item_cache_directory)
+        allow(FileUtils).to receive(:cp).with(item_build_path, item_cache_path)
+
+        subject.add(item: item, source: item_build_path)
+      end
+
+      it "adds the item to the manifest" do
+        expect(manifest).to have_received(:add).with(item)
+      end
+
+      it "ensures the cache directory exists" do
+        expect(FileUtils).to have_received(:mkdir_p).with(item_cache_directory)
+      end
+
+      it "copies the file" do
+        expect(FileUtils). to have_received(:cp).with(
+          item_build_path, item_cache_path
+        )
+      end
+    end
+
+    describe "#save" do
+      it "saves the manifest" do
+        subject.save
+
+        expect(manifest).to have_received(:save)
+      end
+    end
+  end
+end

data/spec/middleman/caching_proxy/cached_resource_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+require "middleman/caching_proxy/cached_resource"
+
+RSpec.describe Middleman::CachingProxy::CachedResource do
+  describe ".new" do
+    %w(path cached_path build_path).each do |param|
+      it "requires a #{param} parameter" do
+        expect(described_class).to require_parameter(param)
+      end
+    end
+  end
+
+  let(:path) { "/foo/bar" }
+  let(:cached_path) { "/cached/path" }
+  let(:build_path) { "/build/path" }
+
+  subject do
+    described_class.new(
+      path: path, cached_path: cached_path, build_path: build_path
+    )
+  end
+
+  describe "#destination_path" do
+    it "is the path without the leading slash" do
+      expect(subject.destination_path).to eq("foo/bar")
+    end
+  end
+
+  describe "#ignored?" do
+    it { is_expected.to_not be_ignored }
+  end
+
+  describe "#binary?" do
+    it { is_expected.to be_binary }
+  end
+
+  describe "#ext" do
+    it "is the an enpty string" do
+      expect(subject.ext).to eq("")
+    end
+  end
+
+  describe "#source_file" do
+    it "is the cached path" do
+      expect(subject.source_file).to eq(cached_path)
+    end
+  end
+
+  describe "#content_type" do
+    it "is HTML" do
+      expect(subject.content_type).to eq("text/html")
+    end
+  end
+end

data/spec/middleman/caching_proxy/extension_spec.rb

@@ -0,0 +1,7 @@
+require "spec_helper"
+require "middleman/caching_proxy/extension"
+
+RSpec.describe Middleman::CachingProxy::Extension do
+  xit "how do I test Middleman extensions?"
+end
+

data/spec/middleman/caching_proxy/version_spec.rb

@@ -0,0 +1,8 @@
+require "spec_helper"
+require "middleman/caching_proxy/version"
+
+describe Middleman::CachingProxy do
+  it "has a version number" do
+    expect(Middleman::CachingProxy::VERSION).not_to be nil
+  end
+end

data/spec/middleman/caching_proxy_spec.rb

@@ -1,7 +1,16 @@
 require "spec_helper"
+require "middleman-core"
 
-describe Middleman::CachingProxy do
-  it "has a version number" do
-    expect(Middleman::Caching::Proxy::VERSION).not_to be nil
+RSpec.describe Middleman::CachingProxy do
+  before do
+    allow(Middleman::Extensions).to receive(:register)
+  end
+
+  it "registers the extension" do
+    require "middleman/caching_proxy"
+    expect(Middleman::Extensions).
+      to have_received(:register).with(
+           :caching_proxy, Middleman::CachingProxy::Extension
+         )
   end
 end

data/spec/spec_helper.rb

@@ -1,2 +1,4 @@
 $LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
-require "middleman/caching_proxy"
+
+root = File.dirname(__FILE__)
+Dir[File.join(root, "support", "**", "*.rb")].each { |f| require f }

data/spec/support/matchers/raise_error_matching.rb

@@ -0,0 +1,52 @@
+# This code is derived from shoulda-matchers version 2.7.0
+
+RSpec::Matchers.define :raise_error_matching do |klass: StandardError, message:|
+  def supports_block_expectations?
+    true
+  end
+
+  match do |block|
+    @actual = nil
+
+    begin
+      block.call
+    rescue => ex
+      @actual = ex
+    end
+
+    @actual &&
+      @actual.is_a?(klass) &&
+      @actual.message.match(message)
+  end
+
+  def failure_message
+    msg = "Block should have failed with #{expected[:klass]}, with a message matching '#{expected[:message]}'"
+
+    if @actual
+      if !@actual.is_a?(expected[:klass])
+        msg << ", actually failed with #{@actual.class} '#{@actual.message}'"
+      else
+        msg << ", actually failed with the message '#{@actual.message}'"
+      end
+    else
+      msg << ", but did not fail."
+    end
+
+    msg
+  end
+
+  def failure_message_for_should
+    failure_message
+  end
+
+  def failure_message_when_negated
+    msg  = "Block should not have failed with #{expected[:klass]}, with message including '#{expected[:message]}'"
+    msg << ", but did."
+
+    msg
+  end
+
+  def failure_message_for_should_not
+    failure_message_when_negated
+  end
+end

data/spec/support/matchers/require_parameter.rb

@@ -0,0 +1,52 @@
+RSpec::Matchers.define :require_parameter do |expected|
+  match do |klass|
+    @actual = nil
+
+    begin
+      klass.new
+    rescue => ex
+      @actual = ex
+    end
+
+    @actual &&
+      @actual.is_a?(ArgumentError) &&
+      @actual.message.match(matcher_for(expected))
+  end
+
+  def matcher_for(param)
+    Regexp.new("missing keywords: .*?\\b#{param}\\b")
+  end
+
+  def failure_message
+    msg = "The constructor should require #{expected}"
+
+    if @actual
+      if @actual.is_a?(ArgumentError) &&
+         @actual.message.start_with?("missing keywords: ")
+        m = /missing keywords: (.*)$/.match(@actual.message)
+        msg << ", actually requires #{m[1]}"
+      else
+        msg << ", actually failed with the message '#{@actual.message}'"
+      end
+    else
+      msg << ", but does not require any parameters."
+    end
+
+    msg
+  end
+
+  def failure_message_for_should
+    failure_message
+  end
+
+  def failure_message_when_negated
+    msg  = "FFFFFFUUUUUUUUUUUUUUUUUUUUUUUUU Block should not have failed with #{expected[:klass]}, with message including '#{expected[:message]}'"
+    msg << ", but did."
+
+    msg
+  end
+
+  def failure_message_for_should_not
+    failure_message_when_negated
+  end
+end

data/spec/support/simplecov.rb

@@ -0,0 +1,5 @@
+require 'simplecov'
+
+SimpleCov.start do
+  add_filter '/spec/'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: middleman-caching-proxy
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Joe Yates
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-11-22 00:00:00.000000000 Z
+date: 2016-11-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: middleman
@@ -72,6 +72,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -127,8 +141,17 @@ files:
 - lib/middleman/caching_proxy/extension.rb
 - lib/middleman/caching_proxy/version.rb
 - middleman-caching-proxy.gemspec
+- spec/middleman/caching_proxy/cache_item_spec.rb
+- spec/middleman/caching_proxy/cache_manifest_spec.rb
+- spec/middleman/caching_proxy/cache_spec.rb
+- spec/middleman/caching_proxy/cached_resource_spec.rb
+- spec/middleman/caching_proxy/extension_spec.rb
+- spec/middleman/caching_proxy/version_spec.rb
 - spec/middleman/caching_proxy_spec.rb
 - spec/spec_helper.rb
+- spec/support/matchers/raise_error_matching.rb
+- spec/support/matchers/require_parameter.rb
+- spec/support/simplecov.rb
 homepage: https://github.com/joeyates/middleman-caching-proxy
 licenses:
 - MIT