geonames_local 2.0.1 → 3.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2e73d4bb7dd75933118a18ad64f13563e47b64e5
+  data.tar.gz: fc75d8a753756a87433b16c9da287cb9bd9bc090
+SHA512:
+  metadata.gz: 82c9f917f022ba89fe63b7cb817e04f4652ba37eaf651760cd5a1c4409a2d090cbf495b23e0117c9f7eedeb860da3f6164aff83f22ebd58be3d72d81ae5a2f2c
+  data.tar.gz: 50d6134373286472f0980f4e68046c355eba088c89311a2b3f0148ff4463284d0c0456d147f19dca033586e4cc1159900cca452e217680a378b12e1eb4e71bc7

data/Gemfile

@@ -2,7 +2,7 @@ source 'http://rubygems.org'
 gemspec # Specify  gem's dependencies in mongoid_geospatial.gemspec
 
 group :development do
-  gem 'mongoid', '~> 3.0'
+  gem 'mongoid'
   gem 'mongoid_geospatial'
   # gem 'pg'
   gem 'rgeo'

data/README.rdoc

@@ -9,8 +9,8 @@ No hit limit, fast as possible.
 
 To use one adapter, install the corresponding gem:
 
+  MongoDB      =>   mongoid, geopolitical (optional: mongo_ext)
   PostgreSQL   =>   pg
-  MongoDB      =>   mongoid (optional: mongo_ext)
   Tokyo        =>   tokyocabinet
 
 You will also need in your system:

data/geonames.yml

@@ -1,16 +1,17 @@
 #
 # Geonames Local Config Example
 #
-:store: mongodb # postgis / tokyo
-:codes: [br] # to store all countries informations in the countries table, just write [country]
+:store: mongodb
 :level: city
+:nations: [br]
+:locales: [pt, en]
 :min_pop: 100000
 :mapping:
   :name: name
   :geom: true
 :db:
   :host: localhost
-  :name: geonames_test
+  :name: baccafe_development
   :user:
   :pass:
   :purge: false

data/geonames_local.gemspec

@@ -8,23 +8,22 @@ Gem::Specification.new do |gem|
 
   gem.authors = ["Marcos Piccinini"]
   gem.default_executable = %q{geonames}
-  gem.description = %q{Dump and feed a tokyo cabinet for local geonames search}
+  gem.description = %q{Dumps geonames data to feed a local db}
   gem.email = %q{x@nofxx.com}
+  gem.license = "MIT"
 
   gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   gem.files         = `git ls-files`.split("\n")
   gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   gem.name          = "geonames_local"
   gem.require_paths = ["lib"]
-  gem.summary = %q{Dump and feed a tokyo local geonames db}
-
+  gem.summary = %q{Dumps geonames data for local usage}
 
   gem.extra_rdoc_files = [
-    "LICENSE",
+    "MIT-LICENSE",
     "README.rdoc"
   ]
 
-
   gem.post_install_message = %q{
 Geonames Local
 --------------

data/lib/geonames_local/cli.rb

@@ -16,13 +16,9 @@ module Geonames
       options = {}
 
       argv.options do |opts|
-        opts.banner = <<BANNER
-Geonames Command Line Usage:
+        opts.banner = "Geonames Command Line Usage\n\n    geonames <nation code(s)> <opts>\n\n\n"
 
-geonames <country code(s)> <opts>
 
-geonames
-BANNER
         opts.on("-l", "--level LEVEL", String, "The level of logging to report" ) { |level| options[:level] = level }
         opts.on("-d", "--dump", "Dump DB before all" ) { options[:dump] = true }
         opts.separator ""
@@ -34,7 +30,7 @@ BANNER
         opts.on("--map TYPE", Array, "Use zone/road to import" ) { |s| options[:map] = s.map(&:to_sym) }
         opts.on("--type TYPE", String, "Use zone/road to import" ) { |s| options[:type] = s }
         opts.on("--city CITY", String, "Use city gid to import" ) { |s| options[:city] = s }
-        opts.on("--country COUNTRY", String, "Use country gid to import" ) { |s| options[:country] = s }
+        opts.on("--nation NATION", String, "Use nation gid to import" ) { |s| options[:nation] = s }
         opts.separator ""
         opts.separator "Common Options:"
         opts.on("-h", "--help", "Show this message" ) { puts opts; exit }
@@ -54,24 +50,37 @@ BANNER
       end
       options
     end
+
     private_class_method :parse_options
 
     class << self
 
+      def load_config
+        if Opt[:config]
+          Opt.merge! YAML.load(File.read(Opt[:config]))
+        else
+          # Load config/geonames.yml if there's one
+          if File.exists?(cfg = File.join("config", "geonames.yml"))
+            Opt.merge! YAML.load(File.read(cfg))
+          else
+            raise
+          end
+        end
+      rescue
+        info "Cant't find config file"
+        exit
+      end
+
     # Ugly but works?
     def work(argv)
       trap(:INT) { stop! }
       trap(:TERM) { stop! }
       Opt.merge! parse_options(argv)
-
-      if Opt[:config]
-        Opt.merge! YAML.load(File.read(Opt[:config]))
+      if Opt[:locales].nil? || Opt[:locales].empty?
+        Opt[:locales] = ['en']
       end
 
-      # Load config/geonames.yml if there's one
-      if File.exists?(cfg = File.join("config", "geonames.yml"))
-        Opt.merge! YAML.load(File.read(cfg))
-      end
+      load_config
 
       if shp = Opt[:shp]
         SHP.import(shp)
@@ -115,7 +124,7 @@ BANNER
       # Export Data as CSV or JSON
       #
       if argv[0] =~ /csv|json/
-        Geonames::Export.new(Country.all).to_csv
+        Geonames::Export.new(Nation.all).to_csv
 
       #
       # Do the magic! Import Geonames Data
@@ -124,24 +133,28 @@ BANNER
         load_adapter(Opt[:store])
         info "Using adapter #{Opt[:store]}.."
 
-        if argv[0] =~ /coun|nati/
-          dump = Geonames::Dump.new(:country, :dump)
+        # Nations
+        if Opt[:nations].empty? || argv[0] =~ /coun|nati/
+          info "\nPopulating 'nations' database..."
+          dump = Geonames::Dump.new(:all, :dump)
           info "\n---\nTotal #{dump.data.length} parsed."
 
-          info "Writing to DB"
-          Geonames::Models::Country.from_batch(dump.data)
+          info "Writing to nations DB"
+          Geonames::Models::MongoWrapper.nations dump.data, Opt[:clean]
+
+        # Regions, Cities....
         else
-          zip = Geonames::Dump.new(Opt[:codes], :zip).data
-          dump = Geonames::Dump.new(Opt[:codes], :dump).data
+          zip = Geonames::Dump.new(Opt[:nations], :zip).data
+          dump = Geonames::Dump.new(Opt[:nations], :dump).data
           info "\n---\nTotal #{dump.size} parsed. #{zip.size} zips."
 
           info "Join dump << zip"
           dump = unify!(dump, zip).group_by(&:kind)
 
-          info "Writing provinces..."
-          Geonames::Models::Province.from_batch dump[:province]
-          info "Writing cities..."
-          Geonames::Models::City.from_batch dump[:city]
+          info "Writing to DB..."
+          Geonames::Models::MongoWrapper.batch dump, Opt[:clean]
+          # info "Writing cities..."
+          # Geonames::Models::City.from_batch dump[:city]
         end
       end
     end
@@ -149,9 +162,9 @@ BANNER
     def load_adapter(name)
       begin
         require "geonames_local/models/#{name}"
-      rescue LoadError
-        puts "Can't find adapter for #{name}"
-        stop!
+    #  rescue LoadError
+     #   puts "Can't find adapter for #{name}"
+      #  stop!
       end
     end
 

data/lib/geonames_local/config/geonames.sql

@@ -20,13 +20,13 @@ SET default_with_oids = false;
 --
 -- TOC entry 2245 (class 1259 OID 21665)
 -- Dependencies: 2544 2545 2546 3 992
--- Name: cities; Type: TABLE; Schema: public; Owner: -; Tablespace: 
+-- Name: cities; Type: TABLE; Schema: public; Owner: -; Tablespace:
 --
 
 CREATE TABLE cities (
     id integer NOT NULL,
-    country_id integer NOT NULL,
-    province_id integer,
+    nation_id integer NOT NULL,
+    region_id integer,
     name character varying(255) NOT NULL,
     gid integer,
     zip integer,
@@ -72,7 +72,7 @@ ALTER TABLE cities ALTER COLUMN id SET DEFAULT nextval('cities_id_seq'::regclass
 --
 -- TOC entry 2548 (class 2606 OID 21670)
 -- Dependencies: 2245 2245
--- Name: cities_pkey; Type: CONSTRAINT; Schema: public; Owner: -; Tablespace: 
+-- Name: cities_pkey; Type: CONSTRAINT; Schema: public; Owner: -; Tablespace:
 --
 
 ALTER TABLE ONLY cities
@@ -82,16 +82,16 @@ ALTER TABLE ONLY cities
 --
 -- TOC entry 2549 (class 1259 OID 21697)
 -- Dependencies: 2245
--- Name: index_cities_on_country_id; Type: INDEX; Schema: public; Owner: -; Tablespace: 
+-- Name: index_cities_on_nation_id; Type: INDEX; Schema: public; Owner: -; Tablespace:
 --
 
-CREATE INDEX index_cities_on_country_id ON cities USING btree (country_id);
+CREATE INDEX index_cities_on_nation_id ON cities USING btree (nation_id);
 
 
 --
 -- TOC entry 2550 (class 1259 OID 21699)
 -- Dependencies: 2245 1869
--- Name: index_cities_on_geom; Type: INDEX; Schema: public; Owner: -; Tablespace: 
+-- Name: index_cities_on_geom; Type: INDEX; Schema: public; Owner: -; Tablespace:
 --
 
 CREATE INDEX index_cities_on_geom ON cities USING gist (geom);
@@ -100,7 +100,7 @@ CREATE INDEX index_cities_on_geom ON cities USING gist (geom);
 --
 -- TOC entry 2551 (class 1259 OID 21695)
 -- Dependencies: 2245
--- Name: index_cities_on_gid; Type: INDEX; Schema: public; Owner: -; Tablespace: 
+-- Name: index_cities_on_gid; Type: INDEX; Schema: public; Owner: -; Tablespace:
 --
 
 CREATE INDEX index_cities_on_gid ON cities USING btree (gid);
@@ -109,7 +109,7 @@ CREATE INDEX index_cities_on_gid ON cities USING btree (gid);
 --
 -- TOC entry 2552 (class 1259 OID 21694)
 -- Dependencies: 2245
--- Name: index_cities_on_name; Type: INDEX; Schema: public; Owner: -; Tablespace: 
+-- Name: index_cities_on_name; Type: INDEX; Schema: public; Owner: -; Tablespace:
 --
 
 CREATE INDEX index_cities_on_name ON cities USING btree (name);
@@ -118,16 +118,16 @@ CREATE INDEX index_cities_on_name ON cities USING btree (name);
 --
 -- TOC entry 2553 (class 1259 OID 21698)
 -- Dependencies: 2245
--- Name: index_cities_on_province_id; Type: INDEX; Schema: public; Owner: -; Tablespace: 
+-- Name: index_cities_on_region_id; Type: INDEX; Schema: public; Owner: -; Tablespace:
 --
 
-CREATE INDEX index_cities_on_province_id ON cities USING btree (province_id);
+CREATE INDEX index_cities_on_region_id ON cities USING btree (region_id);
 
 
 --
 -- TOC entry 2554 (class 1259 OID 21696)
 -- Dependencies: 2245
--- Name: index_cities_on_zip; Type: INDEX; Schema: public; Owner: -; Tablespace: 
+-- Name: index_cities_on_zip; Type: INDEX; Schema: public; Owner: -; Tablespace:
 --
 
 CREATE INDEX index_cities_on_zip ON cities USING btree (zip);
@@ -155,10 +155,10 @@ SET default_with_oids = false;
 --
 -- TOC entry 2249 (class 1259 OID 21688)
 -- Dependencies: 3
--- Name: countries; Type: TABLE; Schema: public; Owner: -; Tablespace: 
+-- Name: nations; Type: TABLE; Schema: public; Owner: -; Tablespace:
 --
 
-CREATE TABLE countries (
+CREATE TABLE nations (
     id integer NOT NULL,
     name character varying(30) NOT NULL,
     abbr character varying(2) NOT NULL
@@ -168,10 +168,10 @@ CREATE TABLE countries (
 --
 -- TOC entry 2248 (class 1259 OID 21686)
 -- Dependencies: 3 2249
--- Name: countries_id_seq; Type: SEQUENCE; Schema: public; Owner: -
+-- Name: nations_id_seq; Type: SEQUENCE; Schema: public; Owner: -
 --
 
-CREATE SEQUENCE countries_id_seq
+CREATE SEQUENCE nations_id_seq
     START WITH 1
     INCREMENT BY 1
     NO MAXVALUE
@@ -182,10 +182,10 @@ CREATE SEQUENCE countries_id_seq
 --
 -- TOC entry 2548 (class 0 OID 0)
 -- Dependencies: 2248
--- Name: countries_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: -
+-- Name: nations_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: -
 --
 
-ALTER SEQUENCE countries_id_seq OWNED BY countries.id;
+ALTER SEQUENCE nations_id_seq OWNED BY nations.id;
 
 
 --
@@ -194,17 +194,17 @@ ALTER SEQUENCE countries_id_seq OWNED BY countries.id;
 -- Name: id; Type: DEFAULT; Schema: public; Owner: -
 --
 
-ALTER TABLE countries ALTER COLUMN id SET DEFAULT nextval('countries_id_seq'::regclass);
+ALTER TABLE nations ALTER COLUMN id SET DEFAULT nextval('nations_id_seq'::regclass);
 
 
 --
 -- TOC entry 2545 (class 2606 OID 21693)
 -- Dependencies: 2249 2249
--- Name: countries_pkey; Type: CONSTRAINT; Schema: public; Owner: -; Tablespace: 
+-- Name: nations_pkey; Type: CONSTRAINT; Schema: public; Owner: -; Tablespace:
 --
 
-ALTER TABLE ONLY countries
-    ADD CONSTRAINT countries_pkey PRIMARY KEY (id);
+ALTER TABLE ONLY nations
+    ADD CONSTRAINT nations_pkey PRIMARY KEY (id);
 
 
 --
@@ -229,12 +229,12 @@ SET default_with_oids = false;
 --
 -- TOC entry 2247 (class 1259 OID 21680)
 -- Dependencies: 3
--- Name: provinces; Type: TABLE; Schema: public; Owner: -; Tablespace: 
+-- Name: regions; Type: TABLE; Schema: public; Owner: -; Tablespace:
 --
 
-CREATE TABLE provinces (
+CREATE TABLE regions (
     id integer NOT NULL,
-    country_id integer NOT NULL,
+    nation_id integer NOT NULL,
     name character varying(255) NOT NULL,
     abbr character varying(2) NOT NULL,
     gid integer
@@ -244,10 +244,10 @@ CREATE TABLE provinces (
 --
 -- TOC entry 2246 (class 1259 OID 21678)
 -- Dependencies: 3 2247
--- Name: provinces_id_seq; Type: SEQUENCE; Schema: public; Owner: -
+-- Name: regions_id_seq; Type: SEQUENCE; Schema: public; Owner: -
 --
 
-CREATE SEQUENCE provinces_id_seq
+CREATE SEQUENCE regions_id_seq
     START WITH 1
     INCREMENT BY 1
     NO MAXVALUE
@@ -258,10 +258,10 @@ CREATE SEQUENCE provinces_id_seq
 --
 -- TOC entry 2552 (class 0 OID 0)
 -- Dependencies: 2246
--- Name: provinces_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: -
+-- Name: regions_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: -
 --
 
-ALTER SEQUENCE provinces_id_seq OWNED BY provinces.id;
+ALTER SEQUENCE regions_id_seq OWNED BY regions.id;
 
 
 --
@@ -270,53 +270,53 @@ ALTER SEQUENCE provinces_id_seq OWNED BY provinces.id;
 -- Name: id; Type: DEFAULT; Schema: public; Owner: -
 --
 
-ALTER TABLE provinces ALTER COLUMN id SET DEFAULT nextval('provinces_id_seq'::regclass);
+ALTER TABLE regions ALTER COLUMN id SET DEFAULT nextval('regions_id_seq'::regclass);
 
 
 --
 -- TOC entry 2549 (class 2606 OID 21685)
 -- Dependencies: 2247 2247
--- Name: provinces_pkey; Type: CONSTRAINT; Schema: public; Owner: -; Tablespace: 
+-- Name: regions_pkey; Type: CONSTRAINT; Schema: public; Owner: -; Tablespace:
 --
 
-ALTER TABLE ONLY provinces
-    ADD CONSTRAINT provinces_pkey PRIMARY KEY (id);
+ALTER TABLE ONLY regions
+    ADD CONSTRAINT regions_pkey PRIMARY KEY (id);
 
 
 --
 -- TOC entry 2544 (class 1259 OID 21701)
 -- Dependencies: 2247
--- Name: index_provinces_on_abbr; Type: INDEX; Schema: public; Owner: -; Tablespace: 
+-- Name: index_regions_on_abbr; Type: INDEX; Schema: public; Owner: -; Tablespace:
 --
 
-CREATE INDEX index_provinces_on_abbr ON provinces USING btree (abbr);
+CREATE INDEX index_regions_on_abbr ON regions USING btree (abbr);
 
 
 --
 -- TOC entry 2545 (class 1259 OID 21703)
 -- Dependencies: 2247
--- Name: index_provinces_on_country_id; Type: INDEX; Schema: public; Owner: -; Tablespace: 
+-- Name: index_regions_on_nation_id; Type: INDEX; Schema: public; Owner: -; Tablespace:
 --
 
-CREATE INDEX index_provinces_on_country_id ON provinces USING btree (country_id);
+CREATE INDEX index_regions_on_nation_id ON regions USING btree (nation_id);
 
 
 --
 -- TOC entry 2546 (class 1259 OID 21702)
 -- Dependencies: 2247
--- Name: index_provinces_on_gid; Type: INDEX; Schema: public; Owner: -; Tablespace: 
+-- Name: index_regions_on_gid; Type: INDEX; Schema: public; Owner: -; Tablespace:
 --
 
-CREATE INDEX index_provinces_on_gid ON provinces USING btree (gid);
+CREATE INDEX index_regions_on_gid ON regions USING btree (gid);
 
 
 --
 -- TOC entry 2547 (class 1259 OID 21700)
 -- Dependencies: 2247
--- Name: index_provinces_on_name; Type: INDEX; Schema: public; Owner: -; Tablespace: 
+-- Name: index_regions_on_name; Type: INDEX; Schema: public; Owner: -; Tablespace:
 --
 
-CREATE INDEX index_provinces_on_name ON provinces USING btree (name);
+CREATE INDEX index_regions_on_name ON regions USING btree (name);
 
 
 -- Completed on 2010-03-19 05:45:19 BRT
@@ -324,8 +324,3 @@ CREATE INDEX index_provinces_on_name ON provinces USING btree (name);
 --
 -- PostgreSQL database dump complete
 --
-
-
-
-
-

data/lib/geonames_local/config/geonames.yml

@@ -2,14 +2,15 @@
 # Geonames Local Config Example
 #
 :store: mongodb
-:codes: [br] # to store all countries informations in the countries table, just write [country]
 :level: city
+:nations: [br, us] # [] to populate nations database
+:locales: [pt, en]
 :mapping:
   :name: name
   :geom: true
 :db:
   :host: localhost
-  :dbname: rtrac_development
-  :user: postgres
-  :password:
-  :purge: false
+  :dbname: geonames_local
+  # :user:
+  # :password:
+  # :purge: false

data/lib/geonames_local/data/dump.rb

@@ -1,31 +1,30 @@
 module Geonames
   class Dump
+    # Geonames base URL
     URL = "http://download.geonames.org/export/"
+    # Work temporary files
     TMP = "/tmp/geonames/"
 
-    def initialize(codes, kind)
-      @codes = codes
+    def initialize(target, kind)
       @kind = kind
       @data = []
-      if codes.respond_to? :each
-        for code in codes
-          work code
-        end
-      elsif codes == :country
-        countries
+      if target.respond_to? :each
+        target.each { |n| work(n) }
+      elsif target == :all
+        nations
       end
     end
 
-    def countries
-      info "\nDumping country database"
-      file = get_file('country')
+    def nations
+      info "\nDumping nation database"
+      file = get_file('nation')
       download file
       parse file
     end
 
-    def work code
-      info "\nWorking on #{@kind} for #{code}"
-      file = get_file(code)
+    def work nation
+      info "\nWorking on #{@kind} for #{nation}"
+      file = get_file(nation)
       download file
       uncompress file
       parse file
@@ -35,8 +34,8 @@ module Geonames
       @data
     end
 
-    def get_file(code)
-      code == "country" ? "countryInfo.txt" : "#{code.upcase}.zip"
+    def get_file(nation)
+      nation == "nation" ? "countryInfo.txt" : "#{nation.upcase}.zip"
     end
 
     def download(file)

data/lib/geonames_local/data/shp.rb

@@ -28,7 +28,7 @@ module Geonames
         info "Free sample\n" + utf.inspect
         @sample = true
       end
-      @type.new(Opt[:map], utf, Opt[:country].upcase, Opt[:city])
+      @type.new(Opt[:map], utf, Opt[:nation].upcase, Opt[:city])
     end
 
     def parse

data/lib/geonames_local/features/road.rb

@@ -2,9 +2,9 @@ require "rubygems"
 require "geo_ruby"
 
 class Road
-  attr_reader :city, :province, :country, :zone, :name, :geom, :kind, :table
+  attr_reader :city, :region, :nation, :zone, :name, :geom, :kind, :table
 
-  def initialize(keys, vals, country=nil, city=nil)
+  def initialize(keys, vals, nation=nil, city=nil)
     s = vals.split("\t")
     r = {}
     keys.each_with_index do |k, i|
@@ -16,7 +16,7 @@ class Road
     @geom = parse_geom(r[:geom])
     @kind = parse_kind(kind)
     @city = city
-    @country = country
+    @nation = nation
     @table = :roads
   end
 

data/lib/geonames_local/features/spot.rb

@@ -1,7 +1,7 @@
 module Geonames
   class Spot
-    attr_accessor :gid, :name, :ascii, :lat, :lon, :country, :kind,
-                  :code,  :pop, :tz, :geom, :province, :zip, :abbr, :id
+    attr_accessor :gid, :name, :ascii, :lat, :lon, :nation, :kind,
+                  :code,  :pop, :tz, :geom, :region, :zip, :abbr, :id
     alias :x :lon
     alias :y :lat
     alias :geoname_id :gid
@@ -11,17 +11,20 @@ module Geonames
     # = Geonames Spot
     #
     # Every geoname type will be parsed as a spot
+    #
     def initialize(params = nil, kind = nil)
       return unless params.instance_of? String
       kind == :zip ? parse_zip(params) : parse(params)
-      if @kind == :province
+      if @kind == :region
         @name.gsub!(/Estado d\w\s/, "")
         @abbr = get_abbr
       end
     end
 
-    # Geonames does not have province/state abbr..#fail!
+    #
+    # Geonames does not have region/state abbr..#fail!
     # This works 75% of the time in brazil heh
+    #
     def get_abbr
       s = @name.split(" ")
       if s.length > 1
@@ -33,32 +36,34 @@ module Geonames
 
     #
     # Parse Geonames Dump Export
-    def parse(row)
+    #
+    def parse row
       gid, @name, @ascii, @alternates, lat, lon, feat, kind,
-        @country, cc2, adm1, adm2, adm3, adm4, @pop, @ele,
-        @gtop, @tz, @up = row.split(/\t/)
-      parse_geom(lat, lon)
+      @nation, cc2, @region, @code, adm3, adm4, @pop, @ele,
+      @gtop, @tz, @up = row.split(/\t/)
+
       @gid = @geoname_id = gid.to_i
       @kind = human_code(kind)
-      @province = adm1
-      @code = adm2
 
-    # puts "#{@kind} - #{@code} - #{@province}"
+      parse_geom(lat, lon)
+      # puts "#{@kind} - #{@code} - #{@region}"
     end
 
     #
     # Parse Geonames Zip Export
+    #
     def parse_zip(row)
-      # country, zip, @name, state, state_code, procince, province_code, community, community_code, lat, lon, acc  = row.split(/\t/)
-      country, zip, @name, a1, @code, a2, a2c, a3, a3c, lat, lon, acc = row.split(/\t/)
-      parse_geom(lat, lon)
-      # @code = adm1
+      nation, @zip, @name, a1, a1c, a2, @code, a3, a3c,
+      lat, lon, acc = row.split(/\t/)
+
       @kind = :city
-      @zip = zip.split("-")[0]
+      parse_geom(lat, lon)
+      # puts "#{row}\n---\n#{@kind} - #{@code} - #{@zip} #{lat}x#{lon}"
     end
 
     #
     # Parse Geom to float or GeoRuby Point
+    #
     def parse_geom(lat, lon)
       @lat, @lon = lat.to_f, lon.to_f
 
@@ -82,32 +87,32 @@ module Geonames
     # Translate geonames ADMx to models
     def human_code(code)
       case code
-        when 'ADM1' then :province
+        when 'ADM1' then :region
         when 'ADM2', 'ADM3', 'ADM4' then :city
-        else :other
+      else :other
       end
     end
 
     class << self
 
-    def nearest(x,y)
-      from_hash(Adapter.find_near(@coll, x, y, 1)[0])
-    end
+      def nearest(x,y)
+        from_hash(Adapter.find_near(@coll, x, y, 1)[0])
+      end
 
-    def from_hash(hsh)
-      spot = self.new
-      hsh.each { |key, val| spot.instance_variable_set("@"+key, val) }
-      spot.geom = GeoRuby::SimpleFeatures::Point.from_x_y(*spot.geom)
-      spot
-    end
+      def from_hash(hsh)
+        spot = self.new
+        hsh.each { |key, val| spot.instance_variable_set("@"+key, val) }
+        spot.geom = GeoRuby::SimpleFeatures::Point.from_x_y(*spot.geom)
+        spot
+      end
 
-    def set_coll(name)
-      @coll = name
-    end
+      def set_coll(name)
+        @coll = name
+      end
 
-    def collection
-      @coll
-    end
+      def collection
+        @coll
+      end
     end
   end
 end

data/lib/geonames_local/models/mongodb.rb

@@ -1,5 +1,6 @@
 require 'mongoid'
 require 'mongoid_geospatial'
+require 'geopolitical/helpers'
 
 Mongoid.configure do |config|
   #config.master = Mongo::Connection.new.db("symbolize_test")
@@ -8,173 +9,121 @@ end
 
 module Geonames
   module Models
-
-
-    class City < Geonames::Spot
-      include Mongoid::Document
-      include Mongoid::Geospatial
-      store_in :collection => "cities"
-
-      field :ascii, type: String
-      field :slug,  type: String
-      field :name,  type: String
-      field :abbr,  type: String
-      field :area
-      field :gid,   type: Integer
-      field :zip,   type: Integer
-      field :geom,  type: Point, spatial: true
-
-      belongs_to :province
-      belongs_to :country, index: true
-      # has_many :hoods
-
-      before_validation :set_defaults
-
-      validates :name, :country, presence: true
-      validates :name, :uniqueness => { :scope => :province_id }
-
-      index name: 1
-      index slug: 1
-      index geom: '2d'
-
-      #spatial_index :geom
-
-      scope :ordered, order_by(name: 1)
-
-      def set_defaults
-        self.country ||= province.try(:country)
-        self.slug    ||= name.try(:downcase) # don't use slugize
-      end
-
-      def self.search(search, page)
-        cities = search ? where(:field => /#{search}/i) : all
-        cities.page(page)
-      end
-
-      def <=> other
-        self.name <=> other.name
-      end
-
-      def to_s
-        "#{name}/#{abbr}"
-      end
-
-      def self.from_batch data
-        data.each do |city|
-          info "Writing city #{city.name}"
-          next unless city.country
-          city = new.parse(city)
-          city.country = city.province.country
-          city.save
+    require 'geopolitical/../../app/models/hood'
+    require 'geopolitical/../../app/models/city'
+    require 'geopolitical/../../app/models/region'
+    require 'geopolitical/../../app/models/nation'
+    module MongoWrapper
+
+      class << self
+
+        def nations data, clean
+          Nation.delete_all # if clean
+          data.each do |row|
+            create Nation, parse_nation(row) rescue nil
+          end
         end
-      end
 
-      def parse(spot)
-        self.name, self.ascii = spot.name, spot.ascii
-        self.code, self.gid = spot.code, spot.gid
-        self.province = Province.find_by(code: spot.province)
-        self.geom = [spot.lon, spot.lat]
-        self.abbr = province.abbr
-        self
-      end
 
-    end
+        def batch data, clean = false
+          [Region, City].each(&:delete_all) #if clean
 
+          @regions, @cities = data[:region], data[:city]
+          @regions.each { |r| create Region, parse_region(r) }
+          @cities.each  { |c| create City, parse_city(c) }
+        end
 
-    class Province < Geonames::Spot
-      include Mongoid::Document
-      store_in :collection => "provinces"
+        def create klass, data
+          klass.create! data
+        rescue => e
+          info "Prob com spot #{klass}, #{data} #{e}"
+        end
 
-      field :gid,    type: Integer  # geonames id
-      field :code,   type: String
-      field :name,   type: String
-      field :abbr,   type: String
-      field :codes,  type: Array # phone code
+        def translate txt
+          name_i18n = Opt[:locales].reduce({}) do |h, l|
+            h.merge({ l => txt })
+          end
+        end
 
-      belongs_to :country
-      has_many :cities
 
-      validates :name, presence: true
-      validates :country, presence: true
+        def parse_nation row
+          abbr, iso3, ison, fips, name, capital, area, pop, continent,
+          tld, cur_code, cur_name, phone, pos_code, pos_regex,
+          langs, gid, neighbours = row.split(/\t/)
+          info "Nation: #{name}/#{abbr}"
+          # info "#{row}"
+          # info "------------------------"
+          {
+            name_translations: translate(name),
+            zip: pos_code, cash: cur_code, gid: gid,
+            abbr: abbr, slug: name.downcase, code: iso3, lang: langs
+          }
+        end
 
-      index name: 1
-      index codes: 1
 
-      scope :ordered, order_by(name: 1)
+        def parse_region s
+          nation = Nation.find_by(abbr: /#{s.nation}/i)
+          info "Region: #{s.name} / #{s.abbr}"
+          {
+            name_translations: translate(s.name),
+            gid: s.gid, abbr: s.abbr,
+            nation: nation, code: s.region
+          }
+        end
 
-      def self.from_batch data
-        data.each do |province|
-          info "Writing province #{province.name}"
-          next unless province.country
-          province = new.parse(province)
-          province.country = Country.find_by(abbr: /#{province.country}/i)
-          province.save!
+        def parse_city s
+          region = Region.find_by(code: s.region)
+          slug = City.new(slug: s.ascii).slug
+          attempt = slug.dup
+          try = 1
+          until City.where(slug: attempt.downcase).first.nil?
+            attempt = "#{slug}-#{region.abbr}-#{try}"
+            try += 1
+            break if try > 7
+          end
+
+          info s.inspect
+          info "City: #{s.zip} | #{slug} - #{s.name} / #{region.try(:abbr)}"
+          {
+            name_translations: translate(s.name),
+            slug: attempt, gid: s.gid, code: s.code,
+            souls: s.pop, geom: [s.lon, s.lat],
+            region: region, abbr: region.abbr, zip: s.zip # tz
+          }
         end
-      end
 
-      def parse(spot)
-        self.code, self.name = spot.province, spot.name
-        self.gid = spot.gid
-        self
       end
-
     end
 
 
-    class Country < Geonames::Spot
-      include Mongoid::Document
-      store_in :collection => "countries"
+    # class Nation < Geonames::Spot
 
-      field :gid,    type: Integer  # geonames id
-      field :name,   type: String
-      field :abbr,   type: String
-      field :code    # optional phone/whatever code
 
-      has_many :cities
-      has_many :provinces
+    #   def parse row
+    #   end
 
-      validates :abbr, :name, presence: true, uniqueness: true
+    #   def to_hash
+    #     { "gid" => @gid.to_s, "name" => @name, "kind" => "nation", "code" => @code}
+    #   end
 
-      index name: 1
-      index code: 1
+    #   def export
+    #     [@gid, @code, @name]
+    #   end
 
-      scope :ordered, order_by(name: 1)
+    #   def export_header
+    #     ["gid", "code", "name"]
+    #   end
+    # end
 
 
-      def parse row
-        self.abbr, @iso3, @ison, @fips, self.name, @capital, @area, @pop, continent, tld,
-        currency, phone, postal, langs, gid, neighbours = row.split(/\t/)
-        self
-      end
 
-      def self.from_batch data
-        data.each do |spot|
-          new.parse(spot).save
-        end
-      end
+    # class Zip
+    #   include Mongoid::Document
 
-      def to_hash
-        { "gid" => @gid.to_s, "name" => @name, "kind" => "country", "code" => @code}
-      end
+    #   field :code
+    #   belongs_to :city
 
-      def export
-        [@gid, @code, @name]
-      end
-
-      def export_header
-        ["gid", "code", "name"]
-      end
-    end
-
-
-
-    class Zip
-      include Mongoid::Document
-
-      field :code
-      belongs_to :city
-
-    end
+    # end
 
   end
 end

data/lib/geonames_local/models/postgis.rb

@@ -1,19 +1,19 @@
 module Geonames
   module Models
-    module AR
+    #module Postgis
 
       class City < ActiveRecord::Base
         attr_accessor :x, :y, :z
 
-        belongs_to :province
-        belongs_to :country
+        belongs_to :region
+        belongs_to :nation
 
-        validates_presence_of :country
+        validates_presence_of :nation
         validates_presence_of :name
-        # validates_uniqueness_of :name, :scope => :province_id
+        # validates_uniqueness_of :name, :scope => :region_id
 
         def abbr
-          province.try(:abbr) || country.abbr
+          region.try(:abbr) || nation.abbr
         end
 
         def geom=(val)
@@ -25,22 +25,22 @@ module Geonames
 
         # Instantiate self.geom as a Point
         def validation
-          self.country ||= province.country
+          self.nation ||= region.nation
           unless !@x || !@y || @x == "" || @y == ""
             self.geom = Point.from_x_y(@x.to_f, @y.to_f)
           end
         end
       end
 
-      class Province < ActiveRecord::Base
+      class Region < ActiveRecord::Base
         has_many :cities
-        belongs_to :country
+        belongs_to :nation
 
-        validates_uniqueness_of :name, :abbr,  :scope => :country_id
+        validates_uniqueness_of :name, :abbr,  :scope => :nation_id
       end
 
-      class Country < ActiveRecord::Base
-        has_many :provinces
+      class Nation < ActiveRecord::Base
+        has_many :regions
         has_many :cities
         validates_presence_of :name, :abbr
         validates_uniqueness_of :name, :abbr
@@ -51,8 +51,6 @@ module Geonames
       end
 
 
-    end
+    #end
   end
 end
-
-

data/lib/geonames_local/models/tokyo.rb

@@ -2,11 +2,11 @@ module Geonames
   module Models
     module Tokyo
 
-  class Country
+  class Nation
     attr_accessor :code, :name, :gid, :iso, :capital, :pop, :currency
 
     def self.all
-      Tokyo.new.all({ :kind => "country" }).map do |c|
+      Tokyo.new.all({ :kind => "nation" }).map do |c|
         new(c)
       end
     end
@@ -46,11 +46,11 @@ module Geonames
     end
 
     def cities
-      # qry.addcond("country", TBDQRY::QSTREQ, @code)
+      # qry.addcond("nation", TBDQRY::QSTREQ, @code)
     end
 
     def to_hash
-      # { "gid" => @gid.to_s, "name" => @name, "kind" => "country", "code" => @code, "currency" => @currency}
+      # { "gid" => @gid.to_s, "name" => @name, "kind" => "nation", "code" => @code, "currency" => @currency}
     { "gid" => @gid.to_s, "iso" => @iso, "iso3" => @iso3, "iso_num" => @ison, "fips" => @fips,
     "name" => @name, "capital" => @capital, "area" => @area, "population" => @pop,
     "continent" => @continent, "tld" => @tld, "currency_code" => @currency, "currency_name" => @currency_name,
@@ -68,11 +68,11 @@ module Geonames
 
     end
   end
-      class Province
+      class Region
     attr_accessor :code, :name, :gid
 
     def self.all
-      Tokyo.new.all({ :kind => "province" }).map do |c|
+      Tokyo.new.all({ :kind => "region" }).map do |c|
         new(c)
       end
     end

data/lib/geonames_local/version.rb

@@ -1,3 +1,3 @@
 module Geonames
-  VERSION = '2.0.1'
+  VERSION = '3.1.1'
 end

metadata

@@ -1,29 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: geonames_local
 version: !ruby/object:Gem::Version
-  version: 2.0.1
-  prerelease: 
+  version: 3.1.1
 platform: ruby
 authors:
 - Marcos Piccinini
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-31 00:00:00.000000000 Z
+date: 2013-09-05 00:00:00.000000000 Z
 dependencies: []
-description: Dump and feed a tokyo cabinet for local geonames search
+description: Dumps geonames data to feed a local db
 email: x@nofxx.com
 executables:
 - geonames
 extensions: []
 extra_rdoc_files:
-- LICENSE
+- MIT-LICENSE
 - README.rdoc
 files:
-- .document
 - .gitignore
 - Gemfile
-- LICENSE
+- MIT-LICENSE
 - README.rdoc
 - Rakefile
 - bin/geonames
@@ -63,31 +61,40 @@ files:
 - task/benchmark.rb
 - task/benchmark_cabinet.rb
 homepage: http://github.com/nofxx/geonames_local
-licenses: []
-post_install_message: ! "\nGeonames Local\n--------------\n\nTo use the adapter, install
-  the corresponding gem:\n\n  PostgreSQL   =>   pg\n  MongoDB      =>   mongoid (optional:
-  mongo_ext)\n  Tokyo        =>   tokyocabinet\n\nHave fun because:\n"
+licenses:
+- MIT
+metadata: {}
+post_install_message: |2
+
+  Geonames Local
+  --------------
+
+  To use the adapter, install the corresponding gem:
+
+    PostgreSQL   =>   pg
+    MongoDB      =>   mongoid (optional: mongo_ext)
+    Tokyo        =>   tokyocabinet
+
+  Have fun because:
 rdoc_options: []
 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: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.7
 signing_key: 
-specification_version: 3
-summary: Dump and feed a tokyo local geonames db
+specification_version: 4
+summary: Dumps geonames data for local usage
 test_files:
 - spec/geonames_local/adapters/mongodb_spec.rb
 - spec/geonames_local/adapters/postgis_spec.rb

data/.document

@@ -1,5 +0,0 @@
-README.rdoc
-lib/**/*.rb
-bin/*
-features/**/*.feature
-LICENSE