rgeo-geojson 0.3.3 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1a486ffc62008cbb9d03e13f7ea93aa229c588de
-  data.tar.gz: c3826e787a98ba17b33f81e59c859898a6807ea3
+  metadata.gz: fc3be76c9c38e00c18464bd4fa71abbcc369a9dc
+  data.tar.gz: 508c6d9bf6a22fa8dba63d8aea3a569f6f287331
 SHA512:
-  metadata.gz: 4ef133754c920d853e2e2a9191e194afdf895bb361692e22d56d2dc160c5dda5b9b8470aad511458d84a35e7ef44f5541346e44ab6750ff1ac7124129f7ccc7f
-  data.tar.gz: e6fd873662287d0b7999190469aad4f805259906e2589f043199128bd56848c84c7f14cb082dacabe7eb5b0073288fc40eccfae2818d098aabaafe74d7d9f476
+  metadata.gz: 21f7f32967c8c92f15ac42375852063c3528fa887f2d1dd728436e7ea26ce157518c5f2dd194c97a3d0c3b7819027aa181cf4a365dd72096085e4637d3b06d3b
+  data.tar.gz: 084e1f589f1a679d10fc15fd1584e94e9a6df76f498a587b9042f93d4a4f35befeacceab8498151e3efe02fadcaf9bd2cc21fa42dd1cee0c28849e2be42c761b

data/History.md

@@ -1,8 +1,16 @@
+### 0.4.0 / 2015-12-28
+
+* Removed error handling for missing parser gems
+* Removed class variables in Coder
+* Removed rgeo/geo_json.rb
+
+
 ### 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/lib/rgeo-geojson.rb

@@ -1 +1,5 @@
-require "rgeo/geo_json"
+require "rgeo"
+require "rgeo/geo_json/version"
+require "rgeo/geo_json/entities"
+require "rgeo/geo_json/coder"
+require "rgeo/geo_json/interface"

data/lib/rgeo/geo_json/coder.rb

@@ -6,10 +6,6 @@ module RGeo
     # 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.
       #
@@ -32,58 +28,25 @@ module RGeo
       #   <tt>:active_support</tt>. Setting one of those special values
       #   will require the corresponding library to be available. Note
       #   that the <tt>:json</tt> library is present in the standard
-      #   library in Ruby 1.9, but requires the "json" gem in Ruby 1.8.
+      #   library in Ruby 1.9.
       #   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_ = {})
-        @geo_factory = opts_[:geo_factory] || ::RGeo::Cartesian.preferred_factory
-        @entity_factory = opts_[:entity_factory] || EntityFactory.instance
-        @json_parser = opts_[:json_parser]
+      def initialize(opts = {})
+        @geo_factory = opts[:geo_factory] || RGeo::Cartesian.preferred_factory
+        @entity_factory = opts[:entity_factory] || EntityFactory.instance
+        @json_parser = opts[:json_parser]
         case @json_parser
         when :json
-          if @@json_available.nil?
-            begin
-              require "json"
-              @@json_available = true
-            rescue ::LoadError
-              @@json_available = false
-            end
-          end
-          if @@json_available
-            @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
+          require "json" unless defined?(JSON)
+          @json_parser = proc { |str| JSON.parse(str) }
         when :yajl
-          if @@yajl_available.nil?
-            begin
-              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_) }
-          else
-            raise Error::RGeoError, "Yajl library is not available. You may need to install the 'yajl' gem."
-          end
+          require "yajl" unless defined?(Yajl)
+          @json_parser = proc { |str| Yajl::Parser.new.parse(str) }
         when :active_support
-          if @@activesupport_available.nil?
-            begin
-              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_) }
-          else
-            raise Error::RGeoError, "ActiveSupport::JSON library is not available. You may need to install the 'activesupport' gem."
-          end
-        when ::Proc, nil
+          require "active_support/json" unless defined?(ActiveSupport::JSON)
+          @json_parser = proc { |str| ActiveSupport::JSON.decode(str) }
+        when Proc, nil
           # Leave as is
         else
           raise ::ArgumentError, "Unrecognzied json_parser: #{@json_parser.inspect}"
@@ -105,18 +68,18 @@ module RGeo
       #
       # Returns nil if nil is passed in as the object.
 
-      def encode(object_)
-        if @entity_factory.is_feature_collection?(object_)
+      def encode(object)
+        if @entity_factory.is_feature_collection?(object)
           {
             "type" => "FeatureCollection",
-            "features" => @entity_factory.map_feature_collection(object_) { |f_| _encode_feature(f_) },
+            "features" => @entity_factory.map_feature_collection(object) { |f| _encode_feature(f) },
           }
-        elsif @entity_factory.is_feature?(object_)
-          _encode_feature(object_)
-        elsif object_.nil?
+        elsif @entity_factory.is_feature?(object)
+          _encode_feature(object)
+        elsif object.nil?
           nil
         else
-          _encode_geometry(object_)
+          _encode_geometry(object)
         end
       end
 
@@ -124,31 +87,31 @@ module RGeo
       # String, or an IO object from which to read the JSON string.
       # If an error occurs, nil is returned.
 
-      def decode(input_)
-        if input_.kind_of?(::IO)
-          input_ = input_.read rescue nil
+      def decode(input)
+        if input.is_a?(IO)
+          input = input.read rescue nil
         end
-        if input_.kind_of?(::String)
-          input_ = @json_parser.call(input_) rescue nil
+        if input.is_a?(String)
+          input = @json_parser.call(input) rescue nil
         end
-        unless input_.kind_of?(::Hash)
+        unless input.is_a?(Hash)
           return nil
         end
-        case input_["type"]
+        case input["type"]
         when "FeatureCollection"
-          features_ = input_["features"]
-          features_ = [] unless features_.kind_of?(::Array)
-          decoded_features_ = []
-          features_.each do |f_|
-            if f_["type"] == "Feature"
-              decoded_features_ << _decode_feature(f_)
+          features = input["features"]
+          features = [] unless features.is_a?(Array)
+          decoded_features = []
+          features.each do |f|
+            if f["type"] == "Feature"
+              decoded_features << _decode_feature(f)
             end
           end
-          @entity_factory.feature_collection(decoded_features_)
+          @entity_factory.feature_collection(decoded_features)
         when "Feature"
-          _decode_feature(input_)
+          _decode_feature(input)
         else
-          _decode_geometry(input_)
+          _decode_geometry(input)
         end
       end
 
@@ -161,107 +124,107 @@ module RGeo
 
       attr_reader :entity_factory
 
-      def _encode_feature(object_) # :nodoc:
-        json_ = {
+      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,
+          "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 = @entity_factory.get_feature_id(object)
+        json["id"] = id if id
+        json
       end
 
-      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] }
+      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 { |p| [p.x, p.y, p.z, p.m] }
             else
-              point_encoder_ = ::Proc.new { |p_| [p_.x, p_.y, p_.z] }
+              point_encoder = proc { |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] }
+            if object.factory.property(:has_m_coordinate)
+              point_encoder = proc { |p| [p.x, p.y, p.m] }
             else
-              point_encoder_ = ::Proc.new { |p_| [p_.x, p_.y] }
+              point_encoder = proc { |p| [p.x, p.y] }
             end
           end
         end
-        case object_
-        when ::RGeo::Feature::Point
+        case object
+        when RGeo::Feature::Point
           {
             "type" => "Point",
-            "coordinates" => object_.coordinates
+            "coordinates" => object.coordinates
           }
-        when ::RGeo::Feature::LineString
+        when RGeo::Feature::LineString
           {
             "type" => "LineString",
-            "coordinates" => object_.coordinates
+            "coordinates" => object.coordinates
           }
-        when ::RGeo::Feature::Polygon
+        when RGeo::Feature::Polygon
           {
             "type" => "Polygon",
-            "coordinates" => object_.coordinates
+            "coordinates" => object.coordinates
           }
-        when ::RGeo::Feature::MultiPoint
+        when RGeo::Feature::MultiPoint
           {
             "type" => "MultiPoint",
-            "coordinates" => object_.coordinates
+            "coordinates" => object.coordinates
           }
-        when ::RGeo::Feature::MultiLineString
+        when RGeo::Feature::MultiLineString
           {
             "type" => "MultiLineString",
-            "coordinates" => object_.coordinates
+            "coordinates" => object.coordinates
           }
-        when ::RGeo::Feature::MultiPolygon
+        when RGeo::Feature::MultiPolygon
           {
             "type" => "MultiPolygon",
-            "coordinates" => object_.coordinates
+            "coordinates" => object.coordinates
           }
-        when ::RGeo::Feature::GeometryCollection
+        when RGeo::Feature::GeometryCollection
           {
             "type" => "GeometryCollection",
-            "geometries" => object_.map { |geom_| _encode_geometry(geom_, point_encoder_) },
+            "geometries" => object.map { |geom| _encode_geometry(geom, point_encoder) },
           }
         else
           nil
         end
       end
 
-      def _decode_feature(input_) # :nodoc:
-        geometry_ = input_["geometry"]
-        if geometry_
-          geometry_ = _decode_geometry(geometry_)
-          return nil unless 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"]
+      def _decode_geometry(input) # :nodoc:
+        case input["type"]
         when "GeometryCollection"
-          _decode_geometry_collection(input_)
+          _decode_geometry_collection(input)
         when "Point"
-          _decode_point_coords(input_["coordinates"])
+          _decode_point_coords(input["coordinates"])
         when "LineString"
-          _decode_line_string_coords(input_["coordinates"])
+          _decode_line_string_coords(input["coordinates"])
         when "Polygon"
-          _decode_polygon_coords(input_["coordinates"])
+          _decode_polygon_coords(input["coordinates"])
         when "MultiPoint"
-          _decode_multi_point_coords(input_["coordinates"])
+          _decode_multi_point_coords(input["coordinates"])
         when "MultiLineString"
-          _decode_multi_line_string_coords(input_["coordinates"])
+          _decode_multi_line_string_coords(input["coordinates"])
         when "MultiPolygon"
-          _decode_multi_polygon_coords(input_["coordinates"])
+          _decode_multi_polygon_coords(input["coordinates"])
         else
           nil
         end
       end
 
-      def _decode_geometry_collection(input_)  # :nodoc:
-        geometries_ = input_["geometries"]
-        geometries_ = [] unless geometries_.kind_of?(::Array)
+      def _decode_geometry_collection(input)  # :nodoc:
+        geometries_ = input["geometries"]
+        geometries_ = [] unless geometries_.is_a?(Array)
         decoded_geometries_ = []
         geometries_.each do |g_|
           g_ = _decode_geometry(g_)
@@ -270,69 +233,69 @@ 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(&:to_f))) rescue nil
+      def _decode_point_coords(point_coords)  # :nodoc:
+        return nil unless point_coords.is_a?(Array)
+        @geo_factory.point(*(point_coords[0...@num_coordinates].map(&:to_f))) rescue nil
       end
 
-      def _decode_line_string_coords(line_coords_) # :nodoc:
-        return nil unless line_coords_.kind_of?(::Array)
-        points_ = []
-        line_coords_.each do |point_coords_|
-          point_ = _decode_point_coords(point_coords_)
-          points_ << point_ if point_
+      def _decode_line_string_coords(line_coords) # :nodoc:
+        return nil unless line_coords.is_a?(Array)
+        points = []
+        line_coords.each do |point_coords|
+          point = _decode_point_coords(point_coords)
+          points << point if point
         end
-        @geo_factory.line_string(points_)
+        @geo_factory.line_string(points)
       end
 
-      def _decode_polygon_coords(poly_coords_) # :nodoc:
-        return nil unless poly_coords_.kind_of?(::Array)
-        rings_ = []
-        poly_coords_.each do |ring_coords_|
-          return nil unless ring_coords_.kind_of?(::Array)
-          points_ = []
-          ring_coords_.each do |point_coords_|
-            point_ = _decode_point_coords(point_coords_)
-            points_ << point_ if point_
+      def _decode_polygon_coords(poly_coords) # :nodoc:
+        return nil unless poly_coords.is_a?(Array)
+        rings = []
+        poly_coords.each do |ring_coords|
+          return nil unless ring_coords.is_a?(Array)
+          points = []
+          ring_coords.each do |point_coords|
+            point = _decode_point_coords(point_coords)
+            points << point if point
           end
-          ring_ = @geo_factory.linear_ring(points_)
-          rings_ << ring_ if ring_
+          ring = @geo_factory.linear_ring(points)
+          rings << ring if ring
         end
-        if rings_.size == 0
+        if rings.size == 0
           nil
         else
-          @geo_factory.polygon(rings_[0], rings_[1..-1])
+          @geo_factory.polygon(rings[0], rings[1..-1])
         end
       end
 
-      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_|
-          point_ = _decode_point_coords(point_coords_)
-          points_ << point_ if point_
+      def _decode_multi_point_coords(multi_point_coords) # :nodoc:
+        return nil unless multi_point_coords.is_a?(Array)
+        points = []
+        multi_point_coords.each do |point_coords|
+          point = _decode_point_coords(point_coords)
+          points << point if point
         end
-        @geo_factory.multi_point(points_)
+        @geo_factory.multi_point(points)
       end
 
-      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_|
-          line_ = _decode_line_string_coords(line_coords_)
-          lines_ << line_ if line_
+      def _decode_multi_line_string_coords(multi_line_coords) # :nodoc:
+        return nil unless multi_line_coords.is_a?(Array)
+        lines = []
+        multi_line_coords.each do |line_coords|
+          line = _decode_line_string_coords(line_coords)
+          lines << line if line
         end
-        @geo_factory.multi_line_string(lines_)
+        @geo_factory.multi_line_string(lines)
       end
 
-      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_|
-          poly_ = _decode_polygon_coords(poly_coords_)
-          polygons_ << poly_ if poly_
+      def _decode_multi_polygon_coords(multi_polygon_coords) # :nodoc:
+        return nil unless multi_polygon_coords.is_a?(Array)
+        polygons = []
+        multi_polygon_coords.each do |poly_coords|
+          poly = _decode_polygon_coords(poly_coords)
+          polygons << poly if poly
         end
-        @geo_factory.multi_polygon(polygons_)
+        @geo_factory.multi_polygon(polygons)
       end
     end
   end

data/lib/rgeo/geo_json/entities.rb

@@ -14,17 +14,17 @@ module RGeo
       # Create a feature wrapping the given geometry, with the given ID
       # and properties.
 
-      def initialize(geometry_, id_ = nil, properties_ = {})
-        @geometry = geometry_
-        @id = id_
+      def initialize(geometry, id = nil, properties = {})
+        @geometry = geometry
+        @id = id
         @properties = {}
-        properties_.each do |k_, v_|
-          @properties[k_.to_s] = v_
+        properties.each do |k, v|
+          @properties[k.to_s] = v
         end
       end
 
       def inspect # :nodoc:
-        "#<#{self.class}:0x#{object_id.to_s(16)} id=#{@id.inspect} geom=#{@geometry ? @geometry.as_text.inspect : 'nil'}>"
+        "#<#{self.class}:0x#{objectid.to_s(16)} id=#{@id.inspect} geom=#{@geometry ? @geometry.as_text.inspect : 'nil'}>"
       end
 
       def to_s  # :nodoc:
@@ -40,8 +40,8 @@ module RGeo
       # This method uses the eql? method to test geometry equality, which
       # may behave differently than the == operator.
 
-      def eql?(rhs_)
-        rhs_.kind_of?(Feature) && @geometry.eql?(rhs_.geometry) && @id.eql?(rhs_.feature_id) && @properties.eql?(rhs_.instance_variable_get(:@properties))
+      def eql?(other)
+        other.is_a?(Feature) && @geometry.eql?(other.geometry) && @id.eql?(other.feature_id) && @properties.eql?(other.instance_variable_get(:@properties))
       end
 
       # Two features are equal if their geometries, IDs, and properties
@@ -49,8 +49,8 @@ module RGeo
       # This method uses the == operator to test geometry equality, which
       # may behave differently than the eql? method.
 
-      def ==(rhs_)
-        rhs_.kind_of?(Feature) && @geometry == rhs_.geometry && @id == rhs_.feature_id && @properties == rhs_.instance_variable_get(:@properties)
+      def ==(other)
+        other.is_a?(Feature) && @geometry == other.geometry && @id == other.feature_id && @properties == other.instance_variable_get(:@properties)
       end
 
       # Returns the geometry contained in this feature, which may be nil.
@@ -72,8 +72,8 @@ module RGeo
       # Gets the value of the given named property.
       # Returns nil if the given property is not found.
 
-      def property(key_)
-        @properties[key_.to_s]
+      def property(key)
+        @properties[key.to_s]
       end
       alias_method :[], :property
 
@@ -95,14 +95,14 @@ module RGeo
     # between the GeoJSON engine and feature collections.
 
     class FeatureCollection
-      include ::Enumerable
+      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.is_a?(Feature) }
       end
 
       def inspect # :nodoc:
@@ -122,8 +122,8 @@ module RGeo
       # This methods uses the eql? method to test geometry equality, which
       # may behave differently than the == operator.
 
-      def eql?(rhs_)
-        rhs_.kind_of?(FeatureCollection) && @features.eql?(rhs_.instance_variable_get(:@features))
+      def eql?(other)
+        other.is_a?(FeatureCollection) && @features.eql?(other.instance_variable_get(:@features))
       end
 
       # Two feature collections are equal if they contain the same
@@ -131,14 +131,14 @@ module RGeo
       # This methods uses the == operator to test geometry equality, which
       # may behave differently than the eql? method.
 
-      def ==(rhs_)
-        rhs_.kind_of?(FeatureCollection) && @features == rhs_.instance_variable_get(:@features)
+      def ==(other)
+        other.is_a?(FeatureCollection) && @features == other.instance_variable_get(:@features)
       end
 
       # Iterates or returns an iterator for the features.
 
-      def each(&block_)
-        @features.each(&block_)
+      def each(&block)
+        @features.each(&block)
       end
 
       # Returns the number of features contained in this collection.
@@ -149,8 +149,8 @@ module RGeo
 
       # Access a feature by index.
 
-      def [](index_)
-        @features[index_]
+      def [](index)
+        @features[index]
       end
     end
 
@@ -163,55 +163,55 @@ module RGeo
       # properties hash. Note that, per the GeoJSON spec, geometry and/or
       # properties may be nil.
 
-      def feature(geometry_, id_ = nil, properties_ = nil)
-        Feature.new(geometry_, id_, properties_ || {})
+      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_ = [])
-        FeatureCollection.new(features_)
+      def feature_collection(features = [])
+        FeatureCollection.new(features)
       end
 
       # Returns true if the given object is a feature created by this
       # entity factory.
 
-      def is_feature?(object_)
-        object_.kind_of?(Feature)
+      def is_feature?(object)
+        object.is_a?(Feature)
       end
 
       # Returns true if the given object is a feature collection created
       # by this entity factory.
 
-      def is_feature_collection?(object_)
-        object_.kind_of?(FeatureCollection)
+      def is_feature_collection?(object)
+        object.is_a?(FeatureCollection)
       end
 
       # Run Enumerable#map on the features contained in the given feature
       # collection.
 
-      def map_feature_collection(object_, &block_)
-        object_.map(&block_)
+      def map_feature_collection(object, &block)
+        object.map(&block)
       end
 
       # Returns the geometry associated with the given feature.
 
-      def get_feature_geometry(object_)
-        object_.geometry
+      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
+      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.
 
-      def get_feature_properties(object_)
-        object_.properties
+      def get_feature_properties(object)
+        object.properties
       end
 
       # Return the singleton instance of EntityFactory.

data/lib/rgeo/geo_json/interface.rb

@@ -12,8 +12,8 @@ module RGeo
       # encode supports objects of type RGeo::GeoJSON::Feature and
       # RGeo::GeoJSON::FeatureCollection.
 
-      def encode(object_, opts_ = {})
-        Coder.new(opts_).encode(object_)
+      def encode(object, opts = {})
+        Coder.new(opts).encode(object)
       end
 
       # High-level convenience routine for decoding an object from GeoJSON.
@@ -43,8 +43,8 @@ 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_ = {})
-        Coder.new(opts_).decode(input_)
+      def decode(input_, opts = {})
+        Coder.new(opts).decode(input_)
       end
 
       # Creates and returns a coder object of type RGeo::GeoJSON::Coder
@@ -75,8 +75,8 @@ 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_ = {})
-        Coder.new(opts_)
+      def coder(opts = {})
+        Coder.new(opts)
       end
     end
   end

data/lib/rgeo/geo_json/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rgeo-geojson
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.4.0
 platform: ruby
 authors:
 - Daniel Azuma
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-23 00:00:00.000000000 Z
+date: 2015-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rgeo
@@ -80,7 +80,6 @@ files:
 - LICENSE.txt
 - README.md
 - lib/rgeo-geojson.rb
-- lib/rgeo/geo_json.rb
 - lib/rgeo/geo_json/coder.rb
 - lib/rgeo/geo_json/entities.rb
 - lib/rgeo/geo_json/interface.rb

data/lib/rgeo/geo_json.rb

@@ -1,20 +0,0 @@
-require "rgeo"
-
-# RGeo is a spatial data library for Ruby, provided by the "rgeo" gem.
-#
-# The optional RGeo::GeoJSON module provides a set of tools for GeoJSON
-# 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"