pubid-iso 0.3.0 → 0.4.0

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

@@ -11,33 +11,39 @@ module Pubid::Iso::Renderer
                IS: 60 }.freeze
 
     def prerender(with_edition: true, **args)
-      @params[:type_stage] = @params.slice(:stage, :type) if @params[:stage] || @params[:type]
+      # @params[:type_stage] = @params.slice(:stage, :type) if @params[:stage] || @params[:type]
       super
     end
 
     # Render identifier
     # @param with_edition [Boolean] include edition in output
-    # @see Pubid::Core::Renderer::Base for another options
-    def render(with_edition: true, **args)
-      # copy type from typed stage
-      @params[:type] = @params[:typed_stage].type if @params[:typed_stage] && @params[:typed_stage].type
-      super(**args.merge({ with_edition: with_edition }))
+    def render(with_edition: true, with_date: true, with_language_code: :iso, **args)
+      render_base_identifier(**args.merge(
+        { with_edition: with_edition,
+          with_date: with_date,
+          with_language_code: with_language_code },
+      ))
+    end
+
+    def render_prefix(params)
+      "urn:iso:std:%{publisher}%{copublisher}%{type}:%{number}%{part}" % params
     end
 
     def render_identifier(params)
-      render_base(params) + "%{typed_stage}"\
+      render_prefix(params) + "%{stage}"\
       "%{corrigendum_stage}%{iteration}%{edition}%{amendments}%{corrigendums}" % params
     end
 
-    def render_typed_stage(typed_stage, _opts, _params)
-      ":stage-#{typed_stage.stage.harmonized_code}" if typed_stage.stage
-    end
-    # def render_stage(stage, _opts, params)
-    #   ":stage-#{stage.harmonized_code}"
+    # def render_typed_stage(typed_stage, _opts, _params)
+    #   ":stage-#{typed_stage.stage.harmonized_code}" if typed_stage.stage
     # end
+    #
+    def render_stage(stage, _opts, params)
+      ":stage-#{stage.harmonized_code.to_s}"
+    end
 
     def render_iteration(iteration, _opts, params)
-      ".v#{iteration}" if params[:typed_stage]&.stage
+      ".v#{iteration}" if params[:stage]
     end
 
     def render_type(type, _, _)
@@ -47,5 +53,11 @@ module Pubid::Iso::Renderer
     def render_year(year, _opts, _params)
       ":#{year}"
     end
+
+    def render_part(part, opts, _params)
+      return ":-#{part.reverse.join('-')}" if part.is_a?(Array)
+
+      ":-#{part}"
+    end
   end
 end

data/lib/pubid/iso/stage.rb

@@ -1,103 +1,5 @@
 module Pubid::Iso
-  class Stage
-    attr_accessor :abbr, :harmonized_code
+  class Stage < Pubid::Core::Stage
 
-    STAGES = { PWI: %w[00.00 00.20 00.60 00.98 00.99],
-               NP: %w[10.00 10.20 10.60 10.98 10.92],
-               AWI: %w[20.00 10.99],
-               WD: %w[20.20 20.60 20.98 20.99],
-               CD: %w[30.00 30.20 30.60 30.92 30.98 30.99],
-               PRF: "60.00" }.freeze
-
-
-    STAGE_NAMES = {
-      WD: "Working Draft",
-      PWI: "Preliminary Work Item",
-      NP: "New Proposal",
-      CD: "Committee Draft",
-      PRF: "Proof of a new International Standard",
-    }.freeze
-
-    # @param abbr [String, Symbol] abbreviation eg. :PWI, :WD
-    # @param harmonized_code [String, Float, HarmonizedStageCode]
-    def initialize(abbr: nil, harmonized_code: nil)
-      @abbr = abbr&.to_s
-
-      if harmonized_code
-        @harmonized_code = if harmonized_code.is_a?(HarmonizedStageCode)
-                             harmonized_code
-                           else
-                             HarmonizedStageCode.new(harmonized_code)
-                           end
-        @abbr ||= lookup_abbr(@harmonized_code.stages)
-        # unless @harmonized_code.fuzzy?
-        #   @abbr ||= lookup_abbr(@harmonized_code.to_s) || lookup_abbr("#{@harmonized_code.stage}.00")
-        # end
-      end
-
-      if abbr
-        raise Errors::StageInvalidError, "#{abbr} is not valid stage" unless STAGES.key?(abbr.to_sym)
-
-        @harmonized_code ||= HarmonizedStageCode.new(lookup_code(abbr))
-      end
-    end
-
-    # Lookup for abbreviated code by numeric stage code
-    # @param lookup_code [String, Array] stage code or array of stage codes,
-    #   e.g. "00.00", "20.20", ["00.00", "00.20"]
-    def lookup_abbr(lookup_code)
-      lookup_code = lookup_code.first if lookup_code.is_a?(Array) && lookup_code.count == 1
-
-      STAGES.each do |abbr, codes|
-        case codes
-        when Array
-          if lookup_code.is_a?(Array)
-            return abbr if codes == lookup_code
-          else
-            return abbr if codes.include?(lookup_code)
-          end
-          # codes.each do |code|
-          #   return abbr if code == lookup_code
-          # end
-        when lookup_code
-          return abbr
-        end
-      end
-
-      nil
-    end
-
-    def lookup_code(lookup_abbr)
-      STAGES[lookup_abbr.to_sym]
-      # code.is_a?(Array) ? code.first : code
-    end
-
-    def self.parse(stage)
-      if /\A[\d.]+\z/.match?(stage)
-        Stage.new(harmonized_code: stage)
-      else
-        raise Errors::StageInvalidError unless stage.is_a?(Symbol) || stage.is_a?(String)
-
-        Stage.new(abbr: stage)
-      end
-    end
-
-    def self.has_stage?(stage)
-      if stage.is_a?(Stage)
-        STAGES.key?(stage.abbr.to_sym)
-      else
-        STAGES.key?(stage.to_sym) || /\A[\d.]+\z/.match?(stage)
-      end
-    end
-
-    # Compares one stage with another
-    def ==(other)
-      other&.harmonized_code == harmonized_code
-    end
-
-    # Return stage name, eg. "Draft International Standard" for "DIS"
-    def name
-      STAGE_NAMES[abbr.to_sym]
-    end
   end
 end

data/lib/pubid/iso/transformer.rb

@@ -1,67 +1,36 @@
+require_relative "identifier/base"
+require_relative "renderer/base"
+
 module Pubid::Iso
   class Transformer < Parslet::Transform
     rule(edition: "Ed") do
       { edition: "1" }
     end
 
-    rule(stage: simple(:stage)) do |context|
-      { stage: convert_stage(context[:stage]) }
+    rule(stage: subtree(:stage)) do |context|
+      stage_and_type = convert_stage(context[:stage])
+      context[:stage] = stage_and_type[:stage]
+      context[:type] = stage_and_type[:type] if stage_and_type[:type]
+      context
     end
 
     rule(supplements: subtree(:supplements)) do |context|
       context[:supplements] =
         context[:supplements].map do |supplement|
-          supplement[:typed_stage] = case supplement[:typed_stage]
-                                     when "PDAM"
-                                       "CD Amd"
-                                     when "pDCOR"
-                                       "CD Cor"
-                                     when "FCOR"
-                                       "FDCor"
-                                     when "FPDAM"
-                                       "DAmd"
-                                     when "FDAM"
-                                       "FDAmd"
-                                     else
-                                       supplement[:typed_stage]
-                                     end
-    #       Supplement.new(
-    #         number: supplement[:number],
-    #         year: supplement[:year],
-    #         typed_stage:
-    #           case supplement[:typed_stage]
-    #           when "FCOR"
-    #             "FDCor"
-    #           else
-    #             supplement[:typed_stage]
-    #           end,
-    #         iteration: supplement[:iteration]
-    #       )
-          supplement
-        end
-      context
-    end
-
-    rule(amendments: subtree(:amendments)) do |context|
-      context[:amendments] =
-        context[:amendments].map do |amendment|
-          Amendment.new(
-            number: amendment[:number],
-            year: amendment[:year],
-            typed_stage: amendment[:stage] && convert_stage(amendment[:stage]),
-            iteration: amendment[:iteration])
-        end
-      context
-    end
-
-    rule(corrigendums: subtree(:corrigendums)) do |context|
-      context[:corrigendums] =
-        context[:corrigendums].map do |corrigendum|
-          Corrigendum.new(
-            number: corrigendum[:number],
-            year: corrigendum[:year],
-            typed_stage: corrigendum[:stage] && convert_stage(corrigendum[:stage]),
-            iteration: corrigendum[:iteration])
+          if supplement[:typed_stage]
+            supplement.merge(
+              case supplement[:typed_stage]
+              when "PDAM"
+                { typed_stage: "CD", type: "Amd" }
+              when "pDCOR"
+                { typed_stage: "CD", type: "Cor" }
+              else
+                {}
+              end
+            )
+          else
+            supplement
+          end
         end
       context
     end
@@ -77,98 +46,113 @@ module Pubid::Iso
     end
 
     rule(type: simple(:type)) do
-      russian_type = Renderer::Russian::TYPE.key(type.to_s)
-      { type: Type.new(russian_type&.downcase&.to_sym ||
+      russian_type = Pubid::Iso::Renderer::Base::TRANSLATION[:russian][:type].key(type.to_s)
+      { type: russian_type&.downcase&.to_sym ||
                         case type
                         # XXX: can't put 2 alternative Russian translations to dictionary, temporary hack
-                        when "GUIDE", "Guide", "Руководства"
+                        when "GUIDE", "Guide", "Руководство"
                           :guide
                         when "ТС", "TS"
                           :ts
                         when "ТО", "TR"
                           :tr
-                        when "Directives Part", "Directives, Part", "Directives,"
+                        when "Directives Part", "Directives, Part", "Directives,", "DIR"
                           :dir
                         when "PAS"
                           :pas
                         when "DPAS"
                           :dpas
-                        when "DIR"
-                          :dir
+                        when "R"
+                          :r
                         else
                           type
-                        end) }
+                        end }
+    end
+
+    rule(tctype: subtree(:tctype))  do |context|
+      context[:type] = :tc
+      context
     end
 
     rule(copublisher: simple(:copublisher)) do
-      russian_copublisher = Renderer::Russian::PUBLISHER.key(copublisher.to_s)
+      russian_copublisher = Pubid::Iso::Renderer::Base::TRANSLATION[:russian][:publisher].key(copublisher.to_s)
       { copublisher: russian_copublisher&.to_s ||
         case copublisher
         when "CEI"
           "IEC"
         else
-          copublisher
+          copublisher.to_s
         end
       }
     end
 
     rule(publisher: simple(:publisher)) do
-      russian_publisher = Renderer::Russian::PUBLISHER.key(publisher.to_s)
+      russian_publisher = Pubid::Iso::Renderer::Base::TRANSLATION[:russian][:publisher].key(publisher.to_s)
       { publisher: russian_publisher&.to_s || publisher }
     end
 
-    # rule(year: simple(:year)) do
-    #   { year: year.to_i }
-    # end
-    #
-    rule(publisher: simple(:publisher), supplement: subtree(:supplement)) do |context|
-      context[:supplement] =
-        Supplement.new(number: context[:supplement][:number],
-                       year: context[:supplement][:year],
-                       publisher: context[:supplement][:publisher],
-                       edition: context[:supplement][:edition])
+    rule(joint_document: subtree(:joint_document)) do |context|
+      context[:joint_document] =
+        Identifier.create(**context[:joint_document])
       context
     end
 
-    rule(supplement: subtree(:supplement)) do |context|
-      context[:supplement] =
-        Supplement.new(number: context[:supplement][:number],
-                       year: context[:supplement][:year],
-                       publisher: context[:supplement][:publisher],
-                       edition: context[:supplement][:edition])
-      context
+    rule(dir_joint_document: subtree(:dir_joint_document)) do |context|
+      context[:joint_document] =
+        Identifier::Base.transform(**(context[:dir_joint_document].merge(type: :dir)))
+      context.select { |k, v| k != :dir_joint_document }
     end
 
-    rule(joint_document: subtree(:joint_document)) do |context|
-      context[:joint_document] =
-        Identifier.new(**context[:joint_document])
-      context
+
+    rule(roman_numerals: simple(:roman_numerals)) do |context|
+      roman_to_int(context[:roman_numerals])
+      # case roman_numerals
+      # when "III"
+      #   3
+      # else
+      #   nil
+      # end
+    end
+
+    ROMAN_TO_INT = {
+      "I" => 1,
+      "V" => 5,
+      "X" => 10,
+      "L" => 50,
+      "C" => 100,
+      "D" => 500,
+      "M" => 1000,
+    }
+
+    def self.roman_to_int(roman)
+      sum = ROMAN_TO_INT[roman.to_s[0]]
+      roman.to_s.chars.each_cons(2) do |c1, c2|
+        sum += ROMAN_TO_INT[c2]
+        sum -= ROMAN_TO_INT[c1] * 2 if ROMAN_TO_INT[c1] < ROMAN_TO_INT[c2]
+      end
+      sum
     end
 
     def self.convert_stage(code)
-      russian_code = Renderer::Russian::STAGE.key(code.to_s)
-      # return russian_code.to_s if russian_code
-
-      code = case code
-             when "NWIP"
-               "NP"
-             when "D", "FPD"
-               "DIS"
-             when "FD", "F"
-               "FDIS"
-             when "Fpr"
-               "PRF"
-             # when "pD", "PD"
-             #   "CD"
-             when "PDTR"
-               "CD TR"
-             when "PDTS"
-               "CD TS"
-             else
-               code
-             end
-      russian_code || code
-      # Stage.new(abbr: (russian_code || code))
+      russian_code = Pubid::Iso::Renderer::Base::TRANSLATION[:russian][:stage].key(code.to_s)
+      return { stage: russian_code } if russian_code
+
+      case code
+      when "NWIP"
+        { stage: "NP" }
+      when "D", "FPD"
+        { stage: "DIS" }
+      when "FD", "F"
+        { stage: "FDIS" }
+      when "Fpr"
+        { stage: "PRF" }
+      when "PDTR"
+        { stage: "CD", type: "TR" }
+      when "PDTS"
+        { stage: "CD", type: "TS" }
+      else
+        { stage: code }
+      end
     end
 
     def self.convert_language(code)

data/lib/pubid/iso/type.rb

@@ -41,11 +41,17 @@ module Pubid::Iso
       amd: {
         short: "Amd",
       },
+      r: {
+        long: "Recommendation",
+        short: "R",
+      },
     }.freeze
 
     # Create new type
     # @param type [Symbol]
-    def initialize(type)
+    def initialize(type = :is)
+      type = type.to_s.downcase.to_sym unless type.is_a?(Symbol)
+
       raise Errors::WrongTypeError, "#{type} type is not available" unless TYPE_NAMES.key?(type)
 
       @type = type
@@ -65,6 +71,8 @@ module Pubid::Iso
     def ==(other)
       return type == other if other.is_a?(Symbol)
 
+      return false if other.nil?
+
       type == other.type
     end
 

data/lib/pubid/iso/version.rb

@@ -1,5 +1,5 @@
 module Pubid
   module Iso
-    VERSION = "0.3.0".freeze
+    VERSION = "0.4.0".freeze
   end
 end

data/lib/pubid/iso.rb

@@ -1,30 +1,36 @@
 # frozen_string_literal: true
 
 require "parslet"
+require "yaml"
 
 module Pubid
   module Iso
-
+    UPDATE_CODES = YAML.load_file(File.join(File.dirname(__FILE__), "../../update_codes.yaml"))
   end
 end
 
+STAGES_CONFIG = YAML.load_file(File.join(File.dirname(__FILE__), "../../stages.yaml"))
+
 require "pubid-core"
 require_relative "iso/errors"
 require_relative "iso/stage"
 require_relative "iso/type"
-require_relative "iso/typed_stage"
 require_relative "iso/harmonized_stage_code"
-require_relative "iso/parser"
 require_relative "iso/transformer"
-require_relative "iso/supplement"
-require_relative "iso/amendment"
-require_relative "iso/corrigendum"
 require_relative "iso/identifier"
-require_relative "iso/renderer/base"
-require_relative "iso/renderer/urn"
-require_relative "iso/renderer/french"
-require_relative "iso/renderer/russian"
-require_relative "iso/renderer/tc"
-require_relative "iso/renderer/urn-tc"
-require_relative "iso/renderer/dir"
-require_relative "iso/renderer/urn-dir"
+require_relative "iso/identifier/base"
+require_relative "iso/identifier/international_standard"
+require_relative "iso/identifier/international_standardized_profile"
+require_relative "iso/identifier/technical_report"
+require_relative "iso/identifier/technical_specification"
+require_relative "iso/identifier/technical_committee"
+require_relative "iso/identifier/supplement"
+require_relative "iso/identifier/amendment"
+require_relative "iso/identifier/corrigendum"
+require_relative "iso/identifier/publicly_available_specification"
+require_relative "iso/identifier/directives"
+require_relative "iso/identifier/guide"
+require_relative "iso/identifier/recommendation"
+require_relative "iso/identifier/technology_trends_assessments"
+require_relative "iso/identifier/international_workshop_agreement"
+require_relative "iso/parser"

data/stages.yaml

@@ -0,0 +1,93 @@
+abbreviations:
+  PWI: ["00.00", "00.20", "00.60", "00.98", "00.99"]
+  NP: ["10.00", "10.20", "10.60", "10.98", "10.92"]
+  AWI: ["20.00", "10.99"]
+  WD: ["20.20", "20.60", "20.98", "20.99"]
+  CD: ["30.00", "30.20", "30.60", "30.92", "30.98", "30.99"]
+  PRF: ["50.00", "50.20", "50.60", "50.92", "50.98", "50.99"]
+
+names:
+  WD: Working Draft
+  PWI: Preliminary Work Item
+  NP: New Proposal
+  CD: Committee Draft
+  PRF: Proof of a new
+
+codes_description:
+  "00.00": Proposal for new project received
+  "00.20": Proposal for new project under review
+  "00.60": Close of review
+  "00.98": Proposal for new project abandoned
+  "00.99": Approval to ballot proposal for new project
+  "10.00": Proposal for new project registered
+  "10.20": New project ballot initiated
+  "10.60": Close of voting
+  "10.92": Proposal returned to submitter for further definition
+  "10.98": New project rejected
+  "10.99": New project approved
+  "20.00": New project registered in TC/SC work programme
+  "20.20": Working draft (WD) study initiated
+  "20.60": Close of comment period
+  "20.98": Project deleted
+  "20.99": WD approved for registration as CD
+  "30.00": Committee draft (CD) registered
+  "30.20": CD study/ballot initiated
+  "30.60": Close of voting/ comment period
+  "30.92": CD referred back to Working Group
+  "30.98": Project deleted
+  "30.99": CD approved for registration as DIS
+  "40.00": DIS registered
+  "40.20": "DIS ballot initiated: 12 weeks"
+  "40.60": Close of voting
+  "40.93": "Full report circulated: decision for new DIS ballot"
+  "40.98": Project deleted
+  "40.92": "Full report circulated: DIS referred back to TC or SC"
+  "40.99": "Full report circulated: DIS approved for registration as FDIS"
+  "50.00": Final text received or FDIS registered for formal approval
+  "50.20": "Proof sent to secretariat or FDIS ballot initiated: 8 weeks"
+  "50.60": Close of voting. Proof returned by secretariat
+  "50.92": FDIS or proof referred back to TC or SC
+  "50.98": Project deleted
+  "50.99": FDIS or proof approved for publication
+  "60.00": International Standard under publication
+  "60.60": International Standard published
+  "90.20": International Standard under systematic review
+  "90.60": Close of review
+  "90.92": International Standard to be revised
+  "90.93": International Standard confirmed
+  "90.99": Withdrawal of International Standard proposed by TC or SC
+  "95.20": Withdrawal ballot initiated
+  "95.60": Close of voting
+  "95.92": Decision not to withdraw International Standard
+  "95.99": Withdrawal of International Standard
+
+stage_codes:
+  preliminary: "00"
+  proposal: "10"
+  preparatory: "20"
+  committee: "30"
+  enquiry: "40"
+  approval: "50"
+  publication: "60"
+  review: "90"
+  withdrawal: "95"
+
+substage_codes:
+  registration: "00"
+  start_of_main_action: "20"
+  completion_of_main_action: "60"
+  repeat_an_earlier_phase: "92"
+  repeat_current_phase: "93"
+  abandon: "98"
+  proceed: "99"
+
+draft_codes: ["00.00", "00.20", "00.60", "00.99", "10.00", "10.20", "10.60", "10.92",
+  "10.99", "20.00", "20.20", "20.60", "20.99", "30.00",
+  "30.20", "30.60", "30.92", "30.99", "40.00", "40.20", "40.60", "40.92",
+  "40.93", "40.99", "50.00", "50.20", "50.60", "50.92", "50.99"]
+
+canceled_codes: ["00.98", "10.98", "20.98", "30.98", "40.98", "50.98", "95.99"]
+published_codes: ["60.00", "60.60", "90.20", "90.60", "90.92", "90.93", "90.99", "95.20", "95.60", "95.92"]
+
+
+

data/update_codes.yaml

@@ -0,0 +1 @@
+ISO/R 657/IV: ISO/R 657-4:1969