diver_down 0.0.1.alpha12 → 0.0.1.alpha14

data/lib/diver_down/web/definition_to_dot.rb

@@ -12,8 +12,8 @@ module DiverDown
       # 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,7 +31,7 @@ module DiverDown
           private
 
           def source_to_h
-            modules = module_store.get_modules(data.source_name).map do
+            modules = metadata.source(data.source_name).modules.map do
               {
                 module_name: _1,
               }
@@ -41,7 +41,7 @@ module DiverDown
               id:,
               type: 'source',
               source_name: data.source_name,
-              memo: module_store.get_memo(data.source_name),
+              memo: metadata.source(data.source_name).memo,
               modules:,
             }
           end
@@ -77,11 +77,11 @@ module DiverDown
           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,13 +89,13 @@ 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>]
@@ -106,17 +106,17 @@ module DiverDown
           if issued_metadata
             issued_metadata.id
           else
-            build_metadata_and_return_id(:module, module_names)
+            build_dot_metadata_and_return_id(:module, module_names)
           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 +126,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 +140,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,18 +179,18 @@ 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)
+          source_modules = metadata.source(source.source_name).modules
           next if source_modules.empty?
 
           source.dependencies.each do |dependency|
-            dependency_modules = module_store.get_modules(dependency.source_name)
+            dependency_modules = metadata.source(dependency.source_name).modules
             next if dependency_modules.empty?
 
             dependency_map[source_modules][dependency_modules].push(dependency)
@@ -198,7 +198,7 @@ module DiverDown
         end
 
         # Remove duplicated prefix modules
-        # from [["A"], ["A", "B"]] to [["A", "B"]]
+        # from [["A"], ["A", "B"], ["A", "C"], ["D"]] to { "A" => { "B" => {}, "C" => {} }, "D" => {} }
         uniq_modules = [*dependency_map.keys, *dependency_map.values.map(&:keys).flatten(1)].uniq
         uniq_modules.reject! do |modules|
           modules.empty? ||
@@ -215,9 +215,9 @@ module DiverDown
 
               io.puts %(subgraph "#{escape_quote(module_label(module_names))}" {)
               io.indented do
-                io.puts %(id="#{@metadata_store.issue_modules_id(module_names)}")
+                io.puts %(id="#{@dot_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))})
+                io.puts %("#{escape_quote(module_name)}" #{build_attributes(label: module_name, id: @dot_metadata_store.issue_modules_id(module_names))})
 
                 next_proc&.call
               end
@@ -245,11 +245,11 @@ module DiverDown
               # 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!(
@@ -268,67 +268,57 @@ module DiverDown
       end
 
       def render_sources
+        # Hash{ modules => sources }
+        # Hash{ Array<String> => Array<DiverDown::Definition::Source> }
         by_modules = definition.sources.group_by do |source|
-          module_store.get_modules(source.source_name)
+          metadata.source(source.source_name).modules
         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 }
+        # Render subgraph for each module and its sources second
+        nested_modules = array_to_hash(by_modules.keys.uniq.sort)
+        render_nested_modules_sources(by_modules, nested_modules)
+
+        # Render dependencies last
+        definition.sources.sort_by(&:source_name).each do |source|
+          insert_dependencies(source)
         end
+      end
 
-        uniq_modules.each do |full_modules|
-          # Render module and source
-          if full_modules.empty?
-            sources = by_modules[full_modules].sort_by(&:source_name)
+      def render_nested_modules_sources(by_modules, nested_modules, prefix = [])
+        nested_modules.each do |module_name, next_nested_modules|
+          module_names = prefix + [module_name].compact
+          sources = (by_modules[module_names] || []).sort_by(&:source_name)
 
+          if module_name.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(module_names))}" {)
+            io.indented do
+              io.puts %(id="#{@dot_metadata_store.issue_modules_id(module_names)}")
+              io.puts %(label="#{escape_quote(module_name)}")
+
+              sources.each do |source|
+                io.puts build_source_node(source)
               end
-            end
 
-            io.write buf.string
+              render_nested_modules_sources(by_modules, next_nested_modules, module_names)
+            end
+            io.puts '}'
           end
         end
-
-        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).modules)
+          lhead = module_label(*metadata.source(_1.source_name).modules)
 
           if @compound && (ltail || lhead)
             # Rendering of dependencies between modules is done only once
@@ -338,11 +328,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 +343,7 @@ module DiverDown
             )
           else
             attributes.merge!(
-              id: @metadata_store.issue_dependency_id(_1)
+              id: @dot_metadata_store.issue_dependency_id(_1)
             )
           end
 
@@ -420,6 +410,28 @@ module DiverDown
       def escape_quote(string)
         string.to_s.gsub(/"/, '\"')
       end
+
+      # from [["A"], ["A", "B"], ["A", "C"], ["D"]] to { "A" => { "B" => {}, "C" => {} }, "D" => {} }
+      def array_to_hash(array)
+        hash = {}
+        array.each do |sub_array|
+          current_hash = hash
+
+          if sub_array.empty?
+            current_hash[nil] = {}
+          else
+            sub_array.each_with_index do |element, index|
+              if index == sub_array.length - 1
+                current_hash[element] = {}
+              else
+                current_hash[element] ||= {}
+                current_hash = current_hash[element]
+              end
+            end
+          end
+        end
+        hash
+      end
     end
   end
 end

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

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module DiverDown
+  class Web
+    class Metadata
+      class SourceMetadata
+        BLANK_MEMO = ''
+        BLANK_RE = /\A\s*\z/
+        BLANK_ARRAY = [].freeze
+        private_constant(:BLANK_MEMO)
+        private_constant(:BLANK_RE)
+        private_constant(:BLANK_ARRAY)
+
+        attr_reader :memo, :modules
+
+        # @param source_name [String]
+        def initialize(memo: BLANK_MEMO, modules: BLANK_ARRAY)
+          @memo = memo
+          @modules = modules
+        end
+
+        # @param memo [String]
+        # @return [void]
+        def memo=(memo)
+          @memo = memo.strip
+        end
+
+        # @param module_names [Array<String>]
+        # @return [void]
+        def modules=(module_names)
+          @modules = module_names.reject do
+            BLANK_RE.match?(_1)
+          end.freeze
+        end
+
+        # @return [Boolean]
+        def modules?
+          @modules.any?
+        end
+
+        # @return [Hash]
+        def to_h
+          hash = {}
+
+          hash[:memo] = memo unless memo == BLANK_MEMO
+          hash[:modules] = modules unless modules.empty?
+
+          hash
+        end
+
+        private
+
+        def by_source_name(source_name)
+          @store[source_name] ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/diver_down/web/metadata.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module DiverDown
+  class Web
+    class Metadata
+      require 'diver_down/web/metadata/source_metadata'
+      require 'diver_down/web/metadata/source_alias'
+
+      attr_reader :source_alias
+
+      # @param path [String]
+      def initialize(path)
+        @path = path
+        load
+      end
+
+      # @param source_name [String]
+      # @return [DiverDown::Web::Metadata::SourceMetadata]
+      def source(source_name)
+        @source_map[source_name]
+      end
+
+      # @return [Hash]
+      def to_h
+        source_names = @source_map.keys.sort
+
+        sources = source_names.filter_map {
+          h = source(_1).to_h
+          [_1, h] unless h.empty?
+        }.to_h
+
+        {
+          sources:,
+          source_alias: @source_alias.to_h,
+        }
+      end
+
+      # Write store to file
+      # @return [void]
+      def flush
+        File.write(@path, to_h.to_yaml)
+      end
+
+      private
+
+      def load
+        @source_map = Hash.new { |h, source_name| h[source_name] = DiverDown::Web::Metadata::SourceMetadata.new }
+        @source_alias = DiverDown::Web::Metadata::SourceAlias.new
+
+        loaded = YAML.load_file(@path)
+
+        return if loaded.nil?
+
+        # NOTE: This is for backward compatibility. It will be removed in the future.
+        (loaded[:sources] || loaded || []).each do |source_name, source_hash|
+          source(source_name).memo = source_hash[:memo] if source_hash[:memo]
+          source(source_name).modules = source_hash[:modules] if source_hash[:modules]
+        end
+
+        loaded[:source_alias]&.each do |alias_name, source_names|
+          @source_alias.update_alias(alias_name, source_names)
+        end
+      end
+    end
+  end
+end

data/lib/diver_down/web/module_sources_filter.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module DiverDown
+  class Web
+    class ModuleSourcesFilter
+      # @param metadata_alias [DiverDown::Web::Metadata]
+      def initialize(metadata)
+        @metadata = metadata
+      end
+
+      # @param definition [DiverDown::Definition]
+      # @param modules [Array<Array<String>>]
+      # @return [DiverDown::Definition]
+      def filter(definition, modules:)
+        new_definition = DiverDown::Definition.new(
+          definition_group: definition.definition_group,
+          title: definition.title
+        )
+
+        is_match_modules = ->(source_name) do
+          source_modules = @metadata.source(source_name).modules
+          source_modules.first(modules.size) == modules
+        end
+
+        definition.sources.each do |source|
+          next unless is_match_modules.call(source.source_name)
+
+          new_source = new_definition.find_or_build_source(source.source_name)
+
+          source.dependencies.each do |dependency|
+            next unless is_match_modules.call(dependency.source_name)
+
+            new_dependency = new_source.find_or_build_dependency(dependency.source_name)
+
+            next unless new_dependency
+
+            dependency.method_ids.each do |method_id|
+              new_method_id = new_dependency.find_or_build_method_id(
+                context: method_id.context,
+                name: method_id.name
+              )
+
+              method_id.paths.each do |path|
+                new_method_id.add_path(path)
+              end
+            end
+          end
+        end
+
+        new_definition
+      end
+    end
+  end
+end

data/lib/diver_down/web/source_alias_resolver.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module DiverDown
+  class Web
+    class SourceAliasResolver
+      # @param metadata_alias [DiverDown::Web::Metadata::SourceAlias]
+      def initialize(metadata_alias)
+        @metadata_alias = metadata_alias
+      end
+
+      # @param definition [DiverDown::Definition]
+      # @return [DiverDown::Definition]
+      def resolve(definition)
+        new_definition = DiverDown::Definition.new(
+          definition_group: definition.definition_group,
+          title: definition.title
+        )
+
+        definition.sources.each do |source|
+          resolved_source_name = @metadata_alias.resolve_alias(source.source_name) || source.source_name
+          new_source = new_definition.find_or_build_source(resolved_source_name)
+
+          source.dependencies.each do |dependency|
+            resolved_dependency_source_name = @metadata_alias.resolve_alias(dependency.source_name) || dependency.source_name
+            new_dependency = new_source.find_or_build_dependency(resolved_dependency_source_name)
+
+            next unless new_dependency
+
+            dependency.method_ids.each do |method_id|
+              new_method_id = new_dependency.find_or_build_method_id(
+                context: method_id.context,
+                name: method_id.name
+              )
+
+              method_id.paths.each do |path|
+                new_method_id.add_path(path)
+              end
+            end
+          end
+        end
+
+        new_definition
+      end
+    end
+  end
+end