rgeo-activerecord 0.2.4 → 0.3.0

data/History.rdoc

@@ -1,3 +1,15 @@
+=== 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.)

data/README.rdoc

@@ -31,8 +31,8 @@ Generally, \ActiveRecord adapters which depend on this module should be
 installed as gems, and they will install this module automatically as
 a dependency. However, you can also install it manually as a gem:
 
- gem install rgeo
- gem install rgeo-activerecord
+  gem install rgeo
+  gem install rgeo-activerecord
 
 See the README for the "rgeo" gem, a required dependency, for further
 installation information.

data/Version

@@ -1 +1 @@
-0.2.4
+0.3.0

data/lib/rgeo/active_record.rb

@@ -60,7 +60,23 @@ module RGeo
 end
 
 
+# The rgeo-activerecord gem installs several patches to Arel to provide
+# support for spatial queries.
+
+module Arel
+end
+
+
+# The rgeo-activerecord gem installs several patches to ActiveRecord
+# to support services needed by spatial adapters.
+
+module ActiveRecord
+end
+
+
 # Implementation files
-require 'rgeo/active_record/common.rb'
-require 'rgeo/active_record/arel_modifications'
-require 'rgeo/active_record/ar_modifications'
+require 'rgeo/active_record/version.rb'
+require 'rgeo/active_record/spatial_expressions.rb'
+require 'rgeo/active_record/arel_spatial_queries'
+require 'rgeo/active_record/common_adapter_elements.rb'
+require 'rgeo/active_record/ar_factory_settings'

data/lib/rgeo/active_record/{ar_modifications.rb → ar_factory_settings.rb}

@@ -37,10 +37,6 @@
 require 'active_record'
 
 
-# RGeo extensions to ActiveRecord are installed when one of the spatial
-# connection adapters is needed. These modifications require ActiveRecord
-# 3.0.3 or later.
-
 module ActiveRecord
   
   
@@ -64,9 +60,6 @@ module ActiveRecord
   class Base
     
     
-    self.attribute_types_cached_by_default << :geometry
-    
-    
     class_attribute :rgeo_factory_generator, :instance_writer => false
     self.rgeo_factory_generator = nil
     
@@ -110,37 +103,6 @@ module ActiveRecord
       end
       
       
-      # :stopdoc:
-      alias_method :columns_without_rgeo_modification, :columns
-      def columns
-        unless defined?(@columns) && @columns
-          columns_without_rgeo_modification.each do |column_|
-            column_.set_ar_class(self) if column_.respond_to?(:set_ar_class)
-          end
-        end
-        @columns
-      end
-      # :startdoc:
-      
-    end
-    
-  end
-  
-  
-  module ConnectionAdapters  # :nodoc:
-    
-    class TableDefinition  # :nodoc:
-      
-      ::RGeo::ActiveRecord::GEOMETRY_TYPES.each do |type_|
-        method_ = <<-END_METHOD
-          def #{type_}(*args_)
-            opts_ = args_.extract_options!
-            args_.each{ |name_| column(name_, '#{type_}', opts_) }
-          end
-        END_METHOD
-        class_eval(method_, __FILE__, __LINE__-5)
-      end
-      
     end
     
   end

data/lib/rgeo/active_record/arel_spatial_queries.rb

@@ -0,0 +1,250 @@
+# -----------------------------------------------------------------------------
+# 
+# Mysqlgeo adapter for ActiveRecord
+# 
+# -----------------------------------------------------------------------------
+# Copyright 2010 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.
+# -----------------------------------------------------------------------------
+;
+
+
+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_)
+        name_ = st_func(node_.name)
+        exprs_ = []
+        node_.expressions.each_with_index do |expr_, index_|
+          exprs_ << (node_.spatial_argument?(index_) ? visit_in_spatial_context(expr_) : visit(expr_))
+        end
+        "#{name_}(#{node_.distinct ? 'DISTINCT ' : ''}#{exprs_.join(', ')})#{node_.alias ? " AS #{visit node_.alias}" : ''}"
+      end
+      
+      
+      # Returns a true value if the given node is of spatial type-- that
+      # is, if it is a spatial literal or a reference to a spatial
+      # attribute.
+      
+      def node_has_spatial_type?(node_)
+        case node_
+        when ::Arel::Attribute
+          @connection.instance_variable_set(:@_getting_columns, true)
+          begin
+            col_ = @engine.columns_hash[node_.name.to_s] unless @engine == ::ActiveRecord::Base
+            col_ && col_.respond_to?(:spatial?) && col_.spatial? ? true : false
+          ensure
+            @connection.instance_variable_set(:@_getting_columns, false)
+          end
+        when ::RGeo::ActiveRecord::SpatialNamedFunction
+          node_.spatial_result?
+        when ::RGeo::ActiveRecord::SpatialConstantNode, ::RGeo::Feature::Instance
+          true
+        else
+          false
+        end
+      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_)
+        case node_
+        when ::String
+          "#{st_func('ST_WKTToSQL')}(#{visit_String(node_)})"
+        when ::RGeo::Feature::Instance
+          visit_RGeo_Feature_Instance(node_)
+        else
+          visit(node_)
+        end
+      end
+      
+      
+      def _check_equality_for_rgeo(node_, negate_)  # :nodoc:
+        left_ = node_.left
+        right_ = node_.right
+        if !@connection.instance_variable_get(:@_getting_columns) && !right_.nil? && (node_has_spatial_type?(left_) || node_has_spatial_type?(right_))
+          "#{negate_ ? 'NOT ' : ''}#{st_func('ST_Equals')}(#{visit_in_spatial_context(left_)}, #{visit_in_spatial_context(right_)})"
+        else
+          false
+        end
+      end
+      
+      
+      # Override equality nodes to use the ST_Equals function if at least
+      # one of the operands is a spatial node.
+      
+      def visit_Arel_Nodes_Equality(node_)
+        _check_equality_for_rgeo(node_, false) || super
+      end
+      
+      
+      # Override equality nodes to use the ST_Equals function if at least
+      # one of the operands is a spatial node.
+      
+      def visit_Arel_Nodes_NotEqual(node_)
+        _check_equality_for_rgeo(node_, true) || super
+      end
+      
+    end
+    
+    
+  end
+  
+end
+
+
+# :stopdoc:
+
+
+# This node wraps an RGeo feature and gives it spatial expression
+# constructors.
+
+module RGeo
+  module ActiveRecord
+    
+    class SpatialConstantNode
+      
+      include ::RGeo::ActiveRecord::SpatialExpressions
+      
+      def initialize(delegate_)
+        @delegate = delegate_
+      end
+      
+      attr_reader :delegate
+      
+    end
+    
+  end
+end
+
+
+# Make sure the standard Arel visitors can handle RGeo feature objects
+# by default.
+
+module Arel
+  module Visitors
+    class Visitor
+      def visit_RGeo_ActiveRecord_SpatialConstantNode(node_)
+        if respond_to?(:visit_in_spatial_context)
+          visit_in_spatial_context(node_.delegate)
+        else
+          visit(node_.delegate)
+        end
+      end
+    end
+    class Dot
+      alias :visit_RGeo_Feature_Instance :visit_String
+    end
+    class DepthFirst
+      alias :visit_RGeo_Feature_Instance :terminal
+    end
+    class ToSql
+      alias :visit_RGeo_Feature_Instance :visit_String
+    end
+  end
+end
+
+
+# Add tools to build spatial structures in the AST.
+# This stuff requires Arel 2.1 or later.
+
+if defined?(::Arel::Nodes::NamedFunction)
+  
+  # Allow chaining of predications from named functions
+  # (Hack because Arel doesn't do this but should.)
+  ::Arel::Nodes::NamedFunction.class_eval do
+    include ::Arel::Predications unless include?(::Arel::Predications)
+  end
+  
+  # Allow chaining of spatial expressions from attributes
+  ::Arel::Attribute.class_eval do
+    include ::RGeo::ActiveRecord::SpatialExpressions
+  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 ::RGeo::ActiveRecord::SpatialNamedFunction < ::Arel::Nodes::NamedFunction
+    
+    include ::RGeo::ActiveRecord::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
+  
+else
+  
+  # A dummy SpatialNamedFunction for pre-2.1 versions of Arel.
+  class ::RGeo::ActiveRecord::SpatialNamedFunction; end
+  
+end
+
+
+# :startdoc:

data/lib/rgeo/active_record/common_adapter_elements.rb

@@ -0,0 +1,226 @@
+# -----------------------------------------------------------------------------
+# 
+# Common tools for spatial adapters for ActiveRecord
+# 
+# -----------------------------------------------------------------------------
+# Copyright 2010 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.
+# -----------------------------------------------------------------------------
+;
+
+
+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 = {
+      :spatial => {:type => 'geometry'},
+      :geometry => {},
+      :point => {},
+      :line_string => {},
+      :polygon => {},
+      :geometry_collection => {},
+      :multi_line_string => {},
+      :multi_point => {},
+      :multi_polygon => {},
+    }.freeze
+    
+    
+    # The default factory generator for ActiveRecord::Base.
+    
+    DEFAULT_FACTORY_GENERATOR = ::Proc.new do |config_|
+      if config_.delete(:geographic)
+        ::RGeo::Geographic.spherical_factory(config_)
+      else
+        ::RGeo::Cartesian.preferred_factory(config_)
+      end
+    end
+    
+    
+    # Index definition struct with a spatial flag field.
+    
+    class SpatialIndexDefinition < ::Struct.new(:table, :name, :unique, :columns, :lengths, :spatial)
+    end
+    
+    
+    # Returns a feature type module given a string type.
+    
+    def self.geometric_type_from_name(name_)
+      case name_.to_s
+      when /^geometry/i then ::RGeo::Feature::Geometry
+      when /^point/i then ::RGeo::Feature::Point
+      when /^linestring/i then ::RGeo::Feature::LineString
+      when /^polygon/i then ::RGeo::Feature::Polygon
+      when /^geometrycollection/i then ::RGeo::Feature::GeometryCollection
+      when /^multipoint/i then ::RGeo::Feature::MultiPoint
+      when /^multilinestring/i then ::RGeo::Feature::MultiLineString
+      when /^multipolygon/i then ::RGeo::Feature::MultiPolygon
+      else nil
+      end
+    end
+    
+    
+  end
+  
+end
+
+
+# :stopdoc:
+
+
+# Make sure a few things are autoloaded before we modify them.
+::Arel::Attributes
+::ActiveRecord::ConnectionAdapters::AbstractAdapter
+::ActiveRecord::ConnectionAdapters::TableDefinition
+::ActiveRecord::ConnectionAdapters::Table
+::ActiveRecord::Base
+::ActiveRecord::SchemaDumper
+
+
+# Hack Arel Attributes dispatcher to recognize geometry columns.
+# This is deprecated but necessary to support legacy Arel versions.
+
+module Arel
+  module Attributes
+    class << self
+      if method_defined?(:for)
+        alias_method :for_without_rgeo_modification, :for
+        def for(column_)
+          column_.type == :spatial ? Attribute : for_without_rgeo_modification(column_)
+        end
+      end
+    end
+  end
+end
+
+
+# Provide methods for each geometric subtype during table definitions.
+
+module ActiveRecord
+  module ConnectionAdapters
+    class TableDefinition
+      
+      alias_method :method_missing_without_rgeo_modification, :method_missing
+      def method_missing(method_name_, *args_, &block_)
+        if @base.respond_to?(:spatial_column_constructor) && (info_ = @base.spatial_column_constructor(method_name_))
+          type_ = (info_.delete(:type) || method_name_).to_s
+          opts_ = args_.extract_options!.merge(info_)
+          args_.each do |name_|
+            column(name_, type_, opts_)
+          end
+        else
+          method_missing_without_rgeo_modification(method_name_, *args_, &block_)
+        end
+      end
+      
+    end
+  end
+end
+
+
+# Provide methods for each geometric subtype during table changes.
+
+module ActiveRecord
+  module ConnectionAdapters
+    class Table
+      
+      alias_method :method_missing_without_rgeo_modification, :method_missing
+      def method_missing(method_name_, *args_, &block_)
+        if @base.respond_to?(:spatial_column_constructor) && (info_ = @base.spatial_column_constructor(method_name_))
+          type_ = (info_.delete(:type) || method_name_).to_s
+          opts_ = args_.extract_options!.merge(info_)
+          args_.each do |name_|
+            @base.add_column(@table_name, name_, type_, opts_)
+          end
+        else
+          method_missing_without_rgeo_modification(method_name_, *args_, &block_)
+        end
+      end
+      
+    end
+  end
+end
+
+
+# When creating column objects, cause the enclosing ActiveRecord class
+# to be set on any column that recognizes it. This is commonly used by
+# spatial column subclasses.
+
+module ActiveRecord
+  class Base
+    class << self
+      alias_method :columns_without_rgeo_modification, :columns
+      def columns
+        unless defined?(@columns) && @columns
+          columns_without_rgeo_modification.each do |column_|
+            column_.set_ar_class(self) if column_.respond_to?(:set_ar_class)
+          end
+        end
+        @columns
+      end
+    end
+  end
+end
+
+
+# Hack schema dumper to output spatial index flag
+
+module ActiveRecord
+  class SchemaDumper
+    private
+    def indexes(table_, stream_)
+      if (indexes_ = @connection.indexes(table_)).any?
+        add_index_statements_ = indexes_.map do |index_|
+          statement_parts_ = [ ('add_index ' + index_.table.inspect) ]
+          statement_parts_ << index_.columns.inspect
+          statement_parts_ << (':name => ' + index_.name.inspect)
+          statement_parts_ << ':unique => true' if index_.unique
+          statement_parts_ << ':spatial => true' if index_.respond_to?(:spatial) && index_.spatial
+          index_lengths_ = index_.lengths.compact if index_.lengths.is_a?(::Array)
+          statement_parts_ << (':length => ' + ::Hash[*index_.columns.zip(index_.lengths).flatten].inspect) if index_lengths_.present?
+          '  ' + statement_parts_.join(', ')
+        end
+        stream_.puts add_index_statements_.sort.join("\n")
+        stream_.puts
+      end
+    end
+  end
+end
+
+
+# Tell ActiveRecord to cache spatial attribute values so they don't get
+# re-parsed on every access.
+
+::ActiveRecord::Base.attribute_types_cached_by_default << :spatial
+
+
+# :startdoc:

data/lib/rgeo/active_record/spatial_expressions.rb

@@ -0,0 +1,314 @@
+# -----------------------------------------------------------------------------
+# 
+# Common tools for spatial adapters for ActiveRecord
+# 
+# -----------------------------------------------------------------------------
+# Copyright 2010 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.
+# -----------------------------------------------------------------------------
+;
+
+
+module RGeo
+  
+  module ActiveRecord
+    
+    
+    # Returns true if spatial expressions (i.e. the methods in the
+    # SpatialExpressions module) are supported. Generally, this is true
+    # if Arel is at version 2.1 or later.
+    
+    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.
+    # 
+    # These functions require Arel 2.1 or later.
+    
+    module SpatialExpressions
+      
+      
+      #--
+      # Generic functions
+      #++
+      
+      def st_function(function_, *args_)
+        spatial_info_ = args_.last.is_a?(::Array) ? args_.pop : []
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new(function_, [self] + args_, spatial_info_)
+      end
+      
+      
+      #--
+      # Geometry functions
+      #++
+      
+      def st_dimension
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Dimension', [self], [false, true])
+      end
+      
+      def st_geometrytype
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_GeometryType', [self], [false, true])
+      end
+      
+      def st_astext
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_AsText', [self], [false, true])
+      end
+      
+      def st_asbinary
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_AsBinary', [self], [false, true])
+      end
+      
+      def st_srid
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_SRID', [self], [false, true])
+      end
+      
+      def st_isempty
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_IsEmpty', [self], [false, true])
+      end
+      
+      def st_issimple
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_IsSimple', [self], [false, true])
+      end
+      
+      def st_boundary
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Boundary', [self], [true, true])
+      end
+      
+      def st_envelope
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Envelope', [self], [true, true])
+      end
+      
+      def st_equals(rhs_)
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Equals', [self, rhs_], [false, true, true])
+      end
+      
+      def st_disjoint(rhs_)
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Disjoint', [self, rhs_], [false, true, true])
+      end
+      
+      def st_intersects(rhs_)
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Intersects', [self, rhs_], [false, true, true])
+      end
+      
+      def st_touches(rhs_)
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Touches', [self, rhs_], [false, true, true])
+      end
+      
+      def st_crosses(rhs_)
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Crosses', [self, rhs_], [false, true, true])
+      end
+      
+      def st_within(rhs_)
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Within', [self, rhs_], [false, true, true])
+      end
+      
+      def st_contains(rhs_)
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Contains', [self, rhs_], [false, true, true])
+      end
+      
+      def st_overlaps(rhs_)
+        ::RGeo::ActiveRecord::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_
+        ::RGeo::ActiveRecord::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_
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Distance', args_, [false, true, true, false])
+      end
+      
+      def st_intersection(rhs_)
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Intersection', [self, rhs_], [true, true, true])
+      end
+      
+      def st_difference(rhs_)
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Difference', [self, rhs_], [true, true, true])
+      end
+      
+      def st_union(rhs_)
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Union', [self, rhs_], [true, true, true])
+      end
+      
+      def st_symdifference(rhs_)
+        ::RGeo::ActiveRecord::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_
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Buffer', args_, [true, true, false])
+      end
+      
+      def st_convexhull
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_ConvexHull', [self], [true, true])
+      end
+      
+      
+      #--
+      # Point functions
+      #++
+      
+      def st_x
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_X', [self], [false, true])
+      end
+      
+      def st_y
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Y', [self], [false, true])
+      end
+      
+      def st_z
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Z', [self], [false, true])
+      end
+      
+      def st_m
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_M', [self], [false, true])
+      end
+      
+      
+      #--
+      # Curve functions
+      #++
+      
+      def st_startpoint
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_StartPoint', [self], [true, true])
+      end
+      
+      def st_endpoint
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_EndPoint', [self], [true, true])
+      end
+      
+      def st_isclosed
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_IsClosed', [self], [false, true])
+      end
+      
+      def st_isring
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_IsRing', [self], [false, true])
+      end
+      
+      def st_length(units_=nil)
+        args_ = [self]
+        args_ << units.to_s if units_
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Length', args_, [false, true, false])
+      end
+      
+      
+      #--
+      # LineString functions
+      #++
+      
+      def st_numpoints
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_NumPoints', [self], [false, true])
+      end
+      
+      def st_pointn(n_)
+        ::RGeo::ActiveRecord::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_
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_StartPoint', args_, [false, true, false])
+      end
+      
+      def st_centroid
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Centroid', [self], [true, true])
+      end
+      
+      def st_pointonsurface
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_PointOnSurface', [self], [true, true])
+      end
+      
+      
+      #--
+      # Polygon functions
+      #++
+      
+      def st_exteriorring
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_ExteriorRing', [self], [true, true])
+      end
+      
+      def st_numinteriorrings
+        # Note: the name difference is intentional. The standard
+        # names this function incorrectly.
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_NumInteriorRing', [self], [false, true])
+      end
+      
+      def st_interiorringn(n_)
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_InteriorRingN', [self, n_.to_i], [true, true, false])
+      end
+      
+      
+      #--
+      # GeometryCollection functions
+      #++
+      
+      def st_numgeometries
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_NumGeometries', [self], [false, true])
+      end
+      
+      def st_geometryn(n_)
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_GeometryN', [self, n_.to_i], [true, true, false])
+      end
+      
+      
+    end
+    
+    
+  end
+  
+end
+
+
+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.
+  # 
+  # Requires Arel 2.1 or later.
+  
+  def self.spatial(arg_)
+    ::RGeo::ActiveRecord::SpatialConstantNode.new(arg_)
+  end
+  
+end

data/lib/rgeo/active_record/task_hacker.rb

@@ -53,10 +53,15 @@ module RGeo
         end
         
         def call(task_)
-          config_ = ::ActiveRecord::Base.configurations[@env || ::Rails.env || 'development']
-          if @pattern === config_['adapter']
-            task_.actions.delete_if{ |a_| a_ != self }
-            @proc.call(config_)
+          env_ = @env || ::Rails.env || 'development'
+          config_ = ::ActiveRecord::Base.configurations[env_]
+          if config_
+            if @pattern === config_['adapter']
+              task_.actions.delete_if{ |a_| a_ != self }
+              @proc.call(config_)
+            end
+          else
+            puts "WARNING: Could not find environment #{env_.inspect} in your database.yml"
           end
         end
         

data/lib/rgeo/active_record/{arel_modifications.rb → version.rb}

@@ -1,6 +1,6 @@
 # -----------------------------------------------------------------------------
 # 
-# Mysqlgeo adapter for ActiveRecord
+# Version of rgeo-activerecord
 # 
 # -----------------------------------------------------------------------------
 # Copyright 2010 Daniel Azuma
@@ -34,44 +34,22 @@
 ;
 
 
-require 'arel'
+begin
+  require 'versionomy'
+rescue ::LoadError
+end
 
 
-# The rgeo-activerecord gem installs several minor hacks into Arel to
-# support geometry values in the AST.
-module Arel
-  
-  # Hack Attributes dispatcher to recognize geometry columns.
-  # This is deprecated but necessary to support legacy Arel versions.
-  module Attributes  # :nodoc:
-    class << self
-      if method_defined?(:for)
-        alias_method :for_without_geometry, :for
-        def for(column_)
-          column_.type == :geometry ? Attribute : for_without_geometry(column_)
-        end
-      end
-    end
-  end
+module RGeo
   
-  # Visitors are modified to handle RGeo::Feature::Instance objects in
-  # the AST.
-  module Visitors
-    
-    # RGeo adds visit_RGeo_Feature_Instance to the Dot visitor.
-    class Dot
-      alias :visit_RGeo_Feature_Instance :visit_String
-    end
+  module ActiveRecord
     
-    # RGeo adds visit_RGeo_Feature_Instance to the DepthFirst visitor.
-    class DepthFirst
-      alias :visit_RGeo_Feature_Instance :terminal
-    end
+    # Current version of RGeo::ActiveRecord as a frozen string
+    VERSION_STRING = ::File.read(::File.dirname(__FILE__)+'/../../../Version').strip.freeze
     
-    # RGeo adds visit_RGeo_Feature_Instance to the ToSql visitor.
-    class ToSql
-      alias :visit_RGeo_Feature_Instance :visit_String
-    end
+    # Current version of RGeo::ActiveRecord as a Versionomy object, if the
+    # Versionomy gem is available; otherwise equal to VERSION_STRING.
+    VERSION = defined?(::Versionomy) ? ::Versionomy.parse(VERSION_STRING) : VERSION_STRING
     
   end
   

data/test/tc_basic.rb

@@ -45,6 +45,11 @@ module RGeo
       class TestBasic < ::Test::Unit::TestCase  # :nodoc:
         
         
+        def test_has_version
+          assert_not_nil(::RGeo::ActiveRecord::VERSION)
+        end
+        
+        
         def test_default_factory_generator
           ::ActiveRecord::Base.rgeo_factory_generator = nil
           factory_ = ::ActiveRecord::Base.rgeo_factory_for_column(:hello).call(:has_z_coordinate => true, :srid => 4326)

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
-  - 4
-  version: 0.2.4
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Daniel Azuma
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-13 00:00:00 -08:00
+date: 2011-01-26 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -73,10 +73,12 @@ extra_rdoc_files:
 - README.rdoc
 files: 
 - lib/rgeo/active_record/adapter_test_helper.rb
-- lib/rgeo/active_record/ar_modifications.rb
-- lib/rgeo/active_record/arel_modifications.rb
-- lib/rgeo/active_record/common.rb
+- lib/rgeo/active_record/ar_factory_settings.rb
+- lib/rgeo/active_record/arel_spatial_queries.rb
+- lib/rgeo/active_record/common_adapter_elements.rb
+- lib/rgeo/active_record/spatial_expressions.rb
 - lib/rgeo/active_record/task_hacker.rb
+- lib/rgeo/active_record/version.rb
 - lib/rgeo/active_record.rb
 - History.rdoc
 - README.rdoc

data/lib/rgeo/active_record/common.rb

@@ -1,148 +0,0 @@
-# -----------------------------------------------------------------------------
-# 
-# Common tools for spatial adapters for ActiveRecord
-# 
-# -----------------------------------------------------------------------------
-# Copyright 2010 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.
-# -----------------------------------------------------------------------------
-;
-
-
-module RGeo
-  
-  module ActiveRecord
-    
-    
-    # Additional column types for geometries.
-    GEOMETRY_TYPES = [:geometry, :point, :line_string, :polygon, :geometry_collection, :multi_line_string, :multi_point, :multi_polygon].freeze
-    
-    # The default factory generator for ActiveRecord::Base.
-    DEFAULT_FACTORY_GENERATOR = ::Proc.new do |config_|
-      if config_.delete(:geographic)
-        ::RGeo::Geographic.spherical_factory(config_)
-      else
-        ::RGeo::Cartesian.preferred_factory(config_)
-      end
-    end
-    
-    
-    # A set of common Arel visitor hacks for spatial ToSql visitors.
-    
-    module SpatialToSql
-      
-      # Map a standard OGC SQL function name to the actual name used by
-      # a particular database.
-      def st_func(standard_name_)
-        standard_name_
-      end
-      
-      # Returns true if the given node is of spatial type-- that is, if
-      # it is a spatial literal or a reference to a spatial attribute.
-      def node_has_spatial_type?(node_)
-        case node_
-        when ::Arel::Attribute
-          @connection.instance_variable_set(:@_getting_columns, true)
-          begin
-            col_ = @engine.columns_hash[node_.name.to_s] unless @engine == ::ActiveRecord::Base
-            col_ && col_.respond_to?(:spatial?) && col_.spatial?
-          ensure
-            @connection.instance_variable_set(:@_getting_columns, false)
-          end
-        when ::RGeo::Feature::Instance
-          true
-        else
-          false
-        end
-      end
-      
-      # Generates SQL for a spatial node.
-      def visit_spatial(node_)
-        case node_
-        when ::String
-          "#{st_func('ST_WKTToSQL')}(#{visit_String(node_)})"
-        when ::RGeo::Feature::Instance
-          visit_RGeo_Feature_Instance(node_)
-        else
-          visit(node_)
-        end
-      end
-      
-      def visit_Arel_Nodes_Equality(node_)  # :nodoc:
-        right_ = node_.right
-        left_ = node_.left
-        if !@connection.instance_variable_get(:@_getting_columns) && (node_has_spatial_type?(right_) || node_has_spatial_type?(left_))
-          "#{st_func('ST_Equals')}(#{visit_spatial(left_)}, #{visit_spatial(right_)})"
-        else
-          super
-        end
-      end
-      
-      def visit_Arel_Nodes_NotEqual(node_)  # :nodoc:
-        right_ = node_.right
-        left_ = node_.left
-        if !@connection.instance_variable_get(:@_getting_columns) && (node_has_spatial_type?(right_) || node_has_spatial_type?(left_))
-          "NOT #{st_func('ST_Equals')}(#{visit_spatial(left_)}, #{visit_spatial(right_)})"
-        else
-          super
-        end
-      end
-      
-    end
-    
-    
-    # Index definition struct with a spatial flag field.
-    
-    class SpatialIndexDefinition < ::Struct.new(:table, :name, :unique, :columns, :lengths, :spatial)
-    end
-    
-    
-    class << self
-      
-      
-      # Returns a feature type module given a string type.
-      
-      def geometric_type_from_name(name_)
-        case name_.downcase
-        when 'geometry' then ::RGeo::Feature::Geometry
-        when 'point' then ::RGeo::Feature::Point
-        when 'linestring' then ::RGeo::Feature::LineString
-        when 'polygon' then ::RGeo::Feature::Polygon
-        when 'geometrycollection' then ::RGeo::Feature::GeometryCollection
-        when 'multipoint' then ::RGeo::Feature::MultiPoint
-        when 'multilinestring' then ::RGeo::Feature::MultiLineString
-        when 'multipolygon' then ::RGeo::Feature::MultiPolygon
-        else nil
-        end
-      end
-      
-    end
-    
-  end
-  
-end