activerecord-postgis-adapter 1.0.0 → 1.1.0

data/test/tc_ddl.rb

@@ -1,279 +0,0 @@
-require 'minitest/autorun'
-require 'rgeo/active_record/adapter_test_helper'
-
-module RGeo
-  module ActiveRecord  # :nodoc:
-    module PostGISAdapter  # :nodoc:
-      module Tests  # :nodoc:
-        class TestDDL < ::MiniTest::Test  # :nodoc:
-          DATABASE_CONFIG_PATH = ::File.dirname(__FILE__)+'/database.yml'
-          OVERRIDE_DATABASE_CONFIG_PATH = ::File.dirname(__FILE__)+'/database_local.yml'
-          include AdapterTestHelper
-
-          define_test_methods do
-            def test_create_simple_geometry
-              klass_ = create_ar_class
-              klass_.connection.create_table(:spatial_test) do |t_|
-                t_.column 'latlon', :geometry
-              end
-              assert_equal(1, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
-              col_ = klass_.columns.last
-              assert_equal(::RGeo::Feature::Geometry, col_.geometric_type)
-              assert_equal(true, col_.has_spatial_constraints?)
-              assert_equal(false, col_.geographic?)
-              assert_equal(0, col_.srid)
-              assert(klass_.cached_attributes.include?('latlon'))
-              klass_.connection.drop_table(:spatial_test)
-              assert_equal(0, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
-            end
-
-            # no_constraints no longer supported in PostGIS 2.0
-            def _test_create_no_constraints_geometry
-              klass_ = create_ar_class
-              klass_.connection.create_table(:spatial_test) do |t_|
-                t_.column 'geom', :geometry, :limit => {:no_constraints => true}
-              end
-              assert_equal(0, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
-              col_ = klass_.columns.last
-              assert_equal(::RGeo::Feature::Geometry, col_.geometric_type)
-              assert_equal(false, col_.geographic?)
-              assert_equal(false, col_.has_spatial_constraints?)
-              assert_nil(col_.srid)
-              assert(klass_.cached_attributes.include?('geom'))
-              klass_.connection.drop_table(:spatial_test)
-              assert_equal(0, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
-            end
-
-            def test_create_simple_geography
-              klass_ = create_ar_class
-              klass_.connection.create_table(:spatial_test) do |t_|
-                t_.column 'latlon', :geometry, :geographic => true
-              end
-              col_ = klass_.columns.last
-              assert_equal(::RGeo::Feature::Geometry, col_.geometric_type)
-              assert_equal(true, col_.has_spatial_constraints?)
-              assert_equal(true, col_.geographic?)
-              assert_equal(4326, col_.srid)
-              assert(klass_.cached_attributes.include?('latlon'))
-              assert_equal(0, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
-            end
-
-            def test_create_point_geometry
-              klass_ = create_ar_class
-              klass_.connection.create_table(:spatial_test) do |t_|
-                t_.column 'latlon', :point
-              end
-              assert_equal(::RGeo::Feature::Point, klass_.columns.last.geometric_type)
-              assert(klass_.cached_attributes.include?('latlon'))
-            end
-
-            def test_create_geometry_with_index
-              klass_ = create_ar_class
-              klass_.connection.create_table(:spatial_test) do |t_|
-                t_.column 'latlon', :geometry
-              end
-              klass_.connection.change_table(:spatial_test) do |t_|
-                t_.index([:latlon], :spatial => true)
-              end
-              assert(klass_.connection.indexes(:spatial_test).last.spatial)
-            end
-
-            def test_add_geometry_column
-              klass_ = create_ar_class
-              klass_.connection.create_table(:spatial_test) do |t_|
-                t_.column('latlon', :geometry)
-              end
-              klass_.connection.change_table(:spatial_test) do |t_|
-                t_.column('geom2', :point, :srid => 4326)
-                t_.column('name', :string)
-              end
-              assert_equal(2, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
-              cols_ = klass_.columns
-              assert_equal(::RGeo::Feature::Geometry, cols_[-3].geometric_type)
-              assert_equal(0, cols_[-3].srid)
-              assert_equal(true, cols_[-3].has_spatial_constraints?)
-              assert_equal(::RGeo::Feature::Point, cols_[-2].geometric_type)
-              assert_equal(4326, cols_[-2].srid)
-              assert_equal(false, cols_[-2].geographic?)
-              assert_equal(true, cols_[-2].has_spatial_constraints?)
-              assert_nil(cols_[-1].geometric_type)
-              assert_equal(false, cols_[-1].has_spatial_constraints?)
-            end
-
-            # no_constraints no longer supported in PostGIS 2.0
-            def _test_add_no_constraints_geometry_column
-              klass_ = create_ar_class
-              klass_.connection.create_table(:spatial_test) do |t_|
-                t_.column('latlon', :geometry)
-              end
-              klass_.connection.change_table(:spatial_test) do |t_|
-                t_.column('geom2', :geometry, :no_constraints => true)
-                t_.column('name', :string)
-              end
-              assert_equal(1, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
-              cols_ = klass_.columns
-              assert_equal(::RGeo::Feature::Geometry, cols_[-3].geometric_type)
-              assert_equal(0, cols_[-3].srid)
-              assert_equal(true, cols_[-3].has_spatial_constraints?)
-              assert_equal(::RGeo::Feature::Geometry, cols_[-2].geometric_type)
-              assert_nil(cols_[-2].srid)
-              assert_equal(false, cols_[-2].geographic?)
-              assert_equal(false, cols_[-2].has_spatial_constraints?)
-              assert_nil(cols_[-1].geometric_type)
-              assert_equal(false, cols_[-1].has_spatial_constraints?)
-            end
-
-            def test_add_geography_column
-              klass_ = create_ar_class
-              klass_.connection.create_table(:spatial_test) do |t_|
-                t_.column('latlon', :geometry)
-              end
-              klass_.connection.change_table(:spatial_test) do |t_|
-                t_.column('geom2', :point, :srid => 4326, :geographic => true)
-                t_.column('name', :string)
-              end
-              assert_equal(1, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
-              cols_ = klass_.columns
-              assert_equal(::RGeo::Feature::Geometry, cols_[-3].geometric_type)
-              assert_equal(0, cols_[-3].srid)
-              assert_equal(true, cols_[-3].has_spatial_constraints?)
-              assert_equal(::RGeo::Feature::Point, cols_[-2].geometric_type)
-              assert_equal(4326, cols_[-2].srid)
-              assert_equal(true, cols_[-2].geographic?)
-              assert_equal(true, cols_[-2].has_spatial_constraints?)
-              assert_nil(cols_[-1].geometric_type)
-              assert_equal(false, cols_[-1].has_spatial_constraints?)
-            end
-
-            def test_drop_geometry_column
-              klass_ = create_ar_class
-              klass_.connection.create_table(:spatial_test) do |t_|
-                t_.column('latlon', :geometry)
-                t_.column('geom2', :point, :srid => 4326)
-              end
-              klass_.connection.change_table(:spatial_test) do |t_|
-                t_.remove('geom2')
-              end
-              assert_equal(1, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
-              cols_ = klass_.columns
-              assert_equal(::RGeo::Feature::Geometry, cols_[-1].geometric_type)
-              assert_equal('latlon', cols_[-1].name)
-              assert_equal(0, cols_[-1].srid)
-              assert_equal(false, cols_[-1].geographic?)
-            end
-
-            def test_drop_geography_column
-              klass_ = create_ar_class
-              klass_.connection.create_table(:spatial_test) do |t_|
-                t_.column('latlon', :geometry)
-                t_.column('geom2', :point, :srid => 4326, :geographic => true)
-                t_.column('geom3', :point, :srid => 4326)
-              end
-              klass_.connection.change_table(:spatial_test) do |t_|
-                t_.remove('geom2')
-              end
-              assert_equal(2, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
-              cols_ = klass_.columns
-              assert_equal(::RGeo::Feature::Point, cols_[-1].geometric_type)
-              assert_equal('geom3', cols_[-1].name)
-              assert_equal(false, cols_[-1].geographic?)
-              assert_equal(::RGeo::Feature::Geometry, cols_[-2].geometric_type)
-              assert_equal('latlon', cols_[-2].name)
-              assert_equal(false, cols_[-2].geographic?)
-            end
-
-            def test_create_simple_geometry_using_shortcut
-              klass_ = create_ar_class
-              klass_.connection.create_table(:spatial_test) do |t_|
-                t_.geometry 'latlon'
-              end
-              assert_equal(1, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
-              col_ = klass_.columns.last
-              assert_equal(::RGeo::Feature::Geometry, col_.geometric_type)
-              assert_equal(false, col_.geographic?)
-              assert_equal(0, col_.srid)
-              assert(klass_.cached_attributes.include?('latlon'))
-              klass_.connection.drop_table(:spatial_test)
-              assert_equal(0, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
-            end
-
-            # no_constraints no longer supported in PostGIS 2.0
-            def _test_create_no_constraints_geometry_using_shortcut
-              klass_ = create_ar_class
-              klass_.connection.create_table(:spatial_test) do |t_|
-                t_.spatial 'geom', :no_constraints => true
-              end
-              assert_equal(0, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
-              col_ = klass_.columns.last
-              assert_equal(::RGeo::Feature::Geometry, col_.geometric_type)
-              assert_equal(false, col_.geographic?)
-              assert_nil(col_.srid)
-              assert(klass_.cached_attributes.include?('geom'))
-              klass_.connection.drop_table(:spatial_test)
-              assert_equal(0, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
-            end
-
-            def test_create_simple_geography_using_shortcut
-              klass_ = create_ar_class
-              klass_.connection.create_table(:spatial_test) do |t_|
-                t_.geometry 'latlon', :geographic => true
-              end
-              col_ = klass_.columns.last
-              assert_equal(::RGeo::Feature::Geometry, col_.geometric_type)
-              assert_equal(true, col_.geographic?)
-              assert_equal(4326, col_.srid)
-              assert(klass_.cached_attributes.include?('latlon'))
-              assert_equal(0, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
-            end
-
-            def test_create_point_geometry_using_shortcut
-              klass_ = create_ar_class
-              klass_.connection.create_table(:spatial_test) do |t_|
-                t_.point 'latlon'
-              end
-              assert_equal(::RGeo::Feature::Point, klass_.columns.last.geometric_type)
-              assert(klass_.cached_attributes.include?('latlon'))
-            end
-
-            def test_create_geometry_with_options
-              klass_ = create_ar_class
-              klass_.connection.create_table(:spatial_test) do |t_|
-                t_.column 'region', :polygon, :has_m => true, :srid => 3785
-              end
-              assert_equal(1, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
-              col_ = klass_.columns.last
-              assert_equal(::RGeo::Feature::Polygon, col_.geometric_type)
-              assert_equal(false, col_.geographic?)
-              assert_equal(false, col_.has_z?)
-              assert_equal(true, col_.has_m?)
-              assert_equal(3785, col_.srid)
-              assert_equal({:has_m => true, :type => 'polygon', :srid => 3785}, col_.limit)
-              assert(klass_.cached_attributes.include?('region'))
-              klass_.connection.drop_table(:spatial_test)
-              assert_equal(0, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
-            end
-
-            def test_create_geometry_using_limit
-              klass_ = create_ar_class
-              klass_.connection.create_table(:spatial_test) do |t_|
-                t_.spatial 'region', :limit => {:has_m => true, :srid => 3785, :type => :polygon}
-              end
-              assert_equal(1, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
-              col_ = klass_.columns.last
-              assert_equal(::RGeo::Feature::Polygon, col_.geometric_type)
-              assert_equal(false, col_.geographic?)
-              assert_equal(false, col_.has_z)
-              assert_equal(true, col_.has_m)
-              assert_equal(3785, col_.srid)
-              assert_equal({:has_m => true, :type => 'polygon', :srid => 3785}, col_.limit)
-              assert(klass_.cached_attributes.include?('region'))
-              klass_.connection.drop_table(:spatial_test)
-              assert_equal(0, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
-            end
-
-          end
-        end
-      end
-    end
-  end
-end

data/test/tc_spatial_queries.rb

@@ -1,126 +0,0 @@
-require 'minitest/autorun'
-require 'rgeo/active_record/adapter_test_helper'
-
-
-module RGeo
-  module ActiveRecord  # :nodoc:
-    module PostGISAdapter  # :nodoc:
-      module Tests  # :nodoc:
-
-        class TestSpatialQueries < ::MiniTest::Test  # :nodoc:
-
-          DATABASE_CONFIG_PATH = ::File.dirname(__FILE__)+'/database.yml'
-          OVERRIDE_DATABASE_CONFIG_PATH = ::File.dirname(__FILE__)+'/database_local.yml'
-          include AdapterTestHelper
-
-          define_test_methods do
-
-
-            def populate_ar_class(content_)
-              klass_ = create_ar_class
-              case content_
-              when :mercator_point
-                klass_.connection.create_table(:spatial_test) do |t_|
-                  t_.column 'latlon', :point, :srid => 3785
-                end
-              when :latlon_point_geographic
-                klass_.connection.create_table(:spatial_test) do |t_|
-                  t_.column 'latlon', :point, :srid => 4326, :geographic => true
-                end
-              when :path_linestring
-                klass_.connection.create_table(:spatial_test) do |t_|
-                  t_.column 'path', :line_string, :srid => 3785
-                end
-              end
-              klass_
-            end
-
-
-            def test_query_point
-              klass_ = populate_ar_class(:mercator_point)
-              obj_ = klass_.new
-              obj_.latlon = @factory.point(1.0, 2.0)
-              obj_.save!
-              id_ = obj_.id
-              obj2_ = klass_.where(:latlon => @factory.multi_point([@factory.point(1.0, 2.0)])).first
-              refute_nil(obj2_)
-              assert_equal(id_, obj2_.id)
-              obj3_ = klass_.where(:latlon => @factory.point(2.0, 2.0)).first
-              assert_nil(obj3_)
-            end
-
-
-            def test_query_point_wkt
-              klass_ = populate_ar_class(:mercator_point)
-              obj_ = klass_.new
-              obj_.latlon = @factory.point(1.0, 2.0)
-              obj_.save!
-              id_ = obj_.id
-              obj2_ = klass_.where(:latlon => 'SRID=3785;POINT(1 2)').first
-              refute_nil(obj2_)
-              assert_equal(id_, obj2_.id)
-              obj3_ = klass_.where(:latlon => 'SRID=3785;POINT(2 2)').first
-              assert_nil(obj3_)
-            end
-
-
-            if ::RGeo::ActiveRecord.spatial_expressions_supported?
-
-
-              def test_query_st_distance
-                klass_ = populate_ar_class(:mercator_point)
-                obj_ = klass_.new
-                obj_.latlon = @factory.point(1.0, 2.0)
-                obj_.save!
-                id_ = obj_.id
-                obj2_ = klass_.where(klass_.arel_table[:latlon].st_distance('SRID=3785;POINT(2 3)').lt(2)).first
-                refute_nil(obj2_)
-                assert_equal(id_, obj2_.id)
-                obj3_ = klass_.where(klass_.arel_table[:latlon].st_distance('SRID=3785;POINT(2 3)').gt(2)).first
-                assert_nil(obj3_)
-              end
-
-
-              def test_query_st_distance_from_constant
-                klass_ = populate_ar_class(:mercator_point)
-                obj_ = klass_.new
-                obj_.latlon = @factory.point(1.0, 2.0)
-                obj_.save!
-                id_ = obj_.id
-                obj2_ = klass_.where(::Arel.spatial('SRID=3785;POINT(2 3)').st_distance(klass_.arel_table[:latlon]).lt(2)).first
-                refute_nil(obj2_)
-                assert_equal(id_, obj2_.id)
-                obj3_ = klass_.where(::Arel.spatial('SRID=3785;POINT(2 3)').st_distance(klass_.arel_table[:latlon]).gt(2)).first
-                assert_nil(obj3_)
-              end
-
-
-              def test_query_st_length
-                klass_ = populate_ar_class(:path_linestring)
-                obj_ = klass_.new
-                obj_.path = @factory.line(@factory.point(1.0, 2.0), @factory.point(3.0, 2.0))
-                obj_.save!
-                id_ = obj_.id
-                obj2_ = klass_.where(klass_.arel_table[:path].st_length.eq(2)).first
-                refute_nil(obj2_)
-                assert_equal(id_, obj2_.id)
-                obj3_ = klass_.where(klass_.arel_table[:path].st_length.gt(3)).first
-                assert_nil(obj3_)
-              end
-
-
-            else
-
-              puts "WARNING: The current Arel does not support named functions. Spatial expression tests skipped."
-
-            end
-
-
-          end
-
-        end
-
-      end
-    end
-  end
-end

data/test/tc_tasks.rb

@@ -1,112 +0,0 @@
-require 'minitest/autorun'
-require 'rgeo/active_record/adapter_test_helper'
-
-module RGeo
-  module ActiveRecord  # :nodoc:
-    module PostGISAdapter  # :nodoc:
-      module Tests  # :nodoc:
-        class TestTasks < ::MiniTest::Test  # :nodoc:
-          DATABASE_CONFIG_PATH = ::File.dirname(__FILE__)+'/database.yml'
-          OVERRIDE_DATABASE_CONFIG_PATH = ::File.dirname(__FILE__)+'/database_local.yml'
-
-          class << self
-            def before_open_database(args_)
-              @new_database_config = args_[:config].merge('database' => 'postgis_adapter_test2')
-              @new_database_config.stringify_keys!
-            end
-            attr_reader :new_database_config
-          end
-
-          include AdapterTestHelper
-
-          def cleanup_tables
-            ::ActiveRecord::Base.remove_connection
-            ::ActiveRecord::Base.clear_active_connections!
-            TestTasks::DEFAULT_AR_CLASS.connection.execute("DROP DATABASE IF EXISTS \"postgis_adapter_test2\"")
-          end
-
-          define_test_methods do
-            def test_create_database_from_extension_in_public_schema
-              ::ActiveRecord::Tasks::DatabaseTasks.create(TestTasks.new_database_config)
-              ::ActiveRecord::Base.connection.select_values("SELECT * from public.spatial_ref_sys")
-            end
-
-            def test_empty_sql_dump
-              filename_ = ::File.expand_path('../tmp/tmp.sql', ::File.dirname(__FILE__))
-              ::FileUtils.rm_f(filename_)
-              ::FileUtils.mkdir_p(::File.dirname(filename_))
-              ::ActiveRecord::Tasks::DatabaseTasks.create(TestTasks.new_database_config.merge('schema_search_path' => 'public,postgis'))
-              ::ActiveRecord::Tasks::DatabaseTasks.structure_dump(TestTasks.new_database_config, filename_)
-              sql_ = ::File.read(filename_)
-              assert(sql_ !~ /CREATE/)
-            end
-
-            def test_basic_geography_sql_dump
-              filename_ = ::File.expand_path('../tmp/tmp.sql', ::File.dirname(__FILE__))
-              ::FileUtils.rm_f(filename_)
-              ::FileUtils.mkdir_p(::File.dirname(filename_))
-              ::ActiveRecord::Tasks::DatabaseTasks.create(TestTasks.new_database_config.merge('schema_search_path' => 'public,postgis'))
-              ::ActiveRecord::Base.connection.create_table(:spatial_test) do |t_|
-                t_.point "latlon", :geographic => true
-              end
-              ::ActiveRecord::Tasks::DatabaseTasks.structure_dump(TestTasks.new_database_config, filename_)
-              data_ = ::File.read(filename_)
-              assert(data_.index('latlon geography(Point,4326)'))
-            end
-
-            def test_empty_schema_dump
-              filename_ = ::File.expand_path('../tmp/tmp.rb', ::File.dirname(__FILE__))
-              ::FileUtils.rm_f(filename_)
-              ::FileUtils.mkdir_p(::File.dirname(filename_))
-              ::ActiveRecord::Tasks::DatabaseTasks.create(TestTasks.new_database_config.merge('schema_search_path' => 'public,postgis'))
-              require 'active_record/schema_dumper'
-              ::File.open(filename_, "w:utf-8") do |file_|
-                ::ActiveRecord::SchemaDumper.dump(::ActiveRecord::Base.connection, file_)
-              end
-              data_ = ::File.read(filename_)
-              assert(data_.index('ActiveRecord::Schema'))
-            end
-
-            def test_basic_geometry_schema_dump
-              filename_ = ::File.expand_path('../tmp/tmp.rb', ::File.dirname(__FILE__))
-              ::FileUtils.rm_f(filename_)
-              ::FileUtils.mkdir_p(::File.dirname(filename_))
-              ::ActiveRecord::Tasks::DatabaseTasks.create(TestTasks.new_database_config.merge('schema_search_path' => 'public,postgis'))
-              conn_ = ::ActiveRecord::Base.connection
-              conn_.create_table(:spatial_test) do |t_|
-                t_.geometry 'object1'
-                t_.spatial "object2", :limit => {:srid=>conn_.default_srid, :type=>"geometry"}
-              end
-              require 'active_record/schema_dumper'
-              ::File.open(filename_, "w:utf-8") do |file_|
-                ::ActiveRecord::SchemaDumper.dump(conn_, file_)
-              end
-              data_ = ::File.read(filename_)
-              assert(data_.index("t.spatial \"object1\", limit: {:srid=>#{conn_.default_srid}, :type=>\"geometry\"}"))
-              assert(data_.index("t.spatial \"object2\", limit: {:srid=>#{conn_.default_srid}, :type=>\"geometry\"}"))
-            end
-
-            def test_basic_geography_schema_dump
-              filename_ = ::File.expand_path('../tmp/tmp.rb', ::File.dirname(__FILE__))
-              ::FileUtils.rm_f(filename_)
-              ::FileUtils.mkdir_p(::File.dirname(filename_))
-              ::ActiveRecord::Tasks::DatabaseTasks.create(TestTasks.new_database_config.merge('schema_search_path' => 'public,postgis'))
-              conn_ = ::ActiveRecord::Base.connection
-              conn_.create_table(:spatial_test) do |t_|
-                t_.point "latlon1", :geographic => true
-                t_.spatial "latlon2", :limit => {:srid=>4326, :type=>"point", :geographic=>true}
-              end
-              require 'active_record/schema_dumper'
-              ::File.open(filename_, "w:utf-8") do |file_|
-                ::ActiveRecord::SchemaDumper.dump(conn_, file_)
-              end
-              data_ = ::File.read(filename_)
-              assert(data_.index('t.spatial "latlon1", limit: {:srid=>4326, :type=>"point", :geographic=>true}'))
-              assert(data_.index('t.spatial "latlon2", limit: {:srid=>4326, :type=>"point", :geographic=>true}'))
-            end
-          end
-        end
-      end
-    end
-  end
-end