docks_app 0.0.1

data/spec/lib/tags/set_by_tag_spec.rb

@@ -0,0 +1,92 @@
+require "spec_helper"
+
+describe Docks::Tags::SetBy do
+  subject { Docks::Tags::SetBy.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) { ":checked?" }
+    let(:complex_setter) { ":size" }
+    let(:complex_constant) { "SIZE::LARGE" }
+    let(:complex_content) { "#{complex_setter} (#{complex_constant})" }
+
+    it "creates a :setter when there is no constant" do
+      expect(process_set_by_with(simple_content).first.setter).to eq simple_content
+    end
+
+    it "creates a :setter when there is a constant" do
+      expect(process_set_by_with(complex_content).first.setter).to eq complex_setter
+    end
+
+    it "does not create a constant when no parentheses are provided" do
+      expect(process_set_by_with(simple_content).first.constant).to be nil
+    end
+
+    it "creates a constant when one is provided without a key" do
+      expect(process_set_by_with(complex_content).first.constant).to eq complex_constant
+    end
+
+    it "creates a constant when one is provided with the :constant key" do
+      complex_content.sub!("(", "(constant: ")
+      expect(process_set_by_with(complex_content).first.constant).to eq complex_constant
+    end
+
+    describe "mutliple :set_by per line" do
+      let(:setter_two) { ":state" }
+      let(:constant_two) { "STATE::CHECKED" }
+      let(:content_two) { "#{setter_two}  (#{constant_two})" }
+
+      it "creates multiple :set_by when they are separated by a comma" do
+        [
+          "#{complex_content}, #{content_two}, #{simple_content}",
+          "#{complex_content} ,#{content_two} ,#{simple_content}",
+          "#{complex_content}  ,   #{content_two}   , #{simple_content}"
+        ].each do |test|
+          result = process_set_by_with(test)
+          expect(result.length).to eq 3
+
+          expect(result[0].setter).to eq complex_setter
+          expect(result[0].constant).to eq complex_constant
+          expect(result[1].setter).to eq setter_two
+          expect(result[1].constant).to eq constant_two
+          expect(result[2].setter).to eq simple_content
+          expect(result[2].constant).to be nil
+        end
+      end
+
+      it "creates multiple :set_by when they are separated by a pipe" do
+        [
+          "#{complex_content}| #{content_two}| #{simple_content}",
+          "#{complex_content} |#{content_two} |#{simple_content}",
+          "#{complex_content}  |   #{content_two}   | #{simple_content}"
+        ].each do |test|
+          result = process_set_by_with(test)
+          expect(result.length).to eq 3
+
+          expect(result[0].setter).to eq complex_setter
+          expect(result[0].constant).to eq complex_constant
+          expect(result[1].setter).to eq setter_two
+          expect(result[1].constant).to eq constant_two
+          expect(result[2].setter).to eq simple_content
+          expect(result[2].constant).to be nil
+        end
+      end
+    end
+
+    private
+
+    def process_set_by_with(content)
+      symbol[subject.name] = content
+      subject.process(symbol)
+      symbol[subject.name]
+    end
+  end
+end

data/spec/lib/tags/signature_tag_spec.rb

@@ -0,0 +1,125 @@
+require "spec_helper"
+
+describe Docks::Tags::Signature do
+  subject { Docks::Tags::Signature.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
+      signature = ["foo", "bar"]
+      symbol = Docks::Containers::Symbol.new(signature: signature.dup)
+      subject.process(symbol)
+      expect(symbol[subject.name]).to eq signature.join("\n")
+    end
+  end
+
+  describe "post process" do
+    before(:each) { Docks::Languages.register_bundled_languages }
+
+    let(:script_source) { OpenStruct.new(file: "foo.coffee") }
+
+    let(:mixin) { Docks::Containers::Mixin.new(name: "foo", source: OpenStruct.new(file: "foo.scss")) }
+    let(:function) { Docks::Containers::Function.new(name: "foo", source: script_source) }
+    let(:method) { Docks::Containers::Function.new(name: "foo", source: script_source) }
+
+    let(:klass) do
+      klass = Docks::Containers::Klass.new(name: "Foo", source: script_source)
+      klass.add_member(method)
+      klass
+    end
+
+    let(:factory) do
+      factory = Docks::Containers::Factory.new(name: "Bar", source: script_source)
+      factory.add_member(method)
+      factory
+    end
+
+    let(:object) do
+      object = Docks::Containers::Variable.new(name: "Baz", object: true, source: script_source)
+      object.add_member(method)
+      object
+    end
+
+    let(:pattern) { Docks::Containers::Pattern.new(name: "foo") }
+
+    it "asks the language for a function to update the signature" do
+      pattern.add(:script, function)
+      expect(Docks::Languages::CoffeeScript.instance).to receive(:signature_for).with(function).and_return("foo")
+
+      post_process
+
+      expect(function.signature).to eq "foo"
+    end
+
+    it "asks the language for a mixin to update the signature" do
+      pattern.add(:style, mixin)
+      expect(Docks::Languages::Sass.instance).to receive(:signature_for).with(mixin).and_return("foo")
+
+      post_process
+
+      expect(mixin.signature).to eq "foo"
+    end
+
+    it "asks the language for a class and its methods to update the signature" do
+      pattern.add(:script, klass)
+      expect(Docks::Languages::CoffeeScript.instance).to receive(:signature_for).with(klass).and_return("foo")
+      expect(Docks::Languages::CoffeeScript.instance).to receive(:signature_for).with(method).and_return("bar")
+
+      post_process
+
+      expect(klass.signature).to eq "foo"
+      expect(method.signature).to eq "bar"
+    end
+
+    it "asks the language for a factory and its methods to update the signature" do
+      pattern.add(:script, factory)
+      expect(Docks::Languages::CoffeeScript.instance).to receive(:signature_for).with(factory).and_return("foo")
+      expect(Docks::Languages::CoffeeScript.instance).to receive(:signature_for).with(method).and_return("bar")
+
+      post_process
+
+      expect(factory.signature).to eq "foo"
+      expect(method.signature).to eq "bar"
+    end
+
+    it "asks the language for an object's methods to update the signature" do
+      pattern.add(:script, object)
+      expect(Docks::Languages::CoffeeScript.instance).to receive(:signature_for).with(method).and_return("foo")
+
+      post_process
+
+      expect(method.signature).to eq "foo"
+    end
+
+    it "adds signatures for nested methods" do
+      second_method = Docks::Containers::Function.new(name: "foo", source: script_source)
+      method.add_member(second_method)
+
+      pattern.add(:script, object)
+      expect(Docks::Languages::CoffeeScript.instance).to receive(:signature_for).with(method).and_return("foo")
+      expect(Docks::Languages::CoffeeScript.instance).to receive(:signature_for).with(second_method).and_return("bar")
+
+      post_process
+
+      expect(method.signature).to eq "foo"
+      expect(second_method.signature).to eq "bar"
+    end
+
+    it "doesn't replace a singature that exists" do
+      factory.signature = "Bar = (node) ->"
+      pattern.add(:script, factory)
+      expect { post_process }.to_not change { factory.signature }
+    end
+
+    def post_process
+      Docks::Process.process(pattern)
+    end
+  end
+end

data/spec/lib/tags/since_tag_spec.rb

@@ -0,0 +1,48 @@
+require "spec_helper"
+
+describe Docks::Tags::Since do
+  subject { Docks::Tags::Since.instance }
+
+  it "allows multiline content" do
+    expect(subject.multiline?).to be true
+  end
+
+  it "allows only one tag per block" do
+    expect(subject.multiple_allowed?).to be false
+  end
+
+  describe "#process" do
+    let(:symbol) { Docks::Containers::Symbol.new }
+    let(:version) { "1.5.0-beta003" }
+    let(:description) { "This is the description" }
+
+    it "correctly sets the version when no description is provided" do
+      expect(process_since_with(version).version).to eq version
+    end
+
+    it "correctly sets the version when a description is provided" do
+      expect(process_since_with("#{version} #{description}").version).to eq version
+      expect(process_since_with("#{version} -  #{description}").version).to eq version
+      expect(process_since_with("#{version}   -#{description}").version).to eq version
+    end
+
+    it "correctly returns a nil description when no description is provided" do
+      expect(process_since_with(version).description).to be nil
+    end
+
+    it "correctly assigns a description when one is provided" do
+      target_description = Docks::Processors.join_with_smart_line_breaks(description)
+      expect(process_since_with("#{version} #{description}").description).to eq target_description
+      expect(process_since_with("#{version} -  #{description}").description).to eq target_description
+      expect(process_since_with("#{version}   -#{description}").description).to eq target_description
+    end
+
+    private
+
+    def process_since_with(content)
+      symbol[subject.name] = content
+      subject.process(symbol)
+      symbol[subject.name]
+    end
+  end
+end

data/spec/lib/tags/state_tag_spec.rb

@@ -0,0 +1,199 @@
+require "spec_helper"
+
+describe Docks::Tags::State do
+  subject { Docks::Tags::State.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
+    before :each do
+      @default_state_hash = {
+        description: nil,
+        activate_with: [],
+        precludes: [],
+        set_by: [],
+        include_with: [],
+        demo_type: Docks::Types::Demo::DEFAULT,
+        active: false,
+        javascript_action: nil
+      }
+
+      @optional_state_params = [:description, :activate_with, :precludes, :set_by, :include_with, :demo_type, :active, :javascript_action]
+    end
+
+    let(:name) { "tab--is-active" }
+    let(:description) { "An active tab." }
+    let(:activate_with) { "tab--is-important |  tab--is-valid" }
+    let(:precludes) { "tab--is-inactive" }
+    let(:set_by) { "TabList#activate | :state (Tabs::State::ACTIVE)" }
+    let(:include_with) { "tab-list" }
+    let(:demo_type) { Docks::Types::Demo::SELECT }
+    let(:active) { "true" }
+    let(:javascript_action) { "this.activate()" }
+
+    it "creates states as their container" do
+      symbol = Docks::Containers::Symbol.new(states: [name])
+      subject.process(symbol)
+      expect(symbol.states.length).to be 1
+      expect(symbol.states.first).to be_a Docks::Containers::State
+    end
+
+    it "sets the defaults when parameters are not included" do
+      result = subject.send(:break_apart_variation_details, name)
+      expect(result[:name]).to eq name
+
+      expect_default_for_optionals_with_exclusions(result)
+    end
+
+    it "sets the description when one is provided without an options parenthetical" do
+      [
+        "#{name} #{description}",
+        "#{name} -  #{description}"
+      ].each do |str|
+        result = subject.send(:break_apart_variation_details, str)
+        expect(result[:name]).to eq name
+        expect(result[:description]).to eq description
+        expect(result[:description]).to eq description
+
+        expect_default_for_optionals_with_exclusions(result, :description)
+      end
+    end
+
+    it "sets the description when one is provided with an options parenthetical" do
+      [
+        "#{name} (#{Docks::Types::Demo::NONE}) #{description}",
+        "#{name} (#{Docks::Types::Demo::NONE}) -  #{description}"
+      ].each do |str|
+        result = subject.send(:break_apart_variation_details, str)
+        expect(result[:name]).to eq name
+        expect(result[:description]).to eq description
+        expect(result[:description]).to eq description
+        expect(result[:demo_type]).to eq Docks::Types::Demo::NONE
+
+        expect_default_for_optionals_with_exclusions(result, :description, :demo_type)
+      end
+    end
+
+    it "sets the demo type when it is the only thing provided in the parenthetical" do
+      demo_type = Docks::Types::Demo::SELECT
+      result = subject.send(:break_apart_variation_details, "#{name} (#{demo_type})")
+      expect(result[:demo_type]).to eq demo_type
+
+      expect_default_for_optionals_with_exclusions(result, :demo_type)
+    end
+
+    it "sets the demo type when other key-value pairs are provided in the parenthetical" do
+      result = subject.send(:break_apart_variation_details, "#{name} (#{demo_type}, activate with: #{activate_with})")
+      expect(result[:name]).to eq name
+      expect(result[:demo_type]).to eq demo_type
+      expect(result[:activate_with]).to eq Docks::Processors.split_on_characters(activate_with, "\s\|")
+
+      expect_default_for_optionals_with_exclusions(result, :demo_type, :activate_with)
+    end
+
+    it "sets active parameter" do
+      [
+        "#{name} (active :  yup)",
+        "#{name} (active: true)"
+      ].each do |str|
+        result = subject.send(:break_apart_variation_details, str)
+        expect(result[:name]).to eq name
+        expect(result[:active]).to be true
+        expect_default_for_optionals_with_exclusions(result, :active)
+      end
+
+      [
+        "#{name} (active: false)",
+        "#{name} (active :    false)"
+      ].each do |str|
+        result = subject.send(:break_apart_variation_details, str)
+        expect(result[:name]).to eq name
+        expect(result[:active]).to be false
+        expect_default_for_optionals_with_exclusions(result, :active)
+      end
+    end
+
+    it "sets the include_with parameter" do
+      result = subject.send(:break_apart_variation_details, "#{name} (include with :  #{include_with})")
+      expect(result[:name]).to eq name
+      expect(result[:include_with]).to eq Docks::Processors.split_on_characters(include_with, "\s\|")
+
+      expect_default_for_optionals_with_exclusions(result, :include_with)
+    end
+
+    it "sets the activate_with parameter" do
+      result = subject.send(:break_apart_variation_details, "#{name} (activate with :  #{activate_with})")
+      expect(result[:name]).to eq name
+      expect(result[:activate_with]).to eq Docks::Processors.split_on_characters(activate_with, "\s\|")
+
+      expect_default_for_optionals_with_exclusions(result, :activate_with)
+    end
+
+    it "sets the precludes parameter" do
+      result = subject.send(:break_apart_variation_details, "#{name} (precludes :  #{precludes})")
+      expect(result[:name]).to eq name
+      expect(result[:precludes]).to eq Docks::Processors.split_on_characters(precludes, "\s\|")
+
+      expect_default_for_optionals_with_exclusions(result, :precludes)
+    end
+
+    it "sets the javascript_action parameter" do
+      result = subject.send(:break_apart_variation_details, "#{name} (javascript action :  #{javascript_action})")
+      expect(result[:name]).to eq name
+      expect(result[:javascript_action]).to eq javascript_action
+
+      expect_default_for_optionals_with_exclusions(result, :javascript_action)
+    end
+
+    it "sets the set_by parameter" do
+      result = subject.send(:break_apart_variation_details, "#{name} (set by :  #{set_by})")
+      expected_setters = Docks::Processors.split_on_top_level_parens_commas_and_pipes(set_by).map do |setter|
+        Docks::Processors.name_and_parenthetical(setter, :setter, :constant)
+      end
+
+      expect(result[:name]).to eq name
+      expect(result[:set_by]).to eq expected_setters
+
+      expect_default_for_optionals_with_exclusions(result, :set_by)
+    end
+
+    it "sets multiple parameters simultaneously" do
+      [
+        "#{name} ( #{demo_type},  activate_with  : #{activate_with} , include_with:  #{include_with} , precludes: #{precludes}, active : true, javascript action  : #{javascript_action},  set by :  #{set_by}) #{description}",
+        "#{name} (#{demo_type},  activate_with  : #{activate_with} , include_with:  #{include_with} , precludes: #{precludes}, active : true, javascript action  : #{javascript_action},  set by :  #{set_by} ) -  #{description}"
+      ].each do |str|
+        result = subject.send(:break_apart_variation_details, str)
+        expected_setters = Docks::Processors.split_on_top_level_parens_commas_and_pipes(set_by).map do |setter|
+          Docks::Processors.name_and_parenthetical(setter, :setter, :constant)
+        end
+
+        expect(result[:name]).to eq name
+        expect(result[:description]).to eq description
+        expect(result[:description]).to eq description
+        expect(result[:demo_type]).to eq demo_type
+        expect(result[:active]).to be true
+        expect(result[:javascript_action]).to eq javascript_action
+        [:include_with, :activate_with, :precludes].each do |param|
+          expect(result[param]).to eq Docks::Processors.split_on_characters(eval(param.to_s), "\s\|")
+        end
+        expect(result[:set_by]).to eq expected_setters
+      end
+    end
+
+    private
+
+    def expect_default_for_optionals_with_exclusions(result, *exclusions)
+      exclusions.each { |excl| @optional_state_params.delete(excl) }
+
+      @optional_state_params.each do |param|
+        expect(result[param]).to eq @default_state_hash[param]
+      end
+    end
+  end
+end

data/spec/lib/tags/static_tag_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+describe Docks::Tags::Static do
+  subject { Docks::Tags::Static.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 "sets the class to be true when it exists at all" do
+      symbol = Docks::Containers::Symbol.new
+
+      symbol[subject.name] = ""
+      subject.process(symbol)
+      expect(symbol[subject.name]).to be true
+
+      symbol[subject.name] = "static"
+      subject.process(symbol)
+      expect(symbol[subject.name]).to be true
+    end
+  end
+end

data/spec/lib/tags/subcomponent_tag_spec.rb

@@ -0,0 +1,78 @@
+require "spec_helper"
+
+describe Docks::Tags::Subcomponent do
+  subject { described_class.instance }
+
+  it "can't be be parsed from files" do
+    expect(subject.parseable?).to be false
+  end
+
+  describe "#setup_post_processors" do
+    let(:component_container) { Docks::Containers::Component }
+
+    let(:pattern) { Docks::Containers::Pattern.new(name: "button") }
+    let(:component) { component_container.new(name: "button") }
+    let(:subcomponent_one) { component_container.new(name: "button__text") }
+    let(:subcomponent_two) { component_container.new(name: "button__text__icon") }
+    let(:orphan_subcomponent_one) { component_container.new(name: "tablist__tab") }
+    let(:orphan_subcomponent_two) { component_container.new(name: "tablist__panel-list__panel") }
+
+    it "leaves components as-is" do
+      pattern.add(:style, component)
+      Docks::Process.process(pattern)
+      expect(pattern.components.length).to be 1
+      expect(pattern.components.first).to be component
+    end
+
+    it "joins subcomponents to the base component" do
+      pattern.add(:style, [component, subcomponent_one, subcomponent_two])
+      Docks::Process.process(pattern)
+      expect(pattern.components.length).to be 1
+
+      component = pattern.components.first
+      expect(component).to be component
+      expect(component.subcomponents.length).to be 1
+
+      subcomponent = component.subcomponents.first
+      expect(subcomponent).to be subcomponent_one
+      expect(subcomponent.subcomponents.length).to be 1
+      expect(subcomponent.subcomponents.first).to be subcomponent_two
+    end
+
+    it "joins subcomponents before the base component to the base component" do
+      pattern.add(:style, [subcomponent_two, component, subcomponent_one])
+      Docks::Process.process(pattern)
+      expect(pattern.components.length).to be 1
+
+      component = pattern.components.first
+      expect(component).to be component
+      expect(component.subcomponents.length).to be 1
+
+      subcomponent = component.subcomponents.first
+      expect(subcomponent).to be subcomponent_one
+      expect(subcomponent.subcomponents.length).to be 1
+      expect(subcomponent.subcomponents.first).to be subcomponent_two
+    end
+
+    it "creates a new base component for orphaned subcomponents" do
+      pattern.add(:style, [orphan_subcomponent_one, orphan_subcomponent_two])
+      Docks::Process.process(pattern)
+      expect(pattern.components.length).to be 1
+
+      component = pattern.components.first
+      expect(component.name).to eq Docks.config.naming_convention.base_component(orphan_subcomponent_one.name)
+
+      subcomponents = component.subcomponents
+      expect(subcomponents.length).to be 2
+      expect(subcomponents).to include orphan_subcomponent_one
+
+      orphan_two_parent = subcomponents.find do |subcomponent|
+        subcomponent.name == Docks.config.naming_convention.parent_component(orphan_subcomponent_two.name)
+      end
+
+      expect(subcomponents).to include orphan_two_parent
+      expect(orphan_two_parent.subcomponents.length).to be 1
+      expect(orphan_two_parent.subcomponents).to include orphan_subcomponent_two
+    end
+  end
+end

data/spec/lib/tags/subtitle_tag_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Docks::Tags::Subtitle do
+  subject { Docks::Tags::Subtitle.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
+end

data/spec/lib/tags/symbol_type_tag_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+
+describe Docks::Tags::SymbolType do
+  subject { Docks::Tags::SymbolType.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/throws_tag_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+describe Docks::Tags::Throws do
+  subject { Docks::Tags::Throws.instance }
+
+  it "allows multiline content" do
+    expect(subject.multiline?).to be true
+  end
+
+  it "allows only multiple tags per block" do
+    expect(subject.multiple_allowed?).to be true
+  end
+
+  describe "#process" do
+    let(:symbol) { Docks::Containers::Symbol.new }
+    let(:types) { "{TypeError | NameError DocksError, Error}" }
+    let(:description) { "This is the description" }
+
+    it "splits apart types when no description is provided" do
+      expect(process_throws_with(types).types).to eq Docks::Processors.split_types(types)
+    end
+
+    it "splits apart types when a description is provided" do
+      type_results = Docks::Processors.split_types(types)
+      expect(process_throws_with("#{types} #{description}").types).to eq type_results
+      expect(process_throws_with("#{types} -  #{description}").types).to eq type_results
+      expect(process_throws_with("#{types}   -#{description}").types).to eq type_results
+      expect(process_throws_with("#{types}-  #{description}").types).to eq type_results
+    end
+
+    it "returns a nil description when no description is provided" do
+      expect(process_throws_with(types).description).to be nil
+    end
+
+    it "assigns a description when one is provided" do
+      target_description = Docks::Processors.join_with_smart_line_breaks(description)
+      expect(process_throws_with("#{types} #{description}").description).to eq target_description
+      expect(process_throws_with("#{types} -  #{description}").description).to eq target_description
+      expect(process_throws_with("#{types}   -#{description}").description).to eq target_description
+      expect(process_throws_with("#{types}-  #{description}").description).to eq target_description
+    end
+
+    def process_throws_with(content)
+      symbol[subject.name] = content
+      subject.process(symbol)
+      symbol[subject.name].first
+    end
+  end
+end

data/spec/lib/tags/title_tag_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+
+describe Docks::Tags::Title do
+  subject { Docks::Tags::Title.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