docks_app 0.0.1

data/spec/lib/containers/component_container_spec.rb

@@ -0,0 +1,158 @@
+require "spec_helper"
+
+describe Docks::Containers::Component do
+  let(:sub_subcomponent) do
+    Docks::Containers::Component.new(name: "foo__bar__baz")
+  end
+
+  let(:subcomponent) do
+    Docks::Containers::Component.new(name: "foo__bar", subcomponents: [sub_subcomponent])
+  end
+
+  let(:component) do
+    Docks::Containers::Component.new(name: "foo", subcomponents: [subcomponent])
+  end
+
+  let(:states) do
+    [
+      Docks::Containers::State.new(name: "foo--is-bar"),
+      Docks::Containers::State.new(name: "foo--is-baz")
+    ]
+  end
+
+  let(:variants) do
+    [
+      Docks::Containers::Variant.new(name: "foo--bar"),
+      Docks::Containers::Variant.new(name: "foo--baz")
+    ]
+  end
+
+  describe "#has_demo?" do
+    it "has a demo when it has non-empty markup" do
+      expect(described_class.new(markup: "<p>Hi!</p>").has_demo?).to be true
+    end
+
+    it "has a demo when it has non-empty helper" do
+      expect(described_class.new(helper: "<p><%= foo %></p>").has_demo?).to be true
+    end
+
+    it "doesn't have a demo when there is no markup or helper" do
+      expect(described_class.new(foo: "bar").has_demo?).to be false
+    end
+
+    it "doesn't have a demo when the markup is empty" do
+      expect(described_class.new(markup: "").has_demo?).to be false
+    end
+
+    it "doesn't have a demo when the helper is empty" do
+      expect(described_class.new(helper: "").has_demo?).to be false
+    end
+  end
+
+  describe "#subcomponents" do
+    context "when no options are passed" do
+      it "has subcomponents when they are included on the component" do
+        expect(component.subcomponent.length).to be 1
+        expect(component.subcomponents).to include subcomponent
+      end
+
+      it "has an empty array of subcomponents when not included" do
+        component = described_class.new
+        expect(component.subcomponent).to be_an Array
+        expect(component.subcomponent).to be_empty
+      end
+    end
+
+    context "when the :recursive option is true" do
+      it "returns subcomponents recursively" do
+        subcomponents = component.subcomponents(recursive: true)
+        expect(subcomponents.length).to be 2
+        expect(subcomponents).to include subcomponent
+        expect(subcomponents).to include sub_subcomponent
+      end
+
+      it "doesn't duplicate the subcomponents" do
+        component.subcomponents(recursive: true)
+        expect(component.subcomponents.length).to be 1
+      end
+    end
+  end
+
+  describe "#variations" do
+    it "has no variations when there are no states or variants" do
+      component = described_class.new({})
+      expect(component.variations).to be_empty
+    end
+
+    it "has variations when there are only states" do
+      component = described_class.new(state: states)
+      variations = component.variations
+
+      expect(variations).not_to be_empty
+      states.each do |state|
+        expect(variations).to include(state)
+      end
+    end
+
+    it "has variations when there are only variants" do
+      component = described_class.new(variant: variants)
+      variations = component.variations
+
+      expect(variations).not_to be_empty
+      variants.each do |variant|
+        expect(variations).to include(variant)
+      end
+    end
+
+    it "has variations when there are states and variants" do
+      component = described_class.new(state: states, variant: variants)
+      variations = component.variations
+
+      expect(variations).not_to be_empty
+      (states + variants).each do |variation|
+        expect(variations).to include(variation)
+      end
+    end
+  end
+
+  describe "#find" do
+    it "returns a component when the descriptor exactly matches" do
+      expect(component.find(component.name)).to be component
+      expect(component.find("#{component.name}#bar")).to be false
+    end
+
+    it "returns a nested component when it exactly matches" do
+      expect(component.find(sub_subcomponent.name)).to be sub_subcomponent
+      expect(component.find("#{sub_subcomponent.name}#bar")).to be false
+    end
+
+    it "returns a variation when the variation name exactly matches" do
+      subcomponent.states.concat(states)
+      states.each { |state| state.for = subcomponent.name }
+      expect(component.find(states.first.name)).to be states.first
+    end
+
+    it "returns a variation that is declared as an instance member" do
+      subcomponent.states.concat(states)
+      states.each { |state| state.for = subcomponent.name }
+      expect(component.find("#{subcomponent.name}##{states.first.name}")).to be states.first
+    end
+
+    it "doesn't return a variation unless the symbol name matches" do
+      subcomponent.states.concat(states)
+      expect(component.find("qux##{states.first.name}")).to be false
+    end
+  end
+
+  describe "#summary" do
+    let(:summary) { component.summary }
+
+    it "preserves the symbol_id, name, variations, and subcomponents" do
+      expect(summary).to be_a described_class
+      expect(summary.name).to eq component.name
+      expect(summary.symbol_id).to eq component.symbol_id
+      expect(summary.variations).to eq component.variations.map(&:summary)
+      expect(summary.subcomponents).to eq component.subcomponents.map(&:summary)
+    end
+  end
+end

data/spec/lib/containers/demo_container_spec.rb

@@ -0,0 +1,113 @@
+require "spec_helper"
+
+state_one = OpenStruct.new(name: "foo", demo_type: Docks::Types::Demo::NONE)
+state_two = OpenStruct.new(name: "bar", base_class: "b", demo_type: Docks::Types::Demo::SELECT)
+variant_one = OpenStruct.new(name: "baz", demo_type: Docks::Types::Demo::SELECT)
+variant_two = OpenStruct.new(name: "qux", demo_type: Docks::Types::Demo::JOINT)
+
+
+describe Docks::Containers::Demo do
+  subject { Docks::Containers::Demo }
+
+  before :each do
+    Docks::Tags.register_bundled_tags
+  end
+
+  let(:basic_component) do
+    Docks::Containers::Component.new(name: "flarb", state: [state_one])
+  end
+
+  let(:complex_component) do
+    Docks::Containers::Component.new(name: "blarg", state: [state_one, state_two], variant: [variant_one, variant_two])
+  end
+
+  let(:basic_demo) { subject.new(basic_component) }
+  let(:complex_demo) { subject.new(complex_component) }
+
+  describe "#name" do
+    it "has the same name as its main component" do
+      expect(complex_demo.name).to eq complex_component.name
+    end
+  end
+
+  describe "#component" do
+    it "returns its main component" do
+      expect(complex_demo.component).to be complex_component
+    end
+  end
+
+  describe "#select_variations" do
+    it "has no select variations when none are included in the component" do
+      expect(basic_demo.select_variations).to eq Array.new
+    end
+
+    it "has select variations when they are included with the component" do
+      variations = complex_demo.select_variations
+      expect(variations.length).to be 2
+      expect(variations).to include state_two
+      expect(variations).to include variant_one
+    end
+
+    it "has no select variations when none are included and the user asks them to be grouped by base component" do
+      expect(basic_demo.select_variations(group_by_component: true)).to eq Hash.new
+    end
+
+    it "groups select variations by their base component when requested" do
+      variations = complex_demo.select_variations(group_by_component: true)
+
+      expect(variations.length).to be 1
+
+      component_variations = variations[complex_demo.name]
+      expect(component_variations.length).to be 2
+      expect(component_variations).to include state_two
+      expect(component_variations).to include variant_one
+    end
+
+    it "includes select variations from subcomponents" do
+      basic_component[:state] = [state_two]
+      complex_component[:subcomponents] = [basic_component]
+      variations = complex_demo.select_variations(group_by_component: true)
+
+      expect(variations.length).to be 2
+
+      subcomponent_variations = variations[basic_component.name]
+      expect(subcomponent_variations.length).to be 1
+      expect(subcomponent_variations).to include state_two
+    end
+
+    it "includes select variations from included components" do
+      basic_component[:state] = [state_two]
+      complex_component[:included_symbols] = [basic_component]
+      variations = complex_demo.select_variations(group_by_component: true)
+
+      expect(variations.length).to be 2
+
+      subcomponent_variations = variations[basic_component.name]
+      expect(subcomponent_variations.length).to be 1
+      expect(subcomponent_variations).to include state_two
+    end
+
+    it "includes select variations that are directly included" do
+      complex_component[:included_symbols] = [state_one, state_two]
+      variations = complex_demo.select_variations(group_by_component: true)
+
+      expect(variations.length).to be 2
+
+      subcomponent_variations = variations[state_two.base_class]
+      expect(subcomponent_variations.length).to be 1
+      expect(subcomponent_variations).to include state_two
+    end
+  end
+
+  describe "#joint_variations" do
+    it "has no joint variations when none are included in the component" do
+      expect(basic_demo.joint_variations).to eq Array.new
+    end
+
+    it "has joint variations when they are included in the component" do
+      variations = complex_demo.joint_variations
+      expect(variations.length).to be 1
+      expect(variations).to include variant_two
+    end
+  end
+end

data/spec/lib/containers/function_container_spec.rb

@@ -0,0 +1,116 @@
+require "spec_helper"
+
+describe Docks::Containers::Function do
+  let(:instance_method) do
+    described_class.new(name: "foo", static: false, method: true, for: "Foo")
+  end
+
+  let(:static_method) do
+    described_class.new(name: "bar", static: true, method: true, for: "Foo")
+  end
+
+  let(:function) do
+    described_class.new(name: "baz")
+  end
+
+  let(:factory) do
+    Docks::Containers::Factory.new(name: "Foo")
+  end
+
+  before(:each) do
+    factory.add_members(instance_method, static_method)
+  end
+
+  describe "#static?" do
+    it "returns true for a static method" do
+      expect(instance_method.static?).to be false
+      expect(static_method.static?).to be true
+    end
+  end
+
+  describe "#instance?" do
+    it "returns true for an instance method" do
+      expect(instance_method.instance?).to be true
+      expect(static_method.instance?).to be false
+    end
+  end
+
+  describe "#method?" do
+    it "is a method when it has a for attribute" do
+      expect(function.method?).to be false
+      expect(instance_method.method?).to be true
+    end
+  end
+
+  describe "#symbol_id" do
+    it "returns the default if the function is not a method" do
+      expect(function.symbol_id).to eq "function-#{function.name}"
+    end
+
+    it "indicates it's a method and adds the classlike's name if it is a method" do
+      expect(instance_method.symbol_id).to eq "method-#{factory.name}-#{instance_method.name}"
+    end
+
+    it "indicates that it's static if appropriate" do
+      expect(static_method.symbol_id).to eq "method-static-#{factory.name}-#{static_method.name}"
+    end
+  end
+
+  describe "#to_descriptor" do
+    let(:pattern) { Docks::Containers::Pattern.new(name: "foo") }
+
+    it "returns the super descriptor if not a property" do
+      expect(function.to_descriptor).to eq function.name
+
+      pattern.add(:script, function)
+      expect(function.to_descriptor).to eq "#{pattern.name}::#{function.name}"
+    end
+
+    it "returns the proper instance property descriptor" do
+      pattern.add(:script, factory)
+      expect(instance_method.to_descriptor).to eq "#{factory.to_descriptor}##{instance_method.name}"
+    end
+
+    it "returns the proper static property descriptor" do
+      pattern.add(:script, factory)
+      expect(static_method.to_descriptor).to eq "#{factory.to_descriptor}.#{static_method.name}"
+    end
+  end
+
+  describe "#summary" do
+    it "preserves the symbol_id, name, static and method status" do
+      [static_method, instance_method, function].each do |func|
+        summary = func.summary
+
+        expect(summary).to be_a described_class
+        expect(summary.name).to eq func.name
+        expect(summary.symbol_id).to eq func.symbol_id
+        expect(summary.method?).to eq func.method?
+        expect(summary.static?).to eq func.static?
+      end
+    end
+  end
+
+  describe "#find" do
+    it "finds the function if it's not a method and the symbol matches" do
+      expect(function.find(function.name)).to be function
+      expect(function.find(static_method.name)).to be false
+      expect(static_method.find(static_method.name)).to be false
+      expect(instance_method.find(instance_method.name)).to be false
+    end
+
+    it "finds the function if it's a static method and the name matches" do
+      expect(function.find("foo.#{function.name}")).to be false
+      expect(static_method.find("foo.#{static_method.name}")).to be static_method
+      expect(static_method.find("foo.#{instance_method.name}")).to be false
+      expect(instance_method.find("foo.#{instance_method.name}")).to be false
+    end
+
+    it "finds the function if it's an instance method and the name matches" do
+      expect(function.find("foo##{function.name}")).to be false
+      expect(static_method.find("foo##{static_method.name}")).to be false
+      expect(instance_method.find("foo##{instance_method.name}")).to be instance_method
+      expect(static_method.find("foo##{static_method.name}")).to be false
+    end
+  end
+end

data/spec/lib/containers/mixin_container_spec.rb

@@ -0,0 +1,4 @@
+require "spec_helper"
+
+describe Docks::Containers::Mixin do
+end

data/spec/lib/containers/pattern_container_spec.rb

@@ -0,0 +1,291 @@
+require "spec_helper"
+
+describe Docks::Containers::Pattern do
+  before :each do
+    Docks::Tags.register_bundled_tags
+  end
+
+  let(:name) { "button" }
+  let(:title) { "UI Button" }
+  let(:now) { Date.parse("1991-01-11") }
+  let(:pattern_symbol) { Docks::Containers::Symbol.new(pattern: title) }
+  let(:pattern) { described_class.new(name: name) }
+
+  describe "#name" do
+    it "is the name of the pattern during initialization" do
+      expect(pattern.name).to eq name
+    end
+  end
+
+  describe "#title" do
+    it "is the capitalized name of the pattern if pattern block has been added" do
+      expect(pattern.title).to eq name.capitalize
+    end
+
+    it "is the title specified in the pattern block if it has been added" do
+      pattern.add(:style, pattern_symbol)
+      expect(pattern.title).to eq title
+    end
+  end
+
+  describe "#group" do
+    it "defaults to including the pattern in some common group" do
+      group_1, group_2 = pattern.group, described_class.new(name: "foo").group
+      expect(group_1).to_not be nil
+      expect(group_1).to eq group_2
+    end
+
+    it "uses the group from the pattern block, if added" do
+      pattern_symbol[Docks::Tags::Group] = "foo"
+      pattern.add(:style, pattern_symbol)
+      expect(pattern.group).to eq "foo"
+    end
+  end
+
+  describe "#valid?" do
+    it "is invalid if it has no pattern block and no other symbols" do
+      expect(pattern.valid?).to be false
+    end
+
+    it "is valid if it has a pattern block" do
+      pattern.add(:style, pattern_symbol)
+      expect(pattern.valid?).to be true
+    end
+
+    it "isn't valid if all details of the pattern are nil" do
+      pattern.description = nil
+      expect(pattern.valid?).to be false
+    end
+
+    it "is valid if any other symbol has been added" do
+      pattern.add(:script, Docks::Containers::Function.new)
+      expect(pattern.valid?).to be true
+    end
+  end
+
+  describe "#structure_symbols" do
+    before(:each) do
+      pattern.add(:style, Docks::Containers::Component.new)
+      pattern.add(:script, Docks::Containers::Component.new)
+    end
+
+    it "returns all symbols from style sources" do
+      expect(pattern.structure_symbols.length).to be 1
+    end
+
+    it "is aliased to #style_symbols" do
+      expect(pattern.style_symbols).to be pattern.structure_symbols
+    end
+  end
+
+  describe "#has_structure?" do
+    it "has no structure when there are no style results" do
+      expect(pattern.has_structure?).to be false
+    end
+
+    it "has structure when there are style results" do
+      pattern.add(:style, Docks::Containers::Component.new)
+      expect(pattern.has_structure?).to be true
+    end
+  end
+
+  describe "#behavior_symbols" do
+    before(:each) do
+      pattern.add(:style, Docks::Containers::Component.new)
+      pattern.add(:script, Docks::Containers::Component.new)
+    end
+
+    it "returns all symbols from style sources" do
+      expect(pattern.behavior_symbols.length).to be 1
+    end
+
+    it "is aliased to #script_symbols" do
+      expect(pattern.script_symbols).to be pattern.behavior_symbols
+    end
+  end
+
+  describe "#has_behavior?" do
+    it "has no behavior when there are no script results" do
+      expect(pattern.has_behavior?).to be false
+    end
+
+    it "has behavior when there are script results" do
+      pattern.add(:script, Docks::Containers::Factory.new)
+      expect(pattern.has_behavior?).to be true
+    end
+  end
+
+  describe "#add" do
+    let(:dummy_symbol_1) { Docks::Containers::Symbol.new }
+    let(:dummy_symbol_2) { Docks::Containers::Symbol.new }
+
+    it "adds a symbol to the passed source" do
+      pattern.add(:script, dummy_symbol_1)
+      pattern.add(:style, dummy_symbol_2)
+
+      expect(pattern.behavior_symbols.length).to be 1
+      expect(pattern.behavior_symbols.first).to be dummy_symbol_1
+      expect(pattern.structure_symbols.length).to be 1
+      expect(pattern.structure_symbols.first).to be dummy_symbol_2
+    end
+
+    it "adds an array of symbols to the passed source" do
+      pattern.add(:script, [dummy_symbol_1, dummy_symbol_2])
+
+      expect(pattern.behavior_symbols.length).to be 2
+      expect(pattern.behavior_symbols).to eq [dummy_symbol_1, dummy_symbol_2]
+    end
+
+    it "doesn't add a pattern symbol to the passed source" do
+      pattern.add(:script, pattern_symbol)
+      expect(pattern.behavior_symbols).to be_empty
+    end
+
+    it "still adds the other symbols in a passed array even if a pattern symbol is among them" do
+      pattern.add(:script, [dummy_symbol_1, pattern_symbol, dummy_symbol_2])
+
+      expect(pattern.behavior_symbols.length).to be 2
+      expect(pattern.behavior_symbols).to eq [dummy_symbol_1, dummy_symbol_2]
+    end
+
+    it "adds the belongs_to attribute to all contained symbols" do
+      pattern.add(:script, [dummy_symbol_1, dummy_symbol_2])
+
+      pattern.symbols.each do |symbol|
+        expect(symbol.belongs_to).to be pattern
+      end
+    end
+  end
+
+  describe "#remove" do
+    it "removes a symbol" do
+      symbol = Docks::Containers::Symbol.new
+      pattern.add(:style, symbol)
+      expect(pattern.structure_symbols).to include symbol
+      pattern.remove(symbol)
+      expect(pattern.structure_symbols).not_to include symbol
+    end
+  end
+
+  describe "#method_missing" do
+    it "delegates missing methods to the pattern block" do
+      expect(pattern.deprecated).to be nil
+
+      pattern_symbol.deprecated = "2.0"
+      pattern.add(:style, pattern_symbol)
+      expect(pattern.deprecated).to eq "2.0"
+    end
+  end
+
+  describe "#find" do
+    it "returns itself if there is a matching pattern name and no symbol" do
+      expect(pattern.find(Docks::Descriptor.new(pattern.name, assume: :pattern))).to be pattern
+    end
+
+    it "returns false when it can't find a given symbol" do
+      expect(pattern.find("foo")).to be false
+    end
+
+    it "returns a symbol whose name matches the passed descriptor" do
+      symbol = Docks::Containers::Component.new(name: "bar")
+      pattern.add(:style, symbol)
+      expect(pattern.find(symbol.name)).to be symbol
+    end
+
+    it "asks the contained symbol to find the descriptor and returns if successful" do
+      method = Docks::Containers::Function.new(name: "toggle", method: true)
+      factory = Docks::Containers::Factory.new(name: "Foo")
+      factory.add_member(method)
+
+      pattern.add(:script, factory)
+
+      search = Docks::Descriptor.new("Foo#toggle")
+      expect(factory).to receive(:find).with(search).and_call_original
+      expect(pattern.find(search)).to be method
+    end
+  end
+
+  describe "container associations" do
+    it "includes a method to access all symbols of a given type" do
+      Docks::Containers::TOP_LEVEL_SYMBOLS.each do |symbol|
+        symbol_instance = Docks::Containers.container_for(symbol).new(name: "foo")
+        pattern.add(:script, symbol_instance)
+
+        results_of_symbol = pattern.send(symbol.pluralize.to_sym)
+        expect(results_of_symbol.length).to be 1
+        expect(results_of_symbol.first).to be symbol_instance
+      end
+    end
+
+    it "includes only the set of symbols of a given type matching the passed options" do
+      Docks::Containers::TOP_LEVEL_SYMBOLS.each do |symbol|
+        symbol_instance = Docks::Containers.container_for(symbol).new(name: "foo")
+        pattern.add(:script, symbol_instance)
+
+        results_of_symbol = pattern.send(symbol.pluralize.to_sym, exclude: :script)
+        expect(results_of_symbol.length).to be 0
+
+        results_of_symbol = pattern.send(symbol.pluralize.to_sym, include: :script)
+        expect(results_of_symbol.length).to be 1
+        expect(results_of_symbol.first).to be symbol_instance
+
+        results_of_symbol = pattern.send(symbol.pluralize.to_sym, exclude: :style)
+        expect(results_of_symbol.length).to be 1
+        expect(results_of_symbol.first).to be symbol_instance
+      end
+    end
+  end
+
+  describe "#symbols" do
+    it "combines all symbol sources" do
+      symbol_one = Docks::Containers::Symbol.new(name: "foo")
+      symbol_two = Docks::Containers::Symbol.new(name: "bar")
+      symbol_three = Docks::Containers::Symbol.new(name: "baz")
+      pattern.add(:style, symbol_one)
+      pattern.add(:script, symbol_two)
+      pattern.add(:style, symbol_three)
+
+      symbols = pattern.symbols
+      expect(symbols.length).to be 3
+      expect(symbols).to include symbol_one
+      expect(symbols).to include symbol_two
+      expect(symbols).to include symbol_three
+    end
+  end
+
+  describe "#demos" do
+    it "creates a demo for each component that needs one" do
+      component_one = Docks::Containers::Component.new(name: "foo")
+      component_two = Docks::Containers::Component.new(name: "bar")
+      pattern.add(:style, [component_one, component_two])
+
+      expect(component_one).to receive(:has_demo?).and_return(true)
+      expect(component_two).to receive(:has_demo?).and_return(false)
+
+      expect(pattern.demos.length).to be 1
+      expect(pattern.demos.first.component).to be component_one
+    end
+
+    it "creates a demo for variations that need one" do
+      variant = OpenStruct.new(demo_type: Docks::Types::Demo::OWN, name: "bar--baz")
+      component = Docks::Containers::Component.new(name: "bar", variant: [variant])
+      pattern.add(:style, component)
+
+      expect(pattern.demos.length).to be 1
+      expect(pattern.demos.last.component).to be variant
+    end
+  end
+
+  describe "#summary" do
+    before(:each) { pattern.add(:script, Docks::Containers::Function.new(name: "foo")) }
+    let(:summary) { pattern.summary }
+
+    it "preserves the name, group, title, and symbols" do
+      expect(summary).to be_a described_class
+      expect(summary.name).to eq pattern.name
+      expect(summary.group).to eq pattern.group
+      expect(summary.title).to eq pattern.title
+      expect(summary.symbols).to eq pattern.symbols.map(&:summary)
+    end
+  end
+end