docks_app 0.0.1

data/spec/lib/tags/description_tag_spec.rb

@@ -0,0 +1,242 @@
+require "spec_helper"
+
+describe Docks::Tags::Description do
+  subject { Docks::Tags::Description.instance }
+
+  it "allows multiline content" do
+    expect(subject.multiline?).to be true
+  end
+
+  it "only allows one description per block" do
+    expect(subject.multiple_allowed?).to be false
+  end
+
+  describe "#process" do
+    it "connects multiline content with smart line breaks" do
+      description = ["foo", "bar"]
+      symbol = Docks::Containers::Symbol.new(description: description.dup)
+      expect(subject.process(symbol).description).to eq Docks::Processors.join_with_smart_line_breaks(description)
+    end
+  end
+
+  describe "post process" do
+    before(:each) do
+      Docks::Languages.register_bundled_languages
+    end
+
+    describe "associating external description files" do
+      let(:name) { "button" }
+      let(:pattern) { Docks::Containers::Pattern.new(name: name) }
+      let(:component) { Docks::Containers::Component.new(name: name) }
+      let(:second_component) { Docks::Containers::Component.new(name: "segmented-button") }
+
+      before(:each) do
+        allow_any_instance_of(Redcarpet::Markdown).to receive(:render) { |renderer, code| code }
+      end
+
+      context "when there is only a pattern symbol" do
+        let(:description_file) { "pattern-lab/descriptions/_#{name}.md" }
+        let(:description) { "Foo\n\nBar." }
+
+        before(:each) { pattern.files = [description_file] }
+
+        it "associates a description file matching a pattern with the description for that pattern" do
+          expect(File).to receive(:read).with(description_file).and_return description
+          process_pattern
+          expect(pattern.description).to eq description
+        end
+
+        it "does not associate a description file when the pattern already has a description" do
+          pattern.description = "foo"
+          expect(File).to receive(:read).with(description_file).and_return description
+          expect { process_pattern }.not_to change { pattern }
+        end
+      end
+
+      context "when there are other symbols" do
+        let(:description_file) { File.expand_path("../../../fixtures/tags/description/button.md", __FILE__) }
+        let(:description_file_contents) { File.read(description_file) }
+
+        before(:each) do
+          pattern.add(:style, [component, second_component])
+          pattern.files = [description_file]
+        end
+
+        it "associates the description with components based on headings and removes these from the pattern's description" do
+          process_pattern
+          expect(component.description).to eq Regexp.new("^# #{component.name}\\n(.*?)^# ", Regexp::MULTILINE).match(description_file_contents).captures.first.strip
+          expect(second_component.description).to eq Regexp.new("^## #{second_component.name}\\n(.*)", Regexp::MULTILINE).match(description_file_contents).captures.first.strip
+          expect(pattern.description).to eq description_file_contents.sub(/#.*/m, "").strip
+        end
+
+        it "doesn't associate a description with a component with no matching heading" do
+          component.name = "foo"
+          process_pattern
+          expect(component.description).to be nil
+        end
+
+        it "doesn't blow up when there is no pattern to take the rest of the description" do
+          expect { process_pattern }.not_to raise_error
+          expect(component.description).to eq Regexp.new("^# #{component.name}\\n(.*?)^# ", Regexp::MULTILINE).match(description_file_contents).captures.first.strip
+        end
+      end
+
+      context "when there are components" do
+        let(:description_file) { File.expand_path("../../../fixtures/tags/description/component.md", __FILE__) }
+        let(:description_file_contents) { File.read(description_file) }
+
+        before(:each) do
+          pattern.files = [description_file]
+          pattern.add(:style, component)
+        end
+
+        let(:state) { Docks::Containers::State.new(name: "#{name}--is-active") }
+        let(:variant) { Docks::Containers::State.new(name: "#{name}--large") }
+
+        it "does the description association for states" do
+          component.states << state
+          process_pattern
+
+          expect(state.description).to eq Regexp.new("^## #{state.name}\\n(.*?)^## ", Regexp::MULTILINE).match(description_file_contents).captures.first.strip
+          expect(component.description).to eq description_file_contents.sub(/[^#]*#.*/, "").sub(/##.*/m, "").strip
+        end
+
+        it "does the description association for variants" do
+          component.variants << variant
+          process_pattern
+
+          expect(variant.description).to eq Regexp.new("^## #{variant.name}\\n(.*?)^# ", Regexp::MULTILINE).match(description_file_contents).captures.first.strip
+          expect(component.description).to eq description_file_contents.sub(/[^#]*#.*/, "").sub(Regexp.new("## #{variant.name}.*", Regexp::MULTILINE), "").strip
+        end
+
+        it "doesn't do a description association for a state with an existing description" do
+          state.description = "foo"
+          component.states << state
+          process_pattern
+
+          expect(state.description).to eq "foo"
+          expect(component.description).to eq description_file_contents.sub(/.*?^# [^\n]*\n\n/m, "").sub(/^# .*/m, "").strip
+        end
+      end
+
+      context "when there are classes and factories" do
+        let(:description_file) { File.expand_path("../../../fixtures/tags/description/class.md", __FILE__) }
+        let(:description_file_contents) { File.read(description_file) }
+
+        let(:method) { Docks::Containers::Function.new(name: "toggle") }
+        let(:property) { Docks::Containers::Variable.new(name: "is_active") }
+        let(:klass) do
+          klass = Docks::Containers::Klass.new(name: name.capitalize)
+          klass.add_members(method, property)
+          klass
+        end
+
+        before(:each) do
+          pattern.files = [description_file]
+          pattern.add(:script, klass)
+        end
+
+        it "does the description association for methods" do
+          process_pattern
+
+          expect(method.description).to eq Regexp.new("^## #{method.name}\\n(.*?)^# ", Regexp::MULTILINE).match(description_file_contents).captures.first.strip
+          expect(klass.description).to eq description_file_contents.sub(/[^#]*#[^#]*#.*?$/m, "").sub(/##.*/m, "").strip
+        end
+
+        it "does the description association for properties" do
+          process_pattern
+
+          expect(property.description).to eq Regexp.new("^## #{property.name}\\n(.*?)^## ", Regexp::MULTILINE).match(description_file_contents).captures.first.strip
+          expect(klass.description).to eq description_file_contents.sub(/[^#]*#[^#]*#.*?$/m, "").sub(Regexp.new("## #{property.name}.*", Regexp::MULTILINE), "").strip
+        end
+
+        it "doesn't do a description association for a method with an existing description" do
+          method.description = "foo"
+          process_pattern
+
+          expect(method.description).to eq "foo"
+          expect(klass.description).to eq description_file_contents.sub(/(.*?^# [^\n]*\n\n){2}/m, "").sub(/^## .*/m, "").strip
+        end
+      end
+
+      context "when there are functions" do
+        let(:description_file) { File.expand_path("../../../fixtures/tags/description/function.md", __FILE__) }
+        let(:description_file_contents) { File.read(description_file) }
+
+        let(:param) { OpenStruct.new(name: "options") }
+        let(:function) { Docks::Containers::Function.new(name: "toggle", params: [param]) }
+
+        before(:each) do
+          pattern.files = [description_file]
+          pattern.add(:script, function)
+        end
+
+        it "does the description association for parameters" do
+          process_pattern
+
+          expect(param.description).to eq Regexp.new("^### #{param.name}\\n(.*?)^# ", Regexp::MULTILINE).match(description_file_contents).captures.first.strip
+          expect(function.description).to eq description_file_contents.sub(/(.*?^## [^\n]*\n\n){2}/m, "").sub(/^### .*/m, "").strip
+        end
+
+        it "doesn't do a description association for a parameter with an existing description" do
+          param.description = "foo"
+          process_pattern
+
+          expect(param.description).to eq "foo"
+          expect(function.description).to eq description_file_contents.sub(/(.*?^## [^\n]*\n\n){2}/m, "").sub(/^# .*/m, "").strip
+        end
+      end
+
+      private
+
+      def process_pattern
+        Docks::Process.process(pattern)
+      end
+    end
+
+    describe "rendering markdown descriptions" do
+      let(:param) { OpenStruct.new(name: "options", description: nil) }
+      let(:method) { Docks::Containers::Function.new(name: "toggle", static: true, params: [param]) }
+      let(:factory) { Docks::Containers::Factory.new(name: "Foo", methods: [method]) }
+      let(:pattern) do
+        pattern = Docks::Containers::Pattern.new(name: "foo")
+        pattern.add(:script, factory)
+        pattern
+      end
+
+      it "uses the custom markdown renderer" do
+        expect(subject.instance_variable_get(:@markdown).renderer).to be_an_instance_of Docks::Markdown::Renderer
+      end
+
+      it "nils out empty, all-whitespace, and nil descriptions" do
+        param.description = "   \n "
+        method.description = ""
+        factory.description = "  "
+        process_pattern
+
+        expect(param.description).to be nil
+        expect(method.description).to be nil
+        expect(factory.description).to be nil
+        expect(pattern.description).to be nil
+      end
+
+      it "calls the markdown renderer recursively for all items that need descriptions" do
+        factory_description = "This is a pattern"
+        factory.description = factory_description
+        param_description = "This is a parameter"
+        param.description = param_description
+
+        expect_any_instance_of(Redcarpet::Markdown).to receive(:render).with(factory_description).and_call_original
+        expect_any_instance_of(Redcarpet::Markdown).to receive(:render).with(param_description).and_call_original
+
+        process_pattern
+      end
+
+      private
+
+      def process_pattern
+        Docks::Process.process(pattern)
+      end
+    end
+  end
+end

data/spec/lib/tags/example_tag_spec.rb

@@ -0,0 +1,37 @@
+#TODO: check for leading whitespace when there is no language/ description
+
+require "spec_helper"
+
+describe Docks::Tags::Example do
+  subject { Docks::Tags::Example.instance }
+
+  it "allows multiline content" do
+    expect(subject.multiline?).to be true
+  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 }
+    let(:code) { "foo = (bar) ->" }
+    let(:language) { "coffee" }
+
+    before(:each) { Docks::Languages.register_bundled_languages }
+
+    it "calls the code block processor" do
+      expect(subject).to receive(:code_block_with_language_and_description).and_call_original
+      symbol[subject.name] = [[language, code]]
+      subject.process(symbol)
+      expect(symbol[subject.name].first).to eq OpenStruct.new(language: language, code: code)
+    end
+
+    it "uses the extension for the current file as the language when none is provided" do
+      expect(Docks).to receive(:current_file).and_return "foo_bar.#{language}"
+      symbol[subject.name] = [[code]]
+      subject.process(symbol)
+      expect(symbol[subject.name].first).to eq OpenStruct.new(language: language, code: code)
+    end
+  end
+end

data/spec/lib/tags/factory_tag_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe Docks::Tags::Factory do
+  subject { Docks::Tags::Factory.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 "marks the attribute as true" do
+      symbol = Docks::Containers::Symbol.new(name: "foo", factory: "")
+      Docks::Process.process(symbol)
+      expect(symbol[subject.name]).to be true
+    end
+
+    it "converts the symbol to be a factory container" do
+      symbol = Docks::Containers::Function.new(factory: "", name: "foo")
+      symbol = Docks::Process.process(symbol)
+
+      expect(symbol).to be_a Docks::Containers::Factory
+      expect(symbol.symbol_type).to eq Docks::Types::Symbol::FACTORY
+    end
+  end
+end

data/spec/lib/tags/for_tag_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+describe Docks::Tags::For do
+  subject { Docks::Tags::For.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 "post process" do
+    let(:pattern) { Docks::Containers::Pattern.new(name: "foo") }
+
+    context "when there are components with variations" do
+      let(:variant) { Docks::Containers::Variant.new(name: "foo--bar") }
+      let(:state) { Docks::Containers::State.new(name: "foo--is-bar") }
+      let(:component) { Docks::Containers::Component.new(name: "foo", states: [state], variants: [variant]) }
+
+      before(:each) { pattern.add(:style, component) }
+
+      it "adds the component name for states and variants" do
+        post_process
+
+        expect(variant.for).to eq component.name
+        expect(state.for).to eq component.name
+      end
+
+      it "adds the for attribute on states and variants in subcomponents" do
+        sub_state = Docks::Containers::State.new(name: "foo__bar--is-baz")
+        subcomponent = Docks::Containers::Component.new(name: "foo__bar", states: [sub_state])
+        component.subcomponents << subcomponent
+        post_process
+
+        expect(sub_state.for).to eq subcomponent.name
+      end
+    end
+
+    def post_process
+      Docks::Process.process(pattern)
+    end
+  end
+end

data/spec/lib/tags/group_tag_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+
+describe Docks::Tags::Group do
+  subject { Docks::Tags::Group.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 "does not perform any processing" do
+      content = "foo"
+      expect(subject.process(content)).to eq content
+    end
+  end
+end

data/spec/lib/tags/helper_tag_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+describe Docks::Tags::Helper do
+  subject { Docks::Tags::Helper.instance }
+
+  it "allows multiline content" do
+    expect(subject.multiline?).to be true
+  end
+
+  it "only allows one description per block" do
+    expect(subject.multiple_allowed?).to be false
+  end
+
+  describe "#process" do
+    it "connects multiline content with line breaks" do
+      helper = ["foo", "bar"]
+      symbol = Docks::Containers::Symbol.new(helper: helper.dup)
+      subject.process(symbol)
+      expect(symbol[subject.name]).to eq helper.join("\n")
+    end
+  end
+end

data/spec/lib/tags/include_with_tag_spec.rb

@@ -0,0 +1,74 @@
+require "spec_helper"
+
+describe Docks::Tags::IncludeWith do
+  subject { Docks::Tags::IncludeWith.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 include_with on commas, spaces and pipes" do
+      include_with = "foo | bar, baz qux"
+      symbol[subject.name] = include_with
+      subject.process(symbol)
+      expect(symbol[subject.name]).to eq Docks::Processors.split_on_commas_spaces_and_pipes(include_with)
+    end
+
+    it "joins together multiple lines of include_with" do
+      include_with = ["foo | bar, baz qux", "lux fuz"]
+      symbol[subject.name] = include_with.dup
+      subject.process(symbol)
+      expect(symbol[subject.name]).to eq include_with.map { |with| Docks::Processors.split_on_commas_spaces_and_pipes(with) }.flatten
+    end
+  end
+
+  describe "post_process" do
+    describe "mirror the inclusion in the referenced symbol" do
+      let(:component) { Docks::Containers::Component.new(name: "foo") }
+      let(:included_component) { Docks::Containers::Component.new(name: "bar", include_with: [component.name]) }
+      let(:included_variation) { Docks::Containers::State.new(name: "baz--qux", include_with: [component.name]) }
+      let(:containing_component) { Docks::Containers::Component.new(name: "bar", states: [included_variation]) }
+      let(:pattern) { Docks::Containers::Pattern.new(name: "foo") }
+
+      it "joins included components" do
+        pattern.add(:style, [component, included_component])
+        post_process
+
+        expect(component.included_symbols).to be_an Array
+        expect(component.included_symbols.length).to be 1
+        expect(component.included_symbols).to include included_component
+      end
+
+      it "joins included variations" do
+        pattern.add(:style, [component, containing_component])
+        post_process
+
+        expect(component.included_symbols).to be_an Array
+        expect(component.included_symbols.length).to be 1
+        expect(component.included_symbols).to include included_variation
+      end
+
+      it "joins included subcomponents" do
+        other_component =  Docks::Containers::Component.new(name: "fizz", subcomponents: [containing_component, included_component])
+        pattern.add(:style, [component, other_component])
+        post_process
+
+        expect(component.included_symbols).to be_an Array
+        expect(component.included_symbols.length).to be 2
+        expect(component.included_symbols).to include included_component
+        expect(component.included_symbols).to include included_variation
+      end
+
+      def post_process
+        Docks::Process.process(pattern)
+      end
+    end
+  end
+end

data/spec/lib/tags/javascript_action_tag_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+
+describe Docks::Tags::JavascriptAction do
+  subject { Docks::Tags::JavascriptAction.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 "does not perform any processing" do
+      content = "foo"
+      expect(subject.process(content)).to eq content
+    end
+  end
+end

data/spec/lib/tags/link_tag_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+describe Docks::Tags::Link do
+  subject { Docks::Tags::Link.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 }
+    let(:simple_content) { "http://apple.com" }
+    let(:caption) { "chrismsauve@gmail.com" }
+    let(:complex_content) { "#{simple_content} (#{caption})" }
+
+    it "creates a :url when there are no other details" do
+      expect(process_link_with(simple_content).first.url).to eq simple_content
+    end
+
+    it "creates a :url when there are other details" do
+      expect(process_link_with(complex_content).first.url).to eq simple_content
+    end
+
+    it "does not create a :caption when no parentheses are provided" do
+      expect(process_link_with(simple_content).first.caption).to be nil
+    end
+
+    it "creates a :caption when one is provided without a key" do
+      expect(process_link_with(complex_content).first.caption).to eq caption
+    end
+
+    it "creates a :caption when the key is provided" do
+      complex_content.sub!("(", "(caption: ")
+      expect(process_link_with(complex_content).first.caption).to eq caption
+    end
+
+    private
+
+    def process_link_with(content)
+      symbol[subject.name] = content
+      subject.process(symbol)
+      symbol[subject.name]
+    end
+  end
+end