docks_app 0.0.1

data/spec/lib/command_line_spec.rb

@@ -0,0 +1,77 @@
+require "spec_helper"
+
+dir = Dir.pwd
+
+describe Docks::CommandLine do
+  subject { Docks::CommandLine }
+
+  describe "#run" do
+    it "runs #init when the first argument is init" do
+      args = %w(init)
+      cli = subject.new(args)
+      expect(cli).to receive(:init)
+      cli.run
+    end
+
+    it "runs the core parsing and building steps when the first argument isn't init" do
+      args = []
+      cli = subject.new(args)
+      expect(Docks).to receive(:configure_with)
+      expect(Docks).to receive(:parse)
+      expect(Docks).to receive(:build)
+      cli.run
+    end
+
+    it "passes the clear cache switch to Docks.parse" do
+      args = ["--clear-cache"]
+      cli = subject.new(args)
+      expect(Docks).to receive(:configure_with)
+      expect(Docks).to receive(:parse).with hash_including(clear_cache: true)
+      expect(Docks).to receive(:build)
+      cli.run
+    end
+  end
+
+  describe "#init" do
+    it "assigns reasonable defaults" do
+      args = %w(init)
+      expect(Docks::Builder).to receive(:setup).with hash_including(config_type: "yaml", template_language: "erb", style_language: "scss", script_language: "javascript")
+      subject.new(args).init
+    end
+
+    it "assigns a config type" do
+      type = "ruby"
+      args = ["init", "--config=#{type}"]
+      expect(Docks::Builder).to receive(:setup).with hash_including(config_type: type)
+      subject.new(args).init
+    end
+
+    it "assigns a template language" do
+      language = "haml"
+      args = ["init", "--template=#{language}"]
+      expect(Docks::Builder).to receive(:setup).with hash_including(template_language: language)
+      subject.new(args).init
+    end
+
+    it "assigns a style preprocessor" do
+      preprocessor = "less"
+      args = ["init", "--styles=#{preprocessor}"]
+      expect(Docks::Builder).to receive(:setup).with hash_including(style_language: preprocessor)
+      subject.new(args).init
+    end
+
+    it "assigns a scripting language" do
+      language = "coffeescript"
+      args = ["init", "--scripts=#{language}"]
+      expect(Docks::Builder).to receive(:setup).with hash_including(script_language: language)
+      subject.new(args).init
+    end
+
+    it "assigns a theme" do
+      theme = "basic"
+      args = ["init", "--theme=#{theme}"]
+      expect(Docks::Builder).to receive(:setup).with hash_including(theme: theme)
+      subject.new(args).init
+    end
+  end
+end

data/spec/lib/configuration_spec.rb

@@ -0,0 +1,180 @@
+require "spec_helper"
+
+describe Docks do
+  subject { Docks }
+
+  it "has a config property" do
+    expect(subject.config).to be Docks::Configuration.instance
+  end
+
+  describe ".configure" do
+    it "yields the configuration object" do
+      yielded = nil
+      subject.configure { |config| yielded = config }
+      expect(yielded).to be Docks::Configuration.instance
+    end
+
+    it "pre- and post-configures before configuration" do
+      expect(subject).to receive(:pre_configuration)
+      expect(subject).to receive(:post_configuration)
+      subject.configure {}
+    end
+
+    it "only runs the pre-configuration steps if it hasn't already been configured" do
+      expect(subject).to receive(:pre_configuration).once
+      subject.configure {}
+      subject.configure {}
+    end
+
+    it "configures itself with the default config file if no block is passed" do
+      expect(subject).to receive(:configure_with).with Docks::CONFIG_FILE
+      subject.configure
+    end
+  end
+end
+
+describe Docks::Configuration do
+  subject { Docks::Configuration.instance }
+
+  it "has the default configuration" do
+    expect(subject.sources).to eq [
+      subject.root + "styles/**/*.{css,scss,sass,less,styl}",
+      subject.root + "scripts/**/*.{js,coffee,coffeescript}"
+    ]
+    expect(subject.compiled_assets).to eq []
+    expect(subject.github_repo).to be nil
+    expect(subject.root).to eq Pathname.pwd
+    expect(subject.destination).to eq subject.root + "public"
+    expect(subject.cache_location).to eq subject.root + ".#{Docks::Cache::DIR}"
+    expect(subject.templates).to eq subject.root + "#{Docks::ASSETS_DIR}/templates"
+    expect(subject.asset_folders).to eq OpenStruct.new(styles: "styles", scripts: "scripts")
+    expect(subject.mount_at).to eq "pattern-library"
+    expect(subject.theme).to eq Docks::Themes::API.instance
+    expect(subject.use_theme_assets).to be true
+  end
+
+  describe "#root=" do
+    it "updates all root-dependent paths for a new root" do
+      test_dir_name = ".foo"
+      FileUtils.rm_rf(test_dir_name)
+      FileUtils.mkdir(test_dir_name)
+
+      subject.root = File.join(Dir.pwd, test_dir_name)
+      subject.sources = %w(styles/foo.css)
+
+      expect(subject.root).to eq Pathname.new(test_dir_name).realpath
+      expect(subject.destination).to eq subject.root + "public"
+      expect(subject.cache_location).to eq subject.root + ".#{Docks::Cache::DIR}"
+      expect(subject.templates).to eq subject.root + "#{Docks::ASSETS_DIR}/templates"
+      expect(subject.sources).to eq [subject.root + "styles/foo.css"]
+
+      FileUtils.rm_rf(test_dir_name)
+    end
+  end
+
+  describe "#destination=" do
+    it "allows setting root-relative paths" do
+      subject.destination = "out"
+      expect(subject.destination).to eq subject.root + "out"
+    end
+
+    it "allows setting non-root-relative paths" do
+      destination = Dir[File.join(Dir.pwd, "*")].first
+      subject.destination = destination
+      expect(subject.destination).to eq Pathname.new(destination).realpath
+    end
+  end
+
+  describe "#asset_folders=" do
+    it "merges the default asset folders" do
+      defaults = subject.asset_folders
+      expect { subject.asset_folders = { scripts: "javascripts" } }.not_to change { defaults.styles }
+      expect(subject.asset_folders.scripts).to eq "javascripts"
+    end
+  end
+
+  describe "#custom_languages" do
+    it "yields the language manager" do
+      expect { |block| subject.custom_languages(&block) }.to yield_with_args Docks::Languages
+    end
+  end
+
+  describe "#custom_templates" do
+    it "yields the template manager" do
+      expect { |block| subject.custom_templates(&block) }.to yield_with_args Docks::Templates
+    end
+  end
+
+  describe "#custom_templates=" do
+    it "passes the templates to Templates.register" do
+      templates = { foo: "bar", bar: "baz" }
+      expect(Docks::Templates).to receive(:register).with(templates)
+      subject.custom_templates = templates
+    end
+  end
+
+  describe "#custom_tags" do
+    it "yields the tag manager" do
+      expect { |block| subject.custom_tags(&block) }.to yield_with_args Docks::Tags
+    end
+  end
+
+  describe "#custom_symbol_sources" do
+    it "yields the symbol source manager" do
+      expect { |block| subject.custom_symbol_sources(&block) }.to yield_with_args Docks::SymbolSources
+    end
+  end
+
+  describe "#custom_parsers" do
+    it "yields the parser manager" do
+      expect { |block| subject.custom_parsers(&block) }.to yield_with_args Docks::Parser
+    end
+  end
+
+  describe "#github_repo" do
+    it "returns nil when there is no github repo" do
+      expect(subject.github_repo).to be nil
+    end
+
+    it "returns the URL for a github repo when provided" do
+      subject.github_repo = "https://github.com/lemonmade/docks"
+      expect(subject.github_repo).to eq "https://github.com/lemonmade/docks"
+    end
+
+    it "constructs the github URL when the repo was specified" do
+      subject.github_repo = "lemonmade/docks"
+      expect(subject.github_repo).to eq "https://github.com/lemonmade/docks"
+    end
+  end
+
+  describe "#naming_convention=" do
+    it "asks the naming convention manager for the new naming convention" do
+      expect(Docks::NamingConventions).to receive(:for).with(:foo).and_return(:bar)
+      subject.naming_convention = :foo
+      expect(subject.naming_convention).to eq :bar
+    end
+  end
+
+  describe "#theme=" do
+    it "asks the theme manager to set the new theme" do
+      expect(Docks::Themes).to receive(:for).with(:foo).and_return(:bar)
+      subject.theme = :foo
+      expect(subject.theme).to eq :bar
+    end
+  end
+
+  describe "#pattern_id=" do
+    it "passes the pattern ID block to the Docks class method" do
+      identifier = Docks.instance_variable_get(:@pattern_id)
+      expect(Docks).to receive(:pattern_id=).with(identifier)
+      subject.pattern_id = identifier
+    end
+  end
+
+  describe "#pattern_id" do
+    it "calls the core pattern ID method" do
+      expect(Docks).to receive(:pattern_id).with("foo").and_return "foo"
+      expect(subject.pattern_id("foo")).to eq "foo"
+    end
+  end
+end

data/spec/lib/containers/base_container_spec.rb

@@ -0,0 +1,214 @@
+require "spec_helper"
+
+describe Docks::Containers::Base do
+  before(:each) { Docks::Tags.register_bundled_tags }
+
+  let(:hash) do
+    { name: "baz", param: Hash.new, title: "bar" }
+  end
+
+  let(:container) { Docks::Containers::Base.new(hash) }
+
+  describe "#method_missing" do
+    context "when the method ends with `=`" do
+      it "normalizes the passed tag name" do
+        expect(Docks::Tags).to receive(:base_tag_name).with(:title).at_least(:once).and_call_original
+        container.title = :bar
+      end
+
+      it "sends the base tag of unrecognized symbols to the initialization hash" do
+        expect(container.instance_variable_get(:@details)).to receive(:[]=).with(:title, :bar)
+        container.title = :bar
+      end
+
+      it "does the default method missing when the method is not a recognized tag" do
+        expect { container.foo = :bar }.to raise_error(NoMethodError)
+      end
+    end
+
+    context "when the method is a plural of a recognized tag" do
+      it "normalizes the singular version of the hash name" do
+        expect(Docks::Tags).to receive(:base_tag_name).at_least(:once).with(:params).and_call_original
+        container.params
+      end
+
+      it "does the default method missing when the method is not a recognized tag" do
+        expect { container.foos }.to raise_error(NoMethodError)
+      end
+    end
+
+    context "when the method ends with anything other than `=` and it's a recognized tag" do
+      it "normalizes the passed tag name" do
+        expect(Docks::Tags).to receive(:base_tag_name).with(:title).at_least(:once).and_call_original
+        container.title
+      end
+
+      it "sends the base tag of unrecognized symbols to the initialization hash" do
+        expect(container.instance_variable_get(:@details)).to receive(:fetch).with(:title, nil)
+        container.title
+      end
+
+      it "does the default method missing when the method is not a recognized tag" do
+        expect { container.foo }.to raise_error(NoMethodError)
+      end
+    end
+  end
+
+  describe "#[]" do
+    it "normalizes the passed tag name" do
+      expect(Docks::Tags).to receive(:base_tag_name).with(:title).and_call_original
+      container[:title]
+    end
+
+    it "accesses the item in the contained hash" do
+      expect(container[:title]).to eq hash[:title]
+    end
+
+    it "returns nil when there is no such key" do
+      expect(container[:pattern]).to be nil
+    end
+  end
+
+  describe "#[]=" do
+    it "normalizes the passed tag name" do
+      expect(Docks::Tags).to receive(:base_tag_name).with(:title).and_call_original
+      container[:title] = :bar
+    end
+
+    it "sets the item in the contained hash" do
+      expect(container.instance_variable_get(:@details)).to receive(:[]=).with(:title, :bar).and_call_original
+      container[:title] = :bar
+      expect(container[:title]).to eq :bar
+    end
+
+    it "doesn't set the value for a non-registered tag" do
+      expect(container.instance_variable_get(:@details)).to_not receive(:[]=)
+      container[:foo] = :bar
+    end
+  end
+
+  describe "#update" do
+    it "normalizes the passed tag name" do
+      expect(Docks::Tags).to receive(:base_tag_name).at_least(:once).with(:title).and_call_original
+      container.update(:title) {}
+    end
+
+    it "yields the current value of the tag" do
+      value = nil
+      expected = container.title
+
+      container.update(:title) { |val| value = val }
+      expect(value).to eq expected
+    end
+
+    it "updates the tag with the value returned from the block" do
+      value = "qux"
+      container.update(:title) { value }
+      expect(container.title).to eq value
+    end
+  end
+
+  describe "#delete" do
+    it "normalizes the passed tag name" do
+      expect(Docks::Tags).to receive(:base_tag_name).with(:title).and_call_original
+      container.delete(:title)
+    end
+
+    it "deletes the item in the contained hash" do
+      original = hash[:title]
+      expect(container.instance_variable_get(:@details)).to receive(:delete).with(:title).and_call_original
+      expect(container.delete(:title)).to eq original
+    end
+  end
+
+  describe "#fetch" do
+    it "normalizes the passed tag name" do
+      expect(Docks::Tags).to receive(:base_tag_name).with(:title).and_call_original
+      container.fetch(:title, :bar)
+    end
+
+    it "passes the fetch method along to the contained hash" do
+      expect(container.instance_variable_get(:@details)).to receive(:fetch).with(:title, :bar).and_call_original
+      container.fetch(:title, :bar)
+    end
+  end
+
+  describe "#to_h" do
+    it "returns the backing hash" do
+      expect(container.to_h).to eq hash
+    end
+
+    it "is aliased to #to_hash" do
+      expect(container.to_hash).to eq container.to_h
+    end
+  end
+
+  describe "#find" do
+    it "returns itself when it matches the descriptor" do
+      expect(container.find(container.name)).to be container
+    end
+
+    it "returns false when it does not match" do
+      expect(container.find("#{container.name}#foo")).to be false
+      expect(container.find("foo")).to be false
+    end
+  end
+
+  describe "#tags" do
+    around do |example|
+      Docks::Tags.register_bundled_tags
+      example.run
+      Docks::Tags.send(:clean)
+    end
+
+    it "returns an array with all tags in the item" do
+      container = Docks::Containers::Base.new
+      expect(container.tags).to be_empty
+
+      container[Docks::Tags::Title] = "foo"
+      expect(container.tags).to be_an Array
+      expect(container.tags.length).to be 1
+      expect(container.tags.first).to be Docks::Tags::Title.instance
+
+      container.name = "bar"
+      expect(container.tags.length).to be 2
+      expect(container.tags).to include Docks::Tags::Title.instance
+      expect(container.tags).to include Docks::Tags::Name.instance
+
+      container.delete(:name)
+      expect(container.tags.length).to be 1
+      expect(container.tags.first).to be Docks::Tags::Title.instance
+    end
+  end
+
+  describe "#summarized?" do
+    it "is summarized only if generated by #summary" do
+      expect(container).to_not be_summarized
+      expect(container.summary).to be_summarized
+    end
+  end
+
+  describe "#summary" do
+    let(:summary) { container.summary }
+
+    it "preserves the name" do
+      expect(summary).to be_a described_class
+      expect(summary.name).to eq container.name
+    end
+
+    it "doesn't preserve anything else" do
+      container.description = "something long " * 100
+      expect(container.summary.description).to be nil
+    end
+  end
+
+  describe "forwarded to hash" do
+    %w(to_s inspect to_json each).each do |forwarded_method|
+      it "forwards #{forwarded_method} to the backing hash" do
+        forwarded_method = forwarded_method.to_sym
+        expect(container.instance_variable_get(:@details)).to receive(forwarded_method).at_least(:once)
+        container.send(forwarded_method)
+      end
+    end
+  end
+end

data/spec/lib/containers/class_container_spec.rb

@@ -0,0 +1,209 @@
+require "spec_helper"
+
+describe Docks::Containers::Klass do
+  subject { Docks::Containers::Klass.new(name: "foo") }
+
+  let(:method) do
+    Docks::Containers::Function.new(name: "bar")
+  end
+
+  let(:property) do
+    Docks::Containers::Variable.new(name: "bar")
+  end
+
+  let(:private_method) do
+    Docks::Containers::Function.new(name: "baz", access: Docks::Types::Access::PRIVATE)
+  end
+
+  let(:private_property) do
+    Docks::Containers::Variable.new(name: "baz", access: Docks::Types::Access::PRIVATE)
+  end
+
+  let(:static_method) do
+    Docks::Containers::Function.new(name: "baz", static: true, access: Docks::Types::Access::PRIVATE)
+  end
+
+  let(:static_property) do
+    Docks::Containers::Variable.new(name: "baz", static: true, access: Docks::Types::Access::PRIVATE)
+  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 an instance method" do
+      static_method.name = method.name
+      subject.add_members(static_method, method)
+      expect(subject.find("#{subject.name}##{method.name}")).to be method
+    end
+
+    it "returns a static method" do
+      static_method.name = method.name
+      subject.add_members(method, static_method)
+      expect(subject.find("#{subject.name}.#{static_method.name}")).to be static_method
+    end
+
+    it "returns an instance property" do
+      static_property.name = property.name
+      subject.add_members(static_property, property)
+      expect(subject.find("#{subject.name}##{property.name}")).to be property
+    end
+
+    it "returns a static property" do
+      static_property.name = property.name
+      subject.add_members(property, static_property)
+      expect(subject.find("#{subject.name}.#{static_property.name}")).to be static_property
+    end
+  end
+
+  describe "#public_methods" do
+    it "returns an empty array when there are no public methods" do
+      subject.add_member(private_method)
+      expect(subject.public_methods).to be_empty
+    end
+
+    it "returns all public methods of the class" do
+      subject.add_members(method, private_method)
+      public_methods = subject.public_methods
+      expect(public_methods.length).to be 1
+      expect(public_methods.first).to be method
+    end
+  end
+
+  describe "#private_methods" do
+    it "returns an empty array when there are no private methods" do
+      subject.add_member(method)
+      expect(subject.private_methods).to be_empty
+    end
+
+    it "returns all private methods of the class" do
+      subject.add_members(method, private_method)
+      public_methods = subject.private_methods
+      expect(public_methods.length).to be 1
+      expect(public_methods.first).to be private_method
+    end
+  end
+
+  describe "#static_methods" do
+    it "returns an empty array when there are no static methods" do
+      subject.add_members(method, private_method)
+      expect(subject.static_methods).to be_empty
+    end
+
+    it "returns all static methods of the class" do
+      subject.add_members(method, static_method, private_method)
+      static_methods = subject.static_methods
+      expect(static_methods.length).to be 1
+      expect(static_methods.first).to be static_method
+    end
+  end
+
+  describe "#instance_methods" do
+    it "returns an empty array when there are no instance methods" do
+      subject.add_member(static_method)
+      expect(subject.instance_methods).to be_empty
+    end
+
+    it "returns all instance methods of the class" do
+      subject.add_members(method, static_method, private_method)
+      instance_methods = subject.instance_methods
+      expect(instance_methods.length).to be 2
+      expect(instance_methods).to include method
+      expect(instance_methods).to include private_method
+    end
+  end
+
+  describe "#public_properties" do
+    it "returns an empty array when there are no public properties" do
+      subject.add_member(private_property)
+      expect(subject.public_properties).to be_empty
+    end
+
+    it "returns all public properties of the class" do
+      subject.add_members(property, private_property)
+      public_properties = subject.public_properties
+      expect(public_properties.length).to be 1
+      expect(public_properties.first).to be property
+    end
+  end
+
+  describe "#private_properties" do
+    it "returns an empty array when there are no private properties" do
+      subject.add_member(property)
+      expect(subject.private_properties).to be_empty
+    end
+
+    it "returns all private properties of the class" do
+      subject.add_members(property, private_property)
+      public_properties = subject.private_properties
+      expect(public_properties.length).to be 1
+      expect(public_properties.first).to be private_property
+    end
+  end
+
+  describe "#static_properties" do
+    it "returns an empty array when there are no static properties" do
+      subject.add_members(property, private_property)
+      expect(subject.static_properties).to be_empty
+    end
+
+    it "returns all static properties of the class" do
+      subject.add_members(property, static_property, private_property)
+      static_properties = subject.static_properties
+      expect(static_properties.length).to be 1
+      expect(static_properties.first).to be static_property
+    end
+  end
+
+  describe "#instance_properties" do
+    it "returns an empty array when there are no instance properties" do
+      subject.add_member(static_property)
+      expect(subject.instance_properties).to be_empty
+    end
+
+    it "returns all instance properties of the class" do
+      subject.add_members(property, static_property, private_property)
+      instance_properties = subject.instance_properties
+      expect(instance_properties.length).to be 2
+      expect(instance_properties).to include property
+      expect(instance_properties).to include private_property
+    end
+  end
+
+  describe "#instance_members" do
+    it "includes all instance methods and properties" do
+      subject.add_members(method, private_method, static_method)
+      subject.add_members(property, private_property, static_property)
+
+      members = subject.instance_members
+      expect(members.length).to be 4
+      expect(members).to include method
+      expect(members).to include property
+      expect(members).to include private_method
+      expect(members).to include private_property
+    end
+  end
+
+  describe "#static_members" do
+    it "includes all static methods and properties" do
+      subject.add_members(method, private_method, static_method)
+      subject.add_members(property, private_property, static_property)
+
+      members = subject.static_members
+      expect(members.length).to be 2
+      expect(members).to include static_method
+      expect(members).to include static_property
+    end
+  end
+end