georss4rb 0.0.2 → 0.1.1

data/README

@@ -4,14 +4,13 @@ GeoRSS4rb is an addon to the FeedTools library that aims at making GeoRSS inform
 ==Installing
 Just type under a command line:
 	gem install georss4rb
-And the last version will be automatically downloaded and installed, along with the latest version of FeedTools, if you don't already have it.
+And the last version will be automatically downloaded and installed, along with the latest version of FeedTools, if you don't already have it, as well as GeoReuby (which is used for the actual GeoRSS parsing).
 
 ==Operations
-Now you have a +location+ method on <tt>FeedTools::Feed</tt> and <tt>FeedTools::Item</tt> objects, that will return either +nil+, if no location exists, or an object of a subclass of <tt>GeoRss4rb::Geometry</tt>, if a location exists. The subclass can be one of four types:
-- <tt>GeoRss4rb::Point</tt>: With 2 properties, +lat+ and +lon+
-- <tt>GeoRss4rb::Line</tt>: Behaves like an array of points
-- <tt>GeoRss4rb::Polygon</tt>: Behaves like an array of lines (although the GeoRss spec version 1 allows only the exterior ring to be defined)
-- <tt>GeoRss4rb::Box</tt>: Holds 2 corner points, +lower_corner+ and +upper_corner+
+Now you have a +location+ method on <tt>FeedTools::Feed</tt> and <tt>FeedTools::Item</tt> objects, that will return either +nil+, if no location exists, or an object of a subclass of <tt>GeoRuby::SimpleFeatures::Geometry</tt> or of <tt>GeoRuby::SimpleFeatures::Envelope</tt>, if a location exists. The subclass can be one of four types:
+- <tt>Point</tt>: With 2 properties, +lat+ and +lon+
+- <tt>LineString</tt>: Behaves like an array of points
+- <tt>Polygon</tt>: Behaves like an array of lines (although the GeoRss spec version 1 allows only the exterior ring to be defined)
 
 Here is an example of usage:
 	feed = FeedTools::Feed.open('http://example.org/georss')
@@ -20,8 +19,10 @@ Here is an example of usage:
 	feed.items.first.location #=><GeoRss4rb::Point ...>
 The location of the entire feed could be a bounding of the location of the items. Then each item can have a location item, here a point. Note that the specific GeoRSS dialect used does not make any difference in the object returned.
 
+It is also possible to retrieve the GeoRss tags (such as +radius+ or +featuretypetag+, if present : Use the <tt>georss_tags</tt> property on either a +Feed+ or +FeedItem+ object. It will return an instance of <tt>GeoRuby::SimpleFeatures::GeoRssTags</tt>.
+
 ==Changes since last version
-- First release
+- Switch to using the GeoRSS parsing features of GeoRuby
 
 ==TODO
 - Add support for other RSS parsing libraries

data/lib/georss4rb.rb

@@ -1,268 +1,61 @@
+require 'rubygems'
 require 'feed_tools'
+require 'geo_ruby'
 
-module GeoRss4rb
+module Georss4rb
   module Location
-    #Returns a GeoRss4rb::Geometry object if info about the location is found.
+    #Returns a Georss4rb::Geometry object if info about the location is found.
     #Returns +nil+ if no location info is found.
     def location
-      if @location.nil?
+      if !located?
+        get_location_info
+      end
+      @location
+    end
+
+    def georss_tags
+      if !located?
+        get_location_info
+      end
+      @georss_tags
+    end
+    
+    #True if the feed or the item has some location info
+    def located?
+      !@location.nil?
+    end
+
+    private
+    
+    def get_location_info
+      begin
         #try all the georss dialects, according to uri
         #first the simple W3C geo
         if w3cgeo = find_node("*[namespace-uri()='http://www.w3.org/2003/01/geo/wgs84_pos#']")
           #get the lat and long
           #either inside a Point element or by themselves
           if w3cgeo.local_name == "Point"
-            lat = w3cgeo.elements["*[local-name()='lat']"]
-            lon = w3cgeo.elements["*[local-name()='long']"]
+            to_parse = w3cgeo.to_s
           else
             if w3cgeo.local_name == "lat"
-              lat = w3cgeo.text.to_f
-              lon = find_node("*[namespace-uri()='http://www.w3.org/2003/01/geo/wgs84_pos#' and local-name()='long']").text.to_f
+              lon = find_node("*[namespace-uri()='http://www.w3.org/2003/01/geo/wgs84_pos#' and local-name()='long']")
+              to_parse = w3cgeo.to_s + lon.to_s if lon
             elsif w3cgeo.local_name == "long"
-              lon = w3cgeo.text.to_f
-              lat = find_node("*[namespace-uri()='http://www.w3.org/2003/01/geo/wgs84_pos#' and local-name()='lat']").text.to_f
+              lat = find_node("*[namespace-uri()='http://www.w3.org/2003/01/geo/wgs84_pos#' and local-name()='lat']")
+              to_parse = w3cgeo.to_s + lat.to_s if lat
             end
           end
-          if lat and lon
-            @location = GeoRss4rb::Point.new(lat,lon)
-          end
+          @location, @georss_tags = GeoRuby::SimpleFeatures::Geometry.from_georss_with_tags(to_parse) if to_parse
         elsif gml = find_node("*[namespace-uri()='http://www.georss.org/georss' and local-name()='where']")
-          #the meat!!
-          case gml.elements["*"].local_name 
-          when "Point"
-            @location = GeoRss4rb::Point.from_gml(gml)
-          when "LineString"
-            @location = GeoRss4rb::Line.from_gml(gml)
-          when "Polygon"
-            @location = GeoRss4rb::Polygon.from_gml(gml)
-          when "Envelope"
-            @location = GeoRss4rb::Box.from_gml(gml)
-          end
-        elsif simple = find_node("*[namespace-uri()='http://www.georss.org/georss']")
-          #not a gml: simple
-          content = simple.text
-          options = {:feature_type_tag => simple.attributes["featuretypetag"], :relationship_tag => simple.attributes["relationshiptag"], :elevation => GeoRss4rb.try_f(simple.attributes["elev"]), :floor => GeoRss4rb.try_i(simple.attributes["floor"]), :radius => GeoRss4rb.try_f(simple.attributes["radius"])}
-          case simple.local_name
-          when 'point'
-            @location = GeoRss4rb::Point.from_text(content,options)
-          when 'line'
-            @location = GeoRss4rb::Line.from_text(content,options)
-          when 'polygon' 
-            @location = GeoRss4rb::Polygon.from_text(content,options)
-          when 'box' 
-            @location = GeoRss4rb::Box.from_text(content,options)
-          end
-        end
-      end
-      return @location
-    end
-    
-    #True if the feed or the item has some location info
-    def located?
-      location != nil #retrieve location info if not already there
-    end
-  end
-
-  class Geometry
-    attr_accessor :feature_type_tag, :relationship_tag, :elevation, :floor, :radius
-    def initialize(options = {})
-      @feature_type_tag = options[:feature_type_tag] || "location"
-      @relationship_tag = options[:relationship_tag] || "is-located_at"
-      @elevation = options[:elevation]
-      @floor = options[:floor]
-      @radius = options[:radius]
-    end
-    def to_s
-      inspect
-    end
-  end
-  
-  class Point < GeoRss4rb::Geometry
-    attr_accessor :lat,:lon
-    def initialize(lat,lon,options = {})
-      super(options)
-      @lat = lat
-      @lon = lon
-    end
-    
-    def ==(point)
-      if point.class != GeoRss4rb::Point
-        false
-      else
-        @lat = point.lat and @lon = point.lon
-      end
-    end
-    
-    def self.from_array(array,options = {})
-      GeoRss4rb::Point.new(array[0],array[1],options)
-    end
-
-    def self.from_text(text,options = {})
-      array = GeoRss4rb::parse_text(text)
-      return nil if array.length != 2
-      self.from_array(array,options)
-    end
-
-    def self.from_gml(gml)
-      pos = gml.elements[".//*[local-name()='pos']"]
-      if pos.nil?
-        nil
-      else
-        self.from_text(pos.text)
-      end
-    end
-  end
-
-  class Line < GeoRss4rb::Geometry
-    attr_reader :points
-    def initialize(points,options = {})
-      super(options)
-      @points = points
-    end
-    
-    #Makes the line behave as an array of points
-    def method_missing(method_name,*args,&b)
-      @points.send(method_name,*args,&b)
-    end
-
-    def ==(line)
-      if line.class != GeoRss4rb::Line or
-          line.length != self.length
-        false
-      else
-        index = 0
-        while index < length
-          return false if self[index] != line[index]
-          index+=1
-        end
-        true
-      end
-    end
-    
-    def self.from_array(array,options = {})
-      points = []
-      0.upto(array.length / 2 - 1) do |pos|
-        points << GeoRss4rb::Point.from_array(array[pos * 2,2])
-      end
-      GeoRss4rb::Line.new(points,options)
-    end
-    
-    def self.from_text(text,options = {})
-      array = GeoRss4rb::parse_text(text)
-      return nil if array.length % 2 != 0 or array.length < 4 # 2 points minimum
-      self.from_array(array,options)
-    end
-    
-    def self.from_gml(gml)
-      pos_list = gml.elements[".//*[local-name()='posList']"]
-      if pos_list.nil?
-        nil
-      else
-        self.from_text(pos_list.text)
-      end
-    end
-  end
-
-  class Polygon < GeoRss4rb::Geometry
-    attr_reader :rings
-    def initialize(rings,options)
-      super(options)
-      @rings = rings
-    end
-
-    #Makes the Polygon behave as an array of rings/lines
-    def method_missing(method_name,*args,&b)
-      @rings.send(method_name,*args,&b)
-    end
-    
-    def ==(polygon)
-      if polygon.class != GeoRss4rb::Polygon or
-          polygon.length != self.length
-        false
-      else
-        index = 0
-        while index < length
-          return false if self[index] != polygon[index]
-          index+=1
+          @location, @georss_tags = GeoRuby::SimpleFeatures::Geometry.from_georss_with_tags(gml.to_s)
+        elsif simple = find_node("*[namespace-uri()='http://www.georss.org/georss']") #not a gml : it is a simple
+          @location, @georss_tags = GeoRuby::SimpleFeatures::Geometry.from_georss_with_tags(simple.to_s)
         end
-        true
       end
-    end
-    
-    def self.from_text(text,options = {})
-      array = GeoRss4rb::parse_text(text)
-      return nil if array.length % 2 != 0 or array.length < 8 # 4 points minimum
-      rings = [GeoRss4rb::Line.from_array(array)] #exterior only
-      GeoRss4rb::Polygon.new(rings,options)
-    end
-    def self.from_gml(gml)
-      pos_list = gml.elements[".//*[local-name()='posList']"]
-      if pos_list.nil?
-        nil
-      else
-        self.from_text(pos_list.text)
-      end
-    end
-  end
-
-  class Box < GeoRss4rb::Geometry
-    attr_reader :lower_corner,:upper_corner
-    def initialize(lower_corner,upper_corner,options = {})
-      super(options)
-      @lower_corner = lower_corner
-      @upper_corner = upper_corner
-    end
-    def ==(box)
-      if box.class != GeoRss4rb::Box
-        false
-      else
-        @lower_corner == box.lower_corner and @upper_corner == box.upper_corner
-      end
-    end
-    def self.from_text(text,options = {})
-      array = GeoRss4rb::parse_text(text)
-      return nil if array.length != 4
-      lower_corner = GeoRss4rb::Point.from_array(array[0,2])
-      upper_corner = GeoRss4rb::Point.from_array(array[2,2])
-      GeoRss4rb::Box.new(lower_corner,upper_corner,options)
-    end
-    def self.from_gml(gml)
-      lower_corner = gml.elements[".//*[local-name()='lowerCorner']"]
-      upper_corner = gml.elements[".//*[local-name()='upperCorner']"]
-      if lower_corner and upper_corner
-        self.from_text(lower_corner.text + " " + upper_corner.text) #the lazy solution
-      end
-    end
-  end
- 
-  
-  def self.parse_text(expr)#:nodoc:
-    expr.scan(/-?(?:\.\d+|\d+(?:\.\d*)?)/).map {|str| str.to_f}
-  end
-  
-  
-  def self.try_f(expr)#:nodoc:
-    if expr.nil?
-      nil
-    else
-      expr.to_f
-    end
-  end
-  
- 
-  def self.try_i(expr) #:nodoc:
-    if expr.nil?
-      nil
-    else
-      expr.to_f.to_i #to_f does not throw exceptions...
+    rescue
     end
   end
 end
 
-FeedTools::FeedItem.class_eval do
-  include GeoRss4rb::Location
-end
-
-FeedTools::Feed.class_eval do
-  include GeoRss4rb::Location
-end
+FeedTools::FeedItem.class_eval { include Georss4rb::Location }
+FeedTools::Feed.class_eval { include Georss4rb::Location }

data/lib/save_georss4rb.rb

@@ -0,0 +1,199 @@
+require 'rubygems'
+require 'feed_tools'
+require 'geo_ruby'
+
+module GeoRss4rb
+  module Location
+    #Returns a GeoRss4rb::Geometry object if info about the location is found.
+    #Returns +nil+ if no location info is found.
+    def location
+      if @location.nil?
+        #try all the georss dialects, according to uri
+        #first the simple W3C geo
+        if w3cgeo = find_node("*[namespace-uri()='http://www.w3.org/2003/01/geo/wgs84_pos#']")
+          #get the lat and long
+          #either inside a Point element or by themselves
+          if w3cgeo.local_name == "Point"
+            lat = w3cgeo.elements["*[local-name()='lat']"]
+            lon = w3cgeo.elements["*[local-name()='long']"]
+          else
+            if w3cgeo.local_name == "lat"
+              lat = w3cgeo.text.to_f
+              lon = find_node("*[namespace-uri()='http://www.w3.org/2003/01/geo/wgs84_pos#' and local-name()='long']").text.to_f
+            elsif w3cgeo.local_name == "long"
+              lon = w3cgeo.text.to_f
+              lat = find_node("*[namespace-uri()='http://www.w3.org/2003/01/geo/wgs84_pos#' and local-name()='lat']").text.to_f
+            end
+          end
+          if lat and lon
+            @location = GeoRuby::SimpleFeatures::Point.from_lon_lat(lon,lat)
+          end
+        elsif gml = find_node("*[namespace-uri()='http://www.georss.org/georss' and local-name()='where']")
+          #the meat!!
+          case gml.elements["*"].local_name 
+          when "Point"
+            @location = GeoRss4rb::PointParser.from_gml(gml)
+          when "LineString"
+            @location = GeoRss4rb::LineParser.from_gml(gml)
+          when "Polygon"
+            @location = GeoRss4rb::PolygonParser.from_gml(gml)
+          when "Envelope"
+            @location = GeoRss4rb::BoxParser.from_gml(gml)
+          end
+        elsif simple = find_node("*[namespace-uri()='http://www.georss.org/georss']")
+          #not a gml: simple
+          content = simple.text
+          options = {:feature_type_tag => simple.attributes["featuretypetag"], :relationship_tag => simple.attributes["relationshiptag"], :elevation => GeoRss4rb.try_f(simple.attributes["elev"]), :floor => GeoRss4rb.try_i(simple.attributes["floor"]), :radius => GeoRss4rb.try_f(simple.attributes["radius"])}
+          case simple.local_name
+          when 'point'
+            @location = GeoRss4rb::PointParser.from_text(content,options)
+          when 'line'
+            @location = GeoRss4rb::LineParser.from_text(content,options)
+          when 'polygon' 
+            @location = GeoRss4rb::PolygonParser.from_text(content,options)
+          when 'box' 
+            @location = GeoRss4rb::BoxParser.from_text(content,options)
+          end
+        end
+      end
+      return @location
+    end
+    
+    #True if the feed or the item has some location info
+    def located?
+      location != nil #retrieve location info if not already there
+    end
+  end
+
+  module GeoRssAttributes
+    attr_accessor :feature_type_tag, :relationship_tag, :elevation, :floor, :radius
+    def add_georss_attributes(options = {})
+      @feature_type_tag = options[:feature_type_tag] || "location"
+      @relationship_tag = options[:relationship_tag] || "is-located_at"
+      @elevation = options[:elevation]
+      @floor = options[:floor]
+      @radius = options[:radius]
+      self
+    end
+  end
+  
+  module PointParser #:nodoc: 
+    def self.from_array(array,options = {})
+      GeoRuby::SimpleFeatures::Point.from_lon_lat(array[1],array[0]).add_georss_attributes(options)
+    end
+
+    def self.from_text(text,options = {})
+      array = GeoRss4rb::parse_text(text)
+      return nil if array.length != 2
+      self.from_array(array,options)
+    end
+
+    def self.from_gml(gml)
+      pos = gml.elements[".//*[local-name()='pos']"]
+      if pos.nil?
+        nil
+      else
+        self.from_text(pos.text)
+      end
+    end
+  end
+
+  module LineParser #:nodoc: 
+    def self.from_array(array,options = {})
+      points = []
+      0.upto(array.length / 2 - 1) do |pos|
+        points << GeoRss4b:PointParser.from_array(array[pos * 2,2])
+      end
+      GeoRuby::SimpleFeatures::LineString.from_points(points).add_georss_attributes(options)
+    end
+    
+    def self.from_text(text,options = {})
+      array = GeoRss4rb::parse_text(text)
+      return nil if array.length % 2 != 0 or array.length < 4 # 2 points minimum
+      self.from_array(array,options)
+    end
+    
+    def self.from_gml(gml)
+      pos_list = gml.elements[".//*[local-name()='posList']"]
+      if pos_list.nil?
+        nil
+      else
+        self.from_text(pos_list.text)
+      end
+    end
+  end
+
+  module PolygonParser #:nodoc: 
+    #bof...
+    def self.linear_ring_from_array(array)
+      points = []
+      0.upto(array.length / 2 - 1) do |pos|
+        points << GeoRss4b:PointParser.from_array(array[pos * 2,2])
+      end
+      GeoRuby::SimpleFeatures::LinearRing.from_points(points)
+    end
+
+    def self.from_text(text,options = {})
+      array = GeoRss4rb::parse_text(text)
+      return nil if array.length % 2 != 0 or array.length < 8 # 4 points minimum
+      rings = [self.linear_ring_from_array(array)] #exterior only
+      GeoRruby::SimpleFeatures::Polygon.from_linear_rings(rings).add_georss_attributes(options)
+    end
+    
+    def self.from_gml(gml)
+      pos_list = gml.elements[".//*[local-name()='posList']"]
+      if pos_list.nil?
+        nil
+      else
+        self.from_text(pos_list.text)
+      end
+    end
+  end
+
+  module BoxParser #:nodoc:
+    def self.from_text(text,options = {})
+      array = GeoRss4rb::parse_text(text)
+      return nil if array.length != 4
+      lower_corner = GeoRss4rb::PointParser.from_array(array[0,2])
+      upper_corner = GeoRss4rb::PointParser.from_array(array[2,2])
+      GeoRuby::SimpleFeatures::Envelope.from_points([lower_corner,upper_corner]).add_georss_attributes(options)
+    end
+    def self.from_gml(gml)
+      lower_corner = gml.elements[".//*[local-name()='lowerCorner']"]
+      upper_corner = gml.elements[".//*[local-name()='upperCorner']"]
+      if lower_corner and upper_corner
+        self.from_text(lower_corner.text + " " + upper_corner.text) #the lazy solution
+      end
+    end
+  end
+  
+  
+  def self.parse_text(expr)#:nodoc:
+    expr.scan(/-?(?:\.\d+|\d+(?:\.\d*)?)/).map {|str| str.to_f}
+  end
+  
+  
+  def self.try_f(expr)#:nodoc:
+    if expr.nil?
+      nil
+    else
+      expr.to_f
+    end
+  end
+  
+ 
+  def self.try_i(expr) #:nodoc:
+    if expr.nil?
+      nil
+    else
+      expr.to_f.to_i #to_f does not throw exceptions...
+    end
+  end
+end
+
+FeedTools::FeedItem.include(GeoRss4rb::Location)
+FeedTools::Feed.include(GeoRss4rb::Location)
+GeoRuby::SimpleFeatures::Geometry.include(GeoRss4rb::GeoRssAttributes)
+GeoRuby::SimpleFeatures::Envelope.include(GeoRss4rb::GeoRssAttributes)
+
+

data/rakefile.rb

@@ -24,9 +24,10 @@ spec = Gem::Specification::new do |s|
   s.platform = Gem::Platform::RUBY
   
   s.add_dependency('feedtools', '>= 0.2.26') #others should be ok though...
- 
+  s.add_dependency('GeoRuby', '>= 1.0.0')
+
   s.name = 'georss4rb'
-  s.version = "0.0.2"
+  s.version = "0.1.1"
   s.summary = "Adds support for all GeoRSS dialects in FeedTools"
   s.description = "Adds support for all GeoRSS dialects in FeedTools"
   

data/test/test_georss.rb

@@ -1,66 +1,40 @@
 $:.unshift(File.dirname(__FILE__) + '/../lib')
+$:.unshift(File.dirname(__FILE__) + '/../../GeoRuby/lib')
 require 'georss4rb'
 require 'test/unit'
 
-include GeoRss4rb
-
 class TestGeorss < Test::Unit::TestCase
-  def test_parse_float_list
-    arr = GeoRss4rb::parse_text("456.3")
-    assert_equal(1,arr.length)
-    assert_equal(456.3,arr[0])
-
-    arr = GeoRss4rb::parse_text("456")
-    assert_equal(1,arr.length)
-    assert_equal(456,arr[0])
-    
-    arr = GeoRss4rb::parse_text(".456")
-    assert_equal(1,arr.length)
-    assert_equal(0.456,arr[0])
-
-    arr = GeoRss4rb::parse_text("456;123; .444 23.44\t56")
-    assert_equal(5,arr.length)
-    assert_equal([456,123,0.444,23.44,56],arr)
-
-    arr = GeoRss4rb::parse_text("456.567 123 .444 23.44 56")
-    assert_equal(5,arr.length)
-    assert_equal([456.567,123,0.444,23.44,56],arr)
-    
-    arr = GeoRss4rb::parse_text("456.567,123 23.44,56")
-    assert_equal(4,arr.length)
-    assert_equal([456.567,123,23.44,56],arr)
-  end
-
+  
   def test_w3cgeo
     #atom
     w3cgeo = FeedTools::Feed.open("file://#{File.dirname(__FILE__)}/atom_w3cgeo.xml")
     assert(w3cgeo.respond_to?(:location))
     assert(!w3cgeo.location.nil?)
     assert(w3cgeo.located?)
-    assert(GeoRss4rb::Point,w3cgeo.location.class)
-    assert_equal(GeoRss4rb::Point.new(26.58,-97.83),w3cgeo.location)
+    assert(GeoRuby::SimpleFeatures::Point,w3cgeo.location.class)
+    assert_equal(GeoRuby::SimpleFeatures::Point.from_lon_lat(-97.83,26.58),w3cgeo.location)
     
     assert(!w3cgeo.items.nil?)
     assert_equal(2,w3cgeo.items.length)
     
     assert(!w3cgeo.items.first.location.nil?)
-    assert_equal(GeoRss4rb::Point.new(28,0.83666),w3cgeo.items.first.location)
+    assert_equal(GeoRuby::SimpleFeatures::Point.from_lon_lat(0.83666,28),w3cgeo.items.first.location)
     
     assert(!w3cgeo.items[1].location.nil?)
-    assert_equal(GeoRss4rb::Point.new(55.701,12.552),w3cgeo.items[1].location)
+    assert_equal(GeoRuby::SimpleFeatures::Point.from_lon_lat(12.552,55.701),w3cgeo.items[1].location)
         
     #rss
     w3cgeo = FeedTools::Feed.open("file://#{File.dirname(__FILE__)}/rss_w3cgeo.xml")
     assert(w3cgeo.respond_to?(:location))
     assert(!w3cgeo.location.nil?)
-    assert(GeoRss4rb::Point,w3cgeo.location.class)
-    assert_equal(GeoRss4rb::Point.new(26.58,-97.83),w3cgeo.location)
+    assert_equal(GeoRuby::SimpleFeatures::Point,w3cgeo.location.class)
+    assert_equal(GeoRuby::SimpleFeatures::Point.from_lon_lat(-97.83,26.58),w3cgeo.location)
     
     assert(!w3cgeo.items.nil?)
     assert_equal(1,w3cgeo.items.length)
     
     assert(!w3cgeo.items[0].location.nil?)
-    assert_equal(GeoRss4rb::Point.new(55.701,12.552),w3cgeo.items[0].location)
+    assert_equal(GeoRuby::SimpleFeatures::Point.from_lon_lat(12.552,55.701),w3cgeo.items[0].location)
   end
   
   def test_simple
@@ -70,33 +44,33 @@ class TestGeorss < Test::Unit::TestCase
     assert(!simple.location.nil?)
 
     #Test point
-    assert(GeoRss4rb::Point,simple.location.class) 
-    assert_equal(GeoRss4rb::Point.new(4.5,56.4123),simple.location)
-    assert_equal("bidon",simple.location.feature_type_tag)
-    assert_equal("is-centered-at",simple.location.relationship_tag)
-    assert_equal(123.3,simple.location.elevation)
-    assert_equal(101,simple.location.floor)
-    assert_equal(456.1,simple.location.radius)
+    assert_equal(GeoRuby::SimpleFeatures::Point,simple.location.class) 
+    assert_equal(GeoRuby::SimpleFeatures::Point.from_lon_lat(56.4123,4.5),simple.location)
+    assert_equal("bidon",simple.georss_tags.featuretypetag)
+    assert_equal("is-centered-at",simple.georss_tags.relationshiptag)
+    assert_equal(123.3,simple.georss_tags.elev)
+    assert_equal(101,simple.georss_tags.floor)
+    assert_equal(456.1,simple.georss_tags.radius)
     assert(!simple.items.nil?)
     assert_equal(3,simple.items.length)
 
     #Test line
     first = simple.items.first
     assert(!first.location.nil?)
-    assert(GeoRss4rb::Line,first.location.class)
-    assert_equal(GeoRss4rb::Line.from_text("123.4 4123.4 312.3 123.5 -65.1 45.1"),first.location)
+    assert_equal(GeoRuby::SimpleFeatures::LineString,first.location.class)
+    assert_equal(GeoRuby::SimpleFeatures::LineString.from_coordinates([[4123.4,123.4],[ 123.5, 312.3],[45.1,-65.1]]),first.location)
 
     #Test polygon
     second = simple.items[1]
     assert(!second.location.nil?)
-    assert(GeoRss4rb::Polygon,second.location.class)
-    assert_equal(GeoRss4rb::Polygon.from_text("45.256 -110.45 46.46 -109.48 43.84 -109.86 45.256 -110.45"),second.location)
+    assert_equal(GeoRuby::SimpleFeatures::Polygon,second.location.class)
+    assert_equal(GeoRuby::SimpleFeatures::Polygon.from_coordinates([[[-110.45, 45.256 ],[ -109.48, 46.46 ],[  -109.86, 43.84],[  -110.45, 45.256]]]),second.location)
 
     #Test box
     third = simple.items[2]
     assert(!third.location.nil?)
-    assert(GeoRss4rb::Box,third.location.class)
-    assert_equal(GeoRss4rb::Box.from_text("45.256 -110.45 46.46 -109.48"),third.location)
+    assert_equal(GeoRuby::SimpleFeatures::Envelope,third.location.class)
+    assert_equal(GeoRuby::SimpleFeatures::Envelope.from_coordinates([[-110.45, 45.256 ],[ -109.48, 46.46 ]]),third.location)
     
     #rss
     simple = FeedTools::Feed.open("file://#{File.dirname(__FILE__)}/rss_simple.xml")
@@ -104,28 +78,28 @@ class TestGeorss < Test::Unit::TestCase
     assert(!simple.location.nil?)
     
     #Test box
-    assert(GeoRss4rb::Box,simple.location.class) 
-    assert_equal(GeoRss4rb::Box.from_text("45.36758436884978 -18.2373046875 60.951776809566965 8.1298828125"),simple.location)
+    assert_equal(GeoRuby::SimpleFeatures::Envelope,simple.location.class) 
+    assert_equal(GeoRuby::SimpleFeatures::Envelope.from_coordinates([[-18.2373046875, 45.36758436884978 ],[  8.1298828125, 60.951776809566965]]),simple.location)
     assert(!simple.items.nil?)
     assert_equal(3,simple.items.length)
     
     #Test point
     first = simple.items.first
     assert(!first.location.nil?)
-    assert(GeoRss4rb::Point,first.location.class)
-    assert_equal(GeoRss4rb::Point.new(52.8872,-2.04454),first.location)
+    assert_equal(GeoRuby::SimpleFeatures::Point,first.location.class)
+    assert_equal(GeoRuby::SimpleFeatures::Point.from_lon_lat(-2.04454,52.8872),first.location)
 
     #Test line
     second = simple.items[1]
     assert(!second.location.nil?)
-    assert(GeoRss4rb::Line,second.location.class)
-    assert_equal(GeoRss4rb::Line.from_text("52.7533,-0.536977 51.73, -0.3336977"),second.location)
+    assert_equal(GeoRuby::SimpleFeatures::LineString,second.location.class)
+    assert_equal(GeoRuby::SimpleFeatures::LineString.from_coordinates([[-0.536977, 52.7533],[-0.3336977, 51.73]]),second.location)
     
     #Test polygon
     third = simple.items[2]
     assert(!third.location.nil?)
-    assert(GeoRss4rb::Polygon,third.location.class)
-    assert_equal(GeoRss4rb::Polygon.from_text("55.9756 -3.9165 52.7533 -0.536977 51.73 -0.3336977 52.7533 -0.536977 51.73 -0.3336977"),third.location) #the polygon does not make any sens geometrically speaking, but it is not checked by the library
+    assert_equal(GeoRuby::SimpleFeatures::Polygon,third.location.class)
+    assert_equal(GeoRuby::SimpleFeatures::Polygon.from_coordinates([[[-3.9165, 55.9756],[-0.536977,  52.7533],[-0.3336977, 51.73],[ -0.536977, 52.7533],[-0.3336977 , 51.73]]]),third.location) #the polygon does not make any sens geometrically speaking, but it is not checked by the library
   end
 
   def test_gml
@@ -135,28 +109,28 @@ class TestGeorss < Test::Unit::TestCase
     assert(!gml.location.nil?)
 
     #Test point
-    assert(GeoRss4rb::Point,gml.location.class) 
-    assert_equal(GeoRss4rb::Point.new(45.256,-110.45),gml.location)
+    assert_equal(GeoRuby::SimpleFeatures::Point,gml.location.class) 
+    assert_equal(GeoRuby::SimpleFeatures::Point.from_lon_lat(-110.45,45.256),gml.location)
     assert(!gml.items.nil?)
     assert_equal(3,gml.items.length)
     
     #Test line
     first = gml.items.first
     assert(!first.location.nil?)
-    assert(GeoRss4rb::Line,first.location.class)
-    assert_equal(GeoRss4rb::Line.from_text("45.256 -110.45 46.46 -109.48 43.84 -109.86 45.8 -109.2"),first.location)
+    assert_equal(GeoRuby::SimpleFeatures::LineString,first.location.class)
+    assert_equal(GeoRuby::SimpleFeatures::LineString.from_coordinates([[-110.45, 45.256],[ -109.48 , 46.46],[-109.86 , 43.84],[ -109.2, 45.8]]),first.location)
 
     #Test polygon
     second = gml.items[1]
     assert(!second.location.nil?)
-    assert(GeoRss4rb::Polygon,second.location.class)
-    assert_equal(GeoRss4rb::Polygon.from_text("45.256 -110.45 46.46 -109.48 43.84 -109.86 45.256 -110.45"),second.location)
+    assert_equal(GeoRuby::SimpleFeatures::Polygon,second.location.class)
+    assert_equal(GeoRuby::SimpleFeatures::Polygon.from_coordinates([[[-110.45, 45.256 ],[-109.48 , 46.46],[-109.86,  43.84 ],[ -110.45, 45.256 ]]]),second.location)
 
     #Test box
     third = gml.items[2]
     assert(!third.location.nil?)
-    assert(GeoRss4rb::Box,third.location.class)
-    assert_equal(GeoRss4rb::Box.from_text("42.943 -71.032 43.039 -69.856"),third.location)
+    assert_equal(GeoRuby::SimpleFeatures::Envelope,third.location.class)
+    assert_equal(GeoRuby::SimpleFeatures::Envelope.from_coordinates([[-71.032, 42.943 ],[-69.856,  43.039]]),third.location)
     
     #rss
     gml = FeedTools::Feed.open("file://#{File.dirname(__FILE__)}/rss_gml.xml")
@@ -164,27 +138,27 @@ class TestGeorss < Test::Unit::TestCase
     assert(!gml.location.nil?)
 
     #Test point
-    assert(GeoRss4rb::Point,gml.location.class) 
-    assert_equal(GeoRss4rb::Point.new(45.256,-110.45),gml.location)
+    assert_equal(GeoRuby::SimpleFeatures::Point,gml.location.class) 
+    assert_equal(GeoRuby::SimpleFeatures::Point.from_lon_lat(-110.45,45.256),gml.location)
     assert(!gml.items.nil?)
     assert_equal(3,gml.items.length)
     
     #Test line
     first = gml.items.first
     assert(!first.location.nil?)
-    assert(GeoRss4rb::Line,first.location.class)
-    assert_equal(GeoRss4rb::Line.from_text("45.256 -110.45 46.46 -109.48 43.84 -109.86 45.8 -109.2"),first.location)
+    assert(GeoRuby::SimpleFeatures::LineString,first.location.class)
+    assert_equal(GeoRuby::SimpleFeatures::LineString.from_coordinates([[-110.45, 45.256],[-109.48, 46.46],[-109.86, 43.84],[-109.2 , 45.8]]),first.location)
 
     #Test polygon
     second = gml.items[1]
     assert(!second.location.nil?)
-    assert(GeoRss4rb::Polygon,second.location.class)
-    assert_equal(GeoRss4rb::Polygon.from_text("45.256 -110.45 46.46 -109.48 43.84 -109.86 45.256 -110.45"),second.location)
+    assert_equal(GeoRuby::SimpleFeatures::Polygon,second.location.class)
+    assert_equal(GeoRuby::SimpleFeatures::Polygon.from_coordinates([[[-110.45, 45.256],[-109.48 , 46.46],[-109.86,  43.84],[-110.45,  45.256 ]]]),second.location)
 
     #Test box
     third = gml.items[2]
     assert(!third.location.nil?)
-    assert(GeoRss4rb::Box,third.location.class)
-    assert_equal(GeoRss4rb::Box.from_text("42.943 -71.032 43.039 -69.856"),third.location)
+    assert_equal(GeoRuby::SimpleFeatures::Envelope,third.location.class)
+    assert_equal(GeoRuby::SimpleFeatures::Envelope.from_coordinates([[-71.032, 42.943 ],[-69.856, 43.039 ]]),third.location)
   end
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: georss4rb
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
-date: 2006-11-27 00:00:00 +01:00
+  version: 0.1.1
+date: 2007-04-01 00:00:00 +02:00
 summary: Adds support for all GeoRSS dialects in FeedTools
 require_paths: 
 - lib
@@ -30,6 +30,7 @@ authors:
 - Guilhem Vellut
 files: 
 - lib/georss4rb.rb
+- lib/save_georss4rb.rb
 - test/test_georss.rb
 - README
 - MIT-LICENSE
@@ -57,3 +58,12 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 0.2.26
     version: 
+- !ruby/object:Gem::Dependency 
+  name: GeoRuby
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+    version: