georuby 2.3.0 → 2.5.1

data/lib/geo_ruby/simple_features.rb

@@ -1,12 +1,9 @@
 module GeoRuby
   module SimpleFeatures
-
-    %w[
+    %w(
       geometry
       circle
       envelope
-      ewkb_parser
-      ewkt_parser
       geometry_collection
       geometry_factory
       helper
@@ -17,9 +14,8 @@ module GeoRuby
       multi_polygon
       point
       polygon
-    ].each do |rel_file|
+    ).each do |rel_file|
       require File.join(File.dirname(__FILE__), 'simple_features', rel_file)
     end
-
   end
 end

data/lib/geo_ruby/simple_features/circle.rb

@@ -1,9 +1,10 @@
 module GeoRuby
   module SimpleFeatures
-    #Represents a point. It is in 3D if the Z coordinate is not +nil+.
+    # Represents a point. It is in 3D if the Z coordinate is not +nil+.
     class Circle < Geometry
       attr_accessor :radius, :center
-      alias :r :radius
+      alias_method :r, :radius
+      alias_method :c, :center
 
       def initialize(srid = DEFAULT_SRID, with_z = false, with_m = false)
         super(srid, with_z, with_m)
@@ -14,26 +15,28 @@ module GeoRuby
          Point.from_x_y(@center.x + @r, @center.y + @r)]
       end
 
+      def diameter
+        radius * 2
+      end
+
       def m_range
-        raise NotImplementedError
+        fail NotImplementedError
       end
 
       def ==(other)
         return false unless other.is_a?(Circle)
-        @center == other.center and @radius == other.radius
+        @center == other.center && @radius == other.radius
       end
 
       def to_json(options = {})
-        {:type => 'Circle',
-         :coordinates => @center.to_coordinates,
-         :radius => @radius}.to_json(options)
+        { type: 'Circle',
+          coordinates: @center.to_coordinates,
+          radius: @radius }.to_json(options)
       end
-      alias :as_geojson :to_json
+      alias_method :as_geojson, :to_json
 
-      def contains_point?(point)
-        dist = Mongoid::Spacial.distance(@center.to_coordinates,
-                  point.to_coordinates, :spherical => true, :unit => :m)
-        dist <= @radius
+      def contains_point?(_point)
+        fail NotImplementedError
       end
 
       class << self
@@ -51,7 +54,6 @@ module GeoRuby
           circle
         end
       end
-
     end
   end
 end

data/lib/geo_ruby/simple_features/envelope.rb

@@ -1,95 +1,101 @@
 module GeoRuby
   module SimpleFeatures
-
-    #Contains the bounding box of a geometry
+    # Contains the bounding box of a geometry
     class Envelope
       attr_accessor :lower_corner, :upper_corner
       attr_accessor :srid, :with_z, :zoom
 
-      #Creates a enw Envelope with +lower_corner+ as the first element of the corners array and +upper_corner+ as the second element
+      # Creates a enw Envelope with +lower_corner+ as the first element
+      # of the corners array and +upper_corner+ as the second element
       def initialize(srid = DEFAULT_SRID, with_z = false)
         @srid = srid
         @with_z = with_z
       end
 
-      #Merges the argument with the current evelope
+      # Merges the argument with the current evelope
       def extend!(envelope)
-        lower_corner.x = [lower_corner.x,envelope.lower_corner.x].min
-        lower_corner.y = [lower_corner.y,envelope.lower_corner.y].min
-        upper_corner.x = [upper_corner.x,envelope.upper_corner.x].max
-        upper_corner.y = [upper_corner.y,envelope.upper_corner.y].max
+        lower_corner.x = [lower_corner.x, envelope.lower_corner.x].min
+        lower_corner.y = [lower_corner.y, envelope.lower_corner.y].min
+        upper_corner.x = [upper_corner.x, envelope.upper_corner.x].max
+        upper_corner.y = [upper_corner.y, envelope.upper_corner.y].max
         self
       end
 
-      #Merges the argument with the current evelope and sends back a new
-      #envelope without changing the current one
+      # Merges the argument with the current evelope and sends back a new
+      # envelope without changing the current one
       def extend(envelope)
-        e = Envelope.from_points([Point.from_x_y(lower_corner.x,lower_corner.y),
-                          Point.from_x_y(upper_corner.x,upper_corner.y)],srid,with_z)
+        e = Envelope.from_points([Point.from_x_y(lower_corner.x, lower_corner.y),
+                                  Point.from_x_y(upper_corner.x, upper_corner.y)], srid, with_z)
         e.extend!(envelope)
         e
       end
-#  def bounding_box(markers)
-#    max_lat, max_lon, min_lat, min_lon = -Float::MAX, -Float::MAX, Float::MAX, Float::MAX
-#    markers.each do |marker|
-#      coord = marker.point
-#      max_lat = coord.lat if coord.lat > max_lat
-#      min_lat = coord.lat if coord.lat < min_lat
-#      max_lon = coord.lng if coord.lng > max_lon
-#      min_lon = coord.lng if coord.lng < min_lon
-#    end
-#    min_point = Point.from_x_y(min_lat,min_lon)
-#    max_point = Point.from_x_y(max_lat,max_lon)
-
-#    end
-#    centrelat = (max_lat + min_lat)/2
-#    centrelng = (max_lon + min_lon)/2
-#    # logger.info("distance[#{distance}],zoom[#{zoom}]")
-#    #return GLatLngBounds.new(GLatLng.new(min_point),GLatLng.new(max_point)), [centrelat,centrelng], zoom
-#    return [centrelat,centrelng], zoom
-
-      #Sends back the center of the envelope
+
+      #  def bounding_box(markers)
+      #    max_lat, max_lon, min_lat, min_lon = -Float::MAX, -Float::MAX, Float::MAX, Float::MAX
+      #    markers.each do |marker|
+      #      coord = marker.point
+      #      max_lat = coord.lat if coord.lat > max_lat
+      #      min_lat = coord.lat if coord.lat < min_lat
+      #      max_lon = coord.lng if coord.lng > max_lon
+      #      min_lon = coord.lng if coord.lng < min_lon
+      #    end
+      #    min_point = Point.from_x_y(min_lat,min_lon)
+      #    max_point = Point.from_x_y(max_lat,max_lon)
+
+      #    end
+      #    centrelat = (max_lat + min_lat)/2
+      #    centrelng = (max_lon + min_lon)/2
+      #    # logger.info("distance[#{distance}],zoom[#{zoom}]")
+      #    #return GLatLngBounds.new(GLatLng.new(min_point),GLatLng.new(max_point)), [centrelat,centrelng], zoom
+      #    return [centrelat,centrelng], zoom
+
+      # Sends back the center of the envelope
       def center
-        Point.from_x_y((lower_corner.x + upper_corner.x)/2,(lower_corner.y + upper_corner.y)/2, srid)
+        Point.from_x_y((lower_corner.x + upper_corner.x) / 2, (lower_corner.y + upper_corner.y) / 2, srid)
       end
 
-      #Zoom level
+      # Zoom level
       def zoom
         distance = lower_corner.spherical_distance(upper_corner) / 10_000
         @zoom = case distance
-        when 150..9000  then 5
-        when 80..149    then 6
-        when 50..79     then 7
-        when 20..49     then 8
-        when 10..19     then 9
-        when 5..9       then 10
-        else 13
-        end
+                when 150..9000  then 5
+                when 80..149    then 6
+                when 50..79     then 7
+                when 20..49     then 8
+                when 10..19     then 9
+                when 5..9       then 10
+                else 13
+                end
       end
 
-      #Tests the equality of line strings
+      # Tests the equality of line strings
       def ==(other_envelope)
         if other_envelope.class != self.class
           false
         else
-          upper_corner == other_envelope.upper_corner and lower_corner == other_envelope.lower_corner
+          upper_corner == other_envelope.upper_corner && lower_corner == other_envelope.lower_corner
         end
       end
 
-      #georss serialization: Dialect can be passed as option <tt>:dialect</tt> and set to <tt>:simple</tt> (default)
-      #<tt>:w3cgeo</tt> or <tt>:gml</tt>. Options <tt>:featuretypetag
+      # georss serialization: Dialect can be passed as option <tt>:dialect</tt>
+      # and set to <tt>:simple</tt> (default) <tt>:w3cgeo</tt> or <tt>:gml</tt>.
+      # Options <tt>:featuretypetag
       def as_georss(options = {})
-        dialect= options[:dialect] || :simple
-        case(dialect)
+        dialect = options[:dialect] || :simple
+        case (dialect)
         when :simple
-          geom_attr = ""
-          geom_attr += " featuretypetag=\"#{options[:featuretypetag]}\"" if options[:featuretypetag]
-          geom_attr += " relationshiptag=\"#{options[:relationshiptag]}\"" if options[:relationshiptag]
+          geom_attr = ''
+          if options[:featuretypetag]
+            geom_attr += " featuretypetag=\"#{options[:featuretypetag]}\""
+          end
+          if options[:relationshiptag]
+            geom_attr += " relationshiptag=\"#{options[:relationshiptag]}\""
+          end
           geom_attr += " floor=\"#{options[:floor]}\"" if options[:floor]
           geom_attr += " radius=\"#{options[:radius]}\"" if options[:radius]
           geom_attr += " elev=\"#{options[:elev]}\"" if options[:elev]
 
-          georss_simple_representation(options.merge(:geom_attr => geom_attr))
+          georss_simple_representation(options.merge(geom_attr: geom_attr))
         when :w3cgeo
           georss_w3cgeo_representation(options)
         when :gml
@@ -97,41 +103,43 @@ module GeoRuby
         end
       end
 
-       #georss simple representation
+      # georss simple representation
       def georss_simple_representation(options = {}) #:nodoc:
-        georss_ns = options[:georss_ns] || "georss"
+        georss_ns = options[:georss_ns] || 'georss'
         geom_attr = options[:geom_attr]
         "<#{georss_ns}:box#{geom_attr}>#{lower_corner.y} #{lower_corner.x} #{upper_corner.y} #{upper_corner.x}</#{georss_ns}:box>\n"
       end
 
-      #georss w3c representation : outputs the first point of the line
+      # georss w3c representation : outputs the first point of the line
       def georss_w3cgeo_representation(options = {}) #:nodoc:
-        w3cgeo_ns = options[:w3cgeo_ns] || "geo"
-        point = self.center
+        w3cgeo_ns = options[:w3cgeo_ns] || 'geo'
+        point = center
         "<#{w3cgeo_ns}:lat>#{point.y}</#{w3cgeo_ns}:lat>\n<#{w3cgeo_ns}:long>#{point.x}</#{w3cgeo_ns}:long>\n"
       end
 
-      #georss gml representation
+      # georss gml representation
       def georss_gml_representation(options = {}) #:nodoc:
-        georss_ns = options[:georss_ns] || "georss"
-        gml_ns = options[:gml_ns] || "gml"
+        georss_ns = options[:georss_ns] || 'georss'
+        gml_ns = options[:gml_ns] || 'gml'
         result = "<#{georss_ns}:where>\n<#{gml_ns}:Envelope>\n"
-        result += "<#{gml_ns}:LowerCorner>" + "#{lower_corner.y} #{lower_corner.x}" + "</#{gml_ns}:LowerCorner>"
-        result += "<#{gml_ns}:UpperCorner>" + "#{upper_corner.y} #{upper_corner.x}" + "</#{gml_ns}:UpperCorner>"
-        result += "</#{gml_ns}:Envelope>\n</#{georss_ns}:where>\n"
+        result += "<#{gml_ns}:LowerCorner>#{lower_corner.y} #{lower_corner.x}"\
+                  "</#{gml_ns}:LowerCorner>"
+        result += "<#{gml_ns}:UpperCorner>#{upper_corner.y} #{upper_corner.x}"\
+                  "</#{gml_ns}:UpperCorner>"
+        result + "</#{gml_ns}:Envelope>\n</#{georss_ns}:where>\n"
       end
 
-      #Sends back a latlonaltbox
+      # Sends back a latlonaltbox
       def as_kml(options = {})
-        geom_data = ""
+        geom_data = ''
         geom_data = "<altitudeMode>#{options[:altitude_mode]}</altitudeMode>\n" if options[:altitude_mode]
 
-        allow_z = with_z && (!options[:altitude_mode].nil?) && options[:atitude_mode] != "clampToGround"
+        allow_z = with_z && (!options[:altitude_mode].nil?) && options[:atitude_mode] != 'clampToGround'
 
-        kml_representation(options.merge(:geom_data => geom_data,:allow_z => allow_z))
+        kml_representation(options.merge(geom_data: geom_data, allow_z: allow_z))
       end
 
-      def kml_representation(options = {})#:nodoc:
+      def kml_representation(options = {}) #:nodoc:
         result = "<LatLonAltBox>\n"
         result += options[:geom_data]
         result += "<north>#{upper_corner.y}</north>\n"
@@ -144,24 +152,23 @@ module GeoRuby
           result += "<maxAltitude>#{upper_corner.z}</maxAltitude>"
         end
 
-        result += "</LatLonAltBox>\n"
+        result + "</LatLonAltBox>\n"
       end
 
-      #Creates a new envelope. Accept an array of 2 points as argument
-      def self.from_points(points,srid=DEFAULT_SRID,with_z=false)
-        raise "Not an array" unless points.class == Array
-        e = Envelope.new(srid,with_z)
+      # Creates a new envelope. Accept an array of 2 points as argument
+      def self.from_points(points, srid = DEFAULT_SRID, with_z = false)
+        fail 'Not an array' unless points.class == Array
+        e = Envelope.new(srid, with_z)
         e.lower_corner, e.upper_corner = points
         e
       end
 
-      #Creates a new envelope. Accept a sequence of point coordinates as argument : ((x,y),(x,y))
+      # Creates a new envelope. Accept a sequence of point coordinates as argument : ((x,y),(x,y))
       def self.from_coordinates(points, srid = DEFAULT_SRID, with_z = false)
-        e = Envelope.new(srid,with_z)
-        e.lower_corner, e.upper_corner =  points.collect{|point_coords| Point.from_coordinates(point_coords,srid,with_z)}
+        e = Envelope.new(srid, with_z)
+        e.lower_corner, e.upper_corner =  points.collect { |point_coords| Point.from_coordinates(point_coords, srid, with_z) }
         e
       end
-
     end
   end
 end

data/lib/geo_ruby/simple_features/geometry.rb

@@ -1,32 +1,31 @@
-module GeoRuby#:nodoc:
+module GeoRuby #:nodoc:
   module SimpleFeatures
-
     # Default SRID
     DEFAULT_SRID = 4326 unless defined? DEFAULT_SRID
 
-    #Root of all geometric data classes.
-    #Objects of class Geometry should not be instantiated.
+    # Root of all geometric data classes.
+    # Objects of class Geometry should not be instantiated.
     class Geometry
-      #SRID of the geometry
-      attr_reader :srid #writer defined below
-      #Flag indicating if the z ordinate of the geometry is meaningful
+      # SRID of the geometry
+      attr_reader :srid # writer defined below
+      # Flag indicating if the z ordinate of the geometry is meaningful
       attr_accessor :with_z
-      alias :with_z? :with_z
-      #Flag indicating if the m ordinate of the geometry is meaningful
+      alias_method :with_z?, :with_z
+      # Flag indicating if the m ordinate of the geometry is meaningful
       attr_accessor :with_m
-      alias :with_m? :with_m
+      alias_method :with_m?, :with_m
 
-      def initialize(srid=DEFAULT_SRID, with_z=false, with_m=false)
-        @srid=srid
-        @with_z=with_z
-        @with_m=with_m
+      def initialize(srid = DEFAULT_SRID, with_z = false, with_m = false)
+        @srid = srid
+        @with_z = with_z
+        @with_m = with_m
       end
 
       def srid=(new_srid)
         @srid = new_srid
         unless self.is_a?(Point)
-          self.each do |geom|
-            geom.srid=new_srid
+          each do |geom|
+            geom.srid = new_srid
           end
         end
       end
@@ -43,30 +42,30 @@ module GeoRuby#:nodoc:
       # Returns an Envelope object for the geometry
       #
       def envelope
-        Envelope.from_points(bounding_box, srid,with_z)
+        Envelope.from_points(bounding_box, srid, with_z)
       end
 
       #
       # Outputs the geometry as an EWKB string.
       #
       # The +allow_srid+, +allow_z+ and +allow_m+ arguments allow the output
-      # to include srid, z and m respectively if they are present in the geometry.
+      # to include srid, z and m respectively if they are present.
       # If these arguments are set to false, srid, z and m are not included,
       # even if they are present in the geometry.
       # By default, the output string contains all the information in the object.
       #
-      def as_ewkb(allow_srid=true, allow_z=true, allow_m=true)
-        ewkb = 1.chr #little_endian by default
+      def as_ewkb(allow_srid = true, allow_z = true, allow_m = true)
+        ewkb = 1.chr # little_endian by default
 
         type = binary_geometry_type
-        type = type | Z_MASK if @with_z and allow_z
-        type = type | M_MASK if @with_m and allow_m
+        type |= Z_MASK if @with_z && allow_z
+        type |= M_MASK if @with_m && allow_m
 
         if allow_srid
           type = type | SRID_MASK
-          ewkb << [type, @srid].pack("VV")
+          ewkb << [type, @srid].pack('VV')
         else
-          ewkb << [type].pack("V")
+          ewkb << [type].pack('V')
         end
 
         ewkb  << binary_representation(allow_z, allow_m)
@@ -82,9 +81,9 @@ module GeoRuby#:nodoc:
       #
       # Outputs the geometry as a HexEWKB string.
       # It is almost the same as a WKB string, except that each byte of a WKB
-      # string is replaced by its hexadecimal 2-character representation in a HexEWKB string.
+      # string is replaced by its hex 2-char representation in a HexEWKB string.
       #
-      def as_hex_ewkb(allow_srid=true, allow_z=true, allow_m=true)
+      def as_hex_ewkb(allow_srid = true, allow_z = true, allow_m = true)
         as_ewkb(allow_srid, allow_z, allow_m).unpack('H*').join('').upcase
       end
 
@@ -92,21 +91,22 @@ module GeoRuby#:nodoc:
       # Outputs the geometry as a strict HexWKB string
       #
       def as_hex_wkb
-        as_hex_ewkb(false,false,false)
+        as_hex_ewkb(false, false, false)
       end
 
       #
       # Outputs the geometry as an EWKT string.
       #
-      def as_ewkt(allow_srid=true,allow_z=true,allow_m=true)
+      def as_ewkt(allow_srid = true, allow_z = true, allow_m = true)
         if allow_srid
-          ewkt="SRID=#{@srid};"
+          ewkt = "SRID=#{@srid};"
         else
-          ewkt=""
+          ewkt = ''
         end
         ewkt << text_geometry_type
-        ewkt << "M" if @with_m and allow_m and (!@with_z or !allow_z) #to distinguish the M from the Z when there is actually no Z...
-        ewkt << "(" << text_representation(allow_z,allow_m) << ")"
+        # to distinguish the M from the Z when there is actually no Z...
+        ewkt << 'M' if @with_m && allow_m && (!@with_z || !allow_z)
+        ewkt << '(' << text_representation(allow_z, allow_m) << ')'
       end
 
       #
@@ -118,18 +118,23 @@ module GeoRuby#:nodoc:
 
       # Outputs the geometry in georss format.
       # Assumes the geometries are in latlon format, with x as lon and y as lat.
-      # Pass the <tt>:dialect</tt> option to swhit format. Possible values are: <tt>:simple</tt> (default), <tt>:w3cgeo</tt> and <tt>:gml</tt>.
+      # Pass the <tt>:dialect</tt> option to swhit format. Possible values are:
+      # <tt>:simple</tt> (default), <tt>:w3cgeo</tt> and <tt>:gml</tt>.
       def as_georss(options = {})
-        dialect= options[:dialect] || :simple
-        case(dialect)
+        dialect = options[:dialect] || :simple
+        case (dialect)
         when :simple
-          geom_attr = ""
-          geom_attr += " featuretypetag=\"#{options[:featuretypetag]}\"" if options[:featuretypetag]
-          geom_attr += " relationshiptag=\"#{options[:relationshiptag]}\"" if options[:relationshiptag]
+          geom_attr = ''
+          if options[:featuretypetag]
+            geom_attr += " featuretypetag=\"#{options[:featuretypetag]}\""
+          end
+          if options[:relationshiptag]
+            geom_attr += " relationshiptag=\"#{options[:relationshiptag]}\""
+          end
           geom_attr += " floor=\"#{options[:floor]}\"" if options[:floor]
           geom_attr += " radius=\"#{options[:radius]}\"" if options[:radius]
           geom_attr += " elev=\"#{options[:elev]}\"" if options[:elev]
-          georss_simple_representation(options.merge(:geom_attr => geom_attr))
+          georss_simple_representation(options.merge(geom_attr: geom_attr))
         when :w3cgeo
           georss_w3cgeo_representation(options)
         when :gml
@@ -137,22 +142,32 @@ module GeoRuby#:nodoc:
         end
       end
 
-      # Iutputs the geometry in kml format : options are <tt>:id</tt>, <tt>:tesselate</tt>, <tt>:extrude</tt>,
-      # <tt>:altitude_mode</tt>. If the altitude_mode option is not present, the Z (if present) will not be output (since
-      # it won't be used by GE anyway: clampToGround is the default)
+      # Iutputs the geometry in kml format : options are <tt>:id</tt>,
+      # <tt>:tesselate</tt>, <tt>:extrude</tt>, <tt>:altitude_mode</tt>.
+      # If the altitude_mode option is not present, the Z (if present) will not
+      # be output (since it won't be used by GE: clampToGround is the default)
       def as_kml(options = {})
-        id_attr = ""
+        id_attr = ''
         id_attr = " id=\"#{options[:id]}\"" if options[:id]
 
-        geom_data = ""
-        geom_data += "<extrude>#{options[:extrude]}</extrude>\n" if options[:extrude]
-        geom_data += "<tesselate>#{options[:tesselate]}</tesselate>\n" if options[:tesselate]
-        geom_data += "<altitudeMode>#{options[:altitude_mode]}</altitudeMode>\n" if options[:altitude_mode]
+        geom_data = ''
+        if options[:extrude]
+          geom_data += "<extrude>#{options[:extrude]}</extrude>\n"
+        end
+        if options[:tesselate]
+          geom_data += "<tesselate>#{options[:tesselate]}</tesselate>\n"
+        end
+        if options[:altitude_mode]
+          geom_data += "<altitudeMode>#{options[:altitude_mode]}</altitudeMode>\n"
+        end
 
-        allow_z = (with_z || !options[:altitude].nil? )&& (!options[:altitude_mode].nil?) && options[:atitude_mode] != "clampToGround"
+        allow_z = (with_z || !options[:altitude].nil?) &&
+                  (!options[:altitude_mode].nil?) &&
+                  options[:atitude_mode] != 'clampToGround'
         fixed_z = options[:altitude]
 
-        kml_representation(options.merge(:id_attr => id_attr, :geom_data => geom_data, :allow_z => allow_z, :fixed_z => fixed_z))
+        kml_representation(options.merge(id_attr: id_attr, geom_data: geom_data,
+                                         allow_z: allow_z, fixed_z: fixed_z))
       end
 
       # simple geojson representation
@@ -161,50 +176,55 @@ module GeoRuby#:nodoc:
         as_json(options).to_json(options)
       end
 
-      def as_json(options = {})
+      def as_json(_options = {})
         # Implemented by each class
       end
-      alias :as_geojson :as_json
+      alias_method :as_geojson, :as_json
 
-      # Creates a geometry based on a EWKB string. The actual class returned depends of the content of the string passed as argument. Since WKB strings are a subset of EWKB, they are also valid.
+      # Creates a geometry based on a EWKB string. The actual class returned
+      # depends of the content of the string passed as argument.
+      # Since WKB strings are a subset of EWKB, they are also valid.
       def self.from_ewkb(ewkb)
-        factory = GeometryFactory::new
-        ewkb_parser = EWKBParser::new(factory)
+        factory = GeometryFactory.new
+        ewkb_parser = EWKBParser.new(factory)
         ewkb_parser.parse(ewkb)
         factory.geometry
       end
 
       # Creates a geometry based on a HexEWKB string given.
       def self.from_hex_ewkb(hexewkb)
-        factory = GeometryFactory::new
-        hexewkb_parser = HexEWKBParser::new(factory)
+        factory = GeometryFactory.new
+        hexewkb_parser = HexEWKBParser.new(factory)
         hexewkb_parser.parse(hexewkb)
         factory.geometry
       end
 
-      # Creates a geometry based on a EWKT string. Since WKT strings are a subset of EWKT, they are also valid.
+      # Creates a geometry based on a EWKT string. Since WKT strings are a
+      # subset of EWKT, they are also valid.
       def self.from_ewkt(ewkt)
-        factory = GeometryFactory::new
-        ewkt_parser= EWKTParser::new(factory)
+        factory = GeometryFactory.new
+        ewkt_parser = EWKTParser.new(factory)
         ewkt_parser.parse(ewkt)
         factory.geometry
       end
 
       # Creates a geometry based on the GeoRSS string given.
       def self.from_georss(georss)
-        georss_parser= GeorssParser::new
+        georss_parser = GeorssParser.new
         georss_parser.parse(georss)
         georss_parser.geometry
       end
 
-      # sends back an array: The first element is the goemetry based on the GeoRSS string passed as argument. The second one is the GeoRSSTags (found only with the Simple format)
+      # sends back an array: The first element is the goemetry based on the
+      # GeoRSS string passed as argument. The second one is the GeoRSSTags
+      # (found only with the Simple format)
       def self.from_georss_with_tags(georss)
-        georss_parser= GeorssParser::new
-        georss_parser.parse(georss,true)
+        georss_parser = GeorssParser.new
+        georss_parser.parse(georss, true)
         [georss_parser.geometry, georss_parser.georss_tags]
       end
 
-      #Sends back a geometry from a KML encoded geometry string.
+      # Sends back a geometry from a KML encoded geometry string.
       def self.from_kml(kml)
         factory = GeometryFactory.new
         parser = KmlParser.new(factory)
@@ -213,8 +233,8 @@ module GeoRuby#:nodoc:
 
       # Some GeoJSON files do not include srid info, so
       # we provide an optional parameter
-      def self.from_geojson(geojson, srid=DEFAULT_SRID)
-        geojson_parser= GeojsonParser::new
+      def self.from_geojson(geojson, srid = DEFAULT_SRID)
+        geojson_parser = GeoJSONParser.new
         geojson_parser.parse(geojson, srid)
         geojson_parser.geometry
       end
@@ -222,9 +242,9 @@ module GeoRuby#:nodoc:
       private
 
       def self.split_coords(coords)
-        coords.split(" ").collect { |coord|
-          coord.gsub(","," ")
-        }
+        coords.split(' ').collect do |coord|
+          coord.gsub(',', ' ')
+        end
       end
     end
   end