jma_code 0.0.1 → 0.0.4

data/lib/jma_code/area_forecast_local.rb

@@ -3,50 +3,199 @@ module JMACode
   using Blank
 
   class AreaForecastLocal < Struct.new(
-    :code, :name, :name_phonetic, :used_by,
+    :code, :name, :name_phonetic, 
+    :belonging_local_code_in_weather_alert, 
+    :belonging_local_code_in_tornado_alert, 
+    :used_by,
     keyword_init: true
   )
+    CSV_ROW_SEP = "\r\n"
+    NUM_HEADER_ROWS = 4
     HEADERS = %i(
       code
       name
       name_phonetic
+      used_by_area_forecast_type3_in_weather_alert
+      used_by_area_forecast_type2_in_weather_alert
+      used_by_area_forecast_type1_in_weather_alert
+      used_by_weather_forecast
+      used_by_weather_description
+      used_by_next_weather_forecast
+      used_by_landslide_alert
+      used_by_area_forecast_type3_in_tornado_alert
+      used_by_area_forecast_type2_in_tornado_alert
+      used_by_area_forecast_type1_in_tornado_alert
+      used_by_recorded_heavy_rain_alert
+      used_by_flood_alert
+      used_by_area_forecast_type3_in_typhoon_probability
+      used_by_area_forecast_type1_in_typhoon_probability
+      belonging_local_code_in_weather_alert
+      belonging_local_code_in_tornado_alert
     )
 
     class << self
-      attr_accessor :area_information_cities
+      attr_accessor :data
 
-      def load_20240216(&block)
-        path = File.join(File.dirname(__FILE__), "../../data/20240216_AreaInformationCity-AreaForecastLocalM/AreaForecastLocalM（コード表）.csv")
+      def load_csv(version: "20240216-completed")
+        path = File.join(File.dirname(__FILE__), "../../data/#{version}_AreaInformationCity-AreaForecastLocalM/AreaForecastLocalM（コード表）.csv")
         File.open(path) do |f|
-          csv = CSV.new(f, headers: HEADERS, row_sep: "\r\n")
-          if block_given?
-            yield(csv)
-          else
-            load(csv, num_headers: 3, &block)
+          csv = CSV.new(f, headers: HEADERS, row_sep: CSV_ROW_SEP)
+          yield(csv)
+        end
+      end
+
+      def load(**args)
+        load_csv(**args) do |csv|
+          csv.drop(NUM_HEADER_ROWS).map do |row|
+            build_by_csv_row(row)
           end
         end
       end
 
-      def load(csv, num_headers: 3)
-        list = []
-        csv.each.with_index do |row, i|
-          next if i < num_headers
-          list << build_by_csv_row(row)
+      def get
+        @data ||= load
+      end
+
+      def load_relation(version: "20240216")
+        headers = %i(code_type3 name_type3 code_type2 name_type2 code_type1 name_type1)
+        
+        path1 = File.join(File.dirname(__FILE__), "../../data/#{version}_AreaInformationCity-AreaForecastLocalM/AreaForecastLocalM（関係表　警報・注意報.csv")
+        relation1 = File.open(path1) do |f|
+          csv = CSV.new(f, headers: headers, row_sep: CSV_ROW_SEP)
+          csv.drop(3).map do |row|
+            [row[:code_type3], row[:code_type2], row[:code_type1]]
+          end
         end
-        list
+
+        path2 = File.join(File.dirname(__FILE__), "../../data/#{version}_AreaInformationCity-AreaForecastLocalM/AreaForecastLocalM（関係表　竜巻注意情報.csv")
+        relation2 = File.open(path2) do |f|
+          csv = CSV.new(f, headers: headers, row_sep: CSV_ROW_SEP)
+          csv.drop(3).map do |row|
+            [row[:code_type3], row[:code_type2], row[:code_type1]]
+          end
+        end
+
+        Struct.new(:relation_weather_alert, :relation_tornado_alert, keyword_init: true).new({
+          relation_weather_alert: relation1, relation_tornado_alert: relation2
+        })
       end
 
       def build_by_csv_row(row)
+        used_by_fields = HEADERS.select{|n| n.to_s.start_with?('used_by_')}
+
         new(
           code: row[:code], 
           name: row[:name], 
           name_phonetic: row[:name_phonetic],
+          belonging_local_code_in_weather_alert: row[:belonging_local_code_in_weather_alert],
+          belonging_local_code_in_tornado_alert: row[:belonging_local_code_in_tornado_alert],
+          used_by: used_by_fields.select{|f| row[f] == '1'}.map{|f| f.to_s.sub(/\Aused_by_/, '').to_sym}
         )
       end
+
+      def build_tree(areas=nil, cities=nil)
+        areas ||= get
+        cities ||= JMACode::AreaInformationCity.get
+
+        toplevels, areas = areas.partition{|a| a.any_belonging_locals.blank?}
+        pref_areas = areas.group_by(&:prefecture_code)
+        pref_cities = cities.group_by(&:prefecture_code)
+        toplevels.group_by(&:prefecture).map{|pref, pref_toplevels|
+          current_areas = pref_areas[pref.code]
+          current_cities = pref_cities[pref.code]
+
+          [
+            block_given? ? yield(pref) : pref, 
+            pref_toplevels.map{|t|
+              secondlevels = (current_areas+current_cities).select{|a| a.child_of?(t)}
+              secondlevels_children = secondlevels.map{|s|
+                thirdlevels = (current_areas+current_cities).select{|a| a.child_of?(s)}
+                thirdlevels_children = thirdlevels.map{|th| 
+                  forthlevels = current_cities.select{|c| c.child_of?(th)}
+                  [
+                    block_given? ? yield(th) : th, 
+                    forthlevels.map{|f|
+                      [block_given? ? yield(f) : f, nil]
+                    }
+                  ]
+                }
+                [
+                  block_given? ? yield(s) : s,
+                  thirdlevels_children
+                ]
+              }
+              [
+                block_given? ? yield(t) : t,
+                secondlevels_children
+              ]
+            }
+          ]
+
+        }
+      end
+
+      def walk_tree(tree, &block)
+        tree.map do |area, children|
+          a = block.call(area)
+          c = if children.is_a?(Array) and children.present?
+            walk_tree(children, &block)
+          else
+            children
+          end
+          [a, c]
+        end
+      end
+    end
+
+    def prefecture_code
+      @prefecture_code ||= code[0, 2]
+    end
+
+    def prefecture
+      @prefecture ||= Prefecture.get.find{|pref| pref.code == prefecture_code}
+    end
+
+    def area_information_cities
+      @area_information_cities ||= AreaInformationCity.get.select{|x| x.area_forecast_local_code == code}
+    end
+
+    def belonging_local_in_weather_alert
+      return nil if belonging_local_code_in_weather_alert.blank?
+      @belonging_local_in_weather_alert ||= begin
+        AreaForecastLocal.get.find{|a| a.code == belonging_local_code_in_weather_alert}
+      end
     end
 
-    def area_information_city
-      @area_information_city ||= (self.class.area_information_cities || []).find{|x| x.area_forecast_local_code == code}
+    def belonging_local_in_tornado_alert
+      return nil if belonging_local_code_in_tornado_alert.blank?
+      @belonging_local_in_tornado_alert ||= begin
+        AreaForecastLocal.get.find{|a| a.code == belonging_local_code_in_tornado_alert}
+      end
+    end
+
+    def any_belonging_locals
+      @any_belonging_locals ||= [belonging_local_in_weather_alert, belonging_local_in_tornado_alert].compact.uniq(&:code)
+    end
+
+    def any_ancestry_locals
+      @any_ancestry_locals ||= [
+        belonging_local_in_weather_alert, 
+        belonging_local_in_tornado_alert, 
+        belonging_local_in_weather_alert&.belonging_local_in_weather_alert, 
+        belonging_local_in_tornado_alert&.belonging_local_in_tornado_alert, 
+      ].compact.uniq(&:code)
+    end
+
+    def child_of?(area_or_city)
+      any_belonging_locals.map(&:code).include?(area_or_city.code)
+    end
+
+    def to_csv_row
+      HEADERS.map do |k|
+        respond_to?(k) ?
+          public_send(k) :
+          nil
+      end
     end
   end
 end

data/lib/jma_code/area_information_city.rb

@@ -3,54 +3,55 @@ module JMACode
   using Blank
 
   class AreaInformationCity < Struct.new(
-    :code, :name, :alt_name, :alt_name_phonetic,
+    :code, :long_name, :alt_name, :alt_name_phonetic,
     :area_forecast_local_code, :used_by,
     keyword_init: true
   )
+    CSV_ROW_SEP = "\r\n"
+    NUM_HEADER_ROWS = 3
     HEADERS = %i(
       code
-      name
+      long_name
       name_used_by_weather
       name_phonetic_used_by_weather
       area_forecast_local_code
-      used_by_weather_alert
-      used_by_tornado_alert
-      used_by_long_surge_alert
-      used_by_short_surge_alert
-      used_by_landslide_alert
-      used_by_flood_alert
+      used_by_weather
+      used_by_tornado
+      used_by_storm_surge
+      used_by_high_wave
+      used_by_landslide
+      used_by_flood
       name_used_by_earthquake
       name_phonetic_used_by_earthquake
       name_used_by_volcano
       name_phonetic_used_by_volcano
       name_used_by_uv
       name_phonetic_used_by_uv
-      name_used_by_rainstorm_alert
-      name_phonetic_used_by_rainstorm_alert
+      name_used_by_rainstorm
+      name_phonetic_used_by_rainstorm
     )
 
     class << self
-      attr_accessor :area_forecast_locals
+      attr_accessor :data
 
-      def load_20240216(&block)
-        path = File.join(File.dirname(__FILE__), "../../data/20240216_AreaInformationCity-AreaForecastLocalM/AreaInformationCity.csv")
+      def load_csv(version: "20240216")
+        path = File.join(File.dirname(__FILE__), "../../data/#{version}_AreaInformationCity-AreaForecastLocalM/AreaInformationCity.csv")
         File.open(path) do |f|
-          csv = CSV.new(f, headers: HEADERS, row_sep: "\r\n")
-          if block_given?
-            yield(csv)
-          else
-            load(csv, num_headers: 3, &block)
-          end
+          csv = CSV.new(f, headers: HEADERS, row_sep: CSV_ROW_SEP)
+          yield(csv)
         end
       end
 
-      def load(csv, num_headers: 3)
-        list = []
-        csv.each.with_index do |row, i|
-          next if i < num_headers
-          list << build_by_csv_row(row)
+      def load(**args)
+        load_csv(**args) do |csv|
+          csv.drop(NUM_HEADER_ROWS).map do |row|
+            build_by_csv_row(row)
+          end
         end
-        list
+      end
+
+      def get
+        @data ||= load
       end
 
       def build_by_csv_row(row)
@@ -62,36 +63,62 @@ module JMACode
           [row[:name_used_by_volcano], row[:name_phonetic_used_by_volcano]]
         elsif row[:name_used_by_uv].present?
           [row[:name_used_by_uv], row[:name_phonetic_used_by_uv]]
-        elsif row[:name_used_by_rainstorm_alert].present?
-          [row[:name_used_by_rainstorm_alert], row[:name_phonetic_used_by_rainstorm_alert]]
+        elsif row[:name_used_by_rainstorm].present?
+          [row[:name_used_by_rainstorm], row[:name_phonetic_used_by_rainstorm]]
         else
           []
         end
 
         new(
           code: row[:code], 
-          name: row[:name], 
+          long_name: row[:long_name], 
           alt_name: alt_name,
           alt_name_phonetic: alt_name_phonetic,
           area_forecast_local_code: row[:area_forecast_local_code],
           used_by: [
-            row[:used_by_weather_alert] == '1' ? :weather_alert : nil,
-            row[:used_by_tornado_alert] == '1' ? :tornado_alert : nil,
-            row[:used_by_long_surge_alert] == '1' ? :long_surge_alert : nil,
-            row[:used_by_short_surge_alert] == '1' ? :short_surge_alert : nil,
-            row[:used_by_landslide_alert] == '1' ? :landslide_alert : nil,
-            row[:used_by_flood_alert] == '1' ? :flood_alert : nil,
+            row[:used_by_weather] == '1' ? :weather : nil,
+            row[:used_by_tornado] == '1' ? :tornado : nil,
+            row[:used_by_storm_surge] == '1' ? :storm_surge : nil,
+            row[:used_by_high_wave] == '1' ? :high_wave : nil,
+            row[:used_by_landslide] == '1' ? :landslide : nil,
+            row[:used_by_flood] == '1' ? :flood : nil,
             row[:name_used_by_earthquake].present? ? :earthquake : nil,
             row[:name_used_by_volcano].present? ? :volcano : nil,
             row[:name_used_by_uv].present? ? :uv : nil,
-            row[:name_used_by_rainstorm_alert].present? ? :rainstorm_alert : nil,
+            row[:name_used_by_rainstorm].present? ? :rainstorm : nil,
           ].compact
         )
       end
     end
 
+    def name
+      alt_name.presence || long_name
+    end
+
+    def name_phonetic
+      alt_name_phonetic
+    end
+
+    def prefecture_code
+      @prefecture_code ||= code[0, 2]
+    end
+
     def area_forecast_local
-      @area_forecast_local ||= (self.class.area_forecast_locals || []).find{|x| x.code == area_forecast_local_code}
+      @area_forecast_local ||= AreaForecastLocal.get.find{|x| x.code == area_forecast_local_code}
+    end
+
+    def child_of?(area_or_city)
+      area_forecast_local_code == area_or_city.code
+    end
+
+    def to_h
+      {
+        code: code,
+        name: name,
+        name_phonetic: name_phonetic,
+        area_forecast_local_code: area_forecast_local_code,
+        used_by: used_by,
+      }
     end
   end
 end

data/lib/jma_code/area_river.rb

@@ -0,0 +1,75 @@
+require "csv"
+
+module JMACode
+  class AreaRiver < Struct.new(
+    :code, :name, :name_phonetic,
+    :name2, :name_phonetic2, :name3, :name_phonetic3,
+    :prefecture_codes,
+    keyword_init: true
+  )
+    CSV_ROW_SEP = "\r\n"
+    HEADERS = %i(code name name_phonetic name2 name_phonetic2 name3 name_phonetic3 prefecture_codes)
+    NUM_HEADER_ROWS = 3
+    PREFECTURE_CODE_SEPARATOR = '/'
+
+    class << self
+      attr_accessor :data
+
+      def load_csv(version: "20230105-completed")
+        path = File.join(File.dirname(__FILE__), "../../data/#{version}_AreaRiver.csv")
+        File.open(path) do |f|
+          csv = CSV.new(f, headers: HEADERS, row_sep: CSV_ROW_SEP)
+          yield(csv)
+        end
+      end
+
+      def load(**args)
+        load_csv(**args) do |csv|
+          csv.drop(NUM_HEADER_ROWS).map do |row|
+            new(
+              code: row[:code], 
+              name: row[:name], 
+              name_phonetic: row[:name_phonetic],
+              name2: row[:name2], 
+              name_phonetic2: row[:name_phonetic2],
+              name3: row[:name3], 
+              name_phonetic3: row[:name_phonetic3],
+              prefecture_codes: row[:prefecture_codes]
+            )
+          end
+        end
+      end
+
+      def get
+        @data ||= load
+      end
+    end
+
+    def prefecture_code_list
+      @prefecture_code_list ||= (prefecture_codes || "").split(PREFECTURE_CODE_SEPARATOR)
+    end
+
+    def add_prefecture_code(pref_code)
+      ids = (prefecture_code_list + [pref_code]).sort.uniq
+      self.prefecture_codes = ids.join(PREFECTURE_CODE_SEPARATOR)
+    end
+
+    def prefectures
+      @prefectures ||= Prefecture.get.select{|pref|
+        prefecture_code_list.include?(pref.code)
+      }
+    end
+
+    def water_level_stations
+      @water_level_stations ||= WaterLevelStation.get.select{|w| w.river_code == code}
+    end
+
+    def to_csv_row
+      HEADERS.map do |k|
+        respond_to?(k) ?
+          public_send(k) :
+          nil
+      end
+    end
+  end
+end

data/lib/jma_code/entity/area_forecast_type.rb

@@ -0,0 +1,16 @@
+class JMACode::AreaForecastType < Struct.new(:slug, :name, keyword_init: true)
+  LIST = {
+    type1: {name: "府県予報区等"},
+    type2: {name: "一次細分区域等"},
+    type3: {name: "市町村等をまとめた地域等"},
+    type4: {name: "市町村等"},
+  }
+
+  def self.load
+    LIST.map{|k,v| new(v.merge(slug: k.to_s))}
+  end
+
+  def self.get
+    @data ||= load
+  end
+end

data/lib/jma_code/prefecture.rb

@@ -0,0 +1,83 @@
+module JMACode
+  class Prefecture < Struct.new(
+    :id, :code, :name, :short_name, :slug, 
+    keyword_init: true
+  )
+    DATA = [
+      [1, '北海道', '北海道', 'hokkaido'],
+      [2, '青森県', '青森', 'aomori'],
+      [3, '岩手県', '岩手', 'iwate'],
+      [4, '宮城県', '宮城', 'miyagi'],
+      [5, '秋田県', '秋田', 'akita'],
+      [6, '山形県', '山形', 'yamagata'],
+      [7, '福島県', '福島', 'fukushima'],
+      [8, '茨城県', '茨城', 'ibaraki'],
+      [9, '栃木県', '栃木', 'tochigi'],
+      [10, '群馬県', '群馬', 'gunma'],
+      [11, '埼玉県', '埼玉', 'saitama'],
+      [12, '千葉県', '千葉', 'chiba'],
+      [13, '東京都', '東京', 'tokyo'],
+      [14, '神奈川県', '神奈川', 'kanagawa'],
+      [15, '新潟県', '新潟', 'niigata'],
+      [16, '富山県', '富山', 'toyama'],
+      [17, '石川県', '石川', 'ishikawa'],
+      [18, '福井県', '福井', 'fukui'],
+      [19, '山梨県', '山梨', 'yamanashi'],
+      [20, '長野県', '長野', 'nagano'],
+      [21, '岐阜県', '岐阜', 'gifu'],
+      [22, '静岡県', '静岡', 'shizuoka'],
+      [23, '愛知県', '愛知', 'aichi'],
+      [24, '三重県', '三重', 'mie'],
+      [25, '滋賀県', '滋賀', 'shiga'],
+      [26, '京都府', '京都', 'kyoto'],
+      [27, '大阪府', '大阪', 'osaka'],
+      [28, '兵庫県', '兵庫', 'hyogo'],
+      [29, '奈良県', '奈良', 'nara'],
+      [30, '和歌山県', '和歌山', 'wakayama'],
+      [31, '鳥取県', '鳥取', 'tottori'],
+      [32, '島根県', '島根', 'shimane'],
+      [33, '岡山県', '岡山', 'okayama'],
+      [34, '広島県', '広島', 'hiroshima'],
+      [35, '山口県', '山口', 'yamaguchi'],
+      [36, '徳島県', '徳島', 'tokushima'],
+      [37, '香川県', '香川', 'kagawa'],
+      [38, '愛媛県', '愛媛', 'ehime'],
+      [39, '高知県', '高知', 'kochi'],
+      [40, '福岡県', '福岡', 'fukuoka'],
+      [41, '佐賀県', '佐賀', 'saga'],
+      [42, '長崎県', '長崎', 'nagasaki'],
+      [43, '熊本県', '熊本', 'kumamoto'],
+      [44, '大分県', '大分', 'oita'],
+      [45, '宮崎県', '宮崎', 'miyazaki'],
+      [46, '鹿児島県', '鹿児島', 'kagoshima'],
+      [47, '沖縄県', '沖縄', 'okinawa'],
+    ]
+
+    class << self
+      attr_accessor :data
+      
+      def load
+        DATA.map do |id, name, short_name, slug|
+          new(
+            id: id, 
+            code: id.to_s.rjust(2, '0'),
+            name: name, 
+            short_name: short_name, 
+            slug: slug
+          )
+        end
+      end
+
+      def get
+        @data ||= load
+      end
+    end
+
+    def type
+      @type ||= begin
+        res = name.sub(short_name, '')
+        res.empty? ? '道' : res
+      end
+    end
+  end
+end

data/lib/jma_code/version.rb

@@ -1,3 +1,3 @@
 module JMACode
-  VERSION = "0.0.1"
+  VERSION = "0.0.4"
 end

data/lib/jma_code/water_level_station.rb

@@ -7,38 +7,44 @@ module JMACode
     :code, :name, :river_name,
     keyword_init: true
   )
-    HEADERS = %i(
-      code 
-      name 
-      river_name
-    )
+    CSV_ROW_SEP = "\r\n"
+    HEADERS = %i(code name river_name)
+    NUM_HEADER_ROWS = 3
 
     class << self
-      def load_20240418(&block)
-        path = File.join(File.dirname(__FILE__), "../../data/20240418_WaterLevelStation.csv")
+      attr_accessor :data
+
+      def load_csv(version: "20240418")
+        path = File.join(File.dirname(__FILE__), "../../data/#{version}_WaterLevelStation.csv")
         File.open(path) do |f|
-          csv = CSV.new(f, headers: HEADERS, row_sep: "\r\n")
-          if block_given?
-            yield(csv)
-          else
-            load(csv, num_headers: 3, &block)
-          end
+          csv = CSV.new(f, headers: HEADERS, row_sep: CSV_ROW_SEP)
+          yield(csv)
         end
       end
 
-      def load(csv, num_headers: 3)
-        csv.drop(num_headers).map do |row|
-          build_by_csv_row(row)
+      def load(**args)
+        load_csv(**args) do |csv|
+          csv.drop(NUM_HEADER_ROWS).map do |row|
+            new(
+              code: row[:code], 
+              name: row[:name], 
+              river_name: row[:river_name],
+            )
+          end
         end
       end
 
-      def build_by_csv_row(row)
-        new(
-          code: row[:code], 
-          name: row[:name], 
-          river_name: row[:river_name],
-        )
+      def get
+        @data ||= load
       end
     end
+
+    def river_code
+      code[0..9]
+    end
+
+    def river
+      @river ||= AreaRiver.get.find{|r| r.code == river_code}
+    end
   end
 end

data/lib/jma_code.rb

@@ -1,5 +1,6 @@
 require "jma_code/version"
 require "jma_code/ext/blank"
+require "jma_code/prefecture"
 require "jma_code/wmo_observing_station"
 require "jma_code/water_level_station"
 require "jma_code/river_office"
@@ -8,6 +9,7 @@ require "jma_code/area_flood_forecast"
 require "jma_code/area_information_city"
 require "jma_code/area_forecast_local"
 require "jma_code/area_marine"
+require "jma_code/area_river"
 
 module JMACode
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jma_code
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.4
 platform: ruby
 authors:
 - metheglin
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-27 00:00:00.000000000 Z
+date: 2024-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -34,6 +34,10 @@ files:
 - data/20130523_AreaMarineAJ/AreaMarineA.csv
 - data/20130523_AreaMarineAJ/AreaMarineJ.csv
 - data/20201026_WmoObservingStations.csv
+- data/20230105-completed_AreaRiver.csv
+- data/20230105_AreaFloodForecast.csv
+- data/20230105_AreaRiver.csv
+- data/20240216-completed_AreaInformationCity-AreaForecastLocalM/AreaForecastLocalM（コード表）.csv
 - data/20240216_AreaInformationCity-AreaForecastLocalM/AreaForecastLocalM（コード表）.csv
 - data/20240216_AreaInformationCity-AreaForecastLocalM/AreaForecastLocalM（関係表　竜巻注意情報.csv
 - data/20240216_AreaInformationCity-AreaForecastLocalM/AreaForecastLocalM（関係表　警報・注意報.csv
@@ -68,8 +72,11 @@ files:
 - lib/jma_code/area_forecast_local.rb
 - lib/jma_code/area_information_city.rb
 - lib/jma_code/area_marine.rb
+- lib/jma_code/area_river.rb
+- lib/jma_code/entity/area_forecast_type.rb
 - lib/jma_code/ext/blank.rb
 - lib/jma_code/point_amedas.rb
+- lib/jma_code/prefecture.rb
 - lib/jma_code/river_office.rb
 - lib/jma_code/version.rb
 - lib/jma_code/water_level_station.rb