georss4rb 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2006 Guilhem Vellut <guilhem.vellut+ym4r@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 

data/README

@@ -0,0 +1,33 @@
+=GeoRSS4rb
+GeoRSS4rb is an addon to the FeedTools library that aims at making GeoRSS information in a feed easily accessible for users of that library. It currently supports all the dialects (W3CGeo, Simple, GML) detailed in the GeoRSS specification version 1, including all the geometry types.
+
+==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.
+
+==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+
+
+Here is an example of usage:
+	feed = FeedTools::Feed.open('http://example.org/georss')
+	feed.title #=>MegaCool GeoRSS feed
+	feed.location #=><GeoRss4rb::Box ...>
+	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.
+
+==Changes since last version
+- First release
+
+==TODO
+- Add support for other RSS parsing libraries
+
+==License
+GeoRSS4rb is released under the MIT license.
+
+==Support
+Any questions, enhancement proposals, bug notifications or corrections can be sent to mailto:guilhem.vellut@gmail.com.

data/lib/georss4rb.rb

@@ -0,0 +1,268 @@
+require 'feed_tools'
+
+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 = GeoRss4rb::Point.new(lat,lon)
+          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::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
+        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...
+    end
+  end
+end
+
+FeedTools::FeedItem.class_eval do
+  include GeoRss4rb::Location
+end
+
+FeedTools::Feed.class_eval do
+  include GeoRss4rb::Location
+end

data/rakefile.rb

@@ -0,0 +1,51 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+task :default => :test
+
+desc "Run the tests"
+Rake::TestTask::new do |t|
+    t.test_files = FileList['test/test*.rb']
+    t.verbose = true
+end
+
+desc "Generate the documentation"
+Rake::RDocTask::new do |rdoc|
+  rdoc.rdoc_dir = 'georss4rb-doc/'
+  rdoc.title    = "GeoRSS4rb Documentation"
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+spec = Gem::Specification::new do |s|
+  s.platform = Gem::Platform::RUBY
+  
+  s.add_dependency('feedtools', '>= 0.2.26') #others should be ok though...
+ 
+  s.name = 'georss4rb'
+  s.version = "0.0.1"
+  s.summary = "Adds support for all GeoRSS dialects in FeedTools"
+  s.description = "Adds support for all GeoRSS dialects in FeedTools"
+  
+  s.author = 'Guilhem Vellut'
+  s.email = 'guilhem.vellut@gmail.com'
+  s.homepage = "http://thepochisuperstarmegashow.com"
+  s.rubyforge_project = "georss4rb"
+  s.requirements << 'none'
+  s.require_path = 'lib'
+  s.files = FileList["lib/**/*.rb","test/**/*.rb", "README","MIT-LICENSE","rakefile.rb"]
+  s.test_files = FileList['test/test*.rb']
+
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README"]
+  s.rdoc_options.concat ['--main',  'README']
+end
+
+desc "Package the library as a gem"
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end

data/test/test_georss.rb

@@ -0,0 +1,190 @@
+$:.unshift(File.dirname(__FILE__) + '/../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(!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(!w3cgeo.items[1].location.nil?)
+    assert_equal(GeoRss4rb::Point.new(55.701,12.552),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(!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)
+  end
+  
+  def test_simple
+    #atom
+    simple = FeedTools::Feed.open("file://#{File.dirname(__FILE__)}/atom_simple.xml")
+    assert(simple.respond_to?(:location))
+    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(!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)
+
+    #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)
+
+    #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)
+    
+    #rss
+    simple = FeedTools::Feed.open("file://#{File.dirname(__FILE__)}/rss_simple.xml")
+    assert(simple.respond_to?(:location))
+    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(!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)
+
+    #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)
+    
+    #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
+  end
+
+  def test_gml
+    #atom
+    gml = FeedTools::Feed.open("file://#{File.dirname(__FILE__)}/atom_gml.xml")
+    assert(gml.respond_to?(:location))
+    assert(!gml.location.nil?)
+
+    #Test point
+    assert(GeoRss4rb::Point,gml.location.class) 
+    assert_equal(GeoRss4rb::Point.new(45.256,-110.45),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)
+
+    #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)
+
+    #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)
+    
+    #rss
+    gml = FeedTools::Feed.open("file://#{File.dirname(__FILE__)}/rss_gml.xml")
+    assert(gml.respond_to?(:location))
+    assert(!gml.location.nil?)
+
+    #Test point
+    assert(GeoRss4rb::Point,gml.location.class) 
+    assert_equal(GeoRss4rb::Point.new(45.256,-110.45),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)
+
+    #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)
+
+    #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)
+  end
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: georss4rb
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2006-11-01 00:00:00 +01:00
+summary: Adds support for all GeoRSS dialects in FeedTools
+require_paths: 
+- lib
+email: guilhem.vellut@gmail.com
+homepage: http://thepochisuperstarmegashow.com
+rubyforge_project: georss4rb
+description: Adds support for all GeoRSS dialects in FeedTools
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Guilhem Vellut
+files: 
+- lib/georss4rb.rb
+- test/test_georss.rb
+- README
+- MIT-LICENSE
+- rakefile.rb
+test_files: 
+- test/test_georss.rb
+rdoc_options: 
+- --main
+- README
+extra_rdoc_files: 
+- README
+executables: []
+
+extensions: []
+
+requirements: 
+- none
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: feedtools
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.26
+    version: