rgeo-geojson 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 503714421404cf164fbb61280d4b0fcdc1ed626f
-  data.tar.gz: bdb19b2bfa801d881f67c2b32399d29750d21ad9
+  metadata.gz: 1a486ffc62008cbb9d03e13f7ea93aa229c588de
+  data.tar.gz: c3826e787a98ba17b33f81e59c859898a6807ea3
 SHA512:
-  metadata.gz: eb72641504799a5d5272c90bd60d170295f7e34cbaab705733abb1a9b80818fadf5bade1425eb6be7e6a6ef6b45c5fad4a3774ec0046323b369d1f90dee0650c
-  data.tar.gz: 1c073bda74e6ac4b19bba2722ff22feb82f956fd4113b24d55d204ce24b4aa699e686517787f635841e0a68f8918225b723b2065e9000571e5a490f0e4c1fdb6
+  metadata.gz: 4ef133754c920d853e2e2a9191e194afdf895bb361692e22d56d2dc160c5dda5b9b8470aad511458d84a35e7ef44f5541346e44ab6750ff1ac7124129f7ccc7f
+  data.tar.gz: e6fd873662287d0b7999190469aad4f805259906e2589f043199128bd56848c84c7f14cb082dacabe7eb5b0073288fc40eccfae2818d098aabaafe74d7d9f476

data/History.md

@@ -1,3 +1,8 @@
+### 0.3.3 / 2015-12-23
+
+* Rubocop style updates #20
+* Do not distribute test files with gem
+
 ### 0.3.2 / 2015-12-10
 
 * Faster coordinates methods (tneems) #18

data/README.md

@@ -1,10 +1,10 @@
-# RGeo::GeoJSON
+# rgeo-geojson
 
 [![Gem Version](https://badge.fury.io/rb/rgeo-geojson.svg)](http://badge.fury.io/rb/rgeo-geojson)
 [![Build Status](https://travis-ci.org/rgeo/rgeo-geojson.svg?branch=master)](https://travis-ci.org/rgeo/rgeo-geojson)
 
-`RGeo::GeoJSON` is an optional module for [RGeo](http://github.com/rgeo/rgeo)
-that provides GeoJSON encoding and decoding services.
+`rgeo-geojson` is an extension to [RGeo](https://github.com/rgeo/rgeo)
+that provides GeoJSON encoding and decoding.
 
 ## Summary
 
@@ -15,10 +15,9 @@ 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::GeoJSON` is an optional RGeo add-on module that provides GeoJSON encoding
-and decoding services. GeoJSON is an emerging standard format used by many web
-services that need to communicate geospatial data. See http://www.geojson.org
-for more information.
+`RGeo::GeoJSON` is an optional RGeo module that provides GeoJSON encoding
+and decoding. [GeoJSON](http://geojson.org) is a JSON format used for
+geographic data structures.
 
 Example:
 
@@ -26,11 +25,11 @@ Example:
 require 'rgeo/geo_json'
 
 str1 = '{"type":"Point","coordinates":[1,2]}'
-geom = RGeo::GeoJSON.decode(str1, :json_parser => :json)
+geom = RGeo::GeoJSON.decode(str1, json_parser: :json)
 geom.as_text              # => "POINT(1.0 2.0)"
 
 str2 = '{"type":"Feature","geometry":{"type":"Point","coordinates":[2.5,4.0]},"properties":{"color":"red"}}'
-feature = RGeo::GeoJSON.decode(str2, :json_parser => :json)
+feature = RGeo::GeoJSON.decode(str2, json_parser: :json)
 feature['color']          # => 'red'
 feature.geometry.as_text  # => "POINT(2.5 4.0)"
 
@@ -43,7 +42,7 @@ hash.to_json == str2      # => true
 `RGeo::GeoJSON` has the following requirements:
 
 * Ruby 1.9.3 or later
-* rgeo 0.3.13 or later.
+* rgeo 0.5.0 or later.
 
 Include in your bundle:
 
@@ -51,7 +50,7 @@ Include in your bundle:
 gem 'rgeo-geojson'
 ```
 
-Install RGeo::GeoJSON as a gem:
+Install `rgeo-geojson` as a gem:
 
 ```sh
 gem install rgeo-geojson
@@ -59,17 +58,11 @@ gem install rgeo-geojson
 
 See the README for the "rgeo" gem, a required dependency, for further installation information.
 
-If you are using Ruby 1.8, use version `0.2.x`.
-
-### To-do list
-
-* Add support for the "bbox" and "crs" elements.
-
 ### Development and support
 
 RDoc Documentation is available at http://rdoc.info/gems/rgeo-geojson
 
-Source code is hosted on Github at http://github.com/rgeo/rgeo-geojson
+Source code is hosted on Github at https://github.com/rgeo/rgeo-geojson
 
 Contributions are welcome. Fork the project on Github.
 
@@ -77,17 +70,13 @@ Report bugs on Github issues at http://github.com/rgeo/rgeo-geojson/issues
 
 ### Acknowledgments
 
-RGeo is written by Daniel Azuma (http://www.daniel-azuma.com).
+RGeo was created by Daniel Azuma (http://www.daniel-azuma.com).
 
-Development is supported by:
-
-* [Pirq](http://www.pirq.com)
-* [Neighborland](https://neighborland.com)
+Development is supported by [Pirq](http://www.pirq.com) and
+[Neighborland](https://neighborland.com).
 
 ### License
 
-Copyright 2014 Daniel Azuma
-
-Copyright 2014 Tee Parham
+Copyright (c) Daniel Azuma, Tee Parham
 
 https://github.com/rgeo/rgeo-geojson/blob/master/LICENSE.txt

data/lib/rgeo/geo_json/coder.rb

@@ -1,21 +1,15 @@
 module RGeo
-
   module GeoJSON
-
-
     # This object encapsulates encoding and decoding settings (principally
     # the RGeo::Feature::Factory and the RGeo::GeoJSON::EntityFactory to
     # be used) so that you can encode and decode without specifying those
     # settings every time.
 
     class Coder
-
-
       @@json_available = nil
       @@yajl_available = nil
       @@activesupport_available = nil
 
-
       # Create a new coder settings object. The geo factory is passed as
       # a required argument.
       #
@@ -42,7 +36,7 @@ module RGeo
       #   If a parser is not specified, then the decode method will not
       #   accept a String or IO object; it will require a Hash.
 
-      def initialize(opts_={})
+      def initialize(opts_ = {})
         @geo_factory = opts_[:geo_factory] || ::RGeo::Cartesian.preferred_factory
         @entity_factory = opts_[:entity_factory] || EntityFactory.instance
         @json_parser = opts_[:json_parser]
@@ -50,42 +44,42 @@ module RGeo
         when :json
           if @@json_available.nil?
             begin
-              require 'json'
+              require "json"
               @@json_available = true
             rescue ::LoadError
               @@json_available = false
             end
           end
           if @@json_available
-            @json_parser = ::Proc.new{ |str_| ::JSON.parse(str_) }
+            @json_parser = ::Proc.new { |str_| ::JSON.parse(str_) }
           else
             raise Error::RGeoError, "JSON library is not available. You may need to install the 'json' gem."
           end
         when :yajl
           if @@yajl_available.nil?
             begin
-              require 'yajl'
+              require "yajl"
               @@yajl_available = true
             rescue ::LoadError
               @@yajl_available = false
             end
           end
           if @@yajl_available
-            @json_parser = ::Proc.new{ |str_| ::Yajl::Parser.new.parse(str_) }
+            @json_parser = ::Proc.new { |str_| ::Yajl::Parser.new.parse(str_) }
           else
             raise Error::RGeoError, "Yajl library is not available. You may need to install the 'yajl' gem."
           end
         when :active_support
           if @@activesupport_available.nil?
             begin
-              require 'active_support/json'
+              require "active_support/json"
               @@activesupport_available = true
             rescue ::LoadError
               @@activesupport_available = false
             end
           end
           if @@activesupport_available
-            @json_parser = ::Proc.new{ |str_| ::ActiveSupport::JSON.decode(str_) }
+            @json_parser = ::Proc.new { |str_| ::ActiveSupport::JSON.decode(str_) }
           else
             raise Error::RGeoError, "ActiveSupport::JSON library is not available. You may need to install the 'activesupport' gem."
           end
@@ -99,7 +93,6 @@ module RGeo
         @num_coordinates += 1 if @geo_factory.property(:has_m_coordinate)
       end
 
-
       # Encode the given object as GeoJSON. The object may be one of the
       # geometry objects specified in RGeo::Feature, or an appropriate
       # GeoJSON wrapper entity supported by this coder's entity factory.
@@ -115,8 +108,8 @@ module RGeo
       def encode(object_)
         if @entity_factory.is_feature_collection?(object_)
           {
-            'type' => 'FeatureCollection',
-            'features' => @entity_factory.map_feature_collection(object_){ |f_| _encode_feature(f_) },
+            "type" => "FeatureCollection",
+            "features" => @entity_factory.map_feature_collection(object_) { |f_| _encode_feature(f_) },
           }
         elsif @entity_factory.is_feature?(object_)
           _encode_feature(object_)
@@ -127,7 +120,6 @@ module RGeo
         end
       end
 
-
       # Decode an object from GeoJSON. The input may be a JSON hash, a
       # String, or an IO object from which to read the JSON string.
       # If an error occurs, nil is returned.
@@ -142,144 +134,133 @@ module RGeo
         unless input_.kind_of?(::Hash)
           return nil
         end
-        case input_['type']
-        when 'FeatureCollection'
-          features_ = input_['features']
+        case input_["type"]
+        when "FeatureCollection"
+          features_ = input_["features"]
           features_ = [] unless features_.kind_of?(::Array)
           decoded_features_ = []
           features_.each do |f_|
-            if f_['type'] == 'Feature'
+            if f_["type"] == "Feature"
               decoded_features_ << _decode_feature(f_)
             end
           end
           @entity_factory.feature_collection(decoded_features_)
-        when 'Feature'
+        when "Feature"
           _decode_feature(input_)
         else
           _decode_geometry(input_)
         end
       end
 
-
       # Returns the RGeo::Feature::Factory used to generate geometry objects.
 
-      def geo_factory
-        @geo_factory
-      end
-
+      attr_reader :geo_factory
 
       # Returns the RGeo::GeoJSON::EntityFactory used to generate GeoJSON
       # wrapper entities.
 
-      def entity_factory
-        @entity_factory
-      end
-
+      attr_reader :entity_factory
 
-      def _encode_feature(object_)  # :nodoc:
+      def _encode_feature(object_) # :nodoc:
         json_ = {
-          'type' => 'Feature',
-          'geometry' => _encode_geometry(@entity_factory.get_feature_geometry(object_)),
-          'properties' => @entity_factory.get_feature_properties(object_).dup,
+          "type" => "Feature",
+          "geometry" => _encode_geometry(@entity_factory.get_feature_geometry(object_)),
+          "properties" => @entity_factory.get_feature_properties(object_).dup,
         }
         id_ = @entity_factory.get_feature_id(object_)
-        json_['id'] = id_ if id_
+        json_["id"] = id_ if id_
         json_
       end
 
-
-      def _encode_geometry(object_, point_encoder_=nil)  # :nodoc:
+      def _encode_geometry(object_, point_encoder_ = nil) # :nodoc:
         unless point_encoder_
           if object_.factory.property(:has_z_coordinate)
             if object_.factory.property(:has_m_coordinate)
-              point_encoder_ = ::Proc.new{ |p_| [p_.x, p_.y, p_.z, p_.m] }
+              point_encoder_ = ::Proc.new { |p_| [p_.x, p_.y, p_.z, p_.m] }
             else
-              point_encoder_ = ::Proc.new{ |p_| [p_.x, p_.y, p_.z] }
+              point_encoder_ = ::Proc.new { |p_| [p_.x, p_.y, p_.z] }
             end
           else
             if object_.factory.property(:has_m_coordinate)
-              point_encoder_ = ::Proc.new{ |p_| [p_.x, p_.y, p_.m] }
+              point_encoder_ = ::Proc.new { |p_| [p_.x, p_.y, p_.m] }
             else
-              point_encoder_ = ::Proc.new{ |p_| [p_.x, p_.y] }
+              point_encoder_ = ::Proc.new { |p_| [p_.x, p_.y] }
             end
           end
         end
         case object_
         when ::RGeo::Feature::Point
           {
-            'type' => 'Point',
-            'coordinates' => object_.coordinates
+            "type" => "Point",
+            "coordinates" => object_.coordinates
           }
         when ::RGeo::Feature::LineString
           {
-            'type' => 'LineString',
-            'coordinates' => object_.coordinates
+            "type" => "LineString",
+            "coordinates" => object_.coordinates
           }
         when ::RGeo::Feature::Polygon
           {
-            'type' => 'Polygon',
-            'coordinates' => object_.coordinates
+            "type" => "Polygon",
+            "coordinates" => object_.coordinates
           }
         when ::RGeo::Feature::MultiPoint
           {
-            'type' => 'MultiPoint',
-            'coordinates' => object_.coordinates
+            "type" => "MultiPoint",
+            "coordinates" => object_.coordinates
           }
         when ::RGeo::Feature::MultiLineString
           {
-            'type' => 'MultiLineString',
-            'coordinates' => object_.coordinates
+            "type" => "MultiLineString",
+            "coordinates" => object_.coordinates
           }
         when ::RGeo::Feature::MultiPolygon
           {
-            'type' => 'MultiPolygon',
-            'coordinates' => object_.coordinates
+            "type" => "MultiPolygon",
+            "coordinates" => object_.coordinates
           }
         when ::RGeo::Feature::GeometryCollection
           {
-            'type' => 'GeometryCollection',
-            'geometries' => object_.map{ |geom_| _encode_geometry(geom_, point_encoder_) },
+            "type" => "GeometryCollection",
+            "geometries" => object_.map { |geom_| _encode_geometry(geom_, point_encoder_) },
           }
         else
           nil
         end
       end
 
-
-      def _decode_feature(input_)  # :nodoc:
-        geometry_ = input_['geometry']
+      def _decode_feature(input_) # :nodoc:
+        geometry_ = input_["geometry"]
         if geometry_
           geometry_ = _decode_geometry(geometry_)
           return nil unless geometry_
         end
-        @entity_factory.feature(geometry_, input_['id'], input_['properties'])
+        @entity_factory.feature(geometry_, input_["id"], input_["properties"])
       end
 
-
-      def _decode_geometry(input_)  # :nodoc:
-        case input_['type']
-        when 'GeometryCollection'
+      def _decode_geometry(input_) # :nodoc:
+        case input_["type"]
+        when "GeometryCollection"
           _decode_geometry_collection(input_)
-        when 'Point'
-          _decode_point_coords(input_['coordinates'])
-        when 'LineString'
-          _decode_line_string_coords(input_['coordinates'])
-        when 'Polygon'
-          _decode_polygon_coords(input_['coordinates'])
-        when 'MultiPoint'
-          _decode_multi_point_coords(input_['coordinates'])
-        when 'MultiLineString'
-          _decode_multi_line_string_coords(input_['coordinates'])
-        when 'MultiPolygon'
-          _decode_multi_polygon_coords(input_['coordinates'])
+        when "Point"
+          _decode_point_coords(input_["coordinates"])
+        when "LineString"
+          _decode_line_string_coords(input_["coordinates"])
+        when "Polygon"
+          _decode_polygon_coords(input_["coordinates"])
+        when "MultiPoint"
+          _decode_multi_point_coords(input_["coordinates"])
+        when "MultiLineString"
+          _decode_multi_line_string_coords(input_["coordinates"])
+        when "MultiPolygon"
+          _decode_multi_polygon_coords(input_["coordinates"])
         else
           nil
         end
       end
 
-
       def _decode_geometry_collection(input_)  # :nodoc:
-        geometries_ = input_['geometries']
+        geometries_ = input_["geometries"]
         geometries_ = [] unless geometries_.kind_of?(::Array)
         decoded_geometries_ = []
         geometries_.each do |g_|
@@ -289,14 +270,12 @@ module RGeo
         @geo_factory.collection(decoded_geometries_)
       end
 
-
       def _decode_point_coords(point_coords_)  # :nodoc:
         return nil unless point_coords_.kind_of?(::Array)
-        @geo_factory.point(*(point_coords_[0...@num_coordinates].map{ |c_| c_.to_f })) rescue nil
+        @geo_factory.point(*(point_coords_[0...@num_coordinates].map(&:to_f))) rescue nil
       end
 
-
-      def _decode_line_string_coords(line_coords_)  # :nodoc:
+      def _decode_line_string_coords(line_coords_) # :nodoc:
         return nil unless line_coords_.kind_of?(::Array)
         points_ = []
         line_coords_.each do |point_coords_|
@@ -306,8 +285,7 @@ module RGeo
         @geo_factory.line_string(points_)
       end
 
-
-      def _decode_polygon_coords(poly_coords_)  # :nodoc:
+      def _decode_polygon_coords(poly_coords_) # :nodoc:
         return nil unless poly_coords_.kind_of?(::Array)
         rings_ = []
         poly_coords_.each do |ring_coords_|
@@ -327,8 +305,7 @@ module RGeo
         end
       end
 
-
-      def _decode_multi_point_coords(multi_point_coords_)  # :nodoc:
+      def _decode_multi_point_coords(multi_point_coords_) # :nodoc:
         return nil unless multi_point_coords_.kind_of?(::Array)
         points_ = []
         multi_point_coords_.each do |point_coords_|
@@ -338,8 +315,7 @@ module RGeo
         @geo_factory.multi_point(points_)
       end
 
-
-      def _decode_multi_line_string_coords(multi_line_coords_)  # :nodoc:
+      def _decode_multi_line_string_coords(multi_line_coords_) # :nodoc:
         return nil unless multi_line_coords_.kind_of?(::Array)
         lines_ = []
         multi_line_coords_.each do |line_coords_|
@@ -349,8 +325,7 @@ module RGeo
         @geo_factory.multi_line_string(lines_)
       end
 
-
-      def _decode_multi_polygon_coords(multi_polygon_coords_)  # :nodoc:
+      def _decode_multi_polygon_coords(multi_polygon_coords_) # :nodoc:
         return nil unless multi_polygon_coords_.kind_of?(::Array)
         polygons_ = []
         multi_polygon_coords_.each do |poly_coords_|
@@ -359,11 +334,6 @@ module RGeo
         end
         @geo_factory.multi_polygon(polygons_)
       end
-
-
     end
-
-
   end
-
 end

data/lib/rgeo/geo_json/entities.rb

@@ -1,8 +1,5 @@
 module RGeo
-
   module GeoJSON
-
-
     # This is a GeoJSON wrapper entity that corresponds to the GeoJSON
     # "Feature" type. It is an immutable type.
     #
@@ -14,12 +11,10 @@ module RGeo
     # engine and features.
 
     class Feature
-
-
       # Create a feature wrapping the given geometry, with the given ID
       # and properties.
 
-      def initialize(geometry_, id_=nil, properties_={})
+      def initialize(geometry_, id_ = nil, properties_ = {})
         @geometry = geometry_
         @id = id_
         @properties = {}
@@ -28,8 +23,7 @@ module RGeo
         end
       end
 
-
-      def inspect  # :nodoc:
+      def inspect # :nodoc:
         "#<#{self.class}:0x#{object_id.to_s(16)} id=#{@id.inspect} geom=#{@geometry ? @geometry.as_text.inspect : 'nil'}>"
       end
 
@@ -41,7 +35,6 @@ module RGeo
         @geometry.hash + @id.hash + @properties.hash
       end
 
-
       # Two features are equal if their geometries, IDs, and properties
       # are all equal.
       # This method uses the eql? method to test geometry equality, which
@@ -51,7 +44,6 @@ module RGeo
         rhs_.kind_of?(Feature) && @geometry.eql?(rhs_.geometry) && @id.eql?(rhs_.feature_id) && @properties.eql?(rhs_.instance_variable_get(:@properties))
       end
 
-
       # Two features are equal if their geometries, IDs, and properties
       # are all equal.
       # This method uses the == operator to test geometry equality, which
@@ -61,13 +53,9 @@ module RGeo
         rhs_.kind_of?(Feature) && @geometry == rhs_.geometry && @id == rhs_.feature_id && @properties == rhs_.instance_variable_get(:@properties)
       end
 
-
       # Returns the geometry contained in this feature, which may be nil.
 
-      def geometry
-        @geometry
-      end
-
+      attr_reader :geometry
 
       # Returns the ID for this feature, which may be nil.
 
@@ -75,14 +63,12 @@ module RGeo
         @id
       end
 
-
       # Returns a copy of the properties for this feature.
 
       def properties
         @properties.dup
       end
 
-
       # Gets the value of the given named property.
       # Returns nil if the given property is not found.
 
@@ -91,17 +77,13 @@ module RGeo
       end
       alias_method :[], :property
 
-
       # Gets an array of the known property keys in this feature.
 
       def keys
         @properties.keys
       end
-
-
     end
 
-
     # This is a GeoJSON wrapper entity that corresponds to the GeoJSON
     # "FeatureCollection" type. It is an immutable type.
     #
@@ -113,20 +95,17 @@ module RGeo
     # between the GeoJSON engine and feature collections.
 
     class FeatureCollection
-
       include ::Enumerable
 
-
       # Create a new FeatureCollection with the given features, which must
       # be provided as an Enumerable.
 
-      def initialize(features_=[])
+      def initialize(features_ = [])
         @features = []
-        features_.each{ |f_| @features << f_ if f_.kind_of?(Feature) }
+        features_.each { |f_| @features << f_ if f_.kind_of?(Feature) }
       end
 
-
-      def inspect  # :nodoc:
+      def inspect # :nodoc:
         "#<#{self.class}:0x#{object_id.to_s(16)}>"
       end
 
@@ -138,7 +117,6 @@ module RGeo
         @features.hash
       end
 
-
       # Two feature collections are equal if they contain the same
       # features in the same order.
       # This methods uses the eql? method to test geometry equality, which
@@ -148,7 +126,6 @@ module RGeo
         rhs_.kind_of?(FeatureCollection) && @features.eql?(rhs_.instance_variable_get(:@features))
       end
 
-
       # Two feature collections are equal if they contain the same
       # features in the same order.
       # This methods uses the == operator to test geometry equality, which
@@ -158,55 +135,45 @@ module RGeo
         rhs_.kind_of?(FeatureCollection) && @features == rhs_.instance_variable_get(:@features)
       end
 
-
       # Iterates or returns an iterator for the features.
 
       def each(&block_)
         @features.each(&block_)
       end
 
-
       # Returns the number of features contained in this collection.
 
       def size
         @features.size
       end
 
-
       # Access a feature by index.
 
       def [](index_)
         @features[index_]
       end
-
-
     end
 
-
     # This is the default entity factory. It creates objects of type
     # RGeo::GeoJSON::Feature and RGeo::GeoJSON::FeatureCollection.
     # You may create your own entity factory by duck-typing this class.
 
     class EntityFactory
-
-
       # Create and return a new feature, given geometry, ID, and
       # properties hash. Note that, per the GeoJSON spec, geometry and/or
       # properties may be nil.
 
-      def feature(geometry_, id_=nil, properties_=nil)
+      def feature(geometry_, id_ = nil, properties_ = nil)
         Feature.new(geometry_, id_, properties_ || {})
       end
 
-
       # Create and return a new feature collection, given an enumerable
       # of feature objects.
 
-      def feature_collection(features_=[])
+      def feature_collection(features_ = [])
         FeatureCollection.new(features_)
       end
 
-
       # Returns true if the given object is a feature created by this
       # entity factory.
 
@@ -214,7 +181,6 @@ module RGeo
         object_.kind_of?(Feature)
       end
 
-
       # Returns true if the given object is a feature collection created
       # by this entity factory.
 
@@ -222,7 +188,6 @@ module RGeo
         object_.kind_of?(FeatureCollection)
       end
 
-
       # Run Enumerable#map on the features contained in the given feature
       # collection.
 
@@ -230,21 +195,18 @@ module RGeo
         object_.map(&block_)
       end
 
-
       # Returns the geometry associated with the given feature.
 
       def get_feature_geometry(object_)
         object_.geometry
       end
 
-
       # Returns the ID of the given feature, or nil for no ID.
 
       def get_feature_id(object_)
         object_.feature_id
       end
 
-
       # Returns the properties of the given feature as a hash. Editing
       # this hash does not change the state of the feature.
 
@@ -252,17 +214,11 @@ module RGeo
         object_.properties
       end
 
-
       # Return the singleton instance of EntityFactory.
 
       def self.instance
-        @instance ||= self.new
+        @instance ||= new
       end
-
-
     end
-
-
   end
-
 end

data/lib/rgeo/geo_json/interface.rb

@@ -1,10 +1,6 @@
 module RGeo
-
   module GeoJSON
-
     class << self
-
-
       # High-level convenience routine for encoding an object as GeoJSON.
       # Pass the object, which may one of the geometry objects specified
       # in RGeo::Feature, or an appropriate GeoJSON wrapper entity such
@@ -16,11 +12,10 @@ module RGeo
       # encode supports objects of type RGeo::GeoJSON::Feature and
       # RGeo::GeoJSON::FeatureCollection.
 
-      def encode(object_, opts_={})
+      def encode(object_, opts_ = {})
         Coder.new(opts_).encode(object_)
       end
 
-
       # High-level convenience routine for decoding an object from GeoJSON.
       # The input may be a JSON hash, a String, or an IO object from which
       # to read the JSON string.
@@ -48,11 +43,10 @@ module RGeo
       #   If a parser is not specified, then the decode method will not
       #   accept a String or IO object; it will require a Hash.
 
-      def decode(input_, opts_={})
+      def decode(input_, opts_ = {})
         Coder.new(opts_).decode(input_)
       end
 
-
       # Creates and returns a coder object of type RGeo::GeoJSON::Coder
       # that encapsulates encoding and decoding settings (principally the
       # RGeo::Feature::Factory and the RGeo::GeoJSON::EntityFactory to be
@@ -81,13 +75,9 @@ module RGeo
       #   If a parser is not specified, then the decode method will not
       #   accept a String or IO object; it will require a Hash.
 
-      def coder(opts_={})
+      def coder(opts_ = {})
         Coder.new(opts_)
       end
-
-
     end
-
   end
-
 end

data/lib/rgeo/geo_json/version.rb

@@ -1,5 +1,5 @@
 module RGeo
   module GeoJSON
-    VERSION = '0.3.2'.freeze
+    VERSION = "0.3.3".freeze
   end
 end

data/lib/rgeo/geo_json.rb

@@ -1,5 +1,4 @@
-require 'rgeo'
-
+require "rgeo"
 
 # RGeo is a spatial data library for Ruby, provided by the "rgeo" gem.
 #
@@ -7,20 +6,15 @@ require 'rgeo'
 # encoding and decoding.
 
 module RGeo
-
-
   # This is a namespace for a set of tools that provide GeoJSON encoding.
   # See http://geojson.org/ for more information about this specification.
 
   module GeoJSON
   end
-
-
 end
 
-
 # Implementation files
-require 'rgeo/geo_json/version'
-require 'rgeo/geo_json/entities'
-require 'rgeo/geo_json/coder'
-require 'rgeo/geo_json/interface'
+require "rgeo/geo_json/version"
+require "rgeo/geo_json/entities"
+require "rgeo/geo_json/coder"
+require "rgeo/geo_json/interface"

data/lib/rgeo-geojson.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rgeo-geojson
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors:
 - Daniel Azuma
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-10 00:00:00.000000000 Z
+date: 2015-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rgeo
@@ -67,10 +67,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.4'
-description: RGeo is a geospatial data library for Ruby. RGeo::GeoJSON is an optional
-  RGeo module providing GeoJSON encoding and decoding services. This module can be
-  used to communicate with location-based web services that understand the GeoJSON
-  format.
+description: Convert RGeo data to and from GeoJSON. rgeo-geojson is an extension to
+  the rgeo gem that converts RGeo data types to and from GeoJSON.
 email:
 - dazuma@gmail.com
 - parhameter@gmail.com
@@ -87,8 +85,7 @@ files:
 - lib/rgeo/geo_json/entities.rb
 - lib/rgeo/geo_json/interface.rb
 - lib/rgeo/geo_json/version.rb
-- test/basic_test.rb
-homepage: http://github.com/rgeo/rgeo-geojson
+homepage: https://github.com/rgeo/rgeo-geojson
 licenses:
 - BSD
 metadata: {}
@@ -108,9 +105,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.0
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: An RGeo module providing GeoJSON encoding and decoding.
-test_files:
-- test/basic_test.rb
+summary: Convert RGeo data to and from GeoJSON.
+test_files: []
+has_rdoc: 

data/test/basic_test.rb

@@ -1,273 +0,0 @@
-require 'minitest/autorun'
-require 'rgeo/geo_json'
-
-module RGeo
-  module GeoJSON
-    module Tests  # :nodoc:
-
-      class BasicTest < Minitest::Test  # :nodoc:
-
-
-        def setup
-          @geo_factory = ::RGeo::Cartesian.simple_factory(:srid => 4326)
-          @geo_factory_z = ::RGeo::Cartesian.simple_factory(:srid => 4326, :has_z_coordinate => true)
-          @geo_factory_m = ::RGeo::Cartesian.simple_factory(:srid => 4326, :has_m_coordinate => true)
-          @geo_factory_zm = ::RGeo::Cartesian.simple_factory(:srid => 4326, :has_z_coordinate => true, :has_m_coordinate => true)
-          @entity_factory = ::RGeo::GeoJSON::EntityFactory.instance
-        end
-
-
-        def test_has_version
-          refute_nil(::RGeo::GeoJSON::VERSION)
-        end
-
-
-        def test_nil
-          assert_nil(::RGeo::GeoJSON.encode(nil))
-          assert_nil(::RGeo::GeoJSON.decode(nil, :geo_factory => @geo_factory))
-        end
-
-
-        def test_point
-          object_ = @geo_factory.point(10, 20)
-          json_ = {
-            'type' => 'Point',
-            'coordinates' => [10.0, 20.0],
-          }
-          assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
-          assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory).eql?(object_))
-        end
-
-
-        def test_point_z
-          object_ = @geo_factory_z.point(10, 20, -1)
-          json_ = {
-            'type' => 'Point',
-            'coordinates' => [10.0, 20.0, -1.0],
-          }
-          assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
-          assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory_z).eql?(object_))
-        end
-
-
-        def test_point_m
-          object_ = @geo_factory_m.point(10, 20, -1)
-          json_ = {
-            'type' => 'Point',
-            'coordinates' => [10.0, 20.0, -1.0],
-          }
-          assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
-          assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory_m).eql?(object_))
-        end
-
-
-        def test_point_zm
-          object_ = @geo_factory_zm.point(10, 20, -1, -2)
-          json_ = {
-            'type' => 'Point',
-            'coordinates' => [10.0, 20.0, -1.0, -2.0],
-          }
-          assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
-          assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory_zm).eql?(object_))
-        end
-
-
-        def test_line_string
-          object_ = @geo_factory.line_string([@geo_factory.point(10, 20), @geo_factory.point(12, 22), @geo_factory.point(-3, 24)])
-          json_ = {
-            'type' => 'LineString',
-            'coordinates' => [[10.0, 20.0], [12.0, 22.0], [-3.0, 24.0]],
-          }
-          assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
-          assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory).eql?(object_))
-        end
-
-
-        def test_polygon
-          object_ = @geo_factory.polygon(@geo_factory.linear_ring([@geo_factory.point(10, 20), @geo_factory.point(12, 22), @geo_factory.point(-3, 24), @geo_factory.point(10, 20)]))
-          json_ = {
-            'type' => 'Polygon',
-            'coordinates' => [[[10.0, 20.0], [12.0, 22.0], [-3.0, 24.0], [10.0, 20.0]]],
-          }
-          assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
-          assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory).eql?(object_))
-        end
-
-
-        def test_polygon_complex
-          object_ = @geo_factory.polygon(@geo_factory.linear_ring([@geo_factory.point(0, 0), @geo_factory.point(10, 0), @geo_factory.point(10, 10), @geo_factory.point(0, 10), @geo_factory.point(0, 0)]), [@geo_factory.linear_ring([@geo_factory.point(4, 4), @geo_factory.point(6, 5), @geo_factory.point(4, 6), @geo_factory.point(4, 4)])])
-          json_ = {
-            'type' => 'Polygon',
-            'coordinates' => [[[0.0, 0.0], [10.0, 0.0], [10.0, 10.0], [0.0, 10.0], [0.0, 0.0]], [[4.0, 4.0], [6.0, 5.0], [4.0, 6.0], [4.0, 4.0]]],
-          }
-          assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
-          assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory).eql?(object_))
-        end
-
-
-        def test_multi_point
-          object_ = @geo_factory.multi_point([@geo_factory.point(10, 20), @geo_factory.point(12, 22), @geo_factory.point(-3, 24)])
-          json_ = {
-            'type' => 'MultiPoint',
-            'coordinates' => [[10.0, 20.0], [12.0, 22.0], [-3.0, 24.0]],
-          }
-          assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
-          assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory).eql?(object_))
-        end
-
-
-        def test_multi_line_string
-          object_ = @geo_factory.multi_line_string([@geo_factory.line_string([@geo_factory.point(10, 20), @geo_factory.point(12, 22), @geo_factory.point(-3, 24)]), @geo_factory.line_string([@geo_factory.point(1, 2), @geo_factory.point(3, 4)])])
-          json_ = {
-            'type' => 'MultiLineString',
-            'coordinates' => [[[10.0, 20.0], [12.0, 22.0], [-3.0, 24.0]], [[1.0, 2.0], [3.0, 4.0]]],
-          }
-          assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
-          assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory).eql?(object_))
-        end
-
-
-        def test_multi_polygon
-          object_ = @geo_factory.multi_polygon([@geo_factory.polygon(@geo_factory.linear_ring([@geo_factory.point(0, 0), @geo_factory.point(10, 0), @geo_factory.point(10, 10), @geo_factory.point(0, 10), @geo_factory.point(0, 0)]), [@geo_factory.linear_ring([@geo_factory.point(4, 4), @geo_factory.point(6, 5), @geo_factory.point(4, 6), @geo_factory.point(4, 4)])]), @geo_factory.polygon(@geo_factory.linear_ring([@geo_factory.point(-10,-10), @geo_factory.point(-15, -10), @geo_factory.point(-10, -15), @geo_factory.point(-10, -10)]))])
-          json_ = {
-            'type' => 'MultiPolygon',
-            'coordinates' => [[[[0.0, 0.0], [10.0, 0.0], [10.0, 10.0], [0.0, 10.0], [0.0, 0.0]], [[4.0, 4.0], [6.0, 5.0], [4.0, 6.0], [4.0, 4.0]]], [[[-10.0, -10.0], [-15.0, -10.0], [-10.0, -15.0], [-10.0, -10.0]]]]
-          }
-          assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
-          assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory).eql?(object_))
-        end
-
-
-        def test_geometry_collection
-          object_ = @geo_factory.collection([@geo_factory.point(10, 20), @geo_factory.collection([@geo_factory.point(12, 22), @geo_factory.point(-3, 24)])])
-          json_ = {
-            'type' => 'GeometryCollection',
-            'geometries' => [
-              {
-                'type' => 'Point',
-                'coordinates' => [10.0, 20.0],
-              },
-              {
-                'type' => 'GeometryCollection',
-                'geometries' => [
-                  {
-                    'type' => 'Point',
-                    'coordinates' => [12.0, 22.0],
-                  },
-                  {
-                    'type' => 'Point',
-                    'coordinates' => [-3.0, 24.0],
-                  },
-                ],
-              },
-            ],
-          }
-          assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
-          assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory).eql?(object_))
-        end
-
-
-        def test_feature
-          object_ = @entity_factory.feature(@geo_factory.point(10, 20))
-          json_ = {
-            'type' => 'Feature',
-            'geometry' => {
-              'type' => 'Point',
-              'coordinates' => [10.0, 20.0],
-            },
-            'properties' => {},
-          }
-          assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
-          assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory).eql?(object_))
-        end
-
-
-        def test_feature_nulls
-          json_ = {
-            'type' => 'Feature',
-            'geometry' => nil,
-            'properties' => nil,
-          }
-          obj_ = ::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory)
-          refute_nil(obj_)
-          assert_nil(obj_.geometry)
-          assert_equal({}, obj_.properties)
-        end
-
-
-        def test_feature_complex
-          object_ = @entity_factory.feature(@geo_factory.point(10, 20), 2, {'prop1' => 'foo', 'prop2' => 'bar'})
-          json_ = {
-            'type' => 'Feature',
-            'geometry' => {
-              'type' => 'Point',
-              'coordinates' => [10.0, 20.0],
-            },
-            'id' => 2,
-            'properties' => {'prop1' => 'foo', 'prop2' => 'bar'},
-          }
-          assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
-          assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory).eql?(object_))
-        end
-
-
-        def test_feature_with_symbol_prop_keys
-          object_ = @entity_factory.feature(@geo_factory.point(10, 20), 2, {:prop1 => 'foo', 'prop2' => 'bar'})
-          json_ = {
-            'type' => 'Feature',
-            'geometry' => {
-              'type' => 'Point',
-              'coordinates' => [10.0, 20.0],
-            },
-            'id' => 2,
-            'properties' => {'prop1' => 'foo', 'prop2' => 'bar'},
-          }
-          assert_equal('foo', object_.property('prop1'))
-          assert_equal('bar', object_.property(:prop2))
-          assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
-          assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory).eql?(object_))
-        end
-
-
-        def test_feature_collection
-          object_ = @entity_factory.feature_collection([@entity_factory.feature(@geo_factory.point(10, 20)), @entity_factory.feature(@geo_factory.point(11, 22)), @entity_factory.feature(@geo_factory.point(10, 20), 8)])
-          json_ = {
-            'type' => 'FeatureCollection',
-            'features' => [
-              {
-                'type' => 'Feature',
-                'geometry' => {
-                  'type' => 'Point',
-                  'coordinates' => [10.0, 20.0],
-                },
-                'properties' => {},
-              },
-              {
-                'type' => 'Feature',
-                'geometry' => {
-                  'type' => 'Point',
-                  'coordinates' => [11.0, 22.0],
-                },
-                'properties' => {},
-              },
-              {
-                'type' => 'Feature',
-                'geometry' => {
-                  'type' => 'Point',
-                  'coordinates' => [10.0, 20.0],
-                },
-                'id' => 8,
-                'properties' => {},
-              },
-            ]
-          }
-          assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
-          assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory).eql?(object_))
-        end
-
-
-      end
-
-    end
-  end
-end