activerecord-postgis-adapter 5.1.0 → 6.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a032372c1d3d40f4808f7bc319c6d6c901612492c6702a882bf245749980b05
-  data.tar.gz: 730358e510e622e42d3ebf743a2e2a6366776a60303b205b7d8fd7fa4743f6bd
+  metadata.gz: 978d238ad317f3e43d498f237d63573aa71291fe2485f2b35b0013e829bc0727
+  data.tar.gz: 2520a77cc0070c3afaa4fdba2d771ba05e9fb569186e35a4e92dd24816f43ae3
 SHA512:
-  metadata.gz: e2bd49f0d89b23776c003411c9c71e6d5882554095a78fc25e8adf6f94d4c06cded265db02881261a0b563f28a92ff2abe50df38f237e185ec628a69728673d7
-  data.tar.gz: 4f2a8607f4561af4400e00f2a44bf65de457267c6aa74ed6432da8633efd2e1dd1ae14151b4b00f0f6f82895e2c97948e2ed8a2edce64ae4981d219dd878a5d5
+  metadata.gz: 5a9e6472022e69fbaf2d07dd76f98cdf97c440f6009a26ccd59d1b580ca4ff3590b889e0c1afe9addb2f518e88decec6e1107a5b0301c12ce19b9df5e22073ff
+  data.tar.gz: 102a2b33b86298a52ae3dac860bf75d0531ad32974b914f2e5ebc154d6d22c21c371770d6c649fa6abb7654984c5e3e3d4bdb6cab106ffb0304cd83f15f8e529

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Arel  # :nodoc:
   module Visitors  # :nodoc:
     # Different super-class under JRuby JDBC adapter.

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

@@ -1,46 +1,48 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostGIS
       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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 if RUBY_ENGINE == "jruby"
   require "active_record/connection_adapters/jdbcpostgresql_adapter"
 else
@@ -29,13 +31,18 @@ module ActiveRecord  # :nodoc:
         conn_params[:user] = conn_params.delete(:username) if conn_params[:username]
         conn_params[:dbname] = conn_params.delete(:database) if conn_params[:database]
 
-        # Forward only valid config params to PGconn.connect.
+        # Forward only valid config params to PG.connect
         valid_conn_param_keys = PG::Connection.conndefaults_hash.keys + [:requiressl]
         conn_params.slice!(*valid_conn_param_keys)
 
-        # The postgres drivers don't allow the creation of an unconnected PGconn object,
-        # so just pass a nil connection object for the time being.
-        ConnectionAdapters::PostGISAdapter.new(nil, logger, conn_params, config)
+        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
       end
 
     end

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

@@ -1,16 +1,19 @@
+# frozen_string_literal: true
+
 namespace :db do
   namespace :gis do
     desc "Setup PostGIS data in the database"
     task setup: [:load_config] do
       environments = [Rails.env]
       environments << "test" if Rails.env.development?
-      ActiveRecord::Base.configurations
-        .values_at(*environments)
-        .compact
-        .reject { |config| config["database"].blank? }
-        .each do |config|
-          ActiveRecord::ConnectionAdapters::PostGIS::PostGISDatabaseTasks.new(config).setup_gis
-        end
+      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
+      end
     end
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostGIS
@@ -25,23 +27,20 @@ module ActiveRecord
             geo_type, srid, has_z, has_m = nil, 0, false, false
 
             if sql_type =~ /(geography|geometry)\((.*)\)$/i
+              # geometry(Point)
               # geometry(Point,4326)
               params = Regexp.last_match(2).split(",")
-              if params.size > 1
-                if params.first =~ /([a-z]+[^zm])(z?)(m?)/i
-                  has_z = Regexp.last_match(2).length > 0
-                  has_m = Regexp.last_match(3).length > 0
-                  geo_type = Regexp.last_match(1)
-                end
-                if params.last =~ /(\d+)/
-                  srid = Regexp.last_match(1).to_i
-                end
-              else
-                # geometry(Point)
-                geo_type = params[0]
+              if params.first =~ /([a-z]+[^zm])(z?)(m?)/i
+                has_z = Regexp.last_match(2).length > 0
+                has_m = Regexp.last_match(3).length > 0
+                geo_type = Regexp.last_match(1)
+              end
+              if params.last =~ /(\d+)/
+                srid = Regexp.last_match(1).to_i
               end
             else
               # geometry
+              # otherType(a,b)
               geo_type = sql_type
             end
             [geo_type, srid, has_z, has_m]

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord  # :nodoc:
   module ConnectionAdapters  # :nodoc:
     module PostGIS  # :nodoc:
@@ -106,7 +108,9 @@ module ActiveRecord  # :nodoc:
         def setup_gis_from_extension
           extension_names.each do |extname|
             if extname == "postgis_topology"
-              raise ::ArgumentError, "'topology' must be in schema_search_path for postgis_topology" unless search_path.include?("topology")
+              unless search_path.include?("topology")
+                raise ArgumentError, "'topology' must be in schema_search_path for postgis_topology"
+              end
               connection.execute("CREATE EXTENSION IF NOT EXISTS #{extname} SCHEMA topology")
             else
               if (postgis_schema = configuration["postgis_schema"])
@@ -125,7 +129,9 @@ module ActiveRecord  # :nodoc:
         end
 
         def schema_exists?(schema_name)
-          connection.execute("SELECT schema_name FROM information_schema.schemata WHERE schema_name = '#{schema_name}'").any?
+          connection.execute(
+            "SELECT schema_name FROM information_schema.schemata WHERE schema_name = '#{schema_name}'"
+          ).any?
         end
       end
 

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord  # :nodoc:
   module ConnectionAdapters  # :nodoc:
     module PostGIS  # :nodoc:

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

@@ -1,45 +1,41 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostGIS
       module SchemaStatements
         # override
-        # pass table_name to #new_column
-        def columns(table_name)
-          # Limit, precision, and scale are all handled by the superclass.
-          column_definitions(table_name).map do |column_name, type, default, notnull, oid, fmod, collation|
-            oid = oid.to_i
-            fmod = fmod.to_i
-            type_metadata = fetch_type_metadata(column_name, type, oid, fmod)
-            cast_type = get_oid_type(oid.to_i, fmod.to_i, column_name, type)
-            default_value = extract_value_from_default(default)
-
-            default_function = extract_default_function(default_value, default)
-            new_column(table_name, column_name, default_value, cast_type, type_metadata, !notnull, default_function, collation)
-          end
-        end
+        # https://github.com/rails/rails/blob/6-0-stable/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb#L624
+        # Create a SpatialColumn instead of a PostgreSQL::Column
+        def new_column_from_field(table_name, field)
+          column_name, type, default, notnull, oid, fmod, collation, comment = field
+          type_metadata = fetch_type_metadata(column_name, type, oid.to_i, fmod.to_i)
+          default_value = extract_value_from_default(default)
+          default_function = extract_default_function(default_value, default)
 
-        # override
-        def new_column(table_name, column_name, default, cast_type, sql_type_metadata = nil, null = true, default_function = nil, collation = nil)
-          # JDBC gets true/false in Rails 4, where other platforms get 't'/'f' strings.
-          if null.is_a?(String)
-            null = (null == "t")
-          end
+          serial =
+            if (match = default_function&.match(/\Anextval\('"?(?<sequence_name>.+_(?<suffix>seq\d*))"?'::regclass\)\z/))
+              sequence_name_from_parts(table_name, column_name, match[:suffix]) == match[:sequence_name]
+            end
 
-          column_info = spatial_column_info(table_name).get(column_name, sql_type_metadata.sql_type)
+          # {:dimension=>2, :has_m=>false, :has_z=>false, :name=>"latlon", :srid=>0, :type=>"GEOMETRY"}
+          spatial = spatial_column_info(table_name).get(column_name, type_metadata.sql_type)
 
-          SpatialColumn.new(column_name,
-                            default,
-                            sql_type_metadata,
-                            null,
-                            table_name,
-                            default_function,
-                            collation,
-                            cast_type,
-                            column_info)
+          SpatialColumn.new(
+            column_name,
+            default_value,
+            type_metadata,
+            !notnull,
+            default_function,
+            collation: collation,
+            comment: comment.presence,
+            serial: serial,
+            spatial: spatial
+          )
         end
 
         # override
-        # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb#L583
+        # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb#L544
         #
         # returns Postgresql sql type string
         # examples:
@@ -49,12 +45,12 @@ module ActiveRecord
         # note: type alone is not enough to detect the sql type,
         # so `limit` is used to pass the additional information. :(
         #
-        # type_to_sql(:geography, "Point,4326")
+        # type_to_sql(:geography, limit: "Point,4326")
         # => "geography(Point,4326)"
-        def type_to_sql(type, options = {})
-          case type
-          when :geometry, :geography
-            "#{type}(#{options[:limit]})"
+        def type_to_sql(type, limit: nil, precision: nil, scale: nil, array: nil, **)
+          case type.to_s
+          when "geometry", "geography"
+            "#{type}(#{limit})"
           else
             super
           end
@@ -78,8 +74,8 @@ module ActiveRecord
         end
 
         # override
-        def create_table_definition(*args)
-          PostGIS::TableDefinition.new(*args)
+        def create_table_definition(*args, **kwargs)
+          PostGIS::TableDefinition.new(self, *args, **kwargs)
         end
 
         # memoize hash of column infos for tables
@@ -89,8 +85,6 @@ module ActiveRecord
         end
 
         def initialize_type_map(map = type_map)
-          super
-
           %w(
             geography
             geometry
@@ -106,6 +100,8 @@ module ActiveRecord
               OID::Spatial.new(oid, sql_type)
             end
           end
+
+          super
         end
       end
     end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord  # :nodoc:
   module ConnectionAdapters  # :nodoc:
     module PostGIS  # :nodoc:

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord  # :nodoc:
   module ConnectionAdapters  # :nodoc:
     module PostGIS  # :nodoc:
@@ -5,18 +7,17 @@ module ActiveRecord  # :nodoc:
         # sql_type examples:
         #   "Geometry(Point,4326)"
         #   "Geography(Point,4326)"
-        # cast_type example classes:
-        #   OID::Spatial
-        #   OID::Integer
-        def initialize(name, default, sql_type_metadata = nil, null = true, table_name = nil, default_function = nil, collation = nil, cast_type = nil, opts = nil)
-          @cast_type = cast_type
+        def initialize(name, default, sql_type_metadata = nil, null = true,
+                       default_function = nil, collation: nil, comment: nil,
+                       serial: nil, spatial: nil)
+          @sql_type_metadata = sql_type_metadata
           @geographic = !!(sql_type_metadata.sql_type =~ /geography\(/i)
-          if opts
+          if spatial
             # This case comes from an entry in the geometry_columns table
-            set_geometric_type_from_name(opts[:type])
-            @srid = opts[:srid].to_i
-            @has_z = !!opts[:has_z]
-            @has_m = !!opts[:has_m]
+            set_geometric_type_from_name(spatial[:type])
+            @srid = spatial[:srid].to_i
+            @has_z = !!spatial[:has_z]
+            @has_m = !!spatial[:has_m]
           elsif @geographic
             # Geographic type information is embedded in the SQL type
             @srid = 4326
@@ -29,7 +30,8 @@ module ActiveRecord  # :nodoc:
             # @geometric_type = geo_type_from_sql_type(sql_type)
             build_from_sql_type(sql_type_metadata.sql_type)
           end
-          super(name, default, sql_type_metadata, null, table_name, default_function, collation)
+          super(name, default, sql_type_metadata, null, default_function,
+                collation: collation, comment: comment, serial: serial)
           if spatial?
             if @srid
               @limit = { srid: @srid, type: to_type_name(geometric_type) }
@@ -51,15 +53,11 @@ module ActiveRecord  # :nodoc:
         alias :has_m? :has_m
 
         def limit
-          if spatial?
-            @limit
-          else
-            super
-          end
+          spatial? ? @limit : super
         end
 
         def spatial?
-          @cast_type.respond_to?(:spatial?) && @cast_type.spatial?
+          %i[geometry geography].include?(@sql_type_metadata.type)
         end
 
         private

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord  # :nodoc:
   module ConnectionAdapters  # :nodoc:
     module PostGIS
@@ -9,7 +11,9 @@ module ActiveRecord  # :nodoc:
         end
 
         def all
-          info = @adapter.query("SELECT f_geometry_column,coord_dimension,srid,type FROM geometry_columns WHERE f_table_name='#{@table_name}'")
+          info = @adapter.query(
+            "SELECT f_geometry_column,coord_dimension,srid,type FROM geometry_columns WHERE f_table_name='#{@table_name}'"
+          )
           result = {}
           info.each do |row|
             name = row[0]

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord  # :nodoc:
   module ConnectionAdapters  # :nodoc:
     module PostGIS  # :nodoc:
@@ -5,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)
@@ -16,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/version.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostGIS
-      VERSION = "5.1.0"
+      VERSION = "6.0.1"
     end
   end
 end

data/lib/active_record/connection_adapters/postgis_adapter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # The activerecord-postgis-adapter gem installs the *postgis*
 # connection adapter into ActiveRecord.
 
@@ -36,7 +38,7 @@ end
 module ActiveRecord
   module ConnectionAdapters
     class PostGISAdapter < PostgreSQLAdapter
-      include PostGIS::SchemaStatements
+      ADAPTER_NAME = 'PostGIS'.freeze
 
       SPATIAL_COLUMN_OPTIONS =
         {
@@ -55,22 +57,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".freeze
+      def arel_visitor # :nodoc:
+        Arel::Visitors::PostGIS.new(self)
       end
 
       def self.spatial_column_options(key)

data/lib/activerecord-postgis-adapter.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require "active_record/connection_adapters/postgis_adapter"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-postgis-adapter
 version: !ruby/object:Gem::Version
-  version: 5.1.0
+  version: 6.0.1
 platform: ruby
 authors:
 - Daniel Azuma, Tee Parham
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-02 00:00:00.000000000 Z
+date: 2020-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: rgeo-activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -130,15 +130,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.2.2
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.0
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: ActiveRecord adapter for PostGIS, based on RGeo.