mayu-live 0.0.0

data/lib/mayu/ref_counter.rb

@@ -0,0 +1,57 @@
+# typed: strict
+
+module Mayu
+  class RefCounter
+    extend T::Sig
+    extend T::Generic
+
+    Elem = type_member
+
+    sig { void }
+    def initialize
+      @refs = T.let(Hash.new { |h, k| h[k] = 0 }, T::Hash[Elem, Integer])
+    end
+
+    sig { params(key: Elem).returns(Integer) }
+    def count(key)
+      @refs.fetch(key, 0)
+    end
+
+    sig { returns(T::Array[Elem]) }
+    def keys
+      @refs.sort_by { _2 }.map(&:first)
+    end
+
+    sig { params(key: Elem).void }
+    def acquire!(key)
+      @refs[key] = @refs[key].to_i + 1
+    end
+
+    sig do
+      type_parameters(:R)
+        .params(key: Elem, block: T.proc.returns(T.type_parameter(:R)))
+        .returns(T.type_parameter(:R))
+    end
+    def acquire(key, &block)
+      acquire!(key)
+
+      begin
+        yield
+      ensure
+        release(key)
+      end
+    end
+
+    sig { params(key: Elem).void }
+    def release(key)
+      count = @refs.fetch(key, nil)
+      return unless count
+
+      if count > 1
+        @refs[key] = count - 1
+      else
+        @refs.delete(key)
+      end
+    end
+  end
+end

data/lib/mayu/resources/README.md

@@ -0,0 +1,14 @@
+# Mayu::Resources
+
+This module contains classes for loading resources.
+
+A resource is any type of file that can be used in an app,
+usually a component, stylesheet or image.
+
+In development mode, it is possible to watch some directories
+for changes and reload resources dynamically as they are updated.
+
+For production, all the resources will be serialized using
+[Marshal](https://docs.ruby-lang.org/en/master/Marshal.html),
+and static fileswill be generated during build time, and then
+loaded in runtime.

data/lib/mayu/resources/asset.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+# typed: strict
+
+require_relative "generators/image"
+require_relative "generators/copy_file"
+require_relative "generators/write_file"
+
+module Mayu
+  module Resources
+    class Asset
+      extend T::Sig
+
+      class Status < T::Enum
+        enums do
+          Pending = new
+          Processing = new
+          Done = new
+          Failed = new
+        end
+      end
+
+      sig { returns(String) }
+      attr_reader :filename
+      sig { returns(Status) }
+      attr_reader :status
+      sig { returns(Generators::Base) }
+      attr_reader :generator
+
+      sig { params(filename: String, generator: Generators::Base).void }
+      def initialize(filename, generator)
+        @filename = filename
+        @generator = generator
+        @status = T.let(Status::Pending, Status)
+      end
+
+      sig { returns(T::Boolean) }
+      def pending? = @status == Status::Pending
+      sig { returns(T::Boolean) }
+      def processing? = @status == Status::Processing
+      sig { returns(T::Boolean) }
+      def done? = @status == Status::Done
+      sig { returns(T::Boolean) }
+      def failed? = @status == Status::Failed
+
+      sig { params(asset_dir: String).returns(T::Boolean) }
+      def process(asset_dir)
+        return false unless pending?
+        @status = Status::Processing
+        @generator.process(File.join(asset_dir, filename))
+      rescue StandardError
+        @status = Status::Failed
+        raise
+      else
+        @status = Status::Done
+        true
+      end
+
+      MarshalFormat = T.type_alias { [String] }
+
+      sig { returns(MarshalFormat) }
+      def marshal_dump
+        [@filename]
+      end
+
+      sig { params(args: MarshalFormat).void }
+      def marshal_load(args)
+        @filename = args.first
+      end
+    end
+  end
+end

data/lib/mayu/resources/assets.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+# typed: strict
+
+require "async/variable"
+require "async/queue"
+require "async/semaphore"
+
+module Mayu
+  module Resources
+    class Assets
+      extend T::Sig
+
+      sig { void }
+      def initialize
+        @queue = T.let(Async::Queue.new, Async::Queue)
+        @results = T.let({}, T::Hash[String, Async::Variable])
+        @assets = T.let({}, T::Hash[String, Asset])
+      end
+
+      sig { params(filename: String).void }
+      def wait_for(filename)
+        (@results[filename] ||= Async::Variable.new).wait
+      end
+
+      sig { params(asset: Asset).void }
+      def add(asset)
+        @assets[asset.filename] ||= asset
+        @queue.enqueue(asset)
+      end
+
+      sig do
+        params(
+          asset_dir: String,
+          concurrency: Integer,
+          forever: T::Boolean,
+          task: Async::Task
+        ).returns(Async::Task)
+      end
+      def run(
+        asset_dir,
+        concurrency:,
+        forever: false,
+        task: Async::Task.current
+      )
+        task.async do
+          semaphore = Async::Semaphore.new(concurrency)
+
+          while forever || !@queue.empty?
+            process(@queue.dequeue, asset_dir, semaphore)
+          end
+        end
+      end
+
+      private
+
+      sig do
+        params(
+          asset: Asset,
+          asset_dir: String,
+          semaphore: Async::Semaphore
+        ).void
+      end
+      def process(asset, asset_dir, semaphore)
+        semaphore.async do
+          if asset.process(asset_dir)
+            var = (@results[asset.filename] ||= Async::Variable.new)
+            var.resolve unless var.resolved?
+          end
+        rescue => e
+          Console.logger.error(self, e)
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/mayu/resources/dependency_graph.rb

@@ -0,0 +1,306 @@
+# frozen_string_literal: true
+# typed: strict
+
+require "tsort"
+require "set"
+require "cgi"
+require_relative "mermaid_exporter"
+require_relative "dot_exporter"
+
+module Mayu
+  module Resources
+    class DependencyGraph
+      extend T::Sig
+      # This is basically a reimplementation of this library:
+      # https://github.com/jriecken/dependency-graph
+
+      class Direction < T::Enum
+        enums do
+          Incoming = new(:incoming)
+          Outgoing = new(:outgoing)
+        end
+      end
+
+      class Node
+        extend T::Sig
+
+        sig { returns(Resource) }
+        attr_reader :resource
+        sig { returns(T::Set[String]) }
+        attr_reader :incoming
+        sig { returns(T::Set[String]) }
+        attr_reader :outgoing
+
+        sig { params(resource: Resource).void }
+        def initialize(resource)
+          @resource = resource
+          @incoming = T.let(Set.new, T::Set[String])
+          @outgoing = T.let(Set.new, T::Set[String])
+        end
+
+        sig { params(id: String).void }
+        def delete(id)
+          @incoming.delete(id)
+          @outgoing.delete(id)
+        end
+
+        MarshalFormat =
+          T.type_alias { [Resource, T::Set[String], T::Set[String]] }
+
+        sig { returns(MarshalFormat) }
+        def marshal_dump
+          [@resource, @incoming, @outgoing]
+        end
+
+        sig { params(dumped: MarshalFormat).void }
+        def marshal_load(dumped)
+          @resource, @incoming, @outgoing = dumped
+        end
+      end
+
+      sig { void }
+      def initialize
+        @nodes = T.let({}, T::Hash[String, Node])
+      end
+
+      sig { returns(Integer) }
+      def size = @nodes.size
+
+      sig { params(id: String).returns(T::Boolean) }
+      def include?(id) = @nodes.include?(id)
+
+      sig { params(id: String, resource: Resource).returns(Resource) }
+      def add_node(id, resource)
+        (@nodes[id] ||= Node.new(resource)).resource
+      end
+
+      sig { params(id: String).void }
+      def delete_node(id)
+        return unless @nodes.include?(id)
+        @nodes.delete(id)
+        delete_connections(id)
+      end
+
+      sig { params(id: String).void }
+      def delete_connections(id)
+        @nodes.each { |node| node.delete(id) }
+      end
+
+      sig { params(id: String).returns(T.nilable(Resource)) }
+      def get_resource(id)
+        @nodes[id]&.resource
+      end
+
+      sig { params(id: String).returns(T::Boolean) }
+      def has_node?(id)
+        @nodes.include?(id)
+      end
+
+      sig { params(source_id: String, target_id: String).void }
+      def add_dependency(source_id, target_id)
+        with_source_and_target(source_id, target_id) do |source, target|
+          source.outgoing.add(target_id)
+          target.incoming.add(source_id)
+        end
+      end
+
+      sig { params(source_id: String, target_id: String).void }
+      def remove_dependency(source_id, target_id)
+        with_source_and_target(source_id, target_id) do |source, target|
+          source.outgoing.delete(target_id)
+          source.incoming.delete(source_id)
+        end
+      end
+
+      sig { params(id: String).returns(T::Array[String]) }
+      def direct_dependencies_of(id)
+        @nodes.fetch(id).outgoing.to_a
+      end
+
+      sig { params(id: String).returns(T::Array[String]) }
+      def direct_dependants_of(id)
+        @nodes.fetch(id).incoming.to_a
+      end
+
+      sig do
+        params(
+          id: String,
+          started_at: T.nilable(String),
+          only_leaves: T::Boolean,
+          block: T.nilable(T.proc.params(arg0: String).returns(T::Boolean))
+        ).returns(T::Set[String])
+      end
+      def dependencies_of(id, started_at = nil, only_leaves: false, &block)
+        raise "Circular" if id == started_at
+
+        @nodes
+          .fetch(id)
+          .outgoing
+          .map do |dependency|
+            next nil unless yield dependency if block_given?
+
+            dependencies = dependencies_of(dependency, started_at || id)
+
+            if !only_leaves || dependencies.empty?
+              dependencies.add(dependency)
+            else
+              dependencies
+            end
+          end
+          .compact
+          .reduce(Set.new, &:merge)
+      end
+
+      sig do
+        params(
+          id: String,
+          started_at: T.nilable(String),
+          only_leaves: T::Boolean
+        ).returns(T::Set[String])
+      end
+      def dependants_of(id, started_at = nil, only_leaves: false)
+        raise "Circular" if id == started_at
+
+        @nodes
+          .fetch(id)
+          .incoming
+          .map do |dependant|
+            dependants = dependants_of(dependant, started_at || id)
+            if !only_leaves || dependants.empty?
+              dependants.add(dependant)
+            else
+              dependants
+            end
+          end
+          .reduce(Set.new, &:merge)
+      end
+
+      sig { returns(T::Array[String]) }
+      def entry_nodes
+        @nodes.filter { _2.incoming.empty? }.keys
+      end
+
+      sig { params(only_leaves: T::Boolean).returns(T::Array[String]) }
+      def overall_order(only_leaves: true)
+        TSort.tsort(
+          ->(&b) { @nodes.keys.each(&b) },
+          ->(key, &b) { @nodes[key]&.outgoing&.each(&b) }
+        )
+      end
+
+      sig { returns(String) }
+      def to_dot
+        DotExporter.new(self).to_source
+      end
+
+      sig { returns(String) }
+      def to_mermaid_source
+        MermaidExporter.new(self).to_source
+      end
+
+      sig { returns(String) }
+      def to_mermaid_url
+        MermaidExporter.new(self).to_url
+      end
+
+      sig { returns(T::Array[String]) }
+      def paths
+        @nodes.keys
+      end
+
+      sig { params(block: T.proc.params(arg0: Resource).void).void }
+      def each_resource(&block)
+        @nodes.each_value { |node| yield node.resource }
+      end
+
+      MarshalFormat = T.type_alias { T::Hash[String, Node] }
+
+      sig { returns(MarshalFormat) }
+      def marshal_dump
+        @nodes
+      end
+
+      sig { params(nodes: MarshalFormat).void }
+      def marshal_load(nodes)
+        @nodes = nodes
+      end
+
+      sig do
+        params(
+          id: String,
+          direction: Direction,
+          visited: T::Set[String],
+          block: T.proc.params(arg0: String).void
+        ).void
+      end
+      def dfs2(id, direction, visited: T::Set[String].new, &block)
+        if visited.include?(id)
+          return
+        else
+          visited.add(id)
+        end
+
+        @nodes
+          .fetch(id)
+          .send(direction.serialize)
+          .each { dfs2(_1, direction, visited:, &block) }
+
+        yield id
+      end
+
+      private
+
+      sig do
+        params(
+          source_id: String,
+          target_id: String,
+          block: T.proc.params(arg0: Node, arg1: Node).void
+        ).void
+      end
+      def with_source_and_target(source_id, target_id, &block)
+        yield(fetch_node(:source, source_id), fetch_node(:target, target_id))
+      end
+
+      sig { params(type: Symbol, id: String).returns(Node) }
+      def fetch_node(type, id)
+        @nodes.fetch(id) do
+          raise ArgumentError,
+                "Could not find #{type} #{id.inspect} in #{@nodes.keys.inspect}"
+        end
+      end
+
+      sig do
+        params(
+          node: Node,
+          direction: Direction,
+          block: T.proc.params(arg0: Node).void
+        ).void
+      end
+      def dfs(node, direction, &block)
+        node
+          .send(direction.serialize)
+          .each { |id| dfs(@nodes.fetch(id), direction, &block) }
+
+        yield node
+      end
+    end
+  end
+end
+
+# if __FILE__ == $0
+#   graph = Resources::DependencyGraph.new
+#
+#   graph.add_node("a")
+#   graph.add_node("b")
+#   graph.add_node("c")
+#
+#   p graph.size
+#
+#   graph.add_dependency("a", "b")
+#   graph.add_dependency("b", "c")
+#   p graph.dependencies_of("a")
+#   p graph.dependencies_of("b")
+#   p graph.dependants_of("c")
+#   p graph.overall_order
+#   p graph.overall_order(only_leaves: true)
+# end

data/lib/mayu/resources/dot_exporter.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+# typed: strict
+
+require "base64"
+require "zlib"
+require_relative "dependency_graph"
+
+module Mayu
+  module Resources
+    class DotExporter
+      extend T::Sig
+
+      sig { params(graph: DependencyGraph).void }
+      def initialize(graph)
+        @graph = graph
+      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)
+        tree = make_tree(entries.map { _1.split("/") })
+
+        out.puts <<~EOF
+        strict digraph "dependency-cruiser output" {
+            ordering="out" rankdir="LR" splines="ortho" overlap="false" nodesep="0.16" ranksep="0.5" fontname="Helvetica-bold" fontsize="9" style="rounded,bold,filled" fillcolor="#ffffff" compound="true"
+            node [shape="box" style="rounded, filled" height="0.2" color="black" fillcolor="#ffffcc" fontcolor="black" fontname="Helvetica" fontsize="9"]
+            edge [arrowhead="normal" arrowsize="0.6" penwidth="2.0" color="#00000033" fontname="Helvetica" fontsize="9"]
+
+      EOF
+
+        entries.each do |entry|
+          fillcolor = "#bbfeff"
+          out.puts "    #{entry.inspect} [label=<#{File.dirname(entry)}<BR/><B>#{File.basename(entry)}</B>> tooltip=#{File.basename(entry).inspect} fillcolor=#{fillcolor.inspect}]"
+
+          @graph
+            .direct_dependencies_of(entry)
+            .each do |dep|
+              color = "#e5009b99"
+              out.puts "    #{entry.inspect} -> #{dep.inspect} [color=#{color.inspect}]"
+            end
+        end
+
+        out.puts "}"
+        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"
+              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"
+              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/generators/base.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+# typed: strict
+
+module Mayu
+  module Resources
+    module Generators
+      class Base
+        extend T::Sig
+        extend T::Helpers
+        abstract!
+
+        sig { abstract.params(target_path: String).void }
+        def process(target_path)
+        end
+      end
+    end
+  end
+end