archimate 1.2.1 → 2.0.0

data/lib/archimate/cli/convert.rb

@@ -5,7 +5,7 @@ module Archimate
     class Convert
       include Archimate::Logging
 
-      SUPPORTED_FORMATS = %w[meff2.1 meff3.0 archi nquads graphml csv cypher].freeze
+      SUPPORTED_FORMATS = %w[meff2.1 meff3.0 archi nquads graphml csv cypher jsonl].freeze
 
       attr_reader :model
 
@@ -30,6 +30,8 @@ module Archimate
           Archimate::Export::CSVExport.new(model).to_csv(output_dir: output_dir)
         when "cypher"
           Archimate::Export::Cypher.new(output_io).to_cypher(model)
+        when "jsonl"
+          Archimate::Export::Jsonl.new(output_io).to_jsonl(model)
         else
           error { "Export to '#{export_format}' is not supported yet." }
         end

data/lib/archimate/cli/mapper.rb

@@ -28,7 +28,7 @@ module Archimate
                    when "archimate:SketchModel"
                      "Sketch"
                    when "archimate:ArchimateDiagramModel"
-                     DataModel::Constants::VIEWPOINTS[(row[2] || 0).to_i]
+                     DataModel::ViewpointType.values[(row[2] || 0).to_i].to_s
                    else
                      row[3]
                    end

data/lib/archimate/cli/stats.rb

@@ -28,7 +28,7 @@ module Archimate
       end
 
       def title_width
-        @title_width ||= (elements_by_layer.keys + ["Total Elements"]).map(&:size).max
+        @title_width ||= (elements_by_layer.keys + ["Total Elements"]).map(&:to_s).map(&:size).max
       end
 
       def row(title, size, color)

data/lib/archimate/config.rb

@@ -3,6 +3,7 @@
 require "logger"
 require "singleton"
 require "observer"
+require "irb"
 
 module Archimate
   # This is the singleton class that contains application configuration.
@@ -12,10 +13,12 @@ module Archimate
 
     attr_reader :interactive
     attr_reader :logger
+    attr_reader :default_lang
 
     def initialize
       @interactive = true
-      @logger ||= Logger.new(STDERR, progname: "archimate")
+      @logger = Logger.new(STDERR, progname: "archimate")
+      @default_lang = IRB::Locale.new.lang
     end
 
     def interactive=(interactive)

data/lib/archimate/data_model.rb

@@ -2,53 +2,40 @@
 
 module Archimate
   module DataModel
-    include Dry::Types.module
-
-    Coercible = Archimate::DataModel::Coercible
-    Strict = Archimate::DataModel::Strict
-
-    # Identifiers in the ArchiMate exchange format standard are of
-    Identifier = Strict::String # .constrained(format: /[[[:alpha:]]_][\w\-\.]*/)
-
-    # An enumeration of data types.
-    DataType = Strict::String.default("string").enum("string", "boolean", "currency", "date", "time", "number")
-
     # Enumeration of Influence Strength types. These are suggestions.
-    InfluenceStrengthEnum = Strict::String.enum(%w[+ ++ - -- 0 1 2 3 4 5 6 7 8 9 10])
+    # InfluenceStrengthEnum = String # Strict::String.enum(%w[+ ++ - -- 0 1 2 3 4 5 6 7 8 9 10])
 
-    require 'archimate/data_model/diffable_primitive'
-    require 'archimate/data_model/diffable_array'
-    require 'archimate/data_model/constants'
-    require 'archimate/data_model/archimate_node'
+    require 'archimate/data_model/connector_type'
+    require 'archimate/data_model/diagram_type'
+    require 'archimate/data_model/element_type'
+    require 'archimate/data_model/relationship_type'
+    require 'archimate/data_model/comparison'
+    require 'archimate/data_model/differentiable'
+    require 'archimate/data_model/layer'
+    require 'archimate/data_model/layers'
+    require 'archimate/data_model/viewpoint_type'
     require 'archimate/data_model/any_attribute'
     require 'archimate/data_model/any_element'
     require 'archimate/data_model/lang_string'
+    require 'archimate/data_model/preserved_lang_string'
     require 'archimate/data_model/schema_info'
     require 'archimate/data_model/metadata'
     require 'archimate/data_model/color'
     require 'archimate/data_model/font'
     require 'archimate/data_model/style'
     require 'archimate/data_model/bounds'
-    require 'archimate/data_model/documentation'
     require 'archimate/data_model/modeling_note'
-    require 'archimate/data_model/referenceable'
-    require 'archimate/data_model/named_referenceable'
     require 'archimate/data_model/property_definition'
     require 'archimate/data_model/property'
-    require 'archimate/data_model/concept'
     require 'archimate/data_model/organization'
     require 'archimate/data_model/element'
     require 'archimate/data_model/relationship'
     require 'archimate/data_model/concern'
     require 'archimate/data_model/viewpoint'
-    require 'archimate/data_model/view'
-    require 'archimate/data_model/view_concept'
     require 'archimate/data_model/location'
     require 'archimate/data_model/connection'
     require 'archimate/data_model/view_node'
-    require 'archimate/data_model/container'
     require 'archimate/data_model/diagram'
-    require 'archimate/data_model/label'
     require 'archimate/data_model/model'
   end
 end

data/lib/archimate/data_model/any_attribute.rb

@@ -3,11 +3,24 @@
 module Archimate
   module DataModel
     # An instance of any XML attribute for arbitrary content like metadata
-    class AnyAttribute < ArchimateNode
-      attribute :attribute, Strict::String
-      attribute :prefix, Strict::String
-      attribute :value, Strict::String
+    class AnyAttribute
+      include Comparison
+
+      # @!attribute [r] attribute
+      #   @return [String]
+      model_attr :attribute
+      # @!attribute [r] prefix
+      #   @return [String]
+      model_attr :prefix
+      # @!attribute [r] value
+      #   @return [String]
+      model_attr :value
+
+      def initialize(attribute, value, prefix: "")
+        @attribute = attribute
+        @prefix = prefix
+        @value = value
+      end
     end
-    Dry::Types.register_class(AnyAttribute)
   end
 end

data/lib/archimate/data_model/any_element.rb

@@ -3,13 +3,36 @@
 module Archimate
   module DataModel
     # An instance of any XML element for arbitrary content like metadata
-    class AnyElement < ArchimateNode
-      attribute :element, Strict::String
-      attribute :prefix, Strict::String.optional
-      attribute :attributes, Strict::Array.member(AnyAttribute).default([])
-      attribute :content, Strict::String.optional
-      attribute :children, Strict::Array.member(AnyElement).default([])
+    class AnyElement
+      include Comparison
+
+      # @!attribute [r] element
+      #   @return [String]
+      model_attr :element
+      # @!attribute [r] prefix
+      #   @return [String, NilClass]
+      model_attr :prefix
+      # @!attribute [r] attributes
+      #   @return [Array<AnyAttribute>]
+      model_attr :attributes
+      # @!attribute [r] content
+      #   @return [String, NilClass]
+      model_attr :content
+      # @!attribute [r] children
+      #   @return [Array<AnyElement>]
+      model_attr :children
+
+      def initialize(element:, prefix: "", attributes: [], content: nil, children: [])
+        @element = element
+        @prefix = prefix
+        @attributes = attributes
+        @content = content
+        @children = children
+      end
+
+      def to_sym
+        element&.to_sym
+      end
     end
-    Dry::Types.register_class(AnyElement)
   end
 end

data/lib/archimate/data_model/bounds.rb

@@ -1,16 +1,36 @@
 # frozen_string_literal: true
+
 module Archimate
   module DataModel
-    class Bounds < ArchimateNode
-      attribute :x, Coercible::Float.optional
-      attribute :y, Coercible::Float.optional
-      attribute :width, Coercible::Float
-      attribute :height, Coercible::Float
+    class Bounds
+      include Comparison
+
+      # @!attribute [r] x
+      #   @return [Float, NilClass]
+      model_attr :x
+      # @!attribute [r] y
+      #   @return [Float, NilClass]
+      model_attr :y
+      # @!attribute [r] width
+      #   @return [Float]
+      model_attr :width
+      # @!attribute [r] height
+      #   @return [Float]
+      model_attr :height
 
       def self.zero
         Archimate::DataModel::Bounds.new(x: 0, y: 0, width: 0, height: 0)
       end
 
+      def initialize(x: nil, y: nil, width:, height:)
+        raise "Width expected" unless width
+        raise "Height expected" unless height
+        @x = x.nil? ? nil : x.to_f
+        @y = y.nil? ? nil : y.to_f
+        @width = width.to_f
+        @height = height.to_f
+      end
+
       def to_s
         "Bounds(x: #{x}, y: #{y}, width: #{width}, height: #{height})"
       end
@@ -39,6 +59,15 @@ module Archimate
         x || 0
       end
 
+      def center
+        DataModel::Bounds.new(
+          x: left + width / 2.0,
+          y: top + height / 2.0,
+          width: 0,
+          height: 0
+        )
+      end
+
       def is_above?(other)
         bottom < other.top
       end
@@ -66,7 +95,5 @@ module Archimate
           bottom < other.bottom
       end
     end
-
-    Dry::Types.register_class(Bounds)
   end
 end

data/lib/archimate/data_model/color.rb

@@ -1,16 +1,30 @@
 # frozen_string_literal: true
+
 module Archimate
   module DataModel
     # RGBColorType in the XSD
     # RGB Color type.
     # The r, g, b attributes range from 0 - 255.
     # The a (alpha) transparency attribute is optional. 0 = full transparency, 100 = opaque.
-    class Color < ArchimateNode
-      attribute :r, Coercible::Int.constrained(lt: 256, gt: -1)
-      attribute :g, Coercible::Int.constrained(lt: 256, gt: -1)
-      attribute :b, Coercible::Int.constrained(lt: 256, gt: -1)
-      attribute :a, Coercible::Int.constrained(lt: 101, gt: -1).optional
+    class Color
+      include Comparison
+
+      # @!attribute [r] r
+      #   @return [Int] red component, value 0-255
+      model_attr :r
+      # @!attribute [r] g
+      #   @return [Int] green component, value 0-255
+      model_attr :g
+      # @!attribute [r] b
+      #   @return [Int] blue component, value 0-255
+      model_attr :b
+      # @!attribute [r] a
+      #   @return [Int, NilClass] optional alpha component, value 0-100
+      model_attr :a
 
+      # Parses a CSS style color string into a color object
+      # @param str [String] CSS color string
+      # @return [Color]
       def self.rgba(str)
         return nil if str.nil?
         md = str.match(/#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})?/)
@@ -23,10 +37,22 @@ module Archimate
         )
       end
 
+      # Results in a Color instance for the color black
+      # @return [Color]
       def self.black
         new(r: 0, g: 0, b: 0, a: 100)
       end
 
+      def initialize(r:, g:, b:, a: nil)
+        raise "r, g, b cannot be nil" if [r, g, b].any?(&:nil?)
+        raise "r, g, b must be between 0 and 255" if [r, g, b].any? { |v| v < 0 || v > 255 }
+        raise "a must be between 0 and 100" if a && (a < 0 || a > 100)
+        @r = r
+        @g = g
+        @b = b
+        @a = a
+      end
+
       def to_s
         "Color(r: #{r}, g: #{g}, b: #{b}, a: #{a})"
       end
@@ -38,10 +64,9 @@ module Archimate
       private
 
       def scaled_alpha(max = 255)
+        return max unless a
         (max * (a / 100.0)).round
       end
     end
-
-    Dry::Types.register_class(Color)
   end
 end

data/lib/archimate/data_model/comparison.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Archimate
+  module DataModel
+    module Comparison
+      def hash
+        @hash_key ||=
+          self.class.attr_names.reduce(self.class.hash) { |ha, attr| ha ^ send(attr).hash }
+      end
+
+      def ==(other)
+        return true if equal?(other)
+        other.is_a?(self.class) &&
+          self.class.comparison_attr_paths.all? do |attr|
+            dig(*attr) == other.dig(*attr)
+          end
+      end
+
+      def [](sym)
+        send(sym)
+      end
+
+      def dig(*args)
+        return self if args.empty?
+        val = send(args.shift)
+        return val if args.empty?
+        val&.dig(*args)
+      end
+
+      def to_h
+        self.class.attr_names.each_with_object({}) { |i, a| a[i] = send(i) }
+      end
+
+      def each(&blk)
+        self.class.comparison_attr_paths.each(&blk)
+      end
+
+      def pretty_print(pp)
+        pp.object_address_group(self) do
+          pp.seplist(self.class.comparison_attr_paths, proc { pp.text ',' }) do |attr|
+            column_value = dig(*attr)
+            pp.breakable ' '
+            pp.group(1) do
+              pp.text Array(attr).map(&:to_s).join(".")
+              pp.text ':'
+              pp.breakable
+              pp.pp column_value
+            end
+          end
+        end
+      end
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        # Define the reader method (or call model_attr)
+        # Append the attr_sym to the @@attrs for the class
+        def model_attr(attr_sym, comparison_attr: nil, writable: false)
+          send(:attr_reader, attr_sym)
+          attrs = attr_names << attr_sym
+          class_variable_set(:@@attr_names, attrs.uniq)
+
+          if comparison_attr != :no_compare
+            attrs = comparison_attr_paths << (comparison_attr ? [attr_sym, comparison_attr] : attr_sym)
+            class_variable_set(:@@comparison_attr_paths, attrs.uniq)
+          end
+          if writable
+            define_method("#{attr_sym}=".to_sym) do |val|
+              instance_variable_set(:@hash_key, nil)
+              instance_variable_set("@#{attr_sym}".to_sym, val)
+            end
+          end
+        end
+
+        def attr_names
+          class_variable_defined?(:@@attr_names) ? class_variable_get(:@@attr_names) : []
+        end
+
+        def comparison_attr_paths
+          class_variable_defined?(:@@comparison_attr_paths) ? class_variable_get(:@@comparison_attr_paths) : []
+        end
+      end
+    end
+  end
+end

data/lib/archimate/data_model/concern.rb

@@ -5,13 +5,26 @@ module Archimate
     # document attribute holds all the concern information.
     #
     # This is ConcernType in the XSD
-    class Concern < ArchimateNode
-      attribute :labels, Strict::Array.member(LangString).constrained(min_size: 1)
-      attribute :documentation, DocumentationGroup
-      attribute :stakeholders, Strict::Array.member(LangString)
-    end
+    class Concern
+      include Comparison
+
+      # @!attribute [r] label
+      #   @return [LangString] one label is required
+      model_attr :label
+      # @!attribute [r] documentation
+      #   @return [PreservedLangString]
+      model_attr :documentation
+      # @!attribute [r] stakeholders
+      #   @return [Array<LangString>]
+      model_attr :stakeholders
 
-    Dry::Types.register_class(Concern)
-    ConcernList = Strict::Array.member(Concern).default([])
+      def initialize(label:, documentation: nil, stakeholders: [])
+        raise "label is required" unless label
+        raise "stakeholders is a list" unless stakeholders.is_a?(Array)
+        @label = label
+        @documentation = documentation
+        @stakeholders = stakeholders
+      end
+    end
   end
 end