diver_down 0.0.1.alpha14 → 0.0.1.alpha15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12f54ddda5108f877d6e1510710b5a397dfc92db94c21f6521739b5032e4351f
-  data.tar.gz: 4c3c4b1063fd4da506077a8f9908a9f621336ffed58e0f5fc8b4c9c5b54cbd15
+  metadata.gz: 4365e60094816d3b24ee259f50cdd2c58ffd60bf85297fa3d5f589932bda2d27
+  data.tar.gz: 315471dc4a1f220478bc5c26a96252ed3f97a06f1cda8604a2d0bb55de7f5c89
 SHA512:
-  metadata.gz: 476bee3370a190cb94adb215abe7c58deb8c0dac475fca258c9e673d09471c477f5ba7826ba2575524c0f80c1f5454236bb71fd244c8306d02d75ad7766e85b9
-  data.tar.gz: 2e155be624f952d2b0e69d8d9a5ec549053e7f2ddfa469c2ce998777421cab30a73a423a2ecba5264f1fe7e603c4186413a801dfcbe49e82ca39d8bad7ec4531
+  metadata.gz: b068eaf0ceb7cb58284e0f6406326e345d466950ca9474ec2e49b15175d5b7676bee0b7548321b1b6c3adb3b4aa6c0ea9e26f84301dac1349973722b814f831d
+  data.tar.gz: a81235611395d6b0702c07da2bea5a862b0a19e76e9ab0b191d9a7b2f314f32596a1ec76618cbcfa2ac8c2cfe5a7367fc31e0c0fd75867a4889cba28d283fed4

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'
@@ -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/version.rb

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

data/lib/diver_down/web/action.rb

@@ -12,14 +12,18 @@ module DiverDown
         :per
       )
 
+      M = Mutex.new
+
+      attr_reader :store
+
       # @param store [DiverDown::Definition::Store]
       # @param metadata [DiverDown::Web::Metadata]
-      # @param request [Rack::Request]
-      def initialize(store:, metadata:, request:)
+      def initialize(store:, metadata:)
         @store = store
         @metadata = metadata
         @source_alias_resolver = DiverDown::Web::SourceAliasResolver.new(@metadata.source_alias)
-        @request = request
+        @module_dependency_map = nil
+        @module_dependency_map_cache_id = nil
       end
 
       # GET /api/source_aliases.json
@@ -61,15 +65,11 @@ module DiverDown
       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 { @metadata.source(_1).modules? }
+        classified_sources_count = source_names.count { @metadata.source(_1).module? }
 
         json(
           sources: source_names.sort.map do |source_name|
@@ -79,9 +79,7 @@ module DiverDown
               source_name:,
               resolved_alias: @metadata.source_alias.resolve_alias(source_name),
               memo: source_metadata.memo,
-              modules: source_metadata.modules.map do |module_name|
-                { module_name: }
-              end,
+              module: source_metadata.module,
             }
           end,
           classified_sources_count:
@@ -91,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 = @metadata.source(source.source_name).modules
-            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 = @metadata.source(source.source_name).modules
-
-            next unless source_module_names[0..module_names.size - 1] == module_names
+      # GET /api/modules/:modulee.json
+      # @param modulee [String]
+      def module(modulee)
+        module_dependency_map = fetch_module_dependency_map
 
-            source_names.add(source.source_name)
-            related_definition_store_ids.add(definition.store_id)
-          end
-        end
-        # rubocop:enable Style/HashEachMethods
-
-        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: @metadata.source(source_name).memo,
+              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
         )
@@ -178,7 +177,7 @@ module DiverDown
               definition_group: definition.definition_group,
               title: definition.title,
               sources_count: definition.sources.size,
-              unclassified_sources_count: definition.sources.reject { @metadata.source(_1.source_name).modules? }.size,
+              unclassified_sources_count: definition.sources.reject { @metadata.source(_1.source_name).module? }.size,
             }
           end,
           pagination: pagination.to_h
@@ -200,39 +199,13 @@ module DiverDown
         )
       end
 
-      # GET /api/module_definition/:module_names.json
-      #
-      # @param bit_id [Integer]
-      # @param compound [Boolean]
-      # @param concentrate [Boolean]
-      # @param only_module [Boolean]
-      # @param modules [Array<String>]
-      def module_definition(compound, concentrate, only_module, modules)
-        definition = @store.combined_definition
-
-        # Filter all sources and dependencies by modules if match_modules is given
-        resolved_definition = DiverDown::Web::ModuleSourcesFilter.new(@metadata).filter(definition, modules:)
-
-        # Resolve source aliases
-        resolved_definition = @source_alias_resolver.resolve(resolved_definition)
-
-        render_combined_definition(
-          (1..@store.size).to_a,
-          resolved_definition,
-          modules,
-          compound:,
-          concentrate:,
-          only_module:
-        )
-      end
-
       # GET /api/definitions/:bit_id.json
       #
       # @param bit_id [Integer]
       # @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
@@ -254,6 +227,8 @@ module DiverDown
         if definition
           # 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,
@@ -304,20 +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)
-                         @metadata.source(source.source_name).modules
-                       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:,
           resolved_alias: @metadata.source_alias.resolve_alias(source_name),
           memo: @metadata.source(source_name).memo,
-          modules: module_names.map do
-            { module_name: _1 }
-          end,
+          module: modulee,
           related_definitions: related_definitions.map do |id, definition|
             {
               id:,
@@ -327,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,
@@ -339,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
@@ -351,7 +325,7 @@ module DiverDown
         end
 
         if found_source
-          @metadata.source(source_name).modules = modules
+          @metadata.source(source_name).module = modulee
           @metadata.flush
 
           json({})
@@ -388,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
@@ -451,13 +423,28 @@ module DiverDown
               source_name: _1.source_name,
               resolved_alias: @metadata.source_alias.resolve_alias(_1.source_name),
               memo: @metadata.source(_1.source_name).memo,
-              modules: @metadata.source(_1.source_name).modules.map do |module_name|
-                { module_name: }
+              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
 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

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