ropenlayer 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+*~
+rdoc
+pkg

data/Gemfile

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

data/History.txt

@@ -0,0 +1,4 @@
+=== 0.0.1 2011-01-11
+
+* 1 major enhancement:
+  * release fist version of ropenlayer gem

data/Manifest.txt

@@ -0,0 +1,23 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+ropenlayer.gemspec
+lib/ropenlayer.rb
+lib/ropenlayer/control.rb
+lib/ropenlayer/js.rb
+lib/ropenlayer/map.rb
+lib/ropenlayer/layer/base.rb
+lib/ropenlayer/layer/elements_marker.rb
+lib/ropenlayer/layer/elements_vector.rb
+lib/ropenlayer/box_control/base.rb
+lib/ropenlayer/box_control/edit_map.rb
+lib/ropenlayer/box_control/layers_select.rb
+script/console
+script/destroy
+script/generate
+spec/
+
+
+

data/PostInstall.txt

@@ -0,0 +1,5 @@
+
+For more information on lidia, see http://lidia.rubyforge.org
+
+
+

data/README.rdoc

@@ -0,0 +1,63 @@
+
+= Ruby && Openlayers
+
+* http://gitorious/gnoxys/ropenlayer
+* http://openlayers.org/
+
+== DESCRIPTION:
+
+Ropenlayer is a wrapper constructor for openlayer javascript library written in ruby. It aims to provide an easy way to build maps and display it on webs.
+
+At the moment, Ropenlayer gem comes with the following features.
+
+ - Create a JS OpenLayer.Map object with some options from ruby methods.
+ - Manage layers and controls displayed on the map.
+ - Create, by default, a marker and vectors layers for render items with icons or differents features as polygons or lines. more will come.
+ - Ropenlayer will namescope all the outpus so several maps on same screen are allowed.
+ - Set defaul latitude, longitude and zoom,
+
+== Before use ropenlayer
+
+Ropenlayer is still in alpha stage, so, you should have some skills with javascript and  openlayers.
+
+Also, ropenlayer assumes you have included openlayers library in your website. For more information, go to openlayers home (http://openlayers.org/) or view the examples at http://openlayers.org/dev/examples/
+
+== Initialize
+
+Create a map object with parsed attributes. Ropenlayer manage two ids for each map.
+
+ - js_div, use to scope all the variables names to draw js output.
+ - div_id, the dom_id passed as argument to construtor. For example
+
+For example
+
+  m = Ropenlayer::Map.new('group_map')
+  => <Ropenlayer::Map:0xf7344fe8>
+  m.js_id
+  => "olObject_group_map"
+  n.div_id
+  => "group_map"
+
+To draw map, just call to_js method. For example, in a rails 3.x application
+
+  <%= raw javascript_tag(Ropenlayer::Map.new('group_map').to_js) %>
+
+For more information see Ropenlayer::Map
+
+== DEMO
+
+You can take a look to cartac (http://cartac.gnoxys.net) a application we develop over ropenlayer gem.
+
+== REQUIREMENTS:
+
+* json_pure (~>1.2.3)
+
+== INSTALL:
+
+* gem install ropenLayer
+
+== LICENSE:
+
+Same as Openlayers project: http://svn.openlayers.org/trunk/openlayers/license.txt
+
+Copyright (c) 2011 Gnoxys. info@goxys.net

data/Rakefile

@@ -0,0 +1,25 @@
+# encoding: UTF-8
+require 'rake'
+require 'rake/rdoctask'
+require 'rubygems'
+require 'rspec'
+require 'rspec/core/rake_task'
+require 'bundler'
+require File.join(File.dirname(__FILE__), 'lib', 'ropenlayer')
+
+
+Rspec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = ["--color"]
+end
+
+task :default => :spec
+
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'ropenlayer'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks

data/lib/ropenlayer/box_control/base.rb

@@ -0,0 +1,47 @@
+module Ropenlayer
+  module BoxControl
+    class Base
+      
+      attr_reader :map
+      attr_reader :name
+      attr_reader :js_links_id
+      
+      attr_accessor :links
+
+      
+      def initialize(name, map, options = {})
+        @name          = name
+        @map           = map
+        @links         = []
+        
+        @js_id         = "#{ map.js_id }_#{ name }"
+        @js_control_id = "#{ @js_id }_control" 
+        @js_links_id   = "#{ @js_id }_links" 
+        @js_panel_id   = "#{ @js_id }_panel" 
+        
+        @css_class = options[:css_class] || "olCustomControl#{ @name.camelize }"
+      end
+
+                          
+      def to_js
+        %( // Adding #{ @name } box control   
+          #{ Ropenlayer::Js.new_var("#{ @js_links_id }", "#{ Ropenlayer::Js.new_method("Element", :args => [ "'div'" ], :propierties => { :class => "'#{ @css_class }Links'",
+                                                                                                                                        :style => "'display: none;'",
+                                                                                                                                        :id    => "'#{ @js_links_id }'" })}").to_js }
+          #{ Ropenlayer::Js.new_var("#{ @js_control_id }", "#{ Ropenlayer::Js.new_method("OpenLayers.Control.Button", :propierties => { :displayClass => "'#{ @css_class }'",
+                                                                                                                                      :trigger      => "function() { $('#{ @js_links_id }').toggle(); }" }) }").to_js }
+          #{ Ropenlayer::Js.new_var("#{ @js_panel_id }", "#{ Ropenlayer::Js.new_method("OpenLayers.Control.Panel", :propierties => { :displayClass    => "'#{ @css_class }Panel'",
+                                                                                                                                    :defaultControl  => "#{ @js_control_id }" }) }").to_js }
+          #{ Ropenlayer::Js.new("#{ @js_panel_id }.addControls([#{ @js_control_id }])").to_js }
+          #{ links.inject('') do |links_string, link_config|
+                link_text = link_config.delete(:text)
+                links_string << "#{  Ropenlayer::Js.new("#{ @js_links_id }.insert(#{ Ropenlayer::Js.new_method("Element", :args => ["'a'"], :propierties => link_config ) }.update('#{ link_text }'))").to_js }\n"
+                links_string
+          end }
+          #{ Ropenlayer::Js.new("#{ @map.js_id }.addControls([#{ @js_panel_id }])").to_js }
+          #{ Ropenlayer::Js.new("#{ @js_control_id }.div.insert(#{ @js_links_id })").to_js }
+          )
+      end
+    end
+  end
+end

data/lib/ropenlayer/box_control/edit_map.rb

@@ -0,0 +1,79 @@
+module Ropenlayer
+  module BoxControl
+    class EditMap < Base
+      def initialize(map)
+        super('edit_map', map, :css_class => 'olControlEditMapControl')
+        Ropenlayer::BoxControl::EditMap.controls.each do |control_name, control_options|
+          
+          @links  << { :id       => "'link_to_edit_map_control_#{ control_name }'",
+                       :class    => "'olControlEditMapControlLink with_icon action_#{ control_name }'",
+                       :text     => "#{ control_options[:description] }",
+                       :title    => "'#{ control_options[:description] }'",
+                       :onclick  => %( "#{ map.js_notification_area }.update('#{ control_options[:help]}'); new Effect.BlindDown(#{ map.js_notification_area });#{ @js_links_id }.hide(); #{ map.js_id }ActivateEditControl('#{ control_name }');return false;" ) }
+        end
+        @links << { :id    => "'link_to_edit_map_control_cancel'",
+                    :class =>  "'olControlEditMapControlLink with_icon action_cancel'",
+                    :text  => "Cancelar",
+                    :onclick  => %( "#{ @js_links_id }.hide(); return false;") }
+      end
+      
+      def to_js
+        %( 
+          var #{ map.js_id }EditMapControls = {};
+          function #{ map.js_id }ActivateEditControl(selectedControl) {
+            for(key in #{ map.js_id }EditMapControls) {
+              var control = #{ map.js_id }EditMapControls[key];
+              if(selectedControl == key) {
+                control.activate();
+              } else {
+                control.deactivate();
+              }
+            }
+          }
+          #{ new_elements_layer = Ropenlayer::Layer::Base.new(:new_elements, @map)
+             new_elements_layer.to_js }
+
+          #{ Ropenlayer::BoxControl::EditMap.controls.inject('') do |edit_controls_js, control_array|
+              control_name    = control_array.first
+              control_options = control_array.last
+              control_options[:args] = [ new_elements_layer.js_id, control_options[:args]].flatten
+              control_options[:propierties][:featureAdded] = map.options[:new_feature_callback] || 'false' # FIXME
+
+              edit_controls_js << %( #{ Ropenlayer::Js.new_var("#{ map.js_id }_#{ control_name }", 
+                                                             "#{ Ropenlayer::Js.new_method(control_options[:method], control_options) }").to_js }
+                                      #{ Ropenlayer::Js.new("#{ map.js_id }.addControl(#{ map.js_id }_#{ control_name })").to_js }
+                                      #{ Ropenlayer::Js.new("#{ map.js_id }EditMapControls['#{ control_name }'] = #{ map.js_id }_#{ control_name }").to_js }
+              )
+              edit_controls_js
+            end }
+     
+          #{ super }
+          )
+      end
+      
+      private
+      def self.controls
+        { :add_point        => {:method      => "OpenLayers.Control.DrawFeature",
+                                :args        => [ "OpenLayers.Handler.Point" ],
+                                :propierties => { },
+                                :description => 'Crear un punto',
+                                :help        => 'Para crear un punto en el mapa, haga click en la posición deseada'
+                              },
+          :add_line         => { :method      => "OpenLayers.Control.DrawFeature",
+                                :args        => [ "OpenLayers.Handler.Path" ],
+                                :propierties => { },
+                                :description => 'Crear una línea',
+                                 :help        => 'Para crear un punto en el mapa, haga click en la posición deseada'
+
+                              },
+          :add_polygon      => { :method      => "OpenLayers.Control.DrawFeature",
+                                :args        => [ "OpenLayers.Handler.Polygon" ],
+                                :propierties => { },
+                                :description => 'Crear un polígono',
+                                 :help        => 'Para crear un punto en el mapa, haga click en la posición deseada'
+                               }
+        }
+      end
+    end
+  end
+end

data/lib/ropenlayer/box_control/layers_select.rb

@@ -0,0 +1,16 @@
+module Ropenlayer
+  module BoxControl
+    class LayersSelect < Base
+      def initialize(map)
+        super('layers_select', map, :css_class => 'olControlLayersBoxControl')
+        map.layers.each do |layer|
+          @links << { :id      => "'link_to_base_layer_#{ layer.name }'",
+                      :class   => "'olControlLayersBoxControl'",
+                      :text    => " » Usar Mapa #{ layer.config[:description] }",
+                      :onclick => "'#{ map.js_id }.setBaseLayer(#{ layer.js_id }); #{ @js_links_id }.hide(); return false;'" }
+        end
+      end
+    end
+  end
+end
+  

data/lib/ropenlayer/control.rb

@@ -0,0 +1,40 @@
+module Ropenlayer
+  class Control
+    
+    attr_reader :config
+    attr_reader :name
+    attr_reader :js_id
+    attr_reader :map
+    
+    def self.build_collection(map)
+      map.control_names.inject([]) do |controls, control_name|
+        controls << new(control_name, map)
+        controls
+      end
+    end
+    
+    def initialize(name, map)
+      @name   = name
+      @map    = map
+      @js_id  = "#{ map.js_id }_#{ name }"
+      @config = Ropenlayer::Control.configs[name]
+    end
+    
+    def to_js
+      %(// Adding #{ @name } control   
+         #{ Ropenlayer::Js.new_var(@js_id, "#{ Ropenlayer::Js.new_method(@config[:method], @config) }").to_js } 
+         #{ Ropenlayer::Js.new("#{ map.js_id }.addControl(#{ @js_id })").to_js } 
+         )
+    end
+
+    private 
+    def self.configs
+      { :layers_switcher => { :method => "OpenLayers.Control.LayerSwitcher", :args  => "" },
+        :mouse_position  => { :method => "OpenLayers.Control.MousePosition", :args  => "" },
+        :pan_panel       => { :method => "OpenLayers.Control.PanPanel",      :args  => "" },
+        :navigation      => { :method => "OpenLayers.Control.Navigation",    :args  => "" },
+        :zoom_panel      => { :method => "OpenLayers.Control.ZoomPanel",     :args  => "" },
+        :scale_line      => { :method => "OpenLayers.Control.ScaleLine",     :args  => "" }}
+    end
+  end
+end

data/lib/ropenlayer/js.rb

@@ -0,0 +1,62 @@
+module Ropenlayer
+  
+  class Js
+    
+    attr_accessor :body
+    
+    # == Ropenlayer::Js
+    #
+    # Just a simple JS constructor for objects methods calls and variable setting
+    def initialize(initialize_string = '')
+      @body = initialize_string
+    end
+   
+    # create a new js method
+    #
+    #  Ropenlayer::Js.new_method("Element.create", "div", { :class => 'eyecandy', :id => 'my_id'}).to_s
+    #  #=> new Element.create("div", { "class":"eyecandy","id":"my_id"});
+    #
+    def self.new_method(method, options = {})
+      js_object  = new
+      args        = options[:args]        || []
+      propierties = options[:propierties] || {}
+      
+      js_object.body =  "new #{ method }("
+      js_object.body << "#{ args.join(', ') }" if args.any?
+      
+      if propierties.keys.any?
+        
+        js_object.body << ", " if args.any? 
+        
+        js_object.body << propierties.keys.inject("{") do |propierties_string, propierty|
+                            propierties_string << "'#{ propierty }': #{ propierties[propierty] }"
+                            propierties_string << ", " unless propierties.keys.last == propierty
+                            propierties_string
+                          end
+        js_object.body << "}"               
+        
+      end
+      js_object.body << ")"
+      js_object
+    end
+    
+    # create a new js global variable:
+    #
+    #  Ropenlayer::Js.new_var("test", "1").to_s
+    #  #=> var test = "1"
+    #
+    def self.new_var(name, value)
+      new("var #{ name } = #{ value }")
+    end
+    
+
+    def to_s
+      @body
+    end
+    
+    def to_js
+      "#{ @body };"
+    end
+    
+  end
+end

data/lib/ropenlayer/layer/base.rb

@@ -0,0 +1,87 @@
+module Ropenlayer
+  module Layer
+    class Base
+      
+      attr_reader :config
+      attr_reader :name
+      attr_reader :js_id
+      attr_reader :map
+      
+      def self.build_collection(map)
+        map.layer_names.inject([]) do |layers, layer_name|
+          layers << new(layer_name, map)
+          layers
+        end
+      end
+      
+      def initialize(name, map)
+        @name   = name
+        @map    = map
+        @js_id  = "#{ map.js_id }_#{ name }"
+        @config = self.class.layers_config[name]
+      end
+      
+      def to_js
+        %( // Adding #{ @name } layer  
+          #{ Ropenlayer::Js.new_var(@js_id, "#{ Ropenlayer::Js.new_method(@config[:method], @config) }").to_js } 
+          #{ Ropenlayer::Js.new("#{ map.js_id }.addLayer(#{ @js_id })").to_js } )
+      end
+      
+      private 
+      # return a hash with config options for Ropenlayer layers.
+      # U can override this method as ur wish to get config from other places, for example, AR.
+      def self.layers_config
+        { :osm              => { :method      => "OpenLayers.Layer.OSM",
+                                :args        => [ "'Usar Mapa OSM'" ],
+                                :propierties => { },
+                                :description => 'Mapa Libre OSM' },
+          
+          :wms              => { :method      => "OpenLayers.Layer.WMS",
+                                :args        => [ "'OpenLayers WMS'", "'http://vmap0.tiles.osgeo.org/wms/vmap0'" ],
+                                :propierties => { :layers => "'basic'" },
+                                :description => 'Mapa Libre WMS'},
+          
+          :wms              => { :method      => "OpenLayers.Layer.WMS",
+                                :args        => [ "'OpenLayers WMS'", "'http://vmap0.tiles.osgeo.org/wms/vmap0'" ],
+                                :propierties => { :layers => "'basic'" },
+                                :description => 'Mapa Libre WMS' },
+          
+          :google_streets   => { :method      => "OpenLayers.Layer.Google",
+                                :args        => [ "'Google Streets'" ],
+                                :propierties => { :numZoomLevels => "20" },
+                                :description => 'Mapa StreetsGoogle' },
+          
+          :google_satellite => { :method      => "OpenLayers.Layer.Google",
+                                :args        => [ "'Google Satellite'" ],
+                                :propierties => { :type => "google.maps.MapTypeId.SATELLITE", :numZoomLevels => "22" },
+                                :description => 'Mapa Satélite de Google' },
+          
+          :google_physical  => { :method      => "OpenLayers.Layer.Google",
+                                :args        => [ "'Google Physical'" ],
+                                :propierties => { :type => "google.maps.MapTypeId.TERRAIN"  },
+                                :description => 'Mapa Físico de Google' },
+          
+          :google_hybrid    => { :method      => "OpenLayers.Layer.Google",
+                                :args        => [ "'Google Hybrid'" ],
+                                :propierties => { :type => "google.maps.MapTypeId.HYBRID", :numZoomLevels => "22"   },
+                                :description => 'Mapa Híbrido de Google' },
+          
+          :yahoo            => { :method      => "OpenLayers.Layer.Yahoo",
+                                :args        => [  ],
+                                :propierties => {  },
+                                :description => 'Mapa Yahoo' },
+          :new_elements     => { :method      => "OpenLayers.Layer.Vector",
+                                :args        => [ "'Vector Layer for create elements'" ],
+                                :propierties => {  },
+                                :description => 'New Vectors Layer' },
+
+          :vector_elements  => { :method      => "OpenLayers.Layer.Vector",
+                                :args        => [ "'Capa de Marcadores''" ],
+                                :propierties => {  },
+                                :description => 'Capa para marcadores de elements' }
+        }
+      end
+    end
+  end
+end
+  

data/lib/ropenlayer/layer/elements_marker.rb

@@ -0,0 +1,18 @@
+module Ropenlayer
+  module Layer
+    class ElementsMarker < Base
+    
+      def initialize(map)
+        super(:marker_elements, map)
+      end
+      
+      private
+      def self.layers_config
+        { :marker_elements  => { :method      => "OpenLayers.Layer.Markers",
+                                 :args        => [ "'Capa de Marcadores'" ],
+                                 :propierties => {  },
+                                 :description => 'Capa para marcadores de elements' } }
+      end
+    end
+  end
+end

data/lib/ropenlayer/layer/elements_vector.rb

@@ -0,0 +1,33 @@
+module Ropenlayer
+  module Layer
+    class ElementsVector < Base
+    
+      def initialize(map)
+        super(:vector_elements, map)
+      end
+      
+      private
+      def self.layers_config
+        { :vector_elements  => { :method      => "OpenLayers.Layer.Vector",
+                                 :args        => [ "'Capa de Elementos'" ],
+                                 :propierties => { :styleMap => "#{ Ropenlayer::Js.new_method("OpenLayers.StyleMap", :propierties => { :default => default_vector_style_parameters.to_json }) }" },
+                                 :description => 'Capa para marcadores de elements' } }
+      end
+      
+      def self.default_vector_style_parameters
+        { :cursor           => 'normal',
+          :graphicWidth     =>  48,
+          :graphicHeight    =>  48,      
+          :strokeColor      =>  '${fillColor}',
+          :strokeOpacity    =>  0.8,
+          :strokeWidth      =>  5,
+          :fillColor        =>  '${fillColor}',
+          :fillOpacity      => 0.8,
+          :pointRadius      =>  30,
+          :pointerEvents    =>  'visiblePainted',
+          :fontSize         =>  '12px',
+          :fontWeight       =>  'bold' }
+      end
+    end
+  end
+end

data/lib/ropenlayer/map.rb

@@ -0,0 +1,176 @@
+module Ropenlayer
+  class Map
+    
+    attr_reader :js_id
+    attr_reader :div_id
+    attr_reader :js_propierties
+    attr_reader :options
+
+    attr_reader :layer_names
+    attr_reader :layers
+    
+    attr_accessor :layers_select
+    
+    attr_accessor :control_names
+    attr_accessor :controls
+    
+    attr_accessor :markers_layer
+    attr_accessor :vectors_layer
+    attr_accessor :js_notification_area
+    
+    # used to scope js variables created with the map. Js name will be created with this prefix + plus dom_id argument
+    MAP_JS_PREFIX                = 'olObject'               
+        
+    def self.print(map_object, options = {})
+      new(map_object, options).to_js
+    end
+    
+    # == Initialize
+    # 
+    # Create a map object with parsed attributes. Ropenlayer manage two ids for each map.
+    # - js_div, use to scope all the variables names to draw js output.
+    # - div_id, the dom_id passed as argument to construtor. For example
+    #
+    # For example
+    #
+    #  m = Ropenlayer::Map.new('group_map')
+    #  => <Ropenlayer::Map:0xf7344fe8>
+    #  m.js_id
+    #  => "olObject_group_map"
+    #  n.div_id
+    #  => "group_map"
+    #
+    # To draw map, just call to_js method. For example, in a rails 3.x application
+    #
+    #  <%= raw javascript_tag(Ropenlayer::Map.new('group_map').to_js) %>
+    #
+    # Ropenlayer::Map use this options
+    #
+    # - layers:  Select which layers are used in map. For a list of available layers see <tt>Ropenlayer::Laye::Baser</tt>
+    # - default_layer: Default layer at render. Default layers.first 
+    # - layer_select: If true, map will render a control for change between differents layers
+    # - controls: Select which controls are used in map. For a list of available controlse see <tt>Ropenlayer::Control</tt>
+    # - latitude: Specify default latitude for map. Map will be pointed at this latitude at render.
+    # - longitude: Specify default longitude for map. Map will be pointed at this longitude at render.
+    # - zoom: Specify default zoom for map. Map will be render with this zoom enable.
+    # - edit_map: If true, map will display a custom control what enable edit capabilities with map 
+    #
+    # Map object accepts other options scoped in :map_js_options key.
+    # 
+    # - theme: CSS theme used to display. By default none is used
+    # - projection: Specify projection. Argument must be a valid OpenLayers.Projection JS object. See more on
+    # - units: Units for measure. By default: "'m'"
+    # - maxResolution: maxResolution of the map, by default word length: "156543.0339"
+    # - meaxExtentd: Bound for projection. Must be valid OpenLayers.Bounds object. By default world length bound. See for more info.
+    # 
+    # After display objects, you can, ofc, call methods from openlayers api to instace js variable. For example
+    #
+    #  <% map = Ropenlayer::Map.new('group_map') %>
+    #  <%= raw javascript_tag map.to_js %>
+    #  <%= raw javascript_tag "#{ map.js_id }.setCenter(new OpenLayers.LonLat(0,0), 10);" %>
+    #
+    # Will call the setCenter OpenLayer.Map JS method to map.js_id js instace object
+    #
+    def initialize(dom_id, options = {})
+      @js_id          = "#{ MAP_JS_PREFIX  }_#{ dom_id }"
+      @div_id         = "#{ dom_id }"
+      @options        = options
+      
+      @js_propierties = map_js_propierties(options[:map_js_options])
+      
+      @layer_names    = @options[:layers]   || self.class.default_layers
+      @layers         = Ropenlayer::Layer::Base.build_collection(self)
+      
+      @control_names  = @options[:controls] || self.class.default_controls
+      @controls       = Ropenlayer::Control.build_collection(self)
+      
+      @latitude       = @options[:latitude]  || self.class.default_latitude
+      @longitude      = @options[:longitude] || self.class.default_longitude
+      @zoom           = @options[:zoom]      || self.class.default_zoom
+      
+      @layers_select  = @options[:layer_select].nil? or @options[:layer_select]
+      @edit_map       = @options[:edit_map]
+      
+      @markers_layer  =  Ropenlayer::Layer::ElementsMarker.new(self)
+      @vectors_layer  =  Ropenlayer::Layer::ElementsVector.new(self)
+      
+      @js_notification_area = "#{ @js_id }_notification_area"
+    end
+    
+    def map_js_propierties(map_js_options = {})
+      map_js_options ||= {}
+      propierties      = {}
+
+      propierties[:div]           = "'#{ div_id }'"
+      propierties[:controls]      = "[]"
+
+      propierties[:theme]         =  map_js_options[:theme]      if map_js_options[:theme]
+      propierties[:projection]    =  map_js_options[:projection] || "#{ Ropenlayer::Js.new_method("OpenLayers.Projection", :args => ["'EPSG:900913'"]) }"
+      propierties[:units]         =  map_js_options[:units]      || "'m'"
+      propierties[:maxResolution] =  map_js_options[:units]      || "156543.0339"
+      propierties[:maxExtent]     =  map_js_options[:maxExtent]  || "#{ Ropenlayer::Js.new_method("OpenLayers.Bounds", :args => ["-20037508", "-20037508", "20037508", "20037508.34"]) }"
+      propierties
+    end
+    
+    
+    def set_center
+      %(// Setting center
+         #{ Ropenlayer::Js.new("#{ @js_id }.setCenter(#{ Ropenlayer::Js.new_method("OpenLayers.LonLat", :args => [ @longitude, @latitude ]) }, #{ @zoom })").to_js } )
+    end
+    
+    def add_notification_area
+      %(// Notification area
+         #{ Ropenlayer::Js.new_var(@js_notification_area,
+                                  Ropenlayer::Js.new_method('Element', :args        => ["'div'"], 
+                                                                      :propierties => { :class => "'olMapNotificationArea'",
+                                                                                        :style => "'display: none;'",
+                                                                                        :id    => "'#{ @js_notification_area }'" }).to_s).to_js } 
+         #{ Ropenlayer::Js.new("#{ @js_id }.div.insert(#{ @js_notification_area });").to_js }
+         )
+    end
+
+
+
+    def self.default_layers
+      [ :google_hybrid, :google_streets, :wms, :google_satellite, :google_physical, :osm ]
+    end
+                                                                                                
+    def self.default_latitude
+      4580313.35287
+    end
+    
+    def self.default_longitude
+      263274.20626803
+    end
+
+    def self.default_zoom
+      4
+    end
+    
+    def self.default_controls
+      [ :scale_line, :mouse_position, :pan_panel, :navigation, :zoom_panel  ]
+    end
+    
+    # Map to JS OpenLayer construtor
+    def to_js
+      %(// Ropenlayer::Map.to_s OpenLayers Cartographic JS project licensed under BSD~style license. More information can be found at http://openlayers.org/
+         #{ Ropenlayer::Js.new_var(@js_id, Ropenlayer::Js.new_method("OpenLayers.Map", :propierties => @js_propierties)).to_js } 
+         
+         #{ add_notification_area }
+         
+         #{ @layers.map(&:to_js) } 
+         #{ @controls.map(&:to_js) } 
+         
+         #{ set_center } 
+         
+         #{ Ropenlayer::BoxControl::LayersSelect.new(self).to_js  if @layers_select }         
+         #{ Ropenlayer::BoxControl::EditMap.new(self).to_js       if @edit_map }
+            
+         #{ @vectors_layer.to_js }
+         #{ @markers_layer.to_js }
+       )
+    end
+  end
+end
+         
+ 

data/lib/ropenlayer.rb

@@ -0,0 +1,17 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+  
+require 'json'
+require 'ropenlayer/map'
+require 'ropenlayer/control'
+require 'ropenlayer/js'
+require 'ropenlayer/box_control/base'
+require 'ropenlayer/box_control/edit_map'
+require 'ropenlayer/box_control/layers_select'
+require 'ropenlayer/layer/base'
+require 'ropenlayer/layer/elements_marker'
+require 'ropenlayer/layer/elements_vector'
+
+module Ropenlayer
+  VERSION = '0.0.1'
+end

data/ropenlayer.gemspec

@@ -0,0 +1,19 @@
+require File.join(File.dirname(__FILE__), 'lib', 'ropenlayer')
+
+Gem::Specification.new do |s|
+  s.name = "ropenlayer"
+  s.version = Ropenlayer::VERSION
+  s.summary = "Ropenlayer is a wrapper constructor for openlayer javascript library written in ruby. It aims to provide an easy way to build maps and display it on webs."
+  s.description = "Ropenlayer is a wrapper constructor for openlayer javascript library written in ruby. It aims to provide an easy way to build maps and display it on webs."
+  s.authors = ['Gnoxys' ]
+  s.email = ['development@gnoxys.net']
+  s.homepage = 'http://gitorious.org/gnoxys/ropenlayer'
+  s.files = `git ls-files`.split("\n")
+
+  s.add_runtime_dependency('json_pure', '~> 1.2.3')
+  s.add_development_dependency('rspec', '~> 2.3.0')
+
+  if RUBY_VERSION < '1.9'
+    s.add_development_dependency('ruby-debug', '~> 0.10.3')
+  end
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/ropenlayer.rb'}"
+puts "Loading ropenlayer gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification 
+name: ropenlayer
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Gnoxys
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-11 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json_pure
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 25
+        segments: 
+        - 1
+        - 2
+        - 3
+        version: 1.2.3
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 3
+        - 0
+        version: 2.3.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 49
+        segments: 
+        - 0
+        - 10
+        - 3
+        version: 0.10.3
+  type: :development
+  version_requirements: *id003
+description: Ropenlayer is a wrapper constructor for openlayer javascript library written in ruby. It aims to provide an easy way to build maps and display it on webs.
+email: 
+- development@gnoxys.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- README.rdoc
+- Rakefile
+- lib/ropenlayer.rb
+- lib/ropenlayer/box_control/base.rb
+- lib/ropenlayer/box_control/edit_map.rb
+- lib/ropenlayer/box_control/layers_select.rb
+- lib/ropenlayer/control.rb
+- lib/ropenlayer/js.rb
+- lib/ropenlayer/layer/base.rb
+- lib/ropenlayer/layer/elements_marker.rb
+- lib/ropenlayer/layer/elements_vector.rb
+- lib/ropenlayer/map.rb
+- ropenlayer.gemspec
+- script/console
+- script/destroy
+- script/generate
+has_rdoc: true
+homepage: http://gitorious.org/gnoxys/ropenlayer
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ropenlayer is a wrapper constructor for openlayer javascript library written in ruby. It aims to provide an easy way to build maps and display it on webs.
+test_files: []
+