relaton 2.2.0.pre.alpha.1 → 3.0.0.pre.alpha.2

data/lib/relaton/cen/bibliography.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Cen
+    # Class methods for search Cenelec standards.
+    class Bibliography
+      class << self
+        # @param text [String]
+        # @return [Relaton::Cen::HitCollection]
+        def search(text, year = nil)
+          HitCollection.new(text, year).search
+        rescue Mechanize::ResponseCodeError, Net::ReadTimeout => e
+          raise Relaton::RequestError, e.message
+        end
+
+        #
+        # Parses a printed CEN/CENELEC reference.
+        #
+        # Deliberately does NOT rescue. An unrecognized query reference must
+        # raise, so that relaton-cli can print `"…" is not a recognized
+        # standards identifier`; returning nil would make "malformed" look like
+        # "not found". Only the DATA side rescues — see `Hit#pubid`, which
+        # drops a catalogue code the grammar cannot read (`prEN 13306 rev`).
+        #
+        # @param ref [String] a printed reference, e.g. "EN 285:2015+A1"
+        #
+        # @return [Pubid::CenCenelec::Identifier]
+        # @raise [Pubid::Errors::ParseError]
+        #
+        def parse(ref)
+          ::Pubid::CenCenelec::Identifier.parse ref
+        end
+
+        #
+        # @param code [String] the CEN standard Code to look up
+        # @param year [String] the year the standard was published (optional)
+        # @param opts [Hash] options
+        # @option opts [Boolean] :keep_year don't upate reference
+        #
+        # @return [Relaton::Cen::ItemData, nil]
+        #
+        def get(code, year = nil, opts = {})
+          # An empty string is no reference, not a malformed one, so it stays a
+          # plain nil rather than a parse failure. Mirrors the guard
+          # HitCollection#search already carries.
+          return if code.nil? || code.strip.empty?
+
+          query = parse code
+          year ||= publication_year query
+
+          bib_get code, year, opts, query
+        end
+
+        private
+
+        #
+        # The year of the document the reference names: the base document's
+        # year for a supplement, and the adopted document's year for an adopted
+        # norm (an `AdoptedEuropeanNorm` carries no year of its own, so `#root`
+        # is the accessor that answers for every form).
+        #
+        # @param id [Pubid::CenCenelec::Identifier]
+        #
+        # @return [String, nil]
+        #
+        def publication_year(id)
+          id.root.year&.to_s
+        end
+
+        # A component is absent from a reference when excluding it changes
+        # nothing. This replaces the old capture-group tests, and works for the
+        # forms that hold the component on a nested identifier (an adopted norm
+        # keeps its part on the adopted ISO document).
+        #
+        # @return [Boolean]
+        def absent?(id, *keys)
+          id.exclude(*keys) == id
+        end
+
+        def fetch_ref_err(_code, year, missed_years)
+          unless missed_years.empty?
+            Util.info "There was no match for `#{year}`, though there " \
+                      "were matches found for `#{missed_years.join('`, `')}`."
+          end
+          nil
+        end
+
+        #
+        # Selects the portal hits that denote the same document as the query.
+        #
+        # The search text stays the caller's raw reference — that is
+        # search-engine input, not identifier parsing — while the SELECTION is
+        # pubid's. A hit whose code the grammar cannot read is dropped rather
+        # than aborting the search.
+        #
+        # The selection is pubid's subset match `query === hit.pubid`. A part,
+        # a year or a supplement year that the query omits matches any value.
+        # pubid declares the CEN `type`, `stage` and `typed_stage` strict, so
+        # `EN 1325` matches neither `prEN 1325` nor `CEN/TS 1325`. The class
+        # must be identical, so a base reference never answers with its own
+        # amendment's record, and a supplement reference never answers with
+        # its base document.
+        #
+        # @param code [String] the raw reference, as the portal form wants it
+        # @param query [Pubid::CenCenelec::Identifier]
+        #
+        # @return [Relaton::Cen::HitCollection]
+        #
+        def search_filter(code, query)
+          search(code).select! { |hit| hit.pubid && query === hit.pubid }
+        end
+
+        # Sort through the results from Isobib, fetching them three at a time,
+        # and return the first result that matches the code,
+        # matches the year (if provided), and which # has a title (amendments do not).
+        # Only expects the first page of results to be populated.
+        # If no match, returns any years which caused mismatch, for error reporting
+        def isobib_results_filter(result, year)
+          missed_years = []
+          result.each do |r|
+            pyear = r.pubid && publication_year(r.pubid)
+            if !year || year == pyear
+              ret = r.item
+              return { ret: ret } if ret
+            end
+
+            missed_years << pyear
+          end
+          { years: missed_years }
+        end
+
+        def bib_get(code, year, opts, query) # rubocop:disable Metrics/MethodLength
+          ref = year && absent?(query, :year) ? "#{code}:#{year}" : code
+          Util.info "Fetching from standards.cencenelec.eu ...", key: ref
+          result = search_filter(code, query)
+          ret = isobib_results_filter(result, year)
+          if ret[:ret]
+            bib = year || opts[:keep_year] ? ret[:ret] : ret[:ret].to_most_recent_reference
+            Util.info "Found: `#{bib.docidentifier.first&.content}`", key: ref
+            bib
+          else
+            Util.info "Not found.", key: ref
+            fetch_ref_err(code, year, ret[:years])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/relaton/cen/committees.yaml

@@ -0,0 +1,66 @@
+ASD-STAN: Aerospace
+CEN/CLC/ETSI/SMCG: CEN-CENELEC-ETSI Coordination Group on Smart Meters
+CEN/CLC/ETSI/JWG eAcc: eAccessibility
+CEN/CLC/ETSI/SEG-CG: CEN-CENELEC-ETSI Coordination Group on Smart Grids
+CEN/CLC/ETSI/SF-SSCC: CEN-CENELEC-ETSI Sector Forum on Smart and Sustainable Cities and Communities
+CEN/CLC/Guides: Group for CEN-CENELEC Guides
+CEN/CLC/JTC 1: Criteria for conformity assessment bodies
+CEN/CLC/JTC 2: Power Engineering
+CEN/CLC/JTC 3: Quality management and corresponding general aspects for medical devices
+CEN/CLC/JTC 4: Services for fire safety and security systems
+CEN/CLC/JTC 5: Space
+CEN/CLC/JTC 6: Hydrogen in energy systems
+CEN/CLC/JTC 10: Energy-related products - Material Efficiency Aspects for Ecodesign
+CEN/CLC/JTC 11: Accessibility in the built environment
+CEN/CLC/JTC 12: Design for All
+CEN/CLC/JTC 13: Cybersecurity and Data Protection
+CEN/CLC/JTC 14: Energy management and energy efficiency in the framework of energy transition
+CEN/CLC/JTC 15: Energy measurement plan for organizations
+CEN/CLC/JTC 16: CEN/CENELEC Joint Technical Committee on Active Implantable Medical Devices
+CEN/CLC/JTC 17: Gas Appliances with Combined Heat and Power
+CEN/CLC/JTC 18: Non automatic weighing instruments (NAWI)
+CEN/CLC/JTC 19: Blockchain and Distributed Ledger Technologies
+CEN/CLC/JTC 20: Hyperloop systems
+CEN/CLC/JTC 21: Artificial Intelligence
+CEN/CLC/WS 017: Development of a GALILEO enabled label
+CEN/CLC/WS 018: Assessment of the resilience of transport infrastructure to potentially disruptive events
+CEN/CLC/WS SEA-TITAN: Modular and cross-cutting Power Take-Off units for wave energy converters. Recommendations and laboratory testing
+CEN/CLC/WS SEP2: Industry Best Practices and an Industry Code of Conduct for Licensing of Standard Essential Patents in the field of 5G and Internet of Things
+CEN/CLC/WS HECTOS: CEN-CENELEC Workshop on Guidelines on evaluation systems and schemes for physical security products
+CEN/CLC/WS INACHUS: Urban search and rescue (USaR) robotic platform technical and procedural interoperability
+CEN/CLC/WS Monsoon: Predictive management of data intensive industrial processes
+CEN/CLC/WS REEMAIN: CEN/CENELEC Workshop on REEMAIN Methodology for Resource and Energy Efficiency Manufacturing
+CEN/CLC/WS SEP-IoT: Workshop on Best Practices and a Code of Conduct for Licensing Industry Standard Essential Patents in 5G and the Internet of Things (IoT), including the Industrial Internet
+CEN/CLC/WS ZONeSEC: Interoperability of security systems for the surveillance of widezones
+CEN/CLC/WS EINSTEIN: Good Practice Thermal Energy Audits (GPTEA)
+CEN/CLC/WS WiseGRID: Reference model for distribution application for microgrids
+CEN/CLC/WS EFPFInterOp: European Connected Factory Platform for Agile Manufacturing Interoperability
+CEN/CLC/WS ZDMterm: Zero Defects in Digital Manufacturing Terminology
+CEN/SS C20: Explosives and firework
+CEN/SS S08: Air quality
+CEN/SS S12: Gas analysis
+CEN/Guides: Group for CEN Guides
+CEN/SS A03: Postal services
+CEN/SS A07: Translation and Interpretation services
+CEN/SS A08: Funeral services
+CEN/SS A10: Services of Real Estate Agents
+CEN/SS A11: Security services
+CEN/SS A99: Services - Undetermined
+CEN/SS B02: Structures
+CEN/SS B09: Energy Performance of Buildings Directive (EPBD)
+CEN/SS B99: Building and construction - Undetermined
+CEN/SS C01: Food Products
+CEN/SS C10: Starch
+CEN/SS F01: Technical drawings
+CEN/SS F02: Units and symbols
+CEN/SS F05: Measuring Instruments
+CEN/SS F12: Information Processing Systems
+CEN/SS F16: Graphical symbols
+CEN/SS F17: Administrative documents
+CEN/SS F20: Quality assurance
+CEN/SS F23: Energy
+CEN/SS H10: Sewing machines
+CEN/SS H22: Smokers' lighters
+CEN/SS H99: Products for household and leisure use - Undetermined
+
+TC 459: ECISS - European Committee for Iron and Steel Standardization

data/lib/relaton/cen/hit.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Cen
+    # Hit.
+    class Hit < Relaton::Core::Hit
+      attr_writer :item
+
+      # Parse page.
+      # @return [Relaton::Cen::ItemData]
+      def item
+        @fetch ||= Scraper.parse_page self
+      end
+
+      # The hit's code parsed with pubid, memoized because the filter, the sort
+      # and the scraper all read it. `nil` when pubid cannot parse the code: the
+      # portal lists draft revisions such as `prEN 13306 rev`, and one such row
+      # must not abort the search. (A malformed *query* raises; see
+      # `Bibliography.parse`.)
+      #
+      # @return [Pubid::CenCenelec::Identifier, nil]
+      def pubid
+        return @pubid if defined?(@pubid)
+
+        @pubid = Bibliography.parse hit[:code]
+      rescue StandardError
+        @pubid = nil
+      end
+    end
+  end
+end

data/lib/relaton/cen/hit_collection.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Cen
+    # Page of hit collection.
+    class HitCollection < Relaton::Core::HitCollection
+      DOMAIN = "https://standards.cencenelec.eu"
+
+      # @param ref [String]
+      # @param year [String]
+      # def initialize(ref, year = nil) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+      #   super ref, year
+      def search
+        if !ref || ref.empty?
+          @array = []
+          return self
+        end
+
+        redirect_page = agent.get DOMAIN
+        redirect_url = redirect_page.body.slice(/(?<=follow the <a href=')#{DOMAIN}[^']+/)
+        search_page = agent.get redirect_url
+        form = search_page.form_with(id: "wwvFlowForm")
+        ref_field = form.field_with(id: "STAND_REF")
+        ref_field.value = ref
+        resp = agent.submit form
+        @array = hits resp
+        sort
+      end
+
+      def agent
+        @agent ||= Mechanize.new.tap { |a| a.user_agent_alias = "Mac Safari" }
+      end
+
+      def select!(&block)
+        @array.select!(&block)
+        self
+      end
+
+      private
+
+      def sort
+        @array.sort_by! { |hit| sort_key hit }
+        self
+      end
+
+      #
+      # The order the `code_to_parts` comparison gave, read from pubid instead:
+      # the document family ascending, then the part ascending with a part-less
+      # hit first, then the year DESCENDING with a year-less hit last, then the
+      # supplement, so a base document precedes its own amendments and
+      # corrigenda. A hit pubid cannot parse sorts last.
+      #
+      # `#root` is the accessor that answers for every form: an adopted norm
+      # keeps its number, part and year on the adopted ISO document.
+      #
+      # @param hit [Relaton::Cen::Hit]
+      #
+      # @return [Array]
+      #
+      def sort_key(hit)
+        id = hit.pubid
+        return [1, "", [], 0, ["", "", ""]] unless id
+
+        root = id.root
+        [0, family(id), part_segments(root), -root.year.to_s.to_i,
+         supplement_key(id)]
+      end
+
+      # The document family: the base document with its part and year dropped,
+      # e.g. `EN 13250:2000/A1:2005` -> `EN 13250`. Read from the base document
+      # rather than from `#root`, so that `EN ISO 1234` and `CEN ISO/TS 1234`
+      # stay apart.
+      def family(id)
+        id.base_document.exclude(:year, :part, :subpart).to_s
+      end
+
+      # Part segments as integers, so `-10` sorts after `-2`. pubid holds a
+      # sub-part inside `part` (`61375-2-3` gives `"2-3"`).
+      def part_segments(root)
+        root.part.to_s.split("-").map(&:to_i)
+      end
+
+      def supplement_key(id)
+        sup = supplements(id).first
+        return ["", "", ""] unless sup
+
+        [sup.supplement_type.to_s, sup.number.to_s, sup.year.to_s]
+      end
+
+      # A consolidated identifier (`EN 285:2015+A1:2021`) holds its base
+      # document and its supplements in `#identifiers`, and answers none of the
+      # supplement accessors itself; an amendment or corrigendum IS the
+      # supplement.
+      def supplements(id)
+        if id.respond_to? :identifiers
+          id.identifiers.drop(1)
+        elsif id.respond_to? :supplement_type
+          [id]
+        else
+          []
+        end
+      end
+
+      # @param resp [Mechanize::Page]
+      # @return [Array<RelatonCen::Hit>]
+      def hits(resp)
+        resp.xpath("//table[@class='dashlist']/tbody/tr/td[2]").map do |h|
+          ref = h.at("strong/a")
+          code = ref.text.strip
+          url = ref[:href]
+          Hit.new({ code: code, url: url }, self)
+        end
+      end
+    end
+  end
+end

data/lib/relaton/cen/item_data.rb

@@ -0,0 +1,7 @@
+module Relaton
+  module Cen
+    # Item data class.
+    class ItemData < Bib::ItemData
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,100 @@
+module Relaton
+  module Cen
+    # A CEN/CENELEC document identifier backed by `Pubid::CenCenelec`.
+    #
+    # `content` stays a plain string, so serialization is unchanged; the parsed
+    # identifier lives beside it in `@pubid` and drives the three mutators.
+    # Follows the IALA shape (`lib/relaton/iala/docidentifier.rb`), which
+    # `lib/relaton/bib/model/docidentifier.rb` names as the reference. CEN has
+    # no relaton-iso dependency, so BSI's `Iso::Type::Pubid` lutaml type does
+    # not fit here.
+    class Docidentifier < Bib::Docidentifier
+      # @return [Pubid::CenCenelec::Identifier, nil] nil when the content is
+      #   not a CEN identifier, or the grammar cannot read it
+      attr_reader :pubid
+
+      # Capture the inherited (LocalizedMarkedUpString) content setter before
+      # overriding #content=, so #refresh_content! writes the re-rendered string
+      # back WITHOUT re-parsing it and discarding the mutation.
+      alias_method :store_content, :content=
+
+      def content=(value)
+        super
+        return unless value
+
+        @pubid = begin
+          # `pubid` is required lazily because deserialization reaches this
+          # class without the flavor entry file having been loaded. LoadError
+          # degrades to a plain string; StandardError covers a non-CEN value
+          # (an ISBN) and a code the grammar rejects (`prEN 13306 rev`), both
+          # of which are DATA and must not raise. A malformed *query* raises —
+          # see Bibliography.parse.
+          require "pubid"
+          ::Pubid::CenCenelec::Identifier.parse(value)
+        rescue LoadError, StandardError
+          nil
+        end
+      end
+
+      # Drops the LAST year, and only that one.
+      #
+      # On a supplement the identifier names the supplement, so its own year is
+      # the last one: `EN 13250:2000/A1:2005` is amendment A1 of 2005, and the
+      # `2000` belongs to the base document it amends. Excluding that base year
+      # would strip the base document's identity rather than a date. Where there
+      # is no supplement year the document's own year is the base year.
+      #
+      # This also closes a case the old `/:\d{4}$/` regex missed:
+      # `EN 61375-2-3:2015/AC:2016-11` does not end in a bare year, so the regex
+      # stripped nothing, while `exclude(:supplement_year)` resets the
+      # supplement's year and month together.
+      def remove_date!
+        return unless @pubid
+
+        stripped = @pubid.exclude(:supplement_year)
+        stripped = @pubid.exclude(:year) if stripped == @pubid
+        replace_pubid stripped
+      end
+
+      def remove_part!
+        return unless @pubid
+
+        replace_pubid @pubid.exclude(:part, :subpart)
+      end
+
+      # Strips the part and the date, then wraps `@pubid` in pubid's `AllParts`.
+      #
+      # `content` stays the plain part-and-date-stripped string —
+      # `Pubid::CenCenelec::Renderer` has no "(all parts)" marker of its own,
+      # and `content` is cached from the pre-wrap pubid on purpose (see
+      # below). `#pubid` itself, read directly, now answers
+      # `all_parts? == true` and renders WITH pubid's own generic marker
+      # (`#to_s`), since it's the wrapper. Same trade-off as
+      # `Relaton::Bsi::Docidentifier` and `Relaton::Iala::Docidentifier`.
+      def to_all_parts!
+        return if !@pubid || @pubid.all_parts?
+
+        # `#exclude` (no args) rebuilds a full independent copy. `remove_part!`
+        # / `remove_date!` happen to replace `@pubid` rather than mutate it in
+        # place here, but this stays correct even if that changes.
+        original = @pubid.exclude
+        remove_part!
+        remove_date!
+        @pubid = original.to_all_parts
+      end
+
+      private
+
+      # `Pubid#exclude` returns a COPY (the BSI shape), so the new identifier
+      # replaces the old one; it does not mutate in place as IALA's setters do.
+      def replace_pubid(new_pubid)
+        @pubid = new_pubid
+        refresh_content!
+      end
+
+      def refresh_content!
+        store_content(@pubid.to_s) if @pubid
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+require_relative "structured_identifier"
+
+module Relaton
+  module Cen
+    class Ext < Bib::Ext
+      attribute :structuredidentifier, StructuredIdentifier, collection: true, initialize_empty: true
+
+      def get_schema_version = Relaton.schema_versions["relaton-model-cen"]
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require_relative "../item_data"
+require_relative "docidentifier"
+require_relative "ext"
+
+module Relaton
+  module Cen
+    class Item < Bib::Item
+      model ItemData
+
+      attribute :docidentifier, Docidentifier, collection: true, initialize_empty: true
+      attribute :ext, Ext
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Relaton
+  module Cen
+    class StructuredIdentifier < Bib::StructuredIdentifier
+      def remove_date!
+        self.year = nil
+      end
+    end
+  end
+end

data/lib/relaton/cen/processor.rb

@@ -0,0 +1,45 @@
+require "relaton/core/processor"
+
+module Relaton
+  module Cen
+    class Processor < Relaton::Core::Processor
+      def initialize # rubocop:disable Lint/MissingSuper
+        @short = :relaton_cen
+        @prefix = "CEN"
+        @pubid_flavor = :CenCenelec # global prefixes from Pubid::CenCenelec.prefixes
+        @defaultprefix = %r{^(C?EN|ENV|CWA|HD|CR)[\s/]}
+        @idtype = "CEN"
+      end
+
+      # @param code [String]
+      # @param date [String, NilClass] year
+      # @param opts [Hash]
+      # @return [Relaton::Cen::ItemData]
+      def get(code, date, opts)
+        require_relative "../cen"
+        ::Relaton::Cen::Bibliography.get(code, date, opts)
+      end
+
+      # @param xml [String]
+      # @return [Relaton::Cen::ItemData]
+      def from_xml(xml)
+        require_relative "../cen"
+        ::Relaton::Cen::Item.from_xml xml
+      end
+
+      # @param yaml [String]
+      # @return [Relaton::Cen::ItemData]
+      def from_yaml(yaml)
+        require_relative "../cen"
+        ::Relaton::Cen::Item.from_yaml yaml
+      end
+
+      # Returns hash of XML grammar
+      # @return [String]
+      def grammar_hash
+        require_relative "../cen"
+        @grammar_hash ||= ::Relaton::Cen.grammar_hash
+      end
+    end
+  end
+end