jekyll-archimate 0.2.2 → 0.2.3

data/lib/jekyll/archimate/catalog_tag.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Jekyll
   module Archimate
     # Insert a diagram from the ArchiMate model.
@@ -9,6 +11,7 @@ module Jekyll
       attr_reader :caption
       attr_reader :element_types
       attr_reader :markup
+      attr_reader :model
 
       def initialize(tag_name, markup, tokens)
         @markup = markup
@@ -20,12 +23,13 @@ module Jekyll
 
       def render(context)
         @context = context
+        @model = ArchimateCache.instance.model
         scan_attributes(context)
         render_table
       end
 
       def render_table
-        <<-END.gsub(/^ {6}/, '')
+        <<-TABLE.gsub(/^ {6}/, '')
         <table>
           <caption>#{caption}</caption>
           <thead>
@@ -36,26 +40,33 @@ module Jekyll
             </tr>
           </thead>
           <tbody>
-          #{render_rows(elements(site.data["archimate"]["catalog"]))}
+          #{render_rows(elements)}
           </tbody>
         </table>
-        END
+        TABLE
       end
 
-      def elements(catalog)
-        @element_types.map { |element_type| catalog[element_type] }.flatten.compact
+      def elements
+        @element_types
+          .map do |element_type|
+            model
+              .elements
+              .select { |el| el.type == element_type }
+          end
+          .flatten
+          .compact
       end
 
       def render_rows(elements)
         return "<tr><td colspan=\"3\">No Items</td></tr>" if elements.empty?
         elements.map do |element|
-          <<-END
+          <<-TABLE_ROW
           <tr>
-            <td><span class="badge badge-primary">#{element["type"]}</span> #{element["name"]}</td>
-            <td>#{@converter.convert(element["documentation"]).gsub(/<\/?p[^>]*>/, '').chomp if element["documentation"]}</td>
-            <td>#{render_properties(element["properties"])}</td>
+            <td><span class="badge badge-primary">#{element.type}</span> #{element.name}</td>
+            <td>#{@converter.convert(element.documentation.to_s).gsub(%r{</?p[^>]*>}, '').chomp if element.documentation}</td>
+            <td>#{render_properties(element.properties)}</td>
           </tr>
-          END
+          TABLE_ROW
         end.join("")
       end
 
@@ -78,7 +89,8 @@ module Jekyll
         end
 
         caption = attributes['caption']&.gsub!(/\A"|"\Z/, '')
-        @caption = @converter.convert(caption).gsub(/<\/?p[^>]*>/, '').chomp if @caption
+        # @caption = @converter.convert(caption).gsub(/<\/?p[^>]*>/, '').chomp if @caption
+        @caption = @converter.convert(caption).gsub(%r{</?p[^>]*>}, '').chomp if @caption
         element_type = attributes['type']
         element_type = element_type.gsub!(/\A"|"\Z/, '') if element_type
         @element_types = element_type.split(",").map(&:strip)
@@ -98,4 +110,3 @@ module Jekyll
 end
 
 Liquid::Template.register_tag("catalog", Jekyll::Archimate::CatalogTag)
-

data/lib/jekyll/archimate/conditional_file.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Archimate
+    # Persists an ArchiMate diagram to a file
+    class ConditionalFile
+      attr_reader :site
+      attr_reader :dir
+      attr_reader :name
+      attr_reader :filename
+      attr_reader :archimate_file
+      attr_reader :relative_path
+
+      def initialize(site, dir, name, archimate_file)
+        @site = site
+        @dir = dir
+        @name = name
+        @archimate_file = archimate_file
+        @filename = File.join(site.source, dir, name)
+        @relative_path = File.join(dir, name)
+      end
+
+      def needs_write?(content)
+        return true unless File.exist?(filename)
+        return true if archimate_file.modified_time.to_i > File.mtime(filename).to_i
+        File.read(filename) != content
+      end
+
+      # Writes content to filename if
+      # * File doesn't exit
+      # * Or File content is different than content
+      def write(content)
+        return unless needs_write?(content)
+        Jekyll.logger.info "Rendering #{relative_path}"
+      end
+
+      private
+
+      def write_file(content)
+        File.open(filename, "w") { |file| file.write(content) }
+        site.static_files << Jekyll::StaticFile.new(site, site.source, dir, name)
+      end
+    end
+  end
+end

data/lib/jekyll/archimate/diagram_entity.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Archimate
+    # Represents an ArchiMate Diagram
+    class DiagramEntity < EntityBase
+      def attr_hash
+        super.merge(
+          type: "Diagram",
+          path: "svg/#{entity.id}.svg",
+          viewpoint: entity.viewpoint,
+          elements: entity.elements.map(&:id),
+          relationships: entity.relationships.map(&:id),
+          views: []
+        )
+      end
+    end
+  end
+end

data/lib/jekyll/archimate/element_entity.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Archimate
+    # Represents an ArchiMate Element
+    class ElementEntity < EntityBase
+      def attr_hash
+        super.merge(
+          type: "Element",
+          element_type: entity.type,
+          relationships: element_relationships,
+          views: model.diagrams.select { |dia| dia.element_ids.include?(entity.id) }.map(&:id)
+        )
+      end
+
+      private
+
+      def element_relationships
+        model.relationships.select do |rel|
+          rel.source&.id == entity.id || rel.target&.id == entity.id
+        end
+             .map(&:id)
+      end
+    end
+  end
+end

data/lib/jekyll/archimate/entity_base.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Archimate
+    # Base class for ArchiMate Entities: Model, Diagram, Element, Relationship
+    class EntityBase
+      attr_reader :entity
+      attr_reader :model
+
+      def initialize(entity, model: nil)
+        @entity = entity
+        @model = model
+      end
+
+      def to_h
+        Archimate.hash_purge(attr_hash)
+      end
+
+      def attr_hash
+        {
+          id: entity.id,
+          name: entity.name,
+          documentation: entity.documentation&.to_h,
+          properties: entity.properties.map(&:to_h)
+        }
+      end
+    end
+  end
+end

data/lib/jekyll/archimate/folder.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Archimate
+    # Represents an ArchiMate Organizing Folder
+    class Folder
+      attr_reader :folder
+
+      def initialize(folder)
+        @folder = folder
+      end
+
+      # This item check is necessary because some models seem to contain
+      # an item that is a string rather than an element of some sort.
+      def items
+        folder.items.map { |item| item.is_a?(String) ? item : item.id }
+      end
+
+      def to_h
+        Archimate.hash_purge(
+          id: folder.id,
+          name: folder.name.to_s,
+          folders: folder.organizations.map { |child| Folder.new(child).to_h },
+          diagrams: items
+        )
+      end
+    end
+  end
+end

data/lib/jekyll/archimate/json_file.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Archimate
+    # Writes any object that can be hashified (with to_h) to a JSON file
+    class JsonFile
+      def initialize(filename)
+        @filename = filename
+      end
+
+      def write(obj)
+        File.open(@filename, "wb") do |file|
+          file.write(JSON.generate(obj.to_h))
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/archimate/matrix_tag.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Jekyll
   module Archimate
     # Insert a diagram from the ArchiMate model.
@@ -5,12 +7,13 @@ module Jekyll
     #   {% matrix plateau:"Today" | caption: "Today's Application Interaction" }
     #
     class MatrixTag < Liquid::Tag
+      EMPTY_CELL = "<td></td>"
+
       attr_reader :context
       attr_reader :caption
       attr_reader :element_types
       attr_reader :markup
 
-
       def initialize(tag_name, markup, tokens)
         @markup = markup
         @context = nil
@@ -26,104 +29,52 @@ module Jekyll
         render_table
       end
 
-      # Here I want all of the Serving relationships between 2 app components
-      # included or derived.
-      #
-      # attrs:
-      # source_selector: Element selector for source elements
-      # target_selector: Element selector for target elements
-      # relationship_selector
-      def application_interaction
-        model = site.data["archimate_model"]
-        dr_engine = ::Archimate::DerivedRelations.new(model)
-
-        relationship_filter = lambda { |rel| rel.weight >= ::Archimate::DataModel::Serving::WEIGHT }
-
-        plateau_today = dr_engine.element_by_name("Today")
-        today_rels = model.relationships.select do |rel|
-          rel.source.id == plateau_today.id &&
-            %w{CompositionRelationship AggregationRelationship}.include?(rel.type) &&
-            rel.target.type == "ApplicationComponent"
-        end
-        today_apps = today_rels.map { |rel| rel.target }
-        source_filter = lambda { |el|  }
-        target_filter = lambda { |el| today_apps.map(&:id).include?(el.id) }
-        stop_filter = lambda { |el| el.type == "ApplicationComponent" }
-
-        concrete_rels = model.relationships.select { |rel|
-          rel.type == "ServingRelationship" &&
-            today_apps.include?(rel.source.id) &&
-            today_apps.include?(rel.target.id)
-        }
-
-        derived_rels = dr_engine.derived_relations(
-          today_apps,
-          relationship_filter,
-          target_filter,
-          stop_filter
-        )
-
-        @all_rels = [concrete_rels, derived_rels].flatten
-
-        @callers = @all_rels.map(&:source).uniq.sort { |a, b| a.name.to_s <=> b.name.to_s }
-        @callees = @all_rels.map(&:target).uniq.sort { |a, b| a.name.to_s <=> b.name.to_s }
-      end
-
-      def matrix_data
-        model = site.data["archimate_model"]
-        dr_engine = ::Archimate::DerivedRelations.new(model)
-
-      end
-
       def render_table
-        <<~END
-        <table class="table table-condensed table-hover table-striped">
-        <caption>#{caption}</caption>
-        <thead>
-        <tr>
-        <th>&nbsp;</th>
-        <th class="success" scope="col" colspan="#{@callers.size}">Callers</th>
-        </tr>
-        <tr>
-        <th class="info" scope="col">Callees</th>
-        #{@callers.map { |ac| "<th class=\"success\" scope=\"col\" style=\"text-transform: capitalize\">#{ac.name}</th>" }.join("\n")}
-        </tr>
-        </thead>
-        <tbody>
-        #{render_rows.strip}
-        </tbody>
-        </table>
-        END
+        <<~TABLE
+          <table class="table table-condensed table-hover table-striped">
+          <caption>#{caption}</caption>
+          <thead>
+          <tr>
+          <th>&nbsp;</th>
+          <th class="success" scope="col" colspan="#{@callers.size}">Callers</th>
+          </tr>
+          <tr>
+          <th class="info" scope="col">Callees</th>
+          #{@callers.map { |ac| "<th class=\"success\" scope=\"col\" style=\"text-transform: capitalize\">#{ac.name}</th>" }.join("\n")}
+          </tr>
+          </thead>
+          <tbody>
+          #{render_rows.strip}
+          </tbody>
+          </table>
+        TABLE
       end
 
       def render_rows
         return "<tr><td>No Items</td></tr>" if @callees.empty?
         @callees.map do |callee|
-          <<~END
-          <tr>
-          <th class="info" scope="row">#{callee.name}</th>
-          #{@callers.map { |caller| cell_content(caller, callee) }.join("")}
-          </tr>
-          END
+          <<~TABLE_ROW
+            <tr>
+            <th class="info" scope="row">#{callee.name}</th>
+            #{@callers.map { |caller| cell_content(caller, callee) }.join('')}
+            </tr>
+          TABLE_ROW
         end.join("")
       end
 
       def cell_content(caller, callee)
         rels = @all_rels.select { |rel| rel.source == caller && rel.target == callee }
-        if rels.empty?
-          "<td></td>"
-        else
-          derived = rels.all? { |rel| rel.derived }
-          span_class = derived ? "text-danger" : "text-primary"
-          tooltip = "#{caller.name} &rarr; #{}#{callee.name} #{"(derived)" if derived}"
-          cell = <<~END
+        return EMPTY_CELL if rels.empty?
+        derived = rels.all?(&:derived)
+        span_class = derived ? "text-danger" : "text-primary"
+        tooltip = "#{caller.name} &rarr; #{callee.name} #{'(derived)' if derived}"
+        <<~TABLE_CELL
           <td>
           <a href="#" data-toggle="tooltip" data-placement="top" title="#{tooltip}">
           <span class="#{span_class}">&crarr; calls</span>
           </a>
           </td>
-          END
-        end
+        TABLE_CELL
       end
 
       def scan_attributes(context)
@@ -157,4 +108,3 @@ module Jekyll
 end
 
 Liquid::Template.register_tag("matrix", Jekyll::Archimate::MatrixTag)
-

data/lib/jekyll/archimate/model_entity.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Archimate
+    # Represents the overall model
+    class ModelEntity < EntityBase
+      def attr_hash
+        super.merge(
+          type: "Model"
+        )
+      end
+    end
+  end
+end

data/lib/jekyll/archimate/relationship_entity.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Archimate
+    # Represents an ArchiMate Relationship
+    class RelationshipEntity < EntityBase
+      def attr_hash
+        super.merge(
+          type: "Relationship",
+          relationship_type: entity.type,
+          source: entity.source&.id,
+          target: entity.target&.id,
+          views: relationship_views
+        )
+      end
+
+      private
+
+      def relationship_views
+        model.diagrams.select { |dia| dia.relationship_ids.include?(entity.id) }.map(&:id)
+      end
+    end
+  end
+end