chemicalml 0.2.1 → 0.4.0

data/lib/chemicalml/convention/unit_type_dictionary/constraints/unit_type_must_have_id_and_name.rb

@@ -7,9 +7,9 @@ module Chemicalml
         # Every unitType MUST have an `id` and a `name` attribute per
         # the unitType-dictionary convention.
         class UnitTypeMustHaveIdAndName < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'Every unitType MUST have an `id` and a `name` attribute per the unitType-dictionary convention.'
           applies_to Chemicalml::Cml::Role::UnitType
           def check_node(node, path)
-
             violations = []
             if node.id.to_s.empty?
               violations << violation(path: path.join('/'),

data/lib/chemicalml/convention/unit_type_dictionary.rb

@@ -8,9 +8,9 @@ module Chemicalml
     module UnitTypeDictionary
       extend Base
 
-      autoload :Constraints, "chemicalml/convention/unit_type_dictionary/constraints"
+      autoload :Constraints, 'chemicalml/convention/unit_type_dictionary/constraints'
 
-      QNAME = "convention:unitType-dictionary".freeze
+      QNAME = 'convention:unitType-dictionary'
       NAMESPACE_URI = "#{Chemicalml::Convention::CONVENTION_NAMESPACE}unitType-dictionary".freeze
 
       def self.qname

data/lib/chemicalml/convention/validation_report.rb

@@ -39,9 +39,7 @@ module Chemicalml
       def +(other)
         return other if other.nil?
 
-        unless other.is_a?(ValidationReport)
-          raise ArgumentError, "cannot combine ValidationReport with #{other.class}"
-        end
+        raise ArgumentError, "cannot combine ValidationReport with #{other.class}" unless other.is_a?(ValidationReport)
 
         ValidationReport.new(violations + other.violations)
       end
@@ -58,6 +56,35 @@ module Chemicalml
       def to_s
         "#{size} violation(s): #{errors.length} error(s), #{warnings.length} warning(s)"
       end
+
+      # Human-readable multi-line summary. Suitable for CLI output
+      # and logging. Each violation is rendered with severity, path,
+      # and message (and value when present).
+      #
+      # @return [String]
+      def summary
+        return 'OK — no violations' if ok? && !has_warnings?
+
+        lines = []
+        lines << "Errors: #{errors.size}, Warnings: #{warnings.size}"
+        unless errors.empty?
+          lines << ''
+          lines << 'Errors:'
+          errors.each { |v| lines << "  ERROR #{v.path}: #{v.message}#{value_suffix(v)}" }
+        end
+        unless warnings.empty?
+          lines << ''
+          lines << 'Warnings:'
+          warnings.each { |v| lines << "  WARN  #{v.path}: #{v.message}#{value_suffix(v)}" }
+        end
+        lines.join("\n")
+      end
+
+      private
+
+      def value_suffix(violation)
+        violation.value.nil? ? '' : " (value=#{violation.value.inspect})"
+      end
     end
   end
 end

data/lib/chemicalml/convention/violation.rb

@@ -5,18 +5,23 @@ module Chemicalml
     # Value object describing one constraint violation. Severity is
     # either `:error` (document is invalid under the convention) or
     # `:warning` (document is valid but problematic).
+    #
+    # `value` carries the offending value where natural (e.g. the
+    # duplicated atom id, the malformed unit symbol). Optional —
+    # constraints that flag a missing attribute leave `value` nil.
     class Violation
       SEVERITIES = %i[error warning].freeze
 
-      attr_reader :path, :message, :severity, :constraint
+      attr_reader :path, :message, :severity, :constraint, :value
 
-      def initialize(path:, message:, severity: :error, constraint: nil)
+      def initialize(path:, message:, severity: :error, constraint: nil, value: nil)
         raise ArgumentError, "unknown severity: #{severity.inspect}" unless SEVERITIES.include?(severity.to_sym)
 
         @path       = path
         @message    = message
         @severity   = severity.to_sym
         @constraint = constraint
+        @value      = value
         freeze
       end
 
@@ -29,7 +34,8 @@ module Chemicalml
       end
 
       def to_s
-        "#{severity.upcase} #{path}: #{message}"
+        suffix = value.nil? ? '' : " (value=#{value.inspect})"
+        "#{severity.upcase} #{path}: #{message}#{suffix}"
       end
     end
   end

data/lib/chemicalml/convention.rb

@@ -8,41 +8,68 @@ module Chemicalml
   # convention owns its constraint classes; the framework walks
   # whatever was registered.
   #
-  # The five built-in conventions:
+  # The built-in conventions:
   #
   #   molecular            http://www.xml-cml.org/convention/molecular
   #   compchem             http://www.xml-cml.org/convention/compchem
   #   dictionary           http://www.xml-cml.org/convention/dictionary
   #   unit-dictionary      http://www.xml-cml.org/convention/unit-dictionary
   #   unitType-dictionary  http://www.xml-cml.org/convention/unitType-dictionary
+  #   spectroscopy         http://www.xml-cml.org/convention/spectroscopy
+  #   cascade              http://www.xml-cml.org/convention/cascade
+  #   simpleUnit           http://www.xml-cml.org/convention/simpleUnit
   module Convention
-    autoload :Base,                "chemicalml/convention/base"
-    autoload :Compchem,            "chemicalml/convention/compchem"
-    autoload :Constraint,          "chemicalml/convention/constraint"
-    autoload :Coordinator,         "chemicalml/convention/coordinator"
-    autoload :Detection,           "chemicalml/convention/detection"
-    autoload :Dictionary,          "chemicalml/convention/dictionary"
-    autoload :Molecular,           "chemicalml/convention/molecular"
-    autoload :Registry,            "chemicalml/convention/registry"
-    autoload :UnitDictionary,      "chemicalml/convention/unit_dictionary"
-    autoload :UnitTypeDictionary,  "chemicalml/convention/unit_type_dictionary"
-    autoload :ValidationReport,    "chemicalml/convention/validation_report"
-    autoload :Violation,           "chemicalml/convention/violation"
+    autoload :Base,                'chemicalml/convention/base'
+    autoload :Cascade,             'chemicalml/convention/cascade'
+    autoload :Compchem,            'chemicalml/convention/compchem'
+    autoload :Constraint,          'chemicalml/convention/constraint'
+    autoload :Coordinator,         'chemicalml/convention/coordinator'
+    autoload :Detection,           'chemicalml/convention/detection'
+    autoload :Dictionary,          'chemicalml/convention/dictionary'
+    autoload :Molecular,           'chemicalml/convention/molecular'
+    autoload :Registry,            'chemicalml/convention/registry'
+    autoload :SimpleUnit,          'chemicalml/convention/simple_unit'
+    autoload :Spectroscopy,        'chemicalml/convention/spectroscopy'
+    autoload :UnitDictionary,      'chemicalml/convention/unit_dictionary'
+    autoload :UnitTypeDictionary,  'chemicalml/convention/unit_type_dictionary'
+    autoload :ValidationReport,    'chemicalml/convention/validation_report'
+    autoload :Violation,           'chemicalml/convention/violation'
 
-    CONVENTION_NAMESPACE = "http://www.xml-cml.org/convention/".freeze
+    CONVENTION_NAMESPACE = 'http://www.xml-cml.org/convention/'
 
+    # Look up a convention by QName (e.g. "convention:molecular").
+    # @param qname [String] the convention QName.
+    # @return [Module, nil] the convention module, or nil if unknown.
     def self.lookup(qname)
       Registry.lookup(qname)
     end
 
+    # Validate a document against a named convention. Returns the
+    # raw violation list.
+    #
+    # @param document [Lutaml::Model::Serializable] the CML document.
+    # @param qname [String] the convention QName (e.g. "convention:molecular").
+    # @return [Array<Chemicalml::Convention::Violation>] the violations.
+    # @raise [ArgumentError] if the qname is not registered.
     def self.validate(document, qname:)
       Registry.validate(document, qname: qname)
     end
 
+    # Validate and return a structured report (errors + warnings).
+    #
+    # @param document [Lutaml::Model::Serializable] the CML document.
+    # @param qname [String] the convention QName.
+    # @return [Chemicalml::Convention::ValidationReport] the report.
     def self.validate_report(document, qname:)
       Registry.validate_report(document, qname: qname)
     end
 
+    # Auto-detect the convention from the document root's `convention`
+    # attribute and validate.
+    #
+    # @param document [Lutaml::Model::Serializable] the CML document.
+    # @return [Chemicalml::Convention::ValidationReport] the report.
+    # @raise [ArgumentError] if no convention is declared.
     def self.detect_and_validate(document)
       Registry.detect_and_validate(document)
     end

data/lib/chemicalml/dictionary.rb

@@ -8,17 +8,21 @@ module Chemicalml
   # Built-in dictionaries ship as YAML under `data/dictionaries/` and
   # are loaded into `Chemicalml::Dictionary::Registry` lazily.
   module Dictionary
-    autoload :Entry,   "chemicalml/dictionary/entry"
-    autoload :Enum,    "chemicalml/dictionary/enum"
-    autoload :Link,    "chemicalml/dictionary/link"
-    autoload :Loader,  "chemicalml/dictionary/loader"
-    autoload :Model,   "chemicalml/dictionary/model"
-    autoload :Registry, "chemicalml/dictionary/registry"
+    autoload :Entry,   'chemicalml/dictionary/entry'
+    autoload :Enum,    'chemicalml/dictionary/enum'
+    autoload :Link,    'chemicalml/dictionary/link'
+    autoload :Loader,  'chemicalml/dictionary/loader'
+    autoload :Model,   'chemicalml/dictionary/model'
+    autoload :Registry, 'chemicalml/dictionary/registry'
 
-    BUILTIN_DIR = File.expand_path("../../data/dictionaries", __dir__).freeze
+    BUILTIN_DIR = File.expand_path('../../data/dictionaries', __dir__).freeze
 
-    # Convenience: load a built-in dictionary by short name
-    # (e.g. `:compchem`). Returns a `Chemicalml::Dictionary::Model`.
+    # Convenience: load a built-in dictionary by short name.
+    #
+    # @param name [Symbol, String] the dictionary short name (YAML
+    #   filename stem, e.g. `:compchem`, `:cml`).
+    # @return [Chemicalml::Dictionary::Model] the loaded dictionary.
+    # @raise [KeyError] if `name` is not a built-in dictionary.
     def self.load(name)
       Registry.load_builtin(name)
     end

data/lib/chemicalml/logger.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Chemicalml
+  # Logger used across the CLI and API. Wraps Ruby's ::Logger and can
+  # bridge to Thor's `say` / `say_error` when running under a Thor
+  # dispatcher — that gives coloured output on the terminal while
+  # plain `Logger.new($stderr)` works for library callers.
+  #
+  # Severity routing under Thor:
+  #   debug → suppressed (set level manually if needed)
+  #   info  → say (green-ish, $stdout)
+  #   warn  → say_error with :yellow ($stderr)
+  #   error → say_error with :red   ($stderr)
+  #   fatal → say_error with :red   ($stderr)
+  class Logger < ::Logger
+    attr_reader :thor_shell
+
+    # Bridge to a Thor shell instance (self inside a Thor command).
+    # When set, info/warn/error route through Thor for coloured output.
+    def thor_shell=(shell)
+      @thor_shell = shell
+    end
+
+    def add(severity, message = nil, progname = nil)
+      return super unless thor_shell
+      return true if severity < level
+
+      msg = message || progname
+      case severity
+      when ERROR, FATAL
+        thor_shell.say_error(msg.to_s, :red)
+      when WARN
+        thor_shell.say_error(msg.to_s, :yellow)
+      else
+        thor_shell.say(msg.to_s)
+      end
+    end
+
+    # Convenience: create a default logger that writes to $stderr at
+    # INFO level. Used when no logger is explicitly provided.
+    def self.default
+      new($stderr).tap { |l| l.level = INFO }
+    end
+  end
+end

data/lib/chemicalml/schema/definition.rb

@@ -19,7 +19,7 @@ module Chemicalml
       end
 
       def wire_namespace_constant
-        ruby_namespace.split("::").reduce(Object) { |ns, name| ns.const_get(name) }
+        ruby_namespace.split('::').reduce(Object) { |ns, name| ns.const_get(name) }
       end
 
       def eql?(other)
@@ -34,7 +34,7 @@ module Chemicalml
       private
 
       def project_root
-        File.expand_path("../../..", __dir__)
+        File.expand_path('../../..', __dir__)
       end
     end
   end

data/lib/chemicalml/schema.rb

@@ -9,10 +9,10 @@ module Chemicalml
   # `reference-docs/schemas/`. They are never modified or regenerated
   # from code.
   module Schema
-    autoload :Definition, "chemicalml/schema/definition"
-    autoload :Registry,   "chemicalml/schema/registry"
+    autoload :Definition, 'chemicalml/schema/definition'
+    autoload :Registry,   'chemicalml/schema/registry'
 
-    CML_XML_NAMESPACE = "http://www.xml-cml.org/schema"
+    CML_XML_NAMESPACE = 'http://www.xml-cml.org/schema'
 
     # Built-in versions registered at load time. Adding a new CML schema
     # version = appending an entry here and creating the matching
@@ -20,15 +20,15 @@ module Chemicalml
     BUILTIN = {
       schema24: Definition.new(
         version: :schema24,
-        xsd_path: "reference-docs/schemas/schema24/schema.xsd",
+        xsd_path: 'reference-docs/schemas/schema24/schema.xsd',
         xml_namespace: CML_XML_NAMESPACE,
-        ruby_namespace: "Chemicalml::Cml::Schema24"
+        ruby_namespace: 'Chemicalml::Cml::Schema24'
       ),
       schema3: Definition.new(
         version: :schema3,
-        xsd_path: "reference-docs/schemas/schema3/schema.xsd",
+        xsd_path: 'reference-docs/schemas/schema3/schema.xsd',
         xml_namespace: CML_XML_NAMESPACE,
-        ruby_namespace: "Chemicalml::Cml::Schema3"
+        ruby_namespace: 'Chemicalml::Cml::Schema3'
       )
     }.freeze
   end

data/lib/chemicalml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Chemicalml
-  VERSION = "0.2.1"
+  VERSION = '0.4.0'
 end

data/lib/chemicalml/versioned_parser.rb

@@ -32,14 +32,14 @@ module Chemicalml
     # Adding a new root type = adding one entry here. OCP — no
     # existing code changes.
     KNOWN_ROOTS = {
-      "cml"          => :Document,
-      "molecule"     => :Molecule,
-      "reaction"     => :Reaction,
-      "reactionList" => :ReactionList,
-      "module"       => :Module,
-      "dictionary"   => :Dictionary,
-      "unitList"     => :UnitList,
-      "unitTypeList" => :UnitTypeList,
+      'cml' => :Document,
+      'molecule' => :Molecule,
+      'reaction' => :Reaction,
+      'reactionList' => :ReactionList,
+      'module' => :Module,
+      'dictionary' => :Dictionary,
+      'unitList' => :UnitList,
+      'unitTypeList' => :UnitTypeList
     }.freeze
 
     def parse(xml, namespace_exist: true)
@@ -57,7 +57,7 @@ module Chemicalml
       unless const_defined?(class_name, false)
         raise ArgumentError,
               "#{name} does not define #{class_name} " \
-              "(not all root elements exist in every schema version)"
+              '(not all root elements exist in every schema version)'
       end
 
       const_get(class_name).from_xml(
@@ -83,7 +83,7 @@ module Chemicalml
       match = xml.match(/<([a-zA-Z][\w.-]*)(?::[a-zA-Z][\w.-]*)?/)
       return match[1] if match
 
-      raise ArgumentError, "could not detect root element in XML"
+      raise ArgumentError, 'could not detect root element in XML'
     end
 
     def xml_input(xml, namespace_exist, root)

data/lib/chemicalml.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "lutaml/model"
+require 'lutaml/model'
 
 # Chemicalml provides a Ruby object model for the Chemical Markup Language
 # (CML).
@@ -13,36 +13,99 @@ require "lutaml/model"
 # declared attributes and an XML mapping block. Serialization is
 # framework-backed — no hand-rolled XML in this library.
 module Chemicalml
-  autoload :Cml, "chemicalml/cml"
-  autoload :ContextConfiguration, "chemicalml/context_configuration"
-  autoload :Convention, "chemicalml/convention"
-  autoload :Dictionary, "chemicalml/dictionary"
-  autoload :Error, "chemicalml/errors"
-  autoload :ParseError, "chemicalml/errors"
-  autoload :Schema, "chemicalml/schema"
-  autoload :VERSION, "chemicalml/version"
-  autoload :VersionedParser, "chemicalml/versioned_parser"
+  autoload :Cml, 'chemicalml/cml'
+  autoload :Cli, 'chemicalml/cli'
+  autoload :ContextConfiguration, 'chemicalml/context_configuration'
+  autoload :Convention, 'chemicalml/convention'
+  autoload :Dictionary, 'chemicalml/dictionary'
+  autoload :Error, 'chemicalml/errors'
+  autoload :Logger, 'chemicalml/logger'
+  autoload :ParseError, 'chemicalml/errors'
+  autoload :Schema, 'chemicalml/schema'
+  autoload :VERSION, 'chemicalml/version'
+  autoload :VersionedParser, 'chemicalml/versioned_parser'
+  autoload :Dictionary, 'chemicalml/dictionary'
+  autoload :Error, 'chemicalml/errors'
+  autoload :ParseError, 'chemicalml/errors'
+  autoload :Schema, 'chemicalml/schema'
+  autoload :VERSION, 'chemicalml/version'
+  autoload :VersionedParser, 'chemicalml/versioned_parser'
 
   module_function
 
+  # Parse a CML XML string into a wire document.
+  #
+  # @param xml [String] the XML content.
+  # @param schema [Symbol] one of `:schema3` (default) or `:schema24`.
+  # @param namespace_exist [Boolean] whether the XML already declares
+  #   the CML namespace. When false, the parser injects it.
+  # @return [Chemicalml::Cml::Schema3::Document,
+  #          Chemicalml::Cml::Schema24::Document,
+  #          Chemicalml::Cml::Schema3::Molecule, ...] the parsed root,
+  #          dispatch by detected root element.
+  # @raise [ArgumentError] if `xml` is nil/empty or `schema` is unknown.
+  # @raise [Chemicalml::ParseError] on malformed XML.
+  #
+  # @example Parse a Schema3 document
+  #   doc = Chemicalml.parse("<cml xmlns='...'>...</cml>")
+  # @example Parse a Schema2.4 document
+  #   doc = Chemicalml.parse(xml, schema: :schema24)
   def parse(xml, schema: :schema3, namespace_exist: true)
-    raise ArgumentError, "xml must not be nil" if xml.nil?
-    raise ArgumentError, "xml must not be empty" if xml.to_s.strip.empty?
+    raise ArgumentError, 'xml must not be nil' if xml.nil?
+    raise ArgumentError, 'xml must not be empty' if xml.to_s.strip.empty?
 
     parser_for(schema).parse(xml, namespace_exist: namespace_exist)
   end
 
-  def serialize(document, **opts)
-    document.to_xml(**opts)
+  # Parse a CML file from disk. Convenience wrapper around `parse`
+  # that handles the `File.read` boilerplate.
+  #
+  # @param path [String] path to the CML file.
+  # @param schema [Symbol] `:schema3` (default) or `:schema24`.
+  # @param namespace_exist [Boolean] forwarded to `parse`.
+  # @return (see .parse)
+  # @raise [ArgumentError] if the file doesn't exist or is empty.
+  def parse_file(path, schema: :schema3, namespace_exist: true)
+    raise ArgumentError, "file not found: #{path}" unless File.exist?(path)
+
+    parse(File.read(path), schema: schema, namespace_exist: namespace_exist)
+  end
+
+  # Serialize a wire document back to XML.
+  #
+  # @param document [Lutaml::Model::Serializable] a CML wire instance.
+  # @param opts [Hash] forwarded to `Lutaml::Model::Serializable#to_xml`.
+  # @return [String] the serialized XML.
+  def serialize(document, **)
+    document.to_xml(**)
   end
 
+  # Resolve the versioned-parser module for a schema id.
+  #
+  # @param schema [Symbol] `:schema3` or `:schema24`.
+  # @return [Module] the matching `Schema3` or `Schema24` module.
+  # @raise [ArgumentError] if `schema` is unknown.
   def parser_for(schema)
     case schema.to_sym
     when :schema3  then Chemicalml::Cml::Schema3
     when :schema24 then Chemicalml::Cml::Schema24
     else
       raise ArgumentError, "unsupported schema: #{schema.inspect} " \
-                           "(supported: :schema3, :schema24)"
+                           '(supported: :schema3, :schema24)'
     end
   end
+
+  # Auto-detect the convention from the document's root and validate.
+  # Top-level convenience for `Convention.detect_and_validate`.
+  #
+  # @param document [Lutaml::Model::Serializable] the CML document.
+  # @param logger [Chemicalml::Logger, nil] optional logger for progress.
+  # @return [Chemicalml::Convention::ValidationReport] the report.
+  # @raise [ArgumentError] if no convention is declared.
+  def validate(document, logger: nil)
+    logger&.info 'Auto-detecting convention…'
+    report = Convention.detect_and_validate(document)
+    logger&.info "Validation complete: #{report.size} violation(s)"
+    report
+  end
 end

data/lib/tasks/reference_fetch.rake

@@ -1,41 +1,41 @@
 # frozen_string_literal: true
 
-require "net/http"
-require "uri"
-require "fileutils"
+require 'net/http'
+require 'uri'
+require 'fileutils'
 
 # Idempotent fetcher for xml-cml.org reference material.
 # Re-running this task only downloads files that are missing locally.
 module ReferenceFetch
-  BASE = "http://www.xml-cml.org".freeze
-  LICENSE = "Source: <url>. Distributed by xml-cml.org under CC-BY-3.0.".freeze
+  BASE = 'http://www.xml-cml.org'
+  LICENSE = 'Source: <url>. Distributed by xml-cml.org under CC-BY-3.0.'
 
   # Map of remote URL => local path under reference-docs/.
   SOURCES = {
     # Conventions
-    "#{BASE}/convention/"                                => "reference-docs/conventions/index.md",
-    "#{BASE}/convention/molecular"                       => "reference-docs/conventions/molecular.md",
-    "#{BASE}/convention/compchem"                        => "reference-docs/conventions/compchem.md",
-    "#{BASE}/convention/dictionary"                      => "reference-docs/conventions/dictionary.md",
-    "#{BASE}/convention/unit-dictionary"                 => "reference-docs/conventions/unit-dictionary.md",
-    "#{BASE}/convention/unitType-dictionary"             => "reference-docs/conventions/unitType-dictionary.md",
+    "#{BASE}/convention/" => 'reference-docs/conventions/index.md',
+    "#{BASE}/convention/molecular" => 'reference-docs/conventions/molecular.md',
+    "#{BASE}/convention/compchem" => 'reference-docs/conventions/compchem.md',
+    "#{BASE}/convention/dictionary" => 'reference-docs/conventions/dictionary.md',
+    "#{BASE}/convention/unit-dictionary" => 'reference-docs/conventions/unit-dictionary.md',
+    "#{BASE}/convention/unitType-dictionary" => 'reference-docs/conventions/unitType-dictionary.md',
     # Dictionaries
-    "#{BASE}/dictionary/"                                => "reference-docs/dictionaries/index.md",
-    "#{BASE}/dictionary/compchem/"                       => "reference-docs/dictionaries/compchem.md",
-    "#{BASE}/dictionary/cml/"                            => "reference-docs/dictionaries/cml.md",
-    "#{BASE}/dictionary/cml/name/"                       => "reference-docs/dictionaries/cml-name.md",
-    "#{BASE}/dictionary/cml/formula/"                    => "reference-docs/dictionaries/cml-formula.md",
-    "#{BASE}/dictionary/cif/"                            => "reference-docs/dictionaries/cif.md",
+    "#{BASE}/dictionary/" => 'reference-docs/dictionaries/index.md',
+    "#{BASE}/dictionary/compchem/" => 'reference-docs/dictionaries/compchem.md',
+    "#{BASE}/dictionary/cml/" => 'reference-docs/dictionaries/cml.md',
+    "#{BASE}/dictionary/cml/name/" => 'reference-docs/dictionaries/cml-name.md',
+    "#{BASE}/dictionary/cml/formula/" => 'reference-docs/dictionaries/cml-formula.md',
+    "#{BASE}/dictionary/cif/" => 'reference-docs/dictionaries/cif.md',
     # Unit dictionaries
-    "#{BASE}/unit/si/"                                   => "reference-docs/dictionaries/unit-si.md",
-    "#{BASE}/unit/nonSi/"                                => "reference-docs/dictionaries/unit-nonSi.md",
-    "#{BASE}/unit/unitType/"                             => "reference-docs/dictionaries/unit-type.md",
+    "#{BASE}/unit/si/" => 'reference-docs/dictionaries/unit-si.md',
+    "#{BASE}/unit/nonSi/" => 'reference-docs/dictionaries/unit-nonSi.md',
+    "#{BASE}/unit/unitType/" => 'reference-docs/dictionaries/unit-type.md',
     # Schema / spec
-    "https://www.xml-cml.org/schema/cmllite.html"        => "reference-docs/cmllite.html",
+    'https://www.xml-cml.org/schema/cmllite.html' => 'reference-docs/cmllite.html',
     # Examples
-    "#{BASE}/examples/schema3/molecular/"                => "reference-docs/examples/schema3-molecular-index.md",
-    "#{BASE}/examples/schema3/compchem/"                 => "reference-docs/examples/schema3-compchem-index.md",
-    "#{BASE}/examples/schema24/"                         => "reference-docs/examples/schema24-index.md"
+    "#{BASE}/examples/schema3/molecular/" => 'reference-docs/examples/schema3-molecular-index.md',
+    "#{BASE}/examples/schema3/compchem/" => 'reference-docs/examples/schema3-compchem-index.md',
+    "#{BASE}/examples/schema24/" => 'reference-docs/examples/schema24-index.md'
   }.freeze
 
   def self.fetch_all
@@ -60,7 +60,7 @@ module ReferenceFetch
       return
     end
 
-    if path.end_with?(".html")
+    if path.end_with?('.html')
       File.write(full, body)
     else
       File.write(full, header(url) + body)
@@ -73,19 +73,18 @@ module ReferenceFetch
   end
 
   def self.http_get(url, limit = 5)
-    raise "too many redirects" if limit.zero?
+    raise 'too many redirects' if limit.zero?
 
     uri = URI(url)
     http = Net::HTTP.new(uri.host, uri.port)
     http.use_ssl = true if uri.is_a?(URI::HTTPS)
     http.read_timeout = 30
-    req = Net::HTTP::Get.new(uri, "User-Agent" => "chemicalml-gem-reference-fetch")
+    req = Net::HTTP::Get.new(uri, 'User-Agent' => 'chemicalml-gem-reference-fetch')
     res = http.request(req)
 
     case res
     when Net::HTTPSuccess then res.body
-    when Net::HTTPRedirection then http_get(res["location"], limit - 1)
-    else nil
+    when Net::HTTPRedirection then http_get(res['location'], limit - 1)
     end
   rescue StandardError => e
     warn "  error fetching #{url}: #{e.message}"
@@ -93,12 +92,12 @@ module ReferenceFetch
   end
 
   def self.project_root
-    File.expand_path("..", __dir__)
+    File.expand_path('..', __dir__)
   end
 end
 
 namespace :reference do
-  desc "Download all xml-cml.org reference material into reference-docs/. Idempotent."
+  desc 'Download all xml-cml.org reference material into reference-docs/. Idempotent.'
   task :fetch do
     ReferenceFetch.fetch_all
   end