genericode 0.1.0 → 0.1.2

data/lib/genericode/cli/commands.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "thor"
+require_relative "validator"
+require_relative "converter"
+require_relative "code_lister"
+require_relative "code_lookup"
+
+module Genericode
+  module Cli
+    class Commands < Thor
+      desc "convert INPUT OUTPUT", "Convert between Genericode XML and JSON formats"
+
+      def convert(input, output)
+        puts "Conversion successful." if Converter.convert(input, output)
+      rescue Error => e
+        puts "Conversion failed: #{e.message}"
+      end
+
+      desc "validate FILE", "Validate a Genericode file"
+      option :verbose, type: :boolean, desc: "Show detailed validation results"
+
+      def validate(file)
+        code_list = CodeList.from_file(file)
+        if options[:verbose]
+          results = code_list.validate_verbose
+          if results.empty?
+            puts "File is valid."
+          else
+            puts "File is invalid. Issues found:"
+            results.each do |error|
+              puts "  [#{error[:code]}] #{error[:message]}"
+            end
+          end
+        elsif code_list.valid?
+          puts "File is valid."
+        else
+          puts "File is invalid."
+        end
+      rescue Error => e
+        puts "Validation failed: #{e.message}"
+      end
+
+      desc "list_codes FILE", "List all codes and their associated data in a Genericode file"
+      option :format, type: :string, default: "tsv", enum: %w[tsv table], desc: "Output format (tsv or table)"
+      option :output, type: :string, desc: "Output file path (default: stdout)"
+
+      def list_codes(file)
+        format = (options[:format] || "tsv").to_sym
+        result = CodeLister.list_codes(file, format: format)
+
+        if options[:output]
+          File.write(options[:output], result)
+          puts "Codes listed in #{options[:output]}"
+        else
+          puts result
+        end
+      rescue Error => e
+        puts "Listing codes failed: #{e.message}"
+      end
+
+      desc "lookup FILE PATH", "Look up a particular code using Genericode path"
+
+      def lookup(file, path)
+        result = CodeLookup.lookup(file, path)
+        if result.is_a?(Hash)
+          result.each { |k, v| puts "#{k}: #{v}" }
+        else
+          puts result
+        end
+      rescue Error => e
+        puts "Lookup failed: #{e.message}"
+      end
+    end
+  end
+end

data/lib/genericode/cli/converter.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Genericode
+  module Cli
+    class Converter
+      def self.convert(input_path, output_path)
+        input_format = File.extname(input_path)
+        output_format = File.extname(output_path)
+
+        raise Error, "Invalid input format" unless [".gc", ".gcj"].include?(input_format)
+        raise Error, "Invalid output format" unless [".gc", ".gcj"].include?(output_format)
+        raise Error, "Input and output formats are the same" if input_format == output_format
+
+        # begin
+        code_list = CodeList.from_file(input_path)
+
+        result = if output_format == ".gcj"
+                   code_list.to_json
+                 else
+                   code_list.to_xml
+                 end
+
+        File.write(output_path, result)
+        true
+        # rescue JSON::ParserError => e
+        #   raise Error, "Invalid JSON in input file: #{e.message}"
+        # rescue Shale::ParseError => e
+        #   raise Error, "Invalid XML in input file: #{e.message}"
+        # rescue StandardError => e
+        #   raise Error, "Conversion error: #{e.message}"
+        # end
+      end
+    end
+  end
+end

data/lib/genericode/cli/validator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Genericode
+  module Cli
+    class Validator
+      def self.validate(file_path)
+        raise Error, "File does not exist" unless File.exist?(file_path)
+        raise Error, "Invalid file format" unless file_path.end_with?(".gc", ".gcj")
+
+        code_list = CodeList.from_file(file_path)
+
+        raise Error, "No columns defined" if code_list.column_set.nil? || code_list.column_set.column.empty?
+        raise Error, "No rows defined" if code_list.simple_code_list.nil? || code_list.simple_code_list.row.empty?
+
+        raise Error, "Invalid Genericode structure" unless code_list.valid?
+
+        true
+      end
+    end
+  end
+end

data/lib/genericode/cli.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Genericode
+  module Cli
+  end
+end
+
+require_relative "cli/commands"

data/lib/genericode/code_list.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require "shale"
+require "lutaml/model"
+require "uri"
 
 require_relative "annotation"
 require_relative "column_set"
@@ -9,35 +10,282 @@ require_relative "identification"
 require_relative "simple_code_list"
 
 module Genericode
-  class CodeList < Shale::Mapper
+  class CodeList < Lutaml::Model::Serializable
     attribute :annotation, Annotation
     attribute :identification, Identification
     attribute :column_set, ColumnSet
     attribute :column_set_ref, ColumnSetRef
     attribute :simple_code_list, SimpleCodeList
-    attribute :schema_location, Shale::Type::String
+
+    def self.from_file(file_path)
+      content = File.read(file_path)
+      if file_path.end_with?(".gc")
+        from_xml(content)
+      elsif file_path.end_with?(".gcj")
+        from_json(content)
+      else
+        raise Error, "Unsupported file format. Expected .gc or .gcj file."
+      end
+    end
 
     json do
       map "Annotation", to: :annotation
       map "Identification", to: :identification
-      map "ColumnSet", to: :column_set
+      map "Columns", to: :column_set, with: { from: :column_set_from_json, to: :column_set_to_json }
       map "ColumnSetRef", to: :column_set_ref
-      map "SimpleCodeList", to: :simple_code_list
+      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 })
+    end
+
+    def column_set_to_json(model, doc)
+      doc["Columns"] = Column.as_json(model.column_set.column)
+    end
+
+    def key_from_json(model, value)
+      model.column_set.key = Key.of_json(value)
+    end
+
+    def key_to_json(model, doc)
+      doc["Keys"] = Key.as_json(model.column_set.key)
+    end
+
+    def simple_code_list_from_json(model, value)
+      rows = value.map do |x|
+        values = x.map do |k, v|
+          Value.new(column_ref: k, simple_value: SimpleValue.new(content: v))
+        end
+
+        Row.new(value: values)
+      end
+
+      model.simple_code_list = SimpleCodeList.new(row: rows)
+    end
+
+    def simple_code_list_to_json(model, doc)
+      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_attribute "schemaLocation", to: :schema_location,
-                                      namespace: "http://www.w3.org/2001/XMLSchema-instance",
-                                      prefix: "xsi"
-
       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
     end
+
+    def lookup(path)
+      parts = path.split(">")
+      conditions = parts[0].split(",").to_h { |c| c.split(":") }
+      target_column = parts[1]
+
+      result = simple_code_list.row.find do |row|
+        conditions.all? do |col, value|
+          column = column_set.column.find { |c| c.short_name.content.downcase == col.downcase }
+          raise Error, "Column not found: #{col}" unless column
+
+          row_value = row.value.find { |v| v.column_ref == column.id }&.simple_value&.content
+          row_value == value
+        end
+      end
+
+      raise Error, "No matching row found for path: #{path}" unless result
+
+      if target_column
+        column = column_set.column.find { |c| c.short_name.content.downcase == target_column.downcase }
+        raise Error, "Target column not found: #{target_column}" unless column
+
+        result.value.find { |v| v.column_ref == column.id }&.simple_value&.content
+      else
+        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
+      end
+    end
+
+    def valid?
+      validate_verbose.empty?
+    end
+
+    def validate_verbose
+      errors = []
+
+      # Rule 1: ColumnSet presence
+      if column_set.nil? || column_set.column.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", }
+      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" }
+      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}", }
+          end
+        end
+      end
+
+      # Rule 5: Unique values in columns
+      column_set&.column&.each do |col|
+        column_values = (simple_code_list&.row&.map do |row|
+          row.value.find { |v| v.column_ref == col.id }&.simple_value&.content
+        end || []).compact
+
+        if column_values.uniq.length != column_values.length
+          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" } || []
+      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}", }
+          end
+        end
+      end
+
+      # Rule 7: Data type consistency
+      column_set&.column&.each do |col|
+        data_type = col.data&.type
+        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}", }
+          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" }
+      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}'", }
+        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}'", }
+        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}'", }
+        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}" }
+        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", }
+        end
+      end
+
+      # Rule 42 and 43: ComplexValue validation
+      simple_code_list&.row&.each_with_index do |row, index|
+        row.value.each do |value|
+          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}'", }
+          end
+        end
+      end
+
+      errors
+    end
+
+    private
+
+    def value_matches_type?(value, type)
+      case type
+      when "string"
+        true # All values can be considered strings
+      when "integer"
+        value.to_i.to_s == value
+      when "decimal"
+        begin
+          Float(value)
+        rescue StandardError
+          false
+        end
+      when "date"
+        begin
+          Date.parse(value)
+        rescue StandardError
+          false
+        end
+      else
+        true # If type is unknown, consider it valid
+      end
+    end
+
+    def valid_uri?(uri)
+      uri =~ URI::DEFAULT_PARSER.make_regexp
+    end
+
+    def valid_datatype_id?(id)
+      %w[string token boolean decimal integer date].include?(id)
+    end
+
+    def valid_complex_value?(complex_value, column)
+      return true unless complex_value && column&.data
+
+      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 == "*"
+        true # Any namespace is allowed
+      else
+        # Check if the namespace matches the datatype library
+        complex_value.namespace == column.data.datatype_library
+      end
+    end
   end
 end

data/lib/genericode/code_list_ref.rb

@@ -1,19 +1,22 @@
 # frozen_string_literal: true
 
-require "shale"
+require "lutaml/model"
 
 require_relative "annotation"
+require_relative "json/canonical_uri_mixin"
 
 module Genericode
-  class CodeListRef < Shale::Mapper
+  class CodeListRef < Lutaml::Model::Serializable
+    include Json::CanonicalUriMixin
+
     attribute :annotation, Annotation
-    attribute :canonical_uri, Shale::Type::String
-    attribute :canonical_version_uri, Shale::Type::String
-    attribute :location_uri, Shale::Type::String, collection: true
+    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
+      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

data/lib/genericode/code_list_set.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "shale"
+require "lutaml/model"
 
 require_relative "annotation"
 require_relative "code_list_ref"
@@ -8,7 +8,7 @@ require_relative "code_list_set_ref"
 require_relative "identification"
 
 module Genericode
-  class CodeListSet < Shale::Mapper
+  class CodeListSet < Lutaml::Model::Serializable
     attribute :annotation, Annotation
     attribute :identification, Identification
     attribute :code_list_ref, CodeListRef, collection: true
@@ -33,5 +33,42 @@ module Genericode
       map_element "CodeListSet", to: :code_list_set, prefix: nil, namespace: nil
       map_element "CodeListSetRef", to: :code_list_set_ref, prefix: nil, namespace: nil
     end
+
+    def validate_verbose
+      errors = []
+
+      # 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" }
+        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)
+      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}" }
+        end
+      end
+
+      errors
+    end
+
+    private
+
+    def valid_uri?(uri)
+      uri =~ URI::DEFAULT_PARSER.make_regexp
+    end
+
+    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")
+    end
   end
 end

data/lib/genericode/code_list_set_ref.rb

@@ -1,19 +1,22 @@
 # frozen_string_literal: true
 
-require "shale"
+require "lutaml/model"
 
 require_relative "annotation"
+require_relative "canonical_uri"
+require_relative "json/canonical_uri_mixin"
 
 module Genericode
-  class CodeListSetRef < Shale::Mapper
+  class CodeListSetRef < Lutaml::Model::Serializable
+    include Json::CanonicalUriMixin
     attribute :annotation, Annotation
-    attribute :canonical_uri, Shale::Type::String
-    attribute :canonical_version_uri, Shale::Type::String
-    attribute :location_uri, Shale::Type::String, collection: true
+    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
+      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

data/lib/genericode/column.rb

@@ -1,32 +1,58 @@
 # frozen_string_literal: true
 
-require "shale"
+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"
 
 module Genericode
-  class Column < Shale::Mapper
-    attribute :id, Shale::Type::String
-    attribute :use, Shale::Type::String
+  class Column < Lutaml::Model::Serializable
+    include Json::CanonicalUriMixin
+    include Json::ShortNameMixin
+
+    attribute :id, :string
+    attribute :use, :string, default: -> { "optional" }
     attribute :annotation, Annotation
     attribute :short_name, ShortName
     attribute :long_name, LongName, collection: true
-    attribute :canonical_uri, Shale::Type::String
-    attribute :canonical_version_uri, Shale::Type::String
+    attribute :canonical_uri, CanonicalUri
+    attribute :canonical_version_uri, :string
     attribute :data, Data
 
     json do
+      map "Required", to: :use, with: { from: :use_from_json, to: :use_to_json }
       map "Id", to: :id
-      map "Use", to: :use
       map "Annotation", to: :annotation
-      map "ShortName", to: :short_name
-      map "LongName", to: :long_name
-      map "CanonicalUri", to: :canonical_uri
+      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 "Data", to: :data
+      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"
+    end
+
+    def use_to_json(model, doc)
+      doc["Required"] = "true" if model.use == "required"
+    end
+
+    def long_name_from_json(model, value)
+      model.long_name = LongName.of_json(Utils.array_wrap(value))
+    end
+
+    def long_name_to_json(model, doc)
+      return if model.long_name.empty?
+
+      doc["LongName"] = LongName.as_json(Utils.one_or_all(model.long_name))
     end
 
     xml do

data/lib/genericode/column_ref.rb

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
-require "shale"
+require "lutaml/model"
 
 require_relative "annotation"
 require_relative "data_restrictions"
 
 module Genericode
-  class ColumnRef < Shale::Mapper
-    attribute :id, Shale::Type::String
-    attribute :external_ref, Shale::Type::String
-    attribute :use, Shale::Type::String
+  class ColumnRef < Lutaml::Model::Serializable
+    attribute :id, :string
+    attribute :external_ref, :string
+    attribute :use, :string
     attribute :annotation, Annotation
-    attribute :canonical_version_uri, Shale::Type::String
-    attribute :location_uri, Shale::Type::String, collection: true
+    attribute :canonical_version_uri, :string
+    attribute :location_uri, :string, collection: true
     attribute :data, DataRestrictions
 
     json do

data/lib/genericode/column_set.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "shale"
+require "lutaml/model"
 
 require_relative "annotation"
 require_relative "column"
@@ -10,8 +10,8 @@ require_relative "key"
 require_relative "key_ref"
 
 module Genericode
-  class ColumnSet < Shale::Mapper
-    attribute :datatype_library, Shale::Type::String
+  class ColumnSet < Lutaml::Model::Serializable
+    attribute :datatype_library, :string
     attribute :annotation, Annotation
     attribute :identification, Identification
     attribute :column, Column, collection: true