activerecord-postgresql-extensions 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c65ffc95f16b554687be6eb67df6ddffc03c6283
-  data.tar.gz: 658228acaf0587e77eefc4d67eb31c4138bc65b2
+  metadata.gz: 19e521403cd36cf7625c8ccd2824cae61db46ca6
+  data.tar.gz: 068388117de07b1cf28a342b6135cf1879ba7623
 SHA512:
-  metadata.gz: 1c235b23d95dee1557b29fb8b7c10ab930284434f89b0d43fc742b7994460b7874d1e1eb4b58ce39efdf0504578e797e22c0b25eacf1f122743d470992720c74
-  data.tar.gz: 0405416cfeb48626e6f26580649858938fcd3636c5853e43385f3d28b08220d18508d546e170739835fd781abfdd0f37bf68ccd5dfcc56c54a24363b25bde53b
+  metadata.gz: 2644c7baf1ada6bae7f49c7755dc81de31db289294ddff377c7ff990a4a73f4ad3614dd9bee0981d2a463743ce50536909da4b48ff4ed885a7d1c5bb945c03b1
+  data.tar.gz: 9deb3cd3329c7c28be94d1cf162e597e9176cfeccdf82353635153e7024b74ae739b22666760f528c93d429a95b7ab859354b73b792bfc9928ae54b6e9b7d284

data/Gemfile

@@ -12,6 +12,7 @@ gem "rdoc", "~> 3.12"
 gem "rake", "~> 10.0"
 gem "minitest", "~> 4.7"
 gem "minitest-reporters"
+gem "guard"
 gem "guard-minitest"
 gem "simplecov"
 

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2013 2167961 Ontario Inc., Zoocasa <code@zoocasa.com>
+Copyright (c) 2014 Zoocasa, Brokerage <code@zoocasa.com>
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

data/lib/active_record/postgresql_extensions/constraints.rb

@@ -23,45 +23,40 @@ module ActiveRecord
 
   module ConnectionAdapters
     class PostgreSQLAdapter
+      # Adds a generic constraint.
+      def add_constraint(table, constraint)
+        execute("ALTER TABLE #{quote_table_name(table)} ADD #{constraint};")
+      end
+
       # Adds a CHECK constraint to the table. See
       # PostgreSQLCheckConstraint for usage.
       def add_check_constraint(table, expression, options = {})
-        sql = "ALTER TABLE #{quote_table_name(table)} ADD "
-        sql << PostgreSQLCheckConstraint.new(self, expression, options).to_s
-        execute("#{sql};")
+        add_constraint(table, PostgreSQLCheckConstraint.new(self, expression, options))
       end
 
       # Adds a UNIQUE constraint to the table. See
       # PostgreSQLUniqueConstraint for details.
       def add_unique_constraint(table, columns, options = {})
-        sql = "ALTER TABLE #{quote_table_name(table)} ADD "
-        sql << PostgreSQLUniqueConstraint.new(self, columns, options).to_s
-        execute("#{sql};")
+        add_constraint(table, PostgreSQLUniqueConstraint.new(self, columns, options))
       end
 
       # Adds a FOREIGN KEY constraint to the table. See
       # PostgreSQLForeignKeyConstraint for details.
       def add_foreign_key_constraint(table, columns, ref_table, *args)
-        sql = "ALTER TABLE #{quote_table_name(table)} ADD "
-        sql << PostgreSQLForeignKeyConstraint.new(self, columns, ref_table, *args).to_s
-        execute("#{sql};")
+        add_constraint(table, PostgreSQLForeignKeyConstraint.new(self, columns, ref_table, *args))
       end
       alias :add_foreign_key :add_foreign_key_constraint
 
       # Adds an EXCLUDE constraint to the table. See
       # PostgreSQLExcludeConstraint for details.
       def add_exclude_constraint(table, excludes, options = {})
-        sql = "ALTER TABLE #{quote_table_name(table)} ADD "
-        sql << PostgreSQLExcludeConstraint.new(self, table, excludes, options).to_s
-        execute("#{sql};")
+        add_constraint(table, PostgreSQLExcludeConstraint.new(self, table, excludes, options))
       end
 
       # Adds a PRIMARY KEY constraint to the table. See
       # PostgreSQLPrimaryKeyConstraint for details.
       def add_primary_key_constraint(table, columns, options = {})
-        sql = "ALTER TABLE #{quote_table_name(table)} ADD "
-        sql << PostgreSQLPrimaryKeyConstraint.new(self, columns, options).to_s
-        execute("#{sql};")
+        add_constraint(table, PostgreSQLPrimaryKeyConstraint.new(self, columns, options))
       end
       alias :add_primary_key :add_primary_key_constraint
 

data/lib/active_record/postgresql_extensions/geometry.rb

@@ -44,68 +44,15 @@ module ActiveRecord
       end
     end
 
-    class PostgreSQLGeometryColumnDefinition
-    end
+    class PostgreSQLGeometryColumnDefinition < ColumnDefinition
+      attr_reader :base, :column_name, :options
+      attr_accessor :default, :null
 
-    class PostgreSQLTableDefinition < TableDefinition
-      # This is a special spatial type for the PostGIS extension's
-      # data types. It is used in a table definition to define
-      # a spatial column.
-      #
-      # Depending on the version of PostGIS being used, we'll try to create
-      # geometry columns in a post-2.0-ish, typmod-based way or a pre-2.0-ish
-      # AddGeometryColumn-based way. We can also add CHECK constraints and
-      # create a GiST index on the column all in one go.
-      #
-      # In versions of PostGIS prior to 2.0, geometry columns are created using
-      # the AddGeometryColumn and will created with CHECK constraints where
-      # appropriate and entries to the <tt>geometry_columns</tt> will be
-      # updated accordingly.
-      #
-      # In versions of PostGIS after 2.0, geometry columns are creating using
-      # typmod specifiers. CHECK constraints can still be created, but their
-      # creation must be forced using the <tt>:force_constraints</tt> option.
-      #
-      # The <tt>geometry</tt> and <tt>geography</tt> methods are shortcuts to
-      # calling the <tt>spatial</tt> method with the <tt>:spatial_column_type</tt>
-      # option set accordingly.
-      #
-      # ==== Options
-      #
-      # * <tt>:spatial_column_type</tt> - the column type. This value can
-      #   be one of <tt>:geometry</tt> or <tt>:geography</tt>. This value
-      #   doesn't refer to the spatial type used by the column, but rather
-      #   by the actual column type itself.
-      # * <tt>:geometry_type</tt> - set the geometry type. The actual
-      #   data type is either "geometry" or "geography"; this option refers to
-      #   the spatial type being used.
-      # * <tt>:add_constraints</tt> - automatically creates the CHECK
-      #   constraints used to enforce ndims, srid and geometry type.
-      #   The default is true.
-      # * <tt>:force_constraints</tt> - forces the creation of CHECK
-      #   constraints in versions of PostGIS post-2.0.
-      # * <tt>:add_geometry_columns_entry</tt> - automatically adds
-      #   an entry to the <tt>geometry_columns</tt> table. We will
-      #   try to delete any existing match in <tt>geometry_columns</tt>
-      #   before inserting. The default is true. This value is ignored in
-      #   versions of PostGIS post-2.0.
-      # * <tt>:create_gist_index</tt> - automatically creates a GiST
-      #   index for the new geometry column. This option accepts either
-      #   a true/false expression or a String. If the value is a String,
-      #   we'll use it as the index name. The default is true.
-      # * <tt>:ndims</tt> - the number of dimensions to allow in the
-      #   geometry. This value is either 2 or 3 by default depending on
-      #   the value of the <tt>:geometry_type</tt> option. If the
-      #   <tt>:geometry_type</tt> ends in an "m" (for "measured
-      #   geometries" the default is 3); for everything else, it is 2.
-      # * <tt>:srid</tt> - the SRID, a.k.a. the Spatial Reference
-      #   Identifier. The default depends on the version of PostGIS being used
-      #   and the spatial column type being used. Refer to the PostGIS docs
-      #   for the specifics, but generally this means either a value of -1
-      #   for versions of PostGIS prior to 2.0 for geometry columns and a value
-      #   of 0 for versions post-2.0 and for all geography columns.
-      def spatial(column_name, opts = {})
-        opts = {
+      def initialize(base, column_name, opts)
+        @base = base
+        @column_name = column_name
+
+        @options = {
           :spatial_column_type => :geometry,
           :geometry_type => :geometry,
           :add_constraints => true,
@@ -115,78 +62,70 @@ module ActiveRecord
           :srid => ActiveRecord::PostgreSQLExtensions::PostGIS.UNKNOWN_SRID
         }.merge(opts)
 
-        if opts[:ndims].blank?
-          opts[:ndims] = if opts[:geometry_type].to_s.upcase =~ /M$/
+        if options[:ndims].blank?
+          options[:ndims] = if options[:geometry_type].to_s.upcase =~ /M$/
             3
           else
             2
           end
         end
 
-        assert_valid_spatial_column_type(opts[:spatial_column_type])
-        assert_valid_geometry_type(opts[:geometry_type])
-        assert_valid_ndims(opts[:ndims], opts[:geometry_type])
+        assert_valid_spatial_column_type(options[:spatial_column_type])
+        assert_valid_geometry_type(options[:geometry_type])
+        assert_valid_ndims(options[:ndims], options[:geometry_type])
 
         column_type = if ActiveRecord::PostgreSQLExtensions::PostGIS.VERSION[:lib] < '2.0'
-          opts[:spatial_column_type]
+          options[:spatial_column_type]
         else
-          column_args = [ opts[:geometry_type].to_s.upcase ]
+          column_args = [ options[:geometry_type].to_s.upcase ]
 
-          if ![ 0, -1 ].include?(opts[:srid])
-            column_args << opts[:srid]
+          if ![ 0, -1 ].include?(options[:srid])
+            column_args << options[:srid]
           end
 
-          "#{opts[:spatial_column_type]}(#{column_args.join(', ')})"
+          "#{options[:spatial_column_type]}(#{column_args.join(', ')})"
         end
 
-        column = self[column_name] || ColumnDefinition.new(base, column_name, column_type)
-        column.default = opts[:default]
-        column.null = opts[:null]
+        super(base, column_name, column_type)
 
-        unless @columns.include?(column)
-          @columns << column
-          if opts[:add_constraints] && (
-            ActiveRecord::PostgreSQLExtensions::PostGIS.VERSION[:lib] < '2.0' ||
-            opts[:force_constraints]
+        @default = options[:default]
+        @null = options[:null]
+
+        if options[:add_constraints] && (
+          ActiveRecord::PostgreSQLExtensions::PostGIS.VERSION[:lib] < '2.0' ||
+          options[:force_constraints]
+        )
+          table_constraints << PostgreSQLCheckConstraint.new(
+            base,
+            "ST_srid(#{base.quote_column_name(column_name)}) = (#{options[:srid].to_i})",
+            :name => "enforce_srid_#{column_name}"
+          )
+
+          table_constraints << PostgreSQLCheckConstraint.new(
+            base,
+            "ST_ndims(#{base.quote_column_name(column_name)}) = #{options[:ndims].to_i}",
+            :name => "enforce_dims_#{column_name}"
           )
-            table_constraints << PostgreSQLCheckConstraint.new(
-              base,
-              "ST_srid(#{base.quote_column_name(column_name)}) = (#{opts[:srid].to_i})",
-              :name => "enforce_srid_#{column_name}"
-            )
 
+          if options[:geometry_type].to_s.upcase != 'GEOMETRY'
             table_constraints << PostgreSQLCheckConstraint.new(
               base,
-              "ST_ndims(#{base.quote_column_name(column_name)}) = #{opts[:ndims].to_i}",
-              :name => "enforce_dims_#{column_name}"
+              "geometrytype(#{base.quote_column_name(column_name)}) = '#{options[:geometry_type].to_s.upcase}'::text OR #{base.quote_column_name(column_name)} IS NULL",
+              :name => "enforce_geotype_#{column_name}"
             )
-
-            if opts[:geometry_type].to_s.upcase != 'GEOMETRY'
-              table_constraints << PostgreSQLCheckConstraint.new(
-                base,
-                "geometrytype(#{base.quote_column_name(column_name)}) = '#{opts[:geometry_type].to_s.upcase}'::text OR #{base.quote_column_name(column_name)} IS NULL",
-                :name => "enforce_geotype_#{column_name}"
-              )
-            end
           end
         end
+      end
 
-        # We want to split up the schema and the table name for the
-        # upcoming geometry_columns rows and GiST index.
-        current_scoped_schema, current_table_name = if self.table_name.is_a?(Hash)
-          [ self.table_name.keys.first, self.table_name.values.first ]
-        elsif base.current_scoped_schema
-          [ base.current_scoped_schema, self.table_name ]
-        else
-          schema, table_name = base.extract_schema_and_table_names(self.table_name)
-          [ schema || 'public', table_name ]
-        end
-
-        if opts[:add_geometry_columns_entry] &&
-          opts[:spatial_column_type].to_s != 'geography' &&
+      def geometry_columns_entry(table_name)
+        return [] unless options[:add_geometry_columns_entry] &&
+          options[:spatial_column_type].to_s != 'geography' &&
           ActiveRecord::PostgreSQLExtensions::PostGIS.VERSION[:lib] < '2.0'
 
-          self.post_processing << sprintf(
+        current_scoped_schema, current_table_name = extract_schema_and_table_names(table_name)
+
+        [
+          sprintf(
             "DELETE FROM \"geometry_columns\" WHERE f_table_catalog = '' AND " +
             "f_table_schema = %s AND " +
             "f_table_name = %s AND " +
@@ -194,50 +133,53 @@ module ActiveRecord
             base.quote(current_scoped_schema.to_s),
             base.quote(current_table_name.to_s),
             base.quote(column_name.to_s)
-          )
+          ),
 
-          self.post_processing << sprintf(
+          sprintf(
             "INSERT INTO \"geometry_columns\" VALUES ('', %s, %s, %s, %d, %d, %s);",
             base.quote(current_scoped_schema.to_s),
             base.quote(current_table_name.to_s),
             base.quote(column_name.to_s),
-            opts[:ndims].to_i,
-            opts[:srid].to_i,
-            base.quote(opts[:geometry_type].to_s.upcase)
+            options[:ndims].to_i,
+            options[:srid].to_i,
+            base.quote(options[:geometry_type].to_s.upcase)
           )
-        end
+        ]
+      end
 
-        if opts[:create_gist_index]
-          index_name = if opts[:create_gist_index].is_a?(String)
-            opts[:create_gist_index]
-          else
-            "#{current_table_name}_#{column_name}_gist_index"
-          end
+      def geometry_column_index(table_name)
+        return [] unless options[:create_gist_index]
+
+        current_scoped_schema, current_table_name = extract_schema_and_table_names(table_name)
+
+        index_name = if options[:create_gist_index].is_a?(String)
+          options[:create_gist_index]
+        else
+          "#{current_table_name}_#{column_name}_gist_index"
+        end
 
-          self.post_processing << PostgreSQLIndexDefinition.new(
+        [
+          PostgreSQLIndexDefinition.new(
             base,
             index_name,
             { current_scoped_schema => current_table_name },
             column_name,
             :using => :gist
           ).to_s
-        end
-
-        self
+        ]
       end
 
-      def geometry(column_name, opts = {})
-        self.spatial(column_name, opts)
+      def to_sql
+        column_sql = "#{base.quote_column_name(name)} #{sql_type}"
+        column_options = {}
+        column_options[:null] = null unless null.nil?
+        column_options[:default] = default unless default.nil?
+        add_column_options!(column_sql, column_options) unless type.to_sym == :primary_key
+        column_sql
       end
 
-      def geography(column_name, opts = {})
-        opts = {
-          :srid => ActiveRecord::PostgreSQLExtensions::PostGIS.UNKNOWN_SRIDS[:geography]
-        }.merge(opts)
-
-        self.spatial(column_name, opts.merge(
-          :spatial_column_type => :geography
-        ))
+      def table_constraints
+        @table_constraints ||= []
       end
 
       private
@@ -296,6 +238,128 @@ module ActiveRecord
             end
           end
         end
+
+        def extract_schema_and_table_names(table_name)
+          # We want to split up the schema and the table name for the
+          # upcoming geometry_columns rows and GiST index.
+          if table_name.is_a?(Hash)
+            [ table_name.keys.first, table_name.values.first ]
+          elsif base.current_scoped_schema
+            [ base.current_scoped_schema, table_name ]
+          else
+            schema, table_name = base.extract_schema_and_table_names(table_name)
+            [ schema || 'public', table_name ]
+          end
+        end
+    end
+
+    class PostgreSQLTableDefinition < TableDefinition
+      # This is a special spatial type for the PostGIS extension's
+      # data types. It is used in a table definition to define
+      # a spatial column.
+      #
+      # Depending on the version of PostGIS being used, we'll try to create
+      # geometry columns in a post-2.0-ish, typmod-based way or a pre-2.0-ish
+      # AddGeometryColumn-based way. We can also add CHECK constraints and
+      # create a GiST index on the column all in one go.
+      #
+      # In versions of PostGIS prior to 2.0, geometry columns are created using
+      # the AddGeometryColumn and will created with CHECK constraints where
+      # appropriate and entries to the <tt>geometry_columns</tt> will be
+      # updated accordingly.
+      #
+      # In versions of PostGIS after 2.0, geometry columns are creating using
+      # typmod specifiers. CHECK constraints can still be created, but their
+      # creation must be forced using the <tt>:force_constraints</tt> option.
+      #
+      # The <tt>geometry</tt> and <tt>geography</tt> methods are shortcuts to
+      # calling the <tt>spatial</tt> method with the <tt>:spatial_column_type</tt>
+      # option set accordingly.
+      #
+      # ==== Options
+      #
+      # * <tt>:spatial_column_type</tt> - the column type. This value can
+      #   be one of <tt>:geometry</tt> or <tt>:geography</tt>. This value
+      #   doesn't refer to the spatial type used by the column, but rather
+      #   by the actual column type itself.
+      # * <tt>:geometry_type</tt> - set the geometry type. The actual
+      #   data type is either "geometry" or "geography"; this option refers to
+      #   the spatial type being used, i.e. "POINT", "POLYGON", ""
+      # * <tt>:add_constraints</tt> - automatically creates the CHECK
+      #   constraints used to enforce ndims, srid and geometry type.
+      #   The default is true.
+      # * <tt>:force_constraints</tt> - forces the creation of CHECK
+      #   constraints in versions of PostGIS post-2.0.
+      # * <tt>:add_geometry_columns_entry</tt> - automatically adds
+      #   an entry to the <tt>geometry_columns</tt> table. We will
+      #   try to delete any existing match in <tt>geometry_columns</tt>
+      #   before inserting. The default is true. This value is ignored in
+      #   versions of PostGIS post-2.0.
+      # * <tt>:create_gist_index</tt> - automatically creates a GiST
+      #   index for the new geometry column. This option accepts either
+      #   a true/false expression or a String. If the value is a String,
+      #   we'll use it as the index name. The default is true.
+      # * <tt>:ndims</tt> - the number of dimensions to allow in the
+      #   geometry. This value is either 2 or 3 by default depending on
+      #   the value of the <tt>:geometry_type</tt> option. If the
+      #   <tt>:geometry_type</tt> ends in an "m" (for "measured
+      #   geometries" the default is 3); for everything else, it is 2.
+      # * <tt>:srid</tt> - the SRID, a.k.a. the Spatial Reference
+      #   Identifier. The default depends on the version of PostGIS being used
+      #   and the spatial column type being used. Refer to the PostGIS docs
+      #   for the specifics, but generally this means either a value of -1
+      #   for versions of PostGIS prior to 2.0 for geometry columns and a value
+      #   of 0 for versions post-2.0 and for all geography columns.
+      def spatial(column_name, opts = {})
+        column = self[column_name] || PostgreSQLGeometryColumnDefinition.new(base, column_name, opts)
+
+        unless @columns.include?(column)
+          @columns << column
+        end
+
+        table_constraints.concat(column.table_constraints)
+        post_processing.concat(column.geometry_columns_entry(table_name))
+        post_processing.concat(column.geometry_column_index(table_name))
+
+        self
+      end
+      alias_method :geometry, :spatial
+
+      def geography(column_name, opts = {})
+        opts = {
+          :srid => ActiveRecord::PostgreSQLExtensions::PostGIS.UNKNOWN_SRIDS[:geography]
+        }.merge(opts)
+
+        self.spatial(column_name, opts.merge(
+          :spatial_column_type => :geography
+        ))
+      end
+    end
+
+    class PostgreSQLTable < Table
+      def spatial(column_name, opts = {})
+        column = PostgreSQLGeometryColumnDefinition.new(@base, column_name, opts)
+
+        post_processing.concat(column.geometry_columns_entry(@table_name))
+        post_processing.concat(column.geometry_column_index(@table_name))
+
+        @base.add_column(@table_name, column_name, column.sql_type, opts)
+
+        column.table_constraints.each do |constraint|
+          @base.add_constraint(@table_name, constraint)
+        end
+      end
+      alias_method :geometry, :spatial
+
+      def geography(column_name, opts = {})
+        opts = {
+          :srid => ActiveRecord::PostgreSQLExtensions::PostGIS.UNKNOWN_SRIDS[:geography]
+        }.merge(opts)
+
+        self.spatial(column_name, opts.merge(
+          :spatial_column_type => :geography
+        ))
+      end
     end
   end
 end