mayu-live 0.0.0

data/lib/mayu/resources/generators/copy_file.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+# typed: strict
+
+require "fileutils"
+require_relative "base"
+
+module Mayu
+  module Resources
+    module Generators
+      class CopyFile < Base
+        extend T::Sig
+
+        sig { params(source_path: String).void }
+        def initialize(source_path)
+          @source_path = source_path
+        end
+
+        sig { override.params(target_path: String).void }
+        def process(target_path)
+          return if File.exist?(target_path)
+          FileUtils.copy_file(@source_path, target_path)
+        end
+      end
+    end
+  end
+end

data/lib/mayu/resources/generators/image.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+# typed: strict
+
+require "image_size"
+require "base64"
+require "shellwords"
+require_relative "base"
+
+module Mayu
+  module Resources
+    module Generators
+      class Image < Base
+        extend T::Sig
+
+        sig do
+          params(
+            source_path: String,
+            version: Types::Image::ImageDescriptor
+          ).void
+        end
+        def initialize(source_path, version)
+          @source_path = source_path
+          @version = version
+        end
+
+        sig { override.params(target_path: String).void }
+        def process(target_path)
+          return if File.exist?(target_path)
+
+          Console.logger.info(
+            self,
+            "Generating #{target_path} from #{@source_path}"
+          )
+
+          case @version.format
+          when :webp
+            convert_webp(
+              source_path: @source_path,
+              quality: 80, # typical quality,
+              width: @version.width,
+              target_path: target_path
+            )
+          else
+            convert_generic(
+              source_path: @source_path,
+              quality: 80, # typical quality,
+              width: @version.width,
+              target_path: target_path
+            )
+          end
+        end
+
+        private
+
+        sig do
+          params(
+            source_path: String,
+            quality: Integer,
+            width: Integer,
+            target_path: String
+          ).void
+        end
+        def convert_webp(source_path:, quality:, width:, target_path:)
+          system(
+            Shellwords.shelljoin(
+              [
+                "cwebp",
+                "-q",
+                "#{quality}",
+                "-resize",
+                "#{width}",
+                "0",
+                source_path,
+                "-o",
+                target_path
+              ]
+            ) + " 2> /dev/null"
+          ) or raise "Could not generate #{target_path} from #{source_path}"
+        end
+
+        sig do
+          params(
+            source_path: String,
+            quality: Integer,
+            width: Integer,
+            target_path: String
+          ).void
+        end
+        def convert_generic(source_path:, quality:, width:, target_path:)
+          system(
+            Shellwords.shelljoin(
+              [
+                "convert",
+                source_path,
+                "-adaptive-resize",
+                "#{width}",
+                "-strip",
+                target_path
+              ]
+            ) + " 2> /dev/null"
+          ) or raise "Could not generate #{target_path} from #{source_path}"
+        end
+      end
+    end
+  end
+end

data/lib/mayu/resources/generators/write_file.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+# typed: strict
+
+require "fileutils"
+require_relative "base"
+
+module Mayu
+  module Resources
+    module Generators
+      class WriteFile < Base
+        extend T::Sig
+
+        sig { params(contents: String, compress: T::Boolean).void }
+        def initialize(contents:, compress:)
+          @contents = contents
+          @compress = compress
+        end
+
+        sig { override.params(target_path: String).void }
+        def process(target_path)
+          write_file(target_path, @contents)
+
+          if @compress
+            write_file(target_path + ".br", Brotli.deflate(@contents))
+          end
+        end
+
+        private
+
+        sig { params(path: String, content: String).void }
+        def write_file(path, content)
+          return if File.exist?(path)
+          Console.logger.info(self, "Writing #{path}")
+          File.write(path, content)
+        end
+      end
+    end
+  end
+end

data/lib/mayu/resources/hot_swap/file_watcher.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+# typed: strict
+
+require "listen"
+require "async"
+require "async/queue"
+require "async/task"
+require "thread"
+
+module Mayu
+  module Resources
+    module HotSwap
+      module FileWatcher
+        extend T::Sig
+
+        class Event < T::Struct
+          const :modified, T::Array[String]
+          const :added, T::Array[String]
+          const :removed, T::Array[String]
+        end
+
+        sig do
+          params(
+            root: String,
+            dirs: T::Array[String],
+            task: Async::Task,
+            block: T.proc.params(arg0: Event).void
+          ).returns(Async::Task)
+        end
+        def self.watch(
+          root = Dir.pwd,
+          dirs = [""],
+          task: Async::Task.current,
+          &block
+        )
+          root = File.expand_path(root)
+          queue = Thread::Queue.new
+          paths = dirs.map { File.join(root, _1) }
+
+          listener =
+            T.let(
+              T
+                .unsafe(Listen)
+                .to(*paths) do |modified, added, removed|
+                  Event
+                    .new(
+                      modified: modified.map { _1.delete_prefix(root) },
+                      added: added.map { _1.delete_prefix(root) },
+                      removed: removed.map { _1.delete_prefix(root) }
+                    )
+                    .then { queue.enq(_1) }
+                end,
+              Listen::Listener
+            )
+
+          listener.start
+
+          Console.logger.info("Watching directories for changes:", *paths)
+
+          task.async do
+            loop { block.call(queue.deq) }
+          ensure
+            listener.stop
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mayu/resources/hot_swap.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+# typed: strict
+
+require_relative "hot_swap/file_watcher"
+require_relative "registry"
+
+module Mayu
+  module Resources
+    module HotSwap
+      extend T::Sig
+
+      sig do
+        params(registry: Registry, block: T.proc.void).returns(Async::Task)
+      end
+      def self.start(registry, &block)
+        FileWatcher.watch(registry.root, ["app"]) do |event|
+          Console.logger.info(self, "\e[33mSwapping code\e[0m")
+          start_at = Time.now.to_f
+
+          visited = T::Set[String].new
+
+          event.modified.each do |path|
+            registry.reload_resource(path, visited:)
+          end
+
+          event.added.each do |path|
+            registry.reload_resource(
+              path,
+              visited:,
+              add: path.start_with?("/app/pages/")
+            )
+          end
+
+          event.removed.each { |path| registry.unload_resource(path, visited:) }
+
+          Console.logger.info(
+            self,
+            format("\e[33mSwapped code in %.3fs\e[0m", Time.now.to_f - start_at)
+          )
+
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/mayu/resources/mermaid_exporter.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+# typed: strict
+
+require "base64"
+require "zlib"
+require_relative "dependency_graph"
+
+module Mayu
+  module Resources
+    class MermaidExporter
+      extend T::Sig
+
+      GRAPH_DIRECTION = "LR" # Left to right
+
+      sig { params(graph: DependencyGraph).void }
+      def initialize(graph)
+        @graph = graph
+      end
+
+      sig { returns(String) }
+      def to_url
+        data = {
+          code: to_source,
+          mermaid: JSON.generate({ theme: "dark" }),
+          updateEditor: false,
+          autoSync: false,
+          updateDiagram: false,
+          editorMode: "code"
+        }
+
+        pako =
+          data
+            .then { JSON.generate(_1) }
+            .then { Zlib.deflate(_1) }
+            .then { Base64.urlsafe_encode64(_1) }
+
+        "https://mermaid.live/view#pako:#{pako}"
+      end
+
+      sig { returns(String) }
+      def to_source
+        StringIO.new.tap { write_source(_1) }.tap(&:rewind).read.to_s
+      end
+
+      sig { params(out: StringIO).returns(StringIO) }
+      def write_source(out)
+        entries =
+          @graph
+            .overall_order(only_leaves: false)
+            .filter { @graph.get_resource(_1)&.exists? }
+
+        tree = make_tree(entries.map { _1.split("/") })
+        out.puts "graph #{GRAPH_DIRECTION}"
+
+        out.puts "  subgraph routes"
+        print_routes(out, tree.dig("", "app", "pages") || {})
+        out.puts "  end"
+
+        print_route_edges(out, tree.dig("", "app", "pages") || {})
+
+        print_subgraphs(out, tree)
+
+        entries.each do |entry|
+          @graph
+            .direct_dependencies_of(entry)
+            .filter { @graph.get_resource(_1)&.exists? }
+            .each { |dep| out.puts "  #{encode(entry)}-->#{encode(dep)}" }
+        rescue StandardError
+          next
+        end
+
+        entries.each do |entry|
+          unless @graph.get_resource(entry)&.exists?
+            out.puts "  class #{encode(entry)} NonExistant"
+          end
+
+          filetype_class(entry)&.tap do
+            out.puts "  class #{encode(entry)} #{_1}"
+          end
+        end
+
+        out.puts <<~EOF.gsub(/^/, "  ")
+        style routes stroke:#09c,stroke-width:5,fill:#f0f;
+        classDef cluster fill:#0003;
+        classDef Ruby fill:#600,stroke:#900,stroke-width:3px;
+        classDef Image fill:#069,stroke:#09c,stroke-width:3px;
+        classDef CSS fill:#063,stroke:#096,stroke-width:3px;
+        classDef NonExistant opacity:50%,stroke-dasharray:5px;
+        linkStyle default fill:transparent,opacity:50%;
+      EOF
+
+        out
+      end
+
+      private
+
+      sig { params(path: String).returns(T.nilable(String)) }
+      def filetype_class(path)
+        case File.extname(path)
+        when ".rb"
+          "Ruby"
+        when ".css"
+          "CSS"
+        when ".png"
+          "Image"
+        end
+      end
+
+      sig { params(str: String).returns(String) }
+      def encode(str)
+        str.gsub("/", "__").gsub("[", "__").gsub("]", "__")
+      end
+
+      sig { params(str: String).returns(String) }
+      def escape(str)
+        str.gsub(/\W/) { |ch| ch.codepoints.map { |cp| "##{cp};" }.join }
+      end
+
+      sig { params(str: String).returns(String) }
+      def display_name(str)
+        case File.extname(str)
+        when ".rb"
+          "fa:fa-gem #{str}&nbsp;"
+        when ".css"
+          "fab:fa-css3 #{str}&nbsp;"
+        when ".png"
+          "fa:fa-image #{str}&nbsp;"
+        else
+          str
+        end
+      end
+
+      sig do
+        params(out: StringIO, node: T.untyped, path: T::Array[String]).void
+      end
+      def print_routes(out, node, path = [])
+        node.each do |key, value|
+          path2 = path + [key]
+
+          if value.is_a?(String)
+            if key == "page.rb" || key == "page.haml"
+              pathstr = path.flatten.join("/").sub(%r{\A/?}, "/")
+              out.puts "    ROUTE__#{encode(value)}[#{pathstr.inspect}]"
+            end
+          else
+            print_routes(out, value, path2)
+          end
+        end
+      end
+
+      sig do
+        params(out: StringIO, node: T.untyped, path: T::Array[String]).void
+      end
+      def print_route_edges(out, node, path = [])
+        node.each do |key, value|
+          path2 = path + [key]
+
+          if value.is_a?(String)
+            if key == "page.rb" || key == "page.haml"
+              pathstr = path.flatten.join("/").sub(%r{\A/?}, "/")
+              out.puts "  ROUTE__#{encode(value)}-->#{encode(value)}"
+            end
+          else
+            print_route_edges(out, value, path2)
+          end
+        end
+      end
+
+      sig do
+        params(out: StringIO, node: T.untyped, path: T::Array[String]).void
+      end
+      def print_subgraphs(out, node, path = [])
+        level = path.length
+        indent = "  " * level.succ
+
+        node.each do |key, value|
+          path2 = path + [key]
+
+          if value.is_a?(String)
+            out.puts "#{indent}#{encode(value)}[#{display_name(key).inspect}]"
+          else
+            pathstr = path2.flatten.join("/").sub(%r{\A/?}, "/")
+            out.puts "#{indent}subgraph PATH#{encode(pathstr)}[#{pathstr.inspect}]"
+            print_subgraphs(out, value, path2)
+            out.puts "#{indent}end"
+          end
+        end
+      end
+
+      sig do
+        params(entries: T::Array[T::Array[String]], level: Integer).returns(
+          T.untyped
+        )
+      end
+      def make_tree(entries, level = 0)
+        entries
+          .group_by { _1[level] }
+          .transform_values do |paths|
+            paths
+              .partition { _1.length.pred <= level.succ }
+              .then do |leaves, branches|
+                leaves.each_with_object(
+                  make_tree(branches, level + 1)
+                ) { |leaf, obj| obj[leaf.last] = leaf.join("/") }
+              end
+          end
+      end
+    end
+  end
+end

data/lib/mayu/resources/registry.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+# typed: strict
+
+require "sorbet-runtime"
+require "msgpack"
+require_relative "resolver"
+require_relative "dependency_graph"
+require_relative "resource"
+require_relative "types"
+require_relative "assets"
+
+MessagePack::DefaultFactory.register_type(0x00, Symbol)
+
+module Mayu
+  module Resources
+    class Registry
+      EXTENSIONS = T.let(["", ".rb", ".haml"].freeze, T::Array[String])
+
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :root
+      sig { returns(DependencyGraph) }
+      attr_reader :dependency_graph
+
+      sig { params(root: String).void }
+      def initialize(root:)
+        @root = T.let(File.expand_path(root), String)
+        @dependency_graph = T.let(DependencyGraph.new, DependencyGraph)
+        @resolver =
+          T.let(
+            Resolver::Filesystem.new(@root, extensions: EXTENSIONS),
+            Resolver::Base
+          )
+        @assets = T.let(Assets.new, T.nilable(Assets))
+      end
+
+      sig { params(dumped: String, root: String).returns(Registry) }
+      def self.load(dumped, root:)
+        MessagePack.unpack(dumped) => { type: "registry", data: String => data }
+        registry =
+          T.cast(
+            Marshal.load(
+              data,
+              ->(obj) do
+                obj.instance_variable_set(:@root, root) if obj.is_a?(Registry)
+                obj
+              end
+            ),
+            Registry
+          )
+
+        registry
+      end
+
+      sig { returns(String) }
+      def dump
+        MessagePack.pack(type: "registry", data: Marshal.dump(self))
+      end
+
+      MarshalFormat = T.type_alias { [String, T::Hash[String, String]] }
+
+      sig { returns(MarshalFormat) }
+      def marshal_dump
+        [Marshal.dump(@dependency_graph), @resolver.resolved_paths]
+      end
+
+      sig { params(args: MarshalFormat).void }
+      def marshal_load(args)
+        dependency_graph =
+          T.cast(
+            Marshal.load(
+              args[0],
+              ->(obj) do
+                if obj.is_a?(Resource)
+                  obj.instance_variable_set(:@registry, self)
+                end
+                obj
+              end
+            ),
+            DependencyGraph
+          )
+
+        @dependency_graph = dependency_graph
+        @resolver = Resolver::Static.new(args[1])
+      end
+
+      sig { params(path: String).returns(String) }
+      def absolute_path(path)
+        File.join(@root, File.expand_path(path, "/"))
+      end
+
+      sig { returns(String) }
+      def mermaid_url
+        @dependency_graph.to_mermaid_url
+      end
+
+      sig { params(filename: String, timeout: Integer, task: Async::Task).void }
+      def wait_for_asset(filename, timeout: 2, task: Async::Task.current)
+        return unless @assets
+
+        task.with_timeout(timeout) { @assets.wait_for(filename) }
+      end
+
+      sig do
+        params(
+          asset_dir: String,
+          concurrency: Integer,
+          forever: T::Boolean
+        ).returns(Async::Task)
+      end
+      def generate_assets(asset_dir, concurrency:, forever:)
+        if @assets
+          @assets.run(asset_dir, concurrency:, forever:)
+        else
+          raise "Assets can't be generated in production"
+        end
+      end
+
+      sig do
+        params(path: String, visited: T::Set[String], add: T::Boolean).void
+      end
+      def reload_resource(path, visited: T::Set[String].new, add: false)
+        unless @dependency_graph.has_node?(path)
+          add_resource(path) if add
+          return
+        end
+
+        reload_resources(
+          [path, *@dependency_graph.dependants_of(path)],
+          visited:
+        )
+      end
+
+      sig { params(path: String, visited: T::Set[String]).void }
+      def unload_resource(path, visited: T::Set[String].new)
+        return unless @dependency_graph.has_node?(path)
+
+        dependants = @dependency_graph.dependants_of(path)
+
+        Console.logger.info(self, "Unloading resource, #{path}")
+
+        @dependency_graph.delete_node(path)
+
+        reload_resources(dependants, visited:)
+      end
+
+      sig { params(path: String, source: String).returns(Resource) }
+      def load_resource(path, source = "/")
+        resolved_path = @resolver.resolve(path, source)
+        add_resource(resolved_path)
+      end
+
+      sig { params(path: String).returns(Resource) }
+      def add_resource(path)
+        if resource = @dependency_graph.get_resource(path)
+          return resource
+        end
+
+        resource = Resource.new(registry: self, path:)
+
+        @dependency_graph.add_node(resource.path, resource)
+
+        resource.assets.each { |asset| @assets.add(asset) } if @assets
+
+        Console.logger.info(
+          self,
+          "Loaded #{resource.type.name} from #{resource.path}"
+        )
+        resource
+      end
+
+      private
+
+      sig { params(paths: T::Enumerable[String], visited: T::Set[String]).void }
+      def reload_resources(paths, visited:)
+        paths
+          .select { visited.add?(_1) }
+          .map { @dependency_graph.get_resource(_1) }
+          .compact
+          .each do |resource|
+            Console.logger.info(self, "Reloading resource: #{resource.path}")
+            @dependency_graph.delete_connections(resource.path)
+            resource.load_type
+            resource.assets.each { |asset| @assets.add(asset) } if @assets
+          end
+      end
+    end
+  end
+end