agrismart_ruby_mapnik 0.1.6

data/test/test_mapnik_stroke.rb

@@ -0,0 +1,94 @@
+require "test_helper"
+
+class TestMapnikStroke < Test::Unit::TestCase
+  
+  def setup
+    @color = Mapnik::Color.new("#ccc")
+    @stroke = Mapnik::Stroke.new(@color, 1.0)
+  end
+  
+  def test_should_instantiate
+    assert @stroke
+  end
+  
+  def test_should_get_and_set_color
+    assert @stroke.color == @color
+    new_color = Mapnik::Color.new("#fff")
+    @stroke.color = new_color
+    assert @stroke.color == new_color
+  end
+  
+  def test_should_get_and_set_opacity
+    opacity_before = @stroke.opacity
+    assert_equal 1, opacity_before
+    
+    new_opacity = 0.5
+    @stroke.opacity = new_opacity
+    assert_equal new_opacity, @stroke.opacity
+  end
+  
+  def test_should_get_and_set_gamma
+
+    gamma_before = @stroke.gamma
+    assert_equal 1, gamma_before
+    
+    new_gamma = 0.5
+    @stroke.gamma = new_gamma
+    assert_equal new_gamma, @stroke.gamma
+  end
+  
+  def test_should_get_and_set_width
+    width_before = @stroke.width
+    assert_equal 1, width_before
+    
+    new_width = 0.5
+    @stroke.width = new_width
+    assert_equal new_width, @stroke.width
+  end
+  
+  def test_should_have_line_caps
+    assert Mapnik::LineCap
+    assert Mapnik::LineCap::BUTT_CAP
+    assert Mapnik::LineCap::SQUARE_CAP
+    assert Mapnik::LineCap::ROUND_CAP
+  end
+  
+  def test_should_have_line_joins
+    assert Mapnik::LineJoin
+    assert Mapnik::LineJoin::MITER_JOIN
+    assert Mapnik::LineJoin::MITER_REVERT_JOIN
+    assert Mapnik::LineJoin::ROUND_JOIN
+    assert Mapnik::LineJoin::BEVEL_JOIN
+  end
+  
+  def test_should_get_and_set_line_cap
+    Mapnik::LineCap.constants.each do |const_name|
+      const = Mapnik::LineCap.const_get(const_name)
+      @stroke.line_cap = const
+      assert_equal const, @stroke.line_cap
+    end
+  end
+  
+  def test_should_get_and_set_line_join
+    Mapnik::LineJoin.constants.each do |const_name|
+      const = Mapnik::LineJoin.const_get(const_name)
+      @stroke.line_join = const
+      assert_equal const, @stroke.line_join
+    end
+  end
+  
+  def test_should_have_dashes
+    assert_equal 0, @stroke.dashes.length
+    dash_hash = {:gap => 1, :length => 1.2}
+    @stroke.dashes << dash_hash
+    assert_equal dash_hash, @stroke.dashes.first
+    assert_equal 1, @stroke.dashes.length
+  end
+  
+  def test_should_have_dash_offset
+    assert_equal 0, @stroke.dash_offset
+    @stroke.dash_offset = 1.4
+    assert_equal 1.4, @stroke.dash_offset 
+  end
+  
+end

data/test/test_mapnik_style.rb

@@ -0,0 +1,28 @@
+require "test_helper"
+
+class TestMapnikStyle < Test::Unit::TestCase
+  
+  def test_presence
+    assert Mapnik::Style
+  end
+  
+  def test_should_have_rules
+    style = Mapnik::Style.new
+    assert style.rules.empty?
+    rule = Mapnik::Rule.new
+    style.rules << rule
+    assert !style.rules.empty?
+  end
+  
+  def test_should_have_filter_types
+    assert Mapnik::FilterMode::ALL
+    assert Mapnik::FilterMode::FIRST
+  end
+  
+  def test_should_get_and_set_filter
+    style = Mapnik::Style.new
+    style.filter_mode = Mapnik::FilterMode::ALL
+    assert_equal Mapnik::FilterMode::ALL, style.filter_mode
+  end
+  
+end

data/test/test_mapnik_symbolizer.rb

@@ -0,0 +1,9 @@
+require "test_helper"
+
+class TestMapnikSymbolizer < Test::Unit::TestCase
+  
+  def test_presence
+    assert Mapnik::Symbolizer
+  end
+  
+end

data/test/test_mapnik_text_symbolizer.rb

@@ -0,0 +1,215 @@
+require "test_helper"
+
+class TestMapnikTextSymbolizer < Test::Unit::TestCase
+  
+  def setup
+    expression = Mapnik::Expression.parse("([place]='town')")
+    @symbolizer = Mapnik::TextSymbolizer.new(expression, "DejaVu Sans Book", 10, Mapnik::Color.new("#fff"))
+  end
+  
+  def test_should_instantiate
+    assert @symbolizer
+  end
+  
+  def test_enums_should_exist
+    assert Mapnik::LABEL_PLACEMENT::LINE_PLACEMENT
+    assert Mapnik::LABEL_PLACEMENT::POINT_PLACEMENT
+    assert Mapnik::LABEL_PLACEMENT::VERTEX_PLACEMENT
+    assert Mapnik::LABEL_PLACEMENT::INTERIOR_PLACEMENT
+
+    assert Mapnik::VERTICAL_ALIGNMENT::TOP
+    assert Mapnik::VERTICAL_ALIGNMENT::MIDDLE
+    assert Mapnik::VERTICAL_ALIGNMENT::BOTTOM
+    assert Mapnik::VERTICAL_ALIGNMENT::AUTO
+
+    assert Mapnik::HORIZONTAL_ALIGNMENT::LEFT
+    assert Mapnik::HORIZONTAL_ALIGNMENT::MIDDLE
+    assert Mapnik::HORIZONTAL_ALIGNMENT::RIGHT
+
+    assert Mapnik::JUSTIFY_ALIGNMENT::LEFT
+    assert Mapnik::JUSTIFY_ALIGNMENT::MIDDLE
+    assert Mapnik::JUSTIFY_ALIGNMENT::RIGHT
+
+    assert Mapnik::TEXT_TRANSFORM::NONE
+    assert Mapnik::TEXT_TRANSFORM::UPPERCASE
+    assert Mapnik::TEXT_TRANSFORM::LOWERCASE
+    assert Mapnik::TEXT_TRANSFORM::CAPITALIZE
+  end
+  
+  def test_should_get_and_set_allow_overlap
+    @symbolizer.allow_overlap = true
+    assert @symbolizer.allow_overlap?
+    @symbolizer.allow_overlap = false
+    assert !@symbolizer.allow_overlap?
+  end
+
+  def test_should_get_and_set_displacement
+    assert @symbolizer.displacement
+    new_vals = [1,2]
+    @symbolizer.displacement = new_vals
+    assert_equal new_vals, @symbolizer.displacement
+  end
+  
+  def test_should_get_and_set_avoid_edges
+    @symbolizer.avoid_edges = true
+    assert @symbolizer.avoid_edges?
+    @symbolizer.avoid_edges = false
+    assert !@symbolizer.avoid_edges?
+  end
+  
+  def test_should_get_and_set_character_spacing
+    assert_equal 0, @symbolizer.character_spacing
+    @symbolizer.character_spacing = 1
+    assert_equal 1, @symbolizer.character_spacing
+  end
+
+  def test_should_get_and_set_face_name
+    assert_equal "DejaVu Sans Book", @symbolizer.face_name
+    @symbolizer.face_name = "DejaVu Sans"
+    assert_equal "DejaVu Sans", @symbolizer.face_name
+  end
+  
+  def test_should_get_and_set_fill
+    assert @symbolizer.fill.instance_of?(Mapnik::Color)
+    white = Mapnik::Color.new("#fff")
+    @symbolizer.fill = white
+    assert_equal white, @symbolizer.fill
+  end
+  
+  # TODO: Need fontset
+  # def test_should_get_and_set_fontset
+  #   raise @symbolizer.fontset.inspect
+  # end
+  
+  def test_should_get_and_set_force_odd_labels
+    @symbolizer.force_odd_labels = true
+    assert @symbolizer.force_odd_labels?
+    @symbolizer.force_odd_labels = false
+    assert !@symbolizer.force_odd_labels?  
+  end
+  
+  def test_should_get_and_set_halo_fill
+    assert @symbolizer.halo_fill.instance_of?(Mapnik::Color)
+    white = Mapnik::Color.new("#fff")
+    @symbolizer.halo_fill = white
+    assert_equal white, @symbolizer.halo_fill
+  end
+  
+  def test_should_get_and_set_halo_radius
+    assert_equal 0, @symbolizer.halo_radius
+    @symbolizer.halo_radius = 1
+    assert_equal 1, @symbolizer.halo_radius
+  end
+  
+  def test_should_get_and_set_horizontal_alignment
+    @symbolizer.horizontal_alignment = Mapnik::HORIZONTAL_ALIGNMENT::LEFT
+    assert_equal Mapnik::HORIZONTAL_ALIGNMENT::LEFT, @symbolizer.horizontal_alignment
+    
+    @symbolizer.horizontal_alignment = Mapnik::HORIZONTAL_ALIGNMENT::MIDDLE
+    assert_equal Mapnik::HORIZONTAL_ALIGNMENT::MIDDLE, @symbolizer.horizontal_alignment
+    
+    @symbolizer.horizontal_alignment = Mapnik::HORIZONTAL_ALIGNMENT::RIGHT
+    assert_equal Mapnik::HORIZONTAL_ALIGNMENT::RIGHT, @symbolizer.horizontal_alignment
+  end
+  
+  def test_should_get_and_set_justify_alignment
+    check_constant_setting(Mapnik::JUSTIFY_ALIGNMENT, :justify_alignment)
+  end
+  
+  def test_should_get_and_set_label_placement
+    check_constant_setting(Mapnik::LABEL_PLACEMENT, :label_placement)
+  end
+  
+  def test_should_get_and_set_label_position_tolerance
+    assert_equal 0, @symbolizer.label_position_tolerance
+    @symbolizer.label_position_tolerance = 1
+    assert_equal 1, @symbolizer.label_position_tolerance
+  end
+  
+  def test_should_get_and_set_label_spacing
+    assert_equal 0, @symbolizer.label_spacing
+    @symbolizer.label_spacing = 1
+    assert_equal 1, @symbolizer.label_spacing
+  end
+  
+  def test_should_get_and_set_line_spacing
+    assert_equal 0, @symbolizer.line_spacing
+    @symbolizer.line_spacing = 1
+    assert_equal 1, @symbolizer.line_spacing
+  end
+  
+  def test_should_get_and_set_max_char_angle_delta
+    @symbolizer.max_char_angle_delta = 0.5
+    assert_equal 0.5, @symbolizer.max_char_angle_delta
+    @symbolizer.max_char_angle_delta = 0.7
+    assert_equal 0.7, @symbolizer.max_char_angle_delta
+  end
+  
+  def test_should_get_and_set_minimum_distance
+    assert_equal 0, @symbolizer.minimum_distance
+    @symbolizer.minimum_distance = 1
+    assert_equal 1, @symbolizer.minimum_distance
+  end
+  
+  def test_should_get_and_set_minimum_padding
+    assert_equal 0, @symbolizer.minimum_padding
+    @symbolizer.minimum_padding = 1
+    assert_equal 1, @symbolizer.minimum_padding
+  end
+  
+  def test_should_get_and_set_opactiy
+    assert_equal 1, @symbolizer.opacity
+    @symbolizer.opacity = 0
+    assert_equal 0, @symbolizer.opacity
+  end
+  
+  def test_should_get_and_set_text_transform
+    check_constant_setting(Mapnik::TEXT_TRANSFORM, :text_transform)
+  end
+  
+  def test_should_get_and_set_text_ratio
+    assert_equal 0, @symbolizer.ratio
+    @symbolizer.ratio = 3
+    assert_equal 3, @symbolizer.ratio
+  end
+  
+  def test_should_get_and_set_text_size
+    assert_equal 10, @symbolizer.size
+    @symbolizer.size = 0
+    assert_equal 0, @symbolizer.size
+  end
+  
+  def test_should_get_and_set_vertical_alignment
+    check_constant_setting(Mapnik::VERTICAL_ALIGNMENT, :vertical_alignment)
+  end
+  
+  def test_should_get_and_set_wrap_width
+    assert_equal 0, @symbolizer.wrap_width
+    @symbolizer.wrap_width = 30
+    assert_equal 30, @symbolizer.wrap_width
+  end
+  
+  def test_should_get_and_set_wrap_character
+    @symbolizer.wrap_character = '|'
+    assert_equal '|', @symbolizer.wrap_character
+    @symbolizer.wrap_character = '%'
+    assert_equal '%', @symbolizer.wrap_character
+  end
+  
+  def test_should_get_and_set_wrap_before
+    assert !@symbolizer.wrap_before
+    @symbolizer.wrap_before = true
+    assert @symbolizer.wrap_before
+  end
+  
+private  
+  
+  def check_constant_setting(enum, property)
+    enum.constants.each do |const_name|
+      const = enum.const_get(const_name)
+      @symbolizer.send(property.to_s + '=', const)
+      assert_equal const, @symbolizer.send(property)
+    end
+  end
+  
+end

data/test/test_polygon_pattern_symbolizer.rb

@@ -0,0 +1,34 @@
+require "test_helper"
+
+class TestPolygonPatternSymbolizer < Test::Unit::TestCase
+  
+  def setup
+    @filename = "/my/file.png"
+    path_expression = Mapnik::PathExpression.parse("/my/file.png")
+    @sym = Mapnik::PolygonPatternSymbolizer.new(path_expression)
+  end
+  
+  def test_presence
+    assert Mapnik::PolygonPatternSymbolizer
+    assert Mapnik::PatternAlignment::LOCAL
+    assert Mapnik::PatternAlignment::GLOBAL
+  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_pattern_alignment
+    assert_equal Mapnik::PatternAlignment::LOCAL, @sym.alignment
+    @sym.alignment = Mapnik::PatternAlignment::GLOBAL
+    assert_equal Mapnik::PatternAlignment::GLOBAL, @sym.alignment
+  end
+  
+end

data/test/test_ruby_mapnik.rb

@@ -0,0 +1,34 @@
+=begin 
+ ******************************************************************************
+ * 
+ * Copyright (C) 2011 Elliot Laster
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ ******************************************************************************
+=end
+require 'test_helper'
+
+class TestRubyMapnik < Test::Unit::TestCase
+  
+  def test_sanity
+    assert Mapnik
+  end
+  
+  def test_should_register_datasources_on_inclusion
+    assert Mapnik::DatasourceCache.available_plugins.any?
+  end
+  
+end

data/yard/lib/yard/parser/generic_parser.rb

@@ -0,0 +1,72 @@
+module YARD
+  module Parser
+    class GenericParser < CParser
+      
+      def initialize(source, file = '(stdin)')
+        @file = file
+        @namespaces = {}
+        @content = clean_source(source)
+      end
+      
+      def parse
+        parse_modules
+        parse_classes
+        parse_methods
+        # parse_constants
+        # parse_includes
+      end
+      
+      def parse_modules
+        @content.scan(/@@Module_var\s*(\w+) = \s*(\w+)/) do |var_name, module_name|
+          handle_module(var_name, module_name)
+        end
+      end
+      
+      def parse_classes
+        @content.scan(/Data_Type< .+ >\s*(\w+)\s*=\s*.+define_class_under<.+>\(\s*(\w+),\s*"(\w+)"/) do |var_name, in_module, class_name|
+          handle_class(var_name, class_name, nil, in_module)
+        end
+      end
+      
+      def parse_methods
+        @content.scan(/(\w+)\.define_(method|singleton_method)\(\s*"(.+)",.+\)/) do |var_name, type, name|
+          handle_method(type, var_name, name, nil, nil) unless nodoc?(name)
+        end
+
+        @content.scan(/(\w+)\.define_constructor\(.+\)/) do |var_name|
+          handle_method("singleton_method", var_name.first, "new" , nil, nil)
+        end
+      end
+      
+      def nodoc?(name, content=@content)
+        name == 'initialize' || content =~ %r{Dont-Document-method:\s#{name}}m
+      end
+      
+      def find_method_body(object, func_name, content = @content)        
+        # No body, but might still have an override comment
+        comment = find_override_comment(object)
+        object.docstring = parse_comments(object, comment) if comment
+      end
+      
+      def find_override_comment(object, content = @content)
+        name = Regexp.escape(object.name.to_s)
+        class_name = object.parent.path
+        if content =~ %r{Document-method:\s+#{class_name}(?:\.|::|#)#{name}\s*?\n((?>.*?\*/))}m then
+          $1
+        elsif content =~ %r{Document-method:\s#{name}\s*?\n((?>.*?\*/))}m then
+          $1
+        else
+          nil
+        end
+      end
+      
+      # def clean_source(source)
+      #   # source = handle_ifdefs_in(source)
+      #   # source = handle_tab_width(source)
+      #   # source = remove_commented_out_lines(source)
+      #   source
+      # end
+      
+    end
+  end
+end