rgeo-shapefile 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c870cd7bc12960ff1abd0a7e7c137a7285cd6725
-  data.tar.gz: ec570ff22df0b91f60d8ea116596879b518847ce
+  metadata.gz: b5a5aafda1242e8363bb7fa480767f84af18ed6f
+  data.tar.gz: 5e2a04bf415526a1614b01a3484f892b350ff72b
 SHA512:
-  metadata.gz: 13fcadbc4f1f2ed1910636ac6fd87cba36e6d18513ecf87e5659550d9a31f2b3ff52a80b93bc590347d32e39e5c5a674a2562843b38eb39391ad615af8f08653
-  data.tar.gz: cf33203550cce003b4088b6e4148e6dd1e86e9263fa3734e30ff83fb0ca34619347627a51f05a293ec9b554b80af30231047b27a9cb757dfc62dc7f8dfe35504
+  metadata.gz: 88cd189943f7d41623ac032b652dde5b5c228def9673887d8cba97ee005a418f8c3c85546a6e0a6cb18649fd183f097477fe7eba6616d036c25e0f56e2476f04
+  data.tar.gz: 99d24dfa29fb82cfb0ea8672c240c0ab47c01a649a3bee5217e20fec28e2dcc4c4028e889a22c8b24fec60376a56f5652061b611a04e8c39d224b0937f576c94

data/README.md

@@ -3,7 +3,7 @@
 [![Gem Version](https://badge.fury.io/rb/rgeo-shapefile.svg)](http://badge.fury.io/rb/rgeo-shapefile)
 [![Build Status](https://travis-ci.org/rgeo/rgeo-shapefile.svg?branch=master)](https://travis-ci.org/rgeo/rgeo-shapefile)
 
-`RGeo::Shapefile` is an optional module for [RGeo](http://github.com/dazuma/rgeo)
+`RGeo::Shapefile` is an optional module for [RGeo](https://github.com/rgeo/rgeo)
 for reading geospatial data from ESRI shapefiles.
 
 ## Summary
@@ -13,7 +13,7 @@ Ruby programming language. At its core is an implementation of the
 industry standard OGC Simple Features Specification, which provides data
 representations of geometric objects such as points, lines, and polygons,
 along with a set of geometric analysis operations. See the README for the
-"rgeo" gem for more information.
+`rgeo` gem for more information.
 
 `RGeo::Shapefile` is an optional RGeo add-on module for reading geospatial
 data from ESRI shapefiles. The shapefile format is a common file format
@@ -42,9 +42,9 @@ end
 
 `RGeo::Shapefile` has the following requirements:
 
-* Ruby 1.9.3 or later preferred.
+* Ruby 2.0.0 or later
 * rgeo 0.3.13 or later.
-* dbf 1.7 or later.
+* dbf 3.0 or later.
 
 Include in your bundle:
 
@@ -55,7 +55,6 @@ gem 'rgeo-shapefile'
 Install `RGeo::Shapefile` as a gem:
 
 ```sh
-gem install rgeo
 gem install rgeo-shapefile
 ```
 
@@ -63,24 +62,21 @@ See the README for the "rgeo" gem, a required dependency, for further installati
 
 If you are using Ruby 1.8, use version `0.2.x` of this gem.
 
-## To-do list
-
-* Improve test case coverage.
-* Support for writing shapefiles.
+If you are using Ruby 1.9, use version `0.3.x` of this gem.
 
 ## Development and support
 
 Documentation is available at http://rdoc.info/gems/rgeo-shapefile
 
-Source code is hosted on Github at http://github.com/rgeo/rgeo-shapefile
+Source code is hosted on Github at https://github.com/rgeo/rgeo-shapefile
 
 Contributions are welcome. Fork the project on Github.
 
-Report bugs on Github issues at http://github.org/rgeo/rgeo-shapefile/issues
+Report bugs on Github issues at https://github.com/rgeo/rgeo-shapefile/issues
 
 ## Acknowledgments
 
-RGeo is written by Daniel Azuma (http://www.daniel-azuma.com).
+`rgeo-shapefile` was orginally written by Daniel Azuma (http://www.daniel-azuma.com).
 
 Development is supported by:
 
@@ -90,10 +86,8 @@ Development is supported by:
 Although we don't use shapelib (http://shapelib.maptools.org) to read
 ESRI shapefiles, we did borrow a bunch of their test cases.
 
-=== License
-
-Copyright 2014 Daniel Azuma
+## License
 
-Copyright 2014 Tee Parham
+Copyright Daniel Azuma, Tee Parham
 
 https://github.com/rgeo/rgeo-shapefile/blob/master/LICENSE.txt

data/lib/rgeo-shapefile.rb

@@ -1 +1 @@
-require 'rgeo/shapefile'
+require "rgeo/shapefile"

data/lib/rgeo/shapefile.rb

@@ -1,5 +1,4 @@
-require 'rgeo'
-
+require "rgeo"
 
 # RGeo is a spatial data library for Ruby, provided by the "rgeo" gem.
 #
@@ -7,8 +6,6 @@ require 'rgeo'
 # ESRI shapefiles.
 
 module RGeo
-
-
   # This module contains an implementation of ESRI Shapefiles.
   # Use the Shapefile::Reader class to read a shapefile, extracting
   # geometry and attribute data from it.
@@ -16,11 +13,8 @@ module RGeo
 
   module Shapefile
   end
-
-
 end
 
-
 # Implementation files
-require 'rgeo/shapefile/version'
-require 'rgeo/shapefile/reader'
+require "rgeo/shapefile/version"
+require "rgeo/shapefile/reader"

data/lib/rgeo/shapefile/reader.rb

@@ -1,11 +1,7 @@
-require 'dbf'
-
+require "dbf"
 
 module RGeo
-
   module Shapefile
-
-
     # Represents a shapefile that is open for reading.
     #
     # You can use this object to read a shapefile straight through,
@@ -94,13 +90,10 @@ module RGeo
     #   a GeometryCollection instead of a MultiPolygon.
 
     class Reader
-
-
       # Values less than this value are considered "no value" in the
       # shapefile format specification.
       NODATA_LIMIT = -1e38
 
-
       # Create a new shapefile reader. You must pass the path for the
       # main shapefile (e.g. "path/to/file.shp"). You may also omit the
       # ".shp" extension from the path. All three files that make up the
@@ -115,6 +108,7 @@ module RGeo
       #
       # If you provide a block, the shapefile reader will be yielded to
       # the block, and automatically closed at the end of the block.
+      # In this instance, File.open returns the value of the block.
       # If you do not provide a block, the shapefile reader will be
       # returned from this call. It is then the caller's responsibility
       # to close the reader when it is done.
@@ -161,7 +155,7 @@ module RGeo
       # a platform without GEOS, you have no choice but to turn on this
       # switch and make this assumption about your input shapefiles.
 
-      def self.open(path_, opts_={}, &block_)
+      def self.open(path_, opts_ = {}, &block_)
         file_ = new(path_, opts_)
         if block_
           begin
@@ -169,31 +163,27 @@ module RGeo
           ensure
             file_.close
           end
-          nil
         else
           file_
         end
       end
 
-
       # Low-level creation of a Reader. The arguments are the same as
       # those passed to Reader::open, except that this doesn't take a
       # block. You should use Reader::open instead.
 
-      def initialize(path_, opts_={})  # :nodoc:
-        path_ = path_.sub(/\.shp$/, '')
+      def initialize(path_, opts_ = {}) # :nodoc:
+        path_ = path_.sub(/\.shp$/, "")
         @base_path = path_
         @opened = true
-        @main_file = ::File.open(path_+'.shp', 'rb:ascii-8bit')
-        @index_file = ::File.open(path_+'.shx', 'rb:ascii-8bit')
-        if ::File.file?(path_+'.dbf') && ::File.readable?(path_+'.dbf')
-          @attr_dbf = ::DBF::Table.new(path_+'.dbf')
-        else
-          @attr_dbf = nil
-        end
-        @main_length, @shape_type_code, @xmin, @ymin, @xmax, @ymax, @zmin, @zmax, @mmin, @mmax = @main_file.read(100).unpack('x24Nx4VE8')
+        @main_file = ::File.open(path_ + ".shp", "rb:ascii-8bit")
+        @index_file = ::File.open(path_ + ".shx", "rb:ascii-8bit")
+        @attr_dbf = if ::File.file?(path_ + ".dbf") && ::File.readable?(path_ + ".dbf")
+                      ::DBF::Table.new(path_ + ".dbf")
+                    end
+        @main_length, @shape_type_code, @xmin, @ymin, @xmax, @ymax, @zmin, @zmax, @mmin, @mmax = @main_file.read(100).unpack("x24Nx4VE8")
         @main_length *= 2
-        index_length_ = @index_file.read(100).unpack('x24Nx72').first
+        index_length_ = @index_file.read(100).unpack("x24Nx72").first
         @num_records = (index_length_ - 50) / 4
         @cur_record_index = 0
 
@@ -216,7 +206,7 @@ module RGeo
         end
 
         @factory = opts_[:factory_generator] || opts_[:factory] || Cartesian.method(:preferred_factory)
-        unless @factory.kind_of?(Feature::Factory::Instance)
+        unless @factory.is_a?(Feature::Factory::Instance)
           factory_config_ = {}
           factory_config_[:srid] = opts_[:srid] if opts_[:srid]
           unless @zmin.nil?
@@ -233,21 +223,18 @@ module RGeo
         @assume_inner_follows_outer = opts_[:assume_inner_follows_outer]
       end
 
-
       # Close the shapefile.
       # You should not use this Reader after it has been closed.
       # Most methods will return nil.
 
       def close
-        if @opened
-          @main_file.close
-          @index_file.close
-          @attr_dbf.close if @attr_dbf
-          @opened = false
-        end
+        return unless @opened
+        @main_file.close
+        @index_file.close
+        @attr_dbf.close if @attr_dbf
+        @opened = false
       end
 
-
       # Returns true if this Reader is still open, or false if it has
       # been closed.
 
@@ -255,7 +242,6 @@ module RGeo
         @opened
       end
 
-
       # Returns true if attributes are available. This may be false
       # because there is no ".dbf" file or because the dbf gem is not
       # available.
@@ -264,21 +250,18 @@ module RGeo
         @opened ? (@attr_dbf ? true : false) : nil
       end
 
-
       # Returns the factory used by this reader.
 
       def factory
         @opened ? @factory : nil
       end
 
-
       # Returns the number of records in the shapefile.
 
       def num_records
         @opened ? @num_records : nil
       end
-      alias_method :size, :num_records
-
+      alias size num_records
 
       # Returns the shape type code.
 
@@ -286,63 +269,54 @@ module RGeo
         @opened ? @shape_type_code : nil
       end
 
-
       # Returns the minimum x.
 
       def xmin
         @opened ? @xmin : nil
       end
 
-
       # Returns the maximum x.
 
       def xmax
         @opened ? @xmax : nil
       end
 
-
       # Returns the minimum y.
 
       def ymin
         @opened ? @ymin : nil
       end
 
-
       # Returns the maximum y.
 
       def ymax
         @opened ? @ymax : nil
       end
 
-
       # Returns the minimum z, or nil if the shapefile does not contain z.
 
       def zmin
         @opened ? @zmin : nil
       end
 
-
       # Returns the maximum z, or nil if the shapefile does not contain z.
 
       def zmax
         @opened ? @zmax : nil
       end
 
-
       # Returns the minimum m, or nil if the shapefile does not contain m.
 
       def mmin
         @opened ? @mmin : nil
       end
 
-
       # Returns the maximum m, or nil if the shapefile does not contain m.
 
       def mmax
         @opened ? @mmax : nil
       end
 
-
       # Returns the current file pointer as a record index (0-based).
       # This is the record number that will be read when Reader#next
       # is called.
@@ -351,32 +325,28 @@ module RGeo
         @opened ? @cur_record_index : nil
       end
 
-
       # Read and return the next record as a Reader::Record.
 
       def next
         @opened && @cur_record_index < @num_records ? _read_next_record : nil
       end
 
-
       # Read the remaining records starting with the current record index,
       # and yield the Reader::Record for each one.
 
       def each
-        while @cur_record_index < @num_records
-          yield _read_next_record
-        end if @opened
+        return unless @opened
+        yield _read_next_record while @cur_record_index < @num_records
       end
 
-
       # Seek to the given record index.
 
       def seek_index(index_)
         if @opened && index_ >= 0 && index_ <= @num_records
           if index_ < @num_records && index_ != @cur_record_index
-            @index_file.seek(100+8*index_)
-            offset_ = @index_file.read(4).unpack('N').first
-            @main_file.seek(offset_*2)
+            @index_file.seek(100 + 8 * index_)
+            offset_ = @index_file.read(4).unpack("N").first
+            @main_file.seek(offset_ * 2)
           end
           @cur_record_index = index_
           true
@@ -385,7 +355,6 @@ module RGeo
         end
       end
 
-
       # Rewind to the beginning of the file.
       # Equivalent to seek_index(0).
 
@@ -393,20 +362,18 @@ module RGeo
         seek_index(0)
       end
 
-
       # Get the given record number. Equivalent to seeking to that index
       # and calling next.
 
       def get(index_)
         seek_index(index_) ? self.next : nil
       end
-      alias_method :[], :get
-
+      alias [] get
 
-      def _read_next_record  # :nodoc:
-        length_ = @main_file.read(8).unpack('NN')[1]
+      def _read_next_record # :nodoc:
+        length_ = @main_file.read(8).unpack("NN")[1]
         data_ = @main_file.read(length_ * 2)
-        shape_type_ = data_[0,4].unpack('V').first
+        shape_type_ = data_[0, 4].unpack("V").first
         geometry_ =
           case shape_type_
           when 1 then _read_point(data_)
@@ -422,7 +389,6 @@ module RGeo
           when 25 then _read_polygon(data_, :m)
           when 28 then _read_multipoint(data_, :m)
           when 31 then _read_multipatch(data_)
-          else nil
           end
         attrs_ = {}
         if @attr_dbf
@@ -437,17 +403,16 @@ module RGeo
         result_
       end
 
-
-      def _read_point(data_, opt_=nil)  # :nodoc:
+      def _read_point(data_, opt_ = nil) # :nodoc:
         case opt_
         when :z
-          x_, y_, z_, m_ = data_[4,32].unpack('EEEE')
+          x_, y_, z_, m_ = data_[4, 32].unpack("EEEE")
           m_ = 0 if m_.nil? || m_ < NODATA_LIMIT
         when :m
-          x_, y_, m_ = data_[4,24].unpack('EEE')
+          x_, y_, m_ = data_[4, 24].unpack("EEE")
           z_ = 0
         else
-          x_, y_ = data_[4,16].unpack('EE')
+          x_, y_ = data_[4, 16].unpack("EE")
           z_ = m_ = 0
         end
         extras_ = []
@@ -456,19 +421,18 @@ module RGeo
         @factory.point(x_, y_, *extras_)
       end
 
-
-      def _read_multipoint(data_, opt_=nil)  # :nodoc:
+      def _read_multipoint(data_, opt_ = nil) # :nodoc:
         # Read number of points
-        num_points_ = data_[36,4].unpack('V').first
+        num_points_ = data_[36, 4].unpack("V").first
 
         # Read remaining data
-        size_ = num_points_*16
-        size_ += 16 + num_points_*8 if opt_
-        size_ += 16 + num_points_*8 if opt_ == :z
-        values_ = data_[40, size_].unpack('E*')
+        size_ = num_points_ * 16
+        size_ += 16 + num_points_ * 8 if opt_
+        size_ += 16 + num_points_ * 8 if opt_ == :z
+        values_ = data_[40, size_].unpack("E*")
 
         # Extract XY, Z, and M values
-        xys_ = values_.slice!(0, num_points_*2)
+        xys_ = values_.slice!(0, num_points_ * 2)
         ms_ = nil
         zs_ = nil
         if opt_
@@ -476,38 +440,37 @@ module RGeo
           if opt_ == :z
             zs_ = ms_
             ms_ = values_.slice!(4, num_points_)
-            ms_.map!{ |val_| val_ < NODATA_LIMIT ? 0 : val_ } if ms_
+            ms_.map! { |val_| val_ < NODATA_LIMIT ? 0 : val_ } if ms_
           end
         end
 
         # Generate points
-        points_ = (0..num_points_-1).map do |i_|
+        points_ = (0..num_points_ - 1).map do |i_|
           extras_ = []
           extras_ << zs_[i_] if zs_ && @factory_supports_z
           extras_ << ms_[i_] if ms_ && @factory_supports_m
-          @factory.point(xys_[i_*2], xys_[i_*2+1], *extras_)
+          @factory.point(xys_[i_ * 2], xys_[i_ * 2 + 1], *extras_)
         end
 
         # Return a MultiPoint
         @factory.multi_point(points_)
       end
 
-
-      def _read_polyline(data_, opt_=nil)  # :nodoc:
+      def _read_polyline(data_, opt_ = nil) # :nodoc:
         # Read counts
-        num_parts_, num_points_ = data_[36,8].unpack('VV')
+        num_parts_, num_points_ = data_[36, 8].unpack("VV")
 
         # Read remaining data
-        size_ = num_parts_*4 + num_points_*16
-        size_ += 16 + num_points_*8 if opt_
-        size_ += 16 + num_points_*8 if opt_ == :z
+        size_ = num_parts_ * 4 + num_points_ * 16
+        size_ += 16 + num_points_ * 8 if opt_
+        size_ += 16 + num_points_ * 8 if opt_ == :z
         values_ = data_[44, size_].unpack("V#{num_parts_}E*")
 
         # Parts array
         part_indexes_ = values_.slice!(0, num_parts_) + [num_points_]
 
         # Extract XY, Z, and M values
-        xys_ = values_.slice!(0, num_points_*2)
+        xys_ = values_.slice!(0, num_points_ * 2)
         ms_ = nil
         zs_ = nil
         if opt_
@@ -515,43 +478,42 @@ module RGeo
           if opt_ == :z
             zs_ = ms_
             ms_ = values_.slice!(4, num_points_)
-            ms_.map!{ |val_| val_ < NODATA_LIMIT ? 0 : val_ }
+            ms_.map! { |val_| val_ < NODATA_LIMIT ? 0 : val_ }
           end
         end
 
         # Generate points
-        points_ = (0..num_points_-1).map do |i_|
+        points_ = (0..num_points_ - 1).map do |i_|
           extras_ = []
           extras_ << zs_[i_] if zs_ && @factory_supports_z
           extras_ << ms_[i_] if ms_ && @factory_supports_m
-          @factory.point(xys_[i_*2], xys_[i_*2+1], *extras_)
+          @factory.point(xys_[i_ * 2], xys_[i_ * 2 + 1], *extras_)
         end
 
         # Generate LineString objects (parts)
-        parts_ = (0..num_parts_-1).map do |i_|
-          @factory.line_string(points_[part_indexes_[i_]...part_indexes_[i_+1]])
+        parts_ = (0..num_parts_ - 1).map do |i_|
+          @factory.line_string(points_[part_indexes_[i_]...part_indexes_[i_ + 1]])
         end
 
         # Generate MultiLineString
         @factory.multi_line_string(parts_)
       end
 
-
-      def _read_polygon(data_, opt_=nil)  # :nodoc:
+      def _read_polygon(data_, opt_ = nil) # :nodoc:
         # Read counts
-        num_parts_, num_points_ = data_[36,8].unpack('VV')
+        num_parts_, num_points_ = data_[36, 8].unpack("VV")
 
         # Read remaining data
-        size_ = num_parts_*4 + num_points_*16
-        size_ += 16 + num_points_*8 if opt_
-        size_ += 16 + num_points_*8 if opt_ == :z
+        size_ = num_parts_ * 4 + num_points_ * 16
+        size_ += 16 + num_points_ * 8 if opt_
+        size_ += 16 + num_points_ * 8 if opt_ == :z
         values_ = data_[44, size_].unpack("V#{num_parts_}E*")
 
         # Parts array
         part_indexes_ = values_.slice!(0, num_parts_) + [num_points_]
 
         # Extract XY, Z, and M values
-        xys_ = values_.slice!(0, num_points_*2)
+        xys_ = values_.slice!(0, num_points_ * 2)
         ms_ = nil
         zs_ = nil
         if opt_
@@ -559,22 +521,22 @@ module RGeo
           if opt_ == :z
             zs_ = ms_
             ms_ = values_.slice!(4, num_points_)
-            ms_.map!{ |val_| val_ < NODATA_LIMIT ? 0 : val_ } if ms_
+            ms_.map! { |val_| val_ < NODATA_LIMIT ? 0 : val_ } if ms_
           end
         end
 
         # Generate points
-        points_ = (0..num_points_-1).map do |i_|
+        points_ = (0..num_points_ - 1).map do |i_|
           extras_ = []
           extras_ << zs_[i_] if zs_ && @factory_supports_z
           extras_ << ms_[i_] if ms_ && @factory_supports_m
-          @factory.point(xys_[i_*2], xys_[i_*2+1], *extras_)
-        end
+          @factory.point(xys_[i_ * 2], xys_[i_ * 2 + 1], *extras_)
+        end.compact
 
         # The parts are LinearRing objects
-        parts_ = (0..num_parts_-1).map do |i_|
-          @factory.linear_ring(points_[part_indexes_[i_]...part_indexes_[i_+1]])
-        end
+        parts_ = (0..num_parts_ - 1).map do |i_|
+          @factory.linear_ring(points_[part_indexes_[i_]...part_indexes_[i_ + 1]])
+        end.compact
 
         # Get a GEOS factory if needed.
         geos_factory_ = nil
@@ -670,7 +632,7 @@ module RGeo
         # Generate the actual polygons from the collected polygon data
         polygons_.map! do |poly_data_|
           outer_ = poly_data_[0][0]
-          inner_ = poly_data_[1..-1].map{ |part_data_| part_data_[0] }
+          inner_ = poly_data_[1..-1].map { |part_data_| part_data_[0] }
           @factory.polygon(outer_, inner_)
         end
 
@@ -678,36 +640,35 @@ module RGeo
         @factory.multi_polygon(polygons_)
       end
 
-
-      def _read_multipatch(data_)  # :nodoc:
+      def _read_multipatch(data_) # :nodoc:
         # Read counts
-        num_parts_, num_points_ = data_[36,8].unpack('VV')
+        num_parts_, num_points_ = data_[36, 8].unpack("VV")
 
         # Read remaining data
-        values_ = data_[44, 32 + num_parts_*8 + num_points_*32].unpack("V#{num_parts_*2}E*")
+        values_ = data_[44, 32 + num_parts_ * 8 + num_points_ * 32].unpack("V#{num_parts_ * 2}E*")
 
         # Parts arrays
         part_indexes_ = values_.slice!(0, num_parts_) + [num_points_]
         part_types_ = values_.slice!(0, num_parts_)
 
         # Extract XY, Z, and M values
-        xys_ = values_.slice!(0, num_points_*2)
+        xys_ = values_.slice!(0, num_points_ * 2)
         zs_ = values_.slice!(2, num_points_)
-        zs_.map!{ |val_| val_ < NODATA_LIMIT ? 0 : val_ } if zs_
+        zs_.map! { |val_| val_ < NODATA_LIMIT ? 0 : val_ } if zs_
         ms_ = values_.slice!(4, num_points_)
-        ms_.map!{ |val_| val_ < NODATA_LIMIT ? 0 : val_ } if ms_
+        ms_.map! { |val_| val_ < NODATA_LIMIT ? 0 : val_ } if ms_
 
         # Generate points
-        points_ = (0..num_points_-1).map do |i_|
+        points_ = (0..num_points_ - 1).map do |i_|
           extras_ = []
           extras_ << zs_[i_] if zs_ && @factory_supports_z
           extras_ << ms_[i_] if ms_ && @factory_supports_m
-          @factory.point(xys_[i_*2], xys_[i_*2+1], *extras_)
+          @factory.point(xys_[i_ * 2], xys_[i_ * 2 + 1], *extras_)
         end
 
         # Create the parts
-        parts_ = (0..num_parts_-1).map do |i_|
-          ps_ = points_[part_indexes_[i_]...part_indexes_[i_+1]]
+        parts_ = (0..num_parts_ - 1).map do |i_|
+          ps_ = points_[part_indexes_[i_]...part_indexes_[i_ + 1]]
           # All part types just translate directly into rings, except for
           # triangle fan, which requires that we reorder the vertices.
           if part_types_[i_] == 0
@@ -779,7 +740,7 @@ module RGeo
               # the first ring is the outer one. Otherwise, we have to
               # use GEOS to determine containment.
               unless @assume_inner_follows_outer
-                geos_polygons_ = sequence_.map{ |ring_| geos_factory_.polygon(ring_) }
+                geos_polygons_ = sequence_.map { |ring_| geos_factory_.polygon(ring_) }
                 outer_poly_ = nil
                 outer_index_ = 0
                 geos_polygons_.each_with_index do |poly_, idx_|
@@ -787,7 +748,7 @@ module RGeo
                     if poly_.contains?(outer_poly_)
                       outer_poly_ = poly_
                       outer_index_ = idx_
-                      break;
+                      break
                     end
                   else
                     outer_poly_ = poly_
@@ -822,7 +783,6 @@ module RGeo
         @factory.collection(polygons_)
       end
 
-
       # Shapefile records are provided to the caller as objects of this
       # type. The record includes the record index (0-based), the
       # geometry (which may be nil if the shape type is the null type),
@@ -831,8 +791,7 @@ module RGeo
       # You should not need to create objects of this type yourself.
 
       class Record
-
-        def initialize(index_, geometry_, attributes_)  # :nodoc:
+        def initialize(index_, geometry_, attributes_) # :nodoc:
           @index = index_
           @geometry = geometry_
           @attributes = attributes_
@@ -856,13 +815,7 @@ module RGeo
         def [](key_)
           @attributes[key_.to_s]
         end
-
       end
-
-
     end
-
-
   end
-
 end