rails_graph 0.1.0

data/lib/rails_graph/commands/build_graph.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative "../graph/graph"
+require_relative "../graph/node"
+require_relative "../graph/relationship"
+
+require_relative "../graph/nodes/abstract_model"
+require_relative "../graph/nodes/column"
+require_relative "../graph/nodes/model"
+require_relative "../graph/nodes/virtual_model"
+
+require_relative "../graph/relationships/association"
+require_relative "../graph/relationships/attribute"
+require_relative "../graph/relationships/inheritance"
+
+require_relative "../helpers/associations"
+require_relative "../helpers/models"
+
+module RailsGraph
+  module Commands
+    class BuildGraph
+      def self.call(configuration:)
+        new(configuration: configuration).call
+      end
+
+      def call
+        polymorphic_node = RailsGraph::Graph::Nodes::VirtualModel.new("PolymorphicModel")
+        graph.add_node(polymorphic_node)
+
+        active_record_base_node = RailsGraph::Graph::Nodes::AbstractModel.new(ActiveRecord::Base)
+        graph.add_node(active_record_base_node)
+
+        build_model_nodes
+        build_associations_relationships
+        build_column_nodes if configuration.columns?
+        build_inheritance_relationships if configuration.inheritance?
+
+        graph
+      end
+
+      private
+
+      attr_reader :configuration, :classes, :graph
+
+      def initialize(configuration:)
+        @configuration = configuration
+        @classes = ActiveRecord::Base.descendants + configuration.include_classes
+        @graph = RailsGraph::Graph::Graph.new
+      end
+
+      def build_model_nodes
+        classes.each do |model|
+          if model.abstract_class
+            node = RailsGraph::Graph::Nodes::AbstractModel.new(model)
+            graph.add_node(node)
+            next
+          end
+
+          node = RailsGraph::Graph::Nodes::Model.new(model)
+          graph.add_node(node)
+        end
+      end
+
+      def build_column_nodes
+        processed = Hash.new(false)
+
+        classes.each do |model|
+          next if model.attribute_names.empty?
+
+          identifier = RailsGraph::Helpers::Models.identifier(model)
+          node = graph.node(identifier)
+
+          next if processed[node.id]
+
+          processed[node.id] = true
+
+          model.columns.each do |column|
+            column_node = RailsGraph::Graph::Nodes::Column.new(column)
+            graph.add_node(column_node)
+
+            relationship = RailsGraph::Graph::Relationships::Attribute.new(node, column_node)
+            graph.add_relationship(relationship)
+          end
+        end
+      end
+
+      def build_inheritance_relationships
+        classes.each do |model|
+          identifier = RailsGraph::Helpers::Models.identifier(model)
+          node = graph.node(identifier)
+
+          superclass_node_identifier = RailsGraph::Helpers::Models.identifier(model.superclass)
+          superclass_node = graph.node(superclass_node_identifier)
+
+          relationship = RailsGraph::Graph::Relationships::Inheritance.new(node, superclass_node)
+          graph.add_relationship(relationship)
+        end
+      end
+
+      def build_associations_relationships
+        classes.each do |model|
+          model.reflect_on_all_associations.each do |association|
+            source_node = RailsGraph::Helpers::Associations.source_node(graph, association)
+            target_node = RailsGraph::Helpers::Associations.target_node(graph, association)
+
+            relationship = RailsGraph::Graph::Relationships::Association.new(association, source_node, target_node)
+            graph.add_relationship(relationship)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_graph/commands/export_graph.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "../exporters/cypher"
+require_relative "../exporters/json"
+require_relative "../exporters/neo4j"
+
+module RailsGraph
+  module Commands
+    class ExportGraph
+      EXPORTERS = {
+        cypher: RailsGraph::Exporters::Cypher,
+        json: RailsGraph::Exporters::Json,
+        neo4j: RailsGraph::Exporters::Neo4j
+      }.freeze
+
+      def self.call(graph:, format: :cypher, **options)
+        EXPORTERS[format].export(graph: graph, **options)
+      end
+    end
+  end
+end

data/lib/rails_graph/configuration.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RailsGraph
+  class Configuration
+    attr_reader :include_classes
+    attr_writer :columns, :inheritance
+
+    def initialize
+      @include_classes = []
+      @columns = false
+      @inheritance = true
+    end
+
+    def include_classes=(include_classes)
+      @include_classes = Array(include_classes)
+    end
+
+    def columns?
+      @columns
+    end
+
+    def inheritance?
+      @inheritance
+    end
+  end
+end

data/lib/rails_graph/error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RailsGraph
+  class Error < StandardError; end
+end

data/lib/rails_graph/exporters/base.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RailsGraph
+  module Exporters
+    class Base; end
+  end
+end

data/lib/rails_graph/exporters/cypher.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module RailsGraph
+  module Exporters
+    class Cypher < Base
+      BASE_CYPHER = "MATCH (n) DETACH DELETE n;"
+
+      def self.export(graph:, filename:)
+        queries = build_queries(graph)
+
+        File.write(filename, queries.join("\n"), mode: "w")
+      end
+
+      def self.build_queries(graph)
+        queries = []
+        queries << BASE_CYPHER
+
+        graph.nodes.each { |node| queries << create_node_cypher(node) }
+        graph.relationships.each { |relationship| queries << create_relationship_cypher(relationship) }
+
+        queries
+      end
+
+      def self.node_ref(node)
+        "ref_#{node.id.gsub("-", "_")}"
+      end
+
+      def self.format_properties(item)
+        output = "name: '#{item.name}'"
+
+        item.properties.each do |k, v|
+          formatted_value = case v
+                            when String, Symbol then "'#{v}'"
+                            when nil then "null"
+                            else v.to_s
+                            end
+
+          output += ", #{k}: #{formatted_value}"
+        end
+
+        output
+      end
+
+      def self.create_node_cypher(node)
+        ref = node_ref(node)
+        labels = node.labels.join(":")
+        properties = format_properties(node)
+
+        "CREATE (#{ref}:#{labels} {#{properties}})"
+      end
+
+      def self.create_relationship_cypher(relationship)
+        source_ref = node_ref(relationship.source)
+        target_ref = node_ref(relationship.target)
+
+        "CREATE (#{source_ref})-[:#{relationship.label} {#{format_properties(relationship)}}]->(#{target_ref})"
+      end
+    end
+  end
+end

data/lib/rails_graph/exporters/json.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require "json"
+
+module RailsGraph
+  module Exporters
+    class Json < Base
+      def self.export(graph:, filename:)
+        json = graph.to_json
+
+        File.write(filename, json, mode: "w")
+      end
+    end
+  end
+end

data/lib/rails_graph/exporters/neo4j.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require "neo4j_ruby_driver"
+
+module RailsGraph
+  module Exporters
+    class Neo4j < Base
+      def self.export(graph:, host:, username:, password:)
+        auth = ::Neo4j::Driver::AuthTokens.basic(username, password)
+
+        ::Neo4j::Driver::GraphDatabase.driver(host, auth) do |driver|
+          driver.session do |session|
+            queries = Cypher.build_queries(graph)
+            queries.shift
+            queries = queries.join("\n")
+
+            session.write_transaction do |tx|
+              tx.run(queries, message: "Success!")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_graph/graph/entity.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module RailsGraph
+  module Graph
+    class Entity
+      attr_reader :id, :name, :properties
+
+      def initialize(name:, id: SecureRandom.uuid, properties: {})
+        @id = id
+        @name = name
+        @properties = properties
+      end
+
+      def identifier
+        id
+      end
+    end
+  end
+end

data/lib/rails_graph/graph/graph.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RailsGraph
+  module Graph
+    class Graph
+      def initialize(nodes: {}, relationships: {})
+        @nodes = nodes
+        @relationships = relationships
+      end
+
+      def add_node(node)
+        @nodes[node.identifier] = node
+      end
+
+      def nodes
+        @nodes.values
+      end
+
+      def node(identifier)
+        @nodes[identifier]
+      end
+
+      def add_relationship(relationship)
+        @relationships[relationship.identifier] = relationship
+      end
+
+      def relationships
+        @relationships.values.flatten
+      end
+
+      def relationship(identifier)
+        @relationships[identifier]
+      end
+
+      def as_json(_options = nil)
+        {
+          nodes: nodes,
+          relationships: relationships
+        }
+      end
+    end
+  end
+end

data/lib/rails_graph/graph/node.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "entity"
+
+module RailsGraph
+  module Graph
+    class Node < Entity
+      attr_reader :labels
+
+      def initialize(labels: [], **opts)
+        @labels = Array(labels)
+
+        super(**opts)
+      end
+
+      def as_json(_options = nil)
+        {
+          id: id,
+          labels: labels,
+          name: name,
+          properties: properties
+        }
+      end
+    end
+  end
+end

data/lib/rails_graph/graph/nodes/abstract_model.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "../node"
+
+module RailsGraph
+  module Graph
+    module Nodes
+      class AbstractModel < Node
+        attr_reader :model
+
+        def initialize(model)
+          @model = model
+
+          super(
+            labels: "AbstractModel",
+            name: model.name,
+            properties: {}
+          )
+        end
+
+        def identifier
+          RailsGraph::Helpers::Models.identifier(model)
+        end
+      end
+    end
+  end
+end

data/lib/rails_graph/graph/nodes/column.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "../node"
+
+module RailsGraph
+  module Graph
+    module Nodes
+      class Column < Node
+        attr_reader :column
+
+        def initialize(column)
+          @column = column
+
+          super(labels: "Column", name: column.name, properties: build_properties)
+        end
+
+        private
+
+        def build_properties
+          {
+            nullable: column.null || false,
+            comment: column.comment,
+            default: column.default,
+            type: column.type,
+            sql_type: column.sql_type
+          }
+        end
+      end
+    end
+  end
+end

data/lib/rails_graph/graph/nodes/model.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "../node"
+
+module RailsGraph
+  module Graph
+    module Nodes
+      class Model < Node
+        attr_reader :model
+
+        def initialize(model)
+          @model = model
+
+          super(labels: "Model", name: model.name, properties: build_properties)
+        end
+
+        def identifier
+          RailsGraph::Helpers::Models.identifier(model)
+        end
+
+        private
+
+        def build_properties
+          {
+            table_name: model.table_name,
+            table_exists: table_exists?,
+            columns_count: model.attribute_names.count,
+            db_indexes_count: db_indexes_count,
+            primary_key: model.primary_key,
+            full_name: model.to_s
+          }
+        end
+
+        def table_exists?
+          ActiveRecord::Base.connection.table_exists?(model.table_name)
+        end
+
+        def db_indexes_count
+          ActiveRecord::Base.connection.indexes(model.table_name).count
+        end
+      end
+    end
+  end
+end

data/lib/rails_graph/graph/nodes/virtual_model.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "../node"
+
+module RailsGraph
+  module Graph
+    module Nodes
+      class VirtualModel < Node
+        def initialize(name)
+          super(
+            labels: "VirtualModel",
+            name: name,
+            properties: {}
+          )
+        end
+
+        def identifier
+          name
+        end
+      end
+    end
+  end
+end

data/lib/rails_graph/graph/relationship.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "entity"
+
+module RailsGraph
+  module Graph
+    class Relationship < Entity
+      attr_reader :source, :target, :label
+
+      def initialize(source:, target:, label:, **opts)
+        @source = source
+        @target = target
+        @label  = label
+
+        super(**opts)
+      end
+
+      def identifier
+        "#{label}##{source.identifier}##{target.identifier}##{name}"
+      end
+
+      def as_json(_options = nil)
+        {
+          id: id,
+          label: label,
+          name: name,
+          source: source.id,
+          target: target.id,
+          properties: properties
+        }
+      end
+    end
+  end
+end

data/lib/rails_graph/graph/relationships/association.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "../relationship"
+
+module RailsGraph
+  module Graph
+    module Relationships
+      class Association < Relationship
+        attr_reader :association
+
+        def initialize(association, source, target)
+          @association = association
+
+          super(
+            source: source,
+            target: target,
+            label: association.macro.to_s.camelize,
+            name: association.name.to_s,
+            properties: build_properties
+          )
+        end
+
+        private
+
+        def build_properties
+          {
+            polymorphic: polymorphic?,
+            through: through?,
+            foreign_key: foreign_key,
+            foreign_type: foreign_type,
+            type: type,
+            dependent: dependent,
+            class_name: class_name,
+            optional: optional?
+          }
+        end
+
+        def class_name
+          name = association.polymorphic? ? association.class_name : association.klass.name
+
+          name.delete_prefix("::")
+        end
+
+        def polymorphic?
+          association.polymorphic? || false
+        end
+
+        def through?
+          association.options[:through] || false
+        end
+
+        def foreign_key
+          association.foreign_key.to_s
+        end
+
+        def foreign_type
+          association.foreign_type.to_s
+        end
+
+        def type
+          association.type
+        end
+
+        def dependent
+          association.options[:dependent]
+        end
+
+        def optional?
+          association.options[:optional] || false
+        end
+      end
+    end
+  end
+end

data/lib/rails_graph/graph/relationships/attribute.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "../relationship"
+
+module RailsGraph
+  module Graph
+    module Relationships
+      class Attribute < Relationship
+        def initialize(source, target)
+          super(
+            source: source,
+            target: target,
+            label: "HasAttribute",
+            name: target.name,
+            properties: {
+              primary_key: source.properties[:primary_key] == target.name
+            }
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rails_graph/graph/relationships/inheritance.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "../relationship"
+
+module RailsGraph
+  module Graph
+    module Relationships
+      class Inheritance < Relationship
+        def initialize(source, target)
+          super(
+            source: source,
+            target: target,
+            label: "InheritsFrom",
+            name: target.name,
+            properties: {}
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rails_graph/helpers/associations.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RailsGraph
+  module Helpers
+    module Associations
+      module_function
+
+      def source_identifier(association)
+        RailsGraph::Helpers::Models.identifier(association.active_record)
+      end
+
+      def source_node(graph, association)
+        identifier = source_identifier(association)
+
+        graph.node(identifier)
+      end
+
+      def target_identifier(association)
+        return "PolymorphicModel" if association.polymorphic?
+
+        RailsGraph::Helpers::Models.identifier(association.klass)
+      end
+
+      def target_node(graph, association)
+        identifier = target_identifier(association)
+
+        graph.node(identifier)
+      end
+    end
+  end
+end