chemicalml 0.2.0 → 0.3.0

data/lib/chemicalml/convention/molecular/constraints/atom_array_must_be_child_of_molecule_or_formula.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # Molecular convention: `<atomArray>` MUST be a child of
+        # `<molecule>` or `<formula>`. Any other parent is invalid.
+        # Checked from the parent's perspective during the walk —
+        # when visiting a non-molecule/non-formula node, look for
+        # misplaced atomArray children.
+        class AtomArrayMustBeChildOfMoleculeOrFormula < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = "Molecular convention: `<atomArray>` MUST be a child of `<molecule>` or `<formula>`. Any other parent is invalid. Checked from the parent's perspective during the walk —"
+          def check_node(node, path)
+            return [] if allowed_parent?(node)
+
+            misplaced = node.wire_children.select { |c| atom_array?(c) }
+            misplaced.map do |child|
+              violation(
+                path: (path + [describe(node), describe(child)]).join('/'),
+                message: 'atomArray must be a child of molecule or formula, ' \
+                         "but appears under #{node.element_name.inspect}"
+              )
+            end
+          end
+
+          private
+
+          def allowed_parent?(node)
+            node.is_a?(Chemicalml::Cml::Role::Molecule) ||
+              node.is_a?(Chemicalml::Cml::Role::Formula)
+          end
+
+          def atom_array?(node)
+            node.is_a?(Chemicalml::Cml::Role::AtomArray)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/molecular/constraints/atom_array_must_contain_atoms.rb

@@ -4,24 +4,33 @@ module Chemicalml
   module Convention
     module Molecular
       module Constraints
-        # `atomArray` MUST contain at least one `atom` child per the
-        # molecular convention.
+        # `atomArray` MUST contain at least one atom. The atoms can
+        # be in the child form (`<atom>` elements) or the parallel-array
+        # form (`atomID` attribute with whitespace-separated ids).
         class AtomArrayMustContainAtoms < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = '`atomArray` MUST contain at least one atom. The atoms can be in the child form (`<atom>` elements) or the parallel-array form (`atomID` attribute with whitespace-separated ids).'
+          applies_to Chemicalml::Cml::Role::Molecule
           def check_node(node, path)
-            return [] unless molecule?(node)
             return [] unless node.atom_array
 
-            atoms = node.atom_array.atoms || []
-            return [] unless atoms.empty?
+            aa = node.atom_array
+            return [] if has_child_atoms?(aa) || has_parallel_array_atoms?(aa)
 
-            [violation(path: path.empty? ? "molecule" : path.join("/"),
-                       message: "atomArray must contain at least one atom")]
+            [violation(path: path.empty? ? 'molecule' : path.join('/'),
+                       message: 'atomArray must contain at least one atom')]
           end
 
           private
 
-          def molecule?(node)
-            node.is_a?(Chemicalml::Cml::Role::Molecule)
+          def has_child_atoms?(atom_array)
+            !(atom_array.atoms || []).empty?
+          end
+
+          # Parallel-array form is identified by a non-empty atomIDArray
+          # attribute — the XSD marks it as mandatory when atoms are
+          # encoded as parallel arrays.
+          def has_parallel_array_atoms?(atom_array)
+            !atom_array.atom_id_array.to_s.strip.empty?
           end
         end
       end

data/lib/chemicalml/convention/molecular/constraints/atom_coordinates_must_be_paired.rb

@@ -5,23 +5,23 @@ module Chemicalml
     module Molecular
       module Constraints
         class AtomCoordinatesMustBePaired < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = '<atom> 2D coordinates (x2, y2) must appear together; 3D coordinates (x3, y3, z3) must appear together.'
+          applies_to Chemicalml::Cml::Role::Atom
           def check_node(node, path)
-            return [] unless node.is_a?(Chemicalml::Cml::Role::Atom)
-
             violations = []
             has_x2 = !node.x2.to_s.empty?
             has_y2 = !node.y2.to_s.empty?
             if has_x2 != has_y2
-              violations << violation(path: path.empty? ? "atom" : path.join("/"),
-                                      message: "x2 and y2 must both be present or both absent")
+              violations << violation(path: path.empty? ? 'atom' : path.join('/'),
+                                      message: 'x2 and y2 must both be present or both absent')
             end
 
             has_x3 = !node.x3.to_s.empty?
             has_y3 = !node.y3.to_s.empty?
             has_z3 = !node.z3.to_s.empty?
             if [has_x3, has_y3, has_z3].any? && ![has_x3, has_y3, has_z3].all?
-              violations << violation(path: path.empty? ? "atom" : path.join("/"),
-                                      message: "x3, y3, and z3 must all be present together")
+              violations << violation(path: path.empty? ? 'atom' : path.join('/'),
+                                      message: 'x3, y3, and z3 must all be present together')
             end
             violations
           end

data/lib/chemicalml/convention/molecular/constraints/atom_element_type_should_be_in_periodic_table.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # An `<atom>`'s `elementType` attribute SHOULD be one of the
+        # XSD elementTypeType enum values (the periodic table plus
+        # the special "Du" dummy and "R" group placeholder). Warns
+        # on typos like "Carb" or "X".
+        class AtomElementTypeShouldBeInPeriodicTable < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = "An `<atom>`'s `elementType` attribute SHOULD be one of the XSD elementTypeType enum values (the periodic table plus the special \"Du\" dummy and \"R\" group placeholder). Warns"
+          include Chemicalml::Cml::Enums
+
+          applies_to Chemicalml::Cml::Role::Atom
+
+          def check_node(node, _path)
+            et = node.element_type.to_s.strip
+            return [] if et.empty?
+            return [] if ELEMENT_TYPE_VALUES.include?(et)
+
+            [violation(path: yield_path(node),
+                       message: "atom #{node.id.inspect} elementType #{et.inspect} should be one of " \
+                                "the periodic table symbols (e.g. C, H, O, Fe) — got #{et.inspect}",
+                       severity: :warning,
+                       value: et)]
+          end
+
+          private
+
+          def yield_path(node)
+            id = node.node_id
+            id ? "atom[#{id}]" : 'atom'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/molecular/constraints/atom_id_must_match_pattern.rb

@@ -5,19 +5,20 @@ module Chemicalml
     module Molecular
       module Constraints
         class AtomIdMustMatchPattern < Chemicalml::Convention::Constraint::NodeConstraint
-          ID_PATTERN = /\A[A-Za-z][A-Za-z0-9._\-]*\z/.freeze
+          self.description = "An <atom>'s id attribute SHOULD start with a letter and contain only letters, digits, dot, hyphen, or underscore."
+          applies_to Chemicalml::Cml::Role::Atom
+          ID_PATTERN = /\A[A-Za-z][A-Za-z0-9._-]*\z/
 
           def check_node(node, path)
-            return [] unless node.is_a?(Chemicalml::Cml::Role::Atom)
-
             id = node.id.to_s
             return [] if id.empty?
             return [] if id.match?(ID_PATTERN)
 
-            [violation(path: path.empty? ? "atom" : path.join("/"),
+            [violation(path: path.empty? ? 'atom' : path.join('/'),
                        message: "atom id #{id.inspect} must start with a letter and " \
-                                "contain only letters, digits, dot, hyphen, or underscore",
-                       severity: :warning)]
+                                'contain only letters, digits, dot, hyphen, or underscore',
+                       severity: :warning,
+                       value: id)]
           end
         end
       end

data/lib/chemicalml/convention/molecular/constraints/atom_ids_unique_within_molecule.rb

@@ -7,6 +7,7 @@ module Chemicalml
         # Atom ids MUST be unique within the eldest containing molecule
         # per the molecular convention.
         class AtomIdsUniqueWithinMolecule < Chemicalml::Convention::Constraint::DocumentConstraint
+          self.description = 'Atom ids MUST be unique within the eldest containing molecule per the molecular convention.'
           def check(document)
             violations = []
             walk_nodes(document) do |node, path|
@@ -16,7 +17,7 @@ module Chemicalml
               duplicates = ids.group_by { |x| x }.select { |_, v| v.length > 1 }.keys
               duplicates.each do |dup|
                 violations << violation(
-                  path: path.empty? ? "molecule[#{node.id}]" : path.join("/"),
+                  path: path.empty? ? "molecule[#{node.id}]" : path.join('/'),
                   message: "duplicate atom id #{dup.inspect} within molecule #{node.id.inspect}"
                 )
               end
@@ -33,7 +34,7 @@ module Chemicalml
           def atom_ids_within(molecule)
             return [] unless molecule.atom_array
 
-            (molecule.atom_array.atoms || []).map { |a| a.id }.compact
+            (molecule.atom_array.atoms || []).map(&:id).compact
           end
         end
       end

data/lib/chemicalml/convention/molecular/constraints/atom_must_have_element_type.rb

@@ -5,13 +5,13 @@ module Chemicalml
     module Molecular
       module Constraints
         class AtomMustHaveElementType < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'An <atom> inside an atomArray in a molecule MUST have an elementType attribute.'
+          applies_to Chemicalml::Cml::Role::Atom
           def check_node(node, path)
-            return [] unless node.is_a?(Chemicalml::Cml::Role::Atom)
-
             return [] unless node.element_type.to_s.empty?
 
-            [violation(path: path.empty? ? "atom" : path.join("/"),
-                       message: "atom must have an elementType attribute")]
+            [violation(path: path.empty? ? 'atom' : path.join('/'),
+                       message: 'atom must have an elementType attribute')]
           end
         end
       end

data/lib/chemicalml/convention/molecular/constraints/atom_must_have_id.rb

@@ -5,13 +5,14 @@ module Chemicalml
     module Molecular
       module Constraints
         class AtomMustHaveId < Chemicalml::Convention::Constraint::NodeConstraint
-          def check_node(node, path)
-            return [] unless node.is_a?(Chemicalml::Cml::Role::Atom)
+          applies_to Chemicalml::Cml::Role::Atom
+          self.description = 'An <atom> inside an atomArray in a molecule MUST have an id attribute.'
 
+          def check_node(node, path)
             return [] unless node.id.to_s.empty?
 
-            [violation(path: path.empty? ? "atom" : path.join("/"),
-                       message: "atom must have an id attribute")]
+            [violation(path: path.empty? ? 'atom' : path.join('/'),
+                       message: 'atom must have an id attribute')]
           end
         end
       end

data/lib/chemicalml/convention/molecular/constraints/atom_parity_atom_refs4_should_be_distinct.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # An `<atomParity>` element's `atomRefs4` attribute SHOULD
+        # reference four distinct atom ids around a chiral center.
+        # Duplicate ids make the parity descriptor meaningless.
+        # Warning severity.
+        class AtomParityAtomRefs4ShouldBeDistinct < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = "An `<atomParity>` element's `atomRefs4` attribute SHOULD reference four distinct atom ids around a chiral center. Duplicate ids make the parity descriptor meaningless."
+          applies_to Chemicalml::Cml::Role::AtomParity
+
+          def check_node(node, _path)
+            ids = parse_refs(node.atom_refs4)
+            return [] if ids.size < 2
+            return [] if ids.uniq.size == ids.size
+
+            duplicates = ids.group_by { |i| i }.select { |_, v| v.size > 1 }.keys
+            [violation(path: yield_path(node),
+                       message: "atomParity #{node.id.inspect} atomRefs4 should reference four distinct atoms; " \
+                                "duplicate ids: #{duplicates.inspect}",
+                       severity: :warning,
+                       value: node.atom_refs4)]
+          end
+
+          private
+
+          def yield_path(node)
+            id = node.node_id
+            id ? "atomParity[#{id}]" : 'atomParity'
+          end
+
+          def parse_refs(value)
+            return [] if value.nil?
+
+            value.to_s.split(/\s+/).reject(&:empty?)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/molecular/constraints/atom_parity_should_include_parent_atom.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # Walks the document and warns on `<atomParity>` elements
+        # whose parent `<atom>`'s id does not appear in atomRefs4.
+        # The CML convention requires the parent atom to be one of
+        # the four references (otherwise the parity is meaningless).
+        #
+        # DocumentConstraint because it needs to walk the tree and
+        # track parent-child relationships.
+        class AtomParityShouldIncludeParentAtom < Chemicalml::Convention::Constraint::DocumentConstraint
+          self.description = "Walks the document and warns on `<atomParity>` elements whose parent `<atom>`'s id does not appear in atomRefs4. The CML convention requires the parent atom to be one of"
+          def check(document)
+            violations = []
+            visit_with_parent(document, nil) do |node, parent|
+              next unless atom_parity?(node)
+              next unless atom?(parent)
+
+              refs = parse_refs(node.atom_refs4)
+              next if refs.empty?
+              next if refs.include?(parent.id)
+
+              violations << violation(
+                path: "atom[#{parent.id}]/atomParity",
+                message: "atomParity atomRefs4 #{refs.inspect} should include the parent atom id " \
+                         "#{parent.id.inspect}",
+                severity: :warning,
+                value: node.atom_refs4
+              )
+            end
+            violations
+          end
+
+          private
+
+          def visit_with_parent(node, parent, &block)
+            return unless node.is_a?(Lutaml::Model::Serializable)
+
+            block.call(node, parent)
+            return unless node.is_a?(Chemicalml::Cml::Visitable)
+
+            node.wire_children.each { |c| visit_with_parent(c, node, &block) }
+          end
+
+          def atom_parity?(node)
+            node.is_a?(Chemicalml::Cml::Role::AtomParity)
+          end
+
+          def atom?(node)
+            node.is_a?(Chemicalml::Cml::Role::Atom)
+          end
+
+          def parse_refs(value)
+            return [] if value.nil?
+
+            value.to_s.split(/\s+/).reject(&:empty?)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/molecular/constraints/bond_array_must_be_child_of_molecule.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # Molecular convention: `<bondArray>` MUST be a child of
+        # `<molecule>`. Any other parent is invalid.
+        class BondArrayMustBeChildOfMolecule < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'Molecular convention: `<bondArray>` MUST be a child of `<molecule>`. Any other parent is invalid.'
+          def check_node(node, path)
+            return [] if molecule?(node)
+
+            misplaced = node.wire_children.select { |c| bond_array?(c) }
+            misplaced.map do |child|
+              violation(
+                path: (path + [describe(node), describe(child)]).join('/'),
+                message: 'bondArray must be a child of molecule, ' \
+                         "but appears under #{node.element_name.inspect}"
+              )
+            end
+          end
+
+          private
+
+          def molecule?(node)
+            node.is_a?(Chemicalml::Cml::Role::Molecule)
+          end
+
+          def bond_array?(node)
+            node.is_a?(Chemicalml::Cml::Role::BondArray)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/molecular/constraints/bond_atom_refs2_should_be_distinct.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # A `<bond>`'s `atomRefs2` SHOULD reference two distinct atom
+        # ids. A self-bond (`a1 a1`) is chemically meaningless.
+        # Warning severity — there are edge cases in non-classical
+        # chemistry (e.g. agostic interactions).
+        class BondAtomRefs2ShouldBeDistinct < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = "A `<bond>`'s `atomRefs2` SHOULD reference two distinct atom ids. A self-bond (`a1 a1`) is chemically meaningless. Warning severity — there are edge cases in non-classical"
+          applies_to Chemicalml::Cml::Role::Bond
+
+          def check_node(node, _path)
+            ids = parse_refs(node.atom_refs2)
+            return [] if ids.size < 2
+            return [] if ids.uniq.size == ids.size
+
+            duplicates = ids.group_by { |i| i }.select { |_, v| v.size > 1 }.keys
+            [violation(path: yield_path(node),
+                       message: "bond #{node.id.inspect} atomRefs2 should reference two distinct atoms; " \
+                                "duplicate ids: #{duplicates.inspect}",
+                       severity: :warning,
+                       value: node.atom_refs2)]
+          end
+
+          private
+
+          def yield_path(node)
+            id = node.node_id
+            id ? "bond[#{id}]" : 'bond'
+          end
+
+          def parse_refs(value)
+            return [] if value.nil?
+
+            value.to_s.split(/\s+/).reject(&:empty?)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/molecular/constraints/bond_id_should_match_pattern.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # A `<bond>`'s `id` attribute SHOULD match the XSD idType
+        # pattern (letter start, alphanumeric body with dots/dashes).
+        # Warning severity.
+        class BondIdShouldMatchPattern < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = "A `<bond>`'s `id` attribute SHOULD match the XSD idType pattern (letter start, alphanumeric body with dots/dashes). Warning severity."
+          include Chemicalml::Cml::Patterns
+
+          applies_to Chemicalml::Cml::Role::Bond
+
+          def check_node(node, _path)
+            id = node.id.to_s
+            return [] if id.empty?
+            return [] if id.match?(/\A#{ID_PATTERN.source}\z/)
+
+            [violation(path: yield_path(node),
+                       message: "bond id #{id.inspect} should match the idType pattern " \
+                                '(letter start, alphanumeric body with . and -)',
+                       severity: :warning,
+                       value: id)]
+          end
+
+          private
+
+          def yield_path(node)
+            id = node.node_id
+            id ? "bond[#{id}]" : 'bond'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/molecular/constraints/bond_ids_unique_within_molecule.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # Molecular convention: a `<bond>` `id` MUST be unique within
+        # the eldest containing molecule. Mirrors the existing
+        # `AtomIdsUniqueWithinMolecule` constraint for bonds.
+        class BondIdsUniqueWithinMolecule < Chemicalml::Convention::Constraint::DocumentConstraint
+          self.description = 'Molecular convention: a `<bond>` `id` MUST be unique within the eldest containing molecule. Mirrors the existing `AtomIdsUniqueWithinMolecule` constraint for bonds.'
+          def check(document)
+            violations = []
+            walk_nodes(document) do |node, path|
+              next unless molecule?(node)
+
+              ids = bond_ids_within(node)
+              duplicates = ids.group_by { |x| x }.select { |_, v| v.length > 1 }.keys
+              duplicates.each do |dup|
+                violations << violation(
+                  path: (path + [describe(node)]).join('/'),
+                  message: "duplicate bond id #{dup.inspect} within molecule #{node.id.inspect}"
+                )
+              end
+            end
+            violations
+          end
+
+          private
+
+          def molecule?(node)
+            node.is_a?(Chemicalml::Cml::Role::Molecule)
+          end
+
+          def bond_ids_within(molecule)
+            return [] unless molecule.bond_array
+
+            (molecule.bond_array.bonds || []).map(&:id).compact
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chemicalml/convention/molecular/constraints/bond_must_have_atom_refs2.rb

@@ -5,13 +5,13 @@ module Chemicalml
     module Molecular
       module Constraints
         class BondMustHaveAtomRefs2 < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A <bond> MUST have an atomRefs2 attribute referencing two distinct atoms in the same molecule.'
+          applies_to Chemicalml::Cml::Role::Bond
           def check_node(node, path)
-            return [] unless node.is_a?(Chemicalml::Cml::Role::Bond)
-
             return [] unless node.atom_refs2.to_s.strip.empty?
 
-            [violation(path: path.empty? ? "bond" : path.join("/"),
-                       message: "bond must have an atomRefs2 attribute")]
+            [violation(path: path.empty? ? 'bond' : path.join('/'),
+                       message: 'bond must have an atomRefs2 attribute')]
           end
         end
       end

data/lib/chemicalml/convention/molecular/constraints/bond_must_have_order.rb

@@ -5,13 +5,14 @@ module Chemicalml
     module Molecular
       module Constraints
         class BondMustHaveOrder < Chemicalml::Convention::Constraint::NodeConstraint
-          def check_node(node, path)
-            return [] unless node.is_a?(Chemicalml::Cml::Role::Bond)
+          applies_to Chemicalml::Cml::Role::Bond
+          self.description = 'A <bond> MUST have an order attribute (S/D/T/A recommended).'
 
+          def check_node(node, path)
             return [] unless node.order.to_s.strip.empty?
 
-            [violation(path: path.empty? ? "bond" : path.join("/"),
-                       message: "bond must have an order attribute")]
+            [violation(path: path.empty? ? 'bond' : path.join('/'),
+                       message: 'bond must have an order attribute')]
           end
         end
       end

data/lib/chemicalml/convention/molecular/constraints/bond_must_reference_atoms_in_same_molecule.rb

@@ -7,6 +7,7 @@ module Chemicalml
         # Bonds MUST reference atoms within the same parent molecule
         # per the molecular convention.
         class BondMustReferenceAtomsInSameMolecule < Chemicalml::Convention::Constraint::DocumentConstraint
+          self.description = 'Bonds MUST reference atoms within the same parent molecule per the molecular convention.'
           def check(document)
             violations = []
             walk_nodes(document) do |node, path|
@@ -18,7 +19,7 @@ module Chemicalml
                 next if missing.empty?
 
                 violations << violation(
-                  path: path.empty? ? "molecule[#{node.id}]" : path.join("/"),
+                  path: path.empty? ? "molecule[#{node.id}]" : path.join('/'),
                   message: "bond #{bond.id.inspect} references atoms not in the same molecule: #{missing.inspect}"
                 )
               end
@@ -35,7 +36,7 @@ module Chemicalml
           def atom_ids_within(molecule)
             return [] unless molecule.atom_array
 
-            (molecule.atom_array.atoms || []).map { |a| a.id }
+            (molecule.atom_array.atoms || []).map(&:id)
           end
 
           def bonds_within(molecule)
@@ -45,7 +46,7 @@ module Chemicalml
           end
 
           def atom_refs_of(bond)
-            bond.atom_refs2.to_s.split(" ")
+            bond.atom_refs2.to_s.split
           end
         end
       end

data/lib/chemicalml/convention/molecular/constraints/bond_order_other_must_have_dict_ref.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # Molecular convention: `<bond>` with `order="other"` MUST
+        # have a `dictRef` pointing to the dictionary that defines
+        # the order semantics. The warning-level "should not be
+        # numeric" rule is separate; this is the hard error.
+        class BondOrderOtherMustHaveDictRef < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'Molecular convention: `<bond>` with `order="other"` MUST have a `dictRef` pointing to the dictionary that defines the order semantics. The warning-level "should not be'
+          applies_to Chemicalml::Cml::Role::Bond
+          def check_node(node, path)
+            return [] unless node.order.to_s.downcase == 'other'
+            return [] unless node.dict_ref.to_s.empty?
+
+            [violation(
+              path: (path + [describe(node)]).join('/'),
+              message: "bond order 'other' must have a dictRef " \
+                       'identifying the dictionary entry that defines it'
+            )]
+          end
+
+          private
+
+          def bond?(node)
+            node.is_a?(Chemicalml::Cml::Role::Bond)
+          end
+        end
+      end
+    end
+  end
+end