activerecord-postgis-array 0.3.4

data/lib/activerecord-postgis-array/active_record/relation.rb

@@ -0,0 +1,2 @@
+require 'activerecord-postgis-array/active_record/relation/query_methods'
+require 'activerecord-postgis-array/active_record/relation/predicate_builder'

data/lib/activerecord-postgis-array/active_record/relation/predicate_builder.rb

@@ -0,0 +1,71 @@
+require 'active_record/relation/predicate_builder'
+
+module ActiveRecord
+  class PredicateBuilder # :nodoc:
+    def self.build_from_hash(engine, attributes, default_table, allow_table_name = true)
+      predicates = attributes.map do |column, value|
+        table = default_table
+
+        if allow_table_name && value.is_a?(Hash)
+          table = Arel::Table.new(column, engine)
+
+          if value.empty?
+            '1 = 2'
+          else
+            build_from_hash(engine, value, table, false)
+          end
+        else
+          column = column.to_s
+
+          if allow_table_name && column.include?('.')
+            table_name, column = column.split('.', 2)
+            table = Arel::Table.new(table_name, engine)
+          end
+
+          attribute = table[column.to_sym]
+
+          case value
+          when ActiveRecord::Relation
+            value = value.select(value.klass.arel_table[value.klass.primary_key]) if value.select_values.empty?
+            attribute.in(value.arel.ast)
+          when Array, ActiveRecord::Associations::CollectionProxy
+            column_definition = engine.columns.find { |col| col.name == column }
+
+            if column_definition.respond_to?(:array) && column_definition.array
+              attribute.eq(value)
+            else
+              values = value.to_a.map {|x| x.is_a?(ActiveRecord::Base) ? x.id : x}
+              ranges, values = values.partition {|v| v.is_a?(Range) || v.is_a?(Arel::Relation)}
+
+              array_predicates = ranges.map {|range| attribute.in(range)}
+
+              if values.include?(nil)
+                values = values.compact
+                if values.empty?
+                  array_predicates << attribute.eq(nil)
+                else
+                  array_predicates << attribute.in(values.compact).or(attribute.eq(nil))
+                end
+              else
+                array_predicates << attribute.in(values)
+              end
+
+              array_predicates.inject {|composite, predicate| composite.or(predicate)}
+            end
+          when Range, Arel::Relation
+            attribute.in(value)
+          when ActiveRecord::Base
+            attribute.eq(value.id)
+          when Class
+            # FIXME: I think we need to deprecate this behavior
+            attribute.eq(value.name)
+          else
+            attribute.eq(value)
+          end
+        end
+      end
+
+      predicates.flatten
+    end
+  end
+end

data/lib/activerecord-postgis-array/active_record/relation/query_methods.rb

@@ -0,0 +1,84 @@
+require 'active_record/relation/query_methods'
+
+module ActiveRecord
+  module QueryMethods
+    class WhereChain
+      def initialize(scope)
+        @scope = scope
+      end
+
+      def overlap(opts)
+        opts.each do |key, value|
+          @scope = @scope.where(arel_table[key].overlap(value))
+        end
+        @scope
+      end
+
+      def contained_within(opts)
+        opts.each do |key, value|
+          @scope = @scope.where(arel_table[key].contained_within(value))
+        end
+
+        @scope
+      end
+
+      def contained_within_or_equals(opts)
+        opts.each do |key, value|
+          @scope = @scope.where(arel_table[key].contained_within_or_equals(value))
+        end
+
+        @scope
+      end
+
+      def contains(opts)
+        opts.each do |key, value|
+          @scope = @scope.where(arel_table[key].contains(value))
+        end
+
+        @scope
+      end
+
+      def contains_or_equals(opts)
+        opts.each do |key, value|
+          @scope = @scope.where(arel_table[key].contains_or_equals(value))
+        end
+
+        @scope
+      end
+
+      def any(opts)
+        equality_to_function('ANY', opts)
+      end
+
+      def all(opts)
+        equality_to_function('ALL', opts)
+      end
+
+      private
+
+      def arel_table
+        @arel_table ||= @scope.engine.arel_table
+      end
+
+      def equality_to_function(function_name, opts)
+        opts.each do |key, value|
+          any_function = Arel::Nodes::NamedFunction.new(function_name, [arel_table[key]])
+          predicate = Arel::Nodes::Equality.new(value, any_function)
+          @scope = @scope.where(predicate)
+        end
+
+        @scope
+      end
+    end
+
+    def where_with_chaining(*opts, &block)
+      if opts.empty? && !block_given?
+        WhereChain.new(self)
+      else
+        where_without_chaining(*opts, &block)
+      end
+    end
+
+    alias_method_chain :where, :chaining
+  end
+end

data/lib/activerecord-postgis-array/active_record/sanitization.rb

@@ -0,0 +1,30 @@
+require 'active_record/sanitization'
+
+module ActiveRecord
+  module Sanitization
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def sanitize_sql_hash_for_assignment(attrs)
+        attrs.map do |attr, value|
+          "#{connection.quote_column_name(attr)} = #{quote_bound_value(value, attr)}"
+        end.join(', ')
+      end
+
+      def quote_bound_value(value, column = nil, c = connection)
+        if column.present? && column != c
+          record_column = self.columns.select {|col| col.name == column}.first
+          c.quote(value, record_column)
+        elsif value.respond_to?(:map) && !value.acts_like?(:string)
+          if value.respond_to?(:empty?) && value.empty?
+            c.quote(nil)
+          else
+            value.map { |v| c.quote(v) }.join(',')
+          end
+        else
+          c.quote(value)
+        end
+      end
+    end
+  end
+end

data/lib/activerecord-postgis-array/active_record/schema_dumper.rb

@@ -0,0 +1,157 @@
+require 'active_record/schema_dumper'
+
+module ActiveRecord
+  class SchemaDumper
+    VALID_COLUMN_SPEC_KEYS = [:name, :limit, :precision, :scale, :default, :null, :array]
+    def self.valid_column_spec_keys
+      VALID_COLUMN_SPEC_KEYS
+    end
+
+    def dump(stream)
+      header(stream)
+      # added
+      extensions(stream) if @connection.respond_to?(:supports_extensions?) && 
+                            @connection.supports_extensions?
+      # /added
+      tables(stream)
+      trailer(stream)
+      stream
+    end
+
+    private
+
+    def extensions(stream)
+      exts = @connection.extensions
+
+      unless exts.empty?
+        stream.puts exts.map { |name| "  add_extension \"#{name}\""}.join("\n") + "\n\n"
+      end
+    end
+
+    def table(table, stream)
+      columns = @connection.columns(table)
+      begin
+        tbl = StringIO.new
+
+        # first dump primary key column
+        if @connection.respond_to?(:pk_and_sequence_for)
+          pk, _ = @connection.pk_and_sequence_for(table)
+        elsif @connection.respond_to?(:primary_key)
+          pk = @connection.primary_key(table)
+        end
+
+        tbl.print "  create_table #{table.inspect}"
+        if columns.detect { |c| c.name == pk }
+          if pk != 'id'
+            tbl.print %Q(, :primary_key => "#{pk}")
+          end
+        else
+          tbl.print ", :id => false"
+        end
+        tbl.print ", :force => true"
+        tbl.puts " do |t|"
+
+        # then dump all non-primary key columns
+        column_specs = columns.map do |column|
+          raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" if @types[column.type].nil?
+          next if column.name == pk
+          spec = column_spec(column)
+          (spec.keys - [:name, :type]).each{ |k| spec[k].insert(0, "#{k.inspect} => ")}
+          spec
+        end.compact
+
+        # find all migration keys used in this table
+        keys = self.class.valid_column_spec_keys & column_specs.map{ |k| k.keys }.flatten
+
+        # figure out the lengths for each column based on above keys
+        lengths = keys.map{ |key| column_specs.map{ |spec| spec[key] ? spec[key].length + 2 : 0 }.max }
+
+        # the string we're going to sprintf our values against, with standardized column widths
+        format_string = lengths.map{ |len| "%-#{len}s" }
+
+        # find the max length for the 'type' column, which is special
+        type_length = column_specs.map{ |column| column[:type].length }.max
+
+        # add column type definition to our format string
+        format_string.unshift "    t.%-#{type_length}s "
+
+        format_string *= ''
+
+        column_specs.each do |colspec|
+          values = keys.zip(lengths).map{ |key, len| colspec.key?(key) ? colspec[key] + ", " : " " * len }
+          values.unshift colspec[:type]
+          tbl.print((format_string % values).gsub(/,\s*$/, ''))
+          tbl.puts
+        end
+
+        tbl.puts "  end"
+        tbl.puts
+
+        indexes(table, tbl)
+
+        tbl.rewind
+        stream.print tbl.read
+      rescue => e
+        stream.puts "# Could not dump table #{table.inspect} because of following #{e.class}"
+        stream.puts "#   #{e.message}"
+        stream.puts
+      end
+
+      stream
+    end
+
+    #mostly rails 3.2 code
+    def indexes(table, stream)
+      if (indexes = @connection.indexes(table)).any?
+        add_index_statements = indexes.map do |index|
+          statement_parts = [
+            ('add_index ' + index.table.inspect),
+            index.columns.inspect,
+            (':name => ' + index.name.inspect),
+          ]
+          statement_parts << ':unique => true' if index.unique
+
+          index_lengths = (index.lengths || []).compact
+          statement_parts << (':length => ' + Hash[index.columns.zip(index.lengths)].inspect) unless index_lengths.empty?
+
+          index_orders = (index.orders || {})
+          statement_parts << (':order => ' + index.orders.inspect) unless index_orders.empty?
+
+          # changed from rails 2.3
+          statement_parts << (':where => ' + index.where.inspect) if index.where
+          statement_parts << (':using => ' + index.using.inspect) if index.using
+          statement_parts << (':index_opclass => ' + index.index_opclass.inspect) if index.index_opclass.present?
+          # /changed
+
+          '  ' + statement_parts.join(', ')
+        end
+
+        stream.puts add_index_statements.sort.join("\n")
+        stream.puts
+      end
+    end
+
+    #mostly rails 3.2 code (pulled out of table method)
+    def column_spec(column)
+      spec = {}
+      spec[:name]      = column.name.inspect
+
+      # AR has an optimization which handles zero-scale decimals as integers. This
+      # code ensures that the dumper still dumps the column as a decimal.
+      spec[:type]      = if column.type == :integer && [/^numeric/, /^decimal/].any? { |e| e.match(column.sql_type) }
+                           'decimal'
+                         else
+                           column.type.to_s
+                         end
+      spec[:limit]     = column.limit.inspect if column.limit != @types[column.type][:limit] && spec[:type] != 'decimal'
+      spec[:precision] = column.precision.inspect if column.precision
+      spec[:scale]     = column.scale.inspect if column.scale
+      spec[:null]      = 'false' unless column.null
+      spec[:default]   = default_string(column.default) if column.has_default?
+      # changed from rails 3.2 code
+      spec[:array]     = 'true' if column.respond_to?(:array) && column.array
+      # /changed
+      spec
+    end
+  end
+end

data/lib/activerecord-postgis-array/arel.rb

@@ -0,0 +1,3 @@
+require 'activerecord-postgis-array/arel/nodes'
+require 'activerecord-postgis-array/arel/predications'
+require 'activerecord-postgis-array/arel/visitors'

data/lib/activerecord-postgis-array/arel/nodes.rb

@@ -0,0 +1,2 @@
+require 'activerecord-postgis-array/arel/nodes/array_nodes'
+require 'activerecord-postgis-array/arel/nodes/contained_within'

data/lib/activerecord-postgis-array/arel/nodes/array_nodes.rb

@@ -0,0 +1,9 @@
+require 'arel/nodes/binary'
+
+module Arel
+  module Nodes
+    class Overlap < Arel::Nodes::Binary
+      def operator; '&&' end
+    end
+  end
+end

data/lib/activerecord-postgis-array/arel/nodes/contained_within.rb

@@ -0,0 +1,20 @@
+require 'arel/nodes/binary'
+module Arel
+  module Nodes
+    class ContainedWithin < Arel::Nodes::Binary
+      def operator; :<< end
+    end
+
+    class ContainedWithinEquals < Arel::Nodes::Binary
+      def operator; '<<='.to_sym end
+    end
+
+    class Contains < Arel::Nodes::Binary
+      def operator; :>> end
+    end
+
+    class ContainsEquals < Arel::Nodes::Binary
+      def operator; '>>='.to_sym end
+    end
+  end
+end

data/lib/activerecord-postgis-array/arel/predications.rb

@@ -0,0 +1,25 @@
+require 'arel/predications'
+
+module Arel
+  module Predications
+    def contained_within(other)
+      Nodes::ContainedWithin.new self, other
+    end
+
+    def contained_within_or_equals(other)
+      Nodes::ContainedWithinEquals.new self, other
+    end
+
+    def contains(other)
+      Nodes::Contains.new self, other
+    end
+
+    def contains_or_equals(other)
+      Nodes::ContainsEquals.new self, other
+    end
+
+    def overlap(other)
+      Nodes::Overlap.new self, other
+    end
+  end
+end

data/lib/activerecord-postgis-array/arel/visitors.rb

@@ -0,0 +1,2 @@
+require 'activerecord-postgis-array/arel/visitors/visitor'
+require 'activerecord-postgis-array/arel/visitors/to_sql'

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

@@ -0,0 +1,15 @@
+require 'arel/visitors/to_sql'
+
+module Arel
+  module Visitors
+    class ToSql
+      def visit_Array o
+        if last_column.respond_to?(:array) && last_column.array
+          quoted o
+        else
+          o.empty? ? 'NULL' : o.map { |x| visit x }.join(', ')
+        end
+      end
+    end
+  end
+end

data/lib/activerecord-postgis-array/arel/visitors/visitor.rb

@@ -0,0 +1,38 @@
+require 'arel/visitors/visitor'
+module Arel
+  module Visitors
+    class Visitor
+      # We are adding our visitors to the main visitor for the time being until the right spot is found to monkey patch
+      private
+      def visit_Arel_Nodes_ContainedWithin o
+        "#{visit o.left} << #{visit o.right}"
+      end
+
+      def visit_Arel_Nodes_ContainedWithinEquals o
+        "#{visit o.left} <<= #{visit o.right}"
+      end
+
+      def visit_Arel_Nodes_Contains o
+        left_column = o.left.relation.engine.columns.find { |col| col.name == o.left.name.to_s }
+
+        if left_column && left_column.respond_to?(:array) && left_column.array
+          "#{visit o.left} @> #{visit o.right}"
+        else
+          "#{visit o.left} >> #{visit o.right}"
+        end
+      end
+
+      def visit_Arel_Nodes_ContainsEquals o
+        "#{visit o.left} >>= #{visit o.right}"
+      end
+
+      def visit_Arel_Nodes_Overlap o
+        "#{visit o.left} && #{visit o.right}"
+      end
+
+      def visit_IPAddr value
+        "'#{value.to_s}/#{value.instance_variable_get(:@mask_addr).to_s(2).count('1')}'"
+      end
+    end
+  end
+end