osmer 0.0.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Alexey Noskov
+
+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/README.rdoc

@@ -0,0 +1,87 @@
+= Osmer
+
+Osmer is a tool to manage local OSM database: import data, transform it to convenient scheme and update it.
+
+== Features
+
+* Importing and updating data in osm2pgsql schema (osm2pgsql required)
+* Custom derived schemas for analysis or rendering convenience
+* BBox restriction of imported data
+* Data reprojection between schemas
+* [planned] Rails-like config/database.yml support for seamless integration with webapps
+* [planned] Importing and updating data in pgsnapshot schema (osmosis required)
+
+== Configuration
+
+Database schemas definition goes to Osmfile which contains basic flags and schema definitions:
+
+  prefix 'osmer' # Prefix for all tables
+
+  schema :source, :type => :osm2pgsql do # Osm2pgsql schema named 'source'
+
+    bbox 35.859375, 54.367759, 36.562495, 54.775345 # It has bounding box restriction as minlon, minlat, maxlon, maxlat
+
+    updates :daily do # It may be updated on daily basis
+      dump 'http://data.gis-lab.info/osm_dump/dump/RU-KLU/RU-KLU-{today}.osm.pbf' # Where initial dump should be downloaded from here
+      diff 'http://data.gis-lab.info/osm_dump/diff/RU/RU-{yesterday}-{today}.osc.gz' # And diff should be downloaded from here
+    end
+
+  end
+
+  schema :rendering, :projection => 900913 do # Rendering schema containing only necessary data
+
+    multipolygons :places do # Table of place boundaries
+      map :place => [:city, :town, :village, :hamlet] # It contains features which have place tag with one of values: city, town, village, hamlet
+
+      with :area # And also polygon area
+    end
+
+    lines :roads do # Table of roads
+      map :highway # It contains features with highway tag
+
+      with :length, :ref => :string # And also road length and ref tag to additional table column
+    end
+
+  end
+
+== Usage
+
+Osmer may be used as command-line executable with following commands:
+
+* osmer schema create [SCHEMA]    # Create given osm schema in database (create all if none specified)
+* osmer schema drop [SCHEMA]      # Drop given osm schema in database (drop all if none specified)
+* osmer schema recreate [SCHEMA]  # Recreate given osm schema in database (recreate all if none specified)
+
+* osmer data import [SCHEMA] [FILE]  # Import data to given schema from file
+* osmer data update [SCHEMA] [FILE]  # Update data in schema from given change file
+
+== Details
+
+=== Schema
+
+Schema is a set of tables representing osm data in a common way. Examples of schemas may be:
+
+* Osm2Pgsql schema
+* PgSnapshot schema populated with Osmosis
+* Custom set of tables, representing data in convenient way
+
+All tables in schema share common projection.
+In database schemas are represented with table prefixes (native schemas will be supported later)
+
+In code, schema is representd by an object, which have following methods:
+
+* create! - to create schema in database
+* drop! - to drop schema in database
+* attach_listener! - (optional) - to add listener to schema data, which may be used to have autoupdate functionality
+
+listener with name <name> is a stored procedure set:
+
+  <name>_insert(id,*args)
+  <name>_update(id,*args)
+  <name>_delete(id)
+
+== Contributors
+
+See https://github.com/alno/osmer/graphs/contributors
+
+Copyright © 2012 Alexey Noskov, released under the MIT license

data/bin/osmer

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+
+require 'osmer/app'
+
+Osmer::App.start

data/data/empty.osm

@@ -0,0 +1,2 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<osm version="0.6" generator="No gen" />

data/lib/osmer.rb

@@ -0,0 +1,92 @@
+class Osmer
+
+  module Data; end
+  module Mapper; end
+  module Schema; end
+  module Target; end
+
+  module Utils
+
+    # Based on https://github.com/intridea/omniauth/blob/v1.0.2/lib/omniauth.rb#L129-139
+    def camelize(str)
+      str.to_s.gsub(/\/(.?)/){ "::" + $1.upcase }.gsub(/(^|_)(.)/){ $2.upcase }
+    end
+
+    def underscore(str)
+      str.to_s.gsub(/::(.?)/){ "/" + $1.downcase }.gsub(/(.)([A-Z])/){ "#{$1}_#{$2.downcase}" }.downcase
+    end
+
+  end
+
+  module Configurable
+
+    def configure(file = nil, &block)
+      if file
+        dsl.instance_eval{ eval File.read(file) }
+      elsif block
+        dsl.instance_eval(&block)
+      end
+
+      self
+    end
+
+    private
+
+    def dsl
+      self.class.const_get('Dsl').new(self)
+    end
+
+  end
+
+  include Utils
+  include Configurable
+
+  attr_reader :schemas
+  attr_accessor :prefix
+
+  def initialize
+    @schemas = []
+  end
+
+  def add_schema(name, options)
+    type = options.delete(:type) || 'custom'
+
+    require "osmer/schema/#{type}"
+
+    schema = Osmer::Schema.const_get(camelize type).new self, name, options
+    schemas << schema
+    schema
+  end
+
+  def find_schema(name)
+    schemas.find{|s| s.name.to_s == name.to_s }
+  end
+
+  def create_all!(db)
+    @schemas.each{|s| s.create! db }
+  end
+
+  def drop_all!(db)
+    @schemas.reverse.each{|s| s.drop! db }
+  end
+
+  def recreate_all!(db)
+    drop_all! db
+    create_all! db
+  end
+
+  class Dsl < Struct.new(:osmer)
+
+    def schema(name, options, &block)
+      schema = osmer.add_schema name, options
+      schema.configure &block if block
+      schema
+    end
+
+    def prefix(value)
+      osmer.prefix = value
+    end
+
+  end
+
+end

data/lib/osmer/app.rb

@@ -0,0 +1,12 @@
+require 'osmer/thor_base'
+require 'osmer/data/app'
+require 'osmer/schema/app'
+
+require 'thor/group'
+
+class Osmer::App < Osmer::ThorBase
+
+  register Osmer::Data::App, 'data', 'data <command>', 'OSM data management'
+  register Osmer::Schema::App, 'schema', 'schema <command>', 'OSM schema management'
+
+end

data/lib/osmer/data/app.rb

@@ -0,0 +1,16 @@
+require 'osmer/thor_base'
+
+class Osmer::Data::App < Osmer::ThorBase
+  namespace :data
+
+  desc "import SCHEMA [FILE]", "Import data to given schema from file"
+  def import(schema, file = nil)
+    osmer.find_schema(schema).import_data! db, file
+  end
+
+  desc "update SCHEMA [FILE]", "Update data in schema from given change file"
+  def update(schema, file = nil)
+    osmer.find_schema(schema).update_data! db, file
+  end
+
+end

data/lib/osmer/mapper/address.rb

@@ -0,0 +1,19 @@
+require 'osmer/mapper/base'
+
+class Osmer::Mapper::Address < Osmer::Mapper::Base
+
+  def assigns
+    { :street => "src_tags->'addr:street'",
+      :housenumber => "src_tags->'addr:housenumber'",
+      :city => "src_tags->'addr:city'",
+      :postcode => "src_tags->'addr:postcode'" }
+  end
+
+  def fields
+    { :street => "TEXT",
+      :housenumber => 'TEXT',
+      :city => "TEXT",
+      :postcode => "TEXT" }
+  end
+
+end

data/lib/osmer/mapper/area.rb

@@ -0,0 +1,13 @@
+require 'osmer/mapper/base'
+
+class Osmer::Mapper::Area < Osmer::Mapper::Base
+
+  def assigns
+    { :area => "ST_Area(ST_Transform(src_geometry,#{table.projection}))" }
+  end
+
+  def fields
+    { :area => "REAL" }
+  end
+
+end

data/lib/osmer/mapper/base.rb

@@ -0,0 +1,28 @@
+require 'osmer'
+
+class Osmer::Mapper::Base
+
+  attr_reader :table, :name
+
+  def initialize(table, name, options = {})
+    @table = table
+    @name = name
+  end
+
+  def fields
+    { name => "TEXT" }
+  end
+
+  def assigns
+    { name => "src_tags->'#{name}'" }
+  end
+
+  def conditions
+    []
+  end
+
+  def indexes
+    {}
+  end
+
+end

data/lib/osmer/mapper/length.rb

@@ -0,0 +1,13 @@
+require 'osmer/mapper/base'
+
+class Osmer::Mapper::Length < Osmer::Mapper::Base
+
+  def assigns
+    { :area => "ST_Length(ST_Transform(src_geometry,#{table.projection}))" }
+  end
+
+  def fields
+    { :area => "REAL" }
+  end
+
+end

data/lib/osmer/mapper/name.rb

@@ -0,0 +1,4 @@
+require 'osmer/mapper/base'
+
+class Osmer::Mapper::Name < Osmer::Mapper::Base
+end

data/lib/osmer/mapper/string.rb

@@ -0,0 +1,4 @@
+require 'osmer/mapper/base'
+
+class Osmer::Mapper::String < Osmer::Mapper::Base
+end

data/lib/osmer/mapper/type.rb

@@ -0,0 +1,91 @@
+require 'osmer/mapper/base'
+
+class Osmer::Mapper::Type < Osmer::Mapper::Base
+
+  attr_reader :mappings
+
+  def initialize(*args)
+    super
+
+    @mappings = []
+    @multi = false
+  end
+
+  def assigns
+    if @multi
+      { :type => expression, :types => expression_multi }
+    else
+      { :type => expression }
+    end
+  end
+
+  def fields
+    if @multi
+      { :type => 'TEXT NOT NULL', :types => 'TEXT[]' }
+    else
+      { :type => 'TEXT NOT NULL' }
+    end
+  end
+
+   def indexes
+    if @multi
+      { :type => "BTREE(type)", :types => "GIN(types)" }
+    else
+      { :type => "BTREE(type)" }
+    end
+  end
+
+  def conditions
+    [ @mappings.map{|m| map_cond(m)}.join(' OR ') ]
+  end
+
+  def expression
+    "CASE #{@mappings.map{|m| "WHEN #{map_cond(m)} THEN trim(regexp_replace(src_tags->'#{m[0]}', ',.*', ''))"}.join(' ')} END"
+  end
+
+  def expression_multi
+    "(#{@mappings.map{|m| "string_to_array(coalesce(CASE WHEN #{map_cond(m)} THEN replace(src_tags->'#{m[0]}',' ','') END,''),',')"}.join(' || ')})"
+  end
+
+  def map_cond(m)
+    m[1] ? "(src_tags->'#{m[0]}') IN ('#{m[1].join("','")}')" : "(src_tags->'#{m[0]}') IS NOT NULL"
+  end
+
+  def add_args(*args)
+    args.each do |arg|
+      if arg.is_a? Hash
+        arg.each(&method(:add_arg))
+      else
+        add_arg arg, nil
+      end
+    end
+  end
+
+  def add_arg(key, value)
+    key = to_key(key)
+
+    if key == 'multi'
+      @multi = value
+    else
+      @mappings << [key, to_keylist(value)]
+    end
+  end
+
+  private
+
+  def to_key(key)
+    raise StandardError.new("Invalid key #{key.inspect}") unless key.is_a? String or key.is_a? Symbol
+    key.to_s
+  end
+
+  def to_keylist(list)
+    if list.nil?
+      list
+    elsif list.is_a? Array
+      list.map(&method(:to_key))
+    else
+      [to_key(list)]
+    end
+  end
+
+end

data/lib/osmer/schema/app.rb

@@ -0,0 +1,33 @@
+require 'osmer/thor_base'
+
+class Osmer::Schema::App < Osmer::ThorBase
+  namespace :schema
+
+  desc "create [SCHEMA]", "Create given osm schema in database (create all if none specified)"
+  def create(schema = nil)
+    if schema
+      osmer.find_schema(schema).create! db
+    else
+      osmer.create_all! db
+    end
+  end
+
+  desc "recreate [SCHEMA]", "Recreate given osm schema in database (recreate all if none specified)"
+  def recreate(schema = nil)
+    if schema
+      osmer.find_schema(schema).recreate! db
+    else
+      osmer.recreate_all! db
+    end
+  end
+
+  desc "drop [SCHEMA]", "Drop given osm schema in database (drop all if none specified)"
+  def drop(schema = nil)
+    if schema
+      osmer.find_schema(schema).drop! db
+    else
+      osmer.drop_all! db
+    end
+  end
+
+end

data/lib/osmer/schema/base.rb

@@ -0,0 +1,68 @@
+require 'osmer'
+
+class Osmer::Schema::Base
+
+  include Osmer::Configurable
+
+  attr_reader :ns, :name
+  attr_accessor :projection
+
+  def initialize(ns, name, options = {})
+    @ns = ns
+    @name = name
+    @projection = 4326
+
+    options.each do |k,v| # Assign all schema options
+      send "#{k}=", v
+    end
+  end
+
+  # Create schema in given database
+  def create!(db)
+    raise StandardError.new("Not implemented")
+  end
+
+  # Drop schema in given database
+  def drop!(db)
+    raise StandardError.new("Not implemented")
+  end
+
+  def recreate!(db)
+    drop! db
+    create! db
+  end
+
+  # Add collection listener
+  # name - stored procedure name
+  #
+  def attach_listener!(conn, collection, name, fields)
+    raise StandardError.new("Not implemented")
+  end
+
+  def detach_listener!(conn, collection, name, fields)
+    raise StandardError.new("Not implemented")
+  end
+
+  def table_prefix
+    [@ns.prefix, name].compact.join('_')
+  end
+
+  private
+
+  class Dsl < Struct.new(:schema)
+
+    def method_missing(method, *args)
+      if schema.respond_to?("#{method}=") && !args.empty?
+        if args.size > 1
+          schema.send "#{method}=", args
+        else
+          schema.send "#{method}=", args.first
+        end
+      else
+        super
+      end
+    end
+
+  end
+
+end

data/lib/osmer/schema/custom.rb

@@ -0,0 +1,198 @@
+require 'osmer/schema/base'
+
+class Osmer::Schema::Custom < Osmer::Schema::Base
+
+  attr_reader :tables
+  attr_accessor :source
+
+  def initialize(*args)
+    @tables = []
+    super
+  end
+
+  def dsl
+    Dsl.new(self)
+  end
+
+  def create!(db)
+    db.in_transaction do |conn|
+      tables.each do |table|
+        create_table! db, conn, table
+      end
+    end
+  end
+
+  def drop!(db)
+    db.in_transaction do |conn|
+      tables.reverse.each do |table|
+        drop_table! db, conn, table
+      end
+    end
+  end
+
+  private
+
+  def create_table!(db, conn, table)
+    table_name = "#{table_prefix}_#{table.name}"
+    table_fields = { :id => 'INT8', :tags => 'HSTORE' }
+    table_assigns = { :tags => 'src_tags' }
+    table_conditions = []
+    table_indexes = { :geometry => 'GIST(geometry)' }
+
+    if table.type.to_s.start_with? 'multi'
+      table_assigns[:geometry] = "ST_Transform(ST_Multi(src_geometry), #{projection})"
+    else
+      table_assigns[:geometry] = "ST_Transform(src_geometry, #{projection})"
+    end
+
+    table.mappers.each do |k,v|
+      table_fields.merge! v.fields
+      table_assigns.merge! v.assigns
+      table_indexes.merge! v.indexes
+      table_conditions |= v.conditions
+    end
+
+    table_assigns_keys = table_assigns.keys.to_a
+    table_assigns_values = table_assigns_keys.map{|k| table_assigns[k] }
+    table_condition = table_conditions.map{|c| "(#{c})"}.join(' AND ')
+
+    conn.exec "CREATE TABLE #{table_name}(#{table_fields.map{|k,v| "#{k} #{v}"}.join(', ')})"
+    conn.exec "SELECT AddGeometryColumn('#{table_name}', 'geometry', #{projection}, '#{db.geometry_type table.type}', 2)"
+
+    table_indexes.each do |key,desc|
+      conn.exec "CREATE INDEX #{table_name}_#{key}_index ON #{table_name} USING #{desc}"
+    end
+
+    conn.exec %Q{CREATE OR REPLACE FUNCTION #{table_name}_insert(src_id BIGINT, src_tags HSTORE, src_geometry GEOMETRY) RETURNS BOOLEAN AS $$
+      BEGIN
+        IF #{table_condition} THEN
+          INSERT INTO #{table_name} (id, #{table_assigns_keys.join(', ')}) VALUES (src_id, #{table_assigns_values.join(', ')});
+          RETURN FOUND;
+        ELSE
+          RETURN FALSE;
+        END IF;
+      END; $$ LANGUAGE plpgsql;}
+
+    conn.exec %Q{CREATE OR REPLACE FUNCTION #{table_name}_update(src_id BIGINT, src_tags HSTORE, src_geometry GEOMETRY) RETURNS BOOLEAN AS $$
+      BEGIN
+        IF #{table_condition} THEN
+          UPDATE #{table_name} SET #{table_assigns.map{|k,v| "#{k} = #{v}"}.join(', ')} WHERE id = src_id;
+
+          IF NOT FOUND THEN
+            INSERT INTO #{table_name} (id, #{table_assigns_keys.join(', ')}) VALUES (src_id, #{table_assigns_values.join(', ')});
+          END IF;
+
+          RETURN FOUND;
+        ELSE
+          DELETE FROM #{table_name} WHERE id = src_id;
+          RETURN FOUND;
+        END IF;
+      END; $$ LANGUAGE plpgsql;}
+
+    conn.exec %Q{CREATE OR REPLACE FUNCTION #{table_name}_delete(src_id BIGINT) RETURNS BOOLEAN AS $$
+      BEGIN
+        DELETE FROM #{table_name} WHERE id = src_id;
+        RETURN FOUND;
+      END; $$ LANGUAGE plpgsql;}
+
+    table.source_schema.attach_listener! conn, table.source_table, table_name, listener_fields
+
+    conn.exec "ANALYZE #{table_name}"
+  end
+
+  def drop_table!(db, conn, table)
+    table_name = "#{table_prefix}_#{table.name}"
+
+    table.source_schema.detach_listener! conn, table.source_table, table_name, listener_fields
+
+    conn.exec "DROP TABLE IF EXISTS #{table_name}"
+  end
+
+  def listener_fields
+    [:tags, :geometry]
+  end
+
+  class Dsl < Osmer::Schema::Base::Dsl
+
+    def multipolygons(name, options = {}, &block)
+      table name, :multipolygons, options, &block
+    end
+
+    def multilines(name, options = {}, &block)
+      table name, :multilines, options, &block
+    end
+
+    def polygons(name, options = {}, &block)
+      table name, :polygons, options, &block
+    end
+
+    def lines(name, options = {}, &block)
+      table name, :lines, options, &block
+    end
+
+    def points(name, options = {}, &block)
+      table name, :points, options, &block
+    end
+
+    def table(name, type, options, &block)
+      schema.tables << Table.new(schema, name, type, options).configure(&block)
+    end
+
+  end
+
+  class Table
+
+    include Osmer::Configurable
+
+    attr_reader :schema, :name, :type, :source_schema, :source_table, :mappers
+
+    def initialize(schema, name, type, options)
+      require 'osmer/mapper/type'
+      require 'osmer/mapper/name'
+
+      @schema, @name, @type = schema, name, type
+
+      @source_table = type.to_s.gsub(/\Amulti/,'')
+      @source_schema = schema.ns.find_schema(options[:source] || schema.source || :source) or raise StandardError.new("Source schema not found")
+
+      @mappers = {
+        :type => Osmer::Mapper::Type.new(self, :type),
+        :name => Osmer::Mapper::Name.new(self, :name)
+      }
+    end
+
+    def projection
+      schema.projection
+    end
+
+    class Dsl < Struct.new(:table)
+
+      include Osmer::Utils
+
+      def map(*args)
+        table.mappers[:type].add_args(*args)
+      end
+
+      def with(*args)
+        args.each do |arg|
+          if arg.is_a? Hash
+            arg.each(&method(:add_mapper))
+          else
+            add_mapper arg, arg
+          end
+        end
+      end
+
+      private
+
+      def add_mapper(key, type)
+        require "osmer/mapper/#{type}"
+
+        table.mappers[key.to_s] = Osmer::Mapper.const_get(camelize type).new table, key
+      end
+
+    end
+
+  end
+
+end

data/lib/osmer/schema/osm2pgsql.rb

@@ -0,0 +1,154 @@
+require 'osmer/schema/base'
+
+class Osmer::Schema::Osm2pgsql < Osmer::Schema::Base
+
+  attr_accessor :osm2pgsql_binary, :bbox, :updater
+
+  def initialize(*args)
+    @osm2pgsql_binary = 'osm2pgsql'
+    super
+  end
+
+  # Create schema in given database
+  def create!(db)
+    db.in_transaction do |conn|
+      raise StandardError.new("Schema #{name} already created!") unless schema_tables(conn).empty?
+    end
+
+    osm2pgsql_exec db, "'#{empty_file}'", "creating osm2pgsql schema"
+  end
+
+  # Drop schema in given database
+  def drop!(db)
+    db.in_transaction do |conn|
+      schema_tables(conn).each do |table|
+        conn.exec "DROP TABLE IF EXISTS #{table}"
+      end
+    end
+  end
+
+  def import_data!(db, file = nil)
+    raise StandardError.new("No file or updater specified") unless file or updater
+
+    db.in_transaction do |conn|
+      schema_tables(conn).each do |table|
+        conn.exec "DELETE FROM #{table}"
+      end
+    end
+
+    if file
+      osm2pgsql_exec db, "-a '#{file}'", "importing data with osm2pgsql from #{file}"
+    else
+      updater.load_dump db, self do |f|
+        osm2pgsql_exec db, "-a '#{f}'", "importing data with osm2pgsql from #{f}"
+      end
+    end
+  end
+
+  def update_data!(db, file = nil)
+    raise StandardError.new("No file or updater specified") unless file or updater
+
+    if file
+      osm2pgsql_exec db, "-a '#{file}'", "importing data with osm2pgsql from #{file}"
+    else
+      updater.load_diffs db, self do |f|
+        osm2pgsql_exec db, "-a '#{f}'", "importing data with osm2pgsql from #{f}"
+      end
+    end
+  end
+
+  def attach_listener!(conn, collection, name, fields)
+    table  = collection_table collection
+    args = fields.map{|f| collection_field(collection, f) }.join(', ')
+
+    conn.exec %Q{CREATE OR REPLACE FUNCTION #{name}_insert_proxy() RETURNS trigger AS $$
+      BEGIN
+        PERFORM #{name}_insert(NEW.osm_id, #{args});
+        RETURN NULL;
+      END; $$ LANGUAGE plpgsql}
+
+    conn.exec %Q{CREATE OR REPLACE FUNCTION #{name}_update_proxy() RETURNS trigger AS $$
+      BEGIN
+        PERFORM #{name}_update(NEW.osm_id, #{args});
+        RETURN NULL;
+      END; $$ LANGUAGE plpgsql}
+
+    conn.exec %Q{CREATE OR REPLACE FUNCTION #{name}_delete_proxy() RETURNS trigger AS $$
+      BEGIN
+        PERFORM #{name}_delete(OLD.osm_id);
+        RETURN NULL;
+      END; $$ LANGUAGE plpgsql}
+
+    # Create new triggers
+    conn.exec "CREATE TRIGGER #{name}_insert_trigger AFTER INSERT ON #{table} FOR EACH ROW EXECUTE PROCEDURE #{name}_insert_proxy()"
+    conn.exec "CREATE TRIGGER #{name}_update_trigger AFTER UPDATE ON #{table} FOR EACH ROW EXECUTE PROCEDURE #{name}_update_proxy()"
+    conn.exec "CREATE TRIGGER #{name}_delete_trigger AFTER DELETE ON #{table} FOR EACH ROW EXECUTE PROCEDURE #{name}_delete_proxy()"
+
+    # Prepopulate dependency
+    conn.exec "SELECT #{name}_insert(NEW.osm_id, #{args}) FROM #{table} NEW"
+  end
+
+  def detach_listener!(conn, collection, name, fields)
+    table  = collection_table collection
+
+    # Drop triggers
+    conn.exec "DROP TRIGGER IF EXISTS #{name}_insert_trigger ON #{table}"
+    conn.exec "DROP TRIGGER IF EXISTS #{name}_update_trigger ON #{table}"
+    conn.exec "DROP TRIGGER IF EXISTS #{name}_delete_trigger ON #{table}"
+  end
+
+  private
+
+  def osm2pgsql_exec(db, tail, desc)
+    cmd = "'#{osm2pgsql_binary}' -j -m -G --slim -U #{db[:username]} -d #{db[:database]} -H #{db[:host]} -p '#{table_prefix}'"
+    cmd << " --bbox #{bbox.join(',')}" if bbox # Restrict import if bbox specified
+
+    case projection.to_i
+    when 4326 then cmd << ' --latlong'
+    when 900913 then cmd << ' --merc'
+    else raise StandardError.new("Unsupported projection #{projection}")
+    end
+
+    puts "#{cmd} #{tail}"
+    system "#{cmd} #{tail}" or raise StandardError.new("Error #{desc}")
+  end
+
+  def schema_tables(conn)
+    res = conn.exec "select table_name from information_schema.tables where table_schema = 'public' AND table_name LIKE '#{table_prefix}_%'"
+    tables = res.values.flatten
+    res.clear
+    tables
+  end
+
+  def collection_table(collection)
+    case collection.to_s
+    when 'polygons' then "#{table_prefix}_polygon"
+    when 'lines' then "#{table_prefix}_line"
+    when 'points' then "#{table_prefix}_point"
+    else raise StandardError.new("Unsupported collection '#{collection}'")
+    end
+  end
+
+  def collection_field(collection, field)
+    case field.to_s
+    when 'geometry' then 'NEW.way'
+    when 'tags' then 'NEW.tags'
+    else raise StandardError.new("Unsupported field '#{field}' in collection '#{collection}'")
+    end
+  end
+
+  def empty_file
+    File.expand_path("../../../../data/empty.osm", __FILE__)
+  end
+
+  class Dsl < Osmer::Schema::Base::Dsl
+
+    def updates(interval = nil, &block)
+      require 'osmer/updater'
+
+      schema.updater = Osmer::Updater.new(interval).configure(&block)
+    end
+
+  end
+
+end

data/lib/osmer/target/pg.rb

@@ -0,0 +1,61 @@
+require 'osmer'
+
+require 'pg'
+
+class Osmer::Target::Pg
+
+  attr_accessor :options
+
+  def initialize(options)
+    @options = options
+  end
+
+  def [](key)
+    @options[key]
+  end
+
+  def in_transaction
+    conn = Connection.new connection_options
+
+    begin
+      conn.exec "BEGIN TRANSACTION"
+
+      yield conn
+
+      conn.exec "COMMIT"
+    ensure
+      conn.close
+    end
+  end
+
+  GEOTYPES = { 'point' => 'POINT', 'line' => 'LINESTRING', 'polygon' => 'POLYGON', 'multiline' => 'MULTILINESTRING', 'multipolygon' => 'MULTIPOLYGON' }
+
+  def geometry_type(type)
+    GEOTYPES[type.to_s.gsub(/s\z/,'')] or raise StandardError.new("Unknown geometry type #{type.inspect}")
+  end
+
+  private
+
+  def connection_options
+    { :host => options[:host], :user => options[:username], :password => options[:password], :dbname => options[:database] }
+  end
+
+  class Connection < Struct.new(:options)
+
+    def initialize(*args)
+      super
+      @conn = PG.connect options
+    end
+
+    def exec(q, *args)
+      puts "  #{q}"
+      @conn.exec q, *args
+    end
+
+    def close
+      @conn.close
+    end
+
+  end
+
+end

data/lib/osmer/thor_base.rb

@@ -0,0 +1,30 @@
+require 'osmer'
+require 'thor'
+
+class Osmer::ThorBase < Thor
+
+  class_option :config, :aliases => '-c', :default => 'Osmfile', :desc => 'Config file location'
+
+  class_option :dbhost, :aliases => '-h', :default => 'localhost', :desc => 'Database host'
+  class_option :dbport, :aliases => '-p', :default => '5432', :desc => 'Database port'
+  class_option :dbuser, :aliases => '-U', :desc => 'Database user'
+  class_option :dbpass, :aliases => '-P', :desc => 'Database password'
+  class_option :dbname, :aliases => '-d', :desc => 'Database name'
+
+  private
+
+  def app_options
+    @app_options = parent_options.merge(options)
+  end
+
+  def db
+    require 'osmer/target/pg'
+
+    @db ||= Osmer::Target::Pg.new :username => app_options[:dbuser], :password => app_options[:dbpass], :host => app_options[:dbhost], :port => app_options[:dbport], :database => app_options[:dbname]
+  end
+
+  def osmer
+    @osmer ||= Osmer.new.configure app_options[:config]
+  end
+
+end

data/lib/osmer/updater.rb

@@ -0,0 +1,123 @@
+require 'osmer'
+
+class Osmer::Updater
+  include Osmer::Configurable
+
+  attr_accessor :interval, :dump, :diff
+
+  def initialize(interval = nil)
+    @interval = interval
+  end
+
+  def load_diffs(db, schema)
+    db.in_transaction do |conn|
+      init_meta_table conn, schema
+      cur = get_current_version conn, schema
+
+      puts "Requesting diff versions"
+      versions = get_diff_versions
+
+      while version = versions.detect{|d| d[0] == cur }
+        puts "Downloading diff #{version.join('-')}"
+        file = download_file diff, version
+
+        puts "Applying diff #{file}"
+        yield file
+
+        set_current_version conn, schema, version[1]
+        cur = version[1]
+      end
+    end
+  end
+
+  def load_dump(db, schema)
+    db.in_transaction do |conn|
+      init_meta_table conn, schema
+
+      puts "Requesting last dump version"
+      version = get_dump_version
+
+      puts "Downloading dump #{version.join('-')}"
+      file = download_file dump, version
+
+      puts "Loading dump #{file}"
+      yield file
+
+      set_current_version conn, schema, version[0]
+    end
+  end
+
+  def reset(db, schema)
+    db.in_transaction do |conn|
+      init_meta_table conn, schema
+      reset_current_version conn, schema
+    end
+  end
+
+  private
+
+  def meta_table(schema)
+    "#{schema.ns.prefix}_schema_versions"
+  end
+
+  def init_meta_table(conn, schema)
+    conn.exec "CREATE TABLE IF NOT EXISTS #{meta_table(schema)}(schema VARCHAR(255) NOT NULL PRIMARY KEY, version INT8 NOT NULL)"
+  end
+
+  def get_current_version(conn, schema)
+    conn.exec("SELECT version FROM #{meta_table(schema)} WHERE schema = $1", [schema.name]).values.first.first
+  end
+
+  def reset_current_version(conn, schema)
+    conn.exec "DELETE FROM #{meta_table(schema)} WHERE schema = $1", [schema.name]
+  end
+
+  def set_current_version(conn, schema, version)
+    if conn.exec("UPDATE #{meta_table(schema)} SET version = $2 WHERE schema = $1", [schema.name, version]).cmdtuples == 0
+      conn.exec "INSERT INTO #{meta_table(schema)}(schema, version) VALUES ($1, $2)", [schema.name, version]
+    end
+  end
+
+  def get_diff_versions
+    get_available_versions(diff).uniq
+  end
+
+  def get_dump_version
+    get_available_versions(dump).max
+  end
+
+  def get_available_versions(url)
+    require 'open-uri'
+
+    dir_content = open(url.gsub(/\/[^\/]+\z/, '/')).read
+    file_regexp = Regexp.compile Regexp.quote(url.gsub(/.*\//, '')).gsub(/\\\{\w+\\\}/,'(\d+)')
+
+    dir_content.scan(file_regexp).uniq
+  end
+
+  def download_file(template, subst)
+    require 'fileutils'
+
+    FileUtils.mkdir_p "/tmp/osmer"
+
+    url = template.split(/\{\w+\}/).zip(subst).flatten.compact.join
+    file = "/tmp/osmer/#{url.gsub(/.*\//, '')}"
+
+    unless File.exists? file
+      system "wget -O '#{file}' '#{url}'" or StandardError.new("Error downloading file '#{file}' from '#{url}'")
+    end
+
+    file
+  end
+
+  class Dsl < Struct.new(:updater)
+
+    [:interval, :dump, :diff].each do |method|
+      define_method method do |value|
+        updater.send "#{method}=", value
+      end
+    end
+
+  end
+
+end

data/lib/osmer/version.rb

@@ -0,0 +1,9 @@
+class Osmer
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification 
+name: osmer
+version: !ruby/object:Gem::Version 
+  hash: 31
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 0
+  version: 0.0.0
+platform: ruby
+authors: 
+- Alexey Noskov
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-08-26 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: pg
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 51
+        segments: 
+        - 0
+        - 11
+        - 0
+        version: 0.11.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: thor
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 43
+        segments: 
+        - 0
+        - 14
+        - 6
+        version: 0.14.6
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :development
+  version_requirements: *id003
+description: Gem for managing OpenStreetMap data in PostgreSQL database
+email: 
+- alexey.noskov@gmail.com
+executables: 
+- osmer
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- MIT-LICENSE
+files: 
+- lib/osmer/updater.rb
+- lib/osmer/schema/app.rb
+- lib/osmer/schema/custom.rb
+- lib/osmer/schema/osm2pgsql.rb
+- lib/osmer/schema/base.rb
+- lib/osmer/app.rb
+- lib/osmer/mapper/string.rb
+- lib/osmer/mapper/type.rb
+- lib/osmer/mapper/area.rb
+- lib/osmer/mapper/base.rb
+- lib/osmer/mapper/name.rb
+- lib/osmer/mapper/length.rb
+- lib/osmer/mapper/address.rb
+- lib/osmer/data/app.rb
+- lib/osmer/thor_base.rb
+- lib/osmer/version.rb
+- lib/osmer/target/pg.rb
+- lib/osmer.rb
+- bin/osmer
+- data/empty.osm
+- MIT-LICENSE
+- README.rdoc
+homepage: http://github.com/alno/osmer
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Osmer
+- --main
+- README.rdoc
+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: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Gem for managing OpenStreetMap data in PostgreSQL database
+test_files: []
+