amanzi-sld 0.0.1

data/lib/amanzi/xml.rb

@@ -0,0 +1,152 @@
+#/usr/bin/env ruby
+
+module Amanzi
+  module XML
+    class Element
+      attr_reader :name, :children, :depth
+      attr_accessor :attributes, :namespace
+      def initialize(name,depth=0)
+        @name = name
+        @depth = depth
+        @children = []
+        @attributes = {}
+      end
+      # Utility for setting the namepace in a method-chaining DSL
+      def ns(ns)
+        self.namespace = ns
+        self
+      end
+      def []= (key,value)
+        @attributes[key] = value
+      end
+      def insert index, child
+        @children.insert index, child
+      end
+      def << child
+        @children << child
+      end
+      def make_child(name,options={},&block)
+        child = Element.new(name,depth+1)
+        namespace && (child.namespace = namespace)
+        options.each{|k,v| child[k]=v}
+        block && block.call(child)
+        child
+      end
+      def insert_child(index,name,options={},&block)
+        insert index, child = make_child(name,options,&block)
+        child
+      end
+      def add_child(name,options={},&block)
+        self << child = make_child(name,options,&block)
+        child
+      end
+      def comment(text)
+        @children << Comment.new(text)
+      end
+      def self.camelize(symbol)
+        symbol.to_s.gsub(/__/,':_').gsub(/(^|_)(\w)/){"#{$2.upcase}"}.gsub(/^(\w+):/){"#{$1.downcase}:"}
+      end
+      def method_missing(symbol,*args,&block)
+        add_child(Element.camelize(symbol), *args, &block)
+      end
+      def indent(offset=0)
+        @indent ||= []
+        @indent[offset] ||= (0...(depth+offset)).inject(''){|a,v|a << (@xml_options[:tab] || "\t")}
+      end
+      def attribute_text
+        attributes.empty? ? "" : " #{attributes.to_a.map{|x|"#{x[0]}=\"#{x[1]}\""}.join(' ')}"
+      end
+      def contents
+        children.length==1 && !children[0].is_a?(Element) && children[0].to_s ||
+        "\n#{indent(1)}#{children.map{|x|x.to_xml(@xml_options)}.join("\n#{indent(1)}")}\n#{indent}"
+      end
+      def tag
+        namespace ? "#{namespace}:#{name}" : name
+      end
+      def to_xml(options={})
+        @xml_options = options
+        children.empty? ? "<#{tag}#{attribute_text}/>" : "<#{tag}#{attribute_text}>#{contents}</#{tag}>"
+      end
+      def to_s
+        tag
+      end
+    end
+    class Comment < Element
+      def to_xml(options={})
+        "<!-- #{[name,children].flatten.map{|c| c.to_s}.join(', ')} -->"
+      end
+    end
+
+    class Document < Element
+      def to_xml(options={})
+        "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n" + super(options) + "\n"
+      end
+      def singleton_elements
+        @singleton_elements ||= []
+      end
+      def comment text
+        !@singleton_elements.empty? && @singleton_elements.flatten[-1].comment(text)
+      end
+      def add_singleton_elements(elements=[])
+        prev_e = nil
+        singleton_elements << elements.map do |e|
+          parent = prev_e || self
+          element = Element.new(Element.camelize(e), parent.depth + 1)
+          parent << element
+          prev_e = element
+        end
+      end
+      def singleton_method(symbol,*args,&block)
+        name = Element.camelize symbol
+        singleton_elements.flatten.each do |element|
+          if element.name === name
+            #puts "Found singleton: #{name}"
+            block && block.call(element)
+            return element
+          end
+        end
+        #puts "Found no singletons for #{name}"
+        nil
+      end
+      def method_missing(symbol,*args,&block)
+        #puts "Method missing in XML::Document: #{symbol}"
+        singleton_method(symbol,*args,&block) || super(symbol,*args,&block)
+      end
+      def to_s
+        to_xml
+      end
+    end
+  end
+
+  module HTML
+    class Document < XML::Document
+      def initialize(title)
+        super 'HTML'
+        add_singleton_elements ['head']
+        add_singleton_elements ['body']
+        head.title << title
+      end
+      # Pass any unknown methods down to body
+      def method_missing(symbol,*args,&block)
+        singleton_method(symbol,*args,&block) ||
+        singleton_method(:body).send(symbol, *args, &block)
+      end
+      def self.test
+        doc = XML::Document.new "HTML"
+        doc.head.title << "Test HTML Document"
+        doc.body.h1 << "Header One"
+
+        puts doc.to_s
+
+        doc = HTML::Document.new 'Another test HTML Document'
+        doc.body.h1 << 'Header Two'
+        doc.table do |t|
+          t.tr{|r| r.th << :one;r.th << :two}
+          t.tr{|r| r.td << 1;r.td << 2}
+        end
+
+        puts doc.to_s
+      end
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'amanzi-sld'
+
+class Test::Unit::TestCase
+end

data/test/test_file.rb

@@ -0,0 +1,47 @@
+require 'helper'
+require 'differ'
+
+class TestFile < Test::Unit::TestCase
+#  should "probably rename this file and start testing for real" do
+#    flunk "hey buddy, you should probably rename this file and start testing for real"
+#  end
+  def show_diff(results,expected)
+    puts "Results: #{results.class.to_s}"
+    puts "Expected: #{expected.class.to_s}"
+    puts "Results: #{results.inspect[0..100]}"
+    puts "Expected: #{expected.inspect[0..100]}"
+    diff = Differ.diff_by_line(results,expected)
+    puts diff.methods.join(', ')
+#    puts diff.inspect
+    puts diff.format_as :color
+  end
+  def test_file(file,expect)
+    @results = `ruby -I lib #{file}`
+
+    if File.exist? expect
+      expected = File.open(expect).read
+      if expected.length != @results.length
+        puts "Got different results: #{expected.length} != #{@results.length}"
+        show_diff(@results,expected)
+        false
+      else
+        true
+      end
+    else
+      File.open(@expect,'w') do |file|
+        file.puts @results
+      end
+      puts "Wrote first time run results to #{@expect}"
+    end
+  end
+
+  context "Test file" do
+    setup do
+      @file = 'examples/test.rb'
+      @expect = 'examples/test.sld'
+    end
+    should "produce expected output" do
+      assert test_file @file, @expect
+    end
+  end
+end

data/test/test_sld.rb

@@ -0,0 +1,123 @@
+require 'helper'
+
+class TestXML < Test::Unit::TestCase
+  context "An SLD document" do
+    setup do
+      @doc = Amanzi::SLD::Document.new 'Test SLD Document'
+    end
+    should "contain an XML header" do
+      #puts "Have SLD document: #{@doc}"
+      assert @doc.to_s =~ /^\<\?xml/
+    end
+    should "have a StyledLayerDescriptor->NamedLayer->UserStyle->Name tree" do
+      assert_equal @doc.name, 'StyledLayerDescriptor'
+      assert_equal (layer = @doc.children[0]).name, 'NamedLayer'
+      assert_equal layer.children[0].name, 'Name'
+      assert_equal (style = layer.children[1]).name, 'UserStyle'
+      assert_equal style.children[0].name, 'Name'
+      assert_equal 2, layer.children.length
+    end
+
+    context "with some line styles" do
+      setup do
+        @doc.comment "Add a simple line style"
+        @doc.add_line_symbolizer :stroke_width => 5
+        @doc.comment "Add a more complex line style with filter"
+        @doc.add_line_symbolizer :stroke_width => 5, :stroke => '#2080a0' do |f|
+          f.geometry = 'LineString'
+        end
+      end
+      should "have two LineSymbolizers" do
+        #puts "Have SLD document: #{@doc}"
+        tags = @doc.to_s.split(/[\r\n]+/).grep(/\<LineSymbolizer/i)
+        assert_equal 2, tags.length
+      end
+      should "have a geometry type function call" do
+        tags = @doc.to_s.split(/[\r\n]+/).grep(/\<ogc\:Function/i)
+        assert_equal 1, tags.length
+        assert /geometryType/.match tags[0]
+      end
+    end
+
+    context "with polygon style and complex filter" do
+      setup do
+        @doc.comment "Polygon with complex Filter"
+        @doc.add_polygon_symbolizer(:stroke_width => 2, :stroke => '#dddddd', :fill => '#aaaaaa', :fill_opacity => 0.4) do |f|
+          f.op(:and) do |f|
+            f.geometry = 'Polygon'
+            f.op(:or) do |f|
+              f.property.not_exists? :highway
+              f.property.exists? :waterway
+              f.property[:natural] = 'water'
+            end
+          end
+        end
+      end
+      should "have one PolygonSymbolizers" do
+        #puts "Have SLD document: #{@doc}"
+        assert_equal 1, @doc.to_s.split(/[\r\n]+/).grep(/\<PolygonSymbolizer/i).length
+        assert_equal 1, @doc.to_s.split(/[\r\n]+/).grep(/\<\/PolygonSymbolizer/i).length
+      end
+      should "have a geometry type function call" do
+        tags = @doc.to_s.split(/[\r\n]+/).grep(/\<ogc\:Function/i)
+        assert_equal 1, tags.length
+        assert /geometryType/.match tags[0]
+      end
+    end
+
+    context "with multiple symbolizers using the same filter rules" do
+      setup do
+        @doc.comment "Multiple symbolizers and complex filter"
+        @doc.
+          add_line_symbolizer(:stroke_width => 7, :stroke => '#303030').
+          add_line_symbolizer(:stroke_width => 5, :stroke => '#e0e0ff') do |f|
+          f.op(:and) do |f|
+            f.geometry = 'LineString'
+            f.property.exists? :highway
+            f.op(:or) do |f|
+              f.property[:highway] = 'secondary'
+              f.property[:highway] = 'tertiary'
+            end
+          end
+        end
+      end
+      should "have two LineSymbolizers" do
+        #puts "Have SLD document: #{@doc}"
+        assert_equal 2, @doc.to_s.split(/[\r\n]+/).grep(/\<LineSymbolizer/i).length
+        assert_equal 2, @doc.to_s.split(/[\r\n]+/).grep(/\<\/LineSymbolizer/i).length
+      end
+      should "have a geometry type function call" do
+        tags = @doc.to_s.split(/[\r\n]+/).grep(/\<ogc\:Function/i)
+        assert_equal 1, tags.length
+        assert /geometryType/.match tags[0]
+      end
+      should "have four CssParameter tags" do
+        assert_equal 4, @doc.to_s.split(/[\r\n]+/).grep(/\<CssParameter/i).length
+        assert_equal 4, @doc.to_s.split(/[\r\n]+/).grep(/\<\/CssParameter/i).length
+      end
+      should "have an rule->filter->and tree with three children" do
+        assert_equal 'StyledLayerDescriptor', @doc.name
+        assert_equal 'NamedLayer', (layer = @doc.children[0]).name
+        assert_equal 'UserStyle', (style = layer.children[1]).name
+        assert_equal 3, style.children.length
+        assert_equal 'FeatureTypeStyle', (fstyle = style.children[2]).name
+        assert_equal 'Rule', (rule = fstyle.children[0]).name
+        assert_equal 3, rule.children.length
+        assert_equal 'Filter', (filter = rule.children[0]).name
+        assert_equal 1, filter.children.length
+        assert_equal 'And', (andtag = filter.children[0]).name
+        assert_equal 3, andtag.children.length
+        assert_equal 'PropertyIsEqualTo', (geom = andtag.children[0]).name
+        assert_equal 2, geom.children.length
+        assert_equal 'Literal', (gname = geom.children[1]).name
+        assert_equal 'LineString', gname.children[0]
+        assert_equal 'Or', (props = andtag.children[2]).name
+        assert_equal 2, props.children.length
+        assert_equal 'PropertyIsEqualTo', (propB = props.children[1]).name
+        assert_equal 'PropertyName', propB.children[0].name
+        assert_equal 'highway', propB.children[0].contents
+        assert_equal 'tertiary', propB.children[1].contents
+      end
+    end
+  end
+end

data/test/test_xml.rb

@@ -0,0 +1,70 @@
+require 'helper'
+
+class TestXML < Test::Unit::TestCase
+  context "An XML document" do
+    setup do
+      @doc = Amanzi::XML::Document.new 'Test'
+    end
+    should "contain an XML header" do
+      assert @doc.to_s =~ /^\<\?xml/
+    end
+    context "with some tags" do
+      setup do
+        @doc.data.body do |body|
+          body.head << "Header"
+          body.content << "Some text"
+        end
+      end
+      should "have only one body" do
+        #puts "Have XML document: #{@doc}"
+        body_tags = @doc.to_s.split(/[\r\n]+/).grep(/\<body/i)
+        assert_equal 1, body_tags.length
+      end
+      should "have an data->body with two child tags" do
+        assert_equal 'data', (data = @doc.children[0]).name.downcase
+        assert_equal 'body', (body = data.children[0]).name.downcase
+        assert_equal 2, body.children.length
+      end
+    end
+  end
+
+  context "An HTML document" do
+    setup do
+      @doc = Amanzi::HTML::Document.new 'Test HTML Document'
+    end
+    should "contain an XML header" do
+      assert @doc.to_s =~ /^\<\?xml/
+    end
+    context "with some tags" do
+      setup do
+        @doc.body.h1 << "Header"
+        @doc.body.p << "Some text"
+        @doc.body.p << "Some more text"
+        @doc.body.table do |t|
+          t.tr do |tr|
+            tr.td << 'a'
+            tr.td << 'b'
+          end
+          t.tr do |tr|
+            tr.td << '1'
+            tr.td << '2'
+          end
+        end
+      end
+      should "have only one body" do
+        #puts "Have HTML document: #{@doc}"
+        body_tags = @doc.to_s.split(/[\r\n]+/).grep(/\<body/i)
+        assert_equal 1, body_tags.length
+      end
+      should "have four table cell tags" do
+        assert_equal 4, @doc.to_s.split(/[\r\n]+/).grep(/\<td/i).length
+        assert_equal 4, @doc.to_s.split(/[\r\n]+/).grep(/\<\/td/i).length
+      end
+      should "have an html->body with four child tags" do
+        assert_equal 'head', (head = @doc.children[0]).name.downcase
+        assert_equal 'body', (body = @doc.children[1]).name.downcase
+        assert_equal 4, body.children.length
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification 
+name: amanzi-sld
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Craig Taverner
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-02 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: differ
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 0
+        - 1
+        version: "0.1"
+  type: :development
+  version_requirements: *id002
+description: Map styles are often defined using SLD, or Style Layer Descriptor documents. These XML documents are very long, verbose and complex to maintain. Amanzi:SLD is a simpler DSL designed to generate SLD documents, but using a very much simpler syntax. Many common cases might be a single line only, while the simplest SLD is usually a dozen lines or more.
+email: craig@amanzi.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- amanzi-sld.gemspec
+- examples/osm.rb
+- examples/osm_highway_shp.rb
+- examples/test.rb
+- examples/test.sld
+- lib/amanzi-sld.rb
+- lib/amanzi/sld.rb
+- lib/amanzi/xml.rb
+- test/helper.rb
+- test/test_file.rb
+- test/test_sld.rb
+- test/test_xml.rb
+has_rdoc: true
+homepage: http://github.com/craigtaverner/amanzi-sld
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A Ruby DSL for simpler SLD creation for styling maps
+test_files: 
+- test/test_file.rb
+- test/test_xml.rb
+- test/test_sld.rb
+- test/helper.rb
+- examples/osm.rb
+- examples/test.rb
+- examples/osm_highway_shp.rb