diver_down 0.0.1.alpha1

data/lib/diver_down/web/action.rb

@@ -0,0 +1,344 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module DiverDown
+  class Web
+    class Action
+      Pagination = Data.define(
+        :current_page,
+        :total_pages,
+        :total_count,
+        :per
+      )
+
+      # @param store [DiverDown::Definition::Store]
+      # @param module_store [DiverDown::Web::ModuleStore]
+      # @param request [Rack::Request]
+      def initialize(store:, module_store:, request:)
+        @store = store
+        @module_store = module_store
+        @request = request
+      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
+        end
+        # rubocop:enable Style/HashEachMethods
+
+        json(
+          sources: source_names.sort.map do |source_name|
+            {
+              source_name:,
+            }
+          end
+        )
+      end
+
+      # GET /api/modules.json
+      def modules
+        # Hash{ DiverDown::Definition::Modulee => Set<Integer> }
+        module_set = Set.new
+
+        # rubocop:disable Style/HashEachMethods
+        @store.each do |_, definition|
+          definition.sources.each do |source|
+            modules = @module_store.get(source.source_name)
+            module_set.add(modules) unless modules.empty?
+          end
+        end
+        # rubocop:enable Style/HashEachMethods
+
+        json(
+          modules: module_set.sort.map do
+            _1.map do |module_name|
+              {
+                module_name:,
+              }
+            end
+          end
+        )
+      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(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
+
+        if related_definition_store_ids.empty?
+          return not_found
+        end
+
+        related_definitions = related_definition_store_ids.map { @store.get(_1) }
+
+        json(
+          modules: module_names.map do
+            {
+              module_name: _1,
+            }
+          end,
+          sources: source_names.sort.map do |source_name|
+            {
+              source_name:,
+            }
+          end,
+          related_definitions: related_definitions.map do |definition|
+            {
+              id: definition.store_id,
+              title: definition.title,
+            }
+          end
+        )
+      end
+
+      # GET /api/definitions.json
+      #
+      # @param page [Integer]
+      # @param per [Integer]
+      # @param title [String]
+      # @param source [String]
+      def definitions(page:, per:, title:, source:)
+        definition_enumerator = DiverDown::Web::DefinitionEnumerator.new(@store, title:, source:)
+        definitions, pagination = paginate(definition_enumerator, page, per)
+
+        json(
+          definitions: definitions.map do |definition|
+            {
+              id: definition.store_id,
+              definition_group: definition.definition_group,
+              title: definition.title,
+            }
+          end,
+          pagination: pagination.to_h
+        )
+      end
+
+      # GET /api/initialization_status.json
+      def initialization_status(total)
+        json(
+          total:,
+          loaded: @store.size
+        )
+      end
+
+      # GET /api/pid.json
+      def pid
+        json(
+          pid: Process.pid
+        )
+      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)
+        ids = DiverDown::Web::BitId.bit_id_to_ids(bit_id)
+
+        valid_ids = ids.select do
+          @store.key?(_1)
+        end
+
+        definition, titles = case valid_ids.length
+                             when 0
+                               return not_found
+                             when 1
+                               definition = @store.get(ids[0])
+                               [definition, [definition.title]]
+                             else
+                               definitions = valid_ids.map { @store.get(_1) }
+                               definition = DiverDown::Definition.combine(definition_group: nil, title: 'combined', definitions:)
+                               [definition, definitions.map(&:title)]
+                             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,
+                modules: @module_store.get(_1.source_name).map do |module_name|
+                  { module_name: }
+                end,
+              }
+            end
+          )
+        else
+          not_found
+        end
+      end
+
+      # GET /api/sources/:source_name.json
+      #
+      # @param source_name [String]
+      def source(source_name)
+        found_sources = []
+        related_definitions = []
+        reverse_dependencies = Hash.new { |h, dependency_source_name| h[dependency_source_name] = DiverDown::Definition::Dependency.new(source_name: dependency_source_name) }
+
+        @store.each do |id, definition|
+          found_source = nil
+
+          definition.sources.each do |definition_source|
+            found_source = definition_source if definition_source.source_name == source_name
+
+            found_reverse_dependencies = definition_source.dependencies.select do |dependency|
+              dependency.source_name == source_name
+            end
+
+            found_reverse_dependencies.each do |dependency|
+              reverse_dependency = reverse_dependencies[dependency.source_name]
+
+              dependency.method_ids.each do |method_id|
+                reverse_method_id = reverse_dependency.find_or_build_method_id(name: method_id.name, context: method_id.context)
+                reverse_method_id.paths.merge(method_id.paths)
+              end
+            end
+          end
+
+          if found_source
+            found_sources << found_source
+            related_definitions << [id, definition]
+          end
+        end
+
+        return not_found if related_definitions.empty?
+
+        module_names = if found_sources.empty?
+                         []
+                       else
+                         source = DiverDown::Definition::Source.combine(*found_sources)
+                         @module_store.get(source.source_name)
+                       end
+
+        json(
+          source_name:,
+          modules: module_names.map do
+            { module_name: _1 }
+          end,
+          related_definitions: related_definitions.map do |id, definition|
+            {
+              id:,
+              title: definition.title,
+            }
+          end,
+          reverse_dependencies: reverse_dependencies.values.map { |reverse_dependency|
+            {
+              source_name: reverse_dependency.source_name,
+              method_ids: reverse_dependency.method_ids.sort.map do |method_id|
+                {
+                  context: method_id.context,
+                  name: method_id.name,
+                  paths: method_id.paths.sort,
+                }
+              end,
+            }
+          }
+        )
+      end
+
+      # POST /api/sources/:source_name/modules.json
+      #
+      # @param source_name [String]
+      # @param modules [Array<String>]
+      def set_modules(source_name, modules)
+        found_source = @store.any? do |_, definition|
+          definition.sources.any? do |source|
+            source.source_name == source_name
+          end
+        end
+
+        if found_source
+          @module_store.set(source_name, modules)
+          @module_store.flush
+
+          json({})
+        else
+          not_found
+        end
+      end
+
+      # @return [Array[Integer, Hash, Array]]
+      def not_found
+        [404, { 'content-type' => 'text/plain' }, ['not found']]
+      end
+
+      private
+
+      attr_reader :request, :store
+
+      def build_method_id_key(dependency, method_id)
+        "#{dependency.source_name}-#{method_id.context}-#{method_id.name}"
+      end
+
+      def paginate(enumerator, page, per)
+        start_index = (page - 1) * per
+        end_index = start_index + per - 1
+
+        items = []
+        enumerator.each_with_index do |item, index|
+          next if index < start_index
+          break if index > end_index
+
+          items.push(item)
+        end
+
+        total_count = enumerator.size
+
+        [
+          items,
+          Pagination.new(
+            current_page: page,
+            total_pages: [(total_count.to_f / per).ceil, 1].max,
+            total_count:,
+            per:
+          ),
+        ]
+      end
+
+      def fetch_definition(ids)
+        case ids.length
+        when 0
+          nil
+        when 1
+          @store.get(ids[0])
+        else
+          combine_ids_definitions(ids)
+        end
+      end
+
+      def json(data)
+        [200, { 'content-type' => 'application/json' }, [data.to_json]]
+      end
+    end
+  end
+end

data/lib/diver_down/web/bit_id.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module DiverDown
+  class Web
+    # Use bitflag for a lightweight representation of a list of bound definitions on a URL.
+    # Each definition is related with a unique bitflag, and when merging, the bitflag is calculated with `OR` to represent the merged definitions in a lightweight and fast.
+    module BitId
+      class << self
+        # @param ids [Array<Integer>]
+        # @return [Integer]
+        def ids_to_bit_id(ids)
+          ids.inject(0) { _1 | id_to_bit_id(_2) }
+        end
+
+        # @param id [Integer]
+        # @return [Array<Integer>]
+        def bit_id_to_ids(bit_id)
+          ids = []
+          shift = 0
+          while bit_id.positive?
+            if (bit_id & 1) == 1
+              ids.push(shift + 1)
+            end
+
+            bit_id >>= 1
+            shift += 1
+          end
+          ids
+        end
+
+        private
+
+        # @param id [Integer]
+        # @return [Integer]
+        def id_to_bit_id(id)
+          1 << (id - 1)
+        end
+      end
+    end
+  end
+end

data/lib/diver_down/web/definition_enumerator.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module DiverDown
+  class Web
+    class DefinitionEnumerator
+      include Enumerable
+
+      # @param store [DiverDown::Definition::Store]
+      # @param query [String]
+      def initialize(store, title: '', source: '')
+        @store = store
+        @title = title
+        @source = source
+      end
+
+      # @yield [parent_bit_id, bit_id, definition]
+      def each
+        return enum_for(__method__) unless block_given?
+
+        definition_groups = @store.definition_groups
+        definition_groups.each do |definition_group|
+          definitions = @store.filter_by_definition_group(definition_group)
+          definitions.each do
+            next unless match_definition?(_1)
+
+            yield(_1)
+          end
+        end
+      end
+
+      # @return [Integer]
+      def size
+        @store.size
+      end
+      alias length size
+
+      private
+
+      def match_definition?(definition)
+        matched = true
+
+        unless @title.empty?
+          matched &&= definition.title.include?(@title)
+        end
+
+        unless @source.empty?
+          matched &&= definition.sources.any? { _1.source_name.include?(@source) }
+        end
+
+        matched
+      end
+    end
+  end
+end

data/lib/diver_down/web/definition_loader.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module DiverDown
+  class Web
+    class DefinitionLoader
+      # @param path [String]
+      def load_file(path)
+        hash = case File.extname(path)
+               when '.yaml', '.yml'
+                 from_yaml(path)
+               when '.msgpack'
+                 from_msgpack(path)
+               when '.json'
+                 from_json(path)
+               else
+                 raise ArgumentError, "Unsupported file type: #{path}"
+               end
+
+        DiverDown::Definition.from_hash(hash)
+      end
+
+      private
+
+      def from_json(path)
+        JSON.parse(File.read(path))
+      end
+
+      def from_yaml(path)
+        YAML.load_file(path)
+      end
+
+      def from_msgpack(path)
+        MessagePack.unpack(File.binread(path))
+      end
+    end
+  end
+end

data/lib/diver_down/web/definition_store.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module DiverDown
+  class Web
+    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] = [] }
+      end
+
+      # @param id [Integer]
+      # @raise [KeyError] if the id is not found
+      # @return [DiverDown::Definition]
+      def get(id)
+        index = id - 1
+
+        raise(KeyError, "id not found: #{id}") if id <= 0 || @definitions.size < id
+
+        @definitions.fetch(index)
+      end
+
+      # @param definitions [Array<DiverDown::Definition>]
+      # @return [Array<Integer>] ids of the definitions
+      def set(*definitions)
+        definitions.map do
+          raise(ArgumentError, 'definition already set') if _1.store_id
+
+          _1.store_id = @definitions.size + 1
+
+          @definitions.push(_1)
+          @definition_group_store[_1.definition_group] << _1
+
+          _1.store_id
+        end
+      end
+
+      # @return [Array<String, nil>]
+      def definition_groups
+        keys = @definition_group_store.keys
+
+        # Sort keys with nil at the end
+        with_nil = keys.include?(nil)
+        keys.delete(nil) if with_nil
+        keys.sort!
+        keys.push(nil) if with_nil
+
+        keys
+      end
+
+      # @param definition_group [String, nil]
+      # @return [Array<DiverDown::Definition>]
+      def filter_by_definition_group(definition_group)
+        @definition_group_store.fetch(definition_group, [])
+      end
+
+      # @param id [Integer]
+      # @return [Boolean]
+      def key?(id)
+        id.positive? && id <= @definitions.size
+      end
+
+      # @return [Integer]
+      def length
+        @definitions.length
+      end
+      alias size length
+
+      # @return [Boolean]
+      def empty?
+        @definitions.empty?
+      end
+
+      # @yield [DiverDown::Definition]
+      def each
+        return enum_for(__method__) unless block_given?
+
+        # NOTE: To allow values to be rewritten during #each, duplicate the value through #to_a.
+        @definitions.each.with_index(1) do |definition, id|
+          yield(id, definition)
+        end
+      end
+    end
+  end
+end