archimate 1.2.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bb777d171110c638d84d1e51687d52cde0fa7270
-  data.tar.gz: 262cdd92904cbe280e73f21cf55082221621f4da
+  metadata.gz: 8b8d5f63a78b5e98d3791d8d58ea7474ad874325
+  data.tar.gz: 3cfc66538c6cbaf0792e96ca208712deff1ea194
 SHA512:
-  metadata.gz: 7b432f2cf362430029f3a15446e0173ebcbedf7d6aac18ffde1b4ef9d280eba8f454e283a2ad511eeb4724b15501a0a1c8c831034cab80328c31b6fdcc8b780d
-  data.tar.gz: 29d7c8bf731ea8bc755b15e3282efadfd38ec14ca1d1a8bdde9b649ce15e5326c5f90e21a64742d03f01e1c1e1d20f9181a34a0c78c00bc3663bf5b8e72ec24f
+  metadata.gz: fe459d02990c355cd440e1460ec8bfac1019a6c3984918d4ee5ea53e9cb8709fd16bcfdf3f29ea3de5b7dbfaca01459143ec6de1294a9d402137e59fafcef1f2
+  data.tar.gz: 1d91a6c7e3cf0f0e0d7aaba0ba1068f0b74c5d08eca30d9e7541e5f15c066b237552eaab001bfa0cc6510459b07d754036bdd18825016213cd55ceca331d10d9

data/README.md

@@ -32,10 +32,57 @@ command        | description
 `archimate convert ARCHIFILE` | Convert the incoming file to the desired type
 `archimate dedupe ARCHIFILE` | de-duplicate elements in Archi file
 `archimate map ARCHIFILE` | *EXPERIMENTAL:* Produce a map of diagram links to a diagram
+`archimate merge ARCHIFILE1 ARCHIFILE2` | *EXPERIMENTAL:*Merge two archimate files
 `archimate project ARCHIFILE PROJECTFILE` | *EXPERIMENTAL:*Synchronize an Archi file and an MSProject XML file
 `archimate svg ARCHIFILE` | Produce semantically meaningful SVG files from an Archi file
 `archimate lint ARCHIFILE` | Produce a report of warnings and issues in the Archi file
 
+### archidiff & archimerge
+
+Archidiff is a set of tools to help with versioning an `.archimate` file from Archi in a version control system (like git). Eventually I want to provide diff and (3-way) merge tools that understand how *Archi* files are structured and avoid problems that happen when multiple people collaborate on a model.
+
+To enable using these from the command line git, add these lines to your `~/.gitconfig` replacing `{PATH_TO_ARCHIDIFF}` with the path to the archidiff binaries.
+
+```
+[difftool "archidiff"]
+    cmd = {PATH_TO_ARCHIDIFF}/archidiff $LOCAL $REMOTE
+
+[difftool "archidiff-summary"]
+    cmd = {PATH_TO_ARCHIDIFF}/archidiff-summary $LOCAL $REMOTE
+
+[mergetool "archimerge"]
+	cmd = {PATH_TO_ARCHIDIFF}/archimerge $PWD/$BASE $PWD/$REMOTE $PWD/$LOCAL $PWD/$MERGED
+	trustExitCode = false
+```
+
+Then to use the tool for diffing you can do this:
+
+```sh
+git difftool --tool archidiff 833cbb7 HEAD  -- path_to/my.archimate
+```
+
+or to see a summary of what changed between versions:
+
+```sh
+git difftool --tool archidiff-summary 833cbb7 HEAD  -- path_to/my.archimate
+```
+
+Finally, if you have a merge conflict, you can use archimerge to help make the merge sane:
+
+```sh
+git mergetool --tool archimerge -- path_to/my.archimate
+```
+
+### fmtxml
+
+Can be used as a `textconv` filter in .gitconfig to pre-format files for better diff use (for visual scanning). You'd set this up in your `$HOME/.gitconfig` file like this.
+
+```
+[diff "archimate"]
+    textconv = fmtxml
+    cachetextconv = true
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/TODOs.org

@@ -284,3 +284,222 @@ effective_entity : (child -> element_name_type)
 get effective entity
 
 that's used to match the rest:
+
+Intermittent Failure with test --seed 11297
+
+---
+
+Remove Id references in preference to object references
+
+Done:
+
+Property (PropertyDefinitionId)
+
+TODO:
+
+Relationship (Source & Target)
+View (Viewpoint)
+
+Connection (For Source & Targets)
+Label (Not Currently Used)
+ViewConcept (View {Concept} list)
+ViewNode (model, targetConnections, archimateNode)
+
+---
+
+Part of Better Diff/Merge redux
+
+What about the path? Need a way to describe diffs & conflicts back to meaningful user world terms. (not id oriented)
+
+Eliminate the use of DiffableArray by making a class for collections
+Eliminate the use of Diffable Primitive with a smarter context diff
+
+Referenceable Object Instance Classes
+
+Archimate::DataModel::Model < Archimate::DataModel::NamedReferenceable
+Archimate::DataModel::PropertyDefinition < Archimate::DataModel::NamedReferenceable,
+Archimate::DataModel::Element < Archimate::DataModel::Concept,
+Archimate::DataModel::Relationship < Archimate::DataModel::Concept,
+Archimate::DataModel::Diagram < Archimate::DataModel::View,
+  Archimate::DataModel::ViewNode < Archimate::DataModel::Referenceable,
+  Archimate::DataModel::Connection < Archimate::DataModel::Referenceable,
+
+What are the non-referenceable things that might be included by a less automated diff?
+
+Model
+  (from Referenceable)
+  id
+  name
+  documentation: Array of LangString - really should be a LangString type (I believe)
+  type: String - TODO: need to handle US/UK spelling differences and naming differences between Archi/ArchiMate2.1/ArchiMate3
+  properties
+  metadata
+  elements
+  relationships
+  organizations
+  property_definitions
+  version
+  diagrams
+  viewpoints
+  filename
+  file_format
+  archimate_version
+  namespaces
+  schema_locations
+
+PropertyDefinition
+  (from Referenceable)
+  id
+  name
+  documentation: Array of LangString - really should be a LangString type (I believe)
+  type: String
+  (from PropertyDefinition)
+  value_type (DataType)
+
+Element
+  (from Referenceable)
+  id
+  name
+  documentation: Array of LangString - really should be a LangString type (I believe)
+  type: String
+  properties (from Concept)
+
+Relationship
+  (from Referenceable)
+  id
+  name
+  documentation: Array of LangString - really should be a LangString type (I believe)
+  type: String
+  source
+  target
+  access_type
+
+Diagram
+  (from Referenceable)
+  id
+  name
+  documentation: Array of LangString - really should be a LangString type (I believe)
+  type: String
+  (from View)
+  properties
+  viewpoint_type
+  viewpoint
+  (from Diagram)
+  nodes (ViewNode collection)
+  connection_router_type (int - enum, Archi only)
+  background (int Archi only)
+  connections (Connection Collection)
+
+ViewNode
+  (from Referenceable)
+  id
+  name
+  documentation: Array of LangString - really should be a LangString type (I believe)
+  type: String
+  model: (identifier - what is this? Archi Only)
+  content: string
+  target_connections: (Archi only, identifiers, collection of ids of targets, TODO, probably not needed)
+  archimate_element (Element)
+  bounds
+  nodes: (ViewNode collection)
+  connections (Connection collection)
+  style
+  type
+  child_type: (TODO: int this selects the shape of the object)
+  properties
+
+There are some sub-classes here that might be valuable to implement?
+Connection
+  (from Referenceable)
+  id
+  name
+  documentation: Array of LangString - really should be a LangString type (I believe)
+  type: String
+  source_attachment (Location)
+  bendpoints
+  target_attachment (Location)
+  source
+  target
+  relationship
+  style
+  properties
+
+What about Organizations - they are horrifically defined in ArchiMate 3. Need an internal model that isn't so insane and is diffable/mergable.
+
+---
+
+Diff implementation
+
+The refinements implementation is hokey. A lot of code and makes thing fragile.
+
+Diff calculation
+
+In most collections (except ones under diagram), the order of items doesn't matter - except it helps make textual diffs of models smaller.
+
+insert and delete are probably only useful for collections
+
+change is typical
+
+how would move be implemented (i.e. move between collections)
+What's the best data structure for collections to make diffs and merges easier? Diff lcs?
+
+validation on demand rather than at creation of data model in absence of dry-struct? Switchable by global setting?
+
+How would we add archimate modules (new concept)? privacy? Timeline? Transitional architectures?
+
+---
+
+Diff
+
+- [ ] User friendly text description
+- [ ] User friendly description includes location information in the model (I.e diagram it's located in, elements describing relationship, and so on)
+- [ ] Diffs can be compared to see if they are in conflict
+- [ ] Diff can be applied to a model to patch model
+
+* TODO Eliminate Documentation class - it's a LangString
+* TODO Make LangString be like a Hash with lang as key and string as value
+* TODO Make LangString use a default lang (stored in Archimate module)
+
+---
+
+Strict::Array.member(AnyAttribute).default([])
+Strict::Array.member(AnyElement).default([])
+Strict::Array.member(Concern).default([])
+Strict::Array.member(Connection).default([])
+Strict::Array.member(Diagram).default([])
+Strict::Array.member(Element).default([])
+Strict::Array.member(ElementType).default([])
+Strict::Array.member(LangString)
+Strict::Array.member(Location).default([])
+Strict::Array.member(ModelingNote).default([])
+Strict::Array.member(Organization).default([])
+Strict::Array.member(Property).default([])
+Strict::Array.member(PropertyDefinition).default([])
+Strict::Array.member(Referenceable).default([])
+Strict::Array.member(Relationship).default([])
+Strict::Array.member(RelationshipType).default([])
+Strict::Array.member(SchemaInfo).default([])
+Strict::Array.member(Strict::String).default([])
+Strict::Array.member(ViewNode).default([])
+Strict::Array.member(Viewpoint).default([])
+Strict::Array.member(ViewpointContentEnum).default([])
+Strict::Array.member(ViewpointPurposeEnum).default([])
+
+---
+
+Use locale for LangString
+IRB::Locale.new.lang
+
+---
+
+referenced_identified_nodes
+Model->
+
+Diagram
+  ViewNode
+    Container
+  Connection
+Element (Property->PropertyDefinition)
+Organization
+Relationship
+

data/archimate.gemspec

@@ -21,12 +21,13 @@ Gem::Specification.new do |spec|
   spec.metadata["yard.run"] = "yri" # use "yard" to build full HTML docs.
   spec.required_ruby_version = '>= 2.3.0'
 
-  spec.add_runtime_dependency "dry-struct", "~> 0.3.0"
   spec.add_runtime_dependency "nokogiri", "~> 1.6"
   spec.add_runtime_dependency "thor", "~> 0.19"
   spec.add_runtime_dependency "highline", "~> 1.7"
   spec.add_runtime_dependency "ruby-progressbar", "~>1.8.1"
   spec.add_runtime_dependency "parallel", "~> 1.11"
+  spec.add_runtime_dependency "ruby-enum", "~> 0.7.1"
+  # spec.add_runtime_dependency "diff-lcs", "~> 1.3"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"

data/exe/archidiff

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby -w
+# frozen_string_literal: true
+
+require "rubygems"
+require "archimate"
+
+Archimate::Cli::Diff.diff(ARGV[0], ARGV[1], Archimate::AIO.new)

data/exe/archidiff-summary

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby -w
+# frozen_string_literal: true
+
+require "rubygems"
+require "archimate"
+
+Archimate::Cli::DiffSummary.diff(ARGV[0], ARGV[1])

data/exe/archimerge

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby -w
+# frozen_string_literal: true
+
+require "rubygems"
+require "archimate"
+
+Archimate::Cli::Merge.merge(ARGV[0], ARGV[1], ARGV[2], ARGV[3])

data/exe/fmtxml

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "archimate"
+
+Archimate::Cli::XmlTextconv.new(ARGV[0])

data/lib/archimate.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
-require "dry-types"
-require "dry-struct"
-
 module Archimate
+  # Support Archimate file format versions
   SUPPORTED_FORMATS = %i[
     archi_3
     archi_4
@@ -11,6 +9,7 @@ module Archimate
     archimate_3_0
   ].freeze
 
+  # Archimate modeling specification version
   ARCHIMATE_VERSIONS = %i[
     archimate_2_1
     archimate_3_0
@@ -32,27 +31,18 @@ module Archimate
     autoload :GraphML, 'archimate/export/graph_ml'
     autoload :CSVExport, 'archimate/export/csv_export'
     autoload :Cypher, 'archimate/export/cypher'
+    autoload :Jsonl, 'archimate/export/jsonl'
   end
 
   module FileFormats
-    autoload :ArchimateV2, 'archimate/file_formats/archimate_v2'
     autoload :ArchiFileFormat, 'archimate/file_formats/archi_file_format'
     autoload :ArchiFileReader, 'archimate/file_formats/archi_file_reader'
     autoload :ArchiFileWriter, 'archimate/file_formats/archi_file_writer'
-    autoload :ModelExchangeFileFormat, 'archimate/file_formats/model_exchange_file_format'
     autoload :ModelExchangeFileReader, 'archimate/file_formats/model_exchange_file_reader'
-    autoload :ModelExchangeFileReader21, 'archimate/file_formats/model_exchange_file_reader_21'
-    autoload :ModelExchangeFileReader30, 'archimate/file_formats/model_exchange_file_reader_30'
-    autoload :ModelExchangeFileWriter, 'archimate/file_formats/model_exchange_file_writer'
     autoload :ModelExchangeFileWriter21, 'archimate/file_formats/model_exchange_file_writer_21'
     autoload :ModelExchangeFileWriter30, 'archimate/file_formats/model_exchange_file_writer_30'
-    autoload :Writer, 'archimate/file_formats/writer'
-    module ModelExchangeFile
-      autoload :XmlLangString, 'archimate/file_formats/model_exchange_file/xml_lang_string'
-      autoload :XmlMetadata, 'archimate/file_formats/model_exchange_file/xml_metadata'
-      autoload :XmlPropertyDefinitions, 'archimate/file_formats/model_exchange_file/xml_property_definitions'
-      autoload :XmlPropertyDefs, 'archimate/file_formats/model_exchange_file/xml_property_defs'
-    end
+    autoload :Sax, 'archimate/file_formats/sax'
+    autoload :Serializer, 'archimate/file_formats/serializer'
   end
 
   module Lint
@@ -68,6 +58,7 @@ module Archimate
     autoload :Entity, 'archimate/svg/entity'
     autoload :EntityFactory, 'archimate/svg/entity_factory'
     autoload :Extents, 'archimate/svg/extents'
+    autoload :Path, 'archimate/svg/path'
     autoload :Point, 'archimate/svg/point'
     autoload :SvgTemplate, 'archimate/svg/svg_template'
   end
@@ -87,17 +78,15 @@ module Archimate
   # @param filename File name of the file to read
   # @return Archimate::DataModel::Model of ArchiMate model in the file
   def self.read(filename)
+    raise "#{filename.inspect} not found" unless File.exist?(filename)
     FileFormat.read(filename)
   end
 
   # Reads the given file and returns the Archimate model
   #
-  # @param filename File name of the file to read
+  # @param str XML string containing the Archimate model
   # @return Archimate::DataModel::Model of ArchiMate model in the file
-  def self.parse(filename)
-    FileFormat.parse(filename)
+  def self.parse(str)
+    FileFormat.parse(str)
   end
-
-  using DataModel::DiffablePrimitive
-  using DataModel::DiffableArray
 end

data/lib/archimate/cli/archi.rb

@@ -8,7 +8,8 @@ module Archimate
       if output_io.is_a?(String)
         if !force && File.exist?(output_io)
           # TODO: This needs to be handled with more grace
-          return nil unless @hl.agree("File #{output_io} exists. Overwrite?")
+          cli = HighLine.new
+          return nil unless cli.agree("File #{output_io} exists. Overwrite?")
         end
         output_io = File.open(output_io, "w")
       end

data/lib/archimate/cli/cleanup.rb

@@ -1,4 +1,6 @@
 # frozen_string_literal: true
+require "nokogiri"
+
 #
 # The point of this script is to identify elements that aren't a part of any
 # relationship and not referenced on any diagrams.
@@ -23,16 +25,13 @@ module Archimate
       end
 
       def remove_unreferenced_nodes
-        model.unreferenced_nodes.each do |id|
-          ns = model.lookup(id)
-          puts "Found duplicate ids: #{ns}" if ns.size > 1
-          unreferenced_node = ns[0]
+        model.unreferenced_nodes.each do |unreferenced_node|
+          raise "This functionality is not implemeted yet"
+
+          # TODO: this needs to be the XML serialization of the node
           trash.root.add_child unreferenced_node.dup
-          prev_sib = unreferenced_node.previous_sibling
-          if prev_sib.instance_of?(Nokogiri::XML::Text) && prev_sib.content.strip.empty?
-            ns << prev_sib
-          end
-          ns.remove
+          # TODO: implement this
+          # model.delete(unreferenced_node)
           @progressbar.increment
         end
       end