ea 0.6.138 → 0.6.140

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

@@ -9,6 +9,8 @@ module Ea
         # dog-eared rectangle (top-right corner folded in) with the
         # note text wrapped inside.
         #
+        # Native EA emits the body and the folded corner as two polygons.
+        #
         # Layout:
         #
         #   ┌──────────────────┐
@@ -19,15 +21,32 @@ module Ea
         #
         class NoteShapeRenderer
           FOLD_SIZE = 12
+          FOLD_FILL = "#DCDCDC"
           TEXT_X_OFFSET = 5
           TEXT_Y_OFFSET = 12
           LINE_HEIGHT = 12
 
-          def self.render(bounds, body:, fill:, stroke:, stroke_width:, family:, size:, text_fill:)
-            new(bounds, body, fill, stroke, stroke_width, family, size, text_fill).to_svg
+          # EA never sets the note pen: the outline takes the cap and join
+          # left by the previous drawing, or the initial pen (square/miter)
+          # when the note is the first thing painted. Checked on all six
+          # native notes: 7C44AC09 first (square/miter), 7D960BD8 after
+          # square/bevel icons (square/bevel), 676B9C9A, 926AFE38, 9DA6C553
+          # and C028B286 after round/bevel shapes (round/bevel).
+          INITIAL_PEN = %w[square miter].freeze
+          PEN_PATTERN = /stroke-linecap:(\w+);stroke-linejoin:(\w+)/
+
+          # The [cap, join] a rendered group leaves behind, or nil.
+          def self.pen_of(group)
+            match = PEN_PATTERN.match(group.to_s)
+            match&.captures
           end
 
-          def initialize(bounds, body, fill, stroke, stroke_width, family, size, text_fill)
+          def self.render(bounds, body:, fill:, stroke:, stroke_width:, family:, size:, text_fill:, pen: nil)
+            new(bounds, body, fill, stroke, stroke_width, family, size, text_fill, pen || INITIAL_PEN).to_svg
+          end
+
+          def initialize(bounds, body, fill, stroke, stroke_width, family, size, text_fill, pen)
+            @pen = pen
             @bounds = bounds
             @body = body.to_s
             @fill = fill
@@ -39,7 +58,7 @@ module Ea
           end
 
           def to_svg
-            %(<g style="#{group_style}">\n  #{path_body}\n  #{fold_line}\n  #{text_block}\n</g>)
+            [body_layer, fold_layer, text_layer].reject(&:empty?).join("\n")
           end
 
           private
@@ -47,39 +66,52 @@ module Ea
           attr_reader :bounds, :body, :fill, :stroke, :stroke_width,
                       :family, :size, :text_fill
 
-          def group_style
-            "stroke-width:#{stroke_width};stroke-linecap:square;stroke-linejoin:bevel; " \
-              "fill:#{fill};fill-opacity:1.00; stroke:#{stroke}; stroke-opacity:1.00"
+          def group_style(layer_fill)
+            "stroke-width:#{stroke_width};stroke-linecap:#{@pen[0]};stroke-linejoin:#{@pen[1]}; " \
+              "fill:#{layer_fill};fill-opacity:1.00; stroke:#{stroke}; stroke-opacity:1.00"
           end
 
-          # Folded-corner body emitted as a closed <path> matching
-          # EA's encoding (not <polygon>). EA uses M..L..L..Z with
-          # stroke-linejoin=bevel for the dog-eared silhouette.
-          def path_body
-            x = bounds.x
-            y = bounds.y
-            w = bounds.width
-            h = bounds.height
-            fold = [FOLD_SIZE, w / 3, h / 3].min
-            d = "M #{Canvas.coord(x)} #{Canvas.coord(y)} " \
-                "L #{Canvas.coord(x + w - fold)} #{Canvas.coord(y)} " \
-                "L #{Canvas.coord(x + w)} #{Canvas.coord(y + fold)} " \
-                "L #{Canvas.coord(x + w)} #{Canvas.coord(y + h)} " \
-                "L #{Canvas.coord(x)} #{Canvas.coord(y + h)} " \
-                "L #{Canvas.coord(x)} #{Canvas.coord(y)} Z"
-            %(<path d="#{d}" shape-rendering="auto"/>)
+          def body_layer
+            %(<g style="#{group_style(fill)}">\n  #{polygon(body_points)}\n</g>)
+          end
+
+          def fold_layer
+            %(<g style="#{group_style(FOLD_FILL)}">\n  #{polygon(fold_points)}\n</g>)
+          end
+
+          def text_layer
+            text = text_block
+            text.empty? ? "" : %(<g style="#{group_style(fill)}">\n  #{text}\n</g>)
           end
 
-          # Inner edges of the folded corner; the outer path supplies the diagonal.
-          def fold_line
-            x = bounds.x
+          # EA encodes the note silhouette as a <polygon> (all six
+          # native Note placements in the PLATEAU and ArcGIS corpora),
+          # starting at the top-left corner and running down first.
+          def body_points
+            left, top, right, bottom = edges
+            [[left, top], [left, bottom], [right, bottom],
+             [right, top + fold_size], [right - fold_size, top]]
+          end
+
+          def edges
+            [bounds.x, bounds.y, bounds.x + bounds.width, bounds.y + bounds.height]
+          end
+
+          # The folded corner is a separate triangle, filled light
+          # grey regardless of the note's own fill.
+          def fold_points
+            r = bounds.x + bounds.width
             y = bounds.y
-            w = bounds.width
-            fold = [FOLD_SIZE, w / 3, bounds.height / 3].min
-            d = "M #{Canvas.coord(x + w - fold)} #{Canvas.coord(y)} " \
-                "L #{Canvas.coord(x + w - fold)} #{Canvas.coord(y + fold)} " \
-                "L #{Canvas.coord(x + w)} #{Canvas.coord(y + fold)}"
-            %(<path d="#{d}" shape-rendering="auto"/>)
+            [[r - fold_size, y], [r - fold_size, y + fold_size], [r, y + fold_size]]
+          end
+
+          def fold_size
+            [FOLD_SIZE, bounds.width / 3, bounds.height / 3].min
+          end
+
+          def polygon(points)
+            list = points.map { |px, py| "#{Canvas.coord(px)} #{Canvas.coord(py)}" }.join(" ")
+            %(<polygon points="#{list}" shape-rendering="auto"   style="fill-rule:evenodd;"/>)
           end
 
           def text_block

data/lib/ea/svg/ea_emitter/elements.rb

@@ -33,7 +33,14 @@ module Ea
         def groups
           @drawn_bounds = {}
           @divider_y = {}
-          ordered_elements.flat_map { |e| groups_for(e) }
+          @painted_any = false
+          @previous_pen = nil
+          ordered_elements.flat_map do |e|
+            groups = groups_for(e)
+            @painted_any ||= groups.any?
+            @previous_pen = Element::NoteShapeRenderer.pen_of(groups.last) || @previous_pen
+            groups
+          end
         end
 
         # Final drawn Bounds per model element reference, captured
@@ -50,8 +57,10 @@ module Ea
 
         private
 
+        # EA paints placements by descending Sequence (the lowest
+        # Sequence is on top); equal keys keep their stored order.
         def ordered_elements
-          (diagram.elements || []).sort_by { |e| e.z_order || 0 }
+          (diagram.elements || []).sort_by.with_index { |e, i| [-(e.z_order || 0), i] }
         end
 
         def groups_for(element)
@@ -300,7 +309,9 @@ module Ea
             canvas: canvas,
             diagram: diagram,
             model_index: model_index,
-            off_canvas_parent_name: parent_name
+            off_canvas_parent_name: parent_name,
+            first_painted: !@painted_any,
+            previous_pen: @previous_pen
           )
         end
 
@@ -380,10 +391,16 @@ module Ea
                                    attr_group_lead: attr_group_lead)
         end
 
+        # A ghost-led header (italic parent label above the stereotype /
+        # name) takes the same compact offsets: EA seats its divider at
+        # the last header baseline + 7 (empirical fit, 21 QEA dividers
+        # that were +1: 0114FD24 uro::AbstractConstruction etc.; 20 of
+        # 21 now exact, no other compared item moved). The tight ghost
+        # variant has no corpus case and keeps the default offsets.
         def compact_header_offsets?(classifier, header_lines, size, **options)
           classifier.is_a?(Ea::Model::Klass) &&
             Ea::Fonts::Metrics.compact_compartment_font?(size, family: options[:family], unit: options[:size_unit]) &&
-            !%i[italic italic_tight].include?(header_lines.dig(0, 1)) &&
+            header_lines.dig(0, 1) != :italic_tight &&
             options.values_at(:logical_height, :marker_count, :enum_literals_count,
                               :divider_offset, :attr_first_offset) == [nil, 0, 0, 8, 7] &&
             theme.compartments.header_line_offset == 6 && theme.compartments.attr_line_offset == 6

data/lib/ea/svg/ea_emitter/label/end_label.rb

@@ -45,6 +45,15 @@ module Ea
             @font_unit = font_unit
             @font_weight = font_weight
             @font_style = font_style
+            @reach = []
+          end
+
+          # [right, bottom] edge, in model coordinates, of the label boxes
+          # (position + stored CX/CY) emitted so far; nil before any.
+          def reach
+            return nil if @reach.empty?
+
+            [@reach.map(&:first).max, @reach.map(&:last).max]
           end
 
           # Returns an Array of `<text>` SVG strings for one endpoint.
@@ -102,6 +111,10 @@ module Ea
             stereo = connector_source_dest_stereotype(connector, end_kind)
             stereo = stereo.nil? || stereo.empty? ? nil : "«#{stereo}»"
             direction = leg_direction(end_kind, heading)
+            if left_seated_source?(connector, end_kind)
+              text_pos, mult_pos = left_seated_positions(anchor, role, mult)
+              direction = nil
+            end
             if direction && !(tree && zero_offset?(text_box, mult_box))
               text_pos = plain_leftward_source_role(connector, direction, anchor, text_box, role) ||
                          plain_vertical_role(connector, direction, anchor, text_box, role) ||
@@ -127,6 +140,7 @@ module Ea
                                     directional_multiplicity(:left, anchor, mult_box, mult)
                                   end
               mult_pos = target_multiplicity_seat(connector, heading, anchor, mult_box) ||
+                         target_diagonal_property_multiplicity(connector, heading, anchor, text_box, mult_box) ||
                          face_multiplicity || target_horizontal_multiplicity(heading, anchor, mult_box, mult) ||
                          mult_pos
             end
@@ -168,7 +182,8 @@ module Ea
             end
 
             build_texts(role:, mult:, standalone:,
-                        text_pos:, mult_pos:, stereo:, text_box:, stereo_pos:)
+                        text_pos:, mult_pos:, stereo:, text_box:, stereo_pos:,
+                        mult_box:)
           end
 
           private
@@ -345,6 +360,24 @@ module Ea
             end
           end
 
+          def left_seated_source?(connector, end_kind)
+            end_kind == :source && connector.style.to_h[:left_seated_source] == true
+          end
+
+          # EMPIRICAL FIT (5038EEE3 connectors 207 and 212, the only reversed
+          # links the builder flags): the source cluster sits left of the
+          # anchor like a source leaving left, whichever way the route leaves:
+          # role right edge 60px out, 7px above; multiplicity ends 3px short
+          # of the anchor, 15px below.
+          def left_seated_positions(anchor, role, mult)
+            role_width = Ea::Fonts::Metrics.text_length(role.to_s, font_size, family: font_family) ||
+                         role.to_s.length * 6
+            mult_width = Ea::Fonts::Metrics.text_length(mult.to_s, font_size, family: font_family) ||
+                         mult.to_s.length * 6
+            [[anchor[0] - 60 - role_width, anchor[1] - 7],
+             [anchor[0] - mult_width - 3, anchor[1] + 15]]
+          end
+
           # Stored source-end boxes on a 7pt label whose first leg
           # leaves straight up or straight right are seated at the box
           # corner, anchor + (OX, OY) with no sign flip, 3px to its
@@ -365,14 +398,15 @@ module Ea
             nil
           end
 
-          # Saved bounds seat a source Property role at the stereotype's left
-          # edge. A centred stored box (ALN=1), or a phantom's synthesized box
+          # Saved bounds seat a source or target Property role at the stereotype's
+          # left edge (target: +endPoint on 159E9DA0 and 90BCA409, the only
+          # corpus targets narrower than the stereotype). A centred stored box (ALN=1), or a phantom's synthesized box
           # without alignment, centres the shorter role over it; a
           # left-aligned box keeps both lines on that edge.
           def bounds_role_centering(connector, end_kind, role, stereo, text_box)
-            return 0 unless end_kind == :source && stereo && seat_font?
+            return 0 unless stereo && seat_font?
             return 0 unless centred_bounds_box?(connector, text_box)
-            return 0 unless property_label?(connector, :source)
+            return 0 unless property_label?(connector, end_kind)
 
             -[stereotype_offset(role, stereo, { "alignment" => 1 }), 0].min
           end
@@ -634,6 +668,16 @@ module Ea
             property_role_offsets(:down).first if dy.negative? && dy.abs > dx.abs
           end
 
+          # With no stored multiplicity box, a Property target on a steep
+          # upward diagonal seats it beside the anchor, above the role baseline.
+          def target_diagonal_property_multiplicity(connector, heading, anchor, text_box, mult_box)
+            return nil if mult_box
+            return nil unless diagonal_property_box?(connector, text_box)
+            return nil unless heading && heading[1].negative? && heading[1].abs > heading[0].abs
+
+            [anchor[0] + 8, anchor[1] - 7]
+          end
+
           def target_vertical_role(connector, heading, anchor, box, role)
             return nil unless heading && heading[0].zero? && !heading[1].zero?
 
@@ -905,9 +949,11 @@ module Ea
           end
 
           def build_texts(role:, mult:, standalone:, text_pos:, mult_pos:,
-                          stereo:, text_box:, stereo_pos: nil)
+                          stereo:, text_box:, stereo_pos: nil, mult_box: nil)
             if role && !role.empty? && text_pos
               x, y = text_pos
+              note_reach(text_pos, text_box)
+              note_reach(mult_pos, mult_box) if mult && !mult.empty? && mult_pos
               texts = [text_at(x, y, role)]
               if stereo
                 stereo_x, stereo_y = stereo_pos || [x + stereotype_offset(role, stereo, text_box),
@@ -919,12 +965,24 @@ module Ea
               end
               texts
             elsif standalone && !standalone.empty? && mult_pos
+              note_reach(mult_pos, mult_box)
               [text_at(*mult_pos, standalone)]
             else
               []
             end
           end
 
+          # A label box starts at the text's x and at its first baseline
+          # less the rounded font height (EA's text top).
+          def note_reach(position, box)
+            width = box && box["cx"]
+            height = box && box["cy"]
+            return unless width && height
+
+            @reach << [position[0] + width,
+                       position[1] - font_pixel_size.ceil + height]
+          end
+
           def umldi_label_position(bounds)
             [bounds[:x], bounds[:y] + font_pixel_size.ceil]
           end

data/lib/ea/svg/ea_emitter/labels.rb

@@ -43,6 +43,12 @@ module Ea
           %(<g style="stroke-width:1;stroke-linecap:round;stroke-linejoin:bevel; fill:#000000;fill-opacity:1.00; stroke:#000000; stroke-opacity:0.00">\n#{texts.join("\n")}\n</g>)
         end
 
+        # Right edge of the stored end-label boxes (model coordinates)
+        # of the last render, or nil when none carry a width.
+        def reach
+          end_renderer.reach
+        end
+
         private
 
         def visible_connectors

data/lib/ea/svg/ea_emitter/layer_sequencer.rb

@@ -49,8 +49,20 @@ module Ea
           @elements&.drawn_bounds
         end
 
+        # Row-slot seating stays off. Elements records each divider in canvas
+        # space, so it only matched logical connector ends when the canvas
+        # origin was 0 (the content-anchored default) and then moved one end
+        # 13 px in all four corpus cases it matched (5D6DB5A0 Aggregation and
+        # Generalization, ADC8773C, F46E8F19), none of which EA seats on a
+        # row; it never matched an XMI route. Under the framed canvas it was
+        # inert, which is the behaviour native parity was measured against.
         def divider_y_by_ref
-          @elements&.divider_y
+          nil
+        end
+
+        # Right edge of the connector end-label boxes, model coordinates.
+        def label_reach
+          @labels&.reach
         end
 
         private
@@ -66,46 +78,48 @@ module Ea
           @elements.groups
         end
 
+        # EA paints connector by connector: each line is followed by
+        # its own heads, and only adjacent same-style groups merge.
         def connector_layers
-          connector_layers_raw = Connectors.new(diagram, canvas: canvas,
-                                                  grouped: true,
-                                                  stroke_width: DEFAULT_STROKE_WIDTH,
-                                                  drawn_bounds: drawn_bounds,
-                                                  divider_y_by_ref: divider_y_by_ref,
-                                                  model_index: model_index).layers
-          marker_layers_raw = Markers.new(diagram, model_index: model_index,
-                                           canvas: canvas, grouped: true,
-                                           stroke_width: DEFAULT_STROKE_WIDTH,
-                                           drawn_bounds: drawn_bounds,
-                                           divider_y_by_ref: divider_y_by_ref).layers
-          merge_layers_by_style(connector_layers_raw + marker_layers_raw).map(&:to_svg)
+          lines = Connectors.new(diagram, canvas: canvas,
+                                          grouped: true,
+                                          stroke_width: DEFAULT_STROKE_WIDTH,
+                                          drawn_bounds: drawn_bounds,
+                                          divider_y_by_ref: divider_y_by_ref,
+                                          model_index: model_index).connector_layers
+          markers = Markers.new(diagram, model_index: model_index,
+                                         canvas: canvas, grouped: true,
+                                         stroke_width: DEFAULT_STROKE_WIDTH,
+                                         drawn_bounds: drawn_bounds,
+                                         divider_y_by_ref: divider_y_by_ref).connector_layers
+          by_owner = {}.compare_by_identity
+          (lines + markers).each { |owner, layer| (by_owner[owner] ||= []) << layer }
+          ordered = PaintOrder.connectors(diagram).flat_map { |connector| by_owner.fetch(connector, []) }
+          merge_adjacent_by_style(ordered).map(&:to_svg)
         end
 
         def labels_layer
-          Labels.new(diagram, canvas: canvas, model_index: model_index,
+          @labels = Labels.new(diagram, canvas: canvas, model_index: model_index,
                               theme: theme, document: document,
                               drawn_bounds: drawn_bounds,
-                              divider_y_by_ref: divider_y_by_ref).render
+                              divider_y_by_ref: divider_y_by_ref)
+          @labels.render
         end
 
         def ghost_labels_layer
           GhostLabels.new(diagram, canvas: canvas).render
         end
 
-        def merge_layers_by_style(layers)
-          merged = {}
-          layers.each do |layer|
-            if merged[layer.style_key]
-              merged[layer.style_key] = Layer.new(
-                style_key: layer.style_key,
-                style: layer.style,
-                body: "#{merged[layer.style_key].body}\n  #{layer.body}"
-              )
+        def merge_adjacent_by_style(layers)
+          layers.each_with_object([]) do |layer, merged|
+            last = merged.last
+            if last && last.style_key == layer.style_key
+              merged[-1] = Layer.new(style_key: last.style_key, style: last.style,
+                                     body: "#{last.body}\n  #{layer.body}")
             else
-              merged[layer.style_key] = layer
+              merged << layer
             end
           end
-          merged.values
         end
       end
     end

data/lib/ea/svg/ea_emitter/markers.rb

@@ -52,17 +52,28 @@ module Ea
           entries = visible_connectors.flat_map { |c| entries_for(c) }
 
           if grouped
-            entries.group_by { |e| [e.style_key, e.stroke_width] }.map do |(key, width), grouped_entries|
+            entries.group_by { |e| [e.style_key, e.stroke_width, e.stroke_color] }.map do |(key, width, color), grouped_entries|
               # EA emits ONE marker per connector regardless of
               # anchor overlap. Verified against plateau Bridge
               # diagram: 9 generalizations fanning from the same
               # parent anchor produce 9 distinct triangle polygons
               # at the same coordinates. The earlier "dedup by
               # anchor" hypothesis is disproven by reference SVGs.
-              marker_layer(key, width, grouped_entries.map(&:body).join("\n  "))
+              marker_layer(key, width, color, grouped_entries.map(&:body).join("\n  "))
             end
           else
-            entries.map { |e| marker_layer(e.style_key, e.stroke_width, e.body) }
+            entries.map { |e| marker_layer(e.style_key, e.stroke_width, e.stroke_color, e.body) }
+          end
+        end
+
+        # One `[connector, Layer]` pair per marker, in diagram link
+        # order, so the sequencer can paint each connector's heads right
+        # after its line like EA does.
+        def connector_layers
+          visible_connectors.flat_map do |connector|
+            entries_for(connector).map do |e|
+              [connector, marker_layer(e.style_key, e.stroke_width, e.stroke_color, e.body)]
+            end
           end
         end
 
@@ -86,7 +97,7 @@ module Ea
         # drives dedup — EA emits one marker per connector.
         Entry = Struct.new(:style_key, :body, :anchor,
                            :connector_waypoint_count, :stroke_width,
-                           keyword_init: true) do
+                           :stroke_color, keyword_init: true) do
           def hash
             anchor.hash
           end
@@ -140,18 +151,18 @@ module Ea
           connector_line: { fill: "#000000", opacity: "0.00" }
         }.freeze
 
-        def marker_layer(key, width, body)
-          Layer.new(style_key: Connectors.layer_key(key, width, stroke_width),
-                    style: style_for(key, width), body: body)
+        def marker_layer(key, width, color, body)
+          Layer.new(style_key: Connectors.layer_key(key, width, stroke_width, color),
+                    style: style_for(key, width, color), body: body)
         end
 
-        def style_for(key, width = stroke_width)
+        def style_for(key, width = stroke_width, color = Connectors::DEFAULT_STROKE)
           spec = STYLE_MAP[key]
           return nil unless spec
 
           "stroke-width:#{width};stroke-linecap:round;stroke-linejoin:bevel; " \
             "fill:#{spec[:fill]};fill-opacity:#{spec[:opacity]}; " \
-            "stroke:#000000; stroke-opacity:1.00"
+            "stroke:#{color}; stroke-opacity:1.00"
         end
 
         def visible_connectors
@@ -171,7 +182,8 @@ module Ea
                       body: body,
                       anchor: anchor_for(spec),
                       connector_waypoint_count: waypoint_count,
-                      stroke_width: Connectors.stroke_width_for(connector, stroke_width))
+                      stroke_width: Connectors.stroke_width_for(connector, stroke_width),
+                      stroke_color: Connectors.stroke_color_for(connector))
           end
         end
 

data/lib/ea/svg/ea_emitter/paint_order.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # EA paints connectors (each line followed by its heads) ordered by the
+      # start element's placement row, then the connector id: the
+      # `paint_order` key the diagram builders store. Verified without a
+      # single inversion over 12785 connector pairs of the QEA corpus.
+      # Connectors with an unresolvable key follow the keyed ones, and
+      # phantoms (no stored key) come last, each in link order.
+      module PaintOrder
+        module_function
+
+        def connectors(diagram)
+          (diagram.connectors || []).each_with_index.sort_by do |connector, index|
+            order = connector.paint_order
+            rank = if order.nil?
+                     2
+                   else
+                     order.empty? ? 1 : 0
+                   end
+            [rank, order || [], index]
+          end.map(&:first)
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/render_context.rb

@@ -19,7 +19,7 @@ module Ea
         :enum_literals, :tagged_values, :constraints, :marker_lines,
         :package_content_lines,
         :geometry, :theme, :canvas, :diagram, :model_index,
-        :off_canvas_parent_name,
+        :off_canvas_parent_name, :first_painted, :previous_pen,
         keyword_init: true
       )
         def note_body
@@ -57,11 +57,22 @@ module Ea
         # roles; the XMI reads them as ownedAttribute), so a class whose
         # only properties are association ends has no feature compartment
         # and no divider (A59065AF urf::Administration).
+        #
+        # A diagram that suppresses a whole feature kind (Style
+        # HideAtts=1 / HideOps=1) has no such compartment to draw, so
+        # that kind never earns a divider: 4881CEEE (HideAtts=1 and
+        # HideOps=1) draws none over classes that own attributes,
+        # 8FD488EF likewise. Per-attribute visibility toggles are a
+        # different mechanism and keep the divider (10E3E08A).
         def hidden_features_present?
           return false unless classifier.respond_to?(:properties)
 
-          classifier.properties.any? { |property| !property.association_id } ||
-            classifier.operations.any?
+          config = diagram&.display_config
+          shows_attributes = config.nil? || config.show_attributes?
+          shows_operations = config.nil? || config.show_operations?
+
+          (shows_attributes && classifier.properties.any? { |property| !property.association_id }) ||
+            (shows_operations && classifier.operations.any?)
         end
       end
     end