rails-erd 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07a38b05691f97bf85079684c7412bff0bf8b4caf737f52479d2209b3fb2fe5f
-  data.tar.gz: c8f38108442a38b331cff3b2c0b856584943ac3def5cec0525255c53595e0482
+  metadata.gz: e8c66456b4d4e9279e9957ffd932fb244aa160c7f271c67cfafec1217161e232
+  data.tar.gz: 70f6317d8e825c273f70495e9eb9f41e4576dea96e4065d8627f45558b5f3cc4
 SHA512:
-  metadata.gz: 146e37a81b1f2008f28442f62498822845810a45bb9a5ab1ba35fec8700be809ba2eac95be388a15878e9ff44d7dc5b4abd8b4db8b479871a993a93668d75337
-  data.tar.gz: 9e5d0c84231120c3e1b804950265a3a6abca1201f46f99bd96b3a0655e46c13bdbb0e7ff0403902f621506de81240818cc7135f92423f8a1be0e50c2468629d2
+  metadata.gz: d7925eb9de863885b214caf8efb6b43b935c5d34df50134d54118aa5924d927bf1cb23ac3bc22ee2f5fb75e0fd59cf63c65873178e90516bc220645c904405ab
+  data.tar.gz: 5f9a9910107772a49ead53f939f1fbf7a553df44ffbe59ffeb3796c7dea3d1f40a06cac449aa7d23d83efc26a2aa42181279014fc09d2fe2588a9ab9b82a972b

data/CHANGES.md

@@ -1,3 +1,19 @@
+Unreleased
+----------
+
+2.2.0
+-----
+
+### New Features
+* Add `only_attributes` option to show only the listed attributes on a per-model basis, the counterpart to `exclude_attributes` (#486, #487)
+* Add `recursive` option (default `true`); set it to `false` to omit self-referential relationships, such as a `parent_id` pointing at the entity's own table (#483, #485)
+
+### Bug Fixes
+* Mermaid no longer draws entities that were filtered out of the diagram: an edge is only emitted when both of its entities were drawn, matching the Graphviz generator (#482, #484)
+
+### Internal
+* Remove unnecessary `ostruct` runtime dependency; replace stale `pry-nav` with `pry-byebug` (#481)
+
 2.1.0
 -----
 

data/README.md

@@ -145,44 +145,20 @@ mermaid_style: erdiagram
 notation: simple
 orientation: horizontal
 polymorphism: false
+recursive: true
 sort: true
 warn: true
 title: true
 exclude: null
 exclude_attributes: null
 only: null
+only_attributes: null
 only_recursion_depth: null
 prepend_primary: false
 cluster: false
 splines: spline
 ```
 
-### Hiding attributes for specific models
-
-While `attributes: false` hides attributes for *every* model, `exclude_attributes`
-lets you hide attributes for individual models without affecting the others. Map a
-model name to `true` to hide all of its attributes, or to a list of attribute names
-to hide only those:
-
-```yaml
-exclude_attributes:
-  BigTable: true            # hide all attributes for BigTable
-  User:                     # hide only these attributes for User
-    - password_digest
-    - remember_token
-```
-
-From the command line, pass a comma separated list where each entry is either
-`Model` (hide all of its attributes) or `Model.attribute` (hide a single one):
-
-```bash
-# rake task (bare key=value)
-bundle exec rake erd exclude_attributes="BigTable,User.password_digest,User.remember_token"
-
-# erd binary (flags require the -- prefix)
-bundle exec erd --exclude_attributes="BigTable,User.password_digest,User.remember_token"
-```
-
 ### Filtering models with exclude and only
 
 Use `exclude` to hide specific models from the diagram, or `only` to show only
@@ -236,6 +212,62 @@ exclude:
 - Only `i`, `m`, `x` regex flags are supported; other flags are ignored
 - When both `exclude` and `only` are specified, `only` is applied first, then `exclude`
 
+### Filtering attributes with exclude_attributes and only_attributes
+
+The `attributes` option selects which *kinds* of attributes are displayed for
+every model. `only_attributes` and `exclude_attributes` refine that per model,
+mirroring the way `only` and `exclude` filter entities: use `only_attributes` to
+show just a few attributes of a model, or `exclude_attributes` to hide a few.
+Both are keyed by model name, and models that are not listed keep all of their
+attributes.
+
+**Showing only some attributes** — map a model name to the attributes to keep:
+
+```yaml
+only_attributes:
+  Book:
+    - title
+    - isbn
+```
+
+**Hiding some attributes** — map a model name to the attributes to hide, or to
+`true` to hide all of them:
+
+```yaml
+exclude_attributes:
+  BigTable: true            # hide all attributes for BigTable
+  User:                     # hide only these attributes for User
+    - password_digest
+    - remember_token
+```
+
+From the command line, both take a comma separated list of `Model.attribute`
+entries. `exclude_attributes` additionally accepts a bare `Model` to hide all of
+its attributes:
+
+```bash
+# rake task (bare key=value)
+bundle exec rake erd only_attributes="Book.title,Book.isbn"
+bundle exec rake erd exclude_attributes="BigTable,User.password_digest,User.remember_token"
+
+# erd binary (flags require the -- prefix)
+bundle exec erd --only_attributes="Book.title,Book.isbn"
+bundle exec erd --exclude_attributes="BigTable,User.password_digest,User.remember_token"
+```
+
+**Notes:**
+
+- Unlike `only`, listing a model in `only_attributes` does not affect any other
+  model; unlisted models keep all of their attributes
+- When both are specified for a model, `only_attributes` is applied first, then
+  `exclude_attributes`
+- Both narrow down the attributes selected by `attributes`; naming an attribute in
+  `only_attributes` does not display it when its kind is not displayed (for example a
+  primary key while `attributes` is only `content`)
+- `only_attributes` cannot be set to `true` the way `exclude_attributes` can, because
+  "show only all attributes" has no meaning. Use `attributes: false` or
+  `exclude_attributes` to hide attributes
+
 ### Grouping models by namespace
 
 Use `cluster: true` to visually group models by their Ruby namespace. This is

data/lib/rails_erd/cli.rb

@@ -47,6 +47,11 @@ Choice.options do
     desc "Display polymorphic and abstract entities."
   end
 
+  option :no_recursive do
+    long "--no-recursive"
+    desc "Omit self-referential relationships (an entity related to itself)."
+  end
+
   option :no_indirect do
     long "--direct"
     desc "Omit indirect relationships (through other entities)."
@@ -72,6 +77,11 @@ Choice.options do
     desc "Filter to exclude listed models in diagram."
   end
 
+  option :only_attributes do
+    long "--only_attributes=MODEL.ATTRIBUTE,..."
+    desc "Show only the listed attributes for a model, e.g. Book.title,Book.isbn. Models that are not listed keep all their attributes."
+  end
+
   option :exclude_attributes do
     long "--exclude_attributes=MODEL[.ATTRIBUTE],..."
     desc "Hide attributes per model. Use Model to hide all its attributes or Model.attribute to hide one, e.g. BigTable,User.password_digest."

data/lib/rails_erd/config.rb

@@ -73,6 +73,11 @@ module RailsERD
       when :only, :exclude
         Array(value).join(",").split(",").map { |v| v.strip }
 
+      # nil | { <string> => [<string>] }
+      when :only_attributes
+        require "rails_erd/diagram"
+        RailsERD::Diagram.normalize_only_attributes(value)
+
       # nil | { <string> => true | [<string>] }
       when :exclude_attributes
         require "rails_erd/diagram"
@@ -80,7 +85,7 @@ module RailsERD
 
       # true | false
       when :disconnected, :indirect, :inheritance, :markup, :polymorphism,
-           :warn, :cluster
+           :recursive, :warn, :cluster
         !!value
 
       # nil | <string>

data/lib/rails_erd/diagram/mermaid.rb

@@ -2,6 +2,7 @@
 
 require "rails_erd/diagram"
 require "erb"
+require "set"
 
 module RailsERD
   class Diagram
@@ -11,6 +12,7 @@ module RailsERD
 
       setup do
         self.graph = [diagram_type]
+        @drawn_entity_names = Set.new
 
         # Respect orientation option: horizontal = TB (top-down), vertical = LR (left-right)
         direction = (options.orientation.to_s == "vertical") ? "LR" : "TB"
@@ -28,6 +30,7 @@ module RailsERD
       end
 
       each_entity do |entity, attributes|
+        @drawn_entity_names << entity.name.to_s
         if er_diagram?
           # Build entity block as a single string to avoid uniq issues with closing braces
           quoted_entity = quote_entity_name(entity)
@@ -79,27 +82,9 @@ module RailsERD
         from, to = relationship.source, relationship.destination
         next unless from && to
 
-        if er_diagram?
-          graph << "\t#{quote_entity_name(from.name)} #{er_relation_notation(relationship)} #{quote_entity_name(to.name)} : \"\""
-
-          from.children.each do |child|
-            graph << "\t#{quote_entity_name(child.name)} #{er_relation_notation(relationship)} #{quote_entity_name(to.name)} : \"\""
-          end
-
-          to.children.each do |child|
-            graph << "\t#{quote_entity_name(from.name)} #{er_relation_notation(relationship)} #{quote_entity_name(child.name)} : \"\""
-          end
-        else
-          graph << "\t`#{from.name}` #{relation_arrow(relationship)} `#{to.name}`"
-
-          from.children.each do |child|
-            graph << "\t`#{child.name}` #{relation_arrow(relationship)} `#{to.name}`"
-          end
-
-          to.children.each do |child|
-            graph << "\t`#{from.name}` #{relation_arrow(relationship)} `#{child.name}`"
-          end
-        end
+        draw_relation(from, to, relationship)
+        from.children.each { |child| draw_relation(child, to, relationship) }
+        to.children.each { |child| draw_relation(from, child, relationship) }
       end
 
       save do
@@ -127,6 +112,22 @@ module RailsERD
         options[:mermaid_style] == :erdiagram || options[:mermaid_style] == :er
       end
 
+      # Mermaid renders any entity a relationship names, so an edge to an entity that was
+      # filtered out would draw it back into the diagram. Skip those, as Graphviz already does.
+      def draw_relation(from, to, relationship)
+        return unless entity_drawn?(from.name) && entity_drawn?(to.name)
+
+        graph << if er_diagram?
+                   "\t#{quote_entity_name(from.name)} #{er_relation_notation(relationship)} #{quote_entity_name(to.name)} : \"\""
+                 else
+                   "\t`#{from.name}` #{relation_arrow(relationship)} `#{to.name}`"
+                 end
+      end
+
+      def entity_drawn?(name)
+        @drawn_entity_names.include?(name.to_s)
+      end
+
       # Quote entity names that contain special characters (like :: for namespaces)
       # Mermaid erDiagram requires double quotes for names with special characters
       def quote_entity_name(name)

data/lib/rails_erd/diagram.rb

@@ -55,6 +55,14 @@ module RailsERD
   # attributes:: Selects which attributes to display. Can be any combination of
   #              +:content+, +:primary_keys+, +:foreign_keys+, +:timestamps+, or
   #              +:inheritance+.
+  # only_attributes:: Shows only the listed attributes for the given models,
+  #                   without affecting other models. Accepts a hash that maps
+  #                   model names to a list of attribute names to keep. From the
+  #                   command line it can also be given as a comma separated
+  #                   string of +Model.attribute+ entries, for example
+  #                   <tt>only_attributes="Book.title,Book.isbn"</tt>. Models
+  #                   that are not listed keep all of their attributes. Unlike
+  #                   +exclude_attributes+ it cannot be set to +true+.
   # exclude_attributes:: Hides attributes on a per-model basis, without affecting
   #                      other models. Accepts a hash that maps model names to
   #                      either +true+ (hide all attributes for that model) or a
@@ -63,6 +71,7 @@ module RailsERD
   #                      entry is either +Model+ (hide all attributes) or
   #                      +Model.attribute+ (hide a single attribute), for example
   #                      <tt>exclude_attributes="BigTable,User.password_digest"</tt>.
+  #                      Applied after +only_attributes+.
   # disconnected:: Set to +false+ to exclude entities that are not connected to other
   #                entities. Defaults to +false+.
   # indirect:: Set to +false+ to exclude relationships that are indirect.
@@ -84,21 +93,26 @@ module RailsERD
         new(Domain.generate(options), options).create
       end
 
-      # Canonicalises the +exclude_attributes+ option into a hash that maps
-      # model names (as strings) to either +true+ (hide all attributes) or an
-      # array of attribute names to hide. Accepts several input shapes:
+      # Canonicalises an attribute filter option (+only_attributes+ or
+      # +exclude_attributes+) into a hash that maps model names (as strings) to
+      # either +true+ (the whole model was named, without any attribute) or an
+      # array of attribute names. Accepts several input shapes:
       #
       #   * a hash, e.g. <tt>{ "BigTable" => true, "User" => ["password_digest"] }</tt>
-      #     (values may be +true+/+"all"+ to hide every attribute, +false+/+nil+
-      #     to hide none, or a comma separated string / array of names);
+      #     (values may be +true+/+"all"+ to name the whole model, +false+/+nil+
+      #     to name no attributes, or a comma separated string / array of names);
       #   * a string or array of <tt>Model</tt> / <tt>Model.attribute</tt>
       #     entries, e.g. <tt>"BigTable,User.password_digest"</tt>.
-      def normalize_exclude_attributes(value)
+      #
+      # How +true+ and an empty list are interpreted is up to the caller: for
+      # +exclude_attributes+ they mean "hide every attribute" and "hide none",
+      # for +only_attributes+ they both mean "keep every attribute".
+      def normalize_attribute_filter(value)
         return {} if value.nil? || value == false
 
         if value.is_a?(Hash)
           value.each_with_object({}) do |(model, attrs), result|
-            result[model.to_s] = normalize_exclude_attribute_value(attrs)
+            result[model.to_s] = normalize_attribute_filter_value(attrs)
           end
         else
           entries = Array(value).flat_map { |entry| entry.to_s.split(",") }
@@ -116,6 +130,25 @@ module RailsERD
         end
       end
 
+      # Canonicalises the +only_attributes+ option. See #normalize_attribute_filter.
+      # Unlike +exclude_attributes+ it cannot be enabled with a bare +true+:
+      # "show only all attributes" has no meaning, so it is rejected rather than
+      # silently ignored.
+      def normalize_only_attributes(value)
+        if value == true
+          raise ArgumentError, "only_attributes cannot be true: it takes the attributes to keep, " \
+            "either as a hash of model names to attribute names, or as a list of Model.attribute " \
+            "entries. Use attributes: false or exclude_attributes to hide attributes."
+        end
+
+        normalize_attribute_filter(value)
+      end
+
+      # Canonicalises the +exclude_attributes+ option. See #normalize_attribute_filter.
+      def normalize_exclude_attributes(value)
+        normalize_attribute_filter(value)
+      end
+
       protected
 
       def setup(&block)
@@ -144,7 +177,7 @@ module RailsERD
         @callbacks ||= Hash.new { proc {} }
       end
 
-      def normalize_exclude_attribute_value(attrs)
+      def normalize_attribute_filter_value(attrs)
         case attrs
         when true then true
         when false, nil then []
@@ -243,6 +276,7 @@ module RailsERD
     def filtered_relationships
       @domain.relationships.reject { |relationship|
         (!options.indirect && relationship.indirect?) ||
+          (!options.recursive && relationship.recursive?) ||
           # Drop relationships to a model removed by :only/:exclude, otherwise the filtered-out
           # model leaks back in: Graphviz skips such edges implicitly (it only draws an edge when
           # both nodes exist) but Mermaid emits every relationship and renders any named entity.
@@ -318,7 +352,12 @@ module RailsERD
       excluded = excluded_attributes_for(entity)
       return [] if excluded == :all
 
+      only = only_attributes_for(entity)
+
       entity.attributes.select { |attribute|
+        # Keep only the attributes listed for this specific model, mirroring how
+        # :only is applied before :exclude when filtering entities.
+        next false if only != :all && !only.include?(attribute.name)
         # Hide attributes excluded for this specific model.
         next false if excluded.include?(attribute.name)
         # Hide every attribute when the :attributes option is off or the entity
@@ -329,6 +368,18 @@ module RailsERD
       }
     end
 
+    # Returns the attributes the given entity is restricted to through the
+    # +only_attributes+ option. Returns +:all+ when no restriction applies,
+    # which is the case when the model is not listed at all, or is listed
+    # without naming any attribute.
+    def only_attributes_for(entity)
+      spec = normalized_only_attributes[entity.name]
+      return :all if spec.nil? || spec == true
+
+      names = Array(spec)
+      names.empty? ? :all : names
+    end
+
     # Returns the attribute exclusions configured for the given entity through
     # the +exclude_attributes+ option. Returns +:all+ when every attribute
     # should be hidden, or an array of attribute names otherwise.
@@ -338,6 +389,10 @@ module RailsERD
       Array(spec)
     end
 
+    def normalized_only_attributes
+      @normalized_only_attributes ||= self.class.normalize_only_attributes(options.only_attributes)
+    end
+
     def normalized_exclude_attributes
       @normalized_exclude_attributes ||= self.class.normalize_exclude_attributes(options.exclude_attributes)
     end

data/lib/rails_erd/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module RailsERD
-  VERSION = "2.1.0"
+  VERSION = "2.2.0"
   BANNER  = "RailsERD #{VERSION}"
 end

data/lib/rails_erd.rb

@@ -51,12 +51,14 @@ module RailsERD
         :notation, :simple,
         :orientation, :horizontal,
         :polymorphism, false,
+        :recursive, true,
         :sort, true,
         :warn, true,
         :title, true,
         :exclude, nil,
         :exclude_attributes, nil,
         :only, nil,
+        :only_attributes, nil,
         :only_recursion_depth, nil,
         :prepend_primary, false,
         :cluster, false,

data/test/test_helper.rb

@@ -1,7 +1,7 @@
 require "rubygems"
 require "bundler/setup"
 require 'pry'
-require 'pry-nav'
+require 'pry-byebug'
 require 'tmpdir'
 
 require "active_record"

data/test/unit/config_test.rb

@@ -133,6 +133,17 @@ class ConfigTest < ActiveSupport::TestCase
     assert_equal expected, normalize_value(:exclude_attributes, "BigTable,User.password_digest")
   end
 
+  test "normalize_value should canonicalize a hash when key is :only_attributes." do
+    value = { "Book" => ["title", "isbn"] }
+    expected = { "Book" => ["title", "isbn"] }
+    assert_equal expected, normalize_value(:only_attributes, value)
+  end
+
+  test "normalize_value should parse a string when key is :only_attributes." do
+    expected = { "Book" => ["title", "isbn"] }
+    assert_equal expected, normalize_value(:only_attributes, "Book.title,Book.isbn")
+  end
+
   test "normalize_value should return hash with symbol keys when key is :fonts and value is a hash." do
     fonts_value = { "normal" => "Arial", "bold" => "Arial Bold", "italic" => "Arial Italic" }
     expected = {:normal => "Arial", :bold => "Arial Bold", :italic => "Arial Italic"}

data/test/unit/diagram_test.rb

@@ -323,6 +323,20 @@ class DiagramTest < ActiveSupport::TestCase
     assert_equal [false, false], retrieve_relationships(:indirect => false).map(&:indirect?)
   end
 
+  test "generate should yield self referential relationships if recursive is true" do
+    create_model "Node", :parent => :references do
+      belongs_to :parent, :class_name => "Node"
+    end
+    assert_equal [true], retrieve_relationships(:recursive => true).map(&:recursive?)
+  end
+
+  test "generate should filter self referential relationships if recursive is false" do
+    create_model "Node", :parent => :references do
+      belongs_to :parent, :class_name => "Node"
+    end
+    assert_equal [], retrieve_relationships(:recursive => false)
+  end
+
   test "generate should yield relationships from specialized entities" do
     create_model "Foo", :bar => :references
     create_model "Bar", :type => :string
@@ -474,6 +488,74 @@ class DiagramTest < ActiveSupport::TestCase
     assert_equal [], attribute_lists[Author].map(&:name)
   end
 
+  test "generate should show only the listed attributes for a model" do
+    create_model "Book", :title => :string, :subtitle => :string, :pages => :integer
+    attribute_lists = retrieve_attribute_lists(:only_attributes => { "Book" => ["title", "pages"] })
+    assert_equal %w{pages title}, attribute_lists[Book].map(&:name).sort
+  end
+
+  test "generate should restrict attributes for the listed model only" do
+    create_model "Book", :title => :string, :subtitle => :string
+    create_model "Author", :name => :string, :born_on => :date
+    attribute_lists = retrieve_attribute_lists(:only_attributes => { "Book" => ["title"] })
+    assert_equal %w{title}, attribute_lists[Book].map(&:name)
+    assert_equal %w{born_on name}, attribute_lists[Author].map(&:name).sort
+  end
+
+  test "generate should accept only_attributes as a string" do
+    create_model "Book", :title => :string, :subtitle => :string
+    create_model "Author", :name => :string
+    attribute_lists = retrieve_attribute_lists(:only_attributes => "Book.title")
+    assert_equal %w{title}, attribute_lists[Book].map(&:name)
+    assert_equal %w{name}, attribute_lists[Author].map(&:name)
+  end
+
+  test "generate should keep all attributes for a model listed in only_attributes without any attribute" do
+    create_model "Book", :title => :string, :subtitle => :string
+    attribute_lists = retrieve_attribute_lists(:only_attributes => "Book")
+    assert_equal %w{subtitle title}, attribute_lists[Book].map(&:name).sort
+  end
+
+  test "generate should not show attributes selected by only_attributes but rejected by attributes" do
+    create_model "Book", :title => :string, :created_at => :datetime
+    attribute_lists = retrieve_attribute_lists(:only_attributes => { "Book" => ["title", "created_at"] },
+      :attributes => [:content])
+    assert_equal %w{title}, attribute_lists[Book].map(&:name)
+  end
+
+  test "generate should apply only_attributes before exclude_attributes" do
+    create_model "Book", :title => :string, :subtitle => :string, :pages => :integer
+    attribute_lists = retrieve_attribute_lists(:only_attributes => { "Book" => ["title", "subtitle"] },
+      :exclude_attributes => { "Book" => ["subtitle"] })
+    assert_equal %w{title}, attribute_lists[Book].map(&:name)
+  end
+
+  test "generate should hide all attributes when a model is in both only_attributes and fully excluded" do
+    create_model "Book", :title => :string, :subtitle => :string
+    attribute_lists = retrieve_attribute_lists(:only_attributes => { "Book" => ["title"] },
+      :exclude_attributes => { "Book" => true })
+    assert_equal [], attribute_lists[Book].map(&:name)
+  end
+
+  test "normalize_only_attributes should split namespaced models on the first dot only" do
+    assert_equal({ "Admin::User" => ["email"] },
+      Diagram.normalize_only_attributes("Admin::User.email"))
+  end
+
+  test "normalize_only_attributes should return an empty hash for nil" do
+    assert_equal({}, Diagram.normalize_only_attributes(nil))
+  end
+
+  test "normalize_only_attributes should return an empty hash for false" do
+    assert_equal({}, Diagram.normalize_only_attributes(false))
+  end
+
+  test "normalize_only_attributes should raise for true" do
+    assert_raises ArgumentError do
+      Diagram.normalize_only_attributes(true)
+    end
+  end
+
   test "normalize_exclude_attributes should split namespaced models on the first dot only" do
     assert_equal({ "Admin::User" => ["password_digest"] },
       Diagram.normalize_exclude_attributes("Admin::User.password_digest"))

data/test/unit/mermaid_test.rb

@@ -188,13 +188,30 @@ class MermaidTest < ActiveSupport::TestCase
       "\tclass `Cannon`",
       "\tclass `Galleon`",
       "\tclass `Stronghold`",
-      "\t`Defensible` --> `Cannon`",
       "\t`Galleon` --> `Cannon`",
       "\t`Stronghold` --> `Cannon`"
     ]
     assert_equal expected, diagram.graph.uniq
   end
 
+  test "generate should not draw polymorphic entity that is omitted by only" do
+    create_model "Cannon", :defensible => :references do
+      belongs_to :defensible, :polymorphic => true
+    end
+    create_model "Galleon" do
+      has_many :cannons, :as => :defensible
+    end
+
+    expected = [
+      "classDiagram",
+      "\tdirection TB",
+      "\tclass `Cannon`",
+      "\tclass `Galleon`",
+      "\t`Galleon` --> `Cannon`"
+    ]
+    assert_equal expected, diagram(:only => %w{Cannon Galleon}).graph.uniq
+  end
+
   test "generate should support one to many relationships" do
     create_one_to_many_assoc_domain
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-erd
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Rolf Timmermans
@@ -52,20 +52,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.2.0
-- !ruby/object:Gem::Dependency
-  name: ostruct
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: ruby-graphviz
   requirement: !ruby/object:Gem::Requirement
@@ -95,7 +81,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry-nav
+  name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="