docks_app 0.0.1

data/spec/lib/processors_spec.rb

@@ -0,0 +1,555 @@
+require "spec_helper"
+
+describe Docks::Processors do
+  subject { described_class }
+
+  before :each do
+    Docks::Languages.register_bundled_languages
+  end
+
+  describe ".split_on_characters" do
+    it "returns the original argument if a non-String was passed" do
+      content = { foo: :bar }
+      expect(subject.split_on_characters(content)).to eq content
+    end
+
+    it "returns the original content if a non-Array and non-String was passed as the `split_on` argument" do
+      content = "String content"
+      split_on = { but: "non-string split_on" }
+
+      expect(subject.split_on_characters(content, split_on)).to eq content
+    end
+
+    it "splits on a single character" do
+      target_array = %w(one two three)
+      expect(subject.split_on_characters("one,two,three", ",")).to eq target_array
+    end
+
+    it "splits on multiple characters" do
+      target_array = %w(one two three)
+      expect(subject.split_on_characters("one,two|three", ",|")).to eq target_array
+    end
+
+    it "splits on an array of characters" do
+      target_array = %w(one two three)
+      expect(subject.split_on_characters("one,two|three", [",", "|"])).to eq target_array
+    end
+
+    it "removes empty strings where they would otherwise be included" do
+      target_array = %w(one two three)
+      expect(subject.split_on_characters("one,,two,three", ",")).to eq target_array
+    end
+  end
+
+  describe ".split_on_commas_spaces_and_pipes" do
+    it "returns the original argument if a non-String and non-Array was passed" do
+      content = { foo: :bar }
+      expect(subject.split_on_commas_spaces_and_pipes(content)).to eq content
+    end
+
+    it "splits breaks apart commas" do
+      target_array = %w(Array String)
+
+      expect(subject.split_on_commas_spaces_and_pipes("Array, String")).to eq target_array
+      expect(subject.split_on_commas_spaces_and_pipes("Array ,String")).to eq target_array
+      expect(subject.split_on_commas_spaces_and_pipes("Array , String")).to eq target_array
+      expect(subject.split_on_commas_spaces_and_pipes("Array ,, String")).to eq target_array
+    end
+
+    it "splits breaks apart pipes" do
+      target_array = %w(Array String)
+
+      expect(subject.split_on_commas_spaces_and_pipes("Array| String")).to eq target_array
+      expect(subject.split_on_commas_spaces_and_pipes("Array |String")).to eq target_array
+      expect(subject.split_on_commas_spaces_and_pipes("Array | String")).to eq target_array
+      expect(subject.split_on_commas_spaces_and_pipes("Array || String")).to eq target_array
+    end
+
+    it "splits on internal spaces" do
+      target_array = ["Item", "1", "Item", "2"]
+
+      expect(subject.split_on_commas_spaces_and_pipes(" Item 1 , Item 2  ")).to eq target_array
+    end
+
+    it "joins together results of a passed array" do
+      target_array = %w(Array Object String Hash)
+      expect(subject.split_on_commas_spaces_and_pipes("Array, Object String | Hash")).to eq target_array
+    end
+  end
+
+  describe ".split_on_top_level_parens_commas_and_pipes" do
+    it "returns the original result as an array if it contained no parentheses" do
+      content = "foo bar"
+      expect(subject.split_on_top_level_parens_commas_and_pipes(content)).to eq [content]
+    end
+
+    it "does not split on unmatched opening parentheses" do
+      content = "This better not match... :( OR ELSE"
+      expect(subject.split_on_top_level_parens_commas_and_pipes(content)).to eq [content]
+    end
+
+    it "does not split on unmatched closing parentheses" do
+      content = "We got past the first one :) now to make it past here..."
+      expect(subject.split_on_top_level_parens_commas_and_pipes(content)).to eq [content]
+    end
+
+    it "does not split on reversed sets of parentheses" do
+      content = "I start happy :) then end sad... :("
+      expect(subject.split_on_top_level_parens_commas_and_pipes(content)).to eq [content]
+    end
+
+    it "does not split when there is only one set of parentheses" do
+      content = "foo (bar)"
+      expect(subject.split_on_top_level_parens_commas_and_pipes(content)).to eq [content]
+    end
+
+    it "does not split when there is a nested set of parentheses" do
+      content = "foo (bar (baz))"
+      expect(subject.split_on_top_level_parens_commas_and_pipes(content)).to eq [content]
+    end
+
+    it "creates a result for each set of top-level parentheses" do
+      content = "here's (one), and here's (two), AND HERE'S (THREE)"
+      expect(subject.split_on_top_level_parens_commas_and_pipes(content).length).to be 3
+    end
+
+    it "does not create additional results for nested parentheses" do
+      content = "here's (one), and here's (t(w)o), AND HERE'S (TH(R)EE)"
+      expect(subject.split_on_top_level_parens_commas_and_pipes(content).length).to be 3
+    end
+
+    it "strips spaces, pipes, and commas between the closing paren and the next character" do
+      content = "here's (one), and here's (t(w)o)   AND HERE'S (TH(R)EE) |  oh and (four)"
+      expect(subject.split_on_top_level_parens_commas_and_pipes(content)).to eq ["here's (one)", "and here's (t(w)o)", "AND HERE'S (TH(R)EE)", "oh and (four)"]
+    end
+
+    it "strips multiple commas/ pipes" do
+      content = "here's (one) ,, and here's (t(w)o)   AND HERE'S (TH(R)EE) ||||  oh and (four)"
+      expect(subject.split_on_top_level_parens_commas_and_pipes(content)).to eq ["here's (one)", "and here's (t(w)o)", "AND HERE'S (TH(R)EE)", "oh and (four)"]
+    end
+
+    it "splits even when the parentheses are directly beside each other" do
+      content = "(one)(two)(three)"
+      expect(subject.split_on_top_level_parens_commas_and_pipes(content)).to eq ["(one)", "(two)", "(three)"]
+    end
+
+    it "splits out the last segment even when it has no parentheses" do
+      content = "foo (bar), baz"
+      expect(subject.split_on_top_level_parens_commas_and_pipes(content)).to eq ["foo (bar)", "baz"]
+    end
+
+    it "does not split on a comma inside of parentheses" do
+      content = "foo (bar, baz)"
+      expect(subject.split_on_top_level_parens_commas_and_pipes(content)).to eq [content]
+    end
+
+    it "does not split on a pipe inside of parentheses" do
+      content = "foo (bar || baz)"
+      expect(subject.split_on_top_level_parens_commas_and_pipes(content)).to eq [content]
+    end
+
+    it "creates a result for each set of top-level commas" do
+      content = "one, two ,,three ,  four"
+      expect(subject.split_on_top_level_parens_commas_and_pipes(content)).to eq %w(one two three four)
+    end
+
+    it "creates a result for each set of top-level pipes" do
+      content = "one| two |three |  four"
+      expect(subject.split_on_top_level_parens_commas_and_pipes(content)).to eq %w(one two three four)
+    end
+
+    it "creates a result for each set of top-level mixed commas and pipes" do
+      content = "one, two |three ,  four,"
+      expect(subject.split_on_top_level_parens_commas_and_pipes(content)).to eq %w(one two three four)
+    end
+
+    it "does not create additional results for nested commas and pipes" do
+      content = "one (one,), and here's (t|wo) || AND HERE'S (TH(R|)EE)"
+      expect(subject.split_on_top_level_parens_commas_and_pipes(content).length).to be 3
+    end
+  end
+
+  describe ".split_types" do
+    let(:target_array) { %w(Array String).map { |type| OpenStruct.new(name: type, array: false) } }
+
+    it "breaks apart commas" do
+      expect(subject.split_types("{Array, String}")).to eq target_array
+      expect(subject.split_types("{Array ,String}")).to eq target_array
+      expect(subject.split_types("{Array , String}")).to eq target_array
+      expect(subject.split_types("{Array ,, ,String}")).to eq target_array
+    end
+
+    it "breaks apart pipes" do
+      expect(subject.split_types("{Array| String}")).to eq target_array
+      expect(subject.split_types("{Array |String}")).to eq target_array
+      expect(subject.split_types("{Array | String}")).to eq target_array
+      expect(subject.split_types("{Array || |String}")).to eq target_array
+    end
+
+    it "breaks apart spaces alone" do
+      expect(subject.split_types("{Array String}")).to eq target_array
+      expect(subject.split_types("{Array  String}")).to eq target_array
+    end
+
+    it "identifies arrays" do
+      expect(subject.split_types("{String[]}").first).to eq OpenStruct.new(name: "String", array: true)
+    end
+
+    it "converts '*' to 'Anything'" do
+      expect(subject.split_types("{*}").first).to eq OpenStruct.new(name: "Anything", array: false)
+    end
+  end
+
+  describe ".stringy_boolean" do
+    it "defaults to true for an empty string" do
+      expect(subject.stringy_boolean("")).to be true
+    end
+
+    it "defaults to false for nil" do
+      expect(subject.stringy_boolean("")).to be true
+    end
+
+    it "defaults to true a non-/false/ string" do
+      expect(subject.stringy_boolean("Anything!")).to be true
+      expect(subject.stringy_boolean("true")).to be true
+      expect(subject.stringy_boolean("We are the knights...")).to be true
+    end
+
+    it "defaults to false for a string matching /false/" do
+      expect(subject.stringy_boolean("false")).to be false
+      expect(subject.stringy_boolean("  false")).to be false
+      expect(subject.stringy_boolean("false    ")).to be false
+      expect(subject.stringy_boolean("  false   ")).to be false
+    end
+  end
+
+  describe ".join_with_smart_line_breaks" do
+    # TODO: ensure that this works:
+
+    # // @page Font Sizes
+    # // @group Helper
+    # //
+    # // The stylesheet exists as a single place to manage all font sizes. To use
+    # // a font size in your stylesheet, follow this procedure:
+    # //
+    # // 1. Add a well-named entry to the `$FONT-SIZES` map with the value set to
+    # //    the font size for that element.
+    # //
+    # // 2. If you wish to include a `font-size` declaration in your stylesheet,
+    # //    `@include font-size()`, passing it the name of the component to retrieve
+    # //    the font-size for.
+    # //
+    # // 3. Retrieving the actual font-size dimension (for example, to be used in a
+    # //    calculation to determine necessary padding) should be done by passing the
+    # //    same argument discussed above to the `font-size` *function*.
+
+    it "returns a non-array argument" do
+      non_array = "I'm not an array!"
+      expect(subject.join_with_smart_line_breaks(non_array)).to eq non_array
+    end
+
+    it "returns nil for an empty array" do
+      expect(subject.join_with_smart_line_breaks([])).to be nil
+    end
+
+    it "returns nil for an array containing only whitespace strings" do
+      expect(subject.join_with_smart_line_breaks([" "])).to be nil
+      expect(subject.join_with_smart_line_breaks([" ", "   "])).to be nil
+    end
+
+    it "identifies paragraphs as any block of text separated by at least one newline" do
+      content = subject.join_with_smart_line_breaks(content_for_fixture(:multiple_paragraphs))
+      expect(paragraph_count(content)).to eq 4
+    end
+
+    context "when there are lists" do
+      let(:content) { subject.join_with_smart_line_breaks(content_for_fixture(:lists)) }
+
+      it "separates lists by a single newline even when they are directly beside each other" do
+        expect(paragraph_count(content)).to eq 9
+      end
+
+      context "when there are nested items" do
+        let(:content) { subject.join_with_smart_line_breaks(content_for_fixture(:lists_with_nesting)) }
+
+        it "puts nested lists directly following one another on their own lines" do
+          content.sub!(/```[^`]*```\s*/, "")
+          expect(paragraph_count(content)).to eq 6
+        end
+
+        it "preserves indentation nested under lists" do
+          expect(content).to match /\n\n\s\sindented paragraph/i
+        end
+
+        it "preserves nested code block indentation" do
+          expect(content).to match /\n\n\s\s```/
+        end
+
+        it "preserves nested list indentation" do
+          expect(content).to match /\n\n\s\s\* items/i
+        end
+      end
+    end
+
+    context "when there are headers" do
+      let(:content) { subject.join_with_smart_line_breaks(content_for_fixture(:headings)) }
+
+      it "puts a newline between the header and its underline" do
+        expect(content).to match /foo\n===/i
+        expect(content).to match /bar\n---/i
+      end
+
+      it "separates paragraphs from immediately preceeding and following contents" do
+        content.gsub!(/\n[=\-]+\n/, "")
+        expect(paragraph_count(content)).to eq 8
+      end
+    end
+
+    context "when there are fenced code blocks" do
+      let(:content) do
+        subject.join_with_smart_line_breaks(content_for_fixture(:code_blocks))
+      end
+
+      let(:code_block) do
+        first_code_fence_index = content.index("```")
+        second_code_fence_index = content.index("```", first_code_fence_index + 1) + 2
+
+        content[first_code_fence_index..second_code_fence_index]
+      end
+
+      it "creates only a single line break between fenced code blocks" do
+        expect(code_block.split("\n").length).to eq 5
+      end
+
+      it "creates paragraphs when a code block is followed immediately by a paragraph" do
+        content.sub!(code_block, "")
+        paragraphs = paragraph_count(content)
+        expect(paragraphs).to eq 3
+      end
+    end
+
+    private
+
+    def content_for_fixture(fixture)
+      file = File.expand_path("../../fixtures/processors/join_with_smart_line_breaks/#{fixture}.txt", __FILE__)
+      File.read(file).split("\n")
+    end
+
+    def paragraph_count(text)
+      text.split(/\n+/).length
+    end
+  end
+
+  describe ".name_and_parenthetical" do
+    let(:basic_content) { ":checked?" }
+    let(:basic_result) { subject.name_and_parenthetical(basic_content) }
+    let(:complex_name) { "Chris Sauve" }
+    let(:complex_details) { "email: chrismsauve@gmail.com" }
+    let(:complex_content) { "#{complex_name}   (#{complex_details})" }
+
+    it "sets the :name of the returned hash to the non-parenthetical part of the passed string if no custom name is passed" do
+      expect(basic_result[:name]).to eq basic_content
+      expect(subject.name_and_parenthetical(complex_content)[:name]).to eq complex_name
+    end
+
+    it "sets the custom name of the returned hash to the passed non-parenthetical string" do
+      custom_name = :setter
+      processed = subject.name_and_parenthetical(basic_content, custom_name)
+      expect(processed[custom_name]).to eq basic_content
+    end
+
+    it "joins the parenthetical results to the name" do
+      parenthetical = {
+        foo: "bar",
+        bar: "baz"
+      }
+      parenthetical_as_string = ""
+      parenthetical.to_a.each do |k, v|
+        parenthetical_as_string << "#{k} : #{v}, "
+      end
+      parenthetical_as_string.sub(/,\s$/, "")
+
+      parenthetical[:name] = basic_content
+
+      content = "#{basic_content} (#{parenthetical_as_string})"
+      expect(subject.name_and_parenthetical(content)).to eq parenthetical
+    end
+
+    it "passes along the default to the parenthetical" do
+      default_key, default_val = :value, "true"
+      content = "#{basic_content} (#{default_val})"
+      expect(subject.name_and_parenthetical(content, :name, default_key)[default_key]).to eq default_val
+    end
+  end
+
+  describe ".parenthetical_options" do
+    let(:default) { :foo }
+    let(:value) { "bar" }
+    let(:simple_result) {
+      result = {}
+      result[default] = value
+      result
+    }
+
+    it "associates a default value when no key-value pairs are found" do
+      expect(subject.parenthetical_options(value, default)).to eq simple_result
+    end
+
+    it "creates a non-default key even if it is the only one provided" do
+      non_default = :bar
+      non_default_value = "baz"
+      non_default_result = {}
+      non_default_result[non_default] = non_default_value
+      expect(subject.parenthetical_options("(#{non_default}: #{non_default_value})", default)).to eq non_default_result
+    end
+
+    it "creates a single key value pair" do
+      expect(subject.parenthetical_options("#{default}: #{value}")).to eq simple_result
+      expect(subject.parenthetical_options("#{default}:   #{value}")).to eq simple_result
+      expect(subject.parenthetical_options("#{default} : #{value}")).to eq simple_result
+      expect(subject.parenthetical_options("#{default}   :  #{value}")).to eq simple_result
+    end
+
+    it "creates multiple key value pairs" do
+      key_2 = :bar
+      val_2 = "baz"
+      pair_1 = "#{default}: #{value}"
+      pair_2 = "#{key_2}: #{val_2}"
+      simple_result[key_2] = val_2
+
+      expect(subject.parenthetical_options("#{pair_1}, #{pair_2}")).to eq simple_result
+      expect(subject.parenthetical_options("#{pair_1},   #{pair_2}")).to eq simple_result
+      expect(subject.parenthetical_options("#{pair_1} ,#{pair_2}")).to eq simple_result
+      expect(subject.parenthetical_options("#{pair_1}   ,#{pair_2}")).to eq simple_result
+      expect(subject.parenthetical_options("#{pair_1} , #{pair_2}")).to eq simple_result
+      expect(subject.parenthetical_options("#{pair_1}   ,  #{pair_2}")).to eq simple_result
+    end
+
+    describe "multi-word keys" do
+      let(:key_string) { "Activate with" }
+      let(:key) { key_string.downcase.gsub(/\s+/, "_").to_sym }
+      let(:result) {
+        result = {}
+        result[key] = key_string
+        result
+      }
+
+      it "creates key-value pairs by symbolizing spaced keys" do
+        expect(subject.parenthetical_options("#{key_string}: #{key_string}")).to eq result
+      end
+
+      it "creates multiple key-value pairs that include multi-word keys" do
+        result.merge!(simple_result)
+        expect(subject.parenthetical_options("#{default}: #{value}  , #{key_string} : #{key_string}")).to eq result
+      end
+    end
+
+    it "creates a default key when a non-default key-value pair is also provided" do
+      key_2 = :bar
+      val_2 = 'baz'
+      simple_result[key_2] = val_2
+      content = "#{value}, #{key_2}: #{val_2}"
+
+      expect(subject.parenthetical_options(content, default)).to eq simple_result
+    end
+  end
+
+  describe ".ensure_valid_demo_type" do
+    it "allows one of the included demo types" do
+      Docks::Types::Demo.constants.each do |const|
+        demo_type = Docks::Types::Demo.const_get(const)
+        expect(subject.ensure_valid_demo_type(demo_type)).to eq demo_type
+      end
+    end
+
+    it "returns the default type when none of the included demo types are provided" do
+      expect(subject.ensure_valid_demo_type("invalid")).to be Docks::Types::Demo::DEFAULT
+    end
+  end
+
+  describe ".multiline_description" do
+    let(:complex_content) { ['First content', 'Second content', 'Third content'] }
+
+    it "ruses the entirety of the original content as the description if the yielded block did not return a Hash" do
+      content = ["Hello!"]
+      final_content = subject.multiline_description(content) { |content| content }
+      expect(final_content).to eq description: content.first
+    end
+
+    it "uses the entirety of the original content as the description if no block was passed" do
+      content = ["Hello!"]
+      final_content = subject.multiline_description(content)
+      expect(final_content).to eq description: content.first
+    end
+
+    it "passes the first item in the array to the passed block" do
+      subject.multiline_description(complex_content) do |content|
+        expect(content).to eq complex_content.first
+      end
+    end
+
+    it "preserves the hash returned by the block in the end result" do
+      key = :name
+      value = nil
+      result = subject.multiline_description(complex_content) do |content|
+        intermediate = {}
+        intermediate[key] = value = content
+        intermediate
+      end
+
+      expect(result[:name]).to eq value
+    end
+
+    it "joins the second thru last items of the passed array as the description" do
+      result = subject.multiline_description(complex_content) do |content|
+        { foo: content }
+      end
+
+      expect(result[:description]).to eq subject.join_with_smart_line_breaks(["Second content", "Third content"])
+    end
+
+    it "joins the description portion identified in the block to the rest of the description" do
+      result = subject.multiline_description(complex_content) do |content|
+        content = content.split(" ")
+        intermediate = { foo: content[0] }
+        intermediate[:description] = content[1]
+        intermediate
+      end
+
+      expect(result[:description]).to eq subject.join_with_smart_line_breaks(["content", "Second content", "Third content"])
+    end
+  end
+
+  describe ".code_block_with_language_and_description" do
+    let(:description) { "The description." }
+    let(:language) { "scss" }
+    let(:code) { [".foo {", "  content: 'bar';", "}"] }
+
+    it "uses the passed language if one is provided" do
+      expect(subject.code_block_with_language_and_description(code.unshift(language))[:language]).to eq language
+    end
+
+    it "has a nil description when only the language is provided" do
+      expect(subject.code_block_with_language_and_description(code.unshift(language))[:description]).to be nil
+    end
+
+    it "uses the description and language when provided" do
+      result = subject.code_block_with_language_and_description(code.unshift("#{language} - #{description}"))
+      expect(result[:description]).to eq description
+      expect(result[:language]).to eq language
+    end
+
+    it "assigns the entire passed content to the code attribute when no language is provided" do
+      expect(subject.code_block_with_language_and_description(code)[:code]).to eq code.join("\n")
+    end
+
+    it "assigns the second thru last array items to the code attribute when a valid language is provided" do
+      expect(subject.code_block_with_language_and_description(code.unshift(language))[:code]).to eq code.join("\n")
+    end
+
+    it "assigns the second thru last array items to the code attribute when a valid language and description is provided" do
+      result = subject.code_block_with_language_and_description(code.unshift("#{language} - #{description}"))
+      expect(result[:code]).to eq code.join("\n")
+    end
+  end
+end

data/spec/lib/renderers/base_renderer_spec.rb

@@ -0,0 +1,122 @@
+require "spec_helper"
+
+describe Docks::Renderers::Base do
+  let(:fixture_dir) { File.expand_path("../../../fixtures/renderers", __FILE__) }
+  let(:template_dir) { Docks.config.templates }
+  let(:partials_dir) { File.join(template_dir, "partials") }
+  let(:layouts_dir) { File.join(template_dir, "layouts") }
+
+  subject { Docks::Renderers::Base.new }
+
+  around do |example|
+    Docks.configure do |config|
+      config.root = fixture_dir
+      config.templates = "templates"
+    end
+
+    example.run
+
+    subject.send(:clean)
+  end
+
+  describe "#normalize_content_and_locals" do
+    it "looks for a template if the full path is given" do
+      file = File.join(template_dir, "template.html.erb")
+      expect(subject.send(:normalize_content_and_locals, file).first).to eq File.read(file)
+    end
+
+    it "looks for a template in the root directory first" do
+      expect(subject.send(:normalize_content_and_locals, "template").first).to eq File.read(File.join(template_dir, "template.html.erb"))
+    end
+
+    it "looks for a template in a subdirectory of root" do
+      expect(subject.send(:normalize_content_and_locals, "partials/template").first).to eq File.read(File.join(partials_dir, "template.html.erb"))
+    end
+
+    it "looks for a template in the root directory if the template key is used" do
+      expect(subject.send(:normalize_content_and_locals, template: "template").first).to eq File.read(File.join(template_dir, "template.html.erb"))
+    end
+
+    it "looks for a template in the partials directory if none exists in the root directory" do
+      expect(subject.send(:normalize_content_and_locals, "partial").first).to eq File.read(File.join(partials_dir, "partial.html.erb"))
+    end
+
+    it "looks for a template in the partials directory if the partial key is used" do
+      expect(subject.send(:normalize_content_and_locals, partial: "template").first).to eq File.read(File.join(partials_dir, "template.html.erb"))
+    end
+
+    it "renders a template with a leading underscore" do
+      expect(subject.send(:normalize_content_and_locals, "leading_underscore").first).to eq File.read(File.join(partials_dir, "_leading_underscore.html.erb"))
+    end
+
+    it "renders a template in a subdirectory of partial" do
+      expect(subject.send(:normalize_content_and_locals, partial: "more/subdirectory").first).to eq File.read(File.join(partials_dir, "more/_subdirectory.html.erb"))
+      expect(subject.send(:normalize_content_and_locals, "more/subdirectory").first).to eq File.read(File.join(partials_dir, "more/_subdirectory.html.erb"))
+    end
+
+    it "finds a layout file in a layout directory" do
+      expect(subject.send(:normalize_content_and_locals, template: "template", layout: "application")[1]).to eq File.read(File.join(layouts_dir, "application.html.erb"))
+    end
+
+    it "finds a layout file in a subdirectory of the layout directory" do
+      expect(subject.send(:normalize_content_and_locals, template: "template", layout: "more/subdirectory")[1]).to eq File.read(File.join(layouts_dir, "more/subdirectory.html.erb"))
+    end
+
+    it "returns inline content" do
+      inline_content = "<p><%= foo %></p>"
+      expect(subject.send(:normalize_content_and_locals, inline: inline_content).first).to eq inline_content
+    end
+
+    it "caches the content of template files" do
+      template = "template"
+      expect(File).to receive(:read).once.and_call_original
+      subject.send(:normalize_content_and_locals, template)
+      subject.send(:normalize_content_and_locals, template)
+    end
+
+    it "provides an empty hash as locals when none are provided" do
+      expect(subject.send(:normalize_content_and_locals, "template").last).to eq Hash.new
+      expect(subject.send(:normalize_content_and_locals, partial: "template").last).to eq Hash.new
+    end
+
+    it "provides the second argument as locals" do
+      locals = { foo: "bar" }
+      expect(subject.send(:normalize_content_and_locals, "template", locals).last).to eq locals
+    end
+
+    it "provides the locals key of the first argument as locals" do
+      locals = { foo: "bar" }
+      expect(subject.send(:normalize_content_and_locals, partial: "template", locals: locals).last).to eq locals
+    end
+
+    it "separates the layout and locals from the second argument" do
+      locals = { foo: "bar" }
+      result = subject.send(:normalize_content_and_locals, "template", layout: "application", locals: locals)
+      expect(result[1]).to eq File.read(File.join(layouts_dir, "application.html.erb"))
+      expect(result.last).to eq locals
+    end
+
+    it "throws an error when no matching template is found" do
+      expect { subject.send(:normalize_content_and_locals, "foo") }.to raise_error(Docks::NoTemplateError)
+    end
+
+    it "throws an error when no matching layout is found" do
+      expect { subject.send(:normalize_content_and_locals, template: "template", layout: "foo") }.to raise_error(Docks::NoTemplateError)
+    end
+
+    it "uses no layout when the layout argument is false" do
+      expect(subject.send(:normalize_content_and_locals, template: "template", layout: false)[1]).to be nil
+    end
+  end
+
+  describe "#ivars=" do
+    it "creates an instance variable for each of the passed hash keys" do
+      ivars = { foo: "bar", baz: "qux" }
+      subject.ivars = ivars
+
+      ivars.each do |ivar, value|
+        expect(subject.instance_variable_get("@#{ivar}".to_sym)).to eq value
+      end
+    end
+  end
+end