mark_mapper 0.0.1

data/spec/functional/keys_spec.rb

@@ -0,0 +1,339 @@
+require 'spec_helper'
+
+describe "Keys" do
+  it "should not have a disparity between the ivar and accessor" do
+    doc = Doc do
+      key :foo, String
+
+      def modify_foo
+        @foo = :baz
+      end
+
+      def get_foo
+        @foo
+      end
+    end
+
+    instance = doc.new(:foo => "bar")
+    instance.get_foo.should == instance.foo
+
+    instance.foo = :bing
+    instance.get_foo.should == instance.foo
+
+    instance.modify_foo
+    instance.get_foo.should == instance.foo
+  end
+
+  it "should return the value when set using send with the writer method" do
+    doc = Doc do
+      key :foo, String
+    end
+
+    instance = doc.new(:foo => 'bar')
+    instance.send("foo=", 'baz').should == 'baz'
+    instance.foo.should == 'baz'
+  end
+
+  context "when persisting an typecasted array" do
+    TypecastedKeyModel = Doc do
+      key :people, Array, :typecast => "Person"
+    end
+
+    Person = Struct.new(:name) do
+      def self.to_marklogic(value)
+        value.name
+      end
+
+      def self.from_marklogic(value)
+        Person.new value
+      end
+    end
+
+    it "should not mutate the model's state" do
+      person = Person.new "Bob"
+      doc = TypecastedKeyModel.new(:people => [person])
+
+      doc.save
+
+      doc.people.should == [person]
+    end
+  end
+
+  it "should not bomb if a key is written before Keys#initialize gets to get called" do
+    doc = Class.new do
+      include MarkMapper::Document
+
+      def initialize
+        self.class.key :something, String
+        self.something = :other_thing
+        super
+      end
+    end
+
+    expect { doc.new }.to_not raise_error
+  end
+
+  it "should not bomb if a key is read before Keys#initialize gets to get called" do
+    doc = Class.new do
+      include MarkMapper::Document
+
+      def initialize
+        self.class.key :something, String
+        self.something
+        super
+      end
+    end
+
+    expect { doc.new }.to_not raise_error
+  end
+
+  it "should permit for key overrides" do
+    doc = Class.new do
+      include MarkMapper::Document
+      key :class, String, :accessors => :skip
+    end
+
+    doc.collection.insert('class' => 'String')
+    doc.all.first.tap do |d|
+      d.class.should == doc
+      d["class"].should == "String"
+      d.attributes["class"].should == "String"
+    end
+  end
+
+  context "key segmenting" do
+    let(:doc) {
+      Doc {
+        key :defined
+      }
+    }
+
+    before do
+      doc.collection.insert(:dynamic => "foo")
+      doc.first
+    end
+
+    describe "#dynamic_keys" do
+      it "should find dynamic keys" do
+        doc.dynamic_keys.keys.should == ["dynamic"]
+      end
+    end
+
+    describe "#defined_keys" do
+      it "should find defined keys" do
+        doc.defined_keys.keys.should =~ ["_id", "defined"]
+      end
+    end
+  end
+
+  describe "with invalid names" do
+    it "should warn when key names start with an uppercase letter" do
+      doc = Doc {}
+      expect(Kernel).to receive(:warn).once.with(/may not start with uppercase letters/)
+      doc.class_eval do
+        key :NotConstant
+      end
+    end
+
+    it "should handle keys that start with uppercase letters by translating their first letter to lowercase" do
+      doc = Doc {}
+      allow(Kernel).to receive(:warn)
+      doc.class_eval do
+        key :NotConstant
+      end
+      doc.collection.insert("NotConstant" => "Just data!")
+      doc.first.notConstant.should == "Just data!"
+    end
+
+    it "should not create accessors for bad keys" do
+      doc = Doc {}
+      expect(doc).to_not receive(:create_accessors_for)
+      doc.class_eval do
+        key :"bad-name", :__dynamic => true
+      end
+      expect { doc.new.method(:"bad-name") }.to raise_error(NameError)
+    end
+
+    it "should not create accessors for reserved keys" do
+      doc = Doc {}
+      expect(doc).to_not receive(:create_accessors_for)
+      doc.class_eval do
+        key :"class", :__dynamic => true
+      end
+      expect(doc.new.class).to eq doc
+    end
+
+    it "should create accessors for good keys" do
+      doc = Doc {
+        key :good_name
+      }
+      doc.new.good_name.should be_nil
+      expect { doc.new.method("good_name") }.to_not raise_error
+    end
+  end
+
+  it "should handle loading dynamic fields from the database that have bad names" do
+    doc = Doc {}
+    doc.collection.insert("foo-bar" => "baz-bin")
+
+    doc.first["foo-bar"].should == "baz-bin"
+  end
+
+  describe "with aliases" do
+    AliasedKeyModel = Doc do
+      key :foo, :abbr => :f
+      key :with_underscores, :alias => "with-hyphens"
+      key :field_name, :field_name => "alternate_field_name"
+      key :bar
+    end
+
+    before { AliasedKeyModel.collection.drop }
+
+    context "standard key operations" do
+      before do
+        AliasedKeyModel.create(:foo => "whee!", :bar => "whoo!")
+      end
+
+      it "should serialize with aliased keys" do
+        AliasedKeyModel.collection.find_one.keys.should =~ %w(_id f bar)
+
+        AliasedKeyModel.first.tap do |d|
+          d.foo.should == "whee!"
+          d.bar.should == "whoo!"
+        end
+      end
+
+      it "should permit querying via direct field names" do
+        AliasedKeyModel.where(AliasedKeyModel.abbr(:foo) => "whee!").first.foo.should == "whee!"
+      end
+
+      it "should permit querying via direct field names" do
+        AliasedKeyModel.where(:foo => "whee!").criteria_hash.keys.should == ["f"]
+        AliasedKeyModel.where(:foo => "whee!").first.foo.should == "whee!"
+      end
+
+      it "should permit filtering via aliases" do
+        AliasedKeyModel.where(:foo => "whee!").fields(:foo).first.foo.should == "whee!"
+      end
+
+      it "should permit dealiasing of atomic operations" do
+        m = AliasedKeyModel.first
+        m.set(:foo => 1)
+        AliasedKeyModel.collection.find_one["f"].should == 1
+        AliasedKeyModel.collection.find_one["foo"].should be_nil
+      end
+
+      it "should permit dealiasing of update operations" do
+        m = AliasedKeyModel.first
+        m.update_attributes(:foo => 1)
+        AliasedKeyModel.collection.find_one["f"].should == 1
+        AliasedKeyModel.collection.find_one["foo"].should be_nil
+      end
+
+      it "should not break when unaliasing non-keys" do
+        AliasedKeyModel.where(:badkey => "whee!").criteria_hash.keys.should == [:badkey]
+      end
+
+      it "should serialize to JSON with full keys" do
+        AliasedKeyModel.first.as_json.tap do |json|
+          json.should have_key "foo"
+          json.should_not have_key "f"
+        end
+      end
+    end
+
+    context "given field which are not valid Ruby method names" do
+      before { AliasedKeyModel.create(:with_underscores => "foobar") }
+      it "should work" do
+        AliasedKeyModel.first.with_underscores.should == "foobar"
+        AliasedKeyModel.collection.find_one["with-hyphens"].should == "foobar"
+      end
+    end
+
+    context "given a field aliased with :field_name" do
+      before { AliasedKeyModel.create(:field_name => "foobar") }
+      it "should work" do
+        AliasedKeyModel.first.field_name.should == "foobar"
+        AliasedKeyModel.collection.find_one["alternate_field_name"].should == "foobar"
+      end
+    end
+
+    context "associations" do
+      AssociatedKeyWithAlias = Doc do
+        set_collection_name "associated_documents"
+        key :name, String, :abbr => :n
+        key :association_id, ObjectId, :abbr => :aid
+      end
+
+      OwnerDocWithKeyAliases = Doc do
+        set_collection_name "owner_documents"
+        key :name, String, :abbr => :n
+        many :associated_documents, :class_name => "AssociatedKeyWithAlias", :foreign_key => AssociatedKeyWithAlias.abbr(:association_id)
+        many :other_documents, :class_name => "EmbeddedDocWithAliases"
+      end
+
+      EmbeddedDocWithAliases = EDoc do
+        key :embedded_name, String, :abbr => :en
+      end
+
+      before do
+        AssociatedKeyWithAlias.collection.drop
+        OwnerDocWithKeyAliases.collection.drop
+      end
+
+      it "should work" do
+        owner = OwnerDocWithKeyAliases.create(:name => "Big Boss")
+
+        associated_documents = 3.times.map {|i| AssociatedKeyWithAlias.new(:name => "Associated Record #{i}") }
+        owner.associated_documents = associated_documents
+        owner.save
+
+        owner.reload
+        owner.associated_documents.to_a.should =~ associated_documents.to_a
+
+        AssociatedKeyWithAlias.collection.find_one.keys.should =~ %w(_id n aid)
+      end
+
+      it "should work with embedded documents" do
+        owner = OwnerDocWithKeyAliases.create(:name => "Big Boss")
+        owner.other_documents << EmbeddedDocWithAliases.new(:embedded_name => "Underling")
+        owner.save
+
+        owner.reload
+        owner.other_documents[0].embedded_name.should == "Underling"
+        owner.collection.find_one["other_documents"][0]["en"].should == "Underling"
+      end
+    end
+  end
+
+  describe "removing keys" do
+    DocWithRemovedKey = Doc do
+      key :something
+      validates_uniqueness_of :something
+      remove_key :something
+    end
+
+    it 'should remove the key' do
+      DocWithRemovedKey.keys.should_not have_key "_something"
+    end
+
+    it 'should remove validations' do
+      DocWithRemovedKey._validate_callbacks.should be_empty
+    end
+  end
+
+  describe "removing keys in the presence of a validation method" do
+    DocWithRemovedValidator = Doc do
+      key :something
+      validate :something_valid?
+      remove_key :something
+
+      def something_valid?; true; end
+    end
+
+    it 'should remove the key' do
+      DocWithRemovedKey.keys.should_not have_key "_something"
+    end
+
+  end
+end

data/spec/functional/logger_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe "Logger" do
+  context "with connection that has logger" do
+    before do
+      @output = StringIO.new
+      @logger = Logger.new(@output)
+      MarkLogic.logger = @logger
+    end
+
+    it "should be able to get access to that logger" do
+      MarkMapper.logger.should == @logger
+    end
+
+    it "should be able to log messages" do
+      MarkMapper.logger.debug 'testing'
+      @output.string.include?('testing').should be_truthy
+    end
+  end
+end

data/spec/functional/modifiers_spec.rb

@@ -0,0 +1,446 @@
+require 'spec_helper'
+
+module Modifiers
+  describe "Modifiers" do
+    let(:page_class_with_compound_key) {
+      Doc do
+        key :_id,        Hash, :default => lambda { { 'n' => 42, 'i' => MarkLogic::ObjectId.new } }
+        key :title,       String
+        key :day_count,   Integer, :default => 0
+        key :week_count,  Integer, :default => 0
+        key :month_count, Integer, :default => 0
+        key :tags,        Array
+      end
+    }
+
+    let(:page_class_with_standard_key) {
+      Doc do
+        key :title,       String
+        key :day_count,   Integer, :default => 0
+        key :week_count,  Integer, :default => 0
+        key :month_count, Integer, :default => 0
+        key :tags,        Array
+      end
+    }
+
+    def assert_page_counts(page, day_count, week_count, month_count)
+      doc = page.collection.find_one(:_id => page.id)
+      doc.should be_present, "Could not find document"
+      doc.fetch('day_count').should == day_count
+      doc.fetch('week_count').should == week_count
+      doc.fetch('month_count').should == month_count
+    end
+
+    def assert_keys_removed(page, *keys)
+      page.class.collection.find_one(:_id => page.id).tap do |doc|
+        doc.should be_present, "Could not find document"
+        (doc.keys & keys).should be_empty, "Expected to not have keys #{keys.inspect}, got #{(keys & doc.keys).inspect}"
+      end
+    end
+
+    context "ClassMethods" do
+      let!(:page_class) { page_class_with_standard_key }
+      let!(:page)  { page_class.create(:title => 'Home') }
+      let!(:page2) { page_class.create(:title => 'Home') }
+
+      context "unset" do
+        let!(:page)  { page_class.create(:title => 'Home', :tags => %w(foo bar)) }
+
+        it "should work with criteria and keys" do
+          page_class.unset({:title => 'Home'}, :title, :tags)
+          assert_keys_removed page, :title, :tags
+          assert_keys_removed page2, :title, :tags
+        end
+
+        it "should work with ids and keys" do
+          page_class.unset(page.id, page2.id, :title, :tags)
+          assert_keys_removed page, :title, :tags
+          assert_keys_removed page2, :title, :tags
+        end
+      end
+
+      context "increment" do
+        it "should work with criteria and modifier hashes" do
+          page_class.increment({:title => 'Home'}, :day_count => 1, :week_count => 2, :month_count => 3)
+
+          assert_page_counts page, 1, 2, 3
+          assert_page_counts page2, 1, 2, 3
+        end
+
+        it "should work with ids and modifier hash" do
+          page_class.increment(page.id, page2.id, :day_count => 1, :week_count => 2, :month_count => 3)
+
+          assert_page_counts page, 1, 2, 3
+          assert_page_counts page2, 1, 2, 3
+        end
+
+        it "should work with ids given as strings" do
+          page_class.increment(page.id.to_s, page2.id.to_s, :day_count => 1, :week_count => 2, :month_count => 3)
+
+          assert_page_counts page, 1, 2, 3
+          assert_page_counts page2, 1, 2, 3
+        end
+      end
+
+      context "decrement" do
+        let!(:page)  { page_class.create(:title => 'Home', :day_count => 1, :week_count => 2, :month_count => 3) }
+        let!(:page2) { page_class.create(:title => 'Home', :day_count => 1, :week_count => 2, :month_count => 3) }
+
+        it "should work with criteria and modifier hashes" do
+          page_class.decrement({:title => 'Home'}, :day_count => 1, :week_count => 2, :month_count => 3)
+
+          assert_page_counts page, 0, 0, 0
+          assert_page_counts page2, 0, 0, 0
+        end
+
+        it "should work with ids and modifier hash" do
+          page_class.decrement(page.id, page2.id, :day_count => 1, :week_count => 2, :month_count => 3)
+
+          assert_page_counts page, 0, 0, 0
+          assert_page_counts page2, 0, 0, 0
+        end
+
+        it "should decrement with positive or negative numbers" do
+          page_class.decrement(page.id, page2.id, :day_count => -1, :week_count => 2, :month_count => -3)
+
+          assert_page_counts page, 0, 0, 0
+          assert_page_counts page2, 0, 0, 0
+        end
+
+        it "should work with ids given as strings" do
+          page_class.decrement(page.id.to_s, page2.id.to_s, :day_count => -1, :week_count => 2, :month_count => -3)
+
+          assert_page_counts page, 0, 0, 0
+          assert_page_counts page2, 0, 0, 0
+        end
+      end
+
+      context "set" do
+        it "should work with criteria and modifier hashes" do
+          page_class.set({:title => 'Home'}, :title => 'Home Revised')
+
+          page.reload
+          page.title.should == 'Home Revised'
+
+          page2.reload
+          page2.title.should == 'Home Revised'
+        end
+
+        it "should work with ids and modifier hash" do
+          page_class.set(page.id, page2.id, :title => 'Home Revised')
+
+          page.reload
+          page.title.should == 'Home Revised'
+
+          page2.reload
+          page2.title.should == 'Home Revised'
+        end
+
+        it "should typecast values before querying" do
+          page_class.key :tags, Set
+
+          expect {
+            page_class.set(page.id, :tags => ['foo', 'bar'].to_set)
+            page.reload
+            page.tags.should == Set.new(['foo', 'bar'])
+          }.to_not raise_error
+        end
+
+        # it "should not typecast keys that are not defined in document" do
+        #   expect {
+        #     page_class.set(page.id, :colors => ['red', 'green'].to_set)
+        #   }.to raise_error(BSON::InvalidDocument)
+        # end
+
+        it "should set keys that are not defined in document" do
+          page_class.set(page.id, :colors => %w[red green])
+          page.reload
+          page[:colors].should == %w[red green]
+        end
+      end
+
+      context "push" do
+        it "should work with criteria and modifier hashes" do
+          page_class.push({:title => 'Home'}, :tags => 'foo')
+
+          page.reload
+          page.tags.should == %w(foo)
+
+          page2.reload
+          page2.tags.should == %w(foo)
+        end
+
+        it "should work with ids and modifier hash" do
+          page_class.push(page.id, page2.id, :tags => 'foo')
+
+          page.reload
+          page.tags.should == %w(foo)
+
+          page2.reload
+          page2.tags.should == %w(foo)
+        end
+      end
+
+      context "push_all" do
+        let(:tags) { %w(foo bar) }
+
+        it "should work with criteria and modifier hashes" do
+          page_class.push_all({:title => 'Home'}, :tags => tags)
+
+          page.reload
+          page.tags.should == tags
+
+          page2.reload
+          page2.tags.should == tags
+        end
+
+        it "should work with ids and modifier hash" do
+          page_class.push_all(page.id, page2.id, :tags => tags)
+
+          page.reload
+          page.tags.should == tags
+
+          page2.reload
+          page2.tags.should == tags
+        end
+      end
+
+      # context "pull" do
+      #   let(:page)  { page_class.create(:title => 'Home', :tags => %w(foo bar)) }
+      #   let(:page2) { page_class.create(:title => 'Home', :tags => %w(foo bar)) }
+
+      #   it "should work with criteria and modifier hashes" do
+      #     page_class.pull({:title => 'Home'}, :tags => 'foo')
+
+      #     page.reload
+      #     page.tags.should == %w(bar)
+
+      #     page2.reload
+      #     page2.tags.should == %w(bar)
+      #   end
+
+      #   it "should be able to pull with ids and modifier hash" do
+      #     page_class.pull(page.id, page2.id, :tags => 'foo')
+
+      #     page.reload
+      #     page.tags.should == %w(bar)
+
+      #     page2.reload
+      #     page2.tags.should == %w(bar)
+      #   end
+      # end
+
+      # context "pull_all" do
+      #   let(:page)  { page_class.create(:title => 'Home', :tags => %w(foo bar baz)) }
+      #   let(:page2) { page_class.create(:title => 'Home', :tags => %w(foo bar baz)) }
+
+      #   it "should work with criteria and modifier hashes" do
+      #     page_class.pull_all({:title => 'Home'}, :tags => %w(foo bar))
+
+      #     page.reload
+      #     page.tags.should == %w(baz)
+
+      #     page2.reload
+      #     page2.tags.should == %w(baz)
+      #   end
+
+      #   it "should work with ids and modifier hash" do
+      #     page_class.pull_all(page.id, page2.id, :tags => %w(foo bar))
+
+      #     page.reload
+      #     page.tags.should == %w(baz)
+
+      #     page2.reload
+      #     page2.tags.should == %w(baz)
+      #   end
+      # end
+
+      # context "add_to_set" do
+      #   let(:page) { page_class.create(:title => 'Home', :tags => 'foo') }
+
+      #   it "should be able to add to set with criteria and modifier hash" do
+      #     page_class.add_to_set({:title => 'Home'}, :tags => 'foo')
+
+      #     page.reload
+      #     page.tags.should == %w(foo)
+
+      #     page2.reload
+      #     page2.tags.should == %w(foo)
+      #   end
+
+      #   it "should be able to add to set with ids and modifier hash" do
+      #     page_class.add_to_set(page.id, page2.id, :tags => 'foo')
+
+      #     page.reload
+      #     page.tags.should == %w(foo)
+
+      #     page2.reload
+      #     page2.tags.should == %w(foo)
+      #   end
+      # end
+
+      # context "push_uniq" do
+      #   let(:page) { page_class.create(:title => 'Home', :tags => 'foo') }
+
+      #   it "should be able to push uniq with criteria and modifier hash" do
+      #     page_class.push_uniq({:title => 'Home'}, :tags => 'foo')
+
+      #     page.reload
+      #     page.tags.should == %w(foo)
+
+      #     page2.reload
+      #     page2.tags.should == %w(foo)
+      #   end
+
+      #   it "should be able to push uniq with ids and modifier hash" do
+      #     page_class.push_uniq(page.id, page2.id, :tags => 'foo')
+
+      #     page.reload
+      #     page.tags.should == %w(foo)
+
+      #     page2.reload
+      #     page2.tags.should == %w(foo)
+      #   end
+      # end
+
+      # context "pop" do
+      #   let(:page) { page_class.create(:title => 'Home', :tags => %w(foo bar)) }
+
+      #   it "should be able to remove the last element the array" do
+      #     page_class.pop(page.id, :tags => 1)
+      #     page.reload
+      #     page.tags.should == %w(foo)
+      #   end
+
+      #   it "should be able to remove the first element of the array" do
+      #     page_class.pop(page.id, :tags => -1)
+      #     page.reload
+      #     page.tags.should == %w(bar)
+      #   end
+      # end
+    end
+
+    context "compound keys" do
+      it "should create a document" do
+        expect {
+          page_class_with_compound_key.create(:title => 'Foo', :tags => %w(foo))
+        }.to change { page_class_with_compound_key.count }.by(1)
+        doc = page_class_with_compound_key.first
+        page_class_with_compound_key.find(doc._id).should == doc
+      end
+    end
+
+    context "instance methods" do
+      {
+        :page_class_with_standard_key => "with standard key",
+        :page_class_with_compound_key => "with compound key",
+      }.each do |klass, description|
+        context description do
+          let!(:page_class) { send(klass) }
+
+          it "should be able to unset with keys" do
+            page = page_class.create(:title => 'Foo', :tags => %w(foo))
+            page.unset(:title, :tags)
+            assert_keys_removed page, :title, :tags
+          end
+
+          it "should be able to increment with modifier hashes" do
+            page = page_class.create
+            page.increment(:day_count => 1, :week_count => 2, :month_count => 3)
+
+            assert_page_counts page, 1, 2, 3
+          end
+
+          it "should be able to decrement with modifier hashes" do
+            page = page_class.create(:day_count => 1, :week_count => 2, :month_count => 3)
+            page.decrement(:day_count => 1, :week_count => 2, :month_count => 3)
+
+            assert_page_counts page, 0, 0, 0
+          end
+
+          it "should always decrement when decrement is called whether number is positive or negative" do
+            page = page_class.create(:day_count => 1, :week_count => 2, :month_count => 3)
+            page.decrement(:day_count => -1, :week_count => 2, :month_count => -3)
+            assert_page_counts page, 0, 0, 0
+          end
+
+          it "should be able to set with modifier hashes" do
+            page  = page_class.create(:title => 'Home')
+            page.set(:title => 'Home Revised')
+
+            page.reload
+            page.title.should == 'Home Revised'
+          end
+
+          it "should be able to push with modifier hashes" do
+            page = page_class.create
+            page.push(:tags => 'foo')
+
+            page.reload
+            page.tags.should == %w(foo)
+          end
+
+          it "should be able to push_all with modifier hashes" do
+            page = page_class.create
+            page.push_all(:tags => %w(foo bar))
+
+            page.reload
+            page.tags.should == %w(foo bar)
+          end
+
+          # it "should be able to pull with criteria and modifier hashes" do
+          #   page = page_class.create(:tags => %w(foo bar))
+          #   page.pull(:tags => 'foo')
+
+          #   page.reload
+          #   page.tags.should == %w(bar)
+          # end
+
+          # it "should be able to pull_all with criteria and modifier hashes" do
+          #   page = page_class.create(:tags => %w(foo bar baz))
+          #   page.pull_all(:tags => %w(foo bar))
+
+          #   page.reload
+          #   page.tags.should == %w(baz)
+          # end
+
+          # it "should be able to add_to_set with criteria and modifier hash" do
+          #   page  = page_class.create(:tags => 'foo')
+          #   page2 = page_class.create
+
+          #   page.add_to_set(:tags => 'foo')
+          #   page2.add_to_set(:tags => 'foo')
+
+          #   page.reload
+          #   page.tags.should == %w(foo)
+
+          #   page2.reload
+          #   page2.tags.should == %w(foo)
+          # end
+
+          # it "should be able to push uniq with criteria and modifier hash" do
+          #   page  = page_class.create(:tags => 'foo')
+          #   page2 = page_class.create
+
+          #   page.push_uniq(:tags => 'foo')
+          #   page2.push_uniq(:tags => 'foo')
+
+          #   page.reload
+          #   page.tags.should == %w(foo)
+
+          #   page2.reload
+          #   page2.tags.should == %w(foo)
+          # end
+
+          # it "should be able to pop with modifier hashes" do
+          #   page = page_class.create(:tags => %w(foo bar))
+          #   page.pop(:tags => 1)
+
+          #   page.reload
+          #   page.tags.should == %w(foo)
+          # end
+        end
+      end
+    end
+  end
+end