geopolitical 3.2.1 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29f0c0d286b916e4998c96f873a2ca71309cebdb24b5237d0d2a9983fb6a0b78
-  data.tar.gz: dc3f5db9a230f9ce51716fd93d41b47f36435bc8a319028399d9980dacd74616
+  metadata.gz: bfe29900897a18f20389e3bcc7107c7934acf4a482594d62cd203d16218baacf
+  data.tar.gz: 7502b7cb5e3b66461e849cbb4eac85ac20e05e7e4c77f05d30067363dd99670c
 SHA512:
-  metadata.gz: 5d5bf693346187061b119960d60de605a1eca32b8a56fd29d9b18273292d826c99b8c06d778b070db3a6dcbc0966263626aa5cfe64de35cee09f0573438a58ed
-  data.tar.gz: 547960a20a10bdba9e01af25e1ed8c9809c2a7f5e25330ff3cea774fc051a2f00380dc574eaff71ad4fde17b95a4a70f6f1be4203e33069f93e6c366da3d578d
+  metadata.gz: 7d878011e11bc16a92e2709938930d3a52bb6acabd4735ddcd393c150cd8c179b594cc0b497db50f37d556414f77f59ee235db6e519e41c3fb6aab6bf1c9f689
+  data.tar.gz: b6fa32e93cd018cf6487c5930b3e22dcd9ca4eb6c89a5c970c8824f56cb3050c55370c7eb3950d07027166f39c6b958440a32950497ea4b6629d008d582a209f

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # 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:

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.
@@ -62,10 +61,9 @@ class City
   index({ slug: 1 }, unique: true)
   index({ name: 1, nation_id: 1 }) # For lookups by name within 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({ 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/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/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' %>

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

@@ -0,0 +1,42 @@
+<div class="container">
+  <div class="row">
+    <div class="page-header">
+      <h1 class="title"><%= Hood.model_name.human(count: 2) %></h1>
+      <%= link_to t('geopolitical.actions.new', model: Hood.model_name.human), new_hood_path %>
+    </div>
+  </div>
+  <div class="row">
+    <div class="content">
+      <table class="table">
+        <thead>
+          <tr>
+            <th><%= Hood.human_attribute_name(:name) %></th>
+            <th><%= Hood.human_attribute_name(:city_id) %></th>
+            <th><%= Hood.human_attribute_name(:souls) %></th>
+            <th></th>
+          </tr>
+        </thead>
+        <tbody>
+          <% @hoods.each do |hood| %>
+            <tr>
+              <td>
+                <%= hood.name %>
+                <%= link_to hood.slug, hood_path(hood) %>
+              </td>
+              <td><%= hood.city&.name %></td>
+              <td><%= hood.souls %></td>
+              <td align="right">
+                <%= link_to t('geopolitical.actions.edit'), edit_hood_path(hood) %>
+                <%= button_to t('geopolitical.actions.destroy'), hood_path(hood), method: :delete,
+                  data: { turbo_confirm: t('geopolitical.actions.confirm_destroy', model: Hood.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/hoods/new.html.erb

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

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

@@ -0,0 +1,20 @@
+<div class="container">
+  <div class="row">
+    <h1><%= @hood.name %></h1>
+  </div>
+  <div class="row">
+    <p>
+      <b><%= Hood.human_attribute_name(:slug) %>:</b>
+      <%= @hood.slug %>
+    </p>
+    <p>
+      <b><%= Hood.human_attribute_name(:city_id) %>:</b>
+      <%= link_to @hood.city, city_path(@hood.city) if @hood.city %>
+    </p>
+  </div>
+  <div class="row">
+    <%= link_to t('geopolitical.actions.edit'), edit_hood_path(@hood) %>
+    |
+    <%= link_to t('geopolitical.actions.back'), hoods_path %>
+  </div>
+</div>