unitsml 0.4.7 → 0.6.0

data/lib/unitsml/unitsdb/dimensions.rb

@@ -2,12 +2,10 @@
 
 module Unitsml
   module Unitsdb
-    class Dimensions
-      attr_accessor :dimensions
-
+    class Dimensions < ::Unitsdb::Dimensions
       def find_by_vector(vector)
-        vectored
-        find(:vector, vector)
+        dimensions.each(&:set_vector)
+        dimensions.find { |dim| dim.set_vector == vector }
       end
 
       def find_by_id(d_id)
@@ -26,10 +24,6 @@ module Unitsml
 
       private
 
-      def vectored
-        @vectored ||= dimensions.each(&:set_vector)
-      end
-
       def find(field, matching_data)
         dimensions.find { |dim| dim.send(field) == matching_data }
       end

data/lib/unitsml/unitsdb/prefix_reference.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Unitsdb
+    class PrefixReference < ::Unitsdb::PrefixReference
+      def base
+        prefix.base
+      end
+
+      def symbolid
+        prefix.symbols.first.ascii
+      end
+
+      def power
+        prefix.power
+      end
+
+      def prefix
+        @prefix ||= Unitsdb.prefixes.find_by_id(id)
+      end
+    end
+  end
+end

data/lib/unitsml/unitsdb/prefixes.rb

@@ -2,19 +2,31 @@
 
 module Unitsml
   module Unitsdb
-    class Prefixes
-      attr_accessor :prefixes
+    class Prefixes < ::Unitsdb::Prefixes
+      def find_by_id(p_id)
+        find(p_id, :id, :identifiers)
+      end
 
       def find_by_symbol_name(ascii_sym)
-        prefixes.find { |prefix| prefix.symbol.ascii == ascii_sym }
+        find(ascii_sym, :ascii, :symbols)
       end
 
       def ascii_symbols
         prefixes.each_with_object([]) do |prefix, names_array|
-          symbol = prefix.symbol.ascii
+          symbol = prefix.symbols.map(&:ascii)
           next if symbol.empty?
 
-          names_array << symbol
+          names_array.concat(symbol)
+        end
+      end
+
+      private
+
+      def find(matching_data, field, prefix_method)
+        prefixes.find do |prefix|
+          prefix.public_send(prefix_method.to_sym).find do |object|
+            object.public_send(field) == matching_data
+          end
         end
       end
     end

data/lib/unitsml/unitsdb/quantities.rb

@@ -2,11 +2,11 @@
 
 module Unitsml
   module Unitsdb
-    class Quantities
-      attr_accessor :quantities
-
+    class Quantities < ::Unitsdb::Quantities
       def find_by_id(q_id)
-        quantities.find { |quantity| quantity.id == q_id }
+        quantities.find do |quantity|
+          quantity.identifiers.find { |id| id.id == q_id }
+        end
       end
     end
   end

data/lib/unitsml/unitsdb/unit.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Unitsml
+  module Unitsdb
+    class Unit < ::Unitsdb::Unit
+      def dimension_url
+        quantity_id = quantity_references[0].id
+        quantity = Unitsdb.quantities.find_by_id(quantity_id)
+        quantity.dimension_reference.id
+      end
+
+      def en_name
+        names.find { |name| name.lang == 'en' }&.value
+      end
+
+      def nist_id
+        identifiers.find { |id| id.type == 'nist' }&.id
+      end
+    end
+  end
+end

data/lib/unitsml/unitsdb/units.rb

@@ -2,42 +2,43 @@
 
 module Unitsml
   module Unitsdb
-    class Units
-      attr_accessor :units
-
+    class Units < ::Unitsdb::Units
       def find_by_id(u_id)
-        units.find { |unit| unit.id == u_id }
+        find(u_id, :id, :identifiers)
       end
 
       def find_by_name(u_name)
-        units.find do |unit|
-          unit.unit_symbols.find { |u_sym| u_sym.id == u_name }
-        end
+        find(u_name, :id, :symbols)
       end
 
       def filtered
-        @filtered ||= units_symbol_ids.reject do |unit|
-          ((/\*|\^|\/|^1$/).match?(unit) || find_by_symbol_id(unit).prefixed)
+        @filtered ||= symbols_ids.reject do |unit|
+          %r{\*|\^|/|^1$}.match?(unit) || find_by_symbol_id(unit).prefixed
         end
       end
 
       def find_by_symbol_id(sym_id)
-        units_symbol_hash[sym_id]
+        symbols_hash[sym_id]
       end
 
-      def units_symbol_ids
-        units_symbol_hash.keys
+      def symbols_ids
+        symbols_hash.keys
       end
 
-      def units_symbol_hash
-        @symbol_ids_hash ||= {}
+      def symbols_hash
+        @symbols_hash ||= units.each_with_object({}) do |unit, object|
+          unit.symbols&.each { |unit_sym| object[unit_sym.id] = unit }
+        end
+      end
+
+      private
 
-        if @symbol_ids_hash.empty?
-          units.each_with_object(@symbol_ids_hash) do |unit, object|
-            unit.unit_symbols.each { |unit_sym| object[unit_sym.id] = unit }
+      def find(matching_data, field, unit_method)
+        units.find do |unit|
+          unit.public_send(unit_method.to_sym).find do |id|
+            id.public_send(field) == matching_data
           end
         end
-        @symbol_ids_hash
       end
     end
   end

data/lib/unitsml/unitsdb.rb

@@ -2,6 +2,15 @@
 
 module Unitsml
   module Unitsdb
+    autoload :Unit, "#{__dir__}/unitsdb/unit"
+    autoload :Units, "#{__dir__}/unitsdb/units"
+    autoload :Prefixes, "#{__dir__}/unitsdb/prefixes"
+    autoload :Dimension, "#{__dir__}/unitsdb/dimension"
+    autoload :Dimensions, "#{__dir__}/unitsdb/dimensions"
+    autoload :Quantities, "#{__dir__}/unitsdb/quantities"
+    autoload :PrefixReference, "#{__dir__}/unitsdb/prefix_reference"
+    autoload :DimensionQuantity, "#{__dir__}/unitsdb/dimension_quantity"
+
     class << self
       def load_file(file_name)
         @@hash ||= {}
@@ -9,19 +18,19 @@ module Unitsml
       end
 
       def units
-        @@units_file ||= ::Unitsdb::Units.from_yaml(load_file(:units))
+        @@units_file ||= Unitsml.get_class_from_register(:unitsdb_units).from_yaml(load_file(:units))
       end
 
       def prefixes
-        @@prefixes ||= ::Unitsdb::Prefixes.from_yaml(load_file(:prefixes))
+        @@prefixes ||= Unitsml.get_class_from_register(:unitsdb_prefixes).from_yaml(load_file(:prefixes))
       end
 
       def dimensions
-        @@dim_file ||= ::Unitsdb::Dimensions.from_yaml(load_file(:dimensions))
+        @@dim_file ||= Unitsml.get_class_from_register(:unitsdb_dimensions).from_yaml(load_file(:dimensions))
       end
 
       def quantities
-        @@quantities ||= ::Unitsdb::Quantities.from_yaml(load_file(:quantities))
+        @@quantities ||= Unitsml.get_class_from_register(:unitsdb_quantities).from_yaml(load_file(:quantities))
       end
 
       def prefixes_array
@@ -37,7 +46,7 @@ module Unitsml
 
       def valid_path(file_name)
         File.expand_path(
-          File.join(__dir__, "..", "..","unitsdb", "#{file_name}.yaml")
+          File.join(__dir__, '..', '..', 'unitsdb', "#{file_name}.yaml")
         )
       end
     end

data/lib/unitsml/utility.rb

@@ -1,37 +1,32 @@
 # frozen_string_literal: true
 
-require "unitsml/model/unit"
-require "unitsml/model/prefix"
-require "unitsml/model/quantity"
-require "unitsml/model/dimension"
-
 module Unitsml
   module Utility
     # Unit to dimension
     U2D = {
-      "m" => { dimension: "Length", order: 1, symbol: "L" },
-      "g" => { dimension: "Mass", order: 2, symbol: "M" },
-      "kg" => { dimension: "Mass", order: 2, symbol: "M" },
-      "s" => { dimension: "Time", order: 3, symbol: "T" },
-      "A" => { dimension: "ElectricCurrent", order: 4, symbol: "I" },
-      "K" => { dimension: "ThermodynamicTemperature", order: 5,
-               symbol: "Theta" },
-      "degK" => { dimension: "ThermodynamicTemperature", order: 5,
-                  symbol: "Theta" },
-      "mol" => { dimension: "AmountOfSubstance", order: 6, symbol: "N" },
-      "cd" => { dimension: "LuminousIntensity", order: 7, symbol: "J" },
-      "deg" => { dimension: "PlaneAngle", order: 8, symbol: "phi" },
+      'm' => { dimension: 'Length', order: 1, symbol: 'L' },
+      'g' => { dimension: 'Mass', order: 2, symbol: 'M' },
+      'kg' => { dimension: 'Mass', order: 2, symbol: 'M' },
+      's' => { dimension: 'Time', order: 3, symbol: 'T' },
+      'A' => { dimension: 'ElectricCurrent', order: 4, symbol: 'I' },
+      'K' => { dimension: 'ThermodynamicTemperature', order: 5,
+               symbol: 'Theta' },
+      'degK' => { dimension: 'ThermodynamicTemperature', order: 5,
+                  symbol: 'Theta' },
+      'mol' => { dimension: 'AmountOfSubstance', order: 6, symbol: 'N' },
+      'cd' => { dimension: 'LuminousIntensity', order: 7, symbol: 'J' },
+      'deg' => { dimension: 'PlaneAngle', order: 8, symbol: 'phi' }
     }.freeze
     # Dimesion for dim_(dimesion) input
-    Dim2D = {
-      "dim_L" => U2D["m"],
-      "dim_M" => U2D["g"],
-      "dim_T" => U2D["s"],
-      "dim_I" => U2D["A"],
-      "dim_Theta" => U2D["K"],
-      "dim_N" => U2D["mol"],
-      "dim_J" => U2D["cd"],
-      "dim_phi" => U2D["deg"],
+    DIM2D = {
+      'dim_L' => U2D['m'],
+      'dim_M' => U2D['g'],
+      'dim_T' => U2D['s'],
+      'dim_I' => U2D['A'],
+      'dim_Theta' => U2D['K'],
+      'dim_N' => U2D['mol'],
+      'dim_J' => U2D['cd'],
+      'dim_phi' => U2D['deg']
     }.freeze
     DIMS_VECTOR = %w[
       ThermodynamicTemperature
@@ -44,6 +39,8 @@ module Unitsml
       Time
     ].freeze
 
+    UNKNOWN = 'unknown'
+
     class << self
       def unit_instance(unit)
         Unitsdb.units.find_by_symbol_id(unit)
@@ -55,7 +52,7 @@ module Unitsml
 
       def units2dimensions(units)
         norm = decompose_units_list(units)
-        return if norm.any? { |u| u.nil? || u[:unit].unit_name == "unknown" || u[:prefix] == "unknown" }
+        return if norm.any? { |u| u.nil? || u[:unit]&.unknown_name? || u[:prefix] == UNKNOWN }
 
         norm.map do |u|
           unit_name = u[:unit].unit_name
@@ -63,7 +60,7 @@ module Unitsml
             dimension: U2D[unit_name][:dimension],
             unit: unit_name,
             exponent: u[:unit].power_numerator || 1,
-            symbol: U2D[unit_name][:symbol],
+            symbol: U2D[unit_name][:symbol]
           }
         end.sort { |a, b| U2D[a[:unit]][:order] <=> U2D[b[:unit]][:order] }
       end
@@ -72,12 +69,20 @@ module Unitsml
         return nil if dims.nil? || dims.empty?
 
         dim_hash = dims.each_with_object({}) { |h, m| m[h[:dimension]] = h }
-        dims_vector = DIMS_VECTOR.map { |h| dim_hash.dig(h, :exponent) }.join(":")
+        dims_vector = DIMS_VECTOR.map { |h| dim_hash.dig(h, :exponent) }.join(':')
         id = Unitsdb.dimensions.find_by_vector(dims_vector)&.id and return id.to_s
-        "D_" + dims.map do |d|
-          (U2D.dig(d[:unit], :symbol) || Dim2D.dig(d[:id], :symbol)) +
-            (d[:exponent] == 1 ? "" : float_to_display(d[:exponent]))
-        end.join("")
+
+        'D_' + dims.map do |d|
+          (U2D.dig(d[:unit], :symbol) || DIM2D.dig(d[:id], :symbol)) +
+            (to_i_value(d[:exponent]) == 1 ? '' : float_to_display(d[:exponent]))
+        end.join('')
+      end
+
+      def to_i_value(object)
+        case object
+        when Integer, Float then object
+        when Number, Fenced then object.to_i
+        end
       end
 
       def decompose_units_list(units)
@@ -85,22 +90,21 @@ module Unitsml
       end
 
       def decompose_unit(u)
-        if u&.unit_name == "g" || u.system_type == "SI_base"
+        if u&.unit_name == 'g' || Lutaml::Model::Utils.snake_case(u.system_type) == 'si_base'
           { unit: u, prefix: u&.prefix }
         elsif u.si_derived_bases.nil? || u.si_derived_bases.empty?
-          { unit: Unit.new("unknown") }
+          { unit: Unit.new(UNKNOWN) }
         else
           u.si_derived_bases.each_with_object([]) do |k, object|
-            prefix = if !k.prefix.nil? && !k.prefix.empty?
-                       combine_prefixes(prefix_object(k.prefix), u.prefix)
+            prefix = if !k.prefix_reference.nil?
+                       combine_prefixes(prefix_object(k.prefix_reference), u.prefix)
                      else
                        u.prefix
                      end
-            unit_name = Unitsdb.units.find_by_id(k.id).unit_symbols.first.id
+            unit_name = Unitsdb.units.find_by_id(k.unit_reference.id).symbols.first.id
             exponent = (k.power&.to_i || 1) * (u.power_numerator&.to_f || 1)
             object << { prefix: prefix,
-                   unit: Unit.new(unit_name, exponent, prefix: prefix),
-                 }
+                        unit: Unit.new(unit_name, exponent, prefix: prefix) }
           end
         end
       end
@@ -110,15 +114,24 @@ module Unitsml
           if m.empty? || m[-1][:unit]&.unit_name != k[:unit]&.unit_name
             m << k
           else
-            m[-1][:unit]&.power_numerator = (k[:unit]&.power_numerator&.to_f || 1) + (m[-1][:unit]&.power_numerator&.to_f || 1)
+            m[-1][:unit]&.power_numerator = Number.new(numerator_value(k, m))
             m[-1] = {
               prefix: combine_prefixes(prefix_object(m[-1][:prefix]), prefix_object(k[:prefix])),
-              unit: m[-1][:unit],
+              unit: m[-1][:unit]
             }
           end
         end
       end
 
+      def numerator_value(unit_hash, unit_array)
+        unit_numerator_float(unit_hash) +
+          unit_numerator_float(unit_array[-1])
+      end
+
+      def unit_numerator_float(object_hash)
+        object_hash[:unit]&.power_numerator&.to_f || 1
+      end
+
       def prefix_object(prefix)
         return prefix unless prefix.is_a?(String)
         return nil unless Unitsdb.prefixes_array.any?(prefix)
@@ -130,76 +143,68 @@ module Unitsml
         return nil if p1.nil? && p2.nil?
         return p1.symbolid if p2.nil?
         return p2.symbolid if p1.nil?
-        return "unknown" if p1.base != p2.base
+        return UNKNOWN if p1.base != p2.base
 
         Unitsdb.prefixes_array.each do |prefix_name|
           p = prefix_object(prefix_name)
           return p if p.base == p1.base && p.power == p1.power + p2.power
         end
 
-        "unknown"
+        UNKNOWN
       end
 
       def unit(units, formula, dims, norm_text, name, options)
         attributes = {
           id: unit_id(norm_text),
           system: unitsystem(units),
-          name: unitname(units, norm_text, name),
+          name: unitname(norm_text, name),
           symbol: unitsymbols(formula, options),
-          root_units: rootunits(units),
+          root_units: rootunits(units)
         }
         attributes[:dimension_url] = "##{dim_id(dims)}" if dims
         Model::Unit.new(attributes).to_xml
-          .gsub("&lt;", "<")
-          .gsub("&gt;", ">")
-          .gsub("&amp;", "&")
-          .gsub(/−/, "&#x2212;")
-          .gsub(/⋅/, "&#x22c5;")
-      end
-
-      def unitname(units, text, name)
-        Model::Units::Name.new(
-          name: unit_instance(text)&.unit_name&.first || text
-        )
-      end
-
-      def postprocess_normtext(units)
-        units.map { |u| "#{u.prefix_name}#{u.unit_name}#{display_exp(u)}" }.join("*")
+                   .force_encoding('UTF-8')
+                   .gsub('&lt;', '<')
+                   .gsub('&gt;', '>')
+                   .gsub('&amp;', '&')
+                   .gsub(/−/, '&#x2212;')
+                   .gsub(/⋅/, '&#x22c5;')
       end
 
-      def display_exp(unit)
-        unit.power_numerator && unit.power_numerator != "1" ? "^#{unit.power_numerator}" : ""
+      def unitname(text, name)
+        name ||= unit_instance(text)&.en_name || text
+        Model::Units::Name.new(name: name)
       end
 
       def unitsymbols(formula, options)
         %w[HTML MathMl].map do |lang|
-          Model::Units::Symbol.new(type: lang, content: formula.public_send(:"to_#{lang.downcase}", options))
+          Model::Units::Symbol.new(
+            type: lang,
+            content: formula.public_send(:"to_#{lang.downcase}", options)
+          )
         end
       end
 
       def unitsystem(units)
         ret = []
-        if units.any? { |u| u.system_name != "SI" }
-          ret << Model::Units::System.new(name: "not_SI", type: "not_SI")
-        end
-        if units.any? { |u| u.system_name == "SI" }
+        ret << Model::Units::System.new(name: 'not_SI', type: 'not_SI') if units.any? { |u| !u.si_system_type? }
+        if units.any?(&:si_system_type?)
           if units.size == 1
-            base = units[0].system_type == "SI-base"
-            base = true if units[0].unit_name == "g" && units[0]&.prefix_name == "k"
+            base = units[0].downcase_system_type == 'si_base'
+            base = true if units[0].unit_name == 'g' && units[0]&.prefix_name == 'k'
           end
-          ret << Model::Units::System.new(name: "SI", type: (base ? 'SI_base' : 'SI_derived'))
+          ret << Model::Units::System.new(name: 'SI', type: (base ? 'SI_base' : 'SI_derived'))
         end
         ret
       end
 
       def dimension(norm_text)
-        dim_url = unit_instance(norm_text)&.dimension_url
-        return unless dim_url
+        dim_id = unit_instance(norm_text)&.dimension_url
+        return unless dim_id
 
-        dim_id = dim_url.sub("#", '')
         dim_attrs = { id: dim_id }
         dimid2dimensions(dim_id)&.compact&.each { |u| dimension1(u, dim_attrs) }
-        Model::Dimension.new(dim_attrs).to_xml
+        Model::Dimension.new(dim_attrs).to_xml.force_encoding('UTF-8')
       end
 
       def dimension1(dim, dims_hash)
@@ -212,26 +217,31 @@ module Unitsml
       end
 
       def float_to_display(float)
-        float.to_f.round(1).to_s.sub(/\.0$/, "")
+        case float
+        when Integer, Float
+          float.to_f.round(1).to_s.sub(/\.0$/, '')
+        when Number, Fenced
+          float.float_to_display
+        end
       end
 
       def dimid2dimensions(normtext)
         dims = Unitsdb.dimensions.find_by_id(normtext)
         dims&.processed_keys&.map do |processed_key|
-          humanized = processed_key.split("_").map(&:capitalize).join
+          humanized = processed_key.split('_').map(&:capitalize).join
           next unless DIMS_VECTOR.include?(humanized)
 
           dim_quantity = dims.public_send(processed_key)
           {
             dimension: humanized,
             symbol: dim_quantity.symbol,
-            exponent: dim_quantity.power_numerator,
+            exponent: dim_quantity.power
           }
         end
       end
 
       def prefixes(units, options)
-        uniq_prefixes = units.map { |unit| unit.prefix }.compact.uniq {|d| d.prefix_name }
+        uniq_prefixes = units.map(&:prefix).compact.uniq(&:prefix_name)
         uniq_prefixes.map do |prefix|
           prefix_attrs = { prefix_base: prefix&.base, prefix_power: prefix&.power, id: prefix&.id }
           type_and_methods = { ASCII: :to_asciimath, unicode: :to_unicode, LaTeX: :to_latex, HTML: :to_html }
@@ -239,10 +249,10 @@ module Unitsml
           prefix_attrs[:symbol] = type_and_methods.map do |type, method_name|
             Model::Prefixes::Symbol.new(
               type: type,
-              content: prefix&.public_send(method_name, options),
+              content: prefix&.public_send(method_name, options)
             )
           end
-          Model::Prefix.new(prefix_attrs).to_xml.gsub("&amp;", "&")
+          Model::Prefix.new(prefix_attrs).to_xml.force_encoding('UTF-8').gsub('&amp;', '&')
         end.join("\n")
       end
 
@@ -252,18 +262,24 @@ module Unitsml
         enum_root_units = units.map do |unit|
           attributes = { unit: unit.enumerated_name }
           attributes[:prefix] = unit.prefix_name if unit.prefix
-          unit.power_numerator && unit.power_numerator != "1" and
-            attributes[:power_numerator] = unit.power_numerator
+          unit.power_numerator && unit.power_numerator != '1' and
+            attributes[:power_numerator] = unit.power_numerator.raw_value
           Model::Units::EnumeratedRootUnit.new(attributes)
         end
         Model::Units::RootUnits.new(enumerated_root_unit: enum_root_units)
       end
 
       def unit_id(text)
-        norm_text = text
-        text = text&.gsub(/[()]/, "")
-        unit = unit_instance(norm_text)
-        "U_#{unit ? unit.id&.gsub(/'/, '_') : norm_text&.gsub(/\*/, '.')&.gsub(/\^/, '')}"
+        text = text&.gsub(/[()]/, '')
+        unit = unit_instance(text)
+
+        format_unit_id(unit, text)&.insert(0, 'U_')
+      end
+
+      def format_unit_id(unit, text)
+        return unit.nist_id&.gsub(/'/, '_') if unit
+
+        text&.gsub(/\*/, '.')&.gsub(/\^/, '')
       end
 
       def dimension_components(dims)
@@ -271,45 +287,59 @@ module Unitsml
 
         dim_attrs = { id: dim_id(dims) }
         dims.map { |u| dimension1(u, dim_attrs) }
-        Model::Dimension.new(dim_attrs).to_xml
+        Model::Dimension.new(dim_attrs).to_xml.force_encoding('UTF-8')
       end
 
-      def quantity(normtext, quantity)
+      def quantity(normtext, instance)
         unit = unit_instance(normtext)
-        return unless unit && unit.quantity_reference.size == 1 ||
+        return unless unit_or_quantity(unit, instance)
+
+        model_quantity_xml(
+          instance || unit.quantity_references&.first&.id,
+          "##{unit.dimension_url}"
+        )
+      end
+
+      def unit_or_quantity(unit, quantity)
+        unit && unit.quantity_references.size == 1 ||
           quantity_instance(quantity)
+      end
 
-        id = (quantity || unit.quantity_reference&.first&.url).sub('#', '')
-        dim_url = unit.dimension_url
-        attributes = { id: id, name: quantity_name(id), dimension_url: dim_url }
-        Model::Quantity.new(attributes).to_xml
+      def model_quantity_xml(id, url)
+        Model::Quantity.new(
+          id: id,
+          name: quantity_name(id),
+          dimension_url: url
+        ).to_xml.force_encoding('UTF-8')
       end
 
       def quantity_name(id)
-        quantity_instance(id)&.quantity_name&.map do |content|
-          Model::Quantities::Name.new(content: content)
+        quantity_instance(id)&.names&.filter_map do |name|
+          next unless name.lang == 'en'
+
+          Model::Quantities::Name.new(content: name.value)
         end
       end
 
       def string_to_html_entity(string)
-        entities = HTMLEntities.new
-        entities.encode(
+        HTMLEntities.new.encode(
           string.frozen? ? string : string.force_encoding('UTF-8'),
-          :hexadecimal,
+          :hexadecimal
         )
       end
 
       def html_entity_to_unicode(string)
-        entities = HTMLEntities.new
-        entities.decode(string)
+        HTMLEntities.new.decode(string)
       end
 
       def underscore(str)
         str.gsub(/([a-z])([A-Z])/, '\1_\2').downcase
       end
 
-      def class_name(klass)
-        klass.name.split("::").last
+      def set_to_fence(set)
+        return set if set.is_a?(Fenced)
+
+        Fenced.new('(', set, ')')
       end
     end
   end