lutaml-lml 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3953cc3c0f81db402cab373b0da574ebd8832e2aa42c98de6e88e3fc157e4503
+  data.tar.gz: d3816ea57a18d40ff1577757367f41fc604e54ad945545223820787dff81a86b
+SHA512:
+  metadata.gz: cd7dc48c1d8a1d89718e755e93ffc7a0ac0d577aab1d6c0986ddd7d45d6df3f88b1716f1514e445df0e3ab6c10b306904b3219247126bf5e60b8568acb6aafd3
+  data.tar.gz: 9c79221cf405d9512c094da610abdb7ab4f8675ce64ca7180c0039e337a281872483ef31db2f9344a0e7c853d1d51085e3108b08b1e6fba83bd200134da5aa2d

data/lib/lutaml/lml/association_label_resolver.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class AssociationLabelResolver
+      def enrich(document)
+        class_index = build_class_index(document)
+        document.associations.each do |assoc|
+          enrich_owner_end(assoc, class_index)
+          enrich_member_end(assoc, class_index)
+        end
+        document
+      end
+
+      private
+
+      def build_class_index(document)
+        document.all_classes.each_with_object({}) { |klass, index| index[klass.name] = klass }
+      end
+
+      def enrich_owner_end(assoc, class_index)
+        return if assoc.owner_end_attribute_name
+
+        owner_class = class_index[assoc.owner_end.to_s]
+        return unless owner_class
+
+        attr = find_attribute_by_type(owner_class, assoc.member_end.to_s)
+        return unless attr
+
+        assoc.owner_end_attribute_name = attr.name
+        assoc.owner_end_cardinality = attr.cardinality if attr.cardinality
+      end
+
+      def enrich_member_end(assoc, class_index)
+        return if assoc.member_end_attribute_name
+
+        member_class = class_index[assoc.member_end.to_s]
+        return unless member_class
+
+        attr = find_attribute_by_type(member_class, assoc.owner_end.to_s)
+        return unless attr
+
+        assoc.member_end_attribute_name = attr.name
+        assoc.member_end_cardinality = attr.cardinality if attr.cardinality
+      end
+
+      def find_attribute_by_type(klass, target_type_name)
+        klass.attributes&.find { |a| a.type == target_type_name }
+      end
+    end
+  end
+end

data/lib/lutaml/lml/cli.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'pathname'
+require 'lutaml/lml'
+
+module Lutaml
+  module Cli
+    # Thor CLI commands for LutaML DSL generation and validation.
+    class LmlCommands < Thor
+      include ::Lutaml::Lml::HasAttributes
+
+      SUPPORTED_FORMATS = %w[yaml lutaml exp].freeze
+      DEFAULT_INPUT_FORMAT = 'lutaml'
+      DEFAULT_OUTPUT_FORMAT = 'svg'
+
+      EXTENSION_FORMAT_MAP = {
+        '.svg' => 'svg', '.svgz' => 'svgz',
+        '.png' => 'png', '.gif' => 'gif', '.jpg' => 'jpg', '.jpeg' => 'jpeg',
+        '.pdf' => 'pdf', '.ps' => 'ps', '.eps' => 'eps',
+        '.dot' => 'dot', '.xdot' => 'xdot',
+        '.fig' => 'fig', '.json' => 'json',
+        '.imap' => 'imap', '.cmapx' => 'cmapx'
+      }.freeze
+
+      PARSE_HANDLERS = {
+        'lutaml' => ->(path) { Lutaml::Lml::Parser.parse(File.new(path)) },
+        'yaml' => ->(path) { Lutaml::Lml::YamlParser.parse(path.to_s) },
+        'yml' => ->(path) { Lutaml::Lml::YamlParser.parse(path.to_s) },
+        'exp' => lambda { |path|
+          require 'lutaml/express'
+          Lutaml::Express::Parsers::Exp.parse(File.new(path))
+        }
+      }.freeze
+
+      FORMATTER_ATTR_TARGETS = %i[graph edge node].freeze
+
+      def initialize(*args)
+        super
+        @formatter = ::Lutaml::Formatter::Graphviz.new if defined?(::Lutaml::Formatter::Graphviz)
+        @out_object = $stdout
+      end
+
+      desc 'generate [PATHS]', 'Generate diagram output from LutaML DSL files'
+      long_desc <<-DESC
+        Generate diagram output from one or more LutaML DSL files.
+
+        Supports multiple input formats (lutaml, yaml, exp) and can output
+        to various formats (svg, png, dot, pdf, etc.).
+
+        Examples:
+          lutaml lml generate model.lutaml -o diagram.svg
+
+          lutaml lml generate model.lutaml -o diagram.dot -t dot
+
+          lutaml lml generate model.lutaml project.lutaml -o output/
+      DESC
+      method_option :output, type: :string, aliases: '-o',
+                             desc: 'Output path (file or directory)'
+      method_option :formatter, type: :string, aliases: '-f',
+                                desc: 'Output formatter (default: graphviz)'
+      method_option :type, type: :string, aliases: '-t',
+                           desc: 'Output format type (svg, png, dot, etc.)'
+      method_option :input_format, type: :string, aliases: '-i',
+                                   desc: 'Input format (lutaml, yaml, exp)'
+      method_option :graph, type: :string, aliases: '-g',
+                            desc: 'Graph attributes (key=value,key2=value2)'
+      method_option :edge, type: :string, aliases: '-e',
+                           desc: 'Edge attributes (key=value,key2=value2)'
+      method_option :node, type: :string, aliases: '-n',
+                           desc: 'Node attributes (key=value,key2=value2)'
+      method_option :all, type: :string, aliases: '-a',
+                          desc: 'Set attributes for graph, edge, and node'
+      def generate(*paths)
+        assert_input_paths(paths)
+
+        setup_options
+        @paths = paths.map { |path| Pathname.new(path) }
+
+        assert_output_path
+
+        @paths.each { |input_path| process_single_file(input_path) }
+      end
+
+      desc 'validate [PATHS]', 'Validate LutaML DSL syntax'
+      long_desc <<-DESC
+        Validate the syntax of one or more LutaML DSL files.
+
+        Checks for syntax errors and structural issues in the DSL files
+        without generating output.
+
+        Examples:
+          lutaml lml validate model.lutaml
+
+          lutaml lml validate model.lutaml project.lutaml
+      DESC
+      def validate(*paths)
+        assert_input_paths(paths)
+        errors = paths.map { |p| validate_single_file(p) }.compact
+        report_validation(errors)
+      end
+
+      desc 'compile PATH', 'Compile LML model definitions into Ruby classes'
+      long_desc <<-DESC
+        Parse an LML file containing model definitions and compile them
+        into Ruby classes that can be used to instantiate and validate data.
+
+        The compiled classes are anonymous Serializable subclasses registered
+        in the ModelCompiler. With --namespace, classes are also registered
+        as constants in the given module.
+
+        Examples:
+          lutaml lml compile models.lml
+
+          lutaml lml compile models.lml --namespace MyModels
+      DESC
+      method_option :namespace, type: :string, aliases: '-n',
+                             desc: 'Register compiled classes in a module'
+      def compile(path)
+        raise Thor::Error, "File does not exist: #{path}" unless File.exist?(path)
+
+        ns = options[:namespace] ? resolve_namespace(options[:namespace]) : nil
+        result = Lutaml::Lml::ModelCompiler.new(namespace: ns).compile(File.new(path))
+
+        result.each_key do |name|
+          say "  compiled: #{name}", :green
+        end
+        say "\n#{result.size} class(es) compiled", :green
+      end
+
+      no_commands do
+        def resolve_namespace(name)
+          name.split('::').reduce(Object) do |mod, const_name|
+            mod.const_get(const_name)
+          end
+        rescue NameError
+          raise Thor::Error, "Namespace '#{name}' not found"
+        end
+
+        def assert_input_paths(paths)
+          return unless paths.empty?
+
+          raise Thor::Error,
+                'No input files provided. Please specify at least ' \
+                'one .lutaml file.'
+        end
+
+        def assert_output_path
+          return unless @output_path&.file? && @paths.length > 1
+
+          raise Thor::Error,
+                'Output path must be a directory if multiple input files ' \
+                'are given'
+        end
+
+        def process_single_file(input_path)
+          raise Thor::Error, "File does not exist: #{input_path}" unless input_path.exist?
+
+          document = parse_document(input_path)
+          result = @formatter.format(document)
+          write_output(input_path, result)
+        end
+
+        def resolve_output_path(input_path)
+          return @out_object unless @output_path
+
+          path = @output_path
+          path = path.join("#{input_path.basename('.*')}.#{@formatter.type}") if path.directory?
+          path
+        end
+
+        def write_output(input_path, result)
+          target = resolve_output_path(input_path)
+          if target.is_a?(Pathname)
+            target.open('w+') { |f| f.write(result) }
+            say "Generated: #{target}", :green
+          else
+            target.puts(result)
+          end
+        end
+
+        def validate_single_file(path_string)
+          input_path = Pathname.new(path_string)
+          return report_file_error(input_path, 'File does not exist') unless input_path.exist?
+
+          parse_document(input_path)
+          say "✓ #{input_path}", :green
+          nil
+        rescue StandardError => e
+          report_file_error(input_path, e.message)
+        end
+
+        def report_file_error(input_path, message)
+          say "✗ #{input_path}: #{message}", :red
+          "#{input_path}: #{message}"
+        end
+
+        def report_validation(errors)
+          if errors.any?
+            say "\nValidation failed with #{errors.size} error(s)", :red
+            exit 1
+          else
+            say "\nAll files valid!", :green
+          end
+        end
+
+        def parse_document(input_path)
+          handler = PARSE_HANDLERS[@input_format]
+          return handler.call(input_path) if handler
+
+          raise Thor::Error, "Unsupported input format: #{@input_format}"
+        end
+
+        def setup_options
+          @formatter = options[:formatter] if options[:formatter]
+          @output_path = Pathname.new(options[:output]) if options[:output]
+          @input_format = options[:input_format] || DEFAULT_INPUT_FORMAT
+          @type = resolve_output_type
+
+          setup_formatter_options
+        end
+
+        def resolve_output_type
+          return options[:type] if options[:type]
+          return DEFAULT_OUTPUT_FORMAT unless @output_path
+
+          ext = @output_path.extname.downcase
+          EXTENSION_FORMAT_MAP.fetch(ext, DEFAULT_OUTPUT_FORMAT)
+        end
+
+        def parse_kv_string(str)
+          str.split(',').to_h do |pair|
+            key, value = pair.split('=', 2)
+            [key.strip, value&.strip]
+          end
+        end
+
+        def apply_kv_to_formatter(option_key, str)
+          targets = option_key == :all ? FORMATTER_ATTR_TARGETS : [option_key]
+          parse_kv_string(str).each do |key, value|
+            targets.each { |t| @formatter.public_send(t)[key] = value }
+          end
+        end
+
+        def setup_formatter_options
+          return unless @formatter
+
+          @formatter.type = @type if @type
+
+          FORMATTER_ATTR_TARGETS.each do |target|
+            apply_kv_to_formatter(target, options[target]) if options[target]
+          end
+          apply_kv_to_formatter(:all, options[:all]) if options[:all]
+        end
+      end
+
+      def self.exit_on_failure?
+        true
+      end
+    end
+  end
+end

data/lib/lutaml/lml/data_processor/attribute_processing.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class DataProcessor
+      module AttributeProcessing
+        EXCLUDED_PASS_THROUGH_KEYS = %i[key value comments add attributes properties].freeze
+
+        def process_attributes(obj)
+          case obj
+          when Array then process_attributes_array(obj)
+          when Hash then process_attributes_hash(obj)
+          end
+        end
+
+        def process_attributes_array(obj)
+          return obj.map { |item| process_attributes(item) } unless single_key_hashes?(obj)
+
+          obj.each_with_object({}) do |item, hash|
+            hash[:properties] ||= []
+            if item.key?(:properties)
+              hash[:properties] << process_attributes(item[:properties])
+            else
+              hash.merge!(process_attributes(item))
+            end
+          end
+        end
+
+        def process_attributes_hash(obj)
+          result = extract_name_and_value(obj)
+          convert_instance_type(result)
+          result[:extended] = !obj[:add].nil? if obj.key?(:add)
+          apply_nested_attributes(result, obj)
+          apply_remaining_keys(result, obj)
+          result
+        end
+
+        private
+
+        def single_key_hashes?(arr)
+          arr.all? { |e| e.is_a?(Hash) && e.keys.size == 1 }
+        end
+
+        def extract_name_and_value(obj)
+          result = {}
+          result[:name] = obj[:key] if obj.key?(:key)
+
+          if obj.key?(:comments)
+            result[:name] = 'Comment'
+            result[:value] = process_value(obj[:comments]).last
+          elsif obj.key?(:value)
+            result[:type], result[:value] = process_value(obj[:value])
+          end
+
+          result
+        end
+
+        def convert_instance_type(result)
+          return unless result[:type]&.start_with?('Instance')
+
+          value = result.delete(:value)
+          result[:instances] = value.is_a?(Array) ? value : [value]
+          result.delete(:type)
+        end
+
+        def apply_nested_attributes(result, obj)
+          result[:attributes] = process_attributes(obj[:attributes]) if obj.key?(:attributes)
+          result[:properties] = process_attributes(obj[:properties]) if obj.key?(:properties)
+        end
+
+        def apply_remaining_keys(result, obj)
+          obj.each do |key, value|
+            next if EXCLUDED_PASS_THROUGH_KEYS.include?(key)
+
+            result[key] = value unless result.key?(key)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/lml/data_processor/collection_processing.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class DataProcessor
+      module CollectionProcessing
+        def process_collections(obj)
+          obj.each_with_object({}) do |(key, value), result|
+            result[key] = process_value(value).last
+          end
+        end
+
+        def process_imports(obj)
+          process_io_definitions(obj)
+        end
+
+        def process_exports(obj)
+          process_io_definitions(obj)
+        end
+
+        private
+
+        def process_io_definitions(obj)
+          obj.map do |item|
+            item.each_with_object({}) do |(key, value), result|
+              result[key] = if key == :attributes
+                              process_attributes(value)
+                            else
+                              process_value(value).last
+                            end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/lml/data_processor/instance_processing.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class DataProcessor
+      module InstanceProcessing
+        INSTANCE_KEY_HANDLERS = {
+          instance: :process_instance,
+          collections: :process_collections,
+          imports: :process_imports,
+          exports: :process_exports
+        }.freeze
+
+        INSTANCE_FIELD_HANDLERS = {
+          instance_type: :handle_instance_type,
+          instance: :handle_instance_nested,
+          attributes: :handle_instance_attributes,
+          template: :handle_instance_template
+        }.freeze
+
+        def process_instances(obj)
+          return [] unless obj.is_a?(Array)
+
+          obj.each_with_object({}) do |instance, acc|
+            acc[:instances] ||= []
+            key = INSTANCE_KEY_HANDLERS.keys.find { |k| instance.key?(k) }
+            next unless key
+
+            result = public_send(INSTANCE_KEY_HANDLERS[key], instance[key])
+            key == :instance ? (acc[:instances] << result) : (acc[key] = result)
+          end
+        end
+
+        def process_instance(hash)
+          hash.each_with_object({}) do |(key, value), result|
+            handler = INSTANCE_FIELD_HANDLERS[key]
+            if handler
+              public_send(handler, value, result)
+            else
+              result[key] = process_value(value).last
+            end
+          end
+        end
+
+        def handle_instance_type(value, result)
+          result[:type] = process_value(value).last
+        end
+
+        def handle_instance_nested(value, result)
+          result[:instance] = process_instance(value)
+        end
+
+        def handle_instance_attributes(value, result)
+          result[:attributes] = process_attributes(value)
+        end
+
+        def handle_instance_template(value, result)
+          result[:template] = process_attributes(value[:attributes])
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/lml/data_processor/value_processing.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class DataProcessor
+      module ValueProcessing
+        VALUE_TYPE_KEYS = %i[instance list string boolean key_value_map number float condition require].freeze
+
+        VALUE_TYPE_HANDLERS = {
+          instance: :handle_instance_value,
+          list: :handle_list_value,
+          string: :handle_string_value,
+          boolean: :handle_boolean_value,
+          key_value_map: :handle_key_value_map,
+          number: :handle_number_value,
+          float: :handle_float_value,
+          condition: :handle_delegate_value,
+          require: :handle_delegate_value
+        }.freeze
+
+        def process_value(value)
+          return [] if value.nil?
+          return process_hash_value(value) if value.is_a?(Hash)
+          return process_array_value(value) if value.is_a?(Array)
+
+          [value.class.to_s, value]
+        end
+
+        def process_list_value(list)
+          process_typed_sequence(list)
+        end
+
+        def process_array_value(value)
+          process_typed_sequence(value)
+        end
+
+        def handle_instance_value(_key, value)
+          ['Instance', process_instance(value[:instance])]
+        end
+
+        def handle_list_value(_key, value)
+          process_typed_sequence(value[:list])
+        end
+
+        def handle_string_value(_key, value)
+          ['String', value[:string]]
+        end
+
+        def handle_boolean_value(_key, value)
+          ['Boolean', value[:boolean] == 'true']
+        end
+
+        def handle_key_value_map(_key, value)
+          process_key_value_map(value[:key_value_map])
+        end
+
+        def handle_number_value(_key, value)
+          ['Number', value[:number].to_i]
+        end
+
+        def handle_float_value(_key, value)
+          ['Float', value[:float].to_f]
+        end
+
+        def handle_delegate_value(key, value)
+          process_value(value[key])
+        end
+
+        private
+
+        def process_hash_value(value)
+          type_key = VALUE_TYPE_KEYS.find { |k| value.key?(k) }
+          return ['Hash', value] unless type_key
+
+          public_send(VALUE_TYPE_HANDLERS[type_key], type_key, value)
+        end
+
+        def process_typed_sequence(items)
+          type = 'String'
+          values = items.map do |item|
+            item_type, item_value = process_value(item)
+            type = item_type
+            item_value
+          end
+          ["#{type}[]", values]
+        end
+
+        def process_key_value_map(kv_map)
+          result = kv_map.each_with_object({}) do |kv, h|
+            key, value = kv.values_at(:key, :value)
+            h[key.to_sym] = process_value(value).last
+          end
+          ['Hash', result]
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/lml/data_processor/view_processing.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class DataProcessor
+      module ViewProcessing
+        def process_show_list(data)
+          extract_entity_names(data)
+        end
+
+        def process_hide_list(data)
+          extract_entity_names(data)
+        end
+
+        private
+
+        def extract_entity_names(data)
+          return data.map { |d| extract_entity_names(d) } if data.is_a?(Array)
+          return data[:entity_name].to_s if data.is_a?(Hash) && data.key?(:entity_name)
+          data.to_s
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/lml/data_processor.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class DataProcessor
+      autoload :ValueProcessing, "lutaml/lml/data_processor/value_processing"
+      autoload :AttributeProcessing, "lutaml/lml/data_processor/attribute_processing"
+      autoload :InstanceProcessing, "lutaml/lml/data_processor/instance_processing"
+      autoload :CollectionProcessing, "lutaml/lml/data_processor/collection_processing"
+      autoload :ViewProcessing, "lutaml/lml/data_processor/view_processing"
+
+      include ValueProcessing
+      include AttributeProcessing
+      include InstanceProcessing
+      include CollectionProcessing
+      include ViewProcessing
+
+      KEY_HANDLERS = {
+        requires: :process_requires,
+        instances: :process_instances,
+        instance: :process_instance,
+        attributes: :process_attributes,
+        show_list: :process_show_list,
+        hide_list: :process_hide_list
+      }.freeze
+
+      def self.process(obj)
+        new.process_data(obj)
+      end
+
+      def process_data(obj)
+        return obj unless obj.is_a?(Hash) || obj.is_a?(Array)
+
+        obj.is_a?(Array) ? obj.map { |item| process_data(item) } : process_hash(obj)
+      end
+
+      def process_hash(obj)
+        obj.each_with_object({}) do |(key, value), result|
+          handler = KEY_HANDLERS[key]
+          result[key] = handler ? public_send(handler, value) : process_data(value)
+        end
+      end
+
+      def process_requires(obj)
+        obj.map { |req| process_value(req).last }
+      end
+    end
+  end
+end