usmu 0.3.2-java → 0.3.3-java

data/lib/usmu/version.rb

@@ -1,5 +1,5 @@
 
 module Usmu
   # The current version string for the gem
-  VERSION = '0.3.2'
+  VERSION = '0.3.3'
 end

data/spec/configuration_spec.rb

@@ -133,6 +133,30 @@ RSpec.describe Usmu::Configuration do
     end
   end
 
+  context '#source_metadata' do
+    it 'should return a new metadata service for the source folder' do
+      ms = {fake: 'success'}
+      expect(Usmu::MetadataService).to receive(:new).with(empty_configuration.source_path).and_return(ms)
+      expect(empty_configuration.source_metadata).to eq(ms)
+    end
+  end
+
+  context '#layouts_metadata' do
+    it 'should return a new metadata service for the layouts folder' do
+      ms = {fake: 'success'}
+      expect(Usmu::MetadataService).to receive(:new).with(empty_configuration.layouts_path).and_return(ms)
+      expect(empty_configuration.layouts_metadata).to eq(ms)
+    end
+  end
+
+  context '#includes_metadata' do
+    it 'should return a new metadata service for the layouts folder' do
+      ms = {fake: 'success'}
+      expect(Usmu::MetadataService).to receive(:new).with(empty_configuration.includes_path).and_return(ms)
+      expect(empty_configuration.includes_metadata).to eq(ms)
+    end
+  end
+
   context '#exclude' do
     it 'returns the exclude option in the configuration array' do
       expect(Usmu::Configuration.from_hash({'exclude' => ['test.md']}).exclude).to eq(['test.md'])

data/spec/deployment/directory_diff_spec.rb

@@ -4,123 +4,109 @@ require 'ostruct'
 require 'digest'
 
 RSpec.describe Usmu::Deployment::DirectoryDiff do
+  let (:configuration) { Usmu::Configuration.from_hash({}) }
+
+  context '#initialize' do
+    it 'initializes variables' do
+      remote_files = OpenStruct.new {}
+      diff = Usmu::Deployment::DirectoryDiff.new(configuration, remote_files)
+
+      expect(diff.send :configuration).to eq(configuration)
+      expect(diff.send :remote_files).to eq(remote_files)
+    end
+  end
+
   context '#get_diffs' do
-    let (:configuration) { Usmu::Configuration.from_hash({}) }
+    it 'returns file changes' do
+      remote_files = Usmu::MockRemoteFiles.new({ 'index.html' => {}, 'articles.html' => {}, 'remote.html' => {} })
+      allow(Dir).to receive(:'[]').with('site/**/{*,.??*}').and_return(%w(site/index.html site/articles.html site/local.html))
+      diff = Usmu::Deployment::DirectoryDiff.new(configuration, remote_files)
+      expect(diff).to receive(:filter_files).with('articles.html').and_return(false)
+      expect(diff).to receive(:filter_files).with('index.html').and_return(true)
+
+      expect(diff.get_diffs).to eq({
+                                       local: %w{local.html},
+                                       remote: %w{remote.html},
+                                       updated: %w{index.html},
+                                   })
+    end
+  end
+
+  context '#filter_files' do
+    let (:now) { Time.now }
     let (:file) { 'Hello world!' }
-    let (:now) { Time.at(1420875742) }
 
     before do
-      allow(File).to receive(:stat).with('site/index.html').and_return(OpenStruct.new({mtime: now}))
-      allow(File).to receive(:read).with('site/index.html').and_return(file)
+      expect(File).to receive(:stat).with('site/index.html').and_return(OpenStruct.new mtime: now)
+      expect(File).to receive(:read).with('site/index.html').and_return(file)
     end
 
-    it 'returns remote only files' do
-      allow(Dir).to receive(:'[]').with('site/**/{*,.??*}').and_return(%w())
-      remote_files = Usmu::MockRemoteFiles.new(
-          {
-              'index.html' => {
-                  :mtime => now + 100,
-              },
-          }
-      )
+    it 'rejects identical files' do
+      remote_files = Usmu::MockRemoteFiles.new({ 'index.html' => {mtime: now} })
       diff = Usmu::Deployment::DirectoryDiff.new(configuration, remote_files)
+      expect(diff).to receive(:check_hash).with(file, {mtime: now}).and_return(true)
 
-      expect(diff.get_diffs).to eq({remote: ['index.html'], local: [], updated: []})
+      expect(diff.send :filter_files, 'index.html').to eq(false)
     end
 
-    it 'returns local only files' do
-      allow(Dir).to receive(:'[]').with('site/**/{*,.??*}').and_return(%w(site/index.html))
-      remote_files = Usmu::MockRemoteFiles.new({})
+    it 'rejects files newer on remote' do
+      remote_files = Usmu::MockRemoteFiles.new({ 'index.html' => {mtime: now + 200} })
       diff = Usmu::Deployment::DirectoryDiff.new(configuration, remote_files)
+      expect(diff).to receive(:check_hash).with(file, {mtime: now + 200}).and_return(true)
 
-      expect(diff.get_diffs).to eq({local: ['index.html'], remote: [], updated: []})
+      expect(diff.send :filter_files, 'index.html').to eq(false)
     end
 
-    it 'hides identical files' do
-      allow(Dir).to receive(:'[]').with('site/**/{*,.??*}').and_return(%w(site/index.html))
-      remote_files = Usmu::MockRemoteFiles.new(
-          {
-              'index.html' => {
-                  :mtime => now,
-              },
-          }
-      )
+    it 'allows files newer on local' do
+      remote_files = Usmu::MockRemoteFiles.new({ 'index.html' => {mtime: now - 200} })
       diff = Usmu::Deployment::DirectoryDiff.new(configuration, remote_files)
+      expect(diff).to receive(:check_hash).with(file, {mtime: now - 200}).and_return(true)
 
-      expect(diff.get_diffs).to eq({local: [], remote: [], updated: []})
+      expect(diff.send :filter_files, 'index.html').to eq(true)
     end
 
-    it 'hides files newer on remote' do
-      allow(Dir).to receive(:'[]').with('site/**/{*,.??*}').and_return(%w(site/index.html))
-      remote_files = Usmu::MockRemoteFiles.new(
-          {
-              'index.html' => {
-                  :mtime => now + 100,
-              },
-          }
-      )
+    it 'allows files with different hashes' do
+      remote_files = Usmu::MockRemoteFiles.new({ 'index.html' => {mtime: now} })
       diff = Usmu::Deployment::DirectoryDiff.new(configuration, remote_files)
+      expect(diff).to receive(:check_hash).with(file, {mtime: now}).and_return(false)
 
-      expect(diff.get_diffs).to eq({local: [], remote: [], updated: []})
+      expect(diff.send :filter_files, 'index.html').to eq(true)
     end
 
-    it 'returns files newer on local' do
-      allow(Dir).to receive(:'[]').with('site/**/{*,.??*}').and_return(%w(site/index.html))
-      remote_files = Usmu::MockRemoteFiles.new(
-          {
-              'index.html' => {
-                  :mtime => now - 100,
-              },
-          }
-      )
+    it 'allows files with different hashes and newer remote file' do
+      remote_files = Usmu::MockRemoteFiles.new({ 'index.html' => {mtime: now + 200} })
       diff = Usmu::Deployment::DirectoryDiff.new(configuration, remote_files)
+      expect(diff).to receive(:check_hash).with(file, {mtime: now + 200}).and_return(false)
 
-      expect(diff.get_diffs).to eq({local: [], remote: [], updated: ['index.html']})
+      expect(diff.send :filter_files, 'index.html').to eq(true)
     end
+  end
 
-    it 'returns files with different md5 hashes' do
-      allow(Dir).to receive(:'[]').with('site/**/{*,.??*}').and_return(%w(site/index.html))
-      remote_files = Usmu::MockRemoteFiles.new(
-          {
-              'index.html' => {
-                  :mtime => now,
-                  :md5 => Digest::MD5.hexdigest(file + 'foo'),
-              },
-          }
-      )
-      diff = Usmu::Deployment::DirectoryDiff.new(configuration, remote_files)
+  context '#check_hash' do
+    let (:contents) { 'Hello world!' }
+    let (:diff) { Usmu::Deployment::DirectoryDiff.new(configuration, nil) }
 
-      expect(diff.get_diffs).to eq({local: [], remote: [], updated: ['index.html']})
+    it 'can validate an MD5 hash' do
+      expect(diff.send :check_hash, contents, {md5: '86fb269d190d2c85f6e0468ceca42a20'}).to eq(true)
+      expect(diff.send :check_hash, contents, {md5: '02a24acec8640e6f58c2d091d962bf68'}).to eq(false)
     end
 
-    it 'returns files with different sha1 hashes' do
-      allow(Dir).to receive(:'[]').with('site/**/{*,.??*}').and_return(%w(site/index.html))
-      remote_files = Usmu::MockRemoteFiles.new(
-          {
-              'index.html' => {
-                  :mtime => now,
-                  :sha1 => Digest::SHA1.hexdigest(file + 'foo'),
-              },
-          }
-      )
-      diff = Usmu::Deployment::DirectoryDiff.new(configuration, remote_files)
+    it 'can validate a SHA1 hash' do
+      expect(diff.send :check_hash, contents, {sha1: 'd3486ae9136e7856bc42212385ea797094475802'}).to eq(true)
+      expect(diff.send :check_hash, contents, {sha1: '208574490797ae58321224cb6587e6319ea6843d'}).to eq(false)
+    end
 
-      expect(diff.get_diffs).to eq({local: [], remote: [], updated: ['index.html']})
+    it 'can validate a remote file with no hash' do
+      expect(diff.send :check_hash, contents, {}).to eq(true)
     end
+  end
 
-    it 'returns files with different hashes and newer remote file' do
-      allow(Dir).to receive(:'[]').with('site/**/{*,.??*}').and_return(%w(site/index.html))
-      remote_files = Usmu::MockRemoteFiles.new(
-          {
-              'index.html' => {
-                  :mtime => now + 100,
-                  :md5 => Digest::MD5.hexdigest(file + 'foo'),
-              },
-          }
-      )
-      diff = Usmu::Deployment::DirectoryDiff.new(configuration, remote_files)
+  context '#local_files_list' do
+    it 'returns a list of files in the local output directory' do
+      expect(Dir).to receive(:[]).with('site/**/{*,.??*}').and_return(%w{site/index.html})
+      diff = Usmu::Deployment::DirectoryDiff.new(configuration, nil)
 
-      expect(diff.get_diffs).to eq({local: [], remote: [], updated: ['index.html']})
+      expect(diff.send :local_files_list).to eq(%w{index.html})
     end
   end
 end

data/spec/metadata_service_spec.rb

@@ -0,0 +1,75 @@
+require 'usmu/metadata_service'
+
+RSpec.describe Usmu::MetadataService do
+  let (:service) { Usmu::MetadataService.new('test') }
+
+  context '#initialize' do
+    it 'stores a base directory for checks' do
+      expect(service.send :base).to eq('test')
+    end
+  end
+
+  context '#metadata' do
+    it 'returns an empty hash if no metadata available' do
+      expect(File).to receive(:exist?).with('test/test.meta.yml').and_return(false)
+      allow(File).to receive(:directory?).and_return(false)
+      expect(service.metadata('test.md')).to eq({})
+    end
+
+    it 'returns metadata for files in the root folder' do
+      expect(File).to receive(:exist?).with('test/a.meta.yml').and_return(true)
+      expect(YAML).to receive(:load_file).with('test/a.meta.yml').and_return({test: 'success'})
+      allow(File).to receive(:directory?).and_return(false)
+      expect(service.metadata('a.md')).to eq({test: 'success'})
+    end
+
+    it 'looks for dotfile metadata using the entire filename' do
+      expect(File).to receive(:exist?).with('test/.dotfile.meta.yml').and_return(true)
+      expect(YAML).to receive(:load_file).with('test/.dotfile.meta.yml').and_return({test: 'success'})
+      allow(File).to receive(:directory?).and_return(false)
+      expect(service.metadata('.dotfile')).to eq({test: 'success'})
+    end
+
+    it 'looks for metadata using the entire filename if file has no extension' do
+      expect(File).to receive(:exist?).with('test/dotfile.meta.yml').and_return(true)
+      expect(YAML).to receive(:load_file).with('test/dotfile.meta.yml').and_return({test: 'success'})
+      allow(File).to receive(:directory?).and_return(false)
+      expect(service.metadata('dotfile')).to eq({test: 'success'})
+    end
+
+    it 'merges metadata from parent folders' do
+      expect(File).to receive(:exist?).with('test/foo/test.meta.yml').and_return(true)
+      expect(YAML).to receive(:load_file).with('test/foo/test.meta.yml').and_return({test: 'success'})
+      expect(File).to receive(:exist?).with('test/foo/meta.yml').and_return(true)
+      expect(YAML).to receive(:load_file).with('test/foo/meta.yml').and_return({dir: 'success'})
+
+      expect(File).to receive(:directory?).with('test/foo').and_return(true)
+      allow(File).to receive(:directory?).and_return(false)
+
+      expect(service.metadata('foo/test.md')).to eq({dir: 'success', test: 'success'})
+    end
+
+    it 'only searches for a file extension in the filename' do
+      expect(File).to receive(:exist?).with('test/te.st/meta.yml').and_return(false)
+      expect(File).to receive(:exist?).with('test/te.st/dotfile.meta.yml').and_return(true)
+      expect(YAML).to receive(:load_file).with('test/te.st/dotfile.meta.yml').and_return({test: 'success'})
+
+      expect(File).to receive(:directory?).with('test/te.st').and_return(true)
+      allow(File).to receive(:directory?).and_return(false)
+
+      expect(service.metadata('te.st/dotfile')).to eq({test: 'success'})
+    end
+
+    it 'favours metadata from objects to metadata from parent objects' do
+      expect(File).to receive(:exist?).with('test/foo/test.meta.yml').and_return(true)
+      expect(YAML).to receive(:load_file).with('test/foo/test.meta.yml').and_return({test: 'success'})
+      expect(File).to receive(:exist?).with('test/foo/meta.yml').and_return(true)
+      expect(YAML).to receive(:load_file).with('test/foo/meta.yml').and_return({test: 'directory'})
+
+      expect(File).to receive(:directory?).with('test/foo').and_return(true)
+      allow(File).to receive(:directory?).and_return(false)
+
+      expect(service.metadata('foo/test.md')).to eq({test: 'success'})
+    end
+  end
+end

data/spec/site_generator_spec.rb

@@ -11,7 +11,7 @@ RSpec.describe Usmu::SiteGenerator do
 
   it 'should have a list of renderable items' do
     expect(generator.respond_to? :renderables).to eq(true)
-    expect(generator.renderables.map {|r| r.name}.sort).to eq(%w{.dotfiletest.txt css/app.scss default.md embedded.md index.md posts/test-post.md robots.txt})
+    expect(generator.renderables.map {|r| r.name}.sort).to eq(%w{.dotfiletest.txt assets/external.scss css/app.scss default.md embedded.md index.md posts/test-post.md robots.txt})
   end
 
   it 'should have pages' do
@@ -21,7 +21,7 @@ RSpec.describe Usmu::SiteGenerator do
 
   it 'should have files' do
     expect(generator.respond_to? :files).to eq(true)
-    expect(generator.files.map {|f| f.name}.sort).to eq(%w{.dotfiletest.txt robots.txt})
+    expect(generator.files.map {|f| f.name}.sort).to eq(%w{.dotfiletest.txt assets/external.scss robots.txt})
   end
 
   it 'should not list directories' do

data/spec/support/shared_layout.rb

@@ -3,13 +3,13 @@ RSpec.shared_examples 'a renderable file' do
   let(:empty_configuration) { Usmu::Configuration.from_hash({}) }
 
   it 'and has a name' do
-    layout = described_class.new(empty_configuration, 'body.slim', 'slim', '', {})
+    layout = described_class.new(empty_configuration, 'body.slim', {}, 'slim', '')
     expect(layout.respond_to? :name).to eq(true)
     expect(layout.name).to eq('body.slim')
   end
 
   it 'and can be rendered' do
-    layout = described_class.new(empty_configuration, 'body.slim', 'slim', '', {})
+    layout = described_class.new(empty_configuration, 'body.slim', {}, 'slim', '')
     expect(layout.respond_to? :render).to eq(true)
     expect(layout.method(:render).arity).to eq(-1)
     expect(layout.method(:render).parameters.length).to eq(1)
@@ -24,13 +24,13 @@ RSpec.shared_examples 'a layout' do
   let(:content) { "title \#{title}\nbody\n  #container\n    | \#{{content}}" }
 
   it 'and has a type' do
-    layout = described_class.new(empty_configuration, 'body.slim', 'slim', content, meta_with_title)
+    layout = described_class.new(empty_configuration, 'body.slim', meta_with_title, 'slim', content)
     expect(layout.respond_to? :type).to eq(true)
     expect(layout.type).to eq('slim')
   end
 
   it 'and it renders a template' do
-    layout = described_class.new(empty_configuration, 'body.slim', 'slim', content, {})
+    layout = described_class.new(empty_configuration, 'body.slim', {}, 'slim', content)
     expect(layout.render({'title' => 'title', 'content' => 'test'})).to eq(<<-EOF)
 <title>title</title><body><div id="container">test</div></body>
     EOF
@@ -38,66 +38,66 @@ RSpec.shared_examples 'a layout' do
 
   context 'and when it\'s type' do
     it 'is invalid' do
-      expect {described_class.new(empty_configuration, 'body.foo', nil, '', {})}.to raise_error()
+      expect {described_class.new(empty_configuration, 'body.foo', {}, nil, '')}.to raise_error()
     end
 
     it 'is erb then it\'s output type should be taken from it\'s filename' do
-      layout = described_class.new(empty_configuration, 'body.txt.erb', 'erb', '', {})
+      layout = described_class.new(empty_configuration, 'body.txt.erb', {}, 'erb', '')
       expect(layout.output_filename).to eq('body.txt')
     end
 
     it 'is rhtml then it\'s output type should be taken from it\'s filename' do
-      layout = described_class.new(empty_configuration, 'body.txt.rhtml', 'rhtml', '', {})
+      layout = described_class.new(empty_configuration, 'body.txt.rhtml', {}, 'rhtml', '')
       expect(layout.output_filename).to eq('body.txt')
     end
 
     it 'is erubis then it\'s output type should be taken from it\'s filename' do
-      layout = described_class.new(empty_configuration, 'body.txt.erubis', 'erubis', '', {})
+      layout = described_class.new(empty_configuration, 'body.txt.erubis', {}, 'erubis', '')
       expect(layout.output_filename).to eq('body.txt')
     end
 
     it 'is markdown then it\'s output type should be html' do
-      layout = described_class.new(empty_configuration, 'body.markdown', 'markdown', '', {})
+      layout = described_class.new(empty_configuration, 'body.markdown', {}, 'markdown', '')
       expect(layout.output_filename).to eq('body.html')
     end
 
     it 'is mkd then it\'s output type should be html' do
-      layout = described_class.new(empty_configuration, 'body.mkd', 'mkd', '', {})
+      layout = described_class.new(empty_configuration, 'body.mkd', {}, 'mkd', '')
       expect(layout.output_filename).to eq('body.html')
     end
 
     it 'is md then it\'s output type should be html' do
-      layout = described_class.new(empty_configuration, 'body.md', 'md', '', {})
+      layout = described_class.new(empty_configuration, 'body.md', {}, 'md', '')
       expect(layout.output_filename).to eq('body.html')
     end
 
     it 'is coffee then it\'s output type should be js' do
-      layout = described_class.new(empty_configuration, 'body.coffee', 'coffee', '', {})
+      layout = described_class.new(empty_configuration, 'body.coffee', {}, 'coffee', '')
       expect(layout.output_filename).to eq('body.js')
     end
 
     it 'is less then it\'s output type should be css' do
-      layout = described_class.new(empty_configuration, 'body.less', 'less', '', {})
+      layout = described_class.new(empty_configuration, 'body.less', {}, 'less', '')
       expect(layout.output_filename).to eq('body.css')
     end
 
     it 'is liquid then it\'s output type should be taken from it\'s filename' do
-      layout = described_class.new(empty_configuration, 'body.txt.liquid', 'liquid', '', {})
+      layout = described_class.new(empty_configuration, 'body.txt.liquid', {}, 'liquid', '')
       expect(layout.output_filename).to eq('body.txt')
     end
 
     it 'is sass then it\'s output type should be scss' do
-      layout = described_class.new(empty_configuration, 'body.sass', 'sass', '', {})
+      layout = described_class.new(empty_configuration, 'body.sass', {}, 'sass', '')
       expect(layout.output_filename).to eq('body.css')
     end
 
     it 'is scss then it\'s output type should be css' do
-      layout = described_class.new(empty_configuration, 'body.scss', 'scss', '', {})
+      layout = described_class.new(empty_configuration, 'body.scss', {}, 'scss', '')
       expect(layout.output_filename).to eq('body.css')
     end
 
     it 'is slim then it\'s output type should be html' do
-      layout = described_class.new(empty_configuration, 'body.slim', 'slim', '', {})
+      layout = described_class.new(empty_configuration, 'body.slim', {}, 'slim', '')
       expect(layout.output_filename).to eq('body.html')
     end
   end
@@ -107,13 +107,13 @@ RSpec.shared_examples 'a layout with metadata' do
   include_examples 'a layout'
 
   it 'and has metadata' do
-    layout = described_class.new(empty_configuration, 'body.slim', 'slim', content, meta_with_title)
+    layout = described_class.new(empty_configuration, 'body.slim', meta_with_title, 'slim', content)
     expect(layout.respond_to? :metadata).to eq(true)
     expect(layout.metadata).to eq(meta_with_title)
   end
 
   it 'and respects default meta from configuration' do
-    layout = described_class.new(title_configuration, 'body.slim', 'slim', content, {})
+    layout = described_class.new(title_configuration, 'body.slim', {}, 'slim', content)
     expect(layout.render({'content' => 'test'})).to eq(<<-EOF)
 <title>title</title><body><div id="container">test</div></body>
     EOF
@@ -121,14 +121,14 @@ RSpec.shared_examples 'a layout with metadata' do
 
   context 'and prioritises' do
     it 'variables over metadata' do
-      layout = described_class.new(empty_configuration, 'body.slim', 'slim', content, meta_with_title)
+      layout = described_class.new(empty_configuration, 'body.slim', meta_with_title, 'slim', content)
       expect(layout.render({'content' => 'test', 'title' => 'overridden title'})).to eq(<<-EOF)
 <title>overridden title</title><body><div id="container">test</div></body>
       EOF
     end
 
     it 'metadata over default metadata' do
-      layout = described_class.new(title_configuration, 'body.slim', 'slim', content, meta_with_title)
+      layout = described_class.new(title_configuration, 'body.slim', meta_with_title, 'slim', content)
       expect(layout.render({'content' => 'test'})).to eq(<<-EOF)
 <title>meta title</title><body><div id="container">test</div></body>
       EOF
@@ -136,7 +136,7 @@ RSpec.shared_examples 'a layout with metadata' do
   end
 
   it 'and it has a html output filename' do
-    layout = described_class.new(empty_configuration, 'index.md', 'md', content, {})
+    layout = described_class.new(empty_configuration, 'index.md', {}, 'md', content)
     expect(layout.output_filename).to eq('index.html')
   end
 end
@@ -147,8 +147,8 @@ RSpec.shared_examples 'an embeddable layout' do
   let(:wrapper) { "html\n  | \#{{content}}"}
 
   it 'and respects parent templates' do
-    parent = described_class.new(empty_configuration, 'html.slim', 'slim', wrapper, {})
-    layout = described_class.new(empty_configuration, 'body.slim', 'slim', content, {'layout' => parent, 'title' => 'test title'})
+    parent = described_class.new(empty_configuration, 'html.slim', {}, 'slim', wrapper)
+    layout = described_class.new(empty_configuration, 'body.slim', {'layout' => parent, 'title' => 'test title'}, 'slim', content)
     expect(layout.render({'content' => 'test'})).to eq(<<-EOF)
 <html><title>test title</title><body><div id="container">test</div></body>
 </html>
@@ -156,9 +156,9 @@ RSpec.shared_examples 'an embeddable layout' do
   end
 
   it 'and respects templates from default metadata' do
-    parent = described_class.new(empty_configuration, 'html.slim', 'slim', wrapper, {})
+    parent = described_class.new(empty_configuration, 'html.slim', {}, 'slim', wrapper)
     default_layout_configuration = Usmu::Configuration.from_hash({'default meta' => {'layout' => parent}})
-    layout = described_class.new(default_layout_configuration, 'body.slim', 'slim', content, {'title' => 'test title'})
+    layout = described_class.new(default_layout_configuration, 'body.slim', {'title' => 'test title'}, 'slim', content)
     expect(layout.render({'content' => 'test'})).to eq(<<-EOF)
 <html><title>test title</title><body><div id="container">test</div></body>
 </html>
@@ -167,15 +167,15 @@ RSpec.shared_examples 'an embeddable layout' do
 
   it 'and uses a template of "none" to explicitly disable the parent template' do
     default_layout_configuration = Usmu::Configuration.from_hash({'default meta' => {'layout' => 'html'}})
-    layout = described_class.new(default_layout_configuration, 'body.slim', 'slim', content, {'layout' => 'none', 'title' => 'test title'})
+    layout = described_class.new(default_layout_configuration, 'body.slim', {'layout' => 'none', 'title' => 'test title'}, 'slim', content)
     expect(layout.render({'content' => 'test'})).to eq(<<-EOF)
 <title>test title</title><body><div id="container">test</div></body>
     EOF
   end
 
   it 'only uses a wrapper layout if the output types match' do
-    parent = described_class.new(empty_configuration, 'html.slim', 'slim', wrapper, {})
-    layout = described_class.new(empty_configuration, 'app.scss', 'scss', 'body { color: #000; }', {'layout' => parent})
+    parent = described_class.new(empty_configuration, 'html.slim', {}, 'slim', wrapper)
+    layout = described_class.new(empty_configuration, 'app.scss', {'layout' => parent}, 'scss', 'body { color: #000; }')
     expect(layout.render({'content' => ''})).to eq(<<-EOF)
 body {
   color: #000; }
@@ -184,8 +184,8 @@ body {
 
   context 'and prioritises' do
     it 'metadata over parent metadata' do
-      parent = described_class.new(empty_configuration, 'html.slim', 'slim', wrapper, {'title' => 'title'})
-      layout = described_class.new(empty_configuration, 'body.slim', 'slim', content, {'layout' => parent, 'title' => 'overridden title'})
+      parent = described_class.new(empty_configuration, 'html.slim', {'title' => 'title'}, 'slim', wrapper)
+      layout = described_class.new(empty_configuration, 'body.slim', {'layout' => parent, 'title' => 'overridden title'}, 'slim', content)
       expect(layout.render({'content' => 'test'})).to eq(<<-EOF)
 <html><title>overridden title</title><body><div id="container">test</div></body>
 </html>
@@ -193,8 +193,8 @@ body {
     end
 
     it 'parent metadata over default metadata' do
-      parent = described_class.new(title_configuration, 'html.slim', 'slim', wrapper, {'title' => 'overridden title'})
-      layout = described_class.new(title_configuration, 'body.slim', 'slim', content, {'layout' => parent})
+      parent = described_class.new(title_configuration, 'html.slim', {'title' => 'overridden title'}, 'slim', wrapper)
+      layout = described_class.new(title_configuration, 'body.slim', {'layout' => parent}, 'slim', content)
       expect(layout.render({'content' => 'test'})).to eq(<<-EOF)
 <html><title>overridden title</title><body><div id="container">test</div></body>
 </html>