diver_down 0.0.1.alpha13 → 0.0.1.alpha15

data/lib/diver_down/web/definition_module_dependencies.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module DiverDown
+  class Web
+    class DefinitionModuleDependencies
+      class ModuleDependency
+        attr_accessor :module
+        attr_reader :module_dependencies, :module_reverse_dependencies, :source_map, :source_reverse_dependency_map
+
+        def initialize(modulee)
+          @module = modulee
+          @module_dependencies = Set.new
+          @module_reverse_dependencies = Set.new
+          @source_map = {}
+          @source_reverse_dependency_map = {}
+        end
+
+        # @return [Array<Source>]
+        def sources
+          @source_map.keys.sort.map { @source_map.fetch(_1) }
+        end
+
+        # @return [Array<Source>]
+        def source_reverse_dependencies
+          @source_reverse_dependency_map.keys.sort.map { @source_reverse_dependency_map.fetch(_1) }
+        end
+      end
+
+      def initialize(metadata, definition)
+        @metadata = metadata
+        @definition = definition
+      end
+
+      # @return [Hash{ String => Hash{ String => Array<DiverDown::Definition::Source> } }]
+      def build_module_dependency_map
+        module_dependency_map = Hash.new { |h, k| h[k] = ModuleDependency.new(k) }
+
+        @definition.sources.each do |source|
+          source_module = @metadata.source(source.source_name).module
+          next if source_module.nil?
+
+          source_module_dependency = module_dependency_map[source_module]
+          source_module_dependency.source_map[source.source_name] ||= DiverDown::Definition::Source.new(source_name: source.source_name)
+
+          source.dependencies.each do |dependency|
+            dependency_module = @metadata.source(dependency.source_name).module
+
+            next if source_module == dependency_module
+            next if dependency_module.nil?
+
+            dependency_module_dependency = module_dependency_map[dependency_module]
+
+            # Add module dependencies
+            source_module_dependency.module_dependencies.add(dependency_module)
+
+            # Add module reverse dependencies
+            dependency_module_dependency.module_reverse_dependencies.add(source_module)
+
+            # Add source
+            definition_source = source_module_dependency.source_map[source.source_name]
+            definition_dependency = definition_source.find_or_build_dependency(dependency.source_name)
+            dependency.method_ids.each do |method_id|
+              definition_dependency.find_or_build_method_id(name: method_id.name, context: method_id.context).add_path(*method_id.paths)
+            end
+
+            # Add source reverse dependencies
+            definition_source = dependency_module_dependency.source_reverse_dependency_map[dependency.source_name] ||= DiverDown::Definition::Source.new(source_name: dependency.source_name)
+            definition_dependency = definition_source.find_or_build_dependency(source.source_name)
+            dependency.method_ids.each do |method_id|
+              definition_dependency.find_or_build_method_id(name: method_id.name, context: method_id.context).add_path(*method_id.paths)
+            end
+          end
+        end
+
+        module_dependency_map
+      end
+    end
+  end
+end

data/lib/diver_down/web/definition_store.rb

@@ -5,12 +5,11 @@ module DiverDown
     class DefinitionStore
       include Enumerable
 
-      attr_reader :bit_id
-
       def initialize
         # Hash{ Integer(unique bit flag) => DiverDown::Definition }
         @definitions = []
         @definition_group_store = Hash.new { |h, k| h[k] = [] }
+        @combined_definition = nil
       end
 
       # @param id [Integer]
@@ -31,14 +30,33 @@ module DiverDown
           raise(ArgumentError, 'definition already set') if _1.store_id
 
           _1.store_id = @definitions.size + 1
+          _1.freeze
 
           @definitions.push(_1)
           @definition_group_store[_1.definition_group] << _1
 
+          # Reset combined_definition
+          @combined_definition = nil
+
           _1.store_id
         end
       end
 
+      # @return [DiverDown::Definition]
+      def combined_definition
+        if @combined_definition.nil?
+          @combined_definition = DiverDown::Definition.combine(
+            definition_group: nil,
+            title: 'All Definitions',
+            definitions: @definitions
+          )
+
+          @combined_definition.freeze
+        end
+
+        @combined_definition
+      end
+
       # @return [Array<String, nil>]
       def definition_groups
         keys = @definition_group_store.keys

data/lib/diver_down/web/definition_to_dot.rb

@@ -7,13 +7,12 @@ module DiverDown
   class Web
     class DefinitionToDot
       ATTRIBUTE_DELIMITER = ' '
-      MODULE_DELIMITER = '::'
 
       # Between modules is prominently distanced
       MODULE_MINLEN = 3
 
-      class MetadataStore
-        Metadata = Data.define(:id, :type, :data, :module_store) do
+      class DotMetadataStore
+        DotMetadata = Data.define(:id, :type, :data, :metadata) do
           # @return [Hash]
           def to_h
             case type
@@ -31,18 +30,12 @@ module DiverDown
           private
 
           def source_to_h
-            modules = module_store.get_modules(data.source_name).map do
-              {
-                module_name: _1,
-              }
-            end
-
             {
               id:,
               type: 'source',
               source_name: data.source_name,
-              memo: module_store.get_memo(data.source_name),
-              modules:,
+              memo: metadata.source(data.source_name).memo,
+              module: metadata.source(data.source_name).module,
             }
           end
 
@@ -68,20 +61,16 @@ module DiverDown
             {
               id:,
               type: 'module',
-              modules: data.map do
-                {
-                  module_name: _1,
-                }
-              end,
+              module: data,
             }
           end
         end
 
-        def initialize(module_store)
+        def initialize(metadata)
           @prefix = 'graph_'
-          @module_store = module_store
+          @metadata = metadata
 
-          # Hash{ id => Metadata }
+          # Hash{ id => DotMetadata }
           @to_h = {}
         end
 
@@ -89,34 +78,34 @@ module DiverDown
         # @param record [DiverDown::Definition::Source]
         # @return [String]
         def issue_source_id(source)
-          build_metadata_and_return_id(:source, source)
+          build_dot_metadata_and_return_id(:source, source)
         end
 
         # @param dependency [DiverDown::Definition::Dependency]
         # @return [String]
         def issue_dependency_id(dependency)
-          build_metadata_and_return_id(:dependency, [dependency])
+          build_dot_metadata_and_return_id(:dependency, [dependency])
         end
 
         # @param module_names [Array<String>]
         # @return [String]
-        def issue_modules_id(module_names)
-          issued_metadata = @to_h.values.find { _1.type == :module && _1.data == module_names }
+        def issue_module_id(modulee)
+          issued_metadata = @to_h.values.find { _1.type == :module && _1.data == modulee }
 
           if issued_metadata
             issued_metadata.id
           else
-            build_metadata_and_return_id(:module, module_names)
+            build_dot_metadata_and_return_id(:module, modulee)
           end
         end
 
         # @param id [String]
         # @param dependency [DiverDown::Definition::Dependency]
         def append_dependency(id, dependency)
-          metadata = @to_h.fetch(id)
-          dependencies = metadata.data
+          dot_metadata = @to_h.fetch(id)
+          dependencies = dot_metadata.data
           combined_dependencies = DiverDown::Definition::Dependency.combine(*dependencies, dependency)
-          metadata.data.replace(combined_dependencies)
+          dot_metadata.data.replace(combined_dependencies)
         end
 
         # @return [Array<Hash>]
@@ -126,10 +115,10 @@ module DiverDown
 
         private
 
-        def build_metadata_and_return_id(type, data)
+        def build_dot_metadata_and_return_id(type, data)
           id = "#{@prefix}#{length + 1}"
-          metadata = Metadata.new(id:, type:, data:, module_store: @module_store)
-          @to_h[id] = metadata
+          dot_metadata = DotMetadata.new(id:, type:, data:, metadata: @metadata)
+          @to_h[id] = dot_metadata
 
           id
         end
@@ -140,24 +129,24 @@ module DiverDown
       end
 
       # @param definition [DiverDown::Definition]
-      # @param module_store [DiverDown::ModuleStore]
+      # @param metadata [DiverDown::Web::Metadata]
       # @param compound [Boolean]
       # @param concentrate [Boolean] https://graphviz.org/docs/attrs/concentrate/
-      def initialize(definition, module_store, compound: false, concentrate: false, only_module: false)
+      def initialize(definition, metadata, compound: false, concentrate: false, only_module: false)
         @definition = definition
-        @module_store = module_store
+        @metadata = metadata
         @io = DiverDown::Web::IndentedStringIo.new
         @indent = 0
         @compound = compound || only_module # When only-module is enabled, dependencies between modules are displayed as compound.
         @compound_map = Hash.new { |h, k| h[k] = {} } # Hash{ ltail => Hash{ lhead => issued id } }
         @concentrate = concentrate
         @only_module = only_module
-        @metadata_store = MetadataStore.new(module_store)
+        @dot_metadata_store = DotMetadataStore.new(metadata)
       end
 
       # @return [Array<Hash>]
-      def metadata
-        @metadata_store.to_a
+      def dot_metadata
+        @dot_metadata_store.to_a
       end
 
       # @return [String]
@@ -179,77 +168,62 @@ module DiverDown
 
       private
 
-      attr_reader :definition, :module_store, :io
+      attr_reader :definition, :metadata, :io
 
       def render_only_modules
         # Hash{ from_module => { to_module => Array<DiverDown::Definition::Dependency> } }
         dependency_map = Hash.new { |h, k| h[k] = Hash.new { |hi, ki| hi[ki] = [] } }
 
         definition.sources.sort_by(&:source_name).each do |source|
-          source_modules = module_store.get_modules(source.source_name)
-          next if source_modules.empty?
+          source_module = metadata.source(source.source_name).module
+          next if source_module.nil?
 
           source.dependencies.each do |dependency|
-            dependency_modules = module_store.get_modules(dependency.source_name)
-            next if dependency_modules.empty?
+            dependency_module = metadata.source(dependency.source_name).module
+            next if dependency_module.nil?
 
-            dependency_map[source_modules][dependency_modules].push(dependency)
+            dependency_map[source_module][dependency_module].push(dependency)
           end
         end
 
         # Remove duplicated prefix modules
-        # from [["A"], ["A", "B"]] to [["A", "B"]]
-        uniq_modules = [*dependency_map.keys, *dependency_map.values.map(&:keys).flatten(1)].uniq
-        uniq_modules.reject! do |modules|
-          modules.empty? ||
-            uniq_modules.any? { _1[0..modules.size - 1] == modules && _1.length > modules.size }
-        end
-
-        uniq_modules.each do |specific_module_names|
-          buf = swap_io do
-            indexes = (0..(specific_module_names.length - 1)).to_a
-
-            chain_yield(indexes) do |index, next_proc|
-              module_names = specific_module_names[0..index]
-              module_name = specific_module_names[index]
-
-              io.puts %(subgraph "#{escape_quote(module_label(module_names))}" {)
-              io.indented do
-                io.puts %(id="#{@metadata_store.issue_modules_id(module_names)}")
-                io.puts %(label="#{escape_quote(module_name)}")
-                io.puts %("#{escape_quote(module_name)}" #{build_attributes(label: module_name, id: @metadata_store.issue_modules_id(module_names))})
-
-                next_proc&.call
-              end
-              io.puts '}'
-            end
+        uniq_modules = [*dependency_map.keys, *dependency_map.values.map(&:keys).flatten].uniq.sort
+        uniq_modules.reject!(&:nil?)
+
+        uniq_modules.each do |modulee|
+          io.puts %(subgraph "#{escape_quote(module_label(modulee))}" {)
+          io.indented do
+            io.puts %(id="#{@dot_metadata_store.issue_module_id(modulee)}")
+            io.puts %(label="#{escape_quote(modulee)}")
+            io.puts %("#{escape_quote(modulee)}" #{build_attributes(label: modulee, id: @dot_metadata_store.issue_module_id(modulee))})
           end
-
-          io.write buf.string
+          io.puts '}'
         end
 
-        dependency_map.each do |from_modules, h|
-          h.each do |to_modules, all_dependencies|
+        dependency_map.keys.sort_by(&:to_s).each do |from_module|
+          dependency_map.fetch(from_module).keys.sort_by(&:to_s).each do |to_module|
+            all_dependencies = dependency_map.fetch(from_module).fetch(to_module)
+
             # Do not render standalone source
             # Do not render self-dependency
-            next if from_modules.empty? || to_modules.empty? || from_modules == to_modules
+            next if from_module.nil? || to_module.empty? || from_module == to_module
 
             dependencies = DiverDown::Definition::Dependency.combine(*all_dependencies)
 
             dependencies.each do
               attributes = {}
-              ltail = module_label(*from_modules)
-              lhead = module_label(*to_modules)
+              ltail = module_label(from_module)
+              lhead = module_label(to_module)
 
               # Already rendered dependencies between modules
               # Add the dependency to the edge of the compound
               if @compound_map[ltail].include?(lhead)
                 compound_id = @compound_map[ltail][lhead]
-                @metadata_store.append_dependency(compound_id, _1)
+                @dot_metadata_store.append_dependency(compound_id, _1)
                 next
               end
 
-              compound_id = @metadata_store.issue_dependency_id(_1)
+              compound_id = @dot_metadata_store.issue_dependency_id(_1)
               @compound_map[ltail][lhead] = compound_id
 
               attributes.merge!(
@@ -259,7 +233,7 @@ module DiverDown
                 minlen: MODULE_MINLEN
               )
 
-              io.write(%("#{escape_quote(from_modules[-1])}" -> "#{escape_quote(to_modules[-1])}"))
+              io.write(%("#{escape_quote(from_module)}" -> "#{escape_quote(to_module)}"))
               io.write(%( #{build_attributes(**attributes)}), indent: false) unless attributes.empty?
               io.write("\n")
             end
@@ -268,67 +242,49 @@ module DiverDown
       end
 
       def render_sources
-        by_modules = definition.sources.group_by do |source|
-          module_store.get_modules(source.source_name)
-        end
-
-        # Remove duplicated prefix modules
-        # from [["A"], ["A", "B"]] to [["A", "B"]]
-        uniq_modules = by_modules.keys.uniq
-        uniq_modules = uniq_modules.reject do |modules|
-          uniq_modules.any? { _1[0..modules.size - 1] == modules && _1.length > modules.size }
+        # Hash{ module => sources }
+        # Hash{ String => Array<DiverDown::Definition::Source> }
+        by_module = definition.sources.group_by do |source|
+          metadata.source(source.source_name).module
         end
 
-        uniq_modules.each do |full_modules|
-          # Render module and source
-          if full_modules.empty?
-            sources = by_modules[full_modules].sort_by(&:source_name)
+        # Render subgraph for each module and its sources second
+        by_module.keys.sort_by(&:to_s).each do |modulee|
+          sources = by_module.fetch(modulee).sort_by(&:source_name)
 
+          if modulee.nil?
             sources.each do |source|
-              insert_source(source)
+              io.puts build_source_node(source)
             end
           else
-            buf = swap_io do
-              indexes = (0..(full_modules.length - 1)).to_a
-
-              chain_yield(indexes) do |index, next_proc|
-                module_names = full_modules[0..index]
-                module_name = module_names[-1]
-
-                io.puts %(subgraph "#{escape_quote(module_label(module_names))}" {)
-                io.indented do
-                  io.puts %(id="#{@metadata_store.issue_modules_id(module_names)}")
-                  io.puts %(label="#{escape_quote(module_name)}")
-
-                  sources = (by_modules[module_names] || []).sort_by(&:source_name)
-                  sources.each do |source|
-                    insert_source(source)
-                  end
-
-                  next_proc&.call
-                end
-                io.puts '}'
+            io.puts %(subgraph "#{escape_quote(module_label(modulee))}" {)
+            io.indented do
+              io.puts %(id="#{@dot_metadata_store.issue_module_id(modulee)}")
+              io.puts %(label="#{escape_quote(modulee)}")
+
+              sources.each do |source|
+                io.puts build_source_node(source)
               end
             end
-
-            io.write buf.string
+            io.puts '}'
           end
         end
 
+        # Render dependencies last
         definition.sources.sort_by(&:source_name).each do |source|
           insert_dependencies(source)
         end
       end
 
-      def insert_source(source)
-        io.puts %("#{escape_quote(source.source_name)}" #{build_attributes(label: source.source_name, id: @metadata_store.issue_source_id(source))})
+      def build_source_node(source)
+        %("#{escape_quote(source.source_name)}" #{build_attributes(label: source.source_name, id: @dot_metadata_store.issue_source_id(source))})
       end
 
       def insert_dependencies(source)
         source.dependencies.each do
           attributes = {}
-          ltail = module_label(*module_store.get_modules(source.source_name))
-          lhead = module_label(*module_store.get_modules(_1.source_name))
+          ltail = module_label(metadata.source(source.source_name).module)
+          lhead = module_label(metadata.source(_1.source_name).module)
 
           if @compound && (ltail || lhead)
             # Rendering of dependencies between modules is done only once
@@ -338,11 +294,11 @@ module DiverDown
             # Add the dependency to the edge of the compound
             if between_modules && @compound_map[ltail].include?(lhead)
               compound_id = @compound_map[ltail][lhead]
-              @metadata_store.append_dependency(compound_id, _1)
+              @dot_metadata_store.append_dependency(compound_id, _1)
               next
             end
 
-            compound_id = @metadata_store.issue_dependency_id(_1)
+            compound_id = @dot_metadata_store.issue_dependency_id(_1)
             @compound_map[ltail][lhead] = compound_id
 
             attributes.merge!(
@@ -353,7 +309,8 @@ module DiverDown
             )
           else
             attributes.merge!(
-              id: @metadata_store.issue_dependency_id(_1)
+              id: @dot_metadata_store.issue_dependency_id(_1),
+              minlen: MODULE_MINLEN
             )
           end
 
@@ -411,10 +368,10 @@ module DiverDown
         @io = old_io
       end
 
-      def module_label(*modules)
-        return if modules.empty?
+      def module_label(modulee)
+        return if modulee.nil?
 
-        "cluster_#{modules.join(MODULE_DELIMITER)}"
+        "cluster_#{modulee}"
       end
 
       def escape_quote(string)

data/lib/diver_down/web/metadata/source_alias.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module DiverDown
+  class Web
+    class Metadata
+      class SourceAlias
+        class ConflictError < StandardError
+          attr_reader :source_name
+
+          def initialize(message, source_name:)
+            @source_name = source_name
+
+            super(message)
+          end
+        end
+
+        BLANK_RE = /\A\s*\z/
+
+        def initialize
+          # Hash{ alias_name => Set<source_name, ...> }
+          @alias_to_source_names = {}
+          @source_name_to_alias = {}
+        end
+
+        # @param alias_name [String]
+        # @param source_names [Array<String>]
+        # @return [void]
+        def update_alias(alias_name, source_names)
+          source_names = source_names.reject { BLANK_RE.match?(_1) }
+
+          if source_names.empty?
+            prev_source_names = @alias_to_source_names.delete(alias_name)
+            prev_source_names&.each do |prev_source_name|
+              @source_name_to_alias.delete(prev_source_name)
+            end
+          else
+            check_conflict(alias_name, source_names)
+            @alias_to_source_names[alias_name] = source_names.sort
+
+            source_names.each do |source_name|
+              @source_name_to_alias[source_name] = alias_name
+            end
+          end
+        end
+
+        # @param alias_name [String]
+        # @return [String]
+        def resolve_alias(source_name)
+          @source_name_to_alias[source_name] if @source_name_to_alias.key?(source_name)
+        end
+
+        # @param alias_name [String]
+        # @return [Array<String>]
+        def aliased_source_names(alias_name)
+          @alias_to_source_names[alias_name] if @alias_to_source_names.key?(alias_name)
+        end
+
+        # Rollback the changes made in the block if an conflict error occurs.
+        #
+        # @raise [ConflictError]
+        def transaction
+          alias_to_source_names = deep_dup(@alias_to_source_names)
+          source_name_to_alias = deep_dup(@source_name_to_alias)
+
+          yield
+        rescue ConflictError
+          @alias_to_source_names = alias_to_source_names
+          @source_name_to_alias = source_name_to_alias
+
+          raise
+        end
+
+        # @return [Hash]
+        def to_h
+          keys = @alias_to_source_names.keys.sort
+          keys.to_h { [_1, aliased_source_names(_1)] }
+        end
+
+        private
+
+        def deep_dup(hash)
+          hash.transform_values do
+            if _1.is_a?(Hash)
+              deep_dup(_1)
+            else
+              _1.dup
+            end
+          end
+        end
+
+        def added_source_names(excluding_alias_name)
+          source_names = Set.new
+
+          @alias_to_source_names.each_key do |name|
+            next if excluding_alias_name == name
+
+            source_names.add(name)
+
+            @alias_to_source_names[name].each do |source_name|
+              source_names.add(source_name)
+            end
+          end
+
+          source_names
+        end
+
+        def check_conflict(alias_name, source_names)
+          if source_names.any? { _1 == alias_name }
+            raise(ConflictError.new("Cannot create an alias for '#{alias_name}' that refers to itself.", source_name: alias_name))
+          end
+
+          registered_source_names = added_source_names(alias_name)
+
+          if registered_source_names.include?(alias_name)
+            raise ConflictError.new("Alias '#{alias_name}' is already aliased.", source_name: alias_name)
+          end
+
+          conflicted_source_name = source_names.find { registered_source_names.include?(_1) }
+
+          if conflicted_source_name
+            resolved_source_name = resolve_alias(conflicted_source_name)
+            raise ConflictError.new("Source '#{conflicted_source_name}' is already aliased to '#{resolved_source_name}'.", source_name: conflicted_source_name)
+          end
+        end
+      end
+    end
+  end
+end