activerecord-postgis-adapter 1.0.0 → 1.1.0

data/lib/active_record/connection_adapters/postgis_adapter/rails4/postgis_database_tasks.rb

@@ -1,18 +1,13 @@
 module ActiveRecord  # :nodoc:
-
   module ConnectionAdapters  # :nodoc:
-
     module PostGISAdapter  # :nodoc:
-
       class PostGISDatabaseTasks < ::ActiveRecord::Tasks::PostgreSQLDatabaseTasks  # :nodoc:
 
-
-        def initialize(config_)
+        def initialize(config)
           super
           ensure_installation_configs
         end
 
-
         def setup_gis
           establish_su_connection
           setup_gis_schemas
@@ -27,43 +22,36 @@ module ActiveRecord  # :nodoc:
           establish_connection(configuration)
         end
 
-
         # Overridden 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_))
+        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))
           setup_gis
-        rescue ::ActiveRecord::StatementInvalid => error_
-          if /database .* already exists/ === error_.message
+        rescue ::ActiveRecord::StatementInvalid => error
+          if /database .* already exists/ === error.message
             raise ::ActiveRecord::Tasks::DatabaseAlreadyExists
           else
             raise
           end
         end
 
-
         # Overridden to remove postgis schema
-
-        def structure_dump(filename_)
+        def structure_dump(filename)
           set_psql_env
-          search_path_ = search_path.dup
-          search_path_.delete('postgis')
-          search_path_ = ['public'] if search_path_.length == 0
-          search_path_clause_ = search_path_.map{ |part_| "--schema=#{::Shellwords.escape(part_)}" }.join(' ')
-          command_ = "pg_dump -i -s -x -O -f #{::Shellwords.escape(filename_)} #{search_path_clause_} #{::Shellwords.escape(configuration['database'])}"
-          raise 'Error dumping database' unless ::Kernel.system(command_)
-          ::File.open(filename_, "a") { |f_| f_ << "SET search_path TO #{ActiveRecord::Base.connection.schema_search_path};\n\n" }
+          _search_path = search_path.dup
+          _search_path.delete('postgis')
+          _search_path = ['public'] if _search_path.length == 0
+          search_path_clause_ = _search_path.map{ |part_| "--schema=#{::Shellwords.escape(part_)}" }.join(' ')
+          command = "pg_dump -i -s -x -O -f #{::Shellwords.escape(filename)} #{search_path_clause_} #{::Shellwords.escape(configuration['database'])}"
+          raise 'Error dumping database' unless ::Kernel.system(command)
+          ::File.open(filename, "a") { |f_| f_ << "SET search_path TO #{ActiveRecord::Base.connection.schema_search_path};\n\n" }
         end
 
-
         private
 
-
         # Overridden to use su_username and su_password
-
         def establish_master_connection
           establish_connection(configuration.merge(
             'database' => 'postgres',
@@ -72,7 +60,6 @@ module ActiveRecord  # :nodoc:
             'password' => su_password))
         end
 
-
         def establish_su_connection
           establish_connection(configuration.merge(
             'schema_search_path' => 'public',
@@ -80,7 +67,6 @@ module ActiveRecord  # :nodoc:
             'password' => su_password))
         end
 
-
         def username
           @username ||= configuration['username']
         end
@@ -133,7 +119,6 @@ module ActiveRecord  # :nodoc:
           end
         end
 
-
         def ensure_installation_configs
           if configuration['setup'] == 'default' && !configuration['script_dir'] && !configuration['postgis_extension']
             share_dir_ = `pg_config --sharedir`.strip rescue '/usr/share'
@@ -147,7 +132,6 @@ module ActiveRecord  # :nodoc:
           end
         end
 
-
         def setup_gis_schemas
           auth_ = has_su? ? " AUTHORIZATION #{quoted_username}" : ''
           search_path.each do |schema_|
@@ -157,26 +141,23 @@ module ActiveRecord  # :nodoc:
           end
         end
 
-
         def setup_gis_from_extension
-          extension_names.each do |extname_|
-            if extname_ == 'postgis_topology'
+          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')
-              connection.execute("CREATE EXTENSION IF NOT EXISTS #{extname_} SCHEMA topology")
+              connection.execute("CREATE EXTENSION IF NOT EXISTS #{extname} SCHEMA topology")
             else
-              connection.execute("CREATE EXTENSION IF NOT EXISTS #{extname_} SCHEMA #{postgis_schema}")
+              connection.execute("CREATE EXTENSION IF NOT EXISTS #{extname} SCHEMA #{postgis_schema}")
             end
           end
         end
 
-
         def setup_gis_from_script_dir
           connection.execute("SET search_path TO #{postgis_schema}")
           connection.execute(::File.read(::File.expand_path('postgis.sql', script_dir)))
           connection.execute(::File.read(::File.expand_path('spatial_ref_sys.sql', script_dir)))
         end
 
-
         def setup_gis_grant_privileges
           connection.execute("GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA #{postgis_schema} TO #{quoted_username}")
           connection.execute("GRANT ALL PRIVILEGES ON ALL FUNCTIONS IN SCHEMA #{postgis_schema} TO #{quoted_username}")
@@ -190,15 +171,10 @@ module ActiveRecord  # :nodoc:
           connection.execute("ALTER TABLE #{postgis_schema}.spatial_ref_sys OWNER TO #{quoted_username}")
         end
 
-
       end
 
-
       ::ActiveRecord::Tasks::DatabaseTasks.register_task(/postgis/, PostGISDatabaseTasks)
 
-
     end
-
   end
-
 end

data/lib/active_record/connection_adapters/postgis_adapter/rails4/spatial_column.rb

@@ -1,42 +1,37 @@
 module ActiveRecord  # :nodoc:
-
   module ConnectionAdapters  # :nodoc:
-
     module PostGISAdapter  # :nodoc:
-
-
       class SpatialColumn < ConnectionAdapters::PostgreSQLColumn  # :nodoc:
 
-
-        def initialize(factory_settings_, table_name_, name_, default_, oid_type_, sql_type_=nil, null_=true, opts_=nil)
-          @factory_settings = factory_settings_
-          @table_name = table_name_
-          @geographic = !!(sql_type_ =~ /geography/i)
-          if opts_
+        def initialize(factory_settings, table_name, name, default, oid_type, sql_type=nil, null=true, opts=nil)
+          @factory_settings = factory_settings
+          @table_name = table_name
+          @geographic = !!(sql_type =~ /geography/i)
+          if opts
             # This case comes from an entry in the geometry_columns table
-            @geometric_type = ::RGeo::ActiveRecord.geometric_type_from_name(opts_[:type]) || ::RGeo::Feature::Geometry
-            @srid = opts_[:srid].to_i
-            @has_z = !!opts_[:has_z]
-            @has_m = !!opts_[:has_m]
+            @geometric_type = ::RGeo::ActiveRecord.geometric_type_from_name(opts[:type]) || ::RGeo::Feature::Geometry
+            @srid = opts[:srid].to_i
+            @has_z = !!opts[:has_z]
+            @has_m = !!opts[:has_m]
           elsif @geographic
             # Geographic type information is embedded in the SQL type
             @geometric_type = ::RGeo::Feature::Geometry
             @srid = 4326
             @has_z = @has_m = false
-            if sql_type_ =~ /geography\((.*)\)$/i
-              params_ = $1.split(',')
-              if params_.size >= 2
-                if params_.first =~ /([a-z]+[^zm])(z?)(m?)/i
+            if sql_type =~ /geography\((.*)\)$/i
+              params = $1.split(',')
+              if params.size >= 2
+                if params.first =~ /([a-z]+[^zm])(z?)(m?)/i
                   @has_z = $2.length > 0
                   @has_m = $3.length > 0
                   @geometric_type = ::RGeo::ActiveRecord.geometric_type_from_name($1)
                 end
-                if params_.last =~ /(\d+)/
+                if params.last =~ /(\d+)/
                   @srid = $1.to_i
                 end
               end
             end
-          elsif sql_type_ =~ /geography|geometry|point|linestring|polygon/i
+          elsif sql_type =~ /geography|geometry|point|linestring|polygon/i
             # Just in case there is a geometry column with no geometry_columns entry.
             @geometric_type = ::RGeo::Feature::Geometry
             @srid = @has_z = @has_m = nil
@@ -44,7 +39,7 @@ module ActiveRecord  # :nodoc:
             # Non-spatial column
             @geometric_type = @has_z = @has_m = @srid = nil
           end
-          super(name_, default_, oid_type_, sql_type_, null_)
+          super(name, default, oid_type, sql_type, null)
           if spatial?
             if @srid
               @limit = {:srid => @srid, :type => @geometric_type.type_name.underscore}
@@ -57,7 +52,6 @@ module ActiveRecord  # :nodoc:
           end
         end
 
-
         attr_reader :geographic
         attr_reader :srid
         attr_reader :geometric_type
@@ -68,61 +62,54 @@ module ActiveRecord  # :nodoc:
         alias_method :has_z?, :has_z
         alias_method :has_m?, :has_m
 
-
         def spatial?
           type == :spatial || type == :geography
         end
 
-
         def has_spatial_constraints?
           !@srid.nil?
         end
 
-
         def klass
           spatial? ? ::RGeo::Feature::Geometry : super
         end
 
-
-        def type_cast(value_)
+        def type_cast(value)
           if spatial?
-            SpatialColumn.convert_to_geometry(value_, @factory_settings, @table_name, name,
+            SpatialColumn.convert_to_geometry(value, @factory_settings, @table_name, name,
               @geographic, @srid, @has_z, @has_m)
           else
             super
           end
         end
 
-
         private
 
-
-        def simplified_type(sql_type_)
-          sql_type_ =~ /geography|geometry|point|linestring|polygon/i ? :spatial : super
+        def simplified_type(sql_type)
+          sql_type =~ /geography|geometry|point|linestring|polygon/i ? :spatial : super
         end
 
-
-        def self.convert_to_geometry(input_, factory_settings_, table_name_, column_, geographic_, srid_, has_z_, has_m_)
-          if srid_
-            constraints_ = {:geographic => geographic_, :has_z_coordinate => has_z_,
-              :has_m_coordinate => has_m_, :srid => srid_}
+        def self.convert_to_geometry(input, factory_settings, table_name, column, geographic, srid, has_z, has_m)
+          if srid
+            constraints = {:geographic => geographic, :has_z_coordinate => has_z,
+              :has_m_coordinate => has_m, :srid => srid}
           else
-            constraints_ = nil
+            constraints = nil
           end
-          if ::RGeo::Feature::Geometry === input_
-            factory_ = factory_settings_.get_column_factory(table_name_, column_, constraints_)
-            ::RGeo::Feature.cast(input_, factory_) rescue nil
-          elsif input_.respond_to?(:to_str)
-            input_ = input_.to_str
-            if input_.length == 0
+          if ::RGeo::Feature::Geometry === input
+            factory = factory_settings.get_column_factory(table_name, column, constraints)
+            ::RGeo::Feature.cast(input, factory) rescue nil
+          elsif input.respond_to?(:to_str)
+            input = input.to_str
+            if input.length == 0
               nil
             else
-              factory_ = factory_settings_.get_column_factory(table_name_, column_, constraints_)
-              marker_ = input_[0,1]
-              if marker_ == "\x00" || marker_ == "\x01" || input_[0,4] =~ /[0-9a-fA-F]{4}/
-                ::RGeo::WKRep::WKBParser.new(factory_, :support_ewkb => true).parse(input_) rescue nil
+              factory = factory_settings.get_column_factory(table_name, column, constraints)
+              marker = input[0,1]
+              if marker == "\x00" || marker == "\x01" || input[0,4] =~ /[0-9a-fA-F]{4}/
+                ::RGeo::WKRep::WKBParser.new(factory, :support_ewkb => true).parse(input) rescue nil
               else
-                ::RGeo::WKRep::WKTParser.new(factory_, :support_ewkt => true).parse(input_) rescue nil
+                ::RGeo::WKRep::WKTParser.new(factory, :support_ewkt => true).parse(input) rescue nil
               end
             end
           else
@@ -130,22 +117,19 @@ module ActiveRecord  # :nodoc:
           end
         end
 
-
       end
 
-
       # Register spatial types with the postgres OID mechanism
       # so we can recognize custom columns coming from the database.
-
       class SpatialOID < PostgreSQLAdapter::OID::Type  # :nodoc:
 
-        def initialize(factory_generator_)
-          @factory_generator = factory_generator_
+        def initialize(factory_generator)
+          @factory_generator = factory_generator
         end
 
-        def type_cast(value_)
-          return if value_.nil?
-          ::RGeo::WKRep::WKBParser.new(@factory_generator, :support_ewkb => true).parse(value_) rescue nil
+        def type_cast(value)
+          return if value.nil?
+          ::RGeo::WKRep::WKBParser.new(@factory_generator, :support_ewkb => true).parse(value) rescue nil
         end
 
       end
@@ -153,31 +137,26 @@ module ActiveRecord  # :nodoc:
       PostgreSQLAdapter::OID.register_type('geometry', SpatialOID.new(nil))
       PostgreSQLAdapter::OID.register_type('geography', SpatialOID.new(::RGeo::Geographic.method(:spherical_factory)))
 
-
       # This is a hack to ActiveRecord::ModelSchema. We have to "decorate" the decorate_columns
       # method to apply class-specific customizations to spatial type casting.
-
       module DecorateColumnsModification  # :nodoc:
 
-        def decorate_columns(columns_hash_)
-          columns_hash_ = super(columns_hash_)
-          return unless columns_hash_
+        def decorate_columns(columns_hash)
+          columns_hash = super(columns_hash)
+          return unless columns_hash
           canonical_columns_ = self.columns_hash
-          columns_hash_.each do |name_, col_|
-            if col_.is_a?(SpatialOID) && (canonical_ = canonical_columns_[name_]) && canonical_.spatial?
-              columns_hash_[name_] = canonical_
+          columns_hash.each do |name, col|
+            if col.is_a?(SpatialOID) && (canonical = canonical_columns_[name]) && canonical.spatial?
+              columns_hash[name] = canonical
             end
           end
-          columns_hash_
+          columns_hash
         end
 
       end
 
       ::ActiveRecord::Base.extend(DecorateColumnsModification)
 
-
     end
-
   end
-
 end

data/lib/active_record/connection_adapters/postgis_adapter/rails4/spatial_table_definition.rb

@@ -1,62 +1,63 @@
 module ActiveRecord  # :nodoc:
-
   module ConnectionAdapters  # :nodoc:
-
     module PostGISAdapter  # :nodoc:
-
-
       class TableDefinition < ConnectionAdapters::PostgreSQLAdapter::TableDefinition  # :nodoc:
 
-        def initialize(types_, name_, temporary_, options_, as_, base_)
-          @base = base_
-          @spatial_columns_hash = {}
-          super(types_, name_, temporary_, options_, as_)
+        if ActiveRecord::VERSION::STRING > '4.1'
+          def initialize(types, name, temporary, options, as, base)
+            @base = base
+            @spatial_columns_hash = {}
+            super(types, name, temporary, options, as)
+          end
+        else
+          def initialize(types, name, temporary, options, base)
+            @base = base
+            @spatial_columns_hash = {}
+            super(types, name, temporary, options)
+          end
         end
 
-        def column(name_, type_, options_={})
-          if (info_ = @base.spatial_column_constructor(type_.to_sym))
-            type_ = options_[:type] || info_[:type] || type_
-            if type_.to_s == 'geometry' &&
-              (options_[:no_constraints] ||
-               options_[:limit].is_a?(::Hash) && options_[:limit][:no_constraints])
-            then
-              options_.delete(:limit)
+        def column(name, type, options={})
+          if (info = @base.spatial_column_constructor(type.to_sym))
+            type = options[:type] || info[:type] || type
+            if type.to_s == 'geometry' && (options[:no_constraints] || options[:limit].is_a?(::Hash) && options[:limit][:no_constraints])
+              options.delete(:limit)
             else
-              options_[:type] = type_
-              type_ = :spatial
+              options[:type] = type
+              type = :spatial
             end
           end
-          if type_ == :spatial
-            if (limit_ = options_.delete(:limit))
-              options_.merge!(limit_) if limit_.is_a?(::Hash)
+          if type == :spatial
+            if (limit = options.delete(:limit))
+              options.merge!(limit) if limit.is_a?(::Hash)
             end
-            if options_[:geographic]
-              type_ = :geography
-              spatial_type_ = (options_[:type] || 'geometry').to_s.upcase.gsub('_', '')
-              spatial_type_ << 'Z' if options_[:has_z]
-              spatial_type_ << 'M' if options_[:has_m]
-              options_[:limit] = "#{spatial_type_},#{options_[:srid] || 4326}"
+            if options[:geographic]
+              type = :geography
+              spatial_type = (options[:type] || 'geometry').to_s.upcase.gsub('_', '')
+              spatial_type << 'Z' if options[:has_z]
+              spatial_type << 'M' if options[:has_m]
+              options[:limit] = "#{spatial_type},#{options[:srid] || 4326}"
             end
-            name_ = name_.to_s
-            if primary_key_column_name == name_
-              raise ArgumentError, "you can't redefine the primary key column '#{name_}'. To define a custom primary key, pass { id: false } to create_table."
+            name = name.to_s
+            if primary_key_column_name == name
+              raise ArgumentError, "you can't redefine the primary key column '#{name}'. To define a custom primary key, pass { id: false } to create_table."
             end
-            col_ = new_column_definition(name_, type_, options_)
-            col_.set_spatial_type(options_[:type])
-            col_.set_geographic(options_[:geographic])
-            col_.set_srid(options_[:srid])
-            col_.set_has_z(options_[:has_z])
-            col_.set_has_m(options_[:has_m])
-            (col_.geographic? ? @columns_hash : @spatial_columns_hash)[name_] = col_
+            column = new_column_definition(name, type, options)
+            column.set_spatial_type(options[:type])
+            column.set_geographic(options[:geographic])
+            column.set_srid(options[:srid])
+            column.set_has_z(options[:has_z])
+            column.set_has_m(options[:has_m])
+            (column.geographic? ? @columns_hash : @spatial_columns_hash)[name] = column
           else
-            super(name_, type_, options_)
+            super(name, type, options)
           end
           self
         end
 
-        def create_column_definition(name_, type_)
-          if type_ == :spatial || type_ == :geography
-            PostGISAdapter::ColumnDefinition.new(name_, type_)
+        def create_column_definition(name, type)
+          if type == :spatial || type == :geography
+            PostGISAdapter::ColumnDefinition.new(name, type)
           else
             super
           end
@@ -68,7 +69,6 @@ module ActiveRecord  # :nodoc:
 
       end
 
-
       class ColumnDefinition < ConnectionAdapters::ColumnDefinition  # :nodoc:
 
         def spatial_type
@@ -95,31 +95,28 @@ module ActiveRecord  # :nodoc:
           @has_m
         end
 
-        def set_geographic(value_)
-          @geographic = value_ ? true : false
+        def set_geographic(value)
+          @geographic = !!value
         end
 
-        def set_spatial_type(value_)
-          @spatial_type = value_.to_s
+        def set_spatial_type(value)
+          @spatial_type = value.to_s
         end
 
-        def set_srid(value_)
-          @srid = value_
+        def set_srid(value)
+          @srid = value
         end
 
-        def set_has_z(value_)
-          @has_z = value_ ? true : false
+        def set_has_z(value)
+          @has_z = !!value
         end
 
-        def set_has_m(value_)
-          @has_m = value_ ? true : false
+        def set_has_m(value)
+          @has_m = !!value
         end
 
       end
 
-
     end
-
   end
-
 end