umlify 0.3.0

data/README

@@ -0,0 +1,19 @@
+                            _ _  __
+                           | (_)/ _|
+            _   _ _ __ ___ | |_| |_ _   _
+           | | | | '_ ` _ \| | |  _| | | |
+           | |_| | | | | | | | | | | |_| |
+            \__,_|_| |_| |_|_|_|_|  \__, |
+                                     __/ |
+                                    |___/
+
+            umlify is a tool that creates
+          uml class diagrams from your code
+
+         <https://github.com/mikaa123/umlify>
+
+
+Introduction
+------------
+
+umlify takes your project's source code and creates an uml class diagram out of it. 

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+
+Rake::TestTask.new do |t|
+    t.test_files = FileList['test/*_test.rb']
+    t.verbose = true
+end

data/bin/umlify

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'umlify'
+
+Umlify::Runner.new(ARGV).run

data/lib/umlify/diagram.rb

@@ -0,0 +1,44 @@
+module Umlify
+
+  ##
+  # Creates and store a yUML api string for generating diagram
+  #
+  class Diagram
+
+    # Array containing yUML DSL statements
+    attr_accessor :statements
+
+    def initialize
+      @statements = []
+    end
+
+    def create &blk
+      instance_eval &blk
+    end
+
+    # Adds the given statement to the @diagram array
+    def add statement
+      # TODO: Add some sort of validation
+
+      @statements << statement if statement.is_a? String
+      if statement.is_a? UmlClass
+
+        if statement.associations.empty?
+          @statements << statement.to_s
+        else
+          @statements << statement.to_s
+
+          statement.associations.each do |name, type|
+            @statements << "[#{statement.name}]-#{name}>[#{type}]"
+          end
+        end
+
+      end
+    end
+
+    # Dumps the html of the diagram
+    def export
+      '<img src="http://yuml.me/diagram/class/'+@statements.join(", ")+'" />'
+    end
+  end
+end

data/lib/umlify/extension.rb

@@ -0,0 +1,13 @@
+# Extends the String to add a String#each method so that
+# strings can be read just like files, line-by-line.
+
+class String
+
+  def each
+
+    self.split(/\n/).each do |line|
+      yield line
+    end
+
+  end
+end

data/lib/umlify/parser.rb

@@ -0,0 +1,79 @@
+module Umlify
+
+  ##
+  # Parser is responsible for parsing ruby source files and building an array
+  # of uml classes
+  #
+  class Parser
+
+    # An array containing all the parsed classes
+    # type: UmlClass
+    attr_accessor :classes
+
+    # files should be an array containing file names with the correct path
+    def initialize files
+      @files = files
+      @classes = []
+    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 = @files.select {|f| f.match /\.rb/}
+      return nil if @source_files.empty?
+
+      @source_files.each do |file|
+        f = File.open file, 'r'
+        (parse_file f).each {|c| @classes << c}
+        f.close
+      end
+
+      @classes
+    end
+
+    # Parse the given file or string, and return the parsed classes
+    def parse_file file
+      classes_in_file = []
+      current_class = nil
+      type_annotation = nil
+
+      file.each do |line|
+
+        # This parses the classes
+        line.match(/^\s*class ([\w]*)\b/) do |m|
+          current_class = UmlClass.new m[1]
+          classes_in_file << current_class
+        end
+
+        if current_class
+
+          # This parses the @variables
+          line.match(/@([\w]*)\b/) do |m|
+            current_class.variables << m[1] unless current_class.variables.include? m[1]
+          end
+
+          # This parses the methods
+          line.match(/def ([\w]*)\b/) do |m|
+            current_class.methods << m[1] unless current_class.methods.include? m[1]
+          end
+
+          # This raises the type_annotation flag
+          line.match(/# type: ([\w]*)\b/) {|m| type_annotation = m[1]}
+
+          # This adds an association to the current class, using the type_annotation
+          # if type_annotation has been set
+          line.match(/attr_accessor :([\w]*)\b/) do |m|
+            current_class.associations[m[1]] = type_annotation
+            type_annotation = nil
+          end if type_annotation
+
+        end
+      end
+
+      classes_in_file
+    end
+  end
+end

data/lib/umlify/runner.rb

@@ -0,0 +1,72 @@
+require 'optparse'
+
+module Umlify
+
+  ###
+  # This class is instanciated and run by the bin file
+  #
+  class Runner
+
+    # Contains the options from the command line
+    attr_reader :args
+
+    # type: Parser
+    attr_accessor :parser
+
+    # type: Diagram
+    attr_accessor :diagram
+
+    # Takes as input an array with the command line options
+    def initialize args
+      @args = args
+    end
+
+    # Runs the application
+    def run
+      @args.push "-h" if @args.empty?
+
+      if @args[0][0] == '-'
+
+        OptionParser.new do |opts|
+          opts.banner = "Usage: umlify [option]"
+          opts.on("-h", "--help",  "Shows this") do
+            puts opts
+          end
+        end.parse! @args
+
+      else
+        puts "umlifying"
+        if files = get_files_from_dir(ARGV[0])
+          puts "about to parse..."
+          @parser = Parser.new files
+
+          if classes = p.parse_sources!
+            @diagram = Diagram.new
+
+            diagram.create do
+              classes.each {|c| add c}
+            end
+
+            File.open("uml.html", 'w') do |file|
+              file << diagram.export
+            end
+
+            puts "Saved in uml.html"
+          else
+            puts "No ruby files in the directory"
+          end
+
+        else
+          puts "empty directory"
+        end
+      end
+
+    end
+
+    private
+
+    def get_files_from_dir directory
+      Dir[directory] unless Dir[directory].empty?
+    end
+  end
+end

data/lib/umlify/uml_class.rb

@@ -0,0 +1,23 @@
+module Umlify
+
+  ##
+  # Represent a parsed uml class
+  #
+  class UmlClass
+    attr_accessor :name, :variables, :methods, :associations
+
+    def initialize name
+      @name = name
+      @variables = []
+      @methods = []
+      @associations = {}
+    end
+
+    def to_s
+      '['+@name+'|'+
+      @variables.collect{|var| var}.join(";")+'|'+
+      @methods.collect{|met| met}.join(";")+']'
+    end
+  end
+end
+

data/lib/umlify/version.rb

@@ -0,0 +1,3 @@
+module Umlify
+  VERSION = "0.3.0"
+end

data/lib/umlify.rb

@@ -0,0 +1,6 @@
+require 'umlify/version'
+require 'umlify/runner'
+require 'umlify/parser'
+require 'umlify/extension'
+require 'umlify/uml_class'
+require 'umlify/diagram'

data/test/diagram_test.rb

@@ -0,0 +1,68 @@
+require 'shoulda'
+require 'umlify'
+
+class DiagramTest < Test::Unit::TestCase
+
+  context "Diagram" do
+
+    setup do
+      @diagram = Umlify::Diagram.new
+    end
+
+    should "respond to create"  do
+      assert_respond_to @diagram, :create
+    end
+
+    should "add Strings statements to diagram"  do
+      test_statement = '[foo]->[bar]'
+      @diagram.create do
+        add test_statement
+      end
+
+      assert_equal ['[foo]->[bar]'], @diagram.statements
+    end
+
+    should "add UmlClass without associations to diagrams"  do
+      test_uml_class = Umlify::UmlClass.new 'Unicorn'
+      test_uml_class.variables << 'foo_variable'
+      test_uml_class.methods << 'bar_method'
+
+      @diagram.create do
+        add test_uml_class
+      end
+
+      assert @diagram.statements.include? '[Unicorn|foo_variable|bar_method]'
+    end
+
+    should "add UmlClass with associations to diagrams"  do
+      test_uml_class = Umlify::UmlClass.new 'Unicorn'
+      test_uml_class.variables << 'foo_variable'
+      test_uml_class.methods << 'bar_method'
+      test_uml_class.associations['foo'] = 'Bar'
+      test_uml_class.associations['chunky'] = 'Bacon'
+
+      @diagram.create do
+        add test_uml_class
+      end
+
+      assert @diagram.statements.include? '[Unicorn|foo_variable|bar_method]'
+      assert @diagram.statements.include? '[Unicorn]-foo>[Bar]'
+      assert @diagram.statements.include? '[Unicorn]-chunky>[Bacon]'
+    end
+
+    should "export th yUML html"  do
+      test_uml_class = Umlify::UmlClass.new 'Unicorn'
+      test_uml_class.variables << 'foo_variable'
+      test_uml_class.methods << 'bar_method'
+
+      @diagram.create do
+        add test_uml_class
+      end
+
+      assert_equal '<img src="http://yuml.me/diagram/class/[Unicorn|foo_variable|bar_method]" />',
+       @diagram.export
+    end
+
+  end
+end
+

data/test/parser_test.rb

@@ -0,0 +1,67 @@
+require 'shoulda'
+require 'umlify'
+
+class ParserTest < Test::Unit::TestCase
+
+  context "Parser" do
+
+    setup do
+      fixture = ["somefile.rb", "someotherfile.rb"]
+      @p = Umlify::Parser.new fixture
+    end
+
+    should "respond to parse_sources!"  do
+      assert_respond_to @p, :parse_sources!
+    end
+
+    should "return nil if no source file in the given directory" do
+      parser = Umlify::Parser.new ["not_source", "still_not_source"]
+      assert_equal nil, parser.parse_sources!
+    end
+
+    should "parse class names" do
+      test = <<-END_FILE
+      class AClassName
+      end
+      END_FILE
+      assert_equal 'AClassName', @p.parse_file(test)[0].name
+    end
+
+    should "parse @variables in classes" do
+      test = <<-END_FILE
+      class Bar
+        def foo
+          @a_variable = "foo"
+        end
+      end
+      END_FILE
+      bar = @p.parse_file(test)[0]
+      assert_instance_of Umlify::UmlClass, bar
+      assert bar.variables.include? "a_variable"
+    end
+
+    should "parse attr_accessor when preceeded by a # type: Type annotation" do
+      test = <<-END_FILE
+      class Bar
+
+        # type: FooBar
+        attr_accessor :unicorn
+
+        def foo
+        end
+      end
+      END_FILE
+      bar = @p.parse_file(test)[0]
+      assert_instance_of Umlify::UmlClass, bar
+      assert_equal "FooBar", bar.associations['unicorn']
+    end
+
+    should "return an array of UmlClasses when the parsing is done" do
+      p = Umlify::Parser.new Dir[File.dirname(__FILE__)+'/fixtures/*']
+      parsed_classes = p.parse_sources!
+      puts "here : #{parsed_classes}"
+      assert_equal 3, parsed_classes.count
+    end
+
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: umlify
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.3.0
+platform: ruby
+authors: 
+- Michael Sokol
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-02 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: 
+email: mikaa123@gmail.com
+executables: 
+- umlify
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- README
+- bin/umlify
+- lib/umlify.rb
+- lib/umlify/version.rb
+- lib/umlify/runner.rb
+- lib/umlify/parser.rb
+- lib/umlify/extension.rb
+- lib/umlify/uml_class.rb
+- lib/umlify/diagram.rb
+- test/parser_test.rb
+- test/diagram_test.rb
+has_rdoc: true
+homepage: https://github.com/mikaa123/umlify
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: umlify is a tool that creates class diagrams from your code.
+test_files: 
+- test/parser_test.rb
+- test/diagram_test.rb