ropenlayer 0.0.1 → 0.3.0

data/lib/ropenlayer/openlayer/control.rb

@@ -0,0 +1,42 @@
+module Ropenlayer
+  module Openlayer
+    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::Openlayer::Control.configs[name]
+      end
+      
+      def to_js
+        %(// Adding #{ @name } control   
+          #{ Ropenlayer::Openlayer::Js.new_var(@js_id, "#{ Ropenlayer::Openlayer::Js.new_method(@config[:method], @config) }").to_js } 
+          #{ Ropenlayer::Openlayer::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
+end

data/lib/ropenlayer/openlayer/feature.rb

@@ -0,0 +1,119 @@
+module Ropenlayer
+  module Openlayer
+    class Feature
+      
+      DEFAULT_ICON_SIZE = [ 40, 34 ]
+      DEFAULT_ICON_URL  = "/images/ropenlayer/default_marker.png"
+      
+      attr_reader :map
+      
+      def self.draw_collection(map_object)
+        features = map_object.draw_features
+        feature_objects = features.inject([]) do |objects, feature_data|
+          objects << new(map_object, feature_data)
+          objects
+        end
+        %( //Adding features
+           #{ feature_objects.map(&:to_js) } )
+      end
+      
+      def initialize(map, attributes)
+        @map           = map
+        @id            = attributes[:id]            || raise("No defined id for feature #{ attributes.inspect }")      
+        @js_id         = "#{ @map.js_id }node#{ @id }"
+        @name          = attributes[:name]          || 'Another Feature'
+        @popup_content = attributes[:popup_content] || false
+        @geometry      = attributes[:geometry]      || raise("No defined geometry for feature #{ attributes.inspect }")
+        @longitude     = attributes[:longitude]     || raise("No defined longitude for feature #{ attributes.inspect }")
+        @latitude      = attributes[:latitude]      || raise("No defined latitude for feature #{ attributes.inspect }")
+        @icon_url      = attributes[:icon_url]
+        @icon_size     = attributes[:icon_size]
+        @color         = attributes[:color]
+        @localizations = attributes[:localizations]
+      end
+      
+      def to_js
+        %( #{ build_main_geometry  }
+           #{ build_vector_feature }
+           #{ build_main_icon      }
+           #{ build_main_feature   }
+           
+           #{ build_marker_click_function if @popup_content }
+           
+           #{  Ropenlayer::Openlayer::Js.new("#{ @map.markers_layer.js_id }.addMarker(#{  @js_id }MainMarker)").to_js } 
+           #{  Ropenlayer::Openlayer::Js.new("#{ @map.vectors_layer.js_id }.addFeatures([#{  @js_id }VectorFeature, #{  @js_id }MainFeature])").to_js } 
+           
+           
+        )
+        
+      end
+
+      private
+      def build_main_geometry
+        case @geometry
+        when "POINT"
+          return Ropenlayer::Openlayer::Js.new_var("#{ @js_id }MainGeometry", Ropenlayer::Openlayer::Js.new_method("OpenLayers.Geometry.Point", :args => [ @longitude, @latitude ]).to_s).to_js
+        when "LINESTRING"
+          return %(  #{ Ropenlayer::Openlayer::Js.new_var("#{ @js_id }LinearPoints", "[]").to_js }
+                     #{ @localizations.inject('') do |points_in_line, localization|
+                          point_in_line  =  Ropenlayer::Openlayer::Js.new_method("OpenLayers.Geometry.Point", :args => [ localization[:longitude], localization[:latitude] ]).to_s
+                          points_in_line << Ropenlayer::Openlayer::Js.new("#{ @js_id }LinearPoints.push(#{ point_in_line }) ").to_js
+                          points_in_line
+                        end }
+                      #{ Ropenlayer::Openlayer::Js.new_var("#{ @js_id }MainGeometry", Ropenlayer::Openlayer::Js.new_method("OpenLayers.Geometry.LineString", :args => ["#{ @js_id }LinearPoints"]).to_s).to_js } )
+        when "POLYGON"
+          return %(  #{ Ropenlayer::Openlayer::Js.new_var("#{ @js_id }LinearPoints", "[]").to_js }
+                     #{ @localizations.inject('') do |points_in_line, localization|
+                          point_in_line  =  Ropenlayer::Openlayer::Js.new_method("OpenLayers.Geometry.Point", :args => [ localization[:longitude], localization[:latitude] ]).to_s
+                          points_in_line << Ropenlayer::Openlayer::Js.new("#{ @js_id }LinearPoints.push(#{ point_in_line }) ").to_js
+                          points_in_line
+                        end }
+                      #{ Ropenlayer::Openlayer::Js.new_var("#{ @js_id }LinearRing",  Ropenlayer::Openlayer::Js.new_method("OpenLayers.Geometry.LinearRing", :args => ["#{ @js_id }LinearPoints"]).to_s).to_js }
+                      #{ Ropenlayer::Openlayer::Js.new_var("#{ @js_id }MainGeometry", Ropenlayer::Openlayer::Js.new_method("OpenLayers.Geometry.Polygon", :args => ["#{ @js_id }LinearRing"]).to_s).to_js } )
+        end
+      end
+      
+      def build_vector_feature
+        vector_feature_method = Ropenlayer::Openlayer::Js.new_method("OpenLayers.Feature.Vector", :args => [ "#{ @js_id }MainGeometry" ]).to_s
+        %( #{ Ropenlayer::Openlayer::Js.new_var("#{ @js_id }VectorFeature", vector_feature_method).to_js }
+           #{ Ropenlayer::Openlayer::Js.new("#{ @js_id }VectorFeature.attributes = { name: '#{ @name }', favColor: 'red', fillColor: '#{ @color }' }").to_js } )
+      end
+        
+      def build_main_icon
+        icon_size   = (@icon_size and @icon_size.is_a?(Array)) ? @icon_size : DEFAULT_ICON_SIZE
+        icon_url    = (@icon_url  and @icon_url.is_a?(String)) ? @icon_url  : DEFAULT_ICON_URL
+
+        size_method   = Ropenlayer::Openlayer::Js.new_method("OpenLayers.Size", :args => icon_size).to_s
+        offset_method = Ropenlayer::Openlayer::Js.new("function(size){ return new OpenLayers.Pixel(-(size.w/2), -(size.h/2)) }").to_s
+        
+        icon_method   = Ropenlayer::Openlayer::Js.new_method("OpenLayers.Icon", :args => [ "'#{ icon_url }'", size_method, 'null', offset_method ]).to_s
+        %( #{ Ropenlayer::Openlayer::Js.new_var("#{ @js_id }Icon", icon_method).to_js } )
+      end
+
+      def build_main_feature
+        main_feature_lonlat = Ropenlayer::Openlayer::Js.new_method("OpenLayers.LonLat", :args => [ @longitude, @latitude ]).to_s
+        main_feature_method = Ropenlayer::Openlayer::Js.new_method("OpenLayers.Feature", :args => [ @map.vectors_layer.js_id, main_feature_lonlat ]).to_s
+        %( #{ Ropenlayer::Openlayer::Js.new_var("#{ @js_id }MainFeature", main_feature_method).to_js }
+           #{ Ropenlayer::Openlayer::Js.new("#{ @js_id }MainFeature.data.icon = #{ @js_id }Icon").to_js }
+           #{ Ropenlayer::Openlayer::Js.new_var("#{ @js_id }MainMarker", "#{ @js_id }MainFeature.createMarker()").to_js } )
+      end
+      
+      def build_marker_click_function
+        function_content = %( 
+          if (this.popup == null) {
+            this.popup = this.createPopup(true);
+            this.popup.setBackgroundColor('#16b87d');
+            this.popup.setContentHTML('#{ @popup_content }');
+            #{ @map.js_id }.addPopup(this.popup);
+            this.popup.show();
+          } else {
+            this.popup.toggle();
+          }
+          OpenLayers.Event.stop(evt);
+        )
+        %( #{ Ropenlayer::Openlayer::Js.new_var("#{ @js_id}MarkerClickFunction", "function(event) {#{ function_content }}").to_js }
+           #{ Ropenlayer::Openlayer::Js.new("#{  @js_id }MainMarker.events.register('mousedown', #{ @js_id }MainFeature, #{ @js_id}MarkerClickFunction)").to_js } )
+      end
+    end
+  end
+end

data/lib/ropenlayer/openlayer/js.rb

@@ -0,0 +1,63 @@
+module Ropenlayer
+  module Openlayer  
+    class Js
+      
+      attr_accessor :body
+      
+      # == Ropenlayer::Openlayer::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::Openlayer::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
+end

data/lib/ropenlayer/openlayer/layer/base.rb

@@ -0,0 +1,88 @@
+module Ropenlayer
+  module Openlayer
+    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.uniq.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::Openlayer::Js.new_var(@js_id, "#{ Ropenlayer::Openlayer::Js.new_method(@config[:method], @config) }").to_js } 
+            #{ Ropenlayer::Openlayer::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
+end  

data/lib/ropenlayer/openlayer/layer/elements_marker.rb

@@ -0,0 +1,20 @@
+module Ropenlayer
+  module Openlayer
+    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
+end

data/lib/ropenlayer/openlayer/layer/elements_vector.rb

@@ -0,0 +1,35 @@
+module Ropenlayer
+  module Openlayer
+    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::Openlayer::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
+end

data/lib/ropenlayer/openlayer/map.rb

@@ -0,0 +1,192 @@
+module Ropenlayer
+  module Openlayer
+    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_reader :js_helper
+      
+      attr_accessor :layers_select
+      
+      attr_accessor :control_names
+      attr_accessor :controls
+      
+      attr_accessor :markers_layer
+      attr_accessor :vectors_layer
+      attr_accessor :js_notification_area
+      
+      attr_accessor :form_localizations_fields
+      
+      attr_accessor :draw_features
+      
+      
+      # 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'        
+      DEFAULT_ADD_FEATURE_CALLBACK = 'addFeatureToMap'
+          
+      
+      # == 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::Openlayer::Map.new('group_map')
+      #  => <Ropenlayer::Openlayer::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::Openlayer::Map.new('group_map').to_js) %>
+      #
+      # Ropenlayer::Openlayer::Map use this options
+      # 
+      # - layers:  Select which layers are used in map. For a list of available layers see <tt>Ropenlayer::Openlayer::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::Openlayer::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::Openlayer::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[:add_feature_callback] ||= DEFAULT_ADD_FEATURE_CALLBACK
+        @options        = options
+        
+        @js_propierties = map_js_propierties(options[:map_js_options])
+        
+        @layer_names    = @options[:layers]   || self.class.default_layers
+        if options[:default_layer]
+          def_layer    = @layer_names.delete(options[:default_layer])
+          @layer_names =  @layer_names.push(def_layer).reverse if def_layer
+        end
+        
+        @layers         = Ropenlayer::Openlayer::Layer::Base.build_collection(self)
+        
+        @control_names  = @options[:controls] || self.class.default_controls
+        @controls       = Ropenlayer::Openlayer::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::Openlayer::Layer::ElementsMarker.new(self)
+        @vectors_layer  =  Ropenlayer::Openlayer::Layer::ElementsVector.new(self)
+        
+        @draw_features  = options[:draw_features] || []
+
+        @js_notification_area      = "#{ @js_id }_notification_area"
+        @form_localizations_fields = {}
+        
+        @js_helper      = Ropenlayer.js_helper
+      end
+      
+      def map_js_propierties(map_js_options = {})
+        map_js_options ||= {}
+        propierties      = {}
+
+        propierties[:div]           = "'#{ div_id }'"
+        propierties[:controls]      = "[]"
+
+        propierties[:theme]         =  map_js_options[:theme]      || "'/stylesheets/ropenlayer.css'"
+        propierties[:projection]    =  map_js_options[:projection] || "#{ Ropenlayer::Openlayer::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::Openlayer::Js.new_method("OpenLayers.Bounds", :args => ["-20037508", "-20037508", "20037508", "20037508.34"]) }"
+        propierties
+      end
+      
+      
+      def set_center
+        %(// Setting center
+          #{ Ropenlayer::Openlayer::Js.new("#{ @js_id }.setCenter(#{ Ropenlayer::Openlayer::Js.new_method("OpenLayers.LonLat", :args => [ @longitude, @latitude ]) }, #{ @zoom })").to_js } )
+      end
+      
+      def add_notification_area
+        %(// Notification area
+          #{ Ropenlayer::Openlayer::Js.new_var(@js_notification_area, Ropenlayer::Openlayer::Js.new(@js_helper.create_xhtml_element('div', { :class => "'olMapNotificationArea'",
+                                                                                                                                             :style => "'display: none;'",
+                                                                                                                                             :id    => "'#{ @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::Openlayer::Map.to_s OpenLayers Cartographic JS project licensed under BSD~style license. More information can be found at http://openlayers.org/
+          #{ Ropenlayer::Openlayer::Js.new_var(@js_id, Ropenlayer::Openlayer::Js.new_method("OpenLayers.Map", :propierties => @js_propierties)).to_js } 
+          
+          #{ add_notification_area }
+          
+          #{ @layers.map(&:to_js) } 
+          #{ @controls.map(&:to_js) } 
+          
+          #{ set_center } 
+          
+          #{ Ropenlayer::Openlayer::BoxControl::LayersSelect.new(self).to_js  if @layers_select }         
+          #{ Ropenlayer::Openlayer::BoxControl::EditMap.new(self).to_js       if @edit_map }
+              
+          #{ @vectors_layer.to_js }
+          #{ @markers_layer.to_js }
+          
+          #{ Ropenlayer::Openlayer::Feature.draw_collection(self)             if @draw_features.any? }   
+        )
+      end
+    end
+  end
+end         
+ 

data/lib/ropenlayer.rb

@@ -1,17 +1,62 @@
-$:.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'
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+# Rubygems and Rails Stuff
+require 'rubygems'
+require 'rails'
+require 'active_record'
 
 module Ropenlayer
-  VERSION = '0.0.1'
+  
+  VERSION = '0.3.0'
+  
+  autoload :Node,               'ropenlayer/node'
+  autoload :Localization,       'ropenlayer/localization'
+  autoload :ActsAs,             'ropenlayer/acts_as'
+  autoload :FormBuilder,        'ropenlayer/form_builder'
+  
+  module ActsAs
+    autoload :Mapper,           'ropenlayer/acts_as/mapper'
+    autoload :Nodeable,         'ropenlayer/acts_as/nodeable'
+  end
+  
+  module JsHelper
+    autoload :Jquery,           'ropenlayer/js_helper/jquery'
+    autoload :Prototype,        'ropenlayer/js_helper/prototype'
+  end
+  
+  module Openlayer
+    autoload :Js,               'ropenlayer/openlayer/js'
+    autoload :Map,              'ropenlayer/openlayer/map'
+    autoload :Control,          'ropenlayer/openlayer/control'
+    autoload :Feature,          'ropenlayer/openlayer/feature'
+    
+    module BoxControl
+      autoload :Base,           'ropenlayer/openlayer/box_control/base'
+      autoload :EditMap,        'ropenlayer/openlayer/box_control/edit_map'
+      autoload :LayersSelect,   'ropenlayer/openlayer/box_control/layers_select'
+    end
+    
+    module Layer
+      autoload :Base,           'ropenlayer/openlayer/layer/base'
+      autoload :ElementsMarker, 'ropenlayer/openlayer/layer/elements_marker'
+      autoload :ElementsVector, 'ropenlayer/openlayer/layer/elements_vector'
+    end
+  end
+  
+  
+  mattr_accessor :js_helper
+  @@js_helper = Ropenlayer::JsHelper::Jquery
+  
+  def self.setup
+    yield self
+  end
+  
+  class Railtie < Rails::Railtie
+    initializer 'ropenlayer.initialize' do
+      ActiveRecord::Base.extend Ropenlayer::ActsAs
+      ActiveSupport.on_load(:action_view) do
+        ActionView::Helpers::FormBuilder.send :include, Ropenlayer::FormBuilder
+      end
+    end
+  end
 end

data/ropenlayer.gemspec

@@ -1,18 +1,21 @@
 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."
+
+  # define gem
+  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.authors     = ['Gnoxys' ]
+  s.email       = ['development@gnoxys.net']
+  s.homepage    = 'http://gitorious.org/gnoxys/ropenlayer'
+  s.files       = `git ls-files`.split("\n")
 
+  # dependencies
   s.add_runtime_dependency('json_pure', '~> 1.2.3')
+  s.add_runtime_dependency('rails', '~> 3.0.3')
   s.add_development_dependency('rspec', '~> 2.3.0')
-
   if RUBY_VERSION < '1.9'
     s.add_development_dependency('ruby-debug', '~> 0.10.3')
   end