lutaml-lml 0.1.0

data/lib/lutaml/lml/models/primitive_type.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class PrimitiveType < Lutaml::Model::Serializable
+      # Primitives in LML are name-only entities, but the formatter
+      # accesses the same attributes as DataType via format_class.
+      attribute :name, :string
+      attribute :keyword, :string, default: "primitive"
+      attribute :definition, :string
+      attribute :stereotype, :string, collection: true, default: -> { [] }
+      attribute :visibility, :string, default: "public"
+      attribute :is_abstract, :boolean, default: false
+      attribute :attributes, "Lutaml::Lml::TopElementAttribute", collection: true,
+                                                                   default: -> { [] }
+      attribute :operations, "Lutaml::Lml::Operation", collection: true,
+                                                         default: -> { [] }
+      attribute :associations, "Lutaml::Lml::Association", collection: true,
+                                                             default: -> { [] }
+
+      def self.entity_type
+        :primitives
+      end
+    end
+  end
+end

data/lib/lutaml/lml/models/top_element_attribute.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class TopElementAttribute < Lutaml::Model::Serializable
+      # Core attributes
+      attribute :name, :string
+      attribute :visibility, :string, default: "public"
+      attribute :type, :string
+      attribute :id, :string
+      attribute :contain, :string
+      attribute :static, :string
+      attribute :cardinality, "Lutaml::Lml::Cardinality"
+      attribute :keyword, :string
+      attribute :is_derived, :boolean, default: false
+      attribute :is_static, :boolean, default: false
+      attribute :is_read_only, :boolean, default: false
+      attribute :stereotype, :string, collection: true, default: -> { [] }
+      attribute :definition, :string
+      attribute :association, :string
+      attribute :default, :string
+
+      # LML-specific attributes
+      attribute :properties, "Lutaml::Lml::TopElementAttribute", collection: true, default: []
+      attribute :value, "Lutaml::Lml::TopElementAttribute", collection: true
+      attribute :attributes, "Lutaml::Lml::TopElementAttribute", collection: true, default: []
+      attribute :extended, :boolean
+      attribute :instances, "Lutaml::Lml::Instance", collection: true, default: []
+    end
+  end
+end

data/lib/lutaml/lml/models/uml_class.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class UmlClass < Lutaml::Model::Serializable
+      # From TopElement
+      attribute :name, :string
+      attribute :definition, :string
+      attribute :keyword, :string
+      attribute :stereotype, :string, collection: true, default: -> { [] }
+      attribute :visibility, :string, default: "public"
+      attribute :comments, :string, collection: true
+
+      # From UmlClassifier
+      attribute :is_abstract, :boolean, default: false
+
+      # From UmlClass
+      attribute :nested_classifier, :string, collection: true, default: -> { [] }
+      attribute :type, :string
+      attribute :attributes, "Lutaml::Lml::TopElementAttribute", collection: true
+      attribute :modifier, :string
+      attribute :constraints, "Lutaml::Lml::Constraint", collection: true
+      attribute :operations, "Lutaml::Lml::Operation", collection: true
+      attribute :data_types, "Lutaml::Lml::DataType", collection: true
+      attribute :associations, "Lutaml::Lml::Association", collection: true
+
+      # LML-specific
+      attribute :parent_class, :string
+
+      yaml do
+        map "name", to: :name
+        map "keyword", to: :keyword
+        map "is_abstract", to: :is_abstract
+        map "definition", to: :definition, with: {
+          to: :definition_to_yaml, from: :definition_from_yaml
+        }
+        map "modifier", to: :modifier
+        map "stereotype", to: :stereotype
+        map "visibility", to: :visibility
+        map "type", to: :type
+        map "attributes", to: :attributes
+        map "operations", to: :operations
+        map "constraints", to: :constraints
+        map "data_types", to: :data_types
+        map "associations", to: :associations, with: {
+          to: :associations_to_yaml, from: :associations_from_yaml
+        }
+      end
+
+      def associations_to_yaml(model, doc)
+        return unless model.associations
+
+        associations = model.associations.map(&:to_hash)
+        doc["associations"] = associations unless associations.empty?
+      end
+
+      def associations_from_yaml(model, values)
+        associations = values.map do |value|
+          value["owner_end"] = model.name if value["owner_end"].nil?
+          Association.from_yaml(value.to_yaml)
+        end
+
+        model.associations = associations
+      end
+
+      def definition_to_yaml(model, doc)
+        doc["definition"] = model.definition if model.definition
+      end
+
+      def definition_from_yaml(model, value)
+        model.definition = value.to_s
+          .gsub(/\\}/, "}")
+          .gsub(/\\{/, "{")
+          .split("\n")
+          .map(&:strip)
+          .join("\n")
+      end
+
+      def self.entity_type
+        :classes
+      end
+    end
+  end
+end

data/lib/lutaml/lml/models/value.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class Value < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :id, :string
+      attribute :type, :string
+      attribute :definition, :string
+    end
+  end
+end

data/lib/lutaml/lml/models/view_filter.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Lutaml
+  module Lml
+    class ViewFilter < Lutaml::Model::Serializable
+      attribute :entity_names, :string, collection: true
+    end
+  end
+end

data/lib/lutaml/lml/models/view_import.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Lutaml
+  module Lml
+    class ViewImport < Lutaml::Model::Serializable
+      attribute :path, :string
+    end
+  end
+end

data/lib/lutaml/lml/parser.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "parslet"
+require "parslet/convenience"
+
+module Lutaml
+  module Lml
+    class Parser < Parslet::Parser
+      include Grammar::Full
+
+      root(:diagram)
+
+      def self.parse(io)
+        Pipeline.call(io)
+      end
+
+      def self.parse_document(io)
+        Pipeline.call(io, resolve: false)
+      end
+    end
+  end
+end

data/lib/lutaml/lml/pipeline.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "parslet"
+require "parslet/convenience"
+
+module Lutaml
+  module Lml
+    class Pipeline
+      def self.call(input, resolve: true)
+        new(input, resolve: resolve).call
+      end
+
+      def initialize(input, resolve: true)
+        @input = input
+        @resolve = resolve
+      end
+
+      def call
+        data = Preprocessor.call(@input)
+        hash = parse_raw(data)
+        hash = DataProcessor.process(hash)
+        document = build_document(hash)
+        if @resolve
+          document = resolve_document(document)
+          AssociationLabelResolver.new.enrich(document)
+        end
+        document
+      end
+
+      private
+
+      def parse_raw(data)
+        reporter = Parslet::ErrorReporter::Deepest.new
+        Transform.new.apply(Parser.new.parse(data, reporter: reporter))
+      rescue Parslet::ParseFailed => e
+        raise(ParsingError,
+              "#{e.message}\ncause: #{e.parse_failure_cause.ascii_tree}")
+      end
+
+      def build_document(hash)
+        DocumentBuilder.new(DocumentBuilder::DEFAULT_REGISTRY).build(:document, hash)
+      end
+
+      def resolve_document(document)
+        return document unless document.view_imports&.any?
+
+        base_path = @input.is_a?(StringIO) ? nil : @input.path
+        entities, associations = ImportResolver.new(base_path).resolve(document)
+        entities, associations = ViewResolver.new.resolve(document, entities, associations)
+        rebuild_document(document, entities, associations)
+      end
+
+      def rebuild_document(document, entities, associations)
+        grouped = entities.group_by { |e| e.class.entity_type }
+
+        document.classes = grouped[:classes] || []
+        document.enums = grouped[:enums] || []
+        document.data_types = grouped[:data_types] || []
+        document.associations = associations
+        document
+      end
+    end
+  end
+end

data/lib/lutaml/lml/preprocessor.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class Preprocessor
+      attr_reader :input_file
+
+      def initialize(input_file)
+        @input_file = input_file
+      end
+
+      class << self
+        def call(input_file)
+          new(input_file).call
+        end
+      end
+
+      def call
+        input_file.rewind
+        include_root = input_file.is_a?(StringIO) ? Dir.pwd : File.dirname(input_file.path)
+        input_file.read.split("\n").reduce([]) do |res, line|
+          res.push(*process_dsl_line(include_root, line))
+        end.join("\n")
+      end
+
+      private
+
+      def process_dsl_line(include_root, line)
+        process_include_line(include_root, process_comment_line(line))
+      end
+
+      def process_comment_line(line)
+        has_comment = line.match(%r{//.*})
+        return line if has_comment.nil?
+
+        line.gsub(%r{//.*}, "")
+      end
+
+      def process_include_line(include_root, line)
+        include_path_match = line.match(/^\s*include\s+(.+)/)
+        return line if include_path_match.nil? || line =~ /^\s\*\*/
+
+        path_to_file = File.expand_path(include_path_match[1].strip, include_root)
+        File.read(path_to_file).split("\n").map do |l|
+          process_comment_line(l)
+        end
+      rescue Errno::ENOENT
+        $stderr.puts(
+          "No such file or directory @ rb_sysopen - #{path_to_file}, " \
+          "include file paths need to be supplied relative to the main document"
+        )
+        []
+      end
+    end
+  end
+end

data/lib/lutaml/lml/transform.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'parslet'
+
+module Lutaml
+  module Lml
+    class Transform < Parslet::Transform
+      VISIBILITY_MAP = {
+        '-' => 'private',
+        '#' => 'protected',
+        '~' => 'friendly'
+      }.freeze
+
+      rule(visibility_modifier: simple(:visibility_value)) do
+        VISIBILITY_MAP.fetch(visibility_value.to_s, 'public')
+      end
+      rule(simple(:member)) { member.nil? ? member : member.to_s.strip }
+    end
+  end
+end

data/lib/lutaml/lml/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    VERSION = "0.1.0"
+  end
+end

data/lib/lutaml/lml/view_resolver.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class ViewResolver
+      def resolve(document, entities, associations)
+        visible = apply_filters(document, entities)
+        filtered_associations = filter_associations(associations, visible)
+
+        [visible, filtered_associations]
+      end
+
+      private
+
+      def apply_filters(document, entities)
+        names = entities.each_with_object({}) { |e, h| h[e.name] = e }
+
+        names = apply_show_filter(names, document.show_filter)
+        names = apply_hide_filter(names, document.hide_filter)
+
+        names.values
+      end
+
+      def apply_show_filter(names, filter)
+        return names unless filter
+
+        show_set = filter.entity_names.to_set
+        names.select { |name, _| show_set.include?(name) }
+      end
+
+      def apply_hide_filter(names, filter)
+        return names unless filter
+
+        hide_set = filter.entity_names.to_set
+        names.reject { |name, _| hide_set.include?(name) }
+      end
+
+      def filter_associations(associations, visible_entities)
+        visible_names = visible_entities.map(&:name).to_set
+        associations.select do |assoc|
+          owner_visible = visible_names.include?(assoc.owner_end.to_s)
+          member_visible = visible_names.include?(assoc.member_end.to_s)
+          owner_visible && member_visible
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/lml/yaml_parser.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Lutaml
+  module Lml
+    class YamlParser
+      def self.parse(yaml_path, options = {})
+        new.parse(yaml_path, options)
+      end
+
+      def parse(yaml_path, _options = {})
+        Lutaml::Lml::Document.from_yaml(File.read(yaml_path))
+      end
+    end
+  end
+end

data/lib/lutaml/lml.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+# Lutaml::Formatter and Lutaml::Layout are in the Lutaml top namespace,
+# not Lutaml::Lml. Require their namespace files to set up autoloads.
+require "lutaml/lml/formatter"
+require "lutaml/lml/layout"
+
+module Lutaml
+  class Error < StandardError; end
+
+  module Lml
+    class Error < Lutaml::Error; end
+    class ParsingError < Error; end
+
+    def self.compile(input, namespace: nil)
+      ModelCompiler.new(namespace: namespace).compile(input)
+    end
+
+    # Top-level autoloads
+    autoload :Parser, "lutaml/lml/parser"
+    autoload :Pipeline, "lutaml/lml/pipeline"
+    autoload :Preprocessor, "lutaml/lml/preprocessor"
+    autoload :Transform, "lutaml/lml/transform"
+    autoload :DataProcessor, "lutaml/lml/data_processor"
+    autoload :DocumentBuilder, "lutaml/lml/document_builder"
+    autoload :ModelCompiler, "lutaml/lml/model_compiler"
+    autoload :ImportResolver, "lutaml/lml/import_resolver"
+    autoload :ViewResolver, "lutaml/lml/view_resolver"
+    autoload :AssociationLabelResolver, "lutaml/lml/association_label_resolver"
+    autoload :Executor, "lutaml/lml/executor"
+    autoload :YamlParser, "lutaml/lml/yaml_parser"
+    autoload :HasAttributes, "lutaml/lml/has_attributes"
+    autoload :VERSION, "lutaml/lml/version"
+
+    # Model classes (in Lutaml::Lml namespace, files in models/ directory)
+    autoload :Action, "lutaml/lml/models/action"
+    autoload :Association, "lutaml/lml/models/association"
+    autoload :Cardinality, "lutaml/lml/models/cardinality"
+    autoload :Collection, "lutaml/lml/models/collection"
+    autoload :Constraint, "lutaml/lml/models/constraint"
+    autoload :DataType, "lutaml/lml/models/data_type"
+    autoload :Diagram, "lutaml/lml/models/diagram"
+    autoload :Document, "lutaml/lml/models/document"
+    autoload :Enum, "lutaml/lml/models/enum"
+    autoload :Fidelity, "lutaml/lml/models/fidelity"
+    autoload :Group, "lutaml/lml/models/group"
+    autoload :Instance, "lutaml/lml/models/instance"
+    autoload :InstanceCollection, "lutaml/lml/models/instance_collection"
+    autoload :InstancesExport, "lutaml/lml/models/instances_export"
+    autoload :InstancesImport, "lutaml/lml/models/instances_import"
+    autoload :Operation, "lutaml/lml/models/operation"
+    autoload :OperationParameter, "lutaml/lml/models/operation_parameter"
+    autoload :Package, "lutaml/lml/models/package"
+    autoload :PrimitiveType, "lutaml/lml/models/primitive_type"
+    autoload :TopElementAttribute, "lutaml/lml/models/top_element_attribute"
+    autoload :UmlClass, "lutaml/lml/models/uml_class"
+    autoload :Value, "lutaml/lml/models/value"
+    autoload :ViewFilter, "lutaml/lml/models/view_filter"
+    autoload :ViewImport, "lutaml/lml/models/view_import"
+
+    # Namespaces with their own autoloads
+    autoload :Grammar, "lutaml/lml/grammar"
+    autoload :Format, "lutaml/lml/format"
+  end
+end

metadata

@@ -0,0 +1,178 @@
+--- !ruby/object:Gem::Specification
+name: lutaml-lml
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ribose Inc.
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lutaml-model
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: moxml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.24
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.24
+- !ruby/object:Gem::Dependency
+  name: ruby-graphviz
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 'Parses LML (.lml / .lutaml) text syntax into UML/LML domain models.
+  Supports two layers: model definitions (classes, enums, attributes) and data instances
+  (collections, imports, exports).'
+email:
+- open.source@ribose.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/lutaml/lml.rb
+- lib/lutaml/lml/association_label_resolver.rb
+- lib/lutaml/lml/cli.rb
+- lib/lutaml/lml/data_processor.rb
+- lib/lutaml/lml/data_processor/attribute_processing.rb
+- lib/lutaml/lml/data_processor/collection_processing.rb
+- lib/lutaml/lml/data_processor/instance_processing.rb
+- lib/lutaml/lml/data_processor/value_processing.rb
+- lib/lutaml/lml/data_processor/view_processing.rb
+- lib/lutaml/lml/document_builder.rb
+- lib/lutaml/lml/executor.rb
+- lib/lutaml/lml/executor/adapter_helpers.rb
+- lib/lutaml/lml/executor/condition_evaluator.rb
+- lib/lutaml/lml/executor/csv_adapter.rb
+- lib/lutaml/lml/executor/format_adapter.rb
+- lib/lutaml/lml/executor/xml_adapter.rb
+- lib/lutaml/lml/format.rb
+- lib/lutaml/lml/format/adapter/document.rb
+- lib/lutaml/lml/format/adapter/mapping.rb
+- lib/lutaml/lml/format/adapter/standard_adapter.rb
+- lib/lutaml/lml/format/adapter/transform.rb
+- lib/lutaml/lml/formatter.rb
+- lib/lutaml/lml/formatter/base.rb
+- lib/lutaml/lml/formatter/graphviz.rb
+- lib/lutaml/lml/formatter/graphviz/document_formatter.rb
+- lib/lutaml/lml/formatter/graphviz/html_builder.rb
+- lib/lutaml/lml/formatter/graphviz/node_formatter.rb
+- lib/lutaml/lml/formatter/graphviz/relationship_formatter.rb
+- lib/lutaml/lml/grammar.rb
+- lib/lutaml/lml/grammar/concerns.rb
+- lib/lutaml/lml/grammar/concerns/associations.rb
+- lib/lutaml/lml/grammar/concerns/attributes.rb
+- lib/lutaml/lml/grammar/concerns/data_structures.rb
+- lib/lutaml/lml/grammar/concerns/definitions.rb
+- lib/lutaml/lml/grammar/concerns/instance_rules.rb
+- lib/lutaml/lml/grammar/concerns/primitives.rb
+- lib/lutaml/lml/grammar/concerns/view_rules.rb
+- lib/lutaml/lml/grammar/core.rb
+- lib/lutaml/lml/grammar/full.rb
+- lib/lutaml/lml/grammar/instances.rb
+- lib/lutaml/lml/has_attributes.rb
+- lib/lutaml/lml/import_resolver.rb
+- lib/lutaml/lml/layout.rb
+- lib/lutaml/lml/layout/engine.rb
+- lib/lutaml/lml/layout/graph_viz_engine.rb
+- lib/lutaml/lml/model_compiler.rb
+- lib/lutaml/lml/models/action.rb
+- lib/lutaml/lml/models/association.rb
+- lib/lutaml/lml/models/cardinality.rb
+- lib/lutaml/lml/models/collection.rb
+- lib/lutaml/lml/models/constraint.rb
+- lib/lutaml/lml/models/data_type.rb
+- lib/lutaml/lml/models/diagram.rb
+- lib/lutaml/lml/models/document.rb
+- lib/lutaml/lml/models/enum.rb
+- lib/lutaml/lml/models/fidelity.rb
+- lib/lutaml/lml/models/group.rb
+- lib/lutaml/lml/models/instance.rb
+- lib/lutaml/lml/models/instance_collection.rb
+- lib/lutaml/lml/models/instances_export.rb
+- lib/lutaml/lml/models/instances_import.rb
+- lib/lutaml/lml/models/operation.rb
+- lib/lutaml/lml/models/operation_parameter.rb
+- lib/lutaml/lml/models/package.rb
+- lib/lutaml/lml/models/primitive_type.rb
+- lib/lutaml/lml/models/top_element_attribute.rb
+- lib/lutaml/lml/models/uml_class.rb
+- lib/lutaml/lml/models/value.rb
+- lib/lutaml/lml/models/view_filter.rb
+- lib/lutaml/lml/models/view_import.rb
+- lib/lutaml/lml/parser.rb
+- lib/lutaml/lml/pipeline.rb
+- lib/lutaml/lml/preprocessor.rb
+- lib/lutaml/lml/transform.rb
+- lib/lutaml/lml/version.rb
+- lib/lutaml/lml/view_resolver.rb
+- lib/lutaml/lml/yaml_parser.rb
+homepage: https://github.com/lutaml/lutaml-lml
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/lutaml/lutaml-lml
+  source_code_uri: https://github.com/lutaml/lutaml-lml
+  changelog_uri: https://github.com/lutaml/lutaml-lml/releases
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: LutaML Model Language (LML) parser and converter
+test_files: []