lutaml-lml 0.1.0

data/lib/lutaml/lml/grammar/concerns/primitives.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    module Grammar
+      module Concerns
+        module Primitives
+          include Parslet
+
+          rule(:quotes) { match['"\''] }
+          rule(:quotes?) { quotes.maybe }
+          rule(:space) { match("\s") }
+          rule(:spaces) { space.repeat(1) }
+          rule(:spaces?) { spaces.maybe }
+          rule(:whitespace) do
+            (space | match("	") | match("\r?\n") | match("\r") | str(";"))
+              .repeat(1)
+          end
+          rule(:whitespace?) { whitespace.maybe }
+          rule(:newline) { match('[\r\n]') }
+
+          rule(:quoted_string) do
+            str('"') >> (str('"').absent? >> any).repeat.as(:string) >> str('"')
+          end
+          rule(:boolean) { (str("true") | str("false")).as(:boolean) }
+          rule(:number) { (match("[0-9]").repeat(1) >> str(".") >> match("[0-9]").repeat(1)).as(:float) | match("[0-9]").repeat(1).as(:number) }
+          rule(:variable) { (quoted_string | match("[a-zA-Z0-9_]").repeat(1)) }
+          rule(:reference) do
+            str("reference:(") >>
+              (variable >> (str(".") >> variable).repeat).as(:reference) >>
+              str(")")
+          end
+          rule(:range) do
+            (variable.as(:start) >> str("..") >> variable.as(:end)).as(:range)
+          end
+          rule(:namespaced_identifier) do
+            variable >> (str("::") >> variable).repeat
+          end
+          rule(:comment_definition) do
+            spaces? >> (str("**") | str("#")) >> (newline.absent? >> any).repeat.as(:comments)
+          end
+          rule(:comment_multiline_definition) do
+            spaces? >> str("*|") >> (str("|*").absent? >> any)
+              .repeat.as(:comments) >> whitespace? >> str("|*")
+          end
+          rule(:class_name_chars) { match('(?:[a-zA-Z0-9 _-]|\:|\.)').repeat(1) }
+          rule(:class_name) do
+            class_name_chars >>
+              (str("(") >>
+                class_name_chars >>
+                str(")")).maybe
+          end
+          rule(:cardinality_body_definition) do
+            match['0-9a-z\*'].as("min") >>
+              str("..").maybe >>
+              match['0-9a-z\*'].as("max").maybe
+          end
+          rule(:cardinality) do
+            str("[") >>
+              cardinality_body_definition.as(:cardinality) >>
+              str("]")
+          end
+          rule(:cardinality?) { cardinality.maybe }
+
+          rule(:value) do
+            boolean |
+              reference |
+              range |
+              number |
+              quoted_string
+          end
+
+          rule(:key_value_pair) do
+            variable.as(:key) >> spaces >> str("=").maybe >> spaces? >> value.as(:value)
+          end
+          rule(:key_value_map) do
+            str("{") >> whitespace? >>
+              (key_value_pair >> whitespace).repeat.as(:key_value_map) >>
+              str("}")
+          end
+
+          rule(:kw_visibility_modifier) do
+            str("+") | str("-") | str("#") | str("~")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/lml/grammar/concerns/view_rules.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    module Grammar
+      module Concerns
+        module ViewRules
+          include Parslet
+
+          rule(:view_import_keyword) { str("import") >> spaces }
+
+          rule(:view_import) do
+            view_import_keyword >>
+              str('"') >> (str('"').absent? >> any).repeat.as(:path) >> str('"') >>
+              whitespace?
+          end
+
+          rule(:entity_name_list) do
+            class_name.as(:entity_name) >>
+              (spaces? >> str(",") >> spaces? >> class_name.as(:entity_name)).repeat
+          end
+
+          rule(:show_directive) do
+            str("show") >> spaces >> entity_name_list.as(:show_list) >> whitespace?
+          end
+
+          rule(:hide_directive) do
+            str("hide") >> spaces >> entity_name_list.as(:hide_list) >> whitespace?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/lml/grammar/concerns.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    module Grammar
+      module Concerns
+        autoload :Primitives, "lutaml/lml/grammar/concerns/primitives"
+        autoload :Attributes, "lutaml/lml/grammar/concerns/attributes"
+        autoload :Associations, "lutaml/lml/grammar/concerns/associations"
+        autoload :Definitions, "lutaml/lml/grammar/concerns/definitions"
+        autoload :ViewRules, "lutaml/lml/grammar/concerns/view_rules"
+        autoload :InstanceRules, "lutaml/lml/grammar/concerns/instance_rules"
+        autoload :DataStructures, "lutaml/lml/grammar/concerns/data_structures"
+      end
+    end
+  end
+end

data/lib/lutaml/lml/grammar/core.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Lutaml
+  module Lml
+    module Grammar
+      module Core
+        include Parslet
+        include Concerns::Primitives
+        include Concerns::Attributes
+        include Concerns::Associations
+        include Concerns::Definitions
+        include Concerns::ViewRules
+
+        CORE_KEYWORDS = %w[
+          abstract
+          aggregation
+          association
+          attribute
+          bidirectional
+          caption
+          class
+          composition
+          data_type
+          dependency
+          diagram
+          directional
+          enum
+          fontname
+          generalizes
+          include
+          interface
+          member
+          member_type
+          method
+          owner
+          owner_type
+          primitive
+          private
+          protected
+          public
+          realizes
+          static
+          title
+          view
+        ].freeze
+
+        CORE_KEYWORDS.each do |keyword|
+          rule("kw_#{keyword}") { whitespace? >> str(keyword) }
+        end
+
+        # === Require statements ===
+        rule(:require_stmt) do
+          kw_require >> spaces >> quoted_string.as(:require) >> whitespace?
+        end
+
+        rule(:require_block) do
+          (require_stmt >> whitespace?).repeat.as(:requires)
+        end
+
+        rule(:require_block?) do
+          require_block.maybe
+        end
+
+        # -- Root (Core: diagram only)
+        rule(:diagram) { require_block? >> diagram_definitions }
+      end
+    end
+  end
+end

data/lib/lutaml/lml/grammar/full.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    module Grammar
+      module Full
+        include Core
+        include Instances
+      end
+    end
+  end
+end

data/lib/lutaml/lml/grammar/instances.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Lutaml
+  module Lml
+    module Grammar
+      module Instances
+        include Parslet
+        include Concerns::InstanceRules
+        include Concerns::DataStructures
+
+        INSTANCE_KEYWORDS = %w[
+          collection
+          condition
+          export
+          extends
+          format
+          import
+          includes
+          instance
+          instances
+          models
+          require
+          template
+          validation
+        ].freeze
+
+        INSTANCE_KEYWORDS.each do |keyword|
+          rule("kw_#{keyword}") { whitespace? >> str(keyword) }
+        end
+
+        # -- Root (Full: diagram + models + instances)
+        rule(:diagram) { require_block? >> (models | diagram_definitions | view_definitions | instances | instance) }
+      end
+    end
+  end
+end

data/lib/lutaml/lml/grammar.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    module Grammar
+      autoload :Core, "lutaml/lml/grammar/core"
+      autoload :Instances, "lutaml/lml/grammar/instances"
+      autoload :Full, "lutaml/lml/grammar/full"
+      autoload :Concerns, "lutaml/lml/grammar/concerns"
+    end
+  end
+end

data/lib/lutaml/lml/has_attributes.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    module HasAttributes
+      def update_attributes(attributes = {})
+        attributes.to_h.each do |name, value|
+          value = value.str if value.is_a?(Parslet::Slice)
+          public_send(:"#{name}=", value)
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/lml/import_resolver.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Lutaml
+  module Lml
+    class ImportResolver
+      def initialize(base_path)
+        @base_path = base_path
+      end
+
+      def resolve(document)
+        entities = {}
+        associations = []
+        visited = Set.new
+
+        document.view_imports.each do |import|
+          resolve_import(import.path, entities, associations, visited, @base_path)
+        end
+
+        collect_local_entities(document, entities, associations)
+
+        [entities.values, associations]
+      end
+
+      private
+
+      def resolve_import(path, entities, associations, visited, base_path)
+        base_dir = base_path ? File.dirname(base_path) : Dir.pwd
+        abs_pattern = File.expand_path(path, base_dir)
+
+        Dir.glob(abs_pattern).each do |file_path|
+          next if visited.include?(file_path)
+          visited.add(file_path)
+
+          if view_file?(file_path)
+            resolve_view_file(file_path, entities, associations, visited)
+          else
+            resolve_model_file(file_path, entities, associations)
+          end
+        end
+      end
+
+      def resolve_view_file(file_path, entities, associations, visited)
+        doc = Parser.parse_document(File.new(file_path))
+
+        collect_local_entities(doc, entities, associations)
+
+        doc.view_imports&.each do |import|
+          resolve_import(import.path, entities, associations, visited, file_path)
+        end
+      rescue Errno::ENOENT, Errno::EACCES => e
+        warn "Skipping #{file_path}: #{e.message}"
+        []
+      end
+
+      def resolve_model_file(file_path, entities, associations)
+        content = File.read(file_path)
+        wrapped = "diagram Fragment {\n#{content}\n}"
+        doc = Parser.parse_document(StringIO.new(wrapped))
+
+        collect_local_entities(doc, entities, associations)
+      rescue Errno::ENOENT, Errno::EACCES => e
+        warn "Skipping #{file_path}: #{e.message}"
+        []
+      end
+
+      def view_file?(file_path)
+        head = File.read(file_path, 200, encoding: "UTF-8")
+        head.match?(/\b(view|diagram)\s+\w/)
+      rescue Errno::ENOENT, Errno::EACCES
+        false
+      end
+
+      def collect_local_entities(doc, entities, associations)
+        merge_entities(doc.classes, entities)
+        merge_entities(doc.enums, entities)
+        merge_entities(doc.data_types, entities)
+        associations.concat(doc.associations.to_a)
+      end
+
+      def merge_entities(collection, entities)
+        collection.each do |entity|
+          entities[entity.name] ||= entity
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/lml/layout/engine.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Layout
+    class Engine
+      attr_accessor :input
+
+      def initialize(input:)
+        @input = input
+      end
+
+      def render(_type)
+        raise ArgumentError, "Implement render method"
+      end
+    end
+  end
+end

data/lib/lutaml/lml/layout/graph_viz_engine.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "ruby-graphviz"
+require "open3"
+
+module Lutaml
+  module Layout
+    class GraphVizEngine < Engine
+      def render(type)
+        Open3.popen3("dot -T#{type}") do |stdin, stdout, _stderr, _wait|
+          stdout.binmode
+          stdin.puts(input)
+          stdin.close
+          stdout.read
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/lml/layout.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Layout
+    autoload :Engine, "lutaml/lml/layout/engine"
+    autoload :GraphVizEngine, "lutaml/lml/layout/graph_viz_engine"
+  end
+end