ea 0.6.40 → 0.6.41

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 164d7f4eec0c15cd5811283a701759887c6b7431337dd9160506d87c9a9ab673
-  data.tar.gz: 603a2def1016cee9b7747c6131d6e815be09c566d8d4325bc0109d71565b9b5f
+  metadata.gz: 648d534db9bc161659ceb4fb001a91dd027c2de38714d64b757ade37728c9608
+  data.tar.gz: ad4addbbbc6e2695b44df97431779acd1cf561d2f4e42c20f64dca60eae11230
 SHA512:
-  metadata.gz: bcdeea949d117ea448e114300f8f3114d78000fd0212a4e2428e120084957df3bf309fe0bea278303432133c3f91168177b43fab6483088f56df26a7d0cc33f4
-  data.tar.gz: 847c43fba07dd14374d031f80731cf10656ebb2e1e63f5674a5c0414dffc1024bba9b7e8026a62f93f17a24921cd7ef5da30b9cb2cec1c598f02b6e76e2321d1
+  metadata.gz: 5c0d526857ccf9c8c78eca78e954f8cc4332c7abaa8311c53559ded2bb78dbee599e7e2ec800f997108310078f58115e269bee8aed700295922f08b196fd96f8
+  data.tar.gz: 63def8e36e609ff0b1a7dc735ae27ae4518de1394009d1c847ecea14da6451ae3e32e40d90c5f8d00bc9795262bc7f85615a1575c23132f0ff46c42dca53e9c7

data/README.adoc

@@ -35,6 +35,42 @@ db = Ea.parse("model.qea")   #=> Ea::Qea::Database
 puts "#{db.packages.size} packages, #{db.objects.size} objects"
 ----
 
+=== Whole and partial XMI loading (pure — no lutaml-uml needed)
+
+`Ea::Xmi.load` parses an EA XMI export into the typed Sparx model.
+Whole load is the default and parses the entire file:
+
+[source,ruby]
+----
+require "ea/xmi"
+
+model = Ea::Xmi.load("export.xmi")
+----
+
+Partial load parses only the reference closure of the named elements.
+The wanted pairs are `[package, name]`; a nil package matches by name
+in any package. The closure is assembled in memory by
+`Ea::Xmi::Slicer` — the export is streamed once, no temporary files
+are written, and the parse runs over the slice:
+
+[source,ruby]
+----
+model = Ea::Xmi.load("export.xmi", partial: [["bldg", "Building"]])
+----
+
+Partial load produces the same content as whole load for everything
+derived from the model's elements: the slice keeps each wanted class
+with its attributes, operations, connectors, generalization parents,
+package ancestry, and the diagrams that reference kept elements. Use
+it when reading a handful of classes out of a large export — a
+100 MB export parses as a few MB slice instead of a 10+ GB object
+graph.
+
+`Ea::Xmi.load_graph` wraps the same two modes one layer up, returning
+the parsed EA graph: the parser, the parsed document, and the lookup
+indexes the table renders resolve through
+(`Ea::Xmi::Loaded`).
+
 === Generate a SPA from QEA (requires lutaml-uml)
 
 [source,bash]

data/lib/ea/svg/ea_emitter/element/header_line_pipeline.rb

@@ -37,6 +37,36 @@ module Ea
             context = Context.new(classifier: classifier, **opts)
             PROVIDERS.flat_map { |provider| provider.call(context) }
           end
+
+          # Greedy word wrap measured with the header's own font.
+          # EA wraps overflowing headers at word boundaries
+          # (81F92FC7: instance header "new ownership: LA_Right"
+          # renders as "new ownership:" / "LA_Right").
+          def self.wrap_words(text, context, weight)
+            font_style = weight == :bold_italic ? "italic" : "normal"
+            width = lambda do |s|
+              TextRenderer.estimate_width(
+                s, context.font_size || 9, nil,
+                family: context.family, weight: "700", style: font_style
+              ).round
+            end
+            return [text] if context.bounds_width.nil?
+            return [text] if width.call(text) <= context.bounds_width.to_i
+
+            lines = []
+            current = +""
+            text.split(" ").each do |word|
+              candidate = current.empty? ? word : "#{current} #{word}"
+              if !current.empty? && width.call(candidate) > context.bounds_width.to_i
+                lines << current
+                current = word
+              else
+                current = candidate
+              end
+            end
+            lines << current unless current.empty?
+            lines
+          end
         end
       end
     end

data/lib/ea/svg/ea_emitter/element/header_line_provider/instance_spec.rb

@@ -6,8 +6,9 @@ module Ea
       module Element
         module HeaderLineProvider
           # InstanceSpecification: short-circuits the pipeline. The
-          # entire header for an instance is "name: Classifier" on
-          # one bold line. No stereotype, no wrap, no parent ghost.
+          # header for an instance is "name: Classifier" on one bold
+          # line, word-wrapped when it overflows the box (81F92FC7:
+          # "new ownership:" / "LA_Right").
           class InstanceSpec
             def self.call(context)
               inst = context.classifier
@@ -17,7 +18,9 @@ module Ea
               if inst.classifier_name && !inst.classifier_name.empty?
                 label = "#{label}: #{inst.classifier_name}"
               end
-              [[label, :bold]]
+              HeaderLinePipeline.wrap_words(label, context, :bold).map do |line|
+                [line, :bold]
+              end
             end
           end
         end

data/lib/ea/svg/ea_emitter/element/header_line_provider/name.rb

@@ -38,13 +38,18 @@ module Ea
             def self.wrapped_name_lines(classifier, context, weight)
               name = display_name(classifier)
               name = "#{context.foreign_package_name}::#{name}" if context.foreign_package_name
-              unless context.bounds_width && name.include?("::") &&
-                     name_exceeds_bounds?(name, context, weight)
+              unless context.bounds_width && name_exceeds_bounds?(name, context, weight)
                 return [[name, weight]]
               end
 
-              qualifier, base = name.split("::", 2)
-              [["#{qualifier}::", weight], [base, weight]]
+              if name.include?("::")
+                qualifier, base = name.split("::", 2)
+                [["#{qualifier}::", weight], [base, weight]]
+              else
+                HeaderLinePipeline.wrap_words(name, context, weight).map do |line|
+                  [line, weight]
+                end
+              end
             end
 
             def self.name_exceeds_bounds?(name, context, weight)

data/lib/ea/version.rb

@@ -4,5 +4,5 @@ module Ea
   # Gem release version. Extracted to its own file so the
   # `gem-release` tool's `gem bump` can find and update it via the
   # standard `lib/<gem>/version.rb` convention.
-  VERSION = "0.6.40"
+  VERSION = "0.6.41"
 end

data/lib/ea/xmi/loader.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "xmi"
+
+module Ea
+  module Xmi
+    # The result of loading an export into the EA graph: the parser,
+    # the parsed document, and the indexes the consumers resolve
+    # through.
+    Loaded = Struct.new(:parser, :uml_document, :drop_options,
+                        :xmi_id_index, keyword_init: true)
+
+    module Loader
+      # Whole load parses the entire export. Partial load parses only
+      # the reference closure of the wanted [package, name] pairs,
+      # assembled in memory by Ea::Xmi::Slicer - no temporary files.
+      # Both modes produce identical content for everything derived
+      # from the model's elements; partial load exists so a consumer
+      # reading a handful of classes out of a large export never has
+      # to hydrate the whole of it. package may be nil, matching by
+      # name in any package.
+      def self.call(source, partial: nil)
+        xml = read(source)
+        xml = Slicer.slice(xml, partial) if partial
+        ::Xmi::Sparx::Root.parse_xml(xml)
+      end
+
+      def self.graph(source, partial: nil)
+        parser = Parser.new
+        uml_document = parser.parse(call(source, partial: partial))
+        Loaded.new(
+          parser: parser,
+          uml_document: uml_document,
+          drop_options: build_drop_options(parser),
+          xmi_id_index: build_xmi_id_index(uml_document),
+        )
+      end
+
+      def self.read(source)
+        source.respond_to?(:read) ? source.read : File.read(source.to_s)
+      end
+
+      def self.build_drop_options(parser)
+        lookup = LookupService.new(parser)
+        {
+          xmi_root_model: parser.xmi_root_model,
+          id_name_mapping: parser.id_name_mapping,
+          lookup: lookup,
+          with_gen: true,
+          with_assoc: true,
+          with_absolute_path: true,
+        }
+      end
+
+      # One xmi_id -> node walk per parse.
+      def self.build_xmi_id_index(uml_document)
+        index = {}
+        collect = lambda do |container|
+          index[container.xmi_id] ||= container if container.respond_to?(:xmi_id)
+          if container.respond_to?(:classes)
+            container.classes.each { |n| index[n.xmi_id] ||= n }
+          end
+          if container.respond_to?(:data_types)
+            container.data_types.each { |n| index[n.xmi_id] ||= n }
+          end
+          if container.respond_to?(:enums)
+            container.enums.each { |n| index[n.xmi_id] ||= n }
+          end
+          (container.packages || []).each { |p| collect.call(p) } if container.respond_to?(:packages)
+        end
+        collect.call(uml_document)
+        index
+      end
+    end
+  end
+end

data/lib/ea/xmi/slicer.rb

@@ -0,0 +1,412 @@
+# frozen_string_literal: true
+
+require "moxml"
+require "stringio"
+
+module Ea
+  module Xmi
+    # Prunes an EA XMI export to the subgraphs reachable from sets of
+    # (package name, element name) pairs, so the existing parse pipeline
+    # hydrates small slices instead of the whole export. A plateau-scale
+    # export is 98 MB, more than half of it diagram presentation data
+    # that no table reads, and materializing the whole Xmi tree plus the
+    # Ea graph costs 10+ GB of live objects.
+    #
+    # The closure is generic: every attribute value that looks like an EA
+    # element id (EAID_/EAPK_/EAEM_) found anywhere inside a kept
+    # element's subtree keeps the referenced element too, transitively -
+    # no XMI semantics are encoded here. Only container tags are
+    # membership-gated (packagedElement in the model, element and
+    # connector in the extension); anything nested inside a kept
+    # container is copied verbatim. The diagrams section is dropped.
+    #
+    # `slices` performs one index pass and one write pass and emits one
+    # standalone slice per requested group, so each consumer (one macro,
+    # one class table) hydrates only its own class's subgraph: the
+    # per-parse peak is the size of one slice, not of the export.
+    class Slicer
+      EA_ID_RE = /\A(?:EAID|EAPK|EAEM)_[0-9A-Za-z_]+\z/
+      private_constant :EA_ID_RE
+
+      XML_DECL = %(<?xml version="1.0" encoding="UTF-8"?>\n)
+      private_constant :XML_DECL
+
+      # SAX passes over ~100 MB EA exports fire millions of events whose
+      # per-event strings and hashes outrun the collector (malloc grows
+      # for GBs before an automatic cycle). Collect at a fixed event
+      # cadence once the malloc budget is blown.
+      GC_BUDGET_BYTES = 512 * 1024 * 1024
+      private_constant :GC_BUDGET_BYTES
+
+      def self.gc_when_bloated
+        GC.start if GC.stat(:malloc_increase_bytes) > GC_BUDGET_BYTES
+      end
+
+      # Containers whose membership is gated against the keep set, by
+      # document section. umldi:Diagram carries the embedded diagram
+      # shapes (tens of MB with waypoints and bounds in an EA export)
+      # and is never referenced by table content, so it gates on the
+      # keep set as well.
+      GATED = {
+        model: ["packagedElement", "umldi:Diagram"].freeze,
+        elements: ["element"].freeze,
+        connectors: ["connector"].freeze,
+        diagrams: ["diagram"].freeze,
+      }.freeze
+      private_constant :GATED
+
+      SECTION_CHILD = {
+        "elements" => :elements,
+        "connectors" => :connectors,
+        "diagrams" => :drop,
+        "profiles" => :drop,
+      }.freeze
+      private_constant :SECTION_CHILD
+
+      Node = Struct.new(:id, :tag, :xmi_type, :name, :parent_id, :section,
+                        :refs, :links_refs, keyword_init: true)
+
+      class << self
+        # Single slice for one wanted set, as a string: the in-memory
+        # form partial loading consumes.
+        # wanted: array of [package_name, element_name]; package may be
+        # nil, in which case elements match by name in any package.
+        def slice(source, wanted)
+          new(source).single(wanted)
+        end
+
+        # One index pass, one write pass, one standalone slice per
+        # group, returned as strings. groups: hash key => wanted array
+        # (same shape as +wanted+ above). Groups whose wanted set
+        # matches nothing are skipped entirely, so callers can fall
+        # back to the full source for them.
+        def slices(source, groups)
+          new(source).multi(groups)
+        end
+      end
+
+      def initialize(source)
+        @source = source
+        @moxml = Moxml.new(:leptris)
+      end
+
+      def single(wanted)
+        nodes = index_pass
+        keep = closure(nodes, seed_ids(nodes, wanted))
+        output = StringIO.new(+"")
+        writer = GroupWriter.new([keep], [output])
+        @moxml.sax_parse(source_string, writer)
+        output.string
+      end
+
+      def multi(groups)
+        nodes = index_pass
+        keeps = []
+        keys = []
+        groups.each do |key, wanted|
+          seeds = seed_ids(nodes, wanted)
+          next if seeds.empty?
+
+          keeps << closure(nodes, seeds)
+          keys << key
+        end
+        outputs = keys.map { StringIO.new(+"") }
+        @moxml.sax_parse(source_string, GroupWriter.new(keeps, outputs))
+        keys.zip(outputs).to_h { |k, o| [k, o.string] }
+      end
+
+      private
+
+      # --- pass one: index id-bearing containers and their references --
+
+      class IndexHandler < ::Moxml::SAX::Handler
+        attr_reader :nodes
+
+        def initialize
+          @nodes = {}
+          @stack = [] # [id_or_nil, shared_refs_array]
+          @section = []
+          @refs_off = 0
+          @events = 0
+          @links_depth = 0
+        end
+
+        # Only gated containers become nodes (packagedElement in the
+        # model, element and connector in the extension, and the
+        # embedded umldi:Diagram blocks). Other id-bearing elements -
+        # `<type xmi:idref>`, `<model package>` and the like - are pure
+        # references: recording them as nodes would let a reference
+        # define the element's ancestry, so their EA-id values flow into
+        # the enclosing container's reference set instead.
+        def on_start_element(name, attributes = {}, _namespaces = {})
+          Slicer.gc_when_bloated if (@events += 1) % 50_000 == 0
+          @section << section_for(name, @section.last)
+          @refs_off += 1 if name == "links"
+          @links_depth += 1 if name == "links"
+          id = attributes["xmi:id"] || attributes["xmi:idref"]
+          is_node = id && GATED.fetch(@section.last, []).include?(name)
+          if is_node && (existing = @nodes[id])
+            # A container id occurs twice in an EA export: as the model
+            # element (uml:Model subtree) and as the extension entry
+            # keyed by xmi:idref. Merge so one node carries the model
+            # ancestry and both occurrences' references; the entry
+            # usually carries the name.
+            existing.name ||= attributes["name"]
+            existing.xmi_type ||= attributes["xmi:type"]
+            collect_refs(attributes, existing.refs)
+            @stack << [id, existing.refs]
+            return
+          end
+          # the parent is the nearest id-bearing element already on the
+          # stack, so it has to be read before this element is pushed
+          parent = nearest_id
+          refs = is_node ? [] : (@stack.last ? @stack.last[1] : [])
+          @stack << [is_node ? id : nil, refs]
+          unless is_node
+            collect_refs(attributes, refs)
+            return
+          end
+
+          node = Node.new(
+            id: id, tag: name,
+            xmi_type: attributes["xmi:type"], name: attributes["name"],
+            parent_id: parent, section: @section.last, refs: refs,
+            links_refs: [],
+          )
+          @nodes[id] = node
+          collect_refs(attributes, node.refs)
+          collect_refs(attributes, node.links_refs) if @links_depth.positive?
+          node
+        end
+
+        def on_end_element(name)
+          @refs_off -= 1 if name == "links"
+          @links_depth -= 1 if name == "links" && @links_depth.positive?
+          @stack.pop
+          @section.pop
+        end
+
+        private
+
+        def nearest_id
+          @stack.reverse_each do |id, _|
+            return id if id
+          end
+          nil
+        end
+
+        def section_for(name, current)
+          return :model if name == "uml:Model"
+          return :extension if name == "xmi:Extension"
+
+          if current == :extension
+            SECTION_CHILD[name] || :drop
+          elsif current == :drop
+            :drop
+          else
+            current
+          end
+        end
+
+        # The links blocks inside extension entries restate every
+        # relation's endpoints; the connector records in the connectors
+        # section already carry both ends, so collecting from links
+        # would pull the endpoint classes of every relation into the
+        # closure transitively (half the model per class).
+        def collect_refs(attributes, refs)
+          return if @refs_off.positive?
+
+          attributes.each_value do |v|
+            refs << v if v.is_a?(String) && v.match?(EA_ID_RE)
+          end
+        end
+      end
+
+      def index_pass
+        handler = IndexHandler.new
+        @moxml.sax_parse(source_string, handler)
+        handler.nodes
+      end
+
+      def source_string
+        case @source
+        when IO, StringIO
+          @source.read
+        else
+          s = @source.to_s
+          # partial loading hands us the export content itself; a path
+          # never starts with markup
+          s.lstrip.start_with?("<") ? s : File.read(s)
+        end
+      end
+
+      # --- closure ------------------------------------------------------
+
+      def closure(nodes, seeds)
+        keep = {}
+        frontier = seeds.map { |i| [i, false] }
+        until frontier.empty?
+          id, via_links = frontier.pop
+          next if keep[id]
+
+          node = nodes[id]
+          next unless node
+          # links references only buy the connector record they name;
+          # following them further pulled every relation's endpoints
+          # into a class's closure (half the model per class)
+          next if via_links && node.section != :connectors
+
+          keep[id] = true
+          node.refs.each { |r| frontier << [r, false] }
+          node.links_refs.each { |r| frontier << [r, true] }
+          # keeping a model element keeps its package ancestry
+          if node.section == :model
+            anc = nodes[node.parent_id]
+            while anc && !keep[anc.id]
+              keep[anc.id] = true
+              anc.refs.each { |r| frontier << [r, false] } unless anc.section == :model
+              anc = nodes[anc.parent_id]
+            end
+          end
+        end
+        keep_diagrams(nodes, keep)
+        keep
+      end
+
+      # The klass tables embed each class's EA diagram; diagrams point
+      # INTO the model (their shapes carry modelElement ids), a
+      # direction the closure never walks, so diagrams whose shapes
+      # reference kept elements are kept in a second pass.
+      def keep_diagrams(nodes, keep)
+        nodes.each_value do |n|
+          next unless n.section == :diagrams && n.tag == "diagram" ||
+                      (n.section == :model && n.xmi_type == "umldi:Diagram")
+
+          keep[n.id] = true if n.refs.any? { |r| keep[r] } ||
+                               n.links_refs.any? { |r| keep[r] }
+        end
+      end
+
+      def seed_ids(nodes, wanted)
+        seeds = []
+        wanted.each do |package, name|
+          named = nodes.values.select { |n| n.name == name }
+          next if named.empty?
+
+          # package-anchored matches first; consumers resolve by name,
+          # so when no package chain matches, every same-named element
+          # is seeded and the resolver picks among them as usual
+          anchored = package ? named.select { |n| under_package?(n, package, nodes) } : []
+          (anchored.empty? ? named : anchored).each { |n| seeds << n.id }
+        end
+        seeds.uniq
+      end
+
+      def under_package?(node, package, nodes)
+        anc = nodes[node.parent_id]
+        while anc && anc.id != node.id
+          return true if anc.name == package && anc.xmi_type == "uml:Package"
+
+          anc = nodes[anc.parent_id]
+        end
+        false
+      end
+
+      # --- pass two: re-serialize the kept subtrees, per group ----------
+
+      class GroupWriter < ::Moxml::SAX::Handler
+        def initialize(keeps, outputs)
+          @keeps = keeps
+          @outputs = outputs
+          @open = []   # [name, keys] - keys = group indexes keeping this element
+          @section = []
+          @events = 0
+        end
+
+        def on_start_document
+          @outputs.each { |io| io << XML_DECL }
+        end
+
+        def on_start_element(name, attributes = {}, namespaces = {})
+          Slicer.gc_when_bloated if (@events += 1) % 50_000 == 0
+          section = section_for(name, @section.last)
+          @section << section
+          parent_keys = @open.empty? ? (0...@keeps.size).to_a : @open.last[1]
+          keys =
+            if section == :drop
+              []
+            elsif GATED[section]&.include?(name)
+              id = attributes["xmi:id"] || attributes["xmi:idref"]
+              if id
+                parent_keys.select { |i| @keeps[i][id] }
+              else
+                parent_keys.dup
+              end
+            else
+              parent_keys
+            end
+          @open << [name, keys]
+          return if keys.empty?
+
+          tag = +"<#{name}"
+          namespaces.each { |p, u| tag << %( xmlns:#{p}="#{esc_attr(u)}") }
+          attributes.each { |k, v| tag << %( #{k}="#{esc_attr(v)}") }
+          tag << ">"
+          keys.each { |i| @outputs[i] << tag }
+        end
+
+        def on_end_element(name)
+          frame = @open.pop
+          @section.pop
+          frame[1].each { |i| @outputs[i] << "</#{name}>" } unless frame[1].empty?
+        end
+
+        def on_characters(text)
+          return if @open.empty? || @open.last[1].empty?
+
+          escaped = esc_text(text)
+          @open.last[1].each { |i| @outputs[i] << escaped }
+        end
+
+        def on_cdata(text)
+          return if @open.empty? || @open.last[1].empty?
+
+          chunk = "<![CDATA[#{text}]]>"
+          @open.last[1].each { |i| @outputs[i] << chunk }
+        end
+
+        private
+
+        def section_for(name, current)
+          return :model if name == "uml:Model"
+          return :extension if name == "xmi:Extension"
+
+          if current == :extension
+            SECTION_CHILD[name] || :drop
+          elsif current == :drop
+            :drop
+          else
+            current
+          end
+        end
+
+        # XML attribute-value normalization folds raw newlines and tabs
+        # into spaces, which would flatten the asciidoc block structure
+        # EA stores inside documentation attributes; character
+        # references survive normalization, so emit those instead
+        def esc_attr(value)
+          value.gsub(/[&<>"\n\r\t]/) do |c|
+            { "&" => "&amp;", "<" => "&lt;", ">" => "&gt;", '"' => "&quot;",
+              "\n" => "&#xA;", "\r" => "&#xD;", "\t" => "&#x9;" }[c]
+          end
+        end
+
+        def esc_text(value)
+          value.gsub(/[&<>]/) do |c|
+            { "&" => "&amp;", "<" => "&lt;", ">" => "&gt;" }[c]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/xmi.rb

@@ -9,6 +9,9 @@ module Ea
   module Xmi
     autoload :Parser, "ea/xmi/parser"
     autoload :LookupService, "ea/xmi/lookup_service"
+    autoload :Slicer, "ea/xmi/slicer"
+    autoload :Loader, "ea/xmi/loader"
+    autoload :Loaded, "ea/xmi/loader"
 
     module LiquidDrops
       autoload :RootDrop, "ea/xmi/liquid_drops/root_drop"
@@ -43,10 +46,27 @@ module Ea
     # To get a `Lutaml::Uml::Document` instead (requires the optional
     # `lutaml-uml` gem), use `Ea::Bridge::XmiToUml.transform(root)`.
     #
-    # @param path [String] path to a .xmi file
+    # @param path [String, IO] path to a .xmi file, or an IO
+    # @param partial [Array, nil] wanted [package, name] pairs; when
+    #   given, only the reference closure of those elements is parsed,
+    #   assembled in memory (see Ea::Xmi::Slicer). Partial load
+    #   produces the same content as whole load for everything derived
+    #   from the model's elements; it exists so reading a handful of
+    #   classes out of a large export does not hydrate the whole of
+    #   it. Whole load is the default. package may be nil, matching by
+    #   name in any package.
     # @return [Xmi::Sparx::Root]
-    def load(path)
-      ::Xmi::Sparx::Root.parse_xml(File.read(path))
+    def load(path, partial: nil)
+      Loader.call(path, partial: partial)
+    end
+
+    # Load an export into the parsed EA graph: the parser, the parsed
+    # document, and the lookup indexes the table renders resolve
+    # through. See #load for whole vs partial loading.
+    #
+    # @return [Ea::Xmi::Loaded]
+    def load_graph(path, partial: nil)
+      Loader.graph(path, partial: partial)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.6.40
+  version: 0.6.41
 platform: ruby
 authors:
 - Ribose Inc.
@@ -999,8 +999,10 @@ files:
 - lib/ea/xmi/liquid_drops/package_drop.rb
 - lib/ea/xmi/liquid_drops/root_drop.rb
 - lib/ea/xmi/liquid_drops/source_target_drop.rb
+- lib/ea/xmi/loader.rb
 - lib/ea/xmi/lookup_service.rb
 - lib/ea/xmi/parser.rb
+- lib/ea/xmi/slicer.rb
 - lib/ea/xml_escape.rb
 - lib/tasks/fonts.rake
 - lib/tasks/svg_bench.rake