map_layers 0.0.3

data/.autotest

@@ -0,0 +1,7 @@
+Autotest.add_hook :initialize do |autotest|
+  %w{coverage log script tasks \.git db}.each do |directory|
+    autotest.add_exception(%r{^\./#{directory}})
+  end
+end
+
+

data/.gitignore

@@ -0,0 +1,2 @@
+log/*
+*~

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--format progress

data/Gemfile

@@ -0,0 +1,2 @@
+source "http://rubygems.org"
+gemspec

data/Gemfile.lock

@@ -0,0 +1,104 @@
+PATH
+  remote: .
+  specs:
+    map_layers (0.0.3)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    ZenTest (4.6.0)
+    abstract (1.0.0)
+    actionmailer (3.0.9)
+      actionpack (= 3.0.9)
+      mail (~> 2.2.19)
+    actionpack (3.0.9)
+      activemodel (= 3.0.9)
+      activesupport (= 3.0.9)
+      builder (~> 2.1.2)
+      erubis (~> 2.6.6)
+      i18n (~> 0.5.0)
+      rack (~> 1.2.1)
+      rack-mount (~> 0.6.14)
+      rack-test (~> 0.5.7)
+      tzinfo (~> 0.3.23)
+    activemodel (3.0.9)
+      activesupport (= 3.0.9)
+      builder (~> 2.1.2)
+      i18n (~> 0.5.0)
+    activerecord (3.0.9)
+      activemodel (= 3.0.9)
+      activesupport (= 3.0.9)
+      arel (~> 2.0.10)
+      tzinfo (~> 0.3.23)
+    activeresource (3.0.9)
+      activemodel (= 3.0.9)
+      activesupport (= 3.0.9)
+    activesupport (3.0.9)
+    arel (2.0.10)
+    autotest-notification (2.3.3)
+      autotest-standalone (~> 4.5)
+    autotest-rails (4.1.0)
+      ZenTest
+    autotest-standalone (4.5.5)
+    builder (2.1.2)
+    diff-lcs (1.1.2)
+    erubis (2.6.6)
+      abstract (>= 1.0.0)
+    i18n (0.5.0)
+    mail (2.2.19)
+      activesupport (>= 2.3.6)
+      i18n (>= 0.4.0)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.16)
+    polyglot (0.3.2)
+    rack (1.2.3)
+    rack-mount (0.6.14)
+      rack (>= 1.0.0)
+    rack-test (0.5.7)
+      rack (>= 1.0)
+    rails (3.0.9)
+      actionmailer (= 3.0.9)
+      actionpack (= 3.0.9)
+      activerecord (= 3.0.9)
+      activeresource (= 3.0.9)
+      activesupport (= 3.0.9)
+      bundler (~> 1.0)
+      railties (= 3.0.9)
+    railties (3.0.9)
+      actionpack (= 3.0.9)
+      activesupport (= 3.0.9)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (~> 0.14.4)
+    rake (0.9.2)
+    rdoc (3.9.2)
+    rspec (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+      rspec-mocks (~> 2.0.1)
+    rspec-core (2.0.1)
+    rspec-expectations (2.0.1)
+      diff-lcs (>= 1.1.2)
+    rspec-mocks (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+    rspec-rails (2.0.1)
+      rspec (~> 2.0.0)
+    thor (0.14.6)
+    treetop (1.4.10)
+      polyglot
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.29)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  autotest-notification
+  autotest-rails
+  map_layers!
+  rails (>= 3.0.0)
+  rake
+  rspec (~> 2.0.0)
+  rspec-rails (~> 2.0.0)

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 [name of plugin creator]
+
+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,160 @@
+=MapLayers plugin for Rails
+
+MapLayers makes it easy to integrate a dynamic map in a Rails application. It can display map tiles and markers loaded from many different data sources.
+The included map viewer is OpenLayers[http://www.openlayers.org/].
+With MapLayers you can display and publish ActiveRecord models with geographic data.
+
+
+==Getting Started
+
+Install the latest version of the plugin:
+  ./script/plugin install git://github.com/pka/map_layers.git
+
+Create a controller and a view
+  ./script/generate controller Map index
+
+===Initialization of the map
+Add the map viewer initialization to the index action in the controller:
+  @map = MapLayers::Map.new("map") do |map, page|
+    page << map.add_layer(MapLayers::GOOGLE)
+    page << map.zoom_to_max_extent()
+  end
+
+Add this to the head of your view:
+  <%= map_layers_includes :google => "ABQIAAAA3HdfrnxFAPWyY-aiJUxmqRTJQa0g3IQ9GZqIMmInSLzwtGDKaBQ0KYLwBEKSM7F9gCevcsIf6WPuIQ" %>
+
+Put a map in the body your view:
+  <div id="map" style="width: 512px; height: 256px;"></div>
+
+  <%= @map.to_html %>
+
+Test your basic map with <tt>http://localhost:3000/map</tt>
+
+===Multiple layers
+Add a second layer and some more controls in the controller action:
+  @map = MapLayers::Map.new("map") do |map, page|
+    page << map.add_layer(MapLayers::GOOGLE)
+    page << map.add_layer(MapLayers::YAHOO_HYBRID)
+
+    page << map.add_control(Control::LayerSwitcher.new)
+    page << map.add_control(Control::Permalink.new('permalink'))
+    page << map.add_control(Control::MousePosition.new)
+
+    page << map.zoom_to_max_extent()
+  end
+
+Add the Yahoo Javascript library to the includes:
+  <%= map_layers_includes :google => "ABQIAAAA3HdfrnxFAPWyY-aiJUxmqRTJQa0g3IQ9GZqIMmInSLzwtGDKaBQ0KYLwBEKSM7F9gCevcsIf6WPuIQ", :yahoo => "euzuro-openlayers" %>
+
+There are many more predefined layer types available:
+GOOGLE_SATELLITE, GOOGLE_HYBRID, GOOGLE_PHYSICAL, VE_ROAD, VE_AERIAL, VE_HYBRID, YAHOO, YAHOO_SATELLITE, YAHOO_HYBRID, MULTIMAP, OSM_MAPNIK, OSM_TELASCIENCE, GEOPOLE_OSM, NASA_GLOBAL_MOSAIC, BLUE_MARBLE_NG, WORLDWIND, WORLDWIND_URBAN, WORLDWIND_BATHY
+
+To include all Javascript APIs, insert your API keys in the following statement:
+  <%= map_layers_includes :google => "ABQIAAAA3HdfrnxFAPWyY-aiJUxmqRTJQa0g3IQ9GZqIMmInSLzwtGDKaBQ0KYLwBEKSM7F9gCevcsIf6WPuIQ", :multimap => "metacarta_04", :virtualearth => true, :yahoo => "euzuro-openlayers" %>
+
+
+===Updating the map
+Now we want to add some simple markers in an Ajax action.
+First we add a link in the view:
+
+  <%= link_to_remote "Add marker", :url => { :action => "add_marker" } %>
+
+This requires including the prototype library:
+
+  <%= javascript_include_tag 'prototype' %>
+
+Then we include a marker layer in the map. Put this after the add_layer statements in the controller:
+
+  page.assign("markers", Layer::Markers.new('Markers'))
+  page << map.addLayer(:markers)
+
+and then we implement the Ajax action:
+
+  def add_marker
+    render :update do |page|
+      @markers = JsVar.new('markers')
+      page << @markers.add_marker(OpenLayers::Marker.new(OpenLayers::LonLat.new(rand*50,rand*50)))
+    end
+  end
+
+For accessing the marker layer in the Ajax action, we declare a Javascript variable with <tt>page.assign</tt> and access the variable later with the +JsVar+ wrapper.
+
+
+===OpenStreetMap in WGS84
+
+To overlay data in WGS84 projection you can use a customized Open Street Map:
+
+  @map = MapLayers::Map.new("map") do |map, page|
+    page << map.add_layer(MapLayers::GEOPOLE_OSM)
+    page << map.zoom_to_max_extent()
+  end
+
+
+=Publish your own data
+
+Create a model:
+  ./script/generate model --skip-timestamps --skip-fixture Place placeName:string countryCode:string postalCode:string lat:float lng:float
+  rake db:migrate
+
+Import some places:
+  ./script/runner "Geonames::Postalcode.search('Sidney').each { |pc| Place.create(pc.attributes.slice('placeName', 'postalCode', 'countryCode', 'lat', 'lng')) }"
+
+Add a new controller with a map_layer:
+
+  class PlacesController < ApplicationController
+
+    map_layer :place, :text => :placeName
+
+  end
+
+And add a layer to the map:
+
+  page << map.addLayer(Layer::GeoRSS.new("GeoRSS", "/places/georss"))
+
+
+Other types of served layers:
+
+  page << map.add_layer(Layer::GML.new("Places KML", "/places/kml", {:format=> JsExpr.new("OpenLayers.Format.KML")}))
+
+  page << map.add_layer(Layer::WFS.new("Places WFS", "/places/wfs", {:typename => "places"}, {:featureClass => JsExpr.new("OpenLayers.Feature.WFS")}))
+
+
+==Spatial database support
+
+Using a spatial database requires GeoRuby[http://georuby.rubyforge.org/] and the Spatial Adapter for Rails:
+
+  sudo gem install georuby
+  ruby script/plugin install svn://rubyforge.org/var/svn/georuby/SpatialAdapter/trunk/spatial_adapter
+
+Install spatial functions in your DB (e.g. Postgis 8.1):
+  DB=map_layers_dev
+  createlang plpgsql $DB
+  psql -d $DB -q -f /usr/share/postgresql-8.1-postgis/lwpostgis.sql
+
+Create a model:
+  ./script/generate model --skip-timestamps --skip-fixture WeatherStation name:string geom:point
+  rake db:migrate
+
+Import some weather stations:
+  ./script/runner "Geonames::Weather.weather(:north => 44.1, :south => -9.9, :east => -22.4, :west => 55.2).each { |st| WeatherStation.create(:name => st.stationName, :geom => Point.from_x_y(st.lng, st.lat)) }"
+
+Add a new controller with a map_layer:
+
+  class WeatherStationsController < ApplicationController
+
+    map_layer :weather_stations, :geometry => :geom
+
+  end
+
+And add a WFS layer to the map:
+
+  page << map.add_layer(Layer::WFS.new("Weather Stations", "/weather_stations/wfs", {:typename => "weather_stations"}, {:featureClass => JsExpr.new("OpenLayers.Feature.WFS")}))
+
+==License
+The MapLayers plugin for Rails is released under the MIT license.
+
+==Support
+For any questions, enhancement proposals, bug notifications or corrections visit http://rubyforge.org/projects/map-layers/ or send a mail to pka[at]sourcepole[dot]ch.
+
+
+<em>Copyright (c) 2008 Pirmin Kalberer, Sourcepole AG</em>

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/autotest/discover.rb

@@ -0,0 +1 @@
+Autotest.add_discovery { "rspec2" }

data/init.rb

@@ -0,0 +1,8 @@
+require 'map_layers'
+require 'map_layers/view_helpers'
+
+ActionController::Base.send(:include, MapLayers)
+ActionView::Base.send(:include, MapLayers)
+ActionView::Base.send(:include, MapLayers::ViewHelpers)
+
+Mime::Type.register "application/vnd.google-earth.kml+xml", :kml

data/install.rb

@@ -0,0 +1,13 @@
+# Workaround a problem with script/plugin and http-based repos.
+# See http://dev.rubyonrails.org/ticket/8189
+Dir.chdir(Dir.getwd.sub(/vendor.*/, '')) do
+
+def copy_files(source_path, destination_path, plugin_root)
+  source, destination = File.join(File.expand_path(plugin_root), source_path), File.join(RAILS_ROOT, destination_path)
+  FileUtils.mkdir(destination) unless File.exist?(destination)
+  FileUtils.cp_r(source, destination)
+end
+
+#copy_files("/public/.", "/public", File.dirname(__FILE__))
+
+end

data/lib/map_layers.rb

@@ -0,0 +1,358 @@
+require 'active_support/core_ext'
+
+module MapLayers # :nodoc:
+
+  #Include helpers in the given scope to AC and AV.
+  # def self.include_helpers(scope)
+  #   ActiveSupport.on_load(:action_controller) do
+  #     include scope::MapLayers
+  #   end
+    
+  #   ActiveSupport.on_load(:action_view) do
+  #     include scope::MapLayers
+  #     include scope::MapLayers::ViewHelpers
+  #   end
+  # end
+  
+  # extend the class that include this with the methods in ClassMethods
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  def map_layers_config
+    self.class.map_layers_config
+  end
+
+  module ClassMethods
+
+    def map_layer(model_id = nil, options = {})
+      options.assert_valid_keys(:id, :lat, :lon, :geometry, :text)
+
+      # converts Foo::BarController to 'bar' and FooBarsController to 'foo_bar' and AddressController to 'address'
+      model_id = self.to_s.split('::').last.sub(/Controller$/, '').pluralize.singularize.underscore unless model_id
+
+      # create the configuration
+      @map_layers_config = MapLayers::Config::new(model_id, options)
+
+      module_eval do
+        include MapLayers::KML
+        include MapLayers::WFS
+        include MapLayers::GeoRSS
+        include MapLayers::Proxy
+        include MapLayers::Rest
+      end
+
+      #session :off, :only => [:kml, :wfs, :georss]
+
+    end
+    
+    def map_layers_config
+      @map_layers_config || self.superclass.instance_variable_get('@map_layers_config')
+    end
+  
+  end
+
+
+  class Config
+    attr_reader :model_id, :id, :lat, :lon, :geometry, :text
+    
+    def initialize(model_id, options)
+      @model_id = model_id.to_s.pluralize.singularize
+      @id = options[:id] || :id
+      @lat = options[:lat] || :lat
+      @lon = options[:lon] || :lng
+      @geometry = options[:geometry]
+      @text = options[:text] || :name
+    end
+    
+    def model
+      @model ||= @model_id.to_s.camelize.constantize
+    end
+  end
+
+  
+  class Feature < Struct.new(:text, :x, :y, :id)
+    attr_accessor :geometry
+    def self.from_geom(text, geom, id = nil)
+      f = new(text, geom.x, geom.y, id)
+      f.geometry = geom
+      f
+    end
+  end
+
+  # KML Server methods
+  module KML
+    
+    # Publish layer in KML format
+    def kml
+      rows = map_layers_config.model.find(:all, :limit => KML_FEATURE_LIMIT)
+      @features = rows.collect do |row|
+        if map_layers_config.geometry
+          Feature.from_geom(row.send(map_layers_config.text), row.send(map_layers_config.geometry))
+        else
+          Feature.new(row.send(map_layers_config.text), row.send(map_layers_config.lon), row.send(map_layers_config.lat))
+        end
+      end
+      @folder_name = map_layers_config.model_id.to_s.pluralize.humanize
+      logger.info "MapLayers::KML: returning #{@features.size} features"
+      render :inline => KML_XML_ERB, :content_type => "text/xml"
+    rescue Exception => e
+      logger.error "MapLayers::KML: returning no features - Caught exception '#{e}'"
+      render :text => KML_EMPTY_RESPONSE, :content_type => "text/xml"
+    end
+    
+    protected
+
+    KML_FEATURE_LIMIT = 1000
+    
+    KML_XML_ERB = <<EOS # :nodoc:
+<?xml version="1.0" encoding="UTF-8" ?>
+<kml xmlns="http://earth.google.com/kml/2.0">
+  <Document>
+  <Folder><name><%= @folder_name %></name>
+  <% for feature in @features -%>
+    <Placemark>
+      <description><%= feature.text %></description>
+      <Point><coordinates><%= feature.x %>,<%= feature.y %></coordinates></Point>
+    </Placemark>
+  <% end -%>
+  </Folder>
+  </Document>
+</kml>
+EOS
+
+    KML_EMPTY_RESPONSE = <<EOS # :nodoc:
+<?xml version="1.0" encoding="UTF-8" ?>
+<kml xmlns="http://earth.google.com/kml/2.0">
+  <Document>
+  </Document>
+</kml>
+EOS
+    
+  end
+  
+  # WFS Server methods
+  module WFS
+    
+    WGS84 = 4326
+    
+    # Publish layer in WFS format
+    def wfs
+      minx, miny, maxx, maxy = extract_params
+      model = map_layers_config.model
+      if map_layers_config.geometry
+        db_srid = model.columns_hash[map_layers_config.geometry.to_s].srid
+        if db_srid != @srid && !db_srid.nil? && db_srid != -1
+          #Transform geometry from db_srid to requested srid (not possible for undefined db_srid)
+          geom = "Transform(#{geom},#{@srid}) AS #{geom}"
+        end
+        
+        spatial_cond = if model.respond_to?(:sanitize_sql_hash_for_conditions)
+          model.sanitize_sql_hash_for_conditions(map_layers_config.geometry => [[minx, miny],[maxx, maxy], db_srid])
+        else # Rails < 2
+          model.sanitize_sql_hash(map_layers_config.geometry => [[minx, miny],[maxx, maxy], db_srid])
+        end
+        #spatial_cond = "Transform(#{spatial_cond}, #{db_srid}) )" Not necessary: bbox is always WGS84 !?
+
+        rows = model.find(:all, :conditions => spatial_cond, :limit => @maxfeatures)
+        @features = rows.collect do |row|
+          Feature.from_geom(row.send(map_layers_config.text), row.send(map_layers_config.geometry.to_s))
+        end
+      else
+        rows = model.find(:all, :limit => @maxfeatures)
+        @features = rows.collect do |row|
+          Feature.new(row.send(map_layers_config.text), row.send(map_layers_config.lon), row.send(map_layers_config.lat))
+        end
+      end
+      logger.info "MapLayers::WFS: returning #{@features.size} features"
+      render :inline => WFS_XML_ERB, :content_type => "text/xml"
+    rescue Exception => e
+      logger.error "MapLayers::WFS: returning no features - Caught exception '#{e}'"
+      render :text => WFS_EMPTY_RESPONSE, :content_type => "text/xml"
+    end
+    
+    protected
+
+    WFS_FEATURE_LIMIT = 1000
+    
+    def extract_params # :nodoc:
+      @maxfeatures = (params[:maxfeatures] || WFS_FEATURE_LIMIT).to_i
+      @srid = params['SRS'].split(/:/)[1].to_i rescue WGS84
+      req_bbox = params['BBOX'].split(/,/).collect {|n| n.to_f } rescue nil
+      @bbox = req_bbox || [-180.0, -90.0, 180.0, 90.0]
+    end
+
+    WFS_XML_ERB = <<EOS # :nodoc:
+<?xml version='1.0' encoding="UTF-8" ?>
+<wfs:FeatureCollection
+   xmlns:ms="http://mapserver.gis.umn.edu/mapserver"
+   xmlns:wfs="http://www.opengis.net/wfs"
+   xmlns:gml="http://www.opengis.net/gml"
+   xmlns:ogc="http://www.opengis.net/ogc"
+   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+   xsi:schemaLocation="http://www.opengis.net/wfs http://schemas.opengeospatial.net/wfs/1.0.0/WFS-basic.xsd 
+                       http://mapserver.gis.umn.edu/mapserver http://www.geopole.org/map/wfs?SERVICE=WFS&amp;VERSION=1.0.0&amp;REQUEST=DescribeFeatureType&amp;TYPENAME=geopole&amp;OUTPUTFORMAT=XMLSCHEMA">
+  <gml:boundedBy>
+    <gml:Box srsName="EPSG:<%= @srid %>">
+      <gml:coordinates><%= @bbox[0] %>,<%= @bbox[1] %> <%= @bbox[2] %>,<%= @bbox[3] %></gml:coordinates>
+    </gml:Box>
+  </gml:boundedBy>
+  <% for feature in @features -%>
+    <gml:featureMember>
+      <ms:geopole>
+        <gml:boundedBy>
+          <gml:Box srsName="EPSG:<%= @srid %>">
+            <gml:coordinates><%= feature.x %>,<%= feature.y %> <%= feature.x %>,<%= feature.y %></gml:coordinates>
+          </gml:Box>
+        </gml:boundedBy>
+        <ms:msGeometry>
+        <gml:Point srsName="EPSG:<%= @srid %>">
+          <gml:coordinates><%= feature.x %>,<%= feature.y %></gml:coordinates>
+        </gml:Point>
+        </ms:msGeometry>
+        <ms:text><%= feature.text %></ms:text>
+      </ms:geopole>
+    </gml:featureMember>
+  <% end -%>
+</wfs:FeatureCollection>
+EOS
+
+    WFS_EMPTY_RESPONSE = <<EOS # :nodoc:
+<?xml version='1.0' encoding="UTF-8" ?>
+<wfs:FeatureCollection
+   xmlns:wfs="http://www.opengis.net/wfs"
+   xmlns:gml="http://www.opengis.net/gml"
+   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+   xsi:schemaLocation="http://www.opengis.net/wfs http://schemas.opengeospatial.net/wfs/1.0.0/WFS-basic.xsd">
+   <gml:boundedBy>
+      <gml:null>missing</gml:null>
+   </gml:boundedBy>
+</wfs:FeatureCollection>
+EOS
+    
+  end
+
+  # GeoRSS Server methods
+  # http://www.georss.org/1
+  
+  module GeoRSS
+    
+    # Publish layer in GeoRSS format
+    def georss
+      rows = map_layers_config.model.find(:all, :limit => GEORSS_FEATURE_LIMIT)
+      @features = rows.collect do |row|
+        if map_layers_config.geometry
+          Feature.from_geom(row.send(map_layers_config.text), row.send(map_layers_config.geometry), row.send(map_layers_config.id))
+        else
+          Feature.new(row.send(map_layers_config.text), row.send(map_layers_config.lon), row.send(map_layers_config.lat))
+        end
+      end
+      @base_url = "http://#{request.env["HTTP_HOST"]}/"
+      @item_url = "#{@base_url}#{map_layers_config.model_id.to_s.pluralize}"
+      @title = map_layers_config.model_id.to_s.pluralize.humanize
+      logger.info "MapLayers::GEORSS: returning #{@features.size} features"
+      render :inline => GEORSS_XML_ERB, :content_type => "text/xml"
+    rescue Exception => e
+      logger.error "MapLayers::GEORSS: returning no features - Caught exception '#{e}'"
+      render :text => GEORSS_EMPTY_RESPONSE, :content_type => "text/xml"
+    end
+    
+    protected
+
+    GEORSS_FEATURE_LIMIT = 1000
+    
+    GEORSS_XML_ERB = <<EOS # :nodoc:
+<?xml version="1.0" encoding="UTF-8"?>
+<rdf:RDF  xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+  xmlns="http://purl.org/rss/1.0/"
+  xmlns:dc="http://purl.org/dc/elements/1.1/"
+  xmlns:georss="http://www.georss.org/georss">
+<docs>This is an RSS file.  Copy the URL into your aggregator of choice.  If you don't know what this means and want to learn more, please see: <span>http://platial.typepad.com/news/2006/04/really_simple_t.html</span> for more info.</docs>
+<channel rdf:about="<%= @base_url %>">
+<link><%= @base_url %></link>
+<title><%= @title %></title>
+<description></description>
+<items>
+<rdf:Seq>
+<% for feature in @features -%>
+<rdf:li resource="<%= @item_url %>/<%= feature.id %>"/>
+<% end -%>
+</rdf:Seq>
+</items>
+</channel>
+<% ts=Time.now.rfc2822 -%>
+<% for feature in @features -%>
+<item rdf:about="<%= @item_url %>/<%= feature.id %>">
+<!--<link><%= @item_url %>/<%= feature.id %></link>-->
+<title><%= @title %></title>
+<description><![CDATA[<%= feature.text %>]]></description>
+<georss:point><%= feature.y %> <%= feature.x %></georss:point>
+<dc:creator>map-layers</dc:creator>
+<dc:date><%= ts %></dc:date>
+</item>
+<% end -%>
+</rdf:RDF>
+EOS
+
+    GEORSS_EMPTY_RESPONSE = <<EOS # :nodoc:
+<?xml version="1.0" encoding="UTF-8"?>
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+  xmlns="http://purl.org/rss/1.0/">
+<docs></docs>
+<channel rdf:about="http://purl.org/rss/1.0/">
+<link>http://purl.org/rss/1.0/</link>
+<title>Empty GeoRSS</title>
+<description></description>
+<items>
+<rdf:Seq>
+</rdf:Seq>
+</items>
+</channel>
+</rdf:RDF>
+EOS
+    
+  end
+  
+  # Remote http Proxy
+  module Proxy
+    
+    # Register an url, before the proxy is called
+    def register_remote_url(url)
+      session[:proxy_url] ||= []
+      session[:proxy_url] << url      
+    end
+    
+    # Proxy for accessing remote files like GeoRSS, which is not allowed directly from the browser
+    def proxy
+      if session[:proxy_url].nil? || !session[:proxy_url].include?(params["url"])
+        logger.warn "Proxy request not in session: #{params["url"]}"
+        render :nothing => true
+        return
+      end
+      
+      url = URI.parse(URI.encode(params[:url]))
+      logger.debug "Proxy request for #{url.scheme}://#{url.host}#{url.path}"
+      
+      result = Net::HTTP.get_response(url)
+      render :text => result.body, :status => result.code, :content_type => "text/xml"
+    end
+  end
+
+  # Restful feture Server methods (http://featureserver.org/)
+  module Rest
+    
+    def index
+      respond_to do |format|
+        format.xml { wfs }
+        format.kml { kml }
+      end
+    end
+    
+  end
+  
+end
+
+require 'map_layers/version'
+require 'map_layers/js_wrapper'
+require 'map_layers/open_layers'
+require 'map_layers/map'