brainstem 1.0.0.pre.1 → 1.0.0

data/spec/brainstem/api_docs/resolver_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'brainstem/api_docs/resolver'
+
+class ActiveRecord::Base
+end
+
+module Brainstem
+  module ApiDocs
+    describe Resolver do
+      let(:atlas) { Object.new }
+      let(:options) { { } }
+
+      subject { described_class.new(atlas, options) }
+
+      describe "#initialize" do
+        it "requires an atlas" do
+          expect { described_class.new }.to raise_error ArgumentError
+          expect { described_class.new(atlas) }.not_to raise_error
+        end
+      end
+
+      describe "#find_by_class" do
+        let(:klass) { Class.new }
+        let(:result) { Object.new }
+
+        context "when activerecord" do
+          let(:klass)  { Class.new(ActiveRecord::Base) }
+
+          it "finds the presenter from the target class" do
+            mock(subject).find_presenter_from_target_class(klass) { result }
+            expect(subject.find_by_class(klass)).to eq result
+          end
+        end
+
+        context "when symbol" do
+          context "when polymorphic" do
+            let(:klass) { :polymorphic }
+
+            it "returns nil" do
+              expect(subject.find_by_class(klass)).to be_nil
+            end
+          end
+        end
+
+        context "when not found" do
+          it "returns nil" do
+            expect(subject.find_by_class(klass)).to be_nil
+          end
+        end
+      end
+
+
+      describe "#find_presenter_from_target_class" do
+        let(:klass)             { Class.new }
+        let(:presenter_const)   { Class.new }
+        let(:pclm)              { Object.new }
+        let(:presenter_wrapper) { OpenStruct.new(const: presenter_const) }
+        let(:options)           { { presenter_constant_lookup_method: pclm } }
+
+        before do
+          stub(klass).to_s { "Klass" }
+          mock(pclm).call("Klass") { presenter_const }
+          stub(atlas).presenters { [ presenter_wrapper ] }
+        end
+
+        it "returns the presenter" do
+          expect(subject.send(:find_presenter_from_target_class, klass)).to eq presenter_wrapper
+        end
+      end
+    end
+  end
+end

data/spec/brainstem/api_docs/sinks/abstract_sink_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'brainstem/api_docs/sinks/abstract_sink'
+
+module Brainstem
+  module ApiDocs
+    module Sinks
+      describe AbstractSink do
+        describe "#<<" do
+          it "is not implemented" do
+            expect { subject << Object.new }.to raise_error NotImplementedError
+          end
+        end
+      end
+    end
+  end
+end

data/spec/brainstem/api_docs/sinks/controller_presenter_multifile_sink_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+require 'brainstem/api_docs/sinks/controller_presenter_multifile_sink'
+
+module Brainstem
+  module ApiDocs
+    module Sinks
+      describe ControllerPresenterMultifileSink do
+        let(:write_method)  { Object.new }
+        let(:atlas)         { Object.new }
+        let(:options) {
+          {
+            format: :markdown,
+            write_method: write_method,
+            write_path: './'
+          }
+        }
+
+        subject { described_class.new(options) }
+
+        context "controllers" do
+          before do
+            stub(subject).write_presenter_files
+          end
+
+          it "writes each controller to its own file" do
+            stub(atlas).controllers
+              .stub!
+              .each_formatted_with_filename(:markdown, include_actions: true)
+              .yields('it has info', 'test.markdown')
+
+            mock(write_method).call("./test.markdown", "it has info")
+            subject << atlas
+          end
+        end
+
+
+        context "presenters" do
+          before do
+            stub(subject).write_controller_files
+          end
+
+
+          it "writes each presenter to its own file" do
+            stub(atlas).presenters
+              .stub!
+              .each_formatted_with_filename(:markdown)
+              .yields('it has info', 'test.markdown')
+
+            mock(write_method).call("./test.markdown", "it has info")
+            subject << atlas
+          end
+        end
+      end
+    end
+  end
+end

data/spec/brainstem/api_docs/sinks/stdout_sink_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'brainstem/api_docs/sinks/stdout_sink'
+
+module Brainstem
+  module ApiDocs
+    module Sinks
+      describe StdoutSink do
+        let(:output)      { "Zadok the Priest and Nathan the Prophet" }
+        let(:dummy_puts)  { Object.new }
+
+        subject { described_class.new(puts_method: dummy_puts) }
+
+        describe "#<<" do
+          it "calls the putting method" do
+            mock(dummy_puts).call(output)
+            subject << output
+          end
+        end
+      end
+    end
+  end
+end

data/spec/brainstem/api_docs_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'brainstem/api_docs'
+
+module Brainstem
+  describe ApiDocs do
+    let(:lorem) { "lorem ipsum dolor sit amet" }
+
+
+    describe "configuration" do
+      describe "formatters" do
+        it "has a formatters constant" do
+          expect(Brainstem::ApiDocs::FORMATTERS).to be_a(Hash)
+        end
+      end
+
+
+      %w(
+        controller_filename_pattern
+        presenter_filename_pattern
+        controller_filename_link_pattern
+        presenter_filename_link_pattern
+        write_path
+        output_extension
+        base_presenter_class
+        base_controller_class
+        document_empty_presenter_associations
+        document_empty_presenter_filters
+      ).each do |meth|
+        describe meth do
+          before do
+            @original = Brainstem::ApiDocs.public_send(meth)
+          end
+
+          after do
+            Brainstem::ApiDocs.public_send("#{meth}=", @original)
+          end
+
+          it "can be set and read" do
+            Brainstem::ApiDocs.public_send("#{meth}=", lorem)
+            expect(Brainstem::ApiDocs.public_send(meth)).to eq lorem
+          end
+        end
+      end
+    end
+
+    describe "filename link patterns" do
+      it 'defaults to the filename pattern' do
+        expect(Brainstem::ApiDocs.public_send("controller_filename_link_pattern")).
+          to eq(Brainstem::ApiDocs.public_send("controller_filename_pattern"))
+
+        expect(Brainstem::ApiDocs.public_send("presenter_filename_link_pattern")).
+          to eq(Brainstem::ApiDocs.public_send("presenter_filename_pattern"))
+      end
+    end
+
+
+  end
+end

data/spec/brainstem/cli/abstract_command_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+require 'brainstem/cli/abstract_command'
+
+module Brainstem
+  module CLI
+    describe AbstractCommand do
+      let(:options) { { } }
+      subject { AbstractCommand.new(options) }
+
+
+      describe ".call" do
+        before do
+          any_instance_of(AbstractCommand) do |instance|
+            stub(instance) do |obj|
+              obj.call
+              obj.extract_options!
+            end
+          end
+        end
+
+        it "creates a new instance" do
+          mock.proxy(AbstractCommand).new([])
+          AbstractCommand.call([])
+        end
+
+        it "passes its args to the instance" do
+          mock.proxy(AbstractCommand).new(%w(--silent))
+          AbstractCommand.call(%w(--silent))
+        end
+
+        it "calls the new instance" do
+          any_instance_of(AbstractCommand) do |instance|
+            mock(instance).call
+          end
+
+          AbstractCommand.call([])
+        end
+
+        it "it returns the new instance" do
+          expect(AbstractCommand.call).to be_an AbstractCommand
+        end
+      end
+
+
+      describe "#extract_options!" do
+        let(:option_parser) { Object.new }
+        let(:args) { %w(--silent --pretend) }
+
+        it "feeds the args to the class's option parser" do
+          mock(option_parser).order!(args)
+
+          any_instance_of(AbstractCommand) do |instance|
+            mock(instance).option_parser { option_parser }
+          end
+
+          AbstractCommand.new(args)
+        end
+      end
+
+
+      describe "#option_parser" do
+        it "is not implemented" do
+          expect { AbstractCommand.new }.to raise_error NotImplementedError
+        end
+      end
+
+
+      describe "#initialize" do
+        it "extracts options from args" do
+          any_instance_of(AbstractCommand) do |instance|
+            mock(instance).extract_options!
+          end
+
+          AbstractCommand.new
+        end
+      end
+
+      describe "#call" do
+        before do
+          any_instance_of(AbstractCommand) do |instance|
+            stub(instance).extract_options!
+          end
+        end
+
+        it "is not implemented" do
+          expect { subject.call }.to raise_error NotImplementedError
+        end
+      end
+    end
+  end
+end

data/spec/brainstem/cli/generate_api_docs_command_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+require 'brainstem/cli/generate_api_docs_command'
+
+module Brainstem
+  module CLI
+    describe GenerateApiDocsCommand do
+      let(:args) { [ ] }
+
+      subject { GenerateApiDocsCommand.new(args) }
+
+      describe "options" do
+        xcontext "when --markdown" do
+          let(:args) { %w(--markdown) }
+
+          it "sets sink options method to the MarkdownFormatter instantiation" do
+            expect(subject.options[:builder]).to have_key :formatter_method
+            expect(subject.options[:builder][:formatter_method]).to be_a Method
+
+            # TODO: If we need to go further here, we can implement .call on
+            # the formatter:
+            # expect(subject.options[:builder][:formatter_method].owner).to \
+            #   eq Brainstem::ApiDocs::Formatters::AbstractFormatter
+          end
+        end
+
+        context "when --multifile-presenters-and-controllers" do
+          let(:args) { %w(--multifile-presenters-and-controllers) }
+
+          it "sets sink to a ControllerPresenterMultifileSink" do
+            expect(subject.options).to have_key :sink
+            expect(subject.options[:sink][:method].call).to be_a \
+              Brainstem::ApiDocs::Sinks::ControllerPresenterMultifileSink
+          end
+        end
+
+        context "when --output-dir" do
+          let(:args) { %w(--output-dir=./blah) }
+
+          it "sets the write_path option of the sink" do
+            expect(subject.options[:sink][:options][:write_path]).to eq "./blah"
+          end
+        end
+
+        context "when --controller-matches" do
+          let(:matches) { subject.options[:builder][:args_for_atlas][:controller_matches] }
+
+          context "when just one match specified" do
+            let(:args) { %w(--controller-matches=/workspaces/) }
+            it "creates a case-insensitive regexp from the in-between-slash info" do
+              mock.proxy(Regexp).new('workspaces', 'i')
+              subject
+            end
+
+            it "appends to the match terms" do
+              expect(matches).to include Regexp.new('workspaces', 'i')
+            end
+          end
+
+          context "when multiple matches specified" do
+            let(:args) { %w(--controller-matches=/workspaces/ --controller-matches=/extra/) }
+
+            it "allows additional specification and merges the arguments" do
+              expect(matches).to include Regexp.new('workspaces', 'i')
+            end
+          end
+        end
+      end
+
+
+      describe "execution" do
+        context "when no sink provided" do
+          before do
+            any_instance_of(described_class) do |instance|
+              stub(instance).default_sink_method { nil }
+            end
+          end
+
+          it "raises an error" do
+            expect { subject.call }.to raise_error \
+              Brainstem::ApiDocs::NoSinkSpecifiedException
+          end
+        end
+
+        context "when sink specified" do
+          before do
+            stub(subject).ensure_sink_specified!
+          end
+
+          describe "builder" do
+            let(:builder_options) { { builder: { test: 123 } } }
+
+            before do
+              stub(subject).present_atlas!
+              stub(subject).builder_options { builder_options }
+            end
+
+            it "creates a new builder with builder options passed" do
+              mock(Brainstem::ApiDocs::Builder).new(builder_options)
+              subject.call
+            end
+          end
+
+          describe "presentation" do
+            it "sends the atlas to the sink" do
+              atlas       = Object.new
+              builder     = mock!.atlas.returns(atlas).subject
+              sink        = mock!.<<(atlas).subject
+              sink_method = mock!.call({ test: 123 }).returns(sink).subject
+
+              stub(subject) do |sub|
+                sub.construct_builder!
+                sub.builder { builder }
+                sub.sink_options { { test: 123 } }
+                sub.sink_method { sink_method }
+              end
+
+              subject.call
+            end
+          end
+        end
+      end
+
+    end
+  end
+end