ffi-geos 1.2.0 → 2.2.0

data/lib/ffi-geos/tools.rb

@@ -1,16 +1,15 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 module Geos
   class NullPointerError < Geos::Error
     def initialize(*)
-      super("Tried to create a Geometry from a NULL pointer!")
+      super('Tried to create a Geometry from a NULL pointer!')
     end
   end
 
   class InvalidGeometryTypeError < Geos::Error
     def initialize(*)
-      super("Invalid geometry type")
+      super('Invalid geometry type')
     end
   end
 
@@ -25,12 +24,10 @@ module Geos
 
     def cast_geometry_ptr(geom_ptr, options = {})
       options = {
-        :auto_free => true
+        auto_free: true
       }.merge(options)
 
-      if geom_ptr.null?
-        raise Geos::NullPointerError.new
-      end
+      raise Geos::NullPointerError if geom_ptr.null?
 
       klass = case FFIGeos.GEOSGeomTypeId_r(Geos.current_handle_pointer, geom_ptr)
         when GEOS_POINT
@@ -50,10 +47,10 @@ module Geos
         when GEOS_GEOMETRYCOLLECTION
           GeometryCollection
         else
-          raise Geos::InvalidGeometryTypeError.new
+          raise Geos::InvalidGeometryTypeError
       end
 
-      klass.new(geom_ptr, options).tap { |ret|
+      klass.new(geom_ptr, options).tap do |ret|
         if options[:srid]
           ret.srid = options[:srid] || 0
         elsif options[:srid_copy]
@@ -63,11 +60,11 @@ module Geos
             options[:srid_copy] || 0
           end
         end
-      }
+      end
     end
 
     def check_geometry(geom)
-      raise TypeError.new("Expected Geos::Geometry") unless geom.is_a?(Geos::Geometry)
+      raise TypeError, 'Expected Geos::Geometry' unless geom.is_a?(Geos::Geometry)
     end
 
     def pick_srid_from_geoms(srid_a, srid_b, policy = Geos.srid_copy_policy)
@@ -81,7 +78,7 @@ module Geos
         when :strict
           raise Geos::MixedSRIDsError.new(srid_a, srid_b)
         else
-          raise ArgumentError.new("Unexpected policy value: #{policy}")
+          raise ArgumentError, "Unexpected policy value: #{policy}"
       end
     end
 
@@ -97,12 +94,12 @@ module Geos
 
     def bool_result(result)
       case result
-      when 1
-        true
-      when 0
-        false
-      else
-        raise Geos::UnexpectedBooleanResultError.new(result)
+        when 1
+          true
+        when 0
+          false
+        else
+          raise Geos::UnexpectedBooleanResultError, result
       end
     end
 
@@ -116,7 +113,7 @@ module Geos
 
     def check_enum_value(enum, value)
       enum[value] or
-        raise TypeError.new("Couldn't find valid #{enum.tag} value: #{value}")
+        raise TypeError, "Couldn't find valid #{enum.tag} value: #{value}"
     end
 
     def symbol_for_enum(enum, value)

data/lib/ffi-geos/utils.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 module Geos
@@ -31,106 +30,86 @@ module Geos
       def create_point(*args)
         options = extract_options!(args)
 
-        if args.length == 1
-          cs = args.first
-        elsif args.length == 2
-          cs = CoordinateSequence.new(1, 2)
-          cs.x[0], cs.y[0] = args[0].to_f, args[1].to_f
-        elsif args.length == 3
-          cs = CoordinateSequence.new(1, 3)
-          cs.x[0], cs.y[0], cs.z[0] = args.map(&:to_f)
-        else
-          raise ArgumentError.new("Wrong number of arguments (#{args.length} for 1-3)")
+        case args.length
+          when 1
+            cs = args.first
+          when 2
+            cs = CoordinateSequence.new(1, 2)
+            cs.x[0] = args[0].to_f
+            cs.y[0] = args[1].to_f
+          when 3
+            cs = CoordinateSequence.new(1, 3)
+            cs.x[0], cs.y[0], cs.z[0] = args.map(&:to_f)
+          else
+            raise ArgumentError, "Wrong number of arguments (#{args.length} for 1-3)"
         end
 
-        if cs.length != 1
-          raise ArgumentError.new("IllegalArgumentException: Point coordinate list must contain a single element")
-        end
+        raise ArgumentError, 'IllegalArgumentException: Point coordinate list must contain a single element' if cs.length != 1
 
         cs_dup = cs.dup
         cs_dup.ptr.autorelease = false
 
-        cast_geometry_ptr(FFIGeos.GEOSGeom_createPoint_r(Geos.current_handle_pointer, cs_dup.ptr), {
-          :srid => options[:srid]
-        })
+        cast_geometry_ptr(FFIGeos.GEOSGeom_createPoint_r(Geos.current_handle_pointer, cs_dup.ptr), srid: options[:srid])
       end
 
       def create_line_string(cs, options = {})
         cs = cs_from_cs_or_geom(cs)
 
-        if cs.length <= 1 && cs.length != 0
-          raise ArgumentError.new("IllegalArgumentException: point array must contain 0 or >1 elements")
-        end
+        raise ArgumentError, 'IllegalArgumentException: point array must contain 0 or >1 elements' if cs.length <= 1 && !cs.empty?
 
         cs_dup = cs.dup
         cs_dup.ptr.autorelease = false
 
-        cast_geometry_ptr(FFIGeos.GEOSGeom_createLineString_r(Geos.current_handle_pointer, cs_dup.ptr), {
-          :srid => options[:srid]
-        })
+        cast_geometry_ptr(FFIGeos.GEOSGeom_createLineString_r(Geos.current_handle_pointer, cs_dup.ptr), srid: options[:srid])
       end
 
       def create_linear_ring(cs, options = {})
         cs = cs_from_cs_or_geom(cs)
 
-        if cs.length <= 1 && cs.length != 0
-          raise ArgumentError.new("IllegalArgumentException: point array must contain 0 or >1 elements")
-        end
+        raise ArgumentError, 'IllegalArgumentException: point array must contain 0 or >1 elements' if cs.length <= 1 && !cs.empty?
 
         cs.ptr.autorelease = false
 
-        cast_geometry_ptr(FFIGeos.GEOSGeom_createLinearRing_r(Geos.current_handle_pointer, cs.ptr), {
-          :srid => options[:srid]
-        })
+        cast_geometry_ptr(FFIGeos.GEOSGeom_createLinearRing_r(Geos.current_handle_pointer, cs.ptr), srid: options[:srid])
       end
 
       def create_polygon(outer, *args)
         options = extract_options!(args)
 
-        inner_dups = Array(args).flatten.collect { |i|
+        inner_dups = Array(args).flatten.collect do |i|
           force_to_linear_ring(i) or
-            raise TypeError.new("Expected inner Array to contain Geos::LinearRing or Geos::CoordinateSequence objects")
-        }
+            raise TypeError, 'Expected inner Array to contain Geos::LinearRing or Geos::CoordinateSequence objects'
+        end
 
         outer_dup = force_to_linear_ring(outer) or
-          raise TypeError.new("Expected outer shell to be a Geos::LinearRing or Geos::CoordinateSequence")
+          raise TypeError, 'Expected outer shell to be a Geos::LinearRing or Geos::CoordinateSequence'
 
         ary = FFI::MemoryPointer.new(:pointer, inner_dups.length)
         ary.write_array_of_pointer(inner_dups.map(&:ptr))
 
         outer_dup.ptr.autorelease = false
-        inner_dups.each { |i|
+        inner_dups.each do |i|
           i.ptr.autorelease = false
-        }
+        end
 
-        cast_geometry_ptr(FFIGeos.GEOSGeom_createPolygon_r(Geos.current_handle_pointer, outer_dup.ptr, ary, inner_dups.length), {
-          :srid => options[:srid]
-        })
+        cast_geometry_ptr(FFIGeos.GEOSGeom_createPolygon_r(Geos.current_handle_pointer, outer_dup.ptr, ary, inner_dups.length), srid: options[:srid])
       end
 
       def create_empty_point(options = {})
-        cast_geometry_ptr(FFIGeos.GEOSGeom_createEmptyPoint_r(Geos.current_handle_pointer), {
-          :srid => options[:srid]
-        })
+        cast_geometry_ptr(FFIGeos.GEOSGeom_createEmptyPoint_r(Geos.current_handle_pointer), srid: options[:srid])
       end
 
       def create_empty_line_string(options = {})
-        cast_geometry_ptr(FFIGeos.GEOSGeom_createEmptyLineString_r(Geos.current_handle_pointer), {
-          :srid => options[:srid]
-        })
+        cast_geometry_ptr(FFIGeos.GEOSGeom_createEmptyLineString_r(Geos.current_handle_pointer), srid: options[:srid])
       end
 
       def create_empty_polygon(options = {})
-        cast_geometry_ptr(FFIGeos.GEOSGeom_createEmptyPolygon_r(Geos.current_handle_pointer), {
-          :srid => options[:srid]
-        })
+        cast_geometry_ptr(FFIGeos.GEOSGeom_createEmptyPolygon_r(Geos.current_handle_pointer), srid: options[:srid])
       end
 
       def create_empty_collection(t, options = {})
         check_enum_value(Geos::GeometryTypes, t)
-        cast_geometry_ptr(FFIGeos.GEOSGeom_createEmptyCollection_r(Geos.current_handle_pointer, t), {
-          :srid => options[:srid]
-        })
+        cast_geometry_ptr(FFIGeos.GEOSGeom_createEmptyCollection_r(Geos.current_handle_pointer, t), srid: options[:srid])
       end
 
       def create_empty_multi_point(options = {})
@@ -169,23 +148,19 @@ module Geos
 
         options = extract_options!(args)
 
-        geoms = Array(args).flatten.tap { |i|
-          if i.detect { |g| !g.is_a?(klass) }
-            raise TypeError.new("Expected geoms Array to contain #{klass} objects")
-          end
-        }
+        geoms = Array(args).flatten.tap do |i|
+          raise TypeError, "Expected geoms Array to contain #{klass} objects" if i.detect { |g| !g.is_a?(klass) }
+        end
 
         geoms_dups = geoms.map(&:dup)
-        geoms_dups.each { |i|
+        geoms_dups.each do |i|
           i.ptr.autorelease = false
-        }
+        end
 
         ary = FFI::MemoryPointer.new(:pointer, geoms.length)
         ary.write_array_of_pointer(geoms_dups.map(&:ptr))
 
-        cast_geometry_ptr(FFIGeos.GEOSGeom_createCollection_r(Geos.current_handle_pointer, t, ary, geoms_dups.length), {
-          :srid => options[:srid]
-        })
+        cast_geometry_ptr(FFIGeos.GEOSGeom_createCollection_r(Geos.current_handle_pointer, t, ary, geoms_dups.length), srid: options[:srid])
       end
 
       def create_multi_point(*args)
@@ -205,6 +180,7 @@ module Geos
       end
 
       private
+
         def cs_from_cs_or_geom(geom_or_cs)
           case geom_or_cs
             when Array

data/lib/ffi-geos/version.rb

@@ -1,7 +1,5 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 module Geos
-  VERSION = '1.2.0'.freeze
+  VERSION = '2.2.0'
 end
-

data/lib/ffi-geos/wkb_reader.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 module Geos
@@ -24,19 +23,15 @@ module Geos
     end
 
     def read(wkb, options = {})
-      cast_geometry_ptr(FFIGeos.GEOSWKBReader_read_r(Geos.current_handle_pointer, self.ptr, wkb, wkb.bytesize), {
-        :srid => options[:srid]
-      })
+      cast_geometry_ptr(FFIGeos.GEOSWKBReader_read_r(Geos.current_handle_pointer, ptr, wkb, wkb.bytesize), srid: options[:srid])
     rescue Geos::GEOSException => e
-      raise ParseError.new(e)
+      raise ParseError, e
     end
 
     def read_hex(wkb, options = {})
-      cast_geometry_ptr(FFIGeos.GEOSWKBReader_readHEX_r(Geos.current_handle_pointer, self.ptr, wkb, wkb.bytesize), {
-        :srid => options[:srid]
-      })
+      cast_geometry_ptr(FFIGeos.GEOSWKBReader_readHEX_r(Geos.current_handle_pointer, ptr, wkb, wkb.bytesize), srid: options[:srid])
     rescue Geos::GEOSException => e
-      raise ParseError.new(e)
+      raise ParseError, e
     end
 
     def self.release(ptr) #:nodoc:

data/lib/ffi-geos/wkb_writer.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 module Geos
@@ -9,7 +8,7 @@ module Geos
 
     def initialize(options = {})
       options = {
-        :include_srid => false
+        include_srid: false
       }.merge(options)
 
       ptr = FFIGeos.GEOSWKBWriter_create_r(Geos.current_handle_pointer)
@@ -30,14 +29,14 @@ module Geos
     def write(geom, options = nil)
       unless options.nil?
         old_options = {
-          :include_srid => self.include_srid
+          include_srid: include_srid
         }
 
         set_options(options)
       end
 
       size_t = FFI::MemoryPointer.new(:size_t)
-      FFIGeos.GEOSWKBWriter_write_r(Geos.current_handle_pointer, self.ptr, geom.ptr, size_t).get_bytes(0, size_t.read_int)
+      FFIGeos.GEOSWKBWriter_write_r(Geos.current_handle_pointer, ptr, geom.ptr, size_t).get_bytes(0, size_t.read_int)
     ensure
       set_options(old_options) unless old_options.nil?
     end
@@ -45,53 +44,49 @@ module Geos
     def write_hex(geom, options = nil)
       unless options.nil?
         old_options = {
-          :include_srid => self.include_srid
+          include_srid: include_srid
         }
 
         set_options(options)
       end
 
       size_t = FFI::MemoryPointer.new(:size_t)
-      FFIGeos.GEOSWKBWriter_writeHEX_r(Geos.current_handle_pointer, self.ptr, geom.ptr, size_t).get_string(0, size_t.read_int)
+      FFIGeos.GEOSWKBWriter_writeHEX_r(Geos.current_handle_pointer, ptr, geom.ptr, size_t).get_string(0, size_t.read_int)
     ensure
       set_options(old_options) unless old_options.nil?
     end
 
     def output_dimensions=(dim)
-      if dim < 2 || dim > 3
-        raise ArgumentError.new("Output dimensions must be either 2 or 3")
-      end
-      FFIGeos.GEOSWKBWriter_setOutputDimension_r(Geos.current_handle_pointer, self.ptr, dim)
+      raise ArgumentError, 'Output dimensions must be either 2 or 3' if dim < 2 || dim > 3
+
+      FFIGeos.GEOSWKBWriter_setOutputDimension_r(Geos.current_handle_pointer, ptr, dim)
     end
 
     def output_dimensions
-      FFIGeos.GEOSWKBWriter_getOutputDimension_r(Geos.current_handle_pointer, self.ptr)
+      FFIGeos.GEOSWKBWriter_getOutputDimension_r(Geos.current_handle_pointer, ptr)
     end
 
     def include_srid
-      bool_result(FFIGeos.GEOSWKBWriter_getIncludeSRID_r(Geos.current_handle_pointer, self.ptr))
+      bool_result(FFIGeos.GEOSWKBWriter_getIncludeSRID_r(Geos.current_handle_pointer, ptr))
     end
 
     def include_srid=(val)
-      FFIGeos.GEOSWKBWriter_setIncludeSRID_r(Geos.current_handle_pointer, self.ptr,
-        Geos::Tools.bool_to_int(val)
-      )
+      FFIGeos.GEOSWKBWriter_setIncludeSRID_r(Geos.current_handle_pointer, ptr, Geos::Tools.bool_to_int(val))
     end
 
     def byte_order
-      FFIGeos.GEOSWKBWriter_getByteOrder_r(Geos.current_handle_pointer, self.ptr)
+      FFIGeos.GEOSWKBWriter_getByteOrder_r(Geos.current_handle_pointer, ptr)
     end
 
     def byte_order=(val)
       check_enum_value(Geos::ByteOrders, val)
-      FFIGeos.GEOSWKBWriter_setByteOrder_r(Geos.current_handle_pointer, self.ptr, val)
+      FFIGeos.GEOSWKBWriter_setByteOrder_r(Geos.current_handle_pointer, ptr, val)
     end
 
     private
+
       def set_options(options) #:nodoc:
-        [ :include_srid ].each do |k|
-          self.send("#{k}=", options[k]) if options.has_key?(k)
-        end
+        self.include_srid = options[:include_srid] if options.key?(:include_srid)
       end
   end
 end

data/lib/ffi-geos/wkt_reader.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 module Geos
@@ -24,11 +23,9 @@ module Geos
     end
 
     def read(wkt, options = {})
-      cast_geometry_ptr(FFIGeos.GEOSWKTReader_read_r(Geos.current_handle_pointer, self.ptr, wkt), {
-        :srid => options[:srid]
-      })
+      cast_geometry_ptr(FFIGeos.GEOSWKTReader_read_r(Geos.current_handle_pointer, ptr, wkt), srid: options[:srid])
     rescue Geos::GEOSException => e
-      raise ParseError.new(e)
+      raise ParseError, e
     end
 
     def self.release(ptr) #:nodoc:

data/lib/ffi-geos/wkt_writer.rb

@@ -1,19 +1,15 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 module Geos
   class WktWriter
-    attr_reader :ptr
-    attr_reader :old_3d
-    attr_reader :rounding_precision
-    attr_reader :trim
+    attr_reader :ptr, :old_3d, :rounding_precision, :trim
 
     def initialize(options = {})
       options = {
-        :trim => false,
-        :old_3d => false,
-        :rounding_precision => -1,
-        :output_dimensions => 2
+        trim: false,
+        old_3d: false,
+        rounding_precision: -1,
+        output_dimensions: 2
       }.merge(options)
 
       ptr = FFIGeos.GEOSWKTWriter_create_r(Geos.current_handle_pointer)
@@ -30,8 +26,8 @@ module Geos
     end
 
     def set_options(options) #:nodoc:
-      [ :trim, :old_3d, :rounding_precision, :output_dimensions ].each do |k|
-        self.send("#{k}=", options[k]) if self.respond_to?("#{k}=") && options.has_key?(k)
+      [:trim, :old_3d, :rounding_precision, :output_dimensions].each do |k|
+        send("#{k}=", options[k]) if respond_to?("#{k}=") && options.key?(k)
       end
     end
     private :set_options
@@ -42,16 +38,16 @@ module Geos
     def write(geom, options = nil)
       unless options.nil?
         old_options = {
-          :trim => self.trim,
-          :old_3d => self.old_3d,
-          :rounding_precision => self.rounding_precision,
-          :output_dimensions => self.output_dimensions
+          trim: trim,
+          old_3d: old_3d,
+          rounding_precision: rounding_precision,
+          output_dimensions: output_dimensions
         }
 
         set_options(options)
       end
 
-      FFIGeos.GEOSWKTWriter_write_r(Geos.current_handle_pointer, self.ptr, geom.ptr)
+      FFIGeos.GEOSWKTWriter_write_r(Geos.current_handle_pointer, ptr, geom.ptr)
     ensure
       set_options(old_options) unless options.nil?
     end
@@ -60,9 +56,7 @@ module Geos
       # Available in GEOS 3.3+.
       def trim=(val)
         @trim = !!val
-        FFIGeos.GEOSWKTWriter_setTrim_r(Geos.current_handle_pointer, self.ptr,
-          Geos::Tools.bool_to_int(@trim)
-        )
+        FFIGeos.GEOSWKTWriter_setTrim_r(Geos.current_handle_pointer, ptr, Geos::Tools.bool_to_int(@trim))
       end
     end
 
@@ -70,12 +64,10 @@ module Geos
       # Available in GEOS 3.3+.
       def rounding_precision=(r)
         r = r.to_i
-        if r > 255
-          raise ArgumentError.new("Rounding precision cannot be greater than 255")
-        end
+        raise ArgumentError, 'Rounding precision cannot be greater than 255' if r > 255
 
         @rounding_precision = r
-        FFIGeos.GEOSWKTWriter_setRoundingPrecision_r(Geos.current_handle_pointer, self.ptr, @rounding_precision)
+        FFIGeos.GEOSWKTWriter_setRoundingPrecision_r(Geos.current_handle_pointer, ptr, @rounding_precision)
       end
     end
 
@@ -83,9 +75,7 @@ module Geos
       # Available in GEOS 3.3+.
       def old_3d=(val)
         @old_3d = !!val
-        FFIGeos.GEOSWKTWriter_setOld3D_r(Geos.current_handle_pointer, self.ptr,
-          Geos::Tools.bool_to_int(@old_3d)
-        )
+        FFIGeos.GEOSWKTWriter_setOld3D_r(Geos.current_handle_pointer, ptr, Geos::Tools.bool_to_int(@old_3d))
       end
     end
 
@@ -93,17 +83,16 @@ module Geos
       # Available in GEOS 3.3+.
       def output_dimensions=(dim)
         dim = dim.to_i
-        if dim < 2 || dim > 3
-          raise ArgumentError.new("Output dimensions must be either 2 or 3")
-        end
-        FFIGeos.GEOSWKTWriter_setOutputDimension_r(Geos.current_handle_pointer, self.ptr, dim)
+        raise ArgumentError, 'Output dimensions must be either 2 or 3' if dim < 2 || dim > 3
+
+        FFIGeos.GEOSWKTWriter_setOutputDimension_r(Geos.current_handle_pointer, ptr, dim)
       end
     end
 
     if FFIGeos.respond_to?(:GEOSWKTWriter_getOutputDimension_r)
       # Available in GEOS 3.3+.
       def output_dimensions
-        FFIGeos.GEOSWKTWriter_getOutputDimension_r(Geos.current_handle_pointer, self.ptr)
+        FFIGeos.GEOSWKTWriter_getOutputDimension_r(Geos.current_handle_pointer, ptr)
       end
     end
   end