geomash 0.2.0

data/lib/geomash/town_lookup.rb

@@ -0,0 +1,19 @@
+module Geomash
+  class TownLookup
+    #Only returns one result for now...
+    #Need to avoid cases like "Boston" and "East Boston"
+    def self.state_town_lookup(state_key, string)
+      return_tgn_id = nil
+      matched_terms_count = 0
+      matching_towns = Geomash::Constants::STATE_TOWN_TGN_IDS[state_key.to_sym].select {|hash| string.include?(hash[:location_name])}
+      matching_towns.each do |matching_town|
+        if matching_town[:location_name].split(' ').length > matched_terms_count
+          return_tgn_id = matching_town[:tgn_id]
+          matched_terms_count = matching_town[:location_name].split(' ').length
+        end
+      end
+
+      return return_tgn_id
+    end
+  end
+end

data/lib/geomash/version.rb

@@ -0,0 +1,3 @@
+module Geomash
+  VERSION = "0.2.0"
+end

data/test/geomash_test.rb

@@ -0,0 +1,146 @@
+# -*- coding: utf-8 -*-
+require 'test_helper'
+
+#Historical stuff like Jews--Soviet Union--History--Catalogs ?
+# Registers of births, etc.--Canada, Western totally borked
+
+#Synagogues--Germany--Baden-Württemberg--Directories  -> doesn't match as google returns Baden-Württemberg as
+#Baden-Wurttemberg . No matches http://vocab.getty.edu/tgn/7003692
+
+class GeomashTest < ActiveSupport::TestCase
+
+  def test_parse_with_flag
+    result = Geomash.parse('Abbeville (France)--History--20th century.', true)
+    assert_equal 'Abbeville', result[:city_part]
+    assert_equal 'Picardy', result[:state_part]
+    assert_equal 'France', result[:country_part]
+    assert_equal nil, result[:street_part]
+    assert_equal '7010587', result[:tgn][:id] if Geomash::TGN.tgn_enabled == true
+    assert_equal true, result[:tgn][:original_string_differs] if Geomash::TGN.tgn_enabled == true
+    assert_equal '2987374', result[:geonames][:id] if Geomash::Geonames.geonames_username != '<username>'
+    assert_equal true, result[:geonames][:original_string_differs] if Geomash::Geonames.geonames_username != '<username>'
+
+    #Slight variation problem with neighborhood: 11. Bezirk (Vienna, Austria)--Biography
+    result = Geomash.parse('15. Bezirk (Rudolfsheim-Fünfhaus, Vienna, Austria)--Exhibitions', true)
+    assert_equal 'Vienna', result[:city_part]
+    assert_equal 'Vienna', result[:state_part]
+    assert_equal 'Austria', result[:country_part]
+    assert_equal 'Rudolfsheim-Fünfhaus', result[:neighborhood_part]
+    assert_equal nil, result[:street_part]
+    assert_equal '7003321', result[:tgn][:id] if Geomash::TGN.tgn_enabled == true
+    assert_equal true, result[:tgn][:original_string_differs] if Geomash::TGN.tgn_enabled == true
+    assert_equal '2779138', result[:geonames][:id] if Geomash::Geonames.geonames_username != '<username>'
+    assert_equal true, result[:geonames][:original_string_differs] if Geomash::Geonames.geonames_username != '<username>'
+
+    result = Geomash.parse('Synagogues--Germany--Baden-Württemberg--Directories', true)
+    assert_equal nil, result[:city_part]
+    assert_equal 'Baden-Wurttemberg', result[:state_part]
+    assert_equal 'Germany', result[:country_part]
+    assert_equal nil, result[:neighborhood_part]
+    assert_equal nil, result[:street_part]
+    assert_equal '7003692', result[:tgn][:id] if Geomash::TGN.tgn_enabled == true
+    assert_equal true, result[:tgn][:original_string_differs] if Geomash::TGN.tgn_enabled == true
+    assert_equal '2953481', result[:geonames][:id] if Geomash::Geonames.geonames_username != '<username>'
+    assert_equal true, result[:geonames][:original_string_differs] if Geomash::Geonames.geonames_username != '<username>'
+
+  end
+
+  def test_parse_with_no_flag
+    result = Geomash.parse('Boston, MA')
+    assert_equal 'Boston', result[:city_part]
+    assert_equal 'Massachusetts', result[:state_part]
+    assert_equal 'United States', result[:country_part]
+    assert_equal nil, result[:street_part]
+    assert_equal '7013445', result[:tgn][:id] if Geomash::TGN.tgn_enabled == true
+    assert_equal false, result[:tgn][:original_string_differs] if Geomash::TGN.tgn_enabled == true
+    assert_equal '4930956', result[:geonames][:id] if Geomash::Geonames.geonames_username != '<username>'
+    assert_equal false, result[:geonames][:original_string_differs] if Geomash::Geonames.geonames_username != '<username>'
+
+    result = Geomash.parse('New York, NY')
+    assert_equal 'New York', result[:city_part]
+    assert_equal 'New York', result[:state_part]
+    assert_equal 'United States', result[:country_part]
+    assert_equal nil, result[:street_part]
+    assert_equal '7007567', result[:tgn][:id] if Geomash::TGN.tgn_enabled == true
+    assert_equal false, result[:tgn][:original_string_differs] if Geomash::TGN.tgn_enabled == true
+    assert_equal '5128581', result[:geonames][:id] if Geomash::Geonames.geonames_username != '<username>'
+    assert_equal false, result[:geonames][:original_string_differs] if Geomash::Geonames.geonames_username != '<username>'
+
+    result = Geomash.parse('Washington, DC')
+    assert_equal 'Washington', result[:city_part]
+    assert_equal 'District of Columbia', result[:state_part]
+    assert_equal 'United States', result[:country_part]
+    assert_equal nil, result[:street_part]
+    assert_equal '7013962', result[:tgn][:id] if Geomash::TGN.tgn_enabled == true
+    assert_equal false, result[:tgn][:original_string_differs] if Geomash::TGN.tgn_enabled == true
+    assert_equal '4140963', result[:geonames][:id] if Geomash::Geonames.geonames_username != '<username>'
+    assert_equal false, result[:geonames][:original_string_differs] if Geomash::Geonames.geonames_username != '<username>'
+
+    result = Geomash.parse('Roxbury (Boston, Mass.)')
+    assert_equal 'Boston', result[:city_part]
+    assert_equal 'Massachusetts', result[:state_part]
+    assert_equal 'United States', result[:country_part]
+    assert_equal 'Roxbury', result[:neighborhood_part]
+    assert_equal nil, result[:street_part]
+    assert_equal '7015002', result[:tgn][:id] if Geomash::TGN.tgn_enabled == true
+    assert_equal false, result[:tgn][:original_string_differs] if Geomash::TGN.tgn_enabled == true
+    #FIXME?
+    assert_equal '4949151', result[:geonames][:id] if Geomash::Geonames.geonames_username != '<username>'
+    assert_equal false, result[:geonames][:original_string_differs] if Geomash::Geonames.geonames_username != '<username>'
+
+    result = Geomash.parse('Roxbury, Mass.')
+    assert_equal 'Boston', result[:city_part]
+    assert_equal 'Massachusetts', result[:state_part]
+    assert_equal 'United States', result[:country_part]
+    assert_equal 'Roxbury', result[:neighborhood_part]
+    assert_equal nil, result[:street_part]
+    assert_equal '7015002', result[:tgn][:id] if Geomash::TGN.tgn_enabled == true
+    assert_equal false, result[:tgn][:original_string_differs] if Geomash::TGN.tgn_enabled == true
+    #FIXME?
+    assert_equal '4949151', result[:geonames][:id] if Geomash::Geonames.geonames_username != '<username>'
+    assert_equal false, result[:geonames][:original_string_differs] if Geomash::Geonames.geonames_username != '<username>'
+
+    result = Geomash.parse('Vietnam')
+    assert_equal nil, result[:city_part]
+    assert_equal nil, result[:state_part]
+    assert_equal 'Vietnam', result[:country_part]
+    assert_equal nil, result[:neighborhood_part]
+    assert_equal '1000145', result[:tgn][:id] if Geomash::TGN.tgn_enabled == true
+    assert_equal nil, result[:street_part]
+    assert_equal false, result[:tgn][:original_string_differs] if Geomash::TGN.tgn_enabled == true
+
+    result = Geomash.parse('Soviet Union')
+    assert_equal nil, result[:city_part]
+    assert_equal nil, result[:state_part]
+    assert_equal nil, result[:country_part]
+    assert_equal nil, result[:neighborhood_part]
+    assert_equal nil, result[:tgn]
+    assert_equal nil, result[:street_part]
+
+    result = Geomash.parse('Fenway (Boston, Mass.)')
+    assert_equal 'Boston', result[:city_part]
+    assert_equal 'Massachusetts', result[:state_part]
+    assert_equal 'United States', result[:country_part]
+    assert_equal 'Fenway/Kenmore', result[:neighborhood_part]
+    assert_equal '7013445', result[:tgn][:id] if Geomash::TGN.tgn_enabled == true
+    assert_equal nil, result[:street_part]
+    assert_equal true, result[:tgn][:original_string_differs] if Geomash::TGN.tgn_enabled == true
+
+    #Should find the Michigan Atlanta over the Georgia Atlanta
+    #State part from an API giving me Atlanta????
+    result = Geomash.parse('Atlanta, MI')
+    assert_equal 'Atlanta', result[:city_part]
+    assert_equal 'Michigan', result[:state_part]
+    assert_equal 'United States', result[:country_part]
+    assert_equal nil, result[:neighborhood_part]
+    assert_equal '2051159', result[:tgn][:id] if Geomash::TGN.tgn_enabled == true
+    assert_equal false, result[:tgn][:original_string_differs] if Geomash::TGN.tgn_enabled == true
+    assert_equal '4984500', result[:geonames][:id] if Geomash::Geonames.geonames_username != '<username>'
+    assert_equal false, result[:geonames][:original_string_differs] if Geomash::Geonames.geonames_username != '<username>'
+
+
+
+
+
+  end
+end

data/test/geonames_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+class GeonamesTest < ActiveSupport::TestCase
+  def test_geonames_lookup_from_id
+    if Geomash::Geonames.geonames_username != '<username>'
+      result = Geomash::Geonames.get_geonames_data('4984500')
+
+      assert_equal '45.00473', result[:coords][:latitude]
+      assert_equal '-84.14389', result[:coords][:longitude]
+      assert_equal '45.00473,-84.14389', result[:coords][:combined]
+      assert_equal '-84.18404', result[:coords][:box][:west]
+      assert_equal '45.01697', result[:coords][:box][:north]
+      assert_equal '-84.11884', result[:coords][:box][:east]
+      assert_equal '44.98859', result[:coords][:box][:south]
+      assert_equal 'Atlanta', result[:hier_geo][:ppla2]
+      assert_equal 'Montmorency County', result[:hier_geo][:adm2]
+      assert_equal 'Michigan', result[:hier_geo][:adm1]
+      assert_equal 'United States', result[:hier_geo][:pcli]
+      assert_equal 'North America', result[:hier_geo][:cont]
+      assert_equal 'Earth', result[:hier_geo][:area]
+
+    end
+  end
+end

data/test/parser_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+class ParserTest < ActiveSupport::TestCase
+  def test_google_parser
+    result = Geomash::Parser.parse_google_api('Boston, MA')
+    assert_equal 'Boston', result[:city_part]
+    assert_equal 'Massachusetts', result[:state_part]
+    assert_equal 'United States', result[:country_part]
+    assert_equal nil, result[:street_part]
+
+    result = Geomash::Parser.parse_google_api('700 Boylston St, Boston, MA 02116')
+    assert_equal 'Boston', result[:city_part]
+    assert_equal 'Massachusetts', result[:state_part]
+    assert_equal 'United States', result[:country_part]
+
+    result = Geomash::Parser.parse_google_api('Roxbury (Boston, Mass.)')
+    assert_equal 'Boston', result[:city_part]
+    assert_equal 'Massachusetts', result[:state_part]
+    assert_equal 'United States', result[:country_part]
+    assert_equal 'Roxbury', result[:neighborhood_part]
+    assert_equal nil, result[:street_part]
+
+
+    #FIXME!!!  Is this alright?
+    #result = Bplgeo::Parser.parse_google_api('201 Dowman Dr., Atlanta, GA 30322')
+    #assert_equal 'Atlanta', result[:city_part]
+    #assert_equal 'Georgia', result[:state_part]
+    #assert_equal 'United States', result[:country_part]
+    #assert_equal 'true', result[:term_differs_from_tgn]
+  end
+
+
+end

data/test/standardizer_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+class ParserTest < ActiveSupport::TestCase
+  def test_dedup_geo
+    sample_array = ['Saigon, Vietnam', 'Saigon (Vietnam)', 'Vietnam', 'Vietnam, Party']
+    result = Geomash::Standardizer.dedup_geo(sample_array)
+    assert_equal ['Saigon, Vietnam', 'Vietnam', 'Vietnam, Party'], result
+
+    result = Geomash::Standardizer.dedup_geo(sample_array, true)
+    assert_equal ['Saigon, Vietnam', 'Vietnam, Party'], result
+
+    sample_array << 'Some Place, Vietnam'
+    result = Geomash::Standardizer.dedup_geo(sample_array)
+    assert_equal ['Saigon, Vietnam', 'Vietnam', 'Vietnam, Party', 'Some Place, Vietnam'], result
+
+    result = Geomash::Standardizer.dedup_geo(sample_array, true)
+    assert_equal ['Saigon, Vietnam', 'Vietnam, Party', 'Some Place, Vietnam'], result
+
+    #sample_array << 'Some Place, Vietnam, Saigon'
+    #result = Geomash::Standardizer.dedup_geo(sample_array, true)
+    #assert_equal ['Some Place, Vietnam, Saigon'], result
+
+  end
+
+
+end

data/test/test_helper.rb

@@ -0,0 +1,16 @@
+# Configure Rails Environment
+ENV["RAILS_ENV"] = "test"
+
+require 'rails'
+require "rails/test_help"
+
+require 'geomash'
+Rails.backtrace_cleaner.remove_silencers!
+
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+# Load fixtures from the engine
+if ActiveSupport::TestCase.method_defined?(:fixture_path=)
+  ActiveSupport::TestCase.fixture_path = File.expand_path("../fixtures", __FILE__)
+end

data/test/tgn_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+class TGNTest < ActiveSupport::TestCase
+  def test_tgn_lookup_from_id
+    if Geomash::TGN.tgn_enabled == 'true'
+       result = Geomash::TGN.get_tgn_data('2051159')
+
+       assert_equal '45', result[:coords][:latitude]
+       assert_equal '-84.1333', result[:coords][:longitude]
+       assert_equal '45,-84.1333', result[:coords][:combined]
+       assert_equal 'Atlanta', result[:hier_geo][:city]
+       assert_equal 'Montmorency', result[:hier_geo][:county]
+       assert_equal 'Michigan', result[:hier_geo][:state]
+       assert_equal 'United States', result[:hier_geo][:country]
+       assert_equal 'North and Central America', result[:hier_geo][:continent]
+
+    end
+  end
+end

data/test/town_lookup_test.rb

@@ -0,0 +1,11 @@
+require 'test_helper'
+
+class TownLookupTest < ActiveSupport::TestCase
+  def test_MA_lookup
+    result = Geomash::TownLookup.state_town_lookup('MA', "This test was written in Boston, MA.")
+    assert_equal '7013445', result
+
+    result = Geomash::TownLookup.state_town_lookup('MA', "This test was written in East Boston, MA.")
+    assert_equal '7015009', result
+  end
+end

metadata

@@ -0,0 +1,210 @@
+--- !ruby/object:Gem::Specification
+name: geomash
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Boston Public Library
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: countries
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: geocoder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: unidecoder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: typhoeus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: htmlentities
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sparql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Parse string for potential geographic matches and return that data along
+  with the TGN ID and Geonames ID.
+email:
+- sanderson@bpl.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- config/geomash.yml.sample
+- lib/geomash.rb
+- lib/geomash/geonames.rb
+- lib/geomash/parser.rb
+- lib/geomash/standardizer.rb
+- lib/geomash/version.rb
+- lib/geomash/tgn.rb
+- lib/geomash/town_lookup.rb
+- lib/geomash/constants.rb
+- Rakefile
+- test/standardizer_test.rb
+- test/parser_test.rb
+- test/geomash_test.rb
+- test/geonames_test.rb
+- test/town_lookup_test.rb
+- test/test_helper.rb
+- test/tgn_test.rb
+homepage: http://www.bpl.org
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.10
+signing_key: 
+specification_version: 4
+summary: Parse string for potential geographic matches and return that data along
+  with the TGN ID and Geonames ID.
+test_files:
+- test/standardizer_test.rb
+- test/parser_test.rb
+- test/geomash_test.rb
+- test/geonames_test.rb
+- test/town_lookup_test.rb
+- test/test_helper.rb
+- test/tgn_test.rb
+has_rdoc: