docks_app 0.0.1

data/spec/lib/tags/type_tag_spec.rb

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

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

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

data/spec/lib/tags/variation_tag_spec.rb

@@ -0,0 +1,154 @@
+require "spec_helper"
+
+describe Docks::Tags::Variation do
+  subject { described_class.instance }
+
+  it "can't be be parsed from files" do
+    expect(subject.parseable?).to be false
+  end
+
+  describe "post process" do
+    before(:each) { Docks::Tags.register_bundled_tags }
+
+    describe "joining variations to their components" do
+      let(:pattern) { Docks::Containers::Pattern.new(name: "foo") }
+      let(:subcomponent) { Docks::Containers::Component.new(name: "foo__bar") }
+      let(:component) { Docks::Containers::Component.new(name: "foo", subcomponents: [subcomponent]) }
+      let(:state) { Docks::Containers::State.new(name: "foo--is-bar") }
+      let(:subcomponent_variant) { Docks::Containers::Variant.new(name: "foo__bar--baz") }
+
+      it "joins orphan variations to their component" do
+        pattern.add(:style, [state, component])
+        Docks::Process.process(pattern)
+
+        expect(pattern.style_symbols.length).to be 1
+        expect(pattern.components.length).to be 1
+        expect(pattern.components.first).to be component
+        expect(pattern.components.first.states.length).to be 1
+        expect(pattern.components.first.states.first).to be state
+      end
+
+      it "joins orphan variations to subcomponents" do
+        pattern.add(:style, [component, subcomponent_variant])
+        Docks::Process.process(pattern)
+
+        expect(pattern.style_symbols.length).to be 1
+        expect(pattern.components.length).to be 1
+
+        the_component = pattern.components.first
+        the_subcomponent = component.subcomponents.first
+
+        expect(the_component.variants).to be_empty
+        expect(the_subcomponent.variants.length).to be 1
+        expect(the_subcomponent.variants.first).to be subcomponent_variant
+      end
+
+      it "creates components for the variation if they don't exist" do
+        pattern.add(:style, [subcomponent_variant])
+        Docks::Process.process(pattern)
+
+        expect(pattern.style_symbols.length).to be 1
+        expect(pattern.components.length).to be 1
+
+        component = pattern.find(Docks::NamingConventions::BEM.instance.component(subcomponent_variant.name))
+        expect(component.variants.length).to be 1
+        expect(component.variants.first).to be subcomponent_variant
+      end
+    end
+
+    describe "clean up names" do
+      let(:pattern) { Docks::Containers::Pattern.new(name: "foo") }
+      let(:variation) { Docks::Containers::State.new(name: "foo--is-bar", activate_with: ["--baz", "foo--fuzz"], precludes: "--qux") }
+      let(:bad_name_variation) { Docks::Containers::Variant.new(name: "--baz") }
+
+      let(:subcomponent) { Docks::Containers::Component.new(name: "foo__bar", variants: [bad_name_variation]) }
+      let(:component) { Docks::Containers::Component.new(name: "foo", states: [variation], subcomponents: [subcomponent]) }
+
+      before(:each) do
+        pattern.add(:style, component)
+        Docks::Process.process(pattern)
+      end
+
+      it "prepends the names of variations with the base class if necessary" do
+        expect(variation.name).to eq "foo--is-bar"
+        expect(bad_name_variation.name).to eq "foo__bar--baz"
+      end
+
+      it "prepends the names of active withs and precludes" do
+        expect(variation.activate_with.first).to eq "foo--baz"
+        expect(variation.activate_with.last).to eq "foo--fuzz"
+        expect(variation.precludes.first).to eq "foo--qux"
+      end
+    end
+
+    describe "mirroring preclusions" do
+      let(:state_one) { Docks::Containers::State.new(name: "tab--is-active") }
+      let(:state_two) { Docks::Containers::State.new(name: "tab--is-inactive", precludes: [state_one.name]) }
+      let(:variant_one) { Docks::Containers::Variant.new(name: "tab--large", precludes: [state_two.name]) }
+      let(:subcomponent_variant) { Docks::Containers::Variant.new(name: "tab__text--subdued") }
+      let(:subcomponent_state) { Docks::Containers::State.new(name: "tab__text--is-blinking", precludes: [subcomponent_variant.name]) }
+      let(:subcomponent) { Docks::Containers::Component.new(name: "tab__text") }
+      let(:component) { Docks::Containers::Component.new(name: "tab", subcomponents: [subcomponent]) }
+
+      let(:pattern) do
+        pattern = Docks::Containers::Pattern.new(name: "tab")
+        pattern.add(:style, component)
+        pattern
+      end
+
+      it "mirrors a single preclusion to the precluded state/ variant" do
+        component.states << state_one
+        component.states << state_two
+        component.variants << variant_one
+        post_process
+
+        expect(state_one.precludes.length).to be 1
+        expect(state_one.precludes).to include state_two.name
+
+        expect(state_two.precludes.length).to be 2
+        expect(state_two.precludes).to include variant_one.name
+      end
+
+      it "does not mirror a preclusion if the class is already included" do
+        state_one.precludes << state_two.name
+        component.states << state_one
+        component.states << state_two
+        post_process
+
+        expect(state_one.precludes.length).to be 1
+        expect(state_one.precludes).to include state_two.name
+      end
+
+      it "mirrors preclusions to multiple states/ variants" do
+        variant_one.precludes << state_one.name
+        component.states << state_one
+        component.states << state_two
+        component.variants << variant_one
+        post_process
+
+        expect(state_one.precludes.length).to be 2
+        expect(state_one.precludes).to include variant_one.name
+
+        expect(state_two.precludes.length).to be 2
+        expect(state_one.precludes).to include variant_one.name
+
+        expect(variant_one.precludes.length).to be 2
+      end
+
+      it "mirror preclusions in subcomponents" do
+        subcomponent.states << subcomponent_state
+        subcomponent.variants << subcomponent_variant
+        post_process
+
+        expect(subcomponent_variant.precludes.length).to be 1
+        expect(subcomponent_variant.precludes).to include subcomponent_state.name
+      end
+
+      private
+
+      def post_process
+        Docks::Process.process(pattern)
+      end
+    end
+  end
+end

data/spec/lib/tags_spec.rb

@@ -0,0 +1,264 @@
+require "spec_helper"
+
+class Example1 < Docks::Tags::Base
+  def initialize
+    @name = :name
+    @synonyms = [:nom, :nome]
+    @multiple_allowed = true
+  end
+end
+
+class Example2 < Docks::Tags::Base
+  def initialize
+    @name = :title
+    @synonyms = [:titre]
+  end
+end
+
+class Example3 < Docks::Tags::Base
+  def initialize
+    @name = :group
+    @parseable = false
+  end
+end
+
+describe Docks::Tags do
+  subject { Docks::Tags }
+
+  let(:example) { Example1.instance }
+
+  before :each do
+    subject.send(:clean)
+  end
+
+  describe ".tag_for" do
+    before :each do
+      subject.register(Example1)
+    end
+
+    it "returns an instance of the tag class in response to the base tag name" do
+      expect(subject.tag_for(example.name)).to be_an Example1
+    end
+
+    it "returns an instance of the tag class in response to a synonym" do
+      example.synonyms.each do |synonym|
+        expect(subject.tag_for(synonym)).to be_an Example1
+      end
+    end
+
+    it "returns nil in response to an unregistered tag name" do
+      expect(subject.tag_for(:foo)).to be nil
+    end
+  end
+
+  describe ".base_tag_name" do
+    before :each do
+      subject.register(Example1)
+      subject.register(Example2)
+    end
+
+    it "returns the passed name if it is a base tag name" do
+      expect(subject.base_tag_name(example.name)).to be example.name
+    end
+
+    it "returns the base tag name for a synonym" do
+      expect(subject.base_tag_name(example.synonyms.first)).to be example.name
+    end
+
+    it "returns nil if the tag is not registered" do
+      expect(subject.base_tag_name(:foo)).to be nil
+    end
+
+    it "returns the name if the tag class is passed" do
+      expect(subject.base_tag_name(example)).to be example.name
+    end
+
+    it "returns the singularized name if the tag allows multiple" do
+      expect(subject.base_tag_name(example)).to be example.name
+    end
+
+    it "returns nil for a pluralized name with multiples prevented" do
+      expect(subject.base_tag_name(Example2.instance.name.to_s.pluralize)).to be nil
+    end
+
+    it "returns the singularized name of a pluralized synonym" do
+      expect(subject.base_tag_name(example.synonyms.first.to_s.pluralize)).to be example.name
+    end
+
+    it "doesn't return anything for the pluralized name of a synonym for a tag that has no multiples" do
+      expect(subject.base_tag_name(Example2.instance.synonyms.first.to_s.pluralize)).to be nil
+    end
+  end
+
+  describe ".supported_tags" do
+    it "lists all supported tags, including synonyms and plurals" do
+      expect(subject.supported_tags).to eq []
+
+      tags = [Example1, Example2, Example3]
+      tags.each { |tag| subject.register(tag) }
+
+      supported_tags = subject.supported_tags
+
+      tags.each do |tag|
+        tag = tag.instance
+        expect(supported_tags).to include tag.name
+        expect(supported_tags.include?(tag.name.to_s.pluralize.to_sym)).to be tag.multiple_allowed?
+
+        tag.synonyms.each do |synonym|
+          expect(supported_tags).to include synonym
+          expect(supported_tags.include?(synonym.to_s.pluralize.to_sym)).to be tag.multiple_allowed?
+        end
+      end
+    end
+  end
+
+  describe ".supported_parseable_tags" do
+    it "lists only tags that are parseable" do
+      expect(subject.supported_parseable_tags).to eq []
+
+      [Example1, Example2, Example3].each { |tag| subject.register(tag) }
+
+      supported_tags = subject.supported_parseable_tags
+
+      [Example1, Example2].each do |tag|
+        tag = tag.instance
+        expect(supported_tags).to include tag.name
+        expect(supported_tags.include?(tag.name.to_s.pluralize.to_sym)).to be tag.multiple_allowed?
+
+        tag.synonyms.each do |synonym|
+          expect(supported_tags).to include synonym
+          expect(supported_tags.include?(synonym.to_s.pluralize.to_sym)).to be tag.multiple_allowed?
+        end
+      end
+
+      tag = Example3.instance
+
+      expect(supported_tags).not_to include tag.name
+      expect(supported_tags).not_to include tag.name.to_s.pluralize.to_sym
+
+      tag.synonyms.each do |synonym|
+        expect(supported_tags).not_to include synonym.name
+        expect(supported_tags).not_to include synonym.name.to_s.pluralize.to_sym
+      end
+    end
+  end
+
+  describe ".register_bundled_tags" do
+    it "registers all bundled tags" do
+      subject.register_bundled_tags
+      supported_tags = subject.supported_tags
+
+      bundled = Docks::Tags.constants.select do |const|
+        klass = Docks::Tags.const_get(const)
+        Class === klass && !(klass.eql?(Docks::Tags::Base))
+      end
+
+      bundled.each do |bundled_tag|
+        bundled_tag = Docks::Tags.const_get(bundled_tag).instance
+        [bundled_tag.name, bundled_tag.synonyms].flatten.each do |name|
+          expect(supported_tags).to include bundled_tag.name
+        end
+      end
+    end
+  end
+
+  describe ".join_synonymous_tags" do
+    let(:value) { "foo" }
+    let(:example_hash) { Hash.new }
+    let(:target_hash) { Hash.new }
+
+    before :each do
+      subject.register(Example1)
+    end
+
+    it "leaves hashes with keys based on the base tag name alone" do
+      example_hash[example.name] = value
+      expect(subject.join_synonymous_tags(example_hash)).to eq example_hash
+    end
+
+    it "renames a synonym hash with its base tag name" do
+      example_hash[example.synonyms.first] = value
+      target_hash[example.name] = value
+      expect(subject.join_synonymous_tags(example_hash)).to eq target_hash
+    end
+
+    it "renames a pluralized tag to its base tag name" do
+      example_hash[example.name.to_s.pluralize.to_sym] = value
+      target_hash[example.name] = value
+      expect(subject.join_synonymous_tags(example_hash)).to eq target_hash
+    end
+
+    it "joins together results of a synonym with results of the base tag name" do
+      example_hash[example.name] = [-1]
+      example.synonyms.each_with_index do |synonym, index|
+        example_hash[synonym] = [index]
+      end
+
+      target_hash[example.name] = (-1...example.synonyms.length).to_a
+      expect(subject.join_synonymous_tags(example_hash)).to eq target_hash
+    end
+
+    it "removes results for unrecognized tags" do
+      example_hash[:foo] = "bar"
+      expect(subject.join_synonymous_tags(example_hash)).to eq Hash.new
+    end
+  end
+
+  describe ".has_tag?" do
+    it "indicates that no tag exists when not previously registered" do
+      expect(subject.has_tag?(example.name)).to be false
+    end
+
+    it "indicates the presence of a tag that has been registered by its name" do
+      subject.register(Example1)
+      expect(subject.has_tag?(example.name)).to be true
+    end
+
+    it "indicates the presence of a tag that has been registered by its class" do
+      subject.register(Example1)
+      expect(subject.has_tag?(Example1)).to be true
+    end
+  end
+
+  describe ".register" do
+    it "registers a tag" do
+      subject.register(Example1)
+
+      expect(subject.has_tag?(example.name)).to be true
+      expect(subject.supported_tags).to include example.name
+    end
+
+    it "registers synonyms" do
+      subject.register(Example1)
+
+      example.synonyms.each do |synonym|
+        expect(subject.has_tag?(synonym)).to be true
+        expect(subject.supported_tags).to include synonym
+      end
+    end
+
+    it "registers synonyms to their respective base tag" do
+      subject.register(Example1)
+      subject.register(Example2)
+
+      example.synonyms.each do |synonym|
+        expect(subject.tag_for(synonym)).to be example
+      end
+
+      example2 = Example2.instance
+      example2.synonyms.each do |synonym|
+        expect(subject.tag_for(synonym)).to be example2
+      end
+    end
+
+    it "allows the tag to setup its post processing" do
+      expect(Example1.instance).to receive(:setup_post_processors)
+      subject.register(Example1)
+    end
+
+    it "is aliased to <<" do
+      expect(subject).to receive(:register).with Example1
+      subject << Example1
+    end
+  end
+end

data/spec/lib/templates_spec.rb

@@ -0,0 +1,185 @@
+require "spec_helper"
+
+describe Docks::Templates do
+  subject { Docks::Templates }
+
+  after :each do
+    subject.send(:clean)
+  end
+
+  describe ".register" do
+    let(:templates) do
+      { "foo" => "bar", "bar" => "baz" }
+    end
+
+    it "calls the private hash registering method when the first argument is a hash" do
+      expect(subject).to receive(:register_from_hash).with(templates)
+      subject.register(templates)
+    end
+
+    it "registers each template for a pattern matching the passed key" do
+      templates.each do |match, template|
+        expect(subject).to receive(:register).with(template, for: Regexp.new(match.to_s))
+      end
+      subject.send(:register_from_hash, templates)
+    end
+
+    it "registers a template with the fallback or default key as the fallback template" do
+      templates["default"] = "default"
+      expect(subject).to receive(:fallback=).with(templates["default"])
+      expect(subject).not_to receive(:register).with(templates["default"], for: Regexp.new("default"))
+      subject.send(:register_from_hash, templates)
+
+      templates["fallback"] = "default"
+      expect(subject).to receive(:fallback=).with(templates["fallback"])
+      subject.send(:register_from_hash, templates)
+    end
+
+    it "registers a template with the :demo key as the demo template" do
+      templates["demo"] = "my-custom-demo"
+      expect(subject).to receive(:demo=).with(templates["demo"])
+      expect(subject).not_to receive(:register).with(templates["demo"], for: Regexp.new("demo"))
+      subject.send(:register_from_hash, templates)
+    end
+  end
+
+  describe ".template_for" do
+    context "when no template matches" do
+      it "provides the default template when no other template matches" do
+        expect(subject.template_for("foo")).to be subject.fallback
+      end
+
+      it "allows setting a custom default template" do
+        template = "custom_default"
+
+        subject.fallback = template
+        expect(subject.template_for("foo").path).to eq template
+      end
+    end
+
+    it "returns a template whose :matches matches the passed ID" do
+      template = "custom_template"
+      subject.register(template, matches: /foo/)
+      expect(subject.template_for("foo").path).to eq template
+    end
+
+    it "returns a template whose :for matches the passed ID" do
+      template = "custom_template"
+      subject.register(template, for: /bar/)
+      expect(subject.template_for("bar").path).to eq template
+    end
+
+    it "returns a template matching the name of a passed pattern" do
+      template = "custom_template"
+      subject.register(template, for: /bar/)
+      expect(subject.template_for(Docks::Containers::Pattern.new(name: "bar")).path).to eq template
+    end
+
+    it "returns the last template matching the passed ID" do
+      subject.register("template_1", for: /bar/)
+      subject.register("template_2", for: /bar/)
+      expect(subject.template_for("bar").path).to eq "template_2"
+    end
+
+    it "throws an error when no template matches the path" do
+      expect { subject.search_for_template("fuzz") }.to raise_error Docks::NoTemplateError
+    end
+
+    it "throws an error with customized messaging for partials, layouts, and normal templates" do
+      expect { subject.search_for_template("fuzz") }.to raise_error %r{No template matching}
+      expect { subject.search_for_template("fuzz", must_be: :layout) }.to raise_error %r{No layout matching}
+      expect { subject.search_for_template("fuzz", must_be: :partial) }.to raise_error %r{No partial matching}
+    end
+  end
+
+  describe ".default_layout=" do
+    it "has the correct default layout" do
+      expect(subject.fallback.layout).to eq "pattern"
+    end
+
+    it "uses the passed default layout" do
+      layout = "my_layout"
+      subject.default_layout = layout
+      subject.register("no_layout", matches: /no_layout/)
+      subject.register("with_layout", matches: /with_layout/, layout: "custom_layout")
+
+      expect(subject.fallback.layout).to eq layout
+      expect(subject.template_for("no_layout").layout).to eq layout
+      expect(subject.template_for("with_layout").layout).not_to eq layout
+    end
+  end
+
+  describe ".demo=" do
+    it "saves the passed template as the demo template" do
+      demo = "custom_demo"
+      subject.demo = demo
+      expect(subject.demo.path).to eq demo
+    end
+
+    it "uses the default demo layout when none is passed" do
+      demo = "custom_demo"
+      subject.demo = demo
+      expect(subject.demo.layout).to eq "demo"
+    end
+
+    it "uses the passed demo layout" do
+      demo_layout = "custom_demo_layout"
+      subject.demo = Docks::Templates::Template.new("custom_demo", layout: demo_layout)
+      expect(subject.demo.layout).to eq demo_layout
+    end
+  end
+
+  describe ".search_for_template" do
+    it "does nothing when a non-string argument is passed" do
+      expect(subject.search_for_template(false)).to be nil
+    end
+  end
+
+  describe ".last_template_update" do
+    before(:each) do
+      Docks.configure_with(root: File.expand_path("../../fixtures/renderers", __FILE__), templates: "templates")
+    end
+
+    it "returns the date of the most recently modified template" do
+      templates = Dir[Docks.config.templates + "**/*.*"]
+      FileUtils.touch(templates.first)
+      expect(subject.last_template_update).to eq File.mtime(templates.first)
+    end
+  end
+end
+
+describe Docks::Templates::Template do
+  subject { Docks::Templates::Template }
+
+  describe "#path" do
+    it "uses the passed template as the path" do
+      path = "path/to/template"
+      expect(subject.new(path).path).to eq path
+    end
+  end
+
+  describe "#layout" do
+    it "uses the layout from the constructor as the layout" do
+      layout = "my_layout"
+      expect(subject.new("path", layout: layout).layout).to eq layout
+    end
+
+    it "uses the default layout when none is provided in the constructor" do
+      expect(subject.new("path").layout).to eq Docks::Templates.default_layout
+    end
+  end
+
+  describe "#matches?" do
+    it "uses the :matches key from the passed option" do
+      template = subject.new("path", matches: /foo/)
+      expect(template.matches?("foo")).to be true
+      expect(template.matches?("bar")).to be false
+    end
+
+    it "uses the :for key from the passed option" do
+      template = subject.new("path", for: /foo/)
+      expect(template.matches?("foo")).to be true
+      expect(template.matches?("bar")).to be false
+    end
+  end
+end

data/spec/lib/themes_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+describe Docks::Themes do
+  subject { described_class }
+  let(:theme) { described_class::API }
+
+  describe ".for" do
+    it "gets the theme from a string" do
+      expect(described_class.for("API")).to be_a theme
+    end
+
+    it "gets the theme from a symbol" do
+      expect(described_class.for(:API)).to be_a theme
+    end
+
+    it "gets the theme from a class" do
+      expect(described_class.for(theme)).to be_a theme
+    end
+
+    it "gets the theme from an instance" do
+      expect(described_class.for(theme.instance)).to be_a theme
+    end
+
+    it "sets the theme to be false if it can't be required" do
+      expect(described_class.for(:FOO)).to be false
+    end
+
+    it "doesn't throw an error when it fails" do
+      expect { described_class.for(:FOO) }.not_to raise_error
+    end
+  end
+end