prailroady 1.5.3

data/README.md

@@ -0,0 +1,34 @@
+# Use online preview
+
+https://planttext.com/
+
+# Or install local
+
+## Mac users
+
+Brew users can install via:
+
+    brew install graphviz
+
+MacPorts users can install in via
+
+    sudo port install graphviz
+
+## Install Plantuml 
+
+http://plantuml.com/download
+
+## Install Atom Preview
+
+https://atom.io/packages/plantuml-viewer
+
+https://atom.io/packages/plantuml-preview
+
+## Run generate
+
+```bash
+prailroady -o models.pu -M # only model name
+prailroady -o models.pu -M -l # with attributes
+```
+
+Then open `models.pu` using atom preview or use online preview.

data/Rakefile

@@ -0,0 +1,12 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib/prailroady'
+  t.test_files = FileList['test/lib/prailroady/*_spec.rb']
+  t.verbose = true
+end
+
+task default: :test

data/bin/prailroady

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+
+# PrailRoady - RoR diagrams generator
+# http://github.com/preston/railroady
+#
+#   PrailRoady generates models and controllers diagrams in DOT language
+#   for a Rails v3 application.
+#
+# Copyright 2007-2008 - Javier Smaldone (http://www.smaldone.com.ar)
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# Modifications 2010-2015 by Preston Lee.
+#
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'prailroady'
+
+APP_NAME       = 'prailroady'
+APP_HUMAN_NAME = 'PrailRoady'
+# APP_VERSION    = [PrailRoady::VERSION::MAJOR, PrailRoady::VERSION::MINOR, PrailRoady::VERSION::PATCH]
+APP_VERSION    = PrailRoady::VERSION
+COPYRIGHT      = 'Copyright (C) 2007-2008 Javier Smaldone, 2009 Peter Hoeg, 2010-2015 Preston Lee'
+
+options = OptionsStruct.new(app_name: APP_NAME, app_human_name: APP_HUMAN_NAME, app_version: APP_VERSION, copyright: COPYRIGHT)
+
+options.parse ARGV
+
+# puts "OPTS!!!"
+# puts options
+
+old_dir = Dir.pwd
+
+Dir.chdir(options.root) if options.root != ''
+
+case options.command
+when 'models'
+  diagram = ModelsDiagram.new options
+when 'controllers'
+  diagram = ControllersDiagram.new options
+when 'aasm'
+  diagram = AasmDiagram.new(options)
+else
+  STDERR.print "#{APP_HUMAN_NAME} v#{APP_VERSION}\n" \
+    "Error: You must supply a command\n" \
+    "  (try #{APP_NAME} -h)\n\n"
+  exit 1
+end
+
+diagram.process
+diagram.generate
+
+Dir.chdir(old_dir)
+
+diagram.print

data/lib/prailroady.rb

@@ -0,0 +1,5 @@
+%w(version options_struct models_diagram controllers_diagram aasm_diagram).each { |f| require "prailroady/#{f}" }
+
+module PrailRoady
+  require 'prailroady/railtie' if defined?(Rails)
+end

data/lib/prailroady/aasm_diagram.rb

@@ -0,0 +1,105 @@
+# PrailRoady - RoR diagrams generator
+# http://railroad.rubyforge.org
+#
+# Copyright 2007-2008 - Javier Smaldone (http://www.smaldone.com.ar)
+# See COPYING for more details
+
+# AASM code provided by Ana Nelson (http://ananelson.com/)
+
+require 'prailroady/app_diagram'
+
+# Diagram for Acts As State Machine
+class AasmDiagram < AppDiagram
+  def initialize(options = OptionsStruct.new)
+    # options.exclude.map! {|e| e = "app/models/" + e}
+    super options
+    @graph.diagram_type = 'Models'
+    # Processed habtm associations
+    @habtm = []
+  end
+
+  # Process model files
+  def generate
+    STDERR.print "Generating AASM diagram\n" if @options.verbose
+    get_files.each do |f|
+      process_class extract_class_name(f).constantize
+    end
+  end
+
+  def get_files(prefix = '')
+    files = !@options.specify.empty? ? Dir.glob(@options.specify) : Dir.glob(prefix + 'app/models/**/*.rb')
+    files += Dir.glob('vendor/plugins/**/app/models/*.rb') if @options.plugins_models
+    files -= Dir.glob(prefix + 'app/models/concerns/**/*.rb') unless @options.include_concerns
+    files -= Dir.glob(@options.exclude)
+    files
+  end
+
+  private
+
+  # Load model classes
+  def load_classes
+    disable_stdout
+    get_files.each { |m| require m }
+    enable_stdout
+  rescue LoadError
+    enable_stdout
+    print_error 'model classes'
+    raise
+  end  # load_classes
+
+  # Process a model class
+  def process_class(current_class)
+    STDERR.print "\tProcessing #{current_class}\n" if @options.verbose
+
+    # Only interested in acts_as_state_machine models.
+    process_acts_as_state_machine_class(current_class)  if current_class.respond_to?(:states)
+    process_aasm_class(current_class)  if current_class.respond_to?(:aasm_states) || current_class.respond_to?(:aasm)
+  end # process_class
+
+  def process_acts_as_state_machine_class(current_class)
+    node_attribs = []
+    node_type = 'aasm'
+
+    STDERR.print "\t\tprocessing as acts_as_state_machine\n" if @options.verbose
+    current_class.aasm.states.each do |state_name|
+      node_shape = (current_class.aasm.initial_state == state_name) ? ', peripheries = 2' : ''
+      node_attribs << "#{current_class.name.downcase}_#{state_name} [label=#{state_name} #{node_shape}];"
+    end
+    @graph.add_node [node_type, current_class.name, node_attribs]
+
+    current_class.aasm.events.each do |event|
+      event_name = event.name
+      event.transitions.each do |transition|
+        @graph.add_edge [
+          'event',
+          current_class.name.downcase + '_' + transition.from.to_s,
+          current_class.name.downcase + '_' + transition.to.to_s,
+          event_name.to_s
+        ]
+      end
+    end
+  end
+
+  def process_aasm_class(current_class)
+    node_attribs = []
+    node_type = 'aasm'
+
+    STDERR.print "\t\tprocessing as aasm\n" if @options.verbose
+    current_class.aasm.states.each do |state|
+      node_shape = (current_class.aasm.initial_state == state.name) ? ', peripheries = 2' : ''
+      node_attribs << "#{current_class.name.downcase}_#{state.name} [label=#{state.name} #{node_shape}];"
+    end
+    @graph.add_node [node_type, current_class.name, node_attribs]
+
+    current_class.aasm.events.each do |event|
+      event.transitions.each do |transition|
+        @graph.add_edge [
+          'event',
+          current_class.name.downcase + '_' + transition.from.to_s,
+          current_class.name.downcase + '_' + transition.to.to_s,
+          event.name.to_s
+        ]
+      end
+    end
+  end
+end # class AasmDiagram

data/lib/prailroady/app_diagram.rb

@@ -0,0 +1,103 @@
+# PrailRoady - RoR diagrams generator
+# http://railroad.rubyforge.org
+#
+# Copyright 2007-2008 - Javier Smaldone (http://www.smaldone.com.ar)
+# See COPYING for more details
+
+require 'prailroady/diagram_graph'
+
+# Root class for PrailRoady diagrams
+class AppDiagram
+  def initialize(options = OptionsStruct.new)
+    @options = options
+    @graph = DiagramGraph.new
+    @graph.show_label = @options.label
+    @graph.alphabetize = @options.alphabetize
+  end
+
+  # Print diagram
+  def print
+    if @options.output
+      old_stdout = STDOUT.dup
+      begin
+        STDOUT.reopen(@options.output)
+      rescue
+        STDERR.print "Error: Cannot write diagram to #{@options.output}\n\n"
+        exit 2
+      end
+    end
+
+    if @options.xmi
+      STDERR.print "Generating XMI diagram\n" if @options.verbose
+      STDOUT.print @graph.to_xmi
+    else
+      STDERR.print "Generating DOT graph\n" if @options.verbose
+      STDOUT.print @graph.to_dot
+    end
+
+    STDOUT.reopen(old_stdout) if @options.output
+  end # print
+
+  def process
+    load_environment
+  end
+
+  # get all engines
+  def engines
+    engines = []
+
+    if defined?(Rails)
+      engines = if Rails::Application::Railties.respond_to?(:engines)
+                  Rails::Application::Railties.engines
+                else
+                  # rails 4 way of getting engines
+                  Rails::Engine.subclasses.map(&:instance)
+                end
+    end
+    engines
+  end
+
+  private
+
+  # Load Rails application's environment
+  def load_environment
+    STDERR.print "Loading application environment\n" if @options.verbose
+    begin
+      disable_stdout
+      l = File.join(Dir.pwd.to_s, @options.config_file)
+      require l
+      enable_stdout
+    rescue LoadError
+      enable_stdout
+      print_error 'application environment'
+      raise
+    end
+    STDERR.print "Loading application classes as we go\n" if @options.verbose
+  end
+
+  # Prevents Rails application from writing to STDOUT
+  def disable_stdout
+    @old_stdout = STDOUT.dup
+    # via  Tomas Matousek, http://www.ruby-forum.com/topic/205887
+    STDOUT.reopen(::RUBY_PLATFORM =~ /djgpp|(cyg|ms|bcc)win|mingw/ ? 'NUL' : '/dev/null')
+  end
+
+  # Restore STDOUT
+  def enable_stdout
+    STDOUT.reopen(@old_stdout)
+  end
+
+  # Print error when loading Rails application
+  def print_error(type)
+    STDERR.print "Error loading #{type}.\n  (Are you running " \
+                 "#{@options.app_name} on the application's root directory?)\n\n"
+  end
+
+  # Extract class name from filename
+  def extract_class_name(filename)
+    # filename.split('/')[2..-1].join('/').split('.').first.camelize
+    # Fixed by patch from ticket #12742
+    # File.basename(filename).chomp(".rb").camelize
+    filename.split('/')[2..-1].collect(&:camelize).join('::').chomp('.rb')
+  end
+end # class AppDiagram

data/lib/prailroady/controllers_diagram.rb

@@ -0,0 +1,103 @@
+# PrailRoady - RoR diagrams generator
+# http://railroad.rubyforge.org
+#
+# Copyright 2007-2008 - Javier Smaldone (http://www.smaldone.com.ar)
+# See COPYING for more details
+
+require 'prailroady/app_diagram'
+
+# PrailRoady controllers diagram
+class ControllersDiagram < AppDiagram
+  # as of Rails 2.3 the file is no longer application.rb but instead
+  # application_controller.rb
+  APP_CONTROLLER = File.exist?('app/controllers/application.rb') ? 'app/controllers/application.rb' : 'app/controllers/application_controller.rb'
+
+  def initialize(options = OptionsStruct.new)
+    # options.exclude.map! {|e| "app/controllers/" + e}
+    super options
+    @graph.diagram_type = 'Controllers'
+  end
+
+  # Process controller files
+  def generate
+    STDERR.print "Generating controllers diagram\n" if @options.verbose
+    files = get_files
+    # only add APP_CONTROLLER if it isn't already included from the glob above
+    files << APP_CONTROLLER unless files.include? APP_CONTROLLER
+    files.each do |f|
+      class_name = extract_class_name(f)
+      # ApplicationController's file is 'application.rb' in Rails < 2.3
+      class_name += 'Controller' if class_name == 'Application'
+      begin
+        process_class class_name.constantize
+      rescue Exception
+        STDERR.print "Warning: exception #{$ERROR_INFO} raised while trying to load controller class #{f}"
+      end
+    end
+  end # generate
+
+  def get_files(prefix = '')
+    files = !@options.specify.empty? ? Dir.glob(@options.specify) : Dir.glob(prefix << 'app/controllers/**/*_controller.rb')
+    files += engine_files if @options.engine_controllers
+    files -= Dir.glob(@options.exclude)
+    files
+  end
+
+  def engine_files
+    engines.collect { |engine| Dir.glob("#{engine.root}/app/controllers/**/*_controller.rb") }.flatten
+  end
+
+  def extract_class_name(filename)
+    filename.match(/.*\/controllers\/(.*).rb$/)[1].camelize
+  end
+
+  private
+
+  # Load controller classes
+  def load_classes
+    disable_stdout
+    # ApplicationController must be loaded first
+    require APP_CONTROLLER
+    get_files.each { |c| require "./#{c}" }
+    enable_stdout
+  rescue LoadError
+    enable_stdout
+    print_error 'controller classes'
+    raise
+  end # load_classes
+
+  # Proccess a controller class
+  def process_class(current_class)
+    STDERR.print "\tProcessing #{current_class}\n" if @options.verbose
+
+    if @options.brief
+      @graph.add_node ['controller-brief', current_class.name]
+    elsif current_class.is_a? Class
+      # Collect controller's methods
+      node_attribs = { public: [],
+                       protected: [],
+                       private: [] }
+      current_class.public_instance_methods(false).sort.each do |m|
+        node_attribs[:public] << m
+      end unless @options.hide_public
+      current_class.protected_instance_methods(false).sort.each do |m|
+        node_attribs[:protected] << m
+      end unless @options.hide_protected
+      current_class.private_instance_methods(false).sort.each do |m|
+        node_attribs[:private] << m
+      end unless @options.hide_private
+      @graph.add_node ['controller', current_class.name, node_attribs]
+    elsif @options.modules && current_class.is_a?(Module)
+      @graph.add_node ['module', current_class.name]
+    end
+
+    # Generate the inheritance edge (only for transitive subclasses of ApplicationControllers)
+    if @options.inheritance && (transitive_subclasses_of(ApplicationController).include? current_class)
+      @graph.add_edge ['is-a', current_class.superclass.name, current_class.name]
+    end
+  end # process_class
+
+  def transitive_subclasses_of(klass)
+    klass.subclasses | klass.subclasses.map { |subklass| transitive_subclasses_of(subklass) }.flatten
+  end
+end # class ControllersDiagram

data/lib/prailroady/diagram_graph.rb

@@ -0,0 +1,125 @@
+# PrailRoady - RoR diagrams generator
+# http://railroad.rubyforge.org
+#
+# Copyright 2007-2008 - Javier Smaldone (http://www.smaldone.com.ar)
+# See COPYING for more details
+
+# PrailRoady diagram structure
+class DiagramGraph
+  def initialize
+    @diagram_type = ''
+    @show_label   = false
+    @alphabetize  = false
+    @nodes = []
+    @edges = []
+  end
+
+  def add_node(node)
+    @nodes << node
+  end
+
+  def add_edge(edge)
+    @edges << edge
+  end
+
+  attr_writer :diagram_type
+
+  attr_writer :show_label
+
+  attr_writer :alphabetize
+
+  # Generate DOT graph
+  def to_dot
+    dot_header +
+      @nodes.map { |n| dot_node n[0], n[1], n[2], n[3] }.join +
+      @edges.map { |e| dot_edge e[0], e[1], e[2], e[3] }.join +
+      dot_footer
+  end
+
+  # Generate XMI diagram (not yet implemented)
+  def to_xmi
+    STDERR.print "Sorry. XMI output not yet implemented.\n\n"
+    ''
+  end
+
+  private
+
+  # Build DOT diagram header
+  def dot_header
+    result = "@startuml\n"
+      result += "\tskinparam linetype ortho\n"
+      result += "\tskinparam packageStyle rectangle\n"
+      result += "\tskinparam shadowing false\n"
+      result += "\tskinparam class {\n"
+        result += "\t\tBackgroundColor White\n"
+        result += "\t\tBorderColor Black\n"
+        result += "\t\tArrowColor Black\n"
+      result += "\t}\n"
+      result += "\thide members\n" if !@show_label
+      result += "\thide circle\n"
+    result
+  end
+
+  # Build DOT diagram footer
+  def dot_footer
+    "\n@enduml\n"
+  end
+
+  # Build a DOT graph node
+  def dot_node(type, name, attributes = nil, custom_options = '')
+    options = ''
+    case type
+      when 'model'
+        options += attributes.sort_by { |s| @alphabetize ? s : nil }.map{|s| "\t\t#{s}"}.join("\n")
+      when 'model-brief'
+        options += ""
+      when 'class'
+        options += ""
+      when 'class-brief'
+        options += ""
+      when 'controller'
+        options += ""
+        options += attributes[:public].sort_by    { |s| @alphabetize ? s : nil }.map{|s| "\t\t#{s}"}.join("\n")
+        options += attributes[:protected].sort_by { |s| @alphabetize ? s : nil }.map{|s| "\t\t#{s}"}.join("\n")
+        options += attributes[:private].sort_by   { |s| @alphabetize ? s : nil }.map{|s| "\t\t#{s}"}.join("\n")
+      when 'controller-brief'
+        options += ""
+      when 'module'
+        options += ""
+      when 'aasm'
+        return "aasm: \\n #{attributes.join("\\n")}"
+    end
+    # options = [options, custom_options].compact.reject{|o| o.empty?}.join(', ')
+    attr_options = "{\n#{options}\n\t}" if @show_label && options.length > 0
+    return "\tclass #{quote(name)} as #{noquote(name)} #{attr_options}\n"
+  end # dot_node
+
+  # Build a DOT graph edge
+  def dot_edge(type, from, to, name = '')
+    ret = ""
+    case type
+      when 'one-one'
+        ret = "\t#{quote(from)} -- #{quote(to)}\n"
+      when 'one-many'
+        ret = "\t#{quote(from)} --|{ #{quote(to)}\n"
+      when 'many-many'
+        ret = "\t#{quote(from)} }|--|{ #{quote(to)}\n"
+      when 'belongs-to'
+        ret = "\t#{quote(from)} }|--|{ #{quote(to)}\n"
+      when 'is-a'
+        ret = "\t#{quote(from)} }|--|{ #{quote(to)}\n"
+      when 'event'
+        ret = "\t#{quote(from)} }|--|{ #{quote(to)}\n"
+    end
+    ret
+  end # dot_edge
+
+  # Quotes a class name
+  def quote(name)
+    ('"' + name.to_s + '"').gsub(":","")
+  end
+  def noquote(name)
+    name.to_s.gsub(":","")
+  end
+
+end # class DiagramGraph