mayu-live 0.0.0

data/lib/mayu/resources/types/stylesheet.rb

@@ -0,0 +1,119 @@
+# typed: strict
+
+require "brotli"
+require_relative "../transformers/css"
+
+module Mayu
+  module Resources
+    module Types
+      class Stylesheet < Base
+        Classes = T.type_alias { T::Hash[Symbol, String] }
+
+        class ClassNames
+          extend T::Sig
+
+          sig { params(classes: Classes).void }
+          def initialize(classes)
+            @classes = classes
+          end
+
+          sig { params(ident: Symbol).returns(String) }
+          def method_missing(ident)
+            @classes[ident].to_s
+          end
+
+          sig { params(args: T.untyped).returns(String) }
+          def [](*args)
+            args
+              .each_with_object(Set.new) { |arg, set| add_to_result(set, arg) }
+              .join(" ")
+          end
+
+          private
+
+          sig { params(result: T::Set[String], arg: T.untyped).void }
+          def add_to_result(result, arg)
+            case arg
+            when Symbol
+              if klass = @classes[arg]
+                result.add(klass)
+              end
+            when String
+              result.add(arg)
+            when Array
+              arg.each { add_to_result(result, _1) }
+            when Hash
+              arg.each { add_to_result(result, _1) if _2 }
+            end
+          end
+        end
+
+        extend T::Sig
+
+        sig { returns(Classes) }
+        attr_reader :classes
+
+        sig { params(resource: Resource).void }
+        def initialize(resource)
+          super
+          klasses = {}
+
+          transform_result =
+            Transformers::CSS.transform(
+              source: resource.read(encoding: "utf-8"),
+              source_path: resource.path
+            )
+
+          transform_result.classes
+
+          @source = T.let(transform_result.output, String)
+          @content_hash = T.let(transform_result.content_hash, String)
+          @classes = T.let(transform_result.classes, Classes)
+          @filename = T.let(transform_result.filename, String)
+          @source_map =
+            T.let(transform_result.source_map, T::Hash[String, T.untyped])
+          @classnames = T.let(nil, T.nilable(ClassNames))
+        end
+
+        sig { returns(ClassNames) }
+        def classnames
+          @classnames ||= ClassNames.new(self.classes)
+        end
+
+        sig { returns(T::Array[Asset]) }
+        def assets
+          source_map_link = "\n/*# sourceMappingURL=#{@filename}.map */\n"
+
+          [
+            Asset.new(
+              @filename,
+              Generators::WriteFile.new(
+                contents: @source + source_map_link,
+                compress: true
+              )
+            ),
+            Asset.new(
+              @filename + ".map",
+              Generators::WriteFile.new(
+                contents: JSON.generate(@source_map),
+                compress: true
+              )
+            )
+          ]
+        end
+
+        MarshalFormat = T.type_alias { [Classes, String, String, String] }
+
+        sig { returns(MarshalFormat) }
+        def marshal_dump
+          [@classes, @source, @content_hash, @filename]
+        end
+
+        sig { params(args: MarshalFormat).void }
+        def marshal_load(args)
+          @classes, @source, @content_hash, @filename = args
+        end
+      end
+    end
+  end
+end

data/lib/mayu/resources/types/svg.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+# typed: strict
+
+require "svg_optimizer"
+require_relative "base"
+
+module Mayu
+  module Resources
+    module Types
+      class SVG < Base
+        extend T::Sig
+
+        SVG_OPTIMIZER_PLUGINS =
+          T.let(
+            SvgOptimizer::DEFAULT_PLUGINS -
+              [
+                # The following plugin sets fill="none" in some cases
+                # which breaks the fontawesome icons... That's why
+                # it's disabled...
+                SvgOptimizer::Plugins::RemoveUselessStrokeAndFill
+              ],
+            T::Array[T.class_of(SvgOptimizer::Plugins::Base)]
+          )
+
+        sig { params(resource: Resource).void }
+        def initialize(resource)
+          @resource = resource
+
+          original = resource.read(encoding: "utf-8")
+          optimized = SvgOptimizer.optimize(original, SVG_OPTIMIZER_PLUGINS)
+
+          content_hash =
+            Base64.urlsafe_encode64(Digest::SHA256.digest(optimized))
+
+          @filename = T.let("#{content_hash}.svg", String)
+          @source = T.let("#{optimized}\n", String)
+        end
+
+        sig { returns(T::Array[Asset]) }
+        def assets
+          [
+            Asset.new(
+              @filename,
+              Generators::WriteFile.new(contents: @source, compress: true)
+            )
+          ]
+        end
+
+        sig { returns(String) }
+        def to_s = src
+
+        sig { returns(String) }
+        def src = "/__mayu/static/#{@filename}"
+
+        MarshalFormat = T.type_alias { [String, String] }
+
+        sig { returns(MarshalFormat) }
+        def marshal_dump
+          [@source, @filename]
+        end
+
+        sig { params(args: MarshalFormat).void }
+        def marshal_load(args)
+          @source, @filename = args
+        end
+      end
+    end
+  end
+end

data/lib/mayu/resources/types.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+# typed: strict
+
+require_relative "types/nil"
+require_relative "types/component"
+require_relative "types/image"
+require_relative "types/stylesheet"
+require_relative "types/javascript"
+require_relative "types/svg"
+
+module Mayu
+  module Resources
+    module Types
+      extend T::Sig
+
+      sig { params(path: String).returns(T.class_of(Types::Base)) }
+      def self.for_path(path)
+        case path
+        when /\.rb\z/
+          return Component
+        when /\.haml\z/
+          return Component
+        when /\.js\z/
+          return JavaScript
+        when /\.css\z/
+          return Stylesheet
+        when /\.(png|jpe?g|gif|webp)$\z/
+          return Image
+        when /\.svg\z/
+          return SVG
+        end
+
+        raise "No type for #{path}"
+      end
+    end
+  end
+end

data/lib/mayu/routes.rb

@@ -0,0 +1,170 @@
+# typed: strict
+
+require "terminal-table"
+
+module Mayu
+  module Routes
+    extend T::Sig
+
+    class NotFoundError < StandardError
+    end
+
+    class Route < T::Struct
+      const :path, String
+      const :regexp, Regexp
+      const :layouts, T::Array[String]
+      const :template, String
+    end
+
+    class RouteMatch < T::Struct
+      const :params, T::Hash[Symbol, String]
+      const :layouts, T::Array[String]
+      const :template, String
+    end
+
+    EXTENSIONS = T.let(%w[.rb .haml].freeze, T::Array[String])
+
+    PAGE_FILENAME = "page"
+    LAYOUT_FILENAME = "layout"
+    NOT_FOUND_FILENAME = "404"
+
+    sig do
+      params(
+        root: String,
+        routes: T::Array[Route],
+        layouts: T::Array[String],
+        path: T::Array[String],
+        level: Integer
+      ).returns(T::Array[Route])
+    end
+    def self.build_routes(root, routes: [], layouts: [], path: [], level: 0)
+      dir = T.unsafe(File).join(root, *path)
+      return routes unless File.directory?(dir)
+
+      entries = Dir.entries(dir) - %w[. ..]
+
+      if layout = find_and_delete(entries, LAYOUT_FILENAME)
+        layouts += [T.unsafe(File).join(*path, layout)]
+      end
+
+      if page = find_and_delete(entries, PAGE_FILENAME)
+        routes.push(
+          Route.new(
+            path: path.join("/"),
+            regexp: path_to_regexp(path.join("/")),
+            layouts:,
+            template: T.unsafe(File).join(*path, page)
+          )
+        )
+      end
+
+      entries.each do |entry|
+        build_routes(
+          File.join(root),
+          routes:,
+          layouts:,
+          path: path + [entry],
+          level: level.succ
+        )
+      end
+
+      if not_found = find_and_delete(entries, NOT_FOUND_FILENAME)
+        routes.push(
+          Route.new(
+            path: path.join("/"),
+            regexp: path_to_regexp([*path, "*"].join("/")),
+            layouts:,
+            template: T.unsafe(File).join(*path, not_found)
+          )
+        )
+      else
+        Console.logger.warn(self) { <<~EOF } if level.zero?
+            There is no #{NOT_FOUND_FILENAME} in the app root,
+            you should probably create one.
+            EOF
+      end
+
+      routes
+    end
+
+    sig { params(routes: T::Array[Route]).void }
+    def self.log_routes(routes)
+      Console
+        .logger
+        .info(self) do
+          Terminal::Table.new do |t|
+            t.headings =
+              %w[Path Template Layouts Regexp].map { "\e[1m#{_1}\e[0m" }
+            t.style = { all_separators: true, border: :unicode }
+
+            routes.each do |route|
+              t.add_row(
+                [
+                  "/#{route.path}",
+                  route.template,
+                  route.layouts.join("\n"),
+                  "/#{route.regexp.to_s}/"
+                ]
+              )
+            end
+          end
+        end
+    end
+
+    sig do
+      params(routes: T::Array[Route], request_path: String).returns(RouteMatch)
+    end
+    def self.match_route(routes, request_path)
+      routes.each do |route|
+        match = route.regexp.match(request_path)
+
+        next unless match
+
+        return(
+          RouteMatch.new(
+            template: route.template,
+            layouts: route.layouts,
+            params:
+              match
+                .named_captures
+                .transform_keys(&:to_sym)
+                .transform_values(&:to_s)
+          )
+        )
+      end
+
+      raise NotFoundError,
+            "Page not found, and no 404 page either. You should probably create one."
+    end
+
+    sig do
+      params(path: String, formats: T::Hash[Symbol, Regexp]).returns(Regexp)
+    end
+    def self.path_to_regexp(path, formats: {})
+      parts =
+        path
+          .delete_prefix("/")
+          .split("/")
+          .map do |part|
+            case part
+            when "*"
+              ".+"
+            when /\A:(?<var>\w+)\Z/
+              var = Regexp.escape($~[:var])
+              "(?<#{var}>[^/]+)"
+            else
+              Regexp.escape(part).to_s
+            end
+          end
+
+      Regexp.new('\A\/' + parts.join('\/') + '\Z')
+    end
+
+    sig { params(a: T::Array[String], name: String).returns(T.nilable(String)) }
+    def self.find_and_delete(a, name)
+      EXTENSIONS.find do |extension|
+        a.delete("#{name}#{extension}")&.tap { return _1 }
+      end
+    end
+  end
+end

data/lib/mayu/routing/builder.rb

@@ -0,0 +1,108 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Mayu
+  module Routing
+    class Builder
+      extend T::Sig
+
+      IGNORE = T.let(%w[. ..].freeze, T::Array[String])
+      EXTENSIONS = T.let(%w[.rb .haml].freeze, T::Array[String])
+
+      sig { params(root: String).returns(Routes::Route) }
+      def self.build(root)
+        new(root).build
+      end
+
+      sig { params(root: String).void }
+      def initialize(root)
+        @root = T.let(File.expand_path(root), String)
+      end
+
+      sig { returns(Routes::Route) }
+      def build
+        traverse_directory(Routes::Route.new, path: [])
+      end
+
+      private
+
+      sig do
+        params(route: Routes::Route, path: T::Array[String]).returns(
+          Routes::Route
+        )
+      end
+      def visit(route, path: [])
+        absolute_path = File.join(@root, path)
+        basename = File.basename(absolute_path)
+        stat = File.stat(absolute_path)
+
+        case
+        when stat.directory?
+          visit_dir(route, path:)
+        when stat.file?
+          visit_file(route, path:)
+        end
+
+        route
+      end
+
+      sig do
+        params(route: Routes::Route, path: T::Array[String]).returns(
+          Routes::Route
+        )
+      end
+      def visit_dir(route, path: [])
+        if match = path.last.to_s.match(/\A:(\w+)\z/)
+          route.add_route(
+            traverse_directory(Routes::Param.new(match[1].to_s), path:)
+          )
+        else
+          route.add_route(
+            traverse_directory(Routes::Named.new(path.last.to_s), path:)
+          )
+        end
+
+        route
+      end
+
+      sig do
+        params(route: Routes::Route, path: T::Array[String]).returns(
+          Routes::Route
+        )
+      end
+      def traverse_directory(route, path: [])
+        absolute_path = File.join(@root, path)
+
+        Dir
+          .entries(absolute_path)
+          .difference(IGNORE)
+          .each { |entry| visit(route, path: [*path, entry]) }
+
+        route
+      end
+
+      sig do
+        params(route: Routes::Route, path: T::Array[String]).returns(
+          Routes::Route
+        )
+      end
+      def visit_file(route, path: [])
+        basename = path.last.to_s
+        extname = File.extname(basename)
+
+        if EXTENSIONS.include?(extname)
+          case basename.delete_suffix(extname)
+          when "page"
+            route.page = basename
+          when "layout"
+            route.layout = basename
+          when "404"
+            route.not_found = basename
+          end
+        end
+
+        route
+      end
+    end
+  end
+end

data/lib/mayu/routing/matcher.rb

@@ -0,0 +1,58 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Mayu
+  module Routing
+    class Matcher
+      extend T::Sig
+
+      class RouteError < StandardError
+      end
+
+      sig { params(root: Routes::Route).void }
+      def initialize(root)
+        @root = root
+      end
+
+      sig { params(path: String).void }
+      def match(path)
+        layouts = []
+        parts = []
+        params = {}
+
+        not_found = T.let(nil, T.nilable(String))
+
+        found =
+          path
+            .delete_prefix("/")
+            .split("/")
+            .reduce(@root) do |curr, part|
+              layouts.push(File.join("", *parts, curr.layout)) if curr.layout
+
+              if curr.not_found
+                not_found = File.join("", *parts, curr.not_found)
+              end
+
+              match = curr.match(part)
+
+              break unless match
+
+              if match.is_a?(Routes::Param)
+                params[match.name.to_sym] = part
+                parts.push(":#{part}")
+              else
+                parts.push(part)
+              end
+
+              match
+            end
+
+        return { layouts:, component: File.join("", *parts), params: } if found
+
+        return { layouts: [], component: not_found, params: } if not_found
+
+        raise RouteError, "No 404 page configured, put one in #{@root}"
+      end
+    end
+  end
+end

data/lib/mayu/routing/routes.rb

@@ -0,0 +1,85 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Mayu
+  module Routing
+    module Routes
+      class Route
+        extend T::Sig
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :page
+        sig { returns(T.nilable(String)) }
+        attr_accessor :layout
+        sig { returns(T.nilable(String)) }
+        attr_accessor :not_found
+
+        sig { void }
+        def initialize
+          @page = nil
+          @layout = nil
+          @not_found = nil
+          @named = T.let({}, T::Hash[String, Named])
+          @params = T.let([], T::Array[Param])
+        end
+
+        sig { params(route: Route).void }
+        def add_route(route)
+          case route
+          when Named
+            @named[route.name] = route
+          when Param
+            @params.push(route)
+          else
+            raise TypeError, "Unknown route type: #{route.class}"
+          end
+        end
+
+        sig { params(part: String).returns(T.nilable(Route)) }
+        def match(part)
+          @named.fetch(part) { @params.find { _1.match?(part) } }
+        end
+
+        sig { params(part: String).returns(T::Boolean) }
+        def match?(part)
+          true
+        end
+      end
+
+      class Named < Route
+        sig { returns(String) }
+        attr_reader :name
+
+        sig { params(name: String).void }
+        def initialize(name)
+          super()
+          @name = name
+        end
+
+        sig { params(part: String).returns(T::Boolean) }
+        def match?(part)
+          part == @name
+        end
+      end
+
+      class Param < Route
+        sig { returns(String) }
+        attr_reader :name
+        sig { returns(Regexp) }
+        attr_reader :format
+
+        sig { params(name: String, format: Regexp).void }
+        def initialize(name, format: /\A\d+\z/)
+          super()
+          @name = name
+          @format = format
+        end
+
+        sig { params(part: String).returns(T::Boolean) }
+        def match?(part)
+          @format.match?(part)
+        end
+      end
+    end
+  end
+end

data/lib/mayu/routing.rb

@@ -0,0 +1,17 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "routing/routes"
+require_relative "routing/builder"
+require_relative "routing/matcher"
+
+module Mayu
+  module Routing
+  end
+end
+
+# root = Routing::Builder.build(File.join(__dir__, "example", "app", "pages"))
+# matcher = Routing::Matcher.new(root)
+# p matcher.match("/pokemon")
+# p matcher.match("/pokemon/123")
+# p matcher.match("/pokemon/123/asd")