db_diagram 0.1.0

data/lib/db_diagram/diagram/graphviz.rb

@@ -0,0 +1,315 @@
+# encoding: utf-8
+require "db_diagram/diagram"
+require "graphviz"
+require "erb"
+
+# Fix bad RegEx test in Ruby-Graphviz.
+GraphViz::Types::LblString.class_eval do
+  def output # @private :nodoc:
+    if /^<.*>$/m =~ @data
+      @data
+    else
+      @data.to_s.inspect.gsub("\\\\", "\\")
+    end
+  end
+
+  alias_method :to_gv, :output
+  alias_method :to_s, :output
+end
+
+module DBDiagram
+  class Diagram
+    # Create Graphviz-based diagrams based on the domain model. For easy
+    # command line graph generation, you can use:
+    #
+    #   % rake erd
+    #
+    # === Options
+    #
+    # The following options are supported:
+    #
+    # filename:: The file basename of the generated diagram. Defaults to +ERD+,
+    #            or any other extension based on the file type.
+    # filetype:: The file type of the generated diagram. Defaults to +pdf+, which
+    #            is the recommended format. Other formats may render significantly
+    #            worse than a PDF file. The available formats depend on your installation
+    #            of Graphviz.
+    # notation:: The cardinality notation to be used. Can be +:simple+ or
+    #            +:bachman+. Refer to README.rdoc or to the examples on the project
+    #            homepage for more information and examples.
+    # orientation:: The direction of the hierarchy of entities. Either +:horizontal+
+    #               or +:vertical+. Defaults to +horizontal+. The orientation of the
+    #               PDF that is generated depends on the amount of hierarchy
+    #               in your models.
+    # title:: The title to add at the top of the diagram. Defaults to
+    #         <tt>"YourApplication domain model"</tt>.
+    class Graphviz < Diagram
+      NODE_LABEL_TEMPLATES = {
+        html: "node.html.erb",
+        record: "node.record.erb"
+      } # @private :nodoc:
+
+      NODE_WIDTH = 130 # @private :nodoc:
+
+      FONTS = { normal: "ArialMT",
+                bold: "Arial BoldMT",
+                italic: "Arial ItalicMT" }
+
+      # Default graph attributes.
+      GRAPH_ATTRIBUTES = {
+        rankdir: :LR,
+        ranksep: 0.5,
+        nodesep: 0.4,
+        pad: "0.4,0.4",
+        margin: "0,0",
+        concentrate: true,
+        labelloc: :t,
+        fontsize: 13,
+        fontname: FONTS[:bold],
+        splines: 'spline'
+      }
+
+      # Default node attributes.
+      NODE_ATTRIBUTES = {
+        shape: "Mrecord",
+        fontsize: 10,
+        fontname: FONTS[:normal],
+        margin: "0.07,0.05",
+        penwidth: 1.0
+      }
+
+      # Default edge attributes.
+      EDGE_ATTRIBUTES = {
+        fontname: FONTS[:normal],
+        fontsize: 7,
+        dir: :both,
+        arrowsize: 0.9,
+        penwidth: 1.0,
+        labelangle: 32,
+        labeldistance: 1.8,
+      }
+
+      # Default cluster attributes.
+      CLUSTER_ATTRIBUTES = {
+        margin: "10,10"
+      }
+
+      module Simple
+        def entity_style(entity, attributes)
+          {}.tap do |options|
+            options[:fontcolor] = options[:color] = :grey60 if entity.abstract?
+          end
+        end
+
+        def relationship_style(relationship)
+          {}.tap do |options|
+            # options[:style] = :dotted #虚线
+
+            # Closed arrows for to/from many.
+            options[:arrowhead] = relationship.to_many? ? "normal" : "none"
+            options[:arrowtail] = relationship.many_to? ? "normal" : "none"
+          end
+        end
+      end
+
+      module Crowsfoot
+        include Simple
+
+        def relationship_style(relationship)
+          {}.tap do |options|
+            # options[:style] = :dotted #虚线
+
+            # Cardinality is "look-across".
+            dst = relationship.to_many? ? "crow" : "tee"
+            src = relationship.many_to? ? "crow" : "tee"
+
+            # Participation is "look-across".
+            dst << (relationship.destination_optional? ? "odot" : "tee")
+            src << (relationship.source_optional? ? "odot" : "tee")
+
+            options[:arrowsize] = 0.6
+            options[:arrowhead], options[:arrowtail] = dst, src
+          end
+        end
+      end
+
+      module Bachman
+        include Simple
+
+        def relationship_style(relationship)
+          {}.tap do |options|
+            # options[:style] = :dotted #虚线
+
+            # Participation is "look-here".
+            dst = relationship.source_optional? ? "odot" : "dot"
+            src = relationship.destination_optional? ? "odot" : "dot"
+
+            # Cardinality is "look-across".
+            dst << "normal" if relationship.to_many?
+            src << "normal" if relationship.many_to?
+
+            options[:arrowsize] = 0.6
+            options[:arrowhead], options[:arrowtail] = dst, src
+          end
+        end
+      end
+
+      module Uml
+        include Simple
+
+        def relationship_style(relationship)
+          {}.tap do |options|
+            # options[:style] = :dotted #虚线
+
+            options[:arrowsize] = 0.7
+            options[:arrowhead] = relationship.to_many? ? "vee" : "none"
+            options[:arrowtail] = relationship.many_to? ? "vee" : "none"
+
+            ranges = [relationship.cardinality.destination_range, relationship.cardinality.source_range].map do |range|
+              if range.min == range.max
+                "#{range.min}"
+              else
+                "#{range.min}..#{range.max == Domain::Relationship::N ? "∗" : range.max}"
+              end
+            end
+            options[:headlabel], options[:taillabel] = *ranges
+          end
+        end
+      end
+
+      attr_accessor :graph
+
+      setup do
+        self.graph = GraphViz.digraph(domain.name)
+
+        # Set all default attributes.
+        GRAPH_ATTRIBUTES.each { |attribute, value| graph[attribute] = value }
+        NODE_ATTRIBUTES.each { |attribute, value| graph.node[attribute] = value }
+        EDGE_ATTRIBUTES.each { |attribute, value| graph.edge[attribute] = value }
+
+        # Switch rank direction if we're creating a vertically oriented graph.
+        graph[:rankdir] = (options.orientation == "vertical") ? :LR : :TB
+
+        # Title of the graph itself.
+        graph[:label] = "#{title}\\n\\n" if title
+
+        # Style of splines
+        graph[:splines] = options.splines unless options.splines.nil?
+
+        # Setup notation options.
+        extend self.class.const_get(options.notation.to_s.capitalize.to_sym)
+      end
+
+      save do
+        raise "Saving diagram failed!\nOutput directory '#{File.dirname(filename)}' does not exist." unless File.directory?(File.dirname(filename))
+
+        begin
+          # GraphViz doesn't like spaces in the filename
+          graph.output(filetype => filename.gsub(/\s/, "_"))
+          filename
+        rescue RuntimeError => e
+          raise "Saving diagram failed!\nGraphviz produced errors. Verify it " +
+                  "has support for filetype=#{options.filetype}, or use " +
+                  "filetype=dot.\nOriginal error: #{e.message.split("\n").last}"
+        rescue StandardError => e
+          raise "Saving diagram failed!\nVerify that Graphviz is installed " +
+                  "and in your path, or use filetype=dot."
+        end
+      end
+
+      each_entity do |entity, attributes|
+        if options[:cluster] && entity.namespace
+          cluster_name = "cluster_#{entity.namespace}"
+          cluster_options = CLUSTER_ATTRIBUTES.merge(label: entity.namespace)
+          cluster = graph.get_graph(cluster_name) ||
+            graph.add_graph(cluster_name, cluster_options)
+
+          draw_cluster_node cluster, entity.name, entity_options(entity, attributes)
+        else
+          draw_node entity.name, entity_options(entity, attributes)
+        end
+      end
+
+      each_relationship do |relationship|
+        from, to = relationship.source, relationship.destination
+        draw_edge from.name, to.name, relationship_options(relationship)
+      end
+
+      private
+
+      def node_exists?(name)
+        !!graph.search_node(escape_name(name))
+      end
+
+      def draw_node(name, options)
+        graph.add_nodes escape_name(name), options
+      end
+
+      def draw_cluster_node(cluster, name, options)
+        cluster.add_nodes escape_name(name), options
+      end
+
+      def draw_edge(from, to, options)
+        graph.add_edges graph.search_node(escape_name(from)), graph.search_node(escape_name(to)), options if node_exists?(from) and node_exists?(to)
+      end
+
+      def escape_name(name)
+        "m_#{name}"
+      end
+
+      # Returns the title to be used for the graph.
+      def title
+        case options.title
+        when false then
+          nil
+        when true
+          if domain.name then
+            "#{domain.name} domain model"
+          else
+            "Domain model"
+          end
+        else
+          options.title
+        end
+      end
+
+      # Returns the file name that will be used when saving the diagram.
+      def filename
+        "#{options.filename.presence || "#{domain.name}_#{domain.current_migration_version}"}.#{options.filetype}"
+      end
+
+      # Returns the default file extension to be used when saving the diagram.
+      def filetype
+        if options.filetype.to_sym == :dot then
+          :none
+        else
+          options.filetype.to_sym
+        end
+      end
+
+      def entity_options(entity, attributes)
+        label = options[:markup] ? "<#{read_template(:html).result(binding)}>" : "#{read_template(:record).result(binding)}"
+        entity_style(entity, attributes).merge :label => label
+      end
+
+      def relationship_options(relationship)
+        relationship_style(relationship).tap do |options|
+          # Edges with a higher weight are optimized to be shorter and straighter.
+          options[:weight] = relationship.strength
+
+          # Indirect relationships should not influence node ranks.
+          # options[:constraint] = false
+        end
+      end
+
+      def read_template(type)
+        template_text = File.read(File.expand_path("templates/#{NODE_LABEL_TEMPLATES[type]}", File.dirname(__FILE__)))
+        if ERB.instance_method(:initialize).parameters.assoc(:key) # Ruby 2.6+
+          ERB.new(template_text, trim_mode: "<>")
+        else
+          ERB.new(template_text, nil, "<>")
+        end
+      end
+    end
+  end
+end

data/lib/db_diagram/diagram/templates/node.html.erb

@@ -0,0 +1,14 @@
+<% if options.orientation == :horizontal %>{<% end %>
+<table border="0" align="center" cellspacing="0.5" cellpadding="0" width="<%= NODE_WIDTH + 4 %>">
+  <tr><td align="center" valign="bottom" width="<%= NODE_WIDTH %>"><font face="<%= FONTS[:bold] %>" point-size="11"><%= entity.name %></font></td></tr>
+</table>
+<% if attributes.any? %>
+|
+<table border="0" align="left" cellspacing="2" cellpadding="0" width="<%= NODE_WIDTH + 4 %>">
+<%   attributes.each do |attribute| %>
+  <tr><td align="left" width="<%= NODE_WIDTH %>" port="<%= attribute %>"><%= attribute %> <font face="<%= FONTS[:italic] %>" color="grey60"><%= attribute.type_description %></font></td></tr>
+<%   end %>
+</table>
+<% else %>
+<% end %>
+<% if options.orientation == :horizontal %>}<% end %>

data/lib/db_diagram/diagram/templates/node.record.erb

@@ -0,0 +1,4 @@
+<% if options.orientation == :horizontal %>{<% end %><%= entity.name %><% if attributes.any? %>
+|<%  attributes.each do |attribute| %><%=
+       attribute %> (<%= attribute.type_description %>)
+<%   end %><% end %><% if options.orientation == :horizontal %>}<% end %>

data/lib/db_diagram/domain.rb

@@ -0,0 +1,173 @@
+require "db_diagram"
+require "db_diagram/domain/attribute"
+require "db_diagram/domain/entity"
+require "db_diagram/domain/relationship"
+
+module DBDiagram
+  # The domain describes your Rails domain model. This class is the starting
+  # point to get information about your models.
+  #
+  # === Options
+  #
+  # The following options are available:
+  #
+  # warn:: When set to +false+, no warnings are printed to the
+  #        command line while processing the domain model. Defaults
+  #        to +true+.
+  class Domain
+    class << self
+      # Generates a domain model object based on all loaded subclasses of
+      # <tt>ActiveRecord::Base</tt>. Make sure your models are loaded before calling
+      # this method.
+      #
+      # The +options+ hash allows you to override the default options. For a
+      # list of available options, see DBDiagram.
+      def generate(options = {})
+        base_klass = options.delete(:base_klass) || ActiveRecord::Base
+        new base_klass.descendants, options
+      end
+
+      # Returns the method name to retrieve the foreign key from an
+      # association reflection object.
+      def foreign_key_method_name # @private :nodoc:
+        @foreign_key_method_name ||= ActiveRecord::Reflection::AssociationReflection.method_defined?(:foreign_key) ? :foreign_key : :primary_key_name
+      end
+    end
+
+    extend Inspectable
+    inspection_attributes
+
+    # The options that are used to generate this domain model.
+    attr_reader :options
+
+    # Create a new domain model object based on the given array of models.
+    # The given models are assumed to be subclasses of <tt>ActiveRecord::Base</tt>.
+    def initialize(models = [], options = {})
+      @source_models, @options = models, DBDiagram.options.merge(options)
+    end
+
+    # Returns the domain model name, which is the name of your Rails
+    # application or +nil+ outside of Rails.
+    def app_name
+      return unless defined?(Rails) && Rails.application
+
+      if Rails.application.class.respond_to?(:module_parent)
+        Rails.application.class.module_parent.name
+      else
+        Rails.application.class.parent.name
+      end
+    end
+
+    def name
+      return app_name if @source_models.empty?
+      @source_models.first.connection.current_database.presence || app_name
+    rescue
+      app_name
+    end
+
+    def current_migration_version
+      raise '' if @source_models.empty?
+      @source_models.first.connection.migration_context.current_version
+    rescue
+      '0001'
+    end
+
+    # Returns all entities of your domain model.
+    def entities
+      @entities ||= Entity.from_models(self, models)
+    end
+
+    # Returns all relationships in your domain model.
+    def relationships
+      @relationships ||= Relationship.from_associations(self, associations)
+    end
+
+    # Returns a specific entity object for the given Active Record model.
+    def entity_by_name(name) # @private :nodoc:
+      entity_mapping[name]
+    end
+
+    # Returns an array of relationships for the given Active Record model.
+    def relationships_by_entity_name(name) # @private :nodoc:
+      relationships_mapping[name] or []
+    end
+
+    def warn(message) # @private :nodoc:
+      puts "Warning: #{message}" if options.warn
+    end
+
+    private
+
+    def entity_mapping
+      @entity_mapping ||= {}.tap do |mapping|
+        entities.each do |entity|
+          mapping[entity.model_name] = entity
+        end
+      end
+    end
+
+    def relationships_mapping
+      @relationships_mapping ||= {}.tap do |mapping|
+        relationships.each do |relationship|
+          (mapping[relationship.source.name] ||= []) << relationship
+          (mapping[relationship.destination.name] ||= []) << relationship
+        end
+      end
+    end
+
+    def models
+      @models ||= @source_models.select { |model| check_model_validity(model) }.reject { |model| check_habtm_model(model) }
+    end
+
+    def associations
+      @associations ||= models.collect(&:reflect_on_all_associations).flatten.select { |assoc| check_association_validity(assoc) }
+    end
+
+    def check_model_validity(model)
+      if model.abstract_class? || model.table_exists?
+        if model.name.nil?
+          raise "is anonymous class"
+        else
+          true
+        end
+      else
+        raise "table #{model.table_name} does not exist"
+      end
+    rescue => e
+      warn "Ignoring invalid model #{model.name} (#{e.message})"
+    end
+
+    def check_association_validity(association)
+      # Raises an ActiveRecord::ActiveRecordError if the association is broken.
+      association.check_validity!
+
+      if association.options[:polymorphic]
+        check_polymorphic_association_validity(association)
+      else
+        entity_name = association.klass.name # Raises NameError if the associated class cannot be found.
+        entity_by_name(entity_name) or raise "model #{entity_name} exists, but is not included in domain"
+      end
+    rescue => e
+      warn "Ignoring invalid association #{association_description(association)} (#{e.message})"
+    end
+
+    def check_polymorphic_association_validity(association)
+      entity_name = association.class_name
+      entity = entity_by_name(entity_name)
+
+      if entity || (entity && entity.generalized?)
+        return entity
+      else
+        raise("polymorphic interface #{entity_name} does not exist")
+      end
+    end
+
+    def association_description(association)
+      "#{association.name.inspect} on #{association.active_record}"
+    end
+
+    def check_habtm_model(model)
+      model.name.start_with?("HABTM_")
+    end
+  end
+end