ruby_to_uml 2.0.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3445cfab16eaa84745cd0b367155f28c86beb1a79e93c072aaf6dfe8b599154b
-  data.tar.gz: 76841acf154c49b453862ffae8525bcae1846a864a0e332cd534a5278e386465
+  metadata.gz: befc4a48683c7d789764a96b099056651fccb47fb9c32ce7cc0530634bfc5e73
+  data.tar.gz: a91d111eac181e1ebdaa72841cb8166230819e6ef53b4ca33273fd67d4ff8fd9
 SHA512:
-  metadata.gz: f7120950f0bf81be765c5758f7d94785c606f8b77cffc8ced2995d80f1aad96bc071bad8334c232c486ee64bc90d85eaaa57524fae0c6683575f29aef1acc549
-  data.tar.gz: 9cc132f121042b7e817b95b58f84187b4bb796712cb580f827407b3ec8999d51677e53a4410c8a0fd08a3dcc6e934b642cbe7d69f7716379a6250eb9a7c08412
+  metadata.gz: 6aa2837bb4861fe1a01e10b83c0848bb453b5ffedcb74f4e02f7fa3683e5fbca10075dc2edc733cd1c8286290bc1307a9b87ff7579672127680f261472f9aeec
+  data.tar.gz: 545c66c708ffb85f36f4a32e070204a40c28e9846d26fa8fbed0db40d5781837c89b3c6c9460a68e8d4d3eb4685038c989e9f4da10f0ac7b8c0f5d50b9fdc8ce

data/bin/ruby_to_uml

@@ -1,7 +1,5 @@
 #!/usr/bin/env ruby
-# frozen_string_literal: true
 
 require 'ruby_to_uml'
 
-runner = RubyToUML::Runner.new ARGV
-runner.run
+RubyToUML::CLI.start(ARGV)

data/lib/ruby_to_uml.rb

@@ -1,9 +1,5 @@
-# frozen_string_literal: true
-
-require 'ruby_to_uml/version'
-require 'ruby_to_uml/runner'
-require 'ruby_to_uml/parser_sexp'
-require 'ruby_to_uml/uml_class'
-require 'ruby_to_uml/diagram'
-
-RubyToUml = RubyToUML # to create alias for module
+require 'ruby_to_uml/uml_diagram_renderer/uml_diagram_renderer'
+require 'ruby_to_uml/uml_info_generator/uml_info_generator'
+require 'ruby_to_uml/cli'
+require 'ruby_to_uml/nomnoml_dsl_generator'
+require 'ruby_to_uml/path_transformer'

data/lib/ruby_to_uml/cli.rb

@@ -0,0 +1,11 @@
+module RubyToUML
+  module CLI
+    def self.start(arguments)
+      abort('Usage: ruby_to_uml [source directory or file]') if arguments.empty?
+      file_paths = PathTransformer.transform_files_and_or_directories_paths_to_file_paths(arguments)
+      uml_info = UMLInfoGenerator.process_files(file_paths)
+      dsl = NomnomlDSLGenerator.generate_dsl(uml_info)
+      UMLDiagramRenderer.create_diagram(dsl.to_s)
+    end
+  end
+end

data/lib/ruby_to_uml/nomnoml_dsl_generator.rb

@@ -0,0 +1,136 @@
+module RubyToUML
+  module NomnomlDSLGenerator
+    def self.generate_dsl(uml_info)
+      classes = create_class_dsl(uml_info.classes)
+      modules = create_modules_dsl(uml_info.modules)
+      relationships = create_relationships_dsl(uml_info.relationships)
+      NomnomlDSL.new(style, classes, modules, relationships)
+    end
+
+    class << NomnomlDSLGenerator
+      private
+
+      def style
+        <<~MSG
+          #direction: right
+          #zoom: 0.9
+
+          #font: Roboto
+          #fontSize: 20
+          #leading: 2
+          #padding: 12
+
+          #fillArrows: true
+          #arrowSize: 0.5
+          #spacing: 130
+
+          #lineWidth: 1.5
+          #stroke: #33322E
+
+          #.class: fill=#FEDCC4 title=bold
+          #.module: fill=#D9E6FF title=bold
+        MSG
+      end
+
+      def create_class_dsl(class_infos)
+        class_infos.each_with_object('') do |class_info, dsl_string|
+          name = class_info.name
+          instance_variables = class_info.instance_variables_info.join('; ')
+          instance_methods = instance_methods_dsl(class_info.instance_methods_info)
+          singleton_methods = singleton_methods_dsl(class_info.singleton_methods_info)
+
+          class_dsl = <<~MSG
+            [<class> #{name} |
+              #{instance_variables} |
+              #{instance_methods} |
+              #{singleton_methods}
+            ]
+          MSG
+
+          dsl_string << class_dsl
+        end
+      end
+
+      def create_modules_dsl(module_infos)
+        module_infos.each_with_object('') do |module_info, dsl_string|
+          name = module_info.name
+          instance_methods = instance_methods_dsl(module_info.instance_methods_info)
+          singleton_methods = singleton_methods_dsl(module_info.singleton_methods_info)
+
+          module_dsl = <<~MSG
+            [<module> #{name} |
+              #{instance_methods} |
+              #{singleton_methods}
+            ]
+          MSG
+
+          dsl_string << module_dsl
+        end
+      end
+
+      def create_relationships_dsl(relationship_infos)
+        relationship_infos.each_with_object('') do |relationship_info, dsl_string|
+          subject = relationship_info.subject
+          verb = relationship_info.verb
+          object = relationship_info.object
+
+          arrow_dictionary = {
+            inherits: '<:-',
+            includes: '<-',
+            extends: '<-',
+            prepends: '<-'
+          }
+
+          arrow = arrow_dictionary[verb]
+
+          relationship_dsl = "[#{subject}] #{verb} #{arrow} [#{object}]\n"
+
+          dsl_string << relationship_dsl
+        end
+      end
+
+      def instance_methods_dsl(method_infos)
+        method_infos.map do |method_info|
+          instance_method_dsl(method_info)
+        end.join('; ').gsub(/\[/, '&rbrack;').gsub(/\]/, '&lbrack;')
+      end
+
+      def singleton_methods_dsl(method_infos)
+        method_infos.map do |method_info|
+          singleton_method_dsl(method_info)
+        end.join('; ').gsub(/\[/, '&rbrack;').gsub(/\]/, '&lbrack;')
+      end
+
+      def instance_method_dsl(method_info)
+        type_dictionary = {
+          public: '+',
+          protected: '#',
+          private: '-'
+        }
+
+        type = type_dictionary[method_info.type]
+        name = method_info.name
+        arguments = method_info.parameters
+
+        arguments = arguments.empty? ? '' : "(#{arguments.join(', ')})"
+
+        "#{type}#{name}#{arguments}"
+      end
+
+      def singleton_method_dsl(method_info)
+        name = method_info.name
+        arguments = method_info.parameters
+
+        arguments = arguments.empty? ? '' : "(#{arguments.join(', ')})"
+
+        "self.#{name}#{arguments}"
+      end
+    end
+
+    NomnomlDSL = Struct.new(:style, :classes, :modules, :relationships) do
+      def to_s
+        style + classes + modules + relationships
+      end
+    end
+  end
+end

data/lib/ruby_to_uml/path_transformer.rb

@@ -0,0 +1,32 @@
+require 'pathname'
+
+module RubyToUML
+  module PathTransformer
+    def self.transform_files_and_or_directories_paths_to_file_paths(paths)
+      paths.map { |path| resolve_absolute_path(path) }
+          .map { |path| path.file? ? path : resolve_children(path) }
+          .flatten
+          .map(&:to_s)
+          .filter { |path| path.match?(/\.rb$/) }
+          .sort
+    end
+
+    class << PathTransformer
+      private
+
+      def resolve_absolute_path(path)
+        Pathname.new(File.expand_path(path, Dir.pwd))
+      end
+
+      def resolve_children(path)
+        path.children.map do |child|
+          if child.file?
+            child
+          elsif child.directory?
+            resolve_children(child)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_to_uml/uml_diagram_renderer/uml_diagram_renderer.rb

@@ -0,0 +1,27 @@
+require 'erb'
+require 'tilt'
+
+module RubyToUML
+  module UMLDiagramRenderer
+    def self.create_diagram(dsl_string)
+      html = render_diagram(dsl_string)
+      save_html_file(html)
+    end
+
+    class << UMLDiagramRenderer
+      private
+
+      def render_diagram(dsl_string)
+        absolute_path = File.expand_path('uml_diagram_template.erb', __dir__)
+        template = Tilt.new(absolute_path)
+        template.render(Object.new, dsl_string: dsl_string)
+      end
+
+      def save_html_file(data)
+        File.open('uml_class_diagram.html', 'w') do |file|
+          file << data
+        end
+      end
+    end
+  end
+end

data/lib/ruby_to_uml/uml_diagram_renderer/uml_diagram_template.erb

@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta http-equiv="X-UA-Compatible" content="IE=edge">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Diagram</title>
+</head>
+<body>
+  <script src="//unpkg.com/graphre/dist/graphre.js"></script>
+  <script src="//unpkg.com/nomnoml/dist/nomnoml.js"></script>
+
+  <canvas id="target-canvas"></canvas>
+  <script>
+      var canvas = document.getElementById('target-canvas');
+      var source = `<%= dsl_string %>`;
+      nomnoml.draw(canvas, source);
+  </script>
+</body>
+</html>

data/lib/ruby_to_uml/uml_info_generator/ast_processor.rb

@@ -0,0 +1,16 @@
+module RubyToUML
+  module UMLInfoGenerator
+    class ASTProcessor < Parser::AST::Processor
+      include ProcessorHelpers
+      include ClassAndRelationshipsProcessor
+      include ModuleProcesor
+      attr_reader :classes, :modules, :relationships
+
+      def initialize
+        @classes = []
+        @modules = []
+        @relationships = []
+      end
+    end
+  end
+end

data/lib/ruby_to_uml/uml_info_generator/info_classes.rb

@@ -0,0 +1,147 @@
+module RubyToUML
+  module UMLInfoGenerator
+    ClassInfo = Struct.new(
+      :name,
+      :instance_methods_info,
+      :singleton_methods_info,
+      :instance_variables_info
+    )
+
+    ModuleInfo = Struct.new(
+      :name,
+      :instance_methods_info,
+      :singleton_methods_info
+    )
+
+    RelationshipInfo = Struct.new(:subject, :object, :verb) do
+      def to_s
+        "#{subject} #{verb} #{object}"
+      end
+    end
+
+    InstanceMethodInfo = Struct.new(:name, :type, :parameters) do
+      def to_s
+        "#{type} #{name}(#{parameters.join(', ')})"
+      end
+    end
+
+    SingletonMethodInfo = Struct.new(:name, :parameters) do
+      def to_s
+        "self.#{name}(#{parameters.join(', ')})"
+      end
+    end
+
+    class UMLInfo
+      attr_reader :classes, :modules, :relationships
+
+      def initialize(classes, modules, relationships)
+        @classes = classes
+        @modules = modules
+        @relationships = relationships
+      end
+
+      def class_names
+        classes.map(&:name)
+      end
+
+      def module_names
+        modules.map(&:name)
+      end
+
+      def class_instance_methods
+        classes.map { |class_info| class_info.instance_methods_info.map(&:to_s).join("\n") }
+      end
+
+      def module_instance_methods
+        modules.map { |class_info| class_info.instance_methods_info.map(&:to_s).join("\n") }
+      end
+
+      def class_singleton_methods
+        classes.map { |class_info| class_info.singleton_methods_info.map(&:to_s).join("\n") }
+      end
+
+      def module_singleton_methods
+        modules.map { |class_info| class_info.singleton_methods_info.map(&:to_s).join("\n") }
+      end
+
+      def class_instance_variables
+        classes.map(&:instance_variables_info)
+      end
+
+      def relationship_descriptions
+        relationships.map(&:to_s)
+      end
+
+      def merge(other_uml_info)
+        unique_relationships = (relationships + other_uml_info.relationships).uniq
+        unique_classes = merge_classes(classes, other_uml_info.classes)
+        unique_modules = merge_modules(modules, other_uml_info.modules)
+        UMLInfo.new(unique_classes, unique_modules, unique_relationships)
+      end
+
+      private
+
+      def merge_classes(classes, other_classes)
+        merge_entities(classes, other_classes, &merge_class_attributes(classes))
+      end
+
+      def merge_modules(modules, other_modules)
+        merge_entities(modules, other_modules, &merge_module_attributes(modules))
+      end
+
+      def merge_entities(group, other_group, &merge_attributes)
+        unique_entities = []
+        merged = []
+
+        distinct_entities = (group + other_group).uniq
+
+        distinct_entities.each do |entity_1|
+          next if merged.include?(entity_1.name)
+
+          matched_entities = []
+          distinct_entities.each do |entity_2|
+            matched_entities << entity_2 if entity_1.name == entity_2.name && entity_1.object_id != entity_2.object_id
+          end
+
+          if matched_entities.empty?
+            unique_entities << entity_1
+          else
+            unique_entities << merge_attributes.call([entity_1, *matched_entities])
+            merged << entity_1.name
+          end
+        end
+
+        unique_entities
+      end
+
+      def merge_class_attributes(classes)
+        getters = %i[instance_methods_info singleton_methods_info instance_variables_info]
+        merge_attributes(classes, getters)
+      end
+
+      def merge_module_attributes(classes)
+        getters = %i[instance_methods_info singleton_methods_info]
+        merge_attributes(classes, getters)
+      end
+
+      def merge_attributes(_objects, getters)
+        lambda do |objects|
+          example_object = objects[0]
+
+          uniq_attributes = []
+          getters.each do |getter|
+            attribute = []
+            objects.each do |object|
+              object.send(getter)
+              attribute << object.send(getter)
+            end
+            uniq_attributes << attribute.flatten.uniq
+          end
+
+          klass = example_object.class
+          klass.new(example_object.name, *uniq_attributes)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_to_uml/uml_info_generator/processor_helpers.rb

@@ -0,0 +1,219 @@
+module RubyToUML
+  module UMLInfoGenerator
+    module ProcessorHelpers
+      private
+
+      def get_class_name(node)
+        constant, inherit, children = *node
+        get_constant_name(constant)
+      end
+
+      def get_class_body(node)
+        body_node_index = 2
+        node.children[body_node_index]
+      end
+
+      def get_superclass_name(node)
+        constant, inherit, children = *node
+        inherit ? get_constant_name(inherit) : nil
+      end
+
+      def get_instance_methods_closure
+        type = :public
+        lambda do |node, instance_methods_info|
+          case node.type
+          when :def
+            method_name = get_method_name(node)
+            args        = get_instance_method_args(node)
+            instance_methods_info << InstanceMethodInfo.new(method_name, type, args)
+          when :send
+            method_name = get_send_method(node)
+            new_type    = get_method_type_change(method_name)
+            type = new_type if new_type
+          end
+        end
+      end
+
+      def get_singleton_methods_closure
+        lambda do |node, singleton_methods_info|
+          if node.type == :defs
+            method_name = get_singleton_method_name(node)
+            args        = get_singleton_method_args(node)
+            singleton_methods_info << SingletonMethodInfo.new(method_name, args)
+          end
+        end
+      end
+
+      def get_instance_variables_closure
+        lambda do |node, instance_variables_info|
+          if node.type == :def && get_method_name(node) == :initialize
+            method_body_node = BodyNodeWrapper.new(get_method_body_node(node))
+            closure = lambda do |node|
+              if node.type == :ivar || node.type == :ivasgn
+                variable_name = get_instance_variable_name(node)
+                instance_variables_info << variable_name
+              end
+            end
+            method_body_node.simple_operation(&closure)
+          end
+        end
+      end
+
+      def add_inheritence_relationship(class_name, superclass_name)
+        relationships << RelationshipInfo.new(class_name, superclass_name, :inherits)
+      end
+
+      def add_module_relationships_if_exist_closure(class_name)
+        lambda do |node|
+          if node.type == :send
+            _, method, module_name = *node
+            if %i[include extend prepend].include? method
+              verb = "#{method}s".to_sym
+              add_module_relationship(class_name, module_name, verb)
+            end
+          end
+        end
+      end
+
+      def add_module_relationship(class_name, arguments, type)
+        module_name = get_constant_name(arguments)
+        relationships << RelationshipInfo.new(class_name, module_name, type)
+      end
+
+      def get_constant_name(const_node)
+        constant_name_index = 1
+        const_node.children[constant_name_index]
+      end
+
+      def get_method_name(def_node)
+        name_index = 0
+        def_node.children[name_index]
+      end
+
+      def get_instance_method_args(def_node)
+        args_index = 1
+        get_arguments(def_node.children[args_index])
+      end
+
+      def get_send_method(send_node)
+        caller, method, arguments = *send_node
+        method
+      end
+
+      def get_method_type_change(method_name)
+        %i[public private protected].include?(method_name) ? method_name : nil
+      end
+
+      def get_singleton_method_name(defs_node)
+        name_index = 1
+        defs_node.children[name_index]
+      end
+
+      def get_singleton_method_args(defs_node)
+        args_index = 2
+        get_arguments(defs_node.children[args_index])
+      end
+
+      def get_arguments(node)
+        return [] if node.children.nil?
+
+        node.children.each_with_object([]) { |node, args| args << node.children[0] }
+      end
+
+      def get_method_body_node(def_node)
+        body_index = 2
+        def_node.children[body_index]
+      end
+
+      def get_instance_variable_name(node)
+        name_index = 0
+        node.children[name_index]
+      end
+
+      def get_module_name(node)
+        constant, = *node
+        get_constant_name(constant)
+      end
+
+      def get_module_body(node)
+        _, body = *node
+        body
+      end
+    end
+
+    module ClassAndRelationshipsProcessor
+      def on_class(node)
+        class_name              = get_class_name(node)
+        superclass_name         = get_superclass_name(node)
+        class_body_node         = BodyNodeWrapper.new(get_class_body(node))
+        instance_methods_info   = class_body_node.array_operation(&get_instance_methods_closure)
+        singleton_methods_info  = class_body_node.array_operation(&get_singleton_methods_closure)
+        instance_variables_info = class_body_node.array_operation(&get_instance_variables_closure)
+
+        add_inheritence_relationship(class_name, superclass_name) if superclass_name
+        class_body_node.simple_operation(&add_module_relationships_if_exist_closure(class_name))
+
+        add_class(class_name, instance_methods_info, singleton_methods_info, instance_variables_info)
+
+        node.updated(nil, process_all(node))
+      end
+
+      private
+
+      def add_class(name, instance_methods_info, singleton_methods_info, instance_variables_info)
+        classes << ClassInfo.new(name, instance_methods_info, singleton_methods_info, instance_variables_info)
+      end
+    end
+
+    module ModuleProcesor
+      def on_module(node)
+        module_name            = get_module_name(node)
+        module_body_node       = BodyNodeWrapper.new(get_module_body(node))
+        instance_methods_info  = module_body_node.array_operation(&get_instance_methods_closure)
+        singleton_methods_info = module_body_node.array_operation(&get_singleton_methods_closure)
+
+        add_module(module_name, instance_methods_info, singleton_methods_info)
+
+        node.updated(nil, process_all(node))
+      end
+
+      private
+
+      def add_module(name, instance_methods_info, singleton_methods_info)
+        modules << ModuleInfo.new(name, instance_methods_info, singleton_methods_info)
+      end
+    end
+
+    class BodyNodeWrapper
+      def initialize(body_node)
+        @body_node = body_node
+      end
+
+      def array_operation(&operation)
+        array = []
+        if body_node.nil?
+          nil
+        elsif body_node.type == :begin
+          body_node.children.each { |node| operation.call(node, array) }
+        else
+          operation.call(body_node, array)
+        end
+        array
+      end
+
+      def simple_operation(&operation)
+        if body_node.nil?
+          nil
+        elsif body_node.type == :begin
+          body_node.children.each { |node| operation.call(node) }
+        else
+          operation.call(body_node)
+        end
+      end
+
+      private
+
+      attr_reader :body_node
+    end
+  end
+end

data/lib/ruby_to_uml/uml_info_generator/uml_info_generator.rb

@@ -0,0 +1,42 @@
+require 'parser/current'
+
+require 'ruby_to_uml/uml_info_generator/processor_helpers'
+require 'ruby_to_uml/uml_info_generator/ast_processor'
+require 'ruby_to_uml/uml_info_generator/info_classes'
+
+module RubyToUML
+  module UMLInfoGenerator
+    def self.process_files(file_paths)
+      uml_infos = file_paths.each_with_object([]) do |file_path, uml_infos|
+        uml_infos << process_file(file_path)
+      end
+
+      uml_infos.reduce(:merge)
+    end
+
+    def self.process_multiple_code_snippets(code_snippets)
+      uml_infos = code_snippets.each_with_object([]) do |code, uml_infos|
+        uml_infos << process_code(code)
+      end
+
+      uml_infos.reduce(:merge)
+    end
+
+    def self.process_file(file_path)
+      top_level_node = Parser::CurrentRuby.parse_file(file_path)
+      parse_ast_to_uml_info(top_level_node)
+    end
+
+    def self.process_code(code)
+      top_level_node = Parser::CurrentRuby.parse(code)
+      parse_ast_to_uml_info(top_level_node)
+    end
+
+    def self.parse_ast_to_uml_info(top_level_node)
+      processor = ASTProcessor.new
+      processor.process(top_level_node)
+      UMLInfo.new(processor.classes, processor.modules, processor.relationships)
+    end
+    private_class_method :parse_ast_to_uml_info
+  end
+end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: ruby_to_uml
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Iuliu Pop
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-13 00:00:00.000000000 Z
+date: 2021-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: erb
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -25,7 +25,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: ruby_parser
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tilt
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -48,11 +62,15 @@ extra_rdoc_files: []
 files:
 - bin/ruby_to_uml
 - lib/ruby_to_uml.rb
-- lib/ruby_to_uml/diagram.rb
-- lib/ruby_to_uml/parser_sexp.rb
-- lib/ruby_to_uml/runner.rb
-- lib/ruby_to_uml/uml_class.rb
-- lib/ruby_to_uml/version.rb
+- lib/ruby_to_uml/cli.rb
+- lib/ruby_to_uml/nomnoml_dsl_generator.rb
+- lib/ruby_to_uml/path_transformer.rb
+- lib/ruby_to_uml/uml_diagram_renderer/uml_diagram_renderer.rb
+- lib/ruby_to_uml/uml_diagram_renderer/uml_diagram_template.erb
+- lib/ruby_to_uml/uml_info_generator/ast_processor.rb
+- lib/ruby_to_uml/uml_info_generator/info_classes.rb
+- lib/ruby_to_uml/uml_info_generator/processor_helpers.rb
+- lib/ruby_to_uml/uml_info_generator/uml_info_generator.rb
 homepage: https://github.com/iulspop/ruby_to_uml
 licenses:
 - MIT
@@ -66,15 +84,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.0.1
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.2.15
 signing_key: 
 specification_version: 4
-summary: ruby_to_uml is a tool that creates class diagrams from Ruby code.
+summary: ruby_to_uml is a tool that creates UML class diagrams from Ruby code.
 test_files: []

data/lib/ruby_to_uml/diagram.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module RubyToUML
-  # Creates and store a yUML api string for generating diagram
-  # * type of @statements: 1..* String
-  class Diagram
-    attr_accessor :statements
-
-    def initialize
-      @statements = []
-    end
-
-    def create(&blk)
-      instance_eval(&blk)
-      self
-    end
-
-    # Adds the given statement to the @diagram array
-    # Statement can either be a String or an UmlClass
-    def add(statement)
-      # TODO: Add some sort of validation
-
-      @statements << statement if statement.is_a? String
-      if statement.is_a? UmlClass
-
-        @statements << statement.to_s
-
-        statement.children&.each do |child|
-          @statements << "[#{statement.name}]^[#{child.name}]"
-        end
-
-        unless statement.associations.empty?
-          statement.associations.each do |name, type|
-            next if name =~ /-/
-
-            cardinality = (" #{statement.associations["#{name}-n"]}" if statement.associations["#{name}-n"])
-            @statements << "[#{statement.name}]-#{name}#{cardinality}>[#{type}]"
-          end
-        end
-
-      end
-    end
-
-    # Sorts the statements array so that
-    # 1. Class definitions
-    # 2. Inheritance
-    # 3. Associations
-    # Otherwise, strange behavior can happen in the downloaded graph
-    def compute!
-      class_def = /^\[[\w;?|=!]*?\]$/
-      inheritance = /\[(.*?)\]\^\[(.*?)\]/
-      association = /\[.*\]-.*>\[.*\]/
-
-      @statements.sort! do |x, y|
-        if x =~ class_def && y =~ inheritance
-          -1
-        elsif x =~ class_def && y =~ association
-          -1
-        elsif x =~ inheritance && y =~ association
-          -1
-        elsif x =~ class_def && y =~ class_def
-          0
-        elsif x =~ inheritance && y =~ inheritance
-          0
-        elsif x =~ association && y =~ association
-          0
-        else
-          1
-        end
-      end
-    end
-
-    # returns just the DSL text for diagram
-    def get_dsl
-      @statements.join(', ')
-    end
-  end
-end

data/lib/ruby_to_uml/parser_sexp.rb

@@ -1,148 +0,0 @@
-# frozen_string_literal: true
-
-require 'ruby_parser'
-require 'pathname'
-
-module RubyToUML
-  # Parses files using S-Expressions given by the RubyParser gem
-  #
-  #  * type of @classes: 0..* UmlClass
-  #
-  class ParserSexp
-    def initialize(path)
-      @path_to_folder_or_file = path
-    end
-
-    # Parses the source code of the files in @files
-    # to build uml classes. Returns an array containing all the
-    # parsed classes or nil if no ruby file were found in the
-    # @files array.
-    def parse_sources!
-      source_files = nil
-      if path_to_folder_or_file.match /.rb/
-        source_files = [path_to_folder_or_file]
-      else
-        files = list_child_files_paths(Pathname.new(path_to_folder_or_file))
-        source_files = files.select { |f| f.match(/\.rb/) }
-      end
-
-      return nil if source_files.empty?
-
-      all_uml_classes = []
-      source_files.each do |file|
-        file_content = File.read(file)
-        parse_file(file_content).each do |uml_class|
-          all_uml_classes << uml_class
-        end
-      end
-
-      # Removes duplicates between variables and associations in the class
-      all_uml_classes.each do |uml_class|
-        uml_class.finalize_uml_class_info(all_uml_classes)
-      end
-    end
-
-    # Parse the given string, and return the parsed classes
-    def parse_file(file_content)
-      uml_classes = []
-
-      s_exp = RubyParser.new.parse(file_content)
-
-      if sexp_contains_one_class?(s_exp)
-        uml_classes << parse_class(s_exp)
-      else
-        s_exp.each_of_type :class do |a_class|
-          uml_classes << parse_class(a_class)
-        end
-      end
-
-      uml_classes
-    end
-
-    private
-
-    attr_reader :path_to_folder_or_file
-
-    def list_child_files_paths(path)
-      path.children.collect do |child|
-        if child.file?
-          child
-        elsif child.directory?
-          list_child_files_paths(child) + [child]
-        end
-      end.select { |x| x }.flatten(1).map(&:to_s)
-    end
-
-    def sexp_contains_one_class?(s_exp)
-      s_exp[0] == :class
-    end
-
-    # Creates a UmlClass from a class s-expression
-    def parse_class(class_s_exp)
-      # Checks if the class is in a module
-      uml_class = is_module?(class_s_exp)
-
-      # Let's start by building the associations of the class
-      each_association_for class_s_exp do |variable, type, cardinality|
-        uml_class.associations[variable] = type
-        uml_class.associations["#{variable}-n"] = cardinality if cardinality
-      end
-
-      # Searching for a s(:const, :Const) right after the class name, which
-      # means the class inherits from a parents class, :Const
-      if class_s_exp[2] && (class_s_exp[2][0] == :const)
-        classname = recursive_class_name_find class_s_exp[2]
-        uml_class.parent = classname unless classname.nil?
-      elsif class_s_exp[2] && (class_s_exp[2][0] == :colon2)
-        # If the parent class belongs to a module
-        classname = recursive_class_name_find class_s_exp[2]
-        uml_class.parent = classname unless classname.nil?
-      end
-
-      # Looks-up for instance methods
-      class_s_exp.each_of_type :defn do |instance_method|
-        # Handle question marks in method names
-        uml_class.methods << instance_method[1].to_s.gsub(/\?/, '&#63;')
-
-        # Now looking for @variables, inside instance methods
-        # I'm looking at assignments such as @var = x
-        instance_method.each_of_type :iasgn do |assignment|
-          if assignment[1].instance_of?(Symbol) && assignment[1].to_s =~ /@/
-            variable = assignment[1].to_s.gsub('@', '')
-            uml_class.variables << variable unless uml_class.variables.include? variable
-          end
-        end
-      end
-      uml_class
-    end
-
-    def is_module?(class_s_exp)
-      if class_s_exp[1].instance_of?(Symbol)
-        UmlClass.new class_s_exp[1].to_s
-      else
-        classname = recursive_class_name_find class_s_exp[1]
-        UmlClass.new classname unless classname.nil?
-      end
-    end
-
-    # Yields the variable, the type and the cardinality for each associations
-    def each_association_for(a_class)
-      if comments = a_class.comments
-        comments.split(/\n/).each do |line|
-          line.match(/type of @(\w*): ([0-9.*n]* )?([:|\w]*)\b/) do |m|
-            yield m[1], m[3], m[2]&.chop
-          end
-        end
-      end
-    end
-
-    def recursive_class_name_find(sexp)
-      return nil if sexp.nil?
-      return sexp[1].to_s if sexp[0] == :const || sexp[0] == :colon3
-
-      classname = recursive_class_name_find sexp[1]
-      classname = '' if classname.nil?
-      "#{classname}::#{sexp[2]}"
-    end
-  end
-end

data/lib/ruby_to_uml/runner.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-require 'optparse'
-require 'net/http'
-require 'erb'
-
-module RubyToUML
-  class Runner
-    def initialize(args)
-      abort('Usage: ruby_to_uml [source directory]') if args.empty?
-
-      @args = args
-      @smart_mode = false
-      @link_mode = false
-
-      parse_options
-    end
-
-    def run
-      classes = parse_s_expressions
-      abort('No ruby files in the directory.') unless classes
-      classes.each { |c| c.infer_types! classes } if smart_mode
-
-      diagram = create_diagram(classes)
-
-      if link_mode
-        uri = yuml_uri(diagram)
-        puts "Link to yUML Diagram: #{uri}"
-      else
-        png = download_diagram(yuml_uri(diagram, type: '.png'))
-        save_file(png, type: '.png')
-        puts 'Diagram saved in uml.png'
-      end
-    end
-
-    private
-
-    attr_reader :args
-    attr_accessor :smart_mode, :link_mode
-
-    def parse_options
-      OptionParser.new do |opts|
-        opts.on('-s', '--smart') { self.smart_mode = true }
-        opts.on('-l', '--link')  { self.link_mode = true }
-        opts.on('-v', '--version') { puts VERSION }
-      end.parse!(args)
-    end
-
-    def parse_s_expressions
-      path = args[0]
-      ParserSexp.new(path).parse_sources!
-    end
-
-    def create_diagram(classes)
-      diagram = Diagram.new
-      diagram.create do
-        classes.each { |c| add c }
-      end.compute!
-      diagram
-    end
-
-    def yuml_uri(diagram, type: '')
-      scheme = 'https://'
-      host = 'yuml.me'
-      path = "/diagram/boring/class/#{ERB::Util.url_encode(diagram.get_dsl)}"
-      uri = URI(scheme + host + path + type)
-    end
-
-    def download_diagram(uri)
-      Net::HTTP.get_response(uri).body
-    end
-
-    def save_file(data, type: '')
-      File.open("uml#{type}", 'w') do |file|
-        file << data
-      end
-    end
-  end
-end

data/lib/ruby_to_uml/uml_class.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/inflector' # To uses String#classify
-module RubyToUML
-  # Represents a parsed uml class
-  class UmlClass
-    attr_accessor :name, :variables, :methods, :associations, :parent, :children
-
-    def initialize(name)
-      @name = name
-      @variables = []
-      @methods = []
-      @associations = {}
-    end
-
-    def finalize_uml_class_info(classes)
-      remove_duplicate_var_and_add_associations(classes)
-    end
-
-    def to_s
-      '[' + @name + '|' +
-        @variables.collect { |var| var }.join(';') + '|' +
-        @methods.collect { |met| met }.join(';') + ']'
-    end
-
-    # Tries to create an association with the attributes in @variables.
-    def infer_types!(classes)
-      class_names = classes.collect(&:name)
-      @variables.each do |attribute|
-        next unless class_names.include? attribute.classify
-
-        # A type has match with the attribute's name
-        @associations[attribute] = attribute.classify
-
-        # If it's a plural, adds a cardinality
-        @associations["#{attribute}-n"] = '*' if attribute == attribute.pluralize
-      end
-      finalize_uml_class_info(classes)
-    end
-
-    private
-
-    # Deletes variables from the @variables array if they appear
-    # in an association.
-    # Sets the @children variable
-    def remove_duplicate_var_and_add_associations(classes)
-      @variables -= @associations.keys unless @associations.nil?
-      @children = classes.select do |c|
-        if c.parent == @name
-          c.parent = nil
-          true
-        end
-      end
-    end
-  end
-end

data/lib/ruby_to_uml/version.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module RubyToUML
-  VERSION = '2.0.0'
-end