relaton-ogc 0.1.0

data/lib/relaton_ogc/hash_converter.rb

@@ -0,0 +1,20 @@
+module RelatonOgc
+  class HashConverter < RelatonIsoBib::HashConverter
+    class << self
+      private
+
+      # @param ret [Hash]
+      def editorialgroup_hash_to_bib(ret)
+        eg = ret[:editorialgroup]
+        return unless eg
+
+        ret[:editorialgroup] = EditorialGroup.new(
+          committee: eg[:committee],
+          subcommittee: eg[:subcommittee],
+          workgroup: eg[:workgroup],
+          secretariat: eg[:secretariat],
+        )
+      end
+    end
+  end
+end

data/lib/relaton_ogc/hit.rb

@@ -0,0 +1,12 @@
+module RelatonOgc
+  class Hit < RelatonBib::Hit
+    # @return [RelatonNist::HitCollection]
+    attr_reader :hit_collection
+
+    # Parse page.
+    # @return [RelatonNist::NistBliographicItem]
+    def fetch
+      @fetch ||= Scrapper.parse_page @hit
+    end
+  end
+end

data/lib/relaton_ogc/hit_collection.rb

@@ -0,0 +1,78 @@
+require "faraday"
+require "relaton_ogc/hit"
+
+module RelatonOgc
+  class HitCollection < RelatonBib::HitCollection
+    ENDPOINT = "https://raw.githubusercontent.com/opengeospatial/"\
+      "NamingAuthority/master/incubation/bibliography/bibliography.json".freeze
+    DATAFILE = File.expand_path "data/bibliography.json", __dir__
+    ETAGFILE = File.expand_path "data/etag.txt", __dir__
+
+    # @param ref [Strig]
+    # @param year [String]
+    # @param opts [Hash]
+    def initialize(ref, year = nil, _opts = {})
+      @text = ref
+      @year = year
+      @fetched = false
+      hits = from_json(ref).sort_by do |hit|
+        hit.hit["date"] ? Date.parse(hit.hit["date"]) : Date.new
+      end
+      concat hits.reverse
+    end
+
+    private
+
+    #
+    # Fetch data form json
+    #
+    # @param docid [String]
+    def from_json(docid, **_opts)
+      ref = docid.sub /^OGC\s/, ""
+      data.select do |_k, doc|
+        doc["type"] != "CC" && doc["identifier"].include?(ref)
+      end.map { |_k, h| Hit.new(h, self) }
+    end
+
+    #
+    # Fetches json data
+    #
+    # @return [Hash]
+    def data
+      ctime = File.ctime DATAFILE if File.exist? DATAFILE
+      fetch_data if !ctime || ctime.to_date < Date.today
+      @data ||= JSON.parse File.read(DATAFILE, encoding: "UTF-8")
+    end
+
+    #
+    # fetch data form server and save it to file.
+    #
+    def fetch_data
+      resp = Faraday.new(ENDPOINT, headers: { "If-None-Match" => etag }).get
+      # return if there aren't any changes since last fetching
+      return unless resp.status == 200
+
+      self.etag = resp[:etag]
+      @data = JSON.parse resp.body
+      File.write DATAFILE, @data.to_json, encoding: "UTF-8"
+    end
+
+    #
+    # Read ETag form file
+    #
+    # @return [String, NilClass]
+    def etag
+      @etag ||= if File.exist? ETAGFILE
+                  File.read ETAGFILE, encoding: "UTF-8"
+                end
+    end
+
+    #
+    # Save ETag to file
+    #
+    # @param tag [String]
+    def etag=(e_tag)
+      File.write ETAGFILE, e_tag, encoding: "UTF-8"
+    end
+  end
+end

data/lib/relaton_ogc/ogc_bibliographic_item.rb

@@ -0,0 +1,11 @@
+module RelatonOgc
+  class OgcBibliographicItem < RelatonIsoBib::IsoBibliographicItem
+    TYPES = %w[
+      standard standard-with-suite
+      abstract-specification best-practice candidate-standard conformance-class
+      change-request community-standard discussion-paper draft-discussion-paper
+      interoperability-program-report implementation-standard
+      public-engineering-report
+    ].freeze
+  end
+end

data/lib/relaton_ogc/ogc_bibliography.rb

@@ -0,0 +1,77 @@
+module RelatonOgc
+  class OgcBibliography
+    class << self
+      # @param text [String]
+      # @return [RelatonOgc::HitCollection]
+      def search(text, year = nil, opts = {})
+        HitCollection.new text, year, opts
+      rescue Faraday::Error::ConnectionFailed
+        raise RelatonBib::RequestError, "Could not access https://www.nist.gov"
+      end
+
+      # @param code [String] the OGC standard Code to look up (e..g "8200")
+      # @param year [String] the year the standard was published (optional)
+      #
+      # @param opts [Hash] options
+      # @option opts [TrueClass, FalseClass] :all_parts restricted to all parts
+      #   if all-parts reference is required
+      # @option opts [TrueClass, FalseClass] :bibdata
+      #
+      # @return [String] Relaton XML serialisation of reference
+      def get(code, year = nil, opts = {})
+        result = bib_search_filter(code, year, opts) || (return nil)
+        ret = bib_results_filter(result, year)
+        return ret[:ret] if ret[:ret]
+
+        fetch_ref_err(code, year, ret[:years])
+      end
+
+      private
+
+      def bib_search_filter(code, year, opts)
+        warn "fetching #{code}..."
+        search(code, year, opts)
+      end
+
+      # Sort through the results from RelatonNist, 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
+      #
+      # @param result
+      # @param opts [Hash] options
+      #
+      # @return [Hash]
+      def bib_results_filter(result, year)
+        missed_years = []
+        result.each do |r|
+          item = r.fetch
+          return { ret: item } if !year
+
+          item.date.select { |d| d.type == "published" }.each do |d|
+            return { ret: item } if year.to_i == d.on.year
+
+            missed_years << d.on.year
+          end
+        end
+        { years: missed_years }
+      end
+
+      # @param code [Strig]
+      # @param year [String]
+      # @param missed_years [Array<Strig>]
+      def fetch_ref_err(code, year, missed_years)
+        id = year ? "#{code} year #{year}" : code
+        warn "WARNING: no match found online for #{id}. "\
+          "The code must be exactly like it is on the standards website."
+        unless missed_years.empty?
+          warn "(There was no match for #{year}, though there were matches "\
+            "found for #{missed_years.join(', ')}.)"
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/relaton_ogc/processor.rb

@@ -0,0 +1,33 @@
+require "relaton/processor"
+
+module RelatonOgc
+  class Processor < Relaton::Processor
+    def initialize
+      @short = :relaton_ogc
+      @prefix = "OGC"
+      @defaultprefix = %r{^OGC\s}
+      @idtype = "OGC"
+    end
+
+    # @param code [String]
+    # @param date [String, NilClass] year
+    # @param opts [Hash]
+    # @return [RelatonOgc::OgcBibliographicItem]
+    def get(code, date = nil, opts = {})
+      ::RelatonOgc::OgcBibliography.get(code, date, opts)
+    end
+
+    # @param xml [String]
+    # @return [RelatonOgc::OgcBibliographicItem]
+    def from_xml(xml)
+      ::RelatonOgc::XMLParser.from_xml xml
+    end
+
+    # @param hash [Hash]
+    # @return [RelatonOgc::OgcBibliographicItem]
+    def hash_to_bib(hash)
+      item_hash = ::RelatonOgc::HashConverter.hash_to_bib(hash)
+      ::RelatonOgc::OgcBibliographicItem.new item_hash
+    end
+  end
+end

data/lib/relaton_ogc/scrapper.rb

@@ -0,0 +1,135 @@
+module RelatonOgc
+  module Scrapper
+    TYPES = {
+      "AS" => "Abstract Specification",
+      "BP" => "Best Practice",
+      "CAN" => "Candidate Standard",
+      "CC" => "Conformance Class",
+      "CR" => "Change Request",
+      "CS" => "Community Standard",
+      "DP" => "Discussion Paper",
+      "DP-Draft" => "Draft Discussion Paper",
+      "IPR" => "Interoperability Program Report - Engineering Specification",
+      "IS" => "Implementation Standard",
+      "ISC" => "Implementation Standard Corrigendum",
+      "ISx" => "Extension Package Standard",
+      "Notes" => "Notes",
+      "ORM" => "OGC Reference Model",
+      "PC" => "Profile Corrigendum",
+      "PER" => "Public Engineering Report",
+      "POL" => "Policy",
+      "POL-NTS" => "Policy - Name Type Specification",
+      "Primer" => "Primer",
+      "Profile" => "Profile",
+      "RFC" => "Request for Comment",
+      "Retired" => "Retired document",
+      "SAP" => "Standard Application Profile",
+      "TS" => "Test Suite",
+      "WhitePaper" => "Whitepaper",
+    }.freeze
+
+    class << self
+      # papam hit [Hash]
+      # @return [RelatonOgc::OrcBibliographicItem]
+      def parse_page(hit)
+        OgcBibliographicItem.new(
+          title: fetch_title(hit["title"]),
+          docid: fetch_docid(hit["identifier"]),
+          link: fetch_link(hit["URL"]),
+          type: fetch_type(hit["type"]),
+          edition: fetch_edition(hit["identifier"]),
+          abstract: fetch_abstract(hit["description"]),
+          contributor: fetch_contributor(hit),
+          language: ["en"],
+          script: ["Latn"],
+          date: fetch_date(hit["date"]),
+        )
+      end
+
+      private
+
+      # @param title [String]
+      # @return [Array<RelatonIsoBib::TypedTitleString>]
+      def fetch_title(title)
+        [
+          RelatonIsoBib::TypedTitleString.new(
+            type: "title-main", content: title, language: "en", script: "Latn",
+            format: "text/plain"
+          ),
+          RelatonIsoBib::TypedTitleString.new(
+            type: "main", content: title, language: "en", script: "Latn",
+            format: "text/plain"
+          ),
+        ]
+      end
+
+      # @param identifier [String]
+      # @return [Array<RelatonBib::DocumentIdentifier>]
+      def fetch_docid(identifier)
+        [RelatonBib::DocumentIdentifier.new(id: identifier, type: "OGC")]
+      end
+
+      # @param url [String]
+      # @return [Array>RelatonBib::TypedUri>]
+      def fetch_link(url)
+        [RelatonBib::TypedUri.new(type: "obp", content: url)]
+      end
+
+      # @param type [String]
+      # @return [String]
+      def fetch_type(type)
+        TYPES[type.sub(/^D-/, "")].downcase.gsub " ", "-"
+      end
+
+      # @param identifier [String]
+      # @return [String]
+      def fetch_edition(identifier)
+        %r{(?<=r)(?<edition>\d+)$} =~ identifier
+        edition
+      end
+
+      # @param description [String]
+      # @return [Array<RelatonBib::FormattedString>]
+      def fetch_abstract(description)
+        [RelatonBib::FormattedString.new(content: description, language: "en",
+                                         script: "Latn")]
+      end
+
+      # @param doc [Hash]
+      # @return [Array<RelatonBib::ContributionInfo>]
+      def fetch_contributor(doc)
+        contribs = doc["creator"].to_s.split(", ").map do |name|
+          personn_contrib name
+        end
+        contribs << org_contrib(doc["publisher"]) if doc["publisher"]
+      end
+
+      # @param name [String]
+      # @return [RelatonBib::ContributionInfo]
+      def personn_contrib(name)
+        fname = RelatonBib::FullName.new(
+          completename: RelatonBib::LocalizedString.new(name),
+        )
+        entity = RelatonBib::Person.new(name: fname)
+        RelatonBib::ContributionInfo.new(
+          entity: entity, role: [type: "author"],
+        )
+      end
+
+      # @param name [String]
+      # @return [RelatonBib::ContributionInfo]
+      def org_contrib(name)
+        entity = RelatonBib::Organization.new(name: name)
+        RelatonBib::ContributionInfo.new(
+          entity: entity, role: [type: "publisher"],
+        )
+      end
+
+      # @param date [String]
+      # @return [Array<RelatonBib::BibliographicDate>]
+      def fetch_date(date)
+        [RelatonBib::BibliographicDate.new(type: "published", on: date)]
+      end
+    end
+  end
+end

data/lib/relaton_ogc/version.rb

@@ -0,0 +1,3 @@
+module RelatonOgc
+  VERSION = "0.1.0"
+end

data/lib/relaton_ogc/xml_parser.rb

@@ -0,0 +1,33 @@
+require "nokogiri"
+
+module RelatonOgc
+  class XMLParser < RelatonIsoBib::XMLParser
+    class << self
+      # Override RelatonIsoBib::XMLParser.form_xml method.
+      # @param xml [String]
+      # @return [RelatonOgc::OgcBibliographicItem]
+      def from_xml(xml)
+        doc = Nokogiri::XML(xml)
+        isoitem = doc.at "/bibitem|/bibdata"
+        OgcBibliographicItem.new item_data(isoitem)
+      end
+
+      private
+
+      # @TODO Organization doesn't recreated
+      # @param ext [Nokogiri::XML::Element]
+      # @return [RelatonIsoBib::EditorialGroup]
+      def fetch_editorialgroup(ext)
+        eg = ext.at("./editorialgroup")
+        return unless eg
+
+        committe = eg&.at("committee")&.text
+        sc = iso_subgroup eg&.at("subcommittee")
+        wg = iso_subgroup eg&.at("workgroup")
+        EditorialGroup.new(
+          committee: committe, subcommittee: sc, workgroup: wg,
+        )
+      end
+    end
+  end
+end

data/relaton_ogc.gemspec

@@ -0,0 +1,39 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "relaton_ogc/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "relaton-ogc"
+  spec.version       = RelatonOgc::VERSION
+  spec.authors       = ["Ribose Inc."]
+  spec.email         = ["open.source@ribose.com"]
+
+  spec.summary       = "RelatonOgc: retrieve OGC Standards for bibliographic "\
+                       "use using the OgcBibliographicItem model"
+  spec.description   = "RelatonIso: retrieve ISO Standards for bibliographic "\
+                       "use using the IsoBibliographicItem model"
+  spec.homepage      = "https://github.com/relaton/relaton-ogc"
+  spec.license       = "BSD-2-Clause"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "debase"
+  spec.add_development_dependency "equivalent-xml", "~> 0.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "ruby-debug-ide"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "vcr"
+  spec.add_development_dependency "webmock"
+
+  spec.add_dependency "faraday"
+  spec.add_dependency "relaton-iso-bib", "~> 0.3.0"
+end