xumlidot 0.1.0

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'id'
+
+module Xumlidot
+  class Diagram
+    class Xmi
+      module Attribute
+        include ::Xumlidot::Diagram::Xmi::ID
+
+        # TODO - public/private visibility on attributes
+        def draw
+          attribute_xmi = "<ownedAttribute aggregation=\"none\" isDerived=\"false\" isDerivedUnion=\"false\" isID=\"false\" isLeaf=\"false\" isReadOnly=\"false\" isStatic=\"false\" name=\"#{name_to_xmi}\" visibility=\"public\" xmi:id=\"#{id}\" xmi:type=\"uml:Property\">"
+          attribute_xmi += "</ownedAttribute>"
+        end
+
+        def name_to_xmi
+          name.encode(:xml => :text) if name
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative '../../types'
+require_relative 'id'
+
+module Xumlidot
+  class Diagram
+    class Xmi
+      module Constant
+        def to_xmi
+          "#{formatted_namespace}::#{@name}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Xumlidot
+  class Diagram
+    class Xmi
+      # Helper - everything needs an id and these ids need to be used in the
+      # Element section
+      module ID
+        def id
+          @_id ||= new_id
+        end
+
+        def force_id(id)
+          @_id = id
+        end
+
+        def gen_id
+          @gen_id ||= "#{new_id[0..5]}.#{new_id[0..5]}".upcase
+        end
+
+        def association_id
+          @association_id ||= "#{new_id[0..5]}.#{new_id[0..5]}".upcase
+        end
+
+        def association_end_id
+          @association_end_id ||= "#{new_id[0..5]}.#{new_id[0..5]}".upcase
+        end
+
+        private
+
+        def new_id
+          SecureRandom.hex
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative '../../types'
+require_relative 'id'
+require_relative 'constant'
+require_relative 'superklass'
+require_relative '../shared/naming'
+
+module Xumlidot
+  class Diagram
+    class Xmi
+      # Draw the klass
+      module Klass
+        include ::Xumlidot::Diagram::Xmi::ID
+        include ::Xumlidot::Diagram::Shared::Naming
+
+        module Name
+          def to_xmi
+            map do |constant|
+              constant.extend(::Xumlidot::Diagram::Xmi::Constant) unless constant.respond_to?(:to_xmi)
+              constant.to_xmi
+            end.join
+          end
+        end
+
+        # TODO: Split this into model and diagram classes
+        class Model
+        end
+
+        class Diagram
+        end
+
+        def draw_klass(options)
+          definition.name.extend(Name)
+          xmi = "<ownedMember isAbstract=\"false\" isActive=\"false\" isLeaf=\"false\" name=\"#{definition.name.to_xmi}\" visibility=\"public\" xmi:id=\"#{id}\" xmi:type=\"uml:Class\">"
+          xmi += draw_model_inheritance if options.inheritance
+          xmi += extend_and_draw(attributes)
+          xmi += extend_and_draw(class_methods)
+          xmi += extend_and_draw(instance_methods)
+          xmi += "</ownedMember>"
+        end
+
+        # Draws a diagram element i.e. the part which is rendered
+        def draw_diagram(options)
+          xml = %(<uml:DiagramElement preferredShapeType="Class" subject="#{id}" xmi:id="#{id}de">
+            </uml:DiagramElement>)
+
+          return xml if @definition.superklass.empty? && @definition.inherited_modules.empty?
+          return xml unless options.inheritance
+
+          xml += draw_diagram_generalisation
+        end
+
+        def draw_diagram_generalisation
+          xml = ''
+
+          if ! @definition.superklass.empty?
+            xml += %(<uml:DiagramElement fromDiagramElement="#{@definition.superklass.id}de" preferredShapeType="Generalization" subject="#{gen_id}" toDiagramElement="#{id}de">
+            </uml:DiagramElement>)
+          end
+
+          return xml if @definition.inherited_modules.empty?
+
+          @definition.inherited_modules.each do |m|
+            next if m.empty?
+
+            xml += %(<uml:DiagramElement fromDiagramElement="#{m.id}de" preferredShapeType="Generalization" subject="#{gen_id}" toDiagramElement="#{id}de">
+            </uml:DiagramElement>)
+          end
+
+          xml
+        end
+
+        # Inheritance has to be drawn both as part of the model
+        # and as a part of the diagram
+        #
+        # general =
+        # id = IMPORTANT; will be used to draw the lines in the diagram
+        #
+        def draw_model_inheritance
+          return '' if @definition.superklass.empty? && @definition.inherited_modules.empty?
+
+          xml = ''
+
+          if ! @definition.superklass.empty?
+            xml += %(<generalization general="#{@definition.superklass.id}" xmi:id="#{gen_id}" xmi:type="uml:Generalization">
+              </generalization>)
+          end
+
+          return xml if @definition.inherited_modules.empty?
+
+          @definition.inherited_modules.each do |m|
+            next if m.empty?
+
+            xml += %(<generalization general="#{m.id}" xmi:id="#{gen_id}" xmi:type="uml:Generalization">
+              </generalization>)
+          end
+          xml
+        end
+
+        def draw_model_composition(composee)
+          %(<ownedMember isAbstract="false" isDerived="false" isLeaf="false" xmi:id="#{association_id}" xmi:type="uml:Association">
+              <memberEnd xmi:idref="#{association_end_id}"/>
+              <ownedEnd aggregation="none" association="#{association_id}" isDerived="false" isDerivedUnion="false" isLeaf="false" isNavigable="true" isReadOnly="false" isStatic="false" type="#{id}" xmi:id="9JMZlYaD.AACASCI" xmi:type="uml:Property">
+              </ownedEnd>
+              <memberEnd xmi:idref="#{composee.association_end_id}"/>
+            <ownedEnd aggregation="composite" association="#{association_id}" isDerived="false" isDerivedUnion="false" isLeaf="false" isNavigable="true" isReadOnly="false" isStatic="false" type="#{composee.id}" xmi:id="9JMZlYaD.AACASCK" xmi:type="uml:Property">
+            </ownedEnd>
+            </ownedMember>)
+        end
+
+        def draw_diagram_composition(composee)
+          %(<uml:DiagramElement fromDiagramElement="#{id}de" preferredShapeType="Association" subject="#{association_id}" toDiagramElement="#{composee.id}de">
+          </uml:DiagramElement>)
+        end
+
+        # Im not happy with this - xmi should not have to
+        # know about types and it should be a method
+        def extend_and_draw(collection)
+          collection.map do |member|
+            case member
+            when ::Xumlidot::Types::MethodSignature
+              member.extend(::Xumlidot::Diagram::Xmi::MethodSignature)
+            when ::Xumlidot::Types::Attribute
+              member.extend(::Xumlidot::Diagram::Xmi::Attribute)
+            end
+            member.draw
+          end.join(' ')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative '../../types'
+require_relative 'id'
+
+module Xumlidot
+  class Diagram
+    class Xmi
+      module MethodSignature
+        include ::Xumlidot::Diagram::Xmi::ID
+
+        # Ugh
+        def name_to_xmi
+          return '&lt;&lt;' if name == :<<
+          return '&gt;&gt;' if name == :>>
+          return '&lt;=&gt;' if name == :<=>
+          name
+        end
+
+        def draw
+          xmi = "<ownedOperation isAbstract=\"false\" isLeaf=\"false\" isOrdered=\"false\" isQuery=\"false\" isStatic=\"#{superclass_method}\" isUnique=\"true\" name=\"#{name_to_xmi}\" visibility=\"#{visibility}\" xmi:id=\"#{id}\" xmi:type=\"uml:Operation\">"
+          xmi += "<ownedParameter kind=\"return\" xmi:id=\"#{return_id}\" xmi:type=\"uml:Parameter\"/>"
+          args.each do |argument|
+            argument.extend(::Xumlidot::Diagram::Xmi::Argument)
+            xmi += argument.draw
+          end
+          xmi += "</ownedOperation>"
+        end
+
+        private
+
+        def return_id
+          @_return_id ||= new_id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative '../../types'
+require_relative 'id'
+
+module Xumlidot
+  class Diagram
+    class Xmi
+      module Superklass
+        include ::Xumlidot::Diagram::Xmi::ID
+
+        def draw_identifier
+          [name, namespace.reverse].reverse.flatten.join('::')
+        end
+      end
+    end
+  end
+end

data/lib/xumlidot/directory_tree.rb

@@ -0,0 +1,24 @@
+require 'find'
+
+module Xumlidot
+  # Recurse down a directory tree
+  class DirectoryTree
+    def initialize(directories, options)
+      @directories = directories
+      @options = options
+      @excluded = Regexp.new(@options.exclude)
+    end
+
+    def find_all_rb_files(&block)
+      @directories.each do |directory|
+        Find.find(directory) do |path|
+          next if path =~ @exluded
+
+          next unless path.end_with? '.rb'
+
+          yield path if block_given?
+        end
+      end
+    end
+  end
+end

data/lib/xumlidot/options.rb

@@ -0,0 +1,104 @@
+require 'optparse'
+require 'optparse/time'
+require 'ostruct'
+
+module Xumlidot
+  OptionsError = Class.new(StandardError)
+
+  class Options
+    def self.method_missing(m, *args, &block)
+      if @options.respond_to?(m)
+        @options.send(m)
+      else
+        raise OptionsError.new("Unknown Option #{m}")
+      end
+    end
+
+    def self.parse(args)
+      @options = OpenStruct.new
+
+      @options.title = 'Class Diagram'
+      @options.model_name = 'My Model'
+      @options.diagram_type = :dot
+      @options.rails = false
+      @options.debug = false
+      @options.inheritance = true
+      @options.composition = true
+      @options.usage = true
+      @options.split = 1
+      @options.sequence = ''
+      @options.exclude = ''
+
+      ENV.delete("XUMLIDOT_DEBUG")
+
+      opt_parser = OptionParser.new do |opts|
+        opts.banner = "Usage: xumlidot.rb [options]"
+
+        opts.separator ""
+        opts.separator "Specific options:"
+
+        opts.on("-t", "--title [TEXT]", "Title for the diagram") do |v|
+          @options.title = v
+        end
+
+        opts.on("-m", "--model [TEXT]", "Model Name for the diagram") do |v|
+          @options.model_name = v
+        end
+
+        opts.on("-d", "--dot", "Output diagram using dot (default)") do |v|
+          @options.diagram_type = :dot
+        end
+
+        opts.on("-x", "--xmi", "Output diagram using xmi") do |v|
+          @options.diagram_type = :xmi
+        end
+
+        opts.on("-d", "--debug", "Output debug information") do |v|
+          @options.debug = true
+          ENV["XUMLIDOT_DEBUG"] = '1'
+        end
+
+        opts.on("-i", "--no-inheritance", "Output inheritence links on the diagram") do |v|
+          @options.inheritance = false
+        end
+
+        opts.on("-c", "--no-composition", "Output composition links on the diagram") do |v|
+          @options.composition = false
+        end
+
+        opts.on("-r", "--rails", "Expect a Rails application") do |v|
+          @options.rails = v
+        end
+
+
+        opts.on("-e", "--exclude [TEXT[", "Output usage links on the diagram") do |v|
+          @options.exclude = v
+        end
+
+        opts.on("-u", "--[no-]usage", "Output usage links on the diagram") do |v|
+          @options.usage = v
+        end
+        opts.separator ""
+
+        opts.separator "Common options:"
+
+        # No argument, shows at tail.  This will print an options summary.
+        # Try it and see!
+        opts.on_tail("-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+
+        # Another typical switch to print the version.
+        opts.on_tail("--version", "Show version") do
+          puts ::Version.join('.')
+          exit
+        end
+      end
+
+      opt_parser.parse!(args)
+      @options
+    end
+
+  end
+end

data/lib/xumlidot/parsers.rb

@@ -0,0 +1,14 @@
+require 'ruby_parser'
+require 'sexp_processor'
+require 'ostruct'
+require 'pry'
+
+require_relative 'parsers/generic'
+require_relative 'parsers/args'
+require_relative 'parsers/call'
+require_relative 'parsers/file'
+require_relative 'parsers/klass_definition'
+require_relative 'parsers/method_signature'
+require_relative 'parsers/module_definition'
+require_relative 'parsers/scope'
+require_relative 'parsers/stack'

data/lib/xumlidot/parsers/args.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require_relative '../parsers'
+require_relative '../types'
+
+module Xumlidot
+  module Parsers
+    # Parser for the arguments to a method
+    #
+    # e.g. formats def method(a, b = nil)
+    #      to a string 'a, b = nil'
+    #
+    class Args < MethodBasedSexpProcessor
+
+      def initialize(exp)
+        super()
+
+        @arguments = ::Xumlidot::Types::Arguments.new
+
+        process(exp)
+      rescue => e
+        STDERR.puts " ** bug: unable to process args #{exp} "
+      end
+
+      def to_s
+        @arguments.to_s
+      end
+
+      def definition
+        @arguments
+      end
+
+      # Note - special case since a value of nil for default
+      # means we shouldn't display it and so we use the :nil
+      # symbol to represent an *actual assignment of nil* to
+      # a variable.
+      def process_nil(exp)
+        @argument.default = :nil
+        s()
+      end
+
+      def process_str(exp)
+        @argument.default = exp.value
+        s()
+      end
+
+      def process_hash(exp)
+        @argument.default = {}
+        s()
+      end
+
+      # const means that we have a constant assignment such as (a = Foo)
+      def process_const(exp)
+        @argument.default = exp.value.to_s
+        s()
+      end
+
+      # Colon2 means that we have a constant assignment such as (a = Foo::Bar)
+      def process_colon2(exp)
+        name = exp.flatten
+        name.delete :const
+        name.delete :colon2
+
+        leader = ''
+        if name.first == :colon3
+          leader = '::'
+          name.delete :colon3
+        end
+
+        # I'm not sure how best to proceed here.
+        #
+        # I can use const_set to start creating the constants heirachy
+        # but this is complex since it needs to be inserted into the right
+        # place and for that I need the namespace...which suggests this ISNT
+        # the place to do that. I possibly need a fake class ...
+        @argument.default = leader + name.map do |v|
+          v.to_s
+        end.to_a.join('::')
+
+        s()
+      end
+
+      # Colon2 means that we have a constant assignment such as (a = ::Foo::Bar)
+      # again see the note in colon2 about how to proceed
+      def process_colon3(exp)
+        process_colon2(exp)
+        @argument.default = "::#{argument.default}"
+      end
+
+      def process_array(exp)
+        @argument.default = []
+
+        exp.shift # remove :array
+        exp.each { |element| process(element) }
+        s()
+      end
+
+      def process_lasgn(exp)
+        exp.shift # remove :lasgn
+
+        @argument.name = exp.shift.to_s
+
+        value = exp.shift
+        process(value)
+        s()
+      end
+
+      def process_lit(exp)
+        exp.shift # remove :lit
+
+        case @argument.default
+        when Array
+          @argument.default << exp.value
+        when nil
+          @argument.default = exp.value
+        when Symbol
+          @argument.default = exp.value.to_s
+        when String
+          @argument.default = exp.value.to_s
+        when Sexp
+          # binding.pry
+        when Hash
+          # binding.pry
+        else
+          # binding.pry
+        end
+        exp.shift
+        s()
+      end
+
+      def process_kwarg(exp)
+        exp.shift # remove :kwarg
+        @argument.name = "#{exp[0]}:"
+        process(exp)
+        s()
+      rescue => e
+        STDERR.puts " ** bug: unable to process kwarg #{exp}; failure to parse default value? "
+        s()
+      end
+
+      def process_args(exp)
+        exp.shift # remove :args
+        exp.each do |arg|
+          @argument = ::Xumlidot::Types::Argument.new
+          if arg.is_a? Sexp
+            @argument.assign = '='
+            process(arg)
+          else
+            @argument.name = arg.to_s
+          end
+
+          @arguments << @argument
+        end
+      rescue => e
+        STDERR.puts " ** bug: unable to process args #{exp}; failure to parse default value? "
+      end
+    end
+  end
+end