activerecord-postgres-postgis 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f9aa50c6ce6da9571d94f676d2858022c24b7266
+  data.tar.gz: 1f6f2362576751d97bdcd4f363758126c6be436f
+SHA512:
+  metadata.gz: cd380b3ac160df3eb0c03e2da64c22a0c79d833aaef7783810e84a4ca0b27a7a44476a999f9be5fbaf939567e6238bee9aa0ad6eb92fce8a5f832bb99c542784
+  data.tar.gz: cd73d7d4fb3c4ddc92ed4556c304c77ea475593ac454c85943835c2d1f46cb9e6376245dbd112df56066af4e921850362ba189b3baf535be6751ed82d67b80e7

data/.gitignore

@@ -0,0 +1,24 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.rbenv*
+.rvmrc

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,22 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - ruby-head
+  - rbx-2
+  - rbx-head
+addons:
+  postgresql: "9.3"
+env:
+  - "RAILS_VERSION=4.1.0"
+matrix:
+  allow_failures:
+    - env: "RAILS_VERSION=master"
+    - rvm: ruby-head
+    - rvm: rbx-head
+script:
+  - cd spec/dummy/rails-$RAILS_VERSION; bundle exec rake db:migrate
+  - cd ../../../; bundle exec rake spec
+before_script:
+  - psql -c 'create database activerecord_postgresql_postgis_test;' -U postgres

data/Gemfile

@@ -0,0 +1,23 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in activerecord-postgres-postgis.gemspec
+gemspec
+
+rails_version = ENV['RAILS_VERSION'] || 'default'
+
+rails = case rails_version
+when 'master'
+  { github: 'rails/rails' }
+when 'default'
+  '>= 4.1.0'
+else
+  "~> #{rails_version}"
+end
+
+gem 'rails', rails
+
+gem 'coveralls', require: false
+
+platforms :ruby do
+  gem 'pg'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Anthony Smith
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Activerecord::Postgres::Postgis
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'activerecord-postgres-postgis'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install activerecord-postgres-postgis
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/activerecord-postgres-postgis/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new :spec
+
+task default: :spec

data/activerecord-postgres-postgis.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'activerecord-postgres-postgis/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'activerecord-postgres-postgis'
+  spec.version       = ActiveRecord::Postgres::Postgis::VERSION
+  spec.authors       = ['Anthony Smith']
+  spec.email         = ['anthony@sticksnleaves.com']
+  spec.summary       = %q{Write a short summary. Required.}
+  spec.description   = %q{Write a longer description. Optional.}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activerecord', '>= 3.2'
+  spec.add_dependency 'rake'
+  spec.add_dependency 'rgeo',         '~> 0.3'
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'database_cleaner'
+  spec.add_development_dependency 'generator_spec'
+  spec.add_development_dependency 'rspec-rails'
+end

data/lib/activerecord-postgres-postgis.rb

@@ -0,0 +1,10 @@
+require 'active_support'
+require 'rgeo'
+
+if defined?(Rails)
+  require 'activerecord-postgres-postgis/railtie'
+else
+  ActiveSupport.on_load :active_record do
+    require File.expand_path('../lib/activerecord-postgres-postgis/active_record', __FILE__)
+  end
+end

data/lib/activerecord-postgres-postgis/active_record.rb

@@ -0,0 +1,3 @@
+Dir["#{File.dirname(__FILE__)}/**/*.rb"].each { |f| require f }
+
+ActiveRecord::Base.extend(ActiveRecord::Postgres::Postgis::Model)

data/lib/activerecord-postgres-postgis/active_record/connection_adapters/column.rb

@@ -0,0 +1,53 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLColumn < Column
+      attr_reader :spatial_type, :srid
+
+      attr_accessor :oid_type
+
+      def initialize_with_spatial(name, default, oid_type, sql_type = nil, null = true)
+        initialize_without_spatial(name, default, oid_type, sql_type, null)
+
+        @spatial_type = extract_spatial_type(sql_type)
+        @srid = extract_srid(sql_type)
+
+        if spatial?
+          oid_type.srid = @srid
+        end
+      end
+
+      alias_method_chain :initialize, :spatial
+
+      def simplified_type_with_spatial(field_type)
+        if field_type =~ /^(?:geometry)/
+          :geometry
+        elsif field_type =~ /^(?:geography)/
+          :geography
+        else
+          simplified_type_without_spatial(field_type)
+        end
+      end
+
+      alias_method_chain :simplified_type, :spatial
+
+      def spatial?
+        !sql_type.match(/^(geometry|geography)/).nil?
+      end
+
+      private
+      def extract_spatial_type(sql_type)
+        if sql_type =~ /^(geometry|geography)\(([a-z]+)(,\d+)?\)/i
+          @limit = nil
+          "'#{$2.upcase}'"
+        end
+      end
+
+      def extract_srid(sql_type)
+        if sql_type =~ /^(geometry|geography)\(([a-z]+)(,(\d+))\)/i
+          @limit = nil
+          $4.to_i
+        end
+      end
+    end
+  end
+end

data/lib/activerecord-postgres-postgis/active_record/connection_adapters/oid.rb

@@ -0,0 +1,33 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter < AbstractAdapter
+      module OID
+        class Spatial < Type
+          attr_accessor :factory_generator, :srid
+
+          def initialize(factory_generator = nil)
+            @factory_generator = factory_generator
+          end
+
+          def type_cast(value)
+            if value.kind_of?(RGeo::Feature::Geometry)
+              RGeo::Feature.cast(value, @factory)
+            elsif value && value.respond_to?(:to_s)
+              marker = value[0, 1]
+              if marker == "\x00" || marker == "\x01" || value[0,4] =~ /[0-9a-fA-F]{4}/
+                RGeo::WKRep::WKBParser.new(@factory_generator, support_ewkb: true, default_srid: srid).parse(value)
+              else
+                RGeo::WKRep::WKTParser.new(@factory_generator, support_ewkt: true, default_srid: srid).parse(value)
+              end
+            else
+              nil
+            end
+          end
+        end
+
+        register_type('geometry', Spatial.new)
+        register_type('geography', Spatial.new(RGeo::Geographic.method(:spherical_factory)))
+      end
+    end
+  end
+end

data/lib/activerecord-postgres-postgis/active_record/connection_adapters/postgresql_adapter.rb

@@ -0,0 +1,29 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter < AbstractAdapter
+      def prepare_column_options_with_spatial(column, types)
+        spec = prepare_column_options_without_spatial(column, types)
+        spec[:spatial_type] = column.spatial_type if column.respond_to?(:spatial_type) && column.spatial_type
+        spec[:srid] = column.srid.to_s if column.respond_to?(:srid) && column.srid
+        spec
+      end
+
+      alias_method_chain :prepare_column_options, :spatial
+
+      def migration_keys_with_spatial
+        migration_keys_without_spatial + [:spatial_type, :srid]
+      end
+
+      alias_method_chain :migration_keys, :spatial
+
+      def native_database_types_with_spatial
+        native_database_types_without_spatial.merge({
+          geometry: { name: 'geometry' },
+          geography: { name: 'geography' }
+        })
+      end
+
+      alias_method_chain :native_database_types, :spatial
+    end
+  end
+end

data/lib/activerecord-postgres-postgis/active_record/connection_adapters/quoting.rb

@@ -0,0 +1,17 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter < AbstractAdapter
+      module Quoting
+        def type_cast_with_spatial(value, column, array_member = false)
+          if value.kind_of?(RGeo::Feature::Geometry)
+            RGeo::WKRep::WKBGenerator.new(hex_format: true, type_format: :ewkb, emit_ewkb_srid: true).generate(value)
+          else
+            type_cast_without_spatial(value, column, array_member)
+          end
+        end
+
+        alias_method_chain  :type_cast, :spatial
+      end
+    end
+  end
+end

data/lib/activerecord-postgres-postgis/active_record/connection_adapters/schema_definitions.rb

@@ -0,0 +1,49 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module ColumnMethods
+      # Adds geometry type for migrations. So you can add column to a table like:
+      #   create_table :locations do |t|
+      #     ...
+      #     t.geometry :geom, srid: 423, type: 'LINESTRING'
+      #     ...
+      #   end
+      #
+      def geometry(name, options = {})
+        column(name, :geometry, options)
+      end
+
+      # Adds geography type for migrations. So you can add column to a table
+      # like:
+      #   create_table :locations do |t|
+      #     ...
+      #     t.geography :geog, type: 'LINESTRING'
+      #     ...
+      #   end
+      #
+      def geography(name, options = {})
+        column(name, :geography, options)
+      end
+    end
+
+    class PostgreSQLAdapter::ColumnDefinition < ActiveRecord::ConnectionAdapters::ColumnDefinition
+      attr_accessor :spatial_type, :srid
+    end
+
+    class PostgreSQLAdapter::TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+      include ColumnMethods
+
+      def column_with_spatial(name, type = nil, options = {})
+        column = column_without_spatial(name, type, options)[name]
+        column.spatial_type = options[:spatial_type]
+        column.srid = options[:srid]
+        self
+      end
+
+      alias_method_chain :column, :spatial
+    end
+
+    class PostgreSQLAdapter::Table < ActiveRecord::ConnectionAdapters::Table
+      include ColumnMethods
+    end
+  end
+end

data/lib/activerecord-postgres-postgis/active_record/connection_adapters/schema_statements.rb

@@ -0,0 +1,42 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter::SchemaCreation < ActiveRecord::ConnectionAdapters::AbstractAdapter::SchemaCreation
+      def add_column_options_with_spatial!(sql, options)
+        column = options.fetch(:column) { return super }
+        if column.type == :geometry
+          if column.spatial_type || column.srid
+            sql_params = column.spatial_type
+            sql_params << ',' if sql_params && column.srid
+            sql_params = column.srid.to_s.prepend(sql_params || '') if column.srid
+            sql << "(#{sql_params})" if sql_params
+          end
+        elsif column.type == :geography
+          if column.spatial_type || column.srid
+            sql_params = column.spatial_type
+            sql_params << ',' if sql_params
+            sql_params = 4326.to_s.prepend(sql_params || '')
+            sql << "(#{sql_params})" if sql_params
+          end
+        else
+          add_column_options_without_spatial!(sql, options)
+        end
+      end
+
+      alias_method_chain :add_column_options!, :spatial
+    end
+
+    module SchemaStatements
+      # Adds a spatial column to the table using the PostGIS
+      # "AddGeometryColumn()" function.
+      #
+      # This method exists for backwards compatability with PostGIS 1.x.
+      #
+      # Example:
+      #   add_geometry_column :roads, :geom, srid: 423, spatial_type: 'LINESTRING', dimension: 2
+      #
+      def add_geometry_column(table_name, column_name, options = {})
+        execute "SELECT AddGeometryColumn('#{table_name}', '#{column_name}', #{options[:srid]}, '#{options[:spatial_type]}', #{options[:dimension]})"
+      end
+    end
+  end
+end

data/lib/activerecord-postgres-postgis/arel/visitors/to_sql.rb

@@ -0,0 +1,9 @@
+module Arel
+  module Visitors
+    class ToSql < Arel::Visitors::Visitor
+      def visit_RGeo_Feature_Geometry(o, a)
+        quote(RGeo::WKRep::WKTGenerator.new(type_format: :ewkt, emit_ewkt_srid: true).generate(o))
+      end
+    end
+  end
+end

data/lib/activerecord-postgres-postgis/model.rb

@@ -0,0 +1,35 @@
+module ActiveRecord
+  module Postgres
+    module Postgis
+      FACTORY_GENERATORS = {
+        geometry: {
+          preferred: :preferred_factory,
+          simple: :simple_factory
+        },
+        geography: {
+          spherical: :spherical_factory,
+          simple_mercator: :simple_mercator_factory,
+          projected: :projected_factory
+        }
+      }
+
+      module Model
+        def spatial(column_name, factory, options = {})
+          column = columns_hash[column_name.to_s]
+          return unless column
+
+          column.oid_type.factory_generator = factory_generator_class(column.type).send(FACTORY_GENERATORS[column.type][factory], { srid: column.srid }.merge(options))
+        end
+
+        private
+        def factory_generator_class(column_type)
+          if column_type == :geometry
+            RGeo::Cartesian
+          elsif column_type == :geography
+            RGeo::Geographic
+          end
+        end
+      end
+    end
+  end
+end