diver_down 0.0.1.alpha1

data/lib/diver_down/web/definition_to_dot.rb

@@ -0,0 +1,399 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'cgi'
+
+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
+          # @return [Hash]
+          def to_h
+            case type
+            when :source
+              source_to_h
+            when :dependency
+              dependency_to_h
+            when :module
+              module_to_h
+            else
+              raise NotImplementedError, "not implemented yet #{type}"
+            end
+          end
+
+          private
+
+          def source_to_h
+            modules = module_store.get(data.source_name).map do
+              {
+                module_name: _1,
+              }
+            end
+
+            {
+              id:,
+              type: 'source',
+              source_name: data.source_name,
+              modules:,
+            }
+          end
+
+          def dependency_to_h
+            {
+              id:,
+              type: 'dependency',
+              dependencies: data.map do |dependency|
+                {
+                  source_name: dependency.source_name,
+                  method_ids: dependency.method_ids.sort.map do
+                    {
+                      name: _1.name,
+                      context: _1.context,
+                    }
+                  end,
+                }
+              end,
+            }
+          end
+
+          def module_to_h
+            {
+              id:,
+              type: 'module',
+              modules: data.map do
+                {
+                  module_name: _1,
+                }
+              end,
+            }
+          end
+        end
+
+        def initialize(module_store)
+          @prefix = 'graph_'
+          @module_store = module_store
+
+          # Hash{ id => Metadata }
+          @to_h = {}
+        end
+
+        # @param type [Symbol]
+        # @param record [DiverDown::Definition::Source]
+        # @return [String]
+        def issue_source_id(source)
+          build_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])
+        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 }
+
+          if issued_metadata
+            issued_metadata.id
+          else
+            build_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
+          combined_dependencies = DiverDown::Definition::Dependency.combine(*dependencies, dependency)
+          metadata.data.replace(combined_dependencies)
+        end
+
+        # @return [Array<Hash>]
+        def to_a
+          @to_h.values.map(&:to_h)
+        end
+
+        private
+
+        def build_metadata_and_return_id(type, data)
+          id = "#{@prefix}#{length + 1}"
+          metadata = Metadata.new(id:, type:, data:, module_store: @module_store)
+          @to_h[id] = metadata
+
+          id
+        end
+
+        def length
+          @to_h.length
+        end
+      end
+
+      # @param definition [DiverDown::Definition]
+      # @param module_store [DiverDown::ModuleStore]
+      # @param compound [Boolean]
+      # @param concentrate [Boolean] https://graphviz.org/docs/attrs/concentrate/
+      def initialize(definition, module_store, compound: false, concentrate: false, only_module: false)
+        @definition = definition
+        @module_store = module_store
+        @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)
+      end
+
+      # @return [Array<Hash>]
+      def metadata
+        @metadata_store.to_a
+      end
+
+      # @return [String]
+      def to_s
+        io.puts %(strict digraph "#{definition.title}" {)
+        io.indented do
+          io.puts('compound=true') if @compound
+          io.puts('concentrate=true') if @concentrate
+
+          if @only_module
+            render_only_modules
+          else
+            definition.sources.sort_by(&:source_name).each do
+              insert_source(_1)
+            end
+          end
+        end
+        io.puts '}'
+        io.string
+      end
+
+      private
+
+      attr_reader :definition, :module_store, :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(source.source_name)
+          next if source_modules.empty?
+
+          source.dependencies.each do |dependency|
+            dependency_modules = module_store.get(dependency.source_name)
+            next if dependency_modules.empty?
+
+            dependency_map[source_modules][dependency_modules].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 "#{module_label(module_names)}" {)
+              io.indented do
+                io.puts %(id="#{@metadata_store.issue_modules_id(module_names)}")
+                io.puts %(label="#{module_name}")
+                io.puts %("#{module_name}" #{build_attributes(label: module_name, id: @metadata_store.issue_modules_id(module_names))})
+
+                next_proc&.call
+              end
+              io.puts '}'
+            end
+          end
+
+          io.write buf.string
+        end
+
+        dependency_map.each do |from_modules, h|
+          h.each do |to_modules, all_dependencies|
+            # Do not render standalone source
+            # Do not render self-dependency
+            next if from_modules.empty? || to_modules.empty? || from_modules == to_modules
+
+            dependencies = DiverDown::Definition::Dependency.combine(*all_dependencies)
+
+            dependencies.each do
+              attributes = {}
+              ltail = module_label(*from_modules)
+              lhead = module_label(*to_modules)
+
+              # 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)
+                next
+              end
+
+              compound_id = @metadata_store.issue_dependency_id(_1)
+              @compound_map[ltail][lhead] = compound_id
+
+              attributes.merge!(
+                id: compound_id,
+                ltail:,
+                lhead:,
+                minlen: MODULE_MINLEN
+              )
+
+              io.write(%("#{from_modules[-1]}" -> "#{to_modules[-1]}"))
+              io.write(%( #{build_attributes(**attributes)}), indent: false) unless attributes.empty?
+              io.write("\n")
+            end
+          end
+        end
+      end
+
+      def insert_source(source)
+        if module_store.get(source.source_name).empty?
+          io.puts %("#{source.source_name}" #{build_attributes(label: source.source_name, id: @metadata_store.issue_source_id(source))})
+        else
+          insert_modules(source)
+        end
+
+        source.dependencies.each do
+          attributes = {}
+          ltail = module_label(*module_store.get(source.source_name))
+          lhead = module_label(*module_store.get(_1.source_name))
+
+          if @compound && (ltail || lhead)
+            # Rendering of dependencies between modules is done only once
+            between_modules = ltail != lhead
+
+            # Already rendered dependencies between modules
+            # 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)
+              next
+            end
+
+            compound_id = @metadata_store.issue_dependency_id(_1)
+            @compound_map[ltail][lhead] = compound_id
+
+            attributes.merge!(
+              id: compound_id,
+              ltail:,
+              lhead:,
+              minlen: MODULE_MINLEN
+            )
+          else
+            attributes.merge!(
+              id: @metadata_store.issue_dependency_id(_1)
+            )
+          end
+
+          io.write(%("#{source.source_name}" -> "#{_1.source_name}"))
+          io.write(%( #{build_attributes(**attributes)}), indent: false) unless attributes.empty?
+          io.write("\n")
+        end
+      end
+
+      def insert_modules(source)
+        buf = swap_io do
+          all_module_names = module_store.get(source.source_name)
+          indexes = (0..(all_module_names.length - 1)).to_a
+
+          chain_yield(indexes) do |index, next_proc|
+            module_names = all_module_names[0..index]
+            module_name = module_names[-1]
+
+            io.puts %(subgraph "#{module_label(module_names)}" {)
+            io.indented do
+              io.puts %(id="#{@metadata_store.issue_modules_id(module_names)}")
+              io.puts %(label="#{module_name}")
+
+              if next_proc
+                next_proc.call
+              else
+                # last. equals indexes[-1] == index
+                io.puts %("#{source.source_name}" #{build_attributes(label: source.source_name, id: @metadata_store.issue_source_id(source))})
+              end
+            end
+            io.puts '}'
+          end
+        end
+
+        io.write buf.string
+      end
+
+      def chain_yield(values, &block)
+        *head, tail = values
+
+        last_proc = proc do
+          block.call(tail, nil)
+        end
+
+        chain_proc = head.inject(last_proc) do |next_proc, value|
+          proc do
+            block.call(value, next_proc)
+          end
+        end
+
+        chain_proc.call
+      end
+
+      # rubocop:disable Lint/UnderscorePrefixedVariableName
+      # attrsの参考 https://qiita.com/rubytomato@github/items/51779135bc4b77c8c20d
+      def build_attributes(_wrap: '[]', **attrs)
+        attrs = attrs.reject { _2.nil? || _2 == '' }
+        return if attrs.empty?
+
+        attrs_str = attrs.map { %(#{_1}="#{_2}") }.join(ATTRIBUTE_DELIMITER)
+
+        if _wrap
+          "#{_wrap[0]}#{attrs_str}#{_wrap[1]}"
+        else
+          attrs_str
+        end
+      end
+      # rubocop:enable Lint/UnderscorePrefixedVariableName
+
+      def increase_indent
+        @indent += 1
+        yield
+      ensure
+        @indent -= 1
+      end
+
+      def swap_io
+        old_io = @io
+        @io = IndentedStringIo.new
+        yield
+        @io
+      ensure
+        @io = old_io
+      end
+
+      def module_label(*modules)
+        return if modules.empty?
+
+        "cluster_#{modules.join(MODULE_DELIMITER)}"
+      end
+    end
+  end
+end

data/lib/diver_down/web/dev_server_middleware.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'rack/proxy'
+require 'websocket/driver'
+require 'eventmachine'
+
+module DiverDown
+  class Web
+    # For vite
+    class DevServerMiddleware
+      class HttpProxy < ::Rack::Proxy
+        def initialize(_app = nil, host:, port:)
+          @host = host
+          @port = port
+
+          super(nil, backend: "http://#{@host}:#{@port}", proxy_host: @host, proxy_port: @port, proxy_scheme: 'http')
+        end
+      end
+
+      class WebSocketProxy
+        attr_reader :env, :url
+
+        def initialize(env, host:, port:)
+          @env = env
+          @url = "ws://#{host}:#{port}#{env['REQUEST_URI']}"
+          @driver = WebSocket::Driver.rack(self)
+
+          env['rack.hijack'].call
+          @io = env['rack.hijack_io']
+
+          EM.attach(@io, Reader) { |conn| conn.driver = @driver }
+
+          @driver.start
+        end
+
+        # @param string [String]
+        def write(string)
+          @io.write(string)
+        end
+
+        module Reader
+          attr_writer :driver
+
+          # @param string [String]
+          def receive_data(string)
+            @driver.parse(string)
+          end
+        end
+      end
+
+      def initialize(app, host:, port:)
+        @app = app
+        @host = host
+        @port = port
+        @http_proxy = HttpProxy.new(@app, host: @host, port: @port)
+      end
+
+      # @param env [Hash]
+      def call(env)
+        request = Rack::Request.new(env)
+
+        if WebSocket::Driver.websocket?(env)
+          WebSocketProxy.new(env, host: @host, port: @port)
+        elsif request.path.start_with?('/api')
+          @app.call(env)
+        else
+          @http_proxy.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/diver_down/web/indented_string_io.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'stringio'
+require 'forwardable'
+
+module DiverDown
+  class Web
+    class IndentedStringIo
+      extend ::Forwardable
+
+      def_delegators :@io, :rewind, :string
+
+      attr_accessor :indent
+
+      # @param tab [String]
+      def initialize(tab: '  ')
+        @io = StringIO.new
+        @indent = 0
+        @tab = tab
+      end
+
+      # @param contents [Array<String>]
+      # @param indent [Boolean] Enable or disable indentation
+      # @return [void]
+      def write(*contents, indent: true)
+        indent_string = if indent
+                          @tab * @indent
+                        else
+                          ''
+                        end
+
+        string = contents.join
+        lines = string.lines
+        lines.each do |line|
+          if line == "\n"
+            @io.write "\n"
+          else
+            @io.write "#{indent_string}#{line}"
+          end
+        end
+      end
+
+      # @param content [String]
+      # @return [void]
+      def puts(*contents, indent: true)
+        write("#{contents.join("\n")}\n", indent:)
+        nil
+      end
+
+      # increase the indent level for the block
+      def indented
+        @indent += 1
+        yield
+      ensure
+        @indent -= 1
+      end
+    end
+  end
+end

data/lib/diver_down/web/module_store.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module DiverDown
+  class Web
+    class ModuleStore
+      BLANK_ARRAY = [].freeze
+      BLANK_RE = /\A\s*\z/
+
+      private_constant(:BLANK_RE)
+
+      def initialize(path)
+        @path = path
+        @store = load
+      end
+
+      # @param source_name [String]
+      # @param module_names [Array<String>]
+      def set(source_name, module_names)
+        @store[source_name] = module_names.dup.reject do
+          BLANK_RE.match?(_1)
+        end.freeze
+      end
+
+      # @param source_name [String]
+      # @return [Array<Module>]
+      def get(source_name)
+        @store[source_name] || BLANK_ARRAY
+      end
+
+      # @return [Hash]
+      def to_h
+        @store.dup
+      end
+
+      # Write store to file
+      # @return [void]
+      def flush
+        File.write(@path, to_h.to_yaml)
+      end
+
+      private
+
+      def load
+        store = {}
+
+        begin
+          loaded = YAML.load_file(@path)
+          store.merge!(loaded) if loaded
+        rescue StandardError
+          # Ignore error
+        end
+
+        store
+      end
+    end
+  end
+end

data/lib/diver_down/web.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'rack'
+require 'yaml'
+
+module DiverDown
+  class Web
+    WEB_DIR = File.expand_path('../../web', __dir__)
+
+    require 'diver_down/web/action'
+    require 'diver_down/web/definition_to_dot'
+    require 'diver_down/web/definition_enumerator'
+    require 'diver_down/web/bit_id'
+    require 'diver_down/web/module_store'
+    require 'diver_down/web/indented_string_io'
+    require 'diver_down/web/definition_store'
+    require 'diver_down/web/definition_loader'
+
+    # For development
+    autoload :DevServerMiddleware, 'diver_down/web/dev_server_middleware'
+
+    # @param definition_dir [String]
+    # @param module_store [DiverDown::ModuleStore]
+    # @param store [DiverDown::Web::DefinitionStore]
+    def initialize(definition_dir:, module_store:, store: DiverDown::Web::DefinitionStore.new)
+      @store = store
+      @module_store = module_store
+      @files_server = Rack::Files.new(File.join(WEB_DIR))
+
+      definition_files = ::Dir["#{definition_dir}/**/*.{yml,yaml,msgpack,json}"].sort
+      @total_definition_files_size = definition_files.size
+
+      load_definition_files_on_thread(definition_files)
+    end
+
+    # @param env [Hash]
+    # @return [Array[Integer, Hash, Array]]
+    def call(env)
+      request = Rack::Request.new(env)
+      action = DiverDown::Web::Action.new(store: @store, module_store: @module_store, request:)
+
+      case [request.request_method, request.path]
+      in ['GET', %r{\A/api/definitions\.json\z}]
+        action.definitions(
+          page: request.params['page']&.to_i || 1,
+          per: request.params['per']&.to_i || 100,
+          title: request.params['title'] || '',
+          source: request.params['source'] || ''
+        )
+      in ['GET', %r{\A/api/sources\.json\z}]
+        action.sources
+      in ['GET', %r{\A/api/modules\.json\z}]
+        action.modules
+      in ['GET', %r{\A/api/modules/(?<module_names>.+)\.json\z}]
+        module_names = Regexp.last_match[:module_names].split('/')
+        action.module(module_names)
+      in ['GET', %r{\A/api/definitions/(?<bit_id>\d+)\.json\z}]
+        bit_id = Regexp.last_match[:bit_id].to_i
+        compound = request.params['compound'] == '1'
+        concentrate = request.params['concentrate'] == '1'
+        only_module = request.params['only_module'] == '1'
+        action.combine_definitions(bit_id, compound, concentrate, only_module)
+      in ['GET', %r{\A/api/sources/(?<source>[^/]+)\.json\z}]
+        source = Regexp.last_match[:source]
+        action.source(source)
+      in ['POST', %r{\A/api/sources/(?<source>[^/]+)/modules.json\z}]
+        source = Regexp.last_match[:source]
+        modules = request.params['modules'] || []
+        action.set_modules(source, modules)
+      in ['GET', %r{\A/api/pid\.json\z}]
+        action.pid
+      in ['GET', %r{\A/api/initialization_status\.json\z}]
+        action.initialization_status(@total_definition_files_size)
+      in ['GET', %r{\A/assets/}]
+        @files_server.call(env)
+      in ['GET', /\.json\z/], ['POST', /\.json\z/]
+        action.not_found
+      else
+        @files_server.call(env.merge('PATH_INFO' => '/index.html'))
+      end
+    end
+
+    private
+
+    def load_definition_files_on_thread(definition_files)
+      definition_loader = DiverDown::Web::DefinitionLoader.new
+
+      Thread.new do
+        loop do
+          break if definition_files.empty?
+
+          definition_file = definition_files.shift
+          definition = definition_loader.load_file(definition_file)
+
+          # No needed to synchronize because this is executed on a single thread.
+          @store.set(definition)
+        end
+      end
+    end
+  end
+end

data/lib/diver_down-trace.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'diver_down'
+require 'diver_down/trace'

data/lib/diver_down-web.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'diver_down'
+require 'diver_down/web'