docks_app 0.0.1

data/spec/lib/renderers/common_features/helperable_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+describe Docks::Renderers::Common::Helperable do
+  subject { Class.new { include Docks::Renderers::Common::Helperable }.new }
+
+  it "includes all passed helpers" do
+    module Module1; end
+    module Module2; end
+
+    expect(subject).to receive(:extend).with Module1
+    expect(subject).to receive(:extend).with Module2
+
+    subject.helpers Module1, Module2
+  end
+
+  it "includes all modules in passed files" do
+    helper_file = File.expand_path("../../../../fixtures/renderers/helpers.rb", __FILE__)
+    require helper_file
+    subject.helpers helper_file
+
+    (Helpers.instance_methods(false) + Helpers2.instance_methods(false)).each do |meth|
+      expect(subject).to respond_to meth
+    end
+  end
+
+  it "doesn't include helper files that don't exist" do
+    expect(File).not_to receive(:read).with "foo.txt"
+    subject.helpers "foo.txt"
+  end
+end

data/spec/lib/renderers/erb_renderer_spec.rb

@@ -0,0 +1,119 @@
+require "spec_helper"
+
+describe Docks::Renderers::ERB do
+  subject { Docks::Renderers::ERB.new }
+
+  after :each do
+    subject.instance_variable_set(:@content_blocks, Hash.new)
+    subject.send(:clean)
+  end
+
+  describe "#render" do
+    it "renders ERB" do
+      erb_template = <<-HTML
+        <ul>
+          <% 5.times do |i| %>
+            <li>Item <%= i + 1 %></li>
+          <% end %>
+        </ul>
+      HTML
+
+      expect(subject.render(inline: erb_template).gsub(/\s/, "")).to eq File.read(File.expand_path("../../../fixtures/renderers/html_output.html", __FILE__)).gsub(/\s/, "")
+    end
+
+    it "captures ERB" do
+      subject.helpers File.expand_path("../../../fixtures/renderers/helpers.rb", __FILE__)
+
+      erb_template = <<-HTML
+        <% helper4 do %>
+          bar
+        <% end %>
+      HTML
+
+      expect(subject.render(inline: erb_template).strip).to eq "foo bar!"
+    end
+
+    it "captures ERB with arguments" do
+      subject.helpers File.expand_path("../../../fixtures/renderers/helpers.rb", __FILE__)
+      expect(subject.render(inline: "<% helper6('bar') do |val| %>\n  foo <%= val %>\n<% end %>").strip).to eq "foo bar"
+    end
+
+    it "renders a template with the passed locals" do
+      expect(subject.render(inline: "<%= foo %>", locals: { foo: "bar" }).strip).to eq "bar"
+    end
+
+    it "throws an error when a method is not available" do
+      expect { subject.render(inline: "<%= foo_bar_baz %>") }.to raise_error(NameError)
+      expect { subject.render(inline: "<%= foo_bar_baz %>", locals: { foo: "bar" }) }.to raise_error(NameError)
+    end
+
+    it "renders a template with access to the same helpers as the base template" do
+      subject.helpers File.expand_path("../../../fixtures/renderers/helpers.rb", __FILE__)
+      expect(subject.render(inline: "<%= helper %>\n<%= helper3 %>").strip).to eq "foo bar baz\nBAR"
+    end
+
+    it "allows helpers to use classes in their scope" do
+      subject.helpers File.expand_path("../../../fixtures/renderers/helpers.rb", __FILE__)
+      expect(subject.render(inline: "<%= helper5 %>").strip).to eq "thing one"
+    end
+
+    it "allows helpers to be called from within capture blocks" do
+      subject.helpers File.expand_path("../../../fixtures/renderers/helpers.rb", __FILE__)
+      expect(subject.render(inline: "<% helper4 do %>\n  <%= render(inline: 'foo') %>\n<% end %>").strip).to eq "foo foo!"
+    end
+
+    it "doesn't preserve locals between template renders" do
+      erb_template = "<%= foo %>"
+
+      subject.render(inline: erb_template, locals: { foo: "bar" })
+      expect(subject.render(inline: erb_template, locals: { foo: "baz" }).strip).to eq "baz"
+      expect(subject.render(inline: erb_template, locals: { foo: "" }).strip).to eq ""
+    end
+
+    context "when there's a layout" do
+      it "allows setting a layout file that is rendered around the main file" do
+        layout = "Foo <%= yield.strip %> baz"
+        expect(Docks::Templates).to receive(:search_for_template).with(layout, anything).and_return(layout)
+        expect(File).to receive(:read).with(layout).and_return(layout)
+
+        expect(subject.render(inline: "bar", layout: layout).strip).to eq "Foo bar baz"
+      end
+
+      describe "#content_for" do
+        it "allows setting the content for multiple yielded blocks using #content_for" do
+          layout = "Foo <%= yield(:first).strip %> <%= yield(:second).strip %>."
+          expect(Docks::Templates).to receive(:search_for_template).with(layout, anything).and_return(layout)
+          expect(File).to receive(:read).with(layout).and_return(layout)
+
+          expect(subject.render(inline: "<% content_for(:first) do %>bar<% end %>\n<% content_for(:second) do %>baz<% end %>", layout: layout).strip).to eq "Foo bar baz."
+        end
+
+        it "allows both named and a default content block" do
+          layout = "Foo <%= yield(:first).strip %> <%= yield.strip %>."
+          expect(Docks::Templates).to receive(:search_for_template).with(layout, anything).and_return(layout)
+          expect(File).to receive(:read).with(layout).and_return(layout)
+
+          expect(subject.render(inline: "<% content_for(:first) do %>bar<% end %>\nbaz", layout: layout).strip).to eq "Foo bar baz."
+        end
+
+        it "yields do a given content block when no block is given" do
+          layout = "Foo <%= content_for(:first).strip %> <%= yield.strip %>."
+          expect(Docks::Templates).to receive(:search_for_template).with(layout, anything).and_return(layout)
+          expect(File).to receive(:read).with(layout).and_return(layout)
+
+          expect(subject.render(inline: "<% content_for(:first) do %>bar<% end %>\nbaz", layout: layout).strip).to eq "Foo bar baz."
+        end
+      end
+
+      describe "#content_for?" do
+        it "identifies whether a block has been given" do
+          layout = "first? <%= content_for?(:first).to_s %>, second? <%= content_for?(:second).to_s %>"
+          expect(Docks::Templates).to receive(:search_for_template).with(layout, anything).and_return(layout)
+          expect(File).to receive(:read).with(layout).and_return(layout)
+
+          expect(subject.render(inline: "<% content_for(:first) do %>bar<% end %>", layout: layout).strip).to eq "first? true, second? false"
+        end
+      end
+    end
+  end
+end

data/spec/lib/renderers/haml_renderer_spec.rb

@@ -0,0 +1,103 @@
+require "spec_helper"
+
+describe Docks::Renderers::Haml do
+  subject { Docks::Renderers::Haml.new }
+
+  after :each do
+    subject.instance_variable_set(:@content_blocks, Hash.new)
+    subject.send(:clean)
+  end
+
+  describe "#render" do
+    it "renders Haml" do
+      haml_template = "%ul\n  - 5.times do |i|\n    %li Item \#{i + 1}"
+      expect(subject.render(inline: haml_template).gsub(/\s/, "")).to eq File.read(File.expand_path("../../../fixtures/renderers/html_output.html", __FILE__)).gsub(/\s/, "")
+    end
+
+    it "captures Haml" do
+      subject.helpers File.expand_path("../../../fixtures/renderers/helpers.rb", __FILE__)
+      expect(subject.render(inline: "= helper4 do\n  bar").strip).to eq "foo bar!"
+    end
+
+    it "captures Haml with arguments" do
+      subject.helpers File.expand_path("../../../fixtures/renderers/helpers.rb", __FILE__)
+      expect(subject.render(inline: "= helper6('bar') do |val|\n  foo \#{val}").strip).to eq "foo bar"
+    end
+
+    it "renders a template with the passed locals" do
+      expect(subject.render(inline: "= foo", locals: { foo: "bar" }).strip).to eq "bar"
+    end
+
+    it "renders a template with access to the same helpers as the base template" do
+      subject.helpers File.expand_path("../../../fixtures/renderers/helpers.rb", __FILE__)
+
+      expect(subject.render(inline: "= helper\n= helper3").strip).to eq "foo bar baz\nBAR"
+    end
+
+    it "allows helpers to use classes in their scope" do
+      subject.helpers File.expand_path("../../../fixtures/renderers/helpers.rb", __FILE__)
+
+      expect(subject.render(inline: "= helper5").strip).to eq "thing one"
+    end
+
+    it "allows helpers to be called from within capture blocks" do
+      subject.helpers File.expand_path("../../../fixtures/renderers/helpers.rb", __FILE__)
+
+      expect(subject.render(inline: "= helper4 do\n  = render(inline: 'foo')").strip).to eq "foo foo!"
+    end
+
+    it "doesn't preserve locals between template renders" do
+      haml_template = "= foo"
+
+      subject.render(inline: haml_template, locals: { foo: "bar" })
+      expect(subject.render(inline: haml_template, locals: { foo: "baz" }).strip).to eq "baz"
+      expect(subject.render(inline: haml_template, locals: { foo: "" }).strip).to eq ""
+    end
+
+    context "when there's a layout" do
+      it "allows setting a layout file that is rendered around the main file" do
+        layout = "Foo \#{yield.strip} baz"
+        expect(Docks::Templates).to receive(:search_for_template).with(layout, anything).and_return(layout)
+        expect(File).to receive(:read).with(layout).and_return(layout)
+
+        expect(subject.render(inline: "bar", layout: layout).strip).to eq "Foo bar baz"
+      end
+
+      describe "#content_for" do
+        it "allows setting the content for multiple yielded blocks using #content_for" do
+          layout = "Foo \#{yield(:first).strip} \#{yield(:second).strip}."
+          expect(Docks::Templates).to receive(:search_for_template).with(layout, anything).and_return(layout)
+          expect(File).to receive(:read).with(layout).and_return(layout)
+
+          expect(subject.render(inline: "- content_for(:first) do\n  bar\n\n- content_for(:second) do\n  baz", layout: layout).strip).to eq "Foo bar baz."
+        end
+
+        it "allows both named and a default content block" do
+          layout = "Foo \#{yield(:first).strip} \#{yield.strip}."
+          expect(Docks::Templates).to receive(:search_for_template).with(layout, anything).and_return(layout)
+          expect(File).to receive(:read).with(layout).and_return(layout)
+
+          expect(subject.render(inline: "- content_for(:first) do\n  bar\n\nbaz", layout: layout).strip).to eq "Foo bar baz."
+        end
+
+        it "yields do a given content block when no block is given" do
+          layout = "Foo \#{content_for(:first).strip} \#{yield.strip}."
+          expect(Docks::Templates).to receive(:search_for_template).with(layout, anything).and_return(layout)
+          expect(File).to receive(:read).with(layout).and_return(layout)
+
+          expect(subject.render(inline: "- content_for(:first) do\n  bar\n\nbaz", layout: layout).strip).to eq "Foo bar baz."
+        end
+      end
+
+      describe "#content_for?" do
+        it "identifies whether a block has been given" do
+          layout = "first? \#{content_for?(:first).to_s}, second? \#{content_for?(:second).to_s}"
+          expect(Docks::Templates).to receive(:search_for_template).with(layout, anything).and_return(layout)
+          expect(File).to receive(:read).with(layout).and_return(layout)
+
+          expect(subject.render(inline: "- content_for(:first) do\n  bar", layout: layout).strip).to eq "first? true, second? false"
+        end
+      end
+    end
+  end
+end

data/spec/lib/renderers/slim_renderer_spec.rb

@@ -0,0 +1,103 @@
+require "spec_helper"
+
+describe Docks::Renderers::Slim do
+  subject { Docks::Renderers::Slim.new }
+
+  after :each do
+    subject.instance_variable_set(:@content_blocks, Hash.new)
+    subject.send(:clean)
+  end
+
+  describe "#render" do
+    it "renders Slim" do
+      slim_template = "ul\n  - 5.times do |i|\n    li Item \#{i + 1}"
+      expect(subject.render(inline: slim_template).gsub(/\s/, "")).to eq File.read(File.expand_path("../../../fixtures/renderers/html_output.html", __FILE__)).gsub(/\s/, "")
+    end
+
+    it "captures Slim" do
+      subject.helpers File.expand_path("../../../fixtures/renderers/helpers.rb", __FILE__)
+      expect(subject.render(inline: "= helper4 do\n  | bar").strip).to eq "foo bar!"
+    end
+
+    it "captures Slim with arguments" do
+      subject.helpers File.expand_path("../../../fixtures/renderers/helpers.rb", __FILE__)
+      expect(subject.render(inline: "= helper6('bar') do |val|\n  | foo \#{val}").strip).to eq "foo bar"
+    end
+
+    it "renders a template with the passed locals" do
+      expect(subject.render(inline: "= foo", locals: { foo: "bar" }).strip).to eq "bar"
+    end
+
+    it "renders a template with access to the same helpers as the base template" do
+      subject.helpers File.expand_path("../../../fixtures/renderers/helpers.rb", __FILE__)
+
+      expect(subject.render(inline: "== helper\n==< helper2").strip).to eq "foo bar baz baz bar foo"
+    end
+
+    it "allows helpers to use classes in their scope" do
+      subject.helpers File.expand_path("../../../fixtures/renderers/helpers.rb", __FILE__)
+
+      expect(subject.render(inline: "= helper5").strip).to eq "thing one"
+    end
+
+    it "allows helpers to be called from within capture blocks" do
+      subject.helpers File.expand_path("../../../fixtures/renderers/helpers.rb", __FILE__)
+
+      expect(subject.render(inline: "= helper4 do\n  = render(inline: '| foo')").strip).to eq "foo foo!"
+    end
+
+    it "doesn't preserve locals between template renders" do
+      slim_template = "= foo"
+
+      subject.render(inline: slim_template, locals: { foo: "bar" })
+      expect(subject.render(inline: slim_template, locals: { foo: "baz" }).strip).to eq "baz"
+      expect(subject.render(inline: slim_template, locals: { foo: "" }).strip).to eq ""
+    end
+
+    context "when there's a layout" do
+      it "allows setting a layout file that is rendered around the main file" do
+        layout = "| Foo \#{yield.strip} baz"
+        expect(Docks::Templates).to receive(:search_for_template).with(layout, anything).and_return(layout)
+        expect(File).to receive(:read).with(layout).and_return(layout)
+
+        expect(subject.render(inline: "| bar", layout: layout).strip).to eq "Foo bar baz"
+      end
+
+      describe "#content_for" do
+        it "allows setting the content for multiple yielded blocks using #content_for" do
+          layout = "| Foo \#{yield(:first).strip} \#{yield(:second).strip}."
+          expect(Docks::Templates).to receive(:search_for_template).with(layout, anything).and_return(layout)
+          expect(File).to receive(:read).with(layout).and_return(layout)
+
+          expect(subject.render(inline: "= content_for(:first) do\n  | bar\n\n= content_for(:second) do\n  | baz", layout: layout).strip).to eq "Foo bar baz."
+        end
+
+        it "allows both named and a default content block" do
+          layout = "| Foo \#{yield(:first).strip} \#{yield.strip}."
+          expect(Docks::Templates).to receive(:search_for_template).with(layout, anything).and_return(layout)
+          expect(File).to receive(:read).with(layout).and_return(layout)
+
+          expect(subject.render(inline: "= content_for(:first) do\n  | bar\n| baz", layout: layout).strip).to eq "Foo bar baz."
+        end
+
+        it "yields do a given content block when no block is given" do
+          layout = "| Foo \#{content_for(:first).strip} \#{yield.strip}."
+          expect(Docks::Templates).to receive(:search_for_template).with(layout, anything).and_return(layout)
+          expect(File).to receive(:read).with(layout).and_return(layout)
+
+          expect(subject.render(inline: "= content_for(:first) do\n  | bar\n\n| baz", layout: layout).strip).to eq "Foo bar baz."
+        end
+      end
+
+      describe "#content_for?" do
+        it "identifies whether a block has been given" do
+          layout = "| first? \#{content_for?(:first).to_s}, second? \#{content_for?(:second).to_s}"
+          expect(Docks::Templates).to receive(:search_for_template).with(layout, anything).and_return(layout)
+          expect(File).to receive(:read).with(layout).and_return(layout)
+
+          expect(subject.render(inline: "= content_for(:first) do\n  | bar", layout: layout).strip).to eq "first? true, second? false"
+        end
+      end
+    end
+  end
+end

data/spec/lib/symbol_sources/jquery_symbol_source_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe Docks::SymbolSources::JQuery do
+  subject { described_class.instance }
+
+  describe "#recognizes?" do
+    it "doesn't recognize a language that isn't a scripting one" do
+      Docks::Languages.register_bundled_languages
+      expect(subject.recognizes?("jQuery", language: "js")).to be true
+      expect(subject.recognizes?("jQuery", language: "coffee")).to be true
+      expect(subject.recognizes?("jQuery", language: "css")).to be false
+    end
+
+    it "identifies a jQuery object" do
+      expect(subject.recognizes?("jQuery")).to be true
+      expect(subject.recognizes?("jquery")).to be true
+    end
+  end
+
+  describe "#path_for" do
+    it "creates a path to jQuery API page" do
+      expect(subject.path_for("jQuery")).to eq "http://api.jquery.com/"
+    end
+  end
+end

data/spec/lib/symbol_sources/mdn_symbol_source_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe Docks::SymbolSources::MDN do
+  subject { described_class.instance }
+
+  describe "#recognizes?" do
+    it "doesn't recognize a language that isn't a scripting one" do
+      Docks::Languages.register_bundled_languages
+      expect(subject.recognizes?("Object", language: "js")).to be true
+      expect(subject.recognizes?("Object", language: "coffee")).to be true
+      expect(subject.recognizes?("Object", language: "css")).to be false
+    end
+
+    it "identifies a symbol that is a global object" do
+      expect(subject.recognizes?("Object")).to be true
+      expect(subject.recognizes?("object")).to be true
+      expect(subject.recognizes?("Array")).to be true
+      expect(subject.recognizes?("String")).to be true
+      expect(subject.recognizes?("Iterator")).to be true
+      expect(subject.recognizes?("Set")).to be true
+    end
+
+    it "identifies a symbol that is a web API object" do
+      expect(subject.recognizes?("HTMLElement")).to be true
+      expect(subject.recognizes?("htmlelement")).to be true
+      expect(subject.recognizes?("Blob")).to be true
+      expect(subject.recognizes?("NodeList")).to be true
+    end
+  end
+
+  describe "#path_for" do
+    it "creates a path to the MDN reference for a global object" do
+      expect(subject.path_for("Object")).to eq "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object"
+    end
+
+    it "creates a path to the MDN reference for a web API object" do
+      expect(subject.path_for("NodeList")).to eq "https://developer.mozilla.org/docs/Web/API/NodeList"
+    end
+  end
+end

data/spec/lib/symbol_sources/sass_symbol_source_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+describe Docks::SymbolSources::Sass do
+  subject { described_class.instance }
+
+  describe "#recognizes?" do
+    it "only recognizes Sass" do
+      Docks::Languages.register_bundled_languages
+      expect(subject.recognizes?("Color", language: "sass")).to be true
+      expect(subject.recognizes?("Color", language: "scss")).to be true
+      expect(subject.recognizes?("Color", language: "css")).to be false
+      expect(subject.recognizes?("Color", language: "js")).to be false
+    end
+
+    it "identifies a symbol that a Sass value object" do
+      expect(subject.recognizes?("arglist")).to be true
+      expect(subject.recognizes?("color")).to be true
+      expect(subject.recognizes?("list")).to be true
+      expect(subject.recognizes?("map")).to be true
+      expect(subject.recognizes?("null")).to be true
+      expect(subject.recognizes?("number")).to be true
+      expect(subject.recognizes?("string")).to be true
+    end
+
+    it "identifies the function symbol" do
+      expect(subject.recognizes?("function")).to be true
+    end
+  end
+
+  describe "#path_for" do
+    it "creates a path to Sass values" do
+      expect(subject.path_for("color")).to eq "http://sass-lang.com/documentation/Sass/Script/Value/Color.html"
+    end
+
+    it "creates a path to Sass functions" do
+      expect(subject.path_for("Function")).to eq "http://sass-lang.com/documentation/Sass/Script/Script/Functions.html"
+    end
+  end
+end

data/spec/lib/symbol_sources_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe Docks::SymbolSources do
+  subject { described_class }
+
+  before(:each) do
+    Docks::Languages.register_bundled_languages
+  end
+
+  describe "#path_for" do
+    it "returns nil when no sources recognize a symbol" do
+      expect(subject.path_for("foo")).to be nil
+    end
+
+    it "returns the path from a symbol source that recognizes the symbol" do
+      expect(subject.path_for("jquery")).to eq Docks::SymbolSources::JQuery.instance.path_for("jquery")
+    end
+  end
+end

data/spec/lib/tags/access_tag_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+describe Docks::Tags::Access do
+  subject { Docks::Tags::Access.instance }
+
+  it "does not allow multiline content" do
+    expect(subject.multiline?).to be false
+  end
+
+  it "only allows one tag per block" do
+    expect(subject.multiple_allowed?).to be false
+  end
+
+  describe "#process" do
+    let(:symbol) { Docks::Containers::Symbol.new }
+
+    it "allows one of the included access types" do
+      Docks::Types::Access.constants.each do |const|
+        access_type = Docks::Types::Access.const_get(const)
+        symbol.access = access_type
+        subject.process(symbol)
+        expect(symbol.access).to eq access_type
+      end
+    end
+
+    it "sets the access to public for any non-recognized access type" do
+      symbol.access = "foo"
+      subject.process(symbol)
+      expect(symbol.access).to eq Docks::Types::Access::PUBLIC
+    end
+  end
+end

data/spec/lib/tags/activate_with_tag_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe Docks::Tags::ActivateWith do
+  subject { Docks::Tags::ActivateWith.instance }
+
+  it "does not allow multiline content" do
+    expect(subject.multiline?).to be false
+  end
+
+  it "allows multiple tags per block" do
+    expect(subject.multiple_allowed?).to be true
+  end
+
+  describe "#process" do
+    let(:symbol) { Docks::Containers::Symbol.new }
+
+    it "breaks apart activate_withs on commas, spaces and pipes" do
+      activate_withs = "foo | bar, baz qux"
+      symbol[subject.name] = activate_withs
+      subject.process(symbol)
+      expect(symbol[subject.name]).to eq Docks::Processors.split_on_commas_spaces_and_pipes(activate_withs)
+    end
+
+    it "joins together multiple lines of activate_withs" do
+      activate_withs = ["foo | bar, baz qux", "lux fuz"]
+      symbol[subject.name] = activate_withs.dup
+      subject.process(symbol)
+      expect(symbol[subject.name]).to eq activate_withs.map { |with| Docks::Processors.split_on_commas_spaces_and_pipes(with) }.flatten
+    end
+  end
+end

data/spec/lib/tags/active_tag_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe Docks::Tags::Active do
+  subject { Docks::Tags::Active.instance }
+
+  it "does not allow multiline content" do
+    expect(subject.multiline?).to be false
+  end
+
+  it "only allows one tag per block" do
+    expect(subject.multiple_allowed?).to be false
+  end
+
+  describe "#process" do
+    it "boolean-ifies the parsed value" do
+      symbol = Docks::Containers::Symbol.new
+      symbol[subject.name] = "false"
+
+      expect(subject).to receive(:stringy_boolean).and_call_original
+      subject.process(symbol)
+      expect(symbol[subject.name]).to be false
+    end
+  end
+end

data/spec/lib/tags/alias_tag_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe Docks::Tags::Alias do
+  subject { Docks::Tags::Alias.instance }
+
+  it "does not allow multiline content" do
+    expect(subject.multiline?).to be false
+  end
+
+  it "allows multiple tags per block" do
+    expect(subject.multiple_allowed?).to be true
+  end
+
+  describe "#process" do
+    let(:symbol) { Docks::Containers::Symbol.new }
+
+    it "breaks apart aliases on commas, spaces and pipes" do
+      aliases = "foo | bar, baz qux"
+      symbol[subject.name] = aliases
+      subject.process(symbol)
+      expect(symbol[subject.name]).to eq Docks::Processors.split_on_commas_spaces_and_pipes(aliases)
+    end
+
+    it "joins together multiple lines of aliases" do
+      aliases = ["foo | bar, baz qux", "lux fuz"]
+      symbol[subject.name] = aliases.dup
+      subject.process(symbol)
+      expect(symbol[subject.name]).to eq aliases.map { |alias_line| Docks::Processors.split_on_commas_spaces_and_pipes(alias_line) }.flatten
+    end
+  end
+end