geonames_local 1.0.0 → 2.0.0

data/lib/geonames_ar.rb

@@ -1,12 +0,0 @@
-#
-# Geonames Extension
-#
-$:.unshift(File.dirname(__FILE__)) unless
-  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
-
-# Adapter = Geonames::Postgres.new(Opt[:db])
-# Require Libs
-require 'geonames_local/geonames'
-
-require 'geonames_local/models/ar'
-#require 'geonames_local/data/shp'

data/lib/geonames_cli.rb

@@ -1,14 +0,0 @@
-#
-# Geonames Local
-#
-$:.unshift(File.dirname(__FILE__)) unless
-  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
-
-# Require CLI Stuff
-require 'geonames_local/geonames'
-require 'geonames_local/data/shp'
-require 'geonames_local/data/dump'
-require 'geonames_local/data/sync'
-require 'geonames_local/data/export'
-require 'geonames_local/cli'
-

data/lib/geonames_local/adapters/mongodb.rb

@@ -1,109 +0,0 @@
-require "mongo"
-
-module Geonames
-  class Mongodb
-
-    RESOURCES = ["countries", "provinces", "cities"]
-
-    def initialize(params={})
-      host, port = params[:host] || "localhost", params[:port] || 27017
-      @conn = Mongo::Connection.new(host, port)
-      @db = @conn.db(params[:dbname] || "geonames")
-      if params[:user] || params[:password]
-        @db.authenticate(params[:user], params[:password])
-      end
-      if params[:purge]
-		info "Purging database.."
-		purge
-	  end
-      setup
-    end
-
-    def setup
-      for re in RESOURCES
-        coll = @db.collection(re)
-        coll.create_index([["id", Mongo::ASCENDING], ["gid", Mongo::ASCENDING]])
-
-        # Geometric index, more info:
-        # http://www.mongodb.org/display/DOCS/Geospatial+Indexing
-        coll.create_index([["geom", Mongo::GEO2D]], :min => -180, :max => 180)
-      end
-    end
-
-    def all(resource, limit=nil, skip=0)
-      @db.collection(resource.to_s).find().to_a
-    end
-
-    def first(resource)
-      @db.collection(resource.to_s).find_one
-    end
-
-    def find(resource, id, name=nil)
-      @db.collection(resource.to_s).find_one("id" => id)
-    end
-
-    def find_by_name(resource, name)
-      do_find(resource, "name" => /#{name}/i)
-    end
-
-    def find_by_zip(resource, zip)
-      do_find(resource, "zip" => /#{zip}/)
-    end
-
-    def do_find(resource, hsh)
-      @db.collection(resource.to_s).find(hsh).to_a
-    end
-
-    def insert(resource, spot)
-      hsh = spot.to_hash
-      hsh["geom"][0] = sin_proj(hsh["geom"])[0] if hsh["geom"]
-      @db.collection(resource.to_s).insert(hsh)
-    end
-
-    def count(resource)
-      @db.collection(resource).count
-    end
-
-    def find_near(resource, x, y, limit=nil, skip=0)
-      coll = @db.collection(resource.to_s).find("geom" => { "$near" => { "x" => x, "y" => y }}).skip(skip)
-      coll.limit(limit) if limit
-      coll.to_a
-    end
-
-    # +1.3.4
-    def find_within(resource, geom, limit=nil)
-      op = geom[1].kind_of?(Numeric) ? "$center" : "$box"
-      coll = @db.collection(resource.to_s).find("geom" => { "$within" => { op => geom }})
-      coll.limit(limit) if limit
-      coll.to_a
-    end
-
-    # getNear command returns distance too
-    # <1.9 needs OrderedHash
-    def near(resource, x, y, limit=nil)
-      # FIXME: Better explicity require OrderedHash?
-      cmd = Object.const_defined?("OrderedHash") ? OrderedHash.new : { }
-      cmd["geoNear"] = resource
-      cmd["near"] = sin_proj(x,y)
-      cmd["num"] = limit if limit
-      @db.command(cmd)["results"].to_a
-    end
-
-    def purge
-      for re in RESOURCES
-        @db.drop_collection(re)
-      end
-    end
-
-    def index_info(resource)
-      @db.collection(resource).index_information
-    end
-
-    private
-
-    def sin_proj(x,y=nil)
-      x,y = x unless y
-      [x * Math.cos(y * Math::PI/180), y]
-    end
-  end
-end

data/lib/geonames_local/adapters/postgres.rb

@@ -1,108 +0,0 @@
-require "pg"
-
-module Geonames
-  class Postgres
-    Countries = {}
-    Provinces = {}
-
-    def initialize(opts={}) #table, addr = "localhost", port = 5432)
-      @conn = PGconn.new(opts)
-    end
-
-    #
-    # Get Country and Province ID from the DB
-    #
-    # Maps the FKs ids correctly for our bank
-    #
-    def get_some_ids(some)
-      cid = Countries[some.country] ||=
-          @conn.exec("SELECT countries.id FROM countries WHERE UPPER(countries.abbr) = UPPER('#{some.country}')")[0]["id"] rescue nil
-      cid ||= write("countries", {:name => Codes[some.country.downcase.to_sym][:pt_br], :abbr => some.country })
-
-      pid = nil
-      tid = nil
-      if some.kind_of? Spot
-        pid = Provinces[some.province] ||= find("provinces", Cache[:provinces].
-                                       find{ |p| p.province == some.province}.gid)
-      else
-        tid = find("cities", some.city)
-        pid = @conn.exec("SELECT cities.province_id FROM cities WHERE cities.id = #{tid}")[0]["province_id"] rescue nil
-      end
-      [cid, pid, tid]
-    end
-
-    #
-    # Insert a record
-    def insert(table, some)
-      country_id, province_id, city_id = get_some_ids(some)
-      case table
-      when :city
-        write("cities", {:name => some.name, :country_id => country_id,
-                 :geom => some.geom.as_hex_ewkb, :gid => some.gid,
-                 :zip => some.zip, :province_id => province_id})
-      when :province
-        write("provinces", { :name => some.name, :abbr => some.abbr,
-                 :country_id => country_id, :gid => some.gid })
-      when :road
-        write("roads", { :name => some.name, :geom => some.geom.as_hex_ewkb, :kind => some.kind,
-                 :country_id => country_id, :city_id => city_id, :province_id => province_id })
-      else
-        puts "Fail to insert #{some}"
-      end
-    end
-
-    #
-    # Find a record`s ID
-    def find(kind, id, name=nil)
-      table = get_table kind
-      begin
-        if name
-          @conn.exec("SELECT #{table}.id FROM #{table} WHERE (#{table}.name = E'#{id}')")[0]["id"]
-        else
-          @conn.exec("SELECT #{table}.id FROM #{table} WHERE #{table}.gid = #{id}")[0]["id"]
-        end
-      rescue => e
-        nil
-      end
-    end
-
-    #
-    # F'oo -> F''oo  (for pg)
-    def escape_name(name)
-      name.to_s.gsub("'", "''")
-    end
-
-    #
-    # Sanitize values por pg.. here until my lazyness open pg rdoc...
-    def pg_values(arr)
-      arr.map do |v|
-        case v
-        when Numeric then v.to_s
-        when Symbol, String then "E'#{escape_name(v)}'"
-        when NilClass then 'NULL'
-        else
-        end
-      end.join(",")
-    end
-
-    def get_table(kind)
-      case kind
-      when :city then "cities"
-      when :country then "countries"
-      else
-        kind.to_s + "s"
-      end
-    end
-
-    #
-    # Naive PG insert ORM =D
-    def write(table, hsh)
-      for_pg = pg_values(hsh.values)
-      @conn.exec("INSERT INTO #{table} (#{hsh.keys.join(",")}) VALUES(#{for_pg}) RETURNING id")[0]["id"]
-    end
-
-    def exec(comm)
-      @conn.exec(comm)
-    end
-  end
-end

data/lib/geonames_local/adapters/tokyo.rb

@@ -1,109 +0,0 @@
-require "tokyocabinet"
-
-module Geonames
-  class Tokyo
-
-    def initialize(conn=nil, resource=nil, extra=nil)
-      if conn
-        require 'tokyotyrant'
-        resource ||= 'localhost'
-        extra ||= 1978
-        @tbl = TokyoTyrant::RDBTBL
-        @qry = TokyoTyrant::RDBQRY
-      else
-        require 'tokyocabinet'
-        resource ||= 'geonames.tct'
-        extra ||= (TokyoCabinet::TDB::OWRITER | TokyoCabinet::TDB::OCREAT)
-        @tbl = TokyoCabinet::TDB
-        @qry = TokyoCabinet::TDBQRY
-      end
-      @rdb = @tbl.new
-      @rdb.open(resource, extra)
-      set_indexes
-    end
-
-    def all(params)
-      qry = @qry.new(@rdb)
-      params.each do |k,v|
-        #qry.addcond(k.to_s, Q::QCNUMEQ, v.to_s)
-        qry.addcond(k.to_s, @qry::QCSTREQ, v.to_s)
-      end
-      qry.setorder("name", @qry::QOSTRASC)
-      qry.search.map { |id| @rdb.get(id) }
-    end
-
-    def find(id)
-      #qry = Q.new(@rdb)
-      #qry.addcond("gid", Q::QCNUMEQ, id.to_s)
-      #qry.setlimit(10)
-      #id = qry.search.pop
-      @rdb.get(id)
-    end
-
-    # def to_obj(hsh)
-    #   hsh["kind"] == "country" ? Country.new(hsh) : Spot.new(hsh)
-    # end
-
-    def write(o)
-      # pkey = @rdb.genuid
-      if @rdb.put(o.gid, o.to_hash)
-       # info "ok"
-      else
-        info "err #{@rdb.errmsg(@rdb.ecode)}"
-      end
-    end
-
-    def count
-      @qry.new(@rdb).search.length
-    end
-
-    def close
-      # close the database
-      if !@rdb.close
-        STDERR.printf("close error: %s\n", @rdb.errmsg(@rdb.ecode))
-      end
-    end
-
-    def set_indexes
-      #for index in indexes
-      # @rdb.setindex("gid", @tbl::ITOPT)
-      @rdb.setindex("kind", @tbl::ITLEXICAL)
-      @rdb.setindex("name", @tbl::ITQGRAM)
-      @rdb.setindex("country", @tbl::ITLEXICAL)
-
-      #end
-
-    end
-
-    def flush
-      @rdb.vanish
-    end
-
-
-  end
-
-end
-
-    # def self.point(tdb, x, y)
-    #         qry = TDBQRY::new(tdb)
-    #   qry.addcond("x", TDBQRY::QCNUMGE, minx.to_s())
-    #   qry.addcond("x", TDBQRY::QCNUMLE, maxx.to_s())
-    #   qry.addcond("y", TDBQRY::QCNUMGE, miny.to_s())
-    #   qry.addcond("y", TDBQRY::QCNUMLE, maxy.to_s())
-    #   qry.setorder("x", TDBQRY::QONUMASC)
-    #   qry.setlimit(80)
-    # end
-
-
-    # def self.area(tdb, minx, maxx, miny, maxy)
-    #   qry = TDBQRY::new(tdb)
-    #   qry.addcond("x", TDBQRY::QCNUMGE, minx.to_s())
-    #   qry.addcond("x", TDBQRY::QCNUMLE, maxx.to_s())
-    #   qry.addcond("y", TDBQRY::QCNUMGE, miny.to_s())
-    #   qry.addcond("y", TDBQRY::QCNUMLE, maxy.to_s())
-    #   qry.setorder("x", TDBQRY::QONUMASC)
-
-    #   res = qry.search
-    #   info res.length # number of results found
-    #   return res
-    # end

data/lib/geonames_local/data/sync.rb

@@ -1,74 +0,0 @@
-module Geonames
-  class Sync
-    class << self
-
-      def work!
-        unify!
-        write_to_store!
-      end
-
-      def load_adapter(name)
-        begin
-          require "geonames_local/adapters/#{name}"
-          Geonames.class_eval(name.capitalize).new(Opt[:db])
-        rescue LoadError
-          puts "Can't find adapter #{name}"
-          stop!
-        end
-      end
-
-      def write_to_store!
-        groups = Cache[:dump].group_by(&:kind)
-        Cache[:provinces] = groups[:province]
-        # ensure this order....
-        do_write(groups[:province])
-        do_write(groups[:city])
-      end
-
-      def do_write(values)
-        return if values.empty?
-        db = load_adapter(Opt[:store])
-        key = values[0].table
-        start = Time.now
-        writt = 0
-        min_pop = Opt[:min_pop]
-        info "\nWriting #{values.length} #{key}..."
-        info "\nWriting spots with pop > #{Opt[:min_pop]} hab." if min_pop
-        values.each do |val|
-          if min_pop
-            next unless val.pop && val.pop.to_i >= min_pop
-          end
-          arg = val.respond_to?(:gid) ? [val.gid] : [val.name, true]
-          unless db.find(val.table, *arg)
-            db.insert(val.table, val)
-            writt += 1
-          end
-        end
-        total = Time.now - start
-        info "#{writt} #{key} written in #{total} sec (#{(writt/total).to_i}/s)"
-      end
-
-      def unify!
-        info "Join dump << zip"
-        start = Time.now
-        Cache[:dump].map! do |spot|
-          if other = Cache[:zip].find { |d| d.code == spot.code }
-            spot.zip = other.zip
-            spot
-          else
-            spot
-          end
-        end
-        info "Done. #{(Time.now-start).to_i}s"
-      end
-
-      def stop!
-        puts "Closing Geonames..."
-        exit
-      end
-
-    end
-
-  end
-
-end

data/spec/geonames_local/models/ar_spec.rb

@@ -1,73 +0,0 @@
-# -*- coding: utf-8 -*-
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_ar_helper')
-module Geonames
-  module Models
-    module AR
-      class User < ActiveRecord::Base
-        belongs_to :city
-      end
-    end
-  end
-end
-
-def brasil
-  Models::AR::Country.find_or_create_by_name(:name => "Brazil", :abbr => "BR")
-end
-
-describe "Country" do
-
-  it "should create countries" do
-    Models::AR::Country.create(:name => "Chad", :abbr => "TD").should be_valid
-  end
-
-  it "should write to db" do
-    lambda do
-      Models::AR::Country.create(:name => "Itália", :abbr => "IT")
-    end.should change(Models::AR::Country, :count).by(1)
-  end
-
-end
-
-describe "Province" do
-
-  it "should be a class instance of ar" do
-    Models::AR::Province.new.should be_instance_of Models::AR::Province
-  end
-
-  it "should create" do
-    Models::AR::Province.create(:name => "Chadland", :country => brasil).should be_valid
-  end
-end
-
-describe "City" do
-
-  it "should be a class instance of ar" do
-    Models::AR::City.new.should be_instance_of Models::AR::City
-  end
-
-  it "should create" do
-    Models::AR::City.create(:name => "Chadland", :country => brasil).should be_valid
-  end
-end
-#  DatabaseCleaner.clean
-
-describe "Active Record Stuff" do
-
-  before do
- #   DatabaseCleaner.clean
-    @br ||= brasil
-    Models::AR::City.create!("name" => "São Tomé", "geom" => [15,15], :country => @br)
-    Models::AR::City.create!("name" => "Rock CIty", "geom" => [18,16], :country => @br)
-  end
-
-  it "should record" do
-    Models::AR::City.count.should eql(2)
-  end
-
-  it "should create" do
-    user = Models::AR::User.new(:name => "Defendor")
-    user.city = Models::AR::City.first
-    user.save
-    Models::AR::User.first.city.name.should eql("São Tomé")
-  end
-end