docks_app 0.0.1

data/spec/lib/containers/pattern_library_container_spec.rb

@@ -0,0 +1,130 @@
+require "spec_helper"
+
+describe Docks::Containers::PatternLibrary do
+  subject { described_class.new }
+
+  let(:name) { "button" }
+
+  let(:pattern_one) do
+    Docks::Containers::Pattern.new(name: name)
+  end
+
+  let(:factory) do
+    Docks::Containers::Factory.new(name: "CodeBlock")
+  end
+
+  let(:pattern_two) do
+    pattern = Docks::Containers::Pattern.new(name: "code_block")
+    pattern.add(:script, factory)
+    pattern
+  end
+
+  describe "#<<" do
+    it "adds a pattern" do
+      subject << pattern_one
+      expect(subject.has_pattern?(name)).to be true
+    end
+  end
+
+  describe "#[]" do
+    it "returns nil for a name that doesn't match any patterns" do
+      expect(subject["foo"]).to be nil
+    end
+
+    it "returns a pattern whose name matches the passed name" do
+      subject << pattern_two
+      subject << pattern_one
+      expect(subject[pattern_one.name]).to be pattern_one
+      expect(subject[pattern_two.name.split("_").join("-")]).to be pattern_two
+    end
+  end
+
+  describe "#has_pattern?" do
+    it "returns false for a pattern that doesn't exist" do
+      expect(subject.has_pattern?("foo")).to be false
+    end
+
+    it "returns true for a pattern that matches the passed name" do
+      subject << pattern_two
+      subject << pattern_one
+      expect(subject.has_pattern?(pattern_one.name)).to be true
+      expect(subject.has_pattern?(pattern_two.name.split("_").join("-"))).to be true
+    end
+  end
+
+  describe "#group_by" do
+    it "groups symbols on the passed attribute" do
+      result = {}
+      subject << pattern_one
+      subject << pattern_two
+
+      subject.group_by(:name) do |name, group|
+        result[name] = group
+      end
+
+      expect(result).to eq("button" => [pattern_one], "code_block" => [pattern_two])
+    end
+  end
+
+  describe "#groups" do
+    it "groups by each pattern's group" do
+      result = {}
+      pattern_one.group = "foo"
+      pattern_two.group = "foo"
+      subject << pattern_one
+      subject << pattern_two
+
+      subject.groups do |group_name, group|
+        result[group_name] = group
+      end
+
+      expect(result).to eq("foo" => [pattern_one, pattern_two])
+    end
+  end
+
+  describe "#find" do
+    before :each do
+      subject << pattern_one
+      subject << pattern_two
+    end
+
+    it "returns false when no pattern matches the passed descriptor" do
+      expect(subject.find("foo")).to be false
+      expect(subject.find("foo::bar")).to be false
+      expect(subject.find("foo#bar")).to be false
+    end
+
+    it "finds a pattern with a name matching the passed descriptor" do
+      expect(subject.find(pattern_two.name)).to eq OpenStruct.new(pattern: pattern_two, symbol: nil)
+    end
+
+    it "finds a pattern with a contained symbol" do
+      expect(subject.find("#{pattern_two.name}::CodeBlock")).to eq OpenStruct.new(pattern: pattern_two, symbol: factory)
+    end
+  end
+
+  describe "#summary" do
+    it "returns a pattern library with all patterns summarized" do
+      subject << pattern_two
+      summary = subject.summary
+      expect(subject).not_to be_summarized
+      expect(summary).to be_summarized
+
+      summary.patterns.each do |name, pattern|
+        expect(pattern).to be_summarized
+      end
+    end
+  end
+
+  describe "#summary!" do
+    it "returns a pattern library with all patterns summarized" do
+      subject << pattern_two
+      expect { subject.summary! }.not_to change { subject.patterns.keys.length }
+      expect(subject).to be_summarized
+
+      subject.patterns.each do |name, pattern|
+        expect(pattern).to be_summarized
+      end
+    end
+  end
+end

data/spec/lib/containers/symbol_container_spec.rb

@@ -0,0 +1,216 @@
+require "spec_helper"
+
+describe Docks::Containers::Symbol do
+  ACCESS_TYPES = Docks::Types::Access
+
+  subject { described_class.new(name: "foo") }
+  let(:access) { Docks::Tags::Access }
+
+  describe "#symbol_type" do
+    class Example < described_class
+      def self.type; "foo" end
+    end
+
+    it "uses the symbol type of the class" do
+      expect(subject.symbol_type).to eq described_class.type
+      expect(Example.new.symbol_type).to eq Example.type
+    end
+
+    it "adds the symbol type to the backing hash" do
+      expect(subject.to_h[:symbol_type]).to eq described_class.type
+    end
+  end
+
+  describe "#private?" do
+    it "identifies a private symbol based on its access type" do
+      expect(subject.private?).to be false
+
+      subject[access] = ACCESS_TYPES::PUBLIC
+      expect(subject.private?).to be false
+
+      subject[access] = ACCESS_TYPES::PRIVATE
+      expect(subject.private?).to be true
+    end
+  end
+
+  describe "#public?" do
+    it "identifies a public variable based on its access type" do
+      expect(subject.public?).to be true
+
+      subject[access] = ACCESS_TYPES::PUBLIC
+      expect(subject.public?).to be true
+
+      subject[access] = ACCESS_TYPES::PRIVATE
+      expect(subject.public?).to be false
+    end
+  end
+
+  describe "#symbol_id" do
+    it "creates a symbol_id" do
+      expect(subject.symbol_id).to eq "#{subject.symbol_type}-#{subject.name}"
+    end
+
+    it "creates a symbol_id that is unique between two symbol types with the same name" do
+      descendants = ObjectSpace.each_object(Class).select { |klass| klass < described_class }.sample(2)
+      descendants.map! { |descendant| descendant.new(name: "foo") }
+      expect(descendants.first.symbol_id).to_not eq descendants.last.symbol_id
+    end
+  end
+
+  describe "#to_descriptor" do
+    it "returns the name of the symbol" do
+      expect(subject.to_descriptor).to eq subject.name
+    end
+
+    it "returns the pattern and name of the symbol when the symbol is part of a pattern" do
+      pattern = Docks::Containers::Pattern.new(name: subject.name)
+      pattern.add(:style, subject)
+      expect(subject.to_descriptor).to eq "#{pattern.name}::#{subject.name}"
+    end
+  end
+
+  describe "#member?" do
+    it "is a member when it is a property or method" do
+      expect(Docks::Containers::Variable.new(property: true)).to be_member
+      expect(Docks::Containers::Function.new(method: true)).to be_member
+    end
+
+    it "is not a member when it is not a property or method" do
+      expect(Docks::Containers::Variable.new).to_not be_member
+      expect(Docks::Containers::Function.new).to_not be_member
+      expect(Docks::Containers::Klass.new).to_not be_member
+      expect(Docks::Containers::Factory.new).to_not be_member
+    end
+  end
+
+  describe "members" do
+    let(:property) { Docks::Containers::Variable.new(name: "baz") }
+    let(:method) { Docks::Containers::Function.new(name: "qux") }
+
+    describe "#add_member" do
+      context "when a variable is added" do
+        it "adds all the relevant details" do
+          subject.add_member(property)
+          expect(property.for).to eq subject.name
+          expect(property.belongs_to).to be subject
+          expect(property.property?).to be true
+          expect(property.static?).to be true
+        end
+
+        it "adds the property to the symbol's properties" do
+          subject.add_member(property)
+          expect(subject.properties).to include property
+        end
+      end
+
+      context "when a function is added" do
+        it "adds all the relevant details" do
+          subject.add_member(method)
+          expect(method.for).to eq subject.name
+          expect(method.belongs_to).to be subject
+          expect(method.method?).to be true
+          expect(method.static?).to be true
+        end
+
+        it "adds the function to the symbol's methods" do
+          subject.add_member(method)
+          expect(subject.methods).to include method
+        end
+      end
+    end
+
+    describe "#methods" do
+      it "returns an empty array when there are no methods" do
+        expect(subject.methods).to be_empty
+      end
+
+      it "returns all of the methods of the class" do
+        subject.add_members(method)
+        all_methods = subject.methods
+        expect(all_methods.length).to be 1
+        expect(all_methods).to include method
+      end
+    end
+
+    describe "#properties" do
+      it "returns an empty array when there are no properties" do
+        expect(subject.properties).to be_empty
+      end
+
+      it "returns all of the properties of the symbol" do
+        subject.add_members(property)
+        all_properties = subject.properties
+        expect(all_properties.length).to be 1
+        expect(all_properties).to include property
+      end
+    end
+
+    describe "#members" do
+      it "returns an empty array when there are no members" do
+        expect(subject.members).to be_empty
+      end
+
+      it "returns all members, of any type" do
+        subject.add_members(method, property)
+
+        members = subject.members
+        expect(members.length).to be 2
+        expect(members).to include method
+        expect(members).to include property
+      end
+    end
+
+    describe "#has_members?" do
+      it "returns false when there are no members" do
+        expect(subject).not_to have_members
+      end
+
+      it "returns true when there are members" do
+        subject.add_members(method, property)
+        expect(subject).to have_members
+      end
+    end
+
+    describe "#find" do
+      it "returns false if the descriptor symbol doesn't match" do
+        expect(subject.find("baz")).to be false
+      end
+
+      it "returns the symbol when the symbol name matches and there are no other parts to the descriptor" do
+        expect(subject.find(subject.name)).to be subject
+      end
+
+      it "returns false when the symbol name matches but the member does not" do
+        expect(subject.find("#{subject.name}.bar")).to be false
+        expect(subject.find("#{subject.name}#bar")).to be false
+        expect(subject.find("#{subject.name}~bar")).to be false
+      end
+
+      it "returns a method" do
+        subject.add_members(method, property)
+        expect(subject.find("#{subject.name}.#{method.name}")).to be method
+      end
+
+      it "returns a property" do
+        subject.add_members(property, method)
+        expect(subject.find("#{subject.name}.#{property.name}")).to be property
+      end
+    end
+  end
+
+  describe "#summary" do
+    before(:each) do
+      subject.add_members(Docks::Containers::Variable.new, Docks::Containers::Function.new)
+    end
+
+    let(:summary) { subject.summary }
+
+    it "preserves the symbol_id, name, properties, and methods" do
+      expect(summary).to be_a described_class
+      expect(summary.name).to eq subject.name
+      expect(summary.symbol_id).to eq subject.symbol_id
+      expect(summary.properties).to eq subject.properties.map(&:summary)
+      expect(summary.methods).to eq subject.methods.map(&:summary)
+    end
+  end
+end

data/spec/lib/containers/variable_container_spec.rb

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

data/spec/lib/containers/variation_container_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+describe Docks::Containers::Variation do
+  subject { Docks::Containers::Variation.new }
+
+  it "sets appropriate details" do
+    expect(subject.active).to be false
+    expect(subject.activate_with).to eq []
+    expect(subject.precludes).to eq []
+    expect(subject.set_by).to eq []
+    expect(subject.include_with).to eq []
+    expect(subject.demo_type).to eq Docks::Types::Demo::SELECT
+  end
+
+  describe "#has_demo?" do
+    it "has a demo only when the demo_type is set to Types::Demo::OWN or Types::Demo::JOINT" do
+      expect(subject.has_demo?).to be false
+
+      subject.demo_type = Docks::Types::Demo::JOINT
+      expect(subject.has_demo?).to be true
+
+      subject.demo_type = Docks::Types::Demo::SELECT
+      expect(subject.has_demo?).to be false
+
+      subject.demo_type = Docks::Types::Demo::OWN
+      expect(subject.has_demo?).to be true
+
+      subject.demo_type = Docks::Types::Demo::NONE
+      expect(subject.has_demo?).to be false
+
+      subject.demo_type = Docks::Types::Demo::HIDDEN
+      expect(subject.has_demo?).to be false
+    end
+  end
+
+  describe "#find" do
+    before(:each) do
+      subject.for = "foo"
+      subject.name = "foo--bar"
+    end
+
+    it "finds a variation when the name matches the symbol" do
+      expect(subject.find(subject.name)).to be subject
+      expect(subject.find("foo--baz")).to be false
+    end
+
+    it "finds a variation when any member information matches the variation name and the symbol matches the base class" do
+      expect(subject.find("#{subject.for}~#{subject.name}")).to be subject
+      expect(subject.find("baz~#{subject.name}")).to be false
+    end
+  end
+end

data/spec/lib/containers_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+describe Docks::Containers do
+  subject { Docks::Containers }
+
+  describe ".container_for" do
+    it "wraps a parse result in the correct container" do
+      subject::TOP_LEVEL_SYMBOLS.each do |type|
+        container = subject.constants.map { |const| subject.const_get(const) }.select { |const| const.respond_to?(:type) && const.type == type }.first
+        expect(subject.container_for(type)).to be container
+      end
+    end
+
+    it "returns the base symbol if no type was passed" do
+      expect(subject.container_for).to be Docks::Containers::Symbol
+    end
+
+    it "returns the base symbol for an unrecognized type" do
+      expect(subject.container_for("foo")).to be Docks::Containers::Symbol
+    end
+  end
+end

data/spec/lib/descriptor_spec.rb

@@ -0,0 +1,73 @@
+require "spec_helper"
+
+describe Docks::Descriptor do
+  subject { described_class }
+
+  let(:symbol) { "CodeBlock" }
+  let(:pattern) { "code-block" }
+  let(:instance_member) { "toggle" }
+  let(:static_member) { "for" }
+  let(:local_member) { "CodeCaches" }
+
+  describe "#initialize" do
+    it "returns something that is already a descriptor" do
+      descriptor = subject.new(symbol)
+      expect(subject.new(descriptor)).to be descriptor
+    end
+
+    it "identifies a symbol name" do
+      expect(subject.new(symbol).symbol).to eq symbol
+    end
+
+    it "identifies a pattern instead of a symbol if the pattern assumption option is passed" do
+      descriptor = subject.new(pattern, assume: :pattern)
+      expect(descriptor.pattern).to eq pattern
+      expect(descriptor.symbol).to be nil
+    end
+
+    it "identifies a pattern name" do
+      result = subject.new("#{pattern}::#{symbol}")
+      expect(result.pattern).to eq Docks.pattern_id(pattern)
+      expect(result.symbol).to eq symbol
+    end
+
+    it "identifies an instance member" do
+      result = subject.new("#{symbol}##{instance_member}")
+      expect(result.symbol).to eq symbol
+      expect(result.instance_member).to eq instance_member
+    end
+
+    it "identifies a static member" do
+      result = subject.new("#{symbol}.#{static_member}")
+      expect(result.symbol).to eq symbol
+      expect(result.static_member).to eq static_member
+    end
+
+    it "identifies a local member" do
+      result = subject.new("#{symbol}~#{local_member}")
+      expect(result.symbol).to eq symbol
+      expect(result.local_member).to eq local_member
+    end
+  end
+
+  describe "#member?" do
+    it "is not a member when it has no member information" do
+      expect(subject.new(symbol).member?).to be false
+    end
+
+    it "is a member when it has member information" do
+      expect(subject.new("#{symbol}##{instance_member}").member?).to be true
+      expect(subject.new("#{symbol}.#{static_member}").member?).to be true
+      expect(subject.new("#{symbol}~#{local_member}").member?).to be true
+    end
+  end
+
+  describe "member" do
+    it "returns any member" do
+      expect(subject.new(symbol).member).to be nil
+      expect(subject.new("#{symbol}##{instance_member}").member).to eq instance_member
+      expect(subject.new("#{symbol}.#{static_member}").member).to eq static_member
+      expect(subject.new("#{symbol}~#{local_member}").member).to eq local_member
+    end
+  end
+end