pubid-iso 0.3.1 → 0.4.0

data/lib/pubid/iso/identifier/technical_report.rb

@@ -0,0 +1,30 @@
+require_relative "../renderer/technical_report"
+
+module Pubid::Iso
+  module Identifier
+    class TechnicalReport < Base
+      def_delegators 'Pubid::Iso::Identifier::TechnicalReport', :type
+
+      TYPED_STAGES = {
+        dtr: {
+          abbr: "DTR",
+          name: "Draft Technical Report",
+          harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
+        },
+        fdtr: {
+          abbr: "FDTR",
+          name: "Final Draft Technical Report",
+          harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+        },
+      }.freeze
+
+      def self.type
+        { key: :tr, title: "Technical Report" }
+      end
+
+      def self.get_renderer_class
+        Renderer::TechnicalReport
+      end
+    end
+  end
+end

data/lib/pubid/iso/identifier/technical_specification.rb

@@ -0,0 +1,30 @@
+require_relative "../renderer/technical_specification"
+
+module Pubid::Iso
+  module Identifier
+    class TechnicalSpecification < Base
+      def_delegators 'Pubid::Iso::Identifier::TechnicalSpecification', :type
+
+      TYPED_STAGES = {
+        dts: {
+          abbr: "DTS",
+          name: "Draft Technical Specification",
+          harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
+        },
+        fdts: {
+          abbr: "FDTS",
+          name: "Final Draft Technical Specification",
+          harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+        },
+      }.freeze
+
+      def self.type
+        { key: :ts, title: "Technical Specification" }
+      end
+
+      def self.get_renderer_class
+        Renderer::TechnicalSpecification
+      end
+    end
+  end
+end

data/lib/pubid/iso/identifier/technology_trends_assessments.rb

@@ -0,0 +1,30 @@
+require_relative "../renderer/technology_trends_assessments"
+
+module Pubid::Iso
+  module Identifier
+    class TechnologyTrendsAssessments < Base
+      def_delegators 'Pubid::Iso::Identifier::TechnologyTrendsAssessments', :type
+
+      TYPED_STAGES = {
+        dtta: {
+          abbr: "DTTA",
+          name: "Technology Trends Assessments Draft",
+          harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
+        },
+        fdtta: {
+          abbr: "FDTTA",
+          name: "Technology Trends Assessments Final Draft",
+          harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+        },
+      }.freeze
+
+      def self.type
+        { key: :tta, title: "Technology Trends Assessments" }
+      end
+
+      def self.get_renderer_class
+        Renderer::TechnologyTrendsAssessments
+      end
+    end
+  end
+end

data/lib/pubid/iso/identifier.rb

@@ -1,281 +1,56 @@
 module Pubid::Iso
-  class Identifier < Pubid::Core::Identifier
-    attr_accessor :stage,
-                  :iteration, :joint_document,
-                  :tctype, :sctype, :wgtype, :tcnumber, :scnumber, :wgnumber,
-                  :dirtype,
-                  # supplement for DIR type identifiers
-                  :supplement,
-                  :base,
-                  :typed_stage,
-                  :supplements
-
-    # Creates new identifier from options provided, includes options from
-    # Pubid::Core::Identifier#initialize
-    #
-    # @param stage [Stage, TypedStage, Symbol, String] stage or typed stage, e.g. "PWI", "NP", "50.00", Stage.new(abbr: :WD), "DTR"
-    # @param iteration [Integer] document iteration, eg. "1", "2", "3"
-    # @param joint_document [Identifier] joint document
-    # @param supplement [Supplement] supplement
-    # @param tctype [String] Technical Committee type, eg. "TC", "JTC"
-    # @param sctype [String] TC subsommittee, eg. "SC"
-    # @param wgtype [String] TC working group type, eg. "AG", "AHG"
-    # @param tcnumber [Integer] Technical Committee number, eg. "1", "2"
-    # @param scnumber [Integer] Subsommittee number, eg. "1", "2"
-    # @param wgnumber [Integer] Working group number, eg. "1", "2"
-    # @param dirtype [String] Directives document type, eg. "JTC"
-    # @param base [Identifier] base document for supplement's identifier
-    # @param type [nil, :tr, :ts, :amd, :cor, :guide, :dir, :tc, Type] document's type, eg. :tr, :ts, :amd, :cor, Type.new(:tr)
-    # @raise [Errors::SupplementWithoutYearOrStageError] when trying to apply
-    #   supplement to the document without edition year or stage
-    # @raise [Errors::IsStageIterationError] when trying to apply iteration
-    #   to document with IS stage
-    # @raise [Errors::IterationWithoutStageError] when trying to applu iteration
-    #   to document without stage
-    # @see Supplement
-    # @see Identifier
-    # @see Pubid::Core::Identifier
-    # @see Parser
-    #
-    def initialize(publisher: "ISO", number: nil, stage: nil, iteration: nil, supplement: nil,
-                   joint_document: nil, tctype: nil, sctype: nil, wgtype: nil, tcnumber: nil,
-                   scnumber: nil, wgnumber:nil,
-                   dir: nil, dirtype: nil, year: nil, amendments: nil,
-                   corrigendums: nil, type: nil, base: nil, supplements: nil, **opts)
-      super(**opts.merge(number: number, publisher: publisher, year: year,
-                         amendments: amendments, corrigendums: corrigendums))
-
-      if supplements
-        @supplements = supplements.map do |supplement|
-          if supplement.is_a?(Hash)
-            self.class.get_transformer_class.new.apply(:supplements => [supplement])[:supplements].first
-          else
-            supplement
+  module Identifier
+    class << self
+      # Resolve identifier's class and create new identifier
+      # @see Pubid::Identifier::Base.initialize for available options
+      def create(**opts)
+        resolve_identifier(
+          opts[:type],
+          opts[:stage],
+          opts.reject { |k, _v| [:type, :stage].include?(k) })
+      end
+
+      # @param typed_stage_or_stage [String] typed stage or stage
+      # @return identifier's class
+      def resolve_identifier(type, typed_stage_or_stage, parameters = {})
+        return Identifier::InternationalStandard.new(**parameters) if type.nil? && typed_stage_or_stage.nil?
+
+        Base.descendants.each do |identifier_type|
+          if type
+            return identifier_type.new(stage: typed_stage_or_stage, **parameters) if identifier_type.has_type?(type)
+
+            next
+          elsif identifier_type.has_typed_stage?(typed_stage_or_stage)
+            return identifier_type.new(stage: typed_stage_or_stage, **parameters)
           end
         end
-      end
-
-      if %i(amd cor).include?(type) && (base.year.nil? && base.stage.nil?)
-        raise Errors::SupplementWithoutYearOrStageError,
-              "Cannot apply supplement to document without base identifieredition year or stage"
-      end
-
-      if stage.is_a?(TypedStage)
-        @typed_stage = stage
-        # add type to typed stage when missing (case for amendment with stage, eg. "CD Amd")
-        @typed_stage.type = Type.new(type) if @typed_stage.type.nil? && type
-      elsif stage || type
-        @typed_stage = if type
-                         TypedStage.new(type: type.is_a?(Type) ? type : Type.new(type))
-                       else
-                         TypedStage.new
-                       end
 
-        if @typed_stage.type == :is && iteration
-          raise Errors::IsStageIterationError, "IS stage document cannot have iteration"
+        # When stage is not typed stage and type is not defined
+        if type.nil? && (typed_stage_or_stage.is_a?(Stage) || Stage.has_stage?(typed_stage_or_stage))
+          return Identifier::InternationalStandard.new(stage: typed_stage_or_stage, **parameters)
         end
 
-        if stage
-          provided_type = @typed_stage.type
+        raise Errors::TypeStageParseError, "cannot parse typed stage or stage '#{typed_stage_or_stage}'" if type.nil?
 
-          @typed_stage.parse_stage(stage.is_a?(Parslet::Slice) ? stage.to_s : stage)
-          if !provided_type.nil? && @typed_stage.type != provided_type
-            raise Errors::StageInvalidError,
-                  "cannot assign typed stage for document with different type (#{provided_type} vs #{@typed_stage.type})"
-          end
-        end
-      elsif iteration
-        raise Errors::IterationWithoutStageError, "Document without stage cannot have iteration"
+        raise Errors::ParseTypeError, "cannot parse type #{type}"
       end
 
-      @iteration = iteration.to_i if iteration
-      @supplement = supplement if supplement
-      @joint_document = joint_document if joint_document
-      @tctype = tctype if tctype
-      @sctype = sctype.to_s if sctype
-      @wgtype = wgtype.to_s if wgtype
-      @tcnumber = tcnumber.to_s if tcnumber
-      @scnumber = scnumber.to_s if scnumber
-      @wgnumber = wgnumber.to_s if wgnumber
-      @dir = dir.to_s if dir
-      @dirtype = dirtype.to_s if dirtype
-      @base = base if base
-    end
-
-    def self.parse_from_title(title)
-      title.split.reverse.inject(title) do |acc, part|
-        return parse(acc)
-      rescue Pubid::Core::Errors::ParseError
-        # delete parts from the title until it's parseable
-        acc.reverse.sub(part.reverse, "").reverse.strip
+      # @see Pubid::Identifier::Base.parse
+      def parse(*args)
+        Base.parse(*args)
       end
-    end
 
-    class << self
-      def supplements_has_type?(supplements, type)
-        supplements.any? do |supplement|
-          supplement.typed_stage.type == type
+      # Parse identifier from title
+      def parse_from_title(title)
+        title.split.reverse.inject(title) do |acc, part|
+          return Base.parse(acc)
+        rescue Pubid::Core::Errors::ParseError
+          # delete parts from the title until it's parseable
+          acc.reverse.sub(part.reverse, "").reverse.strip
         end
-      end
-
-      def supplement_by_type(supplements, type)
-        supplements.select { |supplement| supplement.type == type }.first
-      end
-
-      def transform_supplements(supplements_params, base_params)
-        supplements = supplements_params.map do |supplement|
-          new(number: supplement[:number], year: supplement[:year],
-              stage: supplement[:typed_stage], edition: supplement[:edition],
-              iteration: supplement[:iteration],
-              base: new(**base_params))
-        end
-
-        return supplements.first if supplements.count == 1
-
-        # update corrigendum base to amendment
-        if supplements_has_type?(supplements, :cor) &&
-            supplements_has_type?(supplements, :amd) && supplements.count == 2
-
-          supplement = supplement_by_type(supplements, :cor)
-          supplement.base = supplement_by_type(supplements, :amd)
-          supplement
-        else
-          raise Errors::SupplementRenderingError, "don't know how to render provided supplements"
-        end
-      end
-
-      def transform(params)
-        identifier_params = params.map do |k, v|
-          get_transformer_class.new.apply(k => v).to_a.first
-        end.to_h
-
-        # return supplement if supplements applied
-        if identifier_params[:supplements]
-          return transform_supplements(
-            identifier_params[:supplements],
-            identifier_params.dup.tap { |h| h.delete(:supplements) })
-        end
-
-        new(**identifier_params)
-      end
-
-      def get_amendment_class
-        Pubid::Iso::Amendment
-      end
-
-      def get_corrigendum_class
-        Pubid::Iso::Corrigendum
-      end
-
-      def get_parser_class
-        Parser
-      end
 
-      def get_transformer_class
-        Transformer
+        raise Errors::ParseError, "cannot parse #{title}"
       end
-
-      def get_renderer_class
-        Renderer::Base
-      end
-    end
-
-    # Render URN identifier
-    # @return [String] URN identifier
-    def urn
-      if %i(amd cor).include?(type&.type) && (@base.base.nil? && !@base.edition || (!@base.base.nil? && !@base.base.edition))
-        raise Errors::NoEditionError, "Base document must have edition"
-      end
-      (@tctype && Renderer::UrnTc || type == :dir && Renderer::UrnDir || Pubid::Iso::Renderer::Urn).new(get_params).render
-    end
-
-    # Renders pubid identifier
-    #
-    # @param lang [:french,:russian] use language specific renderer
-    # @param with_date [Boolean] render identifier with date
-    # @param with_edition [Boolean] render identifier with edition
-    # @param stage_format_long [Boolean] render with long or short stage format
-    # @param format [:ref_num_short,:ref_num_long,:ref_dated,:ref_dated_long,:ref_undated,:ref_undated_long] create reference with specified format
-    # @param with_prf [Boolean] include PRF stage in output
-    # Format options are:
-    #   :ref_num_short -- instance reference number: 1 letter language code + short form (DAM) + dated
-    #   :ref_num_long -- instance reference number long: 2 letter language code + long form (DAmd) + dated
-    #   :ref_dated -- reference dated: no language code + short form (DAM) + dated
-    #   :ref_dated_long -- reference dated long: no language code + short form (DAM) + dated
-    #   :ref_undated -- reference undated: no language code + short form (DAM) + undated
-    #   :ref_undated_long -- reference undated long: 1 letter language code + long form (DAmd) + undated
-    # @return [String] pubid identifier
-    def to_s(lang: nil, with_date: true,
-             with_edition: false, with_prf: false,
-             format: :ref_dated_long)
-      with_language_code = nil
-      stage_format_long = nil
-      if format
-        case format
-        when :ref_num_short
-          with_language_code = :single
-          stage_format_long = false
-        when :ref_num_long
-          with_language_code = :iso
-          stage_format_long = true
-        when :ref_dated
-          with_language_code = :none
-          stage_format_long = false
-        when :ref_dated_long
-          with_language_code = :none
-          stage_format_long = true
-        when :ref_undated
-          with_language_code = :none
-          stage_format_long = false
-          with_date = false
-        when :ref_undated_long
-          with_language_code = :none
-          stage_format_long = true
-          with_date = false
-        else
-          raise Errors::WrongFormat, "#{format} is not available"
-        end
-      end
-      case lang
-      when :french
-        Renderer::French.new(get_params)
-      when :russian
-        Renderer::Russian.new(get_params)
-      else
-        if @tctype
-          Renderer::Tc.new(get_params)
-        elsif @typed_stage&.type == :dir
-          Renderer::Dir.new(get_params)
-        else
-          self.class.get_renderer_class.new(get_params)
-        end
-      end.render(with_date: with_date, with_language_code: with_language_code, with_edition: with_edition,
-                 stage_format_long: stage_format_long, with_prf: with_prf) +
-        if @joint_document && @typed_stage&.type != :dir
-          "|#{@joint_document}"
-        end.to_s
-    end
-
-    def stage
-      typed_stage&.stage
-    end
-
-    def type
-      typed_stage&.type
-    end
-
-    # Return typed stage abbreviation, eg. "FDTR", "DIS", "TR"
-    def typed_stage_abbrev
-      typed_stage.to_s
-    end
-
-    # Return typed stage name, eg. "Final Draft Technical Report" for "FDTR"
-    def typed_stage_name
-      typed_stage.name
-    end
-
-    def ==(other)
-      get_params == other.get_params
     end
   end
 end

data/lib/pubid/iso/parser.rb

@@ -1,10 +1,30 @@
+require_relative "identifier/base"
+require_relative "renderer/base"
+
 module Pubid::Iso
   class Parser < Pubid::Core::Parser
     STAGES = %w[NP NWIP WD CD PRF AWI PWI FPD].freeze
     TYPES = %w[DATA ISP IWA R TTA TS TR IS PAS Guide GUIDE DIR].freeze
-    TYPED_STAGES = %w[DIS FDIS DPAS FDTR FDTS DTS DTR PDTR PDTS].freeze
-    SUPPLEMENTS = %w[Amd Cor AMD COR]
-    STAGED_SUPPLEMENTS = %w[DAmd DAM DCor FDAmd FDCor DCOR FCOR FDCOR FDAM PDAM pDCOR FPDAM]
+    # TYPED_STAGES = %w[DIS FDIS DPAS FDTR FDTS DTS DTR PDTR PDTS].freeze
+    SUPPLEMENTS = %w[Amd Cor AMD COR Suppl].freeze
+    STAGED_SUPPLEMENTS = Pubid::Iso::Identifier::Amendment::TYPED_STAGES.map do |_, v|
+      v[:legacy_abbr] + [v[:abbr]]
+    end.flatten +
+      Pubid::Iso::Identifier::Corrigendum::TYPED_STAGES.map do |_, v|
+        v[:legacy_abbr] + [v[:abbr]]
+      end.flatten +
+      Pubid::Iso::Identifier::Supplement::TYPED_STAGES.map do |_, v|
+        v[:abbr]
+      end.flatten +
+      %w[pDCOR PDAM]
+
+    DIR_SUPPLEMENTS = %w[Supplement SUP].freeze
+
+    TYPED_STAGES = Pubid::Iso::Identifier::Base.descendants.map do |type|
+      type::TYPED_STAGES.map do |_, v|
+        v.key?(:legacy_abbr) ? (v[:legacy_abbr] + [v[:abbr]]) : v[:abbr]
+      end
+    end.flatten - STAGED_SUPPLEMENTS + %w[PDTR PDTS]
 
     TCTYPES = ["TC", "JTC", "PC", "IT", "CAB", "CASCO", "COPOLCO",
       "COUNCIL", "CPSG", "CS", "DEVCO", "GA", "GAAB", "INFCO",
@@ -13,15 +33,15 @@ module Pubid::Iso
       "JSAG", "JSCTF-TF", "JTCG", "JTCG-TF", "SAG_Acc", "SAG_CRMI",
       "SAG_CRMI_CG", "SAG_ESG", "SAG_ESG_CG", "SAG_MRS", "SAG SF", "SAG SF_CG",
       "SMCC", "STMG", "MENA STAR"].freeze
-    
+
     WGTYPES = ["AG", "AHG", "AhG", "WG", "JWG", "QC", "TF",
       "PPC", "CAG", "WG SGDG", "WG SR", "STAR", "STTF", "TIG",
       "CPAG", "CSC", "ITSAG", "CSC/FIN", "CSC/NOM", "CSC/OVE",
       "CSC/SP", "CSC/FIN", "JAG"].freeze
 
-    ORGANIZATIONS = %w[IEC IEEE CIW SAE CIE ASME ASTM OECD ISO IWA HL7 CEI].freeze
+    ORGANIZATIONS = %w[IEC IEEE CIW SAE CIE ASME ASTM OECD ISO HL7 CEI].freeze
     rule(:stage) do
-      array_to_str(Renderer::Russian::STAGE.values) | array_to_str(STAGES)
+      array_to_str(Pubid::Iso::Renderer::Base::TRANSLATION[:russian][:stage].values) | array_to_str(STAGES)
     end
 
     rule(:typed_stage) do
@@ -37,7 +57,7 @@ module Pubid::Iso
     end
 
     rule(:type) do
-      (array_to_str(Renderer::Russian::TYPE.values) | array_to_str(TYPES)).as(:type)
+      (array_to_str(Pubid::Iso::Renderer::Base::TRANSLATION[:russian][:type].values) | array_to_str(TYPES)).as(:type)
     end
 
     rule(:tctype) do
@@ -53,13 +73,24 @@ module Pubid::Iso
       array_to_str(WGTYPES)
     end
 
+    rule(:roman_numerals) do
+      array_to_str(%w[I V X L C D M]).repeat(1).as(:roman_numerals)
+    end
+
+    rule(:year_digits) { (str("19") | str("20")) >> match('\d').repeat(2, 2) >> digits.absent? }
+
+
+    rule(:part_matcher) do
+      year_digits.absent? >>
+        (str("Amd") | str("Cor")).absent? >> ((roman_numerals >> digits.absent?) | match['[\dA-Z]'].repeat(1)).as(:part)
+    end
+
     rule(:part) do
-      (str("-") | str("/")) >> space? >>
-        (str("Amd") | str("Cor")).absent? >> (match['[\dA-Z]'] | str("-")).repeat(1).as(:part)
+      (str("/") | str("-")) >> space? >> part_matcher >> (str("-") >> part_matcher).repeat
     end
 
     rule(:organization) do
-      array_to_str(Renderer::Russian::PUBLISHER.values) | array_to_str(ORGANIZATIONS)
+      array_to_str(Pubid::Iso::Renderer::Base::TRANSLATION[:russian][:publisher].values) | array_to_str(ORGANIZATIONS)
     end
 
     rule(:edition) do
@@ -73,13 +104,20 @@ module Pubid::Iso
 
     rule(:supplement) do
       ((str("/") | space).maybe >>
-        (staged_supplement | (stage >> space).maybe >> supplements).as(:typed_stage) >>
+        (((stage.as(:typed_stage) >> space).maybe >> supplements.as(:type)) |
+          (staged_supplement).as(:typed_stage)) >>
         (space | str(".")).repeat(1).maybe >>
-        digits.as(:number) >>
+        digits.as(:number).maybe >>
         (str(".") >> digits.as(:iteration)).maybe >>
         ((str(":") | str("-")) >> digits.as(:year)).maybe).repeat(1).as(:supplements)
     end
 
+    rule(:addendum) do
+      (
+        ((str("/") >> (str("Add") | str("ADD"))) | (str(" — Addendum"))) >> space >> digits.as(:number) >> ((str(":")) >> digits.as(:year)).maybe
+      ).as(:addendum)
+    end
+
     rule(:language) do
       str("(") >> (
         ( # parse ru,en,fr
@@ -114,8 +152,8 @@ module Pubid::Iso
         (str("JTC").as(:dirtype) >> space).maybe >>
         (digits.as(:number) >> (str(":") >> year).maybe).maybe >>
         (str(" -- Consolidated").maybe >> (space? >> (organization.as(:publisher) >> space).maybe >>
-          (str("SUP") | str("Supplement")) >> (str(":") >> year).maybe >>
-          dir_supplement_edition.maybe).as(:supplement)).maybe
+          (array_to_str(DIR_SUPPLEMENTS)) >> (str(":") >> year).maybe >>
+          dir_supplement_edition.maybe).repeat(1).as(:supplements)).maybe
     end
 
     rule(:std_document_body) do
@@ -127,10 +165,8 @@ module Pubid::Iso
         (str("|") >> (str("IDF").as(:publisher) >> space >> digits.as(:number)).as(:joint_document)).maybe >>
         part.maybe >> iteration.maybe >>
         (space? >> (str(":") | str("-")) >> year).maybe >>
-        # stage before amendment
-        (
-          # stage before corrigendum
-          (supplement).maybe) >>
+        supplement.maybe >>
+        addendum.maybe >>
         edition.maybe >>
         language.maybe
     end
@@ -143,9 +179,9 @@ module Pubid::Iso
         (guide_prefix.as(:type) >> space).maybe >>
         (stage.as(:stage) >> space).maybe >>
         (typed_stage.as(:stage) >> space).maybe >>
-        originator >> (space | str("/")) >>
+        (originator >> (space | str("/"))).maybe >>
         (tc_document_body | std_document_body | (dir_document_body >>
-          (str(" + ") >> (originator >> space >> dir_document_body).as(:joint_document)).maybe))
+          (str(" + ") >> (originator >> space >> dir_document_body).as(:dir_joint_document)).maybe))
     end
 
     rule(:root) { identifier }

data/lib/pubid/iso/renderer/amendment.rb

@@ -0,0 +1,7 @@
+require_relative "supplement"
+
+module Pubid::Iso::Renderer
+  class Amendment < Supplement
+    TYPE = "Amd".freeze
+  end
+end