docks_app 0.0.1

data/spec/lib/tags/author_tag_spec.rb

@@ -0,0 +1,172 @@
+require "spec_helper"
+
+describe Docks::Tags::Author do
+  subject { Docks::Tags::Author.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) { "Chris Sauve" }
+    let(:email) { "chrismsauve@gmail.com" }
+    let(:github) { "lemonmade" }
+    let(:complex_content) { "#{simple_content} (#{email}, github: #{github})" }
+
+    it "creates an array of authors even when only one is provided" do
+      expect(process_author_with(simple_content)).to be_an(Array)
+    end
+
+    it "creates a :name when there are no other details" do
+      result = process_author_with(simple_content).first
+      expect(result.name).to eq simple_content
+    end
+
+    it "creates a :name when there are other details" do
+      result = process_author_with(complex_content).first
+      expect(result.name).to eq simple_content
+    end
+
+    it "does not create an :email when no parentheses are provided" do
+      result = process_author_with(simple_content).first
+      expect(result.email).to be nil
+    end
+
+    it "creates details when one is provided without a key" do
+      result = process_author_with(complex_content).first
+      expect(result.email).to eq email
+      expect(result.github).to eq github
+    end
+
+    it "creates details when keys are provided for all values" do
+      complex_content.sub!("(", "(email: ")
+      result = process_author_with(complex_content).first
+      expect(result.email).to eq email
+      expect(result.github).to eq github
+    end
+
+    it "creates an author for each name separated by commas" do
+      input = "#{simple_content},  #{simple_content} ,#{simple_content}"
+      result = process_author_with(input)
+      expect(result.length).to be 3
+
+      result.each do |author|
+        expect(author.name).to eq simple_content
+      end
+    end
+
+    it "creates an author for each name separated by pipes" do
+      input = "#{simple_content}|  #{simple_content} |#{simple_content}"
+      result = process_author_with(input)
+      expect(result.length).to be 3
+
+      result.each do |author|
+        expect(author.name).to eq simple_content
+      end
+    end
+
+    it "creates an author for a complex author after a simple author name, separated by commas" do
+      input = "#{simple_content}, #{complex_content}"
+      result = process_author_with(input)
+      expect(result.length).to be 2
+
+      expect(result.first.name).to eq simple_content
+      expect(result[1].name).to eq simple_content
+      expect(result[1].email).to eq email
+      expect(result[1].github).to eq github
+    end
+
+    it "creates an author for a complex author after a simple author name, separated by pipes" do
+      input = "#{simple_content} |#{complex_content}"
+      result = process_author_with(input)
+      expect(result.length).to be 2
+
+      expect(result.first.name).to eq simple_content
+      expect(result[1].name).to eq simple_content
+      expect(result[1].email).to eq email
+      expect(result[1].github).to eq github
+    end
+
+    it "creates an author for a simple author after a complex author name, separated by spaces" do
+      input = "#{complex_content}   #{simple_content}"
+      result = process_author_with(input)
+      expect(result.length).to be 2
+
+      expect(result.first.name).to eq simple_content
+      expect(result.first.email).to eq email
+      expect(result.first.github).to eq github
+      expect(result[1].name).to eq simple_content
+    end
+
+    it "creates an author for a simple author after a complex author name, separated by commas" do
+      input = "#{complex_content},  #{simple_content}"
+      result = process_author_with(input)
+      expect(result.length).to be 2
+
+      expect(result.first.name).to eq simple_content
+      expect(result.first.email).to eq email
+      expect(result.first.github).to eq github
+      expect(result[1].name).to eq simple_content
+    end
+
+    it "creates an author for a simple author after a complex author name, separated by pipes" do
+      input = "#{complex_content} || #{simple_content}"
+      result = process_author_with(input)
+      expect(result.length).to be 2
+
+      expect(result.first.name).to eq simple_content
+      expect(result.first.email).to eq email
+      expect(result.first.github).to eq github
+      expect(result[1].name).to eq simple_content
+    end
+
+    it "creates an author with details for each author/ parentheses pair separated by spaces" do
+      input = "#{complex_content} #{complex_content}"
+      result = process_author_with(input)
+      expect(result.length).to be 2
+
+      result.each do |author|
+        expect(author.name).to eq simple_content
+        expect(author.email).to eq email
+        expect(author.github).to eq github
+      end
+    end
+
+    it "creates an author with details for each author/ parentheses pair separated by pipes" do
+      input = "#{complex_content} |#{complex_content}"
+      result = process_author_with(input)
+      expect(result.length).to be 2
+
+      result.each do |author|
+        expect(author.name).to eq simple_content
+        expect(author.email).to eq email
+        expect(author.github).to eq github
+      end
+    end
+
+    it "creates an author with details for each author/ parentheses pair separated by commas" do
+      input = "#{complex_content},  #{complex_content}"
+      result = process_author_with(input)
+      expect(result.length).to be 2
+
+      result.each do |author|
+        expect(author.name).to eq simple_content
+        expect(author.email).to eq email
+        expect(author.github).to eq github
+      end
+    end
+
+    private
+
+    def process_author_with(content)
+      symbol[subject.name] = content
+      subject.process(symbol)
+      symbol[subject.name]
+    end
+  end
+end

data/spec/lib/tags/base_tag_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe Docks::Tags::Base do
+  subject { Docks::Tags::Base.instance }
+
+  it "has no synonyms by default" do
+    expect(subject.synonyms).to eq []
+  end
+
+  it "is multiline by default" do
+    expect(subject.multiline?).to be true
+  end
+
+  it "allows only one tag per block by default" do
+    expect(subject.multiple_allowed?).to be false
+  end
+
+  it "can be included in parse results" do
+    expect(subject.parseable?).to be true
+  end
+end

data/spec/lib/tags/beta_tag_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+describe Docks::Tags::Beta do
+  subject { Docks::Tags::Beta.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(:simple_version) { "v2.0" }
+    let(:complex_version) { "Version 2.0.32-b2034" }
+    let(:description) { "This is the description" }
+
+    it "returns just the version when no description is provided" do
+      expect(process_beta_with([simple_version]).version).to eq simple_version
+    end
+
+    it "gets a simple version when a description is provided" do
+      expect(process_beta_with(["#{simple_version}   - #{description}"]).version).to eq simple_version
+      expect(process_beta_with(["#{simple_version} -  #{description}"]).version).to eq simple_version
+    end
+
+    it "gets a complex version when a description is provided" do
+      expect(process_beta_with(["#{complex_version}   - #{description}"]).version).to eq complex_version
+      expect(process_beta_with(["#{complex_version} -  #{description}"]).version).to eq complex_version
+    end
+
+    it "returns a nil description when no description is provided" do
+      expect(process_beta_with([complex_version]).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_beta_with(["#{complex_version}   - #{description}"]).description).to eq target_description
+      expect(process_beta_with(["#{complex_version} -  #{description}"]).description).to eq target_description
+    end
+
+    private
+
+    def process_beta_with(content)
+      symbol[subject.name] = content
+      subject.process(symbol)
+      symbol[subject.name]
+    end
+  end
+end

data/spec/lib/tags/class_tag_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe Docks::Tags::Klass do
+  subject { Docks::Tags::Klass.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", class: "")
+      Docks::Process.process(symbol)
+      expect(symbol[subject.name]).to be true
+    end
+
+    it "converts the symbol to be a class container" do
+      symbol = Docks::Containers::Function.new(class: "", name: "foo")
+      symbol = Docks::Process.process(symbol)
+
+      expect(symbol).to be_a Docks::Containers::Klass
+      expect(symbol.symbol_type).to eq Docks::Types::Symbol::CLASS
+    end
+  end
+end

data/spec/lib/tags/compatibility_tag_spec.rb

@@ -0,0 +1,159 @@
+require "spec_helper"
+
+describe Docks::Tags::Compatibility do
+  subject { Docks::Tags::Compatibility.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) { "Chrome" }
+    let(:version) { "latest" }
+    let(:complex_content) { "#{simple_content} (#{version})" }
+
+    it "creates an array of compatibilities even when only one is provided" do
+      expect(process_compatibility_with(simple_content)).to be_an(Array)
+    end
+
+    it "correctly creates a :browser when there are no other details" do
+      result = process_compatibility_with(simple_content).first
+      expect(result.browser).to eq simple_content
+    end
+
+    it "correctly creates a :browser when there are other details" do
+      result = process_compatibility_with(complex_content).first
+      expect(result.browser).to eq simple_content
+    end
+
+    it "does not create a :version when no parentheses are provided" do
+      result = process_compatibility_with(simple_content).first
+      expect(result.version).to be nil
+    end
+
+    it "correctly creates a :version when it is provided without a key" do
+      result = process_compatibility_with(complex_content).first
+      expect(result.version).to eq version
+    end
+
+    it "correctly creates a :version when provided with a key" do
+      complex_content.sub!("(", "(version: ")
+      result = process_compatibility_with(complex_content).first
+      expect(result.version).to eq version
+    end
+
+    it "creates an entry for each browser separated by commas" do
+      input = "#{simple_content},  #{simple_content} ,#{simple_content}"
+      result = process_compatibility_with(input)
+      expect(result.length).to be 3
+
+      result.each do |compatibility|
+        expect(compatibility.browser).to eq simple_content
+      end
+    end
+
+    it "creates an entry for each browser separated by pipes" do
+      input = "#{simple_content}|  #{simple_content} |#{simple_content}"
+      result = process_compatibility_with(input)
+      expect(result.length).to be 3
+
+      result.each do |compatibility|
+        expect(compatibility.browser).to eq simple_content
+      end
+    end
+
+    it "creates an entry for a complex compatibility detail after a simple browser name, separated by commas" do
+      input = "#{simple_content}, #{complex_content}"
+      result = process_compatibility_with(input)
+      expect(result.length).to be 2
+
+      expect(result.first.browser).to eq simple_content
+      expect(result[1].browser).to eq simple_content
+      expect(result[1].version).to eq version
+    end
+
+    it "creates an entry for a complex compatibility detail after a simple browser name, separated by pipes" do
+      input = "#{simple_content} |#{complex_content}"
+      result = process_compatibility_with(input)
+      expect(result.length).to be 2
+
+      expect(result.first.browser).to eq simple_content
+      expect(result[1].browser).to eq simple_content
+      expect(result[1].version).to eq version
+    end
+
+    it "creates an entry for a browser name after a complex compatibility detail, separated by spaces" do
+      input = "#{complex_content}   #{simple_content}"
+      result = process_compatibility_with(input)
+      expect(result.length).to be 2
+
+      expect(result.first.browser).to eq simple_content
+      expect(result.first.version).to eq version
+      expect(result[1].browser).to eq simple_content
+    end
+
+    it "creates an entry for a browser name after a complex compatibility detail, separated by commas" do
+      input = "#{complex_content},  #{simple_content}"
+      result = process_compatibility_with(input)
+      expect(result.length).to be 2
+
+      expect(result.first.browser).to eq simple_content
+      expect(result.first.version).to eq version
+      expect(result[1].browser).to eq simple_content
+    end
+
+    it "creates an entry for a browser name after a complex compatibility detail, separated by pipes" do
+      input = "#{complex_content} || #{simple_content}"
+      result = process_compatibility_with(input)
+      expect(result.length).to be 2
+
+      expect(result.first.browser).to eq simple_content
+      expect(result.first.version).to eq version
+      expect(result[1].browser).to eq simple_content
+    end
+
+    it "creates an entry with details for each browser/ parentheses pair separated by spaces" do
+      input = "#{complex_content} #{complex_content}"
+      result = process_compatibility_with(input)
+      expect(result.length).to be 2
+
+      result.each do |compatibility|
+        expect(compatibility.browser).to eq simple_content
+        expect(compatibility.version).to eq version
+      end
+    end
+
+    it "creates an entry with details for each browser/ parentheses pair separated by pipes" do
+      input = "#{complex_content} |#{complex_content}"
+      result = process_compatibility_with(input)
+      expect(result.length).to be 2
+
+      result.each do |compatibility|
+        expect(compatibility.browser).to eq simple_content
+        expect(compatibility.version).to eq version
+      end
+    end
+
+    it "creates an entry with details for each browser/ parentheses pair separated by commas" do
+      input = "#{complex_content},  #{complex_content}"
+      result = process_compatibility_with(input)
+      expect(result.length).to be 2
+
+      result.each do |compatibility|
+        expect(compatibility.browser).to eq simple_content
+        expect(compatibility.version).to eq version
+      end
+    end
+
+    def process_compatibility_with(content)
+      symbol[subject.name] = content
+      subject.process(symbol)
+      symbol[subject.name]
+    end
+  end
+end

data/spec/lib/tags/demo_type_tag_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe Docks::Tags::DemoType do
+  subject { Docks::Tags::DemoType.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 "makes sure the value is a valid demo type" do
+      symbol = Docks::Containers::Symbol.new
+      symbol[subject.name] = Docks::Types::Demo::JOINT
+
+      expect(subject).to receive(:ensure_valid_demo_type).and_call_original
+      subject.process(symbol)
+      expect(symbol[subject.name]).to be Docks::Types::Demo::JOINT
+    end
+  end
+end

data/spec/lib/tags/deprecated_tag_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+
+describe Docks::Tags::Deprecated do
+  subject { Docks::Tags::Deprecated.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(:simple_version) { "v2.0" }
+    let(:complex_version) { "Version 2.0.32-b2034" }
+    let(:description) { "This is the description" }
+
+    it "returns just the version when no description is provided" do
+      expect(process_deprecation_with([simple_version]).version).to eq simple_version
+    end
+
+    it "gets a simple version when a description is provided" do
+      expect(process_deprecation_with(["#{simple_version}   - #{description}"]).version).to eq simple_version
+      expect(process_deprecation_with(["#{simple_version} -  #{description}"]).version).to eq simple_version
+    end
+
+    it "gets a complex version when a description is provided" do
+      expect(process_deprecation_with(["#{complex_version}   - #{description}"]).version).to eq complex_version
+      expect(process_deprecation_with(["#{complex_version} -  #{description}"]).version).to eq complex_version
+    end
+
+    it "returns a nil description when no description is provided" do
+      expect(process_deprecation_with([complex_version]).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_deprecation_with(["#{complex_version}   - #{description}"]).description).to eq target_description
+      expect(process_deprecation_with(["#{complex_version} -  #{description}"]).description).to eq target_description
+    end
+
+    def process_deprecation_with(content)
+      symbol[subject.name] = content
+      subject.process(symbol)
+      symbol[subject.name]
+    end
+  end
+end