ruby_mapnik 0.1

data/test/test_mapnik_glyph_symbolizer.rb

@@ -0,0 +1,96 @@
+require "test_helper"
+
+class TestMapnikGlyphSymbolizer < Test::Unit::TestCase
+  
+  def setup 
+    expression = Mapnik::Expression.parse("[g]")
+    @sym = Mapnik::GlyphSymbolizer.new("DejaVu Sans Book",expression)
+  end
+  
+  def test_presence
+    assert Mapnik::GlyphSymbolizer
+    assert Mapnik::AngleMode::AZIMUTH
+    assert Mapnik::AngleMode::TRIGONOMETRIC
+  end
+  
+  def test_should_get_and_set_face_name
+    assert_equal 'DejaVu Sans Book', @sym.face_name
+    new_face_name = 'DejaVu Sans'
+    @sym.face_name = new_face_name
+    assert_equal new_face_name, @sym.face_name
+  end
+  
+  def test_should_get_and_set_char
+    assert @sym.char.instance_of?(Mapnik::Expression)
+    @sym.char = Mapnik::Expression.parse("[t]")
+  end
+  
+  def test_should_get_and_set_allow_overlap
+    @sym.allow_overlap = true
+    assert @sym.allow_overlap?
+    @sym.allow_overlap = false
+    assert !@sym.allow_overlap?
+  end
+  
+  def test_should_get_and_set_avoid_edges
+    @sym.avoid_edges = true
+    assert @sym.avoid_edges?
+    @sym.avoid_edges = false
+    assert !@sym.avoid_edges?
+  end
+  
+  def test_should_get_and_set_displacement
+    assert @sym.displacement
+    new_vals = [1,2]
+    @sym.displacement = new_vals
+    assert_equal new_vals, @sym.displacement
+  end
+  
+  def test_should_get_and_set_halo_fill
+    assert @sym.halo_fill.instance_of?(Mapnik::Color)
+    white = Mapnik::Color.new("#fff")
+    @sym.halo_fill = white
+    assert_equal white, @sym.halo_fill
+  end
+  
+  def test_should_get_and_set_halo_radius
+    assert_equal 0, @sym.halo_radius
+    @sym.halo_radius = 1
+    assert_equal 1, @sym.halo_radius
+  end
+  
+  def test_should_get_and_set_size
+    @sym.size = Mapnik::Expression.parse("[12]")
+    assert @sym.size.instance_of?(Mapnik::Expression)
+  end
+  
+  def test_should_get_and_set_angle
+    @sym.angle = Mapnik::Expression.parse("[90]")
+    assert @sym.angle.instance_of?(Mapnik::Expression)
+  end
+  
+  def test_should_get_and_set_angle_mode
+    @sym.angle_mode = Mapnik::AngleMode::AZIMUTH
+    assert_equal Mapnik::AngleMode::AZIMUTH, @sym.angle_mode
+    @sym.angle_mode = Mapnik::AngleMode::TRIGONOMETRIC
+    assert_equal Mapnik::AngleMode::TRIGONOMETRIC, @sym.angle_mode
+  end
+  
+  def test_should_get_and_set_value
+    @sym.value = Mapnik::Expression.parse("[town]")
+    assert @sym.value.instance_of?(Mapnik::Expression)
+  end
+  
+  # FIXME: Need Expression equality?
+  def test_should_get_and_set_color
+     @sym.color = Mapnik::Expression.parse("[90, 90, 90]")
+     assert @sym.angle.instance_of?(Mapnik::Expression)
+  end
+  
+  # TODO: Colorizer support
+  # def test_should_get_and_set_colorizer
+  #   colorizer = Mapnik::RasterColorizer.new
+  #   @sym.colorizer = colorizer
+  # end
+  
+end

data/test/test_mapnik_layer.rb

@@ -0,0 +1,137 @@
+require "test_helper"
+
+class TestMapnikLayer < Test::Unit::TestCase
+    
+  def test_presence
+    assert Mapnik::Layer
+  end
+  
+  def test_should_initialize
+    assert layer = Mapnik::Layer.new("My Layer", "+proj=latlong +datum=WGS84")
+  end
+  
+  def test_should_have_datasource
+    layer = build_layer
+    assert layer.datasource.envelope
+  end
+  
+  def test_should_have_same_enevelope_as_datasource
+    layer = build_layer
+    assert layer.envelope.kind_of?(Mapnik::Envelope)
+    assert_equal layer.envelope, layer.datasource.envelope
+  end
+  
+  def test_should_get_and_set_name
+    layer = build_layer
+    name_before = layer.name
+    new_name = name_before + "BUT DIFFERENT"
+    layer.name = new_name
+    assert_equal new_name, layer.name
+  end
+  
+  def test_should_get_and_set_title
+    layer = build_layer
+    title_before = layer.title
+    new_title = title_before + "BUT DIFFERENT"
+    layer.title = new_title
+    assert_equal new_title, layer.title
+  end
+  
+  def test_should_get_and_set_abstract
+    layer = build_layer
+    abstract_before = layer.abstract
+    new_abstract = abstract_before + "BUT DIFFERENT"
+    layer.abstract = new_abstract
+    assert_equal new_abstract, layer.abstract
+  end
+  
+  def test_should_get_and_set_srs
+    layer = build_layer
+    srs_before = layer.srs
+    new_srs = '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs'
+    layer.srs = new_srs
+    assert_equal new_srs, layer.srs
+  end
+  
+  def test_should_get_and_set_min_zoom
+    layer = build_layer
+    min_zoom_before = layer.min_zoom
+    new_min_zoom = min_zoom_before + 1.2
+    layer.min_zoom = new_min_zoom
+    assert_equal new_min_zoom, layer.min_zoom
+  end
+  
+  def test_should_get_and_set_max_zoom
+    layer = build_layer
+    max_zoom_before = layer.max_zoom
+    new_max_zoom = max_zoom_before + 1.2
+    layer.max_zoom = new_max_zoom
+    assert_equal new_max_zoom, layer.max_zoom
+  end
+  
+  def test_should_know_if_it_is_visible_at_a_given_scale
+    layer = build_layer
+    layer.min_zoom = 0.0
+    assert layer.visible_at_scale?(1.0/1000000)
+    layer.min_zoom = 2.0
+    assert !layer.visible_at_scale?(1.0/1000000)
+  end
+  
+  def test_should_know_if_it_is_active
+    layer = build_layer
+    assert layer.active?
+    layer.active = false
+    assert !layer.active?
+    layer.active = true
+    assert layer.active?
+  end
+  
+  def test_should_know_if_it_is_queryable
+    layer = build_layer
+    assert !layer.queryable?
+    layer.queryable = true
+    assert layer.queryable?
+    layer.queryable = false
+    assert !layer.queryable?
+  end
+  
+  def test_should_know_if_it_should_cache_features
+    layer = build_layer
+    assert !layer.cache_features?
+    layer.cache_features = true
+    assert layer.cache_features?
+    layer.cache_features = false
+    assert !layer.cache_features?
+  end
+  
+  def test_should_know_if_it_should_clear_its_label_cache
+    layer = build_layer
+    assert !layer.clear_label_cache?
+    layer.clear_label_cache = true
+    assert layer.clear_label_cache?
+    layer.clear_label_cache = false
+    assert !layer.clear_label_cache?
+  end
+  
+  def test_should_have_styles
+    layer = build_layer
+    assert layer.styles.instance_of?(Mapnik::LayerStyleContainer)
+    assert layer.styles.empty?
+    style_name = 'My Style'
+    layer.styles << style_name
+    assert !layer.styles.empty?
+    assert_equal style_name, layer.styles.first
+  end
+  
+private
+
+  def build_layer
+    layer = Mapnik::Layer.new("My Layer", "+proj=latlong +datum=WGS84")
+    layer.datasource = Mapnik::Datasource.create(
+      :type => 'shape',
+      :file => SHAPEFILE
+    )
+    layer
+  end
+  
+end

data/test/test_mapnik_line_symbolizer.rb

@@ -0,0 +1,25 @@
+require "test_helper"
+
+class TestMapnikLineSymbolizer < Test::Unit::TestCase
+  
+  def test_presence
+    assert Mapnik::LineSymbolizer
+  end
+  
+  def test_should_instantiate
+    assert Mapnik::LineSymbolizer.new
+  end
+  
+  def test_should_get_and_set_stroke
+    line = Mapnik::LineSymbolizer.new
+    stroke_before = line.stroke
+    assert stroke_before.kind_of?(Mapnik::Stroke)
+    
+    new_stroke = Mapnik::Stroke.new(Mapnik::Color.new("#fff"), 1.0)
+    line.stroke = new_stroke
+    
+    # Once Equality for strokes is established
+    # assert_equal new_stroke, line.stroke
+  end
+  
+end

data/test/test_mapnik_map.rb

@@ -0,0 +1,191 @@
+require "test_helper"
+
+class TestMapnikMap < Test::Unit::TestCase
+      
+  def setup
+    @map = Mapnik::Map.new
+  end
+  
+  def test_should_initialize
+    assert @map
+  end
+  
+  def test_should_have_envelope
+    assert @map.envelope.kind_of?(Mapnik::Envelope)
+  end
+  
+  def test_should_have_styles
+    assert @map.styles.instance_of?(Mapnik::MapStyleContainer)
+    assert @map.styles.empty?
+    
+    key = "My Style"
+    @map.styles[key] = Mapnik::Style.new
+    assert @map.styles.any?
+    assert @map.styles[key].is_a?(Mapnik::Style)
+    
+    @map.styles.delete(key)
+    assert @map.styles.empty?
+  end
+  
+  def test_should_have_buffered_envelope
+    envelope_before = @map.envelope
+    assert_equal 0, @map.buffer_size
+    buffered_envelope_before = @map.buffered_envelope
+    assert_equal envelope_before, buffered_envelope_before
+    
+    @map.buffer_size = 1
+    
+    assert_equal 1, @map.buffer_size
+    assert_equal envelope_before, @map.envelope
+    assert_not_equal buffered_envelope_before, @map.buffered_envelope    
+  end
+  
+  def test_should_pan
+    center_before = @map.envelope.center
+    @map.pan(-1,-1)
+    assert_not_equal center_before, @map.envelope.center
+  end
+  
+  def test_should_get_and_set_background
+    assert @map.background.nil?
+    color = Mapnik::Color.new("#fff")
+    @map.background = color
+    assert_equal color, @map.background
+  end
+  
+  def test_should_zoom
+    scale_before = @map.scale
+    @map.zoom(2)    
+  end
+  
+  def test_should_zoom_all    
+    # Override since there are no layers
+    @map.maximum_extent = Mapnik::Envelope.new(-180,-90,180,90)
+    @map.zoom_all
+  end
+  
+  def test_should_resize    
+    width_before = @map.width
+    height_before = @map.height
+    
+    new_width = width_before + 1
+    new_height = height_before + 1
+    @map.resize(new_width, new_height)
+    assert_equal(new_width, @map.width)
+    assert_equal(new_height, @map.height)
+  end
+  
+  def test_should_have_scale
+    assert @map.scale.kind_of?(Float)
+  end
+  
+  def test_should_zoom_to_box
+    box = Mapnik::Envelope.new(1,1,1,1)
+    @map.zoom_to_box(box)
+  end
+  
+  def test_mapnik_base_path
+    assert @map.base_path.kind_of?(String)
+    assert_equal "", @map.base_path
+    new_base_path = "/some/path"
+    @map.base_path = new_base_path
+    assert_equal new_base_path, @map.base_path
+  end
+  
+  def test_should_get_and_set_buffer_size
+    assert_equal 0, @map.buffer_size
+    new_buffer_size = 1
+    @map.buffer_size = new_buffer_size
+    assert_equal new_buffer_size, @map.buffer_size
+  end
+  
+  def test_should_get_and_set_height
+    assert_equal 400, @map.height
+    new_height = 401
+    @map.height = new_height
+    assert_equal new_height, @map.height
+  end
+  
+  def test_should_get_and_set_maximum_extent
+    assert_nil @map.maximum_extent
+    new_max_extent = Mapnik::Envelope.new(-180,-90,180,90)
+    @map.maximum_extent = new_max_extent
+    assert_equal new_max_extent, @map.maximum_extent
+  end
+  
+  def test_should_get_and_set_srs
+    assert_equal "+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs", @map.srs
+    new_srs = "+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs +over"
+    @map.srs = new_srs
+    assert_equal new_srs, @map.srs
+  end
+  
+  def test_should_get_and_set_width
+    width_before = @map.width
+    new_width = width_before + 1
+    @map.width = new_width
+    assert_equal new_width, @map.width
+  end
+  
+  def test_should_have_layers
+    assert @map.layers.empty?
+    layer = Mapnik::Layer.new("My Layer", "+proj=latlong +datum=WGS84")
+    @map.layers << layer
+    assert @map.layers.any?
+    
+    @map.layers.clear
+    assert @map.layers.empty?
+  end
+  
+  def test_should_output_to_xml
+    map = build_complete_map
+    assert map.to_xml.instance_of?(String)
+    assert map.to_xml.include?("<?xml")
+  end
+
+  def test_should_render_to_file
+    map = build_complete_map
+    filename = File.join(File.expand_path(File.dirname(__FILE__)), "../tmp/world.png")
+    assert_equal 0, File.size(filename) if File.exists?(filename)
+    map.render_to_file(filename)
+    File.delete(filename)
+  end
+  
+  def test_should_load_from_xml_string
+    map_1 = build_complete_map
+    map_2 = Mapnik::Map.from_xml(map_1.to_xml)
+    assert_equal map_1.layers.count, map_2.layers.count
+    assert_equal map_1.srs, map_2.srs
+  end
+  
+  def test_should_load_from_file
+    file_path = File.join(File.expand_path(File.dirname(__FILE__)), "data", "test_map.xml")
+    map = Mapnik::Map.from_file(file_path)
+    assert map.layers.any?
+    assert map.styles['My Style']
+  end
+  
+private
+  
+  def build_complete_map
+    map = Mapnik::Map.new
+    map.width = 600
+    map.height = 300
+    map.srs = "+proj=latlong +datum=WGS84"
+    map.background = Mapnik::Color.new("#0000FF")
+    style = Mapnik::Style.new
+    rule = Mapnik::Rule.new
+    poly = Mapnik::PolygonSymbolizer.new
+    poly.fill = Mapnik::Color.new("#FF0088")
+    rule.symbols << poly
+    style.rules << rule
+    map.styles["My Style"]=style
+    layer = Mapnik::Layer.new('world',"+proj=latlong +datum=WGS84")
+    layer.datasource = Mapnik::Datasource.create(:type => "shape", :file => SHAPEFILE)
+    layer.styles << "My Style"
+    map.layers << layer
+    map.zoom_to_box(layer.envelope)
+    map
+  end
+  
+end

data/test/test_mapnik_markers_symbolizer.rb

@@ -0,0 +1,46 @@
+require "test_helper"
+
+class TestMarkersSymbolizer < Test::Unit::TestCase
+  
+  def setup
+    @filename = "/my/file.png"
+    path_expression = Mapnik::PathExpression.parse("/my/file.png")
+    @sym = Mapnik::MarkersSymbolizer.new(path_expression)
+  end
+  
+  def test_should_instantiate
+    assert @sym
+  end
+  
+  def test_should_get_and_set_filename
+    assert_equal @filename, @sym.filename
+    new_filename = "/something/else.png"
+    @sym.filename = new_filename
+    assert_equal new_filename, @sym.filename
+  end
+  
+  def test_should_get_and_set_allow_overlap
+    @sym.allow_overlap = true
+    assert @sym.allow_overlap?
+    @sym.allow_overlap = false
+    assert !@sym.allow_overlap?
+  end
+  
+  def test_should_get_and_set_spacing
+    @sym.spacing = 90
+    assert_equal 90, @sym.spacing
+  end
+  
+  def test_should_get_and_set_max_error
+    @sym.max_error = 90
+    assert_equal 90, @sym.max_error
+  end
+  
+  def test_should_get_and_set_opacity
+    assert_equal 1, @sym.opacity
+    # new_opacity = 0.5
+    # @sym.opacity = new_opacity
+    # assert_equal new_opacity, @sym.opacity
+  end
+  
+end

data/test/test_mapnik_point_symbolizer.rb

@@ -0,0 +1,53 @@
+require "test_helper"
+
+class TestMapnikPointSymbolizer < Test::Unit::TestCase
+  
+  def setup
+    @sym = Mapnik::PointSymbolizer.new
+  end
+  
+  def test_presence
+    assert Mapnik::PointSymbolizer
+    assert Mapnik::PointPlacement::CENTROID
+    assert Mapnik::PointPlacement::INTERIOR
+  end
+  
+  def test_should_initialize
+    assert @sym
+  end
+  
+  def test_should_get_and_set_filename
+    assert_equal "", @sym.filename
+    new_filename = "/my/incredible/graphic.png"
+    @sym.filename = new_filename
+    assert_equal new_filename, @sym.filename
+  end
+  
+  def test_should_get_and_set_allows_overlap
+    assert !@sym.allows_overlap?
+    @sym.allows_overlap = true
+    assert @sym.allows_overlap?
+    @sym.allows_overlap = false
+    assert !@sym.allows_overlap?
+  end
+  
+  def test_should_get_and_set_opacity
+    assert_equal 1, @sym.opacity
+    new_opacity = 0.5
+    @sym.opacity = new_opacity
+    assert_equal new_opacity, @sym.opacity
+  end
+  
+  def test_should_get_and_set_ignore_placement
+    assert !@sym.ignores_placement?
+    @sym.ignores_placement = true
+    assert @sym.ignores_placement?
+  end
+  
+  def test_should_get_and_set_placement
+    assert_equal Mapnik::PointPlacement::CENTROID, @sym.placement
+    @sym.placement = Mapnik::PointPlacement::INTERIOR
+    assert_equal Mapnik::PointPlacement::INTERIOR, @sym.placement
+  end
+  
+end

data/test/test_mapnik_polygon_symbolizer.rb

@@ -0,0 +1,44 @@
+require "test_helper"
+
+class TestMapnikPolygonSymbolizer < Test::Unit::TestCase
+  
+  def test_presence
+    assert Mapnik::PolygonSymbolizer
+  end
+  
+  def test_should_instantiate
+    assert Mapnik::PolygonSymbolizer.new
+  end
+  
+  def test_should_get_and_set_fill_to_a_color
+    polygon = Mapnik::PolygonSymbolizer.new
+    color_before = polygon.fill
+    assert color_before.kind_of?(Mapnik::Color)
+    
+    new_color = Mapnik::Color.new("#000")
+    polygon.fill = new_color
+    
+    assert [:red, :green, :blue, :alpha].all?{|x| polygon.fill.send(x) == new_color.send(x)}
+  end
+  
+  def test_should_get_and_set_opacity
+    polygon = Mapnik::PolygonSymbolizer.new
+    opacity_before = polygon.opacity
+    assert_equal 1, opacity_before
+    
+    new_opacity = 0.5
+    polygon.opacity = new_opacity
+    assert_equal new_opacity, polygon.opacity
+  end
+  
+  def test_should_get_and_set_gamma
+    polygon = Mapnik::PolygonSymbolizer.new
+    gamma_before = polygon.gamma
+    assert_equal 1, gamma_before
+    
+    new_gamma = 0.5
+    polygon.gamma = new_gamma
+    assert_equal new_gamma, polygon.gamma
+  end
+  
+end

data/test/test_mapnik_projection.rb

@@ -0,0 +1,46 @@
+require "test_helper"
+
+class TestMapnikProjection < Test::Unit::TestCase
+  
+  PARAMS = '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs'
+  
+  def test_presence
+    assert Mapnik::Projection
+  end
+  
+  def test_should_instantiate_and_return_params
+    assert proj = Mapnik::Projection.new(PARAMS)
+    assert_equal PARAMS, proj.params
+  end
+  
+  def test_should_return_expanded_params
+    assert proj = Mapnik::Projection.new(PARAMS)
+    assert_not_equal PARAMS, proj.expanded_params
+    assert proj.expanded_params.include?(PARAMS)
+  end
+  
+  def test_should_respond_to_geographic
+    assert Mapnik::Projection.new(PARAMS).geographic?
+  end
+  
+  def test_should_inverse_points
+    proj = Mapnik::Projection.new(PARAMS)
+    assert proj.inverse(Mapnik::Coord2d.new(2,3))
+  end
+  
+  def test_should_inverse_envelopes
+    proj = Mapnik::Projection.new(PARAMS)
+    assert proj.inverse(Mapnik::Envelope.new(2,3,4,5))
+  end
+  
+  def test_should_forward_points
+    proj = Mapnik::Projection.new(PARAMS)
+    assert proj.forward(Mapnik::Coord2d.new(2,3))
+  end
+  
+  def test_should_forward_envelopes
+    proj = Mapnik::Projection.new(PARAMS)
+    assert proj.forward(Mapnik::Envelope.new(2,3,4,5))
+  end
+  
+end

data/test/test_mapnik_raster_colorizer.rb

@@ -0,0 +1,56 @@
+require "test_helper"
+
+class TestMapnikRasterColorizer < Test::Unit::TestCase
+  
+  def setup
+    @colorizer = Mapnik::RasterColorizer.new
+  end
+  
+  def test_presence
+    assert Mapnik::RasterColorizer
+    ["INHERIT","LINEAR","DISCRETE","EXACT"].each do |colorizer_mode|
+        assert Mapnik::ColorizerMode.const_get(colorizer_mode)
+    end
+    assert Mapnik::ColorizerStop
+  end
+  
+  def test_should_get_and_set_default_color
+    color = Mapnik::Color.new("#fff")
+    @colorizer.default_color = color
+    assert_equal 255, @colorizer.default_color.red
+    assert_equal 255, @colorizer.default_color.green
+    assert_equal 255, @colorizer.default_color.blue
+    assert_equal 255, @colorizer.default_color.alpha
+  end
+  
+  def test_should_get_and_set_default_mode
+    ["LINEAR", "DISCRETE","EXACT"].each do |mode_name|
+      const = Mapnik::ColorizerMode.const_get(mode_name)
+      @colorizer.default_mode = const
+      assert_equal const, @colorizer.default_mode
+    end
+  end
+  
+  def test_should_get_and_set_epsilon
+    @colorizer.epsilon = 5
+    assert_equal 5, @colorizer.epsilon
+  end
+  
+  def test_should_instantiate_a_stop
+    value = 45.5
+    mode = Mapnik::ColorizerMode::EXACT
+    color = Mapnik::Color.new("#fff")
+    assert stop = Mapnik::ColorizerStop.new(value,mode,color)
+    assert_equal value, stop.value
+    assert_equal mode, stop.mode
+    assert_equal color, stop.color 
+  end
+  
+  def test_should_get_and_add_stops
+    assert @colorizer.stops.empty?
+    stop = Mapnik::ColorizerStop.new(45.45, Mapnik::ColorizerMode::EXACT, Mapnik::Color.new("#fff"))
+    @colorizer.stops << stop
+    assert_equal @colorizer.stops.first, stop
+  end
+  
+end