tairu 0.9.0 → 0.10.0

data/README.md

@@ -2,12 +2,11 @@ tairu ... simple map tile server
 
 In development mode (irb): `rake console`
 
-To run: `tairu -c /path/to/config/file`
+To run from bin: `tairu --config /path/to/config/file`
 
 Example config file:
 
 ```ruby
-
 name: tairu_config_example
 cache:
   type: memory
@@ -17,17 +16,12 @@ layers:
     tileset: geography-class.mbtiles
     location: ~/.tairu/tilesets
     format: png
-
 ```
 
-Tairu relies on a valid configuration object assigned to `Tairu::CONFIG`
-
-This may be read from a yaml file (see example above) using `Tairu::Configuration.config_from_file(file_name)`
-
-or by assigning default values for layers, cache, and name (optional):
+Configuration may be read from a yaml file (see example above) using `Tairu.config_from_file(file_name)`
+or by passing values for layers, cache, and name (optional) into a configuration block:
 
 ```ruby
-
 layers = {
   'geo' => {
     'provider' => 'mbtiles',
@@ -37,10 +31,20 @@ layers = {
   }
 }
 
-cache = Tairu::Configuration.start_cache('memory', {})
-
-name = 'tairu_config_example'
+cache = {
+  'type' => 'redis',
+  'options' => {
+    'host' => 'localhost',
+    'port' => '6379',
+    'db' => 0
+  }
+}
 
-Tairu::CONFIG = Tairu::Configuration.new(layers, cache, name)
+Tairu.configure do |config|
+  config.name = 'tairu_config_example'
+  config.layers = layers
+  config.cache = cache
+end
+```
 
-```
+NOTE: If no cache is passed in, it will default to the memory cache

data/bin/tairu

@@ -11,7 +11,10 @@ OptionParser.new do |o|
   o.banner = 'Usage: tairu.rb [options]'
 
   o.on('-v', '--version', '') do
-    require 'tairu'
+    unless defined?(Tairu)
+      require File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib', 'tairu', 'version')
+    end
+
     puts "Tairu v#{Tairu::VERSION}"
     exit(0)
   end
@@ -30,10 +33,11 @@ OptionParser.new do |o|
 end.parse!
 
 if opts[:config]
-  require 'tairu'
+  unless defined?(Tairu)
+    require File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib', 'tairu')
+  end
 
-  Tairu::CONFIG = Tairu::Configuration.config_from_file(opts[:config])
-  Tairu::CACHE = Tairu::CONFIG.cache
+  Tairu.config_from_file(opts[:config])
 else
   puts "No valid config file specified. Use -c / --config option."
   exit(1)
@@ -45,7 +49,7 @@ server = ::Puma::Server.new(app)
 host = opts[:host] || '0.0.0.0'
 port = opts[:port] || 8080
 server.add_tcp_listener host, port
-min_threads, max_threads = 0, 16
+min_threads, max_threads = 4, 16
 server.min_threads = min_threads
 server.max_threads = max_threads
 

data/lib/tairu.rb

@@ -1,36 +1,40 @@
 $:.push File.expand_path(File.join(File.dirname(__FILE__), 'tairu'))
 
+require 'rubygems'
 require 'sequel'
 require 'cache'
 require 'store'
 require 'coordinate'
 require 'tile'
 require 'configuration'
+require 'version'
 
 module Tairu
-  TILE_404 = Tairu::Tile.new(File.read(File.join(File.expand_path(File.dirname(__FILE__)), 'tairu', 'images', '404.png')), 'image/png')
+  extend self
+  extend Configuration
 
-  def self.get_tile(name, coord, format = nil)
-    tileset = Tairu::CONFIG.layers[name]
+  TILE_404 = Tairu::Tile.new('', 'image/png')
 
-    unless tileset.nil?
-      tile = Tairu::CACHE.get(tileset, coord)
+  class << self
+    attr_accessor :logger
 
-      if tile.nil?
-        provider = Tairu::Store::TYPES[tileset['provider']]
-        provider_tile = provider.get(name, tileset['tileset'], coord, tileset['format'])
+    def get_tile(name, coord, format=nil)
+      tileset = Tairu.tilesets[name]
+
+      return TILE_404 if tileset.nil?
+
+      tile = Tairu.cache.get(name, coord)
 
-        unless provider_tile.nil?
-          tile = provider_tile
-          Tairu::CACHE.add(tileset, coord, tile)
+      if tile.nil?
+        tile = tileset.get(coord, Tairu.layers[name]['format'])
+        unless tile.nil?
+          Tairu.cache.add(name, coord, tile)
         else
           tile = TILE_404
         end
       end
-    else
-      tile = TILE_404
-    end
 
-    tile
+      tile
+    end
   end
-end
+end

data/lib/tairu/cache.rb

@@ -1,13 +1,15 @@
 require 'cache/memory'
 require 'cache/disk'
+require 'cache/redis_cache'
 
 module Tairu
   module Cache
     TYPES = {
       'memory' => Tairu::Cache::Memory,
-      'disk' => Tairu::Cache::Disk
+      'disk' => Tairu::Cache::Disk,
+      'redis' => Tairu::Cache::RedisCache
     }
 
     Key = Struct.new(:layer, :coord, :format)
   end
-end
+end

data/lib/tairu/cache/disk.rb

@@ -3,11 +3,10 @@ require 'fileutils'
 module Tairu
   module Cache
     class Disk
-      def initialize(options = {})
+      def initialize(options={})
         raise "No path specified." unless options['path']
         @path = options['path']
         @expire = options['expire'] || 300
-        @tiles = {}
       end
 
       def lock_write(path, data)
@@ -40,19 +39,18 @@ module Tairu
         data
       end
 
-      def add(layer, coord, tile)
+      def add(name, coord, tile)
         expire = Time.now + @expire
-        tileset = layer['tileset']
-        base_path = File.join(File.expand_path(@path), tileset, "#{coord.zoom}", "#{coord.column}")
+        base_path = File.join(File.expand_path(@path), name, "#{coord.zoom}", "#{coord.column}")
         FileUtils.mkdir_p(base_path)
-        path = File.join(base_path, "#{coord.row}.#{layer['format']}")
+        path = File.join(base_path, "#{coord.row}.#{Tairu.config.layers[name]['format']}")
         lock_write(path, tile.data)
-        purge_expired(layer)
+        purge_expired(name)
       end
 
-      def get(layer, coord)
-        tileset = layer['tileset']
-        path = File.join(File.expand_path(@path), tileset, "#{coord.zoom}", "#{coord.column}", "#{coord.row}.#{layer['format']}")
+      def get(name, coord)
+        layer = Tairu.config.layers[name]
+        path = File.join(File.expand_path(@path), name, "#{coord.zoom}", "#{coord.column}", "#{coord.row}.#{layer['format']}")
         data = lock_read(path)
         
         return nil if data.nil?
@@ -60,10 +58,11 @@ module Tairu
         Tairu::Tile.new(data, layer['format'])
       end
 
-      def purge_expired(layer)
-        Dir.glob(File.join(File.expand_path(@path), "**/*.#{layer['format']}")).each do |f|
+      def purge_expired(name)
+        Dir.glob(File.join(File.expand_path(@path), "**/*.#{Tairu.config.layers[name]['format']}")).each do |f|
           FileUtils.rm(f) if File.mtime(f) < (Time.now - @expire)
         end
+        Dir[File.join(File.expand_path(@path), '**/*')].select {|d| File.directory?(d)}.select {|d| (Dir.entries(d) - %w[. ..]).empty?}.each {|d| Dir.rmdir(d)}
       end
     end
   end

data/lib/tairu/cache/memory.rb

@@ -1,19 +1,19 @@
 module Tairu
   module Cache
     class Memory
-      def initialize(options = nil)
+      def initialize(options=nil)
         @tiles = {}
       end
 
-      def add(layer, coord, tile, age = 300) # format?
-        key = Tairu::Cache::Key.new(layer, coord)
+      def add(name, coord, tile, age=300)
+        key = Tairu::Cache::Key.new(name, coord)
         expire = Time.now + age
         @tiles[key] = {tile: tile, expire: expire}
-        :purge_expired
+        purge_expired
       end
 
-      def get(layer, coord) # format?
-        key = Tairu::Cache::Key.new(layer, coord)
+      def get(name, coord)
+        key = Tairu::Cache::Key.new(name, coord)
         tile = @tiles[key]
 
         return nil if tile.nil?
@@ -31,4 +31,4 @@ module Tairu
       end
     end
   end
-end
+end

data/lib/tairu/cache/redis_cache.rb

@@ -0,0 +1,45 @@
+require 'connection_pool'
+require 'redis'
+require 'base64'
+gem 'json', '1.7.7'
+require 'json'
+require 'multi_json'
+
+module Tairu
+  module Cache
+    class RedisCache
+      def initialize(options={'host' => 'localhost', 'port' => 6379, 'db' => 0})
+        if options['url']
+          redis_url = options['url']
+        else
+          db = options['db'] || 0
+          redis_url = "redis://#{options['host']}:#{options['port']}/#{db}"
+        end
+
+        @pool = ConnectionPool::Wrapper.new(timeout: 1, size: 4) do
+          Redis.connect(url: redis_url, driver: 'ruby')
+        end
+      end
+
+      def add(name, coord, tile, age=300)
+        key = "#{name}_#{coord.zoom}_#{coord.column}_#{coord.row}"
+        expire = Time.now.to_i + age
+        tile = Base64.encode64(tile.data)
+        @pool.set(key, MultiJson.dump({tile: tile, format: Tairu.config.layers[name]['format']}))
+        @pool.expire(key, expire)
+      end
+
+      def get(name, coord)
+        key = "#{name}_#{coord.zoom}_#{coord.column}_#{coord.row}"
+        value = @pool.get(key)
+
+        if value.nil?
+          return nil
+        else
+          tile_hash = MultiJson.load(value)
+          Tairu::Tile.new(Base64.decode64(tile_hash['tile']), tile_hash['format'])
+        end
+      end
+    end
+  end
+end

data/lib/tairu/configuration.rb

@@ -1,54 +1,69 @@
 require 'yaml'
 
 module Tairu
-  class Configuration
-    attr_accessor :layers, :cache, :name
+  module Configuration
+    attr_accessor :layers, :cache, :name, :tilesets
 
-    def initialize(layers, cache, name = nil)
-      @layers = layers
-      @cache = cache
-      @name = name
+    def configure
+      yield self
+      configure_layers
+      configure_cache
+      configure_tilesets
     end
 
-    def self.config_from_file(file)
-      file = File.expand_path(file)
-
-      if File.exists?(file)
-        data = YAML.load_file(file)
+    def configure_cache
+      if self.cache
+        unless self.cache.instance_of? Tairu::Cache
+          if self.cache.instance_of? Hash
+            if self.cache['type']
+              options = self.cache['options'] || nil
+              self.cache = start_cache(self.cache['type'], options)
+            else
+              raise RuntimeError.new('No cache type sepecified')
+            end
+          end
+        end
       else
-        raise 'Configuration file not found at specified location.'
+        self.cache = start_cache
       end
+    end
+
+    def configure_layers
+      raise RuntimeError.new('At least one layer must be specified') unless self.layers
+    end
 
-      name = data['name'] if data['name']
+    def configure_tilesets
+      self.tilesets = {}
 
-      if data['layers']
-        layers = data['layers']
-      else
-        raise 'Layers must be specified.'
+      self.layers.each do |k,v|
+        self.tilesets[k] = Tairu::Store::TYPES[v['provider'].downcase].new(k)
       end
+    end
 
-      if data['cache'] && data['cache']['type']
-        cache_type = data['cache']['type']
-        options = data['cache']['options'] ? data['cache']['options'] : {}
+    def config_from_file(file)
+      file = File.expand_path(file)
 
-        cache = start_cache(cache_type, options)
+      if File.exists?(file)
+        data = YAML.load_file(file)
+      else
+        raise 'Configuration file not found at specified location.'
       end
 
-      cache = Tairu::Cache::Memory.new if cache.nil?
-
-      config = Configuration.new(layers, cache, name)
+      raise RuntimeError.new('At least one layer must be specified') unless data['layers']
 
-      config
+      configure do |config|
+        config.name = data['name']
+        config.layers = data['layers']
+        config.cache = data['cache']
+      end
     end
 
-    def self.start_cache(cache_type = nil, options = nil)
+    def start_cache(cache_type=nil, options=nil)
       if cache_type
-        cache = Tairu::Cache::TYPES[cache_type].new(options)
+        Tairu::Cache::TYPES[cache_type].new(options)
       else
-        cache = Tairu::Cache::Memory.new
+        Tairu::Cache::Memory.new
       end
-
-      cache
     end
   end
-end
+end

data/lib/tairu/server.rb

@@ -3,10 +3,23 @@ require File.join(File.dirname(__FILE__), '..', 'tairu')
 
 module Tairu
   class Server < Sinatra::Base
-    get '/:tileset/:zoom/:row/:col.grid.json' do
+    get '/:tileset/info' do
+      tileset = Tairu.tilesets[params[:tileset]]
+
+      status 404 if tileset.nil?
+
+      content_type :json
+      tileset.info.to_json
+    end
+
+    get '/:tileset/:zoom/:col/:row.grid.json' do
+      status 404 unless Tairu.layers[params[:tileset]]['provider'] == 'mbtiles'
+
+      tileset = Tairu.tilesets[params[:tileset]]
+      status 404 if tileset.nil?
+
       coord = Tairu::Coordinate.new(Integer(params[:row]), Integer(params[:col]), Integer(params[:zoom]))
-      tileset = Tairu::CONFIG.layers[params[:tileset]]
-      tile = Tairu::Store::MBTiles.get_grid(params[:tileset], tileset['tileset'], coord)
+      tile = tileset.get_grid(coord)
 
       callback = params.delete('callback')
 
@@ -19,7 +32,7 @@ module Tairu
       end
     end
 
-    get '/:tileset/:zoom/:row/:col' do
+    get '/:tileset/:zoom/:col/:row' do
       coord = Tairu::Coordinate.new(Integer(params[:row]), Integer(params[:col]), Integer(params[:zoom]))
       tile = Tairu.get_tile(params[:tileset], coord)
 
@@ -28,4 +41,4 @@ module Tairu
       tile.data
     end
   end
-end
+end

data/lib/tairu/store.rb

@@ -1,11 +1,13 @@
 require 'store/mbtiles'
 require 'store/esri'
+require 'store/tms'
 
 module Tairu
   module Store
     TYPES = {
       'mbtiles' => Tairu::Store::MBTiles,
-      'esri' => Tairu::Store::Esri
+      'esri' => Tairu::Store::Esri,
+      'tms' => Tairu::Store::TMS
     }
   end
 end

data/lib/tairu/store/esri.rb

@@ -1,35 +1,37 @@
 module Tairu
   module Store
     class Esri
-      def self.decode_hex(hex_value)
-        Integer("0x#{hex_value}")
-      end
-
-      def self.encode_hex(int_value, length = 8)
-        length = "%02i" % length
-        "%#{length}x" % int_value
+      def initialize(layer)
+        @tileset = File.join(File.expand_path(Tairu.layers[layer]['location']), Tairu.layers[layer]['tileset'])
       end
 
-      def self.get(layer, tileset, coord, format = 'png')
-        loc = File.expand_path(Tairu::CONFIG.layers[layer]['location'])
-        path = File.join(loc, tileset, 'Layers', '_alllayers', "L#{'%02i' % coord.zoom}", "R#{encode_hex(coord.row)}", "C#{encode_hex(coord.column)}.#{format}")
+      def get(coord, format='png')
+        path = File.join(@tileset, 'Layers', '_alllayers', "L#{'%02i' % coord.zoom}", "R#{encode_hex(coord.row)}", "C#{encode_hex(coord.column)}.#{format}")
 
         return nil unless File.exists?(path)
 
-        if File.exists?(path)
-          data = File.open(path, 'r') do |f|
-            begin
-              f.flock(File::LOCK_SH)
-              f.read
-            ensure
-              f.flock(File::LOCK_UN)
-            end
+        data = File.open(path, 'r') do |f|
+          begin
+            f.flock(File::LOCK_SH)
+            f.read
+          ensure
+            f.flock(File::LOCK_UN)
           end
         end
 
         mime_type = "image/#{format}"
-        Tairu::Tile.new(data, mime_type)
+        tile = data.nil? ? nil : Tairu::Tile.new(data, mime_type)
+        tile
+      end
+
+      def decode_hex(hex_value)
+        Integer("0x#{hex_value}")
+      end
+
+      def encode_hex(int_value, length=8)
+        length = "%02i" % length
+        "%#{length}x" % int_value
       end
     end
   end
-end
+end

data/lib/tairu/store/mbtiles.rb

@@ -4,170 +4,68 @@ require 'zlib'
 module Tairu
   module Store
     class MBTiles
-      def initialize;end
-
-      def self.inflate(str)
-        zstream = Zlib::Inflate.new
-        buf = zstream.inflate(str)
-        zstream.finish
-        zstream.close
-        buf
+      def initialize(layer)
+        tileset = File.join(File.expand_path(Tairu.layers[layer]['location']), Tairu.layers[layer]['tileset'])
+        conn = defined?(JRUBY_VERSION) ? "jdbc:sqlite:#{tileset}" : "sqlite://#{tileset}"
+        @db = Sequel.connect(conn, max_connections: 1)
       end
 
-      def self.connection_string(layer)
-        loc = File.expand_path(Tairu::CONFIG.layers[layer]['location'])
-        conn = defined?(JRUBY_VERSION) ? "jdbc:sqlite:#{loc}" : "sqlite://#{loc}"
-        conn
+      def flip_y(zoom, y)
+        (2 ** zoom - 1) - y
       end
 
-      def self.create(layer, file, name, type, version, description, format, bounds = nil)
-        unless %w{png jpg}.index format
-          raise "Format {#{format}} not supported. Must be 'png' or 'jpg' per MBTiles 1.1 spec."
-        end
-
-        conn = connection_string(layer)
-        db = Sequel.connect(File.join(conn, file))
-
-        unless db.table_exists?(:metadata)
-          db.create_table :metadata do
-            primary_key :name
-            String :name
-            String :value
-          end
-
-          db.add_index :metadata, :name, unique: true
-        end
-
-        unless db.table_exists?(:tiles)
-          db.create_table :tiles do
-            Integer :zoom_level
-            Integer :tile_column
-            Integer :tile_row
-            Blob :tile_data
-          end
-
-          db.add_index :tiles, [:zoom_level, :tile_column, :tile_row], unique: true
-        end
-
-        md = db[:metadata]
-
-        md.insert(name: 'name', value: name)
-        md.insert(name: 'type', value: type)
-        md.insert(name: 'version', value: version)
-        md.insert(name: 'description', value: description)
-        md.insert(name: 'format', value: format)
-        md.insert(name: 'bounds', value: bounds) unless bounds.nil?
-
-        db.disconnect
-      end
-
-      def self.exists?(layer, file)
-        conn = connection_string(layer)
-        db = Sequel.connect(File.join(conn, file))
-
-        tv = db.tables + db.views
-
-        [:metadata, :tiles].each {|s| return false unless tv.index(s)}
-
-        exists = db[:metadata].first.nil? && db[:tiles].first.nil?
-
-        db.disconnect
-
-        exists
-      end
-
-      def self.info(layer, file)
-        file_loc = File.join(File.expand_path(Tairu::CONFIG.layers[layer]['location']), file)
-        raise "Tileset does not exist." unless exists? file_loc
-
-        conn = connection_string(layer)
-        db = Sequel.connect(File.join(conn, file))
-
-        info = {}
-
-        %w{name type version description format bounds}.each do |key|
-          value = db[:metadata].where(name: key).first
-          info[key] = value[:value] unless value.nil?
-        end
-
-        db.disconnect
-
-        info
-      end
-
-      def self.list(layer, file)
-        conn = connection_string(layer)
-        db = Sequel.connect(File.join(conn, file))
-
-        tiles = db[:tiles]
-
-        list = []
-
-        tiles.each do |tile|
-          list << [((2 ** tile[:zoom_level] - 1) - tile[:tile_row]), tile[:tile_column], tile[:zoom_level]]
-        end
-
-        db.disconnect
-
-        list
-      end
-
-      def self.get(layer, file, coord, format = nil)
-        conn = connection_string(layer)
-        db = Sequel.connect(File.join(conn, file))
-
+      def get(coord, format=nil)
         formats = {
           'png' => 'image/png',
           'jpg' => 'image/jpg'
         }
 
-        format = db[:metadata].select(:value).where(name: 'format').first
+        format = @db[:metadata].select(:value).where(name: 'format').first
         mime_type = format.nil? ? formats['png'] : formats[format[:value]]
 
-        tile_row = (2 ** coord.zoom - 1) - coord.row
-        tile = db[:tiles].where(zoom_level: coord.zoom, tile_column: coord.column, tile_row: tile_row)
+        tile = @db[:tiles].where(zoom_level: coord.zoom, tile_column: coord.column, tile_row: flip_y(coord.zoom, coord.row))
 
         tile_data = tile.first.nil? ? nil : Tairu::Tile.new(tile.first[:tile_data], mime_type)
-
-        db.disconnect
-
         tile_data
       end
 
-      def self.get_grid(layer, file, coord)
-        conn = connection_string(layer)
-        db = Sequel.connect(File.join(conn, file))
-
-        tile_row = (2 ** coord.zoom - 1) - coord.row
-        grid = db[:grids].where(zoom_level: coord.zoom, tile_column: coord.column, tile_row: tile_row)
+      def get_grid(coord)
+        grid = @db[:grids].where(zoom_level: coord.zoom, tile_column: coord.column, tile_row: flip_y(coord.zoom, coord.row))
 
-        grid_buf = inflate(grid.first[:grid])
-
-        utf_grid = JSON.parse(grid_buf)
+        utf_grid = JSON.parse(inflate(grid.first[:grid]))
         utf_grid[:data] = {}
 
-        grid_data = db[:grid_data].where(zoom_level: coord.zoom, tile_column: coord.column, tile_row: tile_row)
-        
+        grid_data = @db[:grid_data].where(zoom_level: coord.zoom, tile_column: coord.column, tile_row: tile_row)
+
         grid_data.each do |gd|
           utf_grid[:data][gd[:key_name]] = JSON.parse(gd[:key_json])
         end
 
-        db.disconnect
-
         utf_grid
       end
 
-      def self.remove(layer, file, coord)
-        conn = connection_string(layer)
-        db = Sequel.connect(File.join(conn, file))
-        db.disconnect
+      def get_legend
+        @db[:metadata].where(name: 'legend').first
+      end
+
+      def info
+        info = {}
+
+        %w{name type version description format bounds attribution minzoom maxzoom template legend}.each do |key|
+          value = @db[:metadata].where(name: key).first
+          info[key] = value[:value] unless value.nil?
+        end
+
+        info
       end
 
-      def self.add(layer, file, coord, tile_data)
-        conn = connection_string(layer)
-        db = Sequel.connect(File.join(conn, file))
-        db.disconnect
+      def inflate(str)
+        zstream = Zlib::Inflate.new
+        buf = zstream.inflate(str)
+        zstream.finish
+        zstream.close
+        buf
       end
     end
   end
-end
+end

data/lib/tairu/store/tms.rb

@@ -0,0 +1,36 @@
+module Tairu
+  module Store
+    class TMS
+      def initialize(layer)
+        @tileset = File.join(File.expand_path(Tairu.layers[layer]['location']), Tairu.layers[layer]['tileset'])
+      end
+
+      def flip_y(z, y)
+        (2 ** z - 1) - y
+      end
+
+      def get(coord, format='png')
+        z = "#{coord.zoom}"
+        x = "#{coord.column}"
+        y = flip_y(coord.zoom, coord.row)
+
+        path = File.join(@tileset, z, x, "#{y}.#{format}")
+
+        return nil unless File.exists?(path)
+
+        data = File.open(path, 'r') do |f|
+          begin
+            f.flock(File::LOCK_SH)
+            f.read
+          ensure
+            f.flock(File::LOCK_UN)
+          end
+        end
+
+        mime_type = "image/#{format}"
+        tile = data.nil? ? nil : Tairu::Tile.new(data, mime_type)
+        tile
+      end
+    end
+  end
+end

data/lib/tairu/version.rb

@@ -1,3 +1,3 @@
 module Tairu
-  VERSION = '0.9.0'
-end
+  VERSION = '0.10.0'
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tairu
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,49 +9,113 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-11 00:00:00.000000000 Z
+date: 2013-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.46.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.46.0
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.3
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.7.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.7.2
 - !ruby/object:Gem::Dependency
   name: sinatra
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.4.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.4.2
 - !ruby/object:Gem::Dependency
   name: puma
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.6.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.6.3
+- !ruby/object:Gem::Dependency
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
@@ -60,7 +124,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -80,8 +144,7 @@ email:
 - scooterwadsworth@gmail.com
 executables:
 - tairu
-extensions:
-- ext/mkrf_conf.rb
+extensions: []
 extra_rdoc_files: []
 files:
 - README.md
@@ -89,21 +152,21 @@ files:
 - bin/tairu
 - lib/tairu/cache/disk.rb
 - lib/tairu/cache/memory.rb
+- lib/tairu/cache/redis_cache.rb
 - lib/tairu/cache.rb
 - lib/tairu/configuration.rb
 - lib/tairu/coordinate.rb
-- lib/tairu/images/404.png
 - lib/tairu/server.rb
 - lib/tairu/store/esri.rb
 - lib/tairu/store/mbtiles.rb
+- lib/tairu/store/tms.rb
 - lib/tairu/store.rb
 - lib/tairu/tile.rb
 - lib/tairu/version.rb
 - lib/tairu.rb
-- ext/mkrf_conf.rb
 homepage: https://github.com/scooterw/tairu
 licenses:
-- MIT
+- BSD
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -122,7 +185,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Simple Tile Server for Ruby

data/ext/mkrf_conf.rb

@@ -1,26 +0,0 @@
-require 'rubygems'
-require 'rubygems/command.rb'
-require 'rubygems/dependency_installer.rb'
-
-begin
-  Gem::Command.build_args = ARGV
-rescue NoMethodError
-end
-
-inst = Gem::DependencyInstaller.new
-
-begin
-  if defined?(JRUBY_VERSION)
-    inst.install 'jdbc-sqlite3'
-  else
-    inst.install 'sqlite3'
-  end
-rescue
-  exit(1)
-end
-
-p File.expand_path(__FILE__)
-
-f = File.open(File.join(File.expand_path(File.dirname(__FILE__)), 'Rakefile'), 'w')
-f.write("task :default\n")
-f.close