activerecord-spatialite-adapter 0.2.0

data/History.rdoc

@@ -0,0 +1,8 @@
+=== 0.2.0 / 2010-12-07
+
+* Initial public alpha release. Spun activerecord-spatialite-adapter off from the core rgeo gem.
+* You can now set the factory for a specific column by name.
+* Dropping a table that had spatial indexes tied to it didn't remove the index tables. Fixed.
+* You can now remove spatial indexes by name.
+
+For earlier history, see the History file for the rgeo gem.

data/README.rdoc

@@ -0,0 +1,155 @@
+== SpatiaLite \ActiveRecord Adapter
+
+The SpatiaLite \ActiveRecord Adapter is an \ActiveRecord connection
+adapter based on the standard sqlite3 adapter. It extends the standard
+adapter to provide support for spatial extensions using SpatiaLite, using
+the {RGeo}[http://github.com/dazuma/rgeo] library to represent spatial
+data in Ruby. Like the standard sqlite3 adapter, this adapter requires
+the sqlite3-ruby gem.
+
+=== Usage
+
+To use this adapter, add this gem, "activerecord-spatialite-adapter",
+to your Gemfile, and then request the adapter name "spatialite" in
+your database connection configuration (which, for a Rails application,
+is in the config/database.yml file). The other database connection
+configuration parameters are the same as for the stock sqlite3 adapter,
+with the exception of one additional parameter, <tt>libspatialite</tt>,
+which should be set to the full path to the libspatialite shared library,
+if it is not installed in a standard place (such as /usr/local or
+/opt/local).
+
+First, this adapter extends the migration syntax to support creating 
+spatial columns and indexes. To create a spatial column, use the
+<tt>:geometry</tt> type, or any of the OGC spatial types such as
+<tt>:point</tt> or <tt>:line_string</tt>. To create a spatial index, set
+the <tt>:spatial</tt> option to true.
+
+Examples:
+
+ create_table :spatial_table do |t|
+   t.column :latlon, :point  # or t.point :latlon
+   t.line_string :path
+   t.geometry :shape
+ end
+ change_table :spatial_table do |t|
+   t.index :latlon, :spatial => true
+ end
+
+When this adapter is in use, spatial attributes in your \ActiveRecord
+objects will have RGeo geometry values. You can set spatial attributes
+either to RGeo geometry objects, or to strings in WKT (well-known text)
+format, which the adapter will automatically convert to geometry objects.
+
+To specify the RGeo geometry factory, you can either set an explicit
+factory for a column, or provide a factory generator that will yield the
+appropriate factory for the table's spatial columns based on the value.
+For the former, call the set_rgeo_factory_for_column class method on your
+\ActiveRecord class. For the latter, set the rgeo_factory_generator class
+attribute. This generator should understand at least the <tt>:srid</tt>
+option, which will be provided based on the column's specified SRID. Note
+that the spatialite adapter does not currently support Z or M coordinates,
+as it's unclear to me whether SpatiaLite itself supports them. The
+set_rgeo_factory_for_column and rgeo_factory_generator methods are
+actually implemented and documented in the "rgeo-activerecord" gem.
+
+Examples, given the spatial table defined above:
+
+ class SpatialTable < ActiveRecord::Base
+   
+   # By default, use the GEOS implementation for spatial columns.
+   self.rgeo_factory_generator = RGeo::Geos.method(:factory)
+   
+   # But use a geographic implementation for the :latlon column.
+   set_rgeo_factory_for_column(:latlon, RGeo::Geographic.spherical_factory)
+   
+ end
+
+Now you can interact with the data using the RGeo types:
+
+ rec = SpatialTable.new
+ rec.latlon = 'POINT(-122 47)'   # You can set by feature object or WKT.
+ loc = rec.latlon                # Accessing always returns a feature object, in
+                                 # this case, a geographic that understands latitude.
+ loc.latitude                    # => 47
+ rec.shape = loc                 # the factory for the :shape column is GEOS, so the
+                                 # value will be cast from geographic to GEOS.
+ RGeo::Geos.is_geos?(rec.shape)  # => true
+
+=== Installation
+
+This adapter has the following requirements:
+
+* Ruby 1.8.7 or later. Ruby 1.9.2 or later preferred.
+* SpatiaLite 2.3 or later (2.4 recommended).
+* \ActiveRecord 3.0.3 or later. Earlier versions will not work.
+* rgeo gem 0.2.0 or later.
+* rgeo-activerecord gem 0.2.0 or later.
+* sqlite3 gem 1.3 or later.
+
+Install this adapter as a gem:
+
+ gem install activerecord-spatialite-adapter
+
+See the README for the "rgeo" gem, a required dependency, for further
+installation information.
+
+=== Known bugs and limitations
+
+The spatialite adapter works in principle, but there are a few known holes
+in the functionality. Notably, things that require the alter_table
+mechanism may not function properly, because the current sqlite3
+implementation doesn't properly preserve triggers. This means, among
+other things, removing columns in tables with spatial information can
+cause the remaining spatial columns to fail. However, most simple things
+work, including creating tables with geometric columns, adding geometric
+columns to existing tables, and creating and removing spatial R*tree
+indexes. Note that this adapter is not yet well tested.
+
+=== Development and support
+
+Documentation is available at http://virtuoso.rubyforge.org/activerecord-spatialite-adapter/README_rdoc.html
+
+Source code is hosted on Github at http://github.com/dazuma/activerecord-spatialite-adapter
+
+Contributions are welcome. Fork the project on Github.
+
+Report bugs on Github issues at http://github.org/dazuma/activerecord-spatialite-adapter/issues
+
+Contact the author at dazuma at gmail dot com.
+
+=== Acknowledgments
+
+RGeo is written by Daniel Azuma (http://www.daniel-azuma.com).
+
+Development of RGeo is sponsored by GeoPage, Inc. (http://www.geopage.com).
+
+=== License
+
+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.

data/Version

@@ -0,0 +1 @@
+0.2.0

data/lib/active_record/connection_adapters/spatialite_adapter.rb

@@ -0,0 +1,518 @@
+# -----------------------------------------------------------------------------
+# 
+# SpatiaLite 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.
+# -----------------------------------------------------------------------------
+;
+
+
+require 'rgeo/active_record'
+require 'active_record/connection_adapters/sqlite3_adapter'
+
+
+# :stopdoc:
+
+module Arel
+  module Visitors
+    VISITORS['spatialite'] = ::Arel::Visitors::SQLite
+  end
+end
+
+# :startdoc:
+
+
+# The activerecord-spatialite-adapter gem installs the *spatialite*
+# connection adapter into ActiveRecord.
+
+module ActiveRecord
+  
+  
+  # ActiveRecord looks for the spatialite_connection factory method in
+  # this class.
+  
+  class Base
+    
+    
+    # Create a spatialite connection adapter.
+    
+    def self.spatialite_connection(config_)
+      unless 'spatialite' == config_[:adapter]
+        raise ::ArgumentError, 'adapter name should be "spatialite"'
+      end
+      unless config_[:database]
+        raise ::ArgumentError, "No database file specified. Missing argument: database"
+      end
+      
+      # Allow database path relative to Rails.root, but only if
+      # the database path is not the special path that tells
+      # Sqlite to build a database only in memory.
+      if defined?(::Rails.root) && ':memory:' != config_[:database]
+        config_[:database] = ::File.expand_path(config_[:database], ::Rails.root)
+      end
+      
+      unless self.class.const_defined?(:SQLite3)
+        require_library_or_gem('sqlite3')
+      end
+      db_ = ::SQLite3::Database.new(config_[:database], :results_as_hash => true)
+      db_.busy_timeout(config_[:timeout]) unless config_[:timeout].nil?
+      
+      # Load SpatiaLite
+      path_ = config_[:libspatialite]
+      if path_ && (!::File.file?(path_) || !::File.readable?(path_))
+        raise "Cannot read libspatialite library at #{path_}"
+      end
+      unless path_
+        prefixes_ = ['/usr/local/spatialite', '/usr/local/libspatialite', '/usr/local', '/opt/local', '/sw/local', '/usr']
+        suffixes_ = ['so', 'dylib'].join(',')
+        prefixes_.each do |prefix_|
+          pa_ = ::Dir.glob("#{prefix_}/lib/libspatialite.{#{suffixes_}}")
+          if pa_.size > 0
+            path_ = pa_.first
+            break
+          end
+        end
+      end
+      unless path_
+        raise 'Cannot find libspatialite in the usual places. Please provide the path in the "libspatialite" config parameter.'
+      end
+      db_.enable_load_extension(1)
+      db_.load_extension(path_)
+      
+      ConnectionAdapters::SpatiaLiteAdapter.new(db_, logger, config_)
+    end
+    
+    
+  end
+  
+  
+  module ConnectionAdapters  # :nodoc:
+    
+    
+    class SpatiaLiteAdapter < SQLite3Adapter  # :nodoc:
+      
+      
+      ADAPTER_NAME = 'SpatiaLite'.freeze
+      
+      @@native_database_types = nil
+      
+      
+      def native_database_types
+        unless @@native_database_types
+          @@native_database_types = super.dup
+          @@native_database_types.merge!(:geometry => {:name => "geometry"}, :point => {:name => "point"}, :line_string => {:name => "linestring"}, :polygon => {:name => "polygon"}, :geometry_collection => {:name => "geometrycollection"}, :multi_point => {:name => "multipoint"}, :multi_line_string => {:name => "multilinestring"}, :multi_polygon => {:name => "multipolygon"})
+        end
+        @@native_database_types
+      end
+      
+      
+      def adapter_name
+        ADAPTER_NAME
+      end
+      
+      
+      def spatialite_version
+        @spatialite_version ||= SQLiteAdapter::Version.new(select_value('SELECT spatialite_version()'))
+      end
+      
+      
+      def quote(value_, column_=nil)
+        if ::RGeo::Feature::Geometry.check_type(value_)
+          "GeomFromWKB(X'#{::RGeo::WKRep::WKBGenerator.new(:hex_format => true).generate(value_)}', #{value_.srid})"
+        else
+          super
+        end
+      end
+      
+      
+      def columns(table_name_, name_=nil)  #:nodoc:
+        spatial_info_ = spatial_column_info(table_name_)
+        table_structure(table_name_).map do |field_|
+          col_ = SpatialColumn.new(field_['name'], field_['dflt_value'], field_['type'], field_['notnull'].to_i == 0)
+          info_ = spatial_info_[field_['name']]
+          if info_
+            col_.set_srid(info_[:srid])
+          end
+          col_
+        end
+      end
+      
+      
+      def spatial_indexes(table_name_, name_=nil)
+        table_name_ = table_name_.to_s
+        names_ = select_values("SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'idx_#{quote_string(table_name_)}_%' AND rootpage=0") || []
+        names_.map do |name_|
+          col_name_ = name_.sub("idx_#{table_name_}_", '')
+          ::RGeo::ActiveRecord::SpatialIndexDefinition.new(table_name_, name_, false, [col_name_], [], true)
+        end
+      end
+      
+      
+      def create_table(table_name_, options_={})
+        table_name_ = table_name_.to_s
+        table_definition_ = SpatialTableDefinition.new(self)
+        table_definition_.primary_key(options_[:primary_key] || ::ActiveRecord::Base.get_primary_key(table_name_.singularize)) unless options_[:id] == false
+        yield table_definition_ if block_given?
+        if options_[:force] && table_exists?(table_name_)
+          drop_table(table_name_, options_)
+        end
+        
+        create_sql_ = "CREATE#{' TEMPORARY' if options_[:temporary]} TABLE "
+        create_sql_ << "#{quote_table_name(table_name_)} ("
+        create_sql_ << table_definition_.to_sql
+        create_sql_ << ") #{options_[:options]}"
+        execute create_sql_
+        
+        table_definition_.spatial_columns.each do |col_|
+          execute("SELECT AddGeometryColumn('#{quote_string(table_name_)}', '#{quote_string(col_.name.to_s)}', #{col_.srid}, '#{quote_string(col_.type.to_s.gsub('_','').upcase)}', 'XY', #{col_.null ? 0 : 1})")
+        end
+      end
+      
+      
+      def drop_table(table_name_, options_={})
+        spatial_indexes(table_name_).each do |index_|
+          remove_index(table_name_, :spatial => true, :column => index_.columns[0])
+        end
+        execute("DELETE from geometry_columns where f_table_name='#{quote_string(table_name_.to_s)}'")
+        super
+      end
+      
+      
+      def add_column(table_name_, column_name_, type_, options_={})
+        if ::RGeo::ActiveRecord::GEOMETRY_TYPES.include?(type_.to_sym)
+          execute("SELECT AddGeometryColumn('#{quote_string(table_name_.to_s)}', '#{quote_string(column_name_.to_s)}', #{options_[:srid].to_i}, '#{quote_string(type_.to_s)}', 'XY', #{options_[:null] == false ? 0 : 1})")
+        else
+          super
+        end
+      end
+      
+      
+      def add_index(table_name_, column_name_, options_={})
+        if options_[:spatial]
+          column_name_ = column_name_.first if column_name_.kind_of?(::Array) && column_name_.size == 1
+          table_name_ = table_name_.to_s
+          column_name_ = column_name_.to_s
+          spatial_info_ = spatial_column_info(table_name_)
+          unless spatial_info_[column_name_]
+            raise ::ArgumentError, "Can't create spatial index because column '#{column_name_}' in table '#{table_name_}' is not a geometry column"
+          end
+          result_ = select_value("SELECT CreateSpatialIndex('#{quote_string(table_name_)}', '#{quote_string(column_name_)}')").to_i
+          if result_ == 0
+            raise ::ArgumentError, "Spatial index already exists on table '#{table_name_}', column '#{column_name_}'"
+          end
+          result_
+        else
+          super
+        end
+      end
+      
+      
+      def remove_index(table_name_, options_={})
+        if options_[:spatial]
+          table_name_ = table_name_.to_s
+          column_ = options_[:column]
+          if column_
+            column_ = column_[0] if column_.kind_of?(::Array)
+            column_ = column_.to_s
+          else
+            index_name_ = options_[:name]
+            unless index_name_
+              raise ::ArgumentError, "You need to specify a column or index name to remove a spatial index."
+            end
+            if index_name_ =~ /^idx_#{table_name_}_(\w+)$/
+              column_ = $1
+            else
+              raise ::ArgumentError, "Unknown spatial index name: #{index_name_.inspect}."
+            end
+          end
+          spatial_info_ = spatial_column_info(table_name_)
+          unless spatial_info_[column_]
+            raise ::ArgumentError, "Can't remove spatial index because column '#{column_}' in table '#{table_name_}' is not a geometry column"
+          end
+          index_name_ = "idx_#{table_name_}_#{column_}"
+          has_index_ = select_value("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='#{quote_string(index_name_)}'").to_i > 0
+          unless has_index_
+            raise ::ArgumentError, "Spatial index not present on table '#{table_name_}', column '#{column_}'"
+          end
+          execute("SELECT DisableSpatialIndex('#{quote_string(table_name_)}', '#{quote_string(column_)}')")
+          execute("DROP TABLE #{quote_table_name(index_name_)}")
+        else
+          super
+        end
+      end
+      
+      
+      def spatial_column_info(table_name_)
+        info_ = execute("SELECT * FROM geometry_columns WHERE f_table_name='#{quote_string(table_name_.to_s)}'")
+        result_ = {}
+        info_.each do |row_|
+          result_[row_['f_geometry_column']] = {
+            :name => row_['f_geometry_column'],
+            :type => row_['type'],
+            :dimension => row_['coord_dimension'],
+            :srid => row_['srid'],
+            :has_index => row_['spatial_index_enabled'],
+          }
+        end
+        result_
+      end
+      
+      
+      class SpatialTableDefinition < ConnectionAdapters::TableDefinition  # :nodoc:
+        
+        attr_reader :spatial_columns
+        
+        def initialize(base_)
+          super
+        end
+        
+        def column(name_, type_, options_={})
+          super
+          col_ = self[name_]
+          if ::RGeo::ActiveRecord::GEOMETRY_TYPES.include?(col_.type.to_sym)
+            col_.extend(GeometricColumnDefinitionMethods) unless col_.respond_to?(:srid)
+            col_.set_srid(options_[:srid].to_i)
+          end
+          self
+        end
+        
+        def to_sql
+          @columns.find_all{ |c_| !c_.respond_to?(:srid) }.map{ |c_| c_.to_sql } * ', '
+        end
+        
+        def spatial_columns
+          @columns.find_all{ |c_| c_.respond_to?(:srid) }
+        end
+        
+      end
+      
+      
+      module GeometricColumnDefinitionMethods  # :nodoc:
+        
+        def srid
+          defined?(@srid) ? @srid : 4326
+        end
+        
+        def set_srid(value_)
+          @srid = value_
+        end
+        
+      end
+      
+      
+      class SpatialColumn < ConnectionAdapters::SQLiteColumn  # :nodoc:
+        
+        
+        def initialize(name_, default_, sql_type_=nil, null_=true)
+          super(name_, default_, sql_type_, null_)
+          @geometric_type = ::RGeo::ActiveRecord.geometric_type_from_name(sql_type_)
+          @ar_class = ::ActiveRecord::Base
+          @srid = 0
+        end
+        
+        
+        def set_ar_class(val_)
+          @ar_class = val_
+        end
+        
+        def set_srid(val_)
+          @srid = val_
+        end
+        
+        
+        attr_reader :srid
+        attr_reader :geometric_type
+        
+        
+        def spatial?
+          type == :geometry
+        end
+        
+        
+        def klass
+          type == :geometry ? ::RGeo::Feature::Geometry : super
+        end
+        
+        
+        def type_cast(value_)
+          type == :geometry ? SpatialColumn.convert_to_geometry(value_, @ar_class, name, @srid) : super
+        end
+        
+        
+        def type_cast_code(var_name_)
+          type == :geometry ? "::ActiveRecord::ConnectionAdapters::SpatiaLiteAdapter::SpatialColumn.convert_to_geometry(#{var_name_}, self.class, #{name.inspect}, #{@srid})" : super
+        end
+        
+        
+        private
+        
+        
+        def simplified_type(sql_type_)
+          sql_type_ =~ /geometry|point|linestring|polygon/i ? :geometry : super
+        end
+        
+        
+        def self.convert_to_geometry(input_, ar_class_, column_name_, column_srid_)
+          case input_
+          when ::RGeo::Feature::Geometry
+            factory_ = ar_class_.rgeo_factory_for_column(column_name_, :srid => column_srid_)
+            ::RGeo::Feature.cast(input_, factory_)
+          when ::String
+            if input_.length == 0
+              nil
+            else
+              factory_ = ar_class_.rgeo_factory_for_column(column_name_, :srid => column_srid_)
+              if input_[0,1] == "\x00"
+                NativeFormatParser.new(factory_).parse(input_) rescue nil
+              else
+                ::RGeo::WKRep::WKTParser.new(factory_, :support_ewkt => true).parse(input_)
+              end
+            end
+          else
+            nil
+          end
+        end
+        
+        
+      end
+      
+      
+      class NativeFormatParser  # :nodoc:
+        
+        
+        def initialize(factory_)
+          @factory = factory_
+        end
+        
+        
+        def parse(data_)
+          @little_endian = data_[1,1] == "\x01"
+          srid_ = data_[2,4].unpack(@little_endian ? 'V' : 'N').first
+          begin
+            _start_scanner(data_)
+            obj_ = _parse_object(false)
+            _get_byte(0xfe)
+          ensure
+            _clean_scanner
+          end
+          obj_
+        end
+        
+        
+        def _parse_object(contained_)
+          _get_byte(contained_ ? 0x69 : 0x7c)
+          type_code_ = _get_integer
+          case type_code_
+          when 1
+            coords_ = _get_doubles(2)
+            @factory.point(*coords_)
+          when 2
+            _parse_line_string
+          when 3
+            interior_rings_ = (1.._get_integer).map{ _parse_line_string }
+            exterior_ring_ = interior_rings_.shift || @factory.linear_ring([])
+            @factory.polygon(exterior_ring_, interior_rings_)
+          when 4
+            @factory.multi_point((1.._get_integer).map{ _parse_object(1) })
+          when 5
+            @factory.multi_line_string((1.._get_integer).map{ _parse_object(2) })
+          when 6
+            @factory.multi_polygon((1.._get_integer).map{ _parse_object(3) })
+          when 7
+            @factory.collection((1.._get_integer).map{ _parse_object(true) })
+          else
+            raise ::RGeo::Error::ParseError, "Unknown type value: #{type_code_}."
+          end
+        end
+        
+        
+        def _parse_line_string
+          count_ = _get_integer
+          coords_ = _get_doubles(2 * count_)
+          @factory.line_string((0...count_).map{ |i_| @factory.point(*coords_[2*i_,2]) })
+        end
+        
+        
+        def _start_scanner(data_)
+          @_data = data_
+          @_len = data_.length
+          @_pos = 38
+        end
+        
+        
+        def _clean_scanner
+          @_data = nil
+        end
+        
+        
+        def _get_byte(expect_=nil)
+          if @_pos + 1 > @_len
+            raise ::RGeo::Error::ParseError, "Not enough bytes left to fulfill 1 byte"
+          end
+          str_ = @_data[@_pos, 1]
+          @_pos += 1
+          val_ = str_.unpack("C").first
+          if expect_ && expect_ != val_
+            raise ::RGeo::Error::ParseError, "Expected byte 0x#{expect_.to_s(16)} but got 0x#{val_.to_s(16)}"
+          end
+          val_
+        end
+        
+        
+        def _get_integer
+          if @_pos + 4 > @_len
+            raise ::RGeo::Error::ParseError, "Not enough bytes left to fulfill 1 integer"
+          end
+          str_ = @_data[@_pos, 4]
+          @_pos += 4
+          str_.unpack("#{@little_endian ? 'V' : 'N'}").first
+        end
+        
+        
+        def _get_doubles(count_)
+          len_ = 8 * count_
+          if @_pos + len_ > @_len
+            raise ::RGeo::Error::ParseError, "Not enough bytes left to fulfill #{count_} doubles"
+          end
+          str_ = @_data[@_pos, len_]
+          @_pos += len_
+          str_.unpack("#{@little_endian ? 'E' : 'G'}*")
+        end
+        
+        
+      end
+      
+      
+    end
+    
+  end
+  
+  
+end

data/test/tc_basic.rb

@@ -0,0 +1,216 @@
+# -----------------------------------------------------------------------------
+# 
+# Tests for the MysqlSpatial ActiveRecord adapter
+# 
+# -----------------------------------------------------------------------------
+# 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.
+# -----------------------------------------------------------------------------
+;
+
+require 'test/unit'
+require 'rgeo/active_record/adapter_test_helper'
+
+
+module RGeo
+  module ActiveRecord  # :nodoc:
+    module SpatiaLiteAdapter  # :nodoc:
+      module Tests  # :nodoc:
+        
+        class TestBasic < ::Test::Unit::TestCase  # :nodoc:
+          
+          
+          DATABASE_CONFIG_PATH = ::File.dirname(__FILE__)+'/database.yml'
+          
+          def self.before_open_database(params_)
+            database_ = params_[:config][:database]
+            dir_ = ::File.dirname(database_)
+            ::FileUtils.mkdir_p(dir_) unless dir_ == '.'
+            ::FileUtils.rm_f(database_)
+          end
+          
+          def self.initialize_database(params_)
+            params_[:connection].execute('SELECT InitSpatialMetaData()')
+          end
+          
+          include AdapterTestHelper
+          
+          
+          define_test_methods do
+            
+            
+            def populate_ar_class(content_)
+              klass_ = create_ar_class
+              case content_
+              when :latlon_point
+                klass_.connection.create_table(:spatial_test) do |t_|
+                  t_.column 'latlon', :point, :srid => 4326
+                end
+              end
+              klass_
+            end
+            
+            
+            def test_meta_data_present
+              result_ = DEFAULT_AR_CLASS.connection.select_value("SELECT COUNT(*) FROM spatial_ref_sys").to_i
+              assert_not_equal(0, result_)
+            end
+            
+            
+            def test_create_simple_geometry
+              klass_ = create_ar_class
+              klass_.connection.create_table(:spatial_test) do |t_|
+                t_.column 'latlon', :geometry
+              end
+              assert_equal(1, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
+              assert_equal(::RGeo::Feature::Geometry, klass_.columns.last.geometric_type)
+              assert(klass_.cached_attributes.include?('latlon'))
+              klass_.connection.drop_table(:spatial_test)
+              assert_equal(0, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
+            end
+            
+            
+            def test_create_point_geometry
+              klass_ = create_ar_class
+              klass_.connection.create_table(:spatial_test) do |t_|
+                t_.column 'latlon', :point
+              end
+              assert_equal(::RGeo::Feature::Point, klass_.columns.last.geometric_type)
+              assert(klass_.cached_attributes.include?('latlon'))
+            end
+            
+            
+            def test_create_geometry_with_index
+              klass_ = create_ar_class
+              klass_.connection.create_table(:spatial_test) do |t_|
+                t_.column 'latlon', :geometry
+              end
+              klass_.connection.change_table(:spatial_test) do |t_|
+                t_.index([:latlon], :spatial => true)
+              end
+              assert(klass_.connection.spatial_indexes(:spatial_test).last.spatial)
+              assert_equal(1, klass_.connection.select_value("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='idx_spatial_test_latlon'").to_i)
+              klass_.connection.drop_table(:spatial_test)
+              assert_equal(0, klass_.connection.select_value("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='idx_spatial_test_latlon'").to_i)
+            end
+            
+            
+            def test_set_and_get_point
+              klass_ = populate_ar_class(:latlon_point)
+              obj_ = klass_.new
+              assert_nil(obj_.latlon)
+              obj_.latlon = @factory.point(1, 2)
+              assert_equal(@factory.point(1, 2), obj_.latlon)
+              assert_equal(4326, obj_.latlon.srid)
+            end
+            
+            
+            def test_set_and_get_point_from_wkt
+              klass_ = populate_ar_class(:latlon_point)
+              obj_ = klass_.new
+              assert_nil(obj_.latlon)
+              obj_.latlon = 'POINT(1 2)'
+              assert_equal(@factory.point(1, 2), obj_.latlon)
+              assert_equal(4326, obj_.latlon.srid)
+            end
+            
+            
+            def test_save_and_load_point
+              klass_ = populate_ar_class(:latlon_point)
+              obj_ = klass_.new
+              obj_.latlon = @factory.point(1, 2)
+              obj_.save!
+              id_ = obj_.id
+              obj2_ = klass_.find(id_)
+              assert_equal(@factory.point(1, 2), obj2_.latlon)
+              assert_equal(4326, obj2_.latlon.srid)
+            end
+            
+            
+            def test_save_and_load_point_from_wkt
+              klass_ = populate_ar_class(:latlon_point)
+              obj_ = klass_.new
+              obj_.latlon = 'POINT(1 2)'
+              obj_.save!
+              id_ = obj_.id
+              obj2_ = klass_.find(id_)
+              assert_equal(@factory.point(1, 2), obj2_.latlon)
+              assert_equal(4326, obj2_.latlon.srid)
+            end
+            
+            
+            def test_add_column
+              klass_ = create_ar_class
+              klass_.connection.create_table(:spatial_test) do |t_|
+                t_.column('latlon', :geometry)
+              end
+              klass_.connection.change_table(:spatial_test) do |t_|
+                t_.column('geom2', :point, :srid => 4326)
+                t_.column('name', :string)
+              end
+              assert_equal(2, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
+              cols_ = klass_.columns
+              assert_equal(::RGeo::Feature::Geometry, cols_[-3].geometric_type)
+              assert_equal(-1, cols_[-3].srid)
+              assert_equal(::RGeo::Feature::Point, cols_[-2].geometric_type)
+              assert_equal(4326, cols_[-2].srid)
+              assert_nil(cols_[-1].geometric_type)
+            end
+            
+            
+            def test_readme_example
+              klass_ = create_ar_class
+              klass_.connection.create_table(:spatial_test) do |t_|
+                t_.column(:latlon, :point)
+                t_.line_string(:path)
+                t_.geometry(:shape)
+              end
+              klass_.connection.change_table(:spatial_test) do |t_|
+                t_.index(:latlon, :spatial => true)
+              end
+              klass_.class_eval do
+                self.rgeo_factory_generator = ::RGeo::Geos.method(:factory)
+                set_rgeo_factory_for_column(:latlon, ::RGeo::Geographic.spherical_factory)
+              end
+              rec_ = klass_.new
+              rec_.latlon = 'POINT(-122 47)'
+              loc_ = rec_.latlon
+              assert_equal(47, loc_.latitude)
+              rec_.shape = loc_
+              assert_equal(true, ::RGeo::Geos.is_geos?(rec_.shape))
+            end
+            
+            
+          end
+          
+        end
+        
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification 
+name: activerecord-spatialite-adapter
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
+platform: ruby
+authors: 
+- Daniel Azuma
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-07 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rgeo-activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 2
+        - 0
+        version: 0.2.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: sqlite3-ruby
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 3
+        - 2
+        version: 1.3.2
+  type: :runtime
+  version_requirements: *id002
+description: This is an ActiveRecord connection adapter for the SpatiaLite extension to the Sqlite3 database. It is based on the stock sqlite3 adapter, but provides built-in support for spatial databases using SpatiaLite. It uses the RGeo library to represent spatial data in Ruby.
+email: dazuma@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.rdoc
+- README.rdoc
+files: 
+- lib/active_record/connection_adapters/spatialite_adapter.rb
+- History.rdoc
+- README.rdoc
+- test/tc_basic.rb
+- Version
+has_rdoc: true
+homepage: http://virtuoso.rubyforge.org/activerecord-spatialite-adapter
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 8
+      - 7
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: virtuoso
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: An ActiveRecord adapter for SpatiaLite, based on RGeo.
+test_files: 
+- test/tc_basic.rb