jekyll-archimate 0.2.2 → 0.2.3

data/lib/jekyll/archimate/svg_file.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Archimate
+    # Persists an ArchiMate diagram to a file
+    class SvgFile
+      def initialize(filename)
+        @filename = filename
+      end
+
+      def write(diagram)
+        File.open(@filename, "wb") do |svg_file|
+          svg_file.write(::Archimate::Svg::Diagram.new(diagram).to_svg)
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/archimate/unified_model.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Archimate
+    # This is the top level object used by the web Archimate Navigator
+    class UnifiedModel
+      attr_reader :model
+
+      def initialize(model)
+        @model = model
+      end
+
+      def to_h
+        {
+          entities: entities,
+          folders: folders
+        }
+      end
+
+      def elements
+        model.elements.map { |element| ElementEntity.new(element, model: model).to_h }
+      end
+
+      def relationships
+        model.relationships.map { |relationship| RelationshipEntity.new(relationship, model: model).to_h }
+      end
+
+      def diagrams
+        model.diagrams.map { |diagram| DiagramEntity.new(diagram).to_h }
+      end
+
+      def entities
+        [ModelEntity.new(model).to_h].concat(
+          elements
+        ).concat(
+          relationships
+        ).concat(
+          diagrams
+        )
+      end
+
+      def folders
+        [Folder.new(model.organizations.last).to_h]
+      end
+    end
+  end
+end

data/lib/jekyll/archimate/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Jekyll
   module Archimate
-    VERSION = "0.2.2"
+    VERSION = "0.2.3"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-archimate
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Mark Morga
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-10-25 00:00:00.000000000 Z
+date: 2017-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jekyll
@@ -101,9 +101,21 @@ files:
 - lib/jekyll/archimate/application_interaction_matrix_tag.rb
 - lib/jekyll/archimate/archimate_cache.rb
 - lib/jekyll/archimate/archimate_diagram_tag.rb
-- lib/jekyll/archimate/archimate_hook.rb
+- lib/jekyll/archimate/archimate_generator.rb
+- lib/jekyll/archimate/archimate_index_generator.rb
+- lib/jekyll/archimate/archimate_svg_generator.rb
 - lib/jekyll/archimate/catalog_tag.rb
+- lib/jekyll/archimate/conditional_file.rb
+- lib/jekyll/archimate/diagram_entity.rb
+- lib/jekyll/archimate/element_entity.rb
+- lib/jekyll/archimate/entity_base.rb
+- lib/jekyll/archimate/folder.rb
+- lib/jekyll/archimate/json_file.rb
 - lib/jekyll/archimate/matrix_tag.rb
+- lib/jekyll/archimate/model_entity.rb
+- lib/jekyll/archimate/relationship_entity.rb
+- lib/jekyll/archimate/svg_file.rb
+- lib/jekyll/archimate/unified_model.rb
 - lib/jekyll/archimate/version.rb
 homepage: https://github.com/mmorga/jekyll-archimate
 licenses: []

data/lib/jekyll/archimate/archimate_hook.rb

@@ -1,265 +0,0 @@
-# frozen_string_literal: true
-require "archimate"
-require "yaml"
-
-module Jekyll
-  module Archimate
-    # Removes all keys that have null or empty values
-    def self.hash_purge(hash)
-      hash.delete_if { |_, value| !value || (value.is_a?(String) && value.empty?) }
-    end
-
-    # 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
-
-    # Represents the overall model
-    class ModelEntity < EntityBase
-      def attr_hash
-        super.merge(
-          type: "Model"
-        )
-      end
-    end
-
-    # Represents an ArchiMate Element
-    class ElementEntity < EntityBase
-      def attr_hash
-        super.merge(
-          type: "Element",
-          element_type: entity.type,
-          relationships: model.relationships.select { |rel| rel.source&.id == entity.id || rel.target&.id == entity.id }.map(&:id),
-          views: model.diagrams.select { |dia| dia.element_ids.include?(entity.id) }.map(&:id)
-        )
-      end
-    end
-
-    # 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: model.diagrams.select { |dia| dia.relationship_ids.include?(entity.id) }.map(&:id)
-        )
-      end
-    end
-
-    # 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
-
-    # 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
-
-    # This is the top level object used by the web Archimate Navigator
-    class UnifiedModel
-      attr_reader :model
-
-      def initialize(model)
-        @model = model
-      end
-
-      def to_h
-        {
-          entities: entities,
-          folders: folders
-        }
-      end
-
-      def elements
-        model.elements.map { |element| ElementEntity.new(element, model: model).to_h }
-      end
-
-      def relationships
-        model.relationships.map { |relationship| RelationshipEntity.new(relationship, model: model).to_h }
-      end
-
-      def diagrams
-        model.diagrams.map { |diagram| DiagramEntity.new(diagram).to_h }
-      end
-
-      def entities
-        [ModelEntity.new(model).to_h].concat(
-          elements).concat(
-            relationships).concat(
-              diagrams)
-      end
-
-      def folders
-        [Folder.new(model.organizations.last).to_h]
-      end
-    end
-
-    # 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
-
-    # Persists an ArchiMate diagram to a file
-    class SvgFile
-      def initialize(filename)
-        @filename = filename
-      end
-
-      def write(diagram)
-        File.open(@filename, "wb") do |svg_file|
-          svg_file.write(::Archimate::Svg::Diagram.new(diagram).to_svg)
-        end
-      end
-    end
-
-    # Configuration variables:
-    # clean: clean destination directories before rendering
-    # layout: layout to use for the archimate navigator
-    class ArchimateHook
-      attr_reader :clean_generated_dirs
-      attr_reader :site
-      attr_reader :model
-      attr_reader :archimate_file
-
-      def initialize(site, archimate_file)
-        @site = site
-        @archimate_file = archimate_file
-        @clean_generated_dirs = @site.config.fetch('clean', false)
-        @model = ArchimateCache.load_model(archimate_file.sub(site.source, ""))
-        @site.data["archimate_model"] = @model
-      end
-
-      def generate
-        export_svgs
-        export_unified_json
-        export_catalogs
-      end
-
-      def export_unified_json
-        dest_file = File.join(File.dirname(archimate_file), 'index.json')
-        dest_mtime = File.exist?(dest_file) && File.mtime(dest_file)
-        return unless !dest_mtime || File.mtime(archimate_file) > dest_mtime
-        JsonFile.new(dest_file).write(UnifiedModel.new(model))
-      end
-
-      def svg_dest_dir
-        @svg_dest_dir ||= File.join(File.dirname(archimate_file), 'svg')
-      end
-
-      def svgs_need_export?
-        Dir.mkdir(svg_dest_dir) unless Dir.exist?(svg_dest_dir)
-        last_svg_mtime = Dir.glob(File.join(svg_dest_dir, "*.svg")).map { |svg_file| File.mtime(svg_file) }.max
-        !last_svg_mtime || File.mtime(archimate_file) > last_svg_mtime
-      end
-
-      def export_svgs
-        return unless svgs_need_export?
-        model.diagrams.each do |diagram|
-          SvgFile.new(File.join(svg_dest_dir, "#{diagram.id}.svg")).write(diagram)
-        end
-      end
-
-      def export_catalogs
-        data = File.join(site.source, "_data")
-        Dir.mkdir(data) unless Dir.exist?(data)
-        archimate = File.join(data, "archimate")
-        Dir.mkdir(archimate) unless Dir.exist?(archimate)
-        catalog = File.join(archimate, "catalog.yml")
-        File.open(catalog, "wb") do |file|
-          file.write(
-            model
-              .elements
-              .chunk { |el| el.type }
-              .each_with_object({}) { |(type, els), hash|
-                hash[type] = els.map { |el| catalog_element(el) }
-              }
-              .to_yaml
-          )
-        end
-      end
-
-      def catalog_element(el)
-        [:id, :name, :documentation, :type, :properties].each_with_object({}) do |sym, hash|
-          hash[sym] = el.send(sym)
-        end
-        {
-          "id" => el.id,
-          "name" => el.name.to_s,
-          "documentation" => el.documentation&.to_s,
-          "type" => el.type,
-          "properties" => el.properties.each_with_object({}) do |property, hash|
-            hash[property.key.to_s] = property.value.to_s
-          end
-        }
-      end
-    end
-  end
-end
-
-Jekyll::Hooks.register :site, :pre_render do |site|
-  Jekyll.logger.info "ArchiMate Generator..."
-  Dir.glob("#{site.source}/**/*.archimate").each do |archimate_file|
-    unless archimate_file.start_with?(site.dest) || archimate_file.sub(site.source, "").start_with?("/_")
-      Jekyll.logger.info "  processing: #{archimate_file}"
-      Jekyll::Archimate::ArchimateHook.new(site, archimate_file).generate
-    end
-  end
-end