rgeo-activerecord-dschee 5.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1878a64950dfeca28535eda8b6599aa717d685c9
+  data.tar.gz: 81267038dfbb7ecc3e19ecdf6df1c29a51e7b572
+SHA512:
+  metadata.gz: 21023f0ae7931de711cca2e2d780a6ea686348c1a7e4e72cc6fbf667f3dbaabc1de5ebbc36783da102994c516daf8534e1e5baddaf2480d60e6f7befead97085
+  data.tar.gz: b144106f54dc3c7fd9c2ee56eb614f9cd030988187a803851a9e7ad7f3f91e5f12f1a0242208ba390472a7bd748ed763cc6ff71c6c1e630d1aac754029d85fa3

data/History.md

@@ -0,0 +1,207 @@
+### 4.0.5 / 2015-12-29
+
+* Fix #geometric_type_from_name for :geometrycollection
+
+### 4.0.4 / 2015-12-29
+
+* Restore rgeo/active_record.rb
+
+### 4.0.3 / 2015-12-28
+
+* Fix json parser for rgeo-geojson 0.4.0+
+
+### 4.0.2 / 2015-12-28
+
+* Remove unnecessary root namespacing
+* Remove unnecessary namespace qualifiers
+* Remove rgeo/active_record.rb
+
+### 4.0.1 / 2015-12-25
+
+* Rubocop style cleanup #31
+* Do not distribute test files with gem
+
+### 4.0.0 / 2015-05-24
+
+* Remove GeoTableDefinitions, GeoConnectionAdapter
+
+### 3.0.0 / 2015-05-09
+
+* Remove AdapterTestHelper module
+* Remove RGeoFactorySettings
+* Remove #set_rgeo_factory_for_column, #rgeo_factory_for_column, etc
+* Add SpatialFactoryStore (see https://github.com/rgeo/rgeo-activerecord/commit/b1da5cb222)
+
+### 2.1.1 / 2015-03-18
+
+* Fix collector calls for arel 6.0 API
+
+### 2.1.0 / 2015-02-07
+
+* Update visit API for arel 6.0
+* Remove attribute caching (removed in AR 4.2)
+* Remove support for `spatial: true` index option (use standard `using: :gist`)
+
+### 2.0.0 / 2014-12-02
+
+* Dump schema using new style hash - https://github.com/rgeo/rgeo-activerecord/pull/18
+* Require ActiveRecord 4.2
+
+### 1.2.0 / 2014-08-21
+
+* Support ActiveRecord 4.2
+
+### 1.1.0 / 2014-06-17
+
+* Relax rgeo gem dependency
+
+### 1.0.0 / 2014-05-06
+
+* Require ruby 1.9.3+
+* Require ActiveRecord 4+
+* General refactoring and cleanup
+
+### 0.6.0 / 2014-05-06
+
+* Support Rails 4, Arel 4
+
+### 0.5.0 / 2013-02-27
+
+*   No changes. Rereleased as 0.5.0 final.
+
+
+### 0.5.0.beta2 / 2013-02-04
+
+*   Revert change made to SpatialIndexDefinition in beta1.
+*   Fix some deprecations in the post-test cache cleanup.
+
+
+### 0.5.0.beta1 / 2013-02-04
+
+*   Updates for compatibility with Rails 4 and support of Rails 4 oriented
+    adapters.
+*   Testing tool is better factored to allow customization of cleanup
+
+
+### 0.4.6 / 2012-12-11
+
+*   You can now provide both a default and an override database config file in
+    the test helper.
+*   The gemspec no longer includes the timestamp in the version, so that
+    bundler can pull from github. (Reported by corneverbruggen)
+
+
+### 0.4.5 / 2012-04-13
+
+*   Task hacker failed ungracefully when attempting to hack a nonexistent
+    task. Fixed.
+
+
+### 0.4.4 / 2012-04-12
+
+*   Support cartesian bounding boxes in queries.
+
+
+### 0.4.3 / 2012-02-22
+
+*   Some fixes for Rails 3.2 compatibility.
+
+
+### 0.4.2 / 2012-01-09
+
+*   Added an "rgeo-activerecord.rb" wrapper so bundler's auto-require will
+    work without modification. (Reported by Mauricio Pasquier Juan.)
+*   Fixed unit tests so they actually pass...
+
+
+### 0.4.1 / 2011-10-26
+
+*   Fixed wrong variable name crash in rgeo_factory_for_column (patch by Andy
+    Allan).
+
+
+### 0.4.0 / 2011-08-15
+
+*   Several compatibility fixes for Rails 3.1.
+*   Revamped factory setter mechanism with a system that should be more
+    robust.
+*   Some general code cleanup.
+
+
+### 0.3.4 / 2011-05-23
+
+*   Uses the mixin feature of RGeo 0.3 to add an as_json method to all
+    geometry objects. This should allow ActiveRecord's JSON serialization to
+    function for models with geometry fields. (Reported by thenetduck and
+    tonyc on github.)
+
+
+### 0.3.3 / 2011-04-11
+
+*   A .gemspec file is now available for gem building and bundler git
+    integration.
+
+
+### 0.3.2 / 2011-02-28
+
+*   Fixed a bug that sometimes caused spatial column detection to fail, which
+    could result in exceptions or incorrect spatial queries.
+
+
+### 0.3.1 / 2011-02-28
+
+*   Fixed a bug that could cause some spatial ActiveRecord adapters to fail to
+    create multiple spatial columns in a migration.
+
+
+### 0.3.0 / 2011-01-26
+
+*   Experimental support for complex spatial queries. (Requires Arel 2.1,
+    which is expected to be released with Rails 3.1.) Currently, only a
+    low-level Arel-based interface is supported.
+*   Better support for geography types in PostGIS.
+*   Adapters can now define additional column constructors.
+*   Support for spatial column constructors on change_table.
+*   Fixed column type inference for some cases where the column included Z
+    and/or M.
+*   IS NULL predicates now work properly with spatial types.
+*   Preferred attribute type is now :spatial rather than :geometry.
+*   The gem version is now accessible via an api.
+*   Some code reorganization.
+
+
+### 0.2.4 / 2011-01-13
+
+*   Fixed a problem that caused a hang during rake db:rollback, as well as
+    probably certain other functions that use ActiveRecord::Base directly
+    rather than a subclass. (Reported by Alexander Graefe.)
+
+
+### 0.2.3 / 2011-01-07
+
+*   Updated gem dependencies to include Arel 2.0.6, since some earlier Arel
+    versions weren't working. (Reported by Pirmin Kalberer.)
+
+
+### 0.2.2 / 2011-01-06
+
+*   Some adjustments to the Arel integration for future Arel compatibility.
+    (Thanks to Aaron Patterson.)
+*   Support code for hacking ActiveRecord's rake tasks.
+
+
+### 0.2.1 / 2010-12-27
+
+*   Support for RGeo features as nodes in the Arel AST.
+*   Basic utility Arel visitor methods for handling spatial equality nodes in
+    where-expressions.
+
+
+### 0.2.0 / 2010-12-07
+
+*   Initial public alpha release. Spun rgeo-activerecord off from the core
+    rgeo gem.
+*   Support for setting factory by column.
+
+
+For earlier history, see the History file for the rgeo gem.

data/LICENSE.txt

@@ -0,0 +1,29 @@
+# -----------------------------------------------------------------------------
+# Copyright 2010-2012 Daniel Azuma
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------

data/README.md

@@ -0,0 +1,121 @@
+## RGeo::ActiveRecord
+
+[![Gem Version](https://badge.fury.io/rb/rgeo-activerecord.svg)](http://badge.fury.io/rb/rgeo-activerecord)
+[![Build Status](https://travis-ci.org/rgeo/rgeo-activerecord.svg?branch=master)](https://travis-ci.org/rgeo/rgeo-activerecord)
+[![Code Climate](https://codeclimate.com/github/rgeo/rgeo-activerecord.png)](https://codeclimate.com/github/rgeo/rgeo-activerecord)
+
+RGeo::ActiveRecord is an optional [RGeo](http://github.com/dazuma/rgeo) module
+providing spatial extensions for ActiveRecord, as well as a set of helpers for
+writing spatial ActiveRecord adapters based on RGeo.
+
+### Summary
+
+RGeo is a key component for writing location-aware applications in the Ruby
+programming language. At its core is an implementation of the industry
+standard OGC Simple Features Specification, which provides data
+representations of geometric objects such as points, lines, and polygons,
+along with a set of geometric analysis operations. See the README for the
+"rgeo" gem for more information.
+
+RGeo::ActiveRecord is an optional RGeo add-on module providing spatial
+extensions for ActiveRecord, as well as a set of helpers for writing spatial
+ActiveRecord adapters based on RGeo.
+
+### Installation
+
+Gemfile:
+
+```ruby
+gem 'rgeo-activerecord'
+```
+
+`rgeo-activerecord` has the following requirements:
+
+* Ruby 1.9.3 or later
+* rgeo 0.3.20 or later.
+
+The latest version supports ActiveRecord 4.2 and later.
+
+Version `1.1.0` supports ActiveRecord 4.0 and 4.1
+
+Version `0.6.0` supports earlier versions of ruby and ActiveRecord:
+
+* Ruby 1.8.7 or later
+* ActiveRecord 3.0.3 - 3.2.x
+* rgeo 0.3.20 or later
+* arel 2.0.6 or later
+
+### Spatial Factories for Columns
+
+`rgeo_factory_generator` and related methods were removed in version 4.0, since column types
+are no longer tied to their database column in ActiveRecord 4.2.
+
+Register spatial factories in the `SpatialFactoryStore` singleton class. Each spatial type
+in your ActiveRecord models will use the `SpatialFactoryStore` to retrieve
+a factory matching the properties of its type. For example, you can set a different
+spatial factory for point types, or for types matching a specific SRID, or having
+a Z coordinate, or any combination of attributes.
+
+The supported keys when registering a spatial type are listed here with their default values
+and other allowed values:
+
+```
+geo_type: "geometry", # point, polygon, line_string, geometry_collection, 
+                      # multi_line_string, multi_point, multi_polygon
+has_m:    false,      # true
+has_z:    false,      # true
+sql_type: "geometry", # geography
+srid:     0,          # (any valid SRID)
+```
+
+The default factories are `RGeo::Geographic.spherical_factory` for 
+geographic types, and `RGeo::Cartesian.preferred_factory` for geometric types.
+
+Here is an example setup:
+
+```ruby
+RGeo::ActiveRecord::SpatialFactoryStore.instance.tap do |config|
+  # By default, use the GEOS implementation for spatial columns.
+  config.default = RGeo::Geos.factory_generator
+
+  # But use a geographic implementation for point columns.
+  config.register(RGeo::Geographic.spherical_factory(srid: 4326), geo_type: "point")
+end
+```
+
+### RGeo Dependency
+
+See the README for the [rgeo](https://github.com/rgeo/rgeo) gem, a dependency, for further
+installation information.
+
+### Development and support
+
+This README is the official documentation.
+
+RDoc documentation is available at http://rdoc.info/gems/rgeo-activerecord
+
+Source code is hosted on Github at http://github.com/rgeo/rgeo-activerecord
+
+Contributions are welcome. Fork the project on Github.
+
+Report bugs on Github issues at
+http://github.com/rgeo/rgeo-activerecord/issues
+
+Support available on the rgeo-users google group at
+http://groups.google.com/group/rgeo-users
+
+### Acknowledgments
+
+[Daniel Azuma](http://www.daniel-azuma.com) created RGeo.
+[Tee Parham](http://twitter.com/teeparham) is the current maintainer.
+
+Development is supported by:
+
+* [Pirq](http://pirq.com)
+* [Neighborland](https://neighborland.com)
+
+### License
+
+Copyright 2015 Daniel Azuma, Tee Parham
+
+https://github.com/rgeo/rgeo-activerecord/blob/master/LICENSE.txt

data/lib/rgeo-activerecord.rb

@@ -0,0 +1 @@
+require "rgeo/active_record"

data/lib/rgeo/active_record.rb

@@ -0,0 +1,8 @@
+require "rgeo"
+require "active_record"
+require "rgeo/active_record/version"
+require "rgeo/active_record/spatial_expressions"
+require "rgeo/active_record/spatial_factory_store"
+require "rgeo/active_record/arel_spatial_queries"
+require "rgeo/active_record/common_adapter_elements"
+require "rgeo/active_record/geometry_mixin"

data/lib/rgeo/active_record/arel_spatial_queries.rb

@@ -0,0 +1,120 @@
+module RGeo
+  module ActiveRecord
+    # A set of common Arel visitor hacks for spatial ToSql visitors.
+    # Generally, a spatial ActiveRecord adapter should provide a custom
+    # ToSql Arel visitor that includes and customizes this module.
+    # See the existing spatial adapters (i.e. postgis, spatialite,
+    # mysqlspatial, and mysql2spatial) for usage examples.
+
+    module SpatialToSql
+      # Map a standard OGC SQL function name to the actual name used by
+      # a particular database. This method should take a name and
+      # return either the changed name or the original name.
+
+      def st_func(standard_name)
+        standard_name
+      end
+
+      # Visit the SpatialNamedFunction node. This operates similarly to
+      # the standard NamedFunction node, but it performs function name
+      # mapping for the database, and it also uses the type information
+      # in the node to determine when to cast string arguments to WKT,
+
+      def visit_RGeo_ActiveRecord_SpatialNamedFunction(node, collector)
+        name = st_func(node.name)
+        exprs = []
+        node.expressions.each_with_index do |expr, index|
+          exprs << (node.spatial_argument?(index) ? visit_in_spatial_context(expr, collector) : visit(expr, collector))
+        end
+        collector << name
+        collector << "("
+        collector << "DISTINCT " if node.distinct
+        collector << exprs.join(", ")
+        collector << ")"
+        collector << " AS #{visit(node.alias, collector)}" if node.alias
+        collector
+      end
+
+      # Generates SQL for a spatial node.
+      # The node must be a string (in which case it is treated as WKT),
+      # an RGeo feature, or a spatial attribute.
+      def visit_in_spatial_context(node, collector)
+        case node
+        when String
+          collector << "#{st_func('ST_WKTToSQL')}(#{quote(node)})"
+        when RGeo::Feature::Instance
+          collector << visit_RGeo_Feature_Instance(node, collector)
+        when RGeo::Cartesian::BoundingBox
+          collector << visit_RGeo_Cartesian_BoundingBox(node, collector)
+        else
+          visit(node, collector)
+        end
+      end
+    end
+
+    # This node wraps an RGeo feature and gives it spatial expression constructors.
+    class SpatialConstantNode
+      include SpatialExpressions
+
+      # The delegate should be the RGeo feature.
+      def initialize(delegate)
+        @delegate = delegate
+      end
+
+      # Return the RGeo feature
+      attr_reader :delegate
+    end
+
+    # :stopdoc:
+
+    # Make sure the standard Arel visitors can handle RGeo feature objects by default.
+
+    Arel::Visitors::Visitor.class_eval do
+      def visit_RGeo_ActiveRecord_SpatialConstantNode(node, collector)
+        if respond_to?(:visit_in_spatial_context)
+          visit_in_spatial_context(node.delegate, collector)
+        else
+          visit(node.delegate, collector)
+        end
+      end
+    end
+
+    Arel::Visitors::Dot.class_eval do
+      alias :visit_RGeo_Feature_Instance :visit_String
+      alias :visit_RGeo_Cartesian_BoundingBox :visit_String
+    end
+
+    Arel::Visitors::DepthFirst.class_eval do
+      alias :visit_RGeo_Feature_Instance :terminal
+      alias :visit_RGeo_Cartesian_BoundingBox :terminal
+    end
+
+    Arel::Visitors::ToSql.class_eval do
+      alias :visit_RGeo_Feature_Instance :visit_String
+      alias :visit_RGeo_Cartesian_BoundingBox :visit_String
+    end
+
+    # A NamedFunction subclass that keeps track of the spatial-ness of
+    # the arguments and return values, so that it can provide context to
+    # visitors that want to interpret syntax differently when dealing with
+    # spatial elements.
+    class SpatialNamedFunction < Arel::Nodes::NamedFunction
+      include SpatialExpressions
+
+      def initialize(name, expr, spatial_flags = [], aliaz = nil)
+        super(name, expr, aliaz)
+        @spatial_flags = spatial_flags
+      end
+
+      def spatial_result?
+        @spatial_flags.first
+      end
+
+      def spatial_argument?(index)
+        @spatial_flags[index + 1]
+      end
+    end
+
+    # :startdoc:
+  end
+end

data/lib/rgeo/active_record/common_adapter_elements.rb

@@ -0,0 +1,39 @@
+# autoload AbstractAdapter
+ActiveRecord::ConnectionAdapters::AbstractAdapter
+
+module RGeo
+  module ActiveRecord
+    # Some default column constructors specifications for most spatial
+    # databases. Individual adapters may add to or override this list.
+    DEFAULT_SPATIAL_COLUMN_CONSTRUCTORS = {
+      geometry_collection: {}.freeze,
+      geometry:            {}.freeze,
+      line_string:         {}.freeze,
+      multi_line_string:   {}.freeze,
+      multi_point:         {}.freeze,
+      multi_polygon:       {}.freeze,
+      point:               {}.freeze,
+      polygon:             {}.freeze,
+      spatial:             { type: "geometry" }.freeze,
+    }.freeze
+
+    # Index definition struct with a spatial flag field.
+
+    SpatialIndexDefinition = Struct.new(:table, :name, :unique, :columns, :lengths, :orders, :where, :spatial)
+
+    # Returns a feature type module given a string type.
+
+    def self.geometric_type_from_name(name)
+      case name.to_s
+      when /^geometrycollection/i then Feature::GeometryCollection
+      when /^geometry/i then Feature::Geometry
+      when /^linestring/i then Feature::LineString
+      when /^multilinestring/i then Feature::MultiLineString
+      when /^multipoint/i then Feature::MultiPoint
+      when /^multipolygon/i then Feature::MultiPolygon
+      when /^point/i then Feature::Point
+      when /^polygon/i then Feature::Polygon
+      end
+    end
+  end
+end

data/lib/rgeo/active_record/geometry_mixin.rb

@@ -0,0 +1,58 @@
+module RGeo
+  module ActiveRecord
+    # This module is mixed into all geometry objects. It provides an
+    # as_json method so that ActiveRecord knows how to generate JSON
+    # for a geometry-valued field.
+
+    module GeometryMixin
+      # The default JSON generator Proc. Renders geometry fields as WKT.
+      DEFAULT_JSON_GENERATOR = Proc.new(&:to_s)
+
+      @json_generator = DEFAULT_JSON_GENERATOR
+
+      # Set the style of JSON generation used for geometry fields in an
+      # ActiveRecord model by default. You may pass nil to use
+      # DEFAULT_JSON_GENERATOR, a proc that takes a geometry as the
+      # argument and returns an object that can be converted to JSON
+      # (i.e. usually a hash or string), or one of the following symbolic
+      # values:
+      #
+      # <tt>:wkt</tt>::
+      #   Well-known text format. (Same as DEFAULT_JSON_GENERATOR.)
+      # <tt>:geojson</tt>::
+      #   GeoJSON format. Requires the rgeo-geojson gem.
+
+      def self.set_json_generator(value = nil, &block)
+        if block && !value
+          value = block
+        elsif value == :geojson
+          require "rgeo/geo_json"
+          value = proc { |geom| GeoJSON.encode(geom) }
+        end
+        if value.is_a?(Proc)
+          @json_generator = value
+        else
+          @json_generator = DEFAULT_JSON_GENERATOR
+        end
+      end
+
+      # Given a feature, returns an object that can be serialized as JSON
+      # (i.e. usually a hash or string), using the current json_generator.
+      # This is used to generate JSON for geometry-valued ActiveRecord
+      # fields by default.
+
+      def self.generate_json(geom)
+        @json_generator.call(geom)
+      end
+
+      # Serializes this object as JSON for ActiveRecord.
+
+      def as_json(opts = nil)
+        GeometryMixin.generate_json(self)
+      end
+    end
+  end
+end
+
+RGeo::Feature::MixinCollection::GLOBAL.for_type(RGeo::Feature::Geometry)
+  .add(RGeo::ActiveRecord::GeometryMixin)

data/lib/rgeo/active_record/spatial_expressions.rb

@@ -0,0 +1,254 @@
+module RGeo
+  module ActiveRecord
+    # Returns true if spatial expressions (i.e. the methods in the
+    # SpatialExpressions module) are supported.
+    def self.spatial_expressions_supported?
+      defined?(Arel::Nodes::NamedFunction)
+    end
+
+    # A set of spatial expression builders.
+    # These methods can be chained off other spatial expressions to form
+    # complex expressions.
+    module SpatialExpressions
+      #--
+      # Generic functions
+      #++
+
+      def st_function(function, *args)
+        spatial_info = args.last.is_a?(::Array) ? args.pop : []
+        SpatialNamedFunction.new(function, [self] + args, spatial_info)
+      end
+
+      #--
+      # Geometry functions
+      #++
+
+      def st_dimension
+        SpatialNamedFunction.new("ST_Dimension", [self], [false, true])
+      end
+
+      def st_geometrytype
+        SpatialNamedFunction.new("ST_GeometryType", [self], [false, true])
+      end
+
+      def st_astext
+        SpatialNamedFunction.new("ST_AsText", [self], [false, true])
+      end
+
+      def st_asbinary
+        SpatialNamedFunction.new("ST_AsBinary", [self], [false, true])
+      end
+
+      def st_srid
+        SpatialNamedFunction.new("ST_SRID", [self], [false, true])
+      end
+
+      def st_isempty
+        SpatialNamedFunction.new("ST_IsEmpty", [self], [false, true])
+      end
+
+      def st_issimple
+        SpatialNamedFunction.new("ST_IsSimple", [self], [false, true])
+      end
+
+      def st_boundary
+        SpatialNamedFunction.new("ST_Boundary", [self], [true, true])
+      end
+
+      def st_envelope
+        SpatialNamedFunction.new("ST_Envelope", [self], [true, true])
+      end
+
+      def st_equals(rhs)
+        SpatialNamedFunction.new("ST_Equals", [self, rhs], [false, true, true])
+      end
+
+      def st_disjoint(rhs)
+        SpatialNamedFunction.new("ST_Disjoint", [self, rhs], [false, true, true])
+      end
+
+      def st_intersects(rhs)
+        SpatialNamedFunction.new("ST_Intersects", [self, rhs], [false, true, true])
+      end
+
+      def st_touches(rhs)
+        SpatialNamedFunction.new("ST_Touches", [self, rhs], [false, true, true])
+      end
+
+      def st_crosses(rhs)
+        SpatialNamedFunction.new("ST_Crosses", [self, rhs], [false, true, true])
+      end
+
+      def st_within(rhs)
+        SpatialNamedFunction.new("ST_Within", [self, rhs], [false, true, true])
+      end
+
+      def st_contains(rhs)
+        SpatialNamedFunction.new("ST_Contains", [self, rhs], [false, true, true])
+      end
+
+      def st_overlaps(rhs)
+        SpatialNamedFunction.new("ST_Overlaps", [self, rhs], [false, true, true])
+      end
+
+      def st_relate(rhs, matrix = nil)
+        args = [self, rhs]
+        args << matrix.to_s if matrix
+        SpatialNamedFunction.new("ST_Relate", args, [false, true, true, false])
+      end
+
+      def st_distance(rhs, units = nil)
+        args = [self, rhs]
+        args << units.to_s if units
+        SpatialNamedFunction.new("ST_Distance", args, [false, true, true, false])
+      end
+
+      def st_intersection(rhs)
+        SpatialNamedFunction.new("ST_Intersection", [self, rhs], [true, true, true])
+      end
+
+      def st_difference(rhs)
+        SpatialNamedFunction.new("ST_Difference", [self, rhs], [true, true, true])
+      end
+
+      def st_union(rhs)
+        SpatialNamedFunction.new("ST_Union", [self, rhs], [true, true, true])
+      end
+
+      def st_symdifference(rhs)
+        SpatialNamedFunction.new("ST_SymDifference", [self, rhs], [true, true, true])
+      end
+
+      def st_buffer(distance, units = nil)
+        args = [self, distance.to_f]
+        args << units.to_s if units
+        SpatialNamedFunction.new("ST_Buffer", args, [true, true, false])
+      end
+
+      def st_convexhull
+        SpatialNamedFunction.new("ST_ConvexHull", [self], [true, true])
+      end
+
+      #--
+      # Point functions
+      #++
+
+      def st_x
+        SpatialNamedFunction.new("ST_X", [self], [false, true])
+      end
+
+      def st_y
+        SpatialNamedFunction.new("ST_Y", [self], [false, true])
+      end
+
+      def st_z
+        SpatialNamedFunction.new("ST_Z", [self], [false, true])
+      end
+
+      def st_m
+        SpatialNamedFunction.new("ST_M", [self], [false, true])
+      end
+
+      #--
+      # Curve functions
+      #++
+
+      def st_startpoint
+        SpatialNamedFunction.new("ST_StartPoint", [self], [true, true])
+      end
+
+      def st_endpoint
+        SpatialNamedFunction.new("ST_EndPoint", [self], [true, true])
+      end
+
+      def st_isclosed
+        SpatialNamedFunction.new("ST_IsClosed", [self], [false, true])
+      end
+
+      def st_isring
+        SpatialNamedFunction.new("ST_IsRing", [self], [false, true])
+      end
+
+      def st_length(units = nil)
+        args = [self]
+        args << units.to_s if units
+        SpatialNamedFunction.new("ST_Length", args, [false, true, false])
+      end
+
+      #--
+      # LineString functions
+      #++
+
+      def st_numpoints
+        SpatialNamedFunction.new("ST_NumPoints", [self], [false, true])
+      end
+
+      def st_pointn(n)
+        SpatialNamedFunction.new("ST_PointN", [self, n.to_i], [true, true, false])
+      end
+
+      #--
+      # Surface functions
+      #++
+
+      def st_area(units = nil)
+        args = [self]
+        args << units.to_s if units
+        SpatialNamedFunction.new("ST_StartPoint", args, [false, true, false])
+      end
+
+      def st_centroid
+        SpatialNamedFunction.new("ST_Centroid", [self], [true, true])
+      end
+
+      def st_pointonsurface
+        SpatialNamedFunction.new("ST_PointOnSurface", [self], [true, true])
+      end
+
+      #--
+      # Polygon functions
+      #++
+
+      def st_exteriorring
+        SpatialNamedFunction.new("ST_ExteriorRing", [self], [true, true])
+      end
+
+      def st_numinteriorrings
+        # Note: the name difference is intentional. The standard
+        # names this function incorrectly.
+        SpatialNamedFunction.new("ST_NumInteriorRing", [self], [false, true])
+      end
+
+      def st_interiorringn(n)
+        SpatialNamedFunction.new("ST_InteriorRingN", [self, n.to_i], [true, true, false])
+      end
+
+      #--
+      # GeometryCollection functions
+      #++
+
+      def st_numgeometries
+        SpatialNamedFunction.new("ST_NumGeometries", [self], [false, true])
+      end
+
+      def st_geometryn(n)
+        SpatialNamedFunction.new("ST_GeometryN", [self, n.to_i], [true, true, false])
+      end
+    end
+  end
+end
+
+# Add tools to build spatial structures in the AST.
+
+# Allow chaining of spatial expressions from attributes
+Arel::Attribute.send :include, RGeo::ActiveRecord::SpatialExpressions
+
+module Arel
+  # Create a spatial constant node.
+  # This node wraps a spatial value (such as an RGeo feature or a text
+  # string in WKT format). It supports chaining with the functions
+  # defined by RGeo::ActiveRecord::SpatialExpressions.
+  def self.spatial(arg)
+    RGeo::ActiveRecord::SpatialConstantNode.new(arg)
+  end
+end

data/lib/rgeo/active_record/spatial_factory_store.rb

@@ -0,0 +1,61 @@
+module RGeo
+  module ActiveRecord
+    class SpatialFactoryStore
+      include Singleton
+
+      attr_accessor :registry
+
+      def initialize
+        @registry = {}
+      end
+
+      def register(factory, attrs = {})
+        registry[key(attrs)] = factory
+      end
+
+      def default(attrs = {})
+        @default || default_for_attrs(attrs)
+      end
+
+      def default=(factory)
+        @default = factory
+      end
+
+      def factory(attrs)
+        registry[key(attrs)] || default(attrs)
+      end
+
+      def clear
+        @registry = {}
+      end
+
+      private
+
+      def default_for_attrs(attrs)
+        if attrs[:sql_type] =~ /geography/
+          Geographic.spherical_factory(to_factory_attrs(attrs))
+        else
+          Cartesian.preferred_factory(to_factory_attrs(attrs))
+        end
+      end
+
+      def to_factory_attrs(attrs)
+        {
+          has_m_coordinate: attrs[:has_m],
+          has_z_coordinate: attrs[:has_z],
+          srid:             (attrs[:srid] || 0),
+        }
+      end
+
+      def key(attrs)
+        {
+          geo_type: "geometry",
+          has_m:    false,
+          has_z:    false,
+          sql_type: "geometry",
+          srid:     0,
+        }.merge(attrs).hash
+      end
+    end
+  end
+end

data/lib/rgeo/active_record/version.rb

@@ -0,0 +1,5 @@
+module RGeo
+  module ActiveRecord
+    VERSION = "5.0.0".freeze
+  end
+end

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification
+name: rgeo-activerecord-dschee
+version: !ruby/object:Gem::Version
+  version: 5.0.0
+platform: ruby
+authors:
+- Daniel Azuma, Tee Parham
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-07-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rgeo-dschee
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.8'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: rgeo-geojson
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+description: RGeo is a geospatial data library for Ruby. RGeo::ActiveRecord is an
+  optional RGeo module providing some spatial extensions to ActiveRecord, as well
+  as common tools used by RGeo-based spatial adapters.
+email: dazuma@gmail.com, parhameter@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- History.md
+- LICENSE.txt
+- README.md
+- lib/rgeo-activerecord.rb
+- lib/rgeo/active_record.rb
+- lib/rgeo/active_record/arel_spatial_queries.rb
+- lib/rgeo/active_record/common_adapter_elements.rb
+- lib/rgeo/active_record/geometry_mixin.rb
+- lib/rgeo/active_record/spatial_expressions.rb
+- lib/rgeo/active_record/spatial_factory_store.rb
+- lib/rgeo/active_record/version.rb
+homepage: https://github.com/rgeo/rgeo-activerecord
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.2.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: An RGeo module providing spatial extensions to ActiveRecord.
+test_files: []
+has_rdoc: