diver_down 0.0.1.alpha13 → 0.0.1.alpha15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3cb1048dc3dd78965342bb1747ddbf2cc0c84c7c62dbb73fe22a719e64844ffd
-  data.tar.gz: f1137e211bebc58a87a2624916bca7db8d9e2eb29c67bdd6c554b8b3d306f1cd
+  metadata.gz: 4365e60094816d3b24ee259f50cdd2c58ffd60bf85297fa3d5f589932bda2d27
+  data.tar.gz: 315471dc4a1f220478bc5c26a96252ed3f97a06f1cda8604a2d0bb55de7f5c89
 SHA512:
-  metadata.gz: d90b43e78ed7971c7404d703c0ba7c5965b71cf463ca94fd3a5809a0f0070fd3f8771b5f3f38d5a1ca368e5b5a4381b1a3377b5f3e421d81ac9c550c2066e703
-  data.tar.gz: 520e8c6e07d5c6f9815f8a71a5f7ce1b08796c358d6792f4952b7c80b636264fcbf28b3d0cf579ecfc7ed4586292f8b0216ff5fff5415b6100281c218eb31a40
+  metadata.gz: b068eaf0ceb7cb58284e0f6406326e345d466950ca9474ec2e49b15175d5b7676bee0b7548321b1b6c3adb3b4aa6c0ea9e26f84301dac1349973722b814f831d
+  data.tar.gz: a81235611395d6b0702c07da2bea5a862b0a19e76e9ab0b191d9a7b2f314f32596a1ec76618cbcfa2ac8c2cfe5a7367fc31e0c0fd75867a4889cba28d283fed4

data/README.md

@@ -121,10 +121,10 @@ View the analysis results in a browser.
 This gem is specifically designed to analyze large applications with a modular monolithic architecture. It allows users to categorize each analyzed file into specified modules directly through the web interface.
 
 - `--definition-dir` Specifies the directory where the analysis results are stored.
-- `--module-store-path` Designates a path to save the results that include details on which module each file belongs to. If this option is not specified, the results will be temporarily stored in a default temporary file.
+- `--metadata` Designates a path to save the results that include details on which module each file belongs to. If this option is not specified, the results will be temporarily stored in a default temporary file.
 
 ```sh
-bundle exec diver_down_web --definition-dir tmp/diver_down --module-store-path tmp/module_store.yml
+bundle exec diver_down_web --definition-dir tmp/diver_down --metadata tmp/metadata.yml
 open http://localhost:8080
 ```
 
@@ -151,7 +151,7 @@ $ pnpm run dev
 
 # Start server for backend
 $ bundle install
-$ DIVER_DOWN_DIR=/path/to/definitions_dir DIVER_DOWN_MODULE_STORE=/path/to/module_store.yml bundle exec puma
+$ DIVER_DOWN_DIR=/path/to/definitions_dir DIVER_DOWN_METADATA=/path/to/metadata.yml bundle exec puma
 ```
 
 ## Contributing

data/exe/diver_down_web

@@ -3,7 +3,6 @@
 
 require 'bundler/setup'
 require 'rack/contrib'
-require 'webrick'
 require 'diver_down'
 require 'diver_down-web'
 require 'optparse'
@@ -14,7 +13,7 @@ option_parser = OptionParser.new do |opts|
     Usage: diver_down_web [options]
 
     Example:
-      diver_down_web --definition-dir /path/to/definitions --module-store /path/to/module_store.yml
+      diver_down_web --definition-dir /path/to/definitions --metadata /path/to/metadata.yml
 
     Options:
   BANNER
@@ -23,8 +22,8 @@ option_parser = OptionParser.new do |opts|
     options[:definition_dir] = path
   end
 
-  opts.on('--module-store PATH', 'Path to the module store') do |path|
-    options[:module_store] = path
+  opts.on('--metadata PATH', 'Path to the metadata.yml') do |path|
+    options[:metadata] = path
   end
 end
 option_parser.parse!(ARGV)
@@ -39,7 +38,7 @@ end
 app = Rack::JSONBodyParser.new(
   DiverDown::Web.new(
     definition_dir: options.fetch(:definition_dir),
-    module_store: DiverDown::Web::ModuleStore.new(options[:module_store] || Tempfile.new(['module_store', '.yaml']))
+    metadata: DiverDown::Web::Metadata.new(options[:metadata] || Tempfile.new(['metadata', '.yaml']).path)
   )
 )
 
@@ -47,9 +46,9 @@ begin
   # Rack 2.0
   require 'rack'
   require 'rack/server'
-  Rack::Server.new(app:, server: :webrick).start
+  Rack::Server.new(app:).start
 rescue LoadError
   # Rack 3.0
   require 'rackup'
-  Rackup::Server.new(app:, server: :webrick).start
+  Rackup::Server.new(app:).start
 end

data/lib/diver_down/definition/dependency.rb

@@ -102,6 +102,16 @@ module DiverDown
       def inspect
         %(#<#{self.class} source_name="#{source_name}" method_ids=#{method_ids}>")
       end
+
+      # @return [void]
+      def freeze
+        super
+        @method_id_map.transform_values do
+          _1.transform_values(&:freeze)
+          _1.freeze
+        end
+        @method_id_map.freeze
+      end
     end
   end
 end

data/lib/diver_down/definition/method_id.rb

@@ -78,6 +78,12 @@ module DiverDown
       def inspect
         %(#<#{self.class} #{human_method_name} paths=#{paths.inspect}>")
       end
+
+      # @return [void]
+      def freeze
+        super
+        @paths.freeze
+      end
     end
   end
 end

data/lib/diver_down/definition/source.rb

@@ -52,6 +52,12 @@ module DiverDown
         @dependency_map[dependency_source_name]
       end
 
+      # @param dependency_source_name [String]
+      # @return [void]
+      def delete_dependency(dependency_source_name)
+        @dependency_map.delete(dependency_source_name)
+      end
+
       # @return [Array<DiverDown::Definition::Dependency>]
       def dependencies
         @dependency_map.values.sort
@@ -85,6 +91,13 @@ module DiverDown
       def hash
         [self.class, source_name, dependencies].hash
       end
+
+      # @return [void]
+      def freeze
+        super
+        @dependency_map.transform_values(&:freeze)
+        @dependency_map.freeze
+      end
     end
   end
 end

data/lib/diver_down/definition.rb

@@ -103,5 +103,13 @@ module DiverDown
         [self.class, definition_group, title, sources].hash
       end
     end
+
+    # @return [void]
+    def freeze
+      super
+
+      @source_map.transform_values(&:freeze)
+      @source_map.freeze
+    end
   end
 end

data/lib/diver_down/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DiverDown
-  VERSION = '0.0.1.alpha13'
+  VERSION = '0.0.1.alpha15'
 end

data/lib/diver_down/web/action.rb

@@ -12,37 +12,74 @@ module DiverDown
         :per
       )
 
+      M = Mutex.new
+
+      attr_reader :store
+
       # @param store [DiverDown::Definition::Store]
-      # @param module_store [DiverDown::Web::ModuleStore]
-      # @param request [Rack::Request]
-      def initialize(store:, module_store:, request:)
+      # @param metadata [DiverDown::Web::Metadata]
+      def initialize(store:, metadata:)
         @store = store
-        @module_store = module_store
-        @request = request
+        @metadata = metadata
+        @source_alias_resolver = DiverDown::Web::SourceAliasResolver.new(@metadata.source_alias)
+        @module_dependency_map = nil
+        @module_dependency_map_cache_id = nil
+      end
+
+      # GET /api/source_aliases.json
+      def source_aliases
+        source_aliases = @metadata.source_alias.to_h.map do |alias_name, source_names|
+          {
+            alias_name:,
+            source_names:,
+          }
+        end
+
+        json(
+          source_aliases:
+        )
+      end
+
+      # POST /api/source_aliases.json
+      # @param alias_name [String]
+      # @param old_alias_name [String]
+      # @param source_names [Array<String>]
+      def update_source_alias(alias_name, old_alias_name, source_names)
+        @metadata.source_alias.transaction do
+          unless old_alias_name.to_s.empty?
+            # Delete old alias
+            @metadata.source_alias.update_alias(old_alias_name, [])
+          end
+
+          @metadata.source_alias.update_alias(alias_name, source_names)
+        end
+
+        @metadata.flush
+
+        json({})
+      rescue DiverDown::Web::Metadata::SourceAlias::ConflictError => e
+        json_error(e.message)
       end
 
       # GET /api/sources.json
       def sources
         source_names = Set.new
 
-        # rubocop:disable Style/HashEachMethods
-        @store.each do |_, definition|
-          definition.sources.each do |source|
-            source_names.add(source.source_name)
-          end
+        @store.combined_definition.sources.each do |source|
+          source_names.add(source.source_name)
         end
-        # rubocop:enable Style/HashEachMethods
 
-        classified_sources_count = source_names.count { @module_store.classified?(_1) }
+        classified_sources_count = source_names.count { @metadata.source(_1).module? }
 
         json(
           sources: source_names.sort.map do |source_name|
+            source_metadata = @metadata.source(source_name)
+
             {
               source_name:,
-              memo: @module_store.get_memo(source_name),
-              modules: @module_store.get_modules(source_name).map do |module_name|
-                { module_name: }
-              end,
+              resolved_alias: @metadata.source_alias.resolve_alias(source_name),
+              memo: source_metadata.memo,
+              module: source_metadata.module,
             }
           end,
           classified_sources_count:
@@ -52,70 +89,71 @@ module DiverDown
       # GET /api/modules.json
       def modules
         # Hash{ DiverDown::Definition::Modulee => Set<Integer> }
-        module_set = Set.new
+        modules = Set.new
 
-        # rubocop:disable Style/HashEachMethods
-        @store.each do |_, definition|
-          definition.sources.each do |source|
-            modules = @module_store.get_modules(source.source_name)
-            module_set.add(modules) unless modules.empty?
-          end
+        @store.combined_definition.sources.each do |source|
+          modulee = @metadata.source(source.source_name).module
+          modules.add(modulee) unless modulee.nil?
         end
-        # rubocop:enable Style/HashEachMethods
 
         json(
-          modules: module_set.sort.map do
-            _1.map do |module_name|
-              {
-                module_name:,
-              }
-            end
-          end
+          modules: modules.sort
         )
       end
 
-      # GET /api/modules/:module_name.json
-      # @param module_names [Array<String>]
-      def module(module_names)
-        # Hash{ DiverDown::Definition::Modulee => Set<Integer> }
-        related_definition_store_ids = Set.new
-        source_names = Set.new
-
-        # rubocop:disable Style/HashEachMethods
-        @store.each do |_, definition|
-          definition.sources.each do |source|
-            source_module_names = @module_store.get_modules(source.source_name)
-
-            next unless source_module_names[0..module_names.size - 1] == module_names
-
-            source_names.add(source.source_name)
-            related_definition_store_ids.add(definition.store_id)
-          end
-        end
-        # rubocop:enable Style/HashEachMethods
+      # GET /api/modules/:modulee.json
+      # @param modulee [String]
+      def module(modulee)
+        module_dependency_map = fetch_module_dependency_map
 
-        if related_definition_store_ids.empty?
+        unless module_dependency_map.key?(modulee)
           return not_found
         end
 
-        related_definitions = related_definition_store_ids.map { @store.get(_1) }
+        module_dependency = module_dependency_map.fetch(modulee)
 
         json(
-          modules: module_names.map do
+          module: modulee,
+          module_dependencies: module_dependency.module_dependencies.compact.sort,
+          module_reverse_dependencies: module_dependency.module_reverse_dependencies.compact.sort,
+          sources: module_dependency.sources.map do |source|
             {
-              module_name: _1,
-            }
-          end,
-          sources: source_names.sort.map do |source_name|
-            {
-              source_name:,
-              memo: @module_store.get_memo(source_name),
+              source_name: source.source_name,
+              module: @metadata.source(source.source_name).module,
+              memo: @metadata.source(source.source_name).memo,
+              dependencies: source.dependencies.map do |dependency|
+                {
+                  source_name: dependency.source_name,
+                  module: @metadata.source(dependency.source_name).module,
+                  method_ids: dependency.method_ids.sort.map do |method_id|
+                    {
+                      context: method_id.context,
+                      name: method_id.name,
+                      paths: method_id.paths.sort,
+                    }
+                  end,
+                }
+              end,
             }
           end,
-          related_definitions: related_definitions.map do |definition|
+          source_reverse_dependencies: module_dependency.source_reverse_dependencies.map do |source|
             {
-              id: definition.store_id,
-              title: definition.title,
+              source_name: source.source_name,
+              module: @metadata.source(source.source_name).module,
+              memo: @metadata.source(source.source_name).memo,
+              dependencies: source.dependencies.map do |dependency|
+                {
+                  source_name: dependency.source_name,
+                  module: @metadata.source(dependency.source_name).module,
+                  method_ids: dependency.method_ids.sort.map do |method_id|
+                    {
+                      context: method_id.context,
+                      name: method_id.name,
+                      paths: method_id.paths.sort,
+                    }
+                  end,
+                }
+              end,
             }
           end
         )
@@ -139,7 +177,7 @@ module DiverDown
               definition_group: definition.definition_group,
               title: definition.title,
               sources_count: definition.sources.size,
-              unclassified_sources_count: definition.sources.reject { @module_store.classified?(_1.source_name) }.size,
+              unclassified_sources_count: definition.sources.reject { @metadata.source(_1.source_name).module? }.size,
             }
           end,
           pagination: pagination.to_h
@@ -167,7 +205,7 @@ module DiverDown
       # @param compound [Boolean]
       # @param concentrate [Boolean]
       # @param only_module [Boolean]
-      def combine_definitions(bit_id, compound, concentrate, only_module)
+      def combine_definitions(bit_id, compound, concentrate, only_module, remove_internal_sources, focus_modules, modules)
         ids = DiverDown::Web::BitId.bit_id_to_ids(bit_id)
 
         valid_ids = ids.select do
@@ -187,22 +225,18 @@ module DiverDown
                              end
 
         if definition
-          definition_to_dot = DiverDown::Web::DefinitionToDot.new(definition, @module_store, compound:, concentrate:, only_module:)
-
-          json(
-            titles:,
-            bit_id: DiverDown::Web::BitId.ids_to_bit_id(valid_ids).to_s,
-            dot: definition_to_dot.to_s,
-            dot_metadata: definition_to_dot.metadata,
-            sources: definition.sources.map do
-              {
-                source_name: _1.source_name,
-                memo: @module_store.get_memo(_1.source_name),
-                modules: @module_store.get_modules(_1.source_name).map do |module_name|
-                  { module_name: }
-                end,
-              }
-            end
+          # Resolve source aliases
+          resolved_definition = @source_alias_resolver.resolve(definition)
+          # Filter sources and dependencies by condition
+          resolved_definition = DiverDown::Web::DefinitionFilter.new(@metadata, focus_modules:, modules:, remove_internal_sources:).filter(resolved_definition)
+
+          render_combined_definition(
+            valid_ids,
+            resolved_definition,
+            titles,
+            compound:,
+            concentrate:,
+            only_module:
           )
         else
           not_found
@@ -245,19 +279,18 @@ module DiverDown
 
         return not_found if related_definitions.empty?
 
-        module_names = if found_sources.empty?
-                         []
-                       else
-                         source = DiverDown::Definition::Source.combine(*found_sources)
-                         @module_store.get_modules(source.source_name)
-                       end
+        modulee = if found_sources.empty?
+                    nil
+                  else
+                    source = DiverDown::Definition::Source.combine(*found_sources)
+                    @metadata.source(source.source_name).module
+                  end
 
         json(
           source_name:,
-          memo: @module_store.get_memo(source_name),
-          modules: module_names.map do
-            { module_name: _1 }
-          end,
+          resolved_alias: @metadata.source_alias.resolve_alias(source_name),
+          memo: @metadata.source(source_name).memo,
+          module: modulee,
           related_definitions: related_definitions.map do |id, definition|
             {
               id:,
@@ -267,6 +300,7 @@ module DiverDown
           reverse_dependencies: reverse_dependencies.values.map { |reverse_dependency|
             {
               source_name: reverse_dependency.source_name,
+              module: @metadata.source(reverse_dependency.source_name).module,
               method_ids: reverse_dependency.method_ids.sort.map do |method_id|
                 {
                   context: method_id.context,
@@ -279,11 +313,11 @@ module DiverDown
         )
       end
 
-      # POST /api/sources/:source_name/modules.json
+      # POST /api/sources/:source_name/module.json
       #
       # @param source_name [String]
-      # @param modules [Array<String>]
-      def set_modules(source_name, modules)
+      # @param module [Array<String>]
+      def set_module(source_name, modulee)
         found_source = @store.any? do |_, definition|
           definition.sources.any? do |source|
             source.source_name == source_name
@@ -291,8 +325,8 @@ module DiverDown
         end
 
         if found_source
-          @module_store.set_modules(source_name, modules)
-          @module_store.flush
+          @metadata.source(source_name).module = modulee
+          @metadata.flush
 
           json({})
         else
@@ -312,8 +346,8 @@ module DiverDown
         end
 
         if found_source
-          @module_store.set_memo(source_name, memo)
-          @module_store.flush
+          @metadata.source(source_name).memo = memo
+          @metadata.flush
 
           json({})
         else
@@ -328,8 +362,6 @@ module DiverDown
 
       private
 
-      attr_reader :request, :store
-
       def build_method_id_key(dependency, method_id)
         "#{dependency.source_name}-#{method_id.context}-#{method_id.name}"
       end
@@ -370,8 +402,48 @@ module DiverDown
         end
       end
 
-      def json(data)
-        [200, { 'content-type' => 'application/json' }, [data.to_json]]
+      def json(data, status = 200)
+        [status, { 'content-type' => 'application/json' }, [data.to_json]]
+      end
+
+      def json_error(message, status = 422)
+        json({ message: }, status)
+      end
+
+      def render_combined_definition(ids, definition, titles, compound:, concentrate:, only_module:)
+        definition_to_dot = DiverDown::Web::DefinitionToDot.new(definition, @metadata, compound:, concentrate:, only_module:)
+
+        json(
+          titles:,
+          bit_id: DiverDown::Web::BitId.ids_to_bit_id(ids).to_s,
+          dot: definition_to_dot.to_s,
+          dot_metadata: definition_to_dot.dot_metadata,
+          sources: definition.sources.map do
+            {
+              source_name: _1.source_name,
+              resolved_alias: @metadata.source_alias.resolve_alias(_1.source_name),
+              memo: @metadata.source(_1.source_name).memo,
+              module: @metadata.source(_1.source_name).module,
+              dependencies: _1.dependencies.map do |dependency|
+                {
+                  source_name: dependency.source_name,
+                }
+              end,
+            }
+          end
+        )
+      end
+
+      def fetch_module_dependency_map
+        M.synchronize do
+          if @module_dependency_map_cache_id != @store.combined_definition.object_id
+            definition = @store.combined_definition
+            @module_dependency_map = DiverDown::Web::DefinitionModuleDependencies.new(@metadata, definition).build_module_dependency_map
+            @module_dependency_map_cache_id = definition.object_id
+          end
+        end
+
+        @module_dependency_map
       end
     end
   end

data/lib/diver_down/web/definition_filter.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module DiverDown
+  class Web
+    class DefinitionFilter
+      # @param metadata_alias [DiverDown::Web::Metadata]
+      # @param focus_modules [Array<String>]
+      # @param modules [Array<String>]
+      # @param remove_internal_sources [Boolean]
+      def initialize(metadata, focus_modules: [], modules: [], remove_internal_sources: false)
+        @metadata = metadata
+        @focus_modules = focus_modules
+        @modules = modules | focus_modules
+        @remove_internal_sources = remove_internal_sources
+      end
+
+      # @param definition [DiverDown::Definition]
+      # @return [DiverDown::Definition]
+      def filter(definition)
+        return definition if !@remove_internal_sources && @modules.empty?
+
+        new_definition = DiverDown::Definition.new(
+          definition_group: definition.definition_group,
+          title: definition.title
+        )
+
+        source_names = extract_match_source_names(definition.sources)
+
+        definition.sources.each do |source|
+          next unless source_names.include?(source.source_name)
+
+          new_source = new_definition.find_or_build_source(source.source_name)
+
+          source.dependencies.each do |dependency|
+            next unless source_names.include?(dependency.source_name)
+            next unless focus_module?(source, dependency)
+            next if @remove_internal_sources && @metadata.source(source.source_name).module == @metadata.source(dependency.source_name).module
+
+            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
+
+      private
+
+      def focus_module?(source, dependency)
+        return true if @focus_modules.empty?
+        return true if @focus_modules.include?(@metadata.source(source.source_name).module)
+        return true if @focus_modules.include?(@metadata.source(dependency.source_name).module)
+
+        false
+      end
+
+      def extract_match_source_names(sources)
+        # Filter sources by modules.
+        source_names = sources.filter_map do |source|
+          source.source_name if match_module?(source.source_name)
+        end.to_set
+
+        if @remove_internal_sources
+          # Remove internal sources.
+          external_called_sources = Set.new
+
+          sources.each do |source|
+            next unless source_names.include?(source.source_name)
+
+            source_module = @metadata.source(source.source_name).module
+
+            source.dependencies.each do |dependency|
+              next unless source_names.include?(dependency.source_name)
+
+              dependency_module = @metadata.source(dependency.source_name).module
+
+              next if source_module == dependency_module
+
+              external_called_sources << source.source_name
+              external_called_sources << dependency.source_name
+              break
+            end
+          end
+
+          external_called_sources
+        else
+          source_names
+        end
+      end
+
+      def top_module(source_name)
+        @metadata.source(source_name).modules.first
+      end
+
+      def match_module?(source_name)
+        @modules.empty? || @modules.include?(@metadata.source(source_name).module)
+      end
+    end
+  end
+end