{"id":13558125,"url":"https://github.com/rgeo/activerecord-postgis-adapter","last_synced_at":"2025-05-14T05:10:50.655Z","repository":{"id":417581,"uuid":"1145192","full_name":"rgeo/activerecord-postgis-adapter","owner":"rgeo","description":"ActiveRecord connection adapter for PostGIS, based on postgresql and rgeo","archived":false,"fork":false,"pushed_at":"2025-04-25T21:55:47.000Z","size":1300,"stargazers_count":905,"open_issues_count":13,"forks_count":252,"subscribers_count":33,"default_branch":"master","last_synced_at":"2025-05-04T05:02:06.547Z","etag":null,"topics":["activerecord","postgis","postgresql","rails","rgeo","ruby"],"latest_commit_sha":null,"homepage":"","language":"Ruby","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"other","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/rgeo.png","metadata":{"files":{"readme":"README.md","changelog":"History.md","contributing":"CONTRIBUTING.md","funding":".github/FUNDING.yml","license":"LICENSE.txt","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null},"funding":{"open_collective":"rgeo"}},"created_at":"2010-12-07T01:47:35.000Z","updated_at":"2025-04-25T21:55:51.000Z","dependencies_parsed_at":"2023-07-05T15:03:27.443Z","dependency_job_id":"d491f2dd-3000-4841-a567-f4413b52137a","html_url":"https://github.com/rgeo/activerecord-postgis-adapter","commit_stats":{"total_commits":712,"total_committers":65,"mean_commits":"10.953846153846154","dds":0.4143258426966292,"last_synced_commit":"1290093838bfcbab4688463ee45a7ae9c43d3ffe"},"previous_names":["dazuma/activerecord-postgis-adapter"],"tags_count":85,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/rgeo%2Factiverecord-postgis-adapter","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/rgeo%2Factiverecord-postgis-adapter/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/rgeo%2Factiverecord-postgis-adapter/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/rgeo%2Factiverecord-postgis-adapter/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/rgeo","download_url":"https://codeload.github.com/rgeo/activerecord-postgis-adapter/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":253433682,"owners_count":21907775,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["activerecord","postgis","postgresql","rails","rgeo","ruby"],"created_at":"2024-08-01T12:04:45.639Z","updated_at":"2025-05-14T05:10:50.628Z","avatar_url":"https://github.com/rgeo.png","language":"Ruby","funding_links":["https://opencollective.com/rgeo"],"categories":["Ruby","ruby","Gems","Geospatial Library"],"sub_categories":["Articles","Ruby","Database Structure and Schema Management"],"readme":"# ActiveRecord PostGIS Adapter\n\n[![Gem Version](https://badge.fury.io/rb/activerecord-postgis-adapter.svg)](https://badge.fury.io/rb/activerecord-postgis-adapter)\n![Build Status](https://github.com/rgeo/activerecord-postgis-adapter/actions/workflows/tests.yml/badge.svg?branch=master)\n[![Maintainability](https://api.codeclimate.com/v1/badges/4444dc80a2cd6a37baa1/maintainability)](https://codeclimate.com/github/rgeo/activerecord-postgis-adapter/maintainability)\n\nThe activerecord-postgis-adapter provides access to features\nof the PostGIS geospatial database from ActiveRecord. It extends\nthe standard postgresql adapter to provide support for the spatial data types\nand features added by the PostGIS extension. It uses the\n[RGeo](https://github.com/rgeo/rgeo) library to represent spatial data in Ruby.\n\n## Overview\n\nThe adapter provides three basic capabilities:\n\nFirst, it provides _spatial migrations_. It extends the ActiveRecord migration\nsyntax to support creating spatially-typed columns and spatial indexes. You\ncan control the various PostGIS-provided attributes such as SRID, dimension,\nand geographic vs geometric math.\n\nSecond, it recognizes spatial types and casts them properly to RGeo geometry\nobjects. The adapter can configure these objects automatically based on the\nSRID and dimension in the database table, or you can tell it to convert the\ndata to a different form. You can also set attribute data using WKT format.\n\nThird, it lets you include simple spatial data in queries. WKT format data and\nRGeo objects can be embedded in where clauses.\n\n## Install\n\nThe adapter requires PostgreSQL 9.0+ and PostGIS 2.4+.\n\n### Installing PostGIS\n\nHere are common methods for installing PostGIS, but more detailed methods can be found on the [installation guide](https://postgis.net/install/).\n\n#### MacOS\n\n```sh\nbrew install postgis\n```\n\n#### Ubuntu/Debian\n\n```sh\nsudo apt-get install postgis postgresql-16-postgis-3\n```\n\n#### Windows\n\nPostGIS is likely available as an optional package via your Postgresql installer. If not, refer to the installation guide.\n\nGemfile:\n\n```ruby\ngem 'activerecord-postgis-adapter'\n```\n\n#### Version 11.x supports ActiveRecord 8.0\n\n```\nActiveRecord 8.0\nRuby 3.2.0+\nPostGIS 2.0+\n```\n\n#### Version 10.x supports ActiveRecord 7.2\n\n```\nActiveRecord 7.2\nRuby 3.1.0+\nPostGIS 2.0+\n```\n\n#### Version 9.x supports ActiveRecord 7.1\n\n```\nActiveRecord 7.1\nRuby 3.0.0+\nPostGIS 2.0+\n```\n\n#### Version 8.x supports ActiveRecord 7.0\n\nRequirements:\n\n```\nActiveRecord 7.0\nRuby 2.7.0+\nPostGIS 2.0+\n```\n\n#### Version 7.x supports ActiveRecord 6.1\n\nRequirements:\n\n```\nActiveRecord 6.1\nRuby 2.5.0+, JRuby\nPostGIS 2.0+\n```\n\n#### Version 6.x supports ActiveRecord 6.0\n\nRequirements:\n\n```\nActiveRecord 6.0\nRuby 2.5.0+, JRuby\nPostGIS 2.0+\n```\n\n#### Version 5.x supports ActiveRecord 5.1 and 5.2\n\nRequirements:\n\n```\nActiveRecord 5.1 or 5.2\nRuby 2.2.2+, JRuby\nPostGIS 2.0+\n```\n\n#### Version 4.x supports ActiveRecord 5.0\n\nRequirements:\n\n```\nActiveRecord 5.0\nRuby 2.2.2+, JRuby\nPostGIS 2.0+\n```\n\n#### Version 3.x supports ActiveRecord 4.2\n\nRequirements:\n\n```\nActiveRecord 4.2\nRuby 1.9.3+, JRuby\nPostGIS 2.0+\n```\n\n#### Version 2.x supports ActiveRecord 4.0.x and 4.1.x\n\n_If you are using version 2.x, you should read [the version 2.x README](https://github.com/rgeo/activerecord-postgis-adapter/blob/2.0-stable/README.md)_\n\nRequirements:\n\n```\nActiveRecord 4.0.0 - 4.1.x\nRuby 1.9.3+, JRuby\nPostGIS 2.0+\n```\n\n#### Version 0.6.x supports ActiveRecord 3.x\n\n_If you are using version 0.6.x, you should read [the version 0.6.x / 2.x README](https://github.com/rgeo/activerecord-postgis-adapter/blob/2.0-stable/README.md)_\n\nRequirements:\n\n```\nActiveRecord 3.x only\nRuby 1.8.7+, JRuby, Rubinius\nPostGIS 1.5+\n```\n\nGemfile:\n\n```ruby\ngem 'activerecord-postgis-adapter', '~\u003e 0.6.6'\n```\n\nPlease read [PostGIS 1 Notes](https://github.com/rgeo/activerecord-postgis-adapter/blob/master/PostGIS_1.md)\nif you would like to use the adapter with an older version of PostGIS.\n\n#### Upgrading to version 8.x\n\nThe `PostgisDatabaseTasks` module has been removed which means that the rake tasks to install postgis are no longer available. If using a Rails app, please see [Upgrading an Existing Database](#upgrading-an-existing-database)\n\n#### Upgrading from 6.x\n\nWhen upgrading from version 6.x to a newer major version, you may need to modify your `SpatialFactoryStore` configuration. Please see this section of the README in rgeo-activerecord for more details (https://github.com/rgeo/rgeo-activerecord#spatial-factories-for-columns).\n\n##### database.yml\n\nYou must modify your `config/database.yml` file to use the postgis\nadapter. At minimum, you will need to change the `adapter` field from\n`postgresql` to `postgis`. Recommended configuration:\n\n```yml\ndevelopment:\n  username: your_username\n  adapter: postgis\n  host: localhost\n  schema_search_path: public\n```\n\nIf you have installed your PostGIS extension in a schema other than `public`, which\nis the default, add that schema to your `schema_search_path`:\n\n```yml\ndevelopment:\n  schema_search_path: public, postgis\n```\n\nHere are some other options that are supported:\n\n```yml\ndevelopment:\n  adapter: postgis\n  encoding: unicode\n  postgis_extension: postgis # default is postgis\n  postgis_schema: public # default is public\n  schema_search_path: public,postgis\n  pool: 5\n  database: my_app_development # your database name\n  username: my_app_user # the username your app will use to connect\n  password: my_app_password # the user's password\n  su_username: my_global_user # a superuser for the database\n  su_password: my_global_pasword # the superuser's password\n```\n\n##### `rgeo` dependency\n\nThis adapter uses the `rgeo` gem, which has additional dependencies.\nPlease see the README documentation for `rgeo` for more information: https://github.com/rgeo/rgeo\n\n## Setup\n\nIf you have not created your rails app yet start there.\n\n```sh\nrails new my_app --database=postgresql\n```\n\nAdd the gem to your Gemfile.\n\n```ruby\ngem 'activerecord-postgis-adapter'\n```\n\nAnd tell ActiveRecord to use the adapter by setting the `adapter` field in `config/database.yml`\n\n```yml\ndefault: \u0026default\n  adapter: postgis\n```\n\nCreate the database if you haven't already.\n\n```sh\nrake db:create\n```\n\nCreate a migration to add the PostGIS extension to your database.\n\n```sh\nrails generate migration AddPostgisExtensionToDatabase\n```\n\nThe migration should look something like this:\n```ruby\nclass AddPostgisExtensionToDatabase \u003c ActiveRecord::Migration[7.2]\n  def change\n    enable_extension 'postgis'\n  end\nend\n```\n\nThen run the migration.\n\n```sh\nrails db:migrate\n```\n\n### Creating Spatial Tables\n\nTo store spatial data, you must create a column with a spatial type. PostGIS\nprovides a variety of spatial types, including point, linestring, polygon, and\ndifferent kinds of collections. These types are defined in a standard produced\nby the Open Geospatial Consortium. You can specify options indicating the coordinate\nsystem and number of coordinates for the values you are storing.\n\nThe activerecord-postgis-adapter extends ActiveRecord's migration syntax to\nsupport these spatial types. The following example creates five spatial\ncolumns in a table:\n\n```ruby\ncreate_table :my_spatial_table do |t|\n  t.column :shape1, :geometry\n  t.geometry :shape2\n  t.line_string :path, srid: 3785\n  t.st_point :lonlat, geographic: true\n  t.st_point :lonlatheight, geographic: true, has_z: true\nend\n```\n\nThe first column, \"shape1\", is created with type \"geometry\". This is a general\n\"base class\" for spatial types; the column declares that it can contain values\nof _any_ spatial type.\n\nThe second column, \"shape2\", uses a shorthand syntax for the same type as the shape1 column.\nYou can create a column either by invoking `column` or invoking the name of the type directly.\n\nThe third column, \"path\", has a specific geometric type, `line_string`. It\nalso specifies an SRID (spatial reference ID) that indicates which coordinate\nsystem it expects the data to be in. The column now has a \"constraint\" on it;\nit will accept only LineString data, and only data whose SRID is 3785.\n\nThe fourth column, \"lonlat\", has the `st_point` type, and accepts only Point\ndata. Furthermore, it declares the column as \"geographic\", which means it\naccepts longitude/latitude data, and performs calculations such as distances\nusing a spheroidal domain.\n\nThe fifth column, \"lonlatheight\", is a geographic (longitude/latitude) point\nthat also includes a third \"z\" coordinate that can be used to store height\ninformation.\n\nThe following are the data types understood by PostGIS and exposed by\nactiverecord-postgis-adapter:\n\n- `:geometry` -- Any geometric type\n- `:st_point` -- Point data\n- `:line_string` -- LineString data\n- `:st_polygon` -- Polygon data\n- `:geometry_collection` -- Any collection type\n- `:multi_point` -- A collection of Points\n- `:multi_line_string` -- A collection of LineStrings\n- `:multi_polygon` -- A collection of Polygons\n\nFollowing are the options understood by the adapter:\n\n- `:geographic` -- If set to true, create a PostGIS geography column for\n  longitude/latitude data over a spheroidal domain; otherwise create a\n  geometry column in a flat coordinate system. Default is false. Also\n  implies :srid set to 4326.\n- `:srid` -- Set a SRID constraint for the column. Default is 4326 for a\n  geography column, or -1 for a geometry column. Note that PostGIS currently\n  (as of version 2.0) requires geography columns to have SRID 4326, so this\n  constraint is of limited use for geography columns.\n- `:has_z` -- Specify that objects in this column include a Z coordinate.\n  Default is false.\n- `:has_m` -- Specify that objects in this column include an M coordinate.\n  Default is false.\n\nTo create a PostGIS spatial index, add `using: :gist` to your index:\n\n```ruby\nadd_index :my_table, :lonlat, using: :gist\n\n# or\n\nchange_table :my_table do |t|\n  t.index :lonlat, using: :gist\nend\n```\n\n### Attributes\n\nModels may also define attributes using the above data types and options.\n\n```ruby\nclass SpatialModel \u003c ActiveRecord::Base\n  attribute :centroid, :st_point, srid: 4326, geographic: true\nend\n```\n\n`centroid` will not have an associated column in the `spatial_models` table, but any geometry object assigned to the `centroid` attribute will be cast to a geographic point.\n\n### Configuring ActiveRecord\n\nActiveRecord's usefulness stems from the way it automatically configures\nclasses based on the database structure and schema. If a column in the\ndatabase has an integer type, ActiveRecord automatically casts the data to a\nRuby Integer. In the same way, the activerecord-postgis-adapter automatically\ncasts spatial data to a corresponding RGeo data type.\n\nRGeo offers more flexibility in its type system than can be\ninterpreted solely from analyzing the database column. For example, you can\nconfigure RGeo objects to exhibit certain behaviors related to their\nserialization, validation, coordinate system, or computation. These settings\nare embodied in the RGeo factory associated with the object.\n\nYou can configure the adapter to use a particular factory (i.e. a\nparticular combination of settings) for data associated with each type in\nthe database.\n\nHere's an example using a Geos default factory:\n\n```ruby\nRGeo::ActiveRecord::SpatialFactoryStore.instance.tap do |config|\n  # By default, use the GEOS implementation for spatial columns.\n  config.default = RGeo::Geos.factory_generator\n\n  # But use a geographic implementation for point columns.\n  config.register(RGeo::Geographic.spherical_factory(srid: 4326), geo_type: \"point\")\nend\n```\n\nThe default spatial factory for geographic columns is `RGeo::Geographic.spherical_factory`.\nThe default spatial factory for cartesian columns is `RGeo::Cartesian.preferred_factory`.\nYou do not need to configure the `SpatialFactoryStore` if these defaults are ok.\n\nFor more explanation of `SpatialFactoryStore`, see [the rgeo-activerecord README](https://github.com/rgeo/rgeo-activerecord#spatial-factories-for-columns)\n\n### Deploying to Heroku\n\nSee the [wiki entry](https://github.com/rgeo/activerecord-postgis-adapter/wiki/Heroku) and [linked issue](https://github.com/rgeo/activerecord-postgis-adapter/issues/14) for some notes on Heroku deployments.\n\nNote: RGeo is looking for a Heroku user to help formalize/expand the wiki. If you're interested, please open a PR with a new md file, which can be copied to the wiki.\n\n## Working With Spatial Data\n\nOf course, you're using this adapter because you want to work with geospatial\ndata in your ActiveRecord models. Once you've installed the adapter, set up\nyour database, and run your migrations, you can interact directly with spatial\ndata in your models as RGeo objects.\n\nRGeo is a Ruby implementation of the industry standard OGC Simple Features\nspecification. It's a set of data types that can represent a variety of\ngeospatial objects such as points, lines, polygons, and collections. It also\nprovides the standard set of spatial analysis operations such as computing\nintersections or bounding boxes, calculating length or area, and so forth. We\nrecommend browsing the RGeo documentation for a clearer understanding of its\ncapabilities. For now, just note that the data values you will be working with\nare all RGeo geometry objects.\n\n### Reading and Writing Spatial Columns\n\nWhen you access a spatial attribute on your ActiveRecord model, it is given to\nyou as an RGeo geometry object (or nil, for attributes that allow null\nvalues). You can then call the RGeo api on the object. For example, consider\nthe MySpatialTable class we worked with above:\n\n```ruby\nrecord = MySpatialTable.find(1)\np = record.lonlat                  # Returns an RGeo::Feature::Point\nputs p.x                           # displays the x coordinate\nputs p.geometry_type.type_name     # displays \"Point\"\n```\n\nThe RGeo factory for the value is determined by how you configured the\nActiveRecord class, as described above. In this case, we explicitly set a\nspherical factory for the `:lonlat` column:\n\n```ruby\nfactory = p.factory                # returns a spherical factory\n```\n\nYou can set a spatial attribute by providing an RGeo geometry object, or by\nproviding the WKT string representation of the geometry. If a string is\nprovided, the activerecord-postgis-adapter will attempt to parse it as WKT and\nset the value accordingly.\n\n```ruby\nrecord.lonlat = 'POINT(-122 47)'  # sets the value to the given point\n```\n\nIf the WKT parsing fails, the value currently will be silently set to nil. In\nthe future, however, this will raise an exception.\n\n```ruby\nrecord.lonlat = 'POINT(x)'         # sets the value to nil\n```\n\nIf you set the value to an RGeo object, the factory needs to match the factory\nfor the attribute. If the factories do not match, activerecord-postgis-adapter\nwill attempt to cast the value to the correct factory.\n\n```ruby\np2 = factory.point(-122, 47)       # p2 is a point in a spherical factory\nrecord.lonlat = p2                 # sets the value to the given point\nrecord.shape1 = p2                 # shape1 uses a flat geos factory, so it\n                                   # will cast p2 into that coordinate system\n                                   # before setting the value\nrecord.save\n```\n\nIf, however, you attempt to set the value to the wrong type-- for example,\nsetting a linestring attribute to a point value, you will get an exception\nfrom Postgres when you attempt to save the record.\n\n```ruby\nrecord.path = p2      # This will appear to work, but...\nrecord.save           # This will raise an exception from the database\n```\n\n### Spatial Queries\n\nYou can create simple queries based on representational equality in the same\nway you would on a scalar column:\n\n```ruby\nrecord2 = MySpatialTable.where(:lonlat =\u003e factory.point(-122, 47)).first\n```\n\nYou can also use WKT:\n\n```ruby\nrecord3 = MySpatialTable.where(:lonlat =\u003e 'POINT(-122 47)').first\n```\n\nNote that these queries use representational equality, meaning they return\nrecords where the lonlat value matches the given value exactly. A 0.00001\ndegree difference would not match, nor would a different representation of the\nsame geometry (like a multipoint with a single element). Equality queries\naren't generally all that useful in real world applications. Typically, if you\nwant to perform a spatial query, you'll look for, say, all the points within a\ngiven area. For those queries, you'll need to use the standard spatial SQL\nfunctions provided by PostGIS.\n\nTo perform more advanced spatial queries, you can use the extended Arel interface included in the activerecord-postgis-adapter. The functions accept WKT strings or RGeo features.\n\n```rb\npoint = RGeo::Geos.factory(srid: 0).point(1,1)\n\nbuildings = Building.arel_table\ncontaining_buiildings = Building.where(buildings[:geom].st_contains(point))\n```\n\nSee [rgeo-activerecord](https://github.com/rgeo/rgeo-activerecord) for more information about advanced spatial queries.\n\n### Joining Spatial Columns\n\nIf a spatial column is joined with another model, `srid` and `geographic` will not be automatically inferred and they will default to 0 and `false`, by default. In order to properly infer these options after a join, an `attribute` must be created on the target table.\n\n```ruby\nclass SpatialModel \u003c ActiveRecord::Base\n belongs_to :foo\n\n # has column geo_point (:st_point, srid: 4326, geographic: true)\nend\n\nclass Foo \u003c ActiveRecord::Base\n has_one :spatial_model\n\n # re-define geo_point here so join works\n attribute :geo_point, :st_point, srid: 4326, geographic: true\nend\n\n# perform a query where geo_point is joined to foo\nfoo = Foo.joins(:spatial_models).select(\"foos.id, spatial_models.geo_point\").first\np foo.geo_point.class\n# =\u003e RGeo::Geographic::SphericalPointImpl\np foo.geo_point.srid\n# =\u003e 4326\n```\n\n## Background: PostGIS\n\nA spatial database is one that includes a set of data types, functions,\ntables, and other objects related to geospatial data. When these objects are\npresent in your database, you can use them to store and query spatial objects\nsuch as points, lines, and polygons.\n\nPostGIS is an extension for PostgreSQL that provides definitions for the objects\nyou need to add to a database to enable geospatial capabilities.\n\nWhen you create your Rails database as described above in the section on\ninstallation and configuration, activerecord-postgis-adapter automatically\ninvokes PostGIS to add the appropriate definitions to your database. You can\ndetermine whether your database includes the correct definitions by attempting\nto invoke the POSTGIS_VERSION function:\n\n```sql\nSELECT POSTGIS_VERSION(); # succeeds if PostGIS objects are present.\n```\n\nStandard spatial databases also include a table called `spatial_ref_sys`. This\ntable includes a set of \"spatial reference systems\", or coordinate systems---\nfor example, WGS84 latitude and longitude, or Mercator Projection. Spatial\ndatabases also usually include a table called `geometry_columns`, which\nincludes information on each database column that includes geometric data. In\nrecent versions of PostGIS, `geometry_columns` is actually not a table but a\nview into the system catalogs.\n\n## Development and Support\n\nRubyDoc Documentation is available at https://rubydoc.info/gems/activerecord-postgis-adapter\n\nContributions are welcome. See CONTRIBUTING.md for instructions.\n\nReport issues at https://github.com/rgeo/activerecord-postgis-adapter/issues\n\nSupport is also available on the rgeo-users google group at https://groups.google.com/group/rgeo-users\n\n## Acknowledgments\n\n[Daniel Azuma](https://daniel-azuma.com) authored the PostGIS Adapter and its supporting\nlibraries (including RGeo).\n\n[Tee Parham](https://twitter.com/teeparham) is a former maintainer.\n\n[Keith Doggett](https://github.com/keithdoggett) is a current maintainer.\n\n[Ulysse Buonomo](https://github.com/BuonOmo) is a current maintainer.\n\nDevelopment is supported by:\n\n- [Klaxit](https://www.klaxit.com)\n- Goldfish Ads\n\nThis adapter implementation owes some debt to the spatial_adapter plugin\n(https://github.com/fragility/spatial_adapter). Although we made some different\ndesign decisions for this adapter, studying the spatial_adapter source gave us\na head start on the implementation.\n\n## License\n\nCopyright Daniel Azuma, Tee Parham\n\nhttps://github.com/rgeo/activerecord-postgis-adapter/blob/master/LICENSE.txt\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Frgeo%2Factiverecord-postgis-adapter","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Frgeo%2Factiverecord-postgis-adapter","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Frgeo%2Factiverecord-postgis-adapter/lists"}