ea 0.4.0 → 0.5.1

data/lib/ea/qea/validation/database/ocl_constraint_validator.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Validation
+      # Evaluates OCL invariants stored in t_objectconstraint.
+      # For each constraint, parse its OCL expression via
+      # Ea::Ocl::Parser and evaluate it against the owning
+      # object's attribute values. Failures surface as :warning
+      # messages — OCL failures aren't structural errors.
+      class OclConstraintValidator < BaseValidator
+        def validate
+          constraints = database.collections[:object_constraints] || []
+          constraints.each { |c| check_constraint(c) }
+        end
+
+        private
+
+        def check_constraint(constraint)
+          owner = owner_for(constraint)
+          return unless owner
+
+          ast = parse(constraint.constraint)
+          return unless ast
+
+          if evaluate(ast, owner)
+            result.add(:info, "OCL constraint '#{constraint.constraint_type}' " \
+                              "passed for #{owner.name}",
+                       entity_name: owner.name)
+          else
+            result.add(:warning, "OCL constraint '#{constraint.constraint_type}' " \
+                                 "failed for #{owner.name}: #{constraint.constraint}",
+                       entity_name: owner.name)
+          end
+        rescue Ea::Ocl::UnsupportedError => e
+          result.add(:info, "Skipping OCL constraint on #{owner&.name} " \
+                            "(unsupported syntax): #{e.message}",
+                     entity_name: owner&.name)
+        end
+
+        # Parse the OCL body. Returns nil for empty / non-invariant
+        # constraints (we don't try to evaluate non-invariant forms).
+        def parse(body)
+          return nil if body.nil? || body.empty?
+
+          Ea::Ocl::Parser.parse(body)
+        end
+
+        def evaluate(ast, owner)
+          Ea::Ocl::Evaluator.evaluate(ast, owner)
+        end
+
+        def owner_for(constraint)
+          object_id = constraint.respond_to?(:ea_object_id) ?
+                       constraint.ea_object_id :
+                       constraint.object_id
+          return nil unless object_id
+
+          (database.collections[:objects] || [])
+            .find { |o| o.object_id == object_id }
+        end
+      end
+    end
+  end
+end

data/lib/ea/qea/validation/database.rb

@@ -10,6 +10,8 @@ module Ea
                  "ea/qea/validation/database/orphan_validator"
         autoload :ReferentialIntegrityValidator,
                  "ea/qea/validation/database/referential_integrity_validator"
+        autoload :OclConstraintValidator,
+                 "ea/qea/validation/database/ocl_constraint_validator"
       end
     end
   end

data/lib/ea/qea/validation/validation_engine.rb

@@ -83,6 +83,7 @@ module Ea
             orphan
             circular_reference
             package
+            ocl_constraint
           ]
 
           validator_names = if validators
@@ -213,6 +214,7 @@ module Ea
           @registry.register(:circular_reference,
                              CircularReferenceValidator)
           @registry.register(:package, PackageValidator)
+          @registry.register(:ocl_constraint, OclConstraintValidator)
 
           # Phase 2: UML Tree Structure Validators
           # DocumentStructureValidator lives in lutaml-uml and may not be

data/lib/ea/qea/validation.rb

@@ -20,6 +20,8 @@ module Ea
                "ea/qea/validation/database/orphan_validator"
       autoload :CircularReferenceValidator,
                "ea/qea/validation/database/circular_reference_validator"
+      autoload :OclConstraintValidator,
+               "ea/qea/validation/database/ocl_constraint_validator"
       autoload :Database, "ea/qea/validation/database"
       autoload :Formatters, "ea/qea/validation/formatters"
       autoload :ValidationEngine, "ea/qea/validation/validation_engine"

data/lib/ea/query/builder.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Ea
+  module Query
+    # Chainable query builder. Each method returns a new Builder
+    # with the predicate applied — no mutation. Final #call returns
+    # the filtered collection.
+    #
+    # Example:
+    #   Ea::Query.new(model).classes.in_package("core")
+    #            .with_stereotype("FeatureType").call
+    class Builder
+      attr_reader :model, :filters
+
+      def initialize(model, filters: [], kind: :objects)
+        @model = model
+        @filters = filters
+        @kind = kind
+      end
+
+      # Filter to UML classes only.
+      # @return [Builder]
+      def classes
+        with_type("Class")
+      end
+
+      # Filter to interfaces only.
+      # @return [Builder]
+      def interfaces
+        with_type("Interface")
+      end
+
+      # Filter to packages.
+      # @return [Builder]
+      def packages
+        Builder.new(model, filters: filters, kind: :packages)
+      end
+
+      # Filter to diagrams.
+      # @return [Builder]
+      def diagrams
+        Builder.new(model, filters: filters, kind: :diagrams)
+      end
+
+      # Filter by EA object_type (Class, Interface, Package, ...).
+      # @return [Builder]
+      def with_type(type)
+        Builder.new(model, filters: filters + [->(o) { o.object_type == type }], kind: @kind)
+      end
+
+      # Restrict to elements in the named package.
+      # @param name [String]
+      # @return [Builder]
+      def in_package(name)
+        pkg = (model.collections[:packages] || []).find { |p| p.name == name }
+        return self unless pkg
+
+        filter_by { |o| o.package_id == pkg.package_id }
+      end
+
+      # Filter by applied stereotype name. Stereotype lookup walks
+      # t_xref for @STEREO blocks referencing the object's ea_guid.
+      # @param name [String]
+      # @return [Builder]
+      def with_stereotype(name)
+        xrefs = model.collections[:xrefs] || []
+        filter_by do |o|
+          applied = stereotype_names_for(o, xrefs)
+          applied.any? { |r| r == name }
+        end
+      end
+
+      # Filter by name exact match.
+      # @param name [String]
+      # @return [Builder]
+      def named(name)
+        filter_by { |o| o.name == name }
+      end
+
+      # Filter by name substring (case-insensitive).
+      # @param substring [String]
+      # @return [Builder]
+      def name_contains(substring)
+        re = Regexp.new(Regexp.escape(substring), Regexp::IGNORECASE)
+        filter_by { |o| o.name&.match?(re) }
+      end
+
+      # Add a custom filter proc.
+      # @param block [Proc(Object)->Boolean]
+      # @return [Builder]
+      def filter_by(&block)
+        Builder.new(model, filters: filters + [block], kind: @kind)
+      end
+
+      # Extract stereotype names applied to an object via t_xref.
+      # Returns [] when no @STEREO block references the object's GUID.
+      # @param object [Ea::Qea::Models::EaObject]
+      # @param xrefs [Array<Ea::Qea::Models::EaXref>]
+      # @return [Array<String>]
+      def stereotype_names_for(object, xrefs)
+        return [] unless object.is_a?(Ea::Qea::Models::EaObject)
+        return [] unless object.ea_guid
+
+        xrefs.select do |xr|
+          xr.client == object.ea_guid && xr.description&.include?("@STEREO")
+        end.map do |xr|
+          xr.description.match(/Name=([^;]+)/)[1]
+        end.compact
+      end
+      private :stereotype_names_for
+
+      # Materialize the filtered collection.
+      # @return [Array]
+      def call
+        records = model.collections[@kind] || []
+        records.select { |o| filters.all? { |f| f.call(o) } }
+      end
+
+      # Enumerable support.
+      include Enumerable
+
+      def each(&block)
+        call.each(&block)
+      end
+    end
+  end
+end

data/lib/ea/query.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Ea
+  # Query DSL namespace. Provides a chainable builder for filtering
+  # model elements. New predicates add new methods on the chain.
+  module Query
+    autoload :Builder, "ea/query/builder"
+  end
+end

data/lib/ea/render/image_converter.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Ea
+  module Render
+    # Converts SVG strings to PNG and PDF using available system
+    # tools. Detects `rsvg-convert`, ImageMagick `convert`, and
+    # headless Chrome (`chromium --headless`). Raises a clear error
+    # when no converter is available.
+    class ImageConverter
+      attr_reader :svg
+
+      # @param svg [String] SVG markup
+      def initialize(svg)
+        @svg = svg
+      end
+
+      # @return [String] PNG bytes
+      def to_png
+        with_tempfile(".svg") do |svg_path|
+          File.write(svg_path, svg)
+          convert(svg_path, :png)
+        end
+      end
+
+      # @return [String] PDF bytes
+      def to_pdf
+        with_tempfile(".svg") do |svg_path|
+          File.write(svg_path, svg)
+          convert(svg_path, :pdf)
+        end
+      end
+
+      # Returns the first available converter executable, or nil.
+      # @return [Symbol, nil] :rsvg_convert | :magick | :chrome
+      def self.available_converter
+        return :rsvg_convert if system("which rsvg-convert > /dev/null 2>&1")
+        return :magick if system("which convert > /dev/null 2>&1")
+        return :chrome if chromium_executable
+
+        nil
+      end
+
+      def self.chromium_executable
+        %w[chromium chromium-browser google-chrome
+           /Applications/Chromium.app/Contents/MacOS/Chromium
+           /Applications/Google\\ Chrome.app/Contents/MacOS/Google\\ Chrome]
+          .find { |exe| File.executable?(exe) || system("which #{exe} > /dev/null 2>&1") }
+      end
+
+      private
+
+      def convert(svg_path, target)
+        converter = self.class.available_converter
+        raise Ea::Cli::Error,
+              "No SVG→#{target.upcase} converter available. " \
+              "Install rsvg-convert (librsvg) or ImageMagick." unless converter
+
+        with_tempfile(".#{target}") do |out_path|
+          run_converter(converter, svg_path, out_path, target)
+          File.binread(out_path)
+        end
+      end
+
+      def run_converter(name, svg_path, out_path, target)
+        case name
+        when :rsvg_convert
+          format_flag = target == :pdf ? "-f pdf" : "-f png"
+          system("rsvg-convert #{format_flag} -o #{shell_quote(out_path)} " \
+                 "#{shell_quote(svg_path)}",
+                 exception: true)
+        when :magick
+          system("convert #{shell_quote(svg_path)} #{shell_quote(out_path)}",
+                 exception: true)
+        when :chrome
+          chrome = self.class.chromium_executable
+          system("#{shell_quote(chrome)} --headless --disable-gpu " \
+                 "--print-to-pdf=#{shell_quote(out_path)} " \
+                 "file://#{svg_path}",
+                 exception: true)
+        end
+      end
+
+      # Quote a path for safe inclusion in a shell command. Only
+      # handles paths without single quotes (sufficient for tempfile
+      # paths which are numeric IDs under /tmp).
+      def shell_quote(path)
+        "'#{path}'"
+      end
+
+      def with_tempfile(suffix)
+        require "tmpdir"
+        Dir.mktmpdir("ea-render-") do |dir|
+          path = File.join(dir, "input#{suffix}")
+          yield path
+        ensure
+          File.delete(path) if File.exist?(path)
+        end
+      end
+    end
+  end
+end

data/lib/ea/render.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Ea
+  # Conversion of SVG strings to raster/vector formats.
+  # Delegates to external tools (rsvg-convert, headless Chrome) when
+  # available; raises a clear error otherwise.
+  module Render
+    autoload :ImageConverter, "ea/render/image_converter"
+  end
+end

data/lib/ea/shapescript/parser.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module Ea
+  module Shapescript
+    # Tokenizer + parser for ShapeScript. Returns a list of Shape
+    # primitives extracted from a single shape body.
+    #
+    # Supported grammar (extended):
+    #
+    #   script        := statement*
+    #   statement     := shape | var_decl | primitive | if_stmt | label
+    #   shape         := "shape" identifier "{" statement* "}"
+    #   var_decl      := "var" identifier "=" expr ";"
+    #   primitive     := call "(" args ")" ";"
+    #   call          := "rectangle" | "ellipse" | "polygon" |
+    #                    "line" | "path" | "label"
+    #   args          := expr ("," expr)*
+    #   if_stmt       := "if" "(" expr ")" "{" statement* "}"
+    #                    ("else" "{" statement* "}")?
+    #   expr          := identifier | number | string | binop
+    #
+    # Variables are resolved at parse time when possible; otherwise
+    # the identifier is left as a string for late binding.
+    module Parser
+      module_function
+
+      # @param source [String] ShapeScript source
+      # @return [Array<Shape>] flat list of all primitives across
+      #   all shapes in the source. Shape nesting is flattened.
+      #   Variables, conditionals, and labels are resolved/inlined
+      #   where possible; unresolvable expressions are skipped.
+      def parse(source)
+        return [] if source.nil? || source.empty?
+
+        tokens = tokenize(source)
+        env = {}
+        shapes = []
+        consume_statements(tokens, env, shapes)
+        shapes
+      end
+
+      # -- Tokenizer ---------------------------------------------------
+
+      def tokenize(source)
+        clean = source.gsub(%r{//[^\n]*}, "")
+                      .gsub(/\/\*.*?\*\//m, "")
+        clean.scan(/[A-Za-z_][A-Za-z0-9_]*|-?\d+\.?\d*|"[^"]*"|'[^']*'|[{}(),;=+\-*\/]/)
+      end
+
+      # Consume statements until matching close brace or end.
+      def consume_statements(tokens, env, shapes, top_level: true)
+        until tokens.empty?
+          tok = tokens.first
+          if tok == "}"
+            tokens.shift if top_level == false
+            break
+          end
+
+          tokens.shift # consume tok
+          case tok
+          when "shape"
+            _name = tokens.shift
+            _open = tokens.shift # "{"
+            consume_statements(tokens, env.dup, shapes, top_level: false)
+          when "var"
+            consume_var_decl(tokens, env)
+          when "if"
+            consume_if(tokens, env, shapes)
+          when "label"
+            shapes << consume_label(tokens, env)
+          else
+            shapes << consume_primitive(tok, tokens, env) if PRIMITIVES.key?(tok)
+          end
+        end
+      end
+
+      PRIMITIVES = {
+        "rectangle" => :rectangle,
+        "ellipse" => :ellipse,
+        "polygon" => :polygon,
+        "line" => :line,
+        "path" => :path
+      }.freeze
+
+      def consume_primitive(name, tokens, env)
+        kind = PRIMITIVES[name]
+        open_paren = tokens.shift # "("
+        params = []
+        if open_paren == "("
+          until tokens.empty?
+            tok = tokens.shift
+            break if tok == ")"
+
+            value = resolve_expr(tok, tokens, env)
+            params << value if value.is_a?(Numeric)
+          end
+        end
+        consume_semicolon(tokens)
+        Shape.new(kind: kind, params: params)
+      end
+
+      def consume_label(tokens, env)
+        tokens.shift # "("
+        text = tokens.shift
+        text = text.to_s.gsub(/\A["']|["']\z/, "")
+        tokens.shift until tokens.empty? || tokens.first == ")"
+        tokens.shift # ")"
+        consume_semicolon(tokens)
+        Shape.new(kind: :label, params: [text])
+      end
+
+      def consume_var_decl(tokens, env)
+        name = tokens.shift
+        eq = tokens.shift # "="
+        value = resolve_expr(tokens.shift, tokens, env)
+        consume_semicolon(tokens)
+        env[name] = value if value.is_a?(Numeric) || value.is_a?(String)
+      end
+
+      def consume_if(tokens, env, then_shapes)
+        tokens.shift # "("
+        condition = resolve_expr(tokens.shift, tokens, env)
+        tokens.shift until tokens.empty? || tokens.first == ")"
+        tokens.shift # ")"
+        tokens.shift # "{"
+
+        # Evaluate condition; if true, consume then-block into shapes.
+        # If false, skip then-block and consume optional else.
+        truthy = condition == true || (condition.is_a?(Numeric) && condition.nonzero?)
+        if truthy
+          consume_statements(tokens, env, then_shapes, top_level: false)
+        else
+          skip_block(tokens)
+          if tokens.first == "else"
+            tokens.shift
+            tokens.shift # "{"
+            consume_statements(tokens, env, then_shapes, top_level: false)
+          end
+        end
+      end
+
+      def skip_block(tokens)
+        tokens.shift # "{"
+        depth = 1
+        until tokens.empty? || depth.zero?
+          t = tokens.shift
+          depth += 1 if t == "{"
+          depth -= 1 if t == "}"
+        end
+      end
+
+      def consume_semicolon(tokens)
+        tokens.shift if tokens.first == ";"
+      end
+
+      # Resolve an expression to a value. Returns Numeric/String/Boolean
+      # or nil when unresolvable. Handles simple binary ops (+, -, *, /).
+      def resolve_expr(tok, tokens, env)
+        return nil unless tok
+
+        # Parenthesized sub-expression
+        if tok == "("
+          value = resolve_expr(tokens.shift, tokens, env)
+          tokens.shift if tokens.first == ")"
+          return value
+        end
+
+        # Numeric literal
+        return tok.to_i if tok.match?(/\A-?\d+\z/)
+        return tok.to_f if tok.match?(/\A-?\d+\.\d+\z/)
+
+        # String literal
+        return tok[1..-2] if tok.match?(/\A["'].*["']\z/)
+
+        # Boolean literals
+        return true if tok == "true"
+        return false if tok == "false"
+
+        # Variable reference
+        if env.key?(tok)
+          value = env[tok]
+          # Look ahead for binary op
+          if %w[+ - * /].include?(tokens.first)
+            op = tokens.shift
+            rhs = resolve_expr(tokens.shift, tokens, env)
+            return apply_binop(op, value, rhs)
+          end
+          return value
+        end
+
+        # Bare identifier (function call? hasproperty? — leave as nil
+        # for now; treat as false in conditionals).
+        nil
+      end
+
+      def apply_binop(op, left, right)
+        return nil unless left.is_a?(Numeric) && right.is_a?(Numeric)
+
+        case op
+        when "+" then left + right
+        when "-" then left - right
+        when "*" then left * right
+        when "/" then left / right
+        end
+      end
+    end
+  end
+end

data/lib/ea/shapescript/renderer.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Ea
+  module Shapescript
+    # Renders a list of parsed Shape primitives to SVG elements as
+    # a single string. Coordinates are emitted as-is — callers
+    # should wrap in a `<g>` with the appropriate transform if they
+    # want to position the icon.
+    module Renderer
+      module_function
+
+      # @param shapes [Array<Shape>]
+      # @param fill [String] SVG fill color
+      # @param stroke [String] SVG stroke color
+      # @return [String] SVG fragment with one element per shape
+      def render(shapes, fill: "#FFFFFF", stroke: "#000000")
+        return "" if shapes.nil? || shapes.empty?
+
+        shapes.map { |s| render_one(s, fill: fill, stroke: stroke) }.join("\n")
+      end
+
+      def render_one(shape, fill:, stroke:)
+        case shape.kind
+        when :rectangle then render_rect(shape.params, fill, stroke)
+        when :ellipse then render_ellipse(shape.params, fill, stroke)
+        when :polygon then render_polygon(shape.params, fill, stroke)
+        when :line then render_line(shape.params, stroke)
+        when :path then render_path(shape.params, stroke)
+        when :label then render_label(shape.params, fill)
+        end
+      end
+
+      def render_label(p, fill)
+        text = p.first.to_s
+        %(<text x="0" y="0" fill="#{fill}">#{escape(text)}</text>)
+      end
+
+      def escape(text)
+        text.to_s.gsub("&", "&amp;")
+             .gsub("<", "&lt;")
+             .gsub(">", "&gt;")
+      end
+
+      def render_rect(p, fill, stroke)
+        x, y, w, h = p
+        %(<rect x="#{x}" y="#{y}" width="#{w}" height="#{h}" fill="#{fill}" stroke="#{stroke}"/>)
+      end
+
+      def render_ellipse(p, fill, stroke)
+        cx, cy, rx, ry = p
+        %(<ellipse cx="#{cx}" cy="#{cy}" rx="#{rx}" ry="#{ry}" fill="#{fill}" stroke="#{stroke}"/>)
+      end
+
+      def render_polygon(p, fill, stroke)
+        points = p.each_slice(2).map { |x, y| "#{x},#{y}" }.join(" ")
+        %(<polygon points="#{points}" fill="#{fill}" stroke="#{stroke}"/>)
+      end
+
+      def render_line(p, stroke)
+        x1, y1, x2, y2 = p
+        %(<line x1="#{x1}" y1="#{y1}" x2="#{x2}" y2="#{y2}" stroke="#{stroke}"/>)
+      end
+
+      def render_path(p, stroke)
+        return "" if p.empty?
+
+        x, y = p.shift(2)
+        d = "M #{x} #{y}"
+        p.each_slice(2) { |px, py| d += " L #{px} #{py}" }
+        %(<path d="#{d}" fill="none" stroke="#{stroke}"/>)
+      end
+    end
+  end
+end

data/lib/ea/shapescript/shape.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Ea
+  module Shapescript
+    # One rendered shape primitive. Carries type + params
+    # ready for SVG emission.
+    Shape = Struct.new(:kind, :params, keyword_init: true) do
+      # @return [Boolean] true when this shape is a rectangle
+      def rectangle?
+        kind == :rectangle
+      end
+
+      def ellipse?
+        kind == :ellipse
+      end
+
+      def polygon?
+        kind == :polygon
+      end
+
+      def line?
+        kind == :line
+      end
+
+      def path?
+        kind == :path
+      end
+
+      def label?
+        kind == :label
+      end
+    end
+  end
+end

data/lib/ea/shapescript.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Ea
+  # ShapeScript interpreter namespace.
+  #
+  # EA's MDG technologies define stereotype icon decorations via a
+  # domain-specific language called ShapeScript. This is a basic
+  # interpreter supporting the core shape primitives:
+  #
+  #   shape <Name> { ... }
+  #   rectangle(left, top, right, bottom);
+  #   ellipse(left, top, right, bottom);
+  #   polygon(x1, y1, x2, y2, ..., xN, yN);
+  #   line(x1, y1, x2, y2);
+  #   path(x1, y1, x2, y2, ...);
+  #
+  # Compound features (conditionals, variables, color references)
+  # are out of scope for this basic interpreter.
+  module Shapescript
+    autoload :Parser, "ea/shapescript/parser"
+    autoload :Renderer, "ea/shapescript/renderer"
+    autoload :Shape, "ea/shapescript/shape"
+  end
+end