rgeo-activerecord 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c7eb9363bf2ff9df529e4df824e216d4020383a4
-  data.tar.gz: fc42ba79ef9e014b201ed9e0ada19aa097f2b95e
+  metadata.gz: 11ad920c01d1f944cd3d7f4f658b4138a1954284
+  data.tar.gz: 184abfc52e1c1708726c344bc66842133381949d
 SHA512:
-  metadata.gz: e04b5cac8c5de138c78de8ac43c6c7b2ab7b9479340db4fd62acdb498b5d799fda7be8ea73e378d3e37c225e8d23c53d012574d44a39dd8247d36fb57a9845e5
-  data.tar.gz: 14d81921b88784b5c251f589c5cfc912c063f753a059138d52156cfe40eaed029462413840d1e0c672448708eedeecfe0df9602f62dc3225fa2378e36531ba1a
+  metadata.gz: 6bffb41f789ef87f8557cbdbc786a3c2070c7d193e9fe819467397b556a613ac8a9b9e363def43a0f09afcfdfae8fdddeaf4b1584f5166901dbd59be2c6af1f8
+  data.tar.gz: 7254fcac74eb52b88152d27f8f452045f376202462365822432e0cda43c35ffa6f0df65516ad85f63e9f6b9a2af5eabc8d60e25da28bc7f5136b1b28c59745b2

data/History.md

@@ -1,3 +1,8 @@
+### 1.3.0 / 2017-07-02
+
+* Fix indexes in schema dump #25
+* Dump schema using new hash syntax #18
+
 ### 1.2.0 / 2014-08-21
 
 * Support ActiveRecord 4.2

data/lib/rgeo/active_record/ar_factory_settings.rb

@@ -2,11 +2,11 @@ module RGeo
   module ActiveRecord
     # The default factory generator for ActiveRecord::Base.
 
-    DEFAULT_FACTORY_GENERATOR = ::Proc.new do |config_|
-      if config_.delete(:geographic)
-        ::RGeo::Geographic.spherical_factory(config_)
+    DEFAULT_FACTORY_GENERATOR = ::Proc.new do |config|
+      if config.delete(:geographic)
+        ::RGeo::Geographic.spherical_factory(config)
       else
-        ::RGeo::Cartesian.preferred_factory(config_)
+        ::RGeo::Cartesian.preferred_factory(config)
       end
     end
 
@@ -19,40 +19,38 @@ module RGeo
       end
 
       # Get the default factory generator for the given table
-      def get_factory_generator(table_name_)
-        @factory_generators[table_name_.to_s] || ::RGeo::ActiveRecord::DEFAULT_FACTORY_GENERATOR
+      def get_factory_generator(table_name)
+        @factory_generators[table_name.to_s] || ::RGeo::ActiveRecord::DEFAULT_FACTORY_GENERATOR
       end
 
       # Set the default factory generator for the given table
-      def set_factory_generator(table_name_, gen_)
-        @factory_generators[table_name_.to_s] = gen_
+      def set_factory_generator(table_name, generator)
+        @factory_generators[table_name.to_s] = generator
       end
 
-      # Get the factory or factory generator for the given table name
-      # and column name.
-      def get_column_factory(table_name_, column_name_, params_=nil)
-        table_name_ = table_name_.to_s
-        column_name_ = column_name_.to_s
-        result_ = (@column_factories[table_name_] ||= {})[column_name_] ||
-          @factory_generators[table_name_] || ::RGeo::ActiveRecord::DEFAULT_FACTORY_GENERATOR
-        if params_ && !result_.kind_of?(::RGeo::Feature::Factory::Instance)
-          result_ = result_.call(params_)
+      # Get the factory or factory generator for the given table name and column name.
+      def get_column_factory(table_name, column_name, params = nil)
+        table_name = table_name.to_s
+        column_name = column_name.to_s
+        result = (@column_factories[table_name] ||= {})[column_name] ||
+          @factory_generators[table_name] || ::RGeo::ActiveRecord::DEFAULT_FACTORY_GENERATOR
+        if params && !result.kind_of?(::RGeo::Feature::Factory::Instance)
+          result = result.call(params)
         end
-        result_
+        result
       end
 
-      # Set the factory or factory generator for the given table name
-      # and column name.
-      def set_column_factory(table_name_, column_name_, factory_)
-        (@column_factories[table_name_.to_s] ||= {})[column_name_.to_s] = factory_
+      # Set the factory or factory generator for the given table name and column name.
+      def set_column_factory(table_name, column_name, factory)
+        (@column_factories[table_name.to_s] ||= {})[column_name.to_s] = factory
       end
 
       # Clear settings for the given table name, or for all tables
-      def clear!(table_name_=nil)
-        if table_name_
-          table_name_ = table_name_.to_s
-          @factory_generators.delete(table_name_)
-          @column_factories.delete(table_name_)
+      def clear!(table_name = nil)
+        if table_name
+          table_name = table_name.to_s
+          @factory_generators.delete(table_name)
+          @column_factories.delete(table_name)
         else
           @factory_generators.clear
           @column_factories.clear
@@ -65,15 +63,14 @@ module RGeo
     # Additional class methods on ::ActiveRecord::Base that provide
     # a way to control the RGeo factory used for ActiveRecord objects.
     module ActiveRecordBaseFactorySettings
-      # Return the RGeoFactorySettings object associated with this
-      # class's connection.
+      # Return the RGeoFactorySettings object associated with this class's connection.
       def rgeo_factory_settings
-        pool_ = begin
+        pool = begin
           connection_pool
         rescue ::ActiveRecord::ConnectionNotEstablished
           nil
         end
-        pool_ ? pool_.rgeo_factory_settings : RGeoFactorySettings::DEFAULT
+        pool ? pool.rgeo_factory_settings : RGeoFactorySettings::DEFAULT
       end
 
       # The value of this attribute is a RGeo::Feature::FactoryGenerator
@@ -92,21 +89,21 @@ module RGeo
       end
 
       # Set the rgeo_factory_generator attribute
-      def rgeo_factory_generator=(gen_)
-        rgeo_factory_settings.set_factory_generator(table_name, gen_)
+      def rgeo_factory_generator=(generator)
+        rgeo_factory_settings.set_factory_generator(table_name, generator)
       end
 
       # This is a convenient way to set the rgeo_factory_generator by
       # passing a block.
-      def to_generate_rgeo_factory(&block_)
-        rgeo_factory_settings.set_factory_generator(table_name, block_)
+      def to_generate_rgeo_factory(&block)
+        rgeo_factory_settings.set_factory_generator(table_name, block)
       end
 
       # Set a specific factory for this ActiveRecord class and the given
       # column name. This setting, if present, overrides the result of the
       # rgeo_factory_generator.
-      def set_rgeo_factory_for_column(column_name_, factory_)
-        rgeo_factory_settings.set_column_factory(table_name, column_name_, factory_)
+      def set_rgeo_factory_for_column(column_name, factory)
+        rgeo_factory_settings.set_column_factory(table_name, column_name, factory)
       end
 
       # Returns the factory generator or specific factory to use for this
@@ -116,8 +113,8 @@ module RGeo
       # rgeo_factory_generator for this class, and returns the resulting
       # factory. Otherwise, if no params hash is given, just returns the
       # rgeo_factory_generator for this class.
-      def rgeo_factory_for_column(column_name_, params_=nil)
-        rgeo_factory_settings.get_column_factory(table_name, column_name_, params_)
+      def rgeo_factory_for_column(column_name, params = nil)
+        rgeo_factory_settings.get_column_factory(table_name, column_name, params)
       end
     end
 
@@ -135,11 +132,11 @@ module RGeo
 
       alias_method :new_connection_without_rgeo_modification, :new_connection
       def new_connection
-        result_ = new_connection_without_rgeo_modification
-        if result_.respond_to?(:set_rgeo_factory_settings)
-          result_.set_rgeo_factory_settings(rgeo_factory_settings)
+        result = new_connection_without_rgeo_modification
+        if result.respond_to?(:set_rgeo_factory_settings)
+          result.set_rgeo_factory_settings(rgeo_factory_settings)
         end
-        result_
+        result
       end
     end
 

data/lib/rgeo/active_record/arel_spatial_queries.rb

@@ -12,8 +12,8 @@ module RGeo
       # a particular database. This method should take a name and
       # return either the changed name or the original name.
 
-      def st_func(standard_name_)
-        standard_name_
+      def st_func(standard_name)
+        standard_name
       end
 
       # Visit the SpatialNamedFunction node. This operates similarly to
@@ -21,40 +21,39 @@ module RGeo
       # mapping for the database, and it also uses the type information
       # in the node to determine when to cast string arguments to WKT,
 
-      def visit_RGeo_ActiveRecord_SpatialNamedFunction(node_, *args)
-        name_ = st_func(node_.name)
-        exprs_ = []
-        node_.expressions.each_with_index do |expr_, index_|
-          exprs_ << (node_.spatial_argument?(index_) ? visit_in_spatial_context(expr_, *args) : visit(expr_, *args))
+      def visit_RGeo_ActiveRecord_SpatialNamedFunction(node, *args)
+        name_ = st_func(node.name)
+        exprs = []
+        node.expressions.each_with_index do |expr, index|
+          exprs << (node.spatial_argument?(index) ? visit_in_spatial_context(expr, *args) : visit(expr, *args))
         end
-        "#{name_}(#{node_.distinct ? 'DISTINCT ' : ''}#{exprs_.join(', ')})#{node_.alias ? " AS #{visit(node_.alias, *args)}" : ''}"
+        "#{name_}(#{node.distinct ? 'DISTINCT ' : ''}#{exprs.join(', ')})#{node.alias ? " AS #{visit(node.alias, *args)}" : ''}"
       end
 
       # Generates SQL for a spatial node.
       # The node must be a string (in which case it is treated as WKT),
       # an RGeo feature, or a spatial attribute.
-      def visit_in_spatial_context(node_, *args)
-        case node_
+      def visit_in_spatial_context(node, *args)
+        case node
         when ::String
-          "#{st_func('ST_WKTToSQL')}(#{quote(node_)})"
+          "#{st_func('ST_WKTToSQL')}(#{quote(node)})"
         when ::RGeo::Feature::Instance
-          visit_RGeo_Feature_Instance(node_, *args)
+          visit_RGeo_Feature_Instance(node, *args)
         when ::RGeo::Cartesian::BoundingBox
-          visit_RGeo_Cartesian_BoundingBox(node_, *args)
+          visit_RGeo_Cartesian_BoundingBox(node, *args)
         else
-          visit(node_, *args)
+          visit(node, *args)
         end
       end
     end
 
-    # This node wraps an RGeo feature and gives it spatial expression
-    # constructors.
+    # This node wraps an RGeo feature and gives it spatial expression constructors.
     class SpatialConstantNode
       include ::RGeo::ActiveRecord::SpatialExpressions
 
       # The delegate should be the RGeo feature.
-      def initialize(delegate_)
-        @delegate = delegate_
+      def initialize(delegate)
+        @delegate = delegate
       end
 
       # Return the RGeo feature
@@ -63,32 +62,33 @@ module RGeo
 
     # :stopdoc:
 
-    # Make sure the standard Arel visitors can handle RGeo feature objects
-    # by default.
+    # Make sure the standard Arel visitors can handle RGeo feature objects by default.
 
     ::Arel::Visitors::Visitor.class_eval do
-      def visit_RGeo_ActiveRecord_SpatialConstantNode(node_, *args)
+      def visit_RGeo_ActiveRecord_SpatialConstantNode(node, *args)
         if respond_to?(:visit_in_spatial_context)
-          visit_in_spatial_context(node_.delegate, *args)
+          visit_in_spatial_context(node.delegate, *args)
         else
-          visit(node_.delegate, *args)
+          visit(node.delegate, *args)
         end
       end
     end
+
     ::Arel::Visitors::Dot.class_eval do
       alias :visit_RGeo_Feature_Instance :visit_String
       alias :visit_RGeo_Cartesian_BoundingBox :visit_String
     end
+
     ::Arel::Visitors::DepthFirst.class_eval do
       alias :visit_RGeo_Feature_Instance :terminal
       alias :visit_RGeo_Cartesian_BoundingBox :terminal
     end
+
     ::Arel::Visitors::ToSql.class_eval do
       alias :visit_RGeo_Feature_Instance :visit_String
       alias :visit_RGeo_Cartesian_BoundingBox :visit_String
     end
 
-
     # A NamedFunction subclass that keeps track of the spatial-ness of
     # the arguments and return values, so that it can provide context to
     # visitors that want to interpret syntax differently when dealing with
@@ -96,19 +96,18 @@ module RGeo
     class SpatialNamedFunction < ::Arel::Nodes::NamedFunction
       include ::RGeo::ActiveRecord::SpatialExpressions
 
-      def initialize(name_, expr_, spatial_flags_=[], aliaz_=nil)
-        super(name_, expr_, aliaz_)
-        @spatial_flags = spatial_flags_
+      def initialize(name, expr, spatial_flags = [], aliaz = nil)
+        super(name, expr, aliaz)
+        @spatial_flags = spatial_flags
       end
 
       def spatial_result?
         @spatial_flags.first
       end
 
-      def spatial_argument?(index_)
-        @spatial_flags[index_+1]
+      def spatial_argument?(index)
+        @spatial_flags[index + 1]
       end
-
     end
 
     # :startdoc:

data/lib/rgeo/active_record/common_adapter_elements.rb

@@ -6,26 +6,26 @@ module RGeo
     # Some default column constructors specifications for most spatial
     # databases. Individual adapters may add to or override this list.
     DEFAULT_SPATIAL_COLUMN_CONSTRUCTORS = {
-      :spatial => {:type => 'geometry'}.freeze,
-      :geometry => {}.freeze,
-      :point => {}.freeze,
-      :line_string => {}.freeze,
-      :polygon => {}.freeze,
-      :geometry_collection => {}.freeze,
-      :multi_line_string => {}.freeze,
-      :multi_point => {}.freeze,
-      :multi_polygon => {}.freeze,
+      spatial:             { type: 'geometry' }.freeze,
+      geometry:            {}.freeze,
+      point:               {}.freeze,
+      line_string:         {}.freeze,
+      polygon:             {}.freeze,
+      geometry_collection: {}.freeze,
+      multi_line_string:   {}.freeze,
+      multi_point:         {}.freeze,
+      multi_polygon:       {}.freeze,
     }.freeze
 
     # Index definition struct with a spatial flag field.
 
-    class SpatialIndexDefinition < Struct.new(:table, :name, :unique, :columns, :lengths, :orders, :where, :spatial)
+    class SpatialIndexDefinition < Struct.new(:table, :name, :unique, :columns, :lengths, :orders, :where, :using, :type, :spatial)
     end
 
     # Returns a feature type module given a string type.
 
-    def self.geometric_type_from_name(name_)
-      case name_.to_s
+    def self.geometric_type_from_name(name)
+      case name.to_s
       when /^geometry/i then ::RGeo::Feature::Geometry
       when /^point/i then ::RGeo::Feature::Point
       when /^linestring/i then ::RGeo::Feature::LineString
@@ -49,16 +49,16 @@ module RGeo
         end
       end
 
-      def method_missing_with_rgeo(method_name_, *args_, &block_)
-        if @base.respond_to?(:spatial_column_constructor) && (info_ = @base.spatial_column_constructor(method_name_))
-          info_ = info_.dup
-          type_ = (info_.delete(:type) || method_name_).to_s
-          opts_ = args_.extract_options!.merge(info_)
-          args_.each do |name_|
-            column(name_, type_, opts_)
+      def method_missing_with_rgeo(method_name, *args, &block)
+        if @base.respond_to?(:spatial_column_constructor) && (info = @base.spatial_column_constructor(method_name))
+          info = info.dup
+          type = (info.delete(:type) || method_name).to_s
+          opts = args.extract_options!.merge(info)
+          args.each do |name|
+            column(name, type, opts)
           end
         else
-          method_missing_without_rgeo(method_name_, *args_, &block_)
+          method_missing_without_rgeo(method_name, *args, &block)
         end
       end
     end
@@ -75,16 +75,16 @@ module RGeo
         end
       end
 
-      def method_missing_with_rgeo(method_name_, *args_, &block_)
-        if @base.respond_to?(:spatial_column_constructor) && (info_ = @base.spatial_column_constructor(method_name_))
-          info_ = info_.dup
-          type_ = (info_.delete(:type) || method_name_).to_s
-          opts_ = args_.extract_options!.merge(info_)
-          args_.each do |name_|
-            @base.add_column(@table_name, name_, type_, opts_)
+      def method_missing_with_rgeo(method_name, *args, &block)
+        if @base.respond_to?(:spatial_column_construcor) && (info = @base.spatial_column_constructor(method_name))
+          info = info.dup
+          type = (info.delete(:type) || method_name).to_s
+          opts = args.extract_options!.merge(info)
+          args.each do |name|
+            @base.add_column(@table_name, name, type, opts)
           end
         else
-          method_missing_without_rgeo(method_name_, *args_, &block_)
+          method_missing_without_rgeo(method_name, *args, &block)
         end
       end
     end
@@ -103,22 +103,30 @@ module RGeo
 
       private
 
-      def indexes_with_rgeo(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
-            statement_parts_ << ':spatial => true' if index_.respond_to?(:spatial) && index_.spatial
-            index_lengths_ = (index_.lengths || []).compact
-            statement_parts_ << (':length => ' + ::Hash[*index_.columns.zip(index_.lengths).flatten].inspect) unless index_lengths_.empty?
-            '  ' + statement_parts_.join(', ')
+      def indexes_with_rgeo(table, stream)
+        indexes = @connection.indexes(table)
+        if indexes.any?
+          add_index_statements = indexes.map do |index|
+            statement = [
+                ("add_index #{index.table.inspect}"),
+                index.columns.inspect,
+                ("name: #{index.name.inspect}"),
+              ]
+            statement << 'unique: true' if index.unique
+            statement << 'spatial: true' if index.respond_to?(:spatial) && index.spatial
+            index_lengths = (index.lengths || []).compact
+            statement << ("length: #{::Hash[*index.columns.zip(index.lengths).flatten].inspect}") if index_lengths.any?
+
+            index_orders = index.orders || {}
+            statement << "order: #{index.orders.inspect}" if index_orders.any?
+            statement << "where: #{index.where.inspect}" if index.where
+            statement << "using: #{index.using.inspect}" if index.using
+            statement << "type: #{index.type.inspect}" if index.type
+
+            "  #{statement.join(', ')}"
           end
-          stream_.puts add_index_statements_.sort.join("\n")
-          stream_.puts
+          stream.puts add_index_statements.sort.join("\n")
+          stream.puts
         end
       end
     end

data/lib/rgeo/active_record/geometry_mixin.rb

@@ -6,7 +6,7 @@ module RGeo
 
     module GeometryMixin
       # The default JSON generator Proc. Renders geometry fields as WKT.
-      DEFAULT_JSON_GENERATOR = ::Proc.new{ |geom_| geom_.to_s }
+      DEFAULT_JSON_GENERATOR = ::Proc.new{ |geom| geom.to_s }
 
       @json_generator = DEFAULT_JSON_GENERATOR
 
@@ -22,15 +22,15 @@ module RGeo
       # <tt>:geojson</tt>::
       #   GeoJSON format. Requires the rgeo-geojson gem.
 
-      def self.set_json_generator(value_=nil, &block_)
-        if block_ && !value_
-          value_ = block_
-        elsif value_ == :geojson
+      def self.set_json_generator(value = nil, &block)
+        if block && !value
+          value = block
+        elsif value == :geojson
           require 'rgeo/geo_json'
-          value_ = ::Proc.new{ |geom_| ::RGeo::GeoJSON.encode(geom_) }
+          value = ::Proc.new{ |geom_| ::RGeo::GeoJSON.encode(geom_) }
         end
-        if value_.is_a?(::Proc)
-          @json_generator = value_
+        if value.is_a?(::Proc)
+          @json_generator = value
         else
           @json_generator = DEFAULT_JSON_GENERATOR
         end
@@ -41,14 +41,13 @@ module RGeo
       # This is used to generate JSON for geometry-valued ActiveRecord
       # fields by default.
 
-      def self.generate_json(geom_)
-        @json_generator.call(geom_)
+      def self.generate_json(geom)
+        @json_generator.call(geom)
       end
 
-
       # Serializes this object as JSON for ActiveRecord.
 
-      def as_json(opts_=nil)
+      def as_json(opts = nil)
         GeometryMixin.generate_json(self)
       end
     end

data/lib/rgeo/active_record/spatial_expressions.rb

@@ -18,9 +18,9 @@ module RGeo
       # Generic functions
       #++
 
-      def st_function(function_, *args_)
-        spatial_info_ = args_.last.is_a?(::Array) ? args_.pop : []
-        ::RGeo::ActiveRecord::SpatialNamedFunction.new(function_, [self] + args_, spatial_info_)
+      def st_function(function, *args)
+        spatial_info = args.last.is_a?(::Array) ? args.pop : []
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new(function, [self] + args, spatial_info)
       end
 
       #--
@@ -63,70 +63,70 @@ module RGeo
         ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Envelope', [self], [true, true])
       end
 
-      def st_equals(rhs_)
-        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Equals', [self, rhs_], [false, true, true])
+      def st_equals(rhs)
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Equals', [self, rhs], [false, true, true])
       end
 
-      def st_disjoint(rhs_)
-        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Disjoint', [self, rhs_], [false, true, true])
+      def st_disjoint(rhs)
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Disjoint', [self, rhs], [false, true, true])
       end
 
-      def st_intersects(rhs_)
-        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Intersects', [self, rhs_], [false, true, true])
+      def st_intersects(rhs)
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Intersects', [self, rhs], [false, true, true])
       end
 
-      def st_touches(rhs_)
-        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Touches', [self, rhs_], [false, true, true])
+      def st_touches(rhs)
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Touches', [self, rhs], [false, true, true])
       end
 
-      def st_crosses(rhs_)
-        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Crosses', [self, rhs_], [false, true, true])
+      def st_crosses(rhs)
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Crosses', [self, rhs], [false, true, true])
       end
 
-      def st_within(rhs_)
-        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Within', [self, rhs_], [false, true, true])
+      def st_within(rhs)
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Within', [self, rhs], [false, true, true])
       end
 
-      def st_contains(rhs_)
-        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Contains', [self, rhs_], [false, true, true])
+      def st_contains(rhs)
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Contains', [self, rhs], [false, true, true])
       end
 
-      def st_overlaps(rhs_)
-        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Overlaps', [self, rhs_], [false, true, true])
+      def st_overlaps(rhs)
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Overlaps', [self, rhs], [false, true, true])
       end
 
-      def st_relate(rhs_, matrix_=nil)
-        args_ = [self, rhs_]
-        args_ << matrix.to_s if matrix_
-        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Relate', args_, [false, true, true, false])
+      def st_relate(rhs, matrix = nil)
+        args = [self, rhs]
+        args << matrix.to_s if matrix
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Relate', args, [false, true, true, false])
       end
 
-      def st_distance(rhs_, units_=nil)
-        args_ = [self, rhs_]
-        args_ << units.to_s if units_
-        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Distance', args_, [false, true, true, false])
+      def st_distance(rhs, units = nil)
+        args = [self, rhs]
+        args << units.to_s if units
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Distance', args, [false, true, true, false])
       end
 
-      def st_intersection(rhs_)
-        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Intersection', [self, rhs_], [true, true, true])
+      def st_intersection(rhs)
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Intersection', [self, rhs], [true, true, true])
       end
 
-      def st_difference(rhs_)
-        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Difference', [self, rhs_], [true, true, true])
+      def st_difference(rhs)
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Difference', [self, rhs], [true, true, true])
       end
 
-      def st_union(rhs_)
-        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Union', [self, rhs_], [true, true, true])
+      def st_union(rhs)
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Union', [self, rhs], [true, true, true])
       end
 
-      def st_symdifference(rhs_)
-        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_SymDifference', [self, rhs_], [true, true, true])
+      def st_symdifference(rhs)
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_SymDifference', [self, rhs], [true, true, true])
       end
 
-      def st_buffer(distance_, units_=nil)
-        args_ = [self, distance_.to_f]
-        args_ << units.to_s if units_
-        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Buffer', args_, [true, true, false])
+      def st_buffer(distance, units = nil)
+        args = [self, distance.to_f]
+        args << units.to_s if units
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Buffer', args, [true, true, false])
       end
 
       def st_convexhull
@@ -175,10 +175,10 @@ module RGeo
         ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_IsRing', [self], [false, true])
       end
 
-      def st_length(units_=nil)
-        args_ = [self]
-        args_ << units.to_s if units_
-        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Length', args_, [false, true, false])
+      def st_length(units = nil)
+        args = [self]
+        args << units.to_s if units
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_Length', args, [false, true, false])
       end
 
 
@@ -190,8 +190,8 @@ module RGeo
         ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_NumPoints', [self], [false, true])
       end
 
-      def st_pointn(n_)
-        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_PointN', [self, n_.to_i], [true, true, false])
+      def st_pointn(n)
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_PointN', [self, n.to_i], [true, true, false])
       end
 
 
@@ -199,10 +199,10 @@ module RGeo
       # Surface functions
       #++
 
-      def st_area(units_=nil)
-        args_ = [self]
-        args_ << units.to_s if units_
-        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_StartPoint', args_, [false, true, false])
+      def st_area(units = nil)
+        args = [self]
+        args << units.to_s if units
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_StartPoint', args, [false, true, false])
       end
 
       def st_centroid
@@ -227,8 +227,8 @@ module RGeo
         ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_NumInteriorRing', [self], [false, true])
       end
 
-      def st_interiorringn(n_)
-        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_InteriorRingN', [self, n_.to_i], [true, true, false])
+      def st_interiorringn(n)
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_InteriorRingN', [self, n.to_i], [true, true, false])
       end
 
       #--
@@ -239,8 +239,8 @@ module RGeo
         ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_NumGeometries', [self], [false, true])
       end
 
-      def st_geometryn(n_)
-        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_GeometryN', [self, n_.to_i], [true, true, false])
+      def st_geometryn(n)
+        ::RGeo::ActiveRecord::SpatialNamedFunction.new('ST_GeometryN', [self, n.to_i], [true, true, false])
       end
 
     end
@@ -263,8 +263,8 @@ module Arel
   #
   # Requires Arel 2.1 or later.
 
-  def self.spatial(arg_)
-    ::RGeo::ActiveRecord::SpatialConstantNode.new(arg_)
+  def self.spatial(arg)
+    ::RGeo::ActiveRecord::SpatialConstantNode.new(arg)
   end
 
 end

data/lib/rgeo/active_record/version.rb

@@ -1,5 +1,5 @@
 module RGeo
   module ActiveRecord
-    VERSION = '1.2.0'.freeze
+    VERSION = '1.3.0'.freeze
   end
 end

data/test/basic_test.rb

@@ -0,0 +1,75 @@
+require 'test_helper'
+
+class BasicTest < MINITEST_CLASS  # :nodoc:
+  class MyTable < ::ActiveRecord::Base
+  end
+
+  def test_has_version
+    assert RGeo::ActiveRecord::VERSION
+  end
+
+  def test_default_factory_generator
+    MyTable.rgeo_factory_generator = nil
+    factory = MyTable.rgeo_factory_for_column(:hello).call(has_z_coordinate: true, srid: 4326)
+    assert_equal true, factory.property(:has_z_coordinate)
+    assert_equal true, factory.property(:is_cartesian)
+    assert_nil factory.property(:is_geographic)
+    assert_equal 4326, factory.srid
+  end
+
+  def test_set_factory_generator
+    MyTable.rgeo_factory_generator = RGeo::Geographic.method(:spherical_factory)
+    factory = MyTable.rgeo_factory_for_column(:hello, has_z_coordinate: true, srid: 4326)
+    assert_equal true, factory.property(:has_z_coordinate)
+    assert_equal true, factory.property(:is_geographic)
+    assert_nil factory.property(:is_cartesian)
+    assert_equal false, factory.has_projection?
+    assert_equal 4326, factory.srid
+  end
+
+  def test_specific_factory_for_column
+    MyTable.rgeo_factory_generator = nil
+    MyTable.set_rgeo_factory_for_column(:foo, RGeo::Geographic.simple_mercator_factory(has_z_coordinate: true))
+    factory = MyTable.rgeo_factory_for_column(:foo)
+    assert_equal true, factory.property(:has_z_coordinate)
+    assert_equal true, factory.property(:is_geographic)
+    assert_nil factory.property(:is_cartesian)
+    assert_equal true, factory.has_projection?
+    assert_equal 4326, factory.srid
+  end
+
+  def test_default_as_json_wkt
+    RGeo::ActiveRecord::GeometryMixin.set_json_generator(nil)
+    factory = RGeo::Cartesian.preferred_factory
+    point = factory.point(1, 2)
+    assert_equal "POINT (1.0 2.0)", point.as_json
+  end
+
+  def test_default_as_json_geojson
+    RGeo::ActiveRecord::GeometryMixin.set_json_generator(:geojson)
+    factory = RGeo::Cartesian.preferred_factory
+    point = factory.point(1, 2)
+    assert_equal({'type' => 'Point', 'coordinates' => [1.0, 2.0]}, point.as_json)
+  end
+
+  def test_arel_visit_spatial_constant_node
+    visitor = arel_visitor
+
+    # :accept API changed in Arel 6.0:
+    # https://github.com/rails/arel/commit/fcd11dcb99d69d
+    sql = if Arel::VERSION > "6.0.0"
+        visitor.accept(Arel.spatial('POINT (1.0 2.0)'), Arel::Collectors::PlainString.new)
+      else
+        visitor.accept(Arel.spatial('POINT (1.0 2.0)'))
+      end
+
+    assert_equal("ST_WKTToSQL('POINT (1.0 2.0)')", sql)
+  end
+
+  private
+
+  def arel_visitor
+    Arel::Visitors::PostgreSQL.new(Arel::Table.engine.connection)
+  end
+
+end

data/test/test_helper.rb

@@ -10,7 +10,3 @@ MINITEST_CLASS = if defined?(::Minitest::Test)
 
 Arel::Visitors::PostgreSQL.send(:include, ::RGeo::ActiveRecord::SpatialToSql)
 Arel::Table.engine = FakeRecord::Base.new
-
-def arel_visitor
-  Arel::Visitors::PostgreSQL.new(Arel::Table.engine.connection)
-end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rgeo-activerecord
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Daniel Azuma
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-29 00:00:00.000000000 Z
+date: 2017-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rgeo
@@ -86,8 +86,8 @@ files:
 - lib/rgeo/active_record/geometry_mixin.rb
 - lib/rgeo/active_record/spatial_expressions.rb
 - lib/rgeo/active_record/version.rb
+- test/basic_test.rb
 - test/support/fake_record.rb
-- test/tc_basic.rb
 - test/test_helper.rb
 homepage: http://github.com/rgeo/rgeo-activerecord
 licenses: []
@@ -108,12 +108,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.1
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: An RGeo module providing spatial extensions to ActiveRecord.
 test_files:
+- test/basic_test.rb
 - test/support/fake_record.rb
-- test/tc_basic.rb
 - test/test_helper.rb
 has_rdoc: 

data/test/tc_basic.rb

@@ -1,74 +0,0 @@
-require 'test_helper'
-
-module RGeo
-  module ActiveRecord
-    module Tests  # :nodoc:
-      class TestBasic < MINITEST_CLASS  # :nodoc:
-        class MyTable < ::ActiveRecord::Base
-        end
-
-        def test_has_version
-          assert ::RGeo::ActiveRecord::VERSION
-        end
-
-        def test_default_factory_generator
-          MyTable.rgeo_factory_generator = nil
-          factory_ = MyTable.rgeo_factory_for_column(:hello).call(:has_z_coordinate => true, :srid => 4326)
-          assert_equal(true, factory_.property(:has_z_coordinate))
-          assert_equal(true, factory_.property(:is_cartesian))
-          assert_nil(factory_.property(:is_geographic))
-          assert_equal(4326, factory_.srid)
-        end
-
-        def test_set_factory_generator
-          MyTable.rgeo_factory_generator = ::RGeo::Geographic.method(:spherical_factory)
-          factory_ = MyTable.rgeo_factory_for_column(:hello, :has_z_coordinate => true, :srid => 4326)
-          assert_equal(true, factory_.property(:has_z_coordinate))
-          assert_equal(true, factory_.property(:is_geographic))
-          assert_nil(factory_.property(:is_cartesian))
-          assert_equal(false, factory_.has_projection?)
-          assert_equal(4326, factory_.srid)
-        end
-
-        def test_specific_factory_for_column
-          MyTable.rgeo_factory_generator = nil
-          MyTable.set_rgeo_factory_for_column(:foo, ::RGeo::Geographic.simple_mercator_factory(:has_z_coordinate => true))
-          factory_ = MyTable.rgeo_factory_for_column(:foo)
-          assert_equal(true, factory_.property(:has_z_coordinate))
-          assert_equal(true, factory_.property(:is_geographic))
-          assert_nil(factory_.property(:is_cartesian))
-          assert_equal(true, factory_.has_projection?)
-          assert_equal(4326, factory_.srid)
-        end
-
-        def test_default_as_json_wkt
-          GeometryMixin.set_json_generator(nil)
-          factory_ = ::RGeo::Cartesian.preferred_factory
-          p_ = factory_.point(1, 2)
-          assert_equal("POINT (1.0 2.0)", p_.as_json)
-        end
-
-        def test_default_as_json_geojson
-          GeometryMixin.set_json_generator(:geojson)
-          factory_ = ::RGeo::Cartesian.preferred_factory
-          p_ = factory_.point(1, 2)
-          assert_equal({'type' => 'Point', 'coordinates' => [1.0, 2.0]}, p_.as_json)
-        end
-
-        def test_arel_visit_SpatialConstantNode
-          visitor = arel_visitor
-
-          # :accept API changed in Arel 6.0:
-          # https://github.com/rails/arel/commit/fcd11dcb99d69d
-          sql = if Arel::VERSION > "6.0.0"
-              visitor.accept(Arel.spatial('POINT (1.0 2.0)'), Arel::Collectors::PlainString.new)
-            else
-              visitor.accept(Arel.spatial('POINT (1.0 2.0)'))
-            end
-
-          assert_equal("ST_WKTToSQL('POINT (1.0 2.0)')", sql)
-        end
-      end
-    end
-  end
-end