relaton-gb 0.1.0

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/relaton/processor.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "relaton/processor"
+
+module Relaton
+  module RelatonGb
+    class Processor < Relaton::Processor
+
+      def initialize
+        @short = :relaton_gb
+        @prefix = "CN"
+        @defaultprefix = %r{^GB }
+        @idtype = "Chinese Standard"
+      end
+
+      def get(code, date, opts)
+        ::RelatonGb::GbBibliography.get(code, date, opts)
+      end
+
+      def from_xml(xml)
+        ::RelatonGb::XMLParser.from_xml xml
+      end
+    end
+  end
+end

data/lib/relaton_gb.rb

@@ -0,0 +1,7 @@
+require "relaton_gb/version"
+require "relaton_gb/gb_bibliography"
+
+if defined? Relaton
+  require_relative "relaton/processor"
+  Relaton::Registry.instance.register Relaton::RelatoGb::Processor
+end

data/lib/relaton_gb/gb_bibliographic_item.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "relaton_iso_bib"
+require "cnccs"
+require "relaton_gb/gb_technical_committee"
+require "relaton_gb/gb_standard_type"
+require "relaton_gb/xml_parser"
+
+module RelatonGb
+  # GB bibliographic item class.
+  class GbBibliographicItem < RelatonIsoBib::IsoBibliographicItem
+    # @return [RelatonGb::GbTechnicalCommittee]
+    attr_reader :committee
+
+    # @return [RelatonGb::GbStandardType]
+    attr_reader :gbtype
+
+    # @return [String]
+    attr_reader :topic
+
+    # @return [Array<Cnccs::Ccs>]
+    attr_reader :ccs
+
+    # @return [String]
+    attr_reader :plan_number
+
+    # @return [String]
+    attr_reader :type, :gbplannumber
+
+    def initialize(**args)
+      super
+      args[:committee] && @committee = GbTechnicalCommittee.new(args[:committee])
+      @ccs = args[:ccs].map { |c| Cnccs.fetch c }
+      @gbtype = GbStandardType.new args[:gbtype]
+      @type = args[:type]
+      @gbplannumber = args[:gbplannumber] || structuredidentifier.project_number
+    end
+
+    # @param builder [Nokogiri::XML::Builder]
+    # @return [String]
+    def to_xml(builder = nil, **opts)
+      if builder
+        super(builder, **opts) { |xml| render_gbxml(xml) }
+      else
+        Nokogiri::XML::Builder.new(encoding: "UTF-8") do |bldr|
+          super(bldr, **opts) { |xml| render_gbxml(xml) }
+        end.doc.root.to_xml
+      end
+    end
+
+    # @return [String]
+    def inspect
+      "<#{self.class}:#{format('%#.14x', object_id << 1)}>"
+      # "@fullIdentifier=\"#{@fetch&.shortref}\" "\
+      # "@title=\"#{title}\">"
+    end
+
+    # @return [String]
+    def to_s
+      inspect
+    end
+
+    def makeid(id, attribute, _delim = "")
+      return nil if attribute && !@id_attribute
+
+      id ||= @docidentifier.reject { |i| i.type == "DOI" }[0]
+      idstr = id.id
+      # if id.part_number&.size&.positive?
+      #   idstr = idstr + "-#{id.part_number}"
+      # end
+      idstr.gsub(/\s/, "").strip
+    end
+
+    private
+
+    # Overraides IsoBibliographicItem method.
+    # @param language [Array<String>]
+    # @raise ArgumentError
+    def check_language(language)
+      language.each do |lang|
+        unless %w[en zh].include? lang
+          raise ArgumentError, "invalid language: #{lang}"
+        end
+      end
+    end
+
+    # Overraides IsoBibliographicItem method.
+    # @param script [Array<String>]
+    # @raise ArgumentError
+    def check_script(script)
+      script.each do |scr|
+        raise ArgumentError, "invalid script: #{scr}" unless %w[Latn Hans].include? scr
+      end
+    end
+
+    # @param builder [Nokogiri::XML::Builder]
+    def render_gbxml(builder)
+      gbtype.to_xml builder
+      return unless ccs.any?
+
+      ccs.each do |c|
+        builder.ccs do
+          builder.code c.code
+          builder.text_ c.description
+        end
+      end
+
+      builder.gbplannumber gbplannumber if gbplannumber
+    end
+  end
+end

data/lib/relaton_gb/gb_bibliography.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "relaton_gb/gb_bibliographic_item"
+require "relaton_gb/gb_standard_type"
+require "relaton_gb/hit_collection"
+require "relaton_gb/hit"
+
+# GB bib module.
+module RelatonGb
+  # GB entry point class.
+  class GbBibliography
+    class << self
+      # rubocop:disable Metrics/MethodLength
+      # @param text [Strin] code of standard for search
+      # @return [RelatonGb::HitCollection]
+      def search(text)
+        if text =~ /^(GB|GJ|GS)/
+          # Scrape national standards.
+          require "relaton_gb/gb_scrapper"
+          GbScrapper.scrape_page text
+        elsif text =~ /^ZB/
+          # Scrape proffesional.
+        elsif text =~ /^DB/
+          # Scrape local standard.
+        elsif text =~ %r{^Q\/}
+          # Enterprise standard
+        elsif text =~ %r{^T\/[^\s]{3,6}\s}
+          # Scrape social standard.
+          require "relaton_gb/t_scrapper"
+          TScrapper.scrape_page text
+        else
+          # Scrape sector standard.
+          require "relaton_gb/sec_scrapper"
+          SecScrapper.scrape_page text
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      # @param code [String] the GB standard Code to look up (e..g "GB/T 20223")
+      # @param year [String] the year the standard was published (optional)
+      # @param opts [Hash] options; restricted to :all_parts if all-parts reference is required
+      # @return [String] Relaton XML serialisation of reference
+      def get(code, year = nil, opts = {})
+        if year.nil?
+          /^(?<code1>[^-]+)-(?<year1>[^-]+)$/ =~ code
+          unless code1.nil?
+            code = code1
+            year = year1
+          end
+        end
+
+        code += ".1" if opts[:all_parts]
+        code, year = code.split(/-/, 2) if /-/ =~ code
+        ret = get1(code, year, opts)
+        return nil if ret.nil?
+
+        ret.to_most_recent_reference unless year
+        ret.to_all_parts if opts[:all_parts]
+        ret
+      end
+
+      private
+
+      def fetch_ref_err(code, year, missed_years)
+        id = year ? "#{code}:#{year}" : code
+        warn "WARNING: no match found on the GB website for #{id}. "\
+          "The code must be exactly like it is on the website."
+        warn "(There was no match for #{year}, though there were matches "\
+          "found for #{missed_years.join(', ')}.)" unless missed_years.empty?
+        if /\d-\d/ =~ code
+          warn "The provided document part may not exist, or the document "\
+            "may no longer be published in parts."
+        else
+          warn "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
+
+      def get1(code, year, _opts)
+        # search must include year whenever available
+        searchcode = code + (year.nil? ? "" : "-#{year}")
+        result = search_filter(searchcode) || return
+        ret = results_filter(result, year)
+        return ret[:ret] if ret[:ret]
+
+        fetch_ref_err(code, year, ret[:years])
+      end
+
+      def search_filter(code)
+        # search filter needs to incorporate year
+        docidrx = %r{^[^\s]+\s[\d\.-]+}
+        # corrigrx = %r{^[^\s]+\s[\d\.]+-[0-9]+/}
+        warn "fetching #{code}..."
+        result = search(code)
+        ret = result.select do |hit|
+          hit.title && hit.title.match(docidrx).to_s == code # &&
+            # !corrigrx =~ hit.title
+        end
+        return ret unless ret.empty?
+
+        []
+      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 results_filter(result, year)
+        missed_years = []
+        result.each_slice(3) do |s| # ISO website only allows 3 connections
+          fetch_pages(s, 3).each_with_index do |r, i|
+            return { ret: r } if !year
+
+            r.dates.select { |d| d.type == "published" }.each do |d|
+              return { ret: r } if year.to_i == d.on.year
+
+              missed_years << d.on.year
+            end
+          end
+        end
+        { years: missed_years }
+      end
+
+      def fetch_pages(s, n)
+        workers = RelatonBib::WorkersPool.new n
+        workers.worker { |w| { i: w[:i], hit: w[:hit].fetch } }
+        s.each_with_index { |hit, i| workers << { i: i, hit: hit } }
+        workers.end
+        workers.result.sort { |x, y| x[:i] <=> y[:i] }.map { |x| x[:hit] }
+      end
+    end
+  end
+end

data/lib/relaton_gb/gb_scrapper.rb

@@ -0,0 +1,51 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require "open-uri"
+require "nokogiri"
+require "relaton_gb/scrapper"
+require "relaton_gb/gb_bibliographic_item"
+
+module RelatonGb
+  # National standard scrapper.
+  module GbScrapper
+    extend Scrapper
+
+    class << self
+      # @param text [Strin] code of standard for serarch
+      # @return [RelatonGb::HitCollection]
+      def scrape_page(text)
+        search_html = OpenURI.open_uri(
+          "http://www.std.gov.cn/search/stdPage?q=" + text
+        )
+        result = Nokogiri::HTML search_html
+        hits = result.css(".s-title a").map do |h|
+          Hit.new pid: h[:pid], title: h.text, scrapper: self
+        end
+        HitCollection.new hits
+      rescue OpenURI::HTTPError, SocketError
+        warn "Cannot access http://www.std.gov.cn/search/stdPage"
+      end
+
+      # @param pid [Strin] standard's page id
+      # @return [RelatonGb::GbBibliographicItem]
+      def scrape_doc(pid)
+        src = "http://www.std.gov.cn/gb/search/gbDetailed?id=" + pid
+        doc = Nokogiri::HTML OpenURI.open_uri(src)
+        GbBibliographicItem.new scrapped_data(doc, src: src)
+      rescue OpenURI::HTTPError, SocketError
+        warn "Cannot access http://www.std.gov.cn/gb/search/gbDetailed"
+      end
+
+      # @param doc [Nokogiri::HTML]
+      # @return [Hash]
+      #   * :type [String]
+      #   * :name [String]
+      def get_committee(doc)
+        name = doc.xpath("//p/a[1]/following-sibling::text()").text.
+          match(/(?<=（)[^）]+/).to_s
+        { type: "technical", name: name }
+      end
+    end
+  end
+end

data/lib/relaton_gb/gb_standard_type.rb

@@ -0,0 +1,30 @@
+module RelatonGb
+  # GB standard type.
+  class GbStandardType
+    # @return [String]
+    attr_reader :scope
+
+    # @return [String]
+    attr_reader :prefix
+
+    # @return [String]
+    attr_reader :mandate
+
+    # @param scope [String]
+    # @param prefix [String]
+    # @param mandate [String]
+    def initialize(scope:, prefix:, mandate:)
+      @scope   = scope
+      @prefix  = prefix
+      @mandate = mandate
+    end
+
+    def to_xml(builder)
+      builder.gbtype do
+        builder.gbscope @scope
+        builder.gbprefix @prefix
+        builder.gbmandate @mandate
+      end
+    end
+  end
+end

data/lib/relaton_gb/gb_technical_committee.rb

@@ -0,0 +1,23 @@
+module RelatonGb
+  # GB technical committee.
+  class GbTechnicalCommittee
+    # @return [String]
+    attr_reader :type
+
+    # @return [String]
+    attr_reader :name
+
+    # @param type [String]
+    # @param name [String]
+    def initialize(type:, name:)
+      @type = type
+      @name = name
+    end
+
+    def to_xml(builder)
+      builder.gbcommittee(type: @type) do
+        builder.text @name
+      end
+    end
+  end
+end

data/lib/relaton_gb/hit.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RelatonGb
+  # Hit.
+  class Hit
+    # @return [Isobib::HitCollection]
+    attr_reader :hit_collection
+
+    # @return [String]
+    attr_reader :pid
+
+    # @return [String]
+    attr_reader :title
+
+    # @return [RelatonGb::GbScrapper, RelatonGb::SecScraper, RelatonGb::TScrapper]
+    attr_reader :scrapper
+
+    # @param hit [Hash]
+    # @param hit_collection [Isobib:HitCollection]
+    def initialize(pid:, title:, hit_collection: nil, scrapper:)
+      @pid            = pid
+      @title          = title
+      @hit_collection = hit_collection
+      @scrapper       = scrapper
+      self.hit_collection << self if hit_collection
+    end
+
+    # Parse page.
+    # @return [Isobib::IsoBibliographicItem]
+    def fetch
+      @fetch ||= scrapper.scrape_doc pid
+    end
+
+    # @return [String]
+    def to_s
+      inspect
+    end
+
+    # @return [String]
+    def inspect
+      "<#{self.class}:#{format('%#.14x', object_id << 1)} "\
+      "@fullIdentifier=\"#{@fetch&.shortref}\" "\
+      "@title=\"#{title}\">"
+    end
+
+    # @param builder [Nokogiri::XML::Builder]
+    # @param opts [Hash]
+    # @return [String]
+    # def to_xml(builder = nil, opts = {})
+    #   if builder
+    #     fetch.to_xml builder, opts
+    #   else
+    #     builder = Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
+    #       fetch.to_xml xml, opts
+    #     end
+    #     builder.doc.root.to_xml
+    #   end
+    # end
+  end
+end