relaton-iso 1.20.0 → 2.0.0.pre.alpha.1

data/lib/relaton/iso/hash_parser_v1.rb

@@ -0,0 +1,121 @@
+require "relaton/bib/hash_parser_v1"
+require_relative "../iso"
+
+module Relaton
+  module Iso
+    #
+    # This module is used to parse hash data from Relaton YAML version 1 files.
+    # It needs for trasition form Relaton v! to Relaton v2.
+    #
+    module HashParserV1
+      include Bib::HashParserV1
+      extend self
+
+      private
+
+      def ext_hash_to_bib(ret) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        ret[:ext] ||= {}
+        ret[:ext][:schema_version] = ret[:ext].delete(:"schema-version")
+        doctype_hash_to_bib ret
+        ret[:ext][:subdoctype] = ret.delete(:subdoctype) if ret[:subdoctype]
+        ret[:ext][:flavor] ||= flavor(ret)
+        ret[:ext][:horizontal] = ret.delete(:horizontal) unless ret[:horizontal].nil?
+        editorialgroup_hash_to_bib ret
+        approvalgroup_hash_to_bib ret
+        ics_hash_to_bib ret
+        structuredidentifier_hash_to_bib ret
+        stagename_hash_to_bib ret
+        ret[:ext][:fast_track] = ret.delete(:fast_track) unless ret[:fast_track].nil?
+        ret[:ext][:price_code] = ret.delete(:price_code) if ret[:price_code]
+        ret[:ext] = Ext.new(**ret[:ext]) if ret[:ext]
+      end
+
+      def create_docid(**args)
+        Docidentifier.new(**args)
+      end
+
+      #
+      # Ovverides superclass's method
+      #
+      # @param item [Hash]
+      # @retirn [RelatonIsoBib::IsoBibliographicItem]
+      def bib_item(item)
+        ItemData.new(**item)
+      end
+
+      #
+      # Ovverides superclass's method
+      #
+      # @param title [Hash]
+      # @return [RelatonBib::TypedTitleString]
+      def typed_title_strig(title)
+        Relaton::Bib::Title.new(**title)
+      end
+
+      # @param ret [Hash]
+      def editorialgroup_hash_to_bib(ret)
+        eg = ret.dig(:ext, :editorialgroup) || ret[:editorialgroup]
+        return unless eg
+
+        ret[:ext][:editorialgroup] = create_iso_project_group(eg)
+      end
+
+      def approvalgroup_hash_to_bib(ret)
+        ag = ret.dig(:ext, :approvalgroup) || ret[:approvalgroup]
+        return unless ag
+
+        ret[:ext][:approvalgroup] = create_iso_project_group(ag)
+      end
+
+      def create_iso_project_group(args)
+        args[:technical_committee] = workgroup_hash_to_bib args[:technical_committee]
+        args[:subcommittee] = workgroup_hash_to_bib args[:subcommittee]
+        args[:workgroup] = workgroup_hash_to_bib args[:workgroup]
+        ISOProjectGroup.new(**args)
+      end
+
+      # @param ret [Hash]
+      def structuredidentifier_hash_to_bib(ret)
+        struct_id = ret.dig(:ext, :structuredidentifier) || ret[:structuredidentifier]
+        return unless struct_id
+
+        struct_id[:project_number] = project_number_hash_to_bib(struct_id)
+        ret[:ext][:structuredidentifier] = StructuredIdentifier.new(**struct_id)
+      end
+
+      def project_number_hash_to_bib(struct_id)
+        ProjectNumber.new(
+          part: struct_id.delete(:part),
+          subpart: struct_id.delete(:subpart),
+          amendment: struct_id.delete(:amendment),
+          corrigendum: struct_id.delete(:corrigendum),
+          origyr: struct_id.delete(:origyr),
+          content: struct_id.delete(:project_number),
+        )
+      end
+
+      def stagename_hash_to_bib(ret)
+        stagename = ret.dig(:ext, :stagename) || ret[:stagename]
+        return unless stagename
+
+        ret[:ext][:stagename] = Stagename.new(**stagename_args(stagename))
+      end
+
+      def stagename_args(stagename)
+        if stagename.is_a? Hash
+          stagename
+        else
+          { content: stagename }
+        end
+      end
+
+      def create_doctype(args)
+        Doctype.new(**args)
+      end
+
+      def create_relation(rel)
+        Relation.new(**rel)
+      end
+    end
+  end
+end

data/lib/relaton/iso/hit.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Iso
+    # Hit.
+    class Hit < Relaton::Core::Hit
+      # @return [RelatonIsoBib::IsoBibliographicItem]
+      attr_writer :item
+
+      # @return [Pubid::Iso::Identifier] pubid
+      attr_writer :pubid
+
+      # Update edition for pubid when provided in Bibliographic Item
+      # def update_edition(bibliographic_item)
+      #   if bibliographic_item.edition
+      #     pubid.root.edition = bibliographic_item.edition.content
+      #   end
+      # end
+
+      # Parse page.
+      # @return [Relaton::Iso::ItemData]
+      def item
+        @item ||= begin
+          url = "#{HitCollection::ENDPOINT}#{hit[:file]}"
+          resp = Net::HTTP.get_response URI(url)
+          Item.from_yaml resp.body
+        end
+      end
+
+      # @return [Integer]
+      def sort_weight
+        case hit[:status] # && hit["publicationStatus"]["key"]
+        when "Published" then 0
+        when "Under development" then 1
+        when "Withdrawn" then 2
+        when "Deleted" then 3
+        else 4
+        end
+      end
+
+      # @return [Pubid::Iso::Identifier]
+      def pubid
+        return @pubid if defined? @pubid
+
+        @pubid = create_pubid hit[:id]
+      rescue StandardError
+        Util.warn "Unable to create an identifier from #{hit[:id]}"
+        @pubid = nil
+      end
+
+      private
+
+      def create_pubid(id)
+        if id.is_a?(Hash)
+          ::Pubid::Iso::Identifier.create(**id)
+        else
+          id
+        end
+      end
+    end
+  end
+end

data/lib/relaton/iso/hit_collection.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require_relative "hit"
+
+module Relaton
+  module Iso
+    # Page of hit collection.
+    class HitCollection < Relaton::Core::HitCollection
+      INDEXFILE = "index-v1"
+      ENDPOINT = "https://raw.githubusercontent.com/relaton/relaton-data-iso/data-v2/"
+
+      def opts
+        @opts ||= {}
+      end
+
+      def ref_pubid_no_year
+        @ref_pubid_no_year ||= ref.base ? ref.dup.tap { |r| r.base = r.base.exclude(:year) } : ref.exclude(:year)
+      end
+
+      def ref_pubid_excluded
+        return @ref_pubid_excluded if defined? @ref_pubid_excluded
+
+        ref_excludings = excludings.dup
+        ref_excludings << :all_parts
+        @ref_pubid_excluded ||= ref_pubid_no_year.exclude(*ref_excludings)
+      end
+
+      #
+      # Find all the entries that match the given reference.
+      #
+      # @return [Array<Relaton::Iso::Hit>] hits
+      #
+      def find # rubocop:disable Metrics/AbcSize
+        @array = index.search do |row|
+          row[:id].is_a?(Hash) ? pubid_match?(row[:id]) : ref.to_s(with_prf: true) == row[:id]
+        end.map { |row| Hit.new row, self }
+          .sort_by! { |h| h.pubid.to_s }
+          .reverse!
+        self
+      end
+
+      def pubid_match?(id)
+        pubid = create_pubid(id)
+        return false unless pubid
+
+        # pubid.base = pubid.base.exclude(:year, :edition) if pubid.base
+        dir_excludings = excludings.dup
+        dir_excludings << :edition unless pubid.typed_stage_abbrev == "DIR"
+        exclude_id_attrs(pubid, *dir_excludings) == ref_pubid_excluded
+      end
+
+      def create_pubid(id)
+        ::Pubid::Iso::Identifier.create(**id)
+      rescue StandardError => e
+        Util.warn e.message, key: ref.to_s
+      end
+
+      def exclude_id_attrs(pubid, *attrs)
+        xid = pubid.exclude(*attrs)
+        curr = xid
+        while curr.base
+          curr.base = curr.base.exclude(*attrs)
+          curr = curr.base
+        end
+        xid
+      end
+
+      def excludings # rubocop:disable Metrics/AbcSize
+        return @excludings if defined? @excludings
+
+        excl_attrs = %i[year]
+        excl_attrs << :part if ref.root.part.nil? || ref.root.all_parts
+        if ref.stage.nil? || ref.root.all_parts
+          excl_attrs << :stage
+          excl_attrs << :iteration
+        end
+        # excl_parts << :edition if ref.root.edition.nil? || all_parts
+        @escludings = excl_attrs
+      end
+
+      def index
+        @index ||= Relaton::Index.find_or_create :iso, url: "#{ENDPOINT}#{INDEXFILE}.zip", file: "#{INDEXFILE}.yaml"
+      end
+
+      def fetch_doc(options = {})
+        @excludeingds = nil if options != opts
+        @opts = options
+
+        if !ref.root.all_parts || size == 1
+          any? && first.item # (opts[:lang])
+        else
+          to_all_parts
+        end
+      end
+
+      # @return [RelatonIsoBib::IsoBibliographicItem, nil]
+      def to_all_parts # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
+        hit = @array.select { |h| h.pubid.part }.min_by { |h| h.pubid.part.to_i }
+        return @array.first&.item unless hit
+
+        bibitem = hit.item
+        all_parts_item = bibitem.to_all_parts
+        @array.reject { |h| h.pubid.part == hit.pubid.part }.each do |hi|
+          all_parts_item.relation << create_relation(hi)
+        end
+        all_parts_item
+      end
+
+      def create_relation(hit)
+        # pubid = Pubid.new hit.pubid
+        docid = Docidentifier.new(content: hit.pubid, type: "ISO", primary: true)
+        isobib = ItemData.new(formattedref: hit.pubid.to_s, docidentifier: [docid])
+        Relation.new(type: "instanceOf", bibitem: isobib)
+      end
+    end
+  end
+end

data/lib/relaton/iso/item_data.rb

@@ -0,0 +1,49 @@
+module Relaton
+  module Iso
+    class ItemData < Bib::ItemData
+      def deep_clone
+        Item.from_yaml Item.to_yaml(self)
+      end
+
+      def create_id(without_date: false)
+        docid = docidentifier.find(&:primary) || docidentifier.first
+        return unless docid
+
+        pubid = without_date ? docid.content.exclude(:year) : docid.content
+        self.id = pubid.to_s(with_prf: true).gsub(/\W+/, "")
+      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
+
+      # 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/iso/model/bibdata.rb

@@ -0,0 +1,9 @@
+require_relative "ext"
+
+module Relaton
+  module Iso
+    class Bibdata < Item
+      include Bib::BibdataShared
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Relaton
+  module Iso
+    class Bibitem < Item
+      include Bib::BibitemShared
+    end
+  end
+end

data/lib/relaton/iso/model/contributor.rb

@@ -0,0 +1,7 @@
+module Relaton
+  module Iso
+    class Contributor < Bib::Contributor
+      # attributes[:organization].type = :boolean
+    end
+  end
+end

data/lib/relaton/iso/model/contributor_info.rb

@@ -0,0 +1,9 @@
+module Relaton
+  module Iso
+    class ContributorInfo < Lutaml::Model::Serializable
+      choice do
+        attribute :person, Bib::Person
+      end
+    end
+  end
+end

data/lib/relaton/iso/model/docidentifier.rb

@@ -0,0 +1,128 @@
+module Relaton
+  module Iso
+    class Pubid < Lutaml::Model::Type::Value
+      module Renderer
+      end
+
+      class << self
+        def cast(value)
+          value.is_a?(String) ? ::Pubid::Iso::Identifier.parse(value) : value
+        rescue StandardError
+          Util.warn "Failed to parse Pubid: #{value}"
+          value
+        end
+      end
+
+      ::Lutaml::Model::Config::AVAILABLE_FORMATS.each do |format|
+        define_method(:"to_#{format}") { value.to_s with_prf: true }
+      end
+
+      def to_h = value.to_h
+      def urn = value.urn
+    end
+
+    class Docidentifier < Bib::Docidentifier
+      include Pubid::Renderer
+
+      attribute :content, Pubid
+
+      def content_to_xml(model, parent, doc)
+        doc.add_xml_fragment parent, model.to_s
+      end
+
+      def content_to_key_value(model, doc)
+        doc["content"] = model.to_s
+      end
+
+      def to_all_parts!
+        if content.is_a? String
+          Util.warn "Cannot convert String to all parts: #{content}"
+          return
+        end
+
+        remove_part!
+        remove_date!
+        remove_stage!
+        content.all_parts = true
+      end
+
+      def remove_stage!
+        remove_attr! :stage
+        # return if content.is_a? String
+
+        # content.stage = nil
+        # base = content.base
+        # while base
+        #   base.stage = nil
+        #   base = base.base
+        # end
+      end
+
+      def remove_part!
+        remove_attr! :part
+        # return if content.is_a? String
+
+        # content.part = nil
+        # base = content.base
+        # while base
+        #   base.part = nil
+        #   base = base.base
+        # end
+      end
+
+      def remove_date!
+        remove_attr! :year
+        # return if content.is_a? String
+
+        # content.year = nil
+        # base = content.base
+        # while base
+        #   base.year = nil
+        #   base = base.base
+        # end
+      end
+
+      def exclude_year
+        pubid = content.exlude(:year)
+        current_pubid = pubid
+        while current_pubid.base
+          current_pubid.base = current_pubid.base.exclude(:year)
+          current_pubid = current_pubid.base
+        end
+        pubid
+      end
+
+      def to_s
+        return content if content.is_a? String
+
+        case type
+        when "URN" then content.urn
+        when "iso-reference" then iso_reference
+        else content.to_s with_prf: true
+        end
+      end
+
+      def iso_reference
+        return content.to_s(format: :ref_num_short, with_prf: true) if content.language
+
+        pubid_dup = content.dup
+        pubid_dup.language = "en"
+        pubid_dup.to_s(format: :ref_num_short, with_prf: true)
+      end
+
+      private
+
+      def remove_attr!(attr)
+        return false if content.is_a? String
+
+        content.send("#{attr}=", nil)
+        base = content.base
+        while base
+          base.send("#{attr}=", nil)
+          base = base.base
+        end
+        true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Relaton
+  module Iso
+    class Doctype < Bib::Doctype
+      TYPES = %w[
+        international-standard technical-specification technical-report publicly-available-specification
+        international-workshop-agreement guide recommendation amendment technical-corrigendum directive
+        committee-document addendum
+      ].freeze
+
+      attribute :content, :string, values: TYPES
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require_relative "doctype"
+require_relative "iso_project_group"
+require_relative "stagename"
+# require_relative "subdoctype"
+require_relative "structured_identifier"
+
+module Relaton
+  module Iso
+    class Ext < Lutaml::Model::Serializable
+      attribute :schema_version, :string
+      attribute :doctype, Doctype
+      attribute :subdoctype, :string
+      attribute :flavor, :string
+      attribute :horizontal, :boolean
+      attribute :editorialgroup, ISOProjectGroup
+      attribute :approvalgroup, ISOProjectGroup
+      attribute :ics, Bib::ICS, collection: true
+      attribute :structuredidentifier, StructuredIdentifier
+      attribute :stagename, Stagename
+      attribute :updates_document_type, :string, values: Doctype::TYPES
+      attribute :fast_track, :boolean
+      attribute :price_code, :string
+
+      def initialize(**args)
+        super
+        @schema_version = Relaton.schema_versions["relaton-model-iso"]
+      end
+
+      xml do
+        root "ext"
+        map_attribute "schema-version", to: :schema_version
+        map_element "doctype", to: :doctype
+        map_element "subdoctype", to: :subdoctype
+        map_element "flavor", to: :flavor
+        map_element "horizontal", to: :horizontal
+        map_element "editorialgroup", to: :editorialgroup
+        map_element "approvalgroup", to: :approvalgroup
+        map_element "ics", to: :ics
+        map_element "structuredidentifier", to: :structuredidentifier
+        map_element "stagename", to: :stagename
+        map_element "updates-document-type", to: :updates_document_type
+        map_element "fast-track", to: :fast_track
+        map_element "price-code", to: :price_code
+      end
+    end
+  end
+end

data/lib/relaton/iso/model/iso_project_group.rb

@@ -0,0 +1,21 @@
+module Relaton
+  module Iso
+    class ISOProjectGroup < Lutaml::Model::Serializable
+      attribute :agency, :string, collection: true
+      attribute :technical_committee, Bib::WorkGroup, collection: true
+      attribute :subcommittee, Bib::WorkGroup, collection: true
+      attribute :workgroup, Bib::WorkGroup, collection: true
+      attribute :secretariat, :string
+
+      xml do
+        root "editorialgroup"
+
+        map_element "agency", to: :agency
+        map_element "technical-committee", to: :technical_committee
+        map_element "subcommittee", to: :subcommittee
+        map_element "workgroup", to: :workgroup
+        map_element "secretariat", to: :secretariat
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require_relative "docidentifier"
+require_relative "ext"
+
+module Relaton
+  module Iso
+    class Relation < Bib::Relation
+    end
+
+    class Item < Bib::Item
+      model ItemData
+
+      attribute :docidentifier, Docidentifier, collection: true
+      attribute :relation, Relation, collection: true
+      attribute :ext, Ext
+    end
+  end
+end

data/lib/relaton/iso/model/item_base.rb

@@ -0,0 +1,19 @@
+module Relaton
+  module Iso
+    # The class is for relaton bibitem instances.
+    # The in relaton bibitem instances dosn't have schema-version & fetched attributes.
+    class ItemBase < Item
+      model ItemData
+
+      # we don't need schema-version & fetched attributes in reation/bibitem
+      mappings[:xml].instance_variable_get(:@attributes).delete("id")
+      mappings[:xml].instance_variable_get(:@attributes).delete("schema-version")
+      mappings[:xml].instance_variable_get(:@elements).delete("fetched")
+      mappings[:xml].instance_variable_get(:@elements).delete("ext")
+      attributes.delete :id
+      attributes.delete :schema_version
+      attributes.delete :fetched
+      attributes.delete :ext
+    end
+  end
+end

data/lib/relaton/iso/model/organization.rb

@@ -0,0 +1,9 @@
+module Relaton
+  module Iso
+    class Organization < Lutaml::Model::Serializable
+      # choice(min: 1, max: 1) do
+      #   attribute
+      # end
+    end
+  end
+end

data/lib/relaton/iso/model/project_number.rb

@@ -0,0 +1,22 @@
+module Relaton
+  module Iso
+    class ProjectNumber < Lutaml::Model::Serializable
+      attribute :part, :integer
+      attribute :subpart, :integer
+      attribute :amendment, :integer
+      attribute :corrigendum, :integer
+      attribute :origyr, :string
+      attribute :content, :string
+
+      xml do
+        root "project-number"
+        map_attribute "part", to: :part
+        map_attribute "subpart", to: :subpart
+        map_attribute "amendment", to: :amendment
+        map_attribute "corrigendum", to: :corrigendum
+        map_attribute "origyr", to: :origyr
+        map_content to: :content
+      end
+    end
+  end
+end

data/lib/relaton/iso/model/relation.rb

@@ -0,0 +1,9 @@
+require_relative "item_base"
+
+module Relaton
+  module Iso
+    class Relation
+      attribute :bibitem, ItemBase
+    end
+  end
+end