archimate 1.2.1 → 2.0.0

data/lib/archimate/data_model/element_type.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+require "ruby-enum"
+
+module Archimate
+  module DataModel
+    # Enumeration class that defines the strings used for all Archimate element
+    # types.
+    class ElementType
+      include Ruby::Enum
+
+      define :BusinessActor, "BusinessActor"
+      define :BusinessCollaboration, "BusinessCollaboration"
+      define :BusinessEvent, "BusinessEvent"
+      define :BusinessFunction, "BusinessFunction"
+      define :BusinessInteraction, "BusinessInteraction"
+      define :BusinessInterface, "BusinessInterface"
+      define :BusinessObject, "BusinessObject"
+      define :BusinessProcess, "BusinessProcess"
+      define :BusinessRole, "BusinessRole"
+      define :BusinessService, "BusinessService"
+      define :Contract, "Contract"
+      define :Location, "Location"
+      define :Meaning, "Meaning"
+      define :Value, "Value"
+      define :Product, "Product"
+      define :Representation, "Representation"
+      define :ApplicationCollaboration, "ApplicationCollaboration"
+      define :ApplicationComponent, "ApplicationComponent"
+      define :ApplicationFunction, "ApplicationFunction"
+      define :ApplicationInteraction, "ApplicationInteraction"
+      define :ApplicationInterface, "ApplicationInterface"
+      define :ApplicationService, "ApplicationService"
+      define :DataObject, "DataObject"
+      define :Artifact, "Artifact"
+      define :CommunicationPath, "CommunicationPath"
+      define :Device, "Device"
+      define :InfrastructureFunction, "InfrastructureFunction"
+      define :InfrastructureInterface, "InfrastructureInterface"
+      define :InfrastructureService, "InfrastructureService"
+      define :Network, "Network"
+      define :Node, "Node"
+      define :SystemSoftware, "SystemSoftware"
+      define :Assessment, "Assessment"
+      define :Constraint, "Constraint"
+      define :Driver, "Driver"
+      define :Goal, "Goal"
+      define :Principle, "Principle"
+      define :Requirement, "Requirement"
+      define :Stakeholder, "Stakeholder"
+      define :Deliverable, "Deliverable"
+      define :Gap, "Gap"
+      define :Plateau, "Plateau"
+      define :WorkPackage, "WorkPackage"
+      define :AndJunction, "AndJunction"
+      define :Junction, "Junction"
+      define :OrJunction, "OrJunction"
+      define :Capability, "Capability"
+      define :CourseOfAction, "CourseOfAction"
+      define :Resource, "Resource"
+      define :ApplicationProcess, "ApplicationProcess"
+      define :ApplicationEvent, "ApplicationEvent"
+      define :TechnologyCollaboration, "TechnologyCollaboration"
+      define :TechnologyInterface, "TechnologyInterface"
+      define :Path, "Path"
+      define :CommunicationNetwork, "CommunicationNetwork"
+      define :TechnologyFunction, "TechnologyFunction"
+      define :TechnologyProcess, "TechnologyProcess"
+      define :TechnologyInteraction, "TechnologyInteraction"
+      define :TechnologyEvent, "TechnologyEvent"
+      define :TechnologyService, "TechnologyService"
+      define :TechnologyObject, "TechnologyObject"
+      define :Equipment, "Equipment"
+      define :Facility, "Facility"
+      define :DistributionNetwork, "DistributionNetwork"
+      define :Material, "Material"
+      define :Outcome, "Outcome"
+      define :ImplementationEvent, "ImplementationEvent"
+      # @todo Is grouping a valid element type?
+      # define :Grouping, "Grouping"
+
+      # Case equality operator. Used to determine if a value is a member of this enum
+      #
+      # @param other [String] string to test for enum membership.
+      def self.===(other)
+        values.include?(other)
+      end
+    end
+  end
+end

data/lib/archimate/data_model/font.rb

@@ -1,28 +1,48 @@
 # frozen_string_literal: true
+
 module Archimate
   module DataModel
-    class Font < ArchimateNode
-      attribute :name, Strict::String.optional
-      attribute :size, Coercible::Float.constrained(gt: 0.0).optional
-      attribute :style, Coercible::Int.optional # TODO: make this an enum
-      attribute :font_data, Strict::String.optional
+    class Font
+      include Comparison
+
+      # @!attribute [r] name
+      #   @return [String, NilClass]
+      model_attr :name
+      # @!attribute [r] size
+      #   @return [Float, NilClass]
+      model_attr :size
+      # @todo make this an enum
+      # @!attribute [r] style
+      #   @return [Int, NilClass]
+      model_attr :style
+      # @!attribute [r] font_data
+      #   @return [String, NilClass]
+      model_attr :font_data
 
       # Archi font strings look like this:
       #  "1|Arial            |14.0|0|WINDOWS|1|0  |0|0|0|0  |0 |0|0|1|0|0|0|0 |Arial"
       #  "1|Arial            |8.0 |0|WINDOWS|1|0  |0|0|0|0  |0 |0|0|1|0|0|0|0 |Arial"
       #  "1|Segoe UI Semibold|12.0|2|WINDOWS|1|-16|0|0|0|600|-1|0|0|0|3|2|1|34|Segoe UI Semibold"
       #  "1|Times New Roman  |12.0|3|WINDOWS|1|-16|0|0|0|700|-1|0|0|0|3|2|1|18|Times New Roman"
+      # @todo move this to the archi file reader
       def self.archi_font_string(str)
         return nil if str.nil?
         font_parts = str.split("|")
         DataModel::Font.new(
           name: font_parts[1],
-          size: font_parts[2],
-          style: font_parts[3],
+          size: font_parts[2].to_f,
+          style: font_parts[3].to_i,
           font_data: str
         )
       end
 
+      def initialize(name: nil, size: nil, style: nil, font_data: nil)
+        @name = name
+        @size = size.nil? ? nil : size.to_f
+        @style = style.nil? ? nil : style.to_i
+        @font_data = font_data
+      end
+
       def to_s
         "Font(name: #{name}, size: #{size}, style: #{style})"
       end
@@ -30,12 +50,12 @@ module Archimate
       def to_archi_font
         font_data ||
           [
-            1, font.name, font.size, font.style, "WINDOWS", 1, 0, 0, 0, 0, 0, 0,
-            0, 0, 1, 0, 0, 0, 0, font.name
+            1, name, size, style, "WINDOWS", 1, 0, 0, 0, 0, 0, 0,
+            0, 0, 1, 0, 0, 0, 0, name
           ].map(&:to_s).join("|")
       end
 
-      # TODO: this isn't standard
+      # @todo this isn't standard
       # Move to file format
       def style_string
         case style
@@ -48,7 +68,5 @@ module Archimate
         end
       end
     end
-
-    Dry::Types.register_class(Font)
   end
 end

data/lib/archimate/data_model/lang_string.rb

@@ -1,41 +1,114 @@
 # frozen_string_literal: true
+
 require "forwardable"
 
 module Archimate
   module DataModel
     # A base string type for multi-language strings.
-    class LangString < ArchimateNode
-      # include Comparable
+    class LangString
+      include Comparison
       extend Forwardable
-      def_delegators :@text, :to_s, :strip, :strip!, :tr, :+, :gsub, :gsub!, :sub!, :downcase!, :empty?, :split
 
-      attribute :text, Strict::String
-      attribute :lang, Strict::String.optional
+      def_delegators :@default_text, :strip, :tr, :+, :gsub, :sub, :downcase, :empty?, :split, :size, :include?
+      # def_delegators :@lang_hash, :size
+
+      # @!attribute [r] lang_hash
+      #   @return [Hash]
+      model_attr :lang_hash
+      # @!attribute [r] default_lang
+      #   @return [String, NilClass]
+      model_attr :default_lang
+      # @!attribute [r] default_text
+      #   @return [String]
+      model_attr :default_text
+
+      # def self.default_lang
+      #   Archimate::Config.instance.default_lang
+      # end
+
+      def self.string(str, lang = nil)
+        return nil if !str || str.strip.empty?
+        str = str.strip
+        lang = nil if !lang || lang.empty?
+        new(
+          lang_hash: { lang => str },
+          default_lang: lang,
+          default_text: str
+        )
+      end
+
+      def self.create(copy)
+        case copy
+        when String
+          string(copy)
+        when LangString
+          copy
+        when Hash
+          lang_hash = copy.fetch(:lang_hash, {})
+          default_lang = copy.fetch(:default_lang, "")
+          default_text = copy.fetch(:default_text, "")
+          return nil if [lang_hash, default_lang, default_text].any? { |i| i && i.empty? }
+          new(
+            lang_hash: lang_hash,
+            default_lang: default_lang,
+            default_text: default_text
+          )
+        end
+      end
 
-      # @param [Hash{Symbol => Object},Dry::Struct, String] attributes
+      # @param [Hash{Symbol => Object},LangString, String] attributes
       # @raise [Struct::Error] if the given attributes don't conform {#schema}
-      #   with given {#constructor_type}
-      def self.new(attributes)
-        if attributes.instance_of?(String)
-          super(text: attributes.strip)
+      #   with given {# # constructor_type}
+      def initialize(str = nil, lang_hash: {}, default_lang: nil, default_text: nil)
+        @lang_hash = lang_hash
+        @default_lang = default_lang
+        @default_text = default_text
+        case str
+        when String
+          @lang_hash[@default_lang] = @default_text = str.strip
+        when LangString
+          @lang_hash = str.lang_hash
+          @default_lang = str.default_lang
+          @default_text = str.default_text
         else
-          super
+          @lang_hash[default_lang] = default_text if default_text
         end
       end
 
+      def langs
+        @lang_hash.keys
+      end
+
       def to_str
-        @text
+        to_s
+      end
+
+      def to_s
+        @default_text ||= @lang_hash.fetch(default_lang) do |key|
+          @lang_hash.fetch(nil, nil) if key
+        end
+      end
+
+      def by_lang(lang)
+        lang_hash.fetch(lang, nil)
+      end
+
+      def text
+        to_s
+      end
+
+      def lang
+        default_lang
       end
 
       def =~(other)
+        str = to_s
         if other.is_a?(Regexp)
-          other =~ @text
+          other =~ str
         else
-          Regexp.new(Regexp.escape(@text)) =~ other
+          Regexp.new(Regexp.escape(str)) =~ other
         end
       end
     end
-
-    Dry::Types.register_class(LangString)
   end
 end

data/lib/archimate/data_model/layer.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+require "ruby-enum"
+
+module Archimate
+  module DataModel
+    class Layer
+      attr_reader :elements
+      attr_reader :name
+
+      # No user serviceable parts here. don't use me.
+      def initialize(layer = "None", element_names = [])
+        @symbol = Layer.symbolize(layer)
+        @name = layer
+        @elements = element_names
+      end
+
+      def hash
+        self.class.hash ^ @symbol.hash
+      end
+
+      def ===(other)
+        return true if equal?(other)
+        case other
+        when String
+          @symbol == Layer.symbolize(other)
+        when Symbol
+          @symbol == other
+        when Layer
+          self == other
+        else
+          false
+        end
+      end
+
+      def ==(other)
+        @symbol == other&.to_sym
+      end
+
+      def to_sym
+        @symbol
+      end
+
+      def to_s
+        @name
+      end
+
+      private
+
+      def self.symbolize(str)
+        return str if str.is_a?(Symbol)
+        str.downcase.tr(" ", "_").to_sym
+      end
+    end
+  end
+end

data/lib/archimate/data_model/layers.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+require "ruby-enum"
+
+module Archimate
+  module DataModel
+    class Layers
+      include Ruby::Enum
+
+      define :Strategy, Layer.new("Strategy", %w[Capability CourseOfAction Resource])
+
+      define :Business, Layer.new("Business", %w[BusinessActor BusinessCollaboration
+             BusinessEvent BusinessFunction
+             BusinessInteraction BusinessInterface
+             BusinessObject BusinessProcess
+             BusinessRole BusinessService
+             Contract Location
+             Meaning Value
+             Product Representation])
+
+      define :Application, Layer.new("Application", %w[ApplicationCollaboration ApplicationComponent
+             ApplicationFunction ApplicationInteraction
+             ApplicationInterface ApplicationService
+             DataObject ApplicationProcess ApplicationEvent])
+
+      define :Technology, Layer.new("Technology", %w[Artifact CommunicationPath
+             Device InfrastructureFunction
+             InfrastructureInterface InfrastructureService
+             Network Node SystemSoftware TechnologyCollaboration
+             TechnologyInterface Path CommunicationNetwork
+             TechnologyFunction TechnologyProcess TechnologyInteraction
+             TechnologyEvent TechnologyService
+             TechnologyObject])
+
+      define :Physical, Layer.new("Physical", %w[Equipment Facility DistributionNetwork Material])
+
+      define :Motivation, Layer.new("Motivation", %w[Assessment Constraint Driver
+             Goal Principle Requirement
+             Stakeholder Outcome])
+
+      define :Implementation_and_migration, Layer.new("Implementation and Migration", %w[Deliverable Gap Plateau
+             WorkPackage ImplementationEvent])
+
+      # @todo Is Connectors used? Should this be none?
+      define :Connectors, Layer.new("Connectors", %w[AndJunction Junction OrJunction])
+
+      define :None, Layer.new("None")
+
+      # def [](name_or_sym)
+      #   case name_or_sym
+      #   when Integer
+      #     @layers[name_or_sym]
+      #   else
+      #     @layers.find { |layer| layer === name_or_sym }
+      #   end
+      # end
+
+      def self.for_element(type)
+        values.find { |layer| layer.elements.include?(type) } || Layers::None
+      end
+    end
+  end
+end

data/lib/archimate/data_model/location.rb

@@ -2,30 +2,46 @@
 
 module Archimate
   module DataModel
-    # TODO: x & y Defined like this in the XSD
-    NonNegativeInteger = Coercible::Int.constrained(gteq: 0)
-    NonNegativeFloat = Coercible::Float # .constrained(gteq: 0)
+    # @todo x & y Defined like this in the XSD
+    # NonNegativeInteger = Int.constrained(gteq: 0)
+    # NonNegativeFloat = Float # .constrained(gteq: 0)
 
     # Graphical node type. It can contain child node types.
     # This is LocationType/LocationGroup in the XSD.
-    class Location < ArchimateNode
+    class Location
+      include Comparison
+
       # The x (towards the right, associated with width) attribute from the Top,Left (i.e. 0,0)
       # corner of the diagram to the Top, Left corner of the bounding box of the concept.
-      attribute :x, NonNegativeFloat # Note the XSD has this as an Int, NonNegativeInteger
+      # @note the XSD has this as a NonNegativeInteger
+      # @!attribute [r] x
+      #   @return [Float]
+      model_attr :x
       # The y (towards the bottom, associated with height) attribute from the Top,Left (i.e. 0,0)
       # corner of the diagram to the Top, Left corner of the bounding box of the concept.
-      attribute :y, NonNegativeFloat # Note the XSD has this as an Int, NonNegativeInteger
+      # @note the XSD has this as a NonNegativeInteger
+      # @!attribute [r] y
+      #   @return [Float]
+      model_attr :y
 
       # These are holdovers from the archi file format and are only maintained for compatability
-      attribute :end_x, Coercible::Int.optional
-      attribute :end_y, Coercible::Int.optional
+      # @!attribute [r] end_x
+      #   @return [Int, NilClass]
+      model_attr :end_x
+      # @!attribute [r] end_y
+      #   @return [Int, NilClass]
+      model_attr :end_y
+
+      def initialize(x:, y:, end_x: nil, end_y: nil)
+        @x = x.to_i
+        @y = y.to_i
+        @end_x = end_x.nil? ? nil : end_x.to_i
+        @end_y = end_y.nil? ? nil : end_y.to_i
+      end
 
       def to_s
         "Location(x: #{x}, y: #{y})"
       end
     end
-
-    Dry::Types.register_class(Location)
-    LocationList = Strict::Array.member(Location).default([])
   end
 end