docks_app 0.0.1

data/spec/lib/naming_conventions/bem_naming_convention_spec.rb

@@ -0,0 +1,112 @@
+require "spec_helper"
+
+describe Docks::NamingConventions::BEM do
+  subject { described_class.instance }
+
+  describe "#base_component" do
+    it "removes variation details" do
+      expect(subject.base_component("foo--bar")).to eq "foo"
+    end
+
+    it "removes subcomponent details" do
+      expect(subject.base_component("foo__bar")).to eq "foo"
+    end
+
+    it "removes variation and state details" do
+      expect(subject.base_component("foo--bar__baz--qux")).to eq "foo"
+    end
+  end
+
+  describe "#base_component?" do
+    it "identifies a base component name correctly" do
+      expect(subject.base_component?("foo")).to be true
+      expect(subject.base_component?("foo--bar")).to be false
+      expect(subject.base_component?("foo__bar")).to be false
+    end
+  end
+
+  describe "#component" do
+    it "removes variation details" do
+      expect(subject.component("foo--bar")).to eq "foo"
+    end
+
+    it "preserves subcomponents" do
+      expect(subject.component("foo__bar")).to eq "foo__bar"
+    end
+
+    it "preserves the lowest subcomponent and strips all levels of variation" do
+      expect(subject.component("foo--bar__baz--qux__foo--bar")).to eq "foo__baz__foo"
+    end
+  end
+
+  describe "#parent_component" do
+    it "goes one level up" do
+      expect(subject.parent_component("foo")).to eq "foo"
+      expect(subject.parent_component("foo__bar")).to eq "foo"
+      expect(subject.parent_component("foo__bar__baz")).to eq "foo__bar"
+    end
+
+    it "strips away variations" do
+      expect(subject.parent_component("foo--bar")).to eq "foo"
+      expect(subject.parent_component("foo__bar--baz")).to eq "foo"
+      expect(subject.parent_component("foo--fuzz__bar--baz__quz")).to eq "foo__bar"
+    end
+  end
+
+  describe "state?" do
+    it "identifies disconnected states" do
+      expect(subject.state?("is-active")).to be true
+    end
+
+    it "identifies states connected to component names" do
+      expect(subject.state?("foo--is-active")).to be true
+    end
+
+    it "doesn't identify states when the component has is- in the name" do
+      expect(subject.state?("foois-bar")).to be false
+    end
+  end
+
+  describe "variant?" do
+    it "identifies variants" do
+      expect(subject.variant?("foo--bar")).to be true
+    end
+
+    it "doesn't identify a component" do
+      expect(subject.variant?("foo")).to be false
+      expect(subject.variant?("foo__bar")).to be false
+    end
+
+    it "doesn't identify variants when it is actually a connected state" do
+      expect(subject.variant?("foo--is-bar")).to be false
+    end
+  end
+
+  describe "#disconnected_state?" do
+    it "checks whether a state is not connected to the base class name" do
+      expect(subject.disconnected_state?("is-active")).to be true
+      expect(subject.disconnected_state?("component")).to be false
+      expect(subject.disconnected_state?("component--is-active")).to be false
+    end
+  end
+
+  describe "#clean_variation_name" do
+    it "doesn't prepend the base class name for disconnected states" do
+      expect(subject.clean_variation_name("is-active", "foo")).to eq "is-active"
+    end
+
+    it "prepends the base class name and -- for non-disconnected-states" do
+      expect(subject.clean_variation_name("bar", "foo")).to eq "foo--bar"
+    end
+
+    it "prepends the base class name for variations starting with --" do
+      expect(subject.clean_variation_name("--bar", "foo")).to eq "foo--bar"
+      expect(subject.clean_variation_name("--is-active", "foo")).to eq "foo--is-active"
+    end
+
+    it "does nothing for fully-formed variations" do
+      expect(subject.clean_variation_name("foo--bar", "foo")).to eq "foo--bar"
+      expect(subject.clean_variation_name("foo--is-active", "foo")).to eq "foo--is-active"
+    end
+  end
+end

data/spec/lib/naming_conventions/suit_naming_convention_spec.rb

@@ -0,0 +1,107 @@
+require "spec_helper"
+
+describe Docks::NamingConventions::SUIT do
+  subject { described_class.instance }
+
+  describe "#base_component" do
+    it "removes variation details" do
+      expect(subject.base_component("Foo--baz")).to eq "Foo"
+    end
+
+    it "removes subcomponent details" do
+      expect(subject.base_component("Foo-baz")).to eq "Foo"
+    end
+
+    it "removes variation and state details" do
+      expect(subject.base_component("Foo--bar")).to eq "Foo"
+    end
+  end
+
+  describe "#base_component?" do
+    it "identifies a base component name correctly" do
+      expect(subject.base_component?("Foo")).to be true
+      expect(subject.base_component?("Foo--bar")).to be false
+      expect(subject.base_component?("Foo-bar")).to be false
+    end
+  end
+
+  describe "#component" do
+    it "removes variation details" do
+      expect(subject.component("Foo--bar")).to eq "Foo"
+    end
+
+    it "preserves subcomponents" do
+      expect(subject.component("Foo-bar")).to eq "Foo-bar"
+    end
+  end
+
+  describe "#parent_component" do
+    it "goes one level up" do
+      expect(subject.parent_component("Foo")).to eq "Foo"
+      expect(subject.parent_component("Foo-bar")).to eq "Foo"
+      expect(subject.parent_component("Foo-bar-baz")).to eq "Foo-bar"
+    end
+
+    it "strips away variations" do
+      expect(subject.parent_component("Foo--bar")).to eq "Foo"
+      expect(subject.parent_component("Foo-bar--baz")).to eq "Foo"
+    end
+  end
+
+  describe "state?" do
+    it "identifies disconnected states" do
+      expect(subject.state?("is-active")).to be true
+    end
+
+    it "identifies states connected to component names" do
+      expect(subject.state?("Foo--is-active")).to be true
+    end
+
+    it "doesn't identify states when the component has is- in the name" do
+      expect(subject.state?("Foois-bar")).to be false
+    end
+  end
+
+  describe "variant?" do
+    it "identifies variants" do
+      expect(subject.variant?("Foo--bar")).to be true
+    end
+
+    it "doesn't identify a component" do
+      expect(subject.variant?("Foo")).to be false
+      expect(subject.variant?("Foo-bar")).to be false
+    end
+
+    it "doesn't identify variants when it is actually a connected state" do
+      expect(subject.variant?("Foo--is-bar")).to be false
+    end
+  end
+
+  describe "#disconnected_state?" do
+    it "checks whether a state is not connected to the base class name" do
+      expect(subject.disconnected_state?("is-active")).to be true
+      expect(subject.disconnected_state?("Component")).to be false
+      expect(subject.disconnected_state?("Component--is-active")).to be false
+    end
+  end
+
+  describe "#clean_variation_name" do
+    it "doesn't prepend the base class name for disconnected states" do
+      expect(subject.clean_variation_name("is-active", "Foo")).to eq "is-active"
+    end
+
+    it "prepends the base class name and -- for non-disconnected-states" do
+      expect(subject.clean_variation_name("bar", "Foo")).to eq "Foo--bar"
+    end
+
+    it "prepends the base class name for variations starting with --" do
+      expect(subject.clean_variation_name("--bar", "Foo")).to eq "Foo--bar"
+      expect(subject.clean_variation_name("--is-active", "Foo")).to eq "Foo--is-active"
+    end
+
+    it "does nothing for fully-formed variations" do
+      expect(subject.clean_variation_name("Foo--bar", "Foo")).to eq "Foo--bar"
+      expect(subject.clean_variation_name("Foo--is-active", "Foo")).to eq "Foo--is-active"
+    end
+  end
+end

data/spec/lib/naming_conventions_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+describe Docks::NamingConventions do
+  subject { described_class }
+  let(:convention) { described_class::BEM }
+
+  describe ".for" do
+    it "gets the convention from a string" do
+      expect(described_class.for("BEM")).to be_a convention
+    end
+
+    it "gets the convention from a symbol" do
+      expect(described_class.for(:BEM)).to be_a convention
+    end
+
+    it "gets the convention from a class" do
+      expect(described_class.for(convention)).to be_a convention
+    end
+
+    it "gets the convention from an instance" do
+      expect(described_class.for(convention.instance)).to be_a convention
+    end
+
+    it "doesn't throw an error when it fails" do
+      expect { described_class.for(:FOO) }.not_to raise_error
+    end
+  end
+end

data/spec/lib/ostruct_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+describe Docks::OpenStruct do
+  let(:backing) do
+    { foo: "bar" }
+  end
+
+  subject { described_class.new(backing) }
+
+  describe "as_json" do
+    it "directly returns its table as JSON" do
+      expect(subject.to_json).to eq backing.to_json
+    end
+  end
+end

data/spec/lib/parser_spec.rb

@@ -0,0 +1,93 @@
+require "spec_helper"
+
+describe Docks::Parser do
+  subject { Docks::Parser }
+
+  around do |example|
+    Docks::Tags.register_bundled_tags
+    Docks::Languages.register_bundled_languages
+    example.run
+    subject.send(:clean)
+  end
+
+  describe ".parse" do
+    let(:style_file) { File.expand_path("../../fixtures/parsers/sass_parser_fixture_basic.scss", __FILE__) }
+    let(:script_file) { File.expand_path("../../fixtures/parsers/coffeescript_parser_fixture_basic.coffee", __FILE__) }
+    let(:style_parser) { Docks::Parsers::Sass.instance }
+    let(:script_parser) { Docks::Parsers::CoffeeScript.instance }
+
+    it "returns a pattern" do
+      expect(subject.parse(style_file)).to be_a Docks::Containers::Pattern
+    end
+
+    it "parses the contents of each file" do
+      expect(style_parser).to receive(:parse).with(style_file).and_call_original
+      expect(script_parser).to receive(:parse).with(script_file).and_call_original
+      subject.parse([style_file, script_file])
+    end
+
+    it "processes all parsed symbols and the final pattern" do
+      symbols = style_parser.parse(style_file) + script_parser.parse(script_file)
+      symbols.each { |symbol| expect(Docks::Process).to receive(:process).with(symbol) { |arg| arg } }
+      expect(Docks::Process).to receive(:process).with(an_instance_of(Docks::Containers::Pattern))
+      subject.parse([style_file, script_file])
+    end
+
+    it "includes the parse result of a file in the appropriate group" do
+      expect(Docks::Process).to receive(:process).at_least(:once) { |arg| arg }
+      expect_any_instance_of(Docks::Containers::Pattern).to receive(:add).with(:style, style_parser.parse(style_file))
+      expect_any_instance_of(Docks::Containers::Pattern).to receive(:add).with(:script, script_parser.parse(script_file))
+      subject.parse([style_file, script_file])
+    end
+
+    it "uses a matching registered parser" do
+      class ExampleParser < Docks::Parsers::Base; end
+      subject.register(ExampleParser, for: /fixture/)
+      expect(ExampleParser.instance).to receive(:parse).with(style_file).and_return([])
+      subject.parse([style_file])
+    end
+
+    it "uses the last registered parser" do
+      class ExampleParser < Docks::Parsers::Base; end
+      class OtherParser < Docks::Parsers::Base; end
+
+      subject.register(ExampleParser, for: /fixture/)
+      subject.register(OtherParser, for: /parser/)
+      expect(OtherParser.instance).to receive(:parse).with(style_file).and_return([])
+      subject.parse([style_file])
+    end
+
+    it "doesn't use a parser that doesn't match the file" do
+      class ExampleParser < Docks::Parsers::Base; end
+      subject.register(ExampleParser, for: /script/)
+      expect(ExampleParser.instance).to_not receive(:parse)
+      subject.parse([style_file])
+    end
+
+    it "doesn't try to parse a file that doesn't exist" do
+      expect(File).to_not receive(:read).with("foo.bar")
+      subject.parse("foo.bar")
+    end
+
+    it "doesn't try to parse a file that has no parser" do
+      File.open("foo.md", "w") { |file| file.write("foo bar") }
+      expect(subject).to_not receive(:parse_file).with("foo.md")
+      subject.parse("foo.md")
+      FileUtils.rm("foo.md")
+    end
+
+    it "doesn't try to parse a file that doesn't have a supported extension" do
+      File.open("foo.bar", "w") { |file| file.write("foo bar") }
+      expect(File).to_not receive(:read).with("foo.bar")
+      subject.parse("foo.bar")
+      FileUtils.rm("foo.bar")
+    end
+
+    it "sets the most recently modified file's time to be the pattern's modified attribute" do
+      FileUtils.touch(script_file)
+      expected_modified = File.mtime(script_file)
+      pattern = subject.parse([style_file, script_file])
+      expect(pattern.modified).to eq expected_modified
+    end
+  end
+end

data/spec/lib/parsers/base_parser_spec.rb

@@ -0,0 +1,128 @@
+require "spec_helper"
+
+describe Docks::Parsers::Base do
+  subject { Docks::Parsers::Base.instance }
+
+  before :each do
+    Docks::Tags.register_bundled_tags
+  end
+
+  describe "#parse" do
+    let(:example_parser) { Docks::Parsers::Sass.instance }
+    let(:example_files) do
+      [
+        File.expand_path("../../../fixtures/parsers/sass_parser_fixture_complex.scss", __FILE__),
+        File.expand_path("../../../fixtures/parsers/sass_parser_fixture_basic.scss", __FILE__)
+      ]
+    end
+
+    it "adds a source attribute to the symbol with source file" do
+      example_files.each do |file|
+        example_parser.parse(file).each do |symbol|
+          expect(symbol.source.file).to eq file
+        end
+      end
+    end
+
+    it "adds the language code of the file" do
+      example_files.each do |file|
+        example_parser.parse(file).each do |symbol|
+          expect(symbol.source.language_code).to eq Docks::Languages.extension_for_file(file)
+        end
+      end
+    end
+  end
+
+  describe "#pattern_block_extractor" do
+    it "doesn't break within the block when a sequence of characters matches the possible closing symbol" do
+      match = "  //*\n  // @pattern Foo\n\n  // Don't **break** me here!\n\n\n//*\nBreak here".match(Docks::Parsers::Sass.instance.pattern_block_extractor)
+      expect(match[0]).to include "**break**"
+    end
+  end
+
+  describe "#parse_comment_block" do
+    it "adds a description when it is leading without a tag name" do
+      description = "This is\na description"
+      symbol = subject.parse_comment_block(description)
+      expect(symbol.description.join("\n")).to eq description
+    end
+
+    it "adds a normal tag to an array of results" do
+      title = "Next Tab"
+      symbol = subject.parse_comment_block("    @title #{title}")
+      expect(symbol.title).to eq title
+    end
+
+    it "adds a multiple-per-block tag to an array of arrays" do
+      param = "{String} name"
+      symbol = subject.parse_comment_block("   @param #{param}")
+      expect(symbol.param).to eq [[param]]
+    end
+
+    it "adds a result even when there is no text content following the tag" do
+      symbol = subject.parse_comment_block("  @class")
+      expect(symbol[:class]).to eq ""
+    end
+
+    it "appends a second line of a normal tag to the same result array" do
+      line_one = "html"
+      line_two = " <p>Hello</p>"
+      symbol = subject.parse_comment_block(" @example #{line_one}\n#{line_two}")
+      example_result = symbol.example.first
+      expect(example_result.length).to eq 2
+      expect(example_result[0]).to eq line_one
+      expect(example_result[1]).to eq line_two
+    end
+
+    it "adds details for multiple tags" do
+      title = "Title"
+      subtitle = "Subtitle"
+      symbol = subject.parse_comment_block("  @title #{title}\n  @subtitle #{subtitle}")
+      expect(symbol.title).to eq title
+      expect(symbol.subtitle).to eq subtitle
+    end
+
+    it "adds a new array to multiple_allowed tags when other tags are between the first and second ones" do
+      param_one = "{String} name - The\nname"
+      param_two = "{Number} count - The\ncount"
+      title = "Title"
+      subtitle = "Subtitle"
+
+      symbol = subject.parse_comment_block("@param #{param_one}\n@title #{title}\n@subtitle #{subtitle}\n@param #{param_two}")
+      expect(symbol.title).to eq title
+      expect(symbol.subtitle).to eq subtitle
+      expect(symbol.param).to include(param_one.split("\n"))
+      expect(symbol.param).to include(param_two.split("\n"))
+    end
+
+    it "keeps only the last instance of a one_per_file tag" do
+      pattern_one = "Buttons"
+      pattern_two = "No, wait, Forms!"
+
+      symbol = subject.parse_comment_block("@pattern #{pattern_one}\n@pattern #{pattern_two}")
+      expect(symbol.pattern).not_to eq pattern_one
+      expect(symbol.pattern).to eq pattern_two
+    end
+
+    it "does not include lines following non-multiline comments even if the following lines include no tag" do
+      pattern = "Button"
+      following_line = "Here is some more content"
+
+      symbol = subject.parse_comment_block("@pattern #{pattern}\n#{following_line}")
+      expect(symbol.pattern).to eq pattern
+      expect(symbol.description).to include(following_line)
+    end
+
+    it "only removes one space after the tag name" do
+      pattern = "Button"
+      symbol = subject.parse_comment_block("@pattern   #{pattern}")
+      expect(symbol.pattern).to eq "  #{pattern}"
+    end
+
+    it "preserves newlines in multiline tags" do
+      description = "This is\na description"
+      symbol = subject.parse_comment_block(description)
+      expect(symbol.description.join("\n")).to eq description
+    end
+  end
+end

data/spec/lib/parsers/coffeescript_parser_spec.rb

@@ -0,0 +1,184 @@
+require "spec_helper"
+
+describe Docks::Parsers::CoffeeScript do
+  subject { Docks::Parsers::CoffeeScript.instance }
+
+  before :each do
+    Docks::Tags.register_bundled_tags
+  end
+
+  let(:basic_fixture) { File.join(File.dirname(__FILE__), "..", "..", "fixtures", "parsers", "coffeescript_parser_fixture_basic.coffee") }
+  let(:complex_fixture) { File.join(File.dirname(__FILE__), "..", "..", "fixtures", "parsers", "coffeescript_parser_fixture_complex.coffee") }
+
+  describe "#parse" do
+    let(:basic_parsed_symbols) { subject.parse(basic_fixture) }
+    let(:complex_parsed_symbols) { subject.parse(complex_fixture) }
+
+    it "captures the correct number of documentation blocks" do
+      expect(basic_parsed_symbols.length).to eq 2
+      expect(complex_parsed_symbols.length).to eq 6
+    end
+
+    it "captures the pattern comment block when one exists" do
+      expect(basic_parsed_symbols.first[:pattern]).to be nil
+      expect(complex_parsed_symbols.first[:pattern]).to_not be nil
+    end
+
+    it "captures the pattern comment block when it is written using the page synonym" do
+      complex_parsed_symbols = subject.parse(File.read(complex_fixture).sub("@pattern", "@page"))
+      expect(complex_parsed_symbols.first[:page]).to_not be nil
+    end
+
+    it "adds line number for the first line following all other comment blocks" do
+      expected_line_numbers = [10, 20]
+      basic_parsed_symbols.each_with_index do |symbol, index|
+        expect(symbol.source.line_number).to be expected_line_numbers[index]
+      end
+
+      expected_line_numbers = [3, 17, 38, 44, 52, 77]
+      complex_parsed_symbols.each_with_index do |symbol, index|
+        expect(symbol.source.line_number).to be expected_line_numbers[index]
+      end
+    end
+  end
+
+  describe "#symbol_block_extractor" do
+    it "provides the first non-comment line as the second capture group" do
+      [
+        "_foo = 'bar'",
+        "$node = $(this)",
+        "bar = 'baz'"
+      ].each do |non_comment|
+        match = "  #*\n  # Description\n\n  #{non_comment}".match(subject.symbol_block_extractor)
+        expect(match[:first_line]).to eq non_comment
+      end
+    end
+  end
+
+  describe "#comment_line_pattern" do
+    let(:basic_comment) { "This is a comment" }
+    let(:complex_comment) { "# This comment has ##some extra comment-like symbols/characters #" }
+
+    it "strips line comments" do
+      expect("# #{basic_comment}".gsub(subject.comment_line_pattern, "")).to eq basic_comment
+    end
+
+    it "strips line comments with leading whitespace" do
+      expect("    # #{basic_comment}".gsub(subject.comment_line_pattern, "")).to eq basic_comment
+    end
+
+    it "strips line complex comments" do
+      expect("# #{complex_comment}".gsub(subject.comment_line_pattern, "")).to eq complex_comment
+    end
+
+    it "leaves empty lines intact" do
+      content = "# Foo\n#\n# 1. Bar\n\n# 2. Baz"
+      expect(content.gsub(subject.comment_line_pattern, "")).to eq "Foo\n\n1. Bar\n\n2. Baz"
+    end
+  end
+
+  describe "#symbol_details_from_first_line" do
+    it "identifies a class" do
+      target_name = "Tab"
+      name, type = subject.symbol_details_from_first_line(" class #{target_name}  ").values
+      expect(type).to eq Docks::Types::Symbol::CLASS
+      expect(name).to eq target_name
+    end
+
+    describe "functions" do
+      it "identifies a function with the single arrow" do
+        target_name = "activateTab"
+        name, type = subject.symbol_details_from_first_line("#{target_name} = ($tab) -> $tab.activate()").values
+        expect(type).to eq Docks::Types::Symbol::FUNCTION
+        expect(name).to eq target_name
+      end
+
+      it "identifies a function with the fat arrow" do
+        target_name = "activateTab"
+        name, type = subject.symbol_details_from_first_line("#{target_name} = => $tab.activate()").values
+        expect(type).to eq Docks::Types::Symbol::FUNCTION
+        expect(name).to eq target_name
+      end
+
+      it "identifies a function declared in a class definition" do
+        target_name = "activateTab"
+        name, type = subject.symbol_details_from_first_line("  #{target_name} : ($tab) -> $tab.activate()").values
+        expect(type).to eq Docks::Types::Symbol::FUNCTION
+        expect(name).to eq target_name
+      end
+
+      it "identifies a function declared using dot notation" do
+        target_name = "activateTab"
+
+        name, type = subject.symbol_details_from_first_line("  foo.#{target_name} = ($tab) -> $tab.activate()").values
+        expect(type).to eq Docks::Types::Symbol::FUNCTION
+        expect(name).to eq target_name
+
+        name, type = subject.symbol_details_from_first_line("  foo.bar.#{target_name} = ($tab) -> $tab.activate()").values
+        expect(type).to eq Docks::Types::Symbol::FUNCTION
+        expect(name).to eq target_name
+
+        name, type = subject.symbol_details_from_first_line("  foo['bar'].#{target_name} = ($tab) -> $tab.activate()").values
+        expect(type).to eq Docks::Types::Symbol::FUNCTION
+        expect(name).to eq target_name
+      end
+
+      it "identifies a function declared using bracket notation" do
+        target_name = "activateTab"
+
+        name, type = subject.symbol_details_from_first_line("  foo['#{target_name}'] = ($tab) -> $tab.activate()").values
+        expect(type).to eq Docks::Types::Symbol::FUNCTION
+        expect(name).to eq target_name
+
+        name, type = subject.symbol_details_from_first_line("  foo[\"#{target_name}\"] = ($tab) -> $tab.activate()").values
+        expect(type).to eq Docks::Types::Symbol::FUNCTION
+        expect(name).to eq target_name
+
+        name, type = subject.symbol_details_from_first_line("  foo['bar']['#{target_name}'] = ($tab) -> $tab.activate()").values
+        expect(type).to eq Docks::Types::Symbol::FUNCTION
+        expect(name).to eq target_name
+
+        name, type = subject.symbol_details_from_first_line("  foo.bar['#{target_name}'] = ($tab) -> $tab.activate()").values
+        expect(type).to eq Docks::Types::Symbol::FUNCTION
+        expect(name).to eq target_name
+      end
+    end
+
+    describe "variables" do
+      it "identifies a variable" do
+        target_name = "newTab"
+        name, type = subject.symbol_details_from_first_line("  #{target_name} = @newTab()").values
+        expect(type).to eq Docks::Types::Symbol::VARIABLE
+        expect(name).to eq target_name
+      end
+
+      it "identifies a variable declared in a class definition" do
+        target_name = "val"
+        name, type = subject.symbol_details_from_first_line("  #{target_name} : (2 * 3) / 4").values
+        expect(type).to eq Docks::Types::Symbol::VARIABLE
+        expect(name).to eq target_name
+      end
+
+      it "identifies a variable that is declared without assignment" do
+        target_name = "val"
+        name, type = subject.symbol_details_from_first_line(target_name).values
+        expect(type).to eq Docks::Types::Symbol::VARIABLE
+        expect(name).to eq target_name
+      end
+
+      it "identifies the first variable in a comma-separated list without assignment" do
+        target_name = "val"
+        name, type = subject.symbol_details_from_first_line("  #{target_name}, foo, bar , baz").values
+        expect(type).to eq Docks::Types::Symbol::VARIABLE
+        expect(name).to eq target_name
+      end
+
+      it "identifies the first variable in a comma-separated list with assignment" do
+        target_name = "val"
+        name, type = subject.symbol_details_from_first_line("  #{target_name}, foo, bar , baz = 'qux'").values
+        expect(type).to eq Docks::Types::Symbol::VARIABLE
+        expect(name).to eq target_name
+      end
+    end
+  end
+end