rgeo 0.1.16 → 0.1.17

data/lib/rgeo/wkrep/wkt_parser.rb

@@ -56,14 +56,17 @@ module RGeo
     # constructor, or set on the object afterwards.
     # 
     # <tt>:default_factory</tt>::
-    #   The default factory for generated geometries, used when no SRID
-    #   is explicitly specified in the input. If none is provided, the
-    #   default cartesian factory will be used.
-    # <tt>:factory_from_srid</tt>::
-    #   A Proc that takes an SRID as the sole argument, and returns a
-    #   factory for generated geometries when that SRID is specified in
-    #   the input. If no such Proc is provided, the default_factory is
-    #   used, regardless of the input SRID.
+    #   The default factory for parsed geometries, used when no factory
+    #   generator is provided. If no default is provided either, the
+    #   default cartesian factory will be used as the default.
+    # <tt>:factory_generator</tt>::
+    #   A factory generator that should return a factory based on the
+    #   srid and dimension settings in the input. The factory generator
+    #   should understand the configuration options <tt>:srid</tt>,
+    #   <tt>:support_z_coordinate</tt>, and <tt>:support_m_coordinate</tt>.
+    #   See RGeo::Features::FactoryGenerator for more information.
+    #   If no generator is provided, the <tt>:default_factory</tt> is
+    #   used.
     # <tt>:support_ewkt</tt>::
     #   Activate support for PostGIS EWKT type tags, which appends an "M"
     #   to tags to indicate the presence of M but not Z, and also
@@ -89,7 +92,7 @@ module RGeo
       
       def initialize(opts_={})
         @default_factory = opts_[:default_factory] || Cartesian.preferred_factory
-        @factory_from_srid = opts_[:factory_from_srid]
+        @factory_generator = opts_[:factory_generator]
         @support_ewkt = opts_[:support_ewkt] ? true : false
         @support_wkt12 = opts_[:support_wkt12] ? true : false
         @strict_wkt11 = @support_ewkt || @support_wkt12 ? false : opts_[:strict_wkt11] ? true : false
@@ -107,21 +110,21 @@ module RGeo
         @default_factory = value_ || Cartesian.preferred_factory
       end
       
-      # Returns true if this parser has a factory_from_srid procedure.
+      # Returns the factory generator, or nil if there is none.
       # See WKTParser for details.
-      def has_factory_from_srid?
-        @factory_from_srid ? true : false
+      def factory_generator
+        @factory_generator
       end
       
-      # Sets the factory_from_srid. See WKTParser for details.
-      def factory_from_srid=(value_)
-        @factory_from_srid = value_
+      # Sets the factory_generator. See WKTParser for details.
+      def factory_generator=(value_)
+        @factory_generator = value_
       end
       
-      # Sets the factory_from_srid to the given block.
+      # Sets the factory_generator to the given block.
       # See WKTParser for details.
-      def set_factory_from_srid(&block_)
-        @factory_from_srid = block_
+      def to_generate_factory(&block_)
+        @factory_generator = block_
       end
       
       # Returns true if this parser supports EWKT.
@@ -172,21 +175,22 @@ module RGeo
       # Parse the given string, and return a geometry object.
       
       def parse(str_)
-        @cur_factory = @default_factory
         str_ = str_.downcase
-        if @support_ewkt && str_ =~ /^srid=(\d+);/i
-          str_ = $'
-          if @factory_from_srid
-            @cur_factory = @factory_from_srid.call($1.to_i)
-          end
+        @cur_factory = @factory_generator ? nil : @default_factory
+        if @cur_factory
+          @cur_factory_support_z = @cur_factory.has_capability?(:z_coordinate) ? true : false
+          @cur_factory_support_m = @cur_factory.has_capability?(:m_coordinate) ? true : false
         end
-        @cur_factory_support_z = @cur_factory.has_capability?(:z_coordinate)
-        @cur_factory_support_m = @cur_factory.has_capability?(:m_coordinate)
         @cur_expect_z = nil
         @cur_expect_m = nil
+        @cur_srid = nil
+        if @support_ewkt && str_ =~ /^srid=(\d+);/i
+          str_ = $'
+          @cur_srid = $1.to_i
+        end
         begin
           _start_scanner(str_)
-          obj_ = _parse_type_tag
+          obj_ = _parse_type_tag(false)
           if @cur_token && !@ignore_extra_tokens
             raise Errors::ParseError, "Extra tokens beginning with #{@cur_token.inspect}."
           end
@@ -197,7 +201,31 @@ module RGeo
       end
       
       
-      def _parse_type_tag  # :nodoc:
+      def _check_factory_support  # :nodoc:
+        if @cur_expect_z && !@cur_factory_support_z
+          raise Errors::ParseError, "Geometry calls for Z coordinate but factory doesn't support it."
+        end
+        if @cur_expect_m && !@cur_factory_support_m
+          raise Errors::ParseError, "Geometry calls for M coordinate but factory doesn't support it."
+        end
+      end
+      
+      
+      def _ensure_factory  # :nodoc:
+        unless @cur_factory
+          if @factory_generator
+            @cur_factory = @factory_generator.call(:srid => @cur_srid, :support_z_coordinate => @cur_expect_z, :support_m_coordinate => @cur_expect_m)
+          end
+          @cur_factory ||= @default_factory
+          @cur_factory_support_z = @cur_factory.has_capability?(:z_coordinate) ? true : false
+          @cur_factory_support_m = @cur_factory.has_capability?(:m_coordinate) ? true : false
+          _check_factory_support unless @cur_expect_z.nil?
+        end
+        @cur_factory
+      end
+      
+      
+      def _parse_type_tag(contained_)  # :nodoc:
         _expect_token_type(::String)
         if @support_ewkt && @cur_token =~ /^(.+)(m)$/
           type_ = $1
@@ -212,22 +240,26 @@ module RGeo
           _next_token
         end
         if zm_.length > 0 || @strict_wkt11
-          expect_z_ = zm_[0,1] == 'z'
-          if !@cur_expect_z.nil? && expect_z_ != @cur_expect_z
+          creating_expectation_ = @cur_expect_z.nil?
+          expect_z_ = zm_[0,1] == 'z' ? true : false
+          if @cur_expect_z.nil?
+            @cur_expect_z = expect_z_
+          elsif expect_z_ != @cur_expect_z
             raise Errors::ParseError, "Surrounding collection has Z but contained geometry doesn't."
           end
-          @cur_expect_z = expect_z_
-          expect_m_ = zm_[-1,1] == 'm'
-          if !@cur_expect_m.nil? && expect_m_ != @cur_expect_m
+          expect_m_ = zm_[-1,1] == 'm' ? true : false
+          if @cur_expect_m.nil?
+            @cur_expect_m = expect_m_
+          else expect_m_ != @cur_expect_m
             raise Errors::ParseError, "Surrounding collection has M but contained geometry doesn't."
           end
-          @cur_expect_m = expect_m_
-        end
-        if @cur_expect_z && !@cur_factory_support_z
-          raise Errors::ParseError, "Type tag declares #{zm_.inspect} but factory doesn't support Z."
-        end
-        if @cur_expect_m && !@cur_factory_support_m
-          raise Errors::ParseError, "Type tag declares #{zm_.inspect} but factory doesn't support M."
+          if creating_expectation_
+            if @cur_factory
+              _check_factory_support
+            else
+              _ensure_factory
+            end
+          end
         end
         case type_
         when 'point'
@@ -264,31 +296,32 @@ module RGeo
             _next_token
           end
           num_extras_ = extra_.size
-          @cur_expect_z = num_extras_ > 0 && @cur_factory_support_z ? true : false
+          @cur_expect_z = num_extras_ > 0 && (!@cur_factory || @cur_factory_support_z) ? true : false
           num_extras_ -= 1 if @cur_expect_z
-          @cur_expect_m = num_extras_ > 0 && @cur_factory_support_m ? true : false
+          @cur_expect_m = num_extras_ > 0 && (!@cur_factory || @cur_factory_support_m) ? true : false
           num_extras_ -= 1 if @cur_expect_m
           if num_extras_ > 0
             raise Errors::ParseError, "Found #{extra_.size+2} coordinates, which is too many for this factory."
           end
+          _ensure_factory
         else
+          val_ = 0
+          if @cur_expect_z
+            _expect_token_type(::Numeric)
+            val_ = @cur_token
+            _next_token
+          end
           if @cur_factory_support_z
-            if @cur_expect_z
-              _expect_token_type(::Numeric)
-              extra_ << @cur_token
-              _next_token
-            else
-              extra_ << 0
-            end
+            extra_ << val_
+          end
+          val_ = 0
+          if @cur_expect_m
+            _expect_token_type(::Numeric)
+            val_ = @cur_token
+            _next_token
           end
           if @cur_factory_support_m
-            if @cur_expect_m
-              _expect_token_type(::Numeric)
-              extra_ << @cur_token
-              _next_token
-            else
-              extra_ << 0
-            end
+            extra_ << val_
           end
         end
         @cur_factory.point(x_, y_, *extra_)
@@ -297,7 +330,7 @@ module RGeo
       
       def _parse_point(convert_empty_=false)  # :nodoc:
         if convert_empty_ && @cur_token == 'empty'
-          point_ = @cur_factory.multi_point([])
+          point_ = _ensure_factory.multi_point([])
         else
           _expect_token_type(:begin)
           _next_token
@@ -322,7 +355,7 @@ module RGeo
           end
         end
         _next_token
-        @cur_factory.line_string(points_)
+        _ensure_factory.line_string(points_)
       end
       
       
@@ -342,7 +375,7 @@ module RGeo
           end
         end
         _next_token
-        @cur_factory.polygon(outer_ring_, inner_rings_)
+        _ensure_factory.polygon(outer_ring_, inner_rings_)
       end
       
       
@@ -352,14 +385,14 @@ module RGeo
           _expect_token_type(:begin)
           _next_token
           loop do
-            geometries_ << _parse_type_tag
+            geometries_ << _parse_type_tag(true)
             break if @cur_token == :end
             _expect_token_type(:comma)
             _next_token
           end
         end
         _next_token
-        @cur_factory.collection(geometries_)
+        _ensure_factory.collection(geometries_)
       end
       
       
@@ -376,7 +409,7 @@ module RGeo
           end
         end
         _next_token
-        @cur_factory.multi_point(points_)
+        _ensure_factory.multi_point(points_)
       end
       
       
@@ -393,7 +426,7 @@ module RGeo
           end
         end
         _next_token
-        @cur_factory.multi_line_string(line_strings_)
+        _ensure_factory.multi_line_string(line_strings_)
       end
       
       
@@ -410,7 +443,7 @@ module RGeo
           end
         end
         _next_token
-        @cur_factory.multi_polygon(polygons_)
+        _ensure_factory.multi_polygon(polygons_)
       end
       
       

data/tests/active_record/readme.txt

@@ -0,0 +1,33 @@
+The ActiveRecord adapter unit tests require that you connect to actual
+databases. In order for these tests to run, you must therefore provide
+the database connection parameters, in the form of a "database.yml" file
+located in this directory. If this file is not present, the ActiveRecord
+adapter tests will be skipped.
+
+The format of this file is the same as the Rails "config/database.yml"
+file, except that the main keys, instead of environment names, should be
+adapter names.
+
+For example:
+
+####
+mysqlspatial:
+  adapter: mysqlspatial
+  encoding: utf8
+  reconnect: false
+  database: <mysql_test_database>
+  username: <mysql_user>
+  password: <mysql_password>
+  host: localhost
+mysql2spatial:
+  adapter: mysql2spatial
+  encoding: utf8
+  reconnect: false
+  database: <mysql_test_database>
+  username: <mysql_user>
+  password: <mysql_password>
+  host: localhost
+####
+
+Note that the tests assume they "own" these databases, and they may
+modify and/or delete any and all tables at any time.

data/tests/active_record/tc_mysqlspatial.rb

@@ -0,0 +1,219 @@
+# -----------------------------------------------------------------------------
+# 
+# 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.
+# -----------------------------------------------------------------------------
+;
+
+
+if ::File.exists?(::File.dirname(__FILE__)+'/database.yml')
+  
+  require 'test/unit'
+  require 'rgeo'
+  require 'yaml'
+  require 'active_record'
+  
+  
+  module RGeo
+    module Tests  # :nodoc:
+      module ActiveRecord  # :nodoc:
+        
+        ALL_DATABASES_CONFIG = ::YAML.load_file(::File.dirname(__FILE__)+'/database.yml')
+        
+        
+        module Classes  # :nodoc:
+          
+          @class_num = 0
+          
+          def self.new_class(config_)
+            klass_ = ::Class.new(::ActiveRecord::Base)
+            @class_num += 1
+            self.const_set("Klass#{@class_num}".to_sym, klass_)
+            klass_.class_eval do
+              establish_connection(config_)
+              set_table_name(:spatial_test)
+            end
+            klass_
+          end
+          
+        end
+        
+        
+        module CommonTestMethods  # :nodoc:
+          
+          def self.included(klass_)
+            database_config_ = ALL_DATABASES_CONFIG[klass_.const_get(:ADAPTER_NAME)]
+            klass_.const_set(:DATABASE_CONFIG, database_config_)
+            klass_.const_set(:DEFAULT_AR_CLASS, Classes.new_class(database_config_))
+          end
+          
+          
+          def setup
+            @factory = ::RGeo::Cartesian.preferred_factory(:srid => 4326)
+            cleanup_tables
+          end
+          
+          
+          def teardown
+            cleanup_tables
+          end
+          
+          
+          def cleanup_tables
+            klass_ = self.class.const_get(:DEFAULT_AR_CLASS)
+            tables_ = klass_.connection.select_values('SHOW TABLES')
+            tables_.each{ |table_| klass_.connection.drop_table(table_) }
+          end
+          
+          
+          def create_ar_class(opts_={})
+            klass_ = Classes.new_class(self.class.const_get(:DATABASE_CONFIG))
+            case opts_[:content]
+            when :latlon_point
+              klass_.connection.create_table(:spatial_test) do |t_|
+                t_.column 'latlon', :point
+              end
+            end
+            @ar_class = klass_
+          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(::RGeo::Features::Geometry, klass_.columns.last.geometric_type)
+            assert(klass_.cached_attributes.include?('latlon'))
+          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::Features::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, :options => 'ENGINE=MyISAM') do |t_|
+              t_.column 'latlon', :geometry, :null => false
+            end
+            klass_.connection.change_table(:spatial_test) do |t_|
+              t_.index([:latlon], :spatial => true)
+            end
+            assert(klass_.connection.indexes(:spatial_test).last.spatial)
+          end
+          
+          
+          def test_set_and_get_point
+            klass_ = create_ar_class(:content => :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_ = create_ar_class(:content => :latlon_point)
+            obj_ = klass_.new
+            assert_nil(obj_.latlon)
+            obj_.latlon = 'SRID=1000;POINT(1 2)'
+            assert_equal(@factory.point(1, 2), obj_.latlon)
+            assert_equal(1000, obj_.latlon.srid)
+          end
+          
+          
+          def test_save_and_load_point
+            klass_ = create_ar_class(:content => :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_ = create_ar_class(:content => :latlon_point)
+            obj_ = klass_.new
+            obj_.latlon = 'SRID=1000;POINT(1 2)'
+            obj_.save!
+            id_ = obj_.id
+            obj2_ = klass_.find(id_)
+            assert_equal(@factory.point(1, 2), obj2_.latlon)
+            assert_equal(1000, obj2_.latlon.srid)
+          end
+          
+          
+        end
+        
+        
+        if ALL_DATABASES_CONFIG.include?('mysqlspatial')
+          class TestMysqlSpatial < ::Test::Unit::TestCase  # :nodoc:
+            ADAPTER_NAME = 'mysqlspatial'
+            include CommonTestMethods
+          end
+        else
+          puts "WARNING: Couldn't find mysqlspatial in database.yml. Skipping those tests."
+          puts "         See tests/active_record/readme.txt for more info."
+        end
+        
+        
+        if ALL_DATABASES_CONFIG.include?('mysql2spatial')
+          class TestMysql2Spatial < ::Test::Unit::TestCase  # :nodoc:
+            ADAPTER_NAME = 'mysql2spatial'
+            include CommonTestMethods
+          end
+        else
+          puts "WARNING: Couldn't find mysql2spatial in database.yml. Skipping those tests."
+          puts "         See tests/active_record/readme.txt for more info."
+        end
+        
+        
+      end
+      
+    end
+  end
+  
+  
+else
+  puts "WARNING: database.yml not found. Skipping ActiveRecord tests."
+  puts "         See tests/active_record/readme.txt for more info."
+end