docks_app 0.0.1

data/spec/lib/group_spec.rb

@@ -0,0 +1,151 @@
+require "spec_helper"
+
+describe Docks do
+  subject { described_class }
+
+  describe ".pattern_id" do
+    it "returns a nil identifier when a non-string is passed" do
+      expect(subject.pattern_id(:nothing_to_see_here)).to be nil
+    end
+
+    it "uses only the extension-less, base file name" do
+      expect(subject.pattern_id("foo/bar/baz/button.min.css")).to eq subject.pattern_id("button")
+    end
+
+    it "strips leading underscores" do
+      expect(subject.pattern_id("_checkbox.html.erb")).to eq "checkbox"
+    end
+
+    it "normalizes dashes and underscores" do
+      expect(subject.pattern_id("foo_bar_baz")).to eq subject.pattern_id("foo-bar-baz")
+    end
+  end
+
+  describe ".pattern_id=" do
+    it "allows the pattern identification method to be redefined" do
+      built_in_identifier = subject.instance_variable_get(:@pattern_id)
+      subject.pattern_id = lambda { |filename| "foo" }
+      expect(subject.pattern_id("bar")).to eq "foo"
+      subject.pattern_id = built_in_identifier
+    end
+
+    it "does not reassign the pattern identifier unless it returns a result for a valid input" do
+      expect { subject.pattern_id = lambda { |file| } }.not_to change { subject.pattern_id("foo") }
+    end
+  end
+end
+
+describe Docks::Grouper do
+  subject { Docks::Grouper }
+
+  before :each do
+    Docks::Languages.register_bundled_languages
+  end
+
+  describe ".group" do
+    it "returns an empty Hash when no paths are provided" do
+      expect(subject.group([])).to eq Hash.new
+    end
+
+    it "returns an empty Hash when the passed glob does not match any files" do
+      pattern = File.join(File.dirname(__FILE__), "../fixtures/grouper/components/non-existent-thing/*")
+      expect(subject.group(pattern)).to eq Hash.new
+    end
+
+    it "groups together files of the same name that match the passed globbing patterns in an Array" do
+      pattern = File.join(File.dirname(__FILE__), "../fixtures/grouper/components/button/*")
+      files = Dir.glob(pattern)
+
+      group_result = subject.group(pattern)
+      button_result = group_result[Docks.pattern_id(files.first)]
+
+      expect(button_result).to eq files
+    end
+
+    it "groups together files of the same name that match the passed globbing patterns with multiple globbing patterns, some of which do not reference actual files" do
+      button_pattern = File.join(File.dirname(__FILE__), "../fixtures/grouper/components/button/*")
+      button_files = Dir.glob(button_pattern)
+      pattern_non_match = File.join(File.dirname(__FILE__), "../fixtures/grouper/components/non-existent-thing/*")
+
+      group_result = subject.group([button_pattern, pattern_non_match])
+      button_result = group_result[Docks.pattern_id(button_files.first)]
+
+      expect(button_result).to eq button_files
+    end
+
+    it "groups together files of the same name that match the passed globbing patterns with multiple globbing patterns that match" do
+      button_pattern = File.join(File.dirname(__FILE__), "../fixtures/grouper/components/button/*")
+      button_files = Dir.glob(button_pattern)
+
+      tab_pattern = File.join(File.dirname(__FILE__), "../fixtures/grouper/components/next-tab/*")
+      tab_files = Dir.glob(tab_pattern)
+
+      group_result = subject.group([button_pattern, tab_pattern])
+      button_result = group_result[Docks.pattern_id(button_files.first)]
+      tab_result = group_result[Docks.pattern_id(tab_files.first)]
+
+      expect(button_result).to eq button_files
+      expect(tab_result).to eq tab_files
+    end
+
+    context "when components are spread across folders" do
+      let(:globs) do
+        [
+          File.join(File.dirname(__FILE__), "../fixtures/grouper/markup/**/*.haml"),
+          File.join(File.dirname(__FILE__), "../fixtures/grouper/scripts/**/*.coffee"),
+          File.join(File.dirname(__FILE__), "../fixtures/grouper/style/**/*.scss")
+        ]
+      end
+
+      let(:result) { subject.group(globs) }
+      let(:expected_results) do
+        {
+          "resizable" => 2,
+          "list_view" => 2,
+          "toggle" => 3
+        }
+      end
+
+      it "groups together files in dedicated scripts/ markup/ style folders" do
+        expected_results.each do |group, file_count|
+          expect(result[group].length).to eq file_count
+        end
+      end
+
+      it "groups together files in dedicated scripts/ markup/ style folders and in component folders" do
+        globs << File.join(File.dirname(__FILE__), "../fixtures/grouper/components/button/*")
+        globs << File.join(File.dirname(__FILE__), "../fixtures/grouper/components/checkbox/*")
+        expected_results["button"] = 3
+        expected_results["checkbox"] = 3
+
+        result = subject.group(globs)
+
+        expected_results.each do |group, file_count|
+          expect(result[group].length).to eq file_count
+        end
+      end
+    end
+
+    describe "acceptance criteria" do
+      it "rejects minified files" do
+        pattern = File.join(File.dirname(__FILE__), "../fixtures/grouper/components/segmented control/*")
+        files = Dir.glob(pattern).reject! { |filename| filename =~ /\.min\..*$/ }
+
+        group_result = subject.group(pattern)
+        component_result = group_result[Docks.pattern_id(files.first)]
+
+        expect(component_result).to eq files
+      end
+
+      it "rejects files not recognized by Docks" do
+        pattern = File.join(File.dirname(__FILE__), "../fixtures/grouper/components/form/*")
+        files = Dir.glob(pattern).select! { |filename| Docks::Languages.extensions.include?(File.extname(filename)[1..-1]) }
+
+        group_result = subject.group(pattern)
+        component_result = group_result[Docks.pattern_id(files.first)]
+
+        expect(component_result).to eq files
+      end
+    end
+  end
+end

data/spec/lib/helpers/path_helper_spec.rb

@@ -0,0 +1,202 @@
+require "spec_helper"
+
+describe Docks::Helpers::Path do
+  subject do
+    Class.new { include Docks::Helpers::Path }.new
+  end
+
+  let(:pattern_library) { Docks::Containers::PatternLibrary.new }
+  let(:pattern) { Docks::Containers::Pattern.new(name: "foo") }
+
+  before(:each) do
+    Docks::Languages.register_bundled_languages
+    Docks.current_render_destination = Docks.config.destination + "baz/index.html"
+    subject.instance_variable_set(:@pattern_library, pattern_library)
+    subject.instance_variable_set(:@pattern, pattern)
+  end
+
+  describe "#docks_path" do
+    it "returns the anchor for a search that is found in the pattern" do
+      result = Docks::Containers::Symbol.new(name: "foo")
+      expect(pattern).to receive(:find).with("foo").and_return result
+      expect(subject.docks_path("foo")).to eq "##{result.symbol_id}"
+    end
+
+    it "returns the anchor for a search that is found in the pattern library" do
+      result = Docks::Containers::Symbol.new(name: "foo")
+      expect(pattern_library).to receive(:find).with("bar").and_return OpenStruct.new(pattern: pattern, symbol: result)
+      expect(subject.docks_path("bar")).to eq "#{subject.relative_asset_path(subject.pattern_path(pattern))}##{result.symbol_id}"
+    end
+
+    it "returns a path from the registered symbol sources if one exists" do
+      expect(subject.docks_path("Object")).to eq Docks::SymbolSources.path_for("Object")
+    end
+
+    context "when there are multiple requests for the same thing" do
+      it "caches the result of the same path request" do
+        expected = Docks::SymbolSources.path_for("Object")
+        expect(Docks::SymbolSources).to receive(:path_for).with("Object", anything).once.and_call_original
+        subject.docks_path("Object")
+        subject.docks_path("Object")
+
+        result = Docks::Containers::Symbol.new(name: "foo")
+        expect(pattern).to receive(:find).with("foo").once.and_return result
+        subject.docks_path("foo")
+        subject.docks_path("foo")
+      end
+
+      it "caches the results of requests that have different language options" do
+        sass_expected = Docks::SymbolSources.path_for("Map", language: :sass)
+        js_expected = Docks::SymbolSources.path_for("Map", language: :js)
+
+        expect(Docks::SymbolSources).to receive(:path_for).with("Map", language: :sass).once.and_call_original
+        expect(Docks::SymbolSources).to receive(:path_for).with("Map", language: :js).once.and_call_original
+
+        subject.docks_path("Map", language: :sass)
+        subject.docks_path("Map", language: :js)
+        subject.docks_path("Map", language: :sass)
+        subject.docks_path("Map", language: :js)
+      end
+    end
+  end
+
+  describe "#stylesheet_link_tag" do
+    let(:expected_path) { subject.relative_asset_path(Docks.config.destination + "styles/style.css").to_s }
+
+    it "returns a relative path to the stylesheet" do
+      output = subject.stylesheet_link_tag("style")
+      expect(output).to have_tag :link, with: { rel: "stylesheet", type: "text/css", href: expected_path }
+    end
+
+    it "doesn't duplicate the filename" do
+      output = subject.stylesheet_link_tag("style.css")
+      expect(output).to have_tag :link, with: { href: expected_path }
+    end
+
+    it "prints absolute paths directly" do
+      output = subject.stylesheet_link_tag("/foo/bar.css")
+      expect(output).to have_tag :link, with: { rel: "stylesheet", type: "text/css", href: "/foo/bar.css" }
+    end
+  end
+
+  describe "#javascript_include_tag" do
+    let(:expected_path) { subject.relative_asset_path(Docks.config.destination + "scripts/script.js").to_s }
+
+    it "returns a relative path to the script" do
+      output = subject.javascript_include_tag("script")
+      expect(output).to have_tag :script, with: { src: expected_path }
+    end
+
+    it "doesn't duplicate the filename" do
+      output = subject.javascript_include_tag("script.js")
+      expect(output).to have_tag :script, with: { src: expected_path }
+    end
+
+    it "handles absolute paths" do
+      output = subject.javascript_include_tag("/foo/bar.css")
+      expect(output).to have_tag :script, with: { src: "/foo/bar.css" }
+    end
+  end
+
+  describe "#relative_asset_path" do
+    it "returns a path relative to the current render destination" do
+      expect(subject.relative_asset_path(Docks.current_render_destination)).to eq Pathname.new(".")
+      expect(subject.relative_asset_path(Docks.current_render_destination + "foo/bar.baz")).to eq Pathname.new("foo/bar.baz")
+      expect(subject.relative_asset_path(Docks.current_render_destination.dirname)).to eq Pathname.new("..")
+    end
+  end
+
+  describe "#pattern_path" do
+    let(:expected_path) { Docks.config.destination + File.join(Docks.config.mount_at, pattern.name, "index.html") }
+
+    it "Gives the full path to a pattern's index file" do
+      expect(subject.pattern_path(pattern)).to eq expected_path
+    end
+
+    it "adds an anchor if provided" do
+      expect(subject.pattern_path(pattern, anchor: "bar")).to eq Pathname.new("#{expected_path.to_s}#bar")
+    end
+  end
+
+  describe "#compiled_style_tags" do
+    let(:css_filename) { "foo.css" }
+
+    it "returns nothing when the compiled assets are empty" do
+      expect(subject.compiled_style_tags).to be nil
+
+      Docks.configure_with(compiled_assets: [])
+      expect(subject.compiled_style_tags).to be nil
+
+      Docks.configure_with(compiled_assets: nil)
+      expect(subject.compiled_style_tags).to be nil
+    end
+
+    it "includes CSS assets" do
+      Docks.configure_with(compiled_assets: [css_filename, "bar.scss", "baz.js"])
+      expected = subject.stylesheet_link_tag(css_filename)
+
+      expect(subject).to receive(:stylesheet_link_tag).with(css_filename).and_call_original
+
+      expect(subject).not_to receive(:stylesheet_link_tag).with("bar.scss")
+      expect(subject).not_to receive(:stylesheet_link_tag).with("baz.js")
+
+      expect(subject.compiled_style_tags).to eq expected
+    end
+  end
+
+  describe "#compiled_script_tags" do
+    let(:js_filename) { "foo.js" }
+
+    it "returns nothing when the compiled assets are empty" do
+      expect(subject.compiled_script_tags).to be nil
+
+      Docks.configure_with(compiled_assets: [])
+      expect(subject.compiled_script_tags).to be nil
+
+      Docks.configure_with(compiled_assets: nil)
+      expect(subject.compiled_script_tags).to be nil
+    end
+
+    it "includes JavaScript assets" do
+      Docks.configure_with(compiled_assets: [js_filename, "bar.coffee", "baz.css"])
+      expected = subject.javascript_include_tag(js_filename)
+
+      expect(subject).to receive(:javascript_include_tag).with(js_filename).and_call_original
+      expect(subject).not_to receive(:javascript_include_tag).with("bar.scss")
+      expect(subject).not_to receive(:javascript_include_tag).with("baz.js")
+
+      expect(subject.compiled_script_tags).to eq expected
+    end
+  end
+
+  describe "#docks_stylesheet" do
+    it "returns a stylesheet link to the main stylesheet" do
+      expect(subject.docks_stylesheet).to eq subject.stylesheet_link_tag("docks.css")
+    end
+
+    it "returns a stylesheet link with the provided postfix" do
+      expect(subject.docks_stylesheet(:demo)).to eq subject.stylesheet_link_tag("docks-demo.css")
+    end
+
+    it "returns nothing when config.use_theme_assets is false" do
+      Docks.configure_with(use_theme_assets: false)
+      expect(subject.docks_stylesheet).to be nil
+    end
+  end
+
+  describe "#docks_javascript" do
+    it "returns a script tag to the main javascript file" do
+      expect(subject.docks_javascript).to eq subject.javascript_include_tag("docks.js")
+    end
+
+    it "returns a script tag with the provided postfix" do
+      expect(subject.docks_javascript(:demo)).to eq subject.javascript_include_tag("docks_demo.js")
+    end
+
+    it "returns nothing when config.use_theme_assets is false" do
+      Docks.configure_with(use_theme_assets: false)
+      expect(subject.docks_javascript).to be nil
+    end
+  end
+end
+

data/spec/lib/helpers/render_helper_spec.rb

@@ -0,0 +1,159 @@
+require "spec_helper"
+
+describe Docks::Helpers::Render do
+  subject do
+    Class.new { include Docks::Helpers::Render }.new
+  end
+
+  describe "#render_everything" do
+    let(:pattern) { Docks::Containers::Pattern.new(name: "foo") }
+    let(:component) { Docks::Containers::Component.new(name: "foo") }
+    before(:each) { subject.instance_variable_set(:@pattern, pattern) }
+
+    describe "markup" do
+      let(:markup) { "<% 5.times do %>foo<% end %>" }
+      let(:output) { "foo" * 5 }
+      before(:each) { pattern.add(:style, component) }
+
+      it "does nothing for non-symbols" do
+        pattern.param = OpenStruct.new(markup: markup)
+        expect(subject).to_not receive(:render)
+        subject.render_everything
+      end
+
+      it "does nothing for symbols without helper or markup" do
+        expect(subject).to_not receive(:render)
+        subject.render_everything
+      end
+
+      it "renders markup on the component" do
+        component.markup = markup
+        expect(subject).to receive(:render).with(inline: markup, layout: false).and_return(output)
+        subject.render_everything
+        expect(component.markup).to eq output
+      end
+
+      it "renders helper on the component" do
+        component.helper = markup
+        expect(subject).to receive(:render).with(inline: markup, layout: false).and_return(output)
+        subject.render_everything
+        expect(component.markup).to eq output
+      end
+
+      it "renders markup on nested variations" do
+        state = Docks::Containers::State.new(name: "foo--bar", markup: markup)
+        component.states << state
+        expect(subject).to receive(:render).with(inline: markup, layout: false).and_return(output)
+        subject.render_everything
+        expect(state.markup).to eq output
+      end
+
+      it "renders helpers on nested variations" do
+        state = Docks::Containers::State.new(name: "foo--bar", helper: markup)
+        component.states << state
+        expect(subject).to receive(:render).with(inline: markup, layout: false).and_return(output)
+        subject.render_everything
+        expect(state.markup).to eq output
+      end
+    end
+
+    describe "description" do
+      let(:description) { "<% %w(foo bar baz).each do |a| %><%= a %> <% end %>" }
+      let(:output) { "foo bar baz" }
+
+      it "renders the pattern description" do
+        pattern.description = description
+        expect(subject).to receive(:render).with(inline: description, layout: false).and_return(output)
+        subject.render_everything
+        expect(pattern.description).to eq output
+      end
+
+      it "renders the description on symbols" do
+        component.description = description
+        pattern.add(:style, component)
+        expect(subject).to receive(:render).with(inline: description, layout: false).and_return(output)
+        subject.render_everything
+        expect(component.description).to eq output
+      end
+
+      it "renders the description on nested objects" do
+        param = Docks::OpenStruct.new(description: description)
+        component.params = [param]
+        pattern.add(:style, component)
+        expect(subject).to receive(:render).with(inline: description, layout: false).and_return(output)
+        subject.render_everything
+        expect(param.description).to eq output
+      end
+
+      it "doesn't kill the kind of object a nested object originally was" do
+        param = Docks::OpenStruct.new(description: description)
+        component.params = [param]
+        pattern.add(:style, component)
+        expect(subject).to receive(:render).with(inline: description, layout: false).and_return(output)
+        subject.render_everything
+        expect(component.params.first).to be param
+      end
+
+      it "renders @link declarations" do
+        allow(subject).to receive(:render) { |opts| opts[:inline] }
+        pattern.description = "foo bar <a href='@link Baz'>baz</a>"
+        expect(subject).to receive(:docks_path).with("Baz", hash_including(:language)).and_return("/pattern-library/baz")
+        subject.render_everything
+        expect(pattern.description).to eq "foo bar <a href='/pattern-library/baz'>baz</a>"
+      end
+
+      context "when there is a code block" do
+        before(:each) do
+          allow(subject).to receive(:render) { |opts| opts[:inline] }
+        end
+
+        let(:code_block) { "<div>\n  Foo\n</div>" }
+        let(:language) { "html" }
+        let(:markdown) { Redcarpet::Markdown.new(Docks::Markdown::Renderer, fenced_code_blocks: true) }
+
+        it "renders a code block" do
+          pattern.description = markdown.render(markdown_code_block)
+          expect(subject).to receive(:docks_code_block) do |options|
+            expect(options[:hideable?]).to be false
+            expect(options[:demo?]).to be false
+
+            code = options[:code]
+            expect(code.length).to be 1
+            expect(code.first[:code].strip).to eq code_block
+            expect(code.first[:language]).to eq language
+          end
+
+          subject.render_everything
+        end
+
+        it "renders a code block with the a demo" do
+          pattern.description = markdown.render(markdown_code_block(with_demo: true))
+          expect(subject).to receive(:docks_code_block) do |options|
+            expect(options[:hideable?]).to be true
+            expect(options[:demo?]).to be true
+          end
+
+          subject.render_everything
+        end
+
+        it "adds a unique ID to each demo" do
+          pattern.description = markdown.render(markdown_code_block * 2)
+
+          ids = []
+          expect(subject).to receive(:docks_code_block).twice do |options|
+            ids.push(options[:id])
+          end
+
+          subject.render_everything
+          expect(ids).to eq ids.uniq
+        end
+
+        private
+
+        def markdown_code_block(options = {})
+          options.fetch(:with_demo, false) ? "```#{language}_demo\n#{code_block}\n```" : "```#{language}\n#{code_block}\n```\n"
+        end
+      end
+    end
+  end
+end

data/spec/lib/helpers_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+
+describe Docks::Helpers do
+  describe ".add_helpers_to" do
+    let(:renderer) { Docks::Renderers::ERB.new }
+
+    it "adds all bundled helpers" do
+      helpers = []
+      allow(renderer).to receive(:helpers) do |*args|
+        helpers = helpers.concat(args)
+      end
+
+      described_class.add_helpers_to(renderer)
+
+      described_class.constants.each do |const|
+        expect(helpers).to include described_class.const_get(const)
+      end
+    end
+
+    it "adds any user-configured helpers" do
+      Docks.configure_with helpers: ["foo.txt", "bar.txt"]
+
+      helpers = []
+      allow(renderer).to receive(:helpers) do |*args|
+        helpers = helpers.concat(args)
+      end
+
+      described_class.add_helpers_to(renderer)
+
+      Docks.config.helpers.each do |helper|
+        expect(helpers).to include helper
+      end
+    end
+  end
+end

data/spec/lib/languages/base_language_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+describe Docks::Languages::Base do
+  subject { Docks::Languages::Base.instance }
+
+  describe "#load_stub" do
+    it "doesn't do anything to load a stub file" do
+      expect(subject.load_stub("foo.bar")).to be nil
+    end
+  end
+end
+
+describe Docks::Languages do
+  subject { Docks::Languages }
+
+  describe ".bundled_languages" do
+    it "has all bundled languages except the base language" do
+      bundled_languages = subject.bundled_languages
+
+      subject.constants.each do |const|
+        klass = subject.const_get(const)
+        next unless Class === klass && !(klass.eql?(subject::Base))
+        expect(bundled_languages).to include klass
+      end
+    end
+
+    it "caches the bundled languages for subsequent calls" do
+      before = subject.bundled_languages
+      expect(subject.bundled_languages).to be before
+    end
+  end
+end

data/spec/lib/languages/coffeescript_language_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+describe Docks::Languages::CoffeeScript do
+  subject { Docks::Languages::CoffeeScript.instance }
+
+  describe ".extensions" do
+    let(:extensions) { [subject.class.extensions].flatten }
+
+    it "includes .coffee as an extension" do
+      expect(extensions).to include "coffee"
+    end
+
+    it "includes .coffeescript as an extension" do
+      expect(extensions).to include "coffeescript"
+    end
+  end
+
+  describe "#signature_for" do
+    let(:name) { "foo" }
+    let(:function_no_params) { Docks::Containers::Function.new(name: name) }
+    let(:function_with_params) { Docks::Containers::Function.new(name: name, params: [OpenStruct.new(name: "bar"), OpenStruct.new(name: "baz", default: "'qux'")]) }
+    let(:klass) { Docks::Containers::Klass.new(name: name.capitalize, params: function_with_params.params) }
+    let(:something_else) { Docks::Containers::Variable.new(name: "bar") }
+
+    it "gives a signature to functions with no params" do
+      expect(subject.signature_for(function_no_params)).to eq "#{function_no_params.name} = -> # ..."
+    end
+
+    it "gives a signature to functions with params, including default values" do
+      expect(subject.signature_for(function_with_params)).to eq "#{function_with_params.name} = (bar, baz = 'qux') -> # ..."
+    end
+
+    it "gives a signature for classes with params, including default values" do
+      expect(subject.signature_for(klass)).to eq "class #{klass.name}\n  constructor: (bar, baz = 'qux') -> # ..."
+    end
+
+    it "gives a signature to instance methods" do
+      klass.add_member(function_with_params)
+      expect(subject.signature_for(function_with_params)).to eq "#{function_with_params.name}: (bar, baz = 'qux') -> # ..."
+    end
+
+    it "gives a signature to static methods" do
+      function_with_params.static = true
+      klass.add_member(function_with_params)
+      expect(subject.signature_for(function_with_params)).to eq "#{klass.name}.#{function_with_params.name} = (bar, baz = 'qux') -> # ..."
+    end
+
+    it "doesn't provide a signature for a non-function symbol" do
+      expect(subject.signature_for(something_else)).to be nil
+    end
+  end
+end

data/spec/lib/languages/css_language_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Docks::Languages::CSS do
+  subject { Docks::Languages::CSS.instance }
+
+  describe ".extensions" do
+    let(:extensions) { [subject.class.extensions].flatten }
+
+    it "includes .css as an extension" do
+      expect(extensions).to include "css"
+    end
+  end
+end

data/spec/lib/languages/erb_language_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe Docks::Languages::ERB do
+  subject { Docks::Languages::ERB.instance }
+
+  describe ".extensions" do
+    let(:extensions) { [subject.class.extensions].flatten }
+
+    it "includes .erb as an extension" do
+      expect(extensions).to include "erb"
+    end
+  end
+
+  describe "#helper_markup_for" do
+    let(:mixed_arguments) { ["hello", 10, false, :goodbye, { bar: "baz", "baz" => :qux }] }
+    let(:mixed_arguments_output) { "\"hello\", 10, false, :goodbye, bar: \"baz\",\n#{" " * 38}\"baz\" => :qux" }
+    let(:argumentless_hash) { { "baz" => :qux } }
+    let(:argumentless_hash_output) { "\"baz\" => :qux" }
+
+    it "converts an array of arguments into the corresponding function" do
+      expect(subject.helper_markup_for("foo", mixed_arguments)).to eq "<%= foo #{mixed_arguments_output} %>"
+    end
+
+    it "converts a hash with an arguments key into the corresponding function" do
+      expect(subject.helper_markup_for("foo", arguments: mixed_arguments)).to eq "<%= foo #{mixed_arguments_output} %>"
+    end
+
+    it "converts a hash without an array key into a function with the hash as the only param" do
+      expect(subject.helper_markup_for("foo", argumentless_hash)).to eq "<%= foo #{argumentless_hash_output} %>"
+    end
+  end
+end
+