brainstem 1.0.0.pre.1 → 1.0.0

data/spec/brainstem/api_docs/introspectors/abstract_introspector_spec.rb

@@ -0,0 +1,192 @@
+require 'spec_helper'
+require 'brainstem/api_docs/introspectors/abstract_introspector'
+
+module Brainstem
+  module ApiDocs
+    module Introspectors
+      describe AbstractIntrospector do
+        subject { AbstractIntrospector.send(:new) }
+
+        describe ".with_loaded_environment" do
+          it "passes along all options" do
+            any_instance_of(AbstractIntrospector) { |instance| stub(instance).one=(1) }
+            mock.proxy(AbstractIntrospector).new(one: 1) do |obj|
+              stub(obj) do |stub|
+                stub.load_environment!
+              end
+            end
+
+            AbstractIntrospector.with_loaded_environment(one: 1)
+          end
+
+          it "invokes #load_environment! on the instance" do
+            stub.proxy(AbstractIntrospector).new do |obj|
+              mock(obj).load_environment!
+            end
+
+            AbstractIntrospector.with_loaded_environment
+          end
+
+          it "returns the instance" do
+            instance = Object.new
+            stub(instance).load_environment!
+            stub.proxy(AbstractIntrospector).new { |_| instance }
+
+            expect(AbstractIntrospector.with_loaded_environment).to eq instance
+          end
+        end
+
+        describe "#initialize" do
+          it "is private" do
+            expect { AbstractIntrospector.new }.to raise_error NoMethodError
+            expect { AbstractIntrospector.send(:new) }.not_to raise_error
+          end
+        end
+
+
+        describe "#load_environment!" do
+          it "is not implemented" do
+            expect { subject.send(:load_environment!) }.to raise_error NotImplementedError
+          end
+
+        end
+
+        describe "#controllers" do
+          it "is not implemented" do
+            expect { subject.controllers }.to raise_error NotImplementedError
+          end
+        end
+
+        describe "#presenters" do
+          it "is not implemented" do
+            expect { subject.presenters }.to raise_error NotImplementedError
+          end
+        end
+
+        describe "#routes" do
+          it "is not implemented" do
+            expect { subject.routes }.to raise_error NotImplementedError
+          end
+        end
+
+        describe "#valid?" do
+          let! (:controllers_valid) { true }
+          let! (:presenters_valid)  { true }
+          let! (:routes_valid)      { true }
+
+          before do
+            stub(subject) do |s|
+              s.valid_controllers?  { controllers_valid }
+              s.valid_presenters?   { presenters_valid }
+              s.valid_routes?       { routes_valid }
+            end
+          end
+
+          context "when controllers, presenters, and routes are valid" do
+            it "is valid" do
+              expect(subject.valid?).to eq true
+            end
+          end
+
+          context "when controllers are invalid" do
+            let(:controllers_valid) { false }
+
+            it "is not valid" do
+              expect(subject.valid?).to eq false
+            end
+
+          end
+
+          context "when presenters are invalid" do
+            let(:presenters_valid) { false }
+
+            it "is not valid" do
+              expect(subject.valid?).to eq false
+            end
+          end
+
+          context "when routes are invalid" do
+            let(:routes_valid) { false }
+
+            it "is not valid" do
+              expect(subject.valid?).to eq false
+            end
+          end
+        end
+
+        describe "#valid_controllers?" do
+          it "is valid when a collection of at least one class" do
+            stub(subject).controllers { [ Integer ] }
+            expect(subject.send(:valid_controllers?)).to eq true
+          end
+
+          it "is invalid when not a collection" do
+            stub(subject).controllers { { dog: "woof" } }
+            expect(subject.send(:valid_controllers?)).to eq false
+          end
+
+          it "is invalid when empty" do
+            stub(subject).controllers { [] }
+            expect(subject.send(:valid_controllers?)).to eq false
+          end
+        end
+
+
+        describe "#valid_presenters?" do
+          it "is valid when a collection of zero or more classes" do
+            stub(subject).presenters { [ Integer ] }
+            expect(subject.send(:valid_presenters?)).to eq true
+          end
+
+          it "is valid when empty" do
+            stub(subject).presenters { [] }
+            expect(subject.send(:valid_presenters?)).to eq true
+          end
+
+          it "is invalid when not a collection" do
+            stub(subject).presenters { { dog: "woof" } }
+            expect(subject.send(:valid_presenters?)).to eq false
+          end
+
+        end
+
+        describe "#valid_routes?" do
+          it "is valid when a collection of hashes with specific keys" do
+            stub(subject).routes { [
+              {
+                path: "blah",
+                controller: "blah",
+                action: "blah",
+                http_methods: ['blah']
+              }
+            ] }
+
+            expect(subject.send(:valid_routes?)).to eq true
+          end
+
+          it "is invalid when not a collection" do
+            stub(subject).routes { {} }
+            expect(subject.send(:valid_routes?)).to eq false
+          end
+
+          it "is invalid when empty" do
+            stub(subject).routes { [] }
+            expect(subject.send(:valid_routes?)).to eq false
+          end
+
+          it "is invalid if any one hash is missing a required key" do
+            stub(subject).routes { [
+              {
+                path: "blah",
+                controller: "blah",
+                action: "blah"
+              }
+            ] }
+
+            expect(subject.send(:valid_routes?)).to eq false
+          end
+        end
+      end
+    end
+  end
+end

data/spec/brainstem/api_docs/introspectors/rails_introspector_spec.rb

@@ -0,0 +1,170 @@
+require 'spec_helper'
+require 'brainstem/api_docs/introspectors/rails_introspector'
+
+module Brainstem
+  module ApiDocs
+    module Introspectors
+      describe RailsIntrospector do
+        let(:dummy_environment_file) do
+          File.expand_path('../../../../../spec/dummy/rails.rb', __FILE__)
+        end
+
+        let(:described_klass) { RailsIntrospector }
+        let(:default_args)    { { rails_environment_file: dummy_environment_file } }
+
+        subject do
+          RailsIntrospector.send(:new, default_args)
+        end
+
+
+        context "when cannot find the environment file" do
+          describe "#load_environment!" do
+            subject { described_klass.send(:new) }
+
+            before do
+            #   In the event that we've already loaded the environment through
+            #   random ordering of specs, we want to force a reload.
+            #
+            #   For some reason, this has stopped being needed.
+              Object.send(:remove_const, :Rails) if defined?(Rails)
+            end
+
+            it "raises an error" do
+              # Testing this within Brainstem should fail.
+
+              expect { subject.send(:load_environment!) }
+                .to raise_error IncorrectIntrospectorForAppException
+            end
+          end
+        end
+
+        context "when can find the entrypoint file" do
+          describe "#load_environment!" do
+            context "when introspector is invalid" do
+              before do
+                stub(subject).valid? { false }
+              end
+
+              it "raises an error" do
+                expect { subject.send(:load_environment!) }.to \
+                  raise_error InvalidIntrospectorError
+              end
+            end
+
+            context "when introspector is valid" do
+              before do
+                stub(subject).valid? { true }
+              end
+
+              it "does not raise an error" do
+                expect { subject.send(:load_environment!) }.not_to raise_error
+              end
+
+              it "does not load the file if Rails is defined" do
+                # Ensure that this has been sent already.
+                subject.send(:load_environment!)
+
+                dont_allow(subject).rails_environment_file
+                mock(subject).env_already_loaded? { true }
+
+                subject.send(:load_environment!)
+              end
+            end
+          end
+
+          describe "#presenters" do
+            before do
+              stub.any_instance_of(described_klass).validate!
+            end
+
+            subject do
+              described_klass.with_loaded_environment(
+                default_args.merge(base_presenter_class: "::FakeBasePresenter")
+              )
+            end
+
+
+            it "allows the specification of a custom base_presenter_class" do
+              expect(subject.send(:base_presenter_class).to_s)
+                .to eq "::FakeBasePresenter"
+            end
+
+            it "returns the descendants of the base presenter class" do
+              expect(subject.presenters).to eq [FakeDescendantPresenter]
+            end
+          end
+
+          describe "#controllers" do
+            before do
+              stub.any_instance_of(described_klass).validate!
+            end
+
+            subject do
+              described_klass.with_loaded_environment(
+                default_args.merge(base_controller_class: "::FakeBaseController")
+              )
+            end
+
+
+            it "allows the specification of a custom base_controller_class" do
+              expect(subject.send(:base_controller_class).to_s)
+                .to eq "::FakeBaseController"
+            end
+
+            it "returns the descendants of the base controller class" do
+              expect(subject.controllers).to eq [FakeDescendantController]
+            end
+          end
+
+          describe "#routes" do
+            let(:a_proc) { Object.new }
+
+            before do
+              stub.any_instance_of(described_klass).validate!
+            end
+
+            context "with dummy method" do
+              subject do
+                described_klass.with_loaded_environment(
+                  default_args.merge(routes_method: a_proc)
+                )
+              end
+
+              it "allows the specification of a custom method to return the routes" do
+                expect(subject.send(:routes_method)).to eq a_proc
+              end
+
+              it "calls the routes method to return the routes" do
+                mock(a_proc).call
+                subject.routes
+              end
+            end
+
+            context "with fake (but realistic) data" do
+              subject do
+                described_klass.with_loaded_environment(default_args)
+              end
+
+              it "skips the entry if it does not have a valid controller" do
+                expect(subject.routes.count).to eq 1
+              end
+
+              it "adds the controller constant" do
+                expect(subject.routes.first[:controller]).to eq FakeDescendantController
+              end
+
+              it "reports the controller name" do
+                expect(subject.routes.first[:controller_name]).to eq "fake_descendant"
+              end
+
+              it "transforms the HTTP method regexp into a list of verbs" do
+                expect(subject.routes.first[:http_methods]).to eq %w(GET POST)
+              end
+
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/brainstem/api_docs/presenter_collection_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+require 'brainstem/api_docs/presenter_collection'
+
+module Brainstem
+  module ApiDocs
+    describe PresenterCollection do
+      let(:presenter)    { Object.new }
+      let(:target_class) { Class.new }
+      let(:atlas)        { Object.new }
+      let(:options)      { {} }
+
+      subject { described_class.new(atlas, options) }
+
+      describe "#find_by_target_class" do
+        before do
+          stub(presenter) do |p|
+            p.target_class { target_class }
+          end
+
+          subject << presenter
+        end
+
+        context "when matches presenter" do
+          it "returns the matching presenter" do
+            expect(subject.find_by_target_class(target_class)).to eq presenter
+          end
+        end
+
+        context "when does not match presenter" do
+          it "returns nil" do
+            expect(subject.find_by_target_class(Class.new)).to eq nil
+          end
+        end
+      end
+
+
+      describe "#create_from_target_class" do
+        let(:pclm) { Object.new }
+        let(:options) { { presenter_constant_lookup_method: pclm } }
+
+        context "when can find constant" do
+          before do
+            stub(target_class).to_s { "TargetClass" }
+            stub(pclm).call("TargetClass") { Object }
+          end
+
+          it "creates a new presenter, adding it to the members" do
+            presenter = subject.create_from_target_class(target_class)
+            expect(subject.first).to eq presenter
+            expect(presenter.const).to eq Object
+            expect(presenter.target_class).to eq target_class
+          end
+
+        end
+
+        context "when cannot find constant" do
+          before do
+            stub(target_class).to_s { "TargetClass" }
+            stub(pclm).call("TargetClass") { raise KeyError }
+          end
+
+          it "returns nil and does not append to the members" do
+            presenter = subject.create_from_target_class(target_class)
+            expect(presenter).to be_nil
+          end
+        end
+      end
+
+
+      describe "#create_from_presenter_collection" do
+        let(:const) { Class.new }
+
+        it "creates a new presenter, adding it to the members" do
+          presenter = subject.create_from_presenter_collection(target_class, const)
+          expect(subject.first).to eq presenter
+          expect(presenter.const).to eq const
+          expect(presenter.target_class).to eq target_class
+        end
+      end
+
+      it_behaves_like "atlas taker"
+    end
+  end
+end

data/spec/brainstem/api_docs/presenter_spec.rb

@@ -0,0 +1,519 @@
+require 'spec_helper'
+require 'set'
+require 'ostruct'
+require 'brainstem/api_docs/presenter'
+
+module Brainstem
+  module ApiDocs
+    describe Presenter do
+      subject { described_class.new(atlas, options) }
+
+      let(:atlas)        { Object.new }
+      let(:target_class) { Class.new }
+      let(:options)      { { } }
+      let(:nodoc)        { false }
+
+      describe "#initialize" do
+        it "yields self if given a block" do
+          block = Proc.new { |s| s.target_class = target_class}
+          expect(described_class.new(atlas, &block).target_class).to eq target_class
+        end
+      end
+
+
+      describe "configured fields" do
+        let(:lorem)  { "lorem ipsum dolor sit amet" }
+        let(:const)  { Object.new }
+        let(:config) { {} }
+        let(:options)   { { const: const } }
+
+        subject { described_class.new(atlas, options) }
+
+        before do
+          stub(const) do |constant|
+            constant.configuration { config }
+            constant.to_s { "Namespaced::ClassName" }
+            constant.possible_brainstem_keys { Set.new(%w(lorem ipsum)) }
+          end
+        end
+
+
+        describe "#nodoc?" do
+          let(:config) { { nodoc: nodoc } }
+
+          context "when nodoc in default" do
+            let(:nodoc) { true }
+
+            it "is true" do
+              expect(subject.nodoc?).to eq true
+            end
+          end
+
+          context "when not nodoc in default" do
+            it "is false" do
+              expect(subject.nodoc?).to eq false
+            end
+          end
+        end
+
+
+        describe "#title" do
+          let(:config) { { title: { info: lorem, nodoc: nodoc } } }
+
+          context "when nodoc" do
+            let(:nodoc) { true }
+
+            it "uses the last portion of the presenter's class" do
+              expect(subject.title).to eq "ClassName"
+            end
+          end
+
+          context "when not nodoc" do
+            it "uses the presenter's title" do
+              expect(subject.title).to eq lorem
+            end
+          end
+        end
+
+
+        describe "#brainstem_keys" do
+          it "retrieves from the constant, array-izes, and sorts" do
+            expect(subject.brainstem_keys).to eq [ "ipsum", "lorem" ]
+          end
+        end
+
+
+        describe "#description" do
+          context "with description" do
+            let(:config) { { description: { info: lorem, nodoc: nodoc } } }
+
+            context "when nodoc" do
+              let(:nodoc) { true }
+
+              it "returns empty" do
+                expect(subject.description).to eq ""
+              end
+            end
+
+            context "when not nodoc" do
+              it "returns the description" do
+                expect(subject.description).to eq lorem
+              end
+            end
+          end
+
+          context "without description" do
+            it "returns empty" do
+              expect(subject.description).to eq ""
+            end
+          end
+        end
+
+
+        describe "#valid_fields" do
+          let(:field) { Object.new }
+          before      { stub(field).options { { nodoc: nodoc } } }
+
+          describe "leafs" do
+            let(:config) { { fields: { a_field: field } } }
+
+            context "when nodoc" do
+              let(:nodoc)  { true }
+
+              it "rejects the field" do
+                expect(subject.valid_fields.count).to eq 0
+              end
+            end
+
+            context "when not nodoc" do
+              it "keeps the field" do
+                expect(subject.valid_fields.count).to eq 1
+              end
+            end
+          end
+
+          describe "branches" do
+            describe "single nesting" do
+              let(:config) { { fields: { nesting_one: { a_field: field } } } }
+
+              context "when all nodoc" do
+                let(:nodoc)  { true }
+
+                it "rejects the nested field" do
+                  expect(subject.valid_fields.count).to eq 0
+                end
+              end
+
+              context "when not all nodoc" do
+                it "keeps the nested field" do
+                  expect(subject.valid_fields.count).to eq 1
+                end
+              end
+
+            end
+
+            describe "double nesting" do
+              let(:config) { { fields: { nesting_one: { nesting_two: { a_field: field } } } } }
+
+              context "when all nodoc" do
+                let(:nodoc)  { true }
+
+                it "rejects the nested field" do
+                  expect(subject.valid_fields.count).to eq 0
+                end
+              end
+
+              context "when not all nodoc" do
+                it "keeps the nested field" do
+                  expect(subject.valid_fields.count).to eq 1
+                end
+              end
+
+            end
+          end
+        end
+
+
+        describe "#valid_filters" do
+          let(:info)        { lorem }
+          let(:filter)      { { info: info } }
+          let(:config)      { { filters: { an_example: filter } } }
+
+          context "when valid" do
+            before do
+              stub(subject).documentable_filter?(:an_example, filter) { true }
+            end
+
+            it "retrieves from configuration" do
+              expect(subject.valid_filters).to eq({ an_example: filter })
+            end
+          end
+
+          context "when invalid" do
+            before do
+              stub(subject).documentable_filter?(:an_example, filter) { false }
+            end
+
+            it "returns an empty hash" do
+              expect(subject.valid_filters).to be_empty
+            end
+          end
+        end
+
+
+        describe "#documentable_filter?" do
+          let(:info)   { lorem }
+          let(:filter) { { nodoc: nodoc, info: info } }
+
+          context "when nodoc" do
+            let(:nodoc) { true }
+
+            it "is false" do
+              expect(subject.documentable_filter?(:filter, filter)).to eq false
+            end
+          end
+
+          context "when doc" do
+            context "when description present" do
+              it "is true" do
+                expect(subject.documentable_filter?(:filter, filter)).to eq true
+              end
+            end
+
+            context "when description absent" do
+              let(:info) { nil }
+
+              context "when documenting empty filters" do
+                let(:options) { { const: const, document_empty_filters: true } }
+
+                it "is true" do
+                  expect(subject.documentable_filter?(:filter, filter)).to eq true
+                end
+              end
+
+              context "when not documenting empty filters" do
+                let(:options) { { const: const, document_empty_filters: false } }
+
+                it "is false" do
+                  expect(subject.documentable_filter?(:filter, filter)).to eq false
+                end
+              end
+            end
+          end
+        end
+
+
+        describe "#valid_sort_orders" do
+          let(:config) { { sort_orders: { title: { nodoc: true }, date: {} } } }
+
+          it "returns all pairs not marked nodoc" do
+            expect(subject.valid_sort_orders).to have_key(:date)
+            expect(subject.valid_sort_orders).not_to have_key(:title)
+          end
+        end
+
+
+        describe "#valid_associations" do
+          let(:info)        { lorem }
+          let(:association) { Object.new }
+          let(:config)      { { associations: { an_example: association } } }
+
+          context "when valid" do
+            before do
+              stub(subject).documentable_association?(:an_example, association) { true }
+            end
+
+            it "retrieves from configuration" do
+              expect(subject.valid_associations).to eq({ an_example: association })
+            end
+          end
+
+          context "when invalid" do
+            before do
+              stub(subject).documentable_association?(:an_example, association) { false }
+            end
+
+            it "returns an empty hash" do
+              expect(subject.valid_associations).to be_empty
+            end
+          end
+        end
+
+
+        describe "#documentable_association?" do
+          let(:desc)        { lorem }
+          let(:association) { OpenStruct.new(options: { nodoc: nodoc }, description: desc ) }
+
+          context "when nodoc" do
+            let(:nodoc) { true }
+
+            it "is false" do
+              expect(subject.documentable_association?(:assoc, association)).to eq false
+            end
+          end
+
+          context "when doc" do
+            context "when description present" do
+              it "is true" do
+                expect(subject.documentable_association?(:assoc, association)).to eq true
+              end
+            end
+
+            context "when description absent" do
+              let(:desc) { nil }
+
+              context "when documenting empty filters" do
+                let(:options) { { const: const, document_empty_associations: true } }
+
+                it "is true" do
+                  expect(subject.documentable_association?(:assoc, association)).to eq true
+                end
+              end
+
+              context "when not documenting empty filters" do
+                let(:options) { { const: const, document_empty_associations: false } }
+
+                it "is false" do
+                  expect(subject.documentable_association?(:assoc, association)).to eq false
+                end
+              end
+            end
+          end
+        end
+
+
+        describe "#conditionals" do
+          let(:config) { { conditionals: { thing: :other_thing } } }
+
+          it "retrieves from configuration" do
+            expect(subject.conditionals).to eq({ thing: :other_thing })
+          end
+        end
+
+        describe "#default_sort_order" do
+          let(:config) { { default_sort_order: "alphabetical:asc" } }
+
+          it "retrieves from configuration" do
+            expect(subject.default_sort_order).to eq "alphabetical:asc"
+          end
+        end
+
+
+        describe "#default_sort_field" do
+          context "when has default sort order" do
+            let(:config) { { default_sort_order: "alphabetical:asc" } }
+
+            it "returns the first component" do
+              expect(subject.default_sort_field).to eq "alphabetical"
+            end
+          end
+
+          context "when no default sort order" do
+            it "returns nil" do
+              expect(subject.default_sort_field).to be_nil
+            end
+          end
+        end
+
+
+        describe "#default_sort_direction" do
+          context "when has default sort order" do
+            let(:config) { { default_sort_order: "alphabetical:asc" } }
+
+            it "returns the last component" do
+              expect(subject.default_sort_direction).to eq "asc"
+            end
+          end
+
+          context "when no default sort order" do
+            it "returns nil" do
+              expect(subject.default_sort_direction).to be_nil
+            end
+          end
+        end
+
+        describe "#contextual_documentation" do
+          let(:config) { { title: { info: info, nodoc: nodoc } } }
+          let(:info)   { lorem }
+
+          context "when has the key" do
+            let(:key) { :title }
+
+            context "when not nodoc" do
+              context "when has info" do
+                it "is truthy" do
+                  expect(subject.contextual_documentation(key)).to be_truthy
+                end
+
+                it "is the info" do
+                  expect(subject.contextual_documentation(key)).to eq lorem
+                end
+              end
+
+              context "when has no info" do
+                let(:info) { nil }
+
+                it "is falsey" do
+                  expect(subject.contextual_documentation(key)).to be_falsey
+                end
+              end
+            end
+
+            context "when nodoc" do
+              let(:nodoc) { true }
+
+              it "is falsey" do
+                expect(subject.contextual_documentation(key)).to be_falsey
+              end
+            end
+          end
+
+          context "when doesn't have the key" do
+            let(:key) { :herp }
+
+            it "is falsey" do
+              expect(subject.contextual_documentation(key)).to be_falsey
+            end
+          end
+        end
+      end
+
+
+      describe "#suggested_filename" do
+        before do
+          stub(target_class).to_s { "Abc" }
+        end
+
+        it "gsubs name and extension" do
+
+          instance = described_class.new(atlas,
+            filename_pattern: "presenters/{{name}}.{{extension}}",
+            target_class: target_class
+          )
+
+          stub(instance).extension { "xyz" }
+
+          expect(instance.suggested_filename(:xyz)).to eq "presenters/abc.xyz"
+        end
+      end
+
+
+      describe "#suggested_filename_link" do
+        before do
+          stub(target_class).to_s { "Abc" }
+        end
+
+        it "gsubs name and extension" do
+
+          instance = described_class.new(atlas,
+            filename_link_pattern: "presenters/{{name}}.{{extension}}.foo",
+            target_class: target_class
+          )
+
+          stub(instance).extension { "xyz" }
+
+          expect(instance.suggested_filename_link(:xyz)).to eq "presenters/abc.xyz.foo"
+        end
+      end
+
+
+      describe "#relative_path_to_presenter" do
+        let(:presenter) {
+          mock!
+            .suggested_filename_link(:markdown)
+            .returns("objects/sprocket_widget")
+            .subject
+        }
+
+        it "returns a relative path" do
+          expect(subject.relative_path_to_presenter(presenter, :markdown)).to \
+            eq "sprocket_widget"
+        end
+      end
+
+
+      describe "#link_for_association" do
+        let(:presenter)    { Object.new }
+        let(:target_class) { Class.new }
+        let(:association)  { OpenStruct.new(target_class: target_class) }
+
+        context "when can find presenter" do
+          before do
+            mock(subject).find_by_class(target_class) { presenter }
+            stub(subject).relative_path_to_presenter(presenter, :markdown) { "./path" }
+            stub(presenter).nodoc? { nodoc }
+          end
+
+          context "when nodoc" do
+            let(:nodoc) { true }
+
+            it "is nil" do
+              expect(subject.link_for_association(association)).to be_nil
+            end
+          end
+
+          context "when not nodoc" do
+            it "is the path" do
+              expect(subject.link_for_association(association)).to eq "./path"
+            end
+          end
+
+        end
+
+        context "when cannot find presenter" do
+          before do
+            mock(subject).find_by_class(target_class) { nil }
+          end
+
+          it "is nil" do
+            expect(subject.link_for_association(association)).to be_nil
+          end
+        end
+      end
+
+
+      it_behaves_like "formattable"
+      it_behaves_like "atlas taker"
+    end
+  end
+end