mayu-live 0.0.0

data/lib/mayu/commands/build.rb

@@ -0,0 +1,82 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../environment"
+
+module Mayu
+  module Commands
+    class Build < Base
+      extend T::Sig
+
+      sig { params(argv: T::Array[String]).void }
+      def call(argv)
+        require "fileutils"
+
+        Async do
+          started_at = Time.now.to_f
+
+          metrics = AppMetrics.setup(Prometheus::Client.registry)
+          environment = Environment.new(configuration, metrics)
+          environment.init_js
+          resources = environment.resources
+
+          components = []
+
+          components.push(File.join("/app", "root"))
+
+          environment.routes.each do |route|
+            route.layouts.each do |layout|
+              components.push(File.join("/app", "pages", layout))
+            end
+
+            components.push(File.join("/app", "pages", route.template))
+          end
+
+          components.each do |component|
+            resources.load_resource(component).type.component
+          end
+
+          File.write("app-graph.md", <<~EOF)
+            ```mermaid
+            #{resources.dependency_graph.to_mermaid_source.chomp}
+            ```
+          EOF
+
+          mermaid_url = resources.mermaid_url
+
+          assets_dir = environment.path(:assets)
+          FileUtils.mkdir_p(assets_dir)
+          files_to_remove = Dir.glob(File.join(assets_dir, "*"))
+
+          unless files_to_remove.empty?
+            puts "\e[33mRemoving #{files_to_remove.size} files from #{assets_dir}\e[0m"
+            FileUtils.rm(files_to_remove)
+          end
+
+          puts "\e[35mGenerating assets\e[0m"
+
+          resources.generate_assets(
+            assets_dir,
+            concurrency: Async::Container.processor_count,
+            forever: false
+          ).wait
+
+          filename = configuration.paths.bundle_filename
+          puts "\e[35mWriting \e[1m#{filename}\e[0m"
+          File.write(filename, resources.dump)
+
+          puts
+          puts format(
+                 "\e[36mBuilt app in \e[1m%.2f seconds\e[0m",
+                 Time.now.to_f - started_at
+               )
+
+          puts
+          puts "View the app graph:"
+          puts "\e[34;4m#{resources.mermaid_url}\e[0m"
+        end
+      end
+    end
+  end
+end

data/lib/mayu/commands.rb

@@ -0,0 +1,53 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "configuration"
+require_relative "commands/base"
+require_relative "colors"
+require_relative "banner"
+
+module Mayu
+  module Commands
+    extend T::Sig
+
+    sig { params(argv: T::Array[String]).void }
+    def self.call(argv)
+      puts Colors.rainbow(BANNER)
+
+      case argv
+      in ["dev", *rest]
+        require_relative "server"
+        Server.start(load_config(:dev))
+      in ["devbundle", *rest]
+        require_relative "server"
+        Server.start(load_config(:devbundle))
+      in ["build", *rest]
+        require_relative "commands/build"
+        Commands::Build.new(
+          load_config(
+            :prod,
+            overrides: {
+              "use_bundle" => false,
+              "secret_key" => "not important, just needed to avoid an exception"
+            }
+          )
+        ).call(rest)
+      in ["serve", *rest]
+        require_relative "server"
+        Server.start(load_config(:prod))
+      else
+        puts "Invalid args: #{argv.inspect}"
+        exit 1
+      end
+    end
+
+    sig do
+      params(env: Symbol, overrides: T::Hash[String, T.untyped]).returns(
+        Configuration
+      )
+    end
+    def self.load_config(env, overrides: {})
+      Mayu::Configuration.load_config(env, pwd: Dir.pwd, overrides:)
+    end
+  end
+end

data/lib/mayu/component/base.rb

@@ -0,0 +1,177 @@
+# typed: strict
+
+require_relative "handler_ref"
+
+module Mayu
+  module Component
+    class Base
+      extend T::Sig
+      extend T::Helpers
+      abstract!
+
+      sig do
+        params(
+          styles: T::Hash[Symbol, String],
+          assets: T::Array[String]
+        ).returns(T.class_of(Base))
+      end
+      def self.setup_component(styles:, assets:)
+        T.unsafe(
+          class << self
+            self
+          end
+        ).undef_method(T.must(__method__))
+
+        const_set(
+          :MAYU,
+          { styles: styles.freeze, assets: assets.freeze }.freeze
+        )
+
+        self
+      end
+
+      sig { overridable.params(props: T.untyped).returns(Component::State) }
+      def self.get_initial_state(**props)
+        {}
+      end
+
+      class << self
+        extend T::Sig
+
+        sig { void }
+        def initialize
+          # This will never be called but will make Sorbet happy
+          @__mayu_resource = T.let(nil, T.nilable(Resources::Resource))
+        end
+
+        # TODO: Probably better use a WeakMap in Resources for this..
+        sig { params(__mayu_resource: Resources::Resource).void }
+        attr_writer :__mayu_resource
+
+        sig { returns(T.nilable(Resources::Resource)) }
+        def __mayu_resource
+          @__mayu_resource
+        end
+
+        sig { returns(Resources::Resource) }
+        def __mayu_resource!
+          @__mayu_resource or raise "__mayu_resource is not set"
+        end
+
+        sig { returns(T::Boolean) }
+        def __mayu_resource?
+          !!@__mayu_resource
+        end
+      end
+
+      sig do
+        overridable
+          .params(props: Component::Props, state: Component::State)
+          .returns(T.nilable(Component::State))
+      end
+      def self.get_derived_state_from_props(props, state)
+        nil
+      end
+
+      sig { params(wrapper: Wrapper).void }
+      def initialize(wrapper)
+        @__wrapper = wrapper
+      end
+
+      sig { returns(State) }
+      def state = mayu.state
+      sig { returns(Props) }
+      def props = mayu.props
+      sig { returns(String) }
+      def vnode_id = @__wrapper.vnode_id
+
+      sig { overridable.void }
+      def mount
+      end
+
+      sig { overridable.void }
+      def unmount
+      end
+
+      sig do
+        overridable
+          .params(next_props: Component::Props, next_state: Component::State)
+          .returns(T::Boolean)
+      end
+      def should_update?(next_props, next_state)
+        case
+        when props != next_props
+          true
+        when state != next_state
+          true
+        else
+          false
+        end
+      end
+
+      sig do
+        overridable
+          .params(prev_props: Component::Props, prev_state: Component::State)
+          .void
+      end
+      def did_update(prev_props, prev_state)
+      end
+
+      INLINE_CSS_ASSETS = T.let([], T::Array[String])
+
+      sig { returns(T::Array[String]) }
+      def self.assets
+        [self.stylesheet&.assets, const_get(:INLINE_CSS_ASSETS)].flatten
+          .compact
+          .map(&:filename)
+      end
+
+      # TODO: Could probably clean this up...
+      sig { returns(T.nilable(Resources::Types::Stylesheet)) }
+      def self.stylesheet = nil
+      sig { returns(Resources::Types::Stylesheet) }
+      def self.stylesheet! =
+        stylesheet ||
+          raise(RuntimeError, "There is no stylesheet for this component!")
+      sig { returns(Resources::Types::Stylesheet::ClassNames) }
+      def self.styles
+        Resources::Types::Stylesheet::ClassNames.new({})
+      end
+      sig { returns(Resources::Types::Stylesheet::ClassNames) }
+      def styles = self.class.styles
+
+      sig { params(blk: T.proc.bind(T.self_type).void).void }
+      def async(&blk) = @__wrapper.async(&blk)
+
+      sig { abstract.returns(ChildType) }
+      def render
+      end
+
+      sig do
+        params(name: Symbol, args: T.untyped, kwargs: T.untyped).returns(
+          HandlerRef
+        )
+      end
+      def handler(name, *args, **kwargs)
+        HandlerRef.new(self, name, args, kwargs)
+      end
+
+      sig { returns(Helpers) }
+      def mayu = @__wrapper.helpers
+      alias helpers mayu
+
+      sig do
+        params(
+          state: T.nilable(State),
+          blk: T.nilable(Wrapper::UpdateProc)
+        ).void
+      end
+      def update(state = nil, &blk)
+        @__wrapper.update(state, &blk)
+      end
+
+      sig { returns(VDOM::Children) }
+      def children = props[:children]
+    end
+  end
+end

data/lib/mayu/component/handler_ref.rb

@@ -0,0 +1,99 @@
+# typed: strict
+
+require_relative "base"
+
+module Mayu
+  module Component
+    class HandlerRef
+      extend T::Sig
+
+      ID_LENGTH = 16
+      ID_FORMAT = /\A[[:graph:]]{#{ID_LENGTH}}\z/
+
+      sig { returns(String) }
+      attr_reader :id
+
+      sig do
+        params(
+          component: Base,
+          name: Symbol,
+          args: T::Array[T.untyped],
+          kwargs: T::Hash[Symbol, T.untyped]
+        ).void
+      end
+      def initialize(component, name, args = [], kwargs = {})
+        @component = component
+        @name = name
+        @args = args
+        @kwargs = kwargs
+        # TODO: Validate that args and kwargs match the method signature.
+        method = T.let(component.public_method(name), Method)
+        @arity = T.let(method.arity, Integer)
+        @id =
+          T.let(
+            [component.vnode_id, name, @args, @kwargs].inspect
+              .then { Digest::SHA256.digest(_1) }
+              .then { Base64.urlsafe_encode64(_1) }
+              .then { _1[0, ID_LENGTH] },
+            String
+          )
+      end
+
+      sig { returns(Integer) }
+      def hash = [self.class, @id].hash
+      sig { params(other: T.untyped).returns(T::Boolean) }
+      def eql?(other) = self.class === other && other.id == id
+      sig { params(other: T.untyped).returns(T::Boolean) }
+      def ==(other) = self.class === other && other.id == id
+
+      sig { returns(String) }
+      def inspect
+        "#<HandlerRef vnode_id=%d %s(%s)" %
+          [
+            @component.vnode_id,
+            @name,
+            [*@args.map(&:inspect), *@kwargs.inspect].join(", ")
+          ]
+      end
+
+      sig { params(args: T.untyped, kwargs: T.untyped).returns(HandlerRef) }
+      def bind_args(*args, **kwargs)
+        self.class.new(
+          @component,
+          @name,
+          [*@args, *args],
+          { **@kwargs, **kwargs }
+        )
+      end
+
+      sig { void }
+      def marshal_dump
+        []
+      end
+
+      sig { params(a: T.untyped).void }
+      def marshal_load(a)
+        @id = "invalid"
+      end
+
+      sig { params(payload: T.untyped).void }
+      def call(payload)
+        if @arity.zero?
+          T.unsafe(@component).public_send(@name)
+        else
+          T.unsafe(@component).public_send(@name, payload, *@args, **@kwargs)
+        end
+      end
+
+      sig { returns(String) }
+      def to_s
+        "Mayu.handle(event,'#{@id}')"
+      end
+
+      sig { params(other: T.untyped).returns(T::Boolean) }
+      def ==(other)
+        self.class === other && @id == other.id
+      end
+    end
+  end
+end

data/lib/mayu/component/helpers.rb

@@ -0,0 +1,93 @@
+# typed: strict
+
+module Mayu
+  module Component
+    class Helpers
+      extend T::Sig
+
+      sig { params(wrapper: Component::Wrapper).void }
+      def initialize(wrapper)
+        @wrapper = wrapper
+      end
+
+      sig do
+        params(
+          url: String,
+          method: Symbol,
+          headers: T::Hash[String, String],
+          body: T.nilable(String)
+        ).returns(Fetch::Response)
+      end
+      def fetch(url, method: :GET, headers: {}, body: nil)
+        vnode.fetch(url, method:, headers:, body:)
+      end
+
+      sig { params(path: String).void }
+      def navigate(path)
+        vnode.navigate(path)
+      end
+
+      sig { params(selector: String, options: String).void }
+      def scroll_into_view(selector, **options)
+        vnode.action(:scroll_into_view, { selector:, options: })
+      end
+
+      sig { params(message: String).void }
+      def alert(message)
+        vnode.action(:alert, message)
+      end
+
+      sig { returns(State) }
+      def state = @wrapper.state
+      sig { returns(Props) }
+      def props = @wrapper.props
+
+      sig { returns(VDOM::Children) }
+      def children = props[:children]
+
+      sig { params(sources: Props).returns(Props) }
+      def merge_props(*sources)
+        result = sources.reduce({}, &:merge)
+
+        if result.delete(:class)
+          classes = sources.map { _1[:class] }.flatten.compact
+          result[:class] = T.unsafe(@wrapper.instance).styles[*classes]
+        end
+
+        result.transform_keys { _1.to_s.tr("-", "_").to_sym }
+      end
+
+      sig do
+        params(
+          name: T.nilable(String),
+          fallback: T.nilable(T.proc.returns(VDOM::Interfaces::Descriptor))
+        ).returns(
+          T.nilable(
+            T.any(
+              VDOM::Interfaces::Descriptor,
+              T::Array[VDOM::Interfaces::Descriptor]
+            )
+          )
+        )
+      end
+      def slot(name = nil, &fallback) = children.slot(name, &fallback)
+
+      sig { returns(T::Array[T.nilable(String)]) }
+      def slot_names = children.slots.keys
+
+      sig do
+        params(name: Symbol, args: T.untyped, kwargs: T.untyped).returns(
+          HandlerRef
+        )
+      end
+      def handler(name, *args, **kwargs)
+        HandlerRef.new(@wrapper.instance, name, args, kwargs)
+      end
+
+      private
+
+      sig { returns(VDOM::VNode) }
+      def vnode = @wrapper.vnode
+    end
+  end
+end

data/lib/mayu/component/interface.rb

@@ -0,0 +1,18 @@
+# typed: strict
+
+require_relative "handler_ref"
+
+module Mayu
+  module Component
+    module Interface
+      extend T::Sig
+      extend T::Helpers
+      interface!
+    end
+
+    module DSL
+      extend T::Sig
+      extend T::Helpers
+    end
+  end
+end

data/lib/mayu/component/wrapper.rb

@@ -0,0 +1,165 @@
+# typed: strict
+
+require "async/barrier"
+require_relative "helpers"
+
+module Mayu
+  module Component
+    class Wrapper
+      extend T::Sig
+
+      UpdateProc =
+        T.type_alias do
+          T.any(
+            T.proc.params(arg0: State).returns(State),
+            T.proc.params(kwargs: T.untyped).returns(State)
+          )
+        end
+
+      sig { returns(String) }
+      def vnode_id = @vnode.id
+
+      sig { returns(Props) }
+      attr_accessor :props
+      sig { returns(State) }
+      attr_accessor :state
+      sig { returns(State) }
+      attr_reader :next_state
+
+      sig { returns(Helpers) }
+      attr_reader :helpers
+      sig { returns(Component::Base) }
+      attr_reader :instance
+
+      sig { returns(T::Boolean) }
+      def dirty? = @dirty
+      sig { returns(TrueClass) }
+      def dirty! = @dirty = true
+
+      sig { returns(VDOM::VNode) }
+      attr_reader :vnode
+
+      sig do
+        params(vnode: VDOM::VNode, klass: T.class_of(Base), props: Props).void
+      end
+      def initialize(vnode, klass, props = {})
+        @vnode = vnode
+        @props = T.let(props, Props)
+        @state = T.let(klass.get_initial_state(**props), State)
+        @next_state = T.let(@state.dup, State)
+        @dirty = T.let(true, T::Boolean)
+        @instance = T.let(klass.new(self), Base)
+        @barrier = T.let(Async::Barrier.new, Async::Barrier)
+        @helpers = T.let(Helpers.new(self), Helpers)
+      end
+
+      sig { returns(T::Array[String]) }
+      def assets
+        @instance.class.assets
+      end
+
+      sig { returns(T.nilable(Resources::Resource)) }
+      def resource
+        if @instance.class.respond_to?(:__resource)
+          @instance.class.send(:__resource)
+        end
+      end
+
+      sig { void }
+      def mount
+        async { @instance.mount }
+      end
+
+      sig { params(prev_props: Props, prev_state: State).void }
+      def did_update(prev_props, prev_state)
+        async { @instance.did_update(prev_props, prev_state) }
+      end
+
+      sig { void }
+      def unmount
+        @instance.unmount
+      ensure
+        @barrier.stop
+      end
+
+      sig { returns(ChildType) }
+      def render
+        if derived_state =
+             @instance.class.get_derived_state_from_props(props, state)
+          @state = @state.merge(derived_state)
+        end
+
+        @instance.render
+      rescue NotImplementedError => e
+        raise NotImplementedError, "#{@instance} should implement #render"
+      ensure
+        @dirty = false
+      end
+
+      sig { params(next_props: Props, next_state: State).returns(T::Boolean) }
+      def should_update?(next_props, next_state)
+        @dirty || @instance.should_update?(next_props, next_state)
+      end
+
+      sig { params(blk: T.proc.void).void }
+      def async(&blk)
+        @barrier.async(&blk)
+      end
+
+      sig do
+        params(new_state: T.nilable(State), block: T.nilable(UpdateProc)).void
+      end
+      def update(new_state = nil, &block)
+        if new_state
+          @next_state = @next_state.merge(new_state)
+          enqueue_update!
+        end
+
+        return unless block
+
+        if block.parameters in [[:opt, var]]
+          Console.logger.warn(self, <<~EOF) unless var == :state
+            update do |#{var}|
+            # Are you sure you didn't misspell `#{var}`?
+            # Usually it should be called `state`.
+            end
+            EOF
+
+          update(block.call(@next_state))
+        else
+          if block.parameters.all? { _1 in [:key | :keyreq, key] }
+            keys = block.parameters.map(&:last)
+            sliced_state = T.unsafe(@next_state).slice(*keys)
+            update(block.call(**sliced_state))
+          else
+            raise ArgumentError, "All arguments to #update are not keys."
+          end
+        end
+      end
+
+      sig { returns(T.untyped) }
+      def marshal_dump
+        [
+          VDOM::Marshalling.dump_props(@props),
+          VDOM::Marshalling.dump_state(@state)
+        ]
+      end
+
+      sig { params(a: T.untyped).void }
+      def marshal_load(a)
+        @props, @state = a
+        @next_state = @state.clone
+        @dirty = true
+        @barrier = Async::Barrier.new
+      end
+
+      private
+
+      sig { void }
+      def enqueue_update!
+        @vnode.enqueue_update!
+        @dirty = true
+      end
+    end
+  end
+end