agrismart_ruby_mapnik 0.1.6

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

data/test/test_mapnik_raster_symbolizer.rb

@@ -0,0 +1,45 @@
+require "test_helper"
+
+class TestMapnikRasterSymbolizer < Test::Unit::TestCase
+  
+  def setup
+    @sym = Mapnik::RasterSymbolizer.new
+  end
+  
+  def test_should_have_scaling_method
+    scaling_methods = [:NEAR, :BILINEAR, :BICUBIC, 
+                       :SPLINE16, :SPLINE36, :HANNING, 
+                       :HAMMING, :HERMITE, :KAISER, :QUADRIC, 
+                       :CATROM, :GAUSSIAN, :BESSEL, :MITCHELL, 
+                       :SINC, :LANCZOS, :BLACKMAN, :BILINEAR8]
+    assert_equal scaling_methods, Mapnik::ScalingMethod.constants
+  end
+
+  def test_should_get_and_set_mode
+    possible_values = ["normal", "grain_merge", "grain_merge2", "multiply",
+     "multiply2", "divide", "divide2", "screen", "hard_light"]
+    possible_values.each do |value|
+      @sym.mode = value
+      assert_equal value, @sym.mode
+    end
+  end
+  
+  def test_should_get_and_set_scaling
+    Mapnik::ScalingMethod.constants.each do |const_sym|
+      value =  Mapnik::ScalingMethod.const_get(const_sym)
+      @sym.scaling = value
+      assert_equal value, @sym.scaling
+    end
+  end
+  
+  def test_should_get_and_set_opacity
+    @sym.opacity = 0.5
+    assert_equal 0.5, @sym.opacity
+  end
+  
+  def test_should_get_and_set_filter_factor
+    @sym.filter_factor = 0.5
+    assert_equal 0.5, @sym.filter_factor
+  end
+  
+end

data/test/test_mapnik_rule.rb

@@ -0,0 +1,45 @@
+require "test_helper"
+
+class TestMapnikRule < Test::Unit::TestCase
+  
+  def test_presence
+    assert Mapnik::Rule
+  end
+  
+  def test_should_instantiate
+    assert Mapnik::Rule.new
+  end
+  
+  def test_should_get_and_set_name
+    rule = Mapnik::Rule.new
+    assert_equal("", rule.name)
+    
+    new_name = "New name"
+    rule.name = new_name
+    assert_equal new_name, rule.name
+  end
+    
+  def test_should_get_and_set_filter
+    rule = Mapnik::Rule.new
+    expression_string = "([place]='town')"
+    expression = Mapnik::Expression.parse(expression_string)
+    rule.filter = expression
+    assert_equal expression_string, rule.filter.to_s
+  end
+  
+  def test_should_append_and_remove_symbols
+    rule = Mapnik::Rule.new
+    assert_equal 0, rule.symbols.count
+    rule.symbols << Mapnik::PolygonSymbolizer.new
+    assert_equal 1, rule.symbols.count
+    rule.symbols << Mapnik::LineSymbolizer.new
+    assert_equal 2, rule.symbols.count
+    
+    obj = rule.symbols.delete_at(0)
+    assert obj
+    assert_equal 1, rule.symbols.count
+    assert rule.symbols.pop
+    assert_equal 0, rule.symbols.count
+  end
+  
+end

data/test/test_mapnik_shield_symbolizer.rb

@@ -0,0 +1,163 @@
+require "test_helper"
+
+class TestMapnikShieldSymbolizer < Test::Unit::TestCase
+  
+  def setup
+    expression = Mapnik::Expression.parse("[place]")
+    face_name = "DejaVu Sans Book"
+    fill = Mapnik::Color.new("#fff")
+    file = Mapnik::PathExpression.parse("myfile.png")
+    @sym = Mapnik::ShieldSymbolizer.new(expression, face_name, 12, fill, file)
+  end
+    
+  def test_should_instantiate
+    assert @sym
+  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_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_shield_displacement
+    assert @sym.shield_displacement
+    new_vals = [1,2]
+    @sym.shield_displacement = new_vals
+    assert_equal new_vals, @sym.shield_displacement
+  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_character_spacing
+    assert_equal 0, @sym.character_spacing
+    @sym.character_spacing = 1
+    assert_equal 1, @sym.character_spacing
+  end
+  
+  def test_should_get_and_set_face_name
+    assert_equal "DejaVu Sans Book", @sym.face_name
+    @sym.face_name = "DejaVu Sans"
+    assert_equal "DejaVu Sans", @sym.face_name
+  end
+  
+  def test_should_get_and_set_fill
+    assert @sym.fill.instance_of?(Mapnik::Color)
+    white = Mapnik::Color.new("#fff")
+    @sym.fill = white
+    assert_equal white, @sym.fill
+  end
+  
+  # TODO: Need fontset
+  # def test_should_get_and_set_fontset
+  #   raise @sym.fontset.inspect
+  # end
+  
+  def test_should_get_and_set_force_odd_labels
+    @sym.force_odd_labels = true
+    assert @sym.force_odd_labels?
+    @sym.force_odd_labels = false
+    assert !@sym.force_odd_labels?  
+  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_horizontal_alignment
+    @sym.horizontal_alignment = Mapnik::HORIZONTAL_ALIGNMENT::LEFT
+    assert_equal Mapnik::HORIZONTAL_ALIGNMENT::LEFT, @sym.horizontal_alignment
+    
+    @sym.horizontal_alignment = Mapnik::HORIZONTAL_ALIGNMENT::MIDDLE
+    assert_equal Mapnik::HORIZONTAL_ALIGNMENT::MIDDLE, @sym.horizontal_alignment
+    
+    @sym.horizontal_alignment = Mapnik::HORIZONTAL_ALIGNMENT::RIGHT
+    assert_equal Mapnik::HORIZONTAL_ALIGNMENT::RIGHT, @sym.horizontal_alignment
+  end
+  
+  def test_should_get_and_set_label_position_tolerance
+    assert_equal 0, @sym.label_position_tolerance
+    @sym.label_position_tolerance = 1
+    assert_equal 1, @sym.label_position_tolerance
+  end
+  
+  def test_should_get_and_set_label_spacing
+    assert_equal 0, @sym.label_spacing
+    @sym.label_spacing = 1
+    assert_equal 1, @sym.label_spacing
+  end
+  
+  def test_should_get_and_set_line_spacing
+    assert_equal 0, @sym.line_spacing
+    @sym.line_spacing = 1
+    assert_equal 1, @sym.line_spacing
+  end
+  
+  # TODO: failure here!
+  def test_should_get_and_set_max_char_angle_delta
+    @sym.max_char_angle_delta = 0.5
+    assert_equal 0.5, @sym.max_char_angle_delta
+    @sym.max_char_angle_delta = 0.7
+    assert_equal 0.7, @sym.max_char_angle_delta
+  end
+  
+  def test_should_get_and_set_minimum_distance
+    assert_equal 0, @sym.minimum_distance
+    @sym.minimum_distance = 1
+    assert_equal 1, @sym.minimum_distance
+  end
+  
+  def test_should_get_and_set_minimum_padding
+    assert_equal 0, @sym.minimum_padding
+    @sym.minimum_padding = 1
+    assert_equal 1, @sym.minimum_padding
+  end
+  
+  def test_should_get_and_set_opactiy
+    assert_equal 1, @sym.opacity
+    @sym.opacity = 0
+    assert_equal 0, @sym.opacity
+  end
+  
+  def test_should_get_and_set_text_ratio
+    assert_equal 0, @sym.ratio
+    @sym.ratio = 3
+    assert_equal 3, @sym.ratio
+  end
+  
+  def test_should_get_and_set_wrap_character
+    @sym.wrap_character = '|'
+    assert_equal '|', @sym.wrap_character
+    @sym.wrap_character = '%'
+    assert_equal '%', @sym.wrap_character
+  end
+  
+  def test_should_get_and_set_wrap_before
+    assert !@sym.wrap_before
+    @sym.wrap_before = true
+    assert @sym.wrap_before
+  end
+  
+end