docks_app 0.0.1

data/spec/lib/tags/param_tag_spec.rb

@@ -0,0 +1,261 @@
+require "spec_helper"
+
+describe Docks::Tags::Param do
+  subject { Docks::Tags::Param.instance }
+
+  it "allows multiline content" do
+    expect(subject.multiline?).to be true
+  end
+
+  it "allows multiple tags per block" do
+    expect(subject.multiple_allowed?).to be true
+  end
+
+  describe "#process" do
+    let(:symbol) { Docks::Containers::Symbol.new }
+    let(:name) { "_tab_list2" }
+    let(:types) { "Array | DOMElement" }
+    let(:processed_types) { Docks::Processors.split_types(types) }
+    let(:default) { "[]" }
+    let(:description) { "The list of tabs." }
+
+    it "creates the param when only the name is provided" do
+      result = process_param_with([name]).first
+      expect(result.name).to eq name
+      expect(result.multiple).to be false
+    end
+
+    it "creates the param when special characters exist in the name" do
+      result = process_param_with(["_with_underscore"]).first
+      expect(result.name).to eq "_with_underscore"
+
+      result = process_param_with(["$$with-dollars"]).first
+      expect(result.name).to eq "$$with-dollars"
+    end
+
+    context "when this param represents multiple params" do
+      it "is not multiple when no spread operator is used" do
+        result = process_param_with([name]).first
+        expect(result.name).to eq name
+        expect(result.multiple).to be false
+      end
+
+      it "indicates that the param is a multiple param when the spread operator is used" do
+        result = process_param_with(["...#{name}"]).first
+        expect(result.name).to eq name
+        expect(result.multiple).to be true
+      end
+    end
+
+    context "when types provided" do
+      it "creates the param when the name and types are provided" do
+        result = process_param_with(["{#{types}} #{name}"]).first
+        expect(result.name).to eq name
+        expect(result.types).to eq processed_types
+      end
+
+      it "sets the types to an empty array when not provided" do
+        result = process_param_with([name]).first
+        expect(result.name).to eq name
+        expect(result.types).to eq Array.new
+      end
+    end
+
+    context "when optional" do
+      it "creates the param with an optional attribute" do
+        result = process_param_with(["[#{name}]"]).first
+        expect(result.name).to eq name
+        expect(result.optional).to be true
+        expect(result.default).to be nil
+      end
+
+      it "creates the param with an optional attribute and the actual default value" do
+        result = process_param_with(["[#{name} = #{default}]"]).first
+        expect(result.name).to eq name
+        expect(result.optional).to be true
+        expect(result.default).to eq default
+      end
+
+      it "sets optional and default to the appropriate values when not provided" do
+        result = process_param_with([name]).first
+        expect(result.name).to eq name
+        expect(result.optional).to be false
+        expect(result.default).to be nil
+      end
+    end
+
+    context "when description provided" do
+      it "creates the param when the name and description are provided" do
+        result = process_param_with(["#{name} #{description}"]).first
+        expect(result.name).to eq name
+        expect(result.description).to eq description
+
+        result = process_param_with(["#{name} -  #{description}"]).first
+        expect(result.name).to eq name
+        expect(result.description).to eq description
+      end
+
+      it "sets description to be nil when not provided" do
+        result = process_param_with([name]).first
+        expect(result.name).to eq name
+        expect(result.description).to be nil
+      end
+    end
+
+    context "when there are combinations of the components" do
+      it "processes lines with a name, default, and types" do
+        result = process_param_with(["{#{types}}    [#{name}  =#{default}]"]).first
+        expect(result.name).to eq name
+        expect(result.types).to eq processed_types
+        expect(result.optional).to be true
+        expect(result.default).to eq default
+        expect(result.description).to be nil
+      end
+
+      it "processes lines with a name, types, and description" do
+        result = process_param_with(["{#{types}} #{name}    -#{description}"]).first
+        expect(result.name).to eq name
+        expect(result.types).to eq processed_types
+        expect(result.optional).to be false
+        expect(result.default).to be nil
+        expect(result.description).to eq description
+
+        result = process_param_with(["{#{types}} #{name} #{description}"]).first
+        expect(result.name).to eq name
+        expect(result.types).to eq processed_types
+        expect(result.optional).to be false
+        expect(result.default).to be nil
+        expect(result.description).to eq description
+      end
+
+      it "processes lines with a name, optional, and description" do
+        result = process_param_with(["[#{name}] #{description}"]).first
+        expect(result.name).to eq name
+        expect(result.types).to eq Array.new
+        expect(result.optional).to be true
+        expect(result.default).to be nil
+        expect(result.description).to eq description
+
+        result = process_param_with(["[#{name}]   -      #{description}"]).first
+        expect(result.name).to eq name
+        expect(result.types).to eq Array.new
+        expect(result.optional).to be true
+        expect(result.default).to be nil
+        expect(result.description).to eq description
+      end
+
+      it "processes lines with a name, default value, and description" do
+        result = process_param_with(["[#{name}= #{default}] #{description}"]).first
+        expect(result.name).to eq name
+        expect(result.types).to eq Array.new
+        expect(result.optional).to be true
+        expect(result.default).to eq default
+        expect(result.description).to eq description
+
+        result = process_param_with(["[#{name}   = #{default}]   -#{description}"]).first
+        expect(result.name).to eq name
+        expect(result.types).to eq Array.new
+        expect(result.optional).to be true
+        expect(result.default).to eq default
+        expect(result.description).to eq description
+      end
+
+      it "processes lines with a name, types, spread param, and description" do
+        result = process_param_with(["{#{types}} ...#{name}  #{description}"]).first
+        expect(result.name).to eq name
+        expect(result.types).to eq processed_types
+        expect(result.optional).to be false
+        expect(result.multiple).to be true
+        expect(result.default).to be nil
+        expect(result.description).to eq description
+
+        result = process_param_with([" {#{types}}  ...#{name}   -#{description}"]).first
+        expect(result.name).to eq name
+        expect(result.types).to eq processed_types
+        expect(result.optional).to be false
+        expect(result.multiple).to be true
+        expect(result.default).to be nil
+        expect(result.description).to eq description
+      end
+
+      it "processes lines with a name, types, spread param, default value, and description" do
+        result = process_param_with(["{#{types}} [...#{name}= #{default}] #{description}"]).first
+        expect(result.name).to eq name
+        expect(result.types).to eq processed_types
+        expect(result.optional).to be true
+        expect(result.multiple).to be true
+        expect(result.default).to eq default
+        expect(result.description).to eq description
+
+        result = process_param_with([" {#{types}}  [...#{name}   = #{default}]   -#{description}"]).first
+        expect(result.name).to eq name
+        expect(result.types).to eq processed_types
+        expect(result.optional).to be true
+        expect(result.multiple).to be true
+        expect(result.default).to eq default
+        expect(result.description).to eq description
+      end
+    end
+
+    context "when there are properties" do
+      let(:base_param) { "foo" }
+      let(:prop_one) { "{String} foo.bar" }
+      let(:prop_two) { "{Number} foo['baz']" }
+      let(:prop_three) { "{String} foo[].qux" }
+      let(:unrelated) { "qux" }
+
+      it "joins a property using dot syntax" do
+        params = process_param_with [base_param, prop_one]
+        param = params.first
+        expect(params.length).to be 1
+        expect(param.name).to eq base_param
+        expect(param.properties.length).to be 1
+        expect(param.properties.first.name).to eq "bar"
+      end
+
+      it "joins a property using bracket syntax" do
+        params = process_param_with [base_param, prop_two]
+        param = params.first
+        expect(params.length).to be 1
+        expect(param.name).to eq base_param
+        expect(param.properties.length).to be 1
+        expect(param.properties.first.name).to eq "baz"
+      end
+
+      it "joins a property with another property that is an array" do
+        params = process_param_with([base_param, prop_three])
+        param = params.first
+
+        expect(params.length).to be 1
+        expect(param.name).to eq base_param
+        expect(param.properties.length).to be 1
+        expect(param.properties.first.name).to eq "qux"
+      end
+
+      it "creates a base param when none exists" do
+        params = process_param_with prop_two
+        param = params.first
+        expect(params.length).to be 1
+        expect(param.name).to eq base_param
+        expect(param.properties.length).to be 1
+        expect(param.properties.first.name).to eq "baz"
+      end
+
+      it "leaves unrelated base params alone" do
+        params = process_param_with [prop_one, prop_two, unrelated]
+        expect(params.length).to be 2
+        expect(params.first.name).to eq base_param
+        expect(params.first.properties.length).to be 2
+        expect(params.last.name).to eq unrelated
+      end
+    end
+
+    private
+
+    def process_param_with(content)
+      symbol[subject.name] = content
+      subject.process(symbol)
+      symbol[subject.name]
+    end
+  end
+end

data/spec/lib/tags/pattern_tag_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+describe Docks::Tags::Pattern do
+  subject { Docks::Tags::Pattern.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
+
+  describe "post processing" do
+    let(:symbols) do
+      [
+        Docks::Containers::Klass.new(name: "Foo"),
+        Docks::Containers::Factory.new(name: "Bar"),
+        Docks::Containers::Function.new(name: "fooBar"),
+        Docks::Containers::Variable.new(name: "baz")
+      ]
+    end
+
+    let(:pattern) do
+      pattern = Docks::Containers::Pattern.new(name: "foo")
+      pattern.add(:script, symbols)
+      pattern
+    end
+
+    before(:each) do
+      Docks::Tags.register(described_class)
+    end
+
+    it "adds the pattern name to all contained symbols" do
+      Docks::Process.process(pattern)
+
+      pattern.symbols.each do |symbol|
+        expect(symbol[subject]).to eq pattern.name
+      end
+    end
+  end
+end

data/spec/lib/tags/preclude_tag_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe Docks::Tags::Preclude do
+  subject { Docks::Tags::Preclude.instance }
+
+  it "does not allow multiline content" do
+    expect(subject.multiline?).to be false
+  end
+
+  it "allows multiple tags per block" do
+    expect(subject.multiple_allowed?).to be true
+  end
+
+  describe "#process" do
+    let(:symbol) { Docks::Containers::Symbol.new }
+
+    it "breaks apart precludes on commas, spaces and pipes" do
+      precludes = "foo | bar, baz qux"
+      symbol[subject.name] = precludes
+      subject.process(symbol)
+      expect(symbol[subject.name]).to eq Docks::Processors.split_on_commas_spaces_and_pipes(precludes)
+    end
+
+    it "joins together multiple lines of precludes" do
+      precludes = ["foo | bar, baz qux", "lux fuz"]
+      symbol[subject.name] = precludes.dup
+      subject.process(symbol)
+      expect(symbol[subject.name]).to eq precludes.map { |alias_line| Docks::Processors.split_on_commas_spaces_and_pipes(alias_line) }.flatten
+    end
+  end
+end

data/spec/lib/tags/private_tag_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe Docks::Tags::Private do
+  subject { Docks::Tags::Private.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
+    describe "#process" do
+      let(:symbol) { Docks::Containers::Symbol.new(private: true) }
+
+      before :each do
+        subject.process(symbol)
+      end
+
+      it "sets the access attribute to be private" do
+        expect(symbol.access).to be Docks::Types::Access::PRIVATE
+      end
+
+      it "removes the private attribute" do
+        expect(symbol.private).to be nil
+      end
+    end
+  end
+end

data/spec/lib/tags/property_tag_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+describe Docks::Tags::Property do
+  subject { Docks::Tags::Property.instance }
+
+  it "does not allow multiline content" do
+    expect(subject.multiline?).to be false
+  end
+
+  it "only allows one tag per block" do
+    expect(subject.multiple_allowed?).to be false
+  end
+
+  describe "#process" do
+    it "marks the attribute as true" do
+      symbol = Docks::Containers::Symbol.new(name: "foo", property: "")
+      Docks::Process.process(symbol)
+      expect(symbol[subject.name]).to be true
+    end
+
+    it "forces the symbol to be a variable type" do
+      symbol = Docks::Containers::Symbol.new(name: "foo", property: "")
+      symbol = Docks::Process.process(symbol)
+      expect(symbol).to be_a Docks::Containers::Variable
+    end
+  end
+end

data/spec/lib/tags/public_tag_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe Docks::Tags::Public do
+  subject { Docks::Tags::Public.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
+    let(:symbol) { Docks::Containers::Symbol.new(public: true) }
+
+    before :each do
+      subject.process(symbol)
+    end
+
+    it "sets the access attribute to be public" do
+      expect(symbol.access).to be Docks::Types::Access::PUBLIC
+    end
+
+    it "removes the public attribute" do
+      expect(symbol.public).to be nil
+    end
+  end
+end

data/spec/lib/tags/require_tag_spec.rb

@@ -0,0 +1,133 @@
+require "spec_helper"
+
+describe Docks::Tags::Require do
+  subject { Docks::Tags::Require.instance }
+
+  it "does not allow multiline content" do
+    expect(subject.multiline?).to be false
+  end
+
+  it "allows multiple tags per block" do
+    expect(subject.multiple_allowed?).to be true
+  end
+
+  describe "#process" do
+    let(:symbol) { Docks::Containers::Symbol.new }
+
+    it "breaks apart requires on commas, spaces and pipes" do
+      requires = "foo | bar, baz qux"
+      symbol[subject.name] = requires
+      subject.process(symbol)
+      expect(symbol[subject.name]).to eq Docks::Processors.split_on_commas_spaces_and_pipes(requires)
+    end
+
+    it "joins together multiple lines of requires" do
+      requires = ["foo | bar, baz qux", "lux fuz"]
+      symbol[subject.name] = requires.dup
+      subject.process(symbol)
+      expect(symbol[subject.name]).to eq requires.map { |alias_line| Docks::Processors.split_on_commas_spaces_and_pipes(alias_line) }.flatten
+    end
+  end
+
+  describe "post processing" do
+    before(:each) do
+      Docks::Tags.register_bundled_tags
+    end
+
+    let(:method_one) do
+      Docks::Containers::Function.new(name: "foo", method: true)
+    end
+
+    let(:method_two) do
+      Docks::Containers::Function.new(name: "bar", method: true, static: true)
+    end
+
+    let(:klass) do
+      Docks::Containers::Klass.new(name: "Baz")
+    end
+
+    let(:factory) do
+      Docks::Containers::Factory.new(name: "Qux")
+    end
+
+    let(:pattern_one) do
+      pattern = Docks::Containers::Pattern.new(name: klass.name.downcase)
+      pattern.add(:script, [klass, method_one])
+      pattern
+    end
+
+    let(:pattern_two) do
+      pattern = Docks::Containers::Pattern.new(name: factory.name.downcase)
+      pattern.add(:script, [factory, method_two])
+      pattern
+    end
+
+    let(:pattern_library) do
+      library = Docks::Containers::PatternLibrary.new
+      library << pattern_one
+      library << pattern_two
+      library
+    end
+
+    it "adds used_by associations in the corresponding symbol" do
+      requires = "#{pattern_two.name}::#{factory.name}"
+
+      method_one.requires = requires
+      process_library
+
+      expect(method_one.requires).to eq [requires]
+      expect(factory.used_by).to eq [method_one.to_descriptor]
+    end
+
+    it "adds multiple associations to a single symbol" do
+      requires = "#{pattern_two.name}::#{factory.name}.#{method_two.name}"
+
+      method_one.requires = requires
+      klass.requires = requires
+
+      process_library
+
+      expect(method_one.requires).to eq [requires]
+      expect(klass.requires).to eq [requires]
+
+      expect(method_two.used_by).to eq [
+        method_one.to_descriptor,
+        klass.to_descriptor
+      ]
+    end
+
+    it "adds a single symbol with multiple requires" do
+      pattern_require = pattern_two.name
+      method_require = "#{pattern_two.name}::#{factory.name}.#{method_two.name}"
+
+      klass.requires = "#{pattern_require}, #{method_require}"
+
+      process_library
+
+      expect(klass.requires).to eq [pattern_require, method_require]
+      expect(pattern_two.used_by).to eq [klass.to_descriptor]
+      expect(method_two.used_by).to eq [klass.to_descriptor]
+    end
+
+    private
+
+    def process_symbols
+      [method_one, method_two, klass, factory].each do |symbol|
+        Docks::Process.process(symbol)
+      end
+    end
+
+    def process_patterns
+      process_symbols
+
+      [pattern_one, pattern_two].each do |pattern|
+        Docks::Process.process(pattern)
+      end
+    end
+
+    def process_library
+      process_patterns
+      Docks::Process.process(pattern_library)
+    end
+  end
+end

data/spec/lib/tags/returns_tag_spec.rb

@@ -0,0 +1,85 @@
+require "spec_helper"
+
+describe Docks::Tags::Returns do
+  subject { Docks::Tags::Returns.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(:types) { "{String | Array Object, Number}" }
+    let(:description) { "This is the description" }
+
+    it "splits apart types when no description is provided" do
+      expect(process_returns_with(types).types).to eq Docks::Processors.split_types(types)
+    end
+
+    it "splits apart types when no description and no curly braces are provided" do
+      expect(process_returns_with(types.gsub("{", "").gsub("}", "")).types).to eq Docks::Processors.split_types(types)
+    end
+
+    it "sets the types to nil when no types are provided" do
+      expect(process_returns_with("").types).to be nil
+      expect(process_returns_with("   ").types).to be nil
+    end
+
+    it "sets the types to nil when 'nothing' is set as the type" do
+      expect(process_returns_with("Nothing  ").types).to be nil
+    end
+
+    it "preserves a description when the type is nothing" do
+      returns = process_returns_with("nothing - foo")
+      expect(returns.types).to be nil
+      expect(returns.description).to eq "foo"
+    end
+
+    it "splits apart types when a description is provided" do
+      type_results = Docks::Processors.split_types(types)
+      expect(process_returns_with("#{types} #{description}").types).to eq type_results
+      expect(process_returns_with("#{types} -  #{description}").types).to eq type_results
+      expect(process_returns_with("#{types}   -#{description}").types).to eq type_results
+      expect(process_returns_with("#{types}-  #{description}").types).to eq type_results
+    end
+
+    it "returns a nil description when no description is provided" do
+      expect(process_returns_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_returns_with("#{types} #{description}").description).to eq target_description
+      expect(process_returns_with("#{types} -  #{description}").description).to eq target_description
+      expect(process_returns_with("#{types}   -#{description}").description).to eq target_description
+      expect(process_returns_with("#{types}-  #{description}").description).to eq target_description
+    end
+
+    it "splits a apart types without curly braces with a following description" do
+      types.gsub!("{", "")
+      types.gsub!("}", "")
+
+      type_results = Docks::Processors.split_types(types)
+      expect(process_returns_with("#{types} -  #{description}").types).to eq type_results
+      expect(process_returns_with("#{types}   -#{description}").types).to eq type_results
+      expect(process_returns_with("#{types}-  #{description}").types).to eq type_results
+
+      target_description = Docks::Processors.join_with_smart_line_breaks(description)
+      expect(process_returns_with("#{types} -  #{description}").description).to eq target_description
+      expect(process_returns_with("#{types}   -#{description}").description).to eq target_description
+      expect(process_returns_with("#{types}-  #{description}").description).to eq target_description
+    end
+
+    private
+
+    def process_returns_with(content)
+      symbol[subject.name] = content
+      subject.process(symbol)
+      symbol[subject.name]
+    end
+  end
+end