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

data/lib/relaton/ccsds/data/fetcher.rb

@@ -101,40 +101,45 @@ module Relaton
       # @return [void]
       #
       def search_instance_translation(bib)
-        bibid = bib.docidentifier.first.content.dup
-        if bibid.sub!(TRRGX, "")
-          search_relations bibid, bib
+        pubid = bib.docidentifier.first.pubid
+        return unless pubid # unparseable content: no relation to search
+
+        bibid = pubid.exclude(:language)
+        if bibid == pubid
+          search_translations bibid, bib # no language: this is an instance
         else
-          search_translations bibid, bib
+          search_relations bibid, bib # has a language: this is a translation
         end
       end
 
       #
       # Search instance or translation relation
       #
-      # @param [String] bibid instance bibitem id
+      # @param [Pubid::Ccsds::Identifier] bibid_pid language-less instance id
       # @param [Relaton::Ccsds::ItemData] bib instance or translation bibitem
       #
       # @return [void]
       #
-      def search_relations(bibid, bib)
-        bibid_pid = ::Pubid::Ccsds::Identifier.parse(bibid)
+      def search_relations(bibid_pid, bib)
         # search(bibid_pid) narrows candidates by number via binary search first.
         index.search(bibid_pid) do |row|
-          id = row[:id].exclude(:language)
-          # TODO: smiplify this line?
-          next if id != bibid_pid || row[:id] == bib.docidentifier.first.content
+          # Match language-agnostically: `bibid_pid` is language-less, so a
+          # translated row and the instance both match. `===` cannot do this —
+          # pubid declares CCSDS `language` `subset_strict`, so a nil reference
+          # language means "has none" instead of "any". Mirrors `HitCollection`.
+          next unless row[:id].exclude(:language) == bibid_pid
+          next if row[:id] == bib.docidentifier.first.pubid # exclude the document's own row
 
           create_relations bib, row[:file]
         end
       end
 
-      def search_translations(bibid, bib)
-        bibid_pid = ::Pubid::Ccsds::Identifier.parse(bibid)
+      def search_translations(bibid_pid, bib)
         # will call create_instance_relation if
         # there are same identifiers in index but with word "Translated"
         # search(bibid_pid) narrows candidates by number via binary search first.
         index.search(bibid_pid) do |row|
+          # Only translated rows (`row[:id].language`), matched language-agnostically.
           next unless row[:id].language && row[:id].exclude(:language) == bibid_pid
 
           create_instance_relation bib, row[:file]

data/lib/relaton/ccsds/data/parser.rb

@@ -47,7 +47,7 @@ module Relaton
       end
 
       def parse_docidentifier
-        [Bib::Docidentifier.new(content: docidentifier, type: "CCSDS", primary: true)]
+        [Docidentifier.new(content: docidentifier, type: "CCSDS", primary: true)]
       end
 
       def docidentifier

data/lib/relaton/ccsds/hit_collection.rb

@@ -31,7 +31,12 @@ module Relaton
 
       def rows
         if pubid.edition
-          index.search(pubid)
+          # `exact:` keeps the match exact. `Type#search` without it takes
+          # pubid's subset match `pubid === row`. pubid declares `language`
+          # `subset_strict`, so a translation no longer matches, but `suffix` is
+          # still a wildcard: `CCSDS 101.0-B-4` would also reach the historical
+          # `CCSDS 101.0-B-4-S` (260 such pairs in the index fixture).
+          index.search(pubid, exact: true)
         else
           # search(pubid) narrows candidates by number via binary search first.
           index.search(pubid) { |r| r[:id].exclude(:edition) == pubid }

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

@@ -0,0 +1,121 @@
+module Relaton
+  module Ccsds
+    # CCSDS document identifier backed by a parsed Pubid::Ccsds::Identifier.
+    #
+    # Mirrors the IEC flavor (lib/relaton/iec/model/docidentifier.rb): the
+    # lutaml `content` stays a plain string for serialization, while the parsed
+    # pubid is kept in `@pubid` so the structural mutators (`remove_part!`,
+    # `remove_date!`, `to_all_parts!`) can edit the identifier graph and
+    # re-render. CCSDS components are simpler than ISO/IEC — plain strings, no
+    # subpart, no supplement/consolidated special-casing beyond the base chain —
+    # so this is the minimal Pubid-backed shape.
+    class Docidentifier < Bib::Docidentifier
+      attribute :content, :string
+
+      attr_reader :pubid
+
+      def initialize(arg = nil, **kwargs)
+        arg.is_a?(Hash) ? super(arg) : super(**kwargs)
+        # lutaml may run the content setter before `type` is assigned; re-run it
+        # from `initialize` so the authoritative value is parsed with type set.
+        raw = arg.is_a?(Hash) ? (arg["content"] || arg[:content]) : kwargs[:content]
+        self.content = raw if raw
+      end
+
+      alias_method :original_content=, :content=
+      alias_method :original_content, :content
+
+      def content=(value)
+        @pubid = nil
+        @raw_content = nil
+
+        parsed =
+          case value
+          when ::Pubid::Ccsds::Identifier then value
+          when String
+            begin
+              ::Pubid::Ccsds::Identifier.parse(value)
+            rescue StandardError
+              # Suppress while `type` is unset: lutaml runs this setter once
+              # during init before `type` is assigned, then `initialize` re-runs
+              # it — only the second pass is authoritative.
+              Util.warn "Failed to parse Pubid: #{value}" if type
+              nil
+            end
+          end
+
+        if parsed
+          @pubid = parsed
+        elsif value.is_a?(String)
+          @raw_content = value
+        end
+
+        send(:original_content=, to_s)
+      end
+
+      def content
+        return @raw_content if @raw_content
+        return @pubid.to_s if @pubid
+
+        original_content
+      end
+
+      def to_s
+        content.to_s
+      end
+
+      def to_all_parts!
+        return if !@pubid || @pubid.all_parts?
+
+        # `#exclude` (no args) rebuilds a full independent copy, including
+        # the base chain of a supplement/corrigendum — `remove_attr!` walks
+        # and mutates that whole chain in place, so even a shallow `.dup`
+        # would still lose the original part/date to that mutation.
+        original = @pubid.exclude
+        remove_part!
+        remove_date!
+        # `content` is live-derived from `@pubid` (see above), and the wrapped
+        # all-parts identifier renders a "(all parts)" marker pubid-ccsds
+        # itself never has — so freeze the already-stripped rendering into
+        # `@raw_content` (checked first by `content`) before wrapping.
+        @raw_content = to_s
+        # Wrap the ORIGINAL (unstripped) pubid, not the part/date-stripped
+        # working copy above — `identifiers` should hold the real identifier
+        # this all-parts reference was derived from.
+        @pubid = original.to_all_parts
+      end
+
+      def remove_part!
+        remove_attr!(:part)
+      end
+
+      def remove_date!
+        remove_attr!(:date)
+      end
+
+      private
+
+      def remove_attr!(attr)
+        return unless @pubid
+
+        clear_attr_on(@pubid, attr)
+        # Supplements/corrigenda wrap a base identifier; a plain Base returns
+        # nil, so the walk clears the attr down the whole chain and terminates.
+        node = @pubid.base
+        while node
+          clear_attr_on(node, attr)
+          node = node.base
+        end
+        refresh_content!
+      end
+
+      def clear_attr_on(pubid, attr)
+        pubid.send("#{attr}=", nil) if pubid.respond_to?("#{attr}=")
+      end
+
+      def refresh_content!
+        send(:original_content=, to_s)
+      end
+    end
+  end
+end

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

@@ -1,5 +1,6 @@
 require "relaton/bib"
 require_relative "../item_data"
+require_relative "docidentifier"
 require_relative "ext"
 
 module Relaton
@@ -7,6 +8,7 @@ module Relaton
     class Item < Bib::Item
       model ItemData
 
+      attribute :docidentifier, Docidentifier, collection: true, initialize_empty: true
       attribute :ext, Ext
     end
   end

data/lib/relaton/cen/bibliography.rb

@@ -6,91 +6,119 @@ module Relaton
     class Bibliography
       class << self
         # @param text [String]
-        # @return [RelatonCen::HitCollection]
+        # @return [Relaton::Cen::HitCollection]
         def search(text, year = nil)
-          # /^C?EN\s(?<code>.+)/ =~ text
           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 [RelatonBib::BibliographicItem, nil]
+        # @return [Relaton::Cen::ItemData, nil]
         #
         def get(code, year = nil, opts = {})
-          code_parts = code_to_parts code
-          year ||= code_parts[:year] if code_parts
+          # 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)
+          bib_get code, year, opts, query
         end
 
+        private
+
         #
-        # Decopmposes a CEN standard code into its parts.
+        # 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 [String] code the CEN standard code to decompose
+        # @param id [Pubid::CenCenelec::Identifier]
         #
-        # @return [MatchData] the decomposition of the code
+        # @return [String, nil]
         #
-        def code_to_parts(code)
-          %r{^
-            (?<code>[^:-]+)(?:-(?<part>\d+))?
-            (?::(?<year>\d{4}))?
-            (?:\+(?<amd>[A-Z]\d+)(?:(?<amy>\d{4}))?)?
-            (?:\/(?<ac>AC\d+:\d{4}))?
-          }x.match code
+        def publication_year(id)
+          id.root.year&.to_s
         end
 
-        private
+        # 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) # rubocop:disable Metrics/MethodLength
-          # id = year ? "#{code}:#{year}" : code
-          # Util.warn "WARNING: No match found online for `#{id}`. " \
-          #           "The code must be exactly like it is on the standards website."
+        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
-          # if /\d-\d/.match? code
-          #   warn "[relaton-cen] The provided document part may not exist, or "\
-          #     "the document may no longer be published in parts."
-          # else
-          #   warn "[relaton-cen] If you wanted to cite all document parts for "\
-          #     "the reference, use \"#{code} (all parts)\".\nIf the document "\
-          #     "is not a standard, use its document type abbreviation (TS, TR, "]
-          #     "PAS, Guide)."
-          # end
           nil
         end
 
-        # @param code [String]
-        # @return [RelatonCen::HitCollection]
-        def search_filter(code) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
-          parts = code_to_parts code
-          result = search(code)
-          result.select! do |i|
-            pts = code_to_parts i.hit[:code]
-            parts[:code] == pts[:code] &&
-              (!parts[:part] || parts[:part] == pts[:part]) &&
-              (!parts[:year] || parts[:year] == pts[:year]) &&
-              parts[:amd] == pts[:amd] && (!parts[:amy] || parts[:amy] == pts[:amy])
-          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.
-        # Does not match corrigenda etc (e.g. ISO 3166-1:2006/Cor 1:2007)
         # 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>\d{4})/ =~ r.hit[:code]
+            pyear = r.pubid && publication_year(r.pubid)
             if !year || year == pyear
               ret = r.item
               return { ret: ret } if ret
@@ -101,10 +129,10 @@ module Relaton
           { years: missed_years }
         end
 
-        def bib_get(code, year, opts) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity,Metrics/MethodLength
-          ref = year.nil? || code.match?(/:\d{4}/) ? code : "#{code}:#{year}"
+        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) || return
+          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

data/lib/relaton/cen/hit.rb

@@ -7,10 +7,25 @@ module Relaton
       attr_writer :item
 
       # Parse page.
-      # @return [IsoRelatonBib::IsoBibliographicItem]
+      # @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

@@ -39,20 +39,68 @@ module Relaton
       private
 
       def sort
-        @array.sort! do |a, b|
-          ap = Bibliography.code_to_parts a.hit[:code]
-          bp = Bibliography.code_to_parts b.hit[:code]
-          s = ap[:code] <=> bp[:code]
-          s = ap[:part].to_s <=> bp[:part].to_s if s.zero?
-          s = bp[:year].to_s <=> ap[:year].to_s if s.zero?
-          s = ap[:amd].to_s <=> bp[:amd].to_s if s.zero?
-          s = ap[:amy].to_s <=> bp[:amy].to_s if s.zero?
-          s = ap[:ac].to_s <=> bp[:ac].to_s if s.zero?
-          s
-        end
+        @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)

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

@@ -1,8 +1,99 @@
 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!
-        self.content.sub!(/:\d{4}$/, "")
+        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

data/lib/relaton/cen/processor.rb

@@ -1,4 +1,4 @@
-require_relative "../cen"
+require "relaton/core/processor"
 
 module Relaton
   module Cen
@@ -6,6 +6,7 @@ module Relaton
       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
@@ -13,27 +14,31 @@ module Relaton
       # @param code [String]
       # @param date [String, NilClass] year
       # @param opts [Hash]
-      # @return [RelatonBib::BibliographicItem]
+      # @return [Relaton::Cen::ItemData]
       def get(code, date, opts)
-        Bibliography.get(code, date, opts)
+        require_relative "../cen"
+        ::Relaton::Cen::Bibliography.get(code, date, opts)
       end
 
       # @param xml [String]
-      # @return [RelatonBib::BibliographicItem]
+      # @return [Relaton::Cen::ItemData]
       def from_xml(xml)
-        Item.from_xml xml
+        require_relative "../cen"
+        ::Relaton::Cen::Item.from_xml xml
       end
 
       # @param yaml [String]
-      # @return [RelatonBib::BibliographicItem]
+      # @return [Relaton::Cen::ItemData]
       def from_yaml(yaml)
-        Item.from_yaml yaml
+        require_relative "../cen"
+        ::Relaton::Cen::Item.from_yaml yaml
       end
 
       # Returns hash of XML grammar
       # @return [String]
       def grammar_hash
-        @grammar_hash ||= Cen.grammar_hash
+        require_relative "../cen"
+        @grammar_hash ||= ::Relaton::Cen.grammar_hash
       end
     end
   end