ruby_to_uml 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3445cfab16eaa84745cd0b367155f28c86beb1a79e93c072aaf6dfe8b599154b
+  data.tar.gz: 76841acf154c49b453862ffae8525bcae1846a864a0e332cd534a5278e386465
+SHA512:
+  metadata.gz: f7120950f0bf81be765c5758f7d94785c606f8b77cffc8ced2995d80f1aad96bc071bad8334c232c486ee64bc90d85eaaa57524fae0c6683575f29aef1acc549
+  data.tar.gz: 9cc132f121042b7e817b95b58f84187b4bb796712cb580f827407b3ec8999d51677e53a4410c8a0fd08a3dcc6e934b642cbe7d69f7716379a6250eb9a7c08412

data/bin/ruby_to_uml

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

data/lib/ruby_to_uml.rb

@@ -0,0 +1,9 @@
+# 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

data/lib/ruby_to_uml/diagram.rb

@@ -0,0 +1,78 @@
+# 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

@@ -0,0 +1,148 @@
+# 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

@@ -0,0 +1,79 @@
+# 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

@@ -0,0 +1,56 @@
+# 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

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

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: ruby_to_uml
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+platform: ruby
+authors:
+- Iuliu Pop
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-02-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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: ruby_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'
+description: 
+email:
+- iuliu.laurentiu.pop@protonmail.com
+executables:
+- ruby_to_uml
+extensions: []
+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
+homepage: https://github.com/iulspop/ruby_to_uml
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/iulspop/ruby_to_uml
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key: 
+specification_version: 4
+summary: ruby_to_uml is a tool that creates class diagrams from Ruby code.
+test_files: []