ym4r 0.4.1 → 0.5.1

data/lib/ym4r/google_maps/mapping.rb

@@ -1,126 +0,0 @@
-module Ym4r
-  module GoogleMaps
-    #The module where all the Ruby-to-JavaScript conversion takes place. It is included by all the classes in the YM4R library.
-    module MappingObject
-      #The name of the variable in JavaScript space.
-      attr_reader :variable
-      
-      #Creates javascript code for missing methods + takes care of listeners
-      def method_missing(name,*args)
-        str_name = name.to_s
-        if str_name =~ /^on_(.*)/
-          if args.length != 1
-            raise ArgumentError("Only 1 argument is allowed on on_ methods");
-          else
-            Variable.new("GEvent.addListener(#{to_javascript},\"#{javascriptify_method($1)}\",#{args[0]})")
-          end
-        else
-          args.collect! do |arg|
-            MappingObject.javascriptify_variable(arg)
-          end
-          Variable.new("#{to_javascript}.#{MappingObject.javascriptify_method(str_name)}(#{args.join(",")})")
-        end
-      end
-            
-      #Creates javascript code for array or hash indexing
-      def [](index) #index could be an integer or string
-        return Variable.new("#{to_javascript}[#{MappingObject.javascriptify_variable(index)}]")
-      end
-
-      #Transforms a Ruby object into a JavaScript string : MAppingObject, String, Array, Hash and general case (using to_s)
-      def self.javascriptify_variable(arg)
-        if arg.is_a?(MappingObject)
-          arg.to_javascript
-        elsif arg.is_a?(String)
-          "\"#{MappingObject.escape_javascript(arg)}\""
-        elsif arg.is_a?(Array)
-          "[" + arg.collect{ |a| MappingObject.javascriptify_variable(a)}.join(",") + "]"
-        elsif arg.is_a?(Hash)
-          "{" + arg.to_a.collect do |v|
-            "#{MappingObject.javascriptify_method(v[0].to_s)} : #{MappingObject.javascriptify_variable(v[1])}"
-          end.join(",") + "}"
-        else
-          arg.to_s
-        end
-      end
-      
-      #Escape string to be used in JavaScript. Lifted from rails.
-      def self.escape_javascript(javascript)
-        javascript.gsub(/\r\n|\n|\r/, "\\n").gsub(/["']/) { |m| "\\#{m}" }
-      end
-      
-      #Transform a ruby-type method name (like add_overlay) to a JavaScript-style one (like addOverlay).
-      def self.javascriptify_method(method_name)
-        method_name.gsub(/_(\w)/){|s| $1.upcase}
-      end
-      
-      #Declares a Mapping Object bound to a JavaScript variable of name +variable+.
-      def declare(variable)
-        @variable = variable
-        "var #{@variable} = #{create};"
-      end
-
-      #declare with a random variable name
-      def declare_random(init,size = 8)
-        s = init.clone
-        6.times { s << (i = Kernel.rand(62); i += ((i < 10) ? 48 : ((i < 36) ? 55 : 61 ))).chr }
-        declare(s)
-      end
-
-      #Checks if the MappinObject has been declared
-      def declared?
-        !@variable.nil?
-      end
-      
-      #Binds a Mapping object to a previously declared JavaScript variable of name +variable+.
-      def assign_to(variable)
-        @variable = variable
-        "#{@variable} = #{create};"
-      end
-
-      #Assign the +value+ to the +property+ of the MappingObject
-      def set_property(property, value)
-        "#{to_javascript}.#{MappingObject.javascriptify_method(property.to_s)} = #{MappingObject.javascriptify_variable(value)}"
-      end
-
-      #Returns the code to get a +property+ from the MappingObject
-      def get_property(property)
-        Variable.new("#{to_javascript}.#{MappingObject.javascriptify_method(property.to_s)}")
-      end
-      
-      #Returns a Javascript code representing the object
-      def to_javascript
-        unless @variable.nil?
-          @variable
-        else
-          create
-        end
-      end
-      
-      #Creates a Mapping Object in JavaScript.
-      #To be implemented by subclasses if needed
-      def create
-      end
-    end
-
-    #Used to bind a ruby variable to an already existing JavaScript one. It doesn't have to be a variable in the sense "var variable" but it can be any valid JavaScript expression that has a value.
-    class Variable
-      include MappingObject
-      
-      def initialize(variable)
-        @variable = variable
-      end
-      #Returns the javascript expression contained in the object.
-      def create
-        @variable
-      end
-      #Returns the expression inside the Variable followed by a ";"
-      def to_s
-        @variable + ";"
-      end
-
-      UNDEFINED = Variable.new("undefined")
-    end
-  end
-end
-

data/lib/ym4r/google_maps/overlay.rb

@@ -1,187 +0,0 @@
-require 'ym4r/google_maps/mapping'
-
-module Ym4r
-  module GoogleMaps
-    #A graphical marker positionned through geographic coordinates (in the WGS84 datum). An HTML info window can be set to be displayed when the marker is clicked on.
-    class GMarker
-      include MappingObject
-      attr_accessor :point, :options, :info_window, :info_window_tabs
-      #The +points+ argument can be either a GLatLng object or an array of 2 floats. The +options+ keys can be: <tt>:icon</tt>, <tt>:clickable</tt>, <tt>:title</tt>, <tt>:info_window</tt> and <tt>info_window_tabs</tt>. The value of the +info_window+ key is a string of HTML code that will be displayed when the markers is clicked on. The value of the +info_window_tabs+ key is an array of GInfoWindowTab objects.
-      def initialize(point, options = {})
-        if point.is_a?(Array)
-          @point = GLatLng.new(point)
-        else
-          @point = point
-        end
-        @info_window = options.delete(:info_window)
-        @tab_info_window = options.delete(:info_window_tabs)
-        @options = options
-      end
-      #Creates a marker: If an info_window or info_window_tabs is present, the response to the click action from the user is setup here.
-      def create
-        if @options.empty?
-          creation = "new GMarker(#{MappingObject.javascriptify_variable(@point)})"
-        else
-          creation = "new GMarker(#{MappingObject.javascriptify_variable(@point)},#{MappingObject.javascriptify_variable(@options)})"
-        end
-        if @info_window
-          "addInfoWindowToMarker(#{creation},#{MappingObject.javascriptify_variable(@info_window)})"
-        elsif @tab_info_window
-          "addInfoWindowTabsToMarker(#{creation},#{MappingObject.javascriptify_variable(Array(@tab_info_window))})"
-        else
-          creation
-        end
-      end
-    end
-    
-    #Represents a tab to be displayed in a bubble when a marker is clicked on.
-    class GInfoWindowTab < Struct.new(:tab,:content)
-      include MappingObject
-      def create
-        "new GInfoWindowTab(#{MappingObject.javascriptify_variable(tab)},#{MappingObject.javascriptify_variable(content)})"
-      end
-    end
-        
-    #Represents a definition of an icon. You can pass rubyfied versions of the attributes detailed in the Google Maps API documentation. You can initialize global icons to be used in the application by passing a icon object, along with a variable name, to GMap#icon_init. If you want to declare an icon outside this, you will need to declare it first, since the JavaScript constructor does not accept any argument.
-    class GIcon
-      include MappingObject
-      DEFAULT = Variable.new("G_DEFAULT_ICON")
-      attr_accessor :options, :copy_base
-
-      #Options can contain all the attributes (in rubyfied format) of a GIcon object (see Google's doc), as well as <tt>:copy_base</tt>, which indicates if the icon is copied from another one.
-      def initialize(options = {})
-        @copy_base = options.delete(:copy_base)
-        @options = options
-      end
-      #Creates a GIcon.
-      def create
-        if @copy_base
-          c = "new GIcon(#{MappingObject.javascriptify_variable(@copy_base)})"
-        else
-          c = "new GIcon()"
-        end
-        if !options.empty?
-          "addOptionsToIcon(#{c},#{MappingObject.javascriptify_variable(@options)})"
-        else
-          c
-        end
-      end
-    end
-     
-    #A polyline.
-    class GPolyline
-      include MappingObject
-      attr_accessor :points,:color,:weight,:opacity
-      #Can take an array of +GLatLng+ or an array of 2D arrays. A method to directly build a polyline from a GeoRuby linestring is provided in the helper.rb file.
-      def initialize(points,color = nil,weight = nil,opacity = nil)
-        if !points.empty? and points[0].is_a?(Array)
-          @points = points.collect { |pt| GLatLng.new(pt) }
-        else
-          @points = points
-        end
-        @color = color
-        @weight = weight
-        @opacity = opacity
-      end
-      #Creates a new polyline.
-      def create
-        a = "new GPolyline([#{@points.collect{|pt| MappingObject.javascriptify_variable(pt)}.join(",")}]"
-        a << ",#{MappingObject.javascriptify_variable(@color)}" if @color
-        a << ",#{MappingObject.javascriptify_variable(@weight)}" if @weight
-        a << ",#{MappingObject.javascriptify_variable(@opacity)}" if @opacity
-        a << ")"
-      end
-    end
-    #A basic Latitude/longitude point.
-    class GLatLng 
-      include MappingObject
-      attr_accessor :lat,:lng,:unbounded
-      
-      def initialize(latlng,unbounded = nil)
-        @lat = latlng[0]
-        @lng = latlng[1]
-        @unbounded = unbounded
-      end
-      def create
-        unless @unbounded
-          "new GLatLng(#{@lat},#{@lng})"
-        else
-          "new GLatLng(#{@lat},#{@lng},#{@unbounded})"
-        end
-      end
-    end
-    
-    #A rectangular bounding box, defined by its south-western and north-eastern corners.
-    class GLatLngBounds < Struct.new(:sw,:ne)
-      include MappingObject
-      def create
-        "new GLatLngBounds(#{sw},#{ne})"
-      end
-    end
-    
-    #A GOverlay representing a group of GMarkers. The GMarkers can be identified with an id, which can be used to show the info window of a specific marker, in reponse, for example, to a click on a link. The whole group can be shown on and off at once. It should be declared global at initialization time to be useful.
-    class GMarkerGroup
-      include MappingObject
-      attr_accessor :active, :markers, :markers_by_id
-
-      def initialize(active = true , markers = nil)
-        @active = active
-        @markers = []
-        @markers_by_id = {}
-        if markers.is_a?(Array)
-          @markers = markers
-        elsif markers.is_a?(Hash)
-          @markers_by_id = markers
-        end
-      end
-      
-      def create
-        "new GMarkerGroup(#{MappingObject.javascriptify_variable(@active)},#{MappingObject.javascriptify_variable(@markers)},#{MappingObject.javascriptify_variable(@markers_by_id)})"
-      end
-    end
-
-    #Makes the link with the Clusterer2 library by Jef Poskanzer (slightly modified though). Is a GOverlay making clusters out of its GMarkers, so that GMarkers very close to each other appear as one when the zoom is low. When the zoom gets higher, the individual markers are drawn.
-    class Clusterer
-      include MappingObject
-      attr_accessor :markers,:icon, :max_visible_markers, :grid_size, :min_markers_per_cluster , :max_lines_per_info_box
-
-      def initialize(markers = [], options = {})
-        @markers = markers
-        @icon = options[:icon] || GIcon::DEFAULT
-        @max_visible_markers = options[:max_visible_markers] || 150
-        @grid_size = options[:grid_size] || 5
-        @min_markers_per_cluster = options[:min_markers_per_cluster] || 5
-        @max_lines_per_info_box = options[:max_lines_per_info_box] || 10
-      end
-
-      def create 
-        js_marker = '[' + @markers.collect do |marker|
-          add_description(marker)
-        end.join(",") + ']'
-
-        "new Clusterer(#{js_marker},#{MappingObject.javascriptify_variable(@icon)},#{MappingObject.javascriptify_variable(@max_visible_markers)},#{MappingObject.javascriptify_variable(@grid_size)},#{MappingObject.javascriptify_variable(@min_markers_per_cluster)},#{MappingObject.javascriptify_variable(@max_lines_per_info_box)})"
-      end
-            
-      private
-      def add_description(marker)
-        "addDescriptionToMarker(#{MappingObject.javascriptify_variable(marker)},#{MappingObject.javascriptify_variable(marker.options[:description] || marker.options[:title] || '')})"
-      end
-    end
-    
-    class GeoRssOverlay
-      include MappingObject
-      attr_accessor :url, :proxy, :icon
-      
-      def initialize(url, options = {})
-        @url = url
-        @icon = options[:icon] || GIcon::DEFAULT
-        @proxy = options[:proxy] || Variable::UNDEFINED
-      end
-
-      def create 
-        "new GeoRssOverlay(#{MappingObject.javascriptify_variable(@url)},#{MappingObject.javascriptify_variable(@icon)},#{MappingObject.javascriptify_variable(@proxy)})"
-      end
-    end
-
-  end
-end

data/lib/ym4r/google_maps/point.rb

@@ -1,36 +0,0 @@
-require 'ym4r/google_maps/mapping'
-
-module Ym4r
-  module GoogleMaps
-    #A point in pixel coordinates
-    class GPoint < Struct.new(:x,:y)
-      include MappingObject
-      def create
-        "new GPoint(#{x},#{y})"
-      end
-    end
-    #A rectangular that contains all the pixel points passed as arguments
-    class GBounds
-      include MappingObject
-      attr_accessor :points
-      #Accepts both an array of GPoint and an array of 2-element arrays
-      def initialize(points)
-        if !points.empty? and points[0].is_a?(Array)
-          @points = points.collect { |pt| GPoint.new(pt[0],pt[1]) }
-        else
-          @points = points
-        end
-      end
-      def create
-        "new GBounds([#{@points.map { |pt| pt.to_javascript}.join(",")}])"
-      end
-    end
-    #A size object, in pixel space
-    class GSize < Struct.new(:width,:height)
-      include MappingObject
-      def create
-        "new GSize(#{width},#{height})"
-      end
-    end
-  end
-end

data/lib/ym4r/yahoo_maps/flash.rb

@@ -1,7 +0,0 @@
-require 'ym4r/yahoo_maps/app_id'
-require 'ym4r/yahoo_maps/flash/mapping'
-require 'ym4r/yahoo_maps/flash/latlon'
-require 'ym4r/yahoo_maps/flash/marker'
-require 'ym4r/yahoo_maps/flash/widget'
-require 'ym4r/yahoo_maps/flash/tool'
-require 'ym4r/yahoo_maps/flash/overlay'

data/lib/ym4r/yahoo_maps/flash/latlon.rb

@@ -1,18 +0,0 @@
-module Ym4r
-  module YahooMaps
-    module Flash
-      class LatLon < Struct.new(:lat,:lon)
-        include MappingObject
-        def create
-          "new LatLon(#{lat},#{lon})"
-        end
-      end
-      class LatLonRect < Struct.new(:min_lat, :min_lon, :max_lat, :max_lon)
-        include MappingObject
-        def create
-          "new LatLonRect(#{min_lat},#{min_lon},#{max_lat},#{max_lon})"
-        end
-      end
-    end
-  end
-end

data/lib/ym4r/yahoo_maps/flash/map.rb

@@ -1,74 +0,0 @@
-module Ym4r
-  module YahooMaps
-    module Flash
-    
-      module MapViews
-        MAP = Variable.new("MapViews.MAP")
-        HYBRID = Variable.new("MapViews.HYBRID")
-        SATELLITE = Variable.new("MapViews.SATELLITE") 
-      end
-      
-      class Map
-        include MappingObject
-        
-        attr_reader :container
-        attr_accessor :zoom, :latlon, :location, :view_type
-        
-        EVENT_INITIALIZE = "Map.EVENT_INITIALIZE"
-        EVENT_MAP_GEOCODE_ERROR = "Map.EVENT_MAP_GEOCODE_ERROR"
-        EVENT_MAP_GEOCODE_SUCCESS = "Map.EVENT_MAP_GEOCODE_SUCCESS"
-        EVENT_MARKER_GEOCODE_ERROR = "Map.EVENT_MARKER_GEOCODE_ERROR"
-        EVENT_MARKER_GEOCODE_SUCCESS = "Map.EVENT_MARKER_GEOCODE_SUCCESS"
-        EVENT_MOVE = "Map.EVENT_MOVE"
-        EVENT_PAN_START = "Map.EVENT_PAN_START"
-        EVENT_PAN_STOP = "Map.EVENT_PAN_STOP"
-        EVENT_TOOL_ADDED = "Map.EVENT_TOOL_ADDED"
-        EVENT_TOOL_CHANGE = "Map.EVENT_TOOL_CHANGE"
-        EVENT_TOOL_REMOVED = "Map.EVENT_TOOL_REMOVED"
-        EVENT_ZOOM = "Map.EVENT_ZOOM"
-        EVENT_ZOOM_STOP = "Map.EVENT_ZOOM_STOP"
-        EVENT_ZOOM_START = "Map.EVENT_ZOOM_START"
-        
-        #+container+ is the DIV element in the page that will host the SWF map
-        def initialize(container, options={})
-          @container = container
-          @latlon = options[:latlon]
-          @location = options[:location] || ""
-          @zoom = options[:zoom] || 14
-          @view_type = options[:view_type] || MapViews::MAP
-          @init = ""
-        end
-        
-        #returns HTML code to add the necessary include and css code to initialize the map
-        def header
-          "<script type='text/javascript' src='http://api.maps.yahoo.com/v3.0/fl/javascript/apiloader.js?appid=#{Ym4r::APP_ID}'></script>\n"
-        end
-        
-        def header_width_height(width,height)
-          "<style type='text/css'>\n##{@container} {\n  height: #{@height}px;\n  width: #{@width}px;\n}\n</style>\n"
-        end
-        
-        def record_init(code)
-          @init << code
-        end
-        
-        #creates the map and add any initialization javascript code returned by the block (like addition of a set of initial markers or other custom code). 
-        def to_html(with_script_tag = true)
-          html = ""
-          html << "<script type=\"text/javascript\">\n" if with_script_tag
-          html << @init
-          html << "</script>\n" if with_script_tag
-          html
-        end
-        
-        def create
-          unless @latlon.nil?
-            "new Map('#{@container}','#{Ym4r::APP_ID}',#{@latlon.to_javascript},#{@zoom},#{@view_type.to_javascript})"
-          else
-            "new Map('#{@container}','#{Ym4r::APP_ID}','#{@location}',#{@zoom},#{@view_type.to_javascript})"
-          end
-        end
-      end  
-    end
-  end
-end