geopolitical 3.2.0 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6eab76b546c1fe68a2b74c24193504f349c650ef97a5982cc87ee5fb74769d4e
-  data.tar.gz: 3301e6d264d6446a0663941819b76b64f956e83f89a16e5bcf70f87644abe616
+  metadata.gz: bfe29900897a18f20389e3bcc7107c7934acf4a482594d62cd203d16218baacf
+  data.tar.gz: 7502b7cb5e3b66461e849cbb4eac85ac20e05e7e4c77f05d30067363dd99670c
 SHA512:
-  metadata.gz: e4b582dacaf75fe5584450b61ee55d05bab5e15565ee7ee31c0104a852fcd1d28853fef45aa11c5de67bc48d9be8f18997789032fed639dd4deba8a5cd8e45ad
-  data.tar.gz: 1461b8bf452628a21c708f7c884d72301d0ac421079671b554e1aa2d4816064adafde8595c95c988936b52f85b5996c37bd27e08c00ee8e1d31461f88c200e68
+  metadata.gz: 7d878011e11bc16a92e2709938930d3a52bb6acabd4735ddcd393c150cd8c179b594cc0b497db50f37d556414f77f59ee235db6e519e41c3fb6aab6bf1c9f689
+  data.tar.gz: b6fa32e93cd018cf6487c5930b3e22dcd9ca4eb6c89a5c970c8824f56cb3050c55370c7eb3950d07027166f39c6b958440a32950497ea4b6629d008d582a209f

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 4.1.0
+
+- Engine views are ERB; the `haml` gem is gone.
+
+## 4.0.0
+
+- `City#geom` has one index, 2dsphere (`sphere: true`). It had a planar `2d` beside it and `City.nearby` used that one; it is `$nearSphere` now. The `spatial_scope :geom` (`City.closest_to_geom`, planar) is gone. An existing database keeps the old `geom_2d` until `City.remove_undefined_indexes`.
+
+- `Geopolitical::Postal.suggest(text, session:)` and `.pick(ref, session:)` — type any address, pick one, get a `Found` you may store. `Geopolitical.postal_provider = :google` (Places API New, Essentials fields only) or `:geoapify`; `Geopolitical.postal_key` holds the key. A `City` the table lacks is made under its state's `Region`, same as a CEP's.
+- `Geopolitical::Postal.find('01311-925')` — a Brazilian CEP in, the street, the neighbourhood and the `City` out (by IBGE code, `City#code`). A city the table lacks is made under its state's `Region`. BrasilAPI v2, one call, cached a day where Rails has a cache; offline, unknown or malformed answers `nil`. `nation:` is `'BR'`, and anything else answers `nil` rather than a guess.
+
+## 3.2.1
+
+- Every uniqueness validation now has a unique index behind it, so concurrent writes can't slip a duplicate past the check:
+  - `Nation` abbr: unique (the writer upcases, so it is case-insensitive).
+  - `City` name: unique on `{nation_id, region_id, name}`, the validation's own scope.
+  - `Region` abbr within a nation: partial on `abbr > ""` instead of sparse. Sparse did nothing on a compound index whose `nation_id` is always set, so the second abbr-less region in a nation failed to save.
+- The concern no longer declares `{abbr: 1}`. Mongoid keys a declaration on its fields alone, so the concern's copy silently swallowed `Nation`'s unique one. `Region` keeps its own.
+- `spec/models/indexes_spec.rb` inserts straight into the collection, past the validations, and expects the index to refuse.
+
 ## 3.2.0
 
 - Slugs work in every script: `東京` → `東京`, `Санкт-Петербург` → `санкт-петербург`. Non-Latin names were previously invalid (blank slug). Accents are stripped via NFKD (`Hà Nội` → `ha-noi`). Underscores now become hyphens.
@@ -25,4 +45,4 @@
 - `Nation#lang=` keeps the nations other languages instead of wiping `langs` to a single entry.
 - `Nation[]` returns `nil` for an unknown abbr instead of raising `DocumentNotFound`.
 
-**Upgrading:** stored slugs are not rewritten until a document is saved again, so existing data is untouched � but region-less cities will pick up a nation suffix the next time they are saved, and `City.create_indexes` will now fail on a database that already holds duplicate city slugs. `geonames_local` depends on `geopolitical > 0.8.4` (no upper bound) and will pick this up on its next bundle.
+**Upgrading:** stored slugs are not rewritten until a document is saved again, so existing data is untouched � but region-less cities will pick up a nation suffix the next time they are saved, and `City.create_indexes` will now fail on a database that already holds duplicate city slugs. `geonames_local` depends on `geopolitical > 0.8.4` (no upper bound) and will pick this up on its next bundle.

data/README.md

@@ -109,6 +109,47 @@ City.population.first           # biggest city
 Region.ordered                  # by name
 ```
 
+### Addresses — `Geopolitical::Postal`
+
+Two ways in, one answer out: a `Found` with the street, number, hood, postal
+code and the `City` (found, or made under its state's `Region`).
+
+```
+  typing "av paulista 1578"  ──suggest──►  [Suggestion(ref, text), …]   free, nothing kept
+  the person picks one       ──pick─────►  Found                        one call, yours to store
+  a Brazilian CEP            ──find─────►  Found                        free, no key
+```
+
+```ruby
+# config/initializers/geopolitical.rb
+Geopolitical.postal_provider = :google        # :google · :geoapify — nil means no typing search
+Geopolitical.postal_key      = ENV['GOOGLE_MAPS_KEY']
+
+token = SecureRandom.uuid                       # one per form: Google bills the typing as one session
+Geopolitical::Postal.suggest('av paulista 1578', session: token, nation: 'BR')
+# => [#<data Suggestion ref="ChIJ…" text="Avenida Paulista, 1578 - Bela Vista, São Paulo - SP, Brasil">]
+found = Geopolitical::Postal.pick('ChIJ…', session: token)
+found.street                   # => "Avenida Paulista"
+found.number                   # => "1578"
+found.city                     # => #<City São Paulo/SP>
+found.ref                      # => "ChIJ…"   the provider's id, the one thing Google lets you keep forever
+
+Geopolitical::Postal.find('01311-925')          # a CEP, masked or not — BrasilAPI, whatever the provider
+Geopolitical::Postal.find('10001', nation: 'US')  # => nil — no guessing
+```
+
+| provider    | data              | store the pick? | free                            |
+|-------------|-------------------|-----------------|---------------------------------|
+| `:google`   | best, Brazil too  | yes — the address the person picked ([Places policy](https://developers.google.com/maps/documentation/places/web-service/policies)) | typing unlimited in a session, 10k picks/mo |
+| `:geoapify` | OpenStreetMap     | yes             | 3,000 requests/day              |
+| BrasilAPI   | Correios (CEP)    | yes             | no key, `find` only             |
+
+Google's pick asks the **Essentials** fields and nothing else
+(`Postal::Google::FIELDS`) — one field more and it bills as Pro. Suggestions
+and picks are never cached; a CEP is cached a day where Rails has a cache.
+Offline, unknown, a bad key: `[]` or `nil`, and the form stays open for a
+person to type.
+
 Slugs are the API. They're stable, unique, URL-safe and they survive scripts
 you can't transliterate:
 

data/app/models/city.rb

@@ -15,19 +15,18 @@ class City
 
   # @!attribute [rw] area
   #   @return [Integer] The square area of the city in square meters (m2).
-  field :area,    type: Integer
+  field :area, type: Integer
+
   # @!attribute [rw] geom
-  #   @return [Point] The geographical coordinates (longitude, latitude) of the city.
-  #   Indexed for spatial queries.
-  field :geom,    type: Point, spatial: true
+  #   @return [Point] [lng, lat], 2dsphere — `nearby` is `$nearSphere`.
+  #
+  field :geom, type: Point, sphere: true
+
   # @!attribute [rw] rbbr
   #   @return [String] Cached abbreviation of the city's region.
   #   Used internally, primarily to construct unique slugs.
   #   Alias: `region_abbr` (writer only, getter is custom).
-  field :rbbr,    type: String, as: :region_abbr
-
-  # Enables spatial queries on the `geom` field.
-  spatial_scope :geom
+  field :rbbr, type: String, as: :region_abbr
 
   # @!attribute [rw] region
   #   @return [Region, nil] The region this city belongs to. Optional.
@@ -61,10 +60,10 @@ class City
 
   index({ slug: 1 }, unique: true)
   index({ name: 1, nation_id: 1 }) # For lookups by name within a nation
-  index({ nation_id: 1 })          # For finding all cities in a nation
+  index({ nation_id: 1, region_id: 1, name: 1 }, { unique: true }) # Backs the name uniqueness validation
+  index({ nation_id: 1 }) # For finding all cities in a nation
   index({ region_id: 1 }, sparse: true) # For finding cities in a region, sparse if region is optional
   index({ souls: -1 }) # For sorting by population count
-  index({ geom: '2dsphere' }) # Explicit 2dsphere index for geospatial queries
 
   # Validates that if a city is associated with a region, that region
   # belongs to the same nation as the city.

data/app/models/concerns/geopolitocracy.rb

@@ -77,10 +77,10 @@ module Geopolitocracy
     # @!endgroup
 
     # @!group Indexes
-    # NOTE: no plain slug index here — each model declares its own (unique where it
-    # can be), and a duplicate key declaration would silently shadow theirs.
+    # NOTE: no slug or abbr index here — each model declares its own (unique where
+    # it can be). Mongoid keys a declaration on the fields alone, so a second
+    # `index({ abbr: 1 }, unique: true)` in a model would be silently ignored.
     index({ name: 1 }) # For sorting and lookups by name
-    index({ abbr: 1 }, { sparse: true }) # Sparse as abbr can be nil
     index({ code: 1 }, { sparse: true }) # Sparse as code can be nil
     # @!endgroup
 

data/app/models/geopolitical/postal/brasilapi.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Geopolitical
+  module Postal
+    #
+    # A Brazilian CEP → street, hood and City, off the Correios data.
+    #
+    # BrasilAPI v2, not ViaCEP: ViaCEP answers {"erro": "true"} for a
+    # town-wide CEP like 37958-000, BrasilAPI answers it with the IBGE code.
+    # Its coordinates are the city's centroid, not the street, so they are
+    # not read. An answer is a suggestion a person may overwrite — the
+    # provider even places 99999-999 somewhere.
+    #
+    # ponytail: one free provider, no key. A second one the day this one is
+    # down long enough to notice.
+    #
+    module Brasilapi
+      URL = 'https://brasilapi.com.br/api/cep/v2/%s'
+
+      module_function
+
+      def find(code, nation: 'BR')
+        return unless nation.to_s.upcase == 'BR'
+
+        digits = code.to_s.gsub(/\D/, '')
+        return unless digits.size == 8
+
+        body = Postal.cached("geopolitical/postal/#{digits}") { Postal.http(format(URL, digits)) }
+        found(body, "#{digits[0, 5]}-#{digits[5, 3]}") if body
+      end
+
+      def found(body, postal)
+        city = Postal.city(nation: 'BR', state: body['state'], name: body['city'], code: body.dig('ibge', 'city'))
+        Found.new(postal: postal, street: body['street'].presence, number: nil,
+                  hood: body['neighborhood'].presence, city: city, ref: nil)
+      end
+    end
+  end
+end

data/app/models/geopolitical/postal/geoapify.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Geopolitical
+  module Postal
+    #
+    # Geoapify: OpenStreetMap data, 3,000 requests a day free, and a licence
+    # that lets you keep what you picked. Address autocomplete while typing,
+    # place details on the pick. No sessions — every request is one credit.
+    #
+    module Geoapify
+      AUTOCOMPLETE = 'https://api.geoapify.com/v1/geocode/autocomplete'
+      DETAILS = 'https://api.geoapify.com/v2/place-details'
+
+      module_function
+
+      def suggest(text, nation:, **)
+        query = { text: text, format: 'json', lang: Postal.language,
+                  filter: ("countrycode:#{nation.to_s.downcase}" if nation.present?),
+                  apiKey: Geopolitical.postal_key }.compact
+        answer = Postal.http("#{AUTOCOMPLETE}?#{URI.encode_www_form(query)}") or return []
+
+        Array(answer['results']).filter_map do |result|
+          Suggestion.new(ref: result['place_id'], text: result['formatted']) if result['place_id']
+        end
+      end
+
+      def pick(ref, **)
+        query = URI.encode_www_form(id: ref, lang: Postal.language, apiKey: Geopolitical.postal_key)
+        answer = Postal.http("#{DETAILS}?#{query}") or return
+        place = answer.dig('features', 0, 'properties') or return
+
+        Found.new(postal: place['postcode'], street: place['street'], number: place['housenumber'],
+                  hood: place['suburb'] || place['district'],
+                  city: Postal.city(nation: place['country_code'], state: place['state_code'], name: place['city']),
+                  ref: place['place_id'] || ref)
+      end
+    end
+  end
+end

data/app/models/geopolitical/postal/google.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Geopolitical
+  module Postal
+    #
+    # Google Places API (New). The typing is Autocomplete, and a session token
+    # makes it free when the session ends in a pick; the pick is one Place
+    # Details call. The address the person picked is theirs to keep (Places
+    # policy, "Autocomplete for end user addresses"); the suggestion list is
+    # not, and neither is a cache of it.
+    #
+    module Google
+      AUTOCOMPLETE = 'https://places.googleapis.com/v1/places:autocomplete'
+      DETAILS = 'https://places.googleapis.com/v1/places/%s'
+
+      # Place Details Essentials. One field outside that SKU bills every pick
+      # as Pro — half the free allowance, three times the price.
+      FIELDS = %w[id formattedAddress addressComponents].freeze
+
+      module_function
+
+      def suggest(text, session:, nation:)
+        body = { input: text, sessionToken: session, languageCode: Postal.language,
+                 includedRegionCodes: ([nation.to_s.downcase] if nation.present?) }.compact
+        answer = Postal.http(AUTOCOMPLETE, body: body, headers: key) or return []
+
+        Array(answer['suggestions']).filter_map do |suggestion|
+          place = suggestion['placePrediction'] or next
+          Suggestion.new(ref: place['placeId'], text: place.dig('text', 'text'))
+        end
+      end
+
+      def pick(ref, session:)
+        query = URI.encode_www_form({ sessionToken: session, languageCode: Postal.language }.compact)
+        url = "#{format(DETAILS, URI.encode_www_form_component(ref))}?#{query}"
+        place = Postal.http(url, headers: key.merge('X-Goog-FieldMask' => FIELDS.join(','))) or return
+
+        found(Array(place['addressComponents']), place['id'] || ref)
+      end
+
+      # ponytail: locality first, the city in most countries; Brazil often
+      # sends only administrative_area_level_2. Real answers settle the order.
+      def found(parts, ref)
+        Found.new(postal: part(parts, 'postal_code'), street: part(parts, 'route'),
+                  number: part(parts, 'street_number'), ref: ref,
+                  hood: part(parts, 'sublocality_level_1', 'sublocality', 'neighborhood'),
+                  city: Postal.city(nation: part(parts, 'country', text: 'shortText'),
+                                    state: part(parts, 'administrative_area_level_1', text: 'shortText'),
+                                    name: part(parts, 'locality', 'administrative_area_level_2')))
+      end
+
+      # The first component carrying any of the types, in the order asked.
+      def part(parts, *types, text: 'longText')
+        types.each do |type|
+          component = parts.find { |candidate| Array(candidate['types']).include?(type) }
+          return component[text] if component
+        end
+        nil
+      end
+
+      def key = { 'X-Goog-Api-Key' => Geopolitical.postal_key }
+    end
+  end
+end

data/app/models/geopolitical/postal.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'active_support/core_ext/object/blank'
+
+module Geopolitical
+  #
+  # An address in, a `Found` out — the street, the number, the hood, the
+  # postal code and the City (found, or made under its state's Region).
+  #
+  #   suggest(text, session:)   the list while a person types    free, nothing kept
+  #   pick(ref, session:)       the one they chose               one call, yours to store
+  #   find(cep)                 a Brazilian CEP                  BrasilAPI, no key
+  #
+  # `suggest` and `pick` go to `Geopolitical.postal_provider` (:google or
+  # :geoapify) with `Geopolitical.postal_key`; with either unset the search is
+  # off and answers [] / nil. Every call leaves through `http`, which answers
+  # nil for anything but a 200 with JSON — offline, a bad key, a timeout.
+  #
+  # Only CEPs are cached: Google's terms keep the picked address yours, but
+  # not a cache of its answers.
+  #
+  module Postal
+    Found = Data.define(:postal, :street, :number, :hood, :city, :ref)
+    Suggestion = Data.define(:ref, :text)
+
+    module_function
+
+    def suggest(text, session: nil, nation: nil)
+      text = text.to_s.strip
+      api = provider
+      return [] if api.nil? || text.size < 3
+
+      api.suggest(text, session:, nation:)
+    end
+
+    def pick(ref, session: nil)
+      api = provider
+      return if api.nil? || ref.blank?
+
+      api.pick(ref.to_s, session:)
+    end
+
+    def find(code, nation: 'BR') = Brasilapi.find(code, nation:)
+
+    # A typo in the provider's name raises: a search that is silently off is
+    # a form nobody knows is broken.
+    def provider
+      return if Geopolitical.postal_provider.blank? || Geopolitical.postal_key.blank?
+
+      { google: Google, geoapify: Geoapify }.fetch(Geopolitical.postal_provider.to_sym)
+    end
+
+    def http(url, body: nil, headers: {})
+      uri = URI(url)
+      request = body ? Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json') : Net::HTTP::Get.new(uri)
+      headers.each { |name, value| request[name] = value }
+      request.body = JSON.generate(body) if body
+      response = Net::HTTP.start(uri.host, uri.port, use_ssl: true, open_timeout: 2, read_timeout: 4) do |net|
+        net.request(request)
+      end
+      response.is_a?(Net::HTTPSuccess) ? JSON.parse(response.body) : nil
+    rescue StandardError
+      nil
+    end
+
+    # By code where the provider has one (IBGE), else by name under the
+    # state's Region. One the table lacks is made there: a small town is
+    # exactly what a city table is most likely to be missing. No Region for
+    # the state, no City — the rest of the address still fills.
+    def city(nation:, state:, name:, code: nil)
+      known = City.where(code: code).first if code.present?
+      return known if known
+
+      region = region(nation, state)
+      return if region.nil? || name.blank?
+
+      slug = "#{Geopolitocracy.slugify(name)}-#{Geopolitocracy.slugify(region.abbr)}"
+      City.where(slug: slug).first || make_city(name, code, region) || City.where(slug: slug).first
+    end
+
+    def region(nation, state)
+      country = Nation[nation] or return
+      Region.where(nation_id: country.id, abbr: state.to_s.upcase).first
+    end
+
+    # Two people picking the same new town at once: the second insert loses to
+    # the unique slug index, and the caller finds the first one's City.
+    def make_city(name, code, region)
+      made = City.create(name: name, code: code.presence, region: region, nation: region.nation)
+      made if made.persisted?
+    rescue Mongo::Error::OperationFailure
+      nil
+    end
+
+    def language = defined?(I18n) ? I18n.locale.to_s[0, 2] : 'en'
+
+    def cached(key, &)
+      return yield unless defined?(Rails) && Rails.respond_to?(:cache) && Rails.cache
+
+      Rails.cache.fetch(key, expires_in: 86_400, skip_nil: true, &)
+    end
+  end
+end

data/app/models/nation.rb

@@ -61,6 +61,7 @@ class Nation
 
   index({ name: 1 }) # Index for sorting by name, common operation
   index({ slug: 1 }, { unique: true }) # Slugs must be globally unique for nations
+  index({ abbr: 1 }, { unique: true }) # abbr is upcased by its writer, so plain unique is case-insensitive
 
   # Nation['br'] => the Nation with abbr BR (the abbr is the _id), nil if unknown.
   # @param abbr [String, Symbol]

data/app/models/region.rb

@@ -30,14 +30,16 @@ class Region
   validates :name, uniqueness: { scope: :nation_id, message: 'must be unique within its nation' }
   # `abbr` (from Geopolitocracy) should also be unique within its nation if present.
   validates :abbr,
-            uniqueness: { scope: :nation_id, allow_nil: true, message: 'must be unique within its nation if provided' }
+            uniqueness: { scope: :nation_id, allow_blank: true, message: 'must be unique within its nation if provided' }
   # Slug (from Geopolitocracy) should be unique within its nation. Presence is already validated by Geopolitocracy.
   validates :slug, uniqueness: { scope: :nation_id, message: 'must be unique within its nation' }
 
   index({ slug: 1 }) # For .search; global uniqueness is not required, see the compound index below
   index({ abbr: 1 }, { sparse: true }) # Sparse index as abbr can be nil
   index({ nation_id: 1, name: 1 }, { unique: true }) # Enforce uniqueness of name within nation
-  index({ nation_id: 1, abbr: 1 }, { unique: true, sparse: true }) # Enforce uniqueness of abbr within nation
+  # Partial, not sparse: nation_id is always set, so a sparse compound index
+  # still indexes every abbr-less region and the second one collides.
+  index({ nation_id: 1, abbr: 1 }, { unique: true, partial_filter_expression: { abbr: { '$gt' => '' } } })
   index({ nation_id: 1, slug: 1 }, { unique: true }) # Enforce uniqueness of slug within nation
 
   # Retrieves the phone dialing code for the region.

data/app/views/geopolitical/cities/_city.html.erb

@@ -0,0 +1,6 @@
+<div class="city">
+  <h4><%= link_to city.name, city_path(city) %></h4>
+  <div class="right">
+    <%= link_to t('geopolitical.actions.edit'), edit_city_path(city) %>
+  </div>
+</div>

data/app/views/geopolitical/cities/_form.html.erb

@@ -0,0 +1,42 @@
+<div class="container">
+  <div class="row">
+    <div class="page-header">
+      <h1>
+        <% key = @city.new_record? ? 'new' : 'edit' %>
+        <%= t("geopolitical.forms.#{key}", model: City.model_name.human) %>
+      </h1>
+    </div>
+  </div>
+  <div class="row">
+    <%= form_with model: @city, url: (@city.persisted? ? city_path(@city) : cities_path), html: { class: 'form' } do |f| %>
+      <% if @city.errors.any? %>
+        <ul>
+          <% @city.errors.full_messages.each do |message| %>
+            <li><%= message %></li>
+          <% end %>
+        </ul>
+      <% end %>
+      <div class="form-group">
+        <%= f.label :nation_id %>
+        <%= f.select :nation_id, @nations, include_blank: true %>
+      </div>
+      <div class="form-group">
+        <%= f.label :region_id %>
+        <%= f.select :region_id, @regions, include_blank: true %>
+      </div>
+      <div class="form-group">
+        <%= f.label :name %>
+        <%= f.text_field :name %>
+      </div>
+      <div class="form-group">
+        <%= f.label :slug %>
+        <%= f.text_field :slug %>
+      </div>
+      <div class="form-group">
+        <%= f.label :souls %>
+        <%= f.number_field :souls %>
+      </div>
+      <%= f.submit t('geopolitical.actions.save') %>
+    <% end %>
+  </div>
+</div>

data/app/views/geopolitical/cities/edit.html.erb

@@ -0,0 +1 @@
+<%= render 'form' %>

data/app/views/geopolitical/cities/index.html.erb

@@ -0,0 +1,46 @@
+<div class="container">
+  <div class="row">
+    <div class="page-header">
+      <h1 class="title"><%= City.model_name.human(count: 2) %></h1>
+      <%= link_to t('geopolitical.actions.new', model: City.model_name.human), new_city_path %>
+    </div>
+  </div>
+  <div class="row">
+    <div class="content">
+      <table class="table">
+        <thead>
+          <tr>
+            <th><%= City.human_attribute_name(:name) %></th>
+            <th><%= City.human_attribute_name(:postal) %></th>
+            <th><%= City.human_attribute_name(:region_id) %></th>
+            <th><%= City.human_attribute_name(:nation_id) %></th>
+            <th><%= City.human_attribute_name(:souls) %></th>
+            <th></th>
+          </tr>
+        </thead>
+        <tbody>
+          <% @cities.each do |city| %>
+            <tr>
+              <td>
+                <%= city.name %>
+                <%= link_to city.slug, city_path(city) %>
+              </td>
+              <td><%= city.postal %></td>
+              <td><%= city.region&.name %></td>
+              <td><%= city.nation&.name %></td>
+              <td><%= city.souls %></td>
+              <td align="right">
+                <%= link_to t('geopolitical.actions.edit'), edit_city_path(city) %>
+                <%= button_to t('geopolitical.actions.destroy'), city_path(city), method: :delete,
+                  data: { turbo_confirm: t('geopolitical.actions.confirm_destroy', model: City.model_name.human) } %>
+              </td>
+            </tr>
+          <% end %>
+        </tbody>
+      </table>
+    </div>
+  </div>
+  <div class="row">
+    <%= link_to t('geopolitical.actions.back'), root_path %>
+  </div>
+</div>

data/app/views/geopolitical/cities/new.html.erb

@@ -0,0 +1 @@
+<%= render 'form' %>

data/app/views/geopolitical/cities/show.html.erb

@@ -0,0 +1,24 @@
+<div class="container">
+  <div class="row">
+    <h1><%= @city.name %></h1>
+  </div>
+  <div class="row">
+    <p>
+      <b><%= City.human_attribute_name(:slug) %>:</b>
+      <%= @city.slug %>
+    </p>
+    <p>
+      <b><%= City.human_attribute_name(:nation_id) %>:</b>
+      <%= link_to @city.nation, nation_path(@city.nation) if @city.nation %>
+    </p>
+    <p>
+      <b><%= City.human_attribute_name(:region_id) %>:</b>
+      <%= link_to @city.region, region_path(@city.region) if @city.region %>
+    </p>
+  </div>
+  <div class="row">
+    <%= link_to t('geopolitical.actions.edit'), edit_city_path(@city) %>
+    |
+    <%= link_to t('geopolitical.actions.back'), cities_path %>
+  </div>
+</div>

data/app/views/geopolitical/geopolitical/edit.html.erb

@@ -0,0 +1 @@
+<%= render "form" %>

data/app/views/geopolitical/geopolitical/index.html.erb

@@ -0,0 +1,24 @@
+<h1><%= t('geopolitical.title') %></h1>
+<hr>
+
+<% [Nation, Region, City, Hood].each do |klass| %>
+  <div class="block">
+    <h3 class="title">
+      <%= link_to klass.model_name.human(count: 2), send("#{klass.to_s.downcase.pluralize}_path") %>
+      <small><%= klass.count %></small>
+    </h3>
+    <div class="right links">
+      <%= link_to t('geopolitical.actions.new', model: klass.model_name.human),
+        send("new_#{klass.to_s.downcase}_path") %>
+    </div>
+  </div>
+<% end %>
+
+<br>
+<h4>
+  <%= t('geopolitical.dashboard.populate') %>
+  <small><%= link_to 'geonames_local', 'https://github.com/nofxx/geonames_local' %></small>
+</h4>
+
+<hr>
+<p><%= link_to 'fireho/geopolitical', 'https://github.com/fireho/geopolitical' %></p>

data/app/views/geopolitical/geopolitical/new.html.erb

@@ -0,0 +1 @@
+<%= render "form" %>

data/app/views/geopolitical/hoods/_city.html.erb

@@ -0,0 +1,6 @@
+<div class="hood">
+  <h4><%= link_to hood.name, hood_path(hood) %></h4>
+  <div class="right">
+    <%= link_to t('geopolitical.actions.edit'), edit_hood_path(hood) %>
+  </div>
+</div>

data/app/views/geopolitical/hoods/_form.html.erb

@@ -0,0 +1,40 @@
+<div class="container">
+  <div class="row">
+    <div class="page-header">
+      <h1>
+        <% key = @hood.new_record? ? 'new' : 'edit' %>
+        <%= t("geopolitical.forms.#{key}", model: Hood.model_name.human) %>
+      </h1>
+    </div>
+  </div>
+  <div class="row">
+    <div class="content">
+      <%= form_with model: @hood, url: (@hood.persisted? ? hood_path(@hood) : hoods_path), html: { class: 'form' } do |f| %>
+        <% if @hood.errors.any? %>
+          <ul>
+            <% @hood.errors.full_messages.each do |message| %>
+              <li><%= message %></li>
+            <% end %>
+          </ul>
+        <% end %>
+        <div class="form-group">
+          <%= f.label :city_id %>
+          <%= f.select :city_id, @cities, include_blank: true %>
+        </div>
+        <div class="form-group">
+          <%= f.label :name %>
+          <%= f.text_field :name %>
+        </div>
+        <div class="form-group">
+          <%= f.label :slug %>
+          <%= f.text_field :slug %>
+        </div>
+        <div class="form-group">
+          <%= f.label :souls %>
+          <%= f.number_field :souls %>
+        </div>
+        <%= f.submit t('geopolitical.actions.save') %>
+      <% end %>
+    </div>
+  </div>
+</div>

data/app/views/geopolitical/hoods/edit.html.erb

@@ -0,0 +1 @@
+<%= render 'form' %>