osm2mongo 0.0.1

data/.autotest

@@ -0,0 +1,23 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+# Autotest.add_hook :initialize do |at|
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception 'vendor'
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2012-06-26
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,17 @@
+.autotest
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/osm2mongo
+lib/callbacks.rb
+lib/common.rb
+lib/db/abstract_interface.rb
+lib/db/dbhandler.rb
+lib/db/mongohandler.rb
+lib/osm2mongo.rb
+test/profile.rb
+test/test_callbacks.rb
+test/test_mongo.rb
+test/test_osm2mongo.rb
+test/test_preprocessor.rb

data/README.txt

@@ -0,0 +1,62 @@
+= osm2mongo
+
+* https://github.com/posseidon/osm2mongo
+
+== DESCRIPTION:
+
+Import Openstreetmap .osm(xml) data format into MongoDB written in Ruby.
+
+== FEATURES/PROBLEMS:
+
+* TODO: Missing Shift class and modules under Osm2Mongo main module.
+* TODO: Missing command line App.
+* TODO: Finish making gem installable.
+* TODO: Missing Rake task for installing dependencies and generate documentation.
+
+== SYNOPSIS:
+
+  FIX (code sample of usage)
+
+== REQUIREMENTS:
+
+* mongo: ruby driver (http://rubygems.org/gems/mongo)
+* nokogiri: xml parser (http://rubygems.org/gems/nokogiri)
+* progressbar: just for fun and icandy :-) (http://rubygems.org/gems/progressbar)
+
+== INSTALL:
+
+* FIX (sudo gem install, anything else)
+
+== DEVELOPERS:
+
+After checking out the source, run:
+
+  $ rake newb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the RDoc.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2012 OSM2Mongo
+
+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,32 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require 'rubygems/dependency_installer.rb'
+
+# Hoe.plugin :compiler
+# Hoe.plugin :gem_prelude_sucks
+# Hoe.plugin :inline
+# Hoe.plugin :racc
+# Hoe.plugin :rcov
+# Hoe.plugin :rubyforge
+
+Hoe.spec 'osm2mongo' do
+  # HEY! If you fill these out in ~/.hoe_template/Rakefile.erb then
+  # you'll never have to touch them again!
+  # (delete this comment too, of course)
+
+  developer('Binh Nguyen Thai', 'posseidon@gmail.com')
+
+  # self.rubyforge_name = 'osm2mongo' # if different than 'osm2mongo'
+end
+
+# vim: syntax=ruby
+
+inst = Gem::DependencyInstaller.new
+    begin
+     inst.install "progressbar"
+     inst.install "nokogiri"
+    rescue
+     exit(1)
+    end

data/bin/osm2mongo

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+abort "you need to write me"

data/lib/callbacks.rb

@@ -0,0 +1,119 @@
+require_relative 'db/mongohandler'
+
+module Osm2Mongo
+    # Container: Responsible for inserting data.
+    # 
+    # Purpose:
+    #  Ability to bulk insert data by limit set at intantiation.
+    #
+    # Depends:
+    # - Container: Handler for MongoDB.
+    #
+    class Callbacks
+        NODE = "node"
+        WAY = "way"
+        RELATION = "relation"
+        TAG = "tag"
+        TEXT = "#text"
+        NODEREF = "nd"
+        MEMBER = "member"
+    
+        NDS = "nodes"
+        TGS = "tags"
+        MBS = "members"
+        DONE = "done"
+    
+        KEY = "k"
+        VALUE = "v"
+        ID = "id"
+        MID = "_id"
+        LON = "lon"
+        LAT = "lat"
+        REF = "ref"
+    
+        attr_accessor :parsed
+    
+        def initialize(database, collections, qlimit, parser)
+            @nodes = DB::Mongohandler.new(database, collections[NODE], qlimit)
+            @nodes.connect()
+        
+            @ways = DB::Mongohandler.new(database, collections[WAY], qlimit)
+            @ways.use_connection(@nodes.connection)
+        
+            @relations = DB::Mongohandler.new(database, collections[RELATION], qlimit)
+            @relations.use_connection(@nodes.connection)
+        
+            parser.add_observer(self)
+            @parsed = false
+        end
+    
+        def update(reader)
+            case reader.name
+                when NODE
+                    node(reader)
+                when WAY
+                    way(reader)
+                when RELATION
+                    relation(reader)
+                when DONE
+                    flush_all()
+                else
+                    # Skip
+            end
+        end
+    
+        def flush_all
+            @nodes.flush()
+            @ways.flush()
+            @relations.flush()
+            @parsed = true
+        end
+
+        def node(reader)
+            attributes = {MID => reader.attribute(ID), LON => reader.attribute(LON), LAT => reader.attribute(LAT)}
+            unless reader.empty_element?
+                extract_children(reader, attributes)
+            end
+            @nodes.add(attributes)
+        end
+
+        def way(reader)
+            attributes = {MID => reader.attribute(ID)}
+            unless reader.empty_element?
+                extract_children(reader, attributes)
+            end
+            @ways.add(attributes)
+        end
+
+        def relation(reader)
+            attributes = {MID => reader.attribute(ID)}
+            unless reader.empty_element?
+                extract_children(reader, attributes)
+            end
+            @relations.add(attributes)
+        end
+    
+        private
+        def extract_children(node, attributes)
+            nodes = []
+            members = []
+            tags = Hash.new
+            begin
+                node.read()
+                if (node.name == TAG )
+                    tags[node.attribute(KEY)] = node.attribute(VALUE)
+                elsif (node.name == NODEREF)
+                    nodes.push(node.attribute(REF))
+                elsif (node.name == MEMBER)
+                    members.push(node.attributes)
+                else
+                    # Unknown sequence
+                end            
+            end while(node.name == TAG or node.name == NODEREF or node.name == MEMBER or node.name == TEXT)
+
+            attributes[TGS] = tags unless tags.empty?
+            attributes[NDS] = nodes unless nodes.size < 1
+            attributes[MBS] = members unless members.size < 1
+        end
+    end
+end

data/lib/common.rb

@@ -0,0 +1,130 @@
+require 'uri'
+require 'net/http'
+require 'progressbar'
+require 'nokogiri'
+require 'observer'
+
+
+module Osm2Mongo
+    # Responsible for Http actions.
+    # 
+    # Purpose:
+    #  Preprocessing OSM data format, begins with downloading it, to importing into MongoDB.
+    #
+    # Depends:
+    # - Nokogiri: XML Parser
+    # - Progressbar: http://0xcc.net/ruby-progressbar/index.html.en 
+    #
+    # This module contains:
+    # - Downloader method: file downloader
+    # - Decompressor method: unpack gzip2 osm file.
+    # - 
+    #
+    class Common
+        include Observable
+    
+        UNITS = %W(B KiB MiB GiB TiB).freeze
+        READ = "r"
+        ENDL = "\n"
+        INFO = Struct.new(:name)
+        DONE = "done"
+    
+    
+        #
+        # Download file. On success returns absolute path of downloaded file.
+        # ==== Attributes
+        # * +url+ Url address of file.
+        # * +destination+ Where to download it.
+        # ==== Examples
+        #     result = Common::download("http://someurl.com/somedata.txt","/tmp/")
+        #
+        def download(url, destination)
+            uri = URI.parse(url)
+            http = Net::HTTP.new(uri.host)
+            size = http.request_head(url)['content-length'].to_f
+            counter = 0
+            file = open(destination.concat(uri.path.split("/").last), "wb")
+            begin
+                pbar = ProgressBar.new("Downloading: ", size)
+                http.request_get(uri.path) do |response|
+                    response.read_body do |segment|
+                        file.write(segment)
+                        counter += segment.length 
+                        pbar.set(counter)
+                    end
+                end
+                pbar.finish
+            ensure
+                file.close()
+            end
+            return {'path' => file.path}
+        end
+    
+        #
+        # Decompress a GZIP2 file to its actual path.
+        # ==== Attributes
+        # * +source+ Absolute path of archive file.
+        # ==== Examples
+        #     result = Common::decompress("/tmp/hungary.osm.bz2")
+        #
+        def decompress(source)
+            command = Thread.new do
+              system("bunzip2 #{source}") # long-long programm
+            end
+            command.join
+            return {'path' => source.gsub!(".bz2","")}
+        end
+
+        #
+        #  Push OSM XML content into Database.
+        # ==== Attributes
+        # * +osm+ absolute path to osm file.
+        # * +host+ MongoDB host
+        # * +port+  MongoDB port number
+        # * +db_name+ Name of database
+        # * +collection_name+ Collection name
+        # * +batch_limit+ Limit of Array for batch insert (carefull, it may vary on architecture).
+        # ==== Examples
+        #     result = Common::push2mongo("/tmp/map.osm", "osm",  collections, 1000)
+        #
+        def parse(osm_file)
+            File.open(osm_file, READ) do |osm|
+                reader = Nokogiri::XML::Reader(osm)
+                reader.read()
+                while reader.read()
+                    unless reader.value?
+                        changed()
+                        notify_observers(reader)
+                    end
+                end
+                changed()
+                notify_observers(INFO.new(DONE))
+            end
+        end
+    
+
+        #
+        # Print File size as readable.
+        # ==== Attributes
+        # * +size+ size in bytes
+        # ==== Examples
+        #     result = Common::as_size("53344233")
+        #
+        def as_size number
+          if number.to_i < 1024
+            exponent = 0
+
+          else
+            max_exp  = UNITS.size - 1
+
+            exponent = ( Math.log( number ) / Math.log( 1024 ) ).to_i # convert to base
+            exponent = max_exp if exponent > max_exp # we need this to avoid overflow for the highest unit
+
+            number  /= 1024 ** exponent
+          end
+
+          "#{number} #{UNITS[ exponent ]}"
+        end
+    end
+
+end

data/lib/db/abstract_interface.rb

@@ -0,0 +1,24 @@
+module DB
+    module AbstractInterface
+  
+      class InterfaceNotImplementedError < NoMethodError
+      end
+  
+      def self.included(klass)
+        klass.send(:include, AbstractInterface::Methods)
+        klass.send(:extend, AbstractInterface::Methods)
+      end
+  
+      module Methods    
+
+        def api_not_implemented(klass, method_name = nil)
+          if method_name.nil?
+            caller.first.match(/in \`(.+)\'/)
+            method_name = $1
+          end
+          raise AbstractInterface::InterfaceNotImplementedError.new("#{klass.class.name} needs to implement '#{method_name}' for interface #{self.name}!")
+        end
+      end
+  
+    end
+end

data/lib/db/dbhandler.rb

@@ -0,0 +1,40 @@
+require_relative 'abstract_interface'
+
+module DB
+    class Dbhandler
+        include AbstractInterface
+    
+        #
+        # Abstract method
+        #
+        # Connecting to database with given:
+        # ==== Attributes
+        # * +args+ optional: host, port, database name
+        #
+        def connect(*args)
+            Dbhandler.api_not_implemented(self)
+        end
+    
+        #
+        # Abstract method
+        #
+        # Insert data:
+        # ==== Attributes
+        # * +data+ Hash or Array
+        #    
+        def insert(*args)
+            Dbhandler.api_not_implemented(self)
+        end
+
+        #
+        # Abstract method
+        #
+        # Insert many data at once.
+        # ==== Attributes
+        # * +data+ Array of Hashes
+        #    
+        def bulk_insert(*args)
+            Dbhandler.api_not_implemented(self)
+        end
+    end
+end

data/lib/db/mongohandler.rb

@@ -0,0 +1,104 @@
+require_relative 'dbhandler'
+require 'mongo'
+
+module DB
+    class Mongohandler < DB::Dbhandler
+        attr_accessor :connection, :collection, :host, :port
+        attr_accessor :data_array
+
+        #
+        # Constructor.
+        # ==== Attributes
+        # * +database_name+ database name
+        # * +collection_name+ collection name
+        # * +bulk_limit+ Array limit for bulk insert.
+        # * +host+ host name (default: localhost)
+        # * +port+ port number (default: 27017)    
+        def initialize(database_name, collection_name, bulk_limit, host = "localhost", port = "27017")
+            @host = host
+            @port = port
+            @dbname = database_name
+            @collname = collection_name
+            @bulk_limit = bulk_limit
+            @data_array = Array.new
+        end
+        
+        #
+        # Use Existing Connection
+        # ==== Attributes
+        # * +connection+ Existing connection
+        #
+        def use_connection(connection)
+            @connection = connection
+            @collection = (@connection[@dbname])[@collname]
+        end
+
+        #
+        # Connecting to Mongo database.
+        #
+        def connect
+            @connection = Mongo::Connection.new(@host, @port, :pool_size => 5)
+            @collection = (@connection[@dbname])[@collname]
+        end
+
+        #
+        # Insert data.
+        # ==== Attributes
+        # * +data+ Hash or Array
+        # ==== Examples
+        # insert({"key" => value})
+        #    
+        def insert(data)
+            begin
+               @collection.insert(data) 
+            rescue Exception => e
+                puts e
+            end
+        end
+    
+        #
+        # Insert at once many data.
+        # ==== Attributes
+        # * +data+ Array of Hashes
+        # bulk_insert([{"key" => value},{"another_key" => another_value}])
+        #
+        def bulk_insert(data)
+            begin
+               @collection.insert(data)
+            rescue Exception => e
+                puts e
+            end
+        end
+    
+        #
+        # Insert data into Data Array.
+        # 
+        # Purpose:
+        #  When limit reached DBHandler::bulk_insert will be called on data array.
+        #
+        # ==== Attributes
+        # * +data+ Hash or Array
+        #    
+        def add(data)
+            if (@data_array.size >= @bulk_limit)
+                bulk_insert(@data_array)
+                @data_array.clear
+                @data_array.push(data)
+            else
+                @data_array.push(data)
+            end
+        end
+    
+        #
+        # Insert remaining data in Array and close Database connection.
+        #    
+        def flush
+            # Push remaining data to database
+            bulk_insert(@data_array)
+            # Clear Hash Array
+            @data_array.clear
+            # Close Database connection.
+            @connection.close()
+        end
+    end
+end

data/lib/osm2mongo.rb

@@ -0,0 +1,161 @@
+#!/usr/bin/env ruby 
+
+# == Synopsis 
+#   This is a sample description of the application.
+#   Blah blah blah.
+#
+# == Examples
+#   This command does blah blah blah.
+#     ruby_cl_skeleton foo.txt
+#
+#   Other examples:
+#     ruby_cl_skeleton -q bar.doc
+#     ruby_cl_skeleton --verbose foo.html
+#
+# == Usage 
+#   ruby_cl_skeleton [options] source_file
+#
+#   For help use: ruby_cl_skeleton -h
+#
+# == Options
+#   -h, --help          Displays help message
+#   -v, --version       Display the version, then exit
+#   -q, --quiet         Output as little as possible, overrides verbose
+#   -V, --verbose       Verbose output
+#   TO DO - add additional options
+#
+# == Author
+#   YourName
+#
+# == Copyright
+#   Copyright (c) 2007 YourName. Licensed under the MIT License:
+#   http://www.opensource.org/licenses/mit-license.php
+
+
+# TO DO - replace all ruby_cl_skeleton with your app name
+# TO DO - replace all YourName with your actual name
+# TO DO - update Synopsis, Examples, etc
+# TO DO - change license if necessary
+
+
+require 'optparse' 
+#require 'rdoc/usage'
+require 'ostruct'
+require 'date'
+
+
+class App
+  VERSION = '0.0.1'
+  
+  attr_reader :options
+
+  def initialize(arguments, stdin)
+    @arguments = arguments
+    @stdin = stdin
+    
+    # Set defaults
+    @options = OpenStruct.new
+    @options.verbose = false
+    @options.quiet = false
+    # TO DO - add additional defaults
+  end
+
+  # Parse options, check arguments, then process the command
+  def run
+        
+    if parsed_options? && arguments_valid? 
+      
+      puts "Start at #{DateTime.now}\n\n" if @options.verbose
+      
+      output_options if @options.verbose # [Optional]
+            
+      process_arguments            
+      process_command
+      
+      puts "\nFinished at #{DateTime.now}" if @options.verbose
+      
+    else
+      output_usage
+    end
+      
+  end
+  
+  protected
+  
+    def parsed_options?
+      
+      # Specify options
+      opts = OptionParser.new 
+      opts.on('-v', '--version')    { output_version ; exit 0 }
+      opts.on('-h', '--help')       { output_help }
+      opts.on('-V', '--verbose')    { @options.verbose = true }  
+      opts.on('-q', '--quiet')      { @options.quiet = true }
+      # TO DO - add additional options
+            
+      opts.parse!(@arguments) rescue return false
+      
+      process_options
+      true      
+    end
+
+    # Performs post-parse processing on options
+    def process_options
+      @options.verbose = false if @options.quiet
+    end
+    
+    def output_options
+      puts "Options:\n"
+      
+      @options.marshal_dump.each do |name, val|        
+        puts "  #{name} = #{val}"
+      end
+    end
+
+    # True if required arguments were provided
+    def arguments_valid?
+      # TO DO - implement your real logic here
+      true if @arguments.length == 1 
+    end
+    
+    # Setup the arguments
+    def process_arguments
+      # TO DO - place in local vars, etc
+    end
+    
+    def output_help
+      output_version
+      #RDoc::usage() #exits app
+    end
+    
+    def output_usage
+      #RDoc::usage('usage') # gets usage from comments above
+    end
+    
+    def output_version
+      puts "#{File.basename(__FILE__)} version #{VERSION}"
+    end
+    
+    def process_command
+      # TO DO - do whatever this app does
+      
+      #process_standard_input # [Optional]
+    end
+
+    def process_standard_input
+      input = @stdin.read      
+      # TO DO - process input
+      
+      # [Optional]
+      #@stdin.each do |line| 
+      #  # TO DO - process each line
+      #end
+    end
+end
+
+
+# TO DO - Add your Modules, Classes, etc
+
+
+# Create and run the application
+app = App.new(ARGV, STDIN)
+app.run

data/test/profile.rb

@@ -0,0 +1,14 @@
+require 'ruby-prof'
+$LOAD_PATH << '../lib'
+require 'preprocessor.rb'
+
+# Profile the code
+RubyProf.start
+
+status = Common.parse("/tmp/map.osm")
+
+result = RubyProf.stop
+
+# Print a flat profile to text
+printer = RubyProf::FlatPrinter.new(result)
+printer.print(STDOUT)

data/test/test_callbacks.rb

@@ -0,0 +1,25 @@
+$LOAD_PATH << '../lib'
+require 'callbacks.rb'
+require 'observer'
+
+class TestCallbacks
+    include Observable
+    
+    INFO = Struct.new(:name)
+    
+    def publish
+        changed()
+        notify_observers(INFO.new("done"))
+    end
+end
+
+
+describe Osm2Mongo::Callbacks, "#test Observer" do
+    it "should open and process content of osm file" do
+        test = TestCallbacks.new
+        collections = {"node" => "nodes", "way" => "ways", "relation" => "rels"}
+        callback = Osm2Mongo::Callbacks.new("osm",  collections, 1000, test)
+        test.publish()
+        (callback.parsed).should be(true)
+    end
+end

data/test/test_mongo.rb

@@ -0,0 +1,33 @@
+$LOAD_PATH << '../lib/db'
+require 'mongohandler.rb'
+
+
+describe DB::Mongohandler, "#connect" do
+    it "should returns connection status active" do
+        mongo = DB::Mongohandler.new("local", "test", 100)
+        mongo.connect()
+        (mongo.connection.connected?).should be(true)
+    end
+end
+
+describe DB::Mongohandler do
+    before do
+        @handler = DB::Mongohandler.new("local", "test", 100)
+        @handler.connect()
+    end
+    
+    it "should insert a single document" do
+        @handler.insert({"test" => "data"})
+        (@handler.collection.count).should be(1)
+    end
+
+    it "should insert at least one document" do
+        @handler.bulk_insert([{"test" => "data"}, {"another_test" => "another_data"}])
+        (@handler.collection.count).should be(2)
+    end
+    
+    
+    after do
+        @handler.collection.drop()
+    end
+end

data/test/test_osm2mongo.rb

@@ -0,0 +1,8 @@
+require "test/unit"
+require "osm2mongo"
+
+class TestOsm2mongo < Test::Unit::TestCase
+  def test_sanity
+    flunk "write tests or I will kneecap you"
+  end
+end

data/test/test_preprocessor.rb

@@ -0,0 +1,31 @@
+$LOAD_PATH << '../lib/'
+require 'common'
+require 'callbacks'
+
+
+    describe Osm2Mongo::Common, "#download" do
+        it "should returns downloaded file and location" do
+            #common = Osm2Mongo::Common.new()
+            #report = common.download("http://download.geofabrik.de/osm/europe/hungary.osm.bz2", "/tmp/")
+            #report['path'].should == "/tmp/hungary.osm.bz2"
+        end
+    end
+
+    describe Osm2Mongo::Common, "#decompress" do
+        it "should returns downloaded file and location" do
+            #common = Osm2Mongo::Common.new()
+            #result = common.decompress("/tmp/hungary.osm.bz2")
+            #result.should_not be(nil)
+        end
+    end
+
+    describe Osm2Mongo::Common, "#process map.osm" do
+        it "should open and process content of osm file" do
+            collections = {"node" => "nodes", "way" => "ways", "relation" => "rels"}
+            common = Osm2Mongo::Common.new()
+            callback = Osm2Mongo::Callbacks.new("osm",  collections, 100, common)
+            common.parse("/tmp/map.osm")
+            (callback.parsed).should be(true)
+        end
+    end
+

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: osm2mongo
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Binh Nguyen Thai
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Import Openstreetmap .osm(xml) data format into MongoDB written in Ruby.
+email:
+- posseidon@gmail.com
+executables:
+- osm2mongo
+extensions: []
+extra_rdoc_files:
+- History.txt
+- Manifest.txt
+- README.txt
+files:
+- .autotest
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/osm2mongo
+- lib/callbacks.rb
+- lib/common.rb
+- lib/db/abstract_interface.rb
+- lib/db/dbhandler.rb
+- lib/db/mongohandler.rb
+- lib/osm2mongo.rb
+- test/profile.rb
+- test/test_callbacks.rb
+- test/test_mongo.rb
+- test/test_osm2mongo.rb
+- test/test_preprocessor.rb
+- .gemtest
+homepage: https://github.com/posseidon/osm2mongo
+licenses: []
+post_install_message: 
+rdoc_options:
+- --main
+- README.txt
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: osm2mongo
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Import Openstreetmap .osm(xml) data format into MongoDB written in Ruby.
+test_files:
+- test/test_callbacks.rb
+- test/test_mongo.rb
+- test/test_osm2mongo.rb
+- test/test_preprocessor.rb