genericode 0.1.3 → 0.2.0

data/lib/genericode/code_list.rb

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 
-require "lutaml/model"
-require "uri"
+require 'lutaml/model'
+require_relative 'gc_namespace'
+require 'uri'
 
-require_relative "annotation"
-require_relative "column_set"
-require_relative "column_set_ref"
-require_relative "identification"
-require_relative "simple_code_list"
+require_relative 'annotation'
+require_relative 'column_set'
+require_relative 'column_set_ref'
+require_relative 'identification'
+require_relative 'simple_code_list'
 
 module Genericode
   class CodeList < Lutaml::Model::Serializable
@@ -19,30 +20,30 @@ module Genericode
 
     def self.from_file(file_path)
       content = File.read(file_path)
-      if file_path.end_with?(".gc")
+      if file_path.end_with?('.gc')
         from_xml(content)
-      elsif file_path.end_with?(".gcj")
+      elsif file_path.end_with?('.gcj')
         from_json(content)
       else
-        raise Error, "Unsupported file format. Expected .gc or .gcj file."
+        raise Error, 'Unsupported file format. Expected .gc or .gcj file.'
       end
     end
 
     json do
-      map "Annotation", to: :annotation
-      map "Identification", to: :identification
-      map "Columns", to: :column_set, with: { from: :column_set_from_json, to: :column_set_to_json }
-      map "ColumnSetRef", to: :column_set_ref
-      map "Keys", to: :key, delegate: :column_set, with: { from: :key_from_json, to: :key_to_json }
-      map "Codes", to: :simple_code_list, with: { from: :simple_code_list_from_json, to: :simple_code_list_to_json }
+      map 'Annotation', to: :annotation
+      map 'Identification', to: :identification
+      map 'Columns', to: :column_set, with: { from: :column_set_from_json, to: :column_set_to_json }
+      map 'ColumnSetRef', to: :column_set_ref
+      map 'Keys', to: :key, delegate: :column_set, with: { from: :key_from_json, to: :key_to_json }
+      map 'Codes', to: :simple_code_list, with: { from: :simple_code_list_from_json, to: :simple_code_list_to_json }
     end
 
     def column_set_from_json(model, value)
-      model.column_set = ColumnSet.of_json({ "Column" => value })
+      model.column_set = ColumnSet.of_json({ 'Column' => value })
     end
 
     def column_set_to_json(model, doc)
-      doc["Columns"] = Column.as_json(model.column_set.column)
+      doc['Columns'] = Column.as_json(model.column_set.column)
     end
 
     def key_from_json(model, value)
@@ -50,7 +51,7 @@ module Genericode
     end
 
     def key_to_json(model, doc)
-      doc["Keys"] = Key.as_json(model.column_set.key)
+      doc['Keys'] = Key.as_json(model.column_set.key)
     end
 
     def simple_code_list_from_json(model, value)
@@ -66,25 +67,25 @@ module Genericode
     end
 
     def simple_code_list_to_json(model, doc)
-      doc["Codes"] = model.simple_code_list.row.map do |row|
+      doc['Codes'] = model.simple_code_list.row.map do |row|
         row.value.to_h { |v| [v.column_ref, v.simple_value.content] }
       end
     end
 
     xml do
-      root "CodeList"
-      namespace "http://docs.oasis-open.org/codelist/ns/genericode/1.0/", "gc"
-
-      map_element "Annotation", to: :annotation, prefix: nil, namespace: nil
-      map_element "Identification", to: :identification, prefix: nil, namespace: nil
-      map_element "ColumnSet", to: :column_set, prefix: nil, namespace: nil
-      map_element "ColumnSetRef", to: :column_set_ref, prefix: nil, namespace: nil
-      map_element "SimpleCodeList", to: :simple_code_list, prefix: nil, namespace: nil
+      namespace GcNamespace
+      element 'CodeList'
+
+      map_element 'Annotation', to: :annotation
+      map_element 'Identification', to: :identification
+      map_element 'ColumnSet', to: :column_set
+      map_element 'ColumnSetRef', to: :column_set_ref
+      map_element 'SimpleCodeList', to: :simple_code_list
     end
 
     def lookup(path)
-      parts = path.split(">")
-      conditions = parts[0].split(",").to_h { |c| c.split(":") }
+      parts = path.split('>')
+      conditions = parts[0].split(',').to_h { |c| c.split(':') }
       target_column = parts[1]
 
       result = simple_code_list.row.find do |row|
@@ -108,7 +109,7 @@ module Genericode
         result.value.to_h do |v|
           [column_set.column.find do |c|
             c.id == v.column_ref
-          end.short_name.content, v.simple_value.content,]
+          end.short_name.content, v.simple_value.content]
         end
       end
     end
@@ -122,28 +123,28 @@ module Genericode
 
       # Rule 1: ColumnSet presence
       if column_set.nil? || column_set.column.empty?
-        errors << { code: "MISSING_COLUMN_SET",
-                    message: "ColumnSet is missing or empty", }
+        errors << { code: 'MISSING_COLUMN_SET',
+                    message: 'ColumnSet is missing or empty' }
       end
 
       # Rule 2: SimpleCodeList presence
       if simple_code_list.nil? || simple_code_list.row.empty?
-        errors << { code: "MISSING_SIMPLE_CODE_LIST",
-                    message: "SimpleCodeList is missing or empty", }
+        errors << { code: 'MISSING_SIMPLE_CODE_LIST',
+                    message: 'SimpleCodeList is missing or empty' }
       end
 
       # Rule 3: Unique column IDs
       column_ids = column_set&.column&.map(&:id) || []
       if column_ids.uniq.length != column_ids.length
-        errors << { code: "DUPLICATE_COLUMN_IDS", message: "Duplicate column IDs found" }
+        errors << { code: 'DUPLICATE_COLUMN_IDS', message: 'Duplicate column IDs found' }
       end
 
       # Rule 4: Verify ColumnRef values
       simple_code_list&.row&.each_with_index do |row, index|
         row.value.each do |value|
           unless column_ids.include?(value.column_ref)
-            errors << { code: "INVALID_COLUMN_REF",
-                        message: "Invalid ColumnRef '#{value.column_ref}' in row #{index + 1}", }
+            errors << { code: 'INVALID_COLUMN_REF',
+                        message: "Invalid ColumnRef '#{value.column_ref}' in row #{index + 1}" }
           end
         end
       end
@@ -155,17 +156,17 @@ module Genericode
         end || []).compact
 
         if column_values.uniq.length != column_values.length
-          errors << { code: "DUPLICATE_VALUES", message: "Duplicate values found in column '#{col.id}'" }
+          errors << { code: 'DUPLICATE_VALUES', message: "Duplicate values found in column '#{col.id}'" }
         end
       end
 
       # Rule 6: Required column values
-      required_columns = column_set&.column&.select { |col| col.use == "required" } || []
+      required_columns = column_set&.column&.select { |col| col.use == 'required' } || []
       simple_code_list&.row&.each_with_index do |row, index|
         required_columns.each do |col|
           unless row.value.any? { |v| v.column_ref == col.id && v.simple_value&.content }
-            errors << { code: "MISSING_REQUIRED_VALUE",
-                        message: "Missing value for required column '#{col.short_name&.content}' in row #{index + 1}", }
+            errors << { code: 'MISSING_REQUIRED_VALUE',
+                        message: "Missing value for required column '#{col.short_name&.content}' in row #{index + 1}" }
           end
         end
       end
@@ -176,49 +177,49 @@ module Genericode
         simple_code_list&.row&.each_with_index do |row, index|
           value = row.value.find { |v| v.column_ref == col.id }&.simple_value&.content
           unless value_matches_type?(value, data_type)
-            errors << { code: "INVALID_DATA_TYPE",
-                        message: "Invalid data type for column '#{col.short_name&.content}' in row #{index + 1}", }
+            errors << { code: 'INVALID_DATA_TYPE',
+                        message: "Invalid data type for column '#{col.short_name&.content}' in row #{index + 1}" }
           end
         end
       end
 
       # Rule 8: Valid canonical URIs
       if identification&.canonical_uri && !valid_uri?(identification.canonical_uri)
-        errors << { code: "INVALID_CANONICAL_URI", message: "Invalid canonical URI" }
+        errors << { code: 'INVALID_CANONICAL_URI', message: 'Invalid canonical URI' }
       end
 
       # Rule 19: Datatype ID validation
       column_set&.column&.each do |col|
         if col.data&.type && !valid_datatype_id?(col.data.type)
-          errors << { code: "INVALID_DATATYPE_ID",
-                      message: "Invalid datatype ID for column '#{col.short_name&.content}'", }
+          errors << { code: 'INVALID_DATATYPE_ID',
+                      message: "Invalid datatype ID for column '#{col.short_name&.content}'" }
         end
 
         # Rule 20 and 22: Complex data validation
-        if col.data&.type == "*" && col.data&.datatype_library != "*"
-          errors << { code: "INVALID_COMPLEX_DATA",
-                      message: "Invalid complex data configuration for column '#{col.short_name&.content}'", }
+        if col.data&.type == '*' && col.data&.datatype_library != '*'
+          errors << { code: 'INVALID_COMPLEX_DATA',
+                      message: "Invalid complex data configuration for column '#{col.short_name&.content}'" }
         end
 
         # Rule 23: Language attribute validation
         if col.data&.lang && col.data_restrictions&.lang
-          errors << { code: "DUPLICATE_LANG_ATTRIBUTE",
-                      message: "Duplicate lang attribute for column '#{col.short_name&.content}'", }
+          errors << { code: 'DUPLICATE_LANG_ATTRIBUTE',
+                      message: "Duplicate lang attribute for column '#{col.short_name&.content}'" }
         end
       end
 
       # Rule 38: Implicit column reference
       simple_code_list&.row&.each_with_index do |row, index|
         unless row.value.all?(&:column_ref)
-          errors << { code: "MISSING_COLUMN_REF", message: "Missing explicit column reference in row #{index + 1}" }
+          errors << { code: 'MISSING_COLUMN_REF', message: "Missing explicit column reference in row #{index + 1}" }
         end
       end
 
       # Rule 39: ShortName whitespace check
       column_set&.column&.each do |col|
         if col.short_name&.content&.match?(/\s/)
-          errors << { code: "INVALID_SHORT_NAME",
-                      message: "ShortName '#{col.short_name&.content}' contains whitespace", }
+          errors << { code: 'INVALID_SHORT_NAME',
+                      message: "ShortName '#{col.short_name&.content}' contains whitespace" }
         end
       end
 
@@ -228,8 +229,8 @@ module Genericode
           next unless value.complex_value
 
           unless valid_complex_value?(value.complex_value, column_set&.column&.find { |c| c.id == value.column_ref })
-            errors << { code: "INVALID_COMPLEX_VALUE",
-                        message: "Invalid ComplexValue in row #{index + 1}, column '#{value.column_ref}'", }
+            errors << { code: 'INVALID_COMPLEX_VALUE',
+                        message: "Invalid ComplexValue in row #{index + 1}, column '#{value.column_ref}'" }
           end
         end
       end
@@ -241,17 +242,17 @@ module Genericode
 
     def value_matches_type?(value, type)
       case type
-      when "string"
+      when 'string'
         true # All values can be considered strings
-      when "integer"
+      when 'integer'
         value.to_i.to_s == value
-      when "decimal"
+      when 'decimal'
         begin
           Float(value)
         rescue StandardError
           false
         end
-      when "date"
+      when 'date'
         begin
           Date.parse(value)
         rescue StandardError
@@ -273,14 +274,14 @@ module Genericode
     def valid_complex_value?(complex_value, column)
       return true unless complex_value && column&.data
 
-      if column.data.type == "*"
+      if column.data.type == '*'
         true # Any element is allowed
       else
         # Check if the root element name matches the datatype ID
         complex_value.name == column.data.type
       end
 
-      if column.data.datatype_library == "*"
+      if column.data.datatype_library == '*'
         true # Any namespace is allowed
       else
         # Check if the namespace matches the datatype library

data/lib/genericode/code_list_ref.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require "lutaml/model"
+require 'lutaml/model'
 
-require_relative "annotation"
-require_relative "json/canonical_uri_mixin"
+require_relative 'annotation'
+require_relative 'json/canonical_uri_mixin'
 
 module Genericode
   class CodeListRef < Lutaml::Model::Serializable
@@ -15,20 +15,19 @@ module Genericode
     attribute :location_uri, :string, collection: true
 
     json do
-      map "Annotation", to: :annotation
-      map "CanonicalUri", to: :canonical_uri, with: { from: :canonical_uri_from_json, to: :canonical_uri_to_json }
-      map "CanonicalVersionUri", to: :canonical_version_uri
-      map "LocationUri", to: :location_uri
+      map 'Annotation', to: :annotation
+      map 'CanonicalUri', to: :canonical_uri, with: { from: :canonical_uri_from_json, to: :canonical_uri_to_json }
+      map 'CanonicalVersionUri', to: :canonical_version_uri
+      map 'LocationUri', to: :location_uri
     end
 
     xml do
-      root "CodeListRef"
-      namespace "http://docs.oasis-open.org/codelist/ns/genericode/1.0/", "gc"
+      element 'CodeListRef'
 
-      map_element "Annotation", to: :annotation, prefix: nil, namespace: nil
-      map_element "CanonicalUri", to: :canonical_uri, prefix: nil, namespace: nil
-      map_element "CanonicalVersionUri", to: :canonical_version_uri, prefix: nil, namespace: nil
-      map_element "LocationUri", to: :location_uri, prefix: nil, namespace: nil
+      map_element 'Annotation', to: :annotation
+      map_element 'CanonicalUri', to: :canonical_uri
+      map_element 'CanonicalVersionUri', to: :canonical_version_uri
+      map_element 'LocationUri', to: :location_uri
     end
   end
 end

data/lib/genericode/code_list_set.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require "lutaml/model"
+require 'lutaml/model'
 
-require_relative "annotation"
-require_relative "code_list_ref"
-require_relative "code_list_set_ref"
-require_relative "identification"
+require_relative 'annotation'
+require_relative 'code_list_ref'
+require_relative 'code_list_set_ref'
+require_relative 'identification'
 
 module Genericode
   class CodeListSet < Lutaml::Model::Serializable
@@ -16,22 +16,21 @@ module Genericode
     attribute :code_list_set_ref, CodeListSetRef, collection: true
 
     json do
-      map "Annotation", to: :annotation
-      map "Identification", to: :identification
-      map "CodeListRef", to: :code_list_ref
-      map "CodeListSet", to: :code_list_set
-      map "CodeListSetRef", to: :code_list_set_ref
+      map 'Annotation', to: :annotation
+      map 'Identification', to: :identification
+      map 'CodeListRef', to: :code_list_ref
+      map 'CodeListSet', to: :code_list_set
+      map 'CodeListSetRef', to: :code_list_set_ref
     end
 
     xml do
-      root "CodeListSet"
-      namespace "http://docs.oasis-open.org/codelist/ns/genericode/1.0/", "gc"
+      element 'CodeListSet'
 
-      map_element "Annotation", to: :annotation, prefix: nil, namespace: nil
-      map_element "Identification", to: :identification, prefix: nil, namespace: nil
-      map_element "CodeListRef", to: :code_list_ref, prefix: nil, namespace: nil
-      map_element "CodeListSet", to: :code_list_set, prefix: nil, namespace: nil
-      map_element "CodeListSetRef", to: :code_list_set_ref, prefix: nil, namespace: nil
+      map_element 'Annotation', to: :annotation
+      map_element 'Identification', to: :identification
+      map_element 'CodeListRef', to: :code_list_ref
+      map_element 'CodeListSet', to: :code_list_set
+      map_element 'CodeListSetRef', to: :code_list_set_ref
     end
 
     def validate_verbose
@@ -40,19 +39,19 @@ module Genericode
       # Rule 47: CodeListSet reference validation
       code_list_set_ref&.each do |ref|
         unless valid_uri?(ref.canonical_uri) && valid_uri?(ref.canonical_version_uri)
-          errors << { code: "INVALID_CODELIST_SET_REF", message: "Invalid CodeListSet reference URI" }
+          errors << { code: 'INVALID_CODELIST_SET_REF', message: 'Invalid CodeListSet reference URI' }
         end
       end
 
       # Rule 48-51: URI validations
       [canonical_uri, canonical_version_uri].each do |uri|
-        errors << { code: "INVALID_URI", message: "Invalid URI: #{uri}" } unless valid_uri?(uri)
+        errors << { code: 'INVALID_URI', message: "Invalid URI: #{uri}" } unless valid_uri?(uri)
       end
 
       # Rule 52-53: LocationUri validation
       location_uri&.each do |uri|
         unless valid_genericode_uri?(uri)
-          errors << { code: "INVALID_LOCATION_URI", message: "Invalid LocationUri: #{uri}" }
+          errors << { code: 'INVALID_LOCATION_URI', message: "Invalid LocationUri: #{uri}" }
         end
       end
 
@@ -68,7 +67,7 @@ module Genericode
     def valid_genericode_uri?(uri)
       # Add logic to check if the URI points to a valid genericode document
       # This might involve making an HTTP request or checking file extensions
-      uri.end_with?(".gc", ".gcj")
+      uri.end_with?('.gc', '.gcj')
     end
   end
 end

data/lib/genericode/code_list_set_ref.rb

@@ -1,34 +1,34 @@
 # frozen_string_literal: true
 
-require "lutaml/model"
+require 'lutaml/model'
 
-require_relative "annotation"
-require_relative "canonical_uri"
-require_relative "json/canonical_uri_mixin"
+require_relative 'annotation'
+require_relative 'canonical_uri'
+require_relative 'json/canonical_uri_mixin'
 
 module Genericode
   class CodeListSetRef < Lutaml::Model::Serializable
     include Json::CanonicalUriMixin
+
     attribute :annotation, Annotation
     attribute :canonical_uri, CanonicalUri
     attribute :canonical_version_uri, :string
     attribute :location_uri, :string, collection: true
 
     json do
-      map "Annotation", to: :annotation
-      map "CanonicalUri", to: :canonical_uri, with: { from: :canonical_uri_from_json, to: :canonical_uri_to_json }
-      map "CanonicalVersionUri", to: :canonical_version_uri
-      map "LocationUri", to: :location_uri
+      map 'Annotation', to: :annotation
+      map 'CanonicalUri', to: :canonical_uri, with: { from: :canonical_uri_from_json, to: :canonical_uri_to_json }
+      map 'CanonicalVersionUri', to: :canonical_version_uri
+      map 'LocationUri', to: :location_uri
     end
 
     xml do
-      root "CodeListSetRef"
-      namespace "http://docs.oasis-open.org/codelist/ns/genericode/1.0/", "gc"
+      element 'CodeListSetRef'
 
-      map_element "Annotation", to: :annotation, prefix: nil, namespace: nil
-      map_element "CanonicalUri", to: :canonical_uri, prefix: nil, namespace: nil
-      map_element "CanonicalVersionUri", to: :canonical_version_uri, prefix: nil, namespace: nil
-      map_element "LocationUri", to: :location_uri, prefix: nil, namespace: nil
+      map_element 'Annotation', to: :annotation
+      map_element 'CanonicalUri', to: :canonical_uri
+      map_element 'CanonicalVersionUri', to: :canonical_version_uri
+      map_element 'LocationUri', to: :location_uri
     end
   end
 end

data/lib/genericode/column.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-require "lutaml/model"
+require 'lutaml/model'
 
-require_relative "annotation"
-require_relative "data"
-require_relative "canonical_uri"
-require_relative "long_name"
-require_relative "short_name"
-require_relative "json/short_name_mixin"
-require_relative "json/canonical_uri_mixin"
-require_relative "utils"
+require_relative 'annotation'
+require_relative 'data'
+require_relative 'canonical_uri'
+require_relative 'long_name'
+require_relative 'short_name'
+require_relative 'json/short_name_mixin'
+require_relative 'json/canonical_uri_mixin'
+require_relative 'utils'
 
 module Genericode
   class Column < Lutaml::Model::Serializable
@@ -17,7 +17,7 @@ module Genericode
     include Json::ShortNameMixin
 
     attribute :id, :string
-    attribute :use, :string, default: -> { "optional" }
+    attribute :use, :string, default: -> { 'optional' }
     attribute :annotation, Annotation
     attribute :short_name, ShortName
     attribute :long_name, LongName, collection: true, initialize_empty: true
@@ -26,23 +26,23 @@ module Genericode
     attribute :data, Data
 
     json do
-      map "Required", to: :use, with: { from: :use_from_json, to: :use_to_json }
-      map "Id", to: :id
-      map "Annotation", to: :annotation
-      map "ShortName", to: :short_name, with: { from: :short_name_from_json, to: :short_name_to_json }
-      map "LongName", to: :long_name, with: { from: :long_name_from_json, to: :long_name_to_json }
-      map "CanonicalUri", to: :canonical_uri, with: { from: :canonical_uri_from_json, to: :canonical_uri_to_json }
-      map "CanonicalVersionUri", to: :canonical_version_uri
-      map "DataType", to: :type, delegate: :data
-      map "DataLanguage", to: :lang, delegate: :data
+      map 'Required', to: :use, with: { from: :use_from_json, to: :use_to_json }
+      map 'Id', to: :id
+      map 'Annotation', to: :annotation
+      map 'ShortName', to: :short_name, with: { from: :short_name_from_json, to: :short_name_to_json }
+      map 'LongName', to: :long_name, with: { from: :long_name_from_json, to: :long_name_to_json }
+      map 'CanonicalUri', to: :canonical_uri, with: { from: :canonical_uri_from_json, to: :canonical_uri_to_json }
+      map 'CanonicalVersionUri', to: :canonical_version_uri
+      map 'DataType', to: :type, delegate: :data
+      map 'DataLanguage', to: :lang, delegate: :data
     end
 
     def use_from_json(model, value)
-      model.use = value == "true" ? "required" : "optional"
+      model.use = value == 'true' ? 'required' : 'optional'
     end
 
     def use_to_json(model, doc)
-      doc["Required"] = "true" if model.use == "required"
+      doc['Required'] = 'true' if model.use == 'required'
     end
 
     def long_name_from_json(model, value)
@@ -52,21 +52,20 @@ module Genericode
     def long_name_to_json(model, doc)
       return if model.long_name.nil? || model.long_name.empty?
 
-      doc["LongName"] = LongName.as_json(Utils.one_or_all(model.long_name))
+      doc['LongName'] = LongName.as_json(Utils.one_or_all(model.long_name))
     end
 
     xml do
-      root "Column"
-      namespace "http://docs.oasis-open.org/codelist/ns/genericode/1.0/", "gc"
+      element 'Column'
 
-      map_attribute "Id", to: :id
-      map_attribute "Use", to: :use
-      map_element "Annotation", to: :annotation, prefix: nil, namespace: nil
-      map_element "ShortName", to: :short_name, prefix: nil, namespace: nil
-      map_element "LongName", to: :long_name, prefix: nil, namespace: nil
-      map_element "CanonicalUri", to: :canonical_uri, prefix: nil, namespace: nil
-      map_element "CanonicalVersionUri", to: :canonical_version_uri, prefix: nil, namespace: nil
-      map_element "Data", to: :data, prefix: nil, namespace: nil
+      map_attribute 'Id', to: :id
+      map_attribute 'Use', to: :use
+      map_element 'Annotation', to: :annotation
+      map_element 'ShortName', to: :short_name
+      map_element 'LongName', to: :long_name
+      map_element 'CanonicalUri', to: :canonical_uri
+      map_element 'CanonicalVersionUri', to: :canonical_version_uri
+      map_element 'Data', to: :data
     end
   end
 end

data/lib/genericode/column_ref.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require "lutaml/model"
+require 'lutaml/model'
 
-require_relative "annotation"
-require_relative "data_restrictions"
+require_relative 'annotation'
+require_relative 'data_restrictions'
 
 module Genericode
   class ColumnRef < Lutaml::Model::Serializable
@@ -16,26 +16,25 @@ module Genericode
     attribute :data, DataRestrictions
 
     json do
-      map "Id", to: :id
-      map "ExternalRef", to: :external_ref
-      map "Use", to: :use
-      map "Annotation", to: :annotation
-      map "CanonicalVersionUri", to: :canonical_version_uri
-      map "LocationUri", to: :location_uri
-      map "Data", to: :data
+      map 'Id', to: :id
+      map 'ExternalRef', to: :external_ref
+      map 'Use', to: :use
+      map 'Annotation', to: :annotation
+      map 'CanonicalVersionUri', to: :canonical_version_uri
+      map 'LocationUri', to: :location_uri
+      map 'Data', to: :data
     end
 
     xml do
-      root "ColumnRef"
-      namespace "http://docs.oasis-open.org/codelist/ns/genericode/1.0/", "gc"
+      element 'ColumnRef'
 
-      map_attribute "Id", to: :id
-      map_attribute "ExternalRef", to: :external_ref
-      map_attribute "Use", to: :use
-      map_element "Annotation", to: :annotation, prefix: nil, namespace: nil
-      map_element "CanonicalVersionUri", to: :canonical_version_uri, prefix: nil, namespace: nil
-      map_element "LocationUri", to: :location_uri, prefix: nil, namespace: nil
-      map_element "Data", to: :data, prefix: nil, namespace: nil
+      map_attribute 'Id', to: :id
+      map_attribute 'ExternalRef', to: :external_ref
+      map_attribute 'Use', to: :use
+      map_element 'Annotation', to: :annotation
+      map_element 'CanonicalVersionUri', to: :canonical_version_uri
+      map_element 'LocationUri', to: :location_uri
+      map_element 'Data', to: :data
     end
   end
 end