mongoid-geospatial 7.0.0 → 7.2.0

data/spec/mongoid/geospatial/fields/point_spec.rb

@@ -1,296 +0,0 @@
-require 'spec_helper'
-
-describe Mongoid::Geospatial::Point do
-  describe "Moe's Bar" do
-    let(:bar) { Bar.create!(name: "Moe's") }
-
-    it 'should not interfer with mongoid' do
-      expect(bar.class.count).to eql(1)
-    end
-
-    it 'should not fail if point is nil' do
-      expect(bar.location).to be_nil
-    end
-
-    it 'should set point methodically' do
-      bar.location = Mongoid::Geospatial::Point.new(8, 9)
-      expect(bar.save).to be_truthy
-      expect(Bar.first.location.x).to eq(8)
-      expect(Bar.first.location.y).to eq(9)
-    end
-
-    it 'should set point with comma separated text' do
-      bar.location = '2.99,3.99'
-      expect(bar.location.mongoize).to eq([2.99, 3.99])
-    end
-
-    it 'should set point with space separated text' do
-      bar.location = '2.99 3.99'
-      expect(bar.location.mongoize).to eq([2.99, 3.99])
-    end
-
-    it 'should set point with space comma separated text' do
-      bar.location = '2.99 ,  3.99'
-      expect(bar.location.mongoize).to eq([2.99, 3.99])
-    end
-
-    it 'should set point from hash' do
-      bar.location = { latitude: 2.99, longitude: 3.99 }
-      expect(bar.location.mongoize).to eq([3.99, 2.99])
-    end
-
-    context 'configured as latlon' do
-      before do
-        Mongoid::Geospatial.configure do |config|
-          config.point.x = Mongoid::Geospatial.lat_symbols
-          config.point.y = Mongoid::Geospatial.lng_symbols
-        end
-      end
-      it 'should set point from hash' do
-        bar.location = { latitude: 2.99, longitude: 3.99 }
-        expect(bar.location.mongoize).to eq([2.99, 3.99])
-      end
-    end
-  end
-
-  it "should have a to_s method" do
-    bar = Bar.create!(name: "Moe's", location: [1, 2])
-    expect(bar.location.to_s).to eq('1.0, 2.0')
-  end
-
-  it "should have a to_s method" do
-    bar = Bar.create!(name: "Moe's", location: [1.0009, 21.009])
-    expect(bar.location.to_s).to eq('1.0009, 21.009')
-  end
-
-  it "should have a to_geo_json method" do
-    bar = Bar.create!(name: "Moe's", location: [1.0009, 21.009])
-    expect(bar.location.to_geo_json).to eq({
-      type: "Point", coordinates: [1.0009, 21.009]
-    })
-  end
-
-  it "should have a to_json method" do
-    bar = Bar.create!(name: "Moe's", location: [1.0009, 21.009])
-    expect(bar.location.to_json).to eq("[1.0009,21.009]")
-  end
-
-  it 'should have #reverse to get lat, lon' do
-    bar = Bar.create!(name: "Moe's", location: [1, 2])
-    expect(bar.location.reverse).to eq([2, 1])
-  end
-
-  it 'should set point to nil' do
-    bar = Bar.create!(name: "Moe's", location: [1, 1])
-    bar.location = nil
-    expect(bar.location).to be_nil
-    expect(bar.save).to be_truthy
-    expect(Bar.where(location: nil).first).to eq(bar)
-  end
-
-  it 'should update point x' do
-    bar = Bar.create!(name: "Moe's", location: [1, 1])
-    bar.location = [2, 3]
-    expect(bar.save).to be_truthy
-    expect(Bar.first.location.to_a).to eq([2, 3])
-  end
-
-  it 'should set point empty string to nil' do
-    bar = Bar.create!(name: "Moe's", location: [1, 1])
-    bar.location = ''
-    expect(bar.location).to be_nil
-    expect(bar.save).to be_truthy
-    expect(Bar.where(location: nil).first).to eq(bar)
-  end
-
-  it 'should set point empty array to nil' do
-    bar = Bar.create!(name: "Moe's", location: [1, 1])
-    bar.location = []
-    expect(bar.location).to be_nil
-    expect(bar.save).to be_truthy
-    expect(Bar.where(location: nil).first).to eq(bar)
-  end
-
-  describe 'methods' do
-    let(:bar) { Bar.create!(location: [3, 2]) }
-
-    it 'should have a .to_a' do
-      expect(bar.location.to_a[0..1]).to eq([3.0, 2.0])
-    end
-
-    it 'should have an array [] accessor' do
-      expect(bar.location[0]).to eq(3.0)
-    end
-
-    it 'should have an ActiveModel symbol accessor' do
-      expect(bar[:location].to_a).to eq([3, 2])
-    end
-
-    it 'should have a radius helper' do
-      expect(bar.location.radius).to eql([[3.0, 2.0], 1])
-    end
-
-    it 'should have a radius sphere helper' do
-      expect(bar.location.radius_sphere[1])
-        .to be_within(0.0001).of(0.00015)
-    end
-
-    it 'should have a radius sphere helper in meters' do
-      expect(bar.location.radius_sphere(1000, :m)[1])
-        .to be_within(0.0001).of(0.00015)
-    end
-
-    it 'should have a radius sphere helper in miles' do
-      expect(bar.location.radius_sphere(1, :mi)[1])
-        .to be_within(0.0001).of(0.00025)
-    end
-  end
-
-  describe 'queryable' do
-    before do
-      Bar.create_indexes
-    end
-
-    describe ':near :near_sphere' do
-      let!(:berlin) do
-        Bar.create(name: :berlin, location: [52.30, 13.25])
-      end
-
-      let!(:prague) do
-        Bar.create(name: :prague, location: [50.5, 14.26])
-      end
-
-      let!(:paris) do
-        Bar.create(name: :paris, location: [48.48, 2.20])
-      end
-
-      let!(:jim) do
-        Person.new(location: [41.23, 2.9])
-      end
-
-      it 'returns the documents sorted closest to furthest' do
-        expect(Bar.closest_to_location(jim.location).to_a)
-          .to eq([paris, prague, berlin])
-      end
-
-      it 'returns the documents sorted closest to furthest' do
-        expect(Bar.where(:location.near => jim.location).to_a)
-          .to eq([paris, prague, berlin])
-      end
-
-      it 'returns the documents sorted closest to furthest' do
-        expect(Bar.near(location: jim.location))
-          .to eq([paris, prague, berlin])
-      end
-
-      it 'returns the documents sorted closest to furthest sphere' do
-        person = Person.new(location: [41.23, 2.9])
-        expect(Bar.near_sphere(location: person.location))
-          .to eq([paris, prague, berlin])
-      end
-
-      it 'returns the documents sorted closest to furthest sphere' do
-        person = Person.new(location: [41.23, 2.9])
-        expect(Bar.where(:location.near_sphere => person.location))
-          .to eq([paris, prague, berlin])
-      end
-
-      it 'returns the documents sorted closest to furthest with max' do
-        expect(Bar.near(location: jim.location).max_distance(location: 10).to_a)
-          .to eq([paris]) # , prague, berlin ]
-      end
-    end
-
-    describe ':within_circle :within_spherical_circle' do
-      let!(:mile1) do
-        Bar.create(name: 'mile1', location: [-73.997345, 40.759382])
-      end
-
-      let!(:mile3) do
-        Bar.create(name: 'mile3', location: [-73.927088, 40.752151])
-      end
-
-      let!(:mile7) do
-        Bar.create(name: 'mile7', location: [-74.0954913, 40.7161472])
-      end
-
-      let!(:mile9) do
-        Bar.create(name: 'mile9', location: [-74.0604951, 40.9178011])
-      end
-
-      let!(:elvis) do
-        Person.new(location: [-73.98, 40.75])
-      end
-
-      it 'returns the documents within a circle' do
-        pending 'Circle'
-        l = [elvis.location, 500.0 / Mongoid::Geospatial::EARTH_RADIUS_KM]
-        expect(Bar.where(:location.within_circle => l).to_a).to include(mile3)
-      end
-
-      it 'returns the documents within a spherical circle' do
-        pending 'Circle'
-        expect(Bar.where(:location.within_spherical_circle =>
-                         [elvis.location, 0.0005]).to_a).to eq([mile1])
-      end
-
-      it 'returns the documents within a center circle' do
-        pending 'Circle'
-        expect(Bar.where(:location.within_center_circle =>
-                         [elvis.location, 0.0005]).to_a).to eq([mile1])
-      end
-
-      it 'returns the documents within a box' do
-        poly = Mongoid::Geospatial::LineString.new(
-          [elvis.location.map { |c| c + 1 },
-           elvis.location.map { |c| c - 1 }]
-        )
-        expect(Bar.where(:location.within_polygon => [poly.geom_box]).to_a)
-          .to include(mile3)
-      end
-    end
-  end
-
-  describe '(de)mongoize' do
-    it 'should mongoize array' do
-      bar = Bar.new(location: [10, -9])
-      expect(bar.location.class).to eql(Mongoid::Geospatial::Point)
-      expect(bar.location.x).to be_within(0.1).of(10)
-      expect(bar.location.y).to be_within(0.1).of(-9)
-    end
-
-    it 'should mongoize hash' do
-      geom = Bar.new(location: { x: 10, y: -9 }).location
-      expect(geom.class).to eql(Mongoid::Geospatial::Point)
-      expect(geom.x).to be_within(0.1).of(10)
-      expect(geom.y).to be_within(0.1).of(-9)
-    end
-
-    it 'should mongoize hash with symbols in any order' do
-      geom = Bar.new(location: { y: -9, x: 10 }).location
-      expect(geom.class).to eql(Mongoid::Geospatial::Point)
-      expect(geom.x).to be_within(0.1).of(10)
-      expect(geom.y).to be_within(0.1).of(-9)
-    end
-
-    it 'should mongoize hash with string keys in any order' do
-      geom = Bar.new(location: { 'y' => -9, 'x' => 10 }).location
-      expect(geom.class).to eql(Mongoid::Geospatial::Point)
-      expect(geom.x).to be_within(0.1).of(10)
-      expect(geom.y).to be_within(0.1).of(-9)
-    end
-
-    # should raise
-    # geom.to_geo
-
-    describe 'with rgeo' do
-      describe 'instantiated' do
-        let(:bar) { Bar.new(name: 'Vitinho', location: [10, 10]) }
-
-        it 'should demongoize to rgeo' do
-          expect(bar.location.class).to eql(Mongoid::Geospatial::Point)
-        end
-      end
-    end
-  end
-end

data/spec/mongoid/geospatial/fields/polygon_spec.rb

@@ -1,87 +0,0 @@
-require 'spec_helper'
-
-describe Mongoid::Geospatial::Polygon do
-  it 'should have correct indexes on farm' do
-    Farm.create_indexes
-    expect(Farm.collection.indexes.get(geom: '2dsphere')).not_to be_nil
-  end
-
-  describe '(de)mongoize' do
-    it 'should support a field mapped as polygon' do
-      farm = Farm.new(area: [[5, 5], [6, 5], [6, 6], [5, 6]])
-      expect(farm.area).to be_a Mongoid::Geospatial::Polygon
-      expect(farm.area).to eq([[5, 5], [6, 5], [6, 6], [5, 6]])
-    end
-
-    it 'should store as array on mongo' do
-      Farm.create(area: [[5, 5], [6, 5], [6, 6], [5, 6]])
-      expect(Farm.first.area).to eq([[5, 5], [6, 5], [6, 6], [5, 6]])
-    end
-
-    it 'should have a bounding box' do
-      geom = Mongoid::Geospatial::Polygon.new [[1, 5], [6, 5], [6, 6], [5, 6]]
-      expect(geom.bbox).to eq([[1, 5], [6, 6]])
-    end
-
-    it 'should have a center point' do
-      geom = Mongoid::Geospatial::Polygon.new [[1, 1], [1, 1], [9, 9], [9, 9]]
-      expect(geom.center).to eq([5.0, 5.0])
-    end
-
-    it 'should have a radius helper' do
-      geom = Mongoid::Geospatial::Polygon.new [[1, 1], [1, 1], [9, 9], [9, 9]]
-      expect(geom.radius(10)).to eq([[5.0, 5.0], 10])
-    end
-
-    it 'should have a radius sphere' do
-      geom = Mongoid::Geospatial::Polygon.new [[1, 1], [1, 1], [9, 9], [9, 9]]
-      expect(geom.radius_sphere(10)[1]).to be_within(0.001).of(0.001569)
-    end
-
-    describe 'with rgeo' do
-      # farm.area.should be_a RGeo::Geographic::SphericalPolygonImpl
-    end
-  end
-
-  describe 'query' do
-    context ':box, :polygon' do
-      before do
-        Farm.create_indexes
-      end
-
-      let(:ranch) do
-        Farm.create!(name: 'Ranch',
-                     area: [[1, 1], [3, 3], [3, 1], [1, 1]],
-                     geom: [2, 2])
-      end
-
-      let(:farm) do
-        Farm.create!(name: 'Farm',
-                     area: [[47, 1], [48, 1.5], [49, 3], [49, 1], [47, 1]],
-                     geom: [48, 1.28])
-      end
-
-      it 'returns the documents within a box' do
-        query = Farm.geo_spatial(:geom.within_polygon => [ranch.area])
-        expect(query.to_a).to eq([ranch])
-      end
-
-      it 'returns the documents within a polygon' do
-        query = Farm.where(:geom.within_polygon => [farm.area])
-        expect(query.to_a).to eq([farm])
-      end
-
-      # it 'returns the documents within a center' do
-      #   pending 'Moped'
-      #   expect(Farm.where(:geom.within_circle =>
-      #                     [ranch.geom, 0.4]).first).to eq(ranch)
-      # end
-
-      # it 'returns the documents within a center_sphere' do
-      #   pending 'Moped'
-      #   expect(Farm.where(:geom.within_spherical_circle =>
-      #                     [ranch.geom, 0.1]).first).to eq(ranch)
-      # end
-    end
-  end
-end

data/spec/mongoid/geospatial/geospatial_spec.rb

@@ -1,222 +0,0 @@
-require 'spec_helper'
-
-describe Mongoid::Geospatial do
-  context 'Class Stuff' do
-    it 'should have an lng_symbols accessor' do
-      expect(Mongoid::Geospatial.lng_symbols).to be_instance_of Array
-      expect(Mongoid::Geospatial.lng_symbols).to include :x
-    end
-
-    it 'should have an lat_symbols accessor' do
-      expect(Mongoid::Geospatial.lat_symbols).to be_instance_of Array
-      expect(Mongoid::Geospatial.lat_symbols).to include :y
-    end
-  end
-
-  context 'Creating indexes' do
-    it 'should create a 2d index' do
-      Bar.create_indexes
-      expect(Bar.collection.indexes.get(location: '2d')).not_to be_nil
-    end
-
-    it 'should create a 2dsphere index' do
-      Alarm.create_indexes
-      expect(Alarm.collection.indexes.get(spot: '2dsphere')).not_to be_nil
-    end
-  end
-
-  context '#nearby 2d' do
-    before do
-      Bar.create_indexes
-    end
-    after do
-      Bar.collection.indexes.drop_all
-    end
-
-    let!(:moes) do
-      Bar.create!(name: "Moe's", location: [-73.77694444, 40.63861111])
-    end
-
-    let!(:rose) do
-      Bar.create!(name: 'Rosa', location: [-118.40, 33.94])
-    end
-
-    let!(:jane) do
-      Bar.create!(name: "Jane's", location: [1, 1])
-    end
-
-    let!(:foo) do
-      Bar.create!(name: "Foo", location: [3, 3])
-    end
-
-    it 'should work specifing center and different location foo' do
-      expect(Bar.nearby(foo.location)).to be_a Mongoid::Criteria
-      expect(Bar.nearby(foo.location).selector).to eq({"location" => {"$near" => [3.0, 3.0]}})
-    end
-
-    it 'should work specifing center and different location moes' do
-      expect(Bar.nearby(moes.location).limit(2)).to eq([moes, rose])
-    end
-
-    it 'should work finding first' do
-      expect(Bar.nearby(moes.location).first).to eq(moes)
-    end
-
-    it 'really should work find first nearby' do
-      expect(Bar.count).to eq(4)
-      expect(Bar.nearby([1, 1]).to_a).to eq([jane, foo, moes, rose])
-      expect(Bar.nearby([2, 2]).to_a.first).to eq(jane)
-      # THIS WILL FAIL MONGOID ISSUE
-      # expect(Bar.nearby(rose.location).first).to eq(rose)
-    end
-
-    it 'should work specifing first' do
-      bars = Bar.nearby(rose.location).to_a
-      expect(bars.first).to eq(rose)
-    end
-
-    it 'should work specifing first' do
-      expect(Bar.nearby(rose.location).to_a.first).to eq(rose)
-    end
-
-    it 'should work specifing first' do
-      expect(Bar.nearby(rose.location).to_a.first).to eq(rose)
-    end
-
-    it 'should work specifing first' do
-      expect(Bar.nearby(rose.location).first).to eq(rose)
-    end
-
-    it 'returns the documents sorted closest to furthest' do
-      expect(Bar.closest_to_location(rose.location).to_a)
-        .to eq([rose, moes, jane, foo])
-    end
-
-    it 'returns the documents sorted closest to furthest' do
-      expect(Bar.closest_to_location(rose.location).limit(2))
-        .to eq([rose, moes])
-    end
-
-    it 'returns the documents sorted closest to furthest' do
-      expect(Bar.closest_to_location(rose.location).first).to eq(rose)
-    end
-
-    it 'returns the documents sorted closest to furthest' do
-      expect(Bar.closest_to_location(rose.location).to_a)
-        .to eq([rose, moes, jane, foo])
-    end
-
-    it 'should work specifing center and different location foo' do
-      expect(Bar.closest_to_location(foo.location)).to be_a Mongoid::Criteria
-      expect(Bar.closest_to_location(foo.location).selector).to eq({"location" => {"$near" => [3.0, 3.0]}})
-    end
-
-  end
-
-  context '#nearby 2dsphere' do
-    before do
-      Alarm.create_indexes
-    end
-    after do
-      Alarm.collection.indexes.drop_all
-    end
-    let!(:jfk) do
-      Alarm.create(name: 'jfk', spot: [-73.77694444, 40.63861111])
-    end
-
-    let!(:lax) do
-      Alarm.create(name: 'lax', spot: [-118.40, 33.94])
-    end
-
-    it 'should work with specific center and different spot attribute' do
-      expect(Alarm.nearby(lax.spot)).to eq([lax, jfk])
-    end
-
-    it 'should work with default origin' do
-      expect(Alarm.near_sphere(spot: lax.spot)).to eq([lax, jfk])
-    end
-
-    it 'should work with default origin key' do
-      expect(Alarm.where(:spot.near_sphere => lax.spot)).to eq([lax, jfk])
-    end
-
-    context ':paginate' do
-      before do
-        Alarm.create_indexes
-        50.times do
-          Alarm.create(spot: [rand(1..10), rand(1..10)])
-        end
-      end
-
-      it 'limits fine with 25' do
-        expect(Alarm.near_sphere(spot: [5, 5])
-                .limit(25).to_a.size).to eq 25
-      end
-
-      it 'limits fine with 25 and skips' do
-        expect(Alarm.near_sphere(spot: [5, 5])
-                .skip(25).limit(25).to_a.size).to eq 25
-      end
-
-      it 'paginates 50' do
-        page1 = Alarm.near_sphere(spot: [5, 5]).limit(25)
-        page2 = Alarm.near_sphere(spot: [5, 5]).skip(25).limit(25)
-        expect((page1 + page2).uniq.size).to eq(50)
-      end
-    end
-
-    context ':query' do
-      before do
-        Alarm.create_indexes
-        3.times do
-          Alarm.create(spot: [jfk.spot.x + rand(0), jfk.spot.y + rand(0)])
-        end
-      end
-
-      it 'should filter using extra query option' do
-        query = Alarm.near_sphere(spot: jfk.spot).where(name: jfk.name)
-        expect(query.to_a).to eq [jfk]
-      end
-    end
-
-    context ':maxDistance' do
-      it 'should get 1 item' do
-        spot = 2465 / Mongoid::Geospatial.earth_radius[:mi]
-        query = Alarm.near_sphere(spot: lax.spot).max_distance(spot: spot)
-        expect(query.to_a.size).to eq 1
-      end
-    end
-
-    #     context ':distance_multiplier' do
-    #       it "should multiply returned distance with multiplier" do
-    #         Bar.geo_near(lax.location,
-    #         ::distance_multiplier=> Mongoid::Geospatial.earth_radius[:mi])
-    #            .second.geo[:distance].to_i.should be_within(1).of(2469)
-    #       end
-    #     end
-
-    #     context ':unit' do
-    #       it "should multiply returned distance with multiplier" do
-    #         Bar.geo_near(lax.location, :spherical => true, :unit => :mi)
-    #           .second.geo[:distance].to_i.should be_within(1).of(2469)
-    #       end
-
-    #       it "should convert max_distance to radians with unit" do
-    #         Bar.geo_near(lax.location, :spherical => true,
-    #          :max_distance => 2465, :unit => :mi).size.should == 1
-    #       end
-
-    #     end
-
-    #   end
-
-    #   context 'criteria chaining' do
-    #     it "should filter by where" do
-    #       Bar.where(:name => jfk.name).geo_near(jfk.location).should == [jfk]
-    #       Bar.any_of({:name => jfk.name},{:name => lax.name})
-    #         .geo_near(jfk.location).should == [jfk,lax]
-    #     end
-    #   end
-    # end
-  end
-end

data/spec/mongoid/geospatial/helpers/core_spec.rb

@@ -1,35 +0,0 @@
-module Mongoid
-  module Geospatial
-    def self.from_array(ary)
-      ary[0..1].map(&:to_f)
-    end
-
-    def self.from_hash(hsh)
-      raise 'Hash must have at least 2 items' if hsh.size < 2
-
-      [from_hash_x(hsh), from_hash_y(hsh)]
-    end
-
-    def self.from_hash_y(hsh)
-      v = (Mongoid::Geospatial.lat_symbols & hsh.keys).first
-      return hsh[v].to_f if !v.nil? && hsh[v]
-
-      if Mongoid::Geospatial.lng_symbols.index(hsh.keys[1])
-        raise "Hash cannot contain #{Mongoid::Geospatial.lng_symbols.inspect} "\
-             "as second arg without #{Mongoid::Geospatial.lat_symbols.inspect}"
-      end
-      hsh.values[1].to_f
-    end
-
-    def self.from_hash_x(hsh)
-      v = (Mongoid::Geospatial.lng_symbols & hsh.keys).first
-      return hsh[v].to_f if !v.nil? && hsh[v]
-
-      if Mongoid::Geospatial.lat_symbols.index(keys[0])
-        raise "Hash cannot contain #{Mongoid::Geospatial.lat_symbols.inspect} "\
-             "as first arg without #{Mongoid::Geospatial.lng_symbols.inspect}"
-      end
-      values[0].to_f
-    end
-  end
-end

data/spec/mongoid/geospatial/helpers/delegate_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-describe Mongoid::Fields do
-  context 'delegate' do
-    before do
-      Bus.create_indexes
-    end
-
-    context 'x, y helpers' do
-      let(:bus) { Bus.create!(name: 'Far', location: [7, 8]) }
-
-      it 'should set instance method x' do
-        expect(bus.x).to eq(7)
-      end
-
-      it 'should set instance method y' do
-        expect(bus.y).to eq(8)
-      end
-
-      it 'should set instance method x=' do
-        bus.x = 9
-        expect(bus.x).to eq(9)
-      end
-
-      it 'should set instance method y=' do
-        bus.y = 9
-        expect(bus.y).to eq(9)
-      end
-    end
-
-    it 'should set instance methods x= and y=' do
-      bus = Bus.create!(name: 'B', location: [7, 7])
-      bus.x = 8
-      bus.y = 9
-      expect(bus.location.to_a).to eq([8, 9])
-    end
-
-    it 'should work fine with default values' do
-      event = Event.create!(name: 'Bvent')
-      event.x = 8
-      event.y = 9
-      expect(event.location.to_a).to eq([8, 9])
-    end
-
-    it 'should not work fine with nils' do
-      bus = Bus.create!(name: 'B', location: nil)
-      expect do
-        bus.x = 9
-        bus.y = 9
-      end.to raise_error(NoMethodError)
-    end
-
-    it 'should update point x' do
-      bus = Bus.create!(name: '0789', location: [1, 1])
-      bus.x = 2
-      expect(bus.save).to be_truthy
-      expect(Bus.first.location.to_a).to eq([2, 1])
-    end
-
-    it 'should update point y' do
-      bus = Bus.create!(name: '0987', location: [1, 1])
-      bus.y = 2
-      expect(bus.save).to be_truthy
-      expect(Bus.first.location.to_a).to eq([1.0, 2.0])
-    end
-  end
-end