relaton 2.1.0 → 3.0.0.pre.alpha.1

data/lib/relaton/bipm/id_parser.rb

@@ -0,0 +1,277 @@
+module Relaton
+  module Bipm
+    class Id
+      # class Parser < Parslet::Parser
+      #   rule(:space) { match("\s").repeat(1) }
+      #   rule(:space?) { space.maybe }
+      #   rule(:comma) { str(",") >> space? }
+      #   rule(:lparen) { str("(") }
+      #   rule(:rparen) { str(")") }
+      #   rule(:slash) { str("/") }
+      #   rule(:num) { match["0-9"].repeat(1) }
+
+      #   rule(:delimeter) { str("--") >> space }
+      #   rule(:delimeter?) { delimeter.maybe }
+
+      #   rule(:lang) { comma >> space? >> match["A-Z"].repeat(1, 2).as(:lang) }
+      #   rule(:lang?) { lang.maybe }
+
+      #   rule(:numdash) { match["A-Z0-9-"].repeat(1).as(:number) }
+      #   rule(:number) { numdash >> space? }
+      #   rule(:number?) { number.maybe }
+      #   rule(:num_suff) { numdash >> match["a-z"].repeat(1, 2) >> space }
+
+      #   rule(:year) { match["0-9"].repeat(4, 4).as(:year) }
+      #   rule(:year_paren) { lparen >> year >> lang? >> rparen }
+      #   rule(:num_year) { number? >> year_paren }
+      #   rule(:year_num) { year >> str("-") >> number }
+      #   rule(:num_and_year) { num_year | year_num | number }
+
+      #   rule(:sect) { lparen >> match["IVX"].repeat >> rparen }
+      #   rule(:suff) { match["a-zA-Z-"].repeat(1) }
+      #   rule(:cgmp) { str("CGPM") }
+      #   rule(:cipm) { str("CIPM") >> (str(" MRA") | match["A-Z-"]).maybe }
+      #   rule(:cc) { str("CC") >> suff >> sect.maybe }
+      #   rule(:jc) { str("JC") >> suff }
+      #   rule(:cec) { str("CEC") }
+      #   rule(:wgms) { str("WG-MS") }
+      #   rule(:group) { (cgmp | cipm | cc | jc | cec | wgms).as(:group) }
+
+      #   rule(:type) { match["[:alpha:]"].repeat(1).as(:type) >> space }
+
+      #   rule(:type_group) { type >> group >> slash >> num_and_year }
+      #   rule(:group_type) { group >> space >> delimeter? >> type >> num_and_year }
+      #   rule(:group_num) { group >> space >> num_suff >> type >> year_paren }
+      #   rule(:outcome) { group_num | group_type | type_group }
+
+      #   rule(:part_partie) { str("Part") | str("Partie") }
+      #   rule(:part) { comma >> part_partie >> space >> num.as(:part) }
+      #   rule(:append) { (comma | space) >> (str("Appendix") | str("Annexe")) >> space >> num.as(:append) }
+      #   rule(:brochure) { str("SI").as(:group) >> space >> str("Brochure").as(:type) >> (part | append).maybe }
+
+      #   rule(:metrologia) { str("Metrologia").as(:group) >> (space >> match["a-zA-Z0-9\s"].repeat(1).as(:number)).maybe }
+
+      #   rule(:corr) { space >> str("Corrigendum").as(:corr) }
+      #   rule(:corr?) { corr.maybe }
+      #   rule(:jcgm) { group >> space >> numdash >> (str(":") >> year).maybe >> corr? }
+
+      #   rule(:result) { outcome | brochure | metrologia | jcgm }
+
+      #   root :result
+      # end
+
+      TYPES = {
+        "Resolution" => "RES",
+        "Résolution" => "RES",
+        "Recommendation" => "REC",
+        "Recommandation" => "REC",
+        "Decision" => "DECN",
+        "Décision" => "DECN",
+        "Declaration" => "DECL",
+        "Déclaration" => "DECL",
+        "Réunion" => "Meeting",
+        "Action" => "ACT",
+      }.freeze
+
+      # @return [Hash] the parsed id components
+      attr_accessor :id
+
+      #
+      # Create a new Id object
+      #
+      def initialize
+        # @id = Parser.new.parse(id)
+        # @id = parse(id)
+      # rescue Parslet::ParseFailed => e
+        # Util.warn "WARNING: Incorrect reference: `#{id}`"
+        # warn e.parse_failure_cause.ascii_tree
+        # raise RelatonBib::RequestError, e
+      end
+
+      # @param [String] id id string
+      #
+      def parse(id)
+        # str = StringScanner.new id
+        match = parse_outcome(id) || parse_brochure(id) || parse_metrologia(id) || parse_jcgm(id)
+        @id = match.named_captures.compact.transform_keys(&:to_sym)
+        self
+      rescue StandardError => e
+        Util.warn "Incorrect reference: `#{id}`"
+        raise Relaton::RequestError, e
+      end
+
+      def parse_outcome(id)
+        parse_group_num(id) || parse_group_type(id) || parse_type_group(id)
+      end
+
+      def parse_group_num(id)
+        %r{^#{group}\s#{number}[a-z]{1,2}\s#{type}\s#{year_lang}$}.match(id)
+      end
+
+      def parse_group_type(id)
+        %r{^#{group}\s(?:--\s)?#{type}\s#{num_and_year}$}.match(id)
+      end
+
+      def parse_type_group(id)
+        %r{^#{type}\s#{group}\/#{num_and_year}$}.match(id)
+      end
+
+      def group
+        "(?<group>CGPM|CIPM(?:\\sMRA|[A-Z-])?|CC[a-zA-Z-]+[IVX]*|JC[a-zA-Z-]+|CEC|WG-MS)"
+      end
+
+      def type; "(?<type>[[:alpha:]]+)"; end
+      def number; "(?<number>[A-Z0-9-]+)"; end
+      def year; "(?<year>\\d{4})"; end
+      def lang; ",\\s?(?<lang>[A-Z]{1,2})"; end
+      def year_lang; "\\(#{year}(?:#{lang})?\\)"; end
+      def num_and_year; "(?:(?:#{number}\\s)?#{year_lang}|#{year}-#{number}|#{number})"; end
+
+      def parse_brochure(id)
+        parse_si_brochure(id) || parse_brochure_other(id)
+      end
+
+      def parse_si_brochure(id)
+        parse_si_brochure_en(id) || parse_si_brochure_fr(id)
+      end
+
+      # English form. Accepts the bare/sectioned forms ("SI Brochure",
+      # "SI Brochure, Part 1", "SI Brochure Concise" …) and the edition-tagged
+      # docnumber emitted by SI Brochure 9e v3.01:
+      #   "SI Brochure 9e v3.01 (2019/2024, E)"
+      # Edition/version/year/lang are matched but not captured so the index
+      # key collapses to {group, type} as the prior collection-render flow.
+      def parse_si_brochure_en(id)
+        %r{^
+          (?<group>SI)\s(?<type>Brochure)
+          (?:,?\s(?:(?:Part|Partie)\s(?<part>\d+)|(?:Appendix|Annexe)\s(?<append>\d+)|(?<number>Concise|FAQ)))?
+          (?:\s\d+e\sv[\d.]+\s\([\d/]+(?:,\s*[A-Z])?\))?
+        $}x.match(id)
+      end
+
+      # French form. The SI Brochure 9e v3.01 French bibdata emits its
+      # docnumber as "Brochure sur le SI 9e v3.01 (2019/2024, F)". Same
+      # document as the English form — collapse to the same {group, type}.
+      def parse_si_brochure_fr(id)
+        %r{^
+          (?<type>Brochure)\ssur\sle\s(?<group>SI)
+          (?:\s\d+e\sv[\d.]+\s\([\d/]+(?:,\s*[A-Z])?\))?
+        $}x.match(id)
+      end
+
+      def parse_brochure_other(id)
+        %r{^(?<group>CCEM|CCL|CCM|SI|Rapport)[-\s](?<type>GD-RSI|GD-MeP|MEP|BIPM)[-\s](?<number>\w+|\d{4}\/\d{2})$}.match(id)
+      end
+
+      def parse_metrologia(id)
+        %r{^(?<group>Metrologia)(?:\s(?<number>[a-zA-Z0-9\s]+))?$}.match(id)
+      end
+
+      def parse_jcgm(id)
+        %r{^#{group}\s#{number}(?::#{year})?(?:\s(?<corr>Corrigendum))?$}.match(id)
+      end
+
+      # def parse_gorup_num(str)
+      #   return unless group = parse_group(str)
+
+      #   return unless str.scan(" ") && num_suff = parse_num_suff(str)
+
+      #   return unless type = parse_type(str)
+
+      #   return unless year = parse_year_parent(str)
+
+      #   { group: group, number: num_suff, type: type, year: year }
+      # end
+
+      # def parse_group(str)
+      #   str.scan %r{CGPM|CIPM(?:\sMRA|[A-Z-])?|CC[a-zA-Z-]+[IVX]*|JC[a-zA-Z-]|CEC|WG-MS}
+      # end
+
+      # def parse_num_suff(str)
+      #   num = parse_numdash(str)
+      #   num if num && str.scan(/[a-z]{1,2}\s/)
+      # end
+
+      # def parse_number(str)
+      #   parse_numdash(str)
+      # end
+
+      # def parse_numdash(str)
+      #   str.scan(/[A-Z0-9-]+/)
+      # end
+
+      #
+      # Compare two Id objects
+      #
+      # @param [RelatonBipm::Id, Hash] other the other Id object
+      #
+      # @return [Boolean] true if the two Id objects are equal
+      #
+      def ==(other) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity,Metrics/AbcSize
+        other_hash = other.is_a?(Id) ? other.to_hash : normalize_hash(other)
+        hash = to_hash.dup
+        hash.delete(:number) if other_hash[:number].nil? && hash[:number] == "1" && hash[:year]
+        other_hash.delete(:number) if hash[:number].nil? && other_hash[:number] == "1" && other_hash[:year]
+        # hash.delete(:year) unless other_hash[:year]
+        other_hash.delete(:year) unless hash[:year]
+        hash.delete(:lang) unless other_hash[:lang]
+        other_hash.delete(:lang) unless hash[:lang]
+        hash.delete(:part) unless other_hash[:part]
+        hash.delete(:append) unless other_hash[:append]
+        hash == other_hash
+      end
+
+      #
+      # Transform ID parts.
+      # Traslate type into abbreviation, remove leading zeros from number
+      #
+      # @return [Hash] the normalized ID parts
+      #
+      def to_hash
+        @to_hash ||= normalize_hash id
+      end
+
+      #
+      # Normalize ID parts
+      # Traslate type into abbreviation, remove leading zeros from number
+      #
+      # @param [RelatonBipm::Id, Hash] src the ID parts
+      #
+      # @return [Hash] the normalized ID parts
+      #
+      def normalize_hash(src) # rubocop:disable Metrics/AbcSize
+        hash = { group: src[:group].to_s.sub("CCDS", "CCTF") }
+        hash[:type] = normalized_type(src) if src[:type]
+        norm_num = normalized_number(src)
+        hash[:number] = norm_num unless norm_num.nil? || norm_num.empty?
+        hash[:year] = src[:year].to_s if src[:year]
+        hash[:corr] = true if src[:corr]
+        hash[:part] = src[:part].to_s if src[:part]
+        hash[:append] = src[:append].to_s if src[:append]
+        hash[:lang] = src[:lang].to_s if src[:lang]
+        hash
+      end
+
+      #
+      # Translate type into abbreviation
+      #
+      # @return [String] the normalized type
+      #
+      def normalized_type(src)
+        type = TYPES[src[:type].to_s.capitalize] || src[:type].to_s
+        type == type.upcase ? type : type.capitalize
+      end
+
+      #
+      # Remove leading zeros from number
+      #
+      # @return [String, nil] the normalized number
+      #
+      def normalized_number(src)
+        return unless src[:number]
+
+        src[:number].to_s.sub(/^0+/, "")
+      end
+    end
+  end
+end

data/lib/relaton/bipm/item_data.rb

@@ -0,0 +1,47 @@
+require_relative "converter/asciibib"
+
+module Relaton
+  module Bipm
+    class ItemData < Bib::ItemData
+      def deep_clone
+        Item.from_yaml Item.to_yaml(self)
+      end
+
+      # def create_relation(**args)
+      #   Relation.new(**args)
+      # end
+
+      def to_xml(bibdata: false, **opts)
+        add_notes opts[:note] do
+          bibdata ? Bibdata.to_xml(self) : Bibitem.to_xml(self)
+        end
+      end
+
+      def to_yaml(**opts)
+        add_notes opts[:note] do
+          Item.to_yaml(self)
+        end
+      end
+
+      def to_json(**opts)
+        add_notes opts[:note] do
+          Item.to_json(self)
+        end
+      end
+
+      def to_asciibib
+        Converter::Asciibib.from_item(self)
+      end
+
+      # private
+
+      # def add_notes(notes)
+      #   self.note ||= []
+      #   Relaton.array(notes).each { |nt| note << Bib::Note.new(**nt) }
+      #   result = yield
+      #   Relaton.array(notes).each { note.pop }
+      #   result
+      # end
+    end
+  end
+end

data/lib/relaton/bipm/model/bibdata.rb

@@ -0,0 +1,9 @@
+module Relaton
+  module Bipm
+    class Bibdata < Item
+      include Bib::BibdataShared
+
+      model ItemData
+    end
+  end
+end

data/lib/relaton/bipm/model/bibitem.rb

@@ -0,0 +1,9 @@
+module Relaton
+  module Bipm
+    class Bibitem < Item
+      include Bib::BibitemShared
+
+      model ItemData
+    end
+  end
+end

data/lib/relaton/bipm/model/comment_period.rb

@@ -0,0 +1,13 @@
+module Relaton
+  module Bipm
+    class CommentPeriod < Lutaml::Model::Serializable
+      attribute :from, :date
+      attribute :to, :date
+
+      xml do
+        map_element "from", to: :from
+        map_element "to", to: :to
+      end
+    end
+  end
+end

data/lib/relaton/bipm/model/doctype.rb

@@ -0,0 +1,12 @@
+module Relaton
+  module Bipm
+    class Doctype < Bib::Doctype
+      TYPES = %w[
+        brochure mise-en-pratique rapport monographie guide meeting-report
+        technical-report working-party-note strategy cipm-mra resolution policy
+      ].freeze
+
+      attribute :content, :string, values: TYPES
+    end
+  end
+end

data/lib/relaton/bipm/model/ext.rb

@@ -0,0 +1,38 @@
+require_relative "doctype"
+require_relative "comment_period"
+require_relative "structured_identifier"
+
+module Relaton
+  module Bipm
+    class Ext < Bib::Ext
+      SI_ASPECTS = %w[
+        A_e_deltanu A_e cd_Kcd_h_deltanu cd_Kcd full K_k_deltanu K_k
+        kg_h_c_deltanu kg_h m_c_deltanu m_c mol_NA s_deltanu
+      ]
+
+      attribute :doctype, Doctype
+      attribute :comment_period, CommentPeriod
+      attribute :si_aspect, :string, values: SI_ASPECTS
+      attribute :meeting_note, :string
+      attribute :structuredidentifier, StructuredIdentifier
+
+      xml do
+        map_element "comment-period", to: :comment_period
+        map_element "si-aspect", to: :si_aspect
+        map_element "meeting-note", to: :meeting_note
+        map_element "structuredidentifier", to: :structuredidentifier
+      end
+
+      key_value do
+        map_element "comment_period", to: :comment_period
+        map_element "si_aspect", to: :si_aspect
+        map_element "structuredidentifier", to: :structuredidentifier
+        map_element "meeting_note", to: :meeting_note
+      end
+
+      def get_schema_version
+       Relaton.schema_versions["relaton-model-bipm"]
+      end
+    end
+  end
+end

data/lib/relaton/bipm/model/item.rb

@@ -0,0 +1,11 @@
+require_relative "ext"
+
+module Relaton
+  module Bipm
+    class Item < Bib::Item
+      model ItemData
+
+      attribute :ext, Ext
+    end
+  end
+end

data/lib/relaton/bipm/model/structured_identifier.rb

@@ -0,0 +1,15 @@
+module Relaton
+  module Bipm
+    class StructuredIdentifier < Lutaml::Model::Serializable
+      attribute :docnumber, :string
+      attribute :part, :string
+      attribute :appendix, :string
+
+      xml do
+        map_element "docnumber", to: :docnumber
+        map_element "part", to: :part
+        map_element "appendix", to: :appendix
+      end
+    end
+  end
+end

data/lib/relaton/bipm/processor.rb

@@ -0,0 +1,69 @@
+require "relaton/core/processor"
+
+module Relaton
+  module Bipm
+    class Processor < Relaton::Core::Processor
+      attr_reader :idtype
+
+      def initialize
+        @short = :relaton_bipm
+        @prefix = "BIPM"
+        @defaultprefix = %r{^(?:BIPM|CCTF|CCDS|CGPM|CIPM|JCRB|JCGM)(?!\w)}
+        @idtype = "BIPM"
+        @datasets = %w[bipm-data-outcomes bipm-si-brochure rawdata-bipm-metrologia]
+      end
+
+      # @param code [String]
+      # @param date [String, NilClass] year
+      # @param opts [Hash]
+      # @return [RelatonBipm::BipmBibliographicItem]
+      def get(code, date, opts)
+        require_relative "../bipm"
+        Bibliography.get(code, date, opts)
+      end
+
+      #
+      # Fetch all the documents from https://github.com/metanorma/bipm-data-outcomes,
+      #   https://github.com/metanorma/bipm-si-brochure, https://github.com/relaton/rawdata-bipm-metrologia
+      #
+      # @param [String] source source name (bipm-data-outcomes, bipm-si-brochure,
+      #   rawdata-bipm-metrologia)
+      # @param [Hash] opts
+      # @option opts [String] :output directory to output documents
+      # @option opts [String] :format
+      #
+      def fetch_data(source, opts)
+        require_relative "data_fetcher"
+        DataFetcher.fetch(source, **opts)
+      end
+
+      # @param xml [String]
+      # @return [RelatonBipm::BipmBibliographicItem]
+      def from_xml(xml)
+        require_relative "../bipm"
+        Item.from_xml xml
+      end
+
+      def from_yaml(yaml)
+        require_relative "../bipm"
+        Item.from_yaml yaml
+      end
+
+
+      # Returns hash of XML grammar
+      # @return [String]
+      def grammar_hash
+        require_relative "../bipm"
+        @grammar_hash ||= Relaton::Bipm.grammar_hash
+      end
+
+      #
+      # Remove index file
+      #
+      def remove_index_file
+        require_relative "../bipm"
+        Relaton::Index.find_or_create(:bipm, url: true, file: INDEXFILE).remove_file
+      end
+    end
+  end
+end

data/lib/relaton/bipm/rawdata_bipm_metrologia/affiliations.rb

@@ -0,0 +1,111 @@
+module Relaton::Bipm
+  module RawdataBipmMetrologia
+    class Affiliations
+      attr_reader :affiliations
+
+      #
+      # Initialize parser
+      #
+      # @param [Array<Relaton::Bib::Affiliation>] affiliations directory with affiliations
+      #
+      def initialize(affiliations)
+        @affiliations = affiliations
+      end
+
+      #
+      # Parse affiliations
+      #
+      # @return [Relaton::Bipm::RawdataBipmMetrologia::Affiliations] affiliations
+      #
+      def self.parse(dir)
+        affiliations = Dir["#{dir}/*.xml"].each_with_object([]) do |path, m|
+          doc = Nokogiri::XML(File.read(path, encoding: "UTF-8"))
+          doc.xpath("//aff").each do |aff|
+            m << parse_affiliation(aff) if aff.at("institution")
+          end
+        end.uniq { |a| a.organization.name.first.content }
+        new affiliations
+      end
+
+      #
+      # Parse affiliation organization
+      # https://github.com/relaton/relaton-data-bipm/issues/17#issuecomment-1367035444
+      #
+      # @param [Nokogiri::XML::Element] aff
+      #
+      # @return [Relaton::Bib::Affiliation] Organization name, country, division, street address
+      #
+      def self.parse_affiliation(aff)
+        text = aff.at("text()").text
+        return if text.include? "Permanent address:" || text.include?("1005 Southover Lane") ||
+          text == "Germany" || text.starts_with?("Guest") || text.starts_with?("Deceased") ||
+          text.include?("Author to whom any correspondence should be addressed")
+
+        args = {}
+        institution = aff.at('institution')
+        if institution
+          name = institution.text
+          return if name == "1005 Southover Lane"
+
+          args[:subdivision] = parse_division(aff)
+          args[:contact] = parse_address(aff)
+        else
+        #   div, name, city, country = aff.xpath("text()").text.strip.split(", ")
+        #   div, name = name, div if name.nil?
+        #   args[:subdivision] = [Relaton::Bib::LocalizedString.new(div)] if div
+        #   args[:contact] = [Relaton::Bib::Address.new(city: city, country: country)] if city && country
+          name = aff.text
+        end
+        args[:name] = [Relaton::Bib::LocalizedString.new(name)]
+        org = Relaton::Bib::Organization.new(**args)
+        Relaton::Bib::Affiliation.new(organization: org)
+      end
+
+      def self.parse_division(aff)
+        div = aff.xpath("text()[following-sibling::institution]").text.gsub(/^\W*|\W*$/, "")
+        return [] if div.empty?
+
+        [Relaton::Bib::LocalizedString.new(div)]
+      end
+
+      def self.parse_address(aff)
+        address = []
+        addr = aff.xpath("text()[preceding-sibling::institution]").text.gsub(/^\W*|\W*$/, "")
+        address << addr unless addr.empty?
+        country = aff.at('country')
+        address << country.text if country && !country.text.empty?
+        address = address.join(", ")
+        return [] if address.empty?
+
+        [Relaton::Bib::Address.new(formatted_address: address)]
+      end
+
+      def self.parse_elements(aff)
+        elements = aff.xpath("text()").text.strip.split(", ")
+        case elements.size
+        when 1 then { name: Relaton::Bib::LocalizedString.new(elements[0]) }
+        when 2
+          # name, country
+          { name: Relaton::Bib::LocalizedString.new(elements[0]),
+            contact: [Relaton::Bib::Address.new(formatted_address: elements[1])] }
+        when 3
+          # it can be name, country, city or name, city, country
+          # so use formatted_address instead of city and country
+          { name: Relaton::Bib::LocalizedString.new(elements[0]),
+            contact: Relaton::Bib::Address.new(formatted_address: elements[1, 2].join(", ")) }
+        end
+      end
+
+      #
+      # Find affiliation by organization name
+      #
+      # @param [Strign] text string with organization name in it
+      #
+      # @return [Relaton::Bib::Affiliation]
+      #
+      def find(text)
+        @affiliations.select { |a| text.include?(a.organization.name[0].content) }.sort.last
+      end
+    end
+  end
+end