xumlidot 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d57e014e5a04129a7ca8bfcc0cc8dae7e2b4db752de4bf5ad7643db37251de91
+  data.tar.gz: 5fa6e4b9c7004a2078a12123d5d506bd2d6479271285cd868fb87ba61a67b319
+SHA512:
+  metadata.gz: e3dc0e126cb359825379197fb3537881156436db6b65667c2c96cbfe31468e1ad406e78c485125ee334236cd7c9b018e717fd9a2dc29136b376b544adbbff537
+  data.tar.gz: 5d7f6a45fdd7b7f847581991b67e4dee05b0c3aa518ce176c886d898a19a59e729f0d9f3e122ab09dbbf66e2af62c673f122819fa75e6149c315adb3a5f3997f

data/bin/xumlidot

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/xumlidot'
+
+options = ::Xumlidot::Options.parse(ARGV)
+
+# TODO: user input
+directories = [ARGV[0]]
+
+dt = Xumlidot::DirectoryTree.new(directories, options)
+
+# This is our tree of klasses/modules etc
+# since we can't assume rails conventions for naming
+# in a Ruby program.
+constants = ::Xumlidot::Parsers::Stack::Constants.new
+
+# TODO: move into directory tree
+dt.find_all_rb_files do |path|
+  STDERR.puts path if ::Xumlidot::Options.debug == true
+  file_contents = File.read(path)
+
+  @parser = Xumlidot::Parsers::File.new(file_contents, constants)
+  @parser.parse
+end
+
+# If a class is inherited from but does not exist in the constants
+# we will create a dummy class.
+#
+# if a class is inherited from, we want to find it using the constant lookup
+# rules definind in the resolver
+#
+# and what ... we want to add a reference too it?
+#
+# This REALLY should be done whenever we add a superklass
+# i.e. yeah, its a hack
+constants.resolve_inheritance()
+
+diagram = ::Xumlidot::Diagram.new(constants, options)
+diagram.draw

data/lib/xumlidot.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'fileutils'
+
+require_relative 'xumlidot/directory_tree'
+require_relative 'xumlidot/parsers'
+require_relative 'xumlidot/diagram'
+require_relative 'xumlidot/options'
+
+module Xumlidot
+end

data/lib/xumlidot/diagram.rb

@@ -0,0 +1,18 @@
+require_relative 'diagram/dot'
+require_relative 'diagram/xmi'
+
+module Xumlidot
+  class Diagram
+    def initialize(stack, options)
+      @diagram = if options[:diagram_type] == :dot
+                   ::Xumlidot::Diagram::Dot.new(stack, options)
+                 else
+                   ::Xumlidot::Diagram::Xmi.new(stack, options)
+                 end
+    end
+
+    def draw
+      @diagram.draw
+    end
+  end
+end

data/lib/xumlidot/diagram/dot.rb

@@ -0,0 +1,55 @@
+require_relative 'dot/klass'
+require_relative 'dot/module'
+
+module Xumlidot
+  class Diagram
+    class Dot
+
+      def initialize(stack, options = nil)
+        @stack = stack
+        @options = options
+        @output = []
+      end
+
+      # We have to draw any connecting labels AFTER we have drawn the klasses
+      # in order to have something to connect.
+      def draw
+        @output << header
+        @stack.traverse do |klass|
+          klass.extend(::Xumlidot::Diagram::Dot::Klass)
+          @output << klass.draw
+        end
+
+        @stack.traverse do |klass|
+          # Check - i shouldnt need to extend twice
+          klass.extend(::Xumlidot::Diagram::Dot::Klass)
+
+          if @options.inheritance
+            output = klass.draw_inheritence
+            @output << output unless output.nil?
+          end
+
+          if @options.composition
+            klass.constants.each do |k|
+              @output << klass.draw_composition(k)
+            end
+          end
+        end
+        @output << footer
+
+        @output.uniq.each { |l| puts l }
+      end
+
+      private
+
+      def header
+        %(digraph graph_title {
+            graph[overlap=false, splines=true, bgcolor="white"])
+      end
+
+      def footer
+        '}'
+      end
+    end
+  end
+end

data/lib/xumlidot/diagram/dot/klass.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative '../shared/naming'
+
+module Xumlidot
+  class Diagram
+    class Dot
+      module Method
+        def to_dot
+          to_s.gsub('{}', '\{\}')
+        end
+      end
+
+      module Attribute
+        def to_dot
+          to_s
+        end
+      end
+
+      module Klass
+        include ::Xumlidot::Diagram::Shared::Naming
+        def draw
+          [draw_klass].compact.join('\r\n')
+        end
+
+        def draw_klass
+          label = draw_identifier(@definition)
+          "\"#{draw_identifier(@definition)}\" [shape=Mrecord, label=\"{#{label}|#{draw_methods}}\"]"
+        end
+
+        def draw_composition(composee)
+          "\"#{draw_identifier(composee.definition)}\" -> \"#{draw_identifier(@definition)}\" [label=\"\", arrowhead=\"diamond\", arrowtail=\"diamond\"]"
+        end
+
+        def draw_inheritence
+          return nil if @definition.superklass.empty? && @definition.inherited_modules.empty?
+
+          dot = ""
+          if !@definition.superklass.empty?
+            dot += "\"#{draw_identifier(@definition)}\" -> \"#{draw_ancestor(@definition.superklass)}\" [label=\"\", arrowhead=\"empty\", arrowtail=\"onormal\"]\n"
+          end
+
+          return dot if @definition.inherited_modules.empty?
+
+          @definition.inherited_modules.each do |m|
+            next if m.empty?
+            dot += "\"#{draw_identifier(@definition)}\" -> \"#{draw_ancestor(m)}\" [label=\"#{m.type.to_s}s\", arrowhead=\"empty\", arrowtail=\"onormal\"]\n"
+          end
+
+          dot
+        end
+
+        private
+
+        def draw_methods
+          @attributes.each { |a| a.extend(Attribute) }
+          @class_methods.each { |a| a.extend(Method) }
+          @instance_methods.each { |a| a.extend(Method) }
+
+          km = ''
+          km += @attributes.map(&:to_dot).join('\l')
+          km += '\\l' unless km.end_with?('\\l')
+
+          km += @class_methods.map(&:to_dot).join('\l')
+          km += '\\l' unless km.end_with?('\\l')
+          km += '|' if instance_methods.size.positive?
+
+          km += @instance_methods.map(&:to_dot).join('\l')
+          km += '\\l' unless km.end_with?('\\l')
+          km
+        end
+      end
+    end
+  end
+end

data/lib/xumlidot/diagram/dot/module.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Xumlidot
+  class Diagram
+    class Dot
+      module Module
+        include ::Xumlidot::Diagram::Dot::Klass
+      end
+    end
+  end
+end

data/lib/xumlidot/diagram/shared/naming.rb

@@ -0,0 +1,19 @@
+module Xumlidot
+  class Diagram
+    module Shared
+      module Naming
+        def draw_identifier(d = @definition)
+          [d.name.name, d.name.namespace.reverse].reverse.flatten.join('::')
+        end
+
+        def draw_name
+          @definition.name.name.join('::')
+        end
+
+        def draw_ancestor(d = @definition)
+          [d.name, d.namespace.reverse].reverse.flatten.join('::')
+        end
+      end
+    end
+  end
+end

data/lib/xumlidot/diagram/xmi.rb

@@ -0,0 +1,190 @@
+require_relative 'xmi/argument'
+require_relative 'xmi/attribute'
+require_relative 'xmi/klass'
+require_relative 'xmi/method'
+
+require 'rexml/document'
+
+module Xumlidot
+  class Diagram
+    class Xmi
+
+      include REXML
+
+      class Elements < Array
+
+        def initialize(options)
+          super()
+          @options = options
+        end
+
+        def draw
+          xml = header
+          uniq.each { |de| xml += de }
+          xml += yield if block_given?
+          xml += footer
+        end
+
+        private
+
+        def header
+          ''
+        end
+
+        def footer
+          ''
+        end
+      end
+
+      class ModelAssociationElements < Elements
+      end
+
+      class DiagramAssociationElements < Elements
+      end
+
+      class ModelElements < Elements
+        private
+
+        def header
+          %(<uml:Model name="#{@options[:model_name]}" xmi:id="jcBKnwaFYHEAAQV_">)
+        end
+
+        def footer
+          %(</uml:Model>)
+        end
+      end
+
+      class DiagramElements < Elements
+        private
+
+        def header
+          %(<uml:Diagram diagramType="ClassDiagram" documentation="" name="#{@options[:title]}" toolName="Visual Paradigm" xmi:id="QfZKnwaFYHEAAQj3">
+              <uml:Diagram.element>)
+        end
+
+        def footer
+          %(  </uml:Diagram.element>
+            </uml:Diagram>)
+        end
+      end
+
+      # We need to keep track of the ids assigned in the body for each class.
+      class NamespaceToId
+        def initialize
+          @namespace_to_id = {}
+          @id_to_namespace = {}
+        end
+
+        # reverse lookup
+        def has_value?(id)
+          @id_to_namespace[id] != nil
+        end
+
+        def has?(full_namespace)
+          @namespace_to_id[full_namespace] != nil
+        end
+
+        def [](name)
+          @namespace_to_id[name]
+        end
+
+        def []=(name, id)
+          @namespace_to_id[name] = id
+          @id_to_namespace[id] = name
+        end
+      end
+
+      def initialize(stack, options = nil)
+        @stack = stack
+        @options = options
+
+        @namespace_to_id = NamespaceToId.new
+
+        @model = ModelElements.new(options)
+        @diagram = DiagramElements.new(options)
+
+        @model_associations = ModelAssociationElements.new(options)
+        @diagram_associations = DiagramAssociationElements.new(options)
+      end
+
+      def draw
+        # First traversal we're just assigning ids to everything so that when
+        # we come to draw things we can do a lookup on the ids for any composition
+        # aggregation or subclass relationships.
+        @stack.traverse do |klass|
+          klass.extend(::Xumlidot::Diagram::Xmi::Klass)
+          klass.superklass.extend(::Xumlidot::Diagram::Xmi::Superklass) unless klass.superklass.name.nil?
+
+          klass.definition.inherited_modules.each do |m|
+            next if m.empty?
+            m.extend(::Xumlidot::Diagram::Xmi::Superklass)
+          end #unless klass.definition.inherited_modules.empty?
+
+          next if @namespace_to_id.has?(klass.draw_identifier)
+          @namespace_to_id[klass.draw_identifier] = klass.id
+        end
+
+        # Second traversal we are drawing everything
+        @stack.traverse do |klass|
+          # resolve the superclass id to that of an existing class with an id
+          # we do this in the second loop so that all the classes are present
+          unless klass.superklass.name.nil?
+            id = @namespace_to_id[klass.superklass.draw_identifier]
+            klass.superklass.force_id(id)
+          end
+
+          # do the same with the inherited modules
+          klass.definition.inherited_modules.each do |m|
+            next if m.empty?
+            id = @namespace_to_id[m.draw_identifier]
+            m.force_id(id)
+          end #unless klass.definition.inherited_modules.empty?
+
+          # if we have not added an id for this element it is likely a duplicate
+          # so do not draw it.
+          next unless @namespace_to_id.has_value?(klass.id)
+
+          @model << klass.draw_klass(@options)
+          @diagram << klass.draw_diagram(@options)
+
+          if @options.composition
+            klass.constants.each do |k|
+              # Likewise to the above, unless we have an id for the class
+              # we don't want to draw the relationships
+              next unless @namespace_to_id.has_value?(k.id)
+              @model_associations << klass.draw_model_composition(k)
+              @diagram_associations << klass.draw_diagram_composition(k)
+            end
+          end
+        end
+
+        xml = header
+        xml += @model.draw { @model_associations.draw }
+        xml += @diagram.draw { @diagram_associations.draw }
+        xml += footer
+
+        pretty_print(xml)
+      end
+
+      private
+
+      def header
+        %(<?xml version="1.0" encoding="UTF-8"?>
+        <xmi:XMI xmi:version="2.1" xmlns:uml="http://schema.omg.org/spec/UML/2.0" xmlns:xmi="http://schema.omg.org/spec/XMI/2.1">
+          <xmi:Documentation exporter="Visual Paradigm" exporterVersion="7.0.2">
+          </xmi:Documentation>)
+      end
+
+      def footer
+        %(</xmi:XMI>)
+      end
+
+      def pretty_print(xml)
+        doc = Document.new(xml)
+        formatter = REXML::Formatters::Pretty.new
+        formatter.compact = true
+        formatter.write(doc, $stdout)
+      end
+    end
+  end
+end

data/lib/xumlidot/diagram/xmi/argument.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'id'
+
+module Xumlidot
+  class Diagram
+    class Xmi
+      module Argument
+        include ::Xumlidot::Diagram::Xmi::ID
+
+        def draw
+          xmi = "<ownedParameter kind=\"inout\" name=\"#{name_to_xmi}\" xmi:id=\"#{id}\" xmi:type=\"uml:Parameter\">"
+          xmi += "<defaultValue value=\"#{default_to_xmi}\" xmi:id=\"#{default_id}\" xmi:type=\"uml:LiteralString\"/>" if default
+          xmi += "</ownedParameter>"
+        end
+
+        private
+
+        def name_to_xmi
+          name.encode(:xml => :text) if name
+        end
+
+        def default_to_xmi
+          return default unless default.is_a?(String)
+          default.encode(:xml => :text)
+        end
+
+        def default_id
+          @_default_id ||= new_id
+        end
+      end
+    end
+  end
+end