jw-rails-erd 1.4.5

data/lib/rails_erd/tasks.rake

@@ -0,0 +1,58 @@
+def say(message)
+  puts message unless Rake.application.options.silent
+end
+
+namespace :erd do
+  task :options do
+    (RailsERD.options.keys.map(&:to_s) & ENV.keys).each do |option|
+      RailsERD.options[option.to_sym] = case ENV[option]
+      when "true", "yes" then true
+      when "false", "no" then false
+      when /,/ then ENV[option].split(/\s*,\s*/)
+      else ENV[option].to_sym
+      end
+    end
+  end
+
+  task :load_models do
+    say "Loading application environment..."
+    Rake::Task[:environment].invoke
+
+    say "Loading code in search of Active Record models..."
+    begin
+      Rails.application.eager_load!
+    rescue Exception => err
+      if Rake.application.options.trace
+        raise
+      else
+        trace = Rails.backtrace_cleaner.clean(err.backtrace)
+        error = (["Loading models failed!\nError occurred while loading application: #{err} (#{err.class})"] + trace).join("\n    ")
+        raise error
+      end
+    end
+
+    raise "Active Record was not loaded." unless defined? ActiveRecord
+  end
+
+  task :generate => [:options, :load_models] do
+    say "Generating Entity-Relationship Diagram for #{ActiveRecord::Base.descendants.length} models..."
+
+    require "rails_erd/diagram/graphviz"
+    file = RailsERD::Diagram::Graphviz.create
+
+    say "Done! Saved diagram to #{file}."
+  end
+end
+
+desc "Generate an Entity-Relationship Diagram based on your models"
+task :erd => "erd:generate", :arg1, :arg2, :arg3 do |t, args|
+  say "Usage: rake erd <classname> <outputfile> <traversal depth>"
+  if args[0] == nil
+    say "Required field: Root Class node to start with"
+  end
+  if args[1] == nil
+    say "Required field: output file name"
+  end
+  args[2] ||= 1
+  RailsERD::Custom.new(args[0], args[1], args[2])
+end

data/lib/rails_erd/version.rb

@@ -0,0 +1,4 @@
+module RailsERD
+  VERSION = "1.4.5"
+  BANNER  = "RailsERD #{VERSION}"
+end

data/lib/rails_erd.rb

@@ -0,0 +1,73 @@
+require "active_support/ordered_options"
+require "rails_erd/railtie" if defined? Rails
+require "rails_erd/config"
+
+# Welcome to the API documentation of Rails ERD. If you wish to extend or
+# customise the output that is generated by Rails ERD, you have come to the
+# right place.
+#
+# == Creating custom output
+#
+# If you want to create your own kind of diagrams, or some other output, a
+# good starting point is the RailsERD::Diagram class. It can serve as the base
+# of your output generation code.
+#
+# == Options
+#
+# Rails ERD provides several options that allow you to customise the
+# generation of the diagram and the domain model itself. For an overview of
+# all options available in Rails ERD, see README.rdoc.
+#
+# You can specify the option on the command line if you use Rails ERD with
+# Rake:
+#
+#   % rake erd orientation=vertical title='My model diagram'
+#
+# When using Rails ERD from within Ruby, you can set the options on the
+# RailsERD namespace module:
+#
+#   RailsERD.options.orientation = :vertical
+#   RailsERD.options.title = "My model diagram"
+module RailsERD
+  class << self
+    # Access to default options. Any instance of RailsERD::Domain and
+    # RailsERD::Diagram will use these options unless overridden.
+    attr_accessor :options
+
+    def default_options
+      ActiveSupport::OrderedOptions[
+        :attributes, :content,
+        :disconnected, true,
+        :filename, "erd",
+        :filetype, :pdf,
+        :indirect, true,
+        :inheritance, false,
+        :markup, true,
+        :notation, :simple,
+        :orientation, :horizontal,
+        :polymorphism, false,
+        :sort, true,
+        :warn, true,
+        :title, true,
+        :exclude, nil,
+        :only, nil,
+        :prepend_primary, false
+      ]
+    end
+  end
+
+  module Inspectable # @private :nodoc:
+    def inspection_attributes(*attributes)
+      attribute_inspection = attributes.collect { |attribute|
+        " @#{attribute}=\#{[Symbol, String].include?(#{attribute}.class) ? #{attribute}.inspect : #{attribute}}"
+      }.join
+      class_eval <<-RUBY
+        def inspect
+          "#<\#{self.class}:0x%.14x#{attribute_inspection}>" % (object_id << 1)
+        end
+      RUBY
+    end
+  end
+
+  self.options = default_options.merge(Config.load)
+end

data/lib/tasks/auto_generate_diagram.rake

@@ -0,0 +1,21 @@
+namespace :db do
+  task :migrate do
+    ERDGraph::Migration.update_model
+  end
+
+  namespace :migrate do
+    [:change, :up, :down, :reset, :redo].each do |t|
+      task t do
+        ERDGraph::Migration.update_model
+      end
+    end
+  end
+end
+
+module ERDGraph
+  class Migration
+    def self.update_model
+      Rake::Task['erd'].invoke
+    end
+  end
+end

data/test/support_files/erdconfig.another_example

@@ -0,0 +1,3 @@
+attributes:
+  - primary_key
+

data/test/support_files/erdconfig.example

@@ -0,0 +1,19 @@
+attributes:
+  - content
+  - foreign_key
+  - inheritance
+  - false
+disconnected: true
+filename: erd
+filetype: pdf
+indirect: true
+inheritance: false
+markup: true
+notation: simple
+orientation: horizontal
+polymorphism: false
+warn: true
+title: sample title
+exclude:
+only: 
+

data/test/support_files/erdconfig.exclude.example

@@ -0,0 +1,19 @@
+attributes:
+  - content
+  - foreign_key
+  - inheritance
+  - false
+disconnected: true
+filename: erd
+filetype: pdf
+indirect: true
+inheritance: false
+markup: true
+notation: simple
+orientation: horizontal
+polymorphism: false
+warn: true
+title: sample title
+exclude: Book,Author
+only: 
+

data/test/test_helper.rb

@@ -0,0 +1,160 @@
+require "rubygems"
+require "bundler/setup"
+
+require "active_record"
+
+if ActiveSupport::VERSION::MAJOR >= 4
+  require "minitest/autorun"
+  require 'mocha/mini_test'
+else
+  require "test/unit"
+  require 'mocha/test_unit'
+end
+
+require "rails_erd/domain"
+
+ActiveRecord::Base.establish_connection :adapter => "sqlite3", :database => ":memory:"
+
+if ActiveSupport::TestCase.respond_to?(:test_order=)
+  ActiveSupport::TestCase.test_order = :random
+end
+
+class ActiveSupport::TestCase
+  include RailsERD
+
+  setup    :reset_config_file
+  teardown :reset_domain
+
+  def create_table(table, columns = {}, pk = nil)
+    opts = if pk then { :primary_key => pk } else { :id => false } end
+    ActiveRecord::Schema.instance_eval do
+      suppress_messages do
+        create_table table, opts do |t|
+          columns.each do |column, type|
+            t.send type, column
+          end
+        end
+      end
+    end
+    ActiveRecord::Base.clear_cache!
+  end
+
+  def add_column(*args)
+    ActiveRecord::Schema.instance_eval do
+      suppress_messages do
+        add_column(*args)
+      end
+    end
+    ActiveRecord::Base.clear_cache!
+  end
+
+  def create_model(name, *args, &block)
+    superklass = args.first.kind_of?(Class) ? args.shift : ActiveRecord::Base
+    columns = args.first || {}
+    klass = Object.const_set name.to_sym, Class.new(superklass)
+    if superklass == ActiveRecord::Base || superklass.abstract_class?
+      create_table Object.const_get(name.to_sym).table_name, columns, Object.const_get(name.to_sym).primary_key rescue nil
+    end
+    klass.class_eval(&block) if block_given?
+    Object.const_get(name.to_sym)
+  end
+
+  def create_models(*names)
+    names.each do |name|
+      create_model name
+    end
+  end
+
+  def collect_stdout
+    stdout = $stdout
+    $stdout = StringIO.new
+    yield
+    $stdout.rewind
+    $stdout.read
+  ensure
+    $stdout = stdout
+  end
+
+  def create_simple_domain
+    create_model "Beer", :bar => :references do
+      belongs_to :bar
+    end
+    create_model "Bar"
+  end
+
+  def create_one_to_one_assoc_domain
+    create_model "One" do
+      has_one :other
+    end
+    create_model "Other", :one => :references do
+      belongs_to :one
+    end
+  end
+
+  def create_one_to_many_assoc_domain
+    create_model "One" do
+      has_many :many
+    end
+    create_model "Many", :one => :references do
+      belongs_to :one
+    end
+  end
+
+  def create_many_to_many_assoc_domain
+    create_model "Many" do
+      has_and_belongs_to_many :more
+    end
+    create_model "More" do
+      has_and_belongs_to_many :many
+    end
+    create_table "manies_mores", :many_id => :integer, :more_id => :integer
+  end
+
+  def create_specialization
+    create_model "Beverage", :type => :string
+    create_model "Beer", Beverage
+  end
+
+  def create_polymorphic_generalization
+    create_model "Cannon"
+    create_model "Galleon" do
+      has_many :cannons, :as => :defensible
+    end
+  end
+
+  def create_abstract_generalization
+    create_model "Structure" do
+      self.abstract_class = true
+    end
+    create_model "Palace", Structure
+  end
+
+  private
+
+  def reset_config_file
+    RailsERD::Config.send :remove_const, :USER_WIDE_CONFIG_FILE
+    RailsERD::Config.send :const_set, :USER_WIDE_CONFIG_FILE,
+      File.expand_path("../../examples/erdconfig.not_exists", __FILE__)
+
+    RailsERD::Config.send :remove_const, :CURRENT_CONFIG_FILE
+    RailsERD::Config.send :const_set, :CURRENT_CONFIG_FILE,
+      File.expand_path("../../examples/erdconfig.not_exists", __FILE__)
+
+    RailsERD.options = RailsERD.default_options.merge(Config.load)
+  end
+
+  def reset_domain
+    if defined? ActiveRecord
+      ActiveRecord::Base.descendants.each do |model|
+        model.reset_column_information
+        Object.send :remove_const, model.name.to_sym if Object.const_defined? model.name.to_sym
+      end
+      ActiveRecord::Base.connection.tables.each do |table|
+        ActiveRecord::Base.connection.drop_table table
+      end
+      ActiveRecord::Base.direct_descendants.clear
+      ActiveSupport::Dependencies::Reference.clear!
+      ActiveRecord::Base.clear_cache!
+    end
+  end
+end

data/test/unit/attribute_test.rb

@@ -0,0 +1,316 @@
+# encoding: utf-8
+require File.expand_path("../test_helper", File.dirname(__FILE__))
+
+class AttributeTest < ActiveSupport::TestCase
+  def with_native_limit(type, new_limit)
+    ActiveRecord::Base.connection.class_eval do
+      define_method :native_database_types do
+        super().tap do |types|
+          types[type][:limit] = new_limit
+        end
+      end
+    end
+    yield
+  ensure
+    ActiveRecord::Base.connection.class_eval do
+      define_method :native_database_types do
+        super()
+      end
+    end
+  end
+
+  def create_attribute(model, name)
+    Domain::Attribute.new(Domain.generate, model, model.columns_hash[name])
+  end
+
+  # Attribute ================================================================
+  test "column should return database column" do
+    create_model "Foo", :my_column => :string
+    assert_equal Foo.columns_hash["my_column"],
+      Domain::Attribute.from_model(Domain.new, Foo).reject(&:primary_key?).first.column
+  end
+
+  test "from_model should return attributes with sorted order if sort is true" do
+    RailsERD.options[:sort] = true
+    create_model "Foo"
+    add_column :foos, :a, :string
+    assert_equal %w{a id}, Domain::Attribute.from_model(Domain.new, Foo).map(&:name)
+  end
+
+  test "from_model should return attributes with original order if sort is false" do
+    RailsERD.options[:sort] = false
+    create_model "Foo"
+    add_column :foos, :a, :string
+    assert_equal %w{id a}, Domain::Attribute.from_model(Domain.new, Foo).map(&:name)
+  end
+
+  test "from_model should return attributes with PK first if prepend_primary is true" do
+    RailsERD.options[:sort]            = true
+    RailsERD.options[:prepend_primary] = true
+
+    create_model "Foo"
+    add_column :foos, :a, :string
+
+    assert_equal %w{id a}, Domain::Attribute.from_model(Domain.new, Foo).map(&:name)
+  end
+
+  test "spaceship should sort attributes by name" do
+    create_model "Foo", :a => :string, :b => :string, :c => :string
+    a = create_attribute(Foo, "a")
+    b = create_attribute(Foo, "b")
+    c = create_attribute(Foo, "c")
+    assert_equal [a, b, c], [c, a, b].sort
+  end
+
+  test "inspect should show column" do
+    create_model "Foo", :my_column => :string
+    assert_match %r{#<RailsERD::Domain::Attribute:.* @name="my_column" @type=:string>},
+      Domain::Attribute.new(Domain.new, Foo, Foo.columns_hash["my_column"]).inspect
+  end
+
+  test "type should return attribute type" do
+    create_model "Foo", :a => :binary
+    assert_equal :binary, create_attribute(Foo, "a").type
+  end
+
+  test "type should return native type if unsupported by rails" do
+    create_model "Foo"
+    ActiveRecord::Schema.define do
+      suppress_messages do
+        add_column "foos", "a", "REAL"
+      end
+    end
+    assert_equal :real, create_attribute(Foo, "a").type
+  end
+
+  # Attribute properties =====================================================
+  test "mandatory should return false by default" do
+    create_model "Foo", :column => :string
+    assert_equal false, create_attribute(Foo, "column").mandatory?
+  end
+
+  test "mandatory should return true if attribute has a presence validator" do
+    create_model "Foo", :column => :string do
+      validates :column, :presence => true
+    end
+    assert_equal true, create_attribute(Foo, "column").mandatory?
+  end
+
+  test "mandatory should return true if attribute has a not null constraint" do
+    create_model "Foo"
+    add_column :foos, :column, :string, :null => false, :default => ""
+    assert_equal true, create_attribute(Foo, "column").mandatory?
+  end
+
+  test "primary_key should return false by default" do
+    create_model "Bar", :my_key => :integer
+    assert_equal false, create_attribute(Bar, "my_key").primary_key?
+  end
+
+  test "primary_key should return true if column is used as primary key" do
+    create_model "Bar", :my_key => :integer do
+      self.primary_key = :my_key
+    end
+    assert_equal true, create_attribute(Bar, "my_key").primary_key?
+  end
+
+  test "foreign_key should return false by default" do
+    create_model "Foo", :bar => :references
+    assert_equal false, create_attribute(Foo, "bar_id").foreign_key?
+  end
+
+  test "foreign_key should return true if it is used in an association" do
+    create_model "Foo", :bar => :references do
+      belongs_to :bar
+    end
+    create_model "Bar"
+    assert_equal true, create_attribute(Foo, "bar_id").foreign_key?
+  end
+
+  test "foreign_key should return true if it is used in a remote association" do
+    create_model "Foo", :bar => :references
+    create_model "Bar" do
+      has_many :foos
+    end
+    assert_equal true, create_attribute(Foo, "bar_id").foreign_key?
+  end
+
+  test "timestamp should return false by default" do
+    create_model "Foo", :created => :datetime
+    assert_equal false, create_attribute(Foo, "created").timestamp?
+  end
+
+  test "timestamp should return true if it is named created_at/on or updated_at/on" do
+    create_model "Foo", :created_at => :string, :updated_at => :string, :created_on => :string, :updated_on => :string
+    assert_equal [true] * 4, [create_attribute(Foo, "created_at"), create_attribute(Foo, "updated_at"),
+      create_attribute(Foo, "created_on"), create_attribute(Foo, "updated_on")].collect(&:timestamp?)
+  end
+
+  test "inheritance should return false by default" do
+    create_model "Foo", :type => :string, :alternative => :string do
+      self.inheritance_column = :alternative
+    end
+    assert_equal false, create_attribute(Foo, "type").inheritance?
+  end
+
+  test "inheritance should return if this column is used for single table inheritance" do
+    create_model "Foo", :type => :string, :alternative => :string do
+      self.inheritance_column = :alternative
+    end
+    assert_equal true, create_attribute(Foo, "alternative").inheritance?
+  end
+
+  test "content should return true by default" do
+    create_model "Foo", :my_first_column => :string
+    assert_equal true, create_attribute(Foo, "my_first_column").content?
+  end
+
+  test "content should return false for primary keys, foreign keys, timestamps and inheritance columns" do
+    create_model "Book", :type => :string, :created_at => :datetime, :case => :references do
+      belongs_to :case
+    end
+    create_model "Case"
+    assert_equal [false] * 4, %w{id type created_at case_id}.map { |a| create_attribute(Book, a).content? }
+  end
+
+  # Type descriptions ========================================================
+  test "type_description should return short type description" do
+    create_model "Foo", :a => :binary
+    assert_equal "binary", create_attribute(Foo, "a").type_description
+  end
+
+  test "type_description should return short type description if unsupported by rails" do
+    create_model "Foo"
+    ActiveRecord::Schema.define do
+      suppress_messages do
+        add_column "foos", "a", "REAL"
+      end
+    end
+    assert_equal "real", create_attribute(Foo, "a").type_description
+  end
+
+  test "type_description should return short type description without limit if standard" do
+    with_native_limit :string, 456 do
+      create_model "Foo"
+      add_column :foos, :my_str, :string, :limit => 255
+      ActiveRecord::Base.connection.native_database_types[:string]
+      assert_equal "string (255)", create_attribute(Foo, "my_str").type_description
+    end
+  end
+
+  test "type_description should return short type description with limit if nonstandard" do
+    with_native_limit :string, 456 do
+      create_model "Foo"
+      add_column :foos, :my_str, :string, :limit => 456
+      assert_equal "string", create_attribute(Foo, "my_str").type_description
+    end
+  end
+
+  test "type_description should append hair space and low asterisk if field is mandatory" do
+    create_model "Foo", :a => :integer do
+      validates_presence_of :a
+    end
+    assert_equal "integer ∗", create_attribute(Foo, "a").type_description
+  end
+
+  test "type_description should return short type description with scale and precision for decimal types if nonstandard" do
+    create_model "Foo"
+    add_column :foos, :num, :decimal, :precision => 5, :scale => 2
+    assert_equal "decimal (5,2)", create_attribute(Foo, "num").type_description
+  end
+
+  test "limit should return nil if there is no limit" do
+    create_model "Foo"
+    add_column :foos, :my_txt, :text
+    assert_equal nil, create_attribute(Foo, "my_txt").limit
+  end
+
+  test "limit should return nil if equal to standard database limit" do
+    with_native_limit :string, 456 do
+      create_model "Foo"
+      add_column :foos, :my_str, :string, :limit => 456
+      assert_equal nil, create_attribute(Foo, "my_str").limit
+    end
+  end
+
+  test "limit should return limit if nonstandard" do
+    with_native_limit :string, 456 do
+      create_model "Foo"
+      add_column :foos, :my_str, :string, :limit => 255
+      assert_equal 255, create_attribute(Foo, "my_str").limit
+    end
+  end
+
+  test "limit should return precision for decimal columns if nonstandard" do
+    create_model "Foo"
+    add_column :foos, :num, :decimal, :precision => 5, :scale => 2
+    assert_equal 5, create_attribute(Foo, "num").limit
+  end
+
+  test "limit should return nil for decimal columns if equal to standard database limit" do
+    create_model "Foo"
+    add_column :foos, :num, :decimal
+    assert_equal nil, create_attribute(Foo, "num").limit
+  end
+
+  test "limit should return nil if type is unsupported by rails" do
+    create_model "Foo"
+    ActiveRecord::Schema.define do
+      suppress_messages do
+        add_column "foos", "a", "REAL"
+      end
+    end
+    assert_equal nil, create_attribute(Foo, "a").limit
+  end
+
+  test "limit should return nil for oddball column types that misuse the limit attribute" do
+    create_model "Business", :location => :integer
+    attribute = create_attribute(Business, "location")
+    attribute.column.class_eval do
+      define_method :limit do
+        # https://github.com/voormedia/rails-erd/issues/21
+        { :srid => 4326, :type => "point", :geographic => true }
+      end
+    end
+    assert_equal nil, attribute.limit
+  end
+
+  test "scale should return scale for decimal columns if nonstandard" do
+    create_model "Foo"
+    add_column :foos, :num, :decimal, :precision => 5, :scale => 2
+    assert_equal 2, create_attribute(Foo, "num").scale
+  end
+
+  test "scale should return nil for decimal columns if equal to standard database limit" do
+    create_model "Foo"
+    add_column :foos, :num, :decimal
+    assert_equal nil, create_attribute(Foo, "num").scale
+  end
+
+  test "scale should return zero for decimal columns if left to default setting when specifying precision" do
+    create_model "Foo"
+    add_column :foos, :num, :decimal, :precision => 5
+    assert_equal 0, create_attribute(Foo, "num").scale
+  end
+
+  test "scale should return nil if type is unsupported by rails" do
+    create_model "Foo"
+    ActiveRecord::Schema.define do
+      suppress_messages do
+        add_column "foos", "a", "REAL"
+      end
+    end
+    assert_equal nil, create_attribute(Foo, "a").scale
+  end
+
+  test "scale should return nil for oddball column types that misuse the scale attribute" do
+    create_model "Kobold", :size => :integer
+    attribute = create_attribute(Kobold, "size")
+    attribute.column.class_eval do
+      define_method :scale do
+        1..5
+      end
+    end
+    assert_equal nil, attribute.scale
+  end
+end