chemicalml 0.2.0 → 0.3.0

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # A `<bond>`'s `order` attribute SHOULD be one of the XSD
+        # orderType enum values: S/1/D/2/T/3/A/unknown/other.
+        # Warning severity — CML permits extension values via
+        # convention-specific dicts.
+        class BondOrderShouldBeInEnum < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = "A `<bond>`'s `order` attribute SHOULD be one of the XSD orderType enum values: S/1/D/2/T/3/A/unknown/other. Warning severity — CML permits extension values via"
+          include Chemicalml::Cml::Enums
+
+          applies_to Chemicalml::Cml::Role::Bond
+
+          def check_node(node, _path)
+            order = node.order.to_s
+            return [] if order.empty?
+            return [] if ORDER_VALUES.include?(order)
+
+            [violation(path: yield_path(node),
+                       message: "bond #{node.id.inspect} order #{order.inspect} should be one of " \
+                                "#{ORDER_VALUES.to_a.sort.inspect}",
+                       severity: :warning,
+                       value: order)]
+          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_order_should_not_be_numeric.rb

@@ -5,17 +5,17 @@ module Chemicalml
     module Molecular
       module Constraints
         class BondOrderShouldNotBeNumeric < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = "A <bond>'s order attribute SHOULD be one of S/D/T/Q/A or 'other' (numeric values are not recommended)."
+          applies_to Chemicalml::Cml::Role::Bond
           VALID_ORDERS = %w[S D T Q A other].freeze
 
           def check_node(node, path)
-            return [] unless node.is_a?(Chemicalml::Cml::Role::Bond)
-
             order = node.order.to_s
             return [] if order.empty?
 
             return [] if VALID_ORDERS.include?(order) || node.dict_ref.to_s.size.positive?
 
-            [violation(path: path.empty? ? "bond" : path.join("/"),
+            [violation(path: path.empty? ? 'bond' : path.join('/'),
                        message: "bond order #{order.inspect} is not recommended " \
                                 "(use S/D/T/Q/A or 'other' with dictRef)",
                        severity: :warning)]

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # A `<bondStereo>` with `atomRefs4` (used by C/T stereo)
+        # SHOULD reference four distinct atom ids. Duplicate ids make
+        # the stereo descriptor meaningless. Warning severity.
+        class BondStereoAtomRefs4ShouldBeDistinct < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A `<bondStereo>` with `atomRefs4` (used by C/T stereo) SHOULD reference four distinct atom ids. Duplicate ids make the stereo descriptor meaningless. Warning severity.'
+          applies_to Chemicalml::Cml::Role::BondStereo
+
+          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: "bondStereo #{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 ? "bondStereo[#{id}]" : 'bondStereo'
+          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_stereo_cis_trans_must_have_atom_refs4.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # Molecular convention: `<bondStereo>` value C (cis) or T
+        # (trans) MUST have `atomRefs4` and MUST NOT have `atomRefs2`.
+        class BondStereoCisTransMustHaveAtomRefs4 < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'Molecular convention: `<bondStereo>` value C (cis) or T (trans) MUST have `atomRefs4` and MUST NOT have `atomRefs2`.'
+          applies_to Chemicalml::Cml::Role::BondStereo
+          CIS_TRANS_VALUES = %w[C T].freeze
+
+          def check_node(node, path)
+            value = node.content.to_s.upcase
+            return [] unless CIS_TRANS_VALUES.include?(value)
+
+            violations = []
+            if node.atom_refs4.to_s.strip.empty?
+              violations << violation(
+                path: (path + [describe(node)]).join('/'),
+                message: "bondStereo value #{value.inspect} must have atomRefs4 " \
+                         '(four atom ids; two must match the parent bond)'
+              )
+            end
+            unless node.atom_refs2.to_s.strip.empty?
+              violations << violation(
+                path: (path + [describe(node)]).join('/'),
+                message: "bondStereo value #{value.inspect} must not have atomRefs2 " \
+                         '(only W/H wedge/hatch values use atomRefs2)'
+              )
+            end
+            violations
+          end
+
+          private
+
+          def bond_stereo?(node)
+            node.is_a?(Chemicalml::Cml::Role::BondStereo)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # Molecular convention: `<bondStereo>` with value `other`
+        # MUST have a `dictRef` pointing to the convention that
+        # defines the stereo semantics.
+        class BondStereoOtherMustHaveDictRef < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'Molecular convention: `<bondStereo>` with value `other` MUST have a `dictRef` pointing to the convention that defines the stereo semantics.'
+          applies_to Chemicalml::Cml::Role::BondStereo
+          def check_node(node, path)
+            return [] unless node.content.to_s.downcase == 'other'
+            return [] unless node.dict_ref.to_s.empty?
+
+            [violation(
+              path: (path + [describe(node)]).join('/'),
+              message: "bondStereo value 'other' must have a dictRef " \
+                       'identifying the convention that defines it'
+            )]
+          end
+
+          private
+
+          def bond_stereo?(node)
+            node.is_a?(Chemicalml::Cml::Role::BondStereo)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # A `<bondStereo>`'s `value` attribute SHOULD be one of the
+        # XSD stereoType enum values: C/T/W/H/undefined/other.
+        # Warning severity.
+        class BondStereoShouldBeInEnum < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = "A `<bondStereo>`'s `value` attribute SHOULD be one of the XSD stereoType enum values: C/T/W/H/undefined/other. Warning severity."
+          include Chemicalml::Cml::Enums
+
+          applies_to Chemicalml::Cml::Role::BondStereo
+
+          def check_node(node, _path)
+            value = node.content.to_s
+            return [] if value.empty?
+            return [] if STEREO_VALUES.include?(value)
+
+            [violation(path: yield_path(node),
+                       message: "bondStereo #{node.id.inspect} value #{value.inspect} should be one of " \
+                                "#{STEREO_VALUES.to_a.sort.inspect}",
+                       severity: :warning,
+                       value: value)]
+          end
+
+          private
+
+          def yield_path(node)
+            id = node.node_id
+            id ? "bondStereo[#{id}]" : 'bondStereo'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # Molecular convention: `<bondStereo>` value W (wedge) or H
+        # (hatch) MUST have `atomRefs2` and MUST NOT have `atomRefs4`.
+        class BondStereoWedgeHashMustHaveAtomRefs2 < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'Molecular convention: `<bondStereo>` value W (wedge) or H (hatch) MUST have `atomRefs2` and MUST NOT have `atomRefs4`.'
+          applies_to Chemicalml::Cml::Role::BondStereo
+          WEDGE_HASH_VALUES = %w[W H].freeze
+
+          def check_node(node, path)
+            value = node.content.to_s.upcase
+            return [] unless WEDGE_HASH_VALUES.include?(value)
+
+            violations = []
+            if node.atom_refs2.to_s.strip.empty?
+              violations << violation(
+                path: (path + [describe(node)]).join('/'),
+                message: "bondStereo value #{value.inspect} must have atomRefs2 " \
+                         '(first atom = sharp end, second = blunt end)'
+              )
+            end
+            unless node.atom_refs4.to_s.strip.empty?
+              violations << violation(
+                path: (path + [describe(node)]).join('/'),
+                message: "bondStereo value #{value.inspect} must not have atomRefs4 " \
+                         '(only C/T cis-trans values use atomRefs4)'
+              )
+            end
+            violations
+          end
+
+          private
+
+          def bond_stereo?(node)
+            node.is_a?(Chemicalml::Cml::Role::BondStereo)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # Walks the document and warns on any element whose `dictRef`
+        # attribute cannot be resolved against the built-in
+        # dictionaries. Catches typos like `dictRef="cml:bpingpoint"`.
+        #
+        # DocumentConstraint — needs the whole tree, but the resolver
+        # works per-node so it's just a wrapper around the per-node
+        # check.
+        class DictRefShouldResolve < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'Walks the document and warns on any element whose `dictRef` attribute cannot be resolved against the built-in dictionaries. Catches typos like `dictRef="cml:bpingpoint"`.'
+          applies_to Chemicalml::Cml::Role::Atom,
+                     Chemicalml::Cml::Role::Bond,
+                     Chemicalml::Cml::Role::Molecule,
+                     Chemicalml::Cml::Role::Property,
+                     Chemicalml::Cml::Role::Scalar,
+                     Chemicalml::Cml::Role::Array,
+                     Chemicalml::Cml::Role::Matrix,
+                     Chemicalml::Cml::Role::Name,
+                     Chemicalml::Cml::Role::Label
+
+          def check_node(node, path)
+            dict_ref = node.dict_ref.to_s.strip
+            return [] if dict_ref.empty?
+            return [] if resolves?(dict_ref)
+
+            [violation(path: path_fingerprint(node, path),
+                       message: "#{node.element_name} #{node_id_or_blank(node).inspect} " \
+                                "dictRef #{dict_ref.inspect} does not resolve against any built-in dictionary",
+                       severity: :warning,
+                       value: dict_ref)]
+          end
+
+          private
+
+          def resolves?(dict_ref)
+            !Chemicalml::Dictionary::Registry.lookup(dict_ref).nil?
+          rescue StandardError
+            false
+          end
+
+          def path_fingerprint(node, path)
+            base = path.empty? ? node.element_name : path.join('/')
+            id = node.node_id
+            id ? "#{base}[#{id}]" : base
+          end
+
+          def node_id_or_blank(node)
+            node.node_id || ''
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # Molecular convention: a `<molecule>` MAY hold an `atomArray`
+        # OR child `<molecule>` elements, but not both. The two are
+        # mutually exclusive ways of describing composition.
+        class MoleculeAtomArrayMutuallyExclusiveWithChildren < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'Molecular convention: a `<molecule>` MAY hold an `atomArray` OR child `<molecule>` elements, but not both. The two are mutually exclusive ways of describing composition.'
+          applies_to Chemicalml::Cml::Role::Molecule
+          def check_node(node, path)
+            return [] if node.atom_array.nil?
+            return [] if (node.molecules || []).empty?
+
+            [violation(
+              path: (path + [describe(node)]).join('/'),
+              message: "molecule #{node.id.inspect} has both an atomArray " \
+                       'and child molecule elements — these are mutually exclusive'
+            )]
+          end
+
+          private
+
+          def molecule?(node)
+            node.is_a?(Chemicalml::Cml::Role::Molecule)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # Molecular convention: a `<molecule>` MAY hold a `bondArray`
+        # OR child `<molecule>` elements, but not both.
+        class MoleculeBondArrayMutuallyExclusiveWithChildren < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'Molecular convention: a `<molecule>` MAY hold a `bondArray` OR child `<molecule>` elements, but not both.'
+          applies_to Chemicalml::Cml::Role::Molecule
+          def check_node(node, path)
+            return [] if node.bond_array.nil?
+            return [] if (node.molecules || []).empty?
+
+            [violation(
+              path: (path + [describe(node)]).join('/'),
+              message: "molecule #{node.id.inspect} has both a bondArray " \
+                       'and child molecule elements — these are mutually exclusive'
+            )]
+          end
+
+          private
+
+          def molecule?(node)
+            node.is_a?(Chemicalml::Cml::Role::Molecule)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # A `<molecule>`'s `chirality` attribute SHOULD be one of the
+        # XSD chiralityType enum values:
+        # enantiomer/racemate/unknown/other. Warning severity.
+        class MoleculeChiralityShouldBeInEnum < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = "A `<molecule>`'s `chirality` attribute SHOULD be one of the XSD chiralityType enum values: enantiomer/racemate/unknown/other. Warning severity."
+          include Chemicalml::Cml::Enums
+
+          applies_to Chemicalml::Cml::Role::Molecule
+
+          def check_node(node, _path)
+            chirality = node.chirality.to_s
+            return [] if chirality.empty?
+            return [] if CHIRALITY_VALUES.include?(chirality)
+
+            [violation(path: yield_path(node),
+                       message: "molecule #{node.id.inspect} chirality #{chirality.inspect} should be one of " \
+                                "#{CHIRALITY_VALUES.to_a.sort.inspect}",
+                       severity: :warning,
+                       value: chirality)]
+          end
+
+          private
+
+          def yield_path(node)
+            id = node.node_id
+            id ? "molecule[#{id}]" : 'molecule'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # Molecular convention: `count` MUST NOT appear on top-level
+        # molecules (direct children of `<cml>`). It is REQUIRED on
+        # molecules nested inside another `<molecule>`.
+        class MoleculeCountMustNotAppearOnTopLevel < Chemicalml::Convention::Constraint::DocumentConstraint
+          self.description = 'Molecular convention: `count` MUST NOT appear on top-level molecules (direct children of `<cml>`). It is REQUIRED on molecules nested inside another `<molecule>`.'
+          def check(document)
+            violations = []
+            top_level_molecules(document).each do |mol, path|
+              next if mol.count.to_s.empty?
+
+              violations << violation(
+                path: (path + [describe(mol)]).join('/'),
+                message: "top-level molecule #{mol.id.inspect} must not have " \
+                         'a count attribute (only nested molecules may carry count)'
+              )
+            end
+            violations
+          end
+
+          private
+
+          def top_level_molecules(document)
+            (document.molecules || []).map { |m| [m, []] }
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -5,13 +5,13 @@ module Chemicalml
     module Molecular
       module Constraints
         class MoleculeMustHaveId < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A <molecule> in a molecular document MUST have an id attribute unique within document scope.'
+          applies_to Chemicalml::Cml::Role::Molecule
           def check_node(node, path)
-            return [] unless node.is_a?(Chemicalml::Cml::Role::Molecule)
-
             return [] unless node.id.to_s.empty?
 
-            [violation(path: path.empty? ? "molecule" : path.join("/"),
-                       message: "molecule must have an id attribute")]
+            [violation(path: path.empty? ? 'molecule' : path.join('/'),
+                       message: 'molecule must have an id attribute')]
           end
         end
       end

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

@@ -5,13 +5,13 @@ module Chemicalml
     module Molecular
       module Constraints
         class PropertyMustHaveDictRef < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A <property> MUST have a dictRef attribute that identifies the property type via a dictionary entry.'
+          applies_to Chemicalml::Cml::Role::Property
           def check_node(node, path)
-            return [] unless node.is_a?(Chemicalml::Cml::Role::Property)
-
             return [] unless node.dict_ref.to_s.empty?
 
-            [violation(path: path.empty? ? "property" : path.join("/"),
-                       message: "property must have a dictRef attribute")]
+            [violation(path: path.empty? ? 'property' : path.join('/'),
+                       message: 'property must have a dictRef attribute')]
           end
         end
       end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # A `<property>` with a `dictRef` whose dictionary entry declares
+        # a `dataType` SHOULD have a child `<scalar>` whose `dataType`
+        # attribute matches. Catches inconsistencies like a property
+        # declaring `dictRef="cml:bp"` (boiling point, xsd:float) but
+        # carrying a `<scalar dataType="xsd:string">`.
+        #
+        # Warning severity — some dictionaries allow multiple dataTypes.
+        class PropertyScalarDataTypeMatchesDictionary < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A `<property>` with a `dictRef` whose dictionary entry declares a `dataType` SHOULD have a child `<scalar>` whose `dataType` attribute matches. Catches inconsistencies like a property'
+          applies_to Chemicalml::Cml::Role::Property
+
+          def check_node(node, _path)
+            dict_ref = node.dict_ref.to_s
+            return [] if dict_ref.empty?
+
+            entry = lookup_entry(dict_ref)
+            return [] unless entry
+
+            expected_type = entry.data_type.to_s
+            return [] if expected_type.empty?
+
+            scalar = node.scalar
+            return [] unless scalar
+
+            actual_type = scalar.data_type.to_s
+            return [] if actual_type.empty?
+            return [] if actual_type == expected_type
+
+            [violation(path: yield_path(node),
+                       message: "property #{node.id.inspect} dictRef #{dict_ref.inspect} " \
+                                "expects dataType #{expected_type.inspect} but scalar has #{actual_type.inspect}",
+                       severity: :warning,
+                       value: { expected: expected_type, actual: actual_type }.freeze)]
+          end
+
+          private
+
+          def lookup_entry(dict_ref)
+            Chemicalml::Dictionary::Registry.lookup(dict_ref)
+          rescue StandardError
+            nil
+          end
+
+          def yield_path(node)
+            id = node.node_id
+            id ? "property[#{id}]" : 'property'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Chemicalml
+  module Convention
+    module Molecular
+      module Constraints
+        # Walks the document via `Cml::ReferenceResolver` and reports
+        # every bond whose `atomRefs2` references atoms that don't
+        # exist in the parent molecule. Warning severity — there are
+        # edge cases (inter-molecular bonds in transition states).
+        #
+        # DocumentConstraint because it needs the whole tree to
+        # resolve references.
+        class ReferencesShouldResolve < Chemicalml::Convention::Constraint::DocumentConstraint
+          self.description = "Walks the document via `Cml::ReferenceResolver` and reports every bond whose `atomRefs2` references atoms that don't exist in the parent molecule. Warning severity — there are"
+          def check(document)
+            resolver = Chemicalml::Cml::ReferenceResolver.new(document)
+            resolver.unresolved_refs.map do |entry|
+              violation(path: describe(entry[:node]),
+                        message: "bond #{entry[:node].id.inspect} #{entry[:attr]} references " \
+                                 "missing atoms: #{entry[:missing].inspect}",
+                        severity: :warning,
+                        value: entry[:missing])
+            end
+          end
+
+          private
+
+          def describe(node)
+            id = node.node_id
+            id ? "#{node.element_name}[#{id}]" : node.element_name
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,13 +5,13 @@ module Chemicalml
     module Molecular
       module Constraints
         class ScalarMustHaveDataType < Chemicalml::Convention::Constraint::NodeConstraint
+          self.description = 'A <scalar> child of a <property> MUST have a dataType attribute (e.g. xsd:float, xsd:integer).'
+          applies_to Chemicalml::Cml::Role::Scalar
           def check_node(node, path)
-            return [] unless node.is_a?(Chemicalml::Cml::Role::Scalar)
-
             return [] unless node.data_type.to_s.empty?
 
-            [violation(path: path.empty? ? "scalar" : path.join("/"),
-                       message: "scalar must have a dataType attribute")]
+            [violation(path: path.empty? ? 'scalar' : path.join('/'),
+                       message: 'scalar must have a dataType attribute')]
           end
         end
       end