docks_app 0.0.1

data/spec/lib/languages/haml_language_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+describe Docks::Languages::Haml do
+  subject { Docks::Languages::Haml.instance }
+
+  describe ".extensions" do
+    let(:extensions) { [subject.class.extensions].flatten }
+
+    it "includes .haml as an extension" do
+      expect(extensions).to include "haml"
+    end
+  end
+
+  describe "#helper_markup_for" do
+    let(:mixed_arguments) { ["hello", 10, false, :goodbye, { bar: "baz", "baz" => :qux }] }
+    let(:mixed_arguments_output) { "\"hello\", 10, false, :goodbye, bar: \"baz\",\n#{" " * 36}\"baz\" => :qux" }
+    let(:argumentless_hash) { { "baz" => :qux } }
+    let(:argumentless_hash_output) { "\"baz\" => :qux" }
+
+    it "converts an array of arguments into the corresponding function" do
+      expect(subject.helper_markup_for("foo", mixed_arguments)).to eq "= foo #{mixed_arguments_output}"
+    end
+
+    it "converts a hash with an arguments key into the corresponding function" do
+      expect(subject.helper_markup_for("foo", arguments: mixed_arguments)).to eq "= foo #{mixed_arguments_output}"
+    end
+
+    it "converts a hash without an array key into a function with the hash as the only param" do
+      expect(subject.helper_markup_for("foo", argumentless_hash)).to eq "= foo #{argumentless_hash_output}"
+    end
+  end
+end

data/spec/lib/languages/javascript_language_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+
+describe Docks::Languages::JavaScript do
+  subject { Docks::Languages::JavaScript.instance }
+
+  describe ".extensions" do
+    let(:extensions) { [subject.class.extensions].flatten }
+
+    it "includes .js as an extension" do
+      expect(extensions).to include "js"
+    end
+  end
+
+  describe "#signature_for" do
+    let(:name) { "foo" }
+    let(:function_no_params) { Docks::Containers::Function.new(name: name) }
+    let(:function_with_params) { Docks::Containers::Function.new(name: name, params: [OpenStruct.new(name: "bar"), OpenStruct.new(name: "baz", optional: true, default: "'qux'")]) }
+    let(:klass) { Docks::Containers::Klass.new(name: name.capitalize, params: function_with_params.params) }
+    let(:something_else) { Docks::Containers::Variable.new(name: "bar") }
+
+    it "gives a signature to functions with no params" do
+      expect(subject.signature_for(function_no_params)).to eq "function #{function_no_params.name}() { /* ... */ }"
+    end
+
+    it "gives a signature to functions with params, including default values" do
+      expect(subject.signature_for(function_with_params)).to eq "function #{function_with_params.name}(bar, [baz = 'qux']) { /* ... */ }"
+    end
+
+    it "gives a signature for classes with params, including default values" do
+      expect(subject.signature_for(klass)).to eq "function #{klass.name}(bar, [baz = 'qux']) { /* ... */ }"
+    end
+
+    it "gives a signature to instance methods with classes" do
+      klass.add_member(function_with_params)
+      expect(subject.signature_for(function_with_params)).to eq "#{klass.name}.prototype.#{function_with_params.name} = function(bar, [baz = 'qux']) { /* ... */ }"
+    end
+
+    it "gives a signature to instance methods with factories" do
+      factory = Docks::Containers::Factory.new(klass)
+      factory.add_member(function_with_params)
+      expect(subject.signature_for(function_with_params)).to eq "#{function_with_params.name}: function(bar, [baz = 'qux']) { /* ... */ }"
+    end
+
+    it "gives a signature to static methods" do
+      function_with_params.static = true
+      klass.add_member(function_with_params)
+      expect(subject.signature_for(function_with_params)).to eq "#{klass.name}.#{function_with_params.name} = function(bar, [baz = 'qux']) { /* ... */ }"
+    end
+
+    it "doesn't provide a signature for a non-function symbol" do
+      expect(subject.signature_for(something_else)).to be nil
+    end
+  end
+end

data/spec/lib/languages/json_language_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe Docks::Languages::JSON do
+  subject { Docks::Languages::JSON.instance }
+
+  describe ".extensions" do
+    let(:extensions) { [subject.class.extensions].flatten }
+
+    it "includes .erb as an extension" do
+      expect(extensions).to include "json"
+    end
+  end
+
+  describe "#load_stub" do
+    let(:stub_file) { File.expand_path("../../../fixtures/languages/stub.json", __FILE__) }
+    let(:expected_stub) do
+      { "foo" => "bar" }
+    end
+
+    it "loads a stub file" do
+      expect(subject.load_stub(stub_file)).to eq expected_stub
+    end
+  end
+end

data/spec/lib/languages/less_language_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+describe Docks::Languages::Less do
+  subject { Docks::Languages::Less.instance }
+
+  describe ".extensions" do
+    let(:extensions) { [subject.class.extensions].flatten }
+
+    it "includes .less as an extension" do
+      expect(extensions).to include "less"
+    end
+  end
+
+  describe "#signature_for" do
+    let(:name) { "foo" }
+
+    let(:mixin_no_params) { Docks::Containers::Mixin.new(name: name) }
+    let(:mixin_with_params) { Docks::Containers::Mixin.new(name: name, params: [OpenStruct.new(name: "bar"), OpenStruct.new(name: "baz", default: "'qux'")]) }
+
+    let(:something_else) { Docks::Containers::Component.new(name: name) }
+
+    it "gives a signature to mixins with no params" do
+      expect(subject.signature_for(mixin_no_params)).to eq ".#{name}() { /* ... */ }"
+    end
+
+    it "gives a signature to mixins with params, including default values" do
+      expect(subject.signature_for(mixin_with_params)).to eq ".#{name}(@bar, @baz: 'qux') { /* ... */ }"
+    end
+
+    it "only prefixes variable names with @ if they don't already have it" do
+      mixin_with_params.params.first.name = "@bar"
+      expect(subject.signature_for(mixin_with_params)).to eq ".#{name}(@bar, @baz: 'qux') { /* ... */ }"
+    end
+
+    it "returns nil if the symbol is not a function/ mixin" do
+      expect(subject.signature_for(something_else)).to be nil
+    end
+  end
+end

data/spec/lib/languages/markup_language_spec.rb

@@ -0,0 +1,95 @@
+require "spec_helper"
+
+class MarkupLanguageTester
+  include Docks::Languages::Common::Markup
+end
+
+describe Docks::Languages::Common::Markup do
+  subject { MarkupLanguageTester.new }
+
+  let(:mixed_arguments) { ["hello", 10, false, :goodbye, { bar: "baz", "baz" => :qux }] }
+  let(:mixed_arguments_output) { "\"hello\", 10, false, :goodbye, bar: \"baz\",\n#{" " * 34}\"baz\" => :qux" }
+  let(:argumentless_hash) { { "baz" => :qux } }
+  let(:argumentless_hash_output) { "\"baz\" => :qux" }
+
+  describe "#functionize_helper" do
+    it "converts an array of arguments into the corresponding function" do
+      expect(subject.send(:functionize_helper, "foo", mixed_arguments)).to eq "foo #{mixed_arguments_output}"
+    end
+
+    it "converts a hash with an arguments key into the corresponding function" do
+      expect(subject.send(:functionize_helper, "foo", arguments: mixed_arguments)).to eq "foo #{mixed_arguments_output}"
+    end
+
+    it "converts a hash without an array key into a function with the hash as the only param" do
+      expect(subject.send(:functionize_helper, "foo", argumentless_hash)).to eq "foo #{argumentless_hash_output}"
+    end
+
+    it "does not strip symbols from contained hashes when a hash is the last argument" do
+      argumentless_hash["baz"] = argumentless_hash[:qux] = argumentless_hash.clone
+      expected_output = "\"baz\" => { #{argumentless_hash_output} },\n    qux: { #{argumentless_hash_output} }"
+      expect(subject.send(:functionize_helper, "foo", argumentless_hash)).to eq "foo #{expected_output}"
+    end
+  end
+
+  describe "#normalize_arguments" do
+    it "assumes a passed array is the array of arguments" do
+      array = ["foo"]
+      expect(subject.send(:normalize_arguments, array)).to eq array
+    end
+
+    it "assumes the passed object is the only argument if it has no arguments key" do
+      hash = { foo: "bar" }
+      expect(subject.send(:normalize_arguments, hash)).to eq [hash]
+    end
+
+    it "sets the arguments to the contents of the arguments attribute" do
+      hash_one = { arguments: ["foo"] }
+      hash_two = { "arguments" => ["bar"] }
+
+      expect(subject.send(:normalize_arguments, hash_one)).to eq ["foo"]
+      expect(subject.send(:normalize_arguments, hash_two)).to eq ["bar"]
+    end
+
+    it "sets the arguments to the contents of the arguments attribute in an array" do
+      hash_one = { foo: "bar" }
+      hash_two = { arguments: hash_one }
+
+      expect(subject.send(:normalize_arguments, hash_two)).to eq [hash_one]
+    end
+  end
+
+  describe "#stringfy_val" do
+    it "stringifies strings" do
+      expect(subject.send(:stringify_val, "foo")).to eq "\"foo\""
+    end
+
+    it "stringies numbers" do
+      expect(subject.send(:stringify_val, 10)).to eq "10"
+      expect(subject.send(:stringify_val, 0)).to eq "0"
+      expect(subject.send(:stringify_val, -10)).to eq "-10"
+      expect(subject.send(:stringify_val, 10_000)).to eq "10_000"
+    end
+
+    it "stringies booleans" do
+      expect(subject.send(:stringify_val, false)).to eq "false"
+      expect(subject.send(:stringify_val, true)).to eq "true"
+    end
+
+    it "stringifes symbols" do
+      expect(subject.send(:stringify_val, :foo)).to eq ":foo"
+      expect(subject.send(:stringify_val, :"foo bar baz")).to eq ":\"foo bar baz\""
+    end
+
+    it "stringifies arrays" do
+      expect(subject.send(:stringify_val, mixed_arguments)).to eq "[#{mixed_arguments.map { |arg| subject.send(:stringify_val, arg) }.join(", ")}]"
+    end
+
+    it "stringifies hashes" do
+      expect(subject.send(:stringify_val, foo: :bar, baz: :qux)).to eq "{ foo: :bar, baz: :qux }"
+      expect(subject.send(:stringify_val, "foo" => "bar")).to eq "{ \"foo\" => \"bar\" }"
+      expect(subject.send(:stringify_val, "foo" => "bar", baz: :qux)).to eq "{ \"foo\" => \"bar\", baz: :qux }"
+    end
+  end
+end
+

data/spec/lib/languages/sass_language_spec.rb

@@ -0,0 +1,53 @@
+require "spec_helper"
+
+describe Docks::Languages::Sass do
+  subject { Docks::Languages::Sass.instance }
+
+  describe ".extensions" do
+    let(:extensions) { [subject.class.extensions].flatten }
+
+    it "includes .scss as an extension" do
+      expect(extensions).to include "scss"
+    end
+
+    it "includes .sass as an extension" do
+      expect(extensions).to include "sass"
+    end
+  end
+
+  describe "#signature_for" do
+    let(:name) { "foo" }
+
+    let(:function_no_params) { Docks::Containers::Function.new(name: name) }
+    let(:function_with_params) { Docks::Containers::Function.new(name: name, params: [OpenStruct.new(name: "bar"), OpenStruct.new(name: "baz", default: "'qux'")]) }
+    let(:mixin_no_params) { Docks::Containers::Mixin.new(name: name) }
+    let(:mixin_with_params) { Docks::Containers::Mixin.new(name: name, params: [OpenStruct.new(name: "bar"), OpenStruct.new(name: "baz", default: "'qux'")]) }
+
+    let(:something_else) { Docks::Containers::Component.new(name: name) }
+
+    it "gives a signature to functions with no params" do
+      expect(subject.signature_for(function_no_params)).to eq "@function #{name}() { /* ... */ }"
+    end
+
+    it "gives a signature to functions with params, including default values" do
+      expect(subject.signature_for(function_with_params)).to eq "@function #{name}($bar, $baz: 'qux') { /* ... */ }"
+    end
+
+    it "gives a signature to mixins with no params" do
+      expect(subject.signature_for(mixin_no_params)).to eq "@mixin #{name}() { /* ... */ }"
+    end
+
+    it "gives a signature to mixins with params, including default values" do
+      expect(subject.signature_for(mixin_with_params)).to eq "@mixin #{name}($bar, $baz: 'qux') { /* ... */ }"
+    end
+
+    it "only prefixes variable names with dollar signs if they don't already exist" do
+      function_with_params.params.first.name = "$bar"
+      expect(subject.signature_for(function_with_params)).to eq "@function #{name}($bar, $baz: 'qux') { /* ... */ }"
+    end
+
+    it "returns nil if the symbol is not a function/ mixin" do
+      expect(subject.signature_for(something_else)).to be nil
+    end
+  end
+end

data/spec/lib/languages/slim_language_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+describe Docks::Languages::Slim do
+  subject { Docks::Languages::Slim.instance }
+
+  describe ".extensions" do
+    let(:extensions) { [subject.class.extensions].flatten }
+
+    it "includes .slim as an extension" do
+      expect(extensions).to include "slim"
+    end
+  end
+
+  describe "#helper_markup_for" do
+    let(:mixed_arguments) { ["hello", 10, false, :goodbye, { bar: "baz", "baz" => :qux }] }
+    let(:mixed_arguments_output) { "\"hello\", 10, false, :goodbye, bar: \"baz\",\n#{" " * 37}\"baz\" => :qux" }
+    let(:argumentless_hash) { { "baz" => :qux } }
+    let(:argumentless_hash_output) { "\"baz\" => :qux" }
+
+    it "converts an array of arguments into the corresponding function" do
+      expect(subject.helper_markup_for("foo", mixed_arguments)).to eq "== foo #{mixed_arguments_output}"
+    end
+
+    it "converts a hash with an arguments key into the corresponding function" do
+      expect(subject.helper_markup_for("foo", arguments: mixed_arguments)).to eq "== foo #{mixed_arguments_output}"
+    end
+
+    it "converts a hash without an array key into a function with the hash as the only param" do
+      expect(subject.helper_markup_for("foo", argumentless_hash)).to eq "== foo #{argumentless_hash_output}"
+    end
+  end
+end

data/spec/lib/languages/stylus_language_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+describe Docks::Languages::Stylus do
+  subject { Docks::Languages::Stylus.instance }
+
+  describe ".extensions" do
+    let(:extensions) { [subject.class.extensions].flatten }
+
+    it "includes .less as an extension" do
+      expect(extensions).to include "styl"
+    end
+  end
+
+  describe "#signature_for" do
+    let(:name) { "foo" }
+
+    let(:mixin_no_params) { Docks::Containers::Mixin.new(name: name) }
+    let(:mixin_with_params) { Docks::Containers::Mixin.new(name: name, params: [OpenStruct.new(name: "bar"), OpenStruct.new(name: "baz", default: "'qux'")]) }
+
+    let(:something_else) { Docks::Containers::Component.new(name: name) }
+
+    it "gives a signature to mixins with no params" do
+      expect(subject.signature_for(mixin_no_params)).to eq "#{name}() // ..."
+    end
+
+    it "gives a signature to mixins with params, including default values" do
+      expect(subject.signature_for(mixin_with_params)).to eq "#{name}(bar, baz = 'qux') // ..."
+    end
+
+    it "returns nil if the symbol is not a function/ mixin" do
+      expect(subject.signature_for(something_else)).to be nil
+    end
+  end
+end

data/spec/lib/languages/yaml_language_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe Docks::Languages::YAML do
+  subject { Docks::Languages::YAML.instance }
+
+  describe ".extensions" do
+    let(:extensions) { [subject.class.extensions].flatten }
+
+    it "includes .erb as an extension" do
+      expect(extensions).to include "yml"
+    end
+  end
+
+  describe "#load_stub" do
+    let(:stub_file) { File.expand_path("../../../fixtures/languages/stub.yml", __FILE__) }
+    let(:expected_stub) do
+      { "foo" => "bar" }
+    end
+
+    it "loads a stub file" do
+      expect(subject.load_stub(stub_file)).to eq expected_stub
+    end
+  end
+end

data/spec/lib/languages_spec.rb

@@ -0,0 +1,127 @@
+require "spec_helper"
+
+describe Docks::Languages do
+  subject { Docks::Languages }
+
+  before :each do
+    subject.send(:clean)
+  end
+
+  describe ".extensions" do
+    it "returns all extensions in an array" do
+      subject.register(Docks::Languages::Haml)
+      subject.register(Docks::Languages::CoffeeScript)
+
+      [Docks::Languages::Haml.extensions].flatten.each do |extension|
+        expect(subject.extensions).to include(extension)
+      end
+
+      [Docks::Languages::CoffeeScript.extensions].flatten.each do |extension|
+        expect(subject.extensions).to include(extension)
+      end
+    end
+  end
+
+  describe ".<type>_extensions" do
+    it "has a method to retrieve extensions for each type of file" do
+      Docks::Types::Languages.constants.each do |const|
+        expect(subject.respond_to?("#{Docks::Types::Languages.const_get(const)}_extensions")).to be true
+      end
+    end
+
+    it "registers extensions with the correct type" do
+      subject.register(Docks::Languages::Haml)
+      subject.register(Docks::Languages::CoffeeScript)
+
+      [Docks::Languages::Haml.extensions].flatten.each do |extension|
+        expect(subject.send("#{Docks::Languages::Haml.type}_extensions".to_sym)).to include(extension)
+        expect(subject.send("#{Docks::Languages::CoffeeScript.type}_extensions".to_sym)).not_to include(extension)
+      end
+
+      [Docks::Languages::CoffeeScript.extensions].flatten.each do |extension|
+        expect(subject.send("#{Docks::Languages::CoffeeScript.type}_extensions".to_sym)).to include(extension)
+        expect(subject.send("#{Docks::Languages::Haml.type}_extensions".to_sym)).not_to include(extension)
+      end
+    end
+  end
+
+  describe ".register_bundled_languages" do
+    it "registers all bundled languages" do
+      extensions = []
+      subject.constants.select do |const|
+        klass = subject.const_get(const)
+        next unless Class === klass && !(klass.eql?(subject::Base))
+
+        expect(subject).to receive(:register).with(klass).and_call_original
+        extensions.concat([klass.extensions].flatten)
+      end
+
+      subject.register_bundled_languages
+
+      bundled_extensions = subject.extensions
+      extensions.each do |extension|
+        expect(bundled_extensions).to include(extension)
+      end
+    end
+  end
+
+  describe ".language_for" do
+    it "returns the language associated with a file" do
+      subject.register(Docks::Languages::CoffeeScript)
+
+      [Docks::Languages::CoffeeScript.extensions].flatten.each do |extension|
+        expect(subject.language_for("foo/bar/baz.#{extension}")).to be Docks::Languages::CoffeeScript.instance
+        expect(subject.language_for("foo/bar/baz.min.#{extension}")).to be Docks::Languages::CoffeeScript.instance
+      end
+    end
+
+    it "returns nil when no language exists to manage that file" do
+      expect(subject.language_for("foo/bar/baz.#{[Docks::Languages::Haml.extensions].flatten.first}")).to be nil
+    end
+  end
+
+  describe ".file_type" do
+    it "correctly recognizes a registered file type" do
+      subject.register(Docks::Languages::CoffeeScript)
+
+      [Docks::Languages::CoffeeScript.extensions].flatten.each do |extension|
+        expect(subject.file_type("foo/bar/baz.#{extension}")).to be Docks::Types::Languages::SCRIPT
+        expect(subject.file_type("foo/bar/baz.min.#{extension}")).to be Docks::Types::Languages::SCRIPT
+      end
+    end
+
+    it "returns nil for an unregistered file type" do
+      expect(subject.file_type("foo/bar/baz.coffee")).to be nil
+    end
+  end
+
+  describe ".supported_file?" do
+    it "supports a file type whose extension is associated with a registered language" do
+      subject.register(Docks::Languages::CoffeeScript)
+
+      [Docks::Languages::CoffeeScript.extensions].flatten.each do |extension|
+        expect(subject.supported_file?("foo/bar/baz.#{extension}")).to be true
+        expect(subject.supported_file?("foo/bar/baz.min.#{extension}")).to be true
+      end
+    end
+
+    it "doesn't support a file whose extension hasn't been registered" do
+      expect(subject.supported_file?("foo/bar/baz.coffee")).to be false
+    end
+  end
+
+  describe ".register" do
+    it "registers all symbols sources for the language" do
+      Array(Docks::Languages::Sass.symbol_sources).each do |source|
+        expect(Docks::SymbolSources).to receive(:register).with source
+      end
+
+      subject.register(Docks::Languages::Sass)
+    end
+
+    it "is aliased to <<" do
+      expect(subject).to receive(:register).with Docks::Languages::Sass
+      subject << Docks::Languages::Sass
+    end
+  end
+end

data/spec/lib/markdown_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+
+describe Docks::Markdown::Renderer do
+  subject { Redcarpet::Markdown.new(described_class, fenced_code_blocks: true) }
+
+  describe "#block_code" do
+    let(:code) { "<div>\n  <p>Hi!</p>\n</div>" }
+    let(:language) { "html" }
+    let(:code_block) { "```#{language}\n#{code}\n```" }
+
+    it "wraps the content of the code block in a fake element for view-side processing" do
+      result = subject.render(code_block)
+      expect(result).to have_tag "fenced_code_block", content: code
+      expect(result).to_not have_tag "pre"
+      expect(result).to_not have_tag "code"
+    end
+
+    it "adds a data property with the language" do
+      result = subject.render(code_block)
+      expect(result).to have_tag "fenced_code_block", with: { "data-language" => language }
+    end
+
+    it "adds a data property to include a demo if the language has _demo in it, and strips this from the language" do
+      code_block.sub!(language, "#{language}_demo")
+      result = subject.render(code_block)
+      expect(result).to have_tag "fenced_code_block", with: { "data-language" => language, "data-has-demo" => "true" }
+    end
+  end
+
+  describe "#link" do
+    let(:name) { "button" }
+
+    it "doesn't mess up standard links" do
+      description = "[`Apple`](http://apple.com)"
+      expect(subject.render(description)).to eq Redcarpet::Markdown.new(Redcarpet::Render::HTML).render(description)
+    end
+
+    it "preserves @link declarations" do
+      result = subject.render("[#{name}](@link #{name})")
+      expect(result).to have_tag "a", with: { href: "@link #{name}" }
+    end
+
+    it "uses the text from the link for a bare @link declaration" do
+      result = subject.render("[#{name}](@link)")
+      expect(result).to have_tag "a", with: { href: "@link #{name}" }
+    end
+
+    it "removes excess tags from the content for bare @link declarations" do
+      result = subject.render("[`#{name}`](@link)")
+      expect(result).to have_tag "a", with: { href: "@link #{name}" }
+    end
+
+    it "adds a span around content without any wrapping HTML tags" do
+      result = subject.render("[#{name}](@link)")
+      expect(result).to have_tag "span", text: name
+    end
+
+    it "doesn't add a span when it doesn't need to" do
+      result = subject.render("[`#{name}`](@link)")
+      expect(result).to_not have_tag "span"
+    end
+  end
+end

data/spec/lib/messenger_spec.rb

@@ -0,0 +1 @@
+# TODO