activerecord-postgis-adapter 6.0.0 → 7.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a833d2d7fa9bba57717556d4f0caf2999acd233bfc5bbee07a83a3fa611d5027
-  data.tar.gz: 1f5c2155f745932c8f33cf6fed32063078963f026acadd117af60b4ea6a03ec2
+  metadata.gz: fcaaf2a57395c122e6541b1e40bd416f5f31fd1e512c250e5222ec5bb3feb650
+  data.tar.gz: 2772452b3ea880ecab759cb5add73d2ed22a89a78e12eae087aff60a061a8f20
 SHA512:
-  metadata.gz: '0996d86cd8ca024fa121f2396be5fb13bd0da6e04a6fc2ea41cbc3ea5afdb49b03308b7bb90331ff347924b0bc81d624655bc31e6d83d218ef941c06f2ff5285'
-  data.tar.gz: 281e1d2f486993b31636d163d449c901e4dd4d67eb872fd33a0f403ea05001b554980bd621e3fcdd74a0b56b126e3f9e063de5499b93981b07fadb41d08158d6
+  metadata.gz: 743b335ad32f5d872eebd7c512d7557102ed137664e4336a8c26154fe5f3b2bc3ded2b8e0ebe73195e05e8bb9affb538f7dde93e2aa095b142078e464c2fed98
+  data.tar.gz: 8cfc035141871044857863337a94f4c854423afc784f305853cd1a838dde14ec729a941c50a14edc5841829e8c21ce8c4f04c1826611ecb853d8239fb95401f4

data/lib/active_record/connection_adapters/postgis/arel_tosql.rb

@@ -1,5 +1,23 @@
 # frozen_string_literal: true
 
+module RGeo
+  module ActiveRecord
+    ##
+    # Extend rgeo-activerecord visitors to use PostGIS specific functionality
+    module SpatialToPostGISSql
+      def visit_in_spatial_context(node, collector)
+        # Use ST_GeomFromEWKT for EWKT geometries
+        if node.is_a?(String) && node =~ /SRID=[\d+]{0,};/
+          collector << "#{st_func('ST_GeomFromEWKT')}(#{quote(node)})"
+        else
+          super(node, collector)
+        end
+      end
+    end
+  end
+end
+RGeo::ActiveRecord::SpatialToSql.prepend RGeo::ActiveRecord::SpatialToPostGISSql
+
 module Arel  # :nodoc:
   module Visitors  # :nodoc:
     # Different super-class under JRuby JDBC adapter.
@@ -11,22 +29,6 @@ module Arel  # :nodoc:
 
     class PostGIS < PostGISSuperclass  # :nodoc:
       include RGeo::ActiveRecord::SpatialToSql
-
-      FUNC_MAP = {
-        "st_wkttosql" => "ST_GeomFromEWKT",
-      }
-
-      def st_func(standard_name)
-        FUNC_MAP[standard_name.downcase] || standard_name
-      end
-
-      def visit_String(node, collector)
-        collector << "#{st_func('ST_WKTToSQL')}(#{quote(node)})"
-      end
-
-      def visit_RGeo_ActiveRecord_SpatialNamedFunction(node, collector)
-        aggregate(st_func(node.name), node, collector)
-      end
     end
   end
 end

data/lib/active_record/connection_adapters/postgis/column_methods.rb

@@ -6,43 +6,43 @@ module ActiveRecord
       module ColumnMethods
         def spatial(name, options = {})
           raise "You must set a type. For example: 't.spatial type: :st_point'" unless options[:type]
-          column(name, options[:type], options)
+          column(name, options[:type], **options)
         end
 
         def geography(name, options = {})
-          column(name, :geography, options)
+          column(name, :geography, **options)
         end
 
         def geometry(name, options = {})
-          column(name, :geometry, options)
+          column(name, :geometry, **options)
         end
 
         def geometry_collection(name, options = {})
-          column(name, :geometry_collection, options)
+          column(name, :geometry_collection, **options)
         end
 
         def line_string(name, options = {})
-          column(name, :line_string, options)
+          column(name, :line_string, **options)
         end
 
         def multi_line_string(name, options = {})
-          column(name, :multi_line_string, options)
+          column(name, :multi_line_string, **options)
         end
 
         def multi_point(name, options = {})
-          column(name, :multi_point, options)
+          column(name, :multi_point, **options)
         end
 
         def multi_polygon(name, options = {})
-          column(name, :multi_polygon, options)
+          column(name, :multi_polygon, **options)
         end
 
         def st_point(name, options = {})
-          column(name, :st_point, options)
+          column(name, :st_point, **options)
         end
 
         def st_polygon(name, options = {})
-          column(name, :st_polygon, options)
+          column(name, :st_polygon, **options)
         end
       end
     end

data/lib/active_record/connection_adapters/postgis/create_connection.rb

@@ -10,7 +10,11 @@ module ActiveRecord  # :nodoc:
   module ConnectionHandling  # :nodoc:
     if RUBY_ENGINE == "jruby"
 
+      # modified from https://github.com/jruby/activerecord-jdbc-adapter/blob/master/lib/arjdbc/postgresql/connection_methods.rb#L3
       def postgis_connection(config)
+        config = config.deep_dup
+        config = symbolize_keys_if_necessary(config)
+
         config[:adapter_class] = ConnectionAdapters::PostGISAdapter
         postgresql_connection(config)
       end
@@ -23,9 +27,7 @@ module ActiveRecord  # :nodoc:
       # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
       # FULL REPLACEMENT because we need to create a different class.
       def postgis_connection(config)
-        conn_params = config.symbolize_keys
-
-        conn_params.delete_if { |_, v| v.nil? }
+        conn_params = config.symbolize_keys.compact
 
         # Map ActiveRecords param names to PGs.
         conn_params[:user] = conn_params.delete(:username) if conn_params[:username]
@@ -35,14 +37,12 @@ module ActiveRecord  # :nodoc:
         valid_conn_param_keys = PG::Connection.conndefaults_hash.keys + [:requiressl]
         conn_params.slice!(*valid_conn_param_keys)
 
-        conn = PG.connect(conn_params)
-        ConnectionAdapters::PostGISAdapter.new(conn, logger, conn_params, config)
-      rescue ::PG::Error => error
-        if error.message.include?(conn_params[:dbname])
-          raise ActiveRecord::NoDatabaseError
-        else
-          raise
-        end
+        ConnectionAdapters::PostGISAdapter.new(
+          ConnectionAdapters::PostGISAdapter.new_client(conn_params),
+          logger,
+          conn_params,
+          config
+        )
       end
 
     end

data/lib/active_record/connection_adapters/postgis/databases.rake

@@ -2,17 +2,17 @@
 
 namespace :db do
   namespace :gis do
-    desc "Setup PostGIS data in the database"
+    desc 'Setup PostGIS data in the database'
     task setup: [:load_config] do
       environments = [Rails.env]
-      environments << "test" if Rails.env.development?
+      environments << 'test' if Rails.env.development?
       environments.each do |environment|
         ActiveRecord::Base.configurations
-          .configs_for(env_name: environment)
-          .reject { |env| env.config["database"].blank? }
-          .each do |env|
-            ActiveRecord::ConnectionAdapters::PostGIS::PostGISDatabaseTasks.new(env.config).setup_gis
-          end
+                          .configs_for(env_name: environment)
+                          .reject { |env| env.configuration_hash[:database].blank? }
+                          .each do |env|
+          ActiveRecord::ConnectionAdapters::PostGIS::PostGISDatabaseTasks.new(env).setup_gis
+        end
       end
     end
   end

data/lib/active_record/connection_adapters/postgis/oid/spatial.rb

@@ -4,16 +4,17 @@ module ActiveRecord
   module ConnectionAdapters
     module PostGIS
       module OID
+        # OID used to represent geometry/geography database types and attributes.
+        #
+        # Accepts `geo_type`, `srid`, `has_z`, `has_m`, and `geographic` as parameters.
+        # Responsible for parsing sql_types returned from the database and WKT features.
         class Spatial < Type::Value
-          # sql_type is a string that comes from the database definition
-          # examples:
-          #   "geometry(Point,4326)"
-          #   "geography(Point,4326)"
-          #   "geometry(Polygon,4326) NOT NULL"
-          #   "geometry(Geography,4326)"
-          def initialize(oid, sql_type)
-            @sql_type = sql_type
-            @geo_type, @srid, @has_z, @has_m = self.class.parse_sql_type(sql_type)
+          def initialize(geo_type: 'geometry', srid: 0, has_z: false, has_m: false, geographic: false)
+            @geo_type = geo_type
+            @srid = srid
+            @has_z = has_z
+            @has_m = has_m
+            @geographic = geographic
           end
 
           # sql_type: geometry, geometry(Point), geometry(Point,4326), ...
@@ -43,30 +44,24 @@ module ActiveRecord
               # otherType(a,b)
               geo_type = sql_type
             end
-            [geo_type, srid, has_z, has_m]
+            geographic = sql_type.match?(/geography/)
+
+            [geo_type, srid, has_z, has_m, geographic]
           end
 
           def spatial_factory
             @spatial_factory ||=
               RGeo::ActiveRecord::SpatialFactoryStore.instance.factory(
-                geo_type: @geo_type,
-                has_m:    @has_m,
-                has_z:    @has_z,
-                sql_type: @sql_type,
-                srid:     @srid
+                factory_attrs
               )
           end
 
-          def geographic?
-            @sql_type =~ /geography/
-          end
-
           def spatial?
             true
           end
 
           def type
-            geographic? ? :geography : :geometry
+            @geographic ? :geography : :geometry
           end
 
           # support setting an RGeo object or a WKT string
@@ -107,6 +102,16 @@ module ActiveRecord
               RGeo::WKRep::WKTParser.new(spatial_factory, support_ewkt: true, default_srid: @srid)
             end
           end
+
+          def factory_attrs
+            {
+              geo_type: @geo_type.underscore,
+              has_m: @has_m,
+              has_z: @has_z,
+              srid: @srid,
+              sql_type: type.to_s
+            }
+          end
         end
       end
     end

data/lib/active_record/connection_adapters/postgis/postgis_database_tasks.rb

@@ -4,7 +4,7 @@ module ActiveRecord  # :nodoc:
   module ConnectionAdapters  # :nodoc:
     module PostGIS  # :nodoc:
       class PostGISDatabaseTasks < ::ActiveRecord::Tasks::PostgreSQLDatabaseTasks  # :nodoc:
-        def initialize(config)
+        def initialize(db_config)
           super
           ensure_installation_configs
         end
@@ -14,19 +14,19 @@ module ActiveRecord  # :nodoc:
           if extension_names
             setup_gis_from_extension
           end
-          establish_connection(configuration)
+          establish_connection(db_config)
         end
 
         # Override to set the database owner and call setup_gis
         def create(master_established = false)
           establish_master_connection unless master_established
-          extra_configs = { "encoding" => encoding }
-          extra_configs["owner"] = username if has_su?
-          connection.create_database(configuration["database"], configuration.merge(extra_configs))
+          extra_configs = { encoding: encoding }
+          extra_configs[:owner] = username if has_su?
+          connection.create_database(db_config.database, configuration_hash.merge(extra_configs))
           setup_gis
         rescue ::ActiveRecord::StatementInvalid => error
           if /database .* already exists/ === error.message
-            raise ::ActiveRecord::Tasks::DatabaseAlreadyExists
+            raise ::ActiveRecord::DatabaseAlreadyExists
           else
             raise
           end
@@ -36,24 +36,24 @@ module ActiveRecord  # :nodoc:
 
         # Override to use su_username and su_password
         def establish_master_connection
-          establish_connection(configuration.merge(
-            "database"           => "postgres",
-            "password"           => su_password,
-            "schema_search_path" => "public",
-            "username"           => su_username
+          establish_connection(configuration_hash.merge(
+            database:           "postgres",
+            password:           su_password,
+            schema_search_path: "public",
+            username:           su_username
           ))
         end
 
         def establish_su_connection
-          establish_connection(configuration.merge(
-            "password"           => su_password,
-            "schema_search_path" => "public",
-            "username"           => su_username
+          establish_connection(configuration_hash.merge(
+            password:           su_password,
+            schema_search_path: "public",
+            username:           su_username
           ))
         end
 
         def username
-          @username ||= configuration["username"]
+          @username ||= configuration_hash[:username]
         end
 
         def quoted_username
@@ -61,29 +61,30 @@ module ActiveRecord  # :nodoc:
         end
 
         def password
-          @password ||= configuration["password"]
+          @password ||= configuration_hash[:password]
         end
 
         def su_username
-          @su_username ||= configuration["su_username"] || username
+          @su_username ||= configuration_hash.fetch(:su_username, username)
         end
 
         def su_password
-          @su_password ||= configuration["su_password"] || password
+          @su_password ||= configuration_hash.fetch(:su_password, password)
         end
 
         def has_su?
-          @has_su = configuration.include?("su_username") unless defined?(@has_su)
-          @has_su
+          return @has_su if defined?(@has_su)
+
+          @has_su = configuration_hash.include?(:su_username)
         end
 
         def search_path
-          @search_path ||= configuration["schema_search_path"].to_s.strip.split(",").map(&:strip)
+          @search_path ||= configuration_hash[:schema_search_path].to_s.strip.split(",").map(&:strip)
         end
 
         def extension_names
           @extension_names ||= begin
-            extensions = configuration["postgis_extension"]
+            extensions = configuration_hash[:postgis_extension]
             case extensions
             when ::String
               extensions.split(",")
@@ -96,11 +97,11 @@ module ActiveRecord  # :nodoc:
         end
 
         def ensure_installation_configs
-          if configuration["setup"] == "default" && !configuration["postgis_extension"]
+          if configuration_hash[:setup] == "default" && !configuration_hash[:postgis_extension]
             share_dir = `pg_config --sharedir`.strip rescue "/usr/share"
             control_file = ::File.expand_path("extension/postgis.control", share_dir)
             if ::File.readable?(control_file)
-              configuration["postgis_extension"] = "postgis"
+              @configuration_hash = configuration_hash.merge(postgis_extension: "postgis").freeze
             end
           end
         end
@@ -113,7 +114,7 @@ module ActiveRecord  # :nodoc:
               end
               connection.execute("CREATE EXTENSION IF NOT EXISTS #{extname} SCHEMA topology")
             else
-              if (postgis_schema = configuration["postgis_schema"])
+              if (postgis_schema = configuration_hash[:postgis_schema])
                 schema_clause = "WITH SCHEMA #{postgis_schema}"
                 unless schema_exists?(postgis_schema)
                   connection.execute("CREATE SCHEMA #{postgis_schema}")

data/lib/active_record/connection_adapters/postgis/schema_statements.rb

@@ -35,7 +35,7 @@ module ActiveRecord
         end
 
         # override
-        # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb#L523
+        # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb#L544
         #
         # returns Postgresql sql type string
         # examples:
@@ -74,8 +74,8 @@ module ActiveRecord
         end
 
         # override
-        def create_table_definition(*args)
-          PostGIS::TableDefinition.new(self, *args)
+        def create_table_definition(*args, **kwargs)
+          PostGIS::TableDefinition.new(self, *args, **kwargs)
         end
 
         # memoize hash of column infos for tables
@@ -85,8 +85,6 @@ module ActiveRecord
         end
 
         def initialize_type_map(map = type_map)
-          super
-
           %w(
             geography
             geometry
@@ -98,10 +96,19 @@ module ActiveRecord
             st_point
             st_polygon
           ).each do |geo_type|
-            map.register_type(geo_type) do |oid, _, sql_type|
-              OID::Spatial.new(oid, sql_type)
+            map.register_type(geo_type) do |_, _, sql_type|
+              # sql_type is a string that comes from the database definition
+              # examples:
+              #   "geometry(Point,4326)"
+              #   "geography(Point,4326)"
+              #   "geometry(Polygon,4326) NOT NULL"
+              #   "geometry(Geography,4326)"
+              geo_type, srid, has_z, has_m, geographic = OID::Spatial.parse_sql_type(sql_type)
+              OID::Spatial.new(geo_type: geo_type, srid: srid, has_z: has_z, has_m: has_m, geographic: geographic)
             end
           end
+
+          super
         end
       end
     end

data/lib/active_record/connection_adapters/postgis/spatial_column.rb

@@ -67,7 +67,7 @@ module ActiveRecord  # :nodoc:
         end
 
         def build_from_sql_type(sql_type)
-          geo_type, @srid, @has_z, @has_m = OID::Spatial.parse_sql_type(sql_type)
+          geo_type, @srid, @has_z, @has_m, @geographic = OID::Spatial.parse_sql_type(sql_type)
           set_geometric_type_from_name(geo_type)
         end
 

data/lib/active_record/connection_adapters/postgis/spatial_table_definition.rb

@@ -7,7 +7,7 @@ module ActiveRecord  # :nodoc:
         include ColumnMethods
 
         # super: https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
-        def new_column_definition(name, type, options)
+        def new_column_definition(name, type, **options)
           if (info = PostGISAdapter.spatial_column_options(type.to_sym))
             if (limit = options.delete(:limit))
               options.merge!(limit) if limit.is_a?(::Hash)
@@ -18,9 +18,9 @@ module ActiveRecord  # :nodoc:
 
             options[:limit] = ColumnDefinitionUtils.limit_from_options(geo_type, options)
             options[:spatial_type] = geo_type
-            column = super(name, base_type, options)
+            column = super(name, base_type, **options)
           else
-            column = super(name, type, options)
+            column = super(name, type, **options)
           end
 
           column

data/lib/active_record/connection_adapters/postgis/type.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostGIS
+      module Type
+        # Look for :postgis types first, then check for :postgresql
+        # types to simulate a kind of Type inheritance.
+        def lookup(*args, adapter: current_adapter_name, **kwargs)
+          super(*args, adapter: adapter, **kwargs)
+        rescue ArgumentError => e
+          raise e unless current_adapter_name == :postgis
+
+          super(*args, adapter: :postgresql, **kwargs)
+        end
+      end
+    end
+  end
+
+  # Type uses `class << self` syntax so we have to prepend to the singleton_class
+  Type.singleton_class.prepend(ActiveRecord::ConnectionAdapters::PostGIS::Type)
+end

data/lib/active_record/connection_adapters/postgis/version.rb

@@ -3,7 +3,7 @@
 module ActiveRecord
   module ConnectionAdapters
     module PostGIS
-      VERSION = "6.0.0"
+      VERSION = "7.1.0"
     end
   end
 end

data/lib/active_record/connection_adapters/postgis_adapter.rb

@@ -7,13 +7,7 @@
 
 require "rgeo/active_record"
 
-# autoload AbstractAdapter to avoid circular require and void context warnings
-module ActiveRecord
-  module ConnectionAdapters
-    AbstractAdapter
-  end
-end
-
+require "active_record/connection_adapters"
 require "active_record/connection_adapters/postgresql_adapter"
 require "active_record/connection_adapters/postgis/version"
 require "active_record/connection_adapters/postgis/column_methods"
@@ -24,6 +18,7 @@ require "active_record/connection_adapters/postgis/spatial_column"
 require "active_record/connection_adapters/postgis/arel_tosql"
 require "active_record/connection_adapters/postgis/setup"
 require "active_record/connection_adapters/postgis/oid/spatial"
+require "active_record/connection_adapters/postgis/type" # has to be after oid/*
 require "active_record/connection_adapters/postgis/create_connection"
 require "active_record/connection_adapters/postgis/postgis_database_tasks"
 
@@ -38,7 +33,7 @@ end
 module ActiveRecord
   module ConnectionAdapters
     class PostGISAdapter < PostgreSQLAdapter
-      include PostGIS::SchemaStatements
+      ADAPTER_NAME = 'PostGIS'
 
       SPATIAL_COLUMN_OPTIONS =
         {
@@ -57,22 +52,10 @@ module ActiveRecord
       # http://postgis.17.x6.nabble.com/Default-SRID-td5001115.html
       DEFAULT_SRID = 0
 
-      # def initialize(*args)
-      def initialize(connection, logger, connection_parameters, config)
-        super
-
-        @visitor = Arel::Visitors::PostGIS.new(self)
-        # copy from https://github.com/rails/rails/blob/6ece7df8d80c6d93db43878fa4c0278a0204072c/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb#L199
-        if self.class.type_cast_config_to_boolean(config.fetch(:prepared_statements) { true })
-          @prepared_statements = true
-          @visitor.extend(DetermineIfPreparableVisitor)
-        else
-          @prepared_statements = false
-        end
-      end
+      include PostGIS::SchemaStatements
 
-      def adapter_name
-        "PostGIS"
+      def arel_visitor # :nodoc:
+        Arel::Visitors::PostGIS.new(self)
       end
 
       def self.spatial_column_options(key)
@@ -105,6 +88,39 @@ module ActiveRecord
           super
         end
       end
+
+      # PostGIS specific types
+      [
+        :geography,
+        :geometry,
+        :geometry_collection,
+        :line_string,
+        :multi_line_string,
+        :multi_point,
+        :multi_polygon,
+        :st_point,
+        :st_polygon,
+      ].each do |geo_type|
+        ActiveRecord::Type.register(geo_type, PostGIS::OID::Spatial, adapter: :postgis)
+      end
     end
   end
 end
+
+# if using JRUBY, create ArJdbc::PostGIS module
+# and prepend it to the PostgreSQL adapter since
+# it is the default adapter_spec.
+# see: https://github.com/jruby/activerecord-jdbc-adapter/blob/master/lib/arjdbc/postgresql/adapter.rb#27
+if RUBY_ENGINE == "jruby"
+  module ArJdbc
+    module PostGIS
+      ADAPTER_NAME = 'PostGIS'
+
+      def adapter_name
+        ADAPTER_NAME
+      end
+    end
+  end
+
+  ArJdbc::PostgreSQL.prepend(ArJdbc::PostGIS)
+end

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-postgis-adapter
 version: !ruby/object:Gem::Version
-  version: 6.0.0
+  version: 7.1.0
 platform: ruby
 authors:
-- Daniel Azuma, Tee Parham
+- Daniel Azuma
+- Tee Parham
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-21 00:00:00.000000000 Z
+date: 2021-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,28 +17,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '6.1'
 - !ruby/object:Gem::Dependency
   name: rgeo-activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: 7.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: 7.0.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -97,7 +98,10 @@ dependencies:
 description: ActiveRecord connection adapter for PostGIS. It is based on the stock
   PostgreSQL adapter, and adds built-in support for the spatial extensions provided
   by PostGIS. It uses the RGeo library to represent spatial data in Ruby.
-email: dazuma@gmail.com, parhameter@gmail.com
+email:
+- dazuma@gmail.com
+- parhameter@gmail.com
+- kfdoggett@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -115,12 +119,13 @@ files:
 - lib/active_record/connection_adapters/postgis/spatial_column.rb
 - lib/active_record/connection_adapters/postgis/spatial_column_info.rb
 - lib/active_record/connection_adapters/postgis/spatial_table_definition.rb
+- lib/active_record/connection_adapters/postgis/type.rb
 - lib/active_record/connection_adapters/postgis/version.rb
 - lib/active_record/connection_adapters/postgis_adapter.rb
 - lib/activerecord-postgis-adapter.rb
 homepage: http://github.com/rgeo/activerecord-postgis-adapter
 licenses:
-- BSD
+- BSD-3-Clause
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -137,7 +142,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.4
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: ActiveRecord adapter for PostGIS, based on RGeo.