tilecache 0.0.3

data/Changelog

@@ -0,0 +1,4 @@
+== 1.0.0 / 2008-05-07
+
+* 1 major enhancement
+  * Birthday!

data/README.rdoc

@@ -0,0 +1,85 @@
+Ruby-TileCache
+    by Pascal Ehlert, ODAdata
+    http://ruby-tilecache.rubyforge.org
+
+== DESCRIPTION
+
+ruby-tilecache is an implementation of TileCache from MetaCarta, written in pure Ruby.
+It allows you to cache image tiles either rendered by MapScript or taken from another source.
+Additionally, it supports meta-tiling which nearly eliminates label duplication issues
+because of the tiling. 
+
+== FEATURES/PROBLEMS
+
+* See description.
+
+== SYNOPSIS
+
+  require 'tile_cache'
+
+  class MapController < ApplicationController
+
+  	# This action handles WMS GetMap requests
+  	def wms
+   	  wms = TileCache::Services::WMS.new(params)
+      map = wms.get_map
+
+      render :text => map.data, :content_type => map.layer.format
+    end
+  end
+
+== REQUIREMENTS
+
+* RMagick for meta-tiling support
+* Ruby-MapScript for Mapserver layers
+
+== INSTALL
+
+* sudo gem install ruby-mapscript
+
+== CONFIGURATION
+
+If you are in a Rails environment, ruby-tilecache looks for a configuration file in config/tilecache.yml,
+otherwise it searches ~/.tilecache.yml and /etc/tilecache.yml.
+
+As the name suggests, the file format should be YAML, here is an example configuration:
+  
+  cache:
+    type: DiskCache
+    root: '../tmp/mapcache'
+
+  basic:
+    type: MapServer
+    mapfile: app/map/nic.map
+    layers: NIC2,NIC1
+    maxresolution: 0.01991484375
+    levels: 5
+    extension: jpeg
+    metatile: true
+    metabuffer: 0, 0
+    bbox: -87.6903, 10.7075, -82.5921, 15.0259
+
+In a Rails environment relative paths always refer to RAILS_ROOT, in other environments you should use absolute paths.
+
+== LICENSE
+
+Copyright (c) 2008 Pascal Ehlert, ODAdata
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.rubyforge_project = "tilecache"
+    gemspec.name = "tilecache"
+    gemspec.summary = "An implementation of TileCache from MetaCarta, written in pure Ruby"
+    #gemspec.description = "An implementation of TileCache from MetaCarta, written in pure Ruby"
+    gemspec.email = "pascal.ehlert@odadata.eu"
+    gemspec.homepage = "http://github.com/pehlert/ruby-tilecache"
+    gemspec.authors = ["Pascal Ehlert"]
+    gemspec.files.exclude ".gitignore"
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
+end
+
+Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].sort.each { |ext| load ext }

data/VERSION

@@ -0,0 +1 @@
+0.0.3

data/lib/tile_cache/bounds.rb

@@ -0,0 +1,44 @@
+module TileCache
+  class Bounds
+    attr_reader :minx, :miny, :maxx, :maxy
+    
+    def self.parse_string(str)
+      new(*str.split(",").map { |s| Float(s.strip) })
+    end
+    
+    def initialize(minx = -180, miny = -90, maxx = 180, maxy = 90)
+      @minx = Float(minx)
+      @miny = Float(miny)
+      @maxx = Float(maxx)
+      @maxy = Float(maxy)
+        
+      if (minx > maxx) || (miny > maxy)
+        raise TileCache::InvalidBounds, "Invalid Bounds: #{self}"
+      end
+    end
+    
+    def to_s
+      [@minx, @miny, @maxx, @maxy].join(", ")
+    end
+    
+    # Returns this Bboxes resolution
+    def resolution(width = 256, height = 256)
+      return [(maxx - minx) / width,
+              (maxy - miny) / height].max
+    end
+    
+    # Returns the maximum resolution possible for a given tile width and height
+    def max_resolution(width = 256, height = 256)
+      b_width  = (maxx - minx).to_f
+      b_height = (maxy - miny).to_f
+      
+      if b_width >= b_height
+        aspect = (b_width / b_height).ceil
+        b_width / (width * aspect)
+      else
+        aspect = (b_height / b_width).ceil
+        b_height / (height * aspect)
+      end      
+    end
+  end
+end

data/lib/tile_cache/caches/disk.rb

@@ -0,0 +1,53 @@
+module TileCache
+  module Caches
+    class Disk
+      REQUIRED_ATTRIBUTES = %w{ root }
+      
+      def initialize(settings)
+        @root = settings[:root]
+      end
+      
+      def get(tile)
+        file = key_for_tile(tile)
+        
+        if File.exist?(file)
+          File.open(file, File::RDONLY) { |f| tile.data = f.read }          
+          return true
+        else
+          return false
+        end
+      end
+      
+      def store(tile, data = nil)
+        tile.data = data if data
+        raise CacheError, "Called #store! with no data argument and no data associated with the tile." unless tile.data
+        
+        # Create the full path to the cache file
+        file = key_for_tile(tile)
+        FileUtils.mkdir_p(File.dirname(file))
+          
+        File.open(file, (File::WRONLY | File::CREAT)) do |f|
+          f.sync = true
+          f.write(tile.data)
+        end    
+      end
+      
+    protected
+      def key_for_tile(tile)
+        components = [
+          @root,
+          tile.layer.name,
+          sprintf("%02d", tile.z),
+          sprintf("%03d", Integer(tile.x / 1000000)),
+          sprintf("%03d", Integer((tile.x / 1000)) % 1000),
+          sprintf("%03d", Integer(tile.x) % 1000),
+          sprintf("%03d", Integer(tile.y / 1000000)),
+          sprintf("%03d", Integer((tile.y / 1000)) % 1000),
+          sprintf("%03d.%s", Integer(tile.y) % 1000, tile.layer.extension)
+        ]      
+        
+        File.join(*components)
+      end
+    end
+  end
+end

data/lib/tile_cache/caches.rb

@@ -0,0 +1,18 @@
+# Preload all cache handler classes
+Dir[File.dirname(__FILE__) + '/caches/*.rb'].each { |c| require c }
+
+module TileCache
+  module Caches
+    class << self
+      def get_handler_class(cache_type)
+        class_name = cache_type.sub(/Cache$/, '')
+        
+        if Caches.const_defined?(class_name)
+          Caches.const_get(class_name)
+        else
+          raise InvalidConfiguration, "Invalid cache type attribute: #{type}"
+        end
+      end
+    end
+  end
+end

data/lib/tile_cache/layer.rb

@@ -0,0 +1,122 @@
+require 'tile_cache/tile'
+require 'tile_cache/meta_tile'
+
+module TileCache
+  class Layer
+    DEFAULT_CONFIGURATION = {
+      :bbox => [-180, -90, 180, 90],
+      :srs => "EPSG:4326",
+      :description => "",
+      :size => [256, 256],
+      :levels => 20,
+      :extension => "png",
+      :metatile => false,
+      :metasize => [5, 5],
+      :metabuffer => [10, 10]
+    }
+    
+    attr_reader :name, :description, :layers, :bbox, :size, :units, :srs, :extension, :resolutions
+    
+    def initialize(name, config)
+      @name = name
+      @description = config[:description]
+      @layers = config[:layers] || name
+      @bbox = config[:bbox].is_a?(String) ? TileCache::Bounds.parse_string(config[:bbox]) : TileCache::Bounds.new(*config[:bbox])
+      @size = config[:size].is_a?(String) ? config[:size].split(",").map { |s| Integer(s.strip) } : config[:size].map { |s| s.to_i }
+      @units = config[:units]
+      @srs = config[:srs]
+      
+      @extension = config[:extension].downcase
+      @extension = 'jpeg' if @extension == 'jpg'
+      
+      @resolutions = parse_resolutions(config[:resolutions], config[:minresolution], config[:maxresolution], config[:levels])
+    end
+    
+    # Create a new tile for the given bounds
+    def get_tile(bbox)
+      coords = get_cell(bbox)
+      TileCache::Tile.new(self, *coords)        
+    end
+    
+    # Fetch or render tile 
+    def render(tile)
+      cache = ConfigParser.instance.cache
+
+      unless cache.get(tile)
+        data = render_tile(tile)
+        cache.store(tile, data)
+      end
+      
+      return tile
+    end  
+    
+    def render_bbox(bbox)
+      case bbox
+      when String
+        bounds = Bounds.parse_string(bbox)
+      when Bounds
+        bounds = bbox
+      else
+        raise ArgumentError, "Invalid argument for bbox: #{bbox.inspect}"
+      end
+      
+      tile = get_tile(bounds)
+      render(tile)
+    end
+    
+    
+    # This returns the total number of columns and rows of the grid, 
+    # based on the given z-indexes resolution
+    def grid_limits(z)
+      maxcols = (@bbox.maxx - @bbox.minx) / (@resolutions[z] * @size[0])
+      maxrows = (@bbox.maxy - @bbox.miny) / (@resolutions[z] * @size[1])
+      
+      return [maxcols.to_i, maxrows.to_i]
+    end
+    
+    def format
+      return "image/" + @extension
+    end
+    
+  protected
+    # Returns the z-index for the bboxes resolution
+    def level_for_bbox(bbox)
+      max_diff = bbox.resolution(*@size) / @size.max
+      
+      if match = @resolutions.detect { |res| (res - bbox.resolution(*@size)).abs < max_diff }
+        @resolutions.index(match)
+      else
+        raise TileCache::InvalidResolution, "Can't find resolution index for #{bbox.resolution}. Available resolutions are #{@resolutions.join(', ')}."
+      end
+    end
+    
+    # Returns x, y and z coordinates for a given bbox
+    def get_cell(bbox)
+      # Get exact resolution as specified
+      z = level_for_bbox(bbox)
+      res = @resolutions[z]
+            
+      x = ((bbox.minx - @bbox.minx) / (res * @size[0])).round
+      y = ((bbox.miny - @bbox.miny) / (res * @size[1])).round
+      
+      return [x, y, z]
+    end
+    
+  private
+    # Calculate resolutions unless given via configuration
+    def parse_resolutions(res_list, min_res, max_res, levels)
+      case res_list
+      when String
+        res_list.split(",").map { |r| Float(r.strip) }
+      when Array
+        res_list.map { |r| Float(r) }
+      when NilClass
+        max_res ||= @bbox.max_resolution(*@size)
+        (0..levels).map { |i| max_res.to_f / 2 ** i }
+      else
+        raise TileCache::Layers::InvalidConfiguration, "Invalid format of resolutions for layer #{@name}"
+      end
+    end
+    
+  end
+end

data/lib/tile_cache/layers/map_server.rb

@@ -0,0 +1,60 @@
+require 'mapscript'
+
+module TileCache
+  module Layers    
+    class MapServer < TileCache::MetaLayer
+      include Mapscript
+      
+      VALID_ATTRIBUTES = %w{ maxresolution levels extension metatile metabuffer bbox resolutions width height }
+      REQUIRED_ATTRIBUTES = %w{ mapfile layers }
+      
+      attr_reader :mapfile
+      
+      def initialize(name, config)
+        @mapfile = config[:mapfile]
+        super
+      end
+      
+      def render_tile(tile)
+        set_metabuffer if @metabuffer
+        req = build_request(tile)
+        
+        msIO_installStdoutToBuffer
+        map.OWSDispatch(req)
+        msIO_stripStdoutBufferContentType
+        msIO_getStdoutBufferBytes
+      end
+      
+    protected
+      def map
+        @map ||= MapObj.new(File.join(RAILS_ROOT, @mapfile))
+      end
+      
+      def set_metabuffer
+        # Don't override the mapfile settings!
+        begin
+          map.getMetaData("labelcache_map_edge_buffer")
+        rescue
+          buffer = -@metabuffer.max - 5
+          map.setMetaData("labelcache_map_edge_buffer", buffer.to_s)
+        end
+      end
+      
+      def build_request(tile)
+        req = OWSRequest.new
+                
+        req.setParameter("bbox", tile.bounds.to_s)
+        req.setParameter("width", tile.size[0].to_s)
+        req.setParameter("height", tile.size[1].to_s)
+        req.setParameter("srs", @srs)
+        req.setParameter("format", format)
+        req.setParameter("layers", @layers)
+        req.setParameter("request", "GetMap")
+        req.setParameter("service", "WMS")
+        req.setParameter("version", "1.1.1")
+        
+        return req        
+      end
+    end
+  end
+end

data/lib/tile_cache/layers.rb

@@ -0,0 +1,21 @@
+require 'tile_cache/layer'
+require 'tile_cache/meta_layer'
+
+# Preload layer classes
+Dir[File.dirname(__FILE__) + '/layers/*.rb'].each { |c| require c }
+
+module TileCache
+  module Layers
+    class << self
+      def get_handler_class(layer_type)
+        class_name = layer_type.sub(/Layer$/, '')
+        
+        if Layers.const_defined?(class_name)
+          Layers.const_get(class_name)
+        else
+          raise InvalidConfiguration, "Invalid layer type attribute: #{type}"
+        end
+      end
+    end
+  end
+end

data/lib/tile_cache/meta_layer.rb

@@ -0,0 +1,79 @@
+require 'rubygems'
+require 'RMagick'
+
+module TileCache
+  class MetaLayer < TileCache::Layer
+    include Magick
+    
+    attr_reader :metabuffer
+    
+    def initialize(name, config)
+      super
+      
+      @metatile = [true, 1, "true", "yes", "1"].include?(config[:metatile])
+      @metasize = config[:metasize].is_a?(String) ? config[:metasize].split(",").map { |s| Integer(s.strip) } : config[:metasize].map { |s| Integer(s) }
+      @metabuffer = config[:metabuffer].is_a?(String) ? config[:metabuffer].split(",").map { |s| Integer(s.strip) } : config[:metabuffer].map { |s| Integer(s) }
+    end
+  
+    # Columns and rows for a given z-indexes resolution.
+    # Returns 1,1 if meta-tiling is disabled, otherwise the desired metasize or grid limits.
+    def meta_limits(z)
+      return [1, 1] unless @metatile
+      
+      limits = grid_limits(z)
+      maxcols = [@metasize[0], limits[0] + 1].min
+      maxrows = [@metasize[1], limits[1] + 1].min
+      
+      [maxcols, maxrows]
+    end
+    
+    def get_meta_tile(tile)
+      x = (tile.x / @metasize[0]).to_i
+      y = (tile.y / @metasize[1]).to_i
+      
+      MetaTile.new(self, x, y, tile.z)
+    end
+    
+    def render_meta_tile(metatile, tile)
+      data = render_tile(metatile)
+      image = Image.from_blob(data).first
+      
+      (meta_cols, meta_rows) = meta_limits(metatile.z)
+      meta_height = meta_rows * @size[1] + 2 * @metabuffer[1]
+      
+      0.upto(meta_cols-1) do |c|
+        0.upto(meta_rows-1) do |r|
+          minx = c * @size[0] + @metabuffer[0]
+          miny = r * @size[1] + @metabuffer[1]
+
+          subimage = image.crop(SouthWestGravity, minx, miny, @size[0], @size[1])
+          x = metatile.x * @metasize[0] + c
+          y = metatile.y * @metasize[1] + r
+          subtile = TileCache::Tile.new(self, x, y, metatile.z)
+          TileCache.cache.store(subtile, subimage.to_blob)
+          
+          if x == tile.x && y == tile.y
+            tile.data = subimage.to_blob
+          end
+        end
+      end
+      
+      return tile.data
+    end
+    
+    def render(tile)
+      if @metatile
+        metatile = get_meta_tile(tile)        
+        
+        unless TileCache.cache.get(tile)
+          render_meta_tile(metatile, tile)
+        end
+            
+        return tile
+      else
+        super
+      end      
+    end
+
+  end
+end

data/lib/tile_cache/meta_tile.rb

@@ -0,0 +1,31 @@
+module TileCache
+  class MetaTile < TileCache::Tile
+    # Returns the tile's size without meta-buffers
+    def size_without_buffers
+      (meta_cols, meta_rows) = @layer.meta_limits(@z)
+      return [@layer.size[0] * meta_cols, @layer.size[1] * meta_rows]
+    end
+    
+    # Returns this tile's size including buffers
+    def size
+      actual = size_without_buffers
+      return [actual[0] + @layer.metabuffer[0] * 2,
+              actual[1] + @layer.metabuffer[1] * 2]
+    end
+    
+    def bounds
+      tilesize    = size_without_buffers
+      res         = @layer.resolutions[@z]
+      buffer      = [res * @layer.metabuffer[0], res * @layer.metabuffer[1]]
+      meta_width  = res * tilesize[0]
+      meta_height = res * tilesize[1]
+      
+      minx = @layer.bbox.minx + @x * meta_width  - buffer[0]
+      miny = @layer.bbox.miny + @y * meta_height - buffer[1]
+      maxx = minx + meta_width  + 2 * buffer[0]
+      maxy = miny + meta_height + 2 * buffer[1]
+      
+      return TileCache::Bounds.new(minx, miny, maxx, maxy)   
+    end
+  end
+end

data/lib/tile_cache/services/wms.rb

@@ -0,0 +1,31 @@
+module TileCache
+  module Services
+    class WMS
+      FIELDS = %{ bbox srs width height format layers styles }
+      
+      def initialize(params)
+        @params = parse_request(params)
+      end
+      
+      def get_map
+        bbox = Bounds.parse_string(@params[:bbox])        
+        layer = TileCache.layers[@params[:layers]]
+        # TODO: Move into config parser
+        raise LayerNotFound, "Can't find layer '#{@params[:layers]}' in configuration" unless layer
+        tile = layer.get_tile(bbox)
+        
+        layer.render(tile)
+      end
+      
+    private
+      def parse_request(params)
+        parsed = {}
+        params.each do |k, v|
+          key = k.downcase
+          parsed[key.to_sym] = v if FIELDS.include?(key)
+        end  
+        parsed
+      end
+    end
+  end
+end

data/lib/tile_cache/services.rb

@@ -0,0 +1 @@
+Dir[File.dirname(__FILE__) + '/services/*.rb'].each { |c| require c }

data/lib/tile_cache/tile.rb

@@ -0,0 +1,28 @@
+module TileCache
+  class Tile
+    attr_reader :layer, :x, :y, :z, :size
+    attr_accessor :data
+    
+    def initialize(layer, x, y, z)
+      @layer = layer
+      @x = x
+      @y = y
+      @z = z
+      @data = nil
+    end
+    
+    def bounds
+      res = @layer.resolutions[@z]
+      minx = @layer.bbox.minx + (res * @x * @layer.size[0])
+      miny = @layer.bbox.miny + (res * @y * @layer.size[1])
+      maxx = @layer.bbox.minx + (res * (@x + 1) * @layer.size[0])
+      maxy = @layer.bbox.miny + (res * (@y + 1) * @layer.size[1])
+      
+      return TileCache::Bounds.new(minx, miny, maxx, maxy)
+    end
+    
+    def size
+      @layer.size
+    end
+  end
+end

data/lib/tile_cache.rb

@@ -0,0 +1,112 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'active_support/core_ext/hash/reverse_merge.rb'
+require 'yaml'
+  
+require 'tile_cache/bounds'
+require 'tile_cache/services'
+require 'tile_cache/caches'
+require 'tile_cache/layers'
+  
+module TileCache  
+  CONFIG_PATHS = [
+    Pathname.new("/etc/tilecache.yml"), 
+    Pathname.new("#{ENV['HOME']}/.tilecache.yml"),
+    Pathname.new("#{Dir.pwd}/config/tilecache.yml")
+  ]
+  
+  # Exception classes
+  class InvalidBounds < StandardError; end
+  class InvalidResolution < StandardError; end
+  class InvalidConfiguration < StandardError; end
+  class CacheError < StandardError; end
+  class LayerNotFound < StandardError; end
+  
+  class << self
+    attr_accessor :cache, :layers
+  
+    # Initialize TileCache framework, read out configuration and setup cache and layer classes
+    def initialize!
+      read_configuration
+      
+      initialize_cache
+      initialize_layers_pool
+    end
+    
+  private
+    def read_configuration
+      # Select first existing path from hardcoded list
+      path = CONFIG_PATHS.reverse.find(&:exist?)
+  
+      @config = YAML.load(File.read(path))
+    rescue => e
+      raise InvalidConfiguration, "Can't read configuration from #{CONFIG_PATHS.join(', ')}: #{e.message}"
+    end
+  
+    def initialize_cache
+      config = @config.delete('cache')
+      raise InvalidConfiguration, "Missing cache section in your configuration file" unless config
+      config.symbolize_keys!
+  
+      klass = Caches.get_handler_class(config.delete(:type))
+      validate_attributes!(klass, config)
+      merge_with_defaults!(klass, config)
+  
+      TileCache.cache = klass.new(config)
+    end    
+  
+    def initialize_layers_pool
+      layers = @config.delete('layers')
+      raise InvalidConfiguration, "Please configure at least one layer" unless layers
+      
+      TileCache.layers = {}
+      layers.each do |layer, settings|
+        settings.symbolize_keys!
+        
+        klass = Layers.get_handler_class(settings.delete(:type))
+        validate_attributes!(klass, settings)
+        merge_with_defaults!(klass, settings)
+  
+        TileCache.layers.store(layer, klass.new(layer, settings))
+      end
+    end
+    
+    # Reads DEFAULT_CONFIGURATION hash from the class specified in settings[:class]
+    # and merges settings hash with these values. If no DEFAULT_CONFIGURATION has
+    # been specified, it doesn't change settings.
+    def merge_with_defaults!(klass, config)
+      defaults = klass.const_get("DEFAULT_CONFIGURATION").symbolize_keys rescue {}
+      config.reverse_merge!(defaults)    
+    end
+
+    # Check for the validity of configuration attributes
+    # If any attributes that are not specified in the classes VALID_ATTRIBUTES
+    # constant appear in the configuration file or if there are attributes from REQUIRED_ATTRIBUTES missing
+    # this raises TileCache::InvalidConfiguration
+    def validate_attributes!(klass, config)
+      valid_attributes = klass.const_get("VALID_ATTRIBUTES") rescue []
+      required_attributes = klass.const_get("REQUIRED_ATTRIBUTES") rescue []
+      # Merge with required attributes so that we don't have to specify them twice
+      valid_attributes |= required_attributes
+
+      unless valid_attributes.empty?
+        config.except(:name).each_key do |a|
+          unless valid_attributes.include?(a.to_s)
+            raise InvalidConfiguration, "Unrecognized attribute in #{config[:name]}: #{a}" 
+          end
+        end
+      end
+
+      unless required_attributes.empty?
+        required_attributes.each do |a|
+          unless config.include?(a.to_sym)
+            raise InvalidConfiguration, "Missing attribute in #{config[:name]}: #{a}" 
+          end
+        end
+      end
+    end
+  end
+end
+
+TileCache.initialize!

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: tilecache
+version: !ruby/object:Gem::Version 
+  version: 0.0.3
+platform: ruby
+authors: 
+- Pascal Ehlert
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-26 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: 
+email: pascal.ehlert@odadata.eu
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- Changelog
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/tile_cache.rb
+- lib/tile_cache/bounds.rb
+- lib/tile_cache/caches.rb
+- lib/tile_cache/caches/disk.rb
+- lib/tile_cache/layer.rb
+- lib/tile_cache/layers.rb
+- lib/tile_cache/layers/map_server.rb
+- lib/tile_cache/meta_layer.rb
+- lib/tile_cache/meta_tile.rb
+- lib/tile_cache/services.rb
+- lib/tile_cache/services/wms.rb
+- lib/tile_cache/tile.rb
+has_rdoc: true
+homepage: http://github.com/pehlert/ruby-tilecache
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: tilecache
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: An implementation of TileCache from MetaCarta, written in pure Ruby
+test_files: []
+