jma_feed 0.0.2 → 0.0.6

data/lib/jma_feed/report_entry/jmx/visibility.rb

@@ -0,0 +1,20 @@
+class JMAFeed::JMX::Visibility < Giri::TextNodeInteger
+  xml_attribute :type
+  xml_attribute :unit
+  xml_attribute :ref_id, with_name: "refID"
+  xml_attribute :condition
+  xml_attribute :description
+
+  def time_define
+    (context.time_define_list || []).find{ref_id && ref_id == _1.time_id}
+  end
+
+  def metrics_item
+    @metrics_item ||= JMAFeed::WeatherAlert::MetricsItem.new(
+      name: type,
+      value: self,
+      description: description,
+      time_define: time_define,
+    )
+  end
+end

data/lib/jma_feed/report_entry/jmx/water_level.rb

@@ -4,4 +4,8 @@ class JMAFeed::JMX::WaterLevel < Giri::TextNodeBigDecimal
   xml_attribute :ref_id, with_name: "refID"
   xml_attribute :condition
   xml_attribute :description
+
+  def time_define
+    (context.time_define_list || []).find{ref_id && ref_id == _1.time_id}
+  end
 end

data/lib/jma_feed/report_entry/jmx/wave_height.rb

@@ -0,0 +1,20 @@
+class JMAFeed::JMX::WaveHeight < Giri::TextNodeBigDecimal
+  xml_attribute :type
+  xml_attribute :unit
+  xml_attribute :ref_id, with_name: "refID"
+  # xml_attribute :condition
+  xml_attribute :description
+
+  def time_define
+    (context.time_define_list || []).find{ref_id && ref_id == _1.time_id}
+  end
+
+  def metrics_item
+    @metrics_item ||= JMAFeed::WeatherAlert::MetricsItem.new(
+      name: type,
+      value: self,
+      description: description,
+      time_define: time_define,
+    )
+  end
+end

data/lib/jma_feed/report_entry/jmx/wind_direction.rb

@@ -0,0 +1,20 @@
+class JMAFeed::JMX::WindDirection < Giri::TextNodeString
+  xml_attribute :type
+  xml_attribute :unit
+  xml_attribute :ref_id, with_name: "refID"
+  xml_attribute :condition
+  xml_attribute :description
+
+  def time_define
+    (context.time_define_list || []).find{ref_id && ref_id == _1.time_id}
+  end
+
+  def metrics_item
+    @metrics_item ||= JMAFeed::WeatherAlert::MetricsItem.new(
+      name: type,
+      value: self,
+      description: description,
+      time_define: time_define,
+    )
+  end
+end

data/lib/jma_feed/report_entry/jmx/wind_speed.rb

@@ -0,0 +1,20 @@
+class JMAFeed::JMX::WindSpeed < Giri::TextNodeInteger
+  xml_attribute :type
+  xml_attribute :unit
+  xml_attribute :ref_id, with_name: "refID"
+  xml_attribute :condition
+  xml_attribute :description
+
+  def time_define
+    (context.time_define_list || []).find{ref_id && ref_id == _1.time_id}
+  end
+
+  def metrics_item
+    @metrics_item ||= JMAFeed::WeatherAlert::MetricsItem.new(
+      name: type,
+      value: self,
+      description: description,
+      time_define: time_define,
+    )
+  end
+end

data/lib/jma_feed/report_entry/vphw50.rb

@@ -22,19 +22,19 @@ class JMAFeed::VPHW50 < JMAFeed::ReportEntry
       end
     end
 
-    def warning_district_report
+    def warning_area_type1
       warning.find{|w| w.type == "竜巻注意情報（発表細分）"}
     end
 
-    def warning_district_1st
+    def warning_area_type2
       warning.find{|w| w.type == "竜巻注意情報（一次細分区域等）"}
     end
 
-    def warning_district_aggregated
+    def warning_area_type3
       warning.find{|w| w.type == "竜巻注意情報（市町村等をまとめた地域等）"}
     end
 
-    def warning_district_2nd
+    def warning_area_type4
       warning.find{|w| w.type == "竜巻注意情報（市町村等）"}
     end
   end

data/lib/jma_feed/report_entry/vprn50.rb

@@ -40,6 +40,7 @@ class JMAFeed::VPRN50 < JMAFeed::ReportEntry
 
   xml_node :body do
     xml_node_collection :meteorological_infos do
+      xml_attribute :type
       xml_node_collection :meteorological_info do
         date_time_node :date_time
         xml_node_collection :item do
@@ -82,19 +83,19 @@ class JMAFeed::VPRN50 < JMAFeed::ReportEntry
       end
     end
 
-    def info_district_forecast
+    def info_area_type1
       meteorological_infos[0].meteorological_info[0]
     end
 
-    def info_district_1st
+    def info_area_type2
       meteorological_infos[1].meteorological_info[0]
     end
 
-    def info_district_aggregated
+    def info_area_type3
       meteorological_infos[2].meteorological_info[0]
     end
 
-    def info_district_2nd
+    def info_area_type4
       meteorological_infos[3].meteorological_info[0]
     end
   end

data/lib/jma_feed/report_entry/vpww54.rb

@@ -11,67 +11,256 @@
 # </MeteorologicalInfos>
 # 
 class JMAFeed::VPWW54 < JMAFeed::ReportEntry
+  class WarningItemKind < Giri::BaseNode
+    text_node :name
+    text_node :code
+    text_node :status
+    text_node :condition
+    xml_node :last_kind do
+      text_node :name
+      text_node :code
+    end
+    xml_node_collection :next_kinds do
+      xml_node :next_kind do
+        text_node :name
+        text_node :code
+        date_time_node :date_time do
+          xml_attribute :precision, type: :duration
+        end
+        text_node :sentence
+      end
+    end
+    xml_node :attention do
+      text_node :note, collection: true
+    end
+    xml_node :addition do
+      text_node :note, collection: true
+    end
+
+    def weather_alert
+      @weather_alert ||= JMAFeed::WeatherAlert.all.find{|a| a.code == code}
+    end
+  end
+
   xml_node :body do
+    text_node :notice, collection: true
     xml_node_collection :warning do
       xml_attribute :type
       xml_node_collection :item do
-        xml_node_collection :kind do
-          text_node :name
-          text_node :code
-          text_node :status
-          text_node :condition
-          xml_node :attention do
-            text_node :note, collection: true
-          end
-          xml_node :addition do
-            text_node :note, collection: true
-          end
-
-          def alert
-            @alert ||= JMAFeed::Alert.all.find{|a| a.code == code}
-          end
-        end
+        xml_node_collection :kind, type: "JMAFeed::VPWW54::WarningItemKind"
         text_node :change_status
         xml_node :area, type: "JMAFeed::JMX::Area"
 
-        JMAFeed::Alert.clusters.each do |cluster,alerts|
+        JMAFeed::WeatherAlert.clusters.each do |cluster,alerts|
           define_method cluster do
             kind.find{|k| alerts.map(&:code).include?(k.code)}
           end
         end
       end
     end
+
     xml_node :meteorological_infos do
       xml_attribute :type
       xml_node :time_series_info do
+        context :time_define_list do
+          time_defines.time_define
+        end
+
         xml_node :time_defines do
-          xml_node_collection :time_define do
-            xml_attribute :time_id, with_name: :lower_camelcase
-            date_time_node :date_time
-            duration_node :duration
-            text_node :name
-          end
+          xml_node_collection :time_define, type: "JMAFeed::JMX::TimeDefine"
         end
         xml_node_collection :item do
-          # TODO
+          xml_node_collection :kind do
+            text_node :name
+            text_node :code
+            text_node :condition
+            xml_node_collection :property do
+              text_node :type
+
+              JMAFeed::WeatherAlert.metrics_components.each do |metr_component|
+                xml_node_collection "#{metr_component[:name]}_part".to_sym do
+                  xml_node :base do
+                    xml_node_collection metr_component[:name], type: "JMAFeed::JMX::#{metr_component[:name].to_s.camelize}"
+
+                    xml_node_collection :local do
+                      text_node :area_name
+                      xml_node_collection metr_component[:name], type: "JMAFeed::JMX::#{metr_component[:name].to_s.camelize}"
+                    end
+                  end
+                end
+              end
+            end
+
+            def weather_alert
+              @weather_alert ||= JMAFeed::WeatherAlert.all.find{|a| a.code == code}
+            end
+
+            # EXAMPLE of data structure
+            # {
+            #   "土砂災害危険度" => {"全体" => [...]},
+            #   "浸水害危険度" => {"全体" => [...]},
+            #   "1時間最大雨量" => {"全体" => [...]},
+            #   "3時間最大雨量" => {"全体" => [...]},
+            # }
+            # or 
+            # {
+            #   "土砂災害危険度" => {"山地" => [...], "平地" => [...]},
+            #   "浸水害危険度" => {"山地" => [...], "平地" => [...]},
+            #   "1時間最大雨量" => {"山地" => [...], "平地" => [...]},
+            #   "3時間最大雨量" => {"山地" => [...], "平地" => [...]},
+            # }
+            def weather_alert_metrics
+              return nil unless weather_alert
+              weather_alert.metrics.map do |k,v|
+                metrics_part = property.find{_1.type == v[:property_type]}&.public_send("#{v[:name]}_part")
+                metrics_bases = metrics_part&.map(&:base)
+                metrics_items = if metrics_bases && metrics_bases.length > 0
+                  primary_base = metrics_bases.first
+                  metrics_bases_area_items = if primary_base.local && primary_base.local.length > 0
+                    metrics_bases.map{|b| 
+                      b.local.map{|l|
+                        [
+                          l.area_name, 
+                          l.public_send(v[:name]).map(&:metrics_item)
+                        ]
+                      }.to_h
+                    }
+                  else
+                    metrics_bases.map{|b|
+                      [
+                        [
+                          "全体", 
+                          b.public_send(v[:name]).map(&:metrics_item)
+                        ]
+                      ].to_h
+                    }
+                  end
+
+                  metrics_bases_area_items.find{|area_items| 
+                    local_area_name, area_metrics_items = area_items.first
+                    area_metrics_items.first.name == k
+                  }
+                else
+                  nil
+                end
+
+                if metrics_items
+                  [k, metrics_items]
+                else
+                  nil
+                end
+              end.compact.to_h
+            end
+          end
+
+          JMAFeed::WeatherAlert.clusters.each do |cluster,alerts|
+            define_method cluster do
+              kind.find{|k| alerts.map(&:code).include?(k.code)}
+            end
+          end
+
+          xml_node :area, type: "JMAFeed::JMX::Area"
         end
       end
     end
 
-    def warning_district_forecast
-      warning[0]
+    def warning_area_type1
+      warning.find{|w| w.type == "気象警報・注意報（府県予報区等）"}
+    end
+
+    def warning_area_type2
+      warning.find{|w| w.type == "気象警報・注意報（一次細分区域等）"}
+    end
+
+    def warning_area_type3
+      warning.find{|w| w.type == "気象警報・注意報（市町村等をまとめた地域等）"}
+    end
+
+    def warning_area_type4
+      warning.find{|w| w.type == "気象警報・注意報（市町村等）"}
+    end
+  end
+
+  def detect_with_area(area, weather_alert_clusters: nil)
+    weather_alert_clusters ||= JMAFeed::WeatherAlert.clusters.keys
+    warning_item = detect_warning_item_with_area(area)
+    return nil unless warning_item
+
+    warning_alerts = weather_alert_clusters.map{|cluster|
+      warning_item.public_send(cluster)
+    }.compact
+
+    info_item = detect_info_item_with_area(area)
+    info_alerts = info_item && weather_alert_clusters.map{|cluster|
+      info_item.public_send(cluster)
+    }.compact
+
+    AreaAlert.new(
+      entry: self, 
+      area: area, 
+      weather_warnings: warning_alerts.map{|w|
+        WeatherWarning.new(w, info: info_alerts&.find{|i| i.code == w.code})
+      }
+    )
+  end
+
+  def detect_warning_item_with_area(area)
+    items = if area.is_a?(JMACode::AreaInformationCity)
+      body.warning_area_type4.item
+    else
+      if area.used_by.include?("area_forecast_type3_in_weather_alert")
+        body.warning_area_type3.item
+      elsif area.used_by.include?("area_forecast_type2_in_weather_alert")
+        body.warning_area_type2.item
+      elsif area.used_by.include?("area_forecast_type1_in_weather_alert")
+        body.warning_area_type1.item
+      else
+        nil
+      end
+    end
+    items&.find{_1.area.code == area.code}
+  end
+
+  def detect_info_item_with_area(area)
+    # NOTE: 当該電文で特別警報・警報・注意報の全てが解除される場合、MeteorologicalInfos 部は省略される。 (気象警報・注意報（Ｈ２７）_解説資料.pdf > 3-3)
+    return nil unless body.meteorological_infos
+
+    if area.is_a?(JMACode::AreaInformationCity)
+      body.meteorological_infos.time_series_info.item.find{_1.area.code == area.code}
+    else
+      nil
+    end
+  end
+
+  class AreaAlert < Struct.new(:entry, :area, :weather_warnings, keyword_init: true)
+  end
+
+  class WeatherWarning < DelegateClass(WarningItemKind)
+    attr_reader :info
+    def initialize(warning, info:)
+      @warning = warning
+      @info = info
+      super(warning)
+    end
+
+    def cluster
+      weather_alert.cluster
+    end
+
+    def risk_level
+      weather_alert.risk_level
     end
 
-    def warning_district_1st
-      warning[1]
+    def attentions
+      attention&.note
     end
 
-    def warning_district_aggregated
-      warning[2]
+    def additions
+      addition&.note
     end
 
-    def warning_district_2nd
-      warning[3]
+    def metrics
+      info&.weather_alert_metrics
     end
   end
 end

data/lib/jma_feed/report_entry/vxse53.rb

@@ -0,0 +1,135 @@
+# 地震情報（震源・震度に関する情報）
+# https://xml.kishou.go.jp/tec_material.html
+# 電文毎の解説資料 > 解説資料セットzip > 地震火山関連_解説資料.pdf > (ウ)地震情報(震源・震度に関する情報)
+# 
+class JMAFeed::VXSE53 < JMAFeed::ReportEntry
+  xml_node :head do
+    text_node :event_id, with_name: "EventID"
+  end
+
+  xml_node :body do
+    xml_node :earthquake, type: "JMAFeed::JMX::Earthquake"
+
+    xml_node :intensity do
+      xml_node :observation do
+        xml_node :code_define do
+          text_node :type, collection: true do
+            xml_attribute :xpath
+          end
+        end
+
+        text_node :max_int
+
+        xml_node_collection :pref do
+          text_node :name
+          text_node :code
+          xml_node :max_int, type: "JMAFeed::JMX::EarthquakeIntensity"
+          text_node :revise
+          xml_node_collection :area do
+            text_node :name
+            text_node :code
+            xml_node :max_int, type: "JMAFeed::JMX::EarthquakeIntensity"
+            text_node :revise
+            xml_node_collection :city do
+              text_node :name
+              text_node :code
+              xml_node :max_int, type: "JMAFeed::JMX::EarthquakeIntensity"
+              text_node :revise
+              text_node :condition
+              xml_node_collection :intensity_station do
+                text_node :name
+                text_node :code
+                xml_node :int, type: "JMAFeed::JMX::EarthquakeIntensity"
+                text_node :revise
+              end
+            end
+          end
+        end
+      end
+    end
+
+    xml_node :comments do
+      xml_node :forecast_comment do
+        xml_attribute :code_type
+        text_node :text
+        text_node :code
+      end
+      xml_node :var_comment do
+        xml_attribute :code_type
+        text_node :text
+        text_node :code
+      end
+      xml_node :free_form_comment do
+        text_node :text
+      end
+    end
+  end
+
+  def detect_with_area(area)
+    pref = detect_pref_with_area(area)
+    return nil unless pref
+
+    earthquake = body.earthquake
+    comments = [
+      body.comments&.forecast_comment&.text,
+      body.comments&.var_comment&.text,
+      body.comments&.free_form_comment&.text,
+    ].compact
+    if area.is_a?(JMACode::Prefecture)
+      AreaAlert.new(entry: self, area: area, intensity: pref, earthquake: earthquake, comments: comments)
+    else
+      local_area = detect_local_area_with_area(area, pref)
+      if local_area && area.is_a?(JMACode::AreaForecastLocalE)
+        AreaAlert.new(entry: self, area: area, intensity: local_area, earthquake: earthquake, comments: comments)
+      else
+        city = detect_city_with_area(area, local_area)
+        if city && area.is_a?(JMACode::AreaInformationCity)
+          AreaAlert.new(entry: self, area: area, intensity: city, earthquake: earthquake, comments: comments)
+        end
+      end
+    end
+  end
+
+  def detect_pref_with_area(area)
+    intensity = body.intensity
+    return nil unless intensity
+    
+    prefs = intensity.observation.pref
+    pref_code = if area.is_a?(JMACode::Prefecture)
+      area.code
+    elsif area.is_a?(JMACode::AreaForecastLocalE)
+      area.prefecture_code
+    elsif area.is_a?(JMACode::AreaInformationCity)
+      area.prefecture_code
+    else
+      nil
+    end
+
+    prefs.find{|pr| pr.code == pref_code}
+  end
+
+  def detect_local_area_with_area(area, pref_node)
+    area_code = if area.is_a?(JMACode::AreaForecastLocalE)
+      area.code
+    elsif area.is_a?(JMACode::AreaInformationCity)
+      area.area_forecast_local_e_code
+    else
+      nil
+    end
+
+    pref_node.area.find{|ar| ar.code == area_code}
+  end
+
+  def detect_city_with_area(area, local_area_node)
+    city_code = if area.is_a?(JMACode::AreaInformationCity)
+      area.code
+    else
+      nil
+    end
+
+    local_area_node.city.find{|c| c.code == city_code}
+  end
+
+  class AreaAlert < Struct.new(:entry, :area, :intensity, :earthquake, :comments, keyword_init: true)
+  end
+end

data/lib/jma_feed/report_entry.rb

@@ -1,10 +1,13 @@
 require "nokogiri"
-require "giri"
 
-class JMAFeed::ReportEntry < Giri::BaseNode
+class JMAFeed::ReportEntry < JMAFeed::BaseNode
   class << self
     def get(url)
       xml = Net::HTTP.get(URI.parse(url))
+      build(xml)
+    end
+
+    def build(xml)
       doc = Nokogiri::XML(xml)
       new(doc.root)
     end
@@ -25,16 +28,30 @@ class JMAFeed::ReportEntry < Giri::BaseNode
     text_node :info_type
     text_node :info_kind
     text_node :info_kind_version
+    xml_node :headline do
+      text_node :text
+    end
   end
 end
 
 require "jma_feed/report_entry/jmx/area"
+require "jma_feed/report_entry/jmx/time_define"
 require "jma_feed/report_entry/jmx/significancy"
 require "jma_feed/report_entry/jmx/precipitation"
 require "jma_feed/report_entry/jmx/water_level"
 require "jma_feed/report_entry/jmx/discharge"
+require "jma_feed/report_entry/jmx/wind_direction"
+require "jma_feed/report_entry/jmx/wind_speed"
+require "jma_feed/report_entry/jmx/wave_height"
+require "jma_feed/report_entry/jmx/visibility"
+require "jma_feed/report_entry/jmx/snow_fall_depth"
+require "jma_feed/report_entry/jmx/humidity"
+require "jma_feed/report_entry/jmx/tidal_level"
+require "jma_feed/report_entry/jmx/earthquake"
+require "jma_feed/report_entry/jmx/earthquake_intensity"
 require "jma_feed/report_entry/vprn50"
 require "jma_feed/report_entry/vpww54"
 require "jma_feed/report_entry/vxko"
 require "jma_feed/report_entry/vphw50"
 require "jma_feed/report_entry/vptaii"
+require "jma_feed/report_entry/vxse53"

data/lib/jma_feed/result.rb

@@ -13,52 +13,51 @@ class JMAFeed::Result
     http_result.body
   end
 
+  def modified?
+    http_result.kind_of?(Net::HTTPSuccess)
+  end
+
   def last_modified
     DateTime.parse(http_result["Last-Modified"])
   end
 
   def doc
-    @doc ||= Nokogiri::XML(body)
+    @doc ||= JMAFeed::ResultDoc.new(body)
   end
 
-  def namespace
-    {atom: doc.root.namespace.href}
-  end
+  # def namespace
+  #   {atom: doc.root.namespace.href}
+  # end
 
-  def text(name)
-    doc.xpath("/atom:feed/atom:#{name}", namespace).text
-  end
+  # def text(name)
+  #   doc.xpath("/atom:feed/atom:#{name}", namespace).text
+  # end
 
   def title
-    text('title')
+    doc.title
   end
 
   def subtitle
-    text('subtitle')
+    doc.subtitle
   end
 
   def id
-    text('id')
+    doc.id
   end
 
   def updated
-    DateTime.parse(text('updated'))
+    doc.updated
   end
 
   def related
-    text('link[@rel="related"]/@href')
+    doc.related
   end
 
   def entries
-    @entries ||= doc.xpath('/atom:feed/atom:entry', namespace).map do |entry|
-      JMAFeed::ResultEntry.new(
-        title: entry.xpath('atom:title', namespace).text,
-        link: entry.xpath('atom:link/@href', namespace).text,
-        id: entry.xpath('atom:id', namespace).text,
-        updated: entry.xpath('atom:updated', namespace).text,
-        author: entry.xpath('atom:author/atom:name', namespace).text,
-        content: entry.xpath('atom:content', namespace).text,
-      )
-    end
+    doc.entries
+  end
+
+  def all_entries
+    doc.all_entries
   end
 end