pubid-core 0.1.4 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c1b28bf047f8339b5d96fb9ef3ea58aede3156ef1f2379e360afcdb96137c5f3
-  data.tar.gz: 557dd8e1e246b9caf278abcf439001696890f8594116232be357f614b1ae93bd
+  metadata.gz: 9895b8d56bf37310135d11148c71ea31514d203a4157b6d6bcb9a4d4df81be58
+  data.tar.gz: 92d7bc8de5d97c2bda090ba2e2056819d29a31fff22f67495a7a4947ffaecc98
 SHA512:
-  metadata.gz: 78378ed3583f405d843f655ae5e9aee45e071506db0c6a88705ac65f28c2f69b6fcd3304e87578f14742f2fdcca16a32b320e0b2ea51851438115e1dc7aae66d
-  data.tar.gz: a8422326efe996a0d00aea25b3eda737e598a3e32c7136c47a4112cc57ef1576cc9f967b05b260b8851d2c76290fa75418f0b4f4274be0fbe52eb32911b85e9f
+  metadata.gz: 57ad7508563a1bd967e6d60ff78faa2ea7a26e954a001545f0220ccfbbfe6efe935d7d0f8e9a0dec06ef27fb93e5620c6a1e3ca50a43a71b019e63d5bfab4a6b
+  data.tar.gz: 0eda4ada9150f10b557a57610f802463773e8573c6f059180cec900ca769e205aa08e51e17d7152b11be88d57fd261b9b1b19d22f5744b51711b5ad1363569d8

data/lib/pubid/core/amendment.rb

@@ -0,0 +1,14 @@
+module Pubid::Core
+  class Amendment < Supplement
+
+    def render_pubid
+      stage = render_pubid_stage
+      stage += " " unless stage.size == 0
+      "/#{stage}Amd #{render_pubid_number}"
+    end
+
+    def render_urn
+      "#{render_urn_stage}:amd#{render_urn_number}"
+    end
+  end
+end

data/lib/pubid/core/corrigendum.rb

@@ -0,0 +1,14 @@
+module Pubid::Core
+  class Corrigendum < Supplement
+
+    def render_pubid
+      stage = render_pubid_stage
+      stage += " " unless stage.size == 0
+      "/#{stage}Cor #{render_pubid_number}"
+    end
+
+    def render_urn
+      "#{render_urn_stage}:cor#{render_urn_number}"
+    end
+  end
+end

data/lib/pubid/core/errors.rb

@@ -0,0 +1,5 @@
+module Pubid::Core
+  module Errors
+    class ParseError < StandardError; end
+  end
+end

data/lib/pubid/core/identifier.rb

@@ -0,0 +1,87 @@
+module Pubid::Core
+  class Identifier
+    attr_accessor :number, :publisher, :copublisher, :part,
+                  :type, :year, :edition, :language, :amendments,
+                  :corrigendums
+
+    def initialize(amendments: nil, corrigendums: nil, **opts)
+      if amendments
+        @amendments = if amendments.is_a?(Array)
+                        amendments.map do |amendment|
+                          self.class.get_amendment_class.new(**amendment)
+                        end
+                      else
+                        [self.class.get_amendment_class.new(**amendments)]
+                      end
+      end
+      if corrigendums
+        @corrigendums = if corrigendums.is_a?(Array)
+                          corrigendums.map do |corrigendum|
+                            self.class.get_corrigendum_class.new(**corrigendum)
+                          end
+                        else
+                          [self.class.get_corrigendum_class.new(**corrigendums)]
+                        end
+      end
+
+      opts.each { |key, value| send("#{key}=", value.is_a?(Array) && value || value.to_s) }
+    end
+
+    def urn
+      Renderer::Urn.new(get_params).render
+    end
+
+    def get_params
+      instance_variables.map { |var| [var.to_s.gsub("@", "").to_sym, instance_variable_get(var)] }.to_h
+    end
+
+    def to_s
+      self.class.get_renderer_class.new(get_params).render
+    end
+
+    class << self
+      def get_amendment_class
+        Amendment
+      end
+
+      def get_corrigendum_class
+        Corrigendum
+      end
+
+      def get_renderer_class
+        Renderer::Base
+      end
+
+      def get_transformer_class
+        Transformer
+      end
+
+      def parse(code_or_params)
+        params = code_or_params.is_a?(String) ? get_parser_class.new.parse(code_or_params) : code_or_params
+        # Parslet returns an array when match any copublisher
+        # otherwise it's hash
+        if params.is_a?(Array)
+          new(
+            **(
+              params.inject({}) do |r, i|
+                result = r
+                i.map {|k, v| get_transformer_class.new.apply(k => v).to_a.first }.each do |k, v|
+                  result = result.merge(k => r.key?(k) ? [v, r[k]] : v)
+                end
+                result
+              end
+            )
+          )
+        else
+          new(**params.map do |k, v|
+            get_transformer_class.new.apply(k => v).to_a.first
+          end.to_h)
+        end
+        # merge values repeating keys into array (for copublishers)
+
+      rescue Parslet::ParseFailed => failure
+        raise Pubid::Iso::Errors::ParseError, "#{failure.message}\ncause: #{failure.parse_failure_cause.ascii_tree}"
+      end
+    end
+  end
+end

data/lib/pubid/core/renderer/base.rb

@@ -0,0 +1,100 @@
+module Pubid::Core::Renderer
+  class Base
+    attr_accessor :params
+
+    LANGUAGES = {
+      "ru" => "R",
+      "fr" => "F",
+      "en" => "E",
+      "ar" => "A",
+    }.freeze
+
+    def initialize(params)
+      @params = params
+    end
+
+    def prerender_params(params, opts)
+      params.map do |key, value|
+        if respond_to?("render_#{key}")
+          [key, send("render_#{key}", value, opts, params)]
+        else
+          [key, value]
+        end
+      end.to_h
+    end
+
+    # render from hash keys
+    def render(with_date: true, with_language_code: :iso)
+      params = prerender_params(@params,
+                                { with_date: with_date, with_language_code: with_language_code })
+      # render empty string when the key is not exist
+      params.default = ""
+
+      render_identifier(params)
+    end
+
+    def render_identifier(params)
+      "%{publisher}%{copublisher}%{type}%{stage} %{number}%{part}%{iteration}"\
+        "%{year}%{edition}%{amendments}%{corrigendums}%{language}" % params
+    end
+
+    def render_copublisher(copublisher, _opts, _params)
+      # (!@copublisher.is_a?(Array) && [@copublisher]) || @copublisher
+      if copublisher.is_a?(Array)
+        copublisher.map(&:to_s).sort.map do |copublisher|
+          "/#{copublisher.gsub('-', '/')}"
+        end.join
+      else
+        "/#{copublisher}"
+      end
+    end
+
+    def render_amendments(amendments, _opts, _params)
+      amendments.map(&:render_pubid).join("+")
+    end
+
+    def render_corrigendums(corrigendums, _opts, _params)
+      corrigendums.map(&:render_pubid).join("+")
+    end
+
+    def render_type(type, opts, params)
+      if params[:copublisher]
+        " #{type}"
+      else
+        "/#{type}"
+      end
+    end
+
+    def render_stage(stage, opts, params)
+      if params[:copublisher]
+        " #{stage}"
+      else
+        "/#{stage}"
+      end
+    end
+
+    def render_part(part, opts, _params)
+      "-#{part}"
+    end
+
+    def render_year(year, opts, _params)
+      opts[:with_date] && ":#{year}" || ""
+    end
+
+    def render_language(language, opts, _params)
+      if opts[:with_language_code] == :single
+        "(#{LANGUAGES[language]})"
+      else
+        "(#{language})"
+      end
+    end
+    
+    def render_edition(edition, _opts, _params)
+      " ED#{edition}"
+    end
+
+    def render_iteration(iteration, _opts, _params)
+      ".#{iteration}"
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+module Pubid::Core::Renderer
+  class Urn < Base
+    STAGES = { PWI: 0,
+               NP: 10,
+               AWI: 20,
+               WD: 20.20,
+               CD: 30,
+               DIS: 40,
+               FDIS: 50,
+               PRF: 50,
+               IS: 60 }.freeze
+
+    def render_identifier(params)
+      "urn:iso:std:%{publisher}%{copublisher}%{type}:%{number}%{part}%{stage}"\
+      "%{urn_stage}%{corrigendum_stage}%{iteration}%{edition}%{amendments}%{corrigendums}%{language}" % params
+    end
+
+    def render_publisher(publisher, _opts, _params)
+      publisher.downcase
+    end
+
+    def render_copublisher(copublisher, _opts, _params)
+      return "-#{copublisher.downcase}" unless copublisher.is_a?(Array)
+
+      copublisher.map(&:to_s).sort.map do |copublisher|
+        "-#{copublisher.downcase}"
+      end.join
+    end
+
+    def render_edition(edition, _opts, _params)
+      ":ed-#{edition}"
+    end
+
+    def render_type(type, _, _)
+      ":#{type.downcase}"
+    end
+
+    def render_amendments(amendments, _opts, _params)
+      amendments&.map(&:render_urn)&.join || ""
+    end
+
+    def render_corrigendums(corrigendums, _opts, _params)
+      corrigendums&.map(&:render_urn)&.join || ""
+    end
+
+    def render_language(language, _opts, _params)
+      ":#{language}"
+    end
+
+    def render_stage(stage, _opts, _params)
+      return ":stage-#{sprintf('%05.2f', stage)}" if stage.is_a?(Float)
+
+      ":stage-#{sprintf('%05.2f', STAGES[stage.to_sym])}"
+    end
+
+    def render_urn_stage(stage, opts, params)
+      render_stage(stage, opts, params)
+    end
+
+    def render_corrigendum_stage(stage, opts, params)
+      render_stage(stage, opts, params)
+    end
+
+    def render_iteration(iteration, _opts, params)
+      ".v#{iteration}" if params[:stage]
+    end
+
+    def render_part(part, _opts, _params)
+      ":-#{part}"
+    end
+  end
+end

data/lib/pubid/core/supplement.rb

@@ -0,0 +1,29 @@
+module Pubid::Core
+  class Supplement
+    attr_accessor :version, :number, :stage
+
+    def initialize(version:, number: nil, stage: nil)
+      @version, @number, @stage = version, number, stage
+    end
+
+    def ==(other)
+      other.version == version && (number.nil? || other.number == number) && (stage.nil? || other.stage == stage)
+    end
+
+    def render_pubid_number
+        if @number
+          "#{@version}:#{@number}"
+        else
+          "#{@version}"
+        end
+    end
+
+    def render_urn_number
+        if @number
+          ":#{@number}:v#{@version}"
+        else
+          ":#{@version}:v1"
+        end
+    end
+  end
+end

data/lib/pubid/core/transformer.rb

@@ -0,0 +1,4 @@
+module Pubid::Core
+  class Transformer < Parslet::Transform
+  end
+end

data/lib/pubid/core/version.rb

@@ -1,5 +1,5 @@
 module Pubid
   module Core
-    VERSION = "0.1.4".freeze
+    VERSION = "0.1.7".freeze
   end
 end

data/lib/pubid/core.rb

@@ -1,3 +1,11 @@
 require "parslet"
 
+require_relative "core/errors"
 require_relative "core/parser"
+require_relative "core/supplement"
+require_relative "core/amendment"
+require_relative "core/corrigendum"
+require_relative "core/transformer"
+require_relative "core/renderer/base"
+require_relative "core/renderer/urn"
+require_relative "core/identifier"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pubid-core
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.7
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-06-04 00:00:00.000000000 Z
+date: 2022-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -65,7 +65,15 @@ files:
 - README.adoc
 - lib/pubid-core.rb
 - lib/pubid/core.rb
+- lib/pubid/core/amendment.rb
+- lib/pubid/core/corrigendum.rb
+- lib/pubid/core/errors.rb
+- lib/pubid/core/identifier.rb
 - lib/pubid/core/parser.rb
+- lib/pubid/core/renderer/base.rb
+- lib/pubid/core/renderer/urn.rb
+- lib/pubid/core/supplement.rb
+- lib/pubid/core/transformer.rb
 - lib/pubid/core/version.rb
 homepage: https://github.com/metanorma/pubid-core
 licenses: